coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-04-30 19:09:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

Work in progress

Browse Source
This commit is contained in:
John Wellbelove 2024-01-13 11:45:57 +00:00
parent 3ca624efb0
commit 3d3dad8499
5 changed files with 2031 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

616
include/etl/private/bitset_new.h
View File

@ -90,9 +90,18 @@ namespace etl
//***************************************************************************
struct bitset_storage_model
{
static ETL_CONSTANT char Undefined = 0;
static ETL_CONSTANT char Single = 1;
static ETL_CONSTANT char Multi = 2;
enum enum_type
{
Undefined = 0,
Single = 1,
Multi = 2
};
ETL_DECLARE_ENUM_TYPE(bitset_storage_model, char)
ETL_ENUM_TYPE(Undefined, "Undefined")
ETL_ENUM_TYPE(Single, "Single")
ETL_ENUM_TYPE(Multi, "Multi")
ETL_END_ENUM_TYPE
};
//***************************************************************************
@ -151,6 +160,37 @@ namespace etl
}
};
//***************************************************************************
namespace private_bitset
{
template <typename TElement>
class bitset_impl_common
{
public:
typedef TElement element_type;
typedef TElement* pointer;
typedef const TElement* const_pointer;
static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits<TElement>::bits;
static ETL_CONSTANT TElement All_Set_Element = etl::integral_limits<TElement>::max;
static ETL_CONSTANT TElement All_Clear_Element = element_type(0);
};
template <typename TElement>
ETL_CONSTANT size_t bitset_impl_common<TElement>::npos;
template <typename TElement>
ETL_CONSTANT size_t bitset_impl_common<TElement>::Bits_Per_Element;
template <typename TElement>
ETL_CONSTANT TElement bitset_impl_common<TElement>::All_Set_Element;
template <typename TElement>
ETL_CONSTANT TElement bitset_impl_common<TElement>::All_Clear_Element;
}
//*************************************************************************
/// Bitset implementation declaration.
///\ingroup bitset
@ -163,19 +203,19 @@ namespace etl
///\ingroup bitset
//*************************************************************************
template <typename TElement>
class bitset_impl<TElement, etl::bitset_storage_model::Single>
class bitset_impl<TElement, etl::bitset_storage_model::Single> : public etl::private_bitset::bitset_impl_common<TElement>
{
public:
typedef TElement element_type;
typedef element_type* pointer;
typedef const element_type* const_pointer;
using typename etl::private_bitset::bitset_impl_common<TElement>::element_type;
using typename etl::private_bitset::bitset_impl_common<TElement>::pointer;
using typename etl::private_bitset::bitset_impl_common<TElement>::const_pointer;
static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
using etl::private_bitset::bitset_impl_common<TElement>::Bits_Per_Element;
using etl::private_bitset::bitset_impl_common<TElement>::All_Set_Element;
using etl::private_bitset::bitset_impl_common<TElement>::All_Clear_Element;
static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits<element_type>::bits;
static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits<element_type>::max;
static ETL_CONSTANT element_type All_Clear_Element = element_type(0);
using etl::private_bitset::bitset_impl_common<TElement>::npos;
//*************************************************************************
/// Set all of the bits.
@ -210,6 +250,47 @@ namespace etl
}
}
//*************************************************************************
/// Set the bit at the position.
//*************************************************************************
template <size_t Position>
ETL_CONSTEXPR14
static
void set_position(pointer pbuffer,
bool value = true)
{
const element_type mask = element_type(element_type(1) << Position);
if (value == true)
{
*pbuffer |= mask;
}
else
{
*pbuffer &= ~mask;
}
}
//*************************************************************************
/// Set the bit at the position.
//*************************************************************************
template <size_t Position, bool Value>
ETL_CONSTEXPR14
static
void set_position(pointer pbuffer)
{
const element_type mask = element_type(element_type(1) << Position);
if (Value == true)
{
*pbuffer |= mask;
}
else
{
*pbuffer &= ~mask;
}
}
//*************************************************************************
/// Reset all of the bits.
//*************************************************************************
@ -771,19 +852,23 @@ namespace etl
///\ingroup bitset
//*************************************************************************
template <typename TElement>
class bitset_impl<TElement, etl::bitset_storage_model::Multi>
class bitset_impl<TElement, etl::bitset_storage_model::Multi> : public etl::private_bitset::bitset_impl_common<TElement>
{
private:
typedef etl::private_bitset::bitset_impl_common<TElement> common;
public:
typedef TElement element_type;
typedef element_type* pointer;
typedef const element_type* const_pointer;
using typename etl::private_bitset::bitset_impl_common<TElement>::element_type;
using typename etl::private_bitset::bitset_impl_common<TElement>::pointer;
using typename etl::private_bitset::bitset_impl_common<TElement>::const_pointer;
static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
using etl::private_bitset::bitset_impl_common<TElement>::Bits_Per_Element;
using etl::private_bitset::bitset_impl_common<TElement>::All_Set_Element;
using etl::private_bitset::bitset_impl_common<TElement>::All_Clear_Element;
static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits<element_type>::bits;
static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits<element_type>::max;
static ETL_CONSTANT element_type All_Clear_Element = element_type(0);
using etl::private_bitset::bitset_impl_common<TElement>::npos;
//*************************************************************************
/// Check to see if the requested extract is contained within one element.
@ -924,7 +1009,50 @@ namespace etl
size_t index = position >> etl::log2<Bits_Per_Element>::value;
element_type bit = element_type(1) << (position & (Bits_Per_Element - 1));
if (value)
if (value == true)
{
pbuffer[index] |= bit;
}
else
{
pbuffer[index] &= ~bit;
}
}
//*************************************************************************
/// Set the bit at the position.
//*************************************************************************
template <size_t Position>
ETL_CONSTEXPR14
static
void set_position(pointer pbuffer,
bool value = true)
{
size_t index = Position >> etl::log2<Bits_Per_Element>::value;
element_type bit = element_type(1) << (Position & (Bits_Per_Element - 1));
if (value == true)
{
pbuffer[index] |= bit;
}
else
{
pbuffer[index] &= ~bit;
}
}
//*************************************************************************
/// Set the bit at the position.
//*************************************************************************
template <size_t Position, bool Value>
ETL_CONSTEXPR14
static
void set_position(pointer pbuffer)
{
size_t index = Position >> etl::log2<Bits_Per_Element>::value;
element_type bit = element_type(1) << (Position & (Bits_Per_Element - 1));
if (Value == true)
{
pbuffer[index] |= bit;
}
@ -1674,6 +1802,55 @@ namespace etl
}
};
namespace private_bitset
{
//***************************************************************************
template <size_t Active_Bits, typename TElement>
class bitset_common : public etl::private_bitset::bitset_impl_common<TElement>
{
public:
typedef typename etl::private_bitset::bitset_impl_common<TElement>::element_type element_type;
using etl::private_bitset::bitset_impl_common<TElement>::Bits_Per_Element;
using etl::private_bitset::bitset_impl_common<TElement>::All_Set_Element;
using etl::private_bitset::bitset_impl_common<TElement>::All_Clear_Element;
static ETL_CONSTANT size_t Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
static ETL_CONSTANT size_t Size = Active_Bits;
static ETL_CONSTANT size_t Allocated_Bits = Number_Of_Elements * Bits_Per_Element;
static ETL_CONSTANT etl::bitset_storage_model Storage_Model = (Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi;
typedef etl::span<element_type, Number_Of_Elements> span_type;
typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
private:
static ETL_CONSTANT size_t Top_Mask_Shift = ((Bits_Per_Element - ((Number_Of_Elements * Bits_Per_Element) - Active_Bits)) % Bits_Per_Element);
public:
static ETL_CONSTANT TElement Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
};
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Number_Of_Elements;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Size;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT etl::bitset_storage_model bitset_common<Active_Bits, TElement>::Storage_Model;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT size_t bitset_common<Active_Bits, TElement>::Top_Mask_Shift;
template <size_t Active_Bits, typename TElement>
ETL_CONSTANT TElement bitset_common<Active_Bits, TElement>::Top_Mask;
}
//***************************************************************************
/// Bitset forward declaration
//***************************************************************************
@ -1685,61 +1862,46 @@ namespace etl
/// Specialisation for zero bits.
//***************************************************************************
template <>
class bitset<0U, unsigned char>
class bitset<0U, unsigned char> : public etl::private_bitset::bitset_common<0U, unsigned char>
{
public:
typedef unsigned char element_type;
typedef typename etl::private_bitset::bitset_common<0U, unsigned char>::element_type element_type;
typedef typename etl::private_bitset::bitset_common<0U, unsigned char>::span_type span_type;
typedef typename etl::private_bitset::bitset_common<0U, unsigned char>::const_span_type const_span_type;
typedef element_type* pointer;
typedef const element_type* const_pointer;
static ETL_CONSTANT size_t Bits_Per_Element = 0U;
static ETL_CONSTANT size_t Number_Of_Elements = 0U;
static ETL_CONSTANT size_t Allocated_Bits = 0U;
static ETL_CONSTANT element_type All_Set_Element = 0U;
static ETL_CONSTANT element_type All_Clear_Element = 0U;
static ETL_CONSTANT size_t Size = 0U;
static ETL_CONSTANT char Storage_Model = etl::bitset_storage_model::Undefined;
static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
using etl::private_bitset::bitset_common<0U, unsigned char>::Bits_Per_Element;
using etl::private_bitset::bitset_common<0U, unsigned char>::All_Set_Element;
using etl::private_bitset::bitset_common<0U, unsigned char>::All_Clear_Element;
using etl::private_bitset::bitset_common<0U, unsigned char>::Number_Of_Elements;
using etl::private_bitset::bitset_common<0U, unsigned char>::Size;
using etl::private_bitset::bitset_common<0U, unsigned char>::Storage_Model;
using etl::private_bitset::bitset_common<0U, unsigned char>::Top_Mask;
using etl::private_bitset::bitset_common<0U, unsigned char>::Allocated_Bits;
};
//*************************************************************************
/// The bitset top level template.
//*************************************************************************
template <size_t Active_Bits, typename TElement>
class bitset
class bitset : public etl::private_bitset::bitset_common<Active_Bits, TElement>
{
public:
ETL_STATIC_ASSERT(etl::is_unsigned<TElement>::value, "The element type must be unsigned");
typedef TElement element_type;
typedef element_type* pointer;
typedef const element_type* const_pointer;
typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::element_type element_type;
typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::span_type span_type;
typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::const_span_type const_span_type;
static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits<element_type>::bits;
static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits<element_type>::max;
static ETL_CONSTANT element_type All_Clear_Element = element_type(0);
static ETL_CONSTANT size_t Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
static ETL_CONSTANT size_t Allocated_Bits = Number_Of_Elements * Bits_Per_Element;
static ETL_CONSTANT size_t Size = Active_Bits;
static ETL_CONSTANT char Storage_Model = (Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi;
private:
static ETL_CONSTANT size_t Top_Mask_Shift = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element);
static ETL_CONSTANT element_type Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
public:
static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility.
typedef etl::span<element_type, Number_Of_Elements> span_type;
typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
using etl::private_bitset::bitset_common<Active_Bits, TElement>::Bits_Per_Element;
using etl::private_bitset::bitset_common<Active_Bits, TElement>::All_Set_Element;
using etl::private_bitset::bitset_common<Active_Bits, TElement>::All_Clear_Element;
using etl::private_bitset::bitset_common<Active_Bits, TElement>::Number_Of_Elements;
using etl::private_bitset::bitset_common<Active_Bits, TElement>::Size;
using etl::private_bitset::bitset_common<Active_Bits, TElement>::Storage_Model;
using etl::private_bitset::bitset_common<Active_Bits, TElement>::Top_Mask;
using etl::private_bitset::bitset_common<Active_Bits, TElement>::Allocated_Bits;
//*************************************************************************
/// The reference type returned.
@ -1912,7 +2074,8 @@ namespace etl
//*************************************************************************
/// Set the bit at the position.
//*************************************************************************
ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(size_t position, bool value = true)
ETL_CONSTEXPR14
bitset<Active_Bits, TElement>& set(size_t position, bool value = true)
{
ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
@ -1922,11 +2085,27 @@ namespace etl
}
//*************************************************************************
/// Set from a string.
/// Set the bit at the position.
//*************************************************************************
ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(const char* text) ETL_NOEXCEPT
template <size_t Position>
ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(bool value = true)
{
implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
implementation::template set_position<Position>(buffer, value);
return *this;
}
//*************************************************************************
/// Set the bit at the position.
//*************************************************************************
template <size_t Position, bool Value>
ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set()
{
ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
implementation::template set_position<Position, Value>(buffer);
return *this;
}
@ -1934,7 +2113,10 @@ namespace etl
//*************************************************************************
/// Set from a string.
//*************************************************************************
ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(const wchar_t* text) ETL_NOEXCEPT
template <typename TPString>
ETL_CONSTEXPR14
typename etl::enable_if<etl::is_same<TPString, const char*>::value, bitset<Active_Bits, TElement>&>::type
set(TPString text) ETL_NOEXCEPT
{
implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
@ -1942,9 +2124,12 @@ namespace etl
}
//*************************************************************************
/// Set from a string.
/// Set from a wide string.
//*************************************************************************
ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(const char16_t* text) ETL_NOEXCEPT
template <typename TPString>
ETL_CONSTEXPR14
typename etl::enable_if<etl::is_same<TPString, const wchar_t*>::value, bitset<Active_Bits, TElement>&>::type
set(TPString text) ETL_NOEXCEPT
{
implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
@ -1952,9 +2137,25 @@ namespace etl
}
//*************************************************************************
/// Set from a string.
/// Set from a char16 string.
//*************************************************************************
ETL_CONSTEXPR14 bitset<Active_Bits, TElement>& set(const char32_t* text) ETL_NOEXCEPT
template <typename TPString>
ETL_CONSTEXPR14
typename etl::enable_if<etl::is_same<TPString, const char16_t*>::value, bitset<Active_Bits, TElement>&>::type
set(TPString text) ETL_NOEXCEPT
{
implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
return *this;
}
//*************************************************************************
/// Set from a char32 string.
//*************************************************************************
template <typename TPString>
ETL_CONSTEXPR14
typename etl::enable_if<etl::is_same<TPString, const char32_t*>::value, bitset<Active_Bits, TElement>&>::type
set(TPString text) ETL_NOEXCEPT
{
implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text);
@ -2099,14 +2300,84 @@ namespace etl
return implementation::test(buffer, position);
}
//*************************************************************************
/// Tests a bit at a position.
/// Positions greater than the number of configured bits will not compile.
//*************************************************************************
template <size_t Position>
ETL_CONSTEXPR14 bool test() const
{
ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
return implementation::test(buffer, Position);
}
//*************************************************************************
/// The number of bits in the bitset.
//*************************************************************************
ETL_CONSTEXPR14 size_t size() const ETL_NOEXCEPT
static ETL_CONSTEXPR size_t size() ETL_NOEXCEPT
{
return Active_Bits;
}
//*************************************************************************
/// The number of storage elements in the bitset.
//*************************************************************************
static ETL_CONSTEXPR size_t number_of_elements() ETL_NOEXCEPT
{
return Number_Of_Elements;
}
//*************************************************************************
/// The value of a set element.
//*************************************************************************
static ETL_CONSTEXPR element_type all_set_element() ETL_NOEXCEPT
{
return All_Set_Element;
}
//*************************************************************************
/// The value of a clear element.
//*************************************************************************
static ETL_CONSTEXPR element_type all_clear_element() ETL_NOEXCEPT
{
return All_Clear_Element;
}
//*************************************************************************
/// The number of bits in an element.
//*************************************************************************
static ETL_CONSTEXPR size_t bits_per_element() ETL_NOEXCEPT
{
return Bits_Per_Element;
}
//*************************************************************************
/// The mask for the msb element.
//*************************************************************************
static ETL_CONSTEXPR element_type top_mask() ETL_NOEXCEPT
{
return Top_Mask;
}
//*************************************************************************
/// The total number of bits of storage, including unused.
//*************************************************************************
static ETL_CONSTEXPR size_t allocated_bits() ETL_NOEXCEPT
{
return Number_Of_Elements * Bits_Per_Element;
}
//*************************************************************************
/// The storage model for the bitset.
/// etl::bitset_storage_model::Single
/// etl::bitset_storage_model::Multi
//*************************************************************************
static ETL_CONSTEXPR etl::bitset_storage_model storage_model() ETL_NOEXCEPT
{
return Storage_Model;
}
//*************************************************************************
/// Count the number of bits set.
//*************************************************************************
@ -2507,62 +2778,48 @@ namespace etl
/// Specialisation for zero bits.
//***************************************************************************
template <>
class bitset_ext<0U, unsigned char>
class bitset_ext<0U, unsigned char> : public etl::private_bitset::bitset_common<0U, unsigned char>
{
public:
typedef unsigned char element_type;
typedef typename etl::private_bitset::bitset_common<0U, unsigned char>::element_type element_type;
typedef typename etl::private_bitset::bitset_common<0U, unsigned char>::span_type span_type;
typedef typename etl::private_bitset::bitset_common<0U, unsigned char>::const_span_type const_span_type;
typedef element_type* pointer;
typedef const element_type* const_pointer;
static ETL_CONSTANT size_t Bits_Per_Element = 0U;
static ETL_CONSTANT size_t Number_Of_Elements = 0U;
static ETL_CONSTANT size_t Allocated_Bits = 0U;
static ETL_CONSTANT element_type All_Set_Element = 0U;
static ETL_CONSTANT element_type All_Clear_Element = 0U;
static ETL_CONSTANT size_t Size = 0U;
static ETL_CONSTANT char Storage_Model = etl::bitset_storage_model::Undefined;
static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
using etl::private_bitset::bitset_common<0U, unsigned char>::Bits_Per_Element;
using etl::private_bitset::bitset_common<0U, unsigned char>::All_Set_Element;
using etl::private_bitset::bitset_common<0U, unsigned char>::All_Clear_Element;
using etl::private_bitset::bitset_common<0U, unsigned char>::Number_Of_Elements;
using etl::private_bitset::bitset_common<0U, unsigned char>::Size;
using etl::private_bitset::bitset_common<0U, unsigned char>::Storage_Model;
using etl::private_bitset::bitset_common<0U, unsigned char>::Top_Mask;
using etl::private_bitset::bitset_common<0U, unsigned char>::Allocated_Bits;
};
//*************************************************************************
/// The specialisation that uses an array of the default element type.
/// A bitset that uses externally declared storage.
//*************************************************************************
template <size_t Active_Bits, typename TElement>
class bitset_ext
class bitset_ext : public etl::private_bitset::bitset_common<Active_Bits, TElement>
{
public:
ETL_STATIC_ASSERT(etl::is_unsigned<TElement>::value, "The element type must be unsigned");
typedef TElement element_type;
typedef element_type* pointer;
typedef const element_type* const_pointer;
typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::element_type element_type;
typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::span_type span_type;
typedef typename etl::private_bitset::bitset_common<Active_Bits, TElement>::const_span_type const_span_type;
using etl::private_bitset::bitset_common<Active_Bits, TElement>::Bits_Per_Element;
using etl::private_bitset::bitset_common<Active_Bits, TElement>::All_Set_Element;
using etl::private_bitset::bitset_common<Active_Bits, TElement>::All_Clear_Element;
using etl::private_bitset::bitset_common<Active_Bits, TElement>::Number_Of_Elements;
using etl::private_bitset::bitset_common<Active_Bits, TElement>::Size;
using etl::private_bitset::bitset_common<Active_Bits, TElement>::Storage_Model;
using etl::private_bitset::bitset_common<Active_Bits, TElement>::Top_Mask;
using etl::private_bitset::bitset_common<Active_Bits, TElement>::Allocated_Bits;
static ETL_CONSTANT size_t npos = etl::integral_limits<size_t>::max;
static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits<element_type>::bits;
static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits<element_type>::max;
static ETL_CONSTANT element_type All_Clear_Element = element_type(0);
static ETL_CONSTANT size_t Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1;
static ETL_CONSTANT size_t Allocated_Bits = Number_Of_Elements * Bits_Per_Element;
static ETL_CONSTANT size_t Size = Active_Bits;
static ETL_CONSTANT char Storage_Model = (Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi;
private:
static ETL_CONSTANT size_t Top_Mask_Shift = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element);
static ETL_CONSTANT element_type Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift));
public:
static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility.
typedef etl::array<TElement, Number_Of_Elements> buffer_type;
typedef etl::span<element_type, Number_Of_Elements> span_type;
typedef etl::span<const element_type, Number_Of_Elements> const_span_type;
typedef etl::array<TElement, Number_Of_Elements> buffer_type;
//*************************************************************************
/// The reference type returned.
@ -2811,21 +3068,38 @@ namespace etl
//*************************************************************************
/// Set the bit at the position.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(size_t position, bool value = true)
ETL_CONSTEXPR14
bitset_ext<Active_Bits, TElement>& set(size_t position, bool value = true)
{
ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this);
implementation::set_position(pbuffer, position, value);
return *this;
}
//*************************************************************************
/// Set from a string.
/// Set the bit at the position.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(const char* text) ETL_NOEXCEPT
template <size_t Position>
ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(bool value = true)
{
implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
implementation::template set_position<Position>(pbuffer, value);
return *this;
}
//*************************************************************************
/// Set the bit at the position.
//*************************************************************************
template <size_t Position, bool Value>
ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set()
{
ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
implementation::template set_position<Position, Value>(pbuffer);
return *this;
}
@ -2833,7 +3107,10 @@ namespace etl
//*************************************************************************
/// Set from a string.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(const wchar_t* text) ETL_NOEXCEPT
template <typename TPString>
ETL_CONSTEXPR14
typename etl::enable_if<etl::is_same<TPString, const char*>::value, bitset_ext<Active_Bits, TElement>&>::type
set(TPString text) ETL_NOEXCEPT
{
implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
@ -2841,9 +3118,12 @@ namespace etl
}
//*************************************************************************
/// Set from a string.
/// Set from a wide string.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(const char16_t* text) ETL_NOEXCEPT
template <typename TPString>
ETL_CONSTEXPR14
typename etl::enable_if<etl::is_same<TPString, const wchar_t*>::value, bitset_ext<Active_Bits, TElement>&>::type
set(TPString text) ETL_NOEXCEPT
{
implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
@ -2851,9 +3131,25 @@ namespace etl
}
//*************************************************************************
/// Set from a string.
/// Set from a char16 string.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext<Active_Bits, TElement>& set(const char32_t* text) ETL_NOEXCEPT
template <typename TPString>
ETL_CONSTEXPR14
typename etl::enable_if<etl::is_same<TPString, const char16_t*>::value, bitset_ext<Active_Bits, TElement>&>::type
set(TPString text) ETL_NOEXCEPT
{
implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
return *this;
}
//*************************************************************************
/// Set from a char32 string.
//*************************************************************************
template <typename TPString>
ETL_CONSTEXPR14
typename etl::enable_if<etl::is_same<TPString, const char32_t*>::value, bitset_ext<Active_Bits, TElement>&>::type
set(TPString text) ETL_NOEXCEPT
{
implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text);
@ -2997,14 +3293,84 @@ namespace etl
return implementation::test(pbuffer, position);
}
//*************************************************************************
/// Tests a bit at a position.
/// Positions greater than the number of configured bits will not compile.
//*************************************************************************
template <size_t Position>
ETL_CONSTEXPR14 bool test() const
{
ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds");
return implementation::test(pbuffer, Position);
}
//*************************************************************************
/// The number of bits in the bitset.
//*************************************************************************
ETL_CONSTEXPR14 size_t size() const ETL_NOEXCEPT
static ETL_CONSTEXPR size_t size() ETL_NOEXCEPT
{
return Active_Bits;
}
//*************************************************************************
/// The number of storage elements in the bitset.
//*************************************************************************
static ETL_CONSTEXPR size_t number_of_elements() ETL_NOEXCEPT
{
return Number_Of_Elements;
}
//*************************************************************************
/// The value of a set element.
//*************************************************************************
static ETL_CONSTEXPR element_type all_set_element() ETL_NOEXCEPT
{
return All_Set_Element;
}
//*************************************************************************
/// The value of a clear element.
//*************************************************************************
static ETL_CONSTEXPR element_type all_clear_element() ETL_NOEXCEPT
{
return All_Clear_Element;
}
//*************************************************************************
/// The mask for the msb element.
//*************************************************************************
static ETL_CONSTEXPR element_type top_mask() ETL_NOEXCEPT
{
return Top_Mask;
}
//*************************************************************************
/// The number of bits in an element.
//*************************************************************************
static ETL_CONSTEXPR size_t bits_per_element() ETL_NOEXCEPT
{
return Bits_Per_Element;
}
//*************************************************************************
/// The total number of bits of storage, including unused.
//*************************************************************************
static ETL_CONSTEXPR size_t allocated_bits() ETL_NOEXCEPT
{
return Number_Of_Elements * Bits_Per_Element;
}
//*************************************************************************
/// The storage model for the bitset.
/// etl::bitset_storage_model::Single
/// etl::bitset_storage_model::Multi
//*************************************************************************
static ETL_CONSTEXPR etl::bitset_storage_model storage_model() ETL_NOEXCEPT
{
return Storage_Model;
}
//*************************************************************************
/// Count the number of bits set.
//*************************************************************************
@ -3234,14 +3600,6 @@ namespace etl
private:
////*************************************************************************
///// Correct the unused top bits after bit manipulation.
////*************************************************************************
//ETL_CONSTEXPR14 static void clear_unused_bits_in_msb() ETL_NOEXCEPT
//{
// pbuffer[Number_Of_Elements - 1U] &= Top_Mask;
//}
// The implementation of the bitset functionality.
typedef etl::bitset_impl<element_type, (Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi> implementation;

399
test/test_bitset_new_default_element_type.cpp
View File

@ -120,6 +120,77 @@ namespace
SUITE(test_bitset_new_default_element_type)
{
//*************************************************************************
TEST(test_constants)
{
using bitset_type = etl::bitset<60>;
using element_type = bitset_type::element_type;
constexpr size_t Size = 60;
constexpr size_t Bits_Per_Element = etl::integral_limits<element_type>::bits;
constexpr size_t Number_Of_Elements = (Size % Bits_Per_Element == 0) ? Size / Bits_Per_Element : Size / Bits_Per_Element + 1;
constexpr element_type All_Set_Element = etl::integral_limits<element_type>::max;
constexpr element_type All_Clear_Element = etl::integral_limits<element_type>::min;
//*******************************
constexpr size_t Size1 = bitset_type::Size;
constexpr size_t Size2 = bitset_type::size();
CHECK_EQUAL(Size, Size1);
CHECK_EQUAL(Size, Size2);
//*******************************
constexpr size_t Bits_Per_Element1 = bitset_type::Bits_Per_Element;
constexpr size_t Bits_Per_Element2 = bitset_type::bits_per_element();
CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element1);
CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element2);
//*******************************
constexpr size_t Number_Of_Elements1 = bitset_type::Number_Of_Elements;
constexpr size_t Number_Of_Elements2 = bitset_type::number_of_elements();
CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements1);
CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements2);
//*******************************
constexpr element_type All_Set_Element1 = bitset_type::All_Set_Element;
constexpr element_type All_Set_Element2 = bitset_type::all_set_element();
CHECK_EQUAL(All_Set_Element, All_Set_Element1);
CHECK_EQUAL(All_Set_Element, All_Set_Element2);
//*******************************
constexpr size_t All_Clear_Element1 = bitset_type::All_Clear_Element;
constexpr size_t All_Clear_Element2 = bitset_type::all_clear_element();
CHECK_EQUAL(All_Clear_Element, All_Clear_Element1);
CHECK_EQUAL(All_Clear_Element, All_Clear_Element2);
//*******************************
constexpr size_t Allocated_Bits = bitset_type::allocated_bits();
CHECK_EQUAL(Number_Of_Elements * Bits_Per_Element, Allocated_Bits);
//*******************************
constexpr char Storage_Model1 = bitset_type::Storage_Model;
constexpr char Storage_Model2 = bitset_type::storage_model();
CHECK_EQUAL(etl::bitset_storage_model::Multi, Storage_Model1);
CHECK_EQUAL(etl::bitset_storage_model::Multi, Storage_Model2);
etl::bitset_storage_model bsm;
bsm = etl::bitset_storage_model::Undefined;
CHECK_EQUAL(std::string("Undefined"), std::string(bsm.c_str()));
bsm = etl::bitset_storage_model::Single;
CHECK_EQUAL(std::string("Single"), std::string(bsm.c_str()));
bsm = etl::bitset_storage_model::Multi;
CHECK_EQUAL(std::string("Multi"), std::string(bsm.c_str()));
}
//*************************************************************************
TEST(test_default_constructor)
{
@ -394,6 +465,281 @@ namespace
}
}
//*************************************************************************
ETL_CONSTEXPR14 etl::bitset<64> test_set_run_time_position_default_value_helper()
{
etl::bitset<64> data;
data.set(2);
data.set(3);
data.set(5);
data.set(7);
data.set(11);
data.set(13);
data.set(17);
data.set(19);
data.set(23);
data.set(29);
data.set(31);
return data;
}
TEST(test_set_run_time_position_default_value)
{
std::bitset<64> compare;
ETL_CONSTEXPR14 etl::bitset<64> data(test_set_run_time_position_default_value_helper());
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
ETL_CONSTEXPR14 auto size = data.size();
ETL_CONSTEXPR14 auto count = data.count();
ETL_CONSTEXPR14 auto none = data.none();
ETL_CONSTEXPR14 auto any = data.any();
ETL_CONSTEXPR14 auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
ETL_CONSTEXPR14 etl::bitset<64> test_set_run_time_position_value_helper()
{
etl::bitset<64> data;
data.set(2, true);
data.set(3, true);
data.set(5, true);
data.set(7, true);
data.set(11, true);
data.set(13, true);
data.set(17, true);
data.set(19, true);
data.set(23, true);
data.set(29, true);
data.set(31, true);
return data;
}
TEST(test_set_run_time_position_value)
{
std::bitset<64> compare;
ETL_CONSTEXPR14 etl::bitset<64> data(test_set_run_time_position_value_helper());
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
ETL_CONSTEXPR14 auto size = data.size();
ETL_CONSTEXPR14 auto count = data.count();
ETL_CONSTEXPR14 auto none = data.none();
ETL_CONSTEXPR14 auto any = data.any();
ETL_CONSTEXPR14 auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
ETL_CONSTEXPR14 etl::bitset<64> test_set_compile_time_position_run_time_default_value_helper()
{
etl::bitset<64> data;
data.set<2>();
data.set<3>();
data.set<5>();
data.set<7>();
data.set<11>();
data.set<13>();
data.set<17>();
data.set<19>();
data.set<23>();
data.set<29>();
data.set<31>();
return data;
}
TEST(test_set_compile_time_position_run_time_default_value)
{
std::bitset<64> compare;
ETL_CONSTEXPR14 etl::bitset<64> data(test_set_compile_time_position_run_time_default_value_helper());
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
ETL_CONSTEXPR14 auto size = data.size();
ETL_CONSTEXPR14 auto count = data.count();
ETL_CONSTEXPR14 auto none = data.none();
ETL_CONSTEXPR14 auto any = data.any();
ETL_CONSTEXPR14 auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
ETL_CONSTEXPR14 etl::bitset<64> test_set_compile_time_position_run_time_value_helper()
{
etl::bitset<64> data;
data.set<2>(true);
data.set<3>(true);
data.set<5>(true);
data.set<7>(true);
data.set<11>(true);
data.set<13>(true);
data.set<17>(true);
data.set<19>(true);
data.set<23>(true);
data.set<29>(true);
data.set<31>(true);
return data;
}
TEST(test_set_compile_time_position_run_time_value)
{
std::bitset<64> compare;
ETL_CONSTEXPR14 etl::bitset<64> data(test_set_compile_time_position_run_time_value_helper());
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
ETL_CONSTEXPR14 auto size = data.size();
ETL_CONSTEXPR14 auto count = data.count();
ETL_CONSTEXPR14 auto none = data.none();
ETL_CONSTEXPR14 auto any = data.any();
ETL_CONSTEXPR14 auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
ETL_CONSTEXPR14 etl::bitset<64> test_set_compile_time_position_value_helper()
{
etl::bitset<64> data;
data.set<2, true>();
data.set<3, true>();
data.set<5, true>();
data.set<7, true>();
data.set<11, true>();
data.set<13, true>();
data.set<17, true>();
data.set<19, true>();
data.set<23, true>();
data.set<29, true>();
data.set<31, true>();
return data;
}
TEST(test_set_compile_time_position_value)
{
std::bitset<64> compare;
ETL_CONSTEXPR14 etl::bitset<64> data(test_set_compile_time_position_value_helper());
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
ETL_CONSTEXPR14 auto size = data.size();
ETL_CONSTEXPR14 auto count = data.count();
ETL_CONSTEXPR14 auto none = data.none();
ETL_CONSTEXPR14 auto any = data.any();
ETL_CONSTEXPR14 auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
TEST(test_set_with_char_string)
{
@ -2255,5 +2601,58 @@ namespace
//int16_t v1 = b.extract<int16_t, 16, 17>());
//int16_t v2 = b.extract<int16_t, 17, 16>());
}
//*************************************************************************
bool test_bit(int i)
{
return (0x1234 & (1 << i)) != 0;
}
TEST(test_test_run_time)
{
ETL_CONSTEXPR14 etl::bitset<16> b(0x1234);
ETL_CONSTEXPR14 bool t0 = b.test(0);
ETL_CONSTEXPR14 bool t1 = b.test(1);
ETL_CONSTEXPR14 bool t2 = b.test(2);
ETL_CONSTEXPR14 bool t3 = b.test(3);
ETL_CONSTEXPR14 bool t4 = b.test(4);
ETL_CONSTEXPR14 bool t5 = b.test(5);
ETL_CONSTEXPR14 bool t6 = b.test(6);
ETL_CONSTEXPR14 bool t7 = b.test(7);
CHECK_EQUAL(test_bit(0), t0);
CHECK_EQUAL(test_bit(1), t1);
CHECK_EQUAL(test_bit(2), t2);
CHECK_EQUAL(test_bit(3), t3);
CHECK_EQUAL(test_bit(4), t4);
CHECK_EQUAL(test_bit(5), t5);
CHECK_EQUAL(test_bit(6), t6);
CHECK_EQUAL(test_bit(7), t7);
}
//*************************************************************************
TEST(test_test_compile_time)
{
ETL_CONSTEXPR14 etl::bitset<16> b(0x1234);
ETL_CONSTEXPR14 bool t0 = b.test<0>();
ETL_CONSTEXPR14 bool t1 = b.test<1>();
ETL_CONSTEXPR14 bool t2 = b.test<2>();
ETL_CONSTEXPR14 bool t3 = b.test<3>();
ETL_CONSTEXPR14 bool t4 = b.test<4>();
ETL_CONSTEXPR14 bool t5 = b.test<5>();
ETL_CONSTEXPR14 bool t6 = b.test<6>();
ETL_CONSTEXPR14 bool t7 = b.test<7>();
CHECK_EQUAL(test_bit(0), t0);
CHECK_EQUAL(test_bit(1), t1);
CHECK_EQUAL(test_bit(2), t2);
CHECK_EQUAL(test_bit(3), t3);
CHECK_EQUAL(test_bit(4), t4);
CHECK_EQUAL(test_bit(5), t5);
CHECK_EQUAL(test_bit(6), t6);
CHECK_EQUAL(test_bit(7), t7);
}
};
}

399
test/test_bitset_new_explicit_single_element_type.cpp
View File

@ -119,6 +119,77 @@ namespace
SUITE(test_bitset_new_explicit_element_type)
{
//*************************************************************************
TEST(test_constants)
{
using bitset_type = etl::bitset<60, uint64_t>;
using element_type = bitset_type::element_type;
constexpr size_t Size = 60;
constexpr size_t Bits_Per_Element = etl::integral_limits<element_type>::bits;
constexpr size_t Number_Of_Elements = (Size % Bits_Per_Element == 0) ? Size / Bits_Per_Element : Size / Bits_Per_Element + 1;
constexpr element_type All_Set_Element = etl::integral_limits<element_type>::max;
constexpr element_type All_Clear_Element = etl::integral_limits<element_type>::min;
//*******************************
constexpr size_t Size1 = bitset_type::Size;
constexpr size_t Size2 = bitset_type::size();
CHECK_EQUAL(Size, Size1);
CHECK_EQUAL(Size, Size2);
//*******************************
constexpr size_t Bits_Per_Element1 = bitset_type::Bits_Per_Element;
constexpr size_t Bits_Per_Element2 = bitset_type::bits_per_element();
CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element1);
CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element2);
//*******************************
constexpr size_t Number_Of_Elements1 = bitset_type::Number_Of_Elements;
constexpr size_t Number_Of_Elements2 = bitset_type::number_of_elements();
CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements1);
CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements2);
//*******************************
constexpr element_type All_Set_Element1 = bitset_type::All_Set_Element;
constexpr element_type All_Set_Element2 = bitset_type::all_set_element();
CHECK_EQUAL(All_Set_Element, All_Set_Element1);
CHECK_EQUAL(All_Set_Element, All_Set_Element2);
//*******************************
constexpr element_type All_Clear_Element1 = bitset_type::All_Clear_Element;
constexpr element_type All_Clear_Element2 = bitset_type::all_clear_element();
CHECK_EQUAL(All_Clear_Element, All_Clear_Element1);
CHECK_EQUAL(All_Clear_Element, All_Clear_Element2);
//*******************************
constexpr size_t Allocated_Bits = bitset_type::allocated_bits();
CHECK_EQUAL(Number_Of_Elements * Bits_Per_Element, Allocated_Bits);
//*******************************
constexpr char Storage_Model1 = bitset_type::Storage_Model;
constexpr char Storage_Model2 = bitset_type::storage_model();
CHECK_EQUAL(etl::bitset_storage_model::Single, Storage_Model1);
CHECK_EQUAL(etl::bitset_storage_model::Single, Storage_Model2);
etl::bitset_storage_model bsm;
bsm = etl::bitset_storage_model::Undefined;
CHECK_EQUAL(std::string("Undefined"), std::string(bsm.c_str()));
bsm = etl::bitset_storage_model::Single;
CHECK_EQUAL(std::string("Single"), std::string(bsm.c_str()));
bsm = etl::bitset_storage_model::Multi;
CHECK_EQUAL(std::string("Multi"), std::string(bsm.c_str()));
}
//*************************************************************************
TEST(test_default_constructor)
{
@ -390,6 +461,281 @@ namespace
}
}
//*************************************************************************
ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_run_time_position_default_value_helper()
{
etl::bitset<64, uint64_t> data;
data.set(2);
data.set(3);
data.set(5);
data.set(7);
data.set(11);
data.set(13);
data.set(17);
data.set(19);
data.set(23);
data.set(29);
data.set(31);
return data;
}
TEST(test_set_run_time_position_default_value)
{
std::bitset<64> compare;
ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_run_time_position_default_value_helper());
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
ETL_CONSTEXPR14 auto size = data.size();
ETL_CONSTEXPR14 auto count = data.count();
ETL_CONSTEXPR14 auto none = data.none();
ETL_CONSTEXPR14 auto any = data.any();
ETL_CONSTEXPR14 auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_run_time_position_value_helper()
{
etl::bitset<64, uint64_t> data;
data.set(2, true);
data.set(3, true);
data.set(5, true);
data.set(7, true);
data.set(11, true);
data.set(13, true);
data.set(17, true);
data.set(19, true);
data.set(23, true);
data.set(29, true);
data.set(31, true);
return data;
}
TEST(test_set_run_time_position_value)
{
std::bitset<64> compare;
ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_run_time_position_value_helper());
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
ETL_CONSTEXPR14 auto size = data.size();
ETL_CONSTEXPR14 auto count = data.count();
ETL_CONSTEXPR14 auto none = data.none();
ETL_CONSTEXPR14 auto any = data.any();
ETL_CONSTEXPR14 auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_compile_time_position_run_time_default_value_helper()
{
etl::bitset<64, uint64_t> data;
data.set<2>();
data.set<3>();
data.set<5>();
data.set<7>();
data.set<11>();
data.set<13>();
data.set<17>();
data.set<19>();
data.set<23>();
data.set<29>();
data.set<31>();
return data;
}
TEST(test_set_compile_time_position_run_time_default_value)
{
std::bitset<64> compare;
ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_compile_time_position_run_time_default_value_helper());
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
ETL_CONSTEXPR14 auto size = data.size();
ETL_CONSTEXPR14 auto count = data.count();
ETL_CONSTEXPR14 auto none = data.none();
ETL_CONSTEXPR14 auto any = data.any();
ETL_CONSTEXPR14 auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_compile_time_position_run_time_value_helper()
{
etl::bitset<64, uint64_t> data;
data.set<2>(true);
data.set<3>(true);
data.set<5>(true);
data.set<7>(true);
data.set<11>(true);
data.set<13>(true);
data.set<17>(true);
data.set<19>(true);
data.set<23>(true);
data.set<29>(true);
data.set<31>(true);
return data;
}
TEST(test_set_compile_time_position_run_time_value)
{
std::bitset<64> compare;
ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_compile_time_position_run_time_value_helper());
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
ETL_CONSTEXPR14 auto size = data.size();
ETL_CONSTEXPR14 auto count = data.count();
ETL_CONSTEXPR14 auto none = data.none();
ETL_CONSTEXPR14 auto any = data.any();
ETL_CONSTEXPR14 auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_compile_time_position_value_helper()
{
etl::bitset<64, uint64_t> data;
data.set<2, true>();
data.set<3, true>();
data.set<5, true>();
data.set<7, true>();
data.set<11, true>();
data.set<13, true>();
data.set<17, true>();
data.set<19, true>();
data.set<23, true>();
data.set<29, true>();
data.set<31, true>();
return data;
}
TEST(test_set_compile_time_position_value)
{
std::bitset<64> compare;
ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_compile_time_position_value_helper());
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
ETL_CONSTEXPR14 auto size = data.size();
ETL_CONSTEXPR14 auto count = data.count();
ETL_CONSTEXPR14 auto none = data.none();
ETL_CONSTEXPR14 auto any = data.any();
ETL_CONSTEXPR14 auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
TEST(test_set_with_char_string)
{
@ -2348,5 +2694,58 @@ namespace
//int16_t v1 = b.extract<int16_t, 16, 17>());
//int16_t v2 = b.extract<int16_t, 17, 16>());
}
//*************************************************************************
bool test_bit(int i)
{
return (0x1234 & (1 << i)) != 0;
}
TEST(test_test_run_time)
{
ETL_CONSTEXPR14 etl::bitset<16, uint16_t> b(0x1234);
ETL_CONSTEXPR14 bool t0 = b.test(0);
ETL_CONSTEXPR14 bool t1 = b.test(1);
ETL_CONSTEXPR14 bool t2 = b.test(2);
ETL_CONSTEXPR14 bool t3 = b.test(3);
ETL_CONSTEXPR14 bool t4 = b.test(4);
ETL_CONSTEXPR14 bool t5 = b.test(5);
ETL_CONSTEXPR14 bool t6 = b.test(6);
ETL_CONSTEXPR14 bool t7 = b.test(7);
CHECK_EQUAL(test_bit(0), t0);
CHECK_EQUAL(test_bit(1), t1);
CHECK_EQUAL(test_bit(2), t2);
CHECK_EQUAL(test_bit(3), t3);
CHECK_EQUAL(test_bit(4), t4);
CHECK_EQUAL(test_bit(5), t5);
CHECK_EQUAL(test_bit(6), t6);
CHECK_EQUAL(test_bit(7), t7);
}
//*************************************************************************
TEST(test_test_compile_time)
{
ETL_CONSTEXPR14 etl::bitset<16, uint16_t> b(0x1234);
ETL_CONSTEXPR14 bool t0 = b.test<0>();
ETL_CONSTEXPR14 bool t1 = b.test<1>();
ETL_CONSTEXPR14 bool t2 = b.test<2>();
ETL_CONSTEXPR14 bool t3 = b.test<3>();
ETL_CONSTEXPR14 bool t4 = b.test<4>();
ETL_CONSTEXPR14 bool t5 = b.test<5>();
ETL_CONSTEXPR14 bool t6 = b.test<6>();
ETL_CONSTEXPR14 bool t7 = b.test<7>();
CHECK_EQUAL(test_bit(0), t0);
CHECK_EQUAL(test_bit(1), t1);
CHECK_EQUAL(test_bit(2), t2);
CHECK_EQUAL(test_bit(3), t3);
CHECK_EQUAL(test_bit(4), t4);
CHECK_EQUAL(test_bit(5), t5);
CHECK_EQUAL(test_bit(6), t6);
CHECK_EQUAL(test_bit(7), t7);
}
};
}

373
test/test_bitset_new_ext_default_element_type.cpp
View File

@ -45,6 +45,77 @@ namespace
SUITE(test_bitset_new_ext_default_element_type)
{
//*************************************************************************
TEST(test_constants)
{
using bitset_type = etl::bitset_ext<60>;
using element_type = bitset_type::element_type;
constexpr size_t Size = 60;
constexpr size_t Bits_Per_Element = etl::integral_limits<element_type>::bits;
constexpr size_t Number_Of_Elements = (Size % Bits_Per_Element == 0) ? Size / Bits_Per_Element : Size / Bits_Per_Element + 1;
constexpr element_type All_Set_Element = etl::integral_limits<element_type>::max;
constexpr element_type All_Clear_Element = etl::integral_limits<element_type>::min;
//*******************************
constexpr size_t Size1 = bitset_type::Size;
constexpr size_t Size2 = bitset_type::size();
CHECK_EQUAL(Size, Size1);
CHECK_EQUAL(Size, Size2);
//*******************************
constexpr size_t Bits_Per_Element1 = bitset_type::Bits_Per_Element;
constexpr size_t Bits_Per_Element2 = bitset_type::bits_per_element();
CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element1);
CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element2);
//*******************************
constexpr size_t Number_Of_Elements1 = bitset_type::Number_Of_Elements;
constexpr size_t Number_Of_Elements2 = bitset_type::number_of_elements();
CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements1);
CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements2);
//*******************************
constexpr element_type All_Set_Element1 = bitset_type::All_Set_Element;
constexpr element_type All_Set_Element2 = bitset_type::all_set_element();
CHECK_EQUAL(All_Set_Element, All_Set_Element1);
CHECK_EQUAL(All_Set_Element, All_Set_Element2);
//*******************************
constexpr element_type All_Clear_Element1 = bitset_type::All_Clear_Element;
constexpr element_type All_Clear_Element2 = bitset_type::all_clear_element();
CHECK_EQUAL(All_Clear_Element, All_Clear_Element1);
CHECK_EQUAL(All_Clear_Element, All_Clear_Element2);
//*******************************
constexpr size_t Allocated_Bits = bitset_type::allocated_bits();
CHECK_EQUAL(Number_Of_Elements * Bits_Per_Element, Allocated_Bits);
//*******************************
constexpr char Storage_Model1 = bitset_type::Storage_Model;
constexpr char Storage_Model2 = bitset_type::storage_model();
CHECK_EQUAL(etl::bitset_storage_model::Multi, Storage_Model1);
CHECK_EQUAL(etl::bitset_storage_model::Multi, Storage_Model2);
etl::bitset_storage_model bsm;
bsm = etl::bitset_storage_model::Undefined;
CHECK_EQUAL(std::string("Undefined"), std::string(bsm.c_str()));
bsm = etl::bitset_storage_model::Single;
CHECK_EQUAL(std::string("Single"), std::string(bsm.c_str()));
bsm = etl::bitset_storage_model::Multi;
CHECK_EQUAL(std::string("Multi"), std::string(bsm.c_str()));
}
//*************************************************************************
TEST(test_construct_from_nullptr_buffer)
{
@ -334,6 +405,251 @@ namespace
}
}
//*************************************************************************
TEST(test_set_run_time_position_default_value)
{
std::bitset<64> compare;
etl::bitset_ext<64>::buffer_type buffer;
etl::bitset_ext<64> data(buffer);
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
data.set(2);
data.set(3);
data.set(5);
data.set(7);
data.set(11);
data.set(13);
data.set(17);
data.set(19);
data.set(23);
data.set(29);
data.set(31);
auto size = data.size();
auto count = data.count();
auto none = data.none();
auto any = data.any();
auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
TEST(test_set_run_time_position_value)
{
std::bitset<64> compare;
etl::bitset_ext<64>::buffer_type buffer;
etl::bitset_ext<64> data(buffer);
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
data.set(2, true);
data.set(3, true);
data.set(5, true);
data.set(7, true);
data.set(11, true);
data.set(13, true);
data.set(17, true);
data.set(19, true);
data.set(23, true);
data.set(29, true);
data.set(31, true);
auto size = data.size();
auto count = data.count();
auto none = data.none();
auto any = data.any();
auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
TEST(test_set_compile_time_position_run_time_default_value)
{
std::bitset<64> compare;
etl::bitset_ext<64>::buffer_type buffer;
etl::bitset_ext<64> data(buffer);
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
data.set<2>();
data.set<3>();
data.set<5>();
data.set<7>();
data.set<11>();
data.set<13>();
data.set<17>();
data.set<19>();
data.set<23>();
data.set<29>();
data.set<31>();
auto size = data.size();
auto count = data.count();
auto none = data.none();
auto any = data.any();
auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
TEST(test_set_compile_time_position_run_time_value)
{
std::bitset<64> compare;
etl::bitset_ext<64>::buffer_type buffer;
etl::bitset_ext<64> data(buffer);
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
data.set<2>(true);
data.set<3>(true);
data.set<5>(true);
data.set<7>(true);
data.set<11>(true);
data.set<13>(true);
data.set<17>(true);
data.set<19>(true);
data.set<23>(true);
data.set<29>(true);
data.set<31>(true);
auto size = data.size();
auto count = data.count();
auto none = data.none();
auto any = data.any();
auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
TEST(test_set_compile_time_position_value)
{
std::bitset<64> compare;
etl::bitset_ext<64>::buffer_type buffer;
etl::bitset_ext<64> data(buffer);
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
data.set<2, true>();
data.set<3, true>();
data.set<5, true>();
data.set<7, true>();
data.set<11, true>();
data.set<13, true>();
data.set<17, true>();
data.set<19, true>();
data.set<23, true>();
data.set<29, true>();
data.set<31, true>();
auto size = data.size();
auto count = data.count();
auto none = data.none();
auto any = data.any();
auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
TEST(test_set_with_char_string)
{
@ -2020,5 +2336,62 @@ namespace
//uint16_t v1 = b.extract<uint16_t, 16, 17>());
//uint16_t v2 = b.extract<uint16_t, 17, 16>());
}
//*************************************************************************
bool test_bit(int i)
{
return (0x1234 & (1 << i)) != 0;
}
TEST(test_test_run_time)
{
etl::bitset_ext<16>::buffer_type buffer;
etl::bitset_ext<16> b(0x1234, buffer);
bool t0 = b.test(0);
bool t1 = b.test(1);
bool t2 = b.test(2);
bool t3 = b.test(3);
bool t4 = b.test(4);
bool t5 = b.test(5);
bool t6 = b.test(6);
bool t7 = b.test(7);
CHECK_EQUAL(test_bit(0), t0);
CHECK_EQUAL(test_bit(1), t1);
CHECK_EQUAL(test_bit(2), t2);
CHECK_EQUAL(test_bit(3), t3);
CHECK_EQUAL(test_bit(4), t4);
CHECK_EQUAL(test_bit(5), t5);
CHECK_EQUAL(test_bit(6), t6);
CHECK_EQUAL(test_bit(7), t7);
}
//*************************************************************************
TEST(test_test_compile_time)
{
etl::bitset_ext<16>::buffer_type buffer;
etl::bitset_ext<16> b(0x1234, buffer);
bool t0 = b.test<0>();
bool t1 = b.test<1>();
bool t2 = b.test<2>();
bool t3 = b.test<3>();
bool t4 = b.test<4>();
bool t5 = b.test<5>();
bool t6 = b.test<6>();
bool t7 = b.test<7>();
CHECK_EQUAL(test_bit(0), t0);
CHECK_EQUAL(test_bit(1), t1);
CHECK_EQUAL(test_bit(2), t2);
CHECK_EQUAL(test_bit(3), t3);
CHECK_EQUAL(test_bit(4), t4);
CHECK_EQUAL(test_bit(5), t5);
CHECK_EQUAL(test_bit(6), t6);
CHECK_EQUAL(test_bit(7), t7);
}
};
}

373
test/test_bitset_new_ext_explicit_single_element_type.cpp
View File

@ -44,6 +44,77 @@ namespace
SUITE(test_bitset_new_ext_explicit_element_type)
{
//*************************************************************************
TEST(test_constants)
{
using bitset_type = etl::bitset_ext<60, uint64_t>;
using element_type = bitset_type::element_type;
constexpr size_t Size = 60;
constexpr size_t Bits_Per_Element = etl::integral_limits<element_type>::bits;
constexpr size_t Number_Of_Elements = (Size % Bits_Per_Element == 0) ? Size / Bits_Per_Element : Size / Bits_Per_Element + 1;
constexpr element_type All_Set_Element = etl::integral_limits<element_type>::max;
constexpr element_type All_Clear_Element = etl::integral_limits<element_type>::min;
//*******************************
constexpr size_t Size1 = bitset_type::Size;
constexpr size_t Size2 = bitset_type::size();
CHECK_EQUAL(Size, Size1);
CHECK_EQUAL(Size, Size2);
//*******************************
constexpr size_t Bits_Per_Element1 = bitset_type::Bits_Per_Element;
constexpr size_t Bits_Per_Element2 = bitset_type::bits_per_element();
CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element1);
CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element2);
//*******************************
constexpr size_t Number_Of_Elements1 = bitset_type::Number_Of_Elements;
constexpr size_t Number_Of_Elements2 = bitset_type::number_of_elements();
CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements1);
CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements2);
//*******************************
constexpr element_type All_Set_Element1 = bitset_type::All_Set_Element;
constexpr element_type All_Set_Element2 = bitset_type::all_set_element();
CHECK_EQUAL(All_Set_Element, All_Set_Element1);
CHECK_EQUAL(All_Set_Element, All_Set_Element2);
//*******************************
constexpr size_t All_Clear_Element1 = bitset_type::All_Clear_Element;
constexpr size_t All_Clear_Element2 = bitset_type::all_clear_element();
CHECK_EQUAL(All_Clear_Element, All_Clear_Element1);
CHECK_EQUAL(All_Clear_Element, All_Clear_Element2);
//*******************************
constexpr size_t Allocated_Bits = bitset_type::allocated_bits();
CHECK_EQUAL(Number_Of_Elements * Bits_Per_Element, Allocated_Bits);
//*******************************
constexpr char Storage_Model1 = bitset_type::Storage_Model;
constexpr char Storage_Model2 = bitset_type::storage_model();
CHECK_EQUAL(etl::bitset_storage_model::Single, Storage_Model1);
CHECK_EQUAL(etl::bitset_storage_model::Single, Storage_Model2);
etl::bitset_storage_model bsm;
bsm = etl::bitset_storage_model::Undefined;
CHECK_EQUAL(std::string("Undefined"), std::string(bsm.c_str()));
bsm = etl::bitset_storage_model::Single;
CHECK_EQUAL(std::string("Single"), std::string(bsm.c_str()));
bsm = etl::bitset_storage_model::Multi;
CHECK_EQUAL(std::string("Multi"), std::string(bsm.c_str()));
}
//*************************************************************************
TEST(test_construct_from_nullptr_buffer)
{
@ -362,6 +433,251 @@ namespace
}
}
//*************************************************************************
TEST(test_set_run_time_position_default_value)
{
std::bitset<64> compare;
etl::bitset_ext<64, uint64_t>::buffer_type buffer;
etl::bitset_ext<64, uint64_t> data(buffer);
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
data.set(2);
data.set(3);
data.set(5);
data.set(7);
data.set(11);
data.set(13);
data.set(17);
data.set(19);
data.set(23);
data.set(29);
data.set(31);
auto size = data.size();
auto count = data.count();
auto none = data.none();
auto any = data.any();
auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
TEST(test_set_run_time_position_value)
{
std::bitset<64> compare;
etl::bitset_ext<64, uint64_t>::buffer_type buffer;
etl::bitset_ext<64, uint64_t> data(buffer);
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
data.set(2, true);
data.set(3, true);
data.set(5, true);
data.set(7, true);
data.set(11, true);
data.set(13, true);
data.set(17, true);
data.set(19, true);
data.set(23, true);
data.set(29, true);
data.set(31, true);
auto size = data.size();
auto count = data.count();
auto none = data.none();
auto any = data.any();
auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
TEST(test_set_compile_time_position_run_time_default_value)
{
std::bitset<64> compare;
etl::bitset_ext<64, uint64_t>::buffer_type buffer;
etl::bitset_ext<64, uint64_t> data(buffer);
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
data.set<2>();
data.set<3>();
data.set<5>();
data.set<7>();
data.set<11>();
data.set<13>();
data.set<17>();
data.set<19>();
data.set<23>();
data.set<29>();
data.set<31>();
auto size = data.size();
auto count = data.count();
auto none = data.none();
auto any = data.any();
auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
TEST(test_set_compile_time_position_run_time_value)
{
std::bitset<64> compare;
etl::bitset_ext<64, uint64_t>::buffer_type buffer;
etl::bitset_ext<64, uint64_t> data(buffer);
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
data.set<2>(true);
data.set<3>(true);
data.set<5>(true);
data.set<7>(true);
data.set<11>(true);
data.set<13>(true);
data.set<17>(true);
data.set<19>(true);
data.set<23>(true);
data.set<29>(true);
data.set<31>(true);
auto size = data.size();
auto count = data.count();
auto none = data.none();
auto any = data.any();
auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
TEST(test_set_compile_time_position_value)
{
std::bitset<64> compare;
etl::bitset_ext<64, uint64_t>::buffer_type buffer;
etl::bitset_ext<64, uint64_t> data(buffer);
compare.set(2);
compare.set(3);
compare.set(5);
compare.set(7);
compare.set(11);
compare.set(13);
compare.set(17);
compare.set(19);
compare.set(23);
compare.set(29);
compare.set(31);
data.set<2, true>();
data.set<3, true>();
data.set<5, true>();
data.set<7, true>();
data.set<11, true>();
data.set<13, true>();
data.set<17, true>();
data.set<19, true>();
data.set<23, true>();
data.set<29, true>();
data.set<31, true>();
auto size = data.size();
auto count = data.count();
auto none = data.none();
auto any = data.any();
auto all = data.all();
CHECK_EQUAL(compare.size(), size);
CHECK_EQUAL(compare.count(), count);
CHECK_EQUAL(compare.none(), none);
CHECK_EQUAL(compare.any(), any);
CHECK_EQUAL(compare.all(), all);
for (size_t i = 0UL; i < data.size(); ++i)
{
CHECK_EQUAL(compare.test(i), data.test(i));
}
}
//*************************************************************************
TEST(test_set_with_char_string)
{
@ -2168,5 +2484,62 @@ namespace
//uint16_t v1 = b.extract<uint16_t, 16, 17>());
//uint16_t v2 = b.extract<uint16_t, 17, 16>());
}
//*************************************************************************
bool test_bit(int i)
{
return (0x1234 & (1 << i)) != 0;
}
TEST(test_test_run_time)
{
etl::bitset_ext<16, uint16_t>::buffer_type buffer;
etl::bitset_ext<16, uint16_t> b(0x1234, buffer);
bool t0 = b.test(0);
bool t1 = b.test(1);
bool t2 = b.test(2);
bool t3 = b.test(3);
bool t4 = b.test(4);
bool t5 = b.test(5);
bool t6 = b.test(6);
bool t7 = b.test(7);
CHECK_EQUAL(test_bit(0), t0);
CHECK_EQUAL(test_bit(1), t1);
CHECK_EQUAL(test_bit(2), t2);
CHECK_EQUAL(test_bit(3), t3);
CHECK_EQUAL(test_bit(4), t4);
CHECK_EQUAL(test_bit(5), t5);
CHECK_EQUAL(test_bit(6), t6);
CHECK_EQUAL(test_bit(7), t7);
}
//*************************************************************************
TEST(test_test_compile_time)
{
etl::bitset_ext<16, uint16_t>::buffer_type buffer;
etl::bitset_ext<16, uint16_t> b(0x1234, buffer);
bool t0 = b.test<0>();
bool t1 = b.test<1>();
bool t2 = b.test<2>();
bool t3 = b.test<3>();
bool t4 = b.test<4>();
bool t5 = b.test<5>();
bool t6 = b.test<6>();
bool t7 = b.test<7>();
CHECK_EQUAL(test_bit(0), t0);
CHECK_EQUAL(test_bit(1), t1);
CHECK_EQUAL(test_bit(2), t2);
CHECK_EQUAL(test_bit(3), t3);
CHECK_EQUAL(test_bit(4), t4);
CHECK_EQUAL(test_bit(5), t5);
CHECK_EQUAL(test_bit(6), t6);
CHECK_EQUAL(test_bit(7), t7);
}
};
}