From 3d3dad84991e531488e6782fbe63cd4567bb963a Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Sat, 13 Jan 2024 11:45:57 +0000 Subject: [PATCH] Work in progress --- include/etl/private/bitset_new.h | 616 ++++++++++++++---- test/test_bitset_new_default_element_type.cpp | 399 ++++++++++++ ...itset_new_explicit_single_element_type.cpp | 399 ++++++++++++ ...st_bitset_new_ext_default_element_type.cpp | 373 +++++++++++ ...t_new_ext_explicit_single_element_type.cpp | 373 +++++++++++ 5 files changed, 2031 insertions(+), 129 deletions(-) diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h index 1f76a448..8c341eba 100644 --- a/include/etl/private/bitset_new.h +++ b/include/etl/private/bitset_new.h @@ -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 + 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::max; + static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits::bits; + static ETL_CONSTANT TElement All_Set_Element = etl::integral_limits::max; + static ETL_CONSTANT TElement All_Clear_Element = element_type(0); + }; + + template + ETL_CONSTANT size_t bitset_impl_common::npos; + + template + ETL_CONSTANT size_t bitset_impl_common::Bits_Per_Element; + + template + ETL_CONSTANT TElement bitset_impl_common::All_Set_Element; + + template + ETL_CONSTANT TElement bitset_impl_common::All_Clear_Element; + } + //************************************************************************* /// Bitset implementation declaration. ///\ingroup bitset @@ -163,19 +203,19 @@ namespace etl ///\ingroup bitset //************************************************************************* template - class bitset_impl + class bitset_impl : public etl::private_bitset::bitset_impl_common { public: - typedef TElement element_type; - typedef element_type* pointer; - typedef const element_type* const_pointer; + using typename etl::private_bitset::bitset_impl_common::element_type; + using typename etl::private_bitset::bitset_impl_common::pointer; + using typename etl::private_bitset::bitset_impl_common::const_pointer; - static ETL_CONSTANT size_t npos = etl::integral_limits::max; + using etl::private_bitset::bitset_impl_common::Bits_Per_Element; + using etl::private_bitset::bitset_impl_common::All_Set_Element; + using etl::private_bitset::bitset_impl_common::All_Clear_Element; - static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits::bits; - static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits::max; - static ETL_CONSTANT element_type All_Clear_Element = element_type(0); + using etl::private_bitset::bitset_impl_common::npos; //************************************************************************* /// Set all of the bits. @@ -210,6 +250,47 @@ namespace etl } } + //************************************************************************* + /// Set the bit at the position. + //************************************************************************* + template + 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 + 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 - class bitset_impl + class bitset_impl : public etl::private_bitset::bitset_impl_common { + private: + + typedef etl::private_bitset::bitset_impl_common common; + public: - typedef TElement element_type; - typedef element_type* pointer; - typedef const element_type* const_pointer; + using typename etl::private_bitset::bitset_impl_common::element_type; + using typename etl::private_bitset::bitset_impl_common::pointer; + using typename etl::private_bitset::bitset_impl_common::const_pointer; - static ETL_CONSTANT size_t npos = etl::integral_limits::max; + using etl::private_bitset::bitset_impl_common::Bits_Per_Element; + using etl::private_bitset::bitset_impl_common::All_Set_Element; + using etl::private_bitset::bitset_impl_common::All_Clear_Element; - static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits::bits; - static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits::max; - static ETL_CONSTANT element_type All_Clear_Element = element_type(0); + using etl::private_bitset::bitset_impl_common::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::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 + ETL_CONSTEXPR14 + static + void set_position(pointer pbuffer, + bool value = true) + { + size_t index = Position >> etl::log2::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 + ETL_CONSTEXPR14 + static + void set_position(pointer pbuffer) + { + size_t index = Position >> etl::log2::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 + class bitset_common : public etl::private_bitset::bitset_impl_common + { + public: + + typedef typename etl::private_bitset::bitset_impl_common::element_type element_type; + + using etl::private_bitset::bitset_impl_common::Bits_Per_Element; + using etl::private_bitset::bitset_impl_common::All_Set_Element; + using etl::private_bitset::bitset_impl_common::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 span_type; + typedef etl::span 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 + ETL_CONSTANT size_t bitset_common::Number_Of_Elements; + + template + ETL_CONSTANT size_t bitset_common::Size; + + template + ETL_CONSTANT etl::bitset_storage_model bitset_common::Storage_Model; + + template + ETL_CONSTANT size_t bitset_common::Top_Mask_Shift; + + template + ETL_CONSTANT TElement bitset_common::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::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 - class bitset + class bitset : public etl::private_bitset::bitset_common { public: ETL_STATIC_ASSERT(etl::is_unsigned::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::element_type element_type; + typedef typename etl::private_bitset::bitset_common::span_type span_type; + typedef typename etl::private_bitset::bitset_common::const_span_type const_span_type; - static ETL_CONSTANT size_t npos = etl::integral_limits::max; - - static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits::bits; - static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits::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 span_type; - typedef etl::span const_span_type; + using etl::private_bitset::bitset_common::Bits_Per_Element; + using etl::private_bitset::bitset_common::All_Set_Element; + using etl::private_bitset::bitset_common::All_Clear_Element; + using etl::private_bitset::bitset_common::Number_Of_Elements; + using etl::private_bitset::bitset_common::Size; + using etl::private_bitset::bitset_common::Storage_Model; + using etl::private_bitset::bitset_common::Top_Mask; + using etl::private_bitset::bitset_common::Allocated_Bits; //************************************************************************* /// The reference type returned. @@ -1912,7 +2074,8 @@ namespace etl //************************************************************************* /// Set the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 bitset& set(size_t position, bool value = true) + ETL_CONSTEXPR14 + bitset& 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& set(const char* text) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 bitset& 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(buffer, value); + + return *this; + } + + //************************************************************************* + /// Set the bit at the position. + //************************************************************************* + template + ETL_CONSTEXPR14 bitset& set() + { + ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds"); + + implementation::template set_position(buffer); return *this; } @@ -1934,7 +2113,10 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - ETL_CONSTEXPR14 bitset& set(const wchar_t* text) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 + typename etl::enable_if::value, bitset&>::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& set(const char16_t* text) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 + typename etl::enable_if::value, bitset&>::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& set(const char32_t* text) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 + typename etl::enable_if::value, bitset&>::type + set(TPString text) ETL_NOEXCEPT + { + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); + + return *this; + } + + //************************************************************************* + /// Set from a char32 string. + //************************************************************************* + template + ETL_CONSTEXPR14 + typename etl::enable_if::value, bitset&>::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 + 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::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 - class bitset_ext + class bitset_ext : public etl::private_bitset::bitset_common { public: ETL_STATIC_ASSERT(etl::is_unsigned::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::element_type element_type; + typedef typename etl::private_bitset::bitset_common::span_type span_type; + typedef typename etl::private_bitset::bitset_common::const_span_type const_span_type; + + using etl::private_bitset::bitset_common::Bits_Per_Element; + using etl::private_bitset::bitset_common::All_Set_Element; + using etl::private_bitset::bitset_common::All_Clear_Element; + using etl::private_bitset::bitset_common::Number_Of_Elements; + using etl::private_bitset::bitset_common::Size; + using etl::private_bitset::bitset_common::Storage_Model; + using etl::private_bitset::bitset_common::Top_Mask; + using etl::private_bitset::bitset_common::Allocated_Bits; - static ETL_CONSTANT size_t npos = etl::integral_limits::max; - - static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits::bits; - static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits::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 buffer_type; - typedef etl::span span_type; - typedef etl::span const_span_type; + typedef etl::array buffer_type; //************************************************************************* /// The reference type returned. @@ -2811,21 +3068,38 @@ namespace etl //************************************************************************* /// Set the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(size_t position, bool value = true) + ETL_CONSTEXPR14 + bitset_ext& 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& set(const char* text) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 bitset_ext& 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(pbuffer, value); + + return *this; + } + + //************************************************************************* + /// Set the bit at the position. + //************************************************************************* + template + ETL_CONSTEXPR14 bitset_ext& set() + { + ETL_STATIC_ASSERT(Position < Active_Bits, "Position out of bounds"); + + implementation::template set_position(pbuffer); return *this; } @@ -2833,7 +3107,10 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(const wchar_t* text) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 + typename etl::enable_if::value, bitset_ext&>::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& set(const char16_t* text) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 + typename etl::enable_if::value, bitset_ext&>::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& set(const char32_t* text) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 + typename etl::enable_if::value, bitset_ext&>::type + set(TPString text) ETL_NOEXCEPT + { + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); + + return *this; + } + + //************************************************************************* + /// Set from a char32 string. + //************************************************************************* + template + ETL_CONSTEXPR14 + typename etl::enable_if::value, bitset_ext&>::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 + 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 implementation; diff --git a/test/test_bitset_new_default_element_type.cpp b/test/test_bitset_new_default_element_type.cpp index 1a38ef2b..4ca19920 100644 --- a/test/test_bitset_new_default_element_type.cpp +++ b/test/test_bitset_new_default_element_type.cpp @@ -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::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::max; + constexpr element_type All_Clear_Element = etl::integral_limits::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 v2 = b.extract()); } + + //************************************************************************* + 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); + } }; } diff --git a/test/test_bitset_new_explicit_single_element_type.cpp b/test/test_bitset_new_explicit_single_element_type.cpp index 0ce70049..91411477 100644 --- a/test/test_bitset_new_explicit_single_element_type.cpp +++ b/test/test_bitset_new_explicit_single_element_type.cpp @@ -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::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::max; + constexpr element_type All_Clear_Element = etl::integral_limits::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 v2 = b.extract()); } + + //************************************************************************* + 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); + } }; } diff --git a/test/test_bitset_new_ext_default_element_type.cpp b/test/test_bitset_new_ext_default_element_type.cpp index d62d5c42..6945376d 100644 --- a/test/test_bitset_new_ext_default_element_type.cpp +++ b/test/test_bitset_new_ext_default_element_type.cpp @@ -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::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::max; + constexpr element_type All_Clear_Element = etl::integral_limits::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 v2 = b.extract()); } + + //************************************************************************* + 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); + } }; } diff --git a/test/test_bitset_new_ext_explicit_single_element_type.cpp b/test/test_bitset_new_ext_explicit_single_element_type.cpp index a26fa6a9..d98c779d 100644 --- a/test/test_bitset_new_ext_explicit_single_element_type.cpp +++ b/test/test_bitset_new_ext_explicit_single_element_type.cpp @@ -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::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::max; + constexpr element_type All_Clear_Element = etl::integral_limits::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 v2 = b.extract()); } + + //************************************************************************* + 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); + } }; }