diff --git a/arduino/library-arduino.json b/arduino/library-arduino.json index a79a9907..fec95d0c 100644 --- a/arduino/library-arduino.json +++ b/arduino/library-arduino.json @@ -1,5 +1,5 @@ { - "name": "Embedded Template Library - Arduino", + "name": "Embedded Template Library - ETL", "version": "20.38.10", "authors": { "name": "John Wellbelove", diff --git a/arduino/library-arduino.properties b/arduino/library-arduino.properties index 043882bb..c6a8acb8 100644 --- a/arduino/library-arduino.properties +++ b/arduino/library-arduino.properties @@ -1,7 +1,7 @@ -name=Embedded Template Library - Arduino +name=Embedded Template Library - ETL version=20.38.10 -author= John Wellbelove -maintainer=John Wellbelove +author= John Wellbelove +maintainer=John Wellbelove license=MIT sentence=ETL. A C++ template library tailored for embedded systems. paragraph= diff --git a/include/etl/binary.h b/include/etl/binary.h index 37e6b00f..903d2bca 100644 --- a/include/etl/binary.h +++ b/include/etl/binary.h @@ -2286,7 +2286,7 @@ namespace etl //*********************************** ETL_NODISCARD ETL_CONSTEXPR - T operator ()(T value) ETL_NOEXCEPT + T operator ()(T value) const ETL_NOEXCEPT { ETL_STATIC_ASSERT(etl::is_integral::value, "Not an integral type"); @@ -2311,7 +2311,7 @@ namespace etl //*********************************** ETL_NODISCARD ETL_CONSTEXPR - T operator ()(T value) ETL_NOEXCEPT + T operator ()(T value) const ETL_NOEXCEPT { ETL_STATIC_ASSERT(etl::is_integral::value, "Not an integral type"); @@ -2340,7 +2340,7 @@ namespace etl //*********************************** ETL_NODISCARD ETL_CONSTEXPR - T operator ()(T value) ETL_NOEXCEPT + T operator ()(T value) const ETL_NOEXCEPT { ETL_STATIC_ASSERT(etl::is_integral::value, "Not an integral type"); @@ -2369,7 +2369,7 @@ namespace etl //*********************************** ETL_NODISCARD ETL_CONSTEXPR - T operator ()(T value) ETL_NOEXCEPT + T operator ()(T value) const ETL_NOEXCEPT { ETL_STATIC_ASSERT(etl::is_integral::value, "Not an integral type"); diff --git a/include/etl/bloom_filter.h b/include/etl/bloom_filter.h index 711a151b..5d35128c 100644 --- a/include/etl/bloom_filter.h +++ b/include/etl/bloom_filter.h @@ -62,17 +62,17 @@ namespace etl /// An implementation of a bloom filter. /// Allows up to three hashes to be defined. /// Hashes must support the () operator and define 'argument_type'. - ///\tparam DESIRED_WIDTH The desired number of hash results that can be stored. Rounded up to best fit the underlying bitset. + ///\tparam Desired_Width The desired number of hash results that can be stored. Rounded up to best fit the underlying bitset. ///\tparam THash1 The first hash generator class. ///\tparam THash2 The second hash generator class. If omitted, uses the null hash. ///\tparam THash3 The third hash generator class. If omitted, uses the null hash. /// The hash classes must define argument_type. ///\ingroup bloom_filter //*************************************************************************** - template + template class bloom_filter { private: @@ -85,7 +85,7 @@ namespace etl enum { // Make the most efficient use of the bitset. - WIDTH = etl::bitset::ALLOCATED_BITS + WIDTH = etl::bitset::Allocated_Bits }; //*************************************************************************** diff --git a/include/etl/platform.h b/include/etl/platform.h index a9170c6f..17c7961d 100644 --- a/include/etl/platform.h +++ b/include/etl/platform.h @@ -257,7 +257,6 @@ SOFTWARE. #define ETL_CONSTEXPR constexpr #define ETL_CONSTEXPR11 constexpr // Synonym for ETL_CONSTEXPR #define ETL_CONSTANT constexpr - #define ETL_STATIC_CONSTANT constexpr #define ETL_DELETE = delete #define ETL_EXPLICIT explicit #define ETL_OVERRIDE override @@ -279,7 +278,6 @@ SOFTWARE. #define ETL_CONSTEXPR #define ETL_CONSTEXPR11 #define ETL_CONSTANT const - #define ETL_STATIC_CONSTANT static const #define ETL_DELETE #define ETL_EXPLICIT #define ETL_OVERRIDE diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h index 2887c97d..1220ef92 100644 --- a/include/etl/private/bitset_new.h +++ b/include/etl/private/bitset_new.h @@ -45,11 +45,18 @@ SOFTWARE. #include "../error_handler.h" #include "../span.h" #include "../string.h" +#include "../enum_type.h" +#include "../largest.h" +#include "../smallest.h" #include #include #include +#if ETL_USING_STL +#include +#endif + #include "minmax_push.h" #if defined(ETL_COMPILER_KEIL) @@ -76,14 +83,26 @@ SOFTWARE. namespace etl { - template - struct bitset_constants + //*************************************************************************** + /// Flags to indicate whether the bitset is contained in a single element + /// or spread over an array of elements. + ///\ingroup bitset + //*************************************************************************** + struct bitset_storage_model { - static ETL_CONSTANT size_t npos = etl::integral_limits::max; - }; + enum enum_type + { + Undefined = 0, + Single = 1, + Multi = 2 + }; - template - ETL_CONSTANT size_t bitset_constants::npos; + 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 + }; //*************************************************************************** /// Exception base for bitset @@ -141,87 +160,903 @@ 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; + } + //************************************************************************* - /// The implementation class for multi-element etl::bitset + /// Bitset implementation declaration. + ///\ingroup bitset + //************************************************************************* + template + class bitset_impl; + + //************************************************************************* + /// The implementation class for single element etl::bitset ///\ingroup bitset //************************************************************************* template - class bitset_impl : public bitset_constants<> + class bitset_impl : public etl::private_bitset::bitset_impl_common { public: - typedef typename etl::make_unsigned::type element_type; + 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; - typedef element_type* pointer; - typedef const element_type* const_pointer; + 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; //************************************************************************* - /// Count the number of bits set. + /// Set all of the bits. //************************************************************************* - ETL_CONSTEXPR14 size_t count(const_pointer pbuffer, size_t number_of_elements) const ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void set_all(pointer pbuffer, + size_t /*number_of_elements*/, + element_type top_mask) ETL_NOEXCEPT { - size_t n = 0UL; + *pbuffer = All_Set_Element & top_mask; + } - for (size_t i = 0UL; i < number_of_elements; ++i) + //************************************************************************* + /// Set the bit at the position. + //************************************************************************* + ETL_CONSTEXPR14 + static + void set_position(pointer pbuffer, + size_t position, + bool value = true) + { + const element_type mask = element_type(element_type(1) << position); + + if (value == true) { - n += etl::count_bits(pbuffer[i]); + *pbuffer |= mask; + } + else + { + *pbuffer &= ~mask; + } + } + + //************************************************************************* + /// 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. + //************************************************************************* + ETL_CONSTEXPR14 + static + void reset_all(pointer pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + *pbuffer = All_Clear_Element; + } + + //************************************************************************* + /// Reset the bit at the position. + //************************************************************************* + ETL_CONSTEXPR14 + static + void reset_position(pointer pbuffer, + size_t position) + { + const element_type mask = element_type(element_type(1) << position); + *pbuffer &= ~mask; + } + + //************************************************************************* + /// Set from a string. + //************************************************************************* + ETL_CONSTEXPR14 + static + void from_string(pointer pbuffer, + size_t /*number_of_elements*/, + size_t active_bits, + const char* text) ETL_NOEXCEPT + { + reset_all(pbuffer, 1U); + + if (text != ETL_NULLPTR) + { + size_t string_length = etl::strlen(text); + + // Build from the string. + string_length = etl::min(active_bits, string_length); + + element_type mask = element_type(element_type(1) << (string_length - 1U)); + + for (size_t i = 0U; i < string_length; ++i) + { + if (text[i] == ETL_STR('1')) + { + *pbuffer |= mask; + } + + mask >>= 1U; + } + } + } + + //************************************************************************* + /// Set from a wide string. + //************************************************************************* + ETL_CONSTEXPR14 + static + void from_string(pointer pbuffer, + size_t /*number_of_elements*/, + size_t active_bits, + const wchar_t* text) ETL_NOEXCEPT + { + reset_all(pbuffer, 1U); + + if (text != ETL_NULLPTR) + { + size_t string_length = etl::strlen(text); + + // Build from the string. + string_length = etl::min(active_bits, string_length); + + element_type mask = element_type(element_type(1) << (string_length - 1U)); + + for (size_t i = 0U; i < string_length; ++i) + { + if (text[i] == ETL_STRL('1')) + { + *pbuffer |= mask; + } + + mask >>= 1U; + } + } + } + + //************************************************************************* + /// Set from a u16 string. + //************************************************************************* + ETL_CONSTEXPR14 + static + void from_string(pointer pbuffer, + size_t /*number_of_elements*/, + size_t active_bits, + const char16_t* text) ETL_NOEXCEPT + { + reset_all(pbuffer, 1U); + + if (text != ETL_NULLPTR) + { + size_t string_length = etl::strlen(text); + + // Build from the string. + string_length = etl::min(active_bits, string_length); + + element_type mask = element_type(element_type(1) << (string_length - 1U)); + + for (size_t i = 0U; i < string_length; ++i) + { + if (text[i] == ETL_STRu('1')) + { + *pbuffer |= mask; + } + + mask >>= 1U; + } + } + } + + //************************************************************************* + /// Set from a u32 string. + //************************************************************************* + ETL_CONSTEXPR14 + static + void from_string(pointer pbuffer, + size_t /*number_of_elements*/, + size_t active_bits, + const char32_t* text) ETL_NOEXCEPT + { + reset_all(pbuffer, 1U); + + if (text != ETL_NULLPTR) + { + size_t string_length = etl::strlen(text); + + // Build from the string. + string_length = etl::min(active_bits, string_length); + + element_type mask = element_type(element_type(1) << (string_length - 1U)); + + for (size_t i = 0U; i < string_length; ++i) + { + if (text[i] == ETL_STRU('1')) + { + *pbuffer |= mask; + } + + mask >>= 1U; + } + } + } + + //************************************************************************* + /// Get as an integral value. + //************************************************************************* + template + ETL_CONSTEXPR14 + static + T value(const_pointer pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + return T(*pbuffer); + } + + //************************************************************************* + /// Extract an integral value from an arbitrary position and length. + //************************************************************************* + template + ETL_CONSTEXPR14 + static + T extract(const_pointer pbuffer, + size_t position, + size_t length = etl::integral_limits::bits) + { + typedef typename etl::make_unsigned::type unsigned_t; + + const unsigned_t Mask = etl::make_lsb_mask(length); + const unsigned_t Shift = position % Bits_Per_Element; + + unsigned_t value = static_cast(*pbuffer >> Shift) & Mask; + + if ((length != etl::integral_limits::bits) && etl::integral_limits::is_signed) + { + value = etl::sign_extend(value, length); } - return n; + return static_cast(value); + } + + //************************************************************************* + /// Extract an integral value from an arbitrary position and length. + //************************************************************************* +#if ETL_USING_CPP11 + template ::bits> +#else + template +#endif + ETL_CONSTEXPR14 + static + T extract(const_pointer pbuffer) + { + typedef typename etl::make_unsigned::type unsigned_t; + + const unsigned_t Mask = etl::make_lsb_mask(Length); + const unsigned_t Shift = Position % Bits_Per_Element; + + unsigned_t value = static_cast(*pbuffer >> Shift) & Mask; + + if ((Length != etl::integral_limits::bits) && etl::integral_limits::is_signed) + { + value = etl::sign_extend(value, Length); + } + + return static_cast(value); } //************************************************************************* /// Tests a bit at a position. /// Positions greater than the number of configured bits will return false. //************************************************************************* - ETL_CONSTEXPR14 bool test(const_pointer pbuffer, size_t number_of_elements, size_t position) const ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + bool test(const_pointer pbuffer, + size_t position) { - size_t index = 0U; - element_type mask = element_type(0); + const element_type mask = element_type(element_type(1) << position); + return (*pbuffer & mask) != 0U; + } - if (number_of_elements == 1U) + //************************************************************************* + /// Count the number of bits set. + //************************************************************************* + ETL_CONSTEXPR14 + static + size_t count(const_pointer pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + return etl::count_bits(*pbuffer); + } + + //************************************************************************* + // Are all the bits sets? + //************************************************************************* + ETL_CONSTEXPR14 + static + bool all(const_pointer pbuffer, + size_t /*number_of_elements*/, + element_type top_mask) ETL_NOEXCEPT + { + return (*pbuffer & top_mask) == top_mask; + } + + //************************************************************************* + // Are all the mask bits sets? + //************************************************************************* + ETL_CONSTEXPR14 + static + bool all(const_pointer pbuffer, + size_t /*number_of_elements*/, + element_type top_mask, + element_type mask) ETL_NOEXCEPT + { + return (*pbuffer & top_mask & mask) == mask; + } + + //************************************************************************* + /// Are none of the bits set? + //************************************************************************* + ETL_CONSTEXPR14 + static + bool none(const_pointer pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + return *pbuffer == All_Clear_Element; + } + + //************************************************************************* + /// Are none of the mask bits set? + //************************************************************************* + ETL_CONSTEXPR14 + static + bool none(const_pointer pbuffer, + size_t /*number_of_elements*/, + element_type mask) ETL_NOEXCEPT + { + return (*pbuffer & mask) == All_Clear_Element; + } + + //************************************************************************* + /// Are any of the bits set? + //************************************************************************* + ETL_CONSTEXPR14 + static + bool any(const_pointer pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + return *pbuffer != All_Clear_Element; + } + + //************************************************************************* + /// Are any of the mask bits set? + //************************************************************************* + ETL_CONSTEXPR14 + static + bool any(const_pointer pbuffer, + size_t /*number_of_elements*/, + element_type mask) ETL_NOEXCEPT + { + return (*pbuffer & mask) != All_Clear_Element; + } + + //************************************************************************* + /// Flip all of the bits. + //************************************************************************* + ETL_CONSTEXPR14 + static + void flip_all(pointer pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + *pbuffer = ~*pbuffer; + } + + //************************************************************************* + /// Flip some of the bits. + //************************************************************************* + ETL_CONSTEXPR14 + static + void flip_bits(pointer pbuffer, + element_type mask = etl::integral_limits::max) ETL_NOEXCEPT + { + *pbuffer ^= mask; + } + + //************************************************************************* + /// Flip the bit at the position. + //************************************************************************* + ETL_CONSTEXPR14 + static + void flip_position(pointer pbuffer, + size_t position) + { + const element_type mask = element_type(element_type(1) << position); + *pbuffer ^= mask; + } + + //************************************************************************* + /// Returns a string representing the bitset. + //************************************************************************* + template + ETL_CONSTEXPR14 + static + TString to_string(const_pointer pbuffer, + size_t active_bits, + typename TString::value_type zero = typename TString::value_type('0'), + typename TString::value_type one = typename TString::value_type('1')) + { + TString result; + + result.resize(active_bits, '\0'); + + // Check that the string type can contain the digits. + ETL_ASSERT_OR_RETURN_VALUE(result.size() == active_bits, ETL_ERROR(etl::bitset_string_too_small), result); + + for (size_t i = active_bits; i > 0; --i) { - index = 0; - mask = element_type(1) << position; + result[active_bits - i] = test(pbuffer, i - 1) ? one : zero; + } + + return result; + } + + //************************************************************************* + /// Finds the next bit in the specified state. + ///\param state The state to search for. + ///\param position The position to start from. + ///\returns The position of the bit or npos if none were found. + //************************************************************************* + ETL_CONSTEXPR14 + static + size_t find_next(const_pointer pbuffer, + size_t /*number_of_elements*/, + size_t active_bits, + bool state, + size_t position) ETL_NOEXCEPT + { + if (position < active_bits) + { + // Where to start. + size_t bit = position; + + element_type mask = 1U << position; + + // Needs checking? + if ((state && (*pbuffer != All_Clear_Element)) || (!state && (*pbuffer != All_Set_Element))) + { + // For each bit in the element... + while (bit < active_bits) + { + // Equal to the required state? + if (((*pbuffer & mask) != 0) == state) + { + return bit; + } + + // Move on to the next bit. + mask <<= 1; + ++bit; + } + } + } + + return npos; + } + + //************************************************************************* + /// operator assignment + /// Assigns rhs to lhs + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_assignment(pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + *lhs_pbuffer = *rhs_pbuffer; + } + + //************************************************************************* + /// operator and + /// AND lhs and rhs and put the result in lhs + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_and(pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + *lhs_pbuffer &= *rhs_pbuffer; + } + + //************************************************************************* + /// operator or + /// OR lhs and rhs and put the result in lhs + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_or(pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + *lhs_pbuffer |= *rhs_pbuffer; + } + + //************************************************************************* + /// operator xor + /// XOR lhs and rhs and put the result in lhs + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_xor(pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + *lhs_pbuffer ^= *rhs_pbuffer; + } + + //************************************************************************* + /// operator ~ + /// NOT the value in the buffer + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_not(pointer pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + *pbuffer = ~*pbuffer; + } + + //************************************************************************* + /// operator_shift_left + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_shift_left(pointer pbuffer, + size_t /*number_of_elements*/, + size_t active_bits, + size_t shift) ETL_NOEXCEPT + { + if (shift >= active_bits) + { + reset_all(pbuffer, 1U); } else { - index = position >> etl::log2::value; - mask = element_type(1) << (position & (Bits_Per_Element - 1)); + *pbuffer <<= shift; } + } + + //************************************************************************* + /// operator_shift_right + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_shift_right(pointer pbuffer, + size_t /*number_of_elements*/, + size_t active_bits, + size_t shift) ETL_NOEXCEPT + { + if (shift >= active_bits) + { + reset_all(pbuffer, 1U); + } + else + { + *pbuffer >>= shift; + } + } + + //************************************************************************* + /// operator_equality + //************************************************************************* + ETL_CONSTEXPR14 + static + bool operator_equality(const_pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + return (*lhs_pbuffer == *rhs_pbuffer); + } + + //************************************************************************* + /// Initialise from an unsigned long long. + //************************************************************************* + ETL_CONSTEXPR14 + static + void initialise(pointer pbuffer, + size_t /*number_of_elements*/, + unsigned long long value) ETL_NOEXCEPT + { + *pbuffer = static_cast(value); + } + + //************************************************************************* + /// swap + //************************************************************************* + ETL_CONSTEXPR14 + static + void swap(pointer lhs_pbuffer, + pointer rhs_pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + element_type temp = *lhs_pbuffer; + *lhs_pbuffer = *rhs_pbuffer; + *rhs_pbuffer = temp; + } + }; + + //************************************************************************* + /// The implementation class for multi element etl::bitset + ///\ingroup bitset + //************************************************************************* + template + class bitset_impl : public etl::private_bitset::bitset_impl_common + { + private: + + typedef etl::private_bitset::bitset_impl_common common; + + public: + + 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; + + 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; + + using etl::private_bitset::bitset_impl_common::npos; + + //************************************************************************* + /// Check to see if the requested extract is contained within one element. + //************************************************************************* + template + struct value_is_in_one_element + { + static ETL_CONSTANT bool value = ((Position + Length - 1) >> etl::log2::value) == (Position >> etl::log2::value); + }; + + //************************************************************************* + /// Tests a bit at a position. + /// Positions greater than the number of configured bits will return false. + //************************************************************************* + ETL_CONSTEXPR14 + static + bool test(const_pointer pbuffer, + size_t position) ETL_NOEXCEPT + { + size_t index = position >> etl::log2::value; + element_type mask = element_type(1) << (position & (Bits_Per_Element - 1)); return (pbuffer[index] & mask) != 0; } + //************************************************************************* + /// Count the number of bits set. + //************************************************************************* + ETL_CONSTEXPR14 + static + size_t count(const_pointer pbuffer, + size_t number_of_elements) ETL_NOEXCEPT + { + size_t count = 0; + + while (number_of_elements-- != 0) + { + count += etl::count_bits(*pbuffer++); + } + + return count; + } + + //************************************************************************* + // Are all the bits sets? + //************************************************************************* + ETL_CONSTEXPR14 + static + bool all(const_pointer pbuffer, + size_t number_of_elements, + element_type top_mask) ETL_NOEXCEPT + { + // All but the last. + while (number_of_elements-- != 1U) + { + if (*pbuffer++ != All_Set_Element) + { + return false; + } + } + + // The last. + if ((*pbuffer & top_mask) != top_mask) + { + return false; + } + + return true; + } + + //************************************************************************* + /// Are none of the bits set? + //************************************************************************* + ETL_CONSTEXPR14 + static + bool none(const_pointer pbuffer, + size_t number_of_elements) ETL_NOEXCEPT + { + while (number_of_elements-- != 0) + { + if (*pbuffer++ != 0) + { + return false; + } + } + + return true; + } + + //************************************************************************* + /// Are any of the bits set? + //************************************************************************* + ETL_CONSTEXPR14 + static + bool any(const_pointer pbuffer, + size_t number_of_elements) ETL_NOEXCEPT + { + bool any_set = false; + + while (number_of_elements-- != 0) + { + if (*pbuffer++ != All_Clear_Element) + { + any_set = true; + break; + } + } + + return any_set; + } + + //************************************************************************* + /// Set all bits + //************************************************************************* + ETL_CONSTEXPR14 + static + void set_all(pointer pbuffer, + size_t number_of_elements, + element_type top_mask) ETL_NOEXCEPT + { + while (number_of_elements-- != 1U) + { + *pbuffer++ = All_Set_Element; + } + + *pbuffer = (All_Set_Element & top_mask); + } //************************************************************************* /// Set the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t position, bool value = true) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void set_position(pointer pbuffer, + size_t position, + bool value = true) ETL_NOEXCEPT { - size_t index = 0; - element_type bit = 0; + size_t index = position >> etl::log2::value; + element_type bit = element_type(1) << (position & (Bits_Per_Element - 1)); - if (number_of_elements == 0) + if (value == true) { - return; - } - else if (number_of_elements == 1U) - { - index = 0; - bit = element_type(1) << position; + pbuffer[index] |= bit; } else { - index = position >> etl::log2::value; - bit = element_type(1) << (position & (Bits_Per_Element - 1)); + pbuffer[index] &= ~bit; } + } - if (value) + //************************************************************************* + /// 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; } @@ -234,7 +1069,12 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void from_string(pointer pbuffer, + size_t number_of_elements, + size_t total_bits, + const char* text) ETL_NOEXCEPT { if (text == ETL_NULLPTR) { @@ -243,12 +1083,12 @@ namespace etl else { size_t string_length = etl::strlen(text); - size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element)); + size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element)); // Only reset elements we need to. - while (element_index != number_of_elements) + while (index != number_of_elements) { - pbuffer[element_index++] = All_Clear_Element; + pbuffer[index++] = All_Clear_Element; } // Build from the string. @@ -256,7 +1096,7 @@ namespace etl while (i > 0) { - set(pbuffer, number_of_elements, --i, *text++ == ETL_STR('1')); + set_position(pbuffer, --i, *text++ == ETL_STR('1')); } } } @@ -264,7 +1104,12 @@ namespace etl //************************************************************************* /// Set from a wide string. //************************************************************************* - ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const wchar_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void from_string(pointer pbuffer, + size_t number_of_elements, + size_t total_bits, + const wchar_t* text) ETL_NOEXCEPT { if (text == ETL_NULLPTR) { @@ -273,12 +1118,12 @@ namespace etl else { size_t string_length = etl::strlen(text); - size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element)); + size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element)); // Only reset elements we need to. - while (element_index != number_of_elements) + while (index != number_of_elements) { - pbuffer[element_index++] = All_Clear_Element; + pbuffer[index++] = All_Clear_Element; } // Build from the string. @@ -286,7 +1131,7 @@ namespace etl while (i > 0) { - set(pbuffer, number_of_elements, --i, *text++ == ETL_STRL('1')); + set_position(pbuffer, --i, *text++ == ETL_STRL('1')); } } } @@ -294,7 +1139,12 @@ namespace etl //************************************************************************* /// Set from a u16 string. //************************************************************************* - ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char16_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void from_string(pointer pbuffer, + size_t number_of_elements, + size_t total_bits, + const char16_t* text) ETL_NOEXCEPT { if (text == ETL_NULLPTR) { @@ -303,12 +1153,12 @@ namespace etl else { size_t string_length = etl::strlen(text); - size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element)); + size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element)); // Only reset elements we need to. - while (element_index != number_of_elements) + while (index != number_of_elements) { - pbuffer[element_index++] = All_Clear_Element; + pbuffer[index++] = All_Clear_Element; } // Build from the string. @@ -316,7 +1166,7 @@ namespace etl while (i > 0) { - set(pbuffer, number_of_elements, --i, *text++ == ETL_STRu('1')); + set_position(pbuffer, --i, *text++ == ETL_STRu('1')); } } } @@ -324,7 +1174,12 @@ namespace etl //************************************************************************* /// Set from a u32 string. //************************************************************************* - ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char32_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void from_string(pointer pbuffer, + size_t number_of_elements, + size_t total_bits, + const char32_t* text) ETL_NOEXCEPT { if (text == ETL_NULLPTR) { @@ -333,12 +1188,12 @@ namespace etl else { size_t string_length = etl::strlen(text); - size_t element_index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element)); + size_t index = etl::min(number_of_elements - 1U, (string_length / Bits_Per_Element)); // Only reset elements we need to. - while (element_index != number_of_elements) + while (index != number_of_elements) { - pbuffer[element_index++] = All_Clear_Element; + pbuffer[index++] = All_Clear_Element; } // Build from the string. @@ -346,41 +1201,37 @@ namespace etl while (i > 0) { - set(pbuffer, number_of_elements, --i, *text++ == ETL_STRU('1')); + set_position(pbuffer, --i, *text++ == ETL_STRU('1')); } } } //************************************************************************* - /// Set from a string. + /// Reset all of the bits. //************************************************************************* - ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void reset_all(pointer pbuffer, + size_t number_of_elements) ETL_NOEXCEPT { - from_string(pbuffer, number_of_elements, total_bits, text); + while (number_of_elements-- != 0U) + { + *pbuffer++ = All_Clear_Element; + } } //************************************************************************* - /// Set from a wstring. + /// Reset the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const wchar_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void reset_position(pointer pbuffer, + size_t position) ETL_NOEXCEPT { - from_string(pbuffer, number_of_elements, total_bits, text); - } + const size_t index = position >> etl::log2::value;; + const element_type bit = element_type(1) << (position & (Bits_Per_Element - 1)); - //************************************************************************* - /// Set from a u16string. - //************************************************************************* - ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char16_t* text) ETL_NOEXCEPT - { - from_string(pbuffer, number_of_elements, total_bits, text); - } - - //************************************************************************* - /// Set from a u32string. - //************************************************************************* - ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char32_t* text) ETL_NOEXCEPT - { - from_string(pbuffer, number_of_elements, total_bits, text); + pbuffer[index] &= ~bit; } //************************************************************************* @@ -388,8 +1239,9 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - typename etl::enable_if::value, T>::type - value(const_pointer pbuffer, size_t number_of_elements) const ETL_NOEXCEPT + static + T value(const_pointer pbuffer, + size_t number_of_elements) ETL_NOEXCEPT { T v = T(0); @@ -410,129 +1262,214 @@ namespace etl } //************************************************************************* - /// Reset the bit at the position. + /// Extract an value from multiple elements. //************************************************************************* - ETL_CONSTEXPR14 void reset(pointer pbuffer, size_t number_of_elements, size_t position) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 + static + typename etl::make_unsigned::type extract_from_multiple_elements(const element_type* pbuffer, + int element_index, + size_t active_bits_in_msb, + size_t length) ETL_NOEXCEPT { - size_t index = 0U; - element_type bit = element_type(0); + typedef typename etl::make_unsigned::type unsigned_t; - if (number_of_elements == 0) + unsigned_t value(0); + + // Extract the first element, if partially filled. + if (active_bits_in_msb < Bits_Per_Element) { - return; + element_type mask = etl::make_lsb_mask< element_type>(active_bits_in_msb); + value = pbuffer[element_index] & mask; + length -= active_bits_in_msb; + if (length >= Bits_Per_Element) + { + value = value << Bits_Per_Element; + } + --element_index; } - else if (number_of_elements == 1) + + // Loop through the fully filled elements + while (length >= Bits_Per_Element) { - index = 0; - bit = element_type(1) << position; + value |= pbuffer[element_index]; + length -= Bits_Per_Element; + if (length >= Bits_Per_Element) + { + value = value << Bits_Per_Element; + } + --element_index; + } + + // Extract the last element, if partially filled. + if (length != 0) + { + value = value << length; + element_type mask = etl::make_lsb_mask< element_type>(length); + value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask; + } + + return value; + } + + //************************************************************************* + /// Extract an integral value from an arbitrary position and length. + /// Run time position and length. + //************************************************************************* + template + ETL_CONSTEXPR14 + static + typename etl::make_unsigned::type extract_from_buffer(const_pointer pbuffer, + size_t position, + size_t length) ETL_NOEXCEPT + { + typedef typename etl::make_unsigned::type unsigned_t; + + unsigned_t value(0); + + const int Msb_Element_Index = (position + length - 1) >> etl::log2::value; + const int Lsb_Element_Index = position >> etl::log2::value; + + // Is the value contained within one element? + if (Msb_Element_Index == Lsb_Element_Index) + { + const unsigned_t Mask = etl::make_lsb_mask< unsigned_t>(length); + const unsigned_t Shift = position % Bits_Per_Element; + + value = static_cast(pbuffer[Msb_Element_Index] >> Shift) & Mask; } else { - index = position >> etl::log2::value; - bit = element_type(1) << (position & (Bits_Per_Element - 1)); + // Get the number of active bits in the msb element + size_t active_bits_in_msb = (position + length) - (Msb_Element_Index * Bits_Per_Element); + + // Start with index of the element containing the msb. + int element_index = Msb_Element_Index; + + value = extract_from_multiple_elements(pbuffer, element_index, active_bits_in_msb, length); } - pbuffer[index] &= ~bit; + return value; + } + + //************************************************************************* + /// Extract an integral value when the value fits in one element. + /// Compile time position and length. + //************************************************************************* + template + ETL_CONSTEXPR14 + static + typename etl::enable_if::value, typename etl::make_unsigned::type>::type + extract_from_buffer(const_pointer pbuffer) + { + typedef typename etl::make_unsigned::type unsigned_t; + + const int Element_Index = (Position + Length - 1) >> etl::log2::value; + const unsigned_t Mask = etl::lsb_mask::value; + const unsigned_t Shift = Position % Bits_Per_Element; + + return static_cast(pbuffer[Element_Index] >> Shift) & Mask; + } + + //************************************************************************* + /// Extract an integral value when the value spans more than one element. + /// Compile time position and length. + //************************************************************************* + template + ETL_CONSTEXPR14 + static + typename etl::enable_if::value, typename etl::make_unsigned::type>::type + extract_from_buffer(const_pointer pbuffer) + { + // Start with index of the element containing the msb. + const int Msb_Element_Index = (Position + Length - 1) >> etl::log2::value; + + // Get the number of active bits in the first element + const size_t Active_Bits_In_Msb = ((Position + Length - 1) % Bits_Per_Element) + 1; + + return extract_from_multiple_elements(pbuffer, Msb_Element_Index, Active_Bits_In_Msb, Length); + } + + //************************************************************************* + /// Extract an integral value from an arbitrary position and length. + //************************************************************************* + template + ETL_CONSTEXPR14 + static + T extract(const_pointer pbuffer, + size_t position, + size_t length = etl::integral_limits::bits) + { + typedef typename etl::make_unsigned::type unsigned_t; + + unsigned_t value = extract_from_buffer(pbuffer, position, length); + + if ((length != etl::integral_limits::bits) && etl::integral_limits::is_signed) + { + value = etl::sign_extend(value, length); + } + + return static_cast(value); + } + + //************************************************************************* + /// Extract an integral value from an arbitrary position and length. + //************************************************************************* + template + ETL_CONSTEXPR14 + static + T extract(const_pointer pbuffer) + { + typedef typename etl::make_unsigned::type unsigned_t; + + unsigned_t value = extract_from_buffer(pbuffer); + + if ((Length != etl::integral_limits::bits) && etl::integral_limits::is_signed) + { + value = etl::sign_extend(value, Length); + } + + return static_cast(value); } //************************************************************************* /// Flip all of the bits. //************************************************************************* - ETL_CONSTEXPR14 void flip(pointer pbuffer, size_t number_of_elements) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void flip_all(pointer pbuffer, + size_t number_of_elements) ETL_NOEXCEPT { - etl::transform_n(pbuffer, - number_of_elements, - pbuffer, - etl::binary_not()); + operator_not(pbuffer, number_of_elements); } //************************************************************************* /// Flip the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 void flip(pointer pbuffer, size_t number_of_elements, size_t position) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void flip_position(pointer pbuffer, + size_t position) ETL_NOEXCEPT { - size_t index = 0U; - element_type bit = element_type(0); - - if (number_of_elements == 0) - { - return; - } - else if (number_of_elements == 1) - { - index = 0; - bit = element_type(1) << position; - } - else - { - index = position >> log2::value; - bit = element_type(1) << (position & (Bits_Per_Element - 1)); - } + const size_t index = position >> etl::log2::value;; + const element_type bit = element_type(1) << (position & (Bits_Per_Element - 1)); pbuffer[index] ^= bit; } - //************************************************************************* - // Are all the bits sets? - //************************************************************************* - ETL_CONSTEXPR14 bool all(const_pointer pbuffer, size_t number_of_elements, element_type top_mask) const ETL_NOEXCEPT - { - if (number_of_elements == 0UL) - { - return true; - } - - // All but the last. - for (size_t i = 0UL; i < (number_of_elements - 1U); ++i) - { - if (pbuffer[i] != All_Set_Element) - { - return false; - } - } - - // The last. - if (pbuffer[number_of_elements - 1U] != (All_Set_Element & top_mask)) - { - return false; - } - - return true; - } - - //************************************************************************* - /// Are none of the bits set? - //************************************************************************* - ETL_CONSTEXPR14 bool none(const_pointer pbuffer, size_t number_of_elements) const ETL_NOEXCEPT - { - for (size_t i = 0UL; i < number_of_elements; ++i) - { - if (pbuffer[i] != 0) - { - return false; - } - } - - return true; - } - - //************************************************************************* - /// Finds the first bit in the specified state. - ///\param state The state to search for. - ///\returns The position of the bit or Number_Of_Elements if none were found. - //************************************************************************* - ETL_CONSTEXPR14 size_t find_first(const_pointer pbuffer, size_t number_of_elements, size_t total_bits, bool state) const ETL_NOEXCEPT - { - return find_next(pbuffer, number_of_elements, total_bits, state, 0); - } - //************************************************************************* /// Finds the next bit in the specified state. ///\param state The state to search for. ///\param position The position to start from. ///\returns The position of the bit or npos if none were found. //************************************************************************* - ETL_CONSTEXPR14 size_t find_next(const_pointer pbuffer, size_t number_of_elements, size_t total_bits, bool state, size_t position) const ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + size_t find_next(const_pointer pbuffer, + size_t number_of_elements, + size_t total_bits, + bool state, + size_t position) ETL_NOEXCEPT { // Where to start. size_t index = position >> log2::value; @@ -583,11 +1520,12 @@ namespace etl /// Returns a string representing the bitset. //************************************************************************* template - ETL_CONSTEXPR14 TString to_string(const_pointer pbuffer, - size_t number_of_elements, - size_t active_bits, - typename TString::value_type zero, - typename TString::value_type one) const + ETL_CONSTEXPR14 + static + TString to_string(const_pointer pbuffer, + size_t active_bits, + typename TString::value_type zero, + typename TString::value_type one) { TString result; @@ -598,28 +1536,108 @@ namespace etl for (size_t i = active_bits; i > 0; --i) { - result[active_bits - i] = test(pbuffer, number_of_elements, i - 1) ? one : zero; + result[active_bits - i] = test(pbuffer, i - 1) ? one : zero; } return result; } //************************************************************************* - /// shift_left_equals + /// operator assignment //************************************************************************* - ETL_CONSTEXPR14 void shift_left_equals(pointer pbuffer, size_t number_of_elements, size_t shift) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void operator_assignment(pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t number_of_elements) ETL_NOEXCEPT { - if (number_of_elements == 1U) + while (number_of_elements-- != 0) { - // Just one element. - pbuffer[0] <<= shift; + *lhs_pbuffer = *rhs_pbuffer; + ++lhs_pbuffer; + ++rhs_pbuffer; } - else if ((shift % Bits_Per_Element) == 0U) + } + + //************************************************************************* + /// operator and + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_and(pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t number_of_elements) ETL_NOEXCEPT + { + while (number_of_elements-- != 0) { - // Shift by whole element. - const size_t element_shift = shift / Bits_Per_Element; - etl::copy_backward(pbuffer, pbuffer + number_of_elements - element_shift, pbuffer + number_of_elements); - etl::fill_n(pbuffer, element_shift, All_Clear_Element); + *lhs_pbuffer &= *rhs_pbuffer; + ++lhs_pbuffer; + ++rhs_pbuffer; + } + } + + //************************************************************************* + /// operator or + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_or(pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t number_of_elements) ETL_NOEXCEPT + { + while (number_of_elements-- != 0) + { + *lhs_pbuffer |= *rhs_pbuffer; + ++lhs_pbuffer; + ++rhs_pbuffer; + } + } + + //************************************************************************* + /// operator xor + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_xor(pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t number_of_elements) ETL_NOEXCEPT + { + while (number_of_elements-- != 0) + { + *lhs_pbuffer ^= *rhs_pbuffer; + ++lhs_pbuffer; + ++rhs_pbuffer; + } + } + + //************************************************************************* + /// operator not + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_not(pointer pbuffer, + size_t number_of_elements) ETL_NOEXCEPT + { + while (number_of_elements-- != 0) + { + *pbuffer = ~*pbuffer; + ++pbuffer; + } + } + + //************************************************************************* + /// operator_shift_left + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_shift_left(pointer pbuffer, + size_t number_of_elements, + size_t active_bits, + size_t shift) ETL_NOEXCEPT + { + if (shift >= active_bits) + { + reset_all(pbuffer, number_of_elements); } else { @@ -636,10 +1654,10 @@ namespace etl const size_t lsb_shift = Bits_Per_Element - split_position; const size_t msb_shift = split_position; - const element_type lsb_mask = element_type(etl::integral_limits::max >> (Bits_Per_Element - split_position)); - const element_type msb_mask = etl::integral_limits::max - lsb_mask; + const element_type lsb_mask = element_type(etl::integral_limits::max >> (Bits_Per_Element - split_position)); + const element_type msb_mask = etl::integral_limits::max - lsb_mask; const element_type lsb_shifted_mask = element_type(lsb_mask << lsb_shift); - + // First lsb. element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift); pbuffer[dst_index] = lsb; @@ -662,7 +1680,6 @@ namespace etl // Clear the remaining bits. // First lsb. pbuffer[dst_index] &= lsb_shifted_mask; -// --dst_index; // The other remaining bytes on the right. for (int i = 0; i < dst_index; ++i) @@ -673,21 +1690,18 @@ namespace etl } //************************************************************************* - /// shift_right_equals + /// operator_shift_right //************************************************************************* - ETL_CONSTEXPR14 void shift_right_equals(pointer pbuffer, size_t number_of_elements, size_t shift) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void operator_shift_right(pointer pbuffer, + size_t number_of_elements, + size_t active_bits, + size_t shift) ETL_NOEXCEPT { - if (number_of_elements == 1U) + if (shift >= active_bits) { - // Just one element. - pbuffer[0] >>= shift; - } - else if ((shift % Bits_Per_Element) == 0U) - { - // Shift by whole elements. - const size_t element_shift = (shift / Bits_Per_Element); - pointer pzeros_begin = etl::copy(pbuffer + element_shift, pbuffer + number_of_elements, pbuffer); - etl::fill_n(pzeros_begin, element_shift, All_Clear_Element); + reset_all(pbuffer, number_of_elements); } else { @@ -704,8 +1718,8 @@ namespace etl const size_t lsb_shift = Bits_Per_Element - split_position; const size_t msb_shift = split_position; - const element_type lsb_mask = element_type(etl::integral_limits::max >> (Bits_Per_Element - split_position)); - const element_type msb_mask = etl::integral_limits::max - lsb_mask; + const element_type lsb_mask = element_type(etl::integral_limits::max >> (Bits_Per_Element - split_position)); + const element_type msb_mask = etl::integral_limits::max - lsb_mask; const element_type msb_shifted_mask = element_type(msb_mask >> msb_shift); // Now do the shifting. @@ -714,10 +1728,10 @@ namespace etl // Shift msb. element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift); ++src_index; - + // Shift lsb. element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift); - + // Combine them. pbuffer[dst_index] = lsb | msb; ++dst_index; @@ -742,1023 +1756,165 @@ namespace etl } //************************************************************************* - /// and_equals + /// operator_equality //************************************************************************* - ETL_CONSTEXPR14 void and_equals(pointer pbuffer, const_pointer pbuffer2, size_t number_of_elements) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + bool operator_equality(const_pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t number_of_elements) ETL_NOEXCEPT { - for (size_t i = 0U; i < number_of_elements; ++i) - { - pbuffer[i] &= pbuffer2[i]; - } - } - - //************************************************************************* - /// or_equals - //************************************************************************* - ETL_CONSTEXPR14 void or_equals(pointer pbuffer, const_pointer pbuffer2, size_t number_of_elements) ETL_NOEXCEPT - { - for (size_t i = 0U; i < number_of_elements; ++i) - { - pbuffer[i] |= pbuffer2[i]; - } - } - - //************************************************************************* - /// xor_equals - //************************************************************************* - ETL_CONSTEXPR14 void xor_equals(pointer pbuffer, const_pointer pbuffer2, size_t number_of_elements) ETL_NOEXCEPT - { - for (size_t i = 0U; i < number_of_elements; ++i) - { - pbuffer[i] ^= pbuffer2[i]; - } + return etl::equal(lhs_pbuffer, lhs_pbuffer + number_of_elements, rhs_pbuffer); } //************************************************************************* /// Initialise from an unsigned long long. //************************************************************************* - ETL_CONSTEXPR14 void initialise(pointer pbuffer, size_t number_of_elements, unsigned long long value) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void initialise(pointer pbuffer, + size_t number_of_elements, + unsigned long long value) ETL_NOEXCEPT { - const size_t Shift = (etl::integral_limits::bits <= (int)Bits_Per_Element) ? 0 : Bits_Per_Element; + size_t i = 0UL; + const size_t Shift = etl::integral_limits::bits; - // Can we do it in one hit? - if (Shift == 0) + // Set the non-zero elements. + while ((value != 0) && (i != number_of_elements)) { - pbuffer[0] = element_type(value); + pbuffer[i++] = value & All_Set_Element; + value = value >> Shift; } - else + + // Clear the remaining elements. + while (i != number_of_elements) { - size_t i = 0UL; - - // Set the non-zero elements. - while ((value != 0) && (i != number_of_elements)) - { - pbuffer[i++] = value & All_Set_Element; - value = value >> Shift; - } - - // Clear the remaining elements. - while (i != number_of_elements) - { - pbuffer[i++] = All_Clear_Element; - } + pbuffer[i++] = All_Clear_Element; } } //************************************************************************* /// Swap bitset buffers. //************************************************************************* - ETL_CONSTEXPR14 void swap(pointer pbuffer1, pointer pbuffer2, size_t number_of_elements) + ETL_CONSTEXPR14 + static + void swap(pointer pbuffer1, + pointer pbuffer2, + size_t number_of_elements) { - const pointer pbuffer1_end = pbuffer1 + number_of_elements; - - while (pbuffer1 != pbuffer1_end) - { - element_type temp = *pbuffer1; - *pbuffer1 = *pbuffer2; - *pbuffer2 = temp; - ++pbuffer1; - ++pbuffer2; - } + etl::swap_ranges(pbuffer1, pbuffer1 + number_of_elements, pbuffer2); } }; - - template - ETL_CONSTANT size_t bitset_impl::Bits_Per_Element; - template - ETL_CONSTANT typename bitset_impl::element_type bitset_impl::All_Set_Element; + namespace private_bitset + { + //*************************************************************************** + template + class bitset_common : public etl::private_bitset::bitset_impl_common + { + public: - template - ETL_CONSTANT typename bitset_impl::element_type bitset_impl::All_Clear_Element; + 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; + +#if ETL_USING_CPP11 + static ETL_CONSTANT etl::bitset_storage_model Storage_Model = (bitset_common::Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi; +#else + static ETL_CONSTANT etl::bitset_storage_model Storage_Model; +#endif + + 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; + +#if ETL_USING_CPP11 + template + ETL_CONSTANT etl::bitset_storage_model bitset_common::Storage_Model; +#else + template + ETL_CONSTANT etl::bitset_storage_model bitset_common::Storage_Model = (bitset_common::Number_Of_Elements == 1U) ? etl::bitset_storage_model::Single : etl::bitset_storage_model::Multi; +#endif + + template + ETL_CONSTANT size_t bitset_common::Top_Mask_Shift; + + template + ETL_CONSTANT TElement bitset_common::Top_Mask; + } //*************************************************************************** - template ::bits == Active_Bits> + /// Bitset forward declaration + //*************************************************************************** + template class bitset; //*************************************************************************** /// Specialisation for zero bits. - /// Just defines 'npos'. //*************************************************************************** template <> - class bitset<0U, char, true> : public bitset_constants<> - { - }; - - //*************************************************************************** - /// Specialisation for zero bits. - //*************************************************************************** - template <> - class bitset<0U, char, false> : public bitset_constants<> - { - }; - - //*************************************************************************** - /// Specialisation that uses a single element if the element type is the - /// same size as the number of active bits. - //*************************************************************************** - template - class bitset : public bitset_constants<> + class bitset<0U, unsigned char> : public etl::private_bitset::bitset_common<0U, unsigned char> { public: - // The element type is the unsigned variant of 'TElement'. - typedef typename etl::make_unsigned::type element_type; - - typedef element_type* pointer; - typedef const element_type* const_pointer; - - static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits::bits; - static ETL_CONSTANT size_t Number_Of_Elements = 1U; - static ETL_CONSTANT size_t Allocated_Bits = Bits_Per_Element; - static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits::type>::max; - static ETL_CONSTANT element_type All_Clear_Element = element_type(0); - static ETL_CONSTANT size_t Top_Mask_Shift = 0U; - static ETL_CONSTANT element_type Top_Mask = All_Set_Element; - - typedef etl::span span_type; - typedef etl::span const_span_type; - - //************************************************************************* - /// The reference type returned. - //************************************************************************* - class bit_reference - { - public: - - friend class bitset; - - //******************************* - /// Copy constructor. - //******************************* - ETL_CONSTEXPR14 bit_reference(const bit_reference& other) ETL_NOEXCEPT - : p_bitset(other.p_bitset) - , position(other.position) - { - } - - //******************************* - /// Conversion operator. - //******************************* - ETL_CONSTEXPR14 operator bool() const ETL_NOEXCEPT - { - return p_bitset->test(position); - } - - //******************************* - /// Assignment operator. - //******************************* - ETL_CONSTEXPR14 bit_reference& operator = (bool b) ETL_NOEXCEPT - { - p_bitset->set(position, b); - return *this; - } - - //******************************* - /// Assignment operator. - //******************************* - ETL_CONSTEXPR14 bit_reference& operator = (const bit_reference& r) ETL_NOEXCEPT - { - p_bitset->set(position, bool(r)); - return *this; - } - - //******************************* - /// Flip the bit. - //******************************* - ETL_CONSTEXPR14 bit_reference& flip() ETL_NOEXCEPT - { - p_bitset->flip(position); - return *this; - } - - //******************************* - /// Return the logical inverse of the bit. - //******************************* - ETL_CONSTEXPR14 bool operator~() const ETL_NOEXCEPT - { - return !p_bitset->test(position); - } - - private: - - //******************************* - /// Default constructor. - //******************************* - ETL_CONSTEXPR14 bit_reference() ETL_NOEXCEPT - : p_bitset(ETL_NULLPTR) - , position(0) - { - } - - //******************************* - /// Constructor. - //******************************* - ETL_CONSTEXPR14 bit_reference(bitset& r_bitset, size_t position_) ETL_NOEXCEPT - : p_bitset(&r_bitset) - , position(position_) - { - } - - bitset* p_bitset; ///< The bitset. - size_t position; ///< The position in the bitset. - }; - - //************************************************************************* - /// Default constructor. - //************************************************************************* - ETL_CONSTEXPR14 bitset() ETL_NOEXCEPT - : buffer(All_Clear_Element) - { - } - - //************************************************************************* - /// Copy constructor. - //************************************************************************* - ETL_CONSTEXPR14 bitset(const bitset& other) ETL_NOEXCEPT - : buffer(other.buffer) - { - } - - //************************************************************************* - /// Construct from a value. - //************************************************************************* - ETL_CONSTEXPR14 bitset(unsigned long long value) ETL_NOEXCEPT - : buffer(element_type(value)) - { - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset(const char* text) ETL_NOEXCEPT - : buffer(All_Clear_Element) - { - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset(const wchar_t* text) ETL_NOEXCEPT - : buffer(All_Clear_Element) - { - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset(const char16_t* text) ETL_NOEXCEPT - : buffer(All_Clear_Element) - { - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset(const char32_t* text) ETL_NOEXCEPT - : buffer(All_Clear_Element) - { - set(text); - } - - //************************************************************************* - /// Assignment operator. - //************************************************************************* - ETL_CONSTEXPR14 bitset& operator =(const bitset& other) ETL_NOEXCEPT - { - buffer = other.buffer; - - return *this; - } - - //************************************************************************* - /// Set all of the bits. - //************************************************************************* - ETL_CONSTEXPR14 bitset& set() ETL_NOEXCEPT - { - buffer = All_Set_Element; - - return *this; - } - - //************************************************************************* - /// Set from a value. - //************************************************************************* - ETL_CONSTEXPR14 bitset& set(element_type value) ETL_NOEXCEPT - { - buffer = value; - - return *this; - } - - //************************************************************************* - /// Set the bit at the position. - //************************************************************************* - ETL_CONSTEXPR14 bitset& set(size_t position, bool value = true) - { - ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - - const element_type mask = element_type(element_type(1) << position); - if (value == true) - { - buffer |= mask; - } - else - { - buffer &= ~mask; - } - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& set(const char* text) ETL_NOEXCEPT - { - from_string(text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& set(const wchar_t* text) ETL_NOEXCEPT - { - from_string(text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& set(const char16_t* text) ETL_NOEXCEPT - { - from_string(text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& set(const char32_t* text) ETL_NOEXCEPT - { - from_string(text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& from_string(const char* text) ETL_NOEXCEPT - { - if (text == ETL_NULLPTR) - { - reset(); - } - else - { - size_t string_length = etl::strlen(text); - - // Build from the string. - string_length = etl::min(Active_Bits, string_length); - - element_type mask = element_type(element_type(1) << (string_length - 1U)); - - for (size_t i = 0U; i < string_length; ++i) - { - if (text[i] == ETL_STR('1')) - { - buffer |= mask; - } - else - { - buffer &= ~mask; - } - - mask >>= 1U; - } - } - - return *this; - } - - //************************************************************************* - /// Set from a wide string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& from_string(const wchar_t* text) ETL_NOEXCEPT - { - if (text == ETL_NULLPTR) - { - reset(); - } - else - { - size_t string_length = etl::strlen(text); - - // Build from the string. - string_length = etl::min(Active_Bits, string_length); - - element_type mask = element_type(element_type(1) << (string_length - 1U)); - - for (size_t i = 0U; i < string_length; ++i) - { - if (text[i] == ETL_STRL('1')) - { - buffer |= mask; - } - else - { - buffer &= ~mask; - } - - mask >>= 1U; - } - } - - return *this; - } - - //************************************************************************* - /// Set from a u16 string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& from_string(const char16_t* text) ETL_NOEXCEPT - { - if (text == ETL_NULLPTR) - { - reset(); - } - else - { - size_t string_length = etl::strlen(text); - - // Build from the string. - string_length = etl::min(Active_Bits, string_length); - - element_type mask = element_type(element_type(1) << (string_length - 1U)); - - for (size_t i = 0U; i < string_length; ++i) - { - if (text[i] == ETL_STRu('1')) - { - buffer |= mask; - } - else - { - buffer &= ~mask; - } - - mask >>= 1U; - } - } - - return *this; - } - - //************************************************************************* - /// Set from a u32 string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& from_string(const char32_t* text) ETL_NOEXCEPT - { - if (text == ETL_NULLPTR) - { - reset(); - } - else - { - size_t string_length = etl::strlen(text); - - // Build from the string. - string_length = etl::min(Active_Bits, string_length); - - element_type mask = element_type(element_type(1) << (string_length - 1U)); - - for (size_t i = 0U; i < string_length; ++i) - { - if (text[i] == ETL_STRU('1')) - { - buffer |= mask; - } - else - { - buffer &= ~mask; - } - - mask >>= 1U; - } - } - - return *this; - } - - //************************************************************************* - /// Get as an integral value. - //************************************************************************* - template - ETL_CONSTEXPR14 - typename etl::enable_if::value, T>::type - value() const ETL_NOEXCEPT - { - ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); - ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Integral type too small"); - - T v = T(0); - - const bool OK = (sizeof(T) * CHAR_BIT) >= Bits_Per_Element; - - if (OK) - { - v = T(typename etl::make_unsigned::type(buffer)); - } - - return v; - } - - //************************************************************************* - /// Get as an unsigned long. - //************************************************************************* - ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT - { - return value(); - } - - //************************************************************************* - /// Get as an unsigned long long. - //************************************************************************* - ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT - { - return value(); - } - - //************************************************************************* - /// Reset all of the bits. - //************************************************************************* - ETL_CONSTEXPR14 bitset& reset() ETL_NOEXCEPT - { - buffer = All_Clear_Element; - - return *this; - } - - //************************************************************************* - /// Reset the bit at the position. - //************************************************************************* - ETL_CONSTEXPR14 bitset& reset(size_t position) - { - ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - - const element_type mask = element_type(element_type(1) << position); - buffer &= ~mask; - - return *this; - } - - //************************************************************************* - /// Tests a bit at a position. - /// Positions greater than the number of configured bits will return false. - //************************************************************************* - ETL_CONSTEXPR14 bool test(size_t position) const - { - ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false); - - const element_type mask = element_type(element_type(1) << position); - return (buffer & mask) != 0U; - } - - //************************************************************************* - /// The number of bits in the bitset. - //************************************************************************* - ETL_CONSTEXPR14 size_t size() const ETL_NOEXCEPT - { - return Active_Bits; - } - - //************************************************************************* - /// Count the number of bits set. - //************************************************************************* - ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT - { - return etl::count_bits(buffer); - } - - //************************************************************************* - // Are all the bits sets? - //************************************************************************* - ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT - { - return buffer == All_Set_Element; - } - - //************************************************************************* - // Are all the bits sets? - //************************************************************************* - ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT - { - return buffer == (All_Set_Element & mask); - } - - //************************************************************************* - /// Are none of the bits set? - //************************************************************************* - ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT - { - return buffer == All_Clear_Element; - } - - //************************************************************************* - /// Are none of the bits set? - //************************************************************************* - ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT - { - return (buffer & mask) == All_Clear_Element; - } - - //************************************************************************* - /// Are any of the bits set? - //************************************************************************* - ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT - { - return !none(); - } - - //************************************************************************* - /// Are any of the bits set? - //************************************************************************* - ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT - { - return !none(mask); - } - - //************************************************************************* - /// Flip all of the bits. - //************************************************************************* - ETL_CONSTEXPR14 bitset& flip() ETL_NOEXCEPT - { - buffer = ~buffer; - - return *this; - } - - //************************************************************************* - /// Flip some of the bits. - //************************************************************************* - ETL_CONSTEXPR14 bitset& flip_bits(element_type mask = etl::integral_limits::max) ETL_NOEXCEPT - { - buffer ^= mask; - - return *this; - } - - //************************************************************************* - /// Flip the bit at the position. - //************************************************************************* - ETL_CONSTEXPR14 bitset& flip(size_t position) - { - ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - - const element_type mask = element_type(element_type(1) << position); - buffer ^= mask; - - return *this; - } - - //************************************************************************* - /// Read [] operator. - //************************************************************************* - ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT - { - if (position < Active_Bits) - { - const element_type mask = element_type(element_type(1) << position); - return (buffer & mask) != 0U; - } - - return false; - } - - //************************************************************************* - /// Write [] operator. - //************************************************************************* - ETL_CONSTEXPR14 bit_reference operator [] (size_t position) ETL_NOEXCEPT - { - return bit_reference(*this, position); - } - - //************************************************************************* - /// Returns a string representing the bitset. - //************************************************************************* -#if ETL_USING_CPP11 - template > -#else - template -#endif - ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'), - typename TString::value_type one = typename TString::value_type('1')) const - { - TString result; - - result.resize(Active_Bits, '\0'); - - // Check that the string type can contain the digits. - ETL_ASSERT_OR_RETURN_VALUE(result.size() == Active_Bits, ETL_ERROR(etl::bitset_string_too_small), result); - - for (size_t i = Active_Bits; i > 0; --i) - { - result[Active_Bits - i] = test(i - 1) ? one : zero; - } - - return result; - } - - //************************************************************************* - /// Finds the first bit in the specified state. - ///\param state The state to search for. - ///\returns The position of the bit or npos if none were found. - //************************************************************************* - ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT - { - return find_next(state, 0U); - } - - //************************************************************************* - /// Finds the next bit in the specified state. - ///\param state The state to search for. - ///\param position The position to start from. - ///\returns The position of the bit or npos if none were found. - //************************************************************************* - ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT - { - if (position < Active_Bits) - { - // Where to start. - size_t bit = position; - - element_type mask = 1U << position; - - // Needs checking? - if ((state && (buffer != All_Clear_Element)) || (!state && (buffer != All_Set_Element))) - { - // For each bit in the element... - while (bit < Active_Bits) - { - // Equal to the required state? - if (((buffer & mask) != 0) == state) - { - return bit; - } - - // Move on to the next bit. - mask <<= 1; - ++bit; - } - } - } - - return npos; - } - - //************************************************************************* - /// operator & - //************************************************************************* - ETL_CONSTEXPR14 bitset operator &(const bitset& other) const ETL_NOEXCEPT - { - etl::bitset temp(*this); - - temp &= other; - - return temp; - } - - //************************************************************************* - /// operator &= - //************************************************************************* - ETL_CONSTEXPR14 bitset& operator &=(const bitset& other) ETL_NOEXCEPT - { - buffer &= other.buffer; - - return *this; - } - - //************************************************************************* - /// operator | - //************************************************************************* - ETL_CONSTEXPR14 bitset operator |(const bitset& other) const ETL_NOEXCEPT - { - etl::bitset temp(*this); - - temp |= other; - - return temp; - } - - //************************************************************************* - /// operator |= - //************************************************************************* - ETL_CONSTEXPR14 bitset& operator |=(const bitset& other) ETL_NOEXCEPT - { - buffer |= other.buffer; - - return *this; - } - - //************************************************************************* - /// operator ^ - //************************************************************************* - ETL_CONSTEXPR14 bitset operator ^(const bitset& other) const ETL_NOEXCEPT - { - etl::bitset temp(*this); - - temp ^= other; - - return temp; - } - - //************************************************************************* - /// operator ^= - //************************************************************************* - ETL_CONSTEXPR14 bitset& operator ^=(const bitset& other) ETL_NOEXCEPT - { - buffer ^= other.buffer; - - return *this; - } - - //************************************************************************* - /// operator ~ - //************************************************************************* - ETL_CONSTEXPR14 bitset operator ~() const ETL_NOEXCEPT - { - etl::bitset temp(*this); - - temp.flip(); - - return temp; - } - - //************************************************************************* - /// operator << - //************************************************************************* - ETL_CONSTEXPR14 bitset operator <<(size_t shift) const ETL_NOEXCEPT - { - etl::bitset temp(*this); - - temp <<= shift; - - return temp; - } - - //************************************************************************* - /// operator <<= - //************************************************************************* - ETL_CONSTEXPR14 bitset& operator <<=(size_t shift) ETL_NOEXCEPT - { - if (shift >= Active_Bits) - { - reset(); - } - else - { - buffer <<= shift; - } - - return *this; - } - - //************************************************************************* - /// operator >> - //************************************************************************* - ETL_CONSTEXPR14 bitset operator >>(size_t shift) const ETL_NOEXCEPT - { - etl::bitset temp(*this); - - temp >>= shift; - - return temp; - } - - //************************************************************************* - /// operator >>= - //************************************************************************* - ETL_CONSTEXPR14 bitset& operator >>=(size_t shift) ETL_NOEXCEPT - { - if (shift >= Active_Bits) - { - reset(); - } - else - { - buffer >>= shift; - } - - return *this; - } - - //************************************************************************* - /// operator == - //************************************************************************* - friend ETL_CONSTEXPR14 bool operator ==(const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT - { - return (lhs.buffer == rhs.buffer); - } - - //************************************************************************* - /// swap - //************************************************************************* - ETL_CONSTEXPR14 void swap(etl::bitset& other) ETL_NOEXCEPT - { - element_type temp = buffer; - buffer = other.buffer; - other.buffer = temp; - } - - //************************************************************************* - /// span - /// Returns a span of the underlying buffer. - //************************************************************************* - ETL_CONSTEXPR14 span_type span() ETL_NOEXCEPT - { - return span_type(&buffer, 1); - } - - //************************************************************************* - /// span - /// Returns a const span of the underlying buffer. - //************************************************************************* - ETL_CONSTEXPR14 const_span_type span() const ETL_NOEXCEPT - { - return const_span_type(&buffer, 1); - } - - private: - - element_type buffer; + typedef etl::private_bitset::bitset_common<0U, unsigned char>::element_type element_type; + typedef etl::private_bitset::bitset_common<0U, unsigned char>::span_type span_type; + typedef etl::private_bitset::bitset_common<0U, unsigned char>::const_span_type const_span_type; + + 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; }; - template - ETL_CONSTANT size_t bitset::Bits_Per_Element; - - template - ETL_CONSTANT size_t bitset::Number_Of_Elements; - - template - ETL_CONSTANT size_t bitset::Allocated_Bits; - - template - ETL_CONSTANT typename bitset::element_type bitset::All_Set_Element; - - template - ETL_CONSTANT typename bitset::element_type bitset::All_Clear_Element; - - template - ETL_CONSTANT size_t bitset::Top_Mask_Shift; - - template - ETL_CONSTANT typename bitset::element_type bitset::Top_Mask; - //************************************************************************* - /// The specialisation that uses an array of the default element type. + /// The bitset top level template. //************************************************************************* template - class bitset : public bitset_constants<> + class bitset : public etl::private_bitset::bitset_common { - private: - - //************************************************************************* - // If the 'TElement' is the default 'void', then use 'char', otherwise uses - // the unsigned variant of 'TElement'. - //************************************************************************* - struct select_element_type - { - typedef typename etl::make_unsigned::value, char, TElement>::type>::type type; - }; - public: - typedef typename select_element_type::type element_type; - typedef element_type* pointer; - typedef const element_type* const_pointer; - - static ETL_CONSTANT size_t Bits_Per_Element = etl::bitset_impl::Bits_Per_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 Allocated_Bits = Number_Of_Elements * Bits_Per_Element; - static ETL_CONSTANT size_t Top_Mask_Shift = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element); - static ETL_CONSTANT element_type All_Set_Element = etl::bitset_impl::All_Set_Element; - static ETL_CONSTANT element_type All_Clear_Element = etl::bitset_impl::All_Clear_Element; - static ETL_CONSTANT element_type Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift)); + ETL_STATIC_ASSERT(etl::is_unsigned::value, "The element type must be unsigned"); - static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility. + 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; - 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. @@ -1841,7 +1997,7 @@ namespace etl { } - bitset* p_bitset; ///< The bitset. + bitset* p_bitset; ///< The bitset. size_t position; ///< The position in the bitset. }; @@ -1851,16 +2007,16 @@ namespace etl ETL_CONSTEXPR14 bitset() ETL_NOEXCEPT : buffer() { - reset(); + implementation::reset_all(buffer, Number_Of_Elements); } //************************************************************************* /// Copy constructor. //************************************************************************* - ETL_CONSTEXPR14 bitset(const bitset& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset(const bitset& other) ETL_NOEXCEPT : buffer() { - etl::copy_n(other.buffer, Number_Of_Elements, buffer); + implementation::operator_assignment(buffer, other.buffer, Number_Of_Elements); } //************************************************************************* @@ -1869,8 +2025,7 @@ namespace etl ETL_CONSTEXPR14 bitset(unsigned long long value) ETL_NOEXCEPT : buffer() { - ibitset.initialise(buffer, Number_Of_Elements, value); - clear_unused_bits_in_msb(); + implementation::initialise(buffer, Number_Of_Elements, value); } //************************************************************************* @@ -1879,8 +2034,7 @@ namespace etl ETL_CONSTEXPR14 bitset(const char* text) ETL_NOEXCEPT : buffer() { - ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -1889,8 +2043,7 @@ namespace etl ETL_CONSTEXPR14 bitset(const wchar_t* text) ETL_NOEXCEPT : buffer() { - ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -1899,8 +2052,7 @@ namespace etl ETL_CONSTEXPR14 bitset(const char16_t* text) ETL_NOEXCEPT : buffer() { - ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -1909,16 +2061,15 @@ namespace etl ETL_CONSTEXPR14 bitset(const char32_t* text) ETL_NOEXCEPT : buffer() { - ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* /// Assignment operator. //************************************************************************* - ETL_CONSTEXPR14 bitset& operator =(const bitset& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& operator =(const bitset& other) ETL_NOEXCEPT { - etl::copy_n(other.buffer, Number_Of_Elements, buffer); + implementation::operator_assignment(buffer, other.buffer, Number_Of_Elements); return *this; } @@ -1926,10 +2077,9 @@ namespace etl //************************************************************************* /// Set all of the bits. //************************************************************************* - ETL_CONSTEXPR14 bitset& set() ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& set() ETL_NOEXCEPT { - etl::fill_n(buffer, Number_Of_Elements, All_Set_Element); - clear_unused_bits_in_msb(); + implementation::set_all(buffer, Number_Of_Elements, Top_Mask); return *this; } @@ -1937,22 +2087,38 @@ 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); - ibitset.set(buffer, Number_Of_Elements, position, value); - clear_unused_bits_in_msb(); + implementation::set_position(buffer, position, value); return *this; } //************************************************************************* - /// 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) { - ibitset.set(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; } @@ -1960,39 +2126,12 @@ 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 { - ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& set(const char16_t* text) ETL_NOEXCEPT - { - ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& set(const char32_t* text) ETL_NOEXCEPT - { - ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& from_string(const char* text) ETL_NOEXCEPT - { - ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -2000,9 +2139,58 @@ namespace etl //************************************************************************* /// Set from a wide string. //************************************************************************* - ETL_CONSTEXPR14 bitset& from_string(const wchar_t* text) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 + typename etl::enable_if::value, bitset&>::type + set(TPString text) ETL_NOEXCEPT { - ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); + + return *this; + } + + //************************************************************************* + /// Set from a char16 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); + + 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); + + return *this; + } + + //************************************************************************* + /// Set from a string. + //************************************************************************* + ETL_CONSTEXPR14 bitset& from_string(const char* text) ETL_NOEXCEPT + { + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); + + return *this; + } + + //************************************************************************* + /// Set from a wide string. + //************************************************************************* + ETL_CONSTEXPR14 bitset& from_string(const wchar_t* text) ETL_NOEXCEPT + { + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -2010,9 +2198,9 @@ namespace etl //************************************************************************* /// Set from a u16 string. //************************************************************************* - ETL_CONSTEXPR14 bitset& from_string(const char16_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& from_string(const char16_t* text) ETL_NOEXCEPT { - ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -2020,9 +2208,9 @@ namespace etl //************************************************************************* /// Set from a u32 string. //************************************************************************* - ETL_CONSTEXPR14 bitset& from_string(const char32_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& from_string(const char32_t* text) ETL_NOEXCEPT { - ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -2032,13 +2220,48 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - typename etl::enable_if::value, T>::type + typename etl::enable_if::value, T>::type value() const ETL_NOEXCEPT { ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); - ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Type too small"); + ETL_STATIC_ASSERT(etl::integral_limits::bits >= (Number_Of_Elements * Bits_Per_Element), "Type too small"); - return ibitset.template value(buffer, Number_Of_Elements); + return implementation::template value(buffer, Number_Of_Elements); + } + + //************************************************************************* + /// Extract an integral value from an arbitrary position and length. + /// Run time position and length. + //************************************************************************* + template + ETL_CONSTEXPR14 + T extract(size_t position, size_t length = etl::integral_limits::bits) const + { + ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); + + ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits::bits, ETL_ERROR(bitset_overflow), 0); + ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0); + + return implementation::template extract(buffer, position, length); + } + + //************************************************************************* + /// Extract an integral value from an arbitrary position and length. + /// Compile time position and length. + //************************************************************************* +#if ETL_USING_CPP11 + template ::bits> +#else + template +#endif + ETL_CONSTEXPR14 + T extract() const + { + ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); + ETL_STATIC_ASSERT(Length <= etl::integral_limits::bits, "Length is larger that the required type"); + ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset"); + + return implementation::template extract(buffer); } //************************************************************************* @@ -2046,7 +2269,9 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT { - return value(); + ETL_STATIC_ASSERT(etl::integral_limits::bits >= Active_Bits, "to_ulong() : Active_Bits > unsigned long"); + + return implementation::template value(buffer, Number_Of_Elements); } //************************************************************************* @@ -2054,14 +2279,17 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT { - return value(); + ETL_STATIC_ASSERT(etl::integral_limits::bits >= Active_Bits, "to_ullong() : Active_Bits > unsigned long long"); + + return implementation::template value(buffer, Number_Of_Elements); } + //************************************************************************* /// Reset all of the bits. //************************************************************************* - ETL_CONSTEXPR14 bitset& reset() ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& reset() ETL_NOEXCEPT { - etl::fill_n(buffer, Number_Of_Elements, All_Clear_Element); + implementation::reset_all(buffer, Number_Of_Elements); return *this; } @@ -2069,11 +2297,11 @@ namespace etl //************************************************************************* /// Reset the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 bitset& reset(size_t position) + ETL_CONSTEXPR14 bitset& reset(size_t position) { ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - ibitset.reset(buffer, Number_Of_Elements, position); + implementation::reset_position(buffer, position); return *this; } @@ -2086,23 +2314,93 @@ namespace etl { ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false); - return ibitset.test(buffer, Number_Of_Elements, position); + 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. //************************************************************************* ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT { - return ibitset.count(buffer, Number_Of_Elements); + return implementation::count(buffer, Number_Of_Elements); } //************************************************************************* @@ -2110,7 +2408,17 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT { - return ibitset.all(buffer, Number_Of_Elements, Top_Mask); + return implementation::all(buffer, Number_Of_Elements, Top_Mask); + } + + //************************************************************************* + // Are all the mask bits sets? + //************************************************************************* + ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT + { + ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model"); + + return implementation::all(buffer, Number_Of_Elements, Top_Mask, mask); } //************************************************************************* @@ -2118,7 +2426,17 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT { - return ibitset.none(buffer, Number_Of_Elements); + return implementation::none(buffer, Number_Of_Elements); + } + + //************************************************************************* + /// Are none of the mask bits set? + //************************************************************************* + ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT + { + ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model"); + + return implementation::none(buffer, Number_Of_Elements, mask); } //************************************************************************* @@ -2126,16 +2444,25 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT { - return !none(); + return implementation::any(buffer, Number_Of_Elements); } + //************************************************************************* + /// Are any of the mask bits set? + //************************************************************************* + ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT + { + ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model"); + + return implementation::any(buffer, Number_Of_Elements, mask); + } + //************************************************************************* /// Flip all of the bits. //************************************************************************* - ETL_CONSTEXPR14 bitset& flip() ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& flip() ETL_NOEXCEPT { - ibitset.flip(buffer, Number_Of_Elements); - clear_unused_bits_in_msb(); + implementation::flip_all(buffer, Number_Of_Elements); return *this; } @@ -2143,11 +2470,11 @@ namespace etl //************************************************************************* /// Flip the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 bitset& flip(size_t position) + ETL_CONSTEXPR14 bitset& flip(size_t position) { ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - ibitset.flip(buffer, Number_Of_Elements, position); + implementation::flip_position(buffer, position); return *this; } @@ -2157,7 +2484,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT { - return ibitset.test(buffer, Number_Of_Elements, position); + return implementation::test(buffer, position); } //************************************************************************* @@ -2179,7 +2506,7 @@ namespace etl ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'), typename TString::value_type one = typename TString::value_type('1')) const { - return ibitset.template to_string(buffer, Number_Of_Elements, Active_Bits, zero, one); + return implementation::template to_string(buffer, Active_Bits, zero, one); } //************************************************************************* @@ -2189,7 +2516,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT { - return ibitset.find_next(buffer, Number_Of_Elements, Active_Bits, state, 0); + return implementation::find_next(buffer, Number_Of_Elements, Active_Bits, state, 0); } //************************************************************************* @@ -2200,17 +2527,17 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT { - return ibitset.find_next(buffer, Number_Of_Elements, Active_Bits, state, position); + return implementation::find_next(buffer, Number_Of_Elements, Active_Bits, state, position); } //************************************************************************* /// operator & //************************************************************************* - ETL_CONSTEXPR14 bitset operator &(const bitset& other) const ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset operator &(const bitset& other) const ETL_NOEXCEPT { - etl::bitset temp(*this); + etl::bitset temp(*this); - temp &= other; + implementation::operator_and(temp.buffer, other.buffer, Number_Of_Elements); return temp; } @@ -2218,9 +2545,9 @@ namespace etl //************************************************************************* /// operator &= //************************************************************************* - ETL_CONSTEXPR14 bitset& operator &=(const bitset& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& operator &=(const bitset& other) ETL_NOEXCEPT { - ibitset.and_equals(&buffer[0], &other.buffer[0], Number_Of_Elements); + implementation::operator_and(buffer, other.buffer, Number_Of_Elements); return *this; } @@ -2228,11 +2555,11 @@ namespace etl //************************************************************************* /// operator | //************************************************************************* - ETL_CONSTEXPR14 bitset operator |(const bitset& other) const ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset operator |(const bitset& other) const ETL_NOEXCEPT { - etl::bitset temp(*this); + etl::bitset temp(*this); - temp |= other; + implementation::operator_or(temp.buffer, other.buffer, Number_Of_Elements); return temp; } @@ -2240,9 +2567,9 @@ namespace etl //************************************************************************* /// operator |= //************************************************************************* - ETL_CONSTEXPR14 bitset& operator |=(const bitset& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& operator |=(const bitset& other) ETL_NOEXCEPT { - ibitset.or_equals(&buffer[0], &other.buffer[0], Number_Of_Elements); + implementation::operator_or(&buffer[0], &other.buffer[0], Number_Of_Elements); return *this; } @@ -2250,11 +2577,11 @@ namespace etl //************************************************************************* /// operator ^ //************************************************************************* - ETL_CONSTEXPR14 bitset operator ^(const bitset& other) const ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset operator ^(const bitset& other) const ETL_NOEXCEPT { - etl::bitset temp(*this); + etl::bitset temp(*this); - temp ^= other; + implementation::operator_xor(temp.buffer, other.buffer, Number_Of_Elements); return temp; } @@ -2262,9 +2589,9 @@ namespace etl //************************************************************************* /// operator ^= //************************************************************************* - ETL_CONSTEXPR14 bitset& operator ^=(const bitset& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& operator ^=(const bitset& other) ETL_NOEXCEPT { - ibitset.xor_equals(&buffer[0], &other.buffer[0], Number_Of_Elements); + implementation::operator_xor(buffer, other.buffer, Number_Of_Elements); return *this; } @@ -2272,11 +2599,11 @@ namespace etl //************************************************************************* /// operator ~ //************************************************************************* - ETL_CONSTEXPR14 bitset operator ~() const ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset operator ~() const ETL_NOEXCEPT { - etl::bitset temp(*this); + etl::bitset temp(*this); - temp.flip(); + implementation::flip_all(temp.buffer, Number_Of_Elements); return temp; } @@ -2284,11 +2611,11 @@ namespace etl //************************************************************************* /// operator << //************************************************************************* - ETL_CONSTEXPR14 bitset operator <<(size_t shift) const ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset operator <<(size_t shift) const ETL_NOEXCEPT { - etl::bitset temp(*this); + etl::bitset temp(*this); - temp <<= shift; + implementation::operator_shift_left(temp.buffer, Number_Of_Elements, Active_Bits, shift); return temp; } @@ -2296,16 +2623,15 @@ namespace etl //************************************************************************* /// operator <<= //************************************************************************* - ETL_CONSTEXPR14 bitset& operator <<=(size_t shift) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& operator <<=(size_t shift) ETL_NOEXCEPT { if (shift >= Active_Bits) { - reset(); + implementation::reset_all(buffer, Number_Of_Elements); } else { - ibitset.shift_left_equals(buffer, Number_Of_Elements, shift); - clear_unused_bits_in_msb(); + implementation::operator_shift_left(buffer, Number_Of_Elements, Active_Bits, shift); } return *this; @@ -2314,11 +2640,11 @@ namespace etl //************************************************************************* /// operator >> //************************************************************************* - ETL_CONSTEXPR14 bitset operator >>(size_t shift) const ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset operator >>(size_t shift) const ETL_NOEXCEPT { - bitset temp(*this); + bitset temp(*this); - temp >>= shift; + implementation::operator_shift_right(temp.buffer, Number_Of_Elements, Active_Bits, shift); return temp; } @@ -2326,15 +2652,15 @@ namespace etl //************************************************************************* /// operator >>= //************************************************************************* - ETL_CONSTEXPR14 bitset& operator >>=(size_t shift) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& operator >>=(size_t shift) ETL_NOEXCEPT { if (shift >= Active_Bits) { - reset(); + implementation::reset_all(buffer, Number_Of_Elements); } else { - ibitset.shift_right_equals(buffer, Number_Of_Elements, shift); + implementation::operator_shift_right(buffer, Number_Of_Elements, Active_Bits, shift); } return *this; @@ -2343,19 +2669,25 @@ namespace etl //************************************************************************* /// operator == //************************************************************************* - friend ETL_CONSTEXPR14 bool operator ==(const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT + friend ETL_CONSTEXPR14 bool operator ==(const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT { - return etl::equal(lhs.buffer, - lhs.buffer + lhs.Number_Of_Elements, - rhs.buffer); + return implementation::operator_equality(lhs.buffer, rhs.buffer, lhs.Number_Of_Elements); + } + + //************************************************************************* + /// operator != + //************************************************************************* + friend ETL_CONSTEXPR14 bool operator !=(const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT + { + return !(lhs == rhs); } //************************************************************************* /// swap //************************************************************************* - ETL_CONSTEXPR14 void swap(etl::bitset& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 void swap(etl::bitset& other) ETL_NOEXCEPT { - ibitset.swap(buffer, other.buffer, Number_Of_Elements); + implementation::swap(buffer, other.buffer, Number_Of_Elements); } //************************************************************************* @@ -2381,43 +2713,24 @@ namespace etl //************************************************************************* /// Correct the unused top bits after bit manipulation. //************************************************************************* - ETL_CONSTEXPR14 void clear_unused_bits_in_msb() ETL_NOEXCEPT - { - buffer[Number_Of_Elements - 1U] &= Top_Mask; - } + //ETL_CONSTEXPR14 static void clear_unused_bits_in_msb(pointer pbuffer) ETL_NOEXCEPT + //{ + // pbuffer[Number_Of_Elements - 1U] &= Top_Mask; + //} - etl::bitset_impl ibitset; + // The implementation of the bitset functionality. + typedef etl::bitset_impl implementation; - element_type buffer[Number_Of_Elements > 0U ? Number_Of_Elements : 1U]; + // The storage for the bitset. + element_type buffer[Number_Of_Elements]; }; - template - ETL_CONSTANT size_t bitset::Bits_Per_Element; - - template - ETL_CONSTANT size_t bitset::Number_Of_Elements; - - template - ETL_CONSTANT size_t bitset::Allocated_Bits; - - template - ETL_CONSTANT typename bitset::element_type bitset::All_Set_Element; - - template - ETL_CONSTANT typename bitset::element_type bitset::All_Clear_Element; - - template - ETL_CONSTANT size_t bitset::Top_Mask_Shift; - - template - ETL_CONSTANT typename bitset::element_type bitset::Top_Mask; - //*************************************************************************** /// operator & ///\ingroup bitset //*************************************************************************** - template - ETL_CONSTEXPR14 bitset operator & (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 bitset operator & (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT { bitset temp(lhs); temp &= rhs; @@ -2428,8 +2741,8 @@ namespace etl /// operator | ///\ingroup bitset //*************************************************************************** - template - ETL_CONSTEXPR14 bitset operator | (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 bitset operator | (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT { bitset temp(lhs); temp |= rhs; @@ -2440,30 +2753,30 @@ namespace etl /// operator ^ ///\ingroup bitset //*************************************************************************** - template - ETL_CONSTEXPR14 bitset operator ^ (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 bitset operator ^ (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT { bitset temp(lhs); temp ^= rhs; return temp; } +} - //*************************************************************************** - /// operator != - ///\ingroup bitset - //*************************************************************************** - template - ETL_CONSTEXPR14 bool operator != (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT - { - return !(lhs == rhs); - } +//*************************************************************************** +/// operator != +///\ingroup bitset +//*************************************************************************** +template +ETL_CONSTEXPR14 bool operator != (const etl::bitset& lhs, const etl::bitset& rhs) ETL_NOEXCEPT +{ + return !(lhs == rhs); } //************************************************************************* /// swap //************************************************************************* -template -ETL_CONSTEXPR14 void swap(etl::bitset& lhs, etl::bitset& rhs) ETL_NOEXCEPT +template +ETL_CONSTEXPR14 void swap(etl::bitset& lhs, etl::bitset& rhs) ETL_NOEXCEPT { lhs.swap(rhs); } @@ -2475,939 +2788,55 @@ namespace etl { //*************************************************************************** template ::bits == Active_Bits> - class bitset_ext; - - //*************************************************************************** - /// Specialisation for zero bits. - /// Just defines 'npos'. - //*************************************************************************** - template <> - class bitset_ext<0U, char, true> : public bitset_constants<> - { - }; + typename TElement = unsigned char> + class bitset_ext; //*************************************************************************** /// Specialisation for zero bits. //*************************************************************************** template <> - class bitset_ext<0U, char, false> : public bitset_constants<> - { - }; - - //*************************************************************************** - /// Specialisation that uses a single element if the element type is the - /// same size as the number of active bits. - //*************************************************************************** - template - class bitset_ext : public bitset_constants<> + class bitset_ext<0U, unsigned char> : public etl::private_bitset::bitset_common<0U, unsigned char> { public: - // The element type is the unsigned variant of 'TElement'. - typedef typename etl::make_unsigned::type element_type; - - typedef element_type* pointer; - typedef const element_type* const_pointer; - - static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits::bits; - static ETL_CONSTANT size_t Number_Of_Elements = 1U; - static ETL_CONSTANT size_t Allocated_Bits = Bits_Per_Element; - static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits::type>::max; - static ETL_CONSTANT element_type All_Clear_Element = element_type(0); - static ETL_CONSTANT size_t Top_Mask_Shift = 0U; - static ETL_CONSTANT element_type Top_Mask = All_Set_Element; - - typedef etl::span span_type; - typedef etl::span const_span_type; - - typedef element_type buffer_type; - - //************************************************************************* - /// The reference type returned. - //************************************************************************* - class bit_reference - { - public: - - friend class bitset_ext; - - //******************************* - /// Copy constructor. - //******************************* - ETL_CONSTEXPR14 bit_reference(const bit_reference& other) ETL_NOEXCEPT - : p_bitset(other.p_bitset) - , position(other.position) - { - } - - //******************************* - /// Conversion operator. - //******************************* - ETL_CONSTEXPR14 operator bool() const ETL_NOEXCEPT - { - return p_bitset->test(position); - } - - //******************************* - /// Assignment operator. - //******************************* - ETL_CONSTEXPR14 bit_reference& operator = (bool b) ETL_NOEXCEPT - { - p_bitset->set(position, b); - return *this; - } - - //******************************* - /// Assignment operator. - //******************************* - ETL_CONSTEXPR14 bit_reference& operator = (const bit_reference& r) ETL_NOEXCEPT - { - p_bitset->set(position, bool(r)); - return *this; - } - - //******************************* - /// Flip the bit. - //******************************* - ETL_CONSTEXPR14 bit_reference& flip() ETL_NOEXCEPT - { - p_bitset->flip(position); - return *this; - } - - //******************************* - /// Return the logical inverse of the bit. - //******************************* - ETL_CONSTEXPR14 bool operator~() const ETL_NOEXCEPT - { - return !p_bitset->test(position); - } - - private: - - //******************************* - /// Default constructor. - //******************************* - ETL_CONSTEXPR14 bit_reference() ETL_NOEXCEPT - : p_bitset(ETL_NULLPTR) - , position(0) - { - } - - //******************************* - /// Constructor. - //******************************* - ETL_CONSTEXPR14 bit_reference(bitset_ext& r_bitset, size_t position_) ETL_NOEXCEPT - : p_bitset(&r_bitset) - , position(position_) - { - } - - bitset_ext* p_bitset; ///< The bitset. - size_t position; ///< The position in the bitset. - }; - - //************************************************************************* - /// Default constructor. - //************************************************************************* - ETL_CONSTEXPR14 explicit bitset_ext(element_type* pbuffer_) - : pbuffer(pbuffer_) - { - ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - *pbuffer = All_Clear_Element; - } - - //************************************************************************* - /// Default constructor. - //************************************************************************* - ETL_CONSTEXPR14 explicit bitset_ext(buffer_type& buffer) ETL_NOEXCEPT - : pbuffer(&buffer) - { - *pbuffer = All_Clear_Element; - } - - //************************************************************************* - /// Construct copy. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const bitset_ext& other, element_type* pbuffer_) - : pbuffer(pbuffer_) - { - ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - *pbuffer = *other.pbuffer; - } - - //************************************************************************* - /// Construct copy. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const bitset_ext& other, buffer_type& buffer) ETL_NOEXCEPT - : pbuffer(&buffer) - { - *pbuffer = *other.pbuffer; - } - - //************************************************************************* - /// Copy Constructor (Deleted). - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const bitset_ext& other) ETL_NOEXCEPT ETL_DELETE; - - //************************************************************************* - /// Construct from a value. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(unsigned long long value, element_type* pbuffer_) - : pbuffer(pbuffer_) - { - ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - *pbuffer = element_type(value); - } - - //************************************************************************* - /// Construct from a value. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(unsigned long long value, buffer_type& buffer) ETL_NOEXCEPT - : pbuffer(&buffer) - { - *pbuffer = element_type(value); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const char* text, element_type* pbuffer_) - : pbuffer(pbuffer_) - { - ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - *pbuffer = All_Clear_Element; - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const char* text, buffer_type& buffer) ETL_NOEXCEPT - : pbuffer(&buffer) - { - *pbuffer = All_Clear_Element; - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, element_type* pbuffer_) - : pbuffer(pbuffer_) - { - ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - *pbuffer = All_Clear_Element; - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, buffer_type& buffer) ETL_NOEXCEPT - : pbuffer(&buffer) - { - *pbuffer = All_Clear_Element; - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const char16_t* text, element_type* pbuffer_) - : pbuffer(pbuffer_) - { - ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - *pbuffer = All_Clear_Element; - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const char16_t* text, buffer_type& buffer) ETL_NOEXCEPT - : pbuffer(&buffer) - { - *pbuffer = All_Clear_Element; - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const char32_t* text, element_type* pbuffer_) - : pbuffer(pbuffer_) - { - ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - *pbuffer = All_Clear_Element; - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const char32_t* text, buffer_type& buffer) ETL_NOEXCEPT - : pbuffer(&buffer) - { - *pbuffer = All_Clear_Element; - set(text); - } - - //************************************************************************* - /// Assignment operator. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator =(const bitset_ext& other) ETL_NOEXCEPT - { - *pbuffer = *other.pbuffer; - - return *this; - } - - //************************************************************************* - /// Set all of the bits. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set() ETL_NOEXCEPT - { - *pbuffer = All_Set_Element; - - return *this; - } - - //************************************************************************* - /// Set the bit at the position. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(size_t position, bool value = true) - { - ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - - const element_type mask = element_type(element_type(1) << position); - if (value == true) - { - *pbuffer |= mask; - } - else - { - *pbuffer &= ~mask; - } - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(const char* text) ETL_NOEXCEPT - { - from_string(text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(const wchar_t* text) ETL_NOEXCEPT - { - from_string(text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(const char16_t* text) ETL_NOEXCEPT - { - from_string(text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(const char32_t* text) ETL_NOEXCEPT - { - from_string(text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& from_string(const char* text) ETL_NOEXCEPT - { - if (text == ETL_NULLPTR) - { - reset(); - } - else - { - size_t string_length = etl::strlen(text); - - // Build from the string. - string_length = etl::min(Active_Bits, string_length); - - element_type mask = element_type(element_type(1) << (string_length - 1U)); - - for (size_t i = 0U; i < string_length; ++i) - { - if (text[i] == ETL_STR('1')) - { - *pbuffer |= mask; - } - else - { - *pbuffer &= ~mask; - } - - mask >>= 1U; - } - } - - return *this; - } - - //************************************************************************* - /// Set from a wide string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& from_string(const wchar_t* text) ETL_NOEXCEPT - { - if (text == ETL_NULLPTR) - { - reset(); - } - else - { - size_t string_length = etl::strlen(text); - - // Build from the string. - string_length = etl::min(Active_Bits, string_length); - - element_type mask = element_type(element_type(1) << (string_length - 1U)); - - for (size_t i = 0U; i < string_length; ++i) - { - if (text[i] == ETL_STRL('1')) - { - *pbuffer |= mask; - } - else - { - *pbuffer &= ~mask; - } - - mask >>= 1U; - } - } - - return *this; - } - - //************************************************************************* - /// Set from a u16 string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& from_string(const char16_t* text) ETL_NOEXCEPT - { - if (text == ETL_NULLPTR) - { - reset(); - } - else - { - size_t string_length = etl::strlen(text); - - // Build from the string. - string_length = etl::min(Active_Bits, string_length); - - element_type mask = element_type(element_type(1) << (string_length - 1U)); - - for (size_t i = 0U; i < string_length; ++i) - { - if (text[i] == ETL_STRu('1')) - { - *pbuffer |= mask; - } - else - { - *pbuffer &= ~mask; - } - - mask >>= 1U; - } - } - - return *this; - } - - //************************************************************************* - /// Set from a u32 string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& from_string(const char32_t* text) ETL_NOEXCEPT - { - if (text == ETL_NULLPTR) - { - reset(); - } - else - { - size_t string_length = etl::strlen(text); - - // Build from the string. - string_length = etl::min(Active_Bits, string_length); - - element_type mask = element_type(element_type(1) << (string_length - 1U)); - - for (size_t i = 0U; i < string_length; ++i) - { - if (text[i] == ETL_STRU('1')) - { - *pbuffer |= mask; - } - else - { - *pbuffer &= ~mask; - } - - mask >>= 1U; - } - } - - return *this; - } - - //************************************************************************* - /// Get as an integral value. - //************************************************************************* - template - ETL_CONSTEXPR14 - typename etl::enable_if::value, T>::type - value() const ETL_NOEXCEPT - { - ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); - ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Integral type too small"); - - T v = T(0); - - const bool OK = (sizeof(T) * CHAR_BIT) >= Bits_Per_Element; - - if (OK) - { - v = T(typename etl::make_unsigned::type(*pbuffer)); - } - - return v; - } - - //************************************************************************* - /// Get as an unsigned long. - //************************************************************************* - ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT - { - return value(); - } - - //************************************************************************* - /// Get as an unsigned long long. - //************************************************************************* - ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT - { - return value(); - } - - //************************************************************************* - /// Reset all of the bits. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& reset() ETL_NOEXCEPT - { - *pbuffer = All_Clear_Element; - - return *this; - } - - //************************************************************************* - /// Reset the bit at the position. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& reset(size_t position) - { - ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - - const element_type mask = element_type(element_type(1) << position); - *pbuffer &= ~mask; - - return *this; - } - - //************************************************************************* - /// Tests a bit at a position. - /// Positions greater than the number of configured bits will return false. - //************************************************************************* - ETL_CONSTEXPR14 bool test(size_t position) const - { - ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false); - - const element_type mask = element_type(element_type(1) << position); - return (*pbuffer & mask) != 0U; - } - - //************************************************************************* - /// The number of bits in the bitset. - //************************************************************************* - ETL_CONSTEXPR14 size_t size() const ETL_NOEXCEPT - { - return Active_Bits; - } - - //************************************************************************* - /// Count the number of bits set. - //************************************************************************* - ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT - { - return etl::count_bits(*pbuffer); - } - - //************************************************************************* - // Are all the bits sets? - //************************************************************************* - ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT - { - return *pbuffer == All_Set_Element; - } - - //************************************************************************* - // Are all the bits sets? - //************************************************************************* - ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT - { - return *pbuffer == (All_Set_Element & mask); - } - - //************************************************************************* - /// Are none of the bits set? - //************************************************************************* - ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT - { - return *pbuffer == All_Clear_Element; - } - - //************************************************************************* - /// Are none of the bits set? - //************************************************************************* - ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT - { - return (*pbuffer & mask) == All_Clear_Element; - } - - //************************************************************************* - /// Are any of the bits set? - //************************************************************************* - ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT - { - return !none(); - } - - //************************************************************************* - /// Are any of the bits set? - //************************************************************************* - ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT - { - return !none(mask); - } - - //************************************************************************* - /// Flip all of the bits. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& flip() ETL_NOEXCEPT - { - *pbuffer = ~*pbuffer; - - return *this; - } - - //************************************************************************* - /// Flip some of the bits. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& flip_bits(element_type mask = etl::integral_limits::max) ETL_NOEXCEPT - { - *pbuffer ^= mask; - - return *this; - } - - //************************************************************************* - /// Flip the bit at the position. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& flip(size_t position) - { - ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - - const element_type mask = element_type(element_type(1) << position); - *pbuffer ^= mask; - - return *this; - } - - //************************************************************************* - /// Read [] operator. - //************************************************************************* - ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT - { - if (position < Active_Bits) - { - const element_type mask = element_type(element_type(1) << position); - return (*pbuffer & mask) != 0U; - } - - return false; - } - - //************************************************************************* - /// Write [] operator. - //************************************************************************* - ETL_CONSTEXPR14 bit_reference operator [] (size_t position) ETL_NOEXCEPT - { - return bit_reference(*this, position); - } - - //************************************************************************* - /// Returns a string representing the bitset. - //************************************************************************* -#if ETL_USING_CPP11 - template > -#else - template -#endif - ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'), - typename TString::value_type one = typename TString::value_type('1')) const - { - TString result; - - result.resize(Active_Bits, '\0'); - - // Check that the string type can contain the digits. - ETL_ASSERT_OR_RETURN_VALUE(result.size() == Active_Bits, ETL_ERROR(etl::bitset_string_too_small), result); - - for (size_t i = Active_Bits; i > 0; --i) - { - result[Active_Bits - i] = test(i - 1) ? one : zero; - } - - return result; - } - - //************************************************************************* - /// Finds the first bit in the specified state. - ///\param state The state to search for. - ///\returns The position of the bit or npos if none were found. - //************************************************************************* - ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT - { - return find_next(state, 0U); - } - - //************************************************************************* - /// Finds the next bit in the specified state. - ///\param state The state to search for. - ///\param position The position to start from. - ///\returns The position of the bit or npos if none were found. - //************************************************************************* - ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT - { - if (position < Active_Bits) - { - // Where to start. - size_t bit = position; - - element_type mask = 1U << position; - - // Needs checking? - if ((state && (*pbuffer != All_Clear_Element)) || (!state && (*pbuffer != All_Set_Element))) - { - // For each bit in the element... - while (bit < Active_Bits) - { - // Equal to the required state? - if (((*pbuffer & mask) != 0) == state) - { - return bit; - } - - // Move on to the next bit. - mask <<= 1; - ++bit; - } - } - } - - return npos; - } - - //************************************************************************* - /// operator &= - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator &=(const bitset_ext& other) ETL_NOEXCEPT - { - *pbuffer &= *other.pbuffer; - - return *this; - } - - //************************************************************************* - /// operator |= - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator |=(const bitset_ext& other) ETL_NOEXCEPT - { - *pbuffer |= *other.pbuffer; - - return *this; - } - - //************************************************************************* - /// operator ^= - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator ^=(const bitset_ext& other) ETL_NOEXCEPT - { - *pbuffer ^= *other.pbuffer; - - return *this; - } - - //************************************************************************* - /// operator <<= - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator <<=(size_t shift) ETL_NOEXCEPT - { - if (shift >= Active_Bits) - { - reset(); - } - else - { - *pbuffer <<= shift; - } - - return *this; - } - - //************************************************************************* - /// operator >>= - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator >>=(size_t shift) ETL_NOEXCEPT - { - if (shift >= Active_Bits) - { - reset(); - } - else - { - *pbuffer >>= shift; - } - - return *this; - } - - //************************************************************************* - /// operator == - //************************************************************************* - friend ETL_CONSTEXPR14 bool operator ==(const bitset_ext& lhs, const bitset_ext& rhs) ETL_NOEXCEPT - { - return (*lhs.pbuffer == *rhs.pbuffer); - } - - //************************************************************************* - /// swap - //************************************************************************* - ETL_CONSTEXPR14 void swap(etl::bitset_ext& other) ETL_NOEXCEPT - { - element_type temp = *pbuffer; - *pbuffer = *other.pbuffer; - *other.pbuffer = temp; - } - - //************************************************************************* - /// span - /// Returns a span of the underlying buffer. - //************************************************************************* - ETL_CONSTEXPR14 span_type span() ETL_NOEXCEPT - { - return span_type(pbuffer, 1); - } - - //************************************************************************* - /// span - /// Returns a const span of the underlying buffer. - //************************************************************************* - ETL_CONSTEXPR14 const_span_type span() const ETL_NOEXCEPT - { - return const_span_type(pbuffer, 1); - } - - private: - - element_type* pbuffer; + typedef etl::private_bitset::bitset_common<0U, unsigned char>::element_type element_type; + typedef etl::private_bitset::bitset_common<0U, unsigned char>::span_type span_type; + typedef etl::private_bitset::bitset_common<0U, unsigned char>::const_span_type const_span_type; + + 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; }; - template - ETL_CONSTANT size_t bitset_ext::Bits_Per_Element; - - template - ETL_CONSTANT size_t bitset_ext::Number_Of_Elements; - - template - ETL_CONSTANT size_t bitset_ext::Allocated_Bits; - - template - ETL_CONSTANT typename bitset_ext::element_type bitset_ext::All_Set_Element; - - template - ETL_CONSTANT typename bitset_ext::element_type bitset_ext::All_Clear_Element; - - template - ETL_CONSTANT size_t bitset_ext::Top_Mask_Shift; - - template - ETL_CONSTANT typename bitset_ext::element_type bitset_ext::Top_Mask; - //************************************************************************* - /// The specialisation that uses an array of the default element type. + /// A bitset that uses externally declared storage. //************************************************************************* template - class bitset_ext : public bitset_constants<> + class bitset_ext : public etl::private_bitset::bitset_common { - private: - - //************************************************************************* - // If the 'TElement' is the default 'void', then use 'char', otherwise uses - // the unsigned variant of 'TElement'. - //************************************************************************* - struct select_element_type - { - typedef typename etl::make_unsigned::value, char, TElement>::type>::type type; - }; - public: - typedef typename select_element_type::type element_type; - typedef element_type* pointer; - typedef const element_type* const_pointer; + ETL_STATIC_ASSERT(etl::is_unsigned::value, "The element type must be unsigned"); - static ETL_CONSTANT size_t Bits_Per_Element = etl::bitset_impl::Bits_Per_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 Allocated_Bits = Number_Of_Elements * Bits_Per_Element; - static ETL_CONSTANT size_t Top_Mask_Shift = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element); - static ETL_CONSTANT element_type All_Set_Element = etl::bitset_impl::All_Set_Element; - static ETL_CONSTANT element_type All_Clear_Element = etl::bitset_impl::All_Clear_Element; - static ETL_CONSTANT element_type Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift)); + 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 ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility. - - typedef etl::span span_type; - typedef etl::span const_span_type; - - typedef etl::array buffer_type; + typedef etl::array buffer_type; //************************************************************************* /// The reference type returned. @@ -3490,7 +2919,7 @@ namespace etl { } - bitset_ext* p_bitset; ///< The bitset. + bitset_ext* p_bitset; ///< The bitset. size_t position; ///< The position in the bitset. }; @@ -3501,7 +2930,7 @@ namespace etl : pbuffer(pbuffer_) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - reset(); + implementation::reset_all(pbuffer, Number_Of_Elements); } //************************************************************************* @@ -3511,32 +2940,32 @@ namespace etl : pbuffer(buffer.data()) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - reset(); + implementation::reset_all(pbuffer, Number_Of_Elements); } //************************************************************************* /// Construct copy. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const bitset_ext& other, element_type* pbuffer_) + ETL_CONSTEXPR14 bitset_ext(const bitset_ext& other, element_type* pbuffer_) : pbuffer(pbuffer_) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - etl::copy_n(other.pbuffer, Number_Of_Elements, pbuffer); + implementation::operator_assignment(pbuffer, other.pbuffer, Number_Of_Elements); } //************************************************************************* /// Construct copy. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const bitset_ext& other, buffer_type& buffer) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext(const bitset_ext& other, buffer_type& buffer) ETL_NOEXCEPT : pbuffer(buffer.data()) { - etl::copy_n(other.pbuffer, Number_Of_Elements, pbuffer); + implementation::operator_assignment(pbuffer, other.pbuffer, Number_Of_Elements); } //************************************************************************* /// Copy Constructor (Deleted). //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const bitset_ext& other) ETL_NOEXCEPT ETL_DELETE; + ETL_CONSTEXPR14 bitset_ext(const bitset_ext& other) ETL_NOEXCEPT ETL_DELETE; //************************************************************************* /// Construct from a value. @@ -3545,8 +2974,7 @@ namespace etl : pbuffer(pbuffer_) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - ibitset.initialise(pbuffer, Number_Of_Elements, value); - clear_unused_bits_in_msb(); + implementation::initialise(pbuffer, Number_Of_Elements, value); } //************************************************************************* @@ -3555,8 +2983,7 @@ namespace etl ETL_CONSTEXPR14 bitset_ext(unsigned long long value, buffer_type& buffer) ETL_NOEXCEPT : pbuffer(buffer.data()) { - ibitset.initialise(pbuffer, Number_Of_Elements, value); - clear_unused_bits_in_msb(); + implementation::initialise(pbuffer, Number_Of_Elements, value); } //************************************************************************* @@ -3566,8 +2993,7 @@ namespace etl : pbuffer(pbuffer_) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -3576,8 +3002,7 @@ namespace etl ETL_CONSTEXPR14 bitset_ext(const char* text, buffer_type& buffer) ETL_NOEXCEPT : pbuffer(buffer.data()) { - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -3587,8 +3012,7 @@ namespace etl : pbuffer(pbuffer_) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -3597,8 +3021,7 @@ namespace etl ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, buffer_type& buffer) ETL_NOEXCEPT : pbuffer(buffer.data()) { - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -3608,8 +3031,7 @@ namespace etl : pbuffer(pbuffer_) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -3618,8 +3040,7 @@ namespace etl ETL_CONSTEXPR14 bitset_ext(const char16_t* text, buffer_type& buffer) ETL_NOEXCEPT : pbuffer(buffer.data()) { - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -3629,8 +3050,7 @@ namespace etl : pbuffer(pbuffer_) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -3639,16 +3059,15 @@ namespace etl ETL_CONSTEXPR14 bitset_ext(const char32_t* text, buffer_type& buffer) ETL_NOEXCEPT : pbuffer(buffer.data()) { - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* /// Assignment operator. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator =(const bitset_ext& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& operator =(const bitset_ext& other) ETL_NOEXCEPT { - etl::copy_n(other.pbuffer, Number_Of_Elements, pbuffer); + implementation::operator_assignment(pbuffer, other.pbuffer, Number_Of_Elements); return *this; } @@ -3656,10 +3075,9 @@ namespace etl //************************************************************************* /// Set all of the bits. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set() ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& set() ETL_NOEXCEPT { - etl::fill_n(pbuffer, Number_Of_Elements, All_Set_Element); - clear_unused_bits_in_msb(); + implementation::set_all(pbuffer, Number_Of_Elements, Top_Mask); return *this; } @@ -3667,12 +3085,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); - - ibitset.set(pbuffer, Number_Of_Elements, position, value); - clear_unused_bits_in_msb(); + + implementation::set_position(pbuffer, position, value); + + return *this; + } + + //************************************************************************* + /// Set the bit at the position. + //************************************************************************* + template + ETL_CONSTEXPR14 bitset_ext& set(bool value = true) + { + 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; } @@ -3680,49 +3124,12 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(const char* text) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 + typename etl::enable_if::value, bitset_ext&>::type + set(TPString text) ETL_NOEXCEPT { - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(const wchar_t* text) ETL_NOEXCEPT - { - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(const char16_t* text) ETL_NOEXCEPT - { - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(const char32_t* text) ETL_NOEXCEPT - { - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& from_string(const char* text) ETL_NOEXCEPT - { - ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -3730,9 +3137,58 @@ namespace etl //************************************************************************* /// Set from a wide string. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& from_string(const wchar_t* text) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 + typename etl::enable_if::value, bitset_ext&>::type + set(TPString text) ETL_NOEXCEPT { - ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); + + return *this; + } + + //************************************************************************* + /// Set from a char16 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); + + 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); + + return *this; + } + + //************************************************************************* + /// Set from a string. + //************************************************************************* + ETL_CONSTEXPR14 bitset_ext& from_string(const char* text) ETL_NOEXCEPT + { + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); + + return *this; + } + + //************************************************************************* + /// Set from a wide string. + //************************************************************************* + ETL_CONSTEXPR14 bitset_ext& from_string(const wchar_t* text) ETL_NOEXCEPT + { + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -3740,9 +3196,9 @@ namespace etl //************************************************************************* /// Set from a u16 string. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& from_string(const char16_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& from_string(const char16_t* text) ETL_NOEXCEPT { - ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -3750,9 +3206,9 @@ namespace etl //************************************************************************* /// Set from a u32 string. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& from_string(const char32_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& from_string(const char32_t* text) ETL_NOEXCEPT { - ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -3762,13 +3218,47 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - typename etl::enable_if::value, T>::type - value() const ETL_NOEXCEPT + T value() const ETL_NOEXCEPT { ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); - ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Type too small"); + ETL_STATIC_ASSERT(etl::integral_limits::bits >= (Number_Of_Elements * Bits_Per_Element), "Type too small"); - return ibitset.template value(pbuffer, Number_Of_Elements); + return implementation::template value(pbuffer, Number_Of_Elements); + } + + //************************************************************************* + /// Extract an integral value from an arbitrary position and length. + /// Run time position and length. + //************************************************************************* + template + ETL_CONSTEXPR14 + T extract(size_t position, size_t length = etl::integral_limits::bits) + { + ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); + + ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits::bits, ETL_ERROR(bitset_overflow), 0); + ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0); + + return implementation::template extract(pbuffer, position, length); + } + + //************************************************************************* + /// Extract an integral value from an arbitrary position and length. + /// Compile time position and length. + //************************************************************************* +#if ETL_USING_CPP11 + template ::bits> +#else + template +#endif + ETL_CONSTEXPR14 + T extract() const + { + ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); + ETL_STATIC_ASSERT(Length <= etl::integral_limits::bits, "Length is larger that the required type"); + ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset"); + + return implementation::template extract(pbuffer); } //************************************************************************* @@ -3776,7 +3266,9 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT { - return value(); + ETL_STATIC_ASSERT(etl::integral_limits::bits >= Active_Bits, "Active_Bits > unsigned long"); + + return implementation::template value(pbuffer, Number_Of_Elements); } //************************************************************************* @@ -3784,14 +3276,17 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT { - return value(); + ETL_STATIC_ASSERT(etl::integral_limits::bits >= Active_Bits, "Active_Bits > unsigned long long"); + + return implementation::template value(pbuffer, Number_Of_Elements); } + //************************************************************************* /// Reset all of the bits. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& reset() ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& reset() ETL_NOEXCEPT { - etl::fill_n(pbuffer, Number_Of_Elements, All_Clear_Element); + implementation::reset_all(pbuffer, Number_Of_Elements); return *this; } @@ -3799,11 +3294,11 @@ namespace etl //************************************************************************* /// Reset the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& reset(size_t position) + ETL_CONSTEXPR14 bitset_ext& reset(size_t position) { ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - ibitset.reset(pbuffer, Number_Of_Elements, position); + implementation::reset_position(pbuffer, position); return *this; } @@ -3816,23 +3311,93 @@ namespace etl { ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false); - return ibitset.test(pbuffer, Number_Of_Elements, position); + 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. //************************************************************************* ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT { - return ibitset.count(pbuffer, Number_Of_Elements); + return implementation::count(pbuffer, Number_Of_Elements); } //************************************************************************* @@ -3840,7 +3405,17 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT { - return ibitset.all(pbuffer, Number_Of_Elements, Top_Mask); + return implementation::all(pbuffer, Number_Of_Elements, Top_Mask); + } + + //************************************************************************* + // Are all the mask bits sets? + //************************************************************************* + ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT + { + ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model"); + + return implementation::all(pbuffer, Number_Of_Elements, Top_Mask, mask); } //************************************************************************* @@ -3848,7 +3423,17 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT { - return ibitset.none(pbuffer, Number_Of_Elements); + return implementation::none(pbuffer, Number_Of_Elements); + } + + //************************************************************************* + /// Are none of the mask bits set? + //************************************************************************* + ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT + { + ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model"); + + return implementation::none(pbuffer, Number_Of_Elements, mask); } //************************************************************************* @@ -3856,16 +3441,25 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT { - return !none(); + return implementation::any(pbuffer, Number_Of_Elements); + } + + //************************************************************************* + /// Are any of the mask bits set? + //************************************************************************* + ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT + { + ETL_STATIC_ASSERT(Storage_Model == etl::bitset_storage_model::Single, "Not supported for 'Multi' bitset storage model"); + + return implementation::any(pbuffer, Number_Of_Elements, mask); } //************************************************************************* /// Flip all of the bits. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& flip() ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& flip() ETL_NOEXCEPT { - ibitset.flip(pbuffer, Number_Of_Elements); - clear_unused_bits_in_msb(); + implementation::flip_all(pbuffer, Number_Of_Elements); return *this; } @@ -3873,11 +3467,11 @@ namespace etl //************************************************************************* /// Flip the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& flip(size_t position) + ETL_CONSTEXPR14 bitset_ext& flip(size_t position) { ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - ibitset.flip(pbuffer, Number_Of_Elements, position); + implementation::flip_position(pbuffer, position); return *this; } @@ -3887,7 +3481,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT { - return ibitset.test(pbuffer, Number_Of_Elements, position); + return implementation::test(pbuffer, position); } //************************************************************************* @@ -3907,9 +3501,9 @@ namespace etl template #endif ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'), - typename TString::value_type one = typename TString::value_type('1')) const + typename TString::value_type one = typename TString::value_type('1')) const { - return ibitset.template to_string(pbuffer, Number_Of_Elements, Active_Bits, zero, one); + return implementation::template to_string(pbuffer, Active_Bits, zero, one); } //************************************************************************* @@ -3919,7 +3513,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT { - return ibitset.find_next(pbuffer, Number_Of_Elements, Active_Bits, state, 0); + return implementation::find_next(pbuffer, Number_Of_Elements, Active_Bits, state, 0); } //************************************************************************* @@ -3930,15 +3524,15 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT { - return ibitset.find_next(pbuffer, Number_Of_Elements, Active_Bits, state, position); + return implementation::find_next(pbuffer, Number_Of_Elements, Active_Bits, state, position); } //************************************************************************* /// operator &= //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator &=(const bitset_ext& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& operator &=(const bitset_ext& other) ETL_NOEXCEPT { - ibitset.and_equals(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements); + implementation::operator_and(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements); return *this; } @@ -3946,9 +3540,9 @@ namespace etl //************************************************************************* /// operator |= //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator |=(const bitset_ext& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& operator |=(const bitset_ext& other) ETL_NOEXCEPT { - ibitset.or_equals(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements); + implementation::operator_or(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements); return *this; } @@ -3956,9 +3550,9 @@ namespace etl //************************************************************************* /// operator ^= //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator ^=(const bitset_ext& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& operator ^=(const bitset_ext& other) ETL_NOEXCEPT { - ibitset.xor_equals(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements); + implementation::operator_xor(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements); return *this; } @@ -3966,17 +3560,9 @@ namespace etl //************************************************************************* /// operator <<= //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator <<=(size_t shift) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& operator <<=(size_t shift) ETL_NOEXCEPT { - if (shift >= Active_Bits) - { - reset(); - } - else - { - ibitset.shift_left_equals(pbuffer, Number_Of_Elements, shift); - clear_unused_bits_in_msb(); - } + implementation::operator_shift_left(pbuffer, Number_Of_Elements, Active_Bits, shift); return *this; } @@ -3984,16 +3570,9 @@ namespace etl //************************************************************************* /// operator >>= //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator >>=(size_t shift) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& operator >>=(size_t shift) ETL_NOEXCEPT { - if (shift >= Active_Bits) - { - reset(); - } - else - { - ibitset.shift_right_equals(pbuffer, Number_Of_Elements, shift); - } + implementation::operator_shift_right(pbuffer, Number_Of_Elements, Active_Bits, shift); return *this; } @@ -4001,19 +3580,25 @@ namespace etl //************************************************************************* /// operator == //************************************************************************* - friend ETL_CONSTEXPR14 bool operator ==(const bitset_ext& lhs, const bitset_ext& rhs) ETL_NOEXCEPT + friend ETL_CONSTEXPR14 bool operator ==(const bitset_ext& lhs, const bitset_ext& rhs) ETL_NOEXCEPT { - return etl::equal(lhs.pbuffer, - lhs.pbuffer + lhs.Number_Of_Elements, - rhs.pbuffer); + return implementation::operator_equality(lhs.pbuffer, rhs.pbuffer, lhs.Number_Of_Elements); + } + + //************************************************************************* + /// operator != + //************************************************************************* + friend ETL_CONSTEXPR14 bool operator !=(const bitset_ext& lhs, const bitset_ext& rhs) ETL_NOEXCEPT + { + return !(lhs == rhs); } //************************************************************************* /// swap //************************************************************************* - ETL_CONSTEXPR14 void swap(etl::bitset_ext& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 void swap(etl::bitset_ext& other) ETL_NOEXCEPT { - ibitset.swap(pbuffer, other.pbuffer, Number_Of_Elements); + implementation::swap(pbuffer, other.pbuffer, Number_Of_Elements); } //************************************************************************* @@ -4036,59 +3621,301 @@ namespace etl private: - //************************************************************************* - /// Correct the unused top bits after bit manipulation. - //************************************************************************* - ETL_CONSTEXPR14 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; - etl::bitset_impl ibitset; + // Pointer to the storage for the bitset. element_type* pbuffer; }; +} - template - ETL_CONSTANT size_t bitset_ext::Bits_Per_Element; - - template - ETL_CONSTANT size_t bitset_ext::Number_Of_Elements; - - template - ETL_CONSTANT size_t bitset_ext::Allocated_Bits; - - template - ETL_CONSTANT typename bitset_ext::element_type bitset_ext::All_Set_Element; - - template - ETL_CONSTANT typename bitset_ext::element_type bitset_ext::All_Clear_Element; - - template - ETL_CONSTANT size_t bitset_ext::Top_Mask_Shift; - - template - ETL_CONSTANT typename bitset_ext::element_type bitset_ext::Top_Mask; - - //*************************************************************************** - /// operator != - ///\ingroup bitset - //*************************************************************************** - template - ETL_CONSTEXPR14 bool operator != (const bitset_ext& lhs, const bitset_ext& rhs) ETL_NOEXCEPT - { - return !(lhs == rhs); - } +//*************************************************************************** +/// operator != +///\ingroup bitset +//*************************************************************************** +template +ETL_CONSTEXPR14 bool operator != (const etl::bitset_ext& lhs, const etl::bitset_ext& rhs) ETL_NOEXCEPT +{ + return !(lhs == rhs); } //************************************************************************* /// swap //************************************************************************* -template -ETL_CONSTEXPR14 void swap(etl::bitset_ext& lhs, etl::bitset_ext& rhs) ETL_NOEXCEPT +template +ETL_CONSTEXPR14 void swap(etl::bitset_ext& lhs, etl::bitset_ext& rhs) ETL_NOEXCEPT { lhs.swap(rhs); } +namespace etl +{ + namespace private_bitset + { + //************************************************************************* + /// Compare bitset spans. + /// Assumes that the lhs span's element type is larger than rhs's. + //************************************************************************* + template + bool compare_bitset_spans(const TLhsSpan& lhs_span, const TRhsSpan& rhs_span) + { + typedef typename TLhsSpan::value_type lhs_element_t; + typedef typename TRhsSpan::value_type rhs_element_t; + + const int steps = static_cast(sizeof(lhs_element_t) / sizeof(rhs_element_t)); + + typename TLhsSpan::iterator lhs_itr = lhs_span.begin(); + typename TRhsSpan::iterator rhs_itr = rhs_span.begin(); + + while (lhs_itr != lhs_span.end()) + { + const lhs_element_t& lhs_value = *lhs_itr; + + // Build the rhs element in terms of the lhs element type. + lhs_element_t rhs_value = 0; + + const int shift_step = etl::integral_limits::bits; + int shift = 0; + + for (int i = 0; i < steps; ++i) + { + rhs_value |= (static_cast(*rhs_itr) << shift); + ++rhs_itr; + shift += shift_step; + } + + if (lhs_value != rhs_value) + { + return false; + } + + ++lhs_itr; + } + + return true; + } + } +} + +//*************************************************************************** +/// operator == +/// bitset +/// Different element types +///\ingroup bitset +//*************************************************************************** +template +ETL_CONSTEXPR14 +typename etl::enable_if::value, bool>::type + operator == (const etl::bitset& lhs, const etl::bitset& rhs) ETL_NOEXCEPT +{ + // Get a span of each type. + typename etl::bitset::const_span_type lhs_span = lhs.span(); + typename etl::bitset::const_span_type rhs_span = rhs.span(); + + // Put the bitset with the largest element type as the first argument. + if ETL_IF_CONSTEXPR(sizeof(TLhsElement) > sizeof(TRhsElement)) + { + return etl::private_bitset::compare_bitset_spans(lhs_span, rhs_span); + } + else + { + return etl::private_bitset::compare_bitset_spans(rhs_span, lhs_span); + } +} + +//*************************************************************************** +/// operator != +/// bitset +/// Different element types +///\ingroup bitset +//*************************************************************************** +template +ETL_CONSTEXPR14 +typename etl::enable_if::value, bool>::type + operator != (const etl::bitset& lhs, const etl::bitset& rhs) ETL_NOEXCEPT +{ + return !(lhs == rhs); +} + +//*************************************************************************** +/// operator == +/// bitset_ext +/// Different element types +///\ingroup bitset +//*************************************************************************** +template +ETL_CONSTEXPR14 +typename etl::enable_if::value, bool>::type + operator == (const etl::bitset_ext& lhs, const etl::bitset_ext& rhs) ETL_NOEXCEPT +{ + // Get a span of each type. + typename etl::bitset_ext::const_span_type lhs_span = lhs.span(); + typename etl::bitset_ext::const_span_type rhs_span = rhs.span(); + + // Put the bitset with the largest element type as the first argument. + if ETL_IF_CONSTEXPR(sizeof(TLhsElement) > sizeof(TRhsElement)) + { + return etl::private_bitset::compare_bitset_spans(lhs_span, rhs_span); + } + else + { + return etl::private_bitset::compare_bitset_spans(rhs_span, lhs_span); + } +} + +//*************************************************************************** +/// operator != +/// bitset_ext +/// Different element types +///\ingroup bitset +//*************************************************************************** +template +ETL_CONSTEXPR14 +typename etl::enable_if::value, bool>::type + operator != (const etl::bitset_ext& lhs, const etl::bitset_ext& rhs) ETL_NOEXCEPT +{ + return !(lhs == rhs); +} + +//*************************************************************************** +/// operator == +/// bitset compared with bitset_ext, same element types. +///\ingroup bitset +//*************************************************************************** +template +ETL_CONSTEXPR14 +bool operator == (const etl::bitset& lhs, const etl::bitset_ext& rhs) ETL_NOEXCEPT +{ + const char Storage_Model = etl::bitset::Storage_Model; + const size_t Number_Of_Elements = etl::bitset::Number_Of_Elements; + + typename etl::bitset::const_span_type lhs_span = lhs.span(); + typename etl::bitset_ext::const_span_type rhs_span = rhs.span(); + + typedef etl::bitset_impl implementation; + + return implementation::operator_equality(lhs_span.begin(), rhs_span.begin(), Number_Of_Elements); +} + +//*************************************************************************** +/// operator != +/// bitset compared with bitset_ext, same element types. +///\ingroup bitset +//*************************************************************************** +template +ETL_CONSTEXPR14 +bool operator != (const etl::bitset& lhs, const etl::bitset_ext& rhs) ETL_NOEXCEPT +{ + return !(lhs == rhs); +} + +//*************************************************************************** +/// operator == +/// bitset_ext compared with bitset, same element types. +///\ingroup bitset +//*************************************************************************** +template +ETL_CONSTEXPR14 +bool operator == (const etl::bitset_ext& lhs, const etl::bitset& rhs) ETL_NOEXCEPT +{ + const char Storage_Model = etl::bitset::Storage_Model; + const size_t Number_Of_Elements = etl::bitset::Number_Of_Elements; + + typename etl::bitset_ext::const_span_type lhs_span = lhs.span(); + typename etl::bitset::const_span_type rhs_span = rhs.span(); + + typedef etl::bitset_impl implementation; + + return implementation::operator_equality(lhs_span.begin(), rhs_span.begin(), Number_Of_Elements); +} + +//*************************************************************************** +/// operator != +/// bitset_ext compared with bitset, same element types. +///\ingroup bitset +//*************************************************************************** +template +ETL_CONSTEXPR14 +bool operator != (const etl::bitset_ext& lhs, const etl::bitset& rhs) ETL_NOEXCEPT +{ + return !(lhs == rhs); +} + +//*************************************************************************** +/// operator == +/// bitset compared with bitset_ext, different element types. +///\ingroup bitset +//*************************************************************************** +template +ETL_CONSTEXPR14 +typename etl::enable_if::value, bool>::type +operator == (const etl::bitset& lhs, const etl::bitset_ext& rhs) ETL_NOEXCEPT +{ + // Get a span of each type. + typename etl::bitset::const_span_type lhs_span = lhs.span(); + typename etl::bitset_ext::const_span_type rhs_span = rhs.span(); + + // Put the bitset with the largest element type as the first argument. + if ETL_IF_CONSTEXPR(sizeof(TLhsElement) > sizeof(TRhsElement)) + { + return etl::private_bitset::compare_bitset_spans(lhs_span, rhs_span); + } + else + { + return etl::private_bitset::compare_bitset_spans(rhs_span, lhs_span); + } +} + +//*************************************************************************** +/// operator != +/// bitset compared with bitset_ext, different element types. +///\ingroup bitset +//*************************************************************************** +template +ETL_CONSTEXPR14 +typename etl::enable_if::value, bool>::type + operator != (const etl::bitset& lhs, const etl::bitset_ext& rhs) ETL_NOEXCEPT +{ + return !(lhs == rhs); +} + +//*************************************************************************** +/// operator == +/// bitset_ext compared with bitset, different element types. +///\ingroup bitset +//*************************************************************************** +template +ETL_CONSTEXPR14 +typename etl::enable_if::value, bool>::type + operator == (const etl::bitset_ext& lhs, const etl::bitset& rhs) ETL_NOEXCEPT +{ + // Get a span of each type. + typename etl::bitset_ext::const_span_type lhs_span = lhs.span(); + typename etl::bitset::const_span_type rhs_span = rhs.span(); + + // Put the bitset with the largest element type as the first argument. + if ETL_IF_CONSTEXPR(sizeof(TLhsElement) > sizeof(TRhsElement)) + { + return etl::private_bitset::compare_bitset_spans(lhs_span, rhs_span); + } + else + { + return etl::private_bitset::compare_bitset_spans(rhs_span, lhs_span); + } +} + +//*************************************************************************** +/// operator != +/// bitset_ext compared with bitset, different element types. +///\ingroup bitset +//*************************************************************************** +template +ETL_CONSTEXPR14 +typename etl::enable_if::value, bool>::type + operator != (const etl::bitset_ext& lhs, const etl::bitset& rhs) ETL_NOEXCEPT +{ + return !(lhs == rhs); +} #include "minmax_pop.h" diff --git a/test/UnitTest++/Checks.h b/test/UnitTest++/Checks.h index a2571e02..88f1a1c3 100644 --- a/test/UnitTest++/Checks.h +++ b/test/UnitTest++/Checks.h @@ -190,7 +190,9 @@ namespace UnitTest if (!(expected == actual)) { UnitTest::MemoryOutStream stream; - stream << std::hex << std::uppercase << std::setfill('0') << "Expected 0x" << std::setw(2 * sizeof(Expected)) << expected << " but was 0x" << std::setw(2 * sizeof(Actual)) << actual; + stream << std::hex << std::uppercase << std::setfill('0') + << "Expected 0x" << std::setw(2 * sizeof(Expected)) << (expected & ~(typename std::make_unsigned::type(0))) + << " but was 0x" << std::setw(2 * sizeof(Actual)) << (actual & ~(typename std::make_unsigned::type(0))); results.OnTestFailure(details, stream.GetText()); } @@ -214,7 +216,8 @@ namespace UnitTest if (expected == actual) { UnitTest::MemoryOutStream stream; - stream << std::hex << std::uppercase << std::setfill('0') << std::setw(2 * sizeof(Actual)) << "Expected not equal, but both values are " << actual; + stream << std::hex << std::uppercase << std::setfill('0') << std::setw(2 * sizeof(Actual)) + << "Expected not equal, but both values are " << (actual & ~(typename std::make_unsigned::type(0))); results.OnTestFailure(details, stream.GetText()); } diff --git a/test/test_bitset_new_comparisons.cpp b/test/test_bitset_new_comparisons.cpp new file mode 100644 index 00000000..4436982f --- /dev/null +++ b/test/test_bitset_new_comparisons.cpp @@ -0,0 +1,239 @@ +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2022 John Wellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#include "unit_test_framework.h" + +#include "etl/private/bitset_new.h" + +namespace +{ + using ull = unsigned long long; + + SUITE(test_bitset_new_comparisons) + { + //************************************************************************* + TEST(test_equality_single_storage_model) + { + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x0123456789012345ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x0123456789012345ULL); + + etl::bitset_ext<64, uint64_t>::buffer_type buffer3; + etl::bitset_ext<64, uint64_t>::buffer_type buffer4; + etl::bitset_ext<64, uint64_t> data3(0x0123456789012345ULL, buffer3); + etl::bitset_ext<64, uint64_t> data4(0x0123456789012345ULL, buffer4); + + // Double check we are using the single element storage model. + CHECK(etl::bitset_storage_model::Single == data1.Storage_Model); + CHECK(etl::bitset_storage_model::Single == data2.Storage_Model); + CHECK(etl::bitset_storage_model::Single == data3.Storage_Model); + CHECK(etl::bitset_storage_model::Single == data4.Storage_Model); + + CHECK(data1 == data2); // bitset == bitset + CHECK(data1 == data3); // bitset == bitset_ext + CHECK(data3 == data1); // bitset_ext == bitset + CHECK(data3 == data4); // bitset_ext == bitset_ext + } + + //************************************************************************* + TEST(test_inequality_single_storage_model) + { + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x0123456789012345ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x0123456784012345ULL); + + etl::bitset_ext<64, uint64_t>::buffer_type buffer3; + etl::bitset_ext<64, uint64_t>::buffer_type buffer4; + etl::bitset_ext<64, uint64_t> data3(0x0123456787012345ULL, buffer3); + etl::bitset_ext<64, uint64_t> data4(0x0123426789012345ULL, buffer4); + + // Double check we are using the single element storage model. + CHECK(etl::bitset_storage_model::Single == data1.Storage_Model); + CHECK(etl::bitset_storage_model::Single == data2.Storage_Model); + CHECK(etl::bitset_storage_model::Single == data3.Storage_Model); + CHECK(etl::bitset_storage_model::Single == data4.Storage_Model); + + CHECK(data1 != data2); // bitset != bitset + CHECK(data1 != data3); // bitset != bitset_ext + CHECK(data3 != data1); // bitset_ext != bitset + CHECK(data3 != data4); // bitset_ext != bitset_ext + } + + //************************************************************************* + TEST(test_equality_multi_storage_model) + { + ETL_CONSTEXPR14 etl::bitset<64> data1(0x0123456789012345ULL); + ETL_CONSTEXPR14 etl::bitset<64> data2(0x0123456789012345ULL); + + etl::bitset_ext<64>::buffer_type buffer3; + etl::bitset_ext<64>::buffer_type buffer4; + etl::bitset_ext<64> data3(0x0123456789012345ULL, buffer3); + etl::bitset_ext<64> data4(0x0123456789012345ULL, buffer4); + + // Double check we are using the multi element storage model. + CHECK(etl::bitset_storage_model::Multi == data1.Storage_Model); + CHECK(etl::bitset_storage_model::Multi == data2.Storage_Model); + CHECK(etl::bitset_storage_model::Multi == data3.Storage_Model); + CHECK(etl::bitset_storage_model::Multi == data4.Storage_Model); + + CHECK(data1 == data2); // bitset == bitset + CHECK(data1 == data3); // bitset == bitset_ext + CHECK(data3 == data1); // bitset_ext == bitset + CHECK(data3 == data4); // bitset_ext == bitset_ext + } + + //************************************************************************* + TEST(test_inequality_multi_storage_model) + { + ETL_CONSTEXPR14 etl::bitset<64> data1(0x0123456789012345ULL); + ETL_CONSTEXPR14 etl::bitset<64> data2(0x0123456784012345ULL); + + etl::bitset_ext<64>::buffer_type buffer3; + etl::bitset_ext<64>::buffer_type buffer4; + etl::bitset_ext<64> data3(0x0123456787012345ULL, buffer3); + etl::bitset_ext<64> data4(0x0123426789012345ULL, buffer4); + + // Double check we are using the multi element storage model. + CHECK(etl::bitset_storage_model::Multi == data1.Storage_Model); + CHECK(etl::bitset_storage_model::Multi == data2.Storage_Model); + CHECK(etl::bitset_storage_model::Multi == data3.Storage_Model); + CHECK(etl::bitset_storage_model::Multi == data4.Storage_Model); + + CHECK(data1 != data2); // bitset != bitset + CHECK(data1 != data3); // bitset != bitset_ext + CHECK(data3 != data1); // bitset_ext != bitset + CHECK(data3 != data4); // bitset_ext != bitset_ext + } + + //************************************************************************* + TEST(test_equality_mixed_storage_model) + { + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x0123456789012345ULL); + ETL_CONSTEXPR14 etl::bitset<64> data2(0x0123456789012345ULL); + + etl::bitset_ext<64, uint64_t>::buffer_type buffer3; + etl::bitset_ext<64>::buffer_type buffer4; + etl::bitset_ext<64, uint64_t> data3(0x0123456789012345ULL, buffer3); + etl::bitset_ext<64> data4(0x0123456789012345ULL, buffer4); + + // Double check we are using the single/multi element storage model. + CHECK(etl::bitset_storage_model::Single == data1.Storage_Model); + CHECK(etl::bitset_storage_model::Multi == data2.Storage_Model); + CHECK(etl::bitset_storage_model::Single == data3.Storage_Model); + CHECK(etl::bitset_storage_model::Multi == data4.Storage_Model); + + CHECK(data1 == data2); // bitset (S) == bitset (M) + CHECK(data2 == data1); // bitset (M) == bitset (S) + CHECK(data3 == data4); // bitset_ext (S) == bitset_ext (M) + CHECK(data4 == data3); // bitset_ext (M) == bitset_ext (S) + CHECK(data1 == data4); // bitset (S) == bitset_ext (M) + CHECK(data4 == data1); // bitset_ext (M) == bitset (S) + CHECK(data2 == data3); // bitset (M) == bitset_ext (S) + CHECK(data3 == data2); // bitset_ext (S) == bitset (M) + } + + //************************************************************************* + TEST(test_inequality_mixed_storage_model) + { + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x0123456789012345ULL); + ETL_CONSTEXPR14 etl::bitset<64> data2(0x0123456784012345ULL); + + etl::bitset_ext<64, uint64_t>::buffer_type buffer3; + etl::bitset_ext<64>::buffer_type buffer4; + etl::bitset_ext<64, uint64_t> data3(0x0123456787012345ULL, buffer3); + etl::bitset_ext<64> data4(0x0123426789012345ULL, buffer4); + + // Double check we are using the single/multi element storage model. + CHECK(etl::bitset_storage_model::Single == data1.Storage_Model); + CHECK(etl::bitset_storage_model::Multi == data2.Storage_Model); + CHECK(etl::bitset_storage_model::Single == data3.Storage_Model); + CHECK(etl::bitset_storage_model::Multi == data4.Storage_Model); + + CHECK(data1 != data2); // bitset (S) != bitset (M) + CHECK(data2 != data1); // bitset (M) != bitset (S) + CHECK(data3 != data4); // bitset_ext (S) != bitset_ext (M) + CHECK(data4 != data3); // bitset_ext (M) != bitset_ext (S) + CHECK(data1 != data4); // bitset (S) != bitset_ext (M) + CHECK(data4 != data1); // bitset_ext (M) != bitset (S) + CHECK(data2 != data3); // bitset (M) != bitset_ext (S) + CHECK(data3 != data2); // bitset_ext (S) != bitset (M) + } + + //************************************************************************* + TEST(test_equality_mixed_storage_model_different_element_types) + { + ETL_CONSTEXPR14 etl::bitset<64, uint32_t> data1(0x0123456789012345ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint8_t> data2(0x0123456789012345ULL); + + etl::bitset_ext<64, uint32_t>::buffer_type buffer3; + etl::bitset_ext<64, uint8_t>::buffer_type buffer4; + etl::bitset_ext<64, uint32_t> data3(0x0123456789012345ULL, buffer3); + etl::bitset_ext<64, uint8_t> data4(0x0123456789012345ULL, buffer4); + + // Double check we are using the multi element storage model. + CHECK(etl::bitset_storage_model::Multi == data1.Storage_Model); + CHECK(etl::bitset_storage_model::Multi == data2.Storage_Model); + CHECK(etl::bitset_storage_model::Multi == data3.Storage_Model); + CHECK(etl::bitset_storage_model::Multi == data4.Storage_Model); + + CHECK(data1 == data2); // bitset (S) == bitset (M) + CHECK(data2 == data1); // bitset (M) == bitset (S) + CHECK(data3 == data4); // bitset_ext (S) == bitset_ext (M) + CHECK(data4 == data3); // bitset_ext (M) == bitset_ext (S) + CHECK(data1 == data4); // bitset (S) == bitset_ext (M) + CHECK(data4 == data1); // bitset_ext (M) == bitset (S) + CHECK(data2 == data3); // bitset (M) == bitset_ext (S) + CHECK(data3 == data2); // bitset_ext (S) == bitset (M) + } + + //************************************************************************* + TEST(test_inequality_mixed_storage_model_different_element_types) + { + ETL_CONSTEXPR14 etl::bitset<64, uint32_t> data1(0x0123456789012345ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint8_t> data2(0x0123456784012345ULL); + + etl::bitset_ext<64, uint32_t>::buffer_type buffer3; + etl::bitset_ext<64, uint8_t>::buffer_type buffer4; + etl::bitset_ext<64, uint32_t> data3(0x0123456787012345ULL, buffer3); + etl::bitset_ext<64, uint8_t> data4(0x0123426789012345ULL, buffer4); + + // Double check we are using the multi element storage model. + CHECK(etl::bitset_storage_model::Multi == data1.Storage_Model); + CHECK(etl::bitset_storage_model::Multi == data2.Storage_Model); + CHECK(etl::bitset_storage_model::Multi == data3.Storage_Model); + CHECK(etl::bitset_storage_model::Multi == data4.Storage_Model); + + CHECK(data1 != data2); // bitset (S) != bitset (M) + CHECK(data2 != data1); // bitset (M) != bitset (S) + CHECK(data3 != data4); // bitset_ext (S) != bitset_ext (M) + CHECK(data4 != data3); // bitset_ext (M) != bitset_ext (S) + CHECK(data1 != data4); // bitset (S) != bitset_ext (M) + CHECK(data4 != data1); // bitset_ext (M) != bitset (S) + CHECK(data2 != data3); // bitset (M) != bitset_ext (S) + CHECK(data3 != data2); // bitset_ext (S) != bitset (M) + } + }; +} diff --git a/test/test_bitset_new_default_element_type.cpp b/test/test_bitset_new_default_element_type.cpp index 95da4aad..4ca19920 100644 --- a/test/test_bitset_new_default_element_type.cpp +++ b/test/test_bitset_new_default_element_type.cpp @@ -37,6 +37,7 @@ SOFTWARE. #include "etl/wstring.h" #include "etl/u16string.h" #include "etl/u32string.h" +#include "etl/endianness.h" namespace { @@ -46,9 +47,22 @@ namespace template ETL_CONSTEXPR14 etl::bitset generate_shift_left_bitset(ull value, size_t shift) { + ull mask = 0ULL; + + if (shift < 64U) + { + mask = etl::integral_limits::max >> shift; + } + + value &= mask; + etl::bitset data(value); - if (shift != 0U) + if (shift >= 64U) + { + data.reset(); + } + else if (shift != 0U) { data <<= shift; } @@ -63,7 +77,7 @@ namespace etl::bitset data1(value); etl::bitset data2; - if (shift != 0U) + if ((shift != 0U) && (shift != 64U)) { data2 = data1 << shift; } @@ -77,7 +91,11 @@ namespace { etl::bitset data(value); - if (shift != 0U) + if (shift >= 64U) + { + data.reset(); + } + else if (shift != 0U) { data >>= shift; } @@ -102,13 +120,84 @@ 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) { - ETL_CONSTEXPR14 std::bitset<60> compare; - ETL_CONSTEXPR14 etl::bitset<60> data; + ETL_CONSTEXPR14 std::bitset<64> compare; + ETL_CONSTEXPR14 etl::bitset<64> data; - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); for (size_t i = 0UL; i < data.size(); ++i) @@ -118,715 +207,41 @@ namespace } //************************************************************************* - TEST(test_default_constructor_multi_element) + TEST(test_default_constructor_single_element) { - etl::bitset<14, int8_t> data8; - etl::bitset<30, int16_t> data16; - etl::bitset<62, int32_t> data32; + etl::bitset<8> data8; + etl::bitset<16> data16; + etl::bitset<32> data32; + etl::bitset<64> data64; - CHECK_EQUAL(2U, data8.Number_Of_Elements); - CHECK_EQUAL(2U, data16.Number_Of_Elements); - CHECK_EQUAL(2U, data32.Number_Of_Elements); - } + using element_type = etl::bitset<8>::element_type; + size_t element_bits = etl::integral_limits::bits; - //************************************************************************* - TEST(test_default_constructor_default_element_type_bits) - { - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - } - - //************************************************************************* - TEST(test_default_constructor_default_element_type_number_of_elements) - { - CHECK_EQUAL(1U, etl::bitset<1>::Number_Of_Elements); - CHECK_EQUAL(1U, etl::bitset<2>::Number_Of_Elements); - CHECK_EQUAL(1U, etl::bitset<3>::Number_Of_Elements); - CHECK_EQUAL(1U, etl::bitset<4>::Number_Of_Elements); - CHECK_EQUAL(1U, etl::bitset<5>::Number_Of_Elements); - CHECK_EQUAL(1U, etl::bitset<6>::Number_Of_Elements); - CHECK_EQUAL(1U, etl::bitset<7>::Number_Of_Elements); - CHECK_EQUAL(1U, etl::bitset<8>::Number_Of_Elements); - CHECK_EQUAL(2U, etl::bitset<9>::Number_Of_Elements); - CHECK_EQUAL(2U, etl::bitset<10>::Number_Of_Elements); - CHECK_EQUAL(2U, etl::bitset<11>::Number_Of_Elements); - CHECK_EQUAL(2U, etl::bitset<12>::Number_Of_Elements); - CHECK_EQUAL(2U, etl::bitset<13>::Number_Of_Elements); - CHECK_EQUAL(2U, etl::bitset<14>::Number_Of_Elements); - CHECK_EQUAL(2U, etl::bitset<15>::Number_Of_Elements); - CHECK_EQUAL(2U, etl::bitset<16>::Number_Of_Elements); - CHECK_EQUAL(3U, etl::bitset<17>::Number_Of_Elements); - CHECK_EQUAL(3U, etl::bitset<18>::Number_Of_Elements); - CHECK_EQUAL(3U, etl::bitset<19>::Number_Of_Elements); - CHECK_EQUAL(3U, etl::bitset<20>::Number_Of_Elements); - CHECK_EQUAL(3U, etl::bitset<21>::Number_Of_Elements); - CHECK_EQUAL(3U, etl::bitset<22>::Number_Of_Elements); - CHECK_EQUAL(3U, etl::bitset<23>::Number_Of_Elements); - CHECK_EQUAL(3U, etl::bitset<24>::Number_Of_Elements); - CHECK_EQUAL(4U, etl::bitset<25>::Number_Of_Elements); - CHECK_EQUAL(4U, etl::bitset<26>::Number_Of_Elements); - CHECK_EQUAL(4U, etl::bitset<27>::Number_Of_Elements); - CHECK_EQUAL(4U, etl::bitset<28>::Number_Of_Elements); - CHECK_EQUAL(4U, etl::bitset<29>::Number_Of_Elements); - CHECK_EQUAL(4U, etl::bitset<30>::Number_Of_Elements); - CHECK_EQUAL(4U, etl::bitset<31>::Number_Of_Elements); - CHECK_EQUAL(4U, etl::bitset<32>::Number_Of_Elements); - CHECK_EQUAL(5U, etl::bitset<33>::Number_Of_Elements); - CHECK_EQUAL(5U, etl::bitset<34>::Number_Of_Elements); - CHECK_EQUAL(5U, etl::bitset<35>::Number_Of_Elements); - CHECK_EQUAL(5U, etl::bitset<36>::Number_Of_Elements); - CHECK_EQUAL(5U, etl::bitset<37>::Number_Of_Elements); - CHECK_EQUAL(5U, etl::bitset<38>::Number_Of_Elements); - CHECK_EQUAL(5U, etl::bitset<39>::Number_Of_Elements); - CHECK_EQUAL(5U, etl::bitset<40>::Number_Of_Elements); - CHECK_EQUAL(6U, etl::bitset<41>::Number_Of_Elements); - CHECK_EQUAL(6U, etl::bitset<42>::Number_Of_Elements); - CHECK_EQUAL(6U, etl::bitset<43>::Number_Of_Elements); - CHECK_EQUAL(6U, etl::bitset<44>::Number_Of_Elements); - CHECK_EQUAL(6U, etl::bitset<45>::Number_Of_Elements); - CHECK_EQUAL(6U, etl::bitset<46>::Number_Of_Elements); - CHECK_EQUAL(6U, etl::bitset<47>::Number_Of_Elements); - CHECK_EQUAL(6U, etl::bitset<48>::Number_Of_Elements); - CHECK_EQUAL(7U, etl::bitset<49>::Number_Of_Elements); - CHECK_EQUAL(7U, etl::bitset<50>::Number_Of_Elements); - CHECK_EQUAL(7U, etl::bitset<51>::Number_Of_Elements); - CHECK_EQUAL(7U, etl::bitset<52>::Number_Of_Elements); - CHECK_EQUAL(7U, etl::bitset<53>::Number_Of_Elements); - CHECK_EQUAL(7U, etl::bitset<54>::Number_Of_Elements); - CHECK_EQUAL(7U, etl::bitset<55>::Number_Of_Elements); - CHECK_EQUAL(7U, etl::bitset<56>::Number_Of_Elements); - CHECK_EQUAL(8U, etl::bitset<57>::Number_Of_Elements); - CHECK_EQUAL(8U, etl::bitset<58>::Number_Of_Elements); - CHECK_EQUAL(8U, etl::bitset<59>::Number_Of_Elements); - CHECK_EQUAL(8U, etl::bitset<60>::Number_Of_Elements); - CHECK_EQUAL(8U, etl::bitset<61>::Number_Of_Elements); - CHECK_EQUAL(8U, etl::bitset<62>::Number_Of_Elements); - CHECK_EQUAL(8U, etl::bitset<63>::Number_Of_Elements); - CHECK_EQUAL(8U, etl::bitset<64>::Number_Of_Elements); - } + CHECK_EQUAL(8, data8.Size); + CHECK_EQUAL(16, data16.Size); + CHECK_EQUAL(32, data32.Size); + CHECK_EQUAL(64, data64.Size); - //************************************************************************* - TEST(test_default_constructor_explicit_int8_t_element_types_bits) - { - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - } + CHECK_EQUAL( 8 / element_bits, data8.Number_Of_Elements); + CHECK_EQUAL(16 / element_bits, data16.Number_Of_Elements); + CHECK_EQUAL(32 / element_bits, data32.Number_Of_Elements); + CHECK_EQUAL(64 / element_bits, data64.Number_Of_Elements); - //************************************************************************* - TEST(test_default_constructor_explicit_int8_t_element_types_number_of_elements) - { - CHECK_EQUAL(1U, (etl::bitset<1, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<2, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<3, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<4, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<5, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<6, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<7, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<8, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<9, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<10, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<11, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<12, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<13, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<14, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<15, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<16, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<17, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<18, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<19, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<20, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<21, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<22, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<23, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<24, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<25, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<26, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<27, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<28, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<29, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<30, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<31, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<32, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(5U, (etl::bitset<33, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(5U, (etl::bitset<34, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(5U, (etl::bitset<35, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(5U, (etl::bitset<36, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(5U, (etl::bitset<37, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(5U, (etl::bitset<38, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(5U, (etl::bitset<39, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(5U, (etl::bitset<40, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(6U, (etl::bitset<41, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(6U, (etl::bitset<42, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(6U, (etl::bitset<43, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(6U, (etl::bitset<44, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(6U, (etl::bitset<45, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(6U, (etl::bitset<46, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(6U, (etl::bitset<47, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(6U, (etl::bitset<48, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(7U, (etl::bitset<49, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(7U, (etl::bitset<50, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(7U, (etl::bitset<51, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(7U, (etl::bitset<52, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(7U, (etl::bitset<53, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(7U, (etl::bitset<54, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(7U, (etl::bitset<55, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(7U, (etl::bitset<56, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(8U, (etl::bitset<57, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(8U, (etl::bitset<58, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(8U, (etl::bitset<59, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(8U, (etl::bitset<60, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(8U, (etl::bitset<61, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(8U, (etl::bitset<62, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(8U, (etl::bitset<63, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(8U, (etl::bitset<64, int8_t>::Number_Of_Elements)); - } - - //************************************************************************* - TEST(test_default_constructor_explicit_int16_t_element_types_bits) - { - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - } - - //************************************************************************* - TEST(test_default_constructor_explicit_int16_t_element_types_number_of_elements) - { - CHECK_EQUAL(1U, (etl::bitset<1, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<2, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<3, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<4, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<5, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<6, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<7, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<8, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<9, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<10, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<11, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<12, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<13, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<14, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<15, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<16, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<17, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<18, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<19, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<20, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<21, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<22, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<23, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<24, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<25, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<26, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<27, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<28, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<29, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<30, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<31, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<32, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<33, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<34, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<35, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<36, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<37, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<38, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<39, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<40, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<41, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<42, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<43, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<44, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<45, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<46, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<47, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset<48, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<49, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<50, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<51, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<52, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<53, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<54, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<55, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<56, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<57, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<58, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<59, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<60, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<61, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<62, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<63, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset<64, int16_t>::Number_Of_Elements)); - } - - //************************************************************************* - TEST(test_default_constructor_explicit_int32_t_element_types_bits) - { - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - } - - //************************************************************************* - TEST(test_default_constructor_explicit_int32_t_element_types_number_of_elements) - { - CHECK_EQUAL(1U, (etl::bitset<1, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<2, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<3, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<4, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<5, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<6, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<7, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<8, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<9, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<10, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<11, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<12, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<13, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<14, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<15, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<16, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<17, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<18, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<19, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<20, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<21, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<22, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<23, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<24, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<25, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<26, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<27, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<28, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<29, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<30, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<31, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<32, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<33, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<34, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<35, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<36, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<37, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<38, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<39, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<40, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<41, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<42, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<43, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<44, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<45, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<46, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<47, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<48, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<49, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<50, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<51, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<52, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<53, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<54, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<55, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<56, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<57, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<58, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<59, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<60, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<61, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<62, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<63, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset<64, int32_t>::Number_Of_Elements)); - } - - //************************************************************************* - TEST(test_default_constructor_explicit_int64_t_element_types_bits) - { - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - } - - //************************************************************************* - TEST(test_default_constructor_explicit_int64_t_element_types_number_of_elements) - { - CHECK_EQUAL(1U, (etl::bitset<1, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<2, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<3, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<4, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<5, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<6, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<7, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<8, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<9, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<10, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<11, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<12, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<13, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<14, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<15, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<16, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<17, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<18, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<19, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<20, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<21, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<22, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<23, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<24, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<25, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<26, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<27, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<28, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<29, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<30, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<31, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<32, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<33, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<34, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<35, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<36, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<37, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<38, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<39, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<40, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<41, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<42, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<43, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<44, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<45, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<46, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<47, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<48, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<49, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<50, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<51, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<52, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<53, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<54, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<55, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<56, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<57, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<58, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<59, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<60, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<61, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<62, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<63, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset<64, int64_t>::Number_Of_Elements)); + CHECK_EQUAL(etl::bitset_storage_model::Single, data8.Storage_Model); + CHECK_EQUAL(etl::bitset_storage_model::Multi, data16.Storage_Model); + CHECK_EQUAL(etl::bitset_storage_model::Multi, data32.Storage_Model); + CHECK_EQUAL(etl::bitset_storage_model::Multi, data64.Storage_Model); } //************************************************************************* TEST(test_construct_from_value) { - ETL_CONSTEXPR14 std::bitset<60> compare(0x123456731234567ULL); - ETL_CONSTEXPR14 etl::bitset<60> data(0x123456731234567ULL); + ETL_CONSTEXPR14 std::bitset<64> compare(0x123456731234567ULL); + ETL_CONSTEXPR14 etl::bitset<64> data(0x123456731234567ULL); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); + CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -837,9 +252,9 @@ namespace //************************************************************************* TEST(test_copy_construct) { - ETL_CONSTEXPR14 std::bitset<60> compare(0x123456731234567ULL); - ETL_CONSTEXPR14 etl::bitset<60> data(0x123456731234567ULL); - ETL_CONSTEXPR14 etl::bitset<60> data_copy(data); + ETL_CONSTEXPR14 std::bitset<64> compare(0x123456731234567ULL); + ETL_CONSTEXPR14 etl::bitset<64> data(0x123456731234567ULL); + ETL_CONSTEXPR14 etl::bitset<64> data_copy(data); CHECK_EQUAL(compare.size(), data_copy.size()); CHECK_EQUAL(compare.count(), data_copy.count()); @@ -853,10 +268,10 @@ namespace //************************************************************************* TEST(test_construct_from_excess_value) { - ETL_CONSTEXPR14 std::bitset<60> compare(0x8765432187654321ULL); - ETL_CONSTEXPR14 etl::bitset<60> data(0x8765432187654321ULL); + ETL_CONSTEXPR14 std::bitset<64> compare(0x8765432187654321ULL); + ETL_CONSTEXPR14 etl::bitset<64> data(0x8765432187654321ULL); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); for (size_t i = 0UL; i < data.size(); ++i) @@ -868,10 +283,10 @@ namespace //************************************************************************* TEST(test_construct_from_char_string) { - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data("110001001000110100010101100111001100010010001101000101011001"); + std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64> data("110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); for (size_t i = 0UL; i < data.size(); ++i) @@ -883,8 +298,8 @@ namespace //************************************************************************* TEST(test_construct_from_wchar_t_string) { - std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data(L"110001001000110100010101100111001100010010001101000101011001"); + std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64> data(L"110001001000110100010101100111001100010010001101000101011001"); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -898,8 +313,8 @@ namespace //************************************************************************* TEST(test_construct_from_char16_t_string) { - std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data(u"110001001000110100010101100111001100010010001101000101011001"); + std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64> data(u"110001001000110100010101100111001100010010001101000101011001"); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -913,8 +328,8 @@ namespace //************************************************************************* TEST(test_construct_from_char32_t_string) { - std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data(U"110001001000110100010101100111001100010010001101000101011001"); + std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64> data(U"110001001000110100010101100111001100010010001101000101011001"); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -947,7 +362,6 @@ namespace CHECK_EQUAL(0, data.count()); } - //************************************************************************* TEST(test_construct_from_nullptr_char16_t_string) { @@ -973,8 +387,8 @@ namespace //************************************************************************* TEST(test_construct_from_excess_string) { - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001111100001"); - etl::bitset<60> data("110001001000110100010101100111001100010010001101000101011001111100001"); + std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001111100001"); + etl::bitset<64> data("110001001000110100010101100111001100010010001101000101011001111100001"); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -982,6 +396,8 @@ namespace CHECK_EQUAL(compare.any(), data.any()); CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong()); + for (size_t i = 0UL; i < data.size(); ++i) { CHECK_EQUAL(compare.test(i), data.test(i)); @@ -989,7 +405,41 @@ namespace } //************************************************************************* + ETL_CONSTEXPR14 etl::bitset<64> test_set_helper() + { + etl::bitset<64> data; + data.set(); + + return data; + } + TEST(test_set) + { + std::bitset<64> compare; + ETL_CONSTEXPR14 etl::bitset<64> data(test_set_helper()); + + compare.set(); + + 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_less_than_full_size) { std::bitset<60> compare; etl::bitset<60> data; @@ -997,11 +447,292 @@ namespace compare.set(); data.set(); - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + 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)); + } + } + + //************************************************************************* + 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) { @@ -1012,8 +743,8 @@ namespace //************************************************************************* TEST(test_set_with_char_string) { - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data; + std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64> data; data.set("110001001000110100010101100111001100010010001101000101011001"); @@ -1032,16 +763,16 @@ namespace //************************************************************************* TEST(test_set_with_wchar_t_string) { - std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data; + std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64> data; data.set(L"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -1052,16 +783,16 @@ namespace //************************************************************************* TEST(test_set_with_char16_t_string) { - std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data; + std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64> data; data.set(u"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -1072,16 +803,16 @@ namespace //************************************************************************* TEST(test_set_with_char32_t_string) { - std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data; + std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64> data; data.set(U"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -1140,8 +871,8 @@ namespace //************************************************************************* TEST(test_from_string_with_char) { - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data; + std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64> data; data.from_string("110001001000110100010101100111001100010010001101000101011001"); @@ -1160,8 +891,8 @@ namespace //************************************************************************* TEST(test_from_string_with_wchar_t) { - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data; + std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64> data; data.from_string(L"110001001000110100010101100111001100010010001101000101011001"); @@ -1178,10 +909,10 @@ namespace } //************************************************************************* - TEST(test_from_char16_t_6string) + TEST(test_from_string_with_char16_t) { - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data; + std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64> data; data.from_string(u"110001001000110100010101100111001100010010001101000101011001"); @@ -1200,8 +931,8 @@ namespace //************************************************************************* TEST(test_from_string_with_char32_t) { - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data; + std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64> data; data.from_string(U"110001001000110100010101100111001100010010001101000101011001"); @@ -1265,6 +996,42 @@ namespace CHECK_EQUAL(0, data.count()); } + //************************************************************************* + TEST(test_value_u8_min) + { + ETL_CONSTEXPR14 etl::bitset<8> data((unsigned long long)etl::integral_limits::min); + ETL_CONSTEXPR14 uint8_t value = data.value(); + + CHECK_EQUAL(std::numeric_limits::min(), value); + } + + //************************************************************************* + TEST(test_value_u8_max) + { + ETL_CONSTEXPR14 etl::bitset<8> data((unsigned long long)etl::integral_limits::max); + ETL_CONSTEXPR14 uint8_t value = data.value(); + + CHECK_EQUAL(std::numeric_limits::max(), value); + } + + //************************************************************************* + TEST(test_value_s8_min) + { + ETL_CONSTEXPR14 etl::bitset<8> data((unsigned long long)etl::integral_limits::min); + ETL_CONSTEXPR14 int8_t value = data.value(); + + CHECK_EQUAL(std::numeric_limits::min(), value); + } + + //************************************************************************* + TEST(test_value_s8_max) + { + ETL_CONSTEXPR14 etl::bitset<8> data((unsigned long long)etl::integral_limits::max); + ETL_CONSTEXPR14 int8_t value = data.value(); + + CHECK_EQUAL(std::numeric_limits::max(), value); + } + //************************************************************************* TEST(test_value_u16_min) { @@ -1304,19 +1071,19 @@ namespace //************************************************************************* TEST(test_value_u32_min) { - ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits::min); - ETL_CONSTEXPR14 uint32_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits::min); + ETL_CONSTEXPR14 int32_t value = data.value(); - CHECK_EQUAL(std::numeric_limits::min(), value); + CHECK_EQUAL(std::numeric_limits::min(), value); } //************************************************************************* TEST(test_value_u32_max) { - ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits::max); - ETL_CONSTEXPR14 uint32_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<32> data((unsigned long long)etl::integral_limits::max); + ETL_CONSTEXPR14 int32_t value = data.value(); - CHECK_EQUAL(std::numeric_limits::max(), value); + CHECK_EQUAL(std::numeric_limits::max(), value); } //************************************************************************* @@ -1340,26 +1107,26 @@ namespace //************************************************************************* TEST(test_value_u64_min) { - ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::min); - ETL_CONSTEXPR14 uint64_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::min); + ETL_CONSTEXPR14 uint64_t value = data.value(); - CHECK_EQUAL(std::numeric_limits::min(), value); + CHECK_EQUAL(std::numeric_limits::min(), value); } //************************************************************************* TEST(test_value_u64_max) { - ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::max); - ETL_CONSTEXPR14 uint64_t value = data.value(); + ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::max); + ETL_CONSTEXPR14 uint64_t value = data.value(); - CHECK_EQUAL(std::numeric_limits::max(), value); + CHECK_EQUAL(std::numeric_limits::max(), value); } //************************************************************************* TEST(test_value_s64_min) { ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::min); - ETL_CONSTEXPR14 int64_t value = data.value(); + ETL_CONSTEXPR14 uint64_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -1368,7 +1135,7 @@ namespace TEST(test_value_s64_max) { ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::max); - ETL_CONSTEXPR14 int64_t value = data.value(); + ETL_CONSTEXPR14 uint64_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -1376,8 +1143,8 @@ namespace //************************************************************************* TEST(test_position_set) { - std::bitset<60> compare; - etl::bitset<60> data; + std::bitset<64> compare; + etl::bitset<64> data; for (size_t i = 0UL; i < data.size(); ++i) { @@ -1406,13 +1173,20 @@ namespace } //************************************************************************* + ETL_CONSTEXPR14 etl::bitset<64> test_reset_helper() + { + etl::bitset<64> data(0xFFFFFFFFFFFFFFFULL); + data.reset(); + + return data; + } + TEST(test_reset) { - std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL); - etl::bitset<60> data(0xFFFFFFFFFFFFFFFULL); + std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); + ETL_CONSTEXPR14 etl::bitset<64> data(test_reset_helper()); compare.reset(); - data.reset(); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -1427,21 +1201,27 @@ namespace } //************************************************************************* + ETL_CONSTEXPR14 etl::bitset<64> test_position_reset_helper() + { + etl::bitset<64> data(0xFFFFFFFFFFFFFFFULL); + data.reset(1); + data.reset(3); + data.reset(7); + data.reset(13); + + return data; + } + TEST(test_position_reset) { - std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL); - etl::bitset<60> data(0xFFFFFFFFFFFFFFFULL); + std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); + ETL_CONSTEXPR14 etl::bitset<64> data(test_position_reset_helper()); compare.reset(1); compare.reset(3); compare.reset(7); compare.reset(13); - data.reset(1); - data.reset(3); - data.reset(7); - data.reset(13); - CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); CHECK_EQUAL(compare.none(), data.none()); @@ -1481,8 +1261,8 @@ namespace //************************************************************************* TEST(test_index_operator_read) { - ETL_CONSTEXPR14 std::bitset<60> compare(0x3123456731234567ULL); - ETL_CONSTEXPR14 etl::bitset<60> data(0x3123456731234567ULL); + ETL_CONSTEXPR14 std::bitset<64> compare(0x3123456731234567ULL); + ETL_CONSTEXPR14 etl::bitset<64> data(0x3123456731234567ULL); ETL_CONSTEXPR14 bool bc0 = compare[1U]; ETL_CONSTEXPR14 bool bd0 = data[1U]; @@ -1502,15 +1282,22 @@ namespace } //************************************************************************* - TEST(test_index_operator_write) + ETL_CONSTEXPR14 etl::bitset<64> test_index_operator_write_helper() { - etl::bitset<60> data; + etl::bitset<64> data; data[1U] = true; data[3U] = true; data[7U] = true; data[13U] = true; + return data; + } + + TEST(test_index_operator_write) + { + ETL_CONSTEXPR14 etl::bitset<64> data(test_index_operator_write_helper()); + CHECK(data[1U]); CHECK(data[3U]); CHECK(data[7U]); @@ -1520,10 +1307,10 @@ namespace //************************************************************************* TEST(test_any) { - ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000)); - ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000)); - ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x0000010001000100)); - ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64> data4(ull(0xFFFFFFFFFFFFFFFF)); ETL_CONSTEXPR14 bool bd1 = data1.any(); ETL_CONSTEXPR14 bool bd2 = data2.any(); @@ -1539,10 +1326,10 @@ namespace //************************************************************************* TEST(test_none) { - ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000)); - ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000)); - ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x0000010001000100)); - ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64> data4(ull(0xFFFFFFFFFFFFFFFF)); ETL_CONSTEXPR14 bool bd1 = data1.none(); ETL_CONSTEXPR14 bool bd2 = data2.none(); @@ -1558,10 +1345,10 @@ namespace //************************************************************************* TEST(test_all) { - ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000)); - ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000)); - ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x0000010001000100)); - ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64> data4(ull(0xFFFFFFFFFFFFFFFF)); ETL_CONSTEXPR14 bool bd1 = data1.all(); ETL_CONSTEXPR14 bool bd2 = data2.all(); @@ -1575,13 +1362,77 @@ namespace } //************************************************************************* + TEST(test_any_with_reduced_active_bits) + { + ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0xFFFFFFFFFFFFFFFF)); + + ETL_CONSTEXPR14 bool bd1 = data1.any(); + ETL_CONSTEXPR14 bool bd2 = data2.any(); + ETL_CONSTEXPR14 bool bd3 = data3.any(); + ETL_CONSTEXPR14 bool bd4 = data4.any(); + + CHECK_FALSE(bd1); + CHECK_TRUE(bd2); + CHECK_TRUE(bd3); + CHECK_TRUE(bd4); + } + + //************************************************************************* + TEST(test_none_with_reduced_active_bits) + { + ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0xFFFFFFFFFFFFFFFF)); + + ETL_CONSTEXPR14 bool bd1 = data1.none(); + ETL_CONSTEXPR14 bool bd2 = data2.none(); + ETL_CONSTEXPR14 bool bd3 = data3.none(); + ETL_CONSTEXPR14 bool bd4 = data4.none(); + + CHECK_TRUE(bd1); + CHECK_FALSE(bd2); + CHECK_FALSE(bd3); + CHECK_FALSE(bd4); + } + + //************************************************************************* + TEST(test_all_with_reduced_active_bits) + { + ETL_CONSTEXPR14 etl::bitset<60> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<60> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<60> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<60> data4(ull(0xFFFFFFFFFFFFFFFF)); + + ETL_CONSTEXPR14 bool bd1 = data1.all(); + ETL_CONSTEXPR14 bool bd2 = data2.all(); + ETL_CONSTEXPR14 bool bd3 = data3.all(); + ETL_CONSTEXPR14 bool bd4 = data4.all(); + + CHECK_FALSE(bd1); + CHECK_FALSE(bd2); + CHECK_FALSE(bd3); + CHECK_TRUE(bd4); + } + + //************************************************************************* + ETL_CONSTEXPR14 etl::bitset<64> test_flip_helper() + { + etl::bitset<64> data; + data.flip(); + + return data; + } + TEST(test_flip) { - std::bitset<60> compare; - etl::bitset<60> data; + std::bitset<64> compare; + ETL_CONSTEXPR14 etl::bitset<64> data(test_flip_helper()); compare.flip(); - data.flip(); for (size_t i = 0UL; i < data.size(); ++i) { @@ -1590,21 +1441,27 @@ namespace } //************************************************************************* + ETL_CONSTEXPR14 etl::bitset<64> test_flip_position_helper() + { + etl::bitset<64> data; + data.flip(1); + data.flip(3); + data.flip(7); + data.flip(13); + + return data; + } + TEST(test_flip_position) { - std::bitset<60> compare; - etl::bitset<60> data; + std::bitset<64> compare; + ETL_CONSTEXPR14 etl::bitset<64> data(test_flip_position_helper()); compare.flip(1); compare.flip(3); compare.flip(7); compare.flip(13); - data.flip(1); - data.flip(3); - data.flip(7); - data.flip(13); - for (size_t i = 0UL; i < data.size(); ++i) { CHECK_EQUAL(compare.test(i), data.test(i)); @@ -1612,21 +1469,27 @@ namespace } //************************************************************************* + ETL_CONSTEXPR14 etl::bitset<64> test_flip_reference_helper() + { + etl::bitset<64> data; + data[1].flip(); + data[3].flip(); + data[7].flip(); + data[13].flip(); + + return data; + } + TEST(test_flip_reference) { - std::bitset<60> compare; - etl::bitset<60> data; + std::bitset<64> compare; + ETL_CONSTEXPR14 etl::bitset<64> data(test_flip_reference_helper()); compare[1].flip(); compare[3].flip(); compare[7].flip(); compare[13].flip(); - data[1].flip(); - data[3].flip(); - data[7].flip(); - data[13].flip(); - for (size_t i = 0UL; i < data.size(); ++i) { CHECK_EQUAL(compare.test(i), data.test(i)); @@ -1636,8 +1499,8 @@ namespace //************************************************************************* TEST(test_invert_reference) { - std::bitset<60> compare; - etl::bitset<60> data; + std::bitset<64> compare; + etl::bitset<64> data; bool bc = ~compare[3]; bool bd = ~data[3]; @@ -1645,18 +1508,18 @@ namespace } //************************************************************************* - void test_assignment_operator_helper(etl::bitset<60>& from, etl::bitset<60>& to) + ETL_CONSTEXPR14 etl::bitset<64> test_assignment_operator_helper(etl::bitset<64> to, const etl::bitset<64>&from) { to = from; + + return to; } TEST(test_assignment_operator) { - std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL); - etl::bitset<60> data1(0xFFFFFFFFFFFFFFFULL); - etl::bitset<60> data2; - - test_assignment_operator_helper(data1, data2); + ETL_CONSTEXPR14 std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); + ETL_CONSTEXPR14 etl::bitset<64> data1(0xFFFFFFFFFFFFFFFULL); + ETL_CONSTEXPR14 etl::bitset<64> data2(test_assignment_operator_helper(etl::bitset<64>(), data1)); for (size_t i = 0UL; i < data2.size(); ++i) { @@ -1667,11 +1530,11 @@ namespace //************************************************************************* TEST(test_equality_operator) { - ETL_CONSTEXPR14 etl::bitset<60> data1(0x123456781234567ULL); - ETL_CONSTEXPR14 etl::bitset<60> data2(0x123456781234567ULL); - ETL_CONSTEXPR14 etl::bitset<60> data3; + ETL_CONSTEXPR14 etl::bitset<64> data1(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<64> data2(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<64> data3; - ETL_CONSTEXPR14 bool equal = (data1 == data2); + ETL_CONSTEXPR14 bool equal = (data1 == data2); ETL_CONSTEXPR14 bool not_equal = !(data1 == data3); CHECK(equal); @@ -1681,9 +1544,9 @@ namespace //************************************************************************* TEST(test_inequality_operator) { - ETL_CONSTEXPR14 etl::bitset<60> data1(0x123456781234567ULL); - ETL_CONSTEXPR14 etl::bitset<60> data2(0x123456781234567ULL); - ETL_CONSTEXPR14 etl::bitset<60> data3; + ETL_CONSTEXPR14 etl::bitset<64> data1(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<64> data2(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<64> data3; ETL_CONSTEXPR14 bool equal = !(data1 != data2); ETL_CONSTEXPR14 bool not_equal = (data1 != data3); @@ -1695,139 +1558,138 @@ namespace //************************************************************************* TEST(test_shift_left_operator) { - ETL_CONSTEXPR14 etl::bitset<60> shift1(0x2468ACF0ULL); - ETL_CONSTEXPR14 etl::bitset<60> shift2(0x48D159E0ULL); - ETL_CONSTEXPR14 etl::bitset<60> shift11(0x91A2B3C000ULL); + ETL_CONSTEXPR14 etl::bitset<64> shift1(0x2468ACF0ULL); + ETL_CONSTEXPR14 etl::bitset<64> shift2(0x48D159E0ULL); + ETL_CONSTEXPR14 etl::bitset<64> shift11(0x91A2B3C000ULL); - CHECK(generate_shift_left_bitset<60>(0x12345678ULL, 1U) == shift1); - CHECK(generate_shift_left_bitset<60>(0x12345678ULL, 2U) == shift2); - CHECK(generate_shift_left_bitset<60>(0x12345678ULL, 11U) == shift11); + CHECK((generate_shift_left_bitset<64>(0x12345678ULL, 1U)) == shift1); + CHECK((generate_shift_left_bitset<64>(0x12345678ULL, 2U)) == shift2); + CHECK((generate_shift_left_bitset<64>(0x12345678ULL, 11U)) == shift11); } //************************************************************************* TEST(test_shift_left_operator_overflow) { - ETL_CONSTEXPR14 etl::bitset<31> data(generate_shift_left_bitset<31>(0x7FFFFFFFULL, 1U)); - ETL_CONSTEXPR14 etl::bitset<31> shifted(0x7FFFFFFEUL); + ETL_CONSTEXPR14 etl::bitset<32> data(generate_shift_left_bitset<32>(0x7FFFFFFFULL, 1U)); + ETL_CONSTEXPR14 etl::bitset<32> shifted(0xFFFFFFFEUL); - CHECK(data == shifted); + CHECK_EQUAL_HEX(shifted.value(), data.value()); } //************************************************************************* TEST(test_shift_left_copy_operator) { - ETL_CONSTEXPR14 etl::bitset<60> shift8(0x1234567800ULL); - CHECK_EQUAL_HEX(shift8.value(), generate_shift_left_bitset_copy<60>(0x12345678UL, 8U).value()); + ETL_CONSTEXPR14 etl::bitset<64> shift8(0x1234567800ULL); + CHECK_EQUAL_HEX(shift8.value(), (generate_shift_left_bitset_copy<64>(0x12345678UL, 8U).value())); - ETL_CONSTEXPR14 etl::bitset<60> shift16(0x123456780000ULL); - CHECK_EQUAL_HEX(shift16.value(), generate_shift_left_bitset_copy<60>(0x12345678UL, 16U).value()); + ETL_CONSTEXPR14 etl::bitset<64> shift16(0x123456780000ULL); + CHECK_EQUAL_HEX(shift16.value(), (generate_shift_left_bitset_copy<64>(0x12345678UL, 16U).value())); - ETL_CONSTEXPR14 etl::bitset<60> shift24(0x12345678000000ULL); - CHECK_EQUAL_HEX(shift24.value(), generate_shift_left_bitset_copy<60>(0x12345678UL, 24U).value()); + ETL_CONSTEXPR14 etl::bitset<64> shift24(0x12345678000000ULL); + CHECK_EQUAL_HEX(shift24.value(), (generate_shift_left_bitset_copy<64>(0x12345678UL, 24U).value())); - ETL_CONSTEXPR14 etl::bitset<60> shift60(0x0000000000000000ULL); - CHECK_EQUAL_HEX(shift60.value(), generate_shift_left_bitset_copy<60>(0x12345678UL, 60U).value()); + ETL_CONSTEXPR14 etl::bitset<64> shift64(0x0000000000000000ULL); + CHECK_EQUAL_HEX(shift64.value(), (generate_shift_left_bitset_copy<64>(0x12345678UL, 64U).value())); } //************************************************************************* - TEST(test_shift_left_operator_all_shifts_partial_size) + TEST(test_shift_left_operator_all_shifts_full_size) { uint64_t value = 0x0123456789ABCDEFULL; - uint64_t mask = 0x0FFFFFFFFFFFFFFFULL; - CHECK_EQUAL_HEX((value << 0U) & mask, (generate_shift_left_bitset<60>(value, 0U).value())); - CHECK_EQUAL_HEX((value << 1U) & mask, (generate_shift_left_bitset<60>(value, 1U).value())); - CHECK_EQUAL_HEX((value << 2U) & mask, (generate_shift_left_bitset<60>(value, 2U).value())); - CHECK_EQUAL_HEX((value << 3U) & mask, (generate_shift_left_bitset<60>(value, 3U).value())); - CHECK_EQUAL_HEX((value << 4U) & mask, (generate_shift_left_bitset<60>(value, 4U).value())); - CHECK_EQUAL_HEX((value << 5U) & mask, (generate_shift_left_bitset<60>(value, 5U).value())); - CHECK_EQUAL_HEX((value << 6U) & mask, (generate_shift_left_bitset<60>(value, 6U).value())); - CHECK_EQUAL_HEX((value << 7U) & mask, (generate_shift_left_bitset<60>(value, 7U).value())); - CHECK_EQUAL_HEX((value << 8U) & mask, (generate_shift_left_bitset<60>(value, 8U).value())); - CHECK_EQUAL_HEX((value << 9U) & mask, (generate_shift_left_bitset<60>(value, 9U).value())); - CHECK_EQUAL_HEX((value << 10U) & mask, (generate_shift_left_bitset<60>(value, 10U).value())); - CHECK_EQUAL_HEX((value << 11U) & mask, (generate_shift_left_bitset<60>(value, 11U).value())); - CHECK_EQUAL_HEX((value << 12U) & mask, (generate_shift_left_bitset<60>(value, 12U).value())); - CHECK_EQUAL_HEX((value << 13U) & mask, (generate_shift_left_bitset<60>(value, 13U).value())); - CHECK_EQUAL_HEX((value << 14U) & mask, (generate_shift_left_bitset<60>(value, 14U).value())); - CHECK_EQUAL_HEX((value << 15U) & mask, (generate_shift_left_bitset<60>(value, 15U).value())); - CHECK_EQUAL_HEX((value << 16U) & mask, (generate_shift_left_bitset<60>(value, 16U).value())); - CHECK_EQUAL_HEX((value << 17U) & mask, (generate_shift_left_bitset<60>(value, 17U).value())); - CHECK_EQUAL_HEX((value << 18U) & mask, (generate_shift_left_bitset<60>(value, 18U).value())); - CHECK_EQUAL_HEX((value << 19U) & mask, (generate_shift_left_bitset<60>(value, 19U).value())); - CHECK_EQUAL_HEX((value << 20U) & mask, (generate_shift_left_bitset<60>(value, 20U).value())); - CHECK_EQUAL_HEX((value << 21U) & mask, (generate_shift_left_bitset<60>(value, 21U).value())); - CHECK_EQUAL_HEX((value << 22U) & mask, (generate_shift_left_bitset<60>(value, 22U).value())); - CHECK_EQUAL_HEX((value << 23U) & mask, (generate_shift_left_bitset<60>(value, 23U).value())); - CHECK_EQUAL_HEX((value << 24U) & mask, (generate_shift_left_bitset<60>(value, 24U).value())); - CHECK_EQUAL_HEX((value << 25U) & mask, (generate_shift_left_bitset<60>(value, 25U).value())); - CHECK_EQUAL_HEX((value << 26U) & mask, (generate_shift_left_bitset<60>(value, 26U).value())); - CHECK_EQUAL_HEX((value << 27U) & mask, (generate_shift_left_bitset<60>(value, 27U).value())); - CHECK_EQUAL_HEX((value << 28U) & mask, (generate_shift_left_bitset<60>(value, 28U).value())); - CHECK_EQUAL_HEX((value << 29U) & mask, (generate_shift_left_bitset<60>(value, 29U).value())); - CHECK_EQUAL_HEX((value << 30U) & mask, (generate_shift_left_bitset<60>(value, 30U).value())); - CHECK_EQUAL_HEX((value << 31U) & mask, (generate_shift_left_bitset<60>(value, 31U).value())); - CHECK_EQUAL_HEX((value << 32U) & mask, (generate_shift_left_bitset<60>(value, 32U).value())); - CHECK_EQUAL_HEX((value << 33U) & mask, (generate_shift_left_bitset<60>(value, 33U).value())); - CHECK_EQUAL_HEX((value << 34U) & mask, (generate_shift_left_bitset<60>(value, 34U).value())); - CHECK_EQUAL_HEX((value << 35U) & mask, (generate_shift_left_bitset<60>(value, 35U).value())); - CHECK_EQUAL_HEX((value << 36U) & mask, (generate_shift_left_bitset<60>(value, 36U).value())); - CHECK_EQUAL_HEX((value << 37U) & mask, (generate_shift_left_bitset<60>(value, 37U).value())); - CHECK_EQUAL_HEX((value << 38U) & mask, (generate_shift_left_bitset<60>(value, 38U).value())); - CHECK_EQUAL_HEX((value << 39U) & mask, (generate_shift_left_bitset<60>(value, 39U).value())); - CHECK_EQUAL_HEX((value << 40U) & mask, (generate_shift_left_bitset<60>(value, 40U).value())); - CHECK_EQUAL_HEX((value << 41U) & mask, (generate_shift_left_bitset<60>(value, 41U).value())); - CHECK_EQUAL_HEX((value << 42U) & mask, (generate_shift_left_bitset<60>(value, 42U).value())); - CHECK_EQUAL_HEX((value << 43U) & mask, (generate_shift_left_bitset<60>(value, 43U).value())); - CHECK_EQUAL_HEX((value << 44U) & mask, (generate_shift_left_bitset<60>(value, 44U).value())); - CHECK_EQUAL_HEX((value << 45U) & mask, (generate_shift_left_bitset<60>(value, 45U).value())); - CHECK_EQUAL_HEX((value << 46U) & mask, (generate_shift_left_bitset<60>(value, 46U).value())); - CHECK_EQUAL_HEX((value << 47U) & mask, (generate_shift_left_bitset<60>(value, 47U).value())); - CHECK_EQUAL_HEX((value << 48U) & mask, (generate_shift_left_bitset<60>(value, 48U).value())); - CHECK_EQUAL_HEX((value << 49U) & mask, (generate_shift_left_bitset<60>(value, 49U).value())); - CHECK_EQUAL_HEX((value << 50U) & mask, (generate_shift_left_bitset<60>(value, 50U).value())); - CHECK_EQUAL_HEX((value << 51U) & mask, (generate_shift_left_bitset<60>(value, 51U).value())); - CHECK_EQUAL_HEX((value << 52U) & mask, (generate_shift_left_bitset<60>(value, 52U).value())); - CHECK_EQUAL_HEX((value << 53U) & mask, (generate_shift_left_bitset<60>(value, 53U).value())); - CHECK_EQUAL_HEX((value << 54U) & mask, (generate_shift_left_bitset<60>(value, 54U).value())); - CHECK_EQUAL_HEX((value << 55U) & mask, (generate_shift_left_bitset<60>(value, 55U).value())); - CHECK_EQUAL_HEX((value << 56U) & mask, (generate_shift_left_bitset<60>(value, 56U).value())); - CHECK_EQUAL_HEX((value << 57U) & mask, (generate_shift_left_bitset<60>(value, 57U).value())); - CHECK_EQUAL_HEX((value << 58U) & mask, (generate_shift_left_bitset<60>(value, 58U).value())); - CHECK_EQUAL_HEX((value << 59U) & mask, (generate_shift_left_bitset<60>(value, 59U).value())); - CHECK_EQUAL_HEX((value << 60U) & mask, (generate_shift_left_bitset<60>(value, 60U).value())); - CHECK_EQUAL_HEX((value << 61U) & mask, (generate_shift_left_bitset<60>(value, 61U).value())); - CHECK_EQUAL_HEX((value << 62U) & mask, (generate_shift_left_bitset<60>(value, 62U).value())); - CHECK_EQUAL_HEX((value << 63U) & mask, (generate_shift_left_bitset<60>(value, 63U).value())); - CHECK_EQUAL_HEX(0ULL, (generate_shift_left_bitset<60>(value, 64U).value())); + CHECK_EQUAL_HEX((value << 0U), (generate_shift_left_bitset<64>(value, 0U).value())); + CHECK_EQUAL_HEX((value << 1U), (generate_shift_left_bitset<64>(value, 1U).value())); + CHECK_EQUAL_HEX((value << 2U), (generate_shift_left_bitset<64>(value, 2U).value())); + CHECK_EQUAL_HEX((value << 3U), (generate_shift_left_bitset<64>(value, 3U).value())); + CHECK_EQUAL_HEX((value << 4U), (generate_shift_left_bitset<64>(value, 4U).value())); + CHECK_EQUAL_HEX((value << 5U), (generate_shift_left_bitset<64>(value, 5U).value())); + CHECK_EQUAL_HEX((value << 6U), (generate_shift_left_bitset<64>(value, 6U).value())); + CHECK_EQUAL_HEX((value << 7U), (generate_shift_left_bitset<64>(value, 7U).value())); + CHECK_EQUAL_HEX((value << 8U), (generate_shift_left_bitset<64>(value, 8U).value())); + CHECK_EQUAL_HEX((value << 9U), (generate_shift_left_bitset<64>(value, 9U).value())); + CHECK_EQUAL_HEX((value << 10U), (generate_shift_left_bitset<64>(value, 10U).value())); + CHECK_EQUAL_HEX((value << 11U), (generate_shift_left_bitset<64>(value, 11U).value())); + CHECK_EQUAL_HEX((value << 12U), (generate_shift_left_bitset<64>(value, 12U).value())); + CHECK_EQUAL_HEX((value << 13U), (generate_shift_left_bitset<64>(value, 13U).value())); + CHECK_EQUAL_HEX((value << 14U), (generate_shift_left_bitset<64>(value, 14U).value())); + CHECK_EQUAL_HEX((value << 15U), (generate_shift_left_bitset<64>(value, 15U).value())); + CHECK_EQUAL_HEX((value << 16U), (generate_shift_left_bitset<64>(value, 16U).value())); + CHECK_EQUAL_HEX((value << 17U), (generate_shift_left_bitset<64>(value, 17U).value())); + CHECK_EQUAL_HEX((value << 18U), (generate_shift_left_bitset<64>(value, 18U).value())); + CHECK_EQUAL_HEX((value << 19U), (generate_shift_left_bitset<64>(value, 19U).value())); + CHECK_EQUAL_HEX((value << 20U), (generate_shift_left_bitset<64>(value, 20U).value())); + CHECK_EQUAL_HEX((value << 21U), (generate_shift_left_bitset<64>(value, 21U).value())); + CHECK_EQUAL_HEX((value << 22U), (generate_shift_left_bitset<64>(value, 22U).value())); + CHECK_EQUAL_HEX((value << 23U), (generate_shift_left_bitset<64>(value, 23U).value())); + CHECK_EQUAL_HEX((value << 24U), (generate_shift_left_bitset<64>(value, 24U).value())); + CHECK_EQUAL_HEX((value << 25U), (generate_shift_left_bitset<64>(value, 25U).value())); + CHECK_EQUAL_HEX((value << 26U), (generate_shift_left_bitset<64>(value, 26U).value())); + CHECK_EQUAL_HEX((value << 27U), (generate_shift_left_bitset<64>(value, 27U).value())); + CHECK_EQUAL_HEX((value << 28U), (generate_shift_left_bitset<64>(value, 28U).value())); + CHECK_EQUAL_HEX((value << 29U), (generate_shift_left_bitset<64>(value, 29U).value())); + CHECK_EQUAL_HEX((value << 30U), (generate_shift_left_bitset<64>(value, 30U).value())); + CHECK_EQUAL_HEX((value << 31U), (generate_shift_left_bitset<64>(value, 31U).value())); + CHECK_EQUAL_HEX((value << 32U), (generate_shift_left_bitset<64>(value, 32U).value())); + CHECK_EQUAL_HEX((value << 33U), (generate_shift_left_bitset<64>(value, 33U).value())); + CHECK_EQUAL_HEX((value << 34U), (generate_shift_left_bitset<64>(value, 34U).value())); + CHECK_EQUAL_HEX((value << 35U), (generate_shift_left_bitset<64>(value, 35U).value())); + CHECK_EQUAL_HEX((value << 36U), (generate_shift_left_bitset<64>(value, 36U).value())); + CHECK_EQUAL_HEX((value << 37U), (generate_shift_left_bitset<64>(value, 37U).value())); + CHECK_EQUAL_HEX((value << 38U), (generate_shift_left_bitset<64>(value, 38U).value())); + CHECK_EQUAL_HEX((value << 39U), (generate_shift_left_bitset<64>(value, 39U).value())); + CHECK_EQUAL_HEX((value << 40U), (generate_shift_left_bitset<64>(value, 40U).value())); + CHECK_EQUAL_HEX((value << 41U), (generate_shift_left_bitset<64>(value, 41U).value())); + CHECK_EQUAL_HEX((value << 42U), (generate_shift_left_bitset<64>(value, 42U).value())); + CHECK_EQUAL_HEX((value << 43U), (generate_shift_left_bitset<64>(value, 43U).value())); + CHECK_EQUAL_HEX((value << 44U), (generate_shift_left_bitset<64>(value, 44U).value())); + CHECK_EQUAL_HEX((value << 45U), (generate_shift_left_bitset<64>(value, 45U).value())); + CHECK_EQUAL_HEX((value << 46U), (generate_shift_left_bitset<64>(value, 46U).value())); + CHECK_EQUAL_HEX((value << 47U), (generate_shift_left_bitset<64>(value, 47U).value())); + CHECK_EQUAL_HEX((value << 48U), (generate_shift_left_bitset<64>(value, 48U).value())); + CHECK_EQUAL_HEX((value << 49U), (generate_shift_left_bitset<64>(value, 49U).value())); + CHECK_EQUAL_HEX((value << 50U), (generate_shift_left_bitset<64>(value, 50U).value())); + CHECK_EQUAL_HEX((value << 51U), (generate_shift_left_bitset<64>(value, 51U).value())); + CHECK_EQUAL_HEX((value << 52U), (generate_shift_left_bitset<64>(value, 52U).value())); + CHECK_EQUAL_HEX((value << 53U), (generate_shift_left_bitset<64>(value, 53U).value())); + CHECK_EQUAL_HEX((value << 54U), (generate_shift_left_bitset<64>(value, 54U).value())); + CHECK_EQUAL_HEX((value << 55U), (generate_shift_left_bitset<64>(value, 55U).value())); + CHECK_EQUAL_HEX((value << 56U), (generate_shift_left_bitset<64>(value, 56U).value())); + CHECK_EQUAL_HEX((value << 57U), (generate_shift_left_bitset<64>(value, 57U).value())); + CHECK_EQUAL_HEX((value << 58U), (generate_shift_left_bitset<64>(value, 58U).value())); + CHECK_EQUAL_HEX((value << 59U), (generate_shift_left_bitset<64>(value, 59U).value())); + CHECK_EQUAL_HEX((value << 60U), (generate_shift_left_bitset<64>(value, 60U).value())); + CHECK_EQUAL_HEX((value << 61U), (generate_shift_left_bitset<64>(value, 61U).value())); + CHECK_EQUAL_HEX((value << 62U), (generate_shift_left_bitset<64>(value, 62U).value())); + CHECK_EQUAL_HEX((value << 63U), (generate_shift_left_bitset<64>(value, 63U).value())); + CHECK_EQUAL_HEX(0ULL, (generate_shift_left_bitset<64>(value, 64U).value())); } //************************************************************************* TEST(test_shift_right_operator) { - ETL_CONSTEXPR14 etl::bitset<60> shift1(0x91A2B3CULL); - ETL_CONSTEXPR14 etl::bitset<60> shift2(0x48D159EULL); - ETL_CONSTEXPR14 etl::bitset<60> shift11(0x2468AULL); + ETL_CONSTEXPR14 etl::bitset<64> shift1(0x91A2B3CULL); + ETL_CONSTEXPR14 etl::bitset<64> shift2(0x48D159EULL); + ETL_CONSTEXPR14 etl::bitset<64> shift11(0x2468AULL); - CHECK(generate_shift_right_bitset<60>(0x12345678ULL, 1U) == shift1); - CHECK(generate_shift_right_bitset<60>(0x12345678ULL, 2U) == shift2); - CHECK(generate_shift_right_bitset<60>(0x12345678ULL, 11U) == shift11); + CHECK_EQUAL_HEX(shift1.value(), (generate_shift_right_bitset<64>(0x12345678ULL, 1U).value())); + CHECK_EQUAL_HEX(shift2.value(), (generate_shift_right_bitset<64>(0x12345678ULL, 2U).value())); + CHECK_EQUAL_HEX(shift11.value(), (generate_shift_right_bitset<64>(0x12345678ULL, 11U).value())); } //************************************************************************* TEST(test_shift_right_copy_operator) { - ETL_CONSTEXPR14 etl::bitset<60> shift8(0x123456ULL); - CHECK_EQUAL_HEX(shift8.value(), generate_shift_right_bitset_copy<60>(0x12345678UL, 8U).value()); + ETL_CONSTEXPR14 etl::bitset<64> shift8(0x123456ULL); + CHECK_EQUAL_HEX(shift8.value(), (generate_shift_right_bitset_copy<64>(0x12345678UL, 8U).value())); - ETL_CONSTEXPR14 etl::bitset<60> shift16(0x1234ULL); - CHECK_EQUAL_HEX(shift16.value(), generate_shift_right_bitset_copy<60>(0x12345678UL, 16U).value()); + ETL_CONSTEXPR14 etl::bitset<64> shift16(0x1234ULL); + CHECK_EQUAL_HEX(shift16.value(), (generate_shift_right_bitset_copy<64>(0x12345678UL, 16U).value())); - ETL_CONSTEXPR14 etl::bitset<60> shift24(0x12ULL); - CHECK_EQUAL_HEX(shift24.value(), generate_shift_right_bitset_copy<60>(0x12345678UL, 24U).value()); + ETL_CONSTEXPR14 etl::bitset<64> shift24(0x12ULL); + CHECK_EQUAL_HEX(shift24.value(), (generate_shift_right_bitset_copy<64>(0x12345678UL, 24U).value())); - ETL_CONSTEXPR14 etl::bitset<60> shift60(0x00ULL); - CHECK_EQUAL_HEX(shift60.value(), generate_shift_right_bitset_copy<60>(0x12345678UL, 60U).value()); + ETL_CONSTEXPR14 etl::bitset<64> shift60(0x00ULL); + CHECK_EQUAL_HEX(shift60.value(), (generate_shift_right_bitset_copy<64>(0x12345678UL, 60U).value())); } //************************************************************************* @@ -1835,331 +1697,335 @@ namespace { uint64_t value = 0x0123456789ABCDEFULL; - CHECK_EQUAL_HEX((value >> 0U), (generate_shift_right_bitset<64>(value, 0U).value())); - CHECK_EQUAL_HEX((value >> 1U), (generate_shift_right_bitset<64>(value, 1U).value())); - CHECK_EQUAL_HEX((value >> 2U), (generate_shift_right_bitset<64>(value, 2U).value())); - CHECK_EQUAL_HEX((value >> 3U), (generate_shift_right_bitset<64>(value, 3U).value())); - CHECK_EQUAL_HEX((value >> 4U), (generate_shift_right_bitset<64>(value, 4U).value())); - CHECK_EQUAL_HEX((value >> 5U), (generate_shift_right_bitset<64>(value, 5U).value())); - CHECK_EQUAL_HEX((value >> 6U), (generate_shift_right_bitset<64>(value, 6U).value())); - CHECK_EQUAL_HEX((value >> 7U), (generate_shift_right_bitset<64>(value, 7U).value())); - CHECK_EQUAL_HEX((value >> 8U), (generate_shift_right_bitset<64>(value, 8U).value())); - CHECK_EQUAL_HEX((value >> 9U), (generate_shift_right_bitset<64>(value, 9U).value())); - CHECK_EQUAL_HEX((value >> 10U), (generate_shift_right_bitset<64>(value, 10U).value())); - CHECK_EQUAL_HEX((value >> 11U), (generate_shift_right_bitset<64>(value, 11U).value())); - CHECK_EQUAL_HEX((value >> 12U), (generate_shift_right_bitset<64>(value, 12U).value())); - CHECK_EQUAL_HEX((value >> 13U), (generate_shift_right_bitset<64>(value, 13U).value())); - CHECK_EQUAL_HEX((value >> 14U), (generate_shift_right_bitset<64>(value, 14U).value())); - CHECK_EQUAL_HEX((value >> 15U), (generate_shift_right_bitset<64>(value, 15U).value())); - CHECK_EQUAL_HEX((value >> 16U), (generate_shift_right_bitset<64>(value, 16U).value())); - CHECK_EQUAL_HEX((value >> 17U), (generate_shift_right_bitset<64>(value, 17U).value())); - CHECK_EQUAL_HEX((value >> 18U), (generate_shift_right_bitset<64>(value, 18U).value())); - CHECK_EQUAL_HEX((value >> 19U), (generate_shift_right_bitset<64>(value, 19U).value())); - CHECK_EQUAL_HEX((value >> 20U), (generate_shift_right_bitset<64>(value, 20U).value())); - CHECK_EQUAL_HEX((value >> 21U), (generate_shift_right_bitset<64>(value, 21U).value())); - CHECK_EQUAL_HEX((value >> 22U), (generate_shift_right_bitset<64>(value, 22U).value())); - CHECK_EQUAL_HEX((value >> 23U), (generate_shift_right_bitset<64>(value, 23U).value())); - CHECK_EQUAL_HEX((value >> 24U), (generate_shift_right_bitset<64>(value, 24U).value())); - CHECK_EQUAL_HEX((value >> 25U), (generate_shift_right_bitset<64>(value, 25U).value())); - CHECK_EQUAL_HEX((value >> 26U), (generate_shift_right_bitset<64>(value, 26U).value())); - CHECK_EQUAL_HEX((value >> 27U), (generate_shift_right_bitset<64>(value, 27U).value())); - CHECK_EQUAL_HEX((value >> 28U), (generate_shift_right_bitset<64>(value, 28U).value())); - CHECK_EQUAL_HEX((value >> 29U), (generate_shift_right_bitset<64>(value, 29U).value())); - CHECK_EQUAL_HEX((value >> 30U), (generate_shift_right_bitset<64>(value, 30U).value())); - CHECK_EQUAL_HEX((value >> 31U), (generate_shift_right_bitset<64>(value, 31U).value())); - CHECK_EQUAL_HEX((value >> 32U), (generate_shift_right_bitset<64>(value, 32U).value())); - CHECK_EQUAL_HEX((value >> 33U), (generate_shift_right_bitset<64>(value, 33U).value())); - CHECK_EQUAL_HEX((value >> 34U), (generate_shift_right_bitset<64>(value, 34U).value())); - CHECK_EQUAL_HEX((value >> 35U), (generate_shift_right_bitset<64>(value, 35U).value())); - CHECK_EQUAL_HEX((value >> 36U), (generate_shift_right_bitset<64>(value, 36U).value())); - CHECK_EQUAL_HEX((value >> 37U), (generate_shift_right_bitset<64>(value, 37U).value())); - CHECK_EQUAL_HEX((value >> 38U), (generate_shift_right_bitset<64>(value, 38U).value())); - CHECK_EQUAL_HEX((value >> 39U), (generate_shift_right_bitset<64>(value, 39U).value())); - CHECK_EQUAL_HEX((value >> 40U), (generate_shift_right_bitset<64>(value, 40U).value())); - CHECK_EQUAL_HEX((value >> 41U), (generate_shift_right_bitset<64>(value, 41U).value())); - CHECK_EQUAL_HEX((value >> 42U), (generate_shift_right_bitset<64>(value, 42U).value())); - CHECK_EQUAL_HEX((value >> 43U), (generate_shift_right_bitset<64>(value, 43U).value())); - CHECK_EQUAL_HEX((value >> 44U), (generate_shift_right_bitset<64>(value, 44U).value())); - CHECK_EQUAL_HEX((value >> 45U), (generate_shift_right_bitset<64>(value, 45U).value())); - CHECK_EQUAL_HEX((value >> 46U), (generate_shift_right_bitset<64>(value, 46U).value())); - CHECK_EQUAL_HEX((value >> 47U), (generate_shift_right_bitset<64>(value, 47U).value())); - CHECK_EQUAL_HEX((value >> 48U), (generate_shift_right_bitset<64>(value, 48U).value())); - CHECK_EQUAL_HEX((value >> 49U), (generate_shift_right_bitset<64>(value, 49U).value())); - CHECK_EQUAL_HEX((value >> 50U), (generate_shift_right_bitset<64>(value, 50U).value())); - CHECK_EQUAL_HEX((value >> 51U), (generate_shift_right_bitset<64>(value, 51U).value())); - CHECK_EQUAL_HEX((value >> 52U), (generate_shift_right_bitset<64>(value, 52U).value())); - CHECK_EQUAL_HEX((value >> 53U), (generate_shift_right_bitset<64>(value, 53U).value())); - CHECK_EQUAL_HEX((value >> 54U), (generate_shift_right_bitset<64>(value, 54U).value())); - CHECK_EQUAL_HEX((value >> 55U), (generate_shift_right_bitset<64>(value, 55U).value())); - CHECK_EQUAL_HEX((value >> 56U), (generate_shift_right_bitset<64>(value, 56U).value())); - CHECK_EQUAL_HEX((value >> 57U), (generate_shift_right_bitset<64>(value, 57U).value())); - CHECK_EQUAL_HEX((value >> 58U), (generate_shift_right_bitset<64>(value, 58U).value())); - CHECK_EQUAL_HEX((value >> 59U), (generate_shift_right_bitset<64>(value, 59U).value())); - CHECK_EQUAL_HEX((value >> 60U), (generate_shift_right_bitset<64>(value, 60U).value())); - CHECK_EQUAL_HEX((value >> 61U), (generate_shift_right_bitset<64>(value, 61U).value())); - CHECK_EQUAL_HEX((value >> 62U), (generate_shift_right_bitset<64>(value, 62U).value())); - CHECK_EQUAL_HEX((value >> 63U), (generate_shift_right_bitset<64>(value, 63U).value())); - CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64>(value, 64U).value())); + CHECK_EQUAL_HEX((value >> 0U), (generate_shift_right_bitset<64>(value, 0U).value())); + CHECK_EQUAL_HEX((value >> 1U), (generate_shift_right_bitset<64>(value, 1U).value())); + CHECK_EQUAL_HEX((value >> 2U), (generate_shift_right_bitset<64>(value, 2U).value())); + CHECK_EQUAL_HEX((value >> 3U), (generate_shift_right_bitset<64>(value, 3U).value())); + CHECK_EQUAL_HEX((value >> 4U), (generate_shift_right_bitset<64>(value, 4U).value())); + CHECK_EQUAL_HEX((value >> 5U), (generate_shift_right_bitset<64>(value, 5U).value())); + CHECK_EQUAL_HEX((value >> 6U), (generate_shift_right_bitset<64>(value, 6U).value())); + CHECK_EQUAL_HEX((value >> 7U), (generate_shift_right_bitset<64>(value, 7U).value())); + CHECK_EQUAL_HEX((value >> 8U), (generate_shift_right_bitset<64>(value, 8U).value())); + CHECK_EQUAL_HEX((value >> 9U), (generate_shift_right_bitset<64>(value, 9U).value())); + CHECK_EQUAL_HEX((value >> 10U), (generate_shift_right_bitset<64>(value, 10U).value())); + CHECK_EQUAL_HEX((value >> 11U), (generate_shift_right_bitset<64>(value, 11U).value())); + CHECK_EQUAL_HEX((value >> 12U), (generate_shift_right_bitset<64>(value, 12U).value())); + CHECK_EQUAL_HEX((value >> 13U), (generate_shift_right_bitset<64>(value, 13U).value())); + CHECK_EQUAL_HEX((value >> 14U), (generate_shift_right_bitset<64>(value, 14U).value())); + CHECK_EQUAL_HEX((value >> 15U), (generate_shift_right_bitset<64>(value, 15U).value())); + CHECK_EQUAL_HEX((value >> 16U), (generate_shift_right_bitset<64>(value, 16U).value())); + CHECK_EQUAL_HEX((value >> 17U), (generate_shift_right_bitset<64>(value, 17U).value())); + CHECK_EQUAL_HEX((value >> 18U), (generate_shift_right_bitset<64>(value, 18U).value())); + CHECK_EQUAL_HEX((value >> 19U), (generate_shift_right_bitset<64>(value, 19U).value())); + CHECK_EQUAL_HEX((value >> 20U), (generate_shift_right_bitset<64>(value, 20U).value())); + CHECK_EQUAL_HEX((value >> 21U), (generate_shift_right_bitset<64>(value, 21U).value())); + CHECK_EQUAL_HEX((value >> 22U), (generate_shift_right_bitset<64>(value, 22U).value())); + CHECK_EQUAL_HEX((value >> 23U), (generate_shift_right_bitset<64>(value, 23U).value())); + CHECK_EQUAL_HEX((value >> 24U), (generate_shift_right_bitset<64>(value, 24U).value())); + CHECK_EQUAL_HEX((value >> 25U), (generate_shift_right_bitset<64>(value, 25U).value())); + CHECK_EQUAL_HEX((value >> 26U), (generate_shift_right_bitset<64>(value, 26U).value())); + CHECK_EQUAL_HEX((value >> 27U), (generate_shift_right_bitset<64>(value, 27U).value())); + CHECK_EQUAL_HEX((value >> 28U), (generate_shift_right_bitset<64>(value, 28U).value())); + CHECK_EQUAL_HEX((value >> 29U), (generate_shift_right_bitset<64>(value, 29U).value())); + CHECK_EQUAL_HEX((value >> 30U), (generate_shift_right_bitset<64>(value, 30U).value())); + CHECK_EQUAL_HEX((value >> 31U), (generate_shift_right_bitset<64>(value, 31U).value())); + CHECK_EQUAL_HEX((value >> 32U), (generate_shift_right_bitset<64>(value, 32U).value())); + CHECK_EQUAL_HEX((value >> 33U), (generate_shift_right_bitset<64>(value, 33U).value())); + CHECK_EQUAL_HEX((value >> 34U), (generate_shift_right_bitset<64>(value, 34U).value())); + CHECK_EQUAL_HEX((value >> 35U), (generate_shift_right_bitset<64>(value, 35U).value())); + CHECK_EQUAL_HEX((value >> 36U), (generate_shift_right_bitset<64>(value, 36U).value())); + CHECK_EQUAL_HEX((value >> 37U), (generate_shift_right_bitset<64>(value, 37U).value())); + CHECK_EQUAL_HEX((value >> 38U), (generate_shift_right_bitset<64>(value, 38U).value())); + CHECK_EQUAL_HEX((value >> 39U), (generate_shift_right_bitset<64>(value, 39U).value())); + CHECK_EQUAL_HEX((value >> 40U), (generate_shift_right_bitset<64>(value, 40U).value())); + CHECK_EQUAL_HEX((value >> 41U), (generate_shift_right_bitset<64>(value, 41U).value())); + CHECK_EQUAL_HEX((value >> 42U), (generate_shift_right_bitset<64>(value, 42U).value())); + CHECK_EQUAL_HEX((value >> 43U), (generate_shift_right_bitset<64>(value, 43U).value())); + CHECK_EQUAL_HEX((value >> 44U), (generate_shift_right_bitset<64>(value, 44U).value())); + CHECK_EQUAL_HEX((value >> 45U), (generate_shift_right_bitset<64>(value, 45U).value())); + CHECK_EQUAL_HEX((value >> 46U), (generate_shift_right_bitset<64>(value, 46U).value())); + CHECK_EQUAL_HEX((value >> 47U), (generate_shift_right_bitset<64>(value, 47U).value())); + CHECK_EQUAL_HEX((value >> 48U), (generate_shift_right_bitset<64>(value, 48U).value())); + CHECK_EQUAL_HEX((value >> 49U), (generate_shift_right_bitset<64>(value, 49U).value())); + CHECK_EQUAL_HEX((value >> 50U), (generate_shift_right_bitset<64>(value, 50U).value())); + CHECK_EQUAL_HEX((value >> 51U), (generate_shift_right_bitset<64>(value, 51U).value())); + CHECK_EQUAL_HEX((value >> 52U), (generate_shift_right_bitset<64>(value, 52U).value())); + CHECK_EQUAL_HEX((value >> 53U), (generate_shift_right_bitset<64>(value, 53U).value())); + CHECK_EQUAL_HEX((value >> 54U), (generate_shift_right_bitset<64>(value, 54U).value())); + CHECK_EQUAL_HEX((value >> 55U), (generate_shift_right_bitset<64>(value, 55U).value())); + CHECK_EQUAL_HEX((value >> 56U), (generate_shift_right_bitset<64>(value, 56U).value())); + CHECK_EQUAL_HEX((value >> 57U), (generate_shift_right_bitset<64>(value, 57U).value())); + CHECK_EQUAL_HEX((value >> 58U), (generate_shift_right_bitset<64>(value, 58U).value())); + CHECK_EQUAL_HEX((value >> 59U), (generate_shift_right_bitset<64>(value, 59U).value())); + CHECK_EQUAL_HEX((value >> 60U), (generate_shift_right_bitset<64>(value, 60U).value())); + CHECK_EQUAL_HEX((value >> 61U), (generate_shift_right_bitset<64>(value, 61U).value())); + CHECK_EQUAL_HEX((value >> 62U), (generate_shift_right_bitset<64>(value, 62U).value())); + CHECK_EQUAL_HEX((value >> 63U), (generate_shift_right_bitset<64>(value, 63U).value())); + CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64>(value, 64U).value())); } //************************************************************************* TEST(test_shift_right_operator_all_shifts_partial_size) { uint64_t value = 0x0123456789ABCDEFULL; - uint64_t mask = 0x0FFFFFFFFFFFFFFFULL; + uint64_t mask = 0x0FFFFFFFFFFFFFFFULL; - CHECK_EQUAL_HEX((value >> 0U) & mask, (generate_shift_right_bitset<60>(value, 0U).value())); - CHECK_EQUAL_HEX((value >> 1U) & mask, (generate_shift_right_bitset<60>(value, 1U).value())); - CHECK_EQUAL_HEX((value >> 2U) & mask, (generate_shift_right_bitset<60>(value, 2U).value())); - CHECK_EQUAL_HEX((value >> 3U) & mask, (generate_shift_right_bitset<60>(value, 3U).value())); - CHECK_EQUAL_HEX((value >> 4U) & mask, (generate_shift_right_bitset<60>(value, 4U).value())); - CHECK_EQUAL_HEX((value >> 5U) & mask, (generate_shift_right_bitset<60>(value, 5U).value())); - CHECK_EQUAL_HEX((value >> 6U) & mask, (generate_shift_right_bitset<60>(value, 6U).value())); - CHECK_EQUAL_HEX((value >> 7U) & mask, (generate_shift_right_bitset<60>(value, 7U).value())); - CHECK_EQUAL_HEX((value >> 8U) & mask, (generate_shift_right_bitset<60>(value, 8U).value())); - CHECK_EQUAL_HEX((value >> 9U) & mask, (generate_shift_right_bitset<60>(value, 9U).value())); - CHECK_EQUAL_HEX((value >> 10U) & mask, (generate_shift_right_bitset<60>(value, 10U).value())); - CHECK_EQUAL_HEX((value >> 11U) & mask, (generate_shift_right_bitset<60>(value, 11U).value())); - CHECK_EQUAL_HEX((value >> 12U) & mask, (generate_shift_right_bitset<60>(value, 12U).value())); - CHECK_EQUAL_HEX((value >> 13U) & mask, (generate_shift_right_bitset<60>(value, 13U).value())); - CHECK_EQUAL_HEX((value >> 14U) & mask, (generate_shift_right_bitset<60>(value, 14U).value())); - CHECK_EQUAL_HEX((value >> 15U) & mask, (generate_shift_right_bitset<60>(value, 15U).value())); - CHECK_EQUAL_HEX((value >> 16U) & mask, (generate_shift_right_bitset<60>(value, 16U).value())); - CHECK_EQUAL_HEX((value >> 17U) & mask, (generate_shift_right_bitset<60>(value, 17U).value())); - CHECK_EQUAL_HEX((value >> 18U) & mask, (generate_shift_right_bitset<60>(value, 18U).value())); - CHECK_EQUAL_HEX((value >> 19U) & mask, (generate_shift_right_bitset<60>(value, 19U).value())); - CHECK_EQUAL_HEX((value >> 20U) & mask, (generate_shift_right_bitset<60>(value, 20U).value())); - CHECK_EQUAL_HEX((value >> 21U) & mask, (generate_shift_right_bitset<60>(value, 21U).value())); - CHECK_EQUAL_HEX((value >> 22U) & mask, (generate_shift_right_bitset<60>(value, 22U).value())); - CHECK_EQUAL_HEX((value >> 23U) & mask, (generate_shift_right_bitset<60>(value, 23U).value())); - CHECK_EQUAL_HEX((value >> 24U) & mask, (generate_shift_right_bitset<60>(value, 24U).value())); - CHECK_EQUAL_HEX((value >> 25U) & mask, (generate_shift_right_bitset<60>(value, 25U).value())); - CHECK_EQUAL_HEX((value >> 26U) & mask, (generate_shift_right_bitset<60>(value, 26U).value())); - CHECK_EQUAL_HEX((value >> 27U) & mask, (generate_shift_right_bitset<60>(value, 27U).value())); - CHECK_EQUAL_HEX((value >> 28U) & mask, (generate_shift_right_bitset<60>(value, 28U).value())); - CHECK_EQUAL_HEX((value >> 29U) & mask, (generate_shift_right_bitset<60>(value, 29U).value())); - CHECK_EQUAL_HEX((value >> 30U) & mask, (generate_shift_right_bitset<60>(value, 30U).value())); - CHECK_EQUAL_HEX((value >> 31U) & mask, (generate_shift_right_bitset<60>(value, 31U).value())); - CHECK_EQUAL_HEX((value >> 32U) & mask, (generate_shift_right_bitset<60>(value, 32U).value())); - CHECK_EQUAL_HEX((value >> 33U) & mask, (generate_shift_right_bitset<60>(value, 33U).value())); - CHECK_EQUAL_HEX((value >> 34U) & mask, (generate_shift_right_bitset<60>(value, 34U).value())); - CHECK_EQUAL_HEX((value >> 35U) & mask, (generate_shift_right_bitset<60>(value, 35U).value())); - CHECK_EQUAL_HEX((value >> 36U) & mask, (generate_shift_right_bitset<60>(value, 36U).value())); - CHECK_EQUAL_HEX((value >> 37U) & mask, (generate_shift_right_bitset<60>(value, 37U).value())); - CHECK_EQUAL_HEX((value >> 38U) & mask, (generate_shift_right_bitset<60>(value, 38U).value())); - CHECK_EQUAL_HEX((value >> 39U) & mask, (generate_shift_right_bitset<60>(value, 39U).value())); - CHECK_EQUAL_HEX((value >> 40U) & mask, (generate_shift_right_bitset<60>(value, 40U).value())); - CHECK_EQUAL_HEX((value >> 41U) & mask, (generate_shift_right_bitset<60>(value, 41U).value())); - CHECK_EQUAL_HEX((value >> 42U) & mask, (generate_shift_right_bitset<60>(value, 42U).value())); - CHECK_EQUAL_HEX((value >> 43U) & mask, (generate_shift_right_bitset<60>(value, 43U).value())); - CHECK_EQUAL_HEX((value >> 44U) & mask, (generate_shift_right_bitset<60>(value, 44U).value())); - CHECK_EQUAL_HEX((value >> 45U) & mask, (generate_shift_right_bitset<60>(value, 45U).value())); - CHECK_EQUAL_HEX((value >> 46U) & mask, (generate_shift_right_bitset<60>(value, 46U).value())); - CHECK_EQUAL_HEX((value >> 47U) & mask, (generate_shift_right_bitset<60>(value, 47U).value())); - CHECK_EQUAL_HEX((value >> 48U) & mask, (generate_shift_right_bitset<60>(value, 48U).value())); - CHECK_EQUAL_HEX((value >> 49U) & mask, (generate_shift_right_bitset<60>(value, 49U).value())); - CHECK_EQUAL_HEX((value >> 50U) & mask, (generate_shift_right_bitset<60>(value, 50U).value())); - CHECK_EQUAL_HEX((value >> 51U) & mask, (generate_shift_right_bitset<60>(value, 51U).value())); - CHECK_EQUAL_HEX((value >> 52U) & mask, (generate_shift_right_bitset<60>(value, 52U).value())); - CHECK_EQUAL_HEX((value >> 53U) & mask, (generate_shift_right_bitset<60>(value, 53U).value())); - CHECK_EQUAL_HEX((value >> 54U) & mask, (generate_shift_right_bitset<60>(value, 54U).value())); - CHECK_EQUAL_HEX((value >> 55U) & mask, (generate_shift_right_bitset<60>(value, 55U).value())); - CHECK_EQUAL_HEX((value >> 56U) & mask, (generate_shift_right_bitset<60>(value, 56U).value())); - CHECK_EQUAL_HEX((value >> 57U) & mask, (generate_shift_right_bitset<60>(value, 57U).value())); - CHECK_EQUAL_HEX((value >> 58U) & mask, (generate_shift_right_bitset<60>(value, 58U).value())); - CHECK_EQUAL_HEX((value >> 59U) & mask, (generate_shift_right_bitset<60>(value, 59U).value())); - CHECK_EQUAL_HEX((value >> 60U) & mask, (generate_shift_right_bitset<60>(value, 60U).value())); - CHECK_EQUAL_HEX((value >> 61U) & mask, (generate_shift_right_bitset<60>(value, 61U).value())); - CHECK_EQUAL_HEX((value >> 62U) & mask, (generate_shift_right_bitset<60>(value, 62U).value())); - CHECK_EQUAL_HEX((value >> 63U) & mask, (generate_shift_right_bitset<60>(value, 63U).value())); - CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<60>(value, 64U).value())); + CHECK_EQUAL_HEX((value >> 0U) & mask, (generate_shift_right_bitset<64>(value, 0U).value())); + CHECK_EQUAL_HEX((value >> 1U) & mask, (generate_shift_right_bitset<64>(value, 1U).value())); + CHECK_EQUAL_HEX((value >> 2U) & mask, (generate_shift_right_bitset<64>(value, 2U).value())); + CHECK_EQUAL_HEX((value >> 3U) & mask, (generate_shift_right_bitset<64>(value, 3U).value())); + CHECK_EQUAL_HEX((value >> 4U) & mask, (generate_shift_right_bitset<64>(value, 4U).value())); + CHECK_EQUAL_HEX((value >> 5U) & mask, (generate_shift_right_bitset<64>(value, 5U).value())); + CHECK_EQUAL_HEX((value >> 6U) & mask, (generate_shift_right_bitset<64>(value, 6U).value())); + CHECK_EQUAL_HEX((value >> 7U) & mask, (generate_shift_right_bitset<64>(value, 7U).value())); + CHECK_EQUAL_HEX((value >> 8U) & mask, (generate_shift_right_bitset<64>(value, 8U).value())); + CHECK_EQUAL_HEX((value >> 9U) & mask, (generate_shift_right_bitset<64>(value, 9U).value())); + CHECK_EQUAL_HEX((value >> 10U) & mask, (generate_shift_right_bitset<64>(value, 10U).value())); + CHECK_EQUAL_HEX((value >> 11U) & mask, (generate_shift_right_bitset<64>(value, 11U).value())); + CHECK_EQUAL_HEX((value >> 12U) & mask, (generate_shift_right_bitset<64>(value, 12U).value())); + CHECK_EQUAL_HEX((value >> 13U) & mask, (generate_shift_right_bitset<64>(value, 13U).value())); + CHECK_EQUAL_HEX((value >> 14U) & mask, (generate_shift_right_bitset<64>(value, 14U).value())); + CHECK_EQUAL_HEX((value >> 15U) & mask, (generate_shift_right_bitset<64>(value, 15U).value())); + CHECK_EQUAL_HEX((value >> 16U) & mask, (generate_shift_right_bitset<64>(value, 16U).value())); + CHECK_EQUAL_HEX((value >> 17U) & mask, (generate_shift_right_bitset<64>(value, 17U).value())); + CHECK_EQUAL_HEX((value >> 18U) & mask, (generate_shift_right_bitset<64>(value, 18U).value())); + CHECK_EQUAL_HEX((value >> 19U) & mask, (generate_shift_right_bitset<64>(value, 19U).value())); + CHECK_EQUAL_HEX((value >> 20U) & mask, (generate_shift_right_bitset<64>(value, 20U).value())); + CHECK_EQUAL_HEX((value >> 21U) & mask, (generate_shift_right_bitset<64>(value, 21U).value())); + CHECK_EQUAL_HEX((value >> 22U) & mask, (generate_shift_right_bitset<64>(value, 22U).value())); + CHECK_EQUAL_HEX((value >> 23U) & mask, (generate_shift_right_bitset<64>(value, 23U).value())); + CHECK_EQUAL_HEX((value >> 24U) & mask, (generate_shift_right_bitset<64>(value, 24U).value())); + CHECK_EQUAL_HEX((value >> 25U) & mask, (generate_shift_right_bitset<64>(value, 25U).value())); + CHECK_EQUAL_HEX((value >> 26U) & mask, (generate_shift_right_bitset<64>(value, 26U).value())); + CHECK_EQUAL_HEX((value >> 27U) & mask, (generate_shift_right_bitset<64>(value, 27U).value())); + CHECK_EQUAL_HEX((value >> 28U) & mask, (generate_shift_right_bitset<64>(value, 28U).value())); + CHECK_EQUAL_HEX((value >> 29U) & mask, (generate_shift_right_bitset<64>(value, 29U).value())); + CHECK_EQUAL_HEX((value >> 30U) & mask, (generate_shift_right_bitset<64>(value, 30U).value())); + CHECK_EQUAL_HEX((value >> 31U) & mask, (generate_shift_right_bitset<64>(value, 31U).value())); + CHECK_EQUAL_HEX((value >> 32U) & mask, (generate_shift_right_bitset<64>(value, 32U).value())); + CHECK_EQUAL_HEX((value >> 33U) & mask, (generate_shift_right_bitset<64>(value, 33U).value())); + CHECK_EQUAL_HEX((value >> 34U) & mask, (generate_shift_right_bitset<64>(value, 34U).value())); + CHECK_EQUAL_HEX((value >> 35U) & mask, (generate_shift_right_bitset<64>(value, 35U).value())); + CHECK_EQUAL_HEX((value >> 36U) & mask, (generate_shift_right_bitset<64>(value, 36U).value())); + CHECK_EQUAL_HEX((value >> 37U) & mask, (generate_shift_right_bitset<64>(value, 37U).value())); + CHECK_EQUAL_HEX((value >> 38U) & mask, (generate_shift_right_bitset<64>(value, 38U).value())); + CHECK_EQUAL_HEX((value >> 39U) & mask, (generate_shift_right_bitset<64>(value, 39U).value())); + CHECK_EQUAL_HEX((value >> 40U) & mask, (generate_shift_right_bitset<64>(value, 40U).value())); + CHECK_EQUAL_HEX((value >> 41U) & mask, (generate_shift_right_bitset<64>(value, 41U).value())); + CHECK_EQUAL_HEX((value >> 42U) & mask, (generate_shift_right_bitset<64>(value, 42U).value())); + CHECK_EQUAL_HEX((value >> 43U) & mask, (generate_shift_right_bitset<64>(value, 43U).value())); + CHECK_EQUAL_HEX((value >> 44U) & mask, (generate_shift_right_bitset<64>(value, 44U).value())); + CHECK_EQUAL_HEX((value >> 45U) & mask, (generate_shift_right_bitset<64>(value, 45U).value())); + CHECK_EQUAL_HEX((value >> 46U) & mask, (generate_shift_right_bitset<64>(value, 46U).value())); + CHECK_EQUAL_HEX((value >> 47U) & mask, (generate_shift_right_bitset<64>(value, 47U).value())); + CHECK_EQUAL_HEX((value >> 48U) & mask, (generate_shift_right_bitset<64>(value, 48U).value())); + CHECK_EQUAL_HEX((value >> 49U) & mask, (generate_shift_right_bitset<64>(value, 49U).value())); + CHECK_EQUAL_HEX((value >> 50U) & mask, (generate_shift_right_bitset<64>(value, 50U).value())); + CHECK_EQUAL_HEX((value >> 51U) & mask, (generate_shift_right_bitset<64>(value, 51U).value())); + CHECK_EQUAL_HEX((value >> 52U) & mask, (generate_shift_right_bitset<64>(value, 52U).value())); + CHECK_EQUAL_HEX((value >> 53U) & mask, (generate_shift_right_bitset<64>(value, 53U).value())); + CHECK_EQUAL_HEX((value >> 54U) & mask, (generate_shift_right_bitset<64>(value, 54U).value())); + CHECK_EQUAL_HEX((value >> 55U) & mask, (generate_shift_right_bitset<64>(value, 55U).value())); + CHECK_EQUAL_HEX((value >> 56U) & mask, (generate_shift_right_bitset<64>(value, 56U).value())); + CHECK_EQUAL_HEX((value >> 57U) & mask, (generate_shift_right_bitset<64>(value, 57U).value())); + CHECK_EQUAL_HEX((value >> 58U) & mask, (generate_shift_right_bitset<64>(value, 58U).value())); + CHECK_EQUAL_HEX((value >> 59U) & mask, (generate_shift_right_bitset<64>(value, 59U).value())); + CHECK_EQUAL_HEX((value >> 60U) & mask, (generate_shift_right_bitset<64>(value, 60U).value())); + CHECK_EQUAL_HEX((value >> 61U) & mask, (generate_shift_right_bitset<64>(value, 61U).value())); + CHECK_EQUAL_HEX((value >> 62U) & mask, (generate_shift_right_bitset<64>(value, 62U).value())); + CHECK_EQUAL_HEX((value >> 63U) & mask, (generate_shift_right_bitset<64>(value, 63U).value())); + CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64>(value, 64U).value())); } //************************************************************************* TEST(test_and_operator) { - etl::bitset<60> data1(0x12345678UL); - etl::bitset<60> data2(0x23456789UL); - etl::bitset<60> data3(0x12345678UL & 0x23456789UL); - etl::bitset<60> data4(data1 & data2); + ETL_CONSTEXPR14 etl::bitset<64> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64> data4(0x12345678UL & 0x23456789UL); + + ETL_CONSTEXPR14 etl::bitset<64> data3 = data1 & data2; CHECK(data3 == data4); } //************************************************************************* + ETL_CONSTEXPR14 etl::bitset<64> test_and_equals_operator_helper(etl::bitset<64> data1, const etl::bitset<64>&data2) + { + data1 &= data2; + + return data1; + } + TEST(test_and_equals_operator) { - etl::bitset<60> data1(0x12345678UL); - etl::bitset<60> data2(0x23456789UL); - etl::bitset<60> data3(0x12345678UL & 0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64> data2(0x23456789UL); - etl::bitset<60> data4(data1); - data4 &= data2; - CHECK(data3 == data4); + ETL_CONSTEXPR14 etl::bitset<64> data3(test_and_equals_operator_helper(data1, data2)); + + CHECK((data1 & data2) == data3); } //************************************************************************* TEST(test_or_operator) { - etl::bitset<60> data1(0x12345678UL); - etl::bitset<60> data2(0x23456789UL); - etl::bitset<60> data4(0x12345678UL | 0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64> data4(0x12345678UL | 0x23456789UL); - etl::bitset<60> data3(data1 | data2); + ETL_CONSTEXPR14 etl::bitset<64> data3 = data1 | data2; CHECK(data3 == data4); } //************************************************************************* + ETL_CONSTEXPR14 etl::bitset<64> test_or_equals_operator_helper(etl::bitset<64> data1, const etl::bitset<64>&data2) + { + data1 |= data2; + + return data1; + } + TEST(test_or_equals_operator) { - etl::bitset<60> data1(0x12345678UL); - etl::bitset<60> data2(0x23456789UL); - etl::bitset<60> data3(0x12345678UL | 0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64> data2(0x23456789UL); - etl::bitset<60> data4(data1); - data4 |= data2; - CHECK(data3 == data4); + ETL_CONSTEXPR14 etl::bitset<64> data3(test_or_equals_operator_helper(data1, data2)); + + CHECK((data1 | data2) == data3); } //************************************************************************* TEST(test_xor_operator) { - etl::bitset<60> data1(0x12345678UL); - etl::bitset<60> data2(0x23456789UL); - etl::bitset<60> data4(0x12345678UL ^ 0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64> data4(0x12345678UL ^ 0x23456789UL); - etl::bitset<60> data3(data1 ^ data2); + ETL_CONSTEXPR14 etl::bitset<64> data3 = data1 ^ data2; CHECK(data3 == data4); } //************************************************************************* + ETL_CONSTEXPR14 etl::bitset<64> test_xor_equals_operator_helper(etl::bitset<64> data1, const etl::bitset<64>&data2) + { + data1 ^= data2; + + return data1; + } + TEST(test_xor_equals_operator) { - etl::bitset<60> data1(0x12345678UL); - etl::bitset<60> data2(0x23456789UL); - etl::bitset<60> data3(0x12345678UL ^ 0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64> data2(0x23456789UL); - etl::bitset<60> data4(data1); - data4 ^= data2; - CHECK(data3 == data4); + ETL_CONSTEXPR14 etl::bitset<64> data3(test_xor_equals_operator_helper(data1, data2)); + + CHECK((data1 ^ data2) == data3); } //************************************************************************* TEST(test_find_first) { - ETL_CONSTEXPR14 etl::bitset<9> bs1(ull(0x0000)); - ETL_CONSTEXPR14 size_t bs1fff = bs1.find_first(false); - ETL_CONSTEXPR14 size_t bs1fft = bs1.find_first(true); - CHECK_EQUAL(0U, bs1fff); - CHECK_EQUAL(etl::bitset<>::npos, bs1fft); + ETL_CONSTEXPR14 etl::bitset<8> bs1(ull(0x00)); + ETL_CONSTEXPR14 size_t bs1find_first_false = bs1.find_first(false); + ETL_CONSTEXPR14 size_t bs1find_first_true = bs1.find_first(true); + CHECK_EQUAL(0U, bs1find_first_false); + CHECK_EQUAL(etl::bitset<>::npos, bs1find_first_true); - ETL_CONSTEXPR14 etl::bitset<9> bs2(ull(0x01FF)); - ETL_CONSTEXPR14 size_t bs2fff = bs2.find_first(false); - ETL_CONSTEXPR14 size_t bs2fft = bs2.find_first(true); - CHECK_EQUAL(etl::bitset<>::npos, bs2fff); - CHECK_EQUAL(0U, bs2fft); + ETL_CONSTEXPR14 etl::bitset<8> bs2(ull(0xFF)); + ETL_CONSTEXPR14 size_t bs2find_first_false = bs2.find_first(false); + ETL_CONSTEXPR14 size_t bs2find_first_true = bs2.find_first(true); + CHECK_EQUAL(etl::bitset<>::npos, bs2find_first_false); + CHECK_EQUAL(0U, bs2find_first_true); - ETL_CONSTEXPR14 etl::bitset<9> bs3(ull(0x0001)); - ETL_CONSTEXPR14 size_t bs3fff = bs3.find_first(false); - ETL_CONSTEXPR14 size_t bs3fft = bs3.find_first(true); - CHECK_EQUAL(1U, bs3fff); - CHECK_EQUAL(0U, bs3fft); + ETL_CONSTEXPR14 etl::bitset<8> bs3(ull(0x01)); + ETL_CONSTEXPR14 size_t bs3find_first_false = bs3.find_first(false); + ETL_CONSTEXPR14 size_t bs3find_first_true = bs3.find_first(true); + CHECK_EQUAL(1U, bs3find_first_false); + CHECK_EQUAL(0U, bs3find_first_true); - ETL_CONSTEXPR14 etl::bitset<9> bs4(ull(0x0020)); - ETL_CONSTEXPR14 size_t bs4fff = bs4.find_first(false); - ETL_CONSTEXPR14 size_t bs4fft = bs4.find_first(true); - CHECK_EQUAL(0U, bs4fff); - CHECK_EQUAL(5U, bs4fft); + ETL_CONSTEXPR14 etl::bitset<8> bs4(ull(0x20)); + ETL_CONSTEXPR14 size_t bs4find_first_false = bs4.find_first(false); + ETL_CONSTEXPR14 size_t bs4find_first_true = bs4.find_first(true); + CHECK_EQUAL(0U, bs4find_first_false); + CHECK_EQUAL(5U, bs4find_first_true); - ETL_CONSTEXPR14 etl::bitset<9> bs5(ull(0x0021)); - ETL_CONSTEXPR14 size_t bs5fff = bs5.find_first(false); - ETL_CONSTEXPR14 size_t bs5fft = bs5.find_first(true); - CHECK_EQUAL(1U, bs5fff); - CHECK_EQUAL(0U, bs5fft); + ETL_CONSTEXPR14 etl::bitset<8> bs5(ull(0x21)); + ETL_CONSTEXPR14 size_t bs5find_first_false = bs5.find_first(false); + ETL_CONSTEXPR14 size_t bs5find_first_true = bs5.find_first(true); + CHECK_EQUAL(1U, bs5find_first_false); + CHECK_EQUAL(0U, bs5find_first_true); - ETL_CONSTEXPR14 etl::bitset<9> bs6(ull(0x000E)); - ETL_CONSTEXPR14 size_t bs6fff = bs6.find_first(false); - ETL_CONSTEXPR14 size_t bs6fft = bs6.find_first(true); - CHECK_EQUAL(0U, bs6fff); - CHECK_EQUAL(1U, bs6fft); + ETL_CONSTEXPR14 etl::bitset<8> bs6(ull(0x0E)); + ETL_CONSTEXPR14 size_t bs6find_first_false = bs6.find_first(false); + ETL_CONSTEXPR14 size_t bs6find_first_true = bs6.find_first(true); + CHECK_EQUAL(0U, bs6find_first_false); + CHECK_EQUAL(1U, bs6find_first_true); - ETL_CONSTEXPR14 etl::bitset<9> bs7(ull(0x31)); - ETL_CONSTEXPR14 size_t bs7fff = bs7.find_first(false); - ETL_CONSTEXPR14 size_t bs7fft = bs7.find_first(true); - CHECK_EQUAL(1U, bs7fff); - CHECK_EQUAL(0U, bs7fft); + ETL_CONSTEXPR14 etl::bitset<8> bs7(ull(0x31)); + ETL_CONSTEXPR14 size_t bs7find_first_false = bs7.find_first(false); + ETL_CONSTEXPR14 size_t bs7find_first_true = bs7.find_first(true); + CHECK_EQUAL(1U, bs7find_first_false); + CHECK_EQUAL(0U, bs7find_first_true); } - + //************************************************************************* TEST(test_find_next) { - ETL_CONSTEXPR14 etl::bitset<9> bs1(ull(0x0000)); - ETL_CONSTEXPR14 size_t bs1fnf0 = bs1.find_next(false, 0); - ETL_CONSTEXPR14 size_t bs1fnf1 = bs1.find_next(false, 1); - ETL_CONSTEXPR14 size_t bs1fnt2 = bs1.find_next(true, 2); - CHECK_EQUAL(0U, bs1fnf0); - CHECK_EQUAL(1U, bs1fnf1); - CHECK_EQUAL(etl::bitset<>::npos, bs1fnt2); + ETL_CONSTEXPR14 etl::bitset<8> bs1(ull(0x00)); + ETL_CONSTEXPR14 size_t bs1find_next_false0 = bs1.find_next(false, 0); + ETL_CONSTEXPR14 size_t bs1find_next_false1 = bs1.find_next(false, 1); + ETL_CONSTEXPR14 size_t bs1find_next_true2 = bs1.find_next(true, 2); + CHECK_EQUAL(0U, bs1find_next_false0); + CHECK_EQUAL(1U, bs1find_next_false1); + CHECK_EQUAL(etl::bitset<>::npos, bs1find_next_true2); - ETL_CONSTEXPR14 etl::bitset<9> bs2(ull(0x1FF)); - ETL_CONSTEXPR14 size_t bs2fnt0 = bs2.find_next(true, 0); - ETL_CONSTEXPR14 size_t bs2fnt1 = bs2.find_next(true, 1); - ETL_CONSTEXPR14 size_t bs2fnf2 = bs2.find_next(false, 2); - CHECK_EQUAL(0U, bs2fnt0); - CHECK_EQUAL(1U, bs2fnt1); - CHECK_EQUAL(etl::bitset<>::npos, bs2fnf2); + ETL_CONSTEXPR14 etl::bitset<8> bs2(ull(0xFF)); + ETL_CONSTEXPR14 size_t bs2find_next_true0 = bs2.find_next(true, 0); + ETL_CONSTEXPR14 size_t bs2find_next_true1 = bs2.find_next(true, 1); + ETL_CONSTEXPR14 size_t bs2find_next_false2 = bs2.find_next(false, 2); + CHECK_EQUAL(0U, bs2find_next_true0); + CHECK_EQUAL(1U, bs2find_next_true1); + CHECK_EQUAL(etl::bitset<>::npos, bs2find_next_false2); - ETL_CONSTEXPR14 etl::bitset<9> bs3(ull(0x000E)); - ETL_CONSTEXPR14 size_t bs3fnf0 = bs3.find_next(false, 0); - ETL_CONSTEXPR14 size_t bs3fnt1 = bs3.find_next(true, 1); - ETL_CONSTEXPR14 size_t bs3fnf2 = bs3.find_next(false, 2); - CHECK_EQUAL(0U, bs3fnf0); - CHECK_EQUAL(1U, bs3fnt1); - CHECK_EQUAL(4U, bs3fnf2); + ETL_CONSTEXPR14 etl::bitset<8> bs3(ull(0x0E)); + ETL_CONSTEXPR14 size_t bs3find_next_false0 = bs3.find_next(false, 0); + ETL_CONSTEXPR14 size_t bs3find_next_true1 = bs3.find_next(true, 1); + ETL_CONSTEXPR14 size_t bs3find_next_false2 = bs3.find_next(false, 2); + CHECK_EQUAL(0U, bs3find_next_false0); + CHECK_EQUAL(1U, bs3find_next_true1); + CHECK_EQUAL(4U, bs3find_next_false2); - ETL_CONSTEXPR14 etl::bitset<9> bs4(ull(0x0031)); - ETL_CONSTEXPR14 size_t bs4fnt0 = bs4.find_next(true, 0); - ETL_CONSTEXPR14 size_t bs4fnf0 = bs4.find_next(false, 0); - ETL_CONSTEXPR14 size_t bs4fnt1 = bs4.find_next(true, 1); - CHECK_EQUAL(0U, bs4fnt0); - CHECK_EQUAL(1U, bs4fnf0); - CHECK_EQUAL(4U, bs4fnt1); + ETL_CONSTEXPR14 etl::bitset<8> bs4(ull(0x31)); + ETL_CONSTEXPR14 size_t bs4find_next_true0 = bs4.find_next(true, 0); + ETL_CONSTEXPR14 size_t bs4find_next_false0 = bs4.find_next(false, 0); + ETL_CONSTEXPR14 size_t bs4find_next_true1 = bs4.find_next(true, 1); + CHECK_EQUAL(0U, bs4find_next_true0); + CHECK_EQUAL(1U, bs4find_next_false0); + CHECK_EQUAL(4U, bs4find_next_true1); } //************************************************************************* - TEST(test_find_next_github_issue_617) + ETL_CONSTEXPR14 std::pair, etl::bitset<8>> test_swap_helper() { - ETL_CONSTEXPR14 etl::bitset<64> bs1(ull(0xC000000000000031)); - ETL_CONSTEXPR14 size_t bs1fnt1 = bs1.find_next(true, 10); - ETL_CONSTEXPR14 size_t bs1fnt2 = bs1.find_next(true, 59); - CHECK_EQUAL(62U, bs1fnt1); - CHECK_EQUAL(62U, bs1fnt2); + etl::bitset<8> data1(ull(0x2A)); + etl::bitset<8> data2(ull(0x15)); - ETL_CONSTEXPR14 etl::bitset<64> bs2(ull(0x3FFFFFFFFFFFFFCE)); - ETL_CONSTEXPR14 size_t bs2fnf1 = bs2.find_next(false, 10); - ETL_CONSTEXPR14 size_t bs2fnf2 = bs2.find_next(false, 59); - CHECK_EQUAL(62U, bs2fnf1); - CHECK_EQUAL(62U, bs2fnf2); + swap(data1, data2); - ETL_CONSTEXPR14 etl::bitset<64, uint32_t> bs32(ull(0xC000000000000031)); - ETL_CONSTEXPR14 size_t bs32fnt1 = bs32.find_next(true, 10); - ETL_CONSTEXPR14 size_t bs32fnt2 = bs32.find_next(true, 59); - CHECK_EQUAL(62U, bs32fnt1); - CHECK_EQUAL(62U, bs32fnt2); + return std::pair, etl::bitset<8>>(data1, data2); } - //************************************************************************* - //************************************************************************* TEST(test_swap) { - etl::bitset<9> compare1(0x2A); - etl::bitset<9> compare2(0x15); - etl::bitset<9> compare1a(0x2A); - etl::bitset<9> compare2a(0x15); + ETL_CONSTEXPR14 etl::bitset<8> compare1(0x2A); + ETL_CONSTEXPR14 etl::bitset<8> compare2(0x15); - swap(compare1a, compare2a); + ETL_CONSTEXPR14 std::pair, etl::bitset<8>> swapped = test_swap_helper(); - CHECK(compare1 == compare2a); - CHECK(compare2 == compare1a); + CHECK(swapped.first == compare2); + CHECK(swapped.second == compare1); } //************************************************************************* @@ -2170,10 +2036,25 @@ namespace etl::bitset<32> b(0x12345678UL); span_t s = b.span(); - CHECK_EQUAL(0x78U, s[0]); - CHECK_EQUAL(0x56U, s[1]); - CHECK_EQUAL(0x34U, s[2]); - CHECK_EQUAL(0x12U, s[3]); + + if (etl::endianness::value() == etl::endian::little) + { + CHECK_EQUAL(0x78UL, s[0]); + CHECK_EQUAL(0x56UL, s[1]); + CHECK_EQUAL(0x34UL, s[2]); + CHECK_EQUAL(0x12UL, s[3]); + } + else + { + CHECK_EQUAL(0x78UL, s[3]); + CHECK_EQUAL(0x56UL, s[2]); + CHECK_EQUAL(0x34UL, s[1]); + CHECK_EQUAL(0x12UL, s[0]); + } + + s[2] = 0x9AU; + uint32_t value = b.value(); + CHECK_EQUAL(0x129A5678UL, value); } //************************************************************************* @@ -2184,28 +2065,44 @@ namespace const etl::bitset<32> b(0x12345678UL); span_t s = b.span(); - CHECK_EQUAL(0x78U, s[0]); - CHECK_EQUAL(0x56U, s[1]); - CHECK_EQUAL(0x34U, s[2]); - CHECK_EQUAL(0x12U, s[3]); + + if (etl::endianness::value() == etl::endian::little) + { + CHECK_EQUAL(0x78UL, s[0]); + CHECK_EQUAL(0x56UL, s[1]); + CHECK_EQUAL(0x34UL, s[2]); + CHECK_EQUAL(0x12UL, s[3]); + } + else + { + CHECK_EQUAL(0x78UL, s[3]); + CHECK_EQUAL(0x56UL, s[2]); + CHECK_EQUAL(0x34UL, s[1]); + CHECK_EQUAL(0x12UL, s[0]); + } } //************************************************************************* TEST(test_to_string) { - ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); + using bs32 = etl::bitset<32>; + + ETL_CONSTEXPR14 bs32 b(0x12345678UL); etl::string<32> text = b.to_string('.', '*'); - std::string stdtext = b.to_string('.', '*'); + std::string stdtext = b.to_string('.', '*'); - CHECK_EQUAL("...*..*...**.*...*.*.**..****...", text.c_str()); - CHECK_EQUAL("...*..*...**.*...*.*.**..****...", stdtext.c_str()); + //CHECK_THROW(b.to_string>('.', '*'), etl::bitset_overflow); + CHECK_EQUAL(std::string("...*..*...**.*...*.*.**..****..."), std::string(text.c_str())); + CHECK_EQUAL(std::string("...*..*...**.*...*.*.**..****..."), std::string(stdtext.c_str())); } //************************************************************************* TEST(test_to_wstring) { - ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); + using bs32 = etl::bitset<32>; + + ETL_CONSTEXPR14 bs32 b(0x12345678UL); etl::wstring<32> text = b.to_string>(L'.', L'*'); std::wstring stdtext = b.to_string(L'.', L'*'); @@ -2217,7 +2114,9 @@ namespace //************************************************************************* TEST(test_to_u16string) { - ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); + using bs32 = etl::bitset<32>; + + ETL_CONSTEXPR14 bs32 b(0x12345678UL); etl::u16string<32> text = b.to_string>(u'.', u'*'); std::u16string stdtext = b.to_string(u'.', u'*'); @@ -2229,7 +2128,9 @@ namespace //************************************************************************* TEST(test_to_u32string) { - ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); + using bs32 = etl::bitset<32>; + + ETL_CONSTEXPR14 bs32 b(0x12345678UL); etl::u32string<32> text = b.to_string>(U'.', U'*'); std::u32string stdtext = b.to_string(U'.', U'*'); @@ -2237,5 +2138,521 @@ namespace CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(text.c_str())); CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str())); } + + ////************************************************************************* + TEST(test_extract_6_bit_uint8_t_with_run_time_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract(0, 6))); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract(1, 6))); + CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract(2, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract(3, 6))); + CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract(4, 6))); + CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract(5, 6))); + CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract(6, 6))); + CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract(7, 6))); + CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract(8, 6))); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract(9, 6))); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract(10, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract(11, 6))); + CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract(12, 6))); + CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract(13, 6))); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract(14, 6))); + CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract(15, 6))); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract(16, 6))); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract(17, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract(18, 6))); + CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract(19, 6))); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract(20, 6))); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract(21, 6))); + CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract(22, 6))); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract(23, 6))); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract(24, 6))); + CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract(25, 6))); + CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract(26, 6))); + + CHECK_THROW(b.extract(26, 7), etl::bitset_overflow); + CHECK_THROW(b.extract(27, 6), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_6_bit_uint8_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract())); + + // The lines below should static assert. + //uint8_t v1 = b.extract(); + //uint8_t v1 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_6_bit_int8_t_with_run_time_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); + + CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract(0, 6))); + CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract(1, 6))); + CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract(2, 6))); + CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract(3, 6))); + CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract(4, 6))); + CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract(5, 6))); + CHECK_EQUAL_HEX(int8_t(0x19), (b.extract(6, 6))); + CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract(7, 6))); + CHECK_EQUAL_HEX(int8_t(0x16), (b.extract(8, 6))); + CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract(9, 6))); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract(10, 6))); + CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract(11, 6))); + CHECK_EQUAL_HEX(int8_t(0x05), (b.extract(12, 6))); + CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract(13, 6))); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract(14, 6))); + CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract(15, 6))); + CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract(16, 6))); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract(17, 6))); + CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract(18, 6))); + CHECK_EQUAL_HEX(int8_t(0x06), (b.extract(19, 6))); + CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract(20, 6))); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract(21, 6))); + CHECK_EQUAL_HEX(int8_t(0x08), (b.extract(22, 6))); + CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract(23, 6))); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract(24, 6))); + CHECK_EQUAL_HEX(int8_t(0x09), (b.extract(25, 6))); + CHECK_EQUAL_HEX(int8_t(0x04), (b.extract(26, 6))); + + CHECK_THROW(b.extract(26, 7), etl::bitset_overflow); + CHECK_THROW(b.extract(27, 6), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_6_bit_int8_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); + + CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x19), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x16), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x05), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x06), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x08), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x09), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x04), (b.extract())); + + // The lines below should static assert. + //int8_t v1 = b.extract(); + //int8_t v1 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_uint8_t_with_run_time_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint8_t(0x78), b.extract(0, 8)); + CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract(1, 8)); + CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract(2, 8)); + CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract(3, 8)); + CHECK_EQUAL_HEX(uint8_t(0x67), b.extract(4, 8)); + CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract(5, 8)); + CHECK_EQUAL_HEX(uint8_t(0x59), b.extract(6, 8)); + CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract(7, 8)); + CHECK_EQUAL_HEX(uint8_t(0x56), b.extract(8, 8)); + CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract(9, 8)); + CHECK_EQUAL_HEX(uint8_t(0x15), b.extract(10, 8)); + CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract(11, 8)); + CHECK_EQUAL_HEX(uint8_t(0x45), b.extract(12, 8)); + CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract(13, 8)); + CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract(14, 8)); + CHECK_EQUAL_HEX(uint8_t(0x68), b.extract(15, 8)); + CHECK_EQUAL_HEX(uint8_t(0x34), b.extract(16, 8)); + CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract(17, 8)); + CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract(18, 8)); + CHECK_EQUAL_HEX(uint8_t(0x46), b.extract(19, 8)); + CHECK_EQUAL_HEX(uint8_t(0x23), b.extract(20, 8)); + CHECK_EQUAL_HEX(uint8_t(0x91), b.extract(21, 8)); + CHECK_EQUAL_HEX(uint8_t(0x48), b.extract(22, 8)); + CHECK_EQUAL_HEX(uint8_t(0x24), b.extract(23, 8)); + CHECK_EQUAL_HEX(uint8_t(0x12), b.extract(24, 8)); + + CHECK_THROW(b.extract(24, 9), etl::bitset_overflow); + CHECK_THROW(b.extract(25, 8), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_uint8_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract())); + + // The lines below should static assert. + //uint8_t v1 = b.extract(); + //uint8_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_int8_t_with_run_time_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); + + CHECK_EQUAL_HEX(int8_t(0x78), b.extract(0, 8)); + CHECK_EQUAL_HEX(int8_t(0x3C), b.extract(1, 8)); + CHECK_EQUAL_HEX(int8_t(0x9E), b.extract(2, 8)); + CHECK_EQUAL_HEX(int8_t(0xCF), b.extract(3, 8)); + CHECK_EQUAL_HEX(int8_t(0x67), b.extract(4, 8)); + CHECK_EQUAL_HEX(int8_t(0xB3), b.extract(5, 8)); + CHECK_EQUAL_HEX(int8_t(0x59), b.extract(6, 8)); + CHECK_EQUAL_HEX(int8_t(0xAC), b.extract(7, 8)); + CHECK_EQUAL_HEX(int8_t(0x56), b.extract(8, 8)); + CHECK_EQUAL_HEX(int8_t(0x2B), b.extract(9, 8)); + CHECK_EQUAL_HEX(int8_t(0x15), b.extract(10, 8)); + CHECK_EQUAL_HEX(int8_t(0x8A), b.extract(11, 8)); + CHECK_EQUAL_HEX(int8_t(0x45), b.extract(12, 8)); + CHECK_EQUAL_HEX(int8_t(0xA2), b.extract(13, 8)); + CHECK_EQUAL_HEX(int8_t(0xD1), b.extract(14, 8)); + CHECK_EQUAL_HEX(int8_t(0x68), b.extract(15, 8)); + CHECK_EQUAL_HEX(int8_t(0x34), b.extract(16, 8)); + CHECK_EQUAL_HEX(int8_t(0x1A), b.extract(17, 8)); + CHECK_EQUAL_HEX(int8_t(0x8D), b.extract(18, 8)); + CHECK_EQUAL_HEX(int8_t(0x46), b.extract(19, 8)); + CHECK_EQUAL_HEX(int8_t(0x23), b.extract(20, 8)); + CHECK_EQUAL_HEX(int8_t(0x91), b.extract(21, 8)); + CHECK_EQUAL_HEX(int8_t(0x48), b.extract(22, 8)); + CHECK_EQUAL_HEX(int8_t(0x24), b.extract(23, 8)); + CHECK_EQUAL_HEX(int8_t(0x12), b.extract(24, 8)); + + CHECK_THROW(b.extract(24, 9), etl::bitset_overflow); + CHECK_THROW(b.extract(25, 8), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_int8_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); + + CHECK_EQUAL_HEX(int8_t(0x78), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x67), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x59), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x56), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x8A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x45), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xA2), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xD1), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x68), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x8D), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x46), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x91), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x48), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract())); + + // The lines below should static assert. + //int8_t v1 = b.extract(); + //int8_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_13_bits_uint16_t_with_run_time_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract(0, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract(1, 13)); + CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract(2, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract(3, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract(4, 13)); + CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract(5, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract(6, 13)); + CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract(7, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract(8, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract(9, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract(10, 13)); + CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract(11, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract(12, 13)); + CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract(13, 13)); + CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract(14, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract(15, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract(16, 13)); + CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract(17, 13)); + CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract(18, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract(19, 13)); + + CHECK_THROW(b.extract(19, 14), etl::bitset_overflow); + CHECK_THROW(b.extract(20, 13), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_13_bits_uint16_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract())); + + // The lines below should static assert. + //uint16_t v1 = b.extract b(0x12345678UL); + + CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract(0, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract(1, 16)); + CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract(2, 16)); + CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract(3, 16)); + CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract(4, 16)); + CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract(5, 16)); + CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract(6, 16)); + CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract(7, 16)); + CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract(8, 16)); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract(9, 16)); + CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract(10, 16)); + CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract(11, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract(12, 16)); + CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract(13, 16)); + CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract(14, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract(15, 16)); + CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract(16, 16)); + + CHECK_THROW(b.extract(16, 17), etl::bitset_overflow); + CHECK_THROW(b.extract(17, 16), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_uint16_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract())); + + // The lines below should static assert. + //uint16_t v1 = b.extract(); + //uint16_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_int16_t_with_run_time_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); + + CHECK_EQUAL_HEX(int16_t(0x5678), b.extract(0, 16)); + CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract(1, 16)); + CHECK_EQUAL_HEX(int16_t(0x159E), b.extract(2, 16)); + CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract(3, 16)); + CHECK_EQUAL_HEX(int16_t(0x4567), b.extract(4, 16)); + CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract(5, 16)); + CHECK_EQUAL_HEX(int16_t(0xD159), b.extract(6, 16)); + CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract(7, 16)); + CHECK_EQUAL_HEX(int16_t(0x3456), b.extract(8, 16)); + CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract(9, 16)); + CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract(10, 16)); + CHECK_EQUAL_HEX(int16_t(0x468A), b.extract(11, 16)); + CHECK_EQUAL_HEX(int16_t(0x2345), b.extract(12, 16)); + CHECK_EQUAL_HEX(int16_t(0x91A2), b.extract(13, 16)); + CHECK_EQUAL_HEX(int16_t(0x48D1), b.extract(14, 16)); + CHECK_EQUAL_HEX(int16_t(0x2468), b.extract(15, 16)); + CHECK_EQUAL_HEX(int16_t(0x1234), b.extract(16, 16)); + + CHECK_THROW(b.extract(16, 17), etl::bitset_overflow); + CHECK_THROW(b.extract(17, 16), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_int16_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); + + CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x91A2), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x48D1), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x2468), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x1234), (b.extract())); + + // The lines below should static assert. + //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 78de4ef3..91411477 100644 --- a/test/test_bitset_new_explicit_single_element_type.cpp +++ b/test/test_bitset_new_explicit_single_element_type.cpp @@ -117,13 +117,84 @@ namespace return data2; } - SUITE(test_bitset_new_implicit_element_type) + 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) { ETL_CONSTEXPR14 std::bitset<64> compare; - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data; + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data; CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -137,22 +208,32 @@ namespace //************************************************************************* TEST(test_default_constructor_single_element) { - etl::bitset<8, int8_t> data8; - etl::bitset<16, int16_t> data16; - etl::bitset<32, int32_t> data32; - etl::bitset<64, int64_t> data64; + etl::bitset<8, uint8_t> data8; + etl::bitset<16, uint16_t> data16; + etl::bitset<32, uint32_t> data32; + etl::bitset<64, uint64_t> data64; + + CHECK_EQUAL(8, data8.Size); + CHECK_EQUAL(16, data16.Size); + CHECK_EQUAL(32, data32.Size); + CHECK_EQUAL(64, data64.Size); CHECK_EQUAL(1U, data8.Number_Of_Elements); CHECK_EQUAL(1U, data16.Number_Of_Elements); CHECK_EQUAL(1U, data32.Number_Of_Elements); CHECK_EQUAL(1U, data64.Number_Of_Elements); + + CHECK_EQUAL(etl::bitset_storage_model::Single, data8.Storage_Model); + CHECK_EQUAL(etl::bitset_storage_model::Single, data16.Storage_Model); + CHECK_EQUAL(etl::bitset_storage_model::Single, data32.Storage_Model); + CHECK_EQUAL(etl::bitset_storage_model::Single, data64.Storage_Model); } //************************************************************************* TEST(test_construct_from_value) { ETL_CONSTEXPR14 std::bitset<64> compare(0x123456731234567ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x123456731234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(0x123456731234567ULL); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -168,10 +249,10 @@ namespace TEST(test_copy_construct) { ETL_CONSTEXPR14 std::bitset<64> compare(0x123456731234567ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x123456731234567ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data_copy(data); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(0x123456731234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data_copy(data); - CHECK_EQUAL(compare.size(), data_copy.size()); + CHECK_EQUAL(compare.size(), data_copy.size()); CHECK_EQUAL(compare.count(), data_copy.count()); for (size_t i = 0UL; i < data_copy.size(); ++i) @@ -184,7 +265,7 @@ namespace TEST(test_construct_from_excess_value) { ETL_CONSTEXPR14 std::bitset<64> compare(0x8765432187654321ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x8765432187654321ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(0x8765432187654321ULL); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -199,7 +280,7 @@ namespace TEST(test_construct_from_char_string) { std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data("110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64, uint64_t> data("110001001000110100010101100111001100010010001101000101011001"); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -214,9 +295,9 @@ namespace TEST(test_construct_from_wchar_t_string) { std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data(L"110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64, uint64_t> data(L"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); for (size_t i = 0UL; i < data.size(); ++i) @@ -229,9 +310,9 @@ namespace TEST(test_construct_from_char16_t_string) { std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data(u"110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64, uint64_t> data(u"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); for (size_t i = 0UL; i < data.size(); ++i) @@ -244,9 +325,9 @@ namespace TEST(test_construct_from_char32_t_string) { std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data(U"110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64, uint64_t> data(U"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); for (size_t i = 0UL; i < data.size(); ++i) @@ -260,7 +341,7 @@ namespace { const char* s = nullptr; - etl::bitset<60, int64_t> data(s); + etl::bitset<60, uint64_t> data(s); CHECK_EQUAL(60, data.size()); CHECK_EQUAL(0, data.count()); @@ -271,10 +352,10 @@ namespace { const wchar_t* s = nullptr; - etl::bitset<60, int64_t> data(s); + etl::bitset<60, uint64_t> data(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* @@ -282,10 +363,10 @@ namespace { const char16_t* s = nullptr; - etl::bitset<60, int64_t> data(s); + etl::bitset<60, uint64_t> data(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* @@ -293,17 +374,17 @@ namespace { const char32_t* s = nullptr; - etl::bitset<60, int64_t> data(s); + etl::bitset<60, uint64_t> data(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* TEST(test_construct_from_excess_string) { std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001111100001"); - etl::bitset<64, int64_t> data("110001001000110100010101100111001100010010001101000101011001111100001"); + etl::bitset<64, uint64_t> data("110001001000110100010101100111001100010010001101000101011001111100001"); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -320,9 +401,9 @@ namespace } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_set_helper() + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_helper() { - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.set(); return data; @@ -331,7 +412,7 @@ namespace TEST(test_set) { std::bitset<64> compare; - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_set_helper()); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_helper()); compare.set(); @@ -353,11 +434,313 @@ namespace } } + //************************************************************************* + TEST(test_set_less_than_full_size) + { + std::bitset<60> compare; + etl::bitset<60, uint64_t> data; + + compare.set(); + data.set(); + + 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)); + } + } + + //************************************************************************* + 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) { std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.set("110001001000110100010101100111001100010010001101000101011001"); @@ -377,15 +760,15 @@ namespace TEST(test_set_with_wchar_t_string) { std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.set(L"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -397,15 +780,15 @@ namespace TEST(test_set_with_char16_t_string) { std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.set(u"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -417,15 +800,15 @@ namespace TEST(test_set_with_char32_t_string) { std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.set(U"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -438,11 +821,11 @@ namespace { const char* s = nullptr; - etl::bitset<60, int64_t> data; + etl::bitset<60, uint64_t> data; data.set(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* @@ -450,11 +833,11 @@ namespace { const wchar_t* s = nullptr; - etl::bitset<60, int64_t> data; + etl::bitset<60, uint64_t> data; data.set(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* @@ -462,11 +845,11 @@ namespace { const char16_t* s = nullptr; - etl::bitset<60, int64_t> data; + etl::bitset<60, uint64_t> data; data.set(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* @@ -474,26 +857,26 @@ namespace { const char32_t* s = nullptr; - etl::bitset<60, int64_t> data; + etl::bitset<60, uint64_t> data; data.set(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* TEST(test_from_string_with_char) { std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.from_string("110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -505,15 +888,15 @@ namespace TEST(test_from_string_with_wchar_t) { std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.from_string(L"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -522,18 +905,18 @@ namespace } //************************************************************************* - TEST(test_from_char16_t_6string) + TEST(test_from_string_with_char16_t) { std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.from_string(u"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -545,15 +928,15 @@ namespace TEST(test_from_string_with_char32_t) { std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.from_string(U"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -566,11 +949,11 @@ namespace { const char* s = nullptr; - etl::bitset<60, int64_t> data; + etl::bitset<60, uint64_t> data; data.from_string(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* @@ -578,11 +961,11 @@ namespace { const wchar_t* s = nullptr; - etl::bitset<60, int64_t> data; + etl::bitset<60, uint64_t> data; data.from_string(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* @@ -590,11 +973,11 @@ namespace { const char16_t* s = nullptr; - etl::bitset<60, int64_t> data; + etl::bitset<60, uint64_t> data; data.from_string(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* @@ -602,11 +985,11 @@ namespace { const char32_t* s = nullptr; - etl::bitset<60, int64_t> data; + etl::bitset<60, uint64_t> data; data.from_string(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* @@ -721,7 +1104,7 @@ namespace TEST(test_value_u64_min) { ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::min); - ETL_CONSTEXPR14 int64_t value = data.value(); + ETL_CONSTEXPR14 uint64_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -730,7 +1113,7 @@ namespace TEST(test_value_u64_max) { ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::max); - ETL_CONSTEXPR14 int64_t value = data.value(); + ETL_CONSTEXPR14 uint64_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -739,7 +1122,7 @@ namespace TEST(test_value_s64_min) { ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::min); - ETL_CONSTEXPR14 int64_t value = data.value(); + ETL_CONSTEXPR14 uint64_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -748,7 +1131,7 @@ namespace TEST(test_value_s64_max) { ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::max); - ETL_CONSTEXPR14 int64_t value = data.value(); + ETL_CONSTEXPR14 uint64_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -757,7 +1140,7 @@ namespace TEST(test_position_set) { std::bitset<64> compare; - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; for (size_t i = 0UL; i < data.size(); ++i) { @@ -786,9 +1169,9 @@ namespace } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_reset_helper() + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_reset_helper() { - etl::bitset<64, int64_t> data(0xFFFFFFFFFFFFFFFULL); + etl::bitset<64, uint64_t> data(0xFFFFFFFFFFFFFFFULL); data.reset(); return data; @@ -797,7 +1180,7 @@ namespace TEST(test_reset) { std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_reset_helper()); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_reset_helper()); compare.reset(); @@ -814,9 +1197,9 @@ namespace } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_position_reset_helper() + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_position_reset_helper() { - etl::bitset<64, int64_t> data(0xFFFFFFFFFFFFFFFULL); + etl::bitset<64, uint64_t> data(0xFFFFFFFFFFFFFFFULL); data.reset(1); data.reset(3); data.reset(7); @@ -828,7 +1211,7 @@ namespace TEST(test_position_reset) { std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_position_reset_helper()); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_position_reset_helper()); compare.reset(1); compare.reset(3); @@ -875,7 +1258,7 @@ namespace TEST(test_index_operator_read) { ETL_CONSTEXPR14 std::bitset<64> compare(0x3123456731234567ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x3123456731234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(0x3123456731234567ULL); ETL_CONSTEXPR14 bool bc0 = compare[1U]; ETL_CONSTEXPR14 bool bd0 = data[1U]; @@ -895,9 +1278,9 @@ namespace } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_index_operator_write_helper() + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_index_operator_write_helper() { - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data[1U] = true; data[3U] = true; @@ -909,7 +1292,7 @@ namespace TEST(test_index_operator_write) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_index_operator_write_helper()); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_index_operator_write_helper()); CHECK(data[1U]); CHECK(data[3U]); @@ -920,10 +1303,10 @@ namespace //************************************************************************* TEST(test_any) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); ETL_CONSTEXPR14 bool bd1 = data1.any(); ETL_CONSTEXPR14 bool bd2 = data2.any(); @@ -939,10 +1322,10 @@ namespace //************************************************************************* TEST(test_any_with_mask) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0xF000000000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0xF000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF); @@ -960,10 +1343,10 @@ namespace //************************************************************************* TEST(test_none) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); ETL_CONSTEXPR14 bool bd1 = data1.none(); ETL_CONSTEXPR14 bool bd2 = data2.none(); @@ -979,10 +1362,10 @@ namespace //************************************************************************* TEST(test_none_with_mask) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0xF000000000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0xF000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF); @@ -1000,10 +1383,10 @@ namespace //************************************************************************* TEST(test_all) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); ETL_CONSTEXPR14 bool bd1 = data1.all(); ETL_CONSTEXPR14 bool bd2 = data2.all(); @@ -1019,10 +1402,10 @@ namespace //************************************************************************* TEST(test_all_with_mask) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0x0FFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0x0FFFFFFFFFFFFFFF)); ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF); @@ -1038,9 +1421,129 @@ namespace } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_flip_helper() + TEST(test_any_with_reduced_active_bits) { - etl::bitset<64, int64_t> data; + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + + ETL_CONSTEXPR14 bool bd1 = data1.any(); + ETL_CONSTEXPR14 bool bd2 = data2.any(); + ETL_CONSTEXPR14 bool bd3 = data3.any(); + ETL_CONSTEXPR14 bool bd4 = data4.any(); + + CHECK_FALSE(bd1); + CHECK_TRUE(bd2); + CHECK_TRUE(bd3); + CHECK_TRUE(bd4); + } + + //************************************************************************* + TEST(test_any_with_mask_with_reduced_active_bits) + { + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0xF000000000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + + ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF); + + ETL_CONSTEXPR14 bool bd1 = data1.any(mask); + ETL_CONSTEXPR14 bool bd2 = data2.any(mask); + ETL_CONSTEXPR14 bool bd3 = data3.any(mask); + ETL_CONSTEXPR14 bool bd4 = data4.any(mask); + + CHECK_FALSE(bd1); + CHECK_TRUE(bd2); + CHECK_TRUE(bd3); + CHECK_TRUE(bd4); + } + + //************************************************************************* + TEST(test_none_with_reduced_active_bits) + { + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + + ETL_CONSTEXPR14 bool bd1 = data1.none(); + ETL_CONSTEXPR14 bool bd2 = data2.none(); + ETL_CONSTEXPR14 bool bd3 = data3.none(); + ETL_CONSTEXPR14 bool bd4 = data4.none(); + + CHECK_TRUE(bd1); + CHECK_FALSE(bd2); + CHECK_FALSE(bd3); + CHECK_FALSE(bd4); + } + + //************************************************************************* + TEST(test_none_with_mask_with_reduced_active_bits) + { + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0xF000000000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + + ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF); + + ETL_CONSTEXPR14 bool bd1 = data1.none(mask); + ETL_CONSTEXPR14 bool bd2 = data2.none(mask); + ETL_CONSTEXPR14 bool bd3 = data3.none(mask); + ETL_CONSTEXPR14 bool bd4 = data4.none(mask); + + CHECK_TRUE(bd1); + CHECK_FALSE(bd2); + CHECK_FALSE(bd3); + CHECK_FALSE(bd4); + } + + //************************************************************************* + TEST(test_all_with_reduced_active_bits) + { + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + + ETL_CONSTEXPR14 bool bd1 = data1.all(); + ETL_CONSTEXPR14 bool bd2 = data2.all(); + ETL_CONSTEXPR14 bool bd3 = data3.all(); + ETL_CONSTEXPR14 bool bd4 = data4.all(); + + CHECK_FALSE(bd1); + CHECK_FALSE(bd2); + CHECK_FALSE(bd3); + CHECK_TRUE(bd4); + } + + //************************************************************************* + TEST(test_all_with_mask_with_reduced_active_bits) + { + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0x0FFFFFFFFFFFFFFF)); + + ETL_CONSTEXPR14 ull mask = ull(0x00FFFFFFFFFFFFFF); + + ETL_CONSTEXPR14 bool bd1 = data1.all(mask); + ETL_CONSTEXPR14 bool bd2 = data2.all(mask); + ETL_CONSTEXPR14 bool bd3 = data3.all(mask); + ETL_CONSTEXPR14 bool bd4 = data4.all(mask); + + CHECK_FALSE(bd1); + CHECK_FALSE(bd2); + CHECK_FALSE(bd3); + CHECK_TRUE(bd4); + } + + //************************************************************************* + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_flip_helper() + { + etl::bitset<64, uint64_t> data; data.flip(); return data; @@ -1049,7 +1552,7 @@ namespace TEST(test_flip) { std::bitset<64> compare; - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_flip_helper()); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_flip_helper()); compare.flip(); @@ -1060,9 +1563,9 @@ namespace } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_flip_position_helper() + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_flip_position_helper() { - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.flip(1); data.flip(3); data.flip(7); @@ -1074,7 +1577,7 @@ namespace TEST(test_flip_position) { std::bitset<64> compare; - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_flip_position_helper()); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_flip_position_helper()); compare.flip(1); compare.flip(3); @@ -1088,9 +1591,9 @@ namespace } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_flip_reference_helper() + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_flip_reference_helper() { - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data[1].flip(); data[3].flip(); data[7].flip(); @@ -1102,7 +1605,7 @@ namespace TEST(test_flip_reference) { std::bitset<64> compare; - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_flip_reference_helper()); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_flip_reference_helper()); compare[1].flip(); compare[3].flip(); @@ -1119,7 +1622,7 @@ namespace TEST(test_invert_reference) { std::bitset<64> compare; - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; bool bc = ~compare[3]; bool bd = ~data[3]; @@ -1127,7 +1630,7 @@ namespace } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_assignment_operator_helper(etl::bitset<64, int64_t> to, const etl::bitset<64, int64_t>& from) + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_assignment_operator_helper(etl::bitset<64, uint64_t> to, const etl::bitset<64, uint64_t>& from) { to = from; @@ -1137,8 +1640,8 @@ namespace TEST(test_assignment_operator) { ETL_CONSTEXPR14 std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0xFFFFFFFFFFFFFFFULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(test_assignment_operator_helper(etl::bitset<64, int64_t>(), data1)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0xFFFFFFFFFFFFFFFULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(test_assignment_operator_helper(etl::bitset<64, uint64_t>(), data1)); for (size_t i = 0UL; i < data2.size(); ++i) { @@ -1149,9 +1652,9 @@ namespace //************************************************************************* TEST(test_equality_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x123456781234567ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x123456781234567ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3; + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3; ETL_CONSTEXPR14 bool equal = (data1 == data2); ETL_CONSTEXPR14 bool not_equal = !(data1 == data3); @@ -1163,9 +1666,9 @@ namespace //************************************************************************* TEST(test_inequality_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x123456781234567ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x123456781234567ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3; + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3; ETL_CONSTEXPR14 bool equal = !(data1 != data2); ETL_CONSTEXPR14 bool not_equal = (data1 != data3); @@ -1177,38 +1680,38 @@ namespace //************************************************************************* TEST(test_shift_left_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift1(0x2468ACF0ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift2(0x48D159E0ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift11(0x91A2B3C000ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift1(0x2468ACF0ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift2(0x48D159E0ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift11(0x91A2B3C000ULL); - CHECK((generate_shift_left_bitset<64, int64_t>(0x12345678ULL, 1U)) == shift1); - CHECK((generate_shift_left_bitset<64, int64_t>(0x12345678ULL, 2U)) == shift2); - CHECK((generate_shift_left_bitset<64, int64_t>(0x12345678ULL, 11U)) == shift11); + CHECK((generate_shift_left_bitset<64, uint64_t>(0x12345678ULL, 1U)) == shift1); + CHECK((generate_shift_left_bitset<64, uint64_t>(0x12345678ULL, 2U)) == shift2); + CHECK((generate_shift_left_bitset<64, uint64_t>(0x12345678ULL, 11U)) == shift11); } //************************************************************************* TEST(test_shift_left_operator_overflow) { - ETL_CONSTEXPR14 etl::bitset<32, int32_t> data(generate_shift_left_bitset<32, int32_t>(0x7FFFFFFFULL, 1U)); - ETL_CONSTEXPR14 etl::bitset<32, int32_t> shifted(0xFFFFFFFEUL); + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> data(generate_shift_left_bitset<32, uint32_t>(0x7FFFFFFFULL, 1U)); + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> shifted(0xFFFFFFFEUL); - CHECK_EQUAL_HEX(shifted.value(), data.value()); + CHECK_EQUAL_HEX(shifted.value(), data.value()); } //************************************************************************* TEST(test_shift_left_copy_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift8(0x1234567800ULL); - CHECK_EQUAL_HEX(shift8.value(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 8U).value())); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift8(0x1234567800ULL); + CHECK_EQUAL_HEX(shift8.value(), (generate_shift_left_bitset_copy<64, uint64_t>(0x12345678UL, 8U).value())); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift16(0x123456780000ULL); - CHECK_EQUAL_HEX(shift16.value(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 16U).value())); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift16(0x123456780000ULL); + CHECK_EQUAL_HEX(shift16.value(), (generate_shift_left_bitset_copy<64, uint64_t>(0x12345678UL, 16U).value())); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift24(0x12345678000000ULL); - CHECK_EQUAL_HEX(shift24.value(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 24U).value())); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift24(0x12345678000000ULL); + CHECK_EQUAL_HEX(shift24.value(), (generate_shift_left_bitset_copy<64, uint64_t>(0x12345678UL, 24U).value())); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift64(0x0000000000000000ULL); - CHECK_EQUAL_HEX(shift64.value(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 64U).value())); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift64(0x0000000000000000ULL); + CHECK_EQUAL_HEX(shift64.value(), (generate_shift_left_bitset_copy<64, uint64_t>(0x12345678UL, 64U).value())); } //************************************************************************* @@ -1286,189 +1789,189 @@ namespace //************************************************************************* TEST(test_shift_right_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift1(0x91A2B3CULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift2(0x48D159EULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift11(0x2468AULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift1(0x91A2B3CULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift2(0x48D159EULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift11(0x2468AULL); - CHECK_EQUAL_HEX(shift1.value(), (generate_shift_right_bitset<64, int64_t>(0x12345678ULL, 1U).value())); - CHECK_EQUAL_HEX(shift2.value(), (generate_shift_right_bitset<64, int64_t>(0x12345678ULL, 2U).value())); - CHECK_EQUAL_HEX(shift11.value(), (generate_shift_right_bitset<64, int64_t>(0x12345678ULL, 11U).value())); + CHECK_EQUAL_HEX(shift1.value(), (generate_shift_right_bitset<64, uint64_t>(0x12345678ULL, 1U).value())); + CHECK_EQUAL_HEX(shift2.value(), (generate_shift_right_bitset<64, uint64_t>(0x12345678ULL, 2U).value())); + CHECK_EQUAL_HEX(shift11.value(), (generate_shift_right_bitset<64, uint64_t>(0x12345678ULL, 11U).value())); } //************************************************************************* TEST(test_shift_right_copy_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift8(0x123456ULL); - CHECK_EQUAL_HEX(shift8.value(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 8U).value())); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift8(0x123456ULL); + CHECK_EQUAL_HEX(shift8.value(), (generate_shift_right_bitset_copy<64, uint64_t>(0x12345678UL, 8U).value())); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift16(0x1234ULL); - CHECK_EQUAL_HEX(shift16.value(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 16U).value())); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift16(0x1234ULL); + CHECK_EQUAL_HEX(shift16.value(), (generate_shift_right_bitset_copy<64, uint64_t>(0x12345678UL, 16U).value())); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift24(0x12ULL); - CHECK_EQUAL_HEX(shift24.value(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 24U).value())); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift24(0x12ULL); + CHECK_EQUAL_HEX(shift24.value(), (generate_shift_right_bitset_copy<64, uint64_t>(0x12345678UL, 24U).value())); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift60(0x00ULL); - CHECK_EQUAL_HEX(shift60.value(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 60U).value())); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift60(0x00ULL); + CHECK_EQUAL_HEX(shift60.value(), (generate_shift_right_bitset_copy<64, uint64_t>(0x12345678UL, 60U).value())); } //************************************************************************* TEST(test_shift_right_operator_all_shifts_full_size) { - int64_t value = 0x0123456789ABCDEFULL; + uint64_t value = 0x0123456789ABCDEFULL; - CHECK_EQUAL_HEX((value >> 0U), (generate_shift_right_bitset<64, int64_t>(value, 0U).value())); - CHECK_EQUAL_HEX((value >> 1U), (generate_shift_right_bitset<64, int64_t>(value, 1U).value())); - CHECK_EQUAL_HEX((value >> 2U), (generate_shift_right_bitset<64, int64_t>(value, 2U).value())); - CHECK_EQUAL_HEX((value >> 3U), (generate_shift_right_bitset<64, int64_t>(value, 3U).value())); - CHECK_EQUAL_HEX((value >> 4U), (generate_shift_right_bitset<64, int64_t>(value, 4U).value())); - CHECK_EQUAL_HEX((value >> 5U), (generate_shift_right_bitset<64, int64_t>(value, 5U).value())); - CHECK_EQUAL_HEX((value >> 6U), (generate_shift_right_bitset<64, int64_t>(value, 6U).value())); - CHECK_EQUAL_HEX((value >> 7U), (generate_shift_right_bitset<64, int64_t>(value, 7U).value())); - CHECK_EQUAL_HEX((value >> 8U), (generate_shift_right_bitset<64, int64_t>(value, 8U).value())); - CHECK_EQUAL_HEX((value >> 9U), (generate_shift_right_bitset<64, int64_t>(value, 9U).value())); - CHECK_EQUAL_HEX((value >> 10U), (generate_shift_right_bitset<64, int64_t>(value, 10U).value())); - CHECK_EQUAL_HEX((value >> 11U), (generate_shift_right_bitset<64, int64_t>(value, 11U).value())); - CHECK_EQUAL_HEX((value >> 12U), (generate_shift_right_bitset<64, int64_t>(value, 12U).value())); - CHECK_EQUAL_HEX((value >> 13U), (generate_shift_right_bitset<64, int64_t>(value, 13U).value())); - CHECK_EQUAL_HEX((value >> 14U), (generate_shift_right_bitset<64, int64_t>(value, 14U).value())); - CHECK_EQUAL_HEX((value >> 15U), (generate_shift_right_bitset<64, int64_t>(value, 15U).value())); - CHECK_EQUAL_HEX((value >> 16U), (generate_shift_right_bitset<64, int64_t>(value, 16U).value())); - CHECK_EQUAL_HEX((value >> 17U), (generate_shift_right_bitset<64, int64_t>(value, 17U).value())); - CHECK_EQUAL_HEX((value >> 18U), (generate_shift_right_bitset<64, int64_t>(value, 18U).value())); - CHECK_EQUAL_HEX((value >> 19U), (generate_shift_right_bitset<64, int64_t>(value, 19U).value())); - CHECK_EQUAL_HEX((value >> 20U), (generate_shift_right_bitset<64, int64_t>(value, 20U).value())); - CHECK_EQUAL_HEX((value >> 21U), (generate_shift_right_bitset<64, int64_t>(value, 21U).value())); - CHECK_EQUAL_HEX((value >> 22U), (generate_shift_right_bitset<64, int64_t>(value, 22U).value())); - CHECK_EQUAL_HEX((value >> 23U), (generate_shift_right_bitset<64, int64_t>(value, 23U).value())); - CHECK_EQUAL_HEX((value >> 24U), (generate_shift_right_bitset<64, int64_t>(value, 24U).value())); - CHECK_EQUAL_HEX((value >> 25U), (generate_shift_right_bitset<64, int64_t>(value, 25U).value())); - CHECK_EQUAL_HEX((value >> 26U), (generate_shift_right_bitset<64, int64_t>(value, 26U).value())); - CHECK_EQUAL_HEX((value >> 27U), (generate_shift_right_bitset<64, int64_t>(value, 27U).value())); - CHECK_EQUAL_HEX((value >> 28U), (generate_shift_right_bitset<64, int64_t>(value, 28U).value())); - CHECK_EQUAL_HEX((value >> 29U), (generate_shift_right_bitset<64, int64_t>(value, 29U).value())); - CHECK_EQUAL_HEX((value >> 30U), (generate_shift_right_bitset<64, int64_t>(value, 30U).value())); - CHECK_EQUAL_HEX((value >> 31U), (generate_shift_right_bitset<64, int64_t>(value, 31U).value())); - CHECK_EQUAL_HEX((value >> 32U), (generate_shift_right_bitset<64, int64_t>(value, 32U).value())); - CHECK_EQUAL_HEX((value >> 33U), (generate_shift_right_bitset<64, int64_t>(value, 33U).value())); - CHECK_EQUAL_HEX((value >> 34U), (generate_shift_right_bitset<64, int64_t>(value, 34U).value())); - CHECK_EQUAL_HEX((value >> 35U), (generate_shift_right_bitset<64, int64_t>(value, 35U).value())); - CHECK_EQUAL_HEX((value >> 36U), (generate_shift_right_bitset<64, int64_t>(value, 36U).value())); - CHECK_EQUAL_HEX((value >> 37U), (generate_shift_right_bitset<64, int64_t>(value, 37U).value())); - CHECK_EQUAL_HEX((value >> 38U), (generate_shift_right_bitset<64, int64_t>(value, 38U).value())); - CHECK_EQUAL_HEX((value >> 39U), (generate_shift_right_bitset<64, int64_t>(value, 39U).value())); - CHECK_EQUAL_HEX((value >> 40U), (generate_shift_right_bitset<64, int64_t>(value, 40U).value())); - CHECK_EQUAL_HEX((value >> 41U), (generate_shift_right_bitset<64, int64_t>(value, 41U).value())); - CHECK_EQUAL_HEX((value >> 42U), (generate_shift_right_bitset<64, int64_t>(value, 42U).value())); - CHECK_EQUAL_HEX((value >> 43U), (generate_shift_right_bitset<64, int64_t>(value, 43U).value())); - CHECK_EQUAL_HEX((value >> 44U), (generate_shift_right_bitset<64, int64_t>(value, 44U).value())); - CHECK_EQUAL_HEX((value >> 45U), (generate_shift_right_bitset<64, int64_t>(value, 45U).value())); - CHECK_EQUAL_HEX((value >> 46U), (generate_shift_right_bitset<64, int64_t>(value, 46U).value())); - CHECK_EQUAL_HEX((value >> 47U), (generate_shift_right_bitset<64, int64_t>(value, 47U).value())); - CHECK_EQUAL_HEX((value >> 48U), (generate_shift_right_bitset<64, int64_t>(value, 48U).value())); - CHECK_EQUAL_HEX((value >> 49U), (generate_shift_right_bitset<64, int64_t>(value, 49U).value())); - CHECK_EQUAL_HEX((value >> 50U), (generate_shift_right_bitset<64, int64_t>(value, 50U).value())); - CHECK_EQUAL_HEX((value >> 51U), (generate_shift_right_bitset<64, int64_t>(value, 51U).value())); - CHECK_EQUAL_HEX((value >> 52U), (generate_shift_right_bitset<64, int64_t>(value, 52U).value())); - CHECK_EQUAL_HEX((value >> 53U), (generate_shift_right_bitset<64, int64_t>(value, 53U).value())); - CHECK_EQUAL_HEX((value >> 54U), (generate_shift_right_bitset<64, int64_t>(value, 54U).value())); - CHECK_EQUAL_HEX((value >> 55U), (generate_shift_right_bitset<64, int64_t>(value, 55U).value())); - CHECK_EQUAL_HEX((value >> 56U), (generate_shift_right_bitset<64, int64_t>(value, 56U).value())); - CHECK_EQUAL_HEX((value >> 57U), (generate_shift_right_bitset<64, int64_t>(value, 57U).value())); - CHECK_EQUAL_HEX((value >> 58U), (generate_shift_right_bitset<64, int64_t>(value, 58U).value())); - CHECK_EQUAL_HEX((value >> 59U), (generate_shift_right_bitset<64, int64_t>(value, 59U).value())); - CHECK_EQUAL_HEX((value >> 60U), (generate_shift_right_bitset<64, int64_t>(value, 60U).value())); - CHECK_EQUAL_HEX((value >> 61U), (generate_shift_right_bitset<64, int64_t>(value, 61U).value())); - CHECK_EQUAL_HEX((value >> 62U), (generate_shift_right_bitset<64, int64_t>(value, 62U).value())); - CHECK_EQUAL_HEX((value >> 63U), (generate_shift_right_bitset<64, int64_t>(value, 63U).value())); - CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64, int64_t>(value, 64U).value())); + CHECK_EQUAL_HEX((value >> 0U), (generate_shift_right_bitset<64, uint64_t>(value, 0U).value())); + CHECK_EQUAL_HEX((value >> 1U), (generate_shift_right_bitset<64, uint64_t>(value, 1U).value())); + CHECK_EQUAL_HEX((value >> 2U), (generate_shift_right_bitset<64, uint64_t>(value, 2U).value())); + CHECK_EQUAL_HEX((value >> 3U), (generate_shift_right_bitset<64, uint64_t>(value, 3U).value())); + CHECK_EQUAL_HEX((value >> 4U), (generate_shift_right_bitset<64, uint64_t>(value, 4U).value())); + CHECK_EQUAL_HEX((value >> 5U), (generate_shift_right_bitset<64, uint64_t>(value, 5U).value())); + CHECK_EQUAL_HEX((value >> 6U), (generate_shift_right_bitset<64, uint64_t>(value, 6U).value())); + CHECK_EQUAL_HEX((value >> 7U), (generate_shift_right_bitset<64, uint64_t>(value, 7U).value())); + CHECK_EQUAL_HEX((value >> 8U), (generate_shift_right_bitset<64, uint64_t>(value, 8U).value())); + CHECK_EQUAL_HEX((value >> 9U), (generate_shift_right_bitset<64, uint64_t>(value, 9U).value())); + CHECK_EQUAL_HEX((value >> 10U), (generate_shift_right_bitset<64, uint64_t>(value, 10U).value())); + CHECK_EQUAL_HEX((value >> 11U), (generate_shift_right_bitset<64, uint64_t>(value, 11U).value())); + CHECK_EQUAL_HEX((value >> 12U), (generate_shift_right_bitset<64, uint64_t>(value, 12U).value())); + CHECK_EQUAL_HEX((value >> 13U), (generate_shift_right_bitset<64, uint64_t>(value, 13U).value())); + CHECK_EQUAL_HEX((value >> 14U), (generate_shift_right_bitset<64, uint64_t>(value, 14U).value())); + CHECK_EQUAL_HEX((value >> 15U), (generate_shift_right_bitset<64, uint64_t>(value, 15U).value())); + CHECK_EQUAL_HEX((value >> 16U), (generate_shift_right_bitset<64, uint64_t>(value, 16U).value())); + CHECK_EQUAL_HEX((value >> 17U), (generate_shift_right_bitset<64, uint64_t>(value, 17U).value())); + CHECK_EQUAL_HEX((value >> 18U), (generate_shift_right_bitset<64, uint64_t>(value, 18U).value())); + CHECK_EQUAL_HEX((value >> 19U), (generate_shift_right_bitset<64, uint64_t>(value, 19U).value())); + CHECK_EQUAL_HEX((value >> 20U), (generate_shift_right_bitset<64, uint64_t>(value, 20U).value())); + CHECK_EQUAL_HEX((value >> 21U), (generate_shift_right_bitset<64, uint64_t>(value, 21U).value())); + CHECK_EQUAL_HEX((value >> 22U), (generate_shift_right_bitset<64, uint64_t>(value, 22U).value())); + CHECK_EQUAL_HEX((value >> 23U), (generate_shift_right_bitset<64, uint64_t>(value, 23U).value())); + CHECK_EQUAL_HEX((value >> 24U), (generate_shift_right_bitset<64, uint64_t>(value, 24U).value())); + CHECK_EQUAL_HEX((value >> 25U), (generate_shift_right_bitset<64, uint64_t>(value, 25U).value())); + CHECK_EQUAL_HEX((value >> 26U), (generate_shift_right_bitset<64, uint64_t>(value, 26U).value())); + CHECK_EQUAL_HEX((value >> 27U), (generate_shift_right_bitset<64, uint64_t>(value, 27U).value())); + CHECK_EQUAL_HEX((value >> 28U), (generate_shift_right_bitset<64, uint64_t>(value, 28U).value())); + CHECK_EQUAL_HEX((value >> 29U), (generate_shift_right_bitset<64, uint64_t>(value, 29U).value())); + CHECK_EQUAL_HEX((value >> 30U), (generate_shift_right_bitset<64, uint64_t>(value, 30U).value())); + CHECK_EQUAL_HEX((value >> 31U), (generate_shift_right_bitset<64, uint64_t>(value, 31U).value())); + CHECK_EQUAL_HEX((value >> 32U), (generate_shift_right_bitset<64, uint64_t>(value, 32U).value())); + CHECK_EQUAL_HEX((value >> 33U), (generate_shift_right_bitset<64, uint64_t>(value, 33U).value())); + CHECK_EQUAL_HEX((value >> 34U), (generate_shift_right_bitset<64, uint64_t>(value, 34U).value())); + CHECK_EQUAL_HEX((value >> 35U), (generate_shift_right_bitset<64, uint64_t>(value, 35U).value())); + CHECK_EQUAL_HEX((value >> 36U), (generate_shift_right_bitset<64, uint64_t>(value, 36U).value())); + CHECK_EQUAL_HEX((value >> 37U), (generate_shift_right_bitset<64, uint64_t>(value, 37U).value())); + CHECK_EQUAL_HEX((value >> 38U), (generate_shift_right_bitset<64, uint64_t>(value, 38U).value())); + CHECK_EQUAL_HEX((value >> 39U), (generate_shift_right_bitset<64, uint64_t>(value, 39U).value())); + CHECK_EQUAL_HEX((value >> 40U), (generate_shift_right_bitset<64, uint64_t>(value, 40U).value())); + CHECK_EQUAL_HEX((value >> 41U), (generate_shift_right_bitset<64, uint64_t>(value, 41U).value())); + CHECK_EQUAL_HEX((value >> 42U), (generate_shift_right_bitset<64, uint64_t>(value, 42U).value())); + CHECK_EQUAL_HEX((value >> 43U), (generate_shift_right_bitset<64, uint64_t>(value, 43U).value())); + CHECK_EQUAL_HEX((value >> 44U), (generate_shift_right_bitset<64, uint64_t>(value, 44U).value())); + CHECK_EQUAL_HEX((value >> 45U), (generate_shift_right_bitset<64, uint64_t>(value, 45U).value())); + CHECK_EQUAL_HEX((value >> 46U), (generate_shift_right_bitset<64, uint64_t>(value, 46U).value())); + CHECK_EQUAL_HEX((value >> 47U), (generate_shift_right_bitset<64, uint64_t>(value, 47U).value())); + CHECK_EQUAL_HEX((value >> 48U), (generate_shift_right_bitset<64, uint64_t>(value, 48U).value())); + CHECK_EQUAL_HEX((value >> 49U), (generate_shift_right_bitset<64, uint64_t>(value, 49U).value())); + CHECK_EQUAL_HEX((value >> 50U), (generate_shift_right_bitset<64, uint64_t>(value, 50U).value())); + CHECK_EQUAL_HEX((value >> 51U), (generate_shift_right_bitset<64, uint64_t>(value, 51U).value())); + CHECK_EQUAL_HEX((value >> 52U), (generate_shift_right_bitset<64, uint64_t>(value, 52U).value())); + CHECK_EQUAL_HEX((value >> 53U), (generate_shift_right_bitset<64, uint64_t>(value, 53U).value())); + CHECK_EQUAL_HEX((value >> 54U), (generate_shift_right_bitset<64, uint64_t>(value, 54U).value())); + CHECK_EQUAL_HEX((value >> 55U), (generate_shift_right_bitset<64, uint64_t>(value, 55U).value())); + CHECK_EQUAL_HEX((value >> 56U), (generate_shift_right_bitset<64, uint64_t>(value, 56U).value())); + CHECK_EQUAL_HEX((value >> 57U), (generate_shift_right_bitset<64, uint64_t>(value, 57U).value())); + CHECK_EQUAL_HEX((value >> 58U), (generate_shift_right_bitset<64, uint64_t>(value, 58U).value())); + CHECK_EQUAL_HEX((value >> 59U), (generate_shift_right_bitset<64, uint64_t>(value, 59U).value())); + CHECK_EQUAL_HEX((value >> 60U), (generate_shift_right_bitset<64, uint64_t>(value, 60U).value())); + CHECK_EQUAL_HEX((value >> 61U), (generate_shift_right_bitset<64, uint64_t>(value, 61U).value())); + CHECK_EQUAL_HEX((value >> 62U), (generate_shift_right_bitset<64, uint64_t>(value, 62U).value())); + CHECK_EQUAL_HEX((value >> 63U), (generate_shift_right_bitset<64, uint64_t>(value, 63U).value())); + CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64, uint64_t>(value, 64U).value())); } //************************************************************************* TEST(test_shift_right_operator_all_shifts_partial_size) { - int64_t value = 0x0123456789ABCDEFULL; - int64_t mask = 0x0FFFFFFFFFFFFFFFULL; + uint64_t value = 0x0123456789ABCDEFULL; + uint64_t mask = 0x0FFFFFFFFFFFFFFFULL; - CHECK_EQUAL_HEX((value >> 0U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 0U).value())); - CHECK_EQUAL_HEX((value >> 1U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 1U).value())); - CHECK_EQUAL_HEX((value >> 2U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 2U).value())); - CHECK_EQUAL_HEX((value >> 3U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 3U).value())); - CHECK_EQUAL_HEX((value >> 4U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 4U).value())); - CHECK_EQUAL_HEX((value >> 5U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 5U).value())); - CHECK_EQUAL_HEX((value >> 6U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 6U).value())); - CHECK_EQUAL_HEX((value >> 7U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 7U).value())); - CHECK_EQUAL_HEX((value >> 8U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 8U).value())); - CHECK_EQUAL_HEX((value >> 9U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 9U).value())); - CHECK_EQUAL_HEX((value >> 10U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 10U).value())); - CHECK_EQUAL_HEX((value >> 11U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 11U).value())); - CHECK_EQUAL_HEX((value >> 12U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 12U).value())); - CHECK_EQUAL_HEX((value >> 13U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 13U).value())); - CHECK_EQUAL_HEX((value >> 14U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 14U).value())); - CHECK_EQUAL_HEX((value >> 15U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 15U).value())); - CHECK_EQUAL_HEX((value >> 16U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 16U).value())); - CHECK_EQUAL_HEX((value >> 17U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 17U).value())); - CHECK_EQUAL_HEX((value >> 18U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 18U).value())); - CHECK_EQUAL_HEX((value >> 19U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 19U).value())); - CHECK_EQUAL_HEX((value >> 20U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 20U).value())); - CHECK_EQUAL_HEX((value >> 21U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 21U).value())); - CHECK_EQUAL_HEX((value >> 22U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 22U).value())); - CHECK_EQUAL_HEX((value >> 23U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 23U).value())); - CHECK_EQUAL_HEX((value >> 24U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 24U).value())); - CHECK_EQUAL_HEX((value >> 25U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 25U).value())); - CHECK_EQUAL_HEX((value >> 26U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 26U).value())); - CHECK_EQUAL_HEX((value >> 27U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 27U).value())); - CHECK_EQUAL_HEX((value >> 28U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 28U).value())); - CHECK_EQUAL_HEX((value >> 29U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 29U).value())); - CHECK_EQUAL_HEX((value >> 30U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 30U).value())); - CHECK_EQUAL_HEX((value >> 31U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 31U).value())); - CHECK_EQUAL_HEX((value >> 32U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 32U).value())); - CHECK_EQUAL_HEX((value >> 33U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 33U).value())); - CHECK_EQUAL_HEX((value >> 34U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 34U).value())); - CHECK_EQUAL_HEX((value >> 35U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 35U).value())); - CHECK_EQUAL_HEX((value >> 36U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 36U).value())); - CHECK_EQUAL_HEX((value >> 37U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 37U).value())); - CHECK_EQUAL_HEX((value >> 38U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 38U).value())); - CHECK_EQUAL_HEX((value >> 39U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 39U).value())); - CHECK_EQUAL_HEX((value >> 40U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 40U).value())); - CHECK_EQUAL_HEX((value >> 41U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 41U).value())); - CHECK_EQUAL_HEX((value >> 42U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 42U).value())); - CHECK_EQUAL_HEX((value >> 43U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 43U).value())); - CHECK_EQUAL_HEX((value >> 44U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 44U).value())); - CHECK_EQUAL_HEX((value >> 45U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 45U).value())); - CHECK_EQUAL_HEX((value >> 46U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 46U).value())); - CHECK_EQUAL_HEX((value >> 47U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 47U).value())); - CHECK_EQUAL_HEX((value >> 48U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 48U).value())); - CHECK_EQUAL_HEX((value >> 49U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 49U).value())); - CHECK_EQUAL_HEX((value >> 50U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 50U).value())); - CHECK_EQUAL_HEX((value >> 51U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 51U).value())); - CHECK_EQUAL_HEX((value >> 52U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 52U).value())); - CHECK_EQUAL_HEX((value >> 53U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 53U).value())); - CHECK_EQUAL_HEX((value >> 54U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 54U).value())); - CHECK_EQUAL_HEX((value >> 55U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 55U).value())); - CHECK_EQUAL_HEX((value >> 56U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 56U).value())); - CHECK_EQUAL_HEX((value >> 57U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 57U).value())); - CHECK_EQUAL_HEX((value >> 58U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 58U).value())); - CHECK_EQUAL_HEX((value >> 59U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 59U).value())); - CHECK_EQUAL_HEX((value >> 60U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 60U).value())); - CHECK_EQUAL_HEX((value >> 61U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 61U).value())); - CHECK_EQUAL_HEX((value >> 62U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 62U).value())); - CHECK_EQUAL_HEX((value >> 63U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 63U).value())); - CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64, int64_t>(value, 64U).value())); + CHECK_EQUAL_HEX((value >> 0U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 0U).value())); + CHECK_EQUAL_HEX((value >> 1U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 1U).value())); + CHECK_EQUAL_HEX((value >> 2U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 2U).value())); + CHECK_EQUAL_HEX((value >> 3U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 3U).value())); + CHECK_EQUAL_HEX((value >> 4U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 4U).value())); + CHECK_EQUAL_HEX((value >> 5U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 5U).value())); + CHECK_EQUAL_HEX((value >> 6U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 6U).value())); + CHECK_EQUAL_HEX((value >> 7U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 7U).value())); + CHECK_EQUAL_HEX((value >> 8U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 8U).value())); + CHECK_EQUAL_HEX((value >> 9U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 9U).value())); + CHECK_EQUAL_HEX((value >> 10U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 10U).value())); + CHECK_EQUAL_HEX((value >> 11U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 11U).value())); + CHECK_EQUAL_HEX((value >> 12U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 12U).value())); + CHECK_EQUAL_HEX((value >> 13U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 13U).value())); + CHECK_EQUAL_HEX((value >> 14U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 14U).value())); + CHECK_EQUAL_HEX((value >> 15U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 15U).value())); + CHECK_EQUAL_HEX((value >> 16U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 16U).value())); + CHECK_EQUAL_HEX((value >> 17U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 17U).value())); + CHECK_EQUAL_HEX((value >> 18U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 18U).value())); + CHECK_EQUAL_HEX((value >> 19U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 19U).value())); + CHECK_EQUAL_HEX((value >> 20U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 20U).value())); + CHECK_EQUAL_HEX((value >> 21U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 21U).value())); + CHECK_EQUAL_HEX((value >> 22U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 22U).value())); + CHECK_EQUAL_HEX((value >> 23U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 23U).value())); + CHECK_EQUAL_HEX((value >> 24U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 24U).value())); + CHECK_EQUAL_HEX((value >> 25U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 25U).value())); + CHECK_EQUAL_HEX((value >> 26U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 26U).value())); + CHECK_EQUAL_HEX((value >> 27U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 27U).value())); + CHECK_EQUAL_HEX((value >> 28U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 28U).value())); + CHECK_EQUAL_HEX((value >> 29U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 29U).value())); + CHECK_EQUAL_HEX((value >> 30U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 30U).value())); + CHECK_EQUAL_HEX((value >> 31U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 31U).value())); + CHECK_EQUAL_HEX((value >> 32U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 32U).value())); + CHECK_EQUAL_HEX((value >> 33U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 33U).value())); + CHECK_EQUAL_HEX((value >> 34U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 34U).value())); + CHECK_EQUAL_HEX((value >> 35U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 35U).value())); + CHECK_EQUAL_HEX((value >> 36U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 36U).value())); + CHECK_EQUAL_HEX((value >> 37U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 37U).value())); + CHECK_EQUAL_HEX((value >> 38U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 38U).value())); + CHECK_EQUAL_HEX((value >> 39U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 39U).value())); + CHECK_EQUAL_HEX((value >> 40U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 40U).value())); + CHECK_EQUAL_HEX((value >> 41U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 41U).value())); + CHECK_EQUAL_HEX((value >> 42U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 42U).value())); + CHECK_EQUAL_HEX((value >> 43U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 43U).value())); + CHECK_EQUAL_HEX((value >> 44U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 44U).value())); + CHECK_EQUAL_HEX((value >> 45U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 45U).value())); + CHECK_EQUAL_HEX((value >> 46U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 46U).value())); + CHECK_EQUAL_HEX((value >> 47U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 47U).value())); + CHECK_EQUAL_HEX((value >> 48U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 48U).value())); + CHECK_EQUAL_HEX((value >> 49U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 49U).value())); + CHECK_EQUAL_HEX((value >> 50U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 50U).value())); + CHECK_EQUAL_HEX((value >> 51U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 51U).value())); + CHECK_EQUAL_HEX((value >> 52U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 52U).value())); + CHECK_EQUAL_HEX((value >> 53U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 53U).value())); + CHECK_EQUAL_HEX((value >> 54U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 54U).value())); + CHECK_EQUAL_HEX((value >> 55U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 55U).value())); + CHECK_EQUAL_HEX((value >> 56U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 56U).value())); + CHECK_EQUAL_HEX((value >> 57U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 57U).value())); + CHECK_EQUAL_HEX((value >> 58U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 58U).value())); + CHECK_EQUAL_HEX((value >> 59U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 59U).value())); + CHECK_EQUAL_HEX((value >> 60U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 60U).value())); + CHECK_EQUAL_HEX((value >> 61U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 61U).value())); + CHECK_EQUAL_HEX((value >> 62U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 62U).value())); + CHECK_EQUAL_HEX((value >> 63U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 63U).value())); + CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64, uint64_t>(value, 64U).value())); } //************************************************************************* TEST(test_and_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(0x12345678UL & 0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(0x12345678UL & 0x23456789UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3 = data1 & data2; + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3 = data1 & data2; CHECK(data3 == data4); } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_and_equals_operator_helper(etl::bitset<64, int64_t> data1, const etl::bitset<64, int64_t>& data2) + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_and_equals_operator_helper(etl::bitset<64, uint64_t> data1, const etl::bitset<64, uint64_t>& data2) { data1 &= data2; @@ -1477,10 +1980,10 @@ namespace TEST(test_and_equals_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(test_and_equals_operator_helper(data1, data2)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(test_and_equals_operator_helper(data1, data2)); CHECK((data1 & data2) == data3); } @@ -1488,16 +1991,16 @@ namespace //************************************************************************* TEST(test_or_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(0x12345678UL | 0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(0x12345678UL | 0x23456789UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3 = data1 | data2; + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3 = data1 | data2; CHECK(data3 == data4); } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_or_equals_operator_helper(etl::bitset<64, int64_t> data1, const etl::bitset<64, int64_t>& data2) + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_or_equals_operator_helper(etl::bitset<64, uint64_t> data1, const etl::bitset<64, uint64_t>& data2) { data1 |= data2; @@ -1506,10 +2009,10 @@ namespace TEST(test_or_equals_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(test_or_equals_operator_helper(data1, data2)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(test_or_equals_operator_helper(data1, data2)); CHECK((data1 | data2) == data3); } @@ -1517,16 +2020,16 @@ namespace //************************************************************************* TEST(test_xor_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(0x12345678UL ^ 0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(0x12345678UL ^ 0x23456789UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3 = data1 ^ data2; + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3 = data1 ^ data2; CHECK(data3 == data4); } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_xor_equals_operator_helper(etl::bitset<64, int64_t> data1, const etl::bitset<64, int64_t>& data2) + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_xor_equals_operator_helper(etl::bitset<64, uint64_t> data1, const etl::bitset<64, uint64_t>& data2) { data1 ^= data2; @@ -1535,10 +2038,10 @@ namespace TEST(test_xor_equals_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(test_xor_equals_operator_helper(data1, data2)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(test_xor_equals_operator_helper(data1, data2)); CHECK((data1 ^ data2) == data3); } @@ -1546,102 +2049,102 @@ namespace //************************************************************************* TEST(test_find_first) { - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs1(ull(0x00)); - ETL_CONSTEXPR14 size_t bs1fff = bs1.find_first(false); - ETL_CONSTEXPR14 size_t bs1fft = bs1.find_first(true); - CHECK_EQUAL(0U, bs1fff); - CHECK_EQUAL(etl::bitset<>::npos, bs1fft); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs1(ull(0x00)); + ETL_CONSTEXPR14 size_t bs1find_first_false = bs1.find_first(false); + ETL_CONSTEXPR14 size_t bs1find_first_true = bs1.find_first(true); + CHECK_EQUAL(0U, bs1find_first_false); + CHECK_EQUAL(etl::bitset<>::npos, bs1find_first_true); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs2(ull(0xFF)); - ETL_CONSTEXPR14 size_t bs2fff = bs2.find_first(false); - ETL_CONSTEXPR14 size_t bs2fft = bs2.find_first(true); - CHECK_EQUAL(etl::bitset<>::npos, bs2fff); - CHECK_EQUAL(0U, bs2fft); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs2(ull(0xFF)); + ETL_CONSTEXPR14 size_t bs2find_first_false = bs2.find_first(false); + ETL_CONSTEXPR14 size_t bs2find_first_true = bs2.find_first(true); + CHECK_EQUAL(etl::bitset<>::npos, bs2find_first_false); + CHECK_EQUAL(0U, bs2find_first_true); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs3(ull(0x01)); - ETL_CONSTEXPR14 size_t bs3fff = bs3.find_first(false); - ETL_CONSTEXPR14 size_t bs3fft = bs3.find_first(true); - CHECK_EQUAL(1U, bs3fff); - CHECK_EQUAL(0U, bs3fft); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs3(ull(0x01)); + ETL_CONSTEXPR14 size_t bs3find_first_false = bs3.find_first(false); + ETL_CONSTEXPR14 size_t bs3find_first_true = bs3.find_first(true); + CHECK_EQUAL(1U, bs3find_first_false); + CHECK_EQUAL(0U, bs3find_first_true); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs4(ull(0x20)); - ETL_CONSTEXPR14 size_t bs4fff = bs4.find_first(false); - ETL_CONSTEXPR14 size_t bs4fft = bs4.find_first(true); - CHECK_EQUAL(0U, bs4fff); - CHECK_EQUAL(5U, bs4fft); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs4(ull(0x20)); + ETL_CONSTEXPR14 size_t bs4find_first_false = bs4.find_first(false); + ETL_CONSTEXPR14 size_t bs4find_first_true = bs4.find_first(true); + CHECK_EQUAL(0U, bs4find_first_false); + CHECK_EQUAL(5U, bs4find_first_true); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs5(ull(0x21)); - ETL_CONSTEXPR14 size_t bs5fff = bs5.find_first(false); - ETL_CONSTEXPR14 size_t bs5fft = bs5.find_first(true); - CHECK_EQUAL(1U, bs5fff); - CHECK_EQUAL(0U, bs5fft); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs5(ull(0x21)); + ETL_CONSTEXPR14 size_t bs5find_first_false = bs5.find_first(false); + ETL_CONSTEXPR14 size_t bs5find_first_true = bs5.find_first(true); + CHECK_EQUAL(1U, bs5find_first_false); + CHECK_EQUAL(0U, bs5find_first_true); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs6(ull(0x0E)); - ETL_CONSTEXPR14 size_t bs6fff = bs6.find_first(false); - ETL_CONSTEXPR14 size_t bs6fft = bs6.find_first(true); - CHECK_EQUAL(0U, bs6fff); - CHECK_EQUAL(1U, bs6fft); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs6(ull(0x0E)); + ETL_CONSTEXPR14 size_t bs6find_first_false = bs6.find_first(false); + ETL_CONSTEXPR14 size_t bs6find_first_true = bs6.find_first(true); + CHECK_EQUAL(0U, bs6find_first_false); + CHECK_EQUAL(1U, bs6find_first_true); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs7(ull(0x31)); - ETL_CONSTEXPR14 size_t bs7fff = bs7.find_first(false); - ETL_CONSTEXPR14 size_t bs7fft = bs7.find_first(true); - CHECK_EQUAL(1U, bs7fff); - CHECK_EQUAL(0U, bs7fft); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs7(ull(0x31)); + ETL_CONSTEXPR14 size_t bs7find_first_false = bs7.find_first(false); + ETL_CONSTEXPR14 size_t bs7find_first_true = bs7.find_first(true); + CHECK_EQUAL(1U, bs7find_first_false); + CHECK_EQUAL(0U, bs7find_first_true); } //************************************************************************* TEST(test_find_next) { - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs1(ull(0x00)); - ETL_CONSTEXPR14 size_t bs1fnf0 = bs1.find_next(false, 0); - ETL_CONSTEXPR14 size_t bs1fnf1 = bs1.find_next(false, 1); - ETL_CONSTEXPR14 size_t bs1fnt2 = bs1.find_next(true, 2); - CHECK_EQUAL(0U, bs1fnf0); - CHECK_EQUAL(1U, bs1fnf1); - CHECK_EQUAL(etl::bitset<>::npos, bs1fnt2); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs1(ull(0x00)); + ETL_CONSTEXPR14 size_t bs1find_next_false0 = bs1.find_next(false, 0); + ETL_CONSTEXPR14 size_t bs1find_next_false1 = bs1.find_next(false, 1); + ETL_CONSTEXPR14 size_t bs1find_next_true2 = bs1.find_next(true, 2); + CHECK_EQUAL(0U, bs1find_next_false0); + CHECK_EQUAL(1U, bs1find_next_false1); + CHECK_EQUAL(etl::bitset<>::npos, bs1find_next_true2); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs2(ull(0xFF)); - ETL_CONSTEXPR14 size_t bs2fnt0 = bs2.find_next(true, 0); - ETL_CONSTEXPR14 size_t bs2fnt1 = bs2.find_next(true, 1); - ETL_CONSTEXPR14 size_t bs2fnf2 = bs2.find_next(false, 2); - CHECK_EQUAL(0U, bs2fnt0); - CHECK_EQUAL(1U, bs2fnt1); - CHECK_EQUAL(etl::bitset<>::npos, bs2fnf2); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs2(ull(0xFF)); + ETL_CONSTEXPR14 size_t bs2find_next_true0 = bs2.find_next(true, 0); + ETL_CONSTEXPR14 size_t bs2find_next_true1 = bs2.find_next(true, 1); + ETL_CONSTEXPR14 size_t bs2find_next_false2 = bs2.find_next(false, 2); + CHECK_EQUAL(0U, bs2find_next_true0); + CHECK_EQUAL(1U, bs2find_next_true1); + CHECK_EQUAL(etl::bitset<>::npos, bs2find_next_false2); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs3(ull(0x0E)); - ETL_CONSTEXPR14 size_t bs3fnf0 = bs3.find_next(false, 0); - ETL_CONSTEXPR14 size_t bs3fnt1 = bs3.find_next(true, 1); - ETL_CONSTEXPR14 size_t bs3fnf2 = bs3.find_next(false, 2); - CHECK_EQUAL(0U, bs3fnf0); - CHECK_EQUAL(1U, bs3fnt1); - CHECK_EQUAL(4U, bs3fnf2); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs3(ull(0x0E)); + ETL_CONSTEXPR14 size_t bs3find_next_false0 = bs3.find_next(false, 0); + ETL_CONSTEXPR14 size_t bs3find_next_true1 = bs3.find_next(true, 1); + ETL_CONSTEXPR14 size_t bs3find_next_false2 = bs3.find_next(false, 2); + CHECK_EQUAL(0U, bs3find_next_false0); + CHECK_EQUAL(1U, bs3find_next_true1); + CHECK_EQUAL(4U, bs3find_next_false2); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs4(ull(0x31)); - ETL_CONSTEXPR14 size_t bs4fnt0 = bs4.find_next(true, 0); - ETL_CONSTEXPR14 size_t bs4fnf0 = bs4.find_next(false, 0); - ETL_CONSTEXPR14 size_t bs4fnt1 = bs4.find_next(true, 1); - CHECK_EQUAL(0U, bs4fnt0); - CHECK_EQUAL(1U, bs4fnf0); - CHECK_EQUAL(4U, bs4fnt1); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs4(ull(0x31)); + ETL_CONSTEXPR14 size_t bs4find_next_true0 = bs4.find_next(true, 0); + ETL_CONSTEXPR14 size_t bs4find_next_false0 = bs4.find_next(false, 0); + ETL_CONSTEXPR14 size_t bs4find_next_true1 = bs4.find_next(true, 1); + CHECK_EQUAL(0U, bs4find_next_true0); + CHECK_EQUAL(1U, bs4find_next_false0); + CHECK_EQUAL(4U, bs4find_next_true1); } //************************************************************************* - ETL_CONSTEXPR14 std::pair, etl::bitset<8, int8_t>> test_swap_helper() + ETL_CONSTEXPR14 std::pair, etl::bitset<8, uint8_t>> test_swap_helper() { - etl::bitset<8, int8_t> data1(ull(0x2A)); - etl::bitset<8, int8_t> data2(ull(0x15)); + etl::bitset<8, uint8_t> data1(ull(0x2A)); + etl::bitset<8, uint8_t> data2(ull(0x15)); swap(data1, data2); - return std::pair, etl::bitset<8, int8_t>>(data1, data2); + return std::pair, etl::bitset<8, uint8_t>>(data1, data2); } TEST(test_swap) { - ETL_CONSTEXPR14 etl::bitset<8, int8_t> compare1(0x2A); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> compare2(0x15); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> compare1(0x2A); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> compare2(0x15); - ETL_CONSTEXPR14 std::pair, etl::bitset<8, int8_t>> swapped = test_swap_helper(); + ETL_CONSTEXPR14 std::pair, etl::bitset<8, uint8_t>> swapped = test_swap_helper(); CHECK(swapped.first == compare2); CHECK(swapped.second == compare1); @@ -1656,14 +2159,17 @@ namespace span_t s = b.span(); CHECK_EQUAL(0x12345678UL, s[0]); + + s[0] = 0x87654321UL; + CHECK_EQUAL(0x87654321UL, b.value()); } //************************************************************************* TEST(test_const_span) { - using span_t = etl::bitset<32, int32_t>::const_span_type; + using span_t = etl::bitset<32, uint32_t>::const_span_type; - const etl::bitset<32, int32_t> b(0x12345678UL); + const etl::bitset<32, uint32_t> b(0x12345678UL); span_t s = b.span(); CHECK_EQUAL(0x12345678UL, s[0]); @@ -1672,7 +2178,7 @@ namespace //************************************************************************* TEST(test_to_string) { - using bs32 = etl::bitset<32, int32_t>; + using bs32 = etl::bitset<32, uint32_t>; ETL_CONSTEXPR14 bs32 b(0x12345678UL); @@ -1687,7 +2193,7 @@ namespace //************************************************************************* TEST(test_to_wstring) { - using bs32 = etl::bitset<32, int32_t>; + using bs32 = etl::bitset<32, uint32_t>; ETL_CONSTEXPR14 bs32 b(0x12345678UL); @@ -1701,7 +2207,7 @@ namespace //************************************************************************* TEST(test_to_u16string) { - using bs32 = etl::bitset<32, int32_t>; + using bs32 = etl::bitset<32, uint32_t>; ETL_CONSTEXPR14 bs32 b(0x12345678UL); @@ -1715,7 +2221,7 @@ namespace //************************************************************************* TEST(test_to_u32string) { - using bs32 = etl::bitset<32, int32_t>; + using bs32 = etl::bitset<32, uint32_t>; ETL_CONSTEXPR14 bs32 b(0x12345678UL); @@ -1725,5 +2231,521 @@ namespace CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(text.c_str())); CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str())); } + + ////************************************************************************* + TEST(test_extract_6_bit_uint8_t_with_run_time_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract( 0, 6))); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract( 1, 6))); + CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract( 2, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract( 3, 6))); + CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract( 4, 6))); + CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract( 5, 6))); + CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract( 6, 6))); + CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract( 7, 6))); + CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract( 8, 6))); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract( 9, 6))); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract(10, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract(11, 6))); + CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract(12, 6))); + CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract(13, 6))); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract(14, 6))); + CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract(15, 6))); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract(16, 6))); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract(17, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract(18, 6))); + CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract(19, 6))); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract(20, 6))); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract(21, 6))); + CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract(22, 6))); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract(23, 6))); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract(24, 6))); + CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract(25, 6))); + CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract(26, 6))); + + CHECK_THROW(b.extract(26, 7), etl::bitset_overflow); + CHECK_THROW(b.extract(27, 6), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_6_bit_uint8_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract())); + + // The lines below should static assert. + //uint8_t v1 = b.extract(); + //uint8_t v1 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_6_bit_int8_t_with_run_time_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract( 0, 6))); + CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract( 1, 6))); + CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract( 2, 6))); + CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract( 3, 6))); + CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract( 4, 6))); + CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract( 5, 6))); + CHECK_EQUAL_HEX(int8_t(0x19), (b.extract( 6, 6))); + CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract( 7, 6))); + CHECK_EQUAL_HEX(int8_t(0x16), (b.extract( 8, 6))); + CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract( 9, 6))); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract(10, 6))); + CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract(11, 6))); + CHECK_EQUAL_HEX(int8_t(0x05), (b.extract(12, 6))); + CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract(13, 6))); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract(14, 6))); + CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract(15, 6))); + CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract(16, 6))); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract(17, 6))); + CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract(18, 6))); + CHECK_EQUAL_HEX(int8_t(0x06), (b.extract(19, 6))); + CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract(20, 6))); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract(21, 6))); + CHECK_EQUAL_HEX(int8_t(0x08), (b.extract(22, 6))); + CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract(23, 6))); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract(24, 6))); + CHECK_EQUAL_HEX(int8_t(0x09), (b.extract(25, 6))); + CHECK_EQUAL_HEX(int8_t(0x04), (b.extract(26, 6))); + + CHECK_THROW(b.extract(26, 7), etl::bitset_overflow); + CHECK_THROW(b.extract(27, 6), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_6_bit_int8_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x19), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x16), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x05), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x06), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x08), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x09), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x04), (b.extract())); + + // The lines below should static assert. + //int8_t v1 = b.extract(); + //int8_t v1 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_uint8_t_with_run_time_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint8_t(0x78), b.extract( 0, 8)); + CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract( 1, 8)); + CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract( 2, 8)); + CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract( 3, 8)); + CHECK_EQUAL_HEX(uint8_t(0x67), b.extract( 4, 8)); + CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract( 5, 8)); + CHECK_EQUAL_HEX(uint8_t(0x59), b.extract( 6, 8)); + CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract( 7, 8)); + CHECK_EQUAL_HEX(uint8_t(0x56), b.extract( 8, 8)); + CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract( 9, 8)); + CHECK_EQUAL_HEX(uint8_t(0x15), b.extract(10, 8)); + CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract(11, 8)); + CHECK_EQUAL_HEX(uint8_t(0x45), b.extract(12, 8)); + CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract(13, 8)); + CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract(14, 8)); + CHECK_EQUAL_HEX(uint8_t(0x68), b.extract(15, 8)); + CHECK_EQUAL_HEX(uint8_t(0x34), b.extract(16, 8)); + CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract(17, 8)); + CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract(18, 8)); + CHECK_EQUAL_HEX(uint8_t(0x46), b.extract(19, 8)); + CHECK_EQUAL_HEX(uint8_t(0x23), b.extract(20, 8)); + CHECK_EQUAL_HEX(uint8_t(0x91), b.extract(21, 8)); + CHECK_EQUAL_HEX(uint8_t(0x48), b.extract(22, 8)); + CHECK_EQUAL_HEX(uint8_t(0x24), b.extract(23, 8)); + CHECK_EQUAL_HEX(uint8_t(0x12), b.extract(24, 8)); + + CHECK_THROW(b.extract(24, 9), etl::bitset_overflow); + CHECK_THROW(b.extract(25, 8), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_uint8_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract())); + + // The lines below should static assert. + //uint8_t v1 = b.extract(); + //uint8_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_int8_t_with_run_time_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(int8_t(0x78), b.extract( 0, 8)); + CHECK_EQUAL_HEX(int8_t(0x3C), b.extract( 1, 8)); + CHECK_EQUAL_HEX(int8_t(0x9E), b.extract( 2, 8)); + CHECK_EQUAL_HEX(int8_t(0xCF), b.extract( 3, 8)); + CHECK_EQUAL_HEX(int8_t(0x67), b.extract( 4, 8)); + CHECK_EQUAL_HEX(int8_t(0xB3), b.extract( 5, 8)); + CHECK_EQUAL_HEX(int8_t(0x59), b.extract( 6, 8)); + CHECK_EQUAL_HEX(int8_t(0xAC), b.extract( 7, 8)); + CHECK_EQUAL_HEX(int8_t(0x56), b.extract( 8, 8)); + CHECK_EQUAL_HEX(int8_t(0x2B), b.extract( 9, 8)); + CHECK_EQUAL_HEX(int8_t(0x15), b.extract(10, 8)); + CHECK_EQUAL_HEX(int8_t(0x8A), b.extract(11, 8)); + CHECK_EQUAL_HEX(int8_t(0x45), b.extract(12, 8)); + CHECK_EQUAL_HEX(int8_t(0xA2), b.extract(13, 8)); + CHECK_EQUAL_HEX(int8_t(0xD1), b.extract(14, 8)); + CHECK_EQUAL_HEX(int8_t(0x68), b.extract(15, 8)); + CHECK_EQUAL_HEX(int8_t(0x34), b.extract(16, 8)); + CHECK_EQUAL_HEX(int8_t(0x1A), b.extract(17, 8)); + CHECK_EQUAL_HEX(int8_t(0x8D), b.extract(18, 8)); + CHECK_EQUAL_HEX(int8_t(0x46), b.extract(19, 8)); + CHECK_EQUAL_HEX(int8_t(0x23), b.extract(20, 8)); + CHECK_EQUAL_HEX(int8_t(0x91), b.extract(21, 8)); + CHECK_EQUAL_HEX(int8_t(0x48), b.extract(22, 8)); + CHECK_EQUAL_HEX(int8_t(0x24), b.extract(23, 8)); + CHECK_EQUAL_HEX(int8_t(0x12), b.extract(24, 8)); + + CHECK_THROW(b.extract(24, 9), etl::bitset_overflow); + CHECK_THROW(b.extract(25, 8), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_int8_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(int8_t(0x78), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x67), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x59), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x56), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x8A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x45), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xA2), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xD1), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x68), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x8D), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x46), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x91), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x48), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract())); + + // The lines below should static assert. + //int8_t v1 = b.extract(); + //int8_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_13_bits_uint16_t_with_run_time_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract( 0, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract( 1, 13)); + CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract( 2, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract( 3, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract( 4, 13)); + CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract( 5, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract( 6, 13)); + CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract( 7, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract( 8, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract( 9, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract(10, 13)); + CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract(11, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract(12, 13)); + CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract(13, 13)); + CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract(14, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract(15, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract(16, 13)); + CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract(17, 13)); + CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract(18, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract(19, 13)); + + CHECK_THROW(b.extract(19, 14), etl::bitset_overflow); + CHECK_THROW(b.extract(20, 13), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_13_bits_uint16_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract())); + + // The lines below should static assert. + //uint16_t v1 = b.extract b(0x12345678UL); + + CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract( 0, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract( 1, 16)); + CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract( 2, 16)); + CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract( 3, 16)); + CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract( 4, 16)); + CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract( 5, 16)); + CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract( 6, 16)); + CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract( 7, 16)); + CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract( 8, 16)); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract( 9, 16)); + CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract(10, 16)); + CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract(11, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract(12, 16)); + CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract(13, 16)); + CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract(14, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract(15, 16)); + CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract(16, 16)); + + CHECK_THROW(b.extract(16, 17), etl::bitset_overflow); + CHECK_THROW(b.extract(17, 16), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_uint16_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract())); + + // The lines below should static assert. + //uint16_t v1 = b.extract(); + //uint16_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_int16_t_with_run_time_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(int16_t(0x5678), b.extract( 0, 16)); + CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract( 1, 16)); + CHECK_EQUAL_HEX(int16_t(0x159E), b.extract( 2, 16)); + CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract( 3, 16)); + CHECK_EQUAL_HEX(int16_t(0x4567), b.extract( 4, 16)); + CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract( 5, 16)); + CHECK_EQUAL_HEX(int16_t(0xD159), b.extract( 6, 16)); + CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract( 7, 16)); + CHECK_EQUAL_HEX(int16_t(0x3456), b.extract( 8, 16)); + CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract( 9, 16)); + CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract(10, 16)); + CHECK_EQUAL_HEX(int16_t(0x468A), b.extract(11, 16)); + CHECK_EQUAL_HEX(int16_t(0x2345), b.extract(12, 16)); + CHECK_EQUAL_HEX(int16_t(0x91A2), b.extract(13, 16)); + CHECK_EQUAL_HEX(int16_t(0x48D1), b.extract(14, 16)); + CHECK_EQUAL_HEX(int16_t(0x2468), b.extract(15, 16)); + CHECK_EQUAL_HEX(int16_t(0x1234), b.extract(16, 16)); + + CHECK_THROW(b.extract(16, 17), etl::bitset_overflow); + CHECK_THROW(b.extract(17, 16), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_int16_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x91A2), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x48D1), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x2468), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x1234), (b.extract())); + + // The lines below should static assert. + //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 8eb3cbb6..6945376d 100644 --- a/test/test_bitset_new_ext_default_element_type.cpp +++ b/test/test_bitset_new_ext_default_element_type.cpp @@ -37,6 +37,7 @@ SOFTWARE. #include "etl/wstring.h" #include "etl/u16string.h" #include "etl/u32string.h" +#include "etl/endianness.h" namespace { @@ -45,726 +46,74 @@ namespace SUITE(test_bitset_new_ext_default_element_type) { //************************************************************************* - TEST(test_default_constructor) + TEST(test_constants) { - etl::bitset_ext<60>::buffer_type buffer; + using bitset_type = etl::bitset_ext<60>; + using element_type = bitset_type::element_type; - std::bitset<60> compare; - etl::bitset_ext<60> data(buffer); + 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; - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); + //******************************* + constexpr size_t Size1 = bitset_type::Size; + constexpr size_t Size2 = bitset_type::size(); - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } + CHECK_EQUAL(Size, Size1); + CHECK_EQUAL(Size, Size2); - //************************************************************************* - TEST(test_default_constructor_multi_element) - { - etl::bitset_ext<14, int8_t>::buffer_type buffer14; - etl::bitset_ext<30, int16_t>::buffer_type buffer30; - etl::bitset_ext<62, int32_t>::buffer_type buffer62; + //******************************* + constexpr size_t Bits_Per_Element1 = bitset_type::Bits_Per_Element; + constexpr size_t Bits_Per_Element2 = bitset_type::bits_per_element(); - etl::bitset_ext<14, int8_t> data8(buffer14); - etl::bitset_ext<30, int16_t> data16(buffer30); - etl::bitset_ext<62, int32_t> data32(buffer62); + CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element1); + CHECK_EQUAL(Bits_Per_Element, Bits_Per_Element2); - CHECK_EQUAL(2U, data8.Number_Of_Elements); - CHECK_EQUAL(2U, data16.Number_Of_Elements); - CHECK_EQUAL(2U, data32.Number_Of_Elements); - } + //******************************* + constexpr size_t Number_Of_Elements1 = bitset_type::Number_Of_Elements; + constexpr size_t Number_Of_Elements2 = bitset_type::number_of_elements(); - //************************************************************************* - TEST(test_default_constructor_default_element_type_bits) - { - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - } - - //************************************************************************* - TEST(test_default_constructor_default_element_type_number_of_elements) - { - CHECK_EQUAL(1U, etl::bitset_ext<1>::Number_Of_Elements); - CHECK_EQUAL(1U, etl::bitset_ext<2>::Number_Of_Elements); - CHECK_EQUAL(1U, etl::bitset_ext<3>::Number_Of_Elements); - CHECK_EQUAL(1U, etl::bitset_ext<4>::Number_Of_Elements); - CHECK_EQUAL(1U, etl::bitset_ext<5>::Number_Of_Elements); - CHECK_EQUAL(1U, etl::bitset_ext<6>::Number_Of_Elements); - CHECK_EQUAL(1U, etl::bitset_ext<7>::Number_Of_Elements); - CHECK_EQUAL(1U, etl::bitset_ext<8>::Number_Of_Elements); - CHECK_EQUAL(2U, etl::bitset_ext<9>::Number_Of_Elements); - CHECK_EQUAL(2U, etl::bitset_ext<10>::Number_Of_Elements); - CHECK_EQUAL(2U, etl::bitset_ext<11>::Number_Of_Elements); - CHECK_EQUAL(2U, etl::bitset_ext<12>::Number_Of_Elements); - CHECK_EQUAL(2U, etl::bitset_ext<13>::Number_Of_Elements); - CHECK_EQUAL(2U, etl::bitset_ext<14>::Number_Of_Elements); - CHECK_EQUAL(2U, etl::bitset_ext<15>::Number_Of_Elements); - CHECK_EQUAL(2U, etl::bitset_ext<16>::Number_Of_Elements); - CHECK_EQUAL(3U, etl::bitset_ext<17>::Number_Of_Elements); - CHECK_EQUAL(3U, etl::bitset_ext<18>::Number_Of_Elements); - CHECK_EQUAL(3U, etl::bitset_ext<19>::Number_Of_Elements); - CHECK_EQUAL(3U, etl::bitset_ext<20>::Number_Of_Elements); - CHECK_EQUAL(3U, etl::bitset_ext<21>::Number_Of_Elements); - CHECK_EQUAL(3U, etl::bitset_ext<22>::Number_Of_Elements); - CHECK_EQUAL(3U, etl::bitset_ext<23>::Number_Of_Elements); - CHECK_EQUAL(3U, etl::bitset_ext<24>::Number_Of_Elements); - CHECK_EQUAL(4U, etl::bitset_ext<25>::Number_Of_Elements); - CHECK_EQUAL(4U, etl::bitset_ext<26>::Number_Of_Elements); - CHECK_EQUAL(4U, etl::bitset_ext<27>::Number_Of_Elements); - CHECK_EQUAL(4U, etl::bitset_ext<28>::Number_Of_Elements); - CHECK_EQUAL(4U, etl::bitset_ext<29>::Number_Of_Elements); - CHECK_EQUAL(4U, etl::bitset_ext<30>::Number_Of_Elements); - CHECK_EQUAL(4U, etl::bitset_ext<31>::Number_Of_Elements); - CHECK_EQUAL(4U, etl::bitset_ext<32>::Number_Of_Elements); - CHECK_EQUAL(5U, etl::bitset_ext<33>::Number_Of_Elements); - CHECK_EQUAL(5U, etl::bitset_ext<34>::Number_Of_Elements); - CHECK_EQUAL(5U, etl::bitset_ext<35>::Number_Of_Elements); - CHECK_EQUAL(5U, etl::bitset_ext<36>::Number_Of_Elements); - CHECK_EQUAL(5U, etl::bitset_ext<37>::Number_Of_Elements); - CHECK_EQUAL(5U, etl::bitset_ext<38>::Number_Of_Elements); - CHECK_EQUAL(5U, etl::bitset_ext<39>::Number_Of_Elements); - CHECK_EQUAL(5U, etl::bitset_ext<40>::Number_Of_Elements); - CHECK_EQUAL(6U, etl::bitset_ext<41>::Number_Of_Elements); - CHECK_EQUAL(6U, etl::bitset_ext<42>::Number_Of_Elements); - CHECK_EQUAL(6U, etl::bitset_ext<43>::Number_Of_Elements); - CHECK_EQUAL(6U, etl::bitset_ext<44>::Number_Of_Elements); - CHECK_EQUAL(6U, etl::bitset_ext<45>::Number_Of_Elements); - CHECK_EQUAL(6U, etl::bitset_ext<46>::Number_Of_Elements); - CHECK_EQUAL(6U, etl::bitset_ext<47>::Number_Of_Elements); - CHECK_EQUAL(6U, etl::bitset_ext<48>::Number_Of_Elements); - CHECK_EQUAL(7U, etl::bitset_ext<49>::Number_Of_Elements); - CHECK_EQUAL(7U, etl::bitset_ext<50>::Number_Of_Elements); - CHECK_EQUAL(7U, etl::bitset_ext<51>::Number_Of_Elements); - CHECK_EQUAL(7U, etl::bitset_ext<52>::Number_Of_Elements); - CHECK_EQUAL(7U, etl::bitset_ext<53>::Number_Of_Elements); - CHECK_EQUAL(7U, etl::bitset_ext<54>::Number_Of_Elements); - CHECK_EQUAL(7U, etl::bitset_ext<55>::Number_Of_Elements); - CHECK_EQUAL(7U, etl::bitset_ext<56>::Number_Of_Elements); - CHECK_EQUAL(8U, etl::bitset_ext<57>::Number_Of_Elements); - CHECK_EQUAL(8U, etl::bitset_ext<58>::Number_Of_Elements); - CHECK_EQUAL(8U, etl::bitset_ext<59>::Number_Of_Elements); - CHECK_EQUAL(8U, etl::bitset_ext<60>::Number_Of_Elements); - CHECK_EQUAL(8U, etl::bitset_ext<61>::Number_Of_Elements); - CHECK_EQUAL(8U, etl::bitset_ext<62>::Number_Of_Elements); - CHECK_EQUAL(8U, etl::bitset_ext<63>::Number_Of_Elements); - CHECK_EQUAL(8U, etl::bitset_ext<64>::Number_Of_Elements); - } + CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements1); + CHECK_EQUAL(Number_Of_Elements, Number_Of_Elements2); - //************************************************************************* - TEST(test_default_constructor_explicit_int8_t_element_types_bits) - { - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(8U, (etl::integral_limits::element_type>::bits)); - } + //******************************* + constexpr element_type All_Set_Element1 = bitset_type::All_Set_Element; + constexpr element_type All_Set_Element2 = bitset_type::all_set_element(); - //************************************************************************* - TEST(test_default_constructor_explicit_int8_t_element_types_number_of_elements) - { - CHECK_EQUAL(1U, (etl::bitset_ext<1, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<2, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<3, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<4, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<5, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<6, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<7, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<8, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<9, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<10, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<11, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<12, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<13, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<14, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<15, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<16, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<17, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<18, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<19, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<20, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<21, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<22, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<23, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<24, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<25, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<26, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<27, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<28, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<29, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<30, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<31, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<32, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(5U, (etl::bitset_ext<33, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(5U, (etl::bitset_ext<34, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(5U, (etl::bitset_ext<35, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(5U, (etl::bitset_ext<36, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(5U, (etl::bitset_ext<37, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(5U, (etl::bitset_ext<38, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(5U, (etl::bitset_ext<39, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(5U, (etl::bitset_ext<40, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(6U, (etl::bitset_ext<41, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(6U, (etl::bitset_ext<42, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(6U, (etl::bitset_ext<43, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(6U, (etl::bitset_ext<44, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(6U, (etl::bitset_ext<45, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(6U, (etl::bitset_ext<46, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(6U, (etl::bitset_ext<47, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(6U, (etl::bitset_ext<48, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(7U, (etl::bitset_ext<49, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(7U, (etl::bitset_ext<50, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(7U, (etl::bitset_ext<51, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(7U, (etl::bitset_ext<52, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(7U, (etl::bitset_ext<53, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(7U, (etl::bitset_ext<54, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(7U, (etl::bitset_ext<55, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(7U, (etl::bitset_ext<56, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(8U, (etl::bitset_ext<57, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(8U, (etl::bitset_ext<58, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(8U, (etl::bitset_ext<59, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(8U, (etl::bitset_ext<60, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(8U, (etl::bitset_ext<61, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(8U, (etl::bitset_ext<62, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(8U, (etl::bitset_ext<63, int8_t>::Number_Of_Elements)); - CHECK_EQUAL(8U, (etl::bitset_ext<64, int8_t>::Number_Of_Elements)); - } + CHECK_EQUAL(All_Set_Element, All_Set_Element1); + CHECK_EQUAL(All_Set_Element, All_Set_Element2); - //************************************************************************* - TEST(test_default_constructor_explicit_int16_t_element_types_bits) - { - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(16U, (etl::integral_limits::element_type>::bits)); - } + //******************************* + constexpr element_type All_Clear_Element1 = bitset_type::All_Clear_Element; + constexpr element_type All_Clear_Element2 = bitset_type::all_clear_element(); - //************************************************************************* - TEST(test_default_constructor_explicit_int16_t_element_types_number_of_elements) - { - CHECK_EQUAL(1U, (etl::bitset_ext<1, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<2, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<3, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<4, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<5, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<6, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<7, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<8, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<9, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<10, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<11, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<12, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<13, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<14, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<15, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<16, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<17, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<18, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<19, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<20, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<21, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<22, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<23, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<24, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<25, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<26, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<27, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<28, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<29, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<30, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<31, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<32, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<33, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<34, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<35, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<36, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<37, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<38, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<39, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<40, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<41, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<42, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<43, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<44, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<45, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<46, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<47, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(3U, (etl::bitset_ext<48, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<49, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<50, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<51, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<52, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<53, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<54, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<55, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<56, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<57, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<58, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<59, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<60, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<61, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<62, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<63, int16_t>::Number_Of_Elements)); - CHECK_EQUAL(4U, (etl::bitset_ext<64, int16_t>::Number_Of_Elements)); - } + CHECK_EQUAL(All_Clear_Element, All_Clear_Element1); + CHECK_EQUAL(All_Clear_Element, All_Clear_Element2); - //************************************************************************* - TEST(test_default_constructor_explicit_int32_t_element_types_bits) - { - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(32U, (etl::integral_limits::element_type>::bits)); - } + //******************************* + constexpr size_t Allocated_Bits = bitset_type::allocated_bits(); - //************************************************************************* - TEST(test_default_constructor_explicit_int32_t_element_types_number_of_elements) - { - CHECK_EQUAL(1U, (etl::bitset_ext<1, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<2, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<3, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<4, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<5, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<6, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<7, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<8, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<9, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<10, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<11, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<12, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<13, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<14, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<15, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<16, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<17, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<18, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<19, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<20, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<21, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<22, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<23, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<24, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<25, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<26, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<27, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<28, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<29, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<30, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<31, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<32, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<33, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<34, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<35, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<36, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<37, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<38, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<39, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<40, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<41, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<42, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<43, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<44, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<45, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<46, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<47, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<48, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<49, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<50, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<51, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<52, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<53, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<54, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<55, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<56, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<57, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<58, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<59, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<60, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<61, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<62, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<63, int32_t>::Number_Of_Elements)); - CHECK_EQUAL(2U, (etl::bitset_ext<64, int32_t>::Number_Of_Elements)); - } + CHECK_EQUAL(Number_Of_Elements * Bits_Per_Element, Allocated_Bits); - //************************************************************************* - TEST(test_default_constructor_explicit_int64_t_element_types_bits) - { - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - CHECK_EQUAL(64U, (etl::integral_limits::element_type>::bits)); - } + //******************************* + constexpr char Storage_Model1 = bitset_type::Storage_Model; + constexpr char Storage_Model2 = bitset_type::storage_model(); - //************************************************************************* - TEST(test_default_constructor_explicit_int64_t_element_types_number_of_elements) - { - CHECK_EQUAL(1U, (etl::bitset_ext<1, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<2, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<3, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<4, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<5, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<6, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<7, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<8, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<9, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<10, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<11, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<12, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<13, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<14, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<15, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<16, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<17, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<18, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<19, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<20, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<21, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<22, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<23, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<24, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<25, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<26, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<27, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<28, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<29, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<30, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<31, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<32, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<33, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<34, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<35, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<36, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<37, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<38, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<39, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<40, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<41, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<42, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<43, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<44, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<45, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<46, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<47, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<48, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<49, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<50, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<51, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<52, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<53, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<54, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<55, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<56, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<57, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<58, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<59, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<60, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<61, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<62, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<63, int64_t>::Number_Of_Elements)); - CHECK_EQUAL(1U, (etl::bitset_ext<64, int64_t>::Number_Of_Elements)); + 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())); } //************************************************************************* @@ -777,23 +126,55 @@ namespace CHECK_THROW(BsExt bs1(nullptr), etl::bitset_invalid_buffer); CHECK_THROW(BsExt bs2b(bs2a, nullptr), etl::bitset_invalid_buffer); - CHECK_THROW(BsExt bs3(0ULL, nullptr), etl::bitset_invalid_buffer); - CHECK_THROW(BsExt bs4("0", nullptr), etl::bitset_invalid_buffer); - CHECK_THROW(BsExt bs5(L"0", nullptr), etl::bitset_invalid_buffer); - CHECK_THROW(BsExt bs6(u"0", nullptr), etl::bitset_invalid_buffer); - CHECK_THROW(BsExt bs7(U"0", nullptr), etl::bitset_invalid_buffer); + CHECK_THROW(BsExt bs3(0ULL, nullptr), etl::bitset_invalid_buffer); + CHECK_THROW(BsExt bs4("0", nullptr), etl::bitset_invalid_buffer); + CHECK_THROW(BsExt bs5(L"0", nullptr), etl::bitset_invalid_buffer); + CHECK_THROW(BsExt bs6(u"0", nullptr), etl::bitset_invalid_buffer); + CHECK_THROW(BsExt bs7(U"0", nullptr), etl::bitset_invalid_buffer); + } + + //************************************************************************* + TEST(test_default_constructor_from_array) + { + etl::bitset_ext<64>::element_type buffer[etl::bitset_ext<64>::Number_Of_Elements]; + std::bitset<64> compare; + etl::bitset_ext<64> data(buffer); + + CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.count(), data.count()); + + for (size_t i = 0UL; i < data.size(); ++i) + { + CHECK_EQUAL(compare.test(i), data.test(i)); + } + } + + //************************************************************************* + TEST(test_default_constructor_from_buffer_type) + { + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare; + etl::bitset_ext<64> data(buffer); + + CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.count(), data.count()); + + for (size_t i = 0UL; i < data.size(); ++i) + { + CHECK_EQUAL(compare.test(i), data.test(i)); + } } //************************************************************************* TEST(test_construct_from_value) { - etl::bitset_ext<60>::buffer_type buffer; + etl::bitset_ext<64>::buffer_type buffer1; + std::bitset<64> compare(0x123456731234567ULL); + etl::bitset_ext<64> data(0x123456731234567ULL, buffer1); - std::bitset<60> compare(0x123456731234567ULL); - etl::bitset_ext<60> data(0x123456731234567ULL, buffer); - - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); + CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -804,12 +185,11 @@ namespace //************************************************************************* TEST(test_copy_construct) { - etl::bitset_ext<60>::buffer_type buffer1; - etl::bitset_ext<60>::buffer_type buffer2; - - std::bitset<60> compare(0x123456731234567ULL); - etl::bitset_ext<60> data(0x123456731234567ULL, buffer1); - etl::bitset_ext<60> data_copy(data, buffer2); + etl::bitset_ext<64>::buffer_type buffer1; + etl::bitset_ext<64>::buffer_type buffer2; + std::bitset<64> compare(0x123456731234567ULL); + etl::bitset_ext<64> data(0x123456731234567ULL, buffer1); + etl::bitset_ext<64> data_copy(data, buffer2); CHECK_EQUAL(compare.size(), data_copy.size()); CHECK_EQUAL(compare.count(), data_copy.count()); @@ -823,12 +203,11 @@ namespace //************************************************************************* TEST(test_construct_from_excess_value) { - etl::bitset_ext<60>::buffer_type buffer; + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare(0x8765432187654321ULL); + etl::bitset_ext<64> data(0x8765432187654321ULL, buffer); - std::bitset<60> compare(0x8765432187654321ULL); - etl::bitset_ext<60> data(0x8765432187654321ULL, buffer); - - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); for (size_t i = 0UL; i < data.size(); ++i) @@ -840,12 +219,11 @@ namespace //************************************************************************* TEST(test_construct_from_char_string) { - etl::bitset_ext<60>::buffer_type buffer; + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); + etl::bitset_ext<64> data("110001001000110100010101100111001100010010001101000101011001", buffer); - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<60> data("110001001000110100010101100111001100010010001101000101011001", buffer); - - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); for (size_t i = 0UL; i < data.size(); ++i) @@ -857,10 +235,9 @@ namespace //************************************************************************* TEST(test_construct_from_wchar_t_string) { - etl::bitset_ext<60>::buffer_type buffer; - - std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<60> data(L"110001001000110100010101100111001100010010001101000101011001", buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001"); + etl::bitset_ext<64> data(L"110001001000110100010101100111001100010010001101000101011001", buffer); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -874,10 +251,9 @@ namespace //************************************************************************* TEST(test_construct_from_char16_t_string) { - etl::bitset_ext<60>::buffer_type buffer; - - std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<60> data(u"110001001000110100010101100111001100010010001101000101011001", buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001"); + etl::bitset_ext<64> data(u"110001001000110100010101100111001100010010001101000101011001", buffer); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -891,10 +267,9 @@ namespace //************************************************************************* TEST(test_construct_from_char32_t_string) { - etl::bitset_ext<60>::buffer_type buffer; - - std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<60> data(U"110001001000110100010101100111001100010010001101000101011001", buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001"); + etl::bitset_ext<64> data(U"110001001000110100010101100111001100010010001101000101011001", buffer); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -908,10 +283,9 @@ namespace //************************************************************************* TEST(test_construct_from_nullptr_char_string) { - etl::bitset_ext<60>::buffer_type buffer; - const char* s = nullptr; + etl::bitset_ext<60>::buffer_type buffer; etl::bitset_ext<60> data(s, buffer); CHECK_EQUAL(60, data.size()); @@ -921,10 +295,9 @@ namespace //************************************************************************* TEST(test_construct_from_nullptr_wchar_t_string) { - etl::bitset_ext<60>::buffer_type buffer; - const wchar_t* s = nullptr; + etl::bitset_ext<60>::buffer_type buffer; etl::bitset_ext<60> data(s, buffer); CHECK_EQUAL(60, data.size()); @@ -934,10 +307,9 @@ namespace //************************************************************************* TEST(test_construct_from_nullptr_char16_t_string) { - etl::bitset_ext<60>::buffer_type buffer; - const char16_t* s = nullptr; + etl::bitset_ext<60>::buffer_type buffer; etl::bitset_ext<60> data(s, buffer); CHECK_EQUAL(60, data.size()); @@ -947,10 +319,9 @@ namespace //************************************************************************* TEST(test_construct_from_nullptr_char32_t_string) { - etl::bitset_ext<60>::buffer_type buffer; - const char32_t* s = nullptr; + etl::bitset_ext<60>::buffer_type buffer; etl::bitset_ext<60> data(s, buffer); CHECK_EQUAL(60, data.size()); @@ -960,16 +331,17 @@ namespace //************************************************************************* TEST(test_construct_from_excess_string) { - etl::bitset_ext<60>::buffer_type buffer; + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001111100001"); + etl::bitset_ext<64> data("110001001000110100010101100111001100010010001101000101011001111100001", buffer); - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001111100001"); - etl::bitset_ext<60> data("110001001000110100010101100111001100010010001101000101011001111100001", buffer); - - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); + + CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -977,22 +349,300 @@ namespace } } - //************************************************************************* + //************************************************************************* TEST(test_set) { - etl::bitset_ext<60>::buffer_type buffer; + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare; + etl::bitset_ext<64> data(buffer); + compare.set(); + data.set(); + + 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_less_than_full_size) + { + etl::bitset_ext<60>::buffer_type buffer; std::bitset<60> compare; etl::bitset_ext<60> data(buffer); compare.set(); data.set(); - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + 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_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) { @@ -1003,18 +653,17 @@ namespace //************************************************************************* TEST(test_set_with_char_string) { - etl::bitset_ext<60>::buffer_type buffer; - - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<60> data(buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); + etl::bitset_ext<64> data(buffer); data.set("110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -1025,10 +674,9 @@ namespace //************************************************************************* TEST(test_set_with_wchar_t_string) { - etl::bitset_ext<60>::buffer_type buffer; - - std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<60> data(buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001"); + etl::bitset_ext<64> data(buffer); data.set(L"110001001000110100010101100111001100010010001101000101011001"); @@ -1047,10 +695,9 @@ namespace //************************************************************************* TEST(test_set_with_char16_t_string) { - etl::bitset_ext<60>::buffer_type buffer; - - std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<60> data(buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001"); + etl::bitset_ext<64> data(buffer); data.set(u"110001001000110100010101100111001100010010001101000101011001"); @@ -1069,10 +716,9 @@ namespace //************************************************************************* TEST(test_set_with_char32_t_string) { - etl::bitset_ext<60>::buffer_type buffer; - - std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<60> data(buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001"); + etl::bitset_ext<64> data(buffer); data.set(U"110001001000110100010101100111001100010010001101000101011001"); @@ -1093,11 +739,11 @@ namespace { const char* s = nullptr; - etl::bitset_ext<60>::buffer_type buffer; - etl::bitset_ext<60> data(buffer); + etl::bitset_ext<64>::buffer_type buffer; + etl::bitset_ext<64> data(buffer); data.set(s); - CHECK_EQUAL(60, data.size()); + CHECK_EQUAL(64, data.size()); CHECK_EQUAL(0, data.count()); } @@ -1106,11 +752,11 @@ namespace { const wchar_t* s = nullptr; - etl::bitset_ext<60>::buffer_type buffer; - etl::bitset_ext<60> data(buffer); + etl::bitset_ext<64>::buffer_type buffer; + etl::bitset_ext<64> data(buffer); data.set(s); - CHECK_EQUAL(60, data.size()); + CHECK_EQUAL(64, data.size()); CHECK_EQUAL(0, data.count()); } @@ -1119,11 +765,11 @@ namespace { const char16_t* s = nullptr; - etl::bitset_ext<60>::buffer_type buffer; - etl::bitset_ext<60> data(buffer); + etl::bitset_ext<64>::buffer_type buffer; + etl::bitset_ext<64> data(buffer); data.set(s); - CHECK_EQUAL(60, data.size()); + CHECK_EQUAL(64, data.size()); CHECK_EQUAL(0, data.count()); } @@ -1132,21 +778,20 @@ namespace { const char32_t* s = nullptr; - etl::bitset_ext<60>::buffer_type buffer; - etl::bitset_ext<60> data(buffer); + etl::bitset_ext<64>::buffer_type buffer; + etl::bitset_ext<64> data(buffer); data.set(s); - CHECK_EQUAL(60, data.size()); + CHECK_EQUAL(64, data.size()); CHECK_EQUAL(0, data.count()); } //************************************************************************* TEST(test_from_string_with_char) { - etl::bitset_ext<60>::buffer_type buffer; - - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<60> data(buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); + etl::bitset_ext<64> data(buffer); data.from_string("110001001000110100010101100111001100010010001101000101011001"); @@ -1165,10 +810,9 @@ namespace //************************************************************************* TEST(test_from_string_with_wchar_t) { - etl::bitset_ext<60>::buffer_type buffer; - - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<60> data(buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); + etl::bitset_ext<64> data(buffer); data.from_string(L"110001001000110100010101100111001100010010001101000101011001"); @@ -1185,12 +829,11 @@ namespace } //************************************************************************* - TEST(test_from_char16_t_6string) + TEST(test_from_string_with_char16_t) { - etl::bitset_ext<60>::buffer_type buffer; - - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<60> data(buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); + etl::bitset_ext<64> data(buffer); data.from_string(u"110001001000110100010101100111001100010010001101000101011001"); @@ -1209,10 +852,9 @@ namespace //************************************************************************* TEST(test_from_string_with_char32_t) { - etl::bitset_ext<60>::buffer_type buffer; - - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<60> data(buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); + etl::bitset_ext<64> data(buffer); data.from_string(U"110001001000110100010101100111001100010010001101000101011001"); @@ -1280,11 +922,50 @@ namespace CHECK_EQUAL(0, data.count()); } + //************************************************************************* + TEST(test_value_u8_min) + { + etl::bitset_ext<8>::buffer_type buffer; + etl::bitset_ext<8> data((unsigned long long)etl::integral_limits::min, buffer); + uint8_t value = data.value(); + + CHECK_EQUAL(std::numeric_limits::min(), value); + } + + //************************************************************************* + TEST(test_value_u8_max) + { + etl::bitset_ext<8>::buffer_type buffer; + etl::bitset_ext<8> data((unsigned long long)etl::integral_limits::max, buffer); + uint8_t value = data.value(); + + CHECK_EQUAL(std::numeric_limits::max(), value); + } + + //************************************************************************* + TEST(test_value_s8_min) + { + etl::bitset_ext<8>::buffer_type buffer; + etl::bitset_ext<8> data((unsigned long long)etl::integral_limits::min, buffer); + uint8_t value = data.value(); + + CHECK_EQUAL(std::numeric_limits::min(), value); + } + + //************************************************************************* + TEST(test_value_s8_max) + { + etl::bitset_ext<8>::buffer_type buffer; + etl::bitset_ext<8> data((unsigned long long)etl::integral_limits::max, buffer); + uint8_t value = data.value(); + + CHECK_EQUAL(std::numeric_limits::max(), value); + } + //************************************************************************* TEST(test_value_u16_min) { etl::bitset_ext<16>::buffer_type buffer; - etl::bitset_ext<16> data((unsigned long long)etl::integral_limits::min, buffer); uint16_t value = data.value(); @@ -1295,7 +976,6 @@ namespace TEST(test_value_u16_max) { etl::bitset_ext<16>::buffer_type buffer; - etl::bitset_ext<16> data((unsigned long long)etl::integral_limits::max, buffer); uint16_t value = data.value(); @@ -1306,29 +986,26 @@ namespace TEST(test_value_s16_min) { etl::bitset_ext<16>::buffer_type buffer; + etl::bitset_ext<16> data((unsigned long long)etl::integral_limits::min, buffer); + uint16_t value = data.value(); - etl::bitset_ext<16> data((unsigned long long)etl::integral_limits::min, buffer); - int16_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::min(), value); + CHECK_EQUAL(std::numeric_limits::min(), value); } //************************************************************************* TEST(test_value_s16_max) { etl::bitset_ext<16>::buffer_type buffer; + etl::bitset_ext<16> data((unsigned long long)etl::integral_limits::max, buffer); + uint16_t value = data.value(); - etl::bitset_ext<16> data((unsigned long long)etl::integral_limits::max, buffer); - int16_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::max(), value); + CHECK_EQUAL(std::numeric_limits::max(), value); } //************************************************************************* TEST(test_value_u32_min) { - etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements]; - + etl::bitset_ext<32>::buffer_type buffer; etl::bitset_ext<32> data((unsigned long long)etl::integral_limits::min, buffer); uint32_t value = data.value(); @@ -1338,8 +1015,7 @@ namespace //************************************************************************* TEST(test_value_u32_max) { - etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements]; - + etl::bitset_ext<32>::buffer_type buffer; etl::bitset_ext<32> data((unsigned long long)etl::integral_limits::max, buffer); uint32_t value = data.value(); @@ -1349,30 +1025,27 @@ namespace //************************************************************************* TEST(test_value_s32_min) { - etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements]; + etl::bitset_ext<32>::buffer_type buffer; + etl::bitset_ext<32> data((unsigned long long)etl::integral_limits::min, buffer); + uint32_t value = data.value(); - etl::bitset_ext<32> data((unsigned long long)etl::integral_limits::min, buffer); - int32_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::min(), value); + CHECK_EQUAL(std::numeric_limits::min(), value); } //************************************************************************* TEST(test_value_s32_max) { - etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements]; + etl::bitset_ext<32>::buffer_type buffer; + etl::bitset_ext<32> data((unsigned long long)etl::integral_limits::max, buffer); + uint32_t value = data.value(); - etl::bitset_ext<32> data((unsigned long long)etl::integral_limits::max, buffer); - int32_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::max(), value); + CHECK_EQUAL(std::numeric_limits::max(), value); } //************************************************************************* TEST(test_value_u64_min) { - etl::bitset_ext<64>::element_type buffer[etl::bitset_ext<64>::Number_Of_Elements]; - + etl::bitset_ext<64>::buffer_type buffer; etl::bitset_ext<64> data((unsigned long long)etl::integral_limits::min, buffer); uint64_t value = data.value(); @@ -1382,8 +1055,7 @@ namespace //************************************************************************* TEST(test_value_u64_max) { - etl::bitset_ext<64>::element_type buffer[etl::bitset_ext<64>::Number_Of_Elements]; - + etl::bitset_ext<64>::buffer_type buffer; etl::bitset_ext<64> data((unsigned long long)etl::integral_limits::max, buffer); uint64_t value = data.value(); @@ -1393,32 +1065,29 @@ namespace //************************************************************************* TEST(test_value_s64_min) { - etl::bitset_ext<64>::element_type buffer[etl::bitset_ext<64>::Number_Of_Elements]; + etl::bitset_ext<64>::buffer_type buffer; + etl::bitset_ext<64> data((unsigned long long)etl::integral_limits::min, buffer); + uint64_t value = data.value(); - etl::bitset_ext<64> data((unsigned long long)etl::integral_limits::min, buffer); - int64_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::min(), value); + CHECK_EQUAL(std::numeric_limits::min(), value); } //************************************************************************* TEST(test_value_s64_max) { - etl::bitset_ext<64>::element_type buffer[etl::bitset_ext<64>::Number_Of_Elements]; + etl::bitset_ext<64>::buffer_type buffer; + etl::bitset_ext<64> data((unsigned long long)etl::integral_limits::max, buffer); + uint64_t value = data.value(); - etl::bitset_ext<64> data((unsigned long long)etl::integral_limits::max, buffer); - int64_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::max(), value); + CHECK_EQUAL(std::numeric_limits::max(), value); } //************************************************************************* TEST(test_position_set) { - etl::bitset_ext<60>::buffer_type buffer; - - std::bitset<60> compare; - etl::bitset_ext<60> data(buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare; + etl::bitset_ext<64> data(buffer); for (size_t i = 0UL; i < data.size(); ++i) { @@ -1450,19 +1119,18 @@ namespace //************************************************************************* TEST(test_reset) { - etl::bitset_ext<60>::buffer_type buffer; - - std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL); - etl::bitset_ext<60> data(0xFFFFFFFFFFFFFFFULL, buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); + etl::bitset_ext<64> data(0xFFFFFFFFFFFFFFFULL, buffer); compare.reset(); data.reset(); - - CHECK_EQUAL(compare.size(), data.size()); + + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -1473,10 +1141,9 @@ namespace //************************************************************************* TEST(test_position_reset) { - etl::bitset_ext<60>::buffer_type buffer; - - std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL); - etl::bitset_ext<60> data(0xFFFFFFFFFFFFFFFULL, buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); + etl::bitset_ext<64> data(0xFFFFFFFFFFFFFFFULL, buffer); compare.reset(1); compare.reset(3); @@ -1488,11 +1155,11 @@ namespace data.reset(7); data.reset(13); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -1530,10 +1197,9 @@ namespace //************************************************************************* TEST(test_index_operator_read) { - etl::bitset_ext<60>::buffer_type buffer; - - std::bitset<60> compare(0x3123456731234567ULL); - etl::bitset_ext<60> data(0x3123456731234567ULL, buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare(0x3123456731234567ULL); + etl::bitset_ext<64> data(0x3123456731234567ULL, buffer); bool bc0 = compare[1U]; bool bd0 = data[1U]; @@ -1555,8 +1221,8 @@ namespace //************************************************************************* TEST(test_index_operator_write) { - etl::bitset_ext<60>::buffer_type buffer; - etl::bitset_ext<60> data(buffer); + etl::bitset_ext<64>::buffer_type buffer; + etl::bitset_ext<64> data(buffer); data[1U] = true; data[3U] = true; @@ -1572,15 +1238,14 @@ namespace //************************************************************************* TEST(test_any) { - etl::bitset_ext<60>::buffer_type buffer1; - etl::bitset_ext<60>::buffer_type buffer2; - etl::bitset_ext<60>::buffer_type buffer3; - etl::bitset_ext<60>::buffer_type buffer4; - - etl::bitset_ext<60> data1(ull(0x0000000000000000), buffer1); - etl::bitset_ext<60> data2(ull(0x0000010000000000), buffer2); - etl::bitset_ext<60> data3(ull(0x0000010001000100), buffer3); - etl::bitset_ext<60> data4(ull(0x0FFFFFFFFFFFFFFF), buffer4); + etl::bitset_ext<64>::buffer_type buffer1; + etl::bitset_ext<64>::buffer_type buffer2; + etl::bitset_ext<64>::buffer_type buffer3; + etl::bitset_ext<64>::buffer_type buffer4; + etl::bitset_ext<64> data1(ull(0x0000000000000000), buffer1); + etl::bitset_ext<64> data2(ull(0x0000010000000000), buffer2); + etl::bitset_ext<64> data3(ull(0x1000010001000100), buffer3); + etl::bitset_ext<64> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); bool bd1 = data1.any(); bool bd2 = data2.any(); @@ -1596,15 +1261,14 @@ namespace //************************************************************************* TEST(test_none) { - etl::bitset_ext<60>::buffer_type buffer1; - etl::bitset_ext<60>::buffer_type buffer2; - etl::bitset_ext<60>::buffer_type buffer3; - etl::bitset_ext<60>::buffer_type buffer4; - - etl::bitset_ext<60> data1(ull(0x0000000000000000), buffer1); - etl::bitset_ext<60> data2(ull(0x0000010000000000), buffer2); - etl::bitset_ext<60> data3(ull(0x0000010001000100), buffer3); - etl::bitset_ext<60> data4(ull(0x0FFFFFFFFFFFFFFF), buffer4); + etl::bitset_ext<64>::buffer_type buffer1; + etl::bitset_ext<64>::buffer_type buffer2; + etl::bitset_ext<64>::buffer_type buffer3; + etl::bitset_ext<64>::buffer_type buffer4; + etl::bitset_ext<64> data1(ull(0x0000000000000000), buffer1); + etl::bitset_ext<64> data2(ull(0x0000010000000000), buffer2); + etl::bitset_ext<64> data3(ull(0x1000010001000100), buffer3); + etl::bitset_ext<64> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); bool bd1 = data1.none(); bool bd2 = data2.none(); @@ -1619,16 +1283,84 @@ namespace //************************************************************************* TEST(test_all) + { + etl::bitset_ext<64>::buffer_type buffer1; + etl::bitset_ext<64>::buffer_type buffer2; + etl::bitset_ext<64>::buffer_type buffer3; + etl::bitset_ext<64>::buffer_type buffer4; + etl::bitset_ext<64> data1(ull(0x0000000000000000), buffer1); + etl::bitset_ext<64> data2(ull(0x0000010000000000), buffer2); + etl::bitset_ext<64> data3(ull(0x1000010001000100), buffer3); + etl::bitset_ext<64> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); + + bool bd1 = data1.all(); + bool bd2 = data2.all(); + bool bd3 = data3.all(); + bool bd4 = data4.all(); + + CHECK_FALSE(bd1); + CHECK_FALSE(bd2); + CHECK_FALSE(bd3); + CHECK_TRUE(bd4); + } + + //************************************************************************* + TEST(test_any_with_reduced_active_bits) { etl::bitset_ext<60>::buffer_type buffer1; etl::bitset_ext<60>::buffer_type buffer2; etl::bitset_ext<60>::buffer_type buffer3; etl::bitset_ext<60>::buffer_type buffer4; - etl::bitset_ext<60> data1(ull(0x0000000000000000), buffer1); etl::bitset_ext<60> data2(ull(0x0000010000000000), buffer2); - etl::bitset_ext<60> data3(ull(0x0000010001000100), buffer3); - etl::bitset_ext<60> data4(ull(0x0FFFFFFFFFFFFFFF), buffer4); + etl::bitset_ext<60> data3(ull(0x1000010001000100), buffer3); + etl::bitset_ext<60> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); + + bool bd1 = data1.any(); + bool bd2 = data2.any(); + bool bd3 = data3.any(); + bool bd4 = data4.any(); + + CHECK_FALSE(bd1); + CHECK_TRUE(bd2); + CHECK_TRUE(bd3); + CHECK_TRUE(bd4); + } + + //************************************************************************* + TEST(test_none_with_reduced_active_bits) + { + etl::bitset_ext<60>::buffer_type buffer1; + etl::bitset_ext<60>::buffer_type buffer2; + etl::bitset_ext<60>::buffer_type buffer3; + etl::bitset_ext<60>::buffer_type buffer4; + etl::bitset_ext<60> data1(ull(0x0000000000000000), buffer1); + etl::bitset_ext<60> data2(ull(0x0000010000000000), buffer2); + etl::bitset_ext<60> data3(ull(0x1000010001000100), buffer3); + etl::bitset_ext<60> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); + + bool bd1 = data1.none(); + bool bd2 = data2.none(); + bool bd3 = data3.none(); + bool bd4 = data4.none(); + + CHECK_TRUE(bd1); + CHECK_FALSE(bd2); + CHECK_FALSE(bd3); + CHECK_FALSE(bd4); + } + + //************************************************************************* + TEST(test_all_with_reduced_active_bits) + { + etl::bitset_ext<60>::buffer_type buffer1; + etl::bitset_ext<60>::buffer_type buffer2; + etl::bitset_ext<60>::buffer_type buffer3; + etl::bitset_ext<60>::buffer_type buffer4; + etl::bitset_ext<60> data1(ull(0x0000000000000000), buffer1); + etl::bitset_ext<60> data2(ull(0x0000010000000000), buffer2); + etl::bitset_ext<60> data3(ull(0x1000010001000100), buffer3); + etl::bitset_ext<60> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); bool bd1 = data1.all(); bool bd2 = data2.all(); @@ -1644,9 +1376,9 @@ namespace //************************************************************************* TEST(test_flip) { - etl::bitset_ext<60>::buffer_type buffer; - std::bitset<60> compare; - etl::bitset_ext<60> data(buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare; + etl::bitset_ext<64> data(buffer); compare.flip(); data.flip(); @@ -1657,12 +1389,12 @@ namespace } } - //************************************************************************* + //************************************************************************* TEST(test_flip_position) { - etl::bitset_ext<60>::buffer_type buffer; - std::bitset<60> compare; - etl::bitset_ext<60> data(buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare; + etl::bitset_ext<64> data(buffer); compare.flip(1); compare.flip(3); @@ -1683,9 +1415,9 @@ namespace //************************************************************************* TEST(test_flip_reference) { - etl::bitset_ext<60>::buffer_type buffer; - std::bitset<60> compare; - etl::bitset_ext<60> data(buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare; + etl::bitset_ext<64> data(buffer); compare[1].flip(); compare[3].flip(); @@ -1706,10 +1438,9 @@ namespace //************************************************************************* TEST(test_invert_reference) { - etl::bitset_ext<60>::buffer_type buffer; - - std::bitset<60> compare; - etl::bitset_ext<60> data(buffer); + etl::bitset_ext<64>::buffer_type buffer; + std::bitset<64> compare; + etl::bitset_ext<64> data(buffer); bool bc = ~compare[3]; bool bd = ~data[3]; @@ -1717,19 +1448,18 @@ namespace } //************************************************************************* - void test_assignment_operator_helper(etl::bitset_ext<60>& from, etl::bitset_ext<60>& to) + void test_assignment_operator_helper(etl::bitset_ext<64>&from, etl::bitset_ext<64>&to) { to = from; } TEST(test_assignment_operator) { - etl::bitset_ext<60>::buffer_type buffer1; - etl::bitset_ext<60>::buffer_type buffer2; - - std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL); - etl::bitset_ext<60> data1(0xFFFFFFFFFFFFFFFULL, buffer1); - etl::bitset_ext<60> data2(buffer2); + etl::bitset_ext<64>::buffer_type buffer1; + etl::bitset_ext<64>::buffer_type buffer2; + std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); + etl::bitset_ext<64> data1(0xFFFFFFFFFFFFFFFULL, buffer1); + etl::bitset_ext<64> data2(buffer2); test_assignment_operator_helper(data1, data2); @@ -1742,15 +1472,14 @@ namespace //************************************************************************* TEST(test_equality_operator) { - etl::bitset_ext<60>::buffer_type buffer1; - etl::bitset_ext<60>::buffer_type buffer2; - etl::bitset_ext<60>::buffer_type buffer3; + etl::bitset_ext<64>::buffer_type buffer1; + etl::bitset_ext<64>::buffer_type buffer2; + etl::bitset_ext<64>::buffer_type buffer3; + etl::bitset_ext<64> data1(0x123456781234567ULL, buffer1); + etl::bitset_ext<64> data2(0x123456781234567ULL, buffer2); + etl::bitset_ext<64> data3(buffer3); - etl::bitset_ext<60> data1(0x123456781234567ULL, buffer1); - etl::bitset_ext<60> data2(0x123456781234567ULL, buffer2); - etl::bitset_ext<60> data3(buffer3); - - bool equal = (data1 == data2); + bool equal = (data1 == data2); bool not_equal = !(data1 == data3); CHECK(equal); @@ -1760,13 +1489,12 @@ namespace //************************************************************************* TEST(test_inequality_operator) { - etl::bitset_ext<60>::buffer_type buffer1; - etl::bitset_ext<60>::buffer_type buffer2; - etl::bitset_ext<60>::buffer_type buffer3; - - etl::bitset_ext<60> data1(0x123456781234567ULL, buffer1); - etl::bitset_ext<60> data2(0x123456781234567ULL, buffer2); - etl::bitset_ext<60> data3(buffer3); + etl::bitset_ext<64>::buffer_type buffer1; + etl::bitset_ext<64>::buffer_type buffer2; + etl::bitset_ext<64>::buffer_type buffer3; + etl::bitset_ext<64> data1(0x123456781234567ULL, buffer1); + etl::bitset_ext<64> data2(0x123456781234567ULL, buffer2); + etl::bitset_ext<64> data3(buffer3); bool equal = !(data1 != data2); bool not_equal = (data1 != data3); @@ -1776,9 +1504,9 @@ namespace } //************************************************************************* - TEST(test_shift_left_operator_all_shifts_full_size) + TEST(test_shift_left_operator) { - int64_t value = 0x0123456789ABCDEFULL; + uint64_t value = 0x0123456789ABCDEFULL; uint64_t mask = 0xFFFFFFFFFFFFFFFFULL; etl::bitset_ext<64>::buffer_type buffer1; @@ -1789,40 +1517,31 @@ namespace for (ull shift = 0U; shift < 64U; ++shift) { etl::bitset_ext<64> data(original, buffer2); - CHECK_EQUAL_HEX(((value & mask) << shift), (data <<= shift).value()); + CHECK_EQUAL_HEX(((value & mask) << shift), (data <<= shift).value()); mask >>= 1; } etl::bitset_ext<64> data(original, buffer2); - CHECK_EQUAL_HEX(0ULL, (data <<= 64U).value()); + CHECK_EQUAL_HEX(0ULL, (data <<= 64U).value()); } //************************************************************************* - TEST(test_shift_left_operator_all_shifts_partial_size) + TEST(test_shift_left_operator_overflow) { - int64_t value = 0x0123456789ABCDEFULL; - uint64_t mask = 0x0FFFFFFFFFFFFFFFULL; + etl::bitset_ext<32>::buffer_type buffer1; + etl::bitset_ext<32>::buffer_type buffer2; - etl::bitset_ext<60>::buffer_type buffer1; - etl::bitset_ext<60>::buffer_type buffer2; + etl::bitset_ext<32> data(0xFFFFFFFFULL, buffer1); + data <<= 1U; + etl::bitset_ext<32> shifted(0xFFFFFFFEUL, buffer2); - etl::bitset_ext<60> original(0x0123456789ABCDEFULL, buffer1); - - for (ull shift = 0U; shift < 64U; ++shift) - { - etl::bitset_ext<60> data(original, buffer2); - CHECK_EQUAL_HEX(((value & mask) << shift), (data <<= shift).value()); - mask >>= 1; - } - - etl::bitset_ext<60> data(original, buffer2); - CHECK_EQUAL_HEX(0ULL, (data <<= 64U).value()); + CHECK_EQUAL_HEX(shifted.value(), data.value()); } //************************************************************************* - TEST(test_shift_right_operator_all_shifts_full_size) + TEST(test_shift_right_operator) { - int64_t value = 0x0123456789ABCDEFULL; + uint64_t value = 0x0123456789ABCDEFULL; etl::bitset_ext<64>::buffer_type buffer1; etl::bitset_ext<64>::buffer_type buffer2; @@ -1832,46 +1551,26 @@ namespace for (ull shift = 0U; shift < 64U; ++shift) { etl::bitset_ext<64> data(original, buffer2); - CHECK_EQUAL_HEX((value >> shift), (data >>= shift).value()); + CHECK_EQUAL_HEX((value >> shift), (data >>= shift).value()); } etl::bitset_ext<64> data(original, buffer2); - CHECK_EQUAL_HEX(0ULL, (data >>= 64U).value()); - } - - //************************************************************************* - TEST(test_shift_right_operator_all_shifts_partial_size) - { - int64_t value = 0x0123456789ABCDEFULL; - - etl::bitset_ext<60>::buffer_type buffer1; - etl::bitset_ext<60>::buffer_type buffer2; - - etl::bitset_ext<60> original(0x0123456789ABCDEFULL, buffer1); - - for (ull shift = 0U; shift < 64U; ++shift) - { - etl::bitset_ext<60> data(original, buffer2); - CHECK_EQUAL_HEX((value >> shift), (data >>= shift).value()); - } - - etl::bitset_ext<60> data(original, buffer2); - CHECK_EQUAL_HEX(0ULL, (data >>= 64U).value()); + CHECK_EQUAL_HEX(0ULL, (data >>= 64U).value()); } //************************************************************************* TEST(test_and_equals_operator) { - etl::bitset_ext<60>::buffer_type buffer1; - etl::bitset_ext<60>::buffer_type buffer2; - etl::bitset_ext<60>::buffer_type buffer3; - etl::bitset_ext<60>::buffer_type buffer4; + etl::bitset_ext<64>::buffer_type buffer1; + etl::bitset_ext<64>::buffer_type buffer2; + etl::bitset_ext<64>::buffer_type buffer3; + etl::bitset_ext<64>::buffer_type buffer4; - etl::bitset_ext<60> data1(0x12345678UL, buffer1); - etl::bitset_ext<60> data2(0x23456789UL, buffer2); - etl::bitset_ext<60> data3(0x12345678UL & 0x23456789UL, buffer3); - - etl::bitset_ext<60> data4(data1, buffer4); + etl::bitset_ext<64> data1(0x12345678UL, buffer1); + etl::bitset_ext<64> data2(0x23456789UL, buffer2); + etl::bitset_ext<64> data3(0x12345678UL & 0x23456789UL, buffer3); + + etl::bitset_ext<64> data4(data1, buffer4); data4 &= data2; CHECK(data3 == data4); } @@ -1879,16 +1578,16 @@ namespace //************************************************************************* TEST(test_or_equals_operator) { - etl::bitset_ext<60>::buffer_type buffer1; - etl::bitset_ext<60>::buffer_type buffer2; - etl::bitset_ext<60>::buffer_type buffer3; - etl::bitset_ext<60>::buffer_type buffer4; + etl::bitset_ext<64>::buffer_type buffer1; + etl::bitset_ext<64>::buffer_type buffer2; + etl::bitset_ext<64>::buffer_type buffer3; + etl::bitset_ext<64>::buffer_type buffer4; - etl::bitset_ext<60> data1(0x12345678UL, buffer1); - etl::bitset_ext<60> data2(0x23456789UL, buffer2); - etl::bitset_ext<60> data3(0x12345678UL | 0x23456789UL, buffer3); + etl::bitset_ext<64> data1(0x12345678UL, buffer1); + etl::bitset_ext<64> data2(0x23456789UL, buffer2); + etl::bitset_ext<64> data3(0x12345678UL | 0x23456789UL, buffer3); - etl::bitset_ext<60> data4(data1, buffer4); + etl::bitset_ext<64> data4(data1, buffer4); data4 |= data2; CHECK(data3 == data4); } @@ -1896,16 +1595,16 @@ namespace //************************************************************************* TEST(test_xor_equals_operator) { - etl::bitset_ext<60>::buffer_type buffer1; - etl::bitset_ext<60>::buffer_type buffer2; - etl::bitset_ext<60>::buffer_type buffer3; - etl::bitset_ext<60>::buffer_type buffer4; + etl::bitset_ext<64>::buffer_type buffer1; + etl::bitset_ext<64>::buffer_type buffer2; + etl::bitset_ext<64>::buffer_type buffer3; + etl::bitset_ext<64>::buffer_type buffer4; - etl::bitset_ext<60> data1(0x12345678UL, buffer1); - etl::bitset_ext<60> data2(0x23456789UL, buffer2); - etl::bitset_ext<60> data3(0x12345678UL ^ 0x23456789UL, buffer3); + etl::bitset_ext<64> data1(0x12345678UL, buffer1); + etl::bitset_ext<64> data2(0x23456789UL, buffer2); + etl::bitset_ext<64> data3(0x12345678UL ^ 0x23456789UL, buffer3); - etl::bitset_ext<60> data4(data1, buffer4); + etl::bitset_ext<64> data4(data1, buffer4); data4 ^= data2; CHECK(data3 == data4); } @@ -1913,66 +1612,57 @@ namespace //************************************************************************* TEST(test_find_first) { - etl::bitset_ext<9>::element_type buffer1[etl::bitset_ext<9>::Number_Of_Elements]; - etl::bitset_ext<9>::element_type buffer2[etl::bitset_ext<9>::Number_Of_Elements]; - etl::bitset_ext<9>::element_type buffer3[etl::bitset_ext<9>::Number_Of_Elements]; - etl::bitset_ext<9>::element_type buffer4[etl::bitset_ext<9>::Number_Of_Elements]; - etl::bitset_ext<9>::element_type buffer5[etl::bitset_ext<9>::Number_Of_Elements]; - etl::bitset_ext<9>::element_type buffer6[etl::bitset_ext<9>::Number_Of_Elements]; - etl::bitset_ext<9>::element_type buffer7[etl::bitset_ext<9>::Number_Of_Elements]; + etl::bitset_ext<8>::buffer_type buffer; - etl::bitset_ext<9> bs1(ull(0x0000), buffer1); + etl::bitset_ext<8> bs1(ull(0x00), buffer); size_t bs1fff = bs1.find_first(false); size_t bs1fft = bs1.find_first(true); CHECK_EQUAL(0U, bs1fff); CHECK_EQUAL(etl::bitset_ext<>::npos, bs1fft); - etl::bitset_ext<9> bs2(ull(0x01FF), buffer2); + etl::bitset_ext<8> bs2(ull(0xFF), buffer); size_t bs2fff = bs2.find_first(false); size_t bs2fft = bs2.find_first(true); CHECK_EQUAL(etl::bitset_ext<>::npos, bs2fff); CHECK_EQUAL(0U, bs2fft); - etl::bitset_ext<9> bs3(ull(0x0001), buffer3); + etl::bitset_ext<8> bs3(ull(0x01), buffer); size_t bs3fff = bs3.find_first(false); size_t bs3fft = bs3.find_first(true); CHECK_EQUAL(1U, bs3fff); CHECK_EQUAL(0U, bs3fft); - etl::bitset_ext<9> bs4(ull(0x0020), buffer4); + etl::bitset_ext<8> bs4(ull(0x20), buffer); size_t bs4fff = bs4.find_first(false); size_t bs4fft = bs4.find_first(true); CHECK_EQUAL(0U, bs4fff); CHECK_EQUAL(5U, bs4fft); - etl::bitset_ext<9> bs5(ull(0x0021), buffer5); + etl::bitset_ext<8> bs5(ull(0x21), buffer); size_t bs5fff = bs5.find_first(false); size_t bs5fft = bs5.find_first(true); CHECK_EQUAL(1U, bs5fff); CHECK_EQUAL(0U, bs5fft); - etl::bitset_ext<9> bs6(ull(0x000E), buffer6); + etl::bitset_ext<8> bs6(ull(0x0E), buffer); size_t bs6fff = bs6.find_first(false); size_t bs6fft = bs6.find_first(true); CHECK_EQUAL(0U, bs6fff); CHECK_EQUAL(1U, bs6fft); - etl::bitset_ext<9> bs7(ull(0x31), buffer7); + etl::bitset_ext<8> bs7(ull(0x31), buffer); size_t bs7fff = bs7.find_first(false); size_t bs7fft = bs7.find_first(true); CHECK_EQUAL(1U, bs7fff); CHECK_EQUAL(0U, bs7fft); } - + //************************************************************************* TEST(test_find_next) { - etl::bitset_ext<9>::element_type buffer1[etl::bitset_ext<9>::Number_Of_Elements]; - etl::bitset_ext<9>::element_type buffer2[etl::bitset_ext<9>::Number_Of_Elements]; - etl::bitset_ext<9>::element_type buffer3[etl::bitset_ext<9>::Number_Of_Elements]; - etl::bitset_ext<9>::element_type buffer4[etl::bitset_ext<9>::Number_Of_Elements]; + etl::bitset_ext<8>::buffer_type buffer; - etl::bitset_ext<9> bs1(ull(0x0000), buffer1); + etl::bitset_ext<8> bs1(ull(0x00), buffer); size_t bs1fnf0 = bs1.find_next(false, 0); size_t bs1fnf1 = bs1.find_next(false, 1); size_t bs1fnt2 = bs1.find_next(true, 2); @@ -1980,7 +1670,7 @@ namespace CHECK_EQUAL(1U, bs1fnf1); CHECK_EQUAL(etl::bitset_ext<>::npos, bs1fnt2); - etl::bitset_ext<9> bs2(ull(0x1FF), buffer2); + etl::bitset_ext<8> bs2(ull(0xFF), buffer); size_t bs2fnt0 = bs2.find_next(true, 0); size_t bs2fnt1 = bs2.find_next(true, 1); size_t bs2fnf2 = bs2.find_next(false, 2); @@ -1988,7 +1678,7 @@ namespace CHECK_EQUAL(1U, bs2fnt1); CHECK_EQUAL(etl::bitset_ext<>::npos, bs2fnf2); - etl::bitset_ext<9> bs3(ull(0x000E), buffer3); + etl::bitset_ext<8> bs3(ull(0x0E), buffer); size_t bs3fnf0 = bs3.find_next(false, 0); size_t bs3fnt1 = bs3.find_next(true, 1); size_t bs3fnf2 = bs3.find_next(false, 2); @@ -1996,7 +1686,7 @@ namespace CHECK_EQUAL(1U, bs3fnt1); CHECK_EQUAL(4U, bs3fnf2); - etl::bitset_ext<9> bs4(ull(0x0031), buffer4); + etl::bitset_ext<8> bs4(ull(0x31), buffer); size_t bs4fnt0 = bs4.find_next(true, 0); size_t bs4fnf0 = bs4.find_next(false, 0); size_t bs4fnt1 = bs4.find_next(true, 1); @@ -2005,37 +1695,18 @@ namespace CHECK_EQUAL(4U, bs4fnt1); } - //************************************************************************* - TEST(test_find_next_github_issue_617) - { - etl::bitset_ext<64>::element_type buffer1[etl::bitset_ext<64>::Number_Of_Elements]; - etl::bitset_ext<64>::element_type buffer2[etl::bitset_ext<64>::Number_Of_Elements]; - - etl::bitset_ext<64> bs1(ull(0xC000000000000031), buffer1); - size_t bs1fnt1 = bs1.find_next(true, 10); - size_t bs1fnt2 = bs1.find_next(true, 59); - CHECK_EQUAL(62U, bs1fnt1); - CHECK_EQUAL(62U, bs1fnt2); - - etl::bitset_ext<64> bs2(ull(0x3FFFFFFFFFFFFFCE), buffer2); - size_t bs2fnf1 = bs2.find_next(false, 10); - size_t bs2fnf2 = bs2.find_next(false, 59); - CHECK_EQUAL(62U, bs2fnf1); - CHECK_EQUAL(62U, bs2fnf2); - } - //************************************************************************* TEST(test_swap) { - etl::bitset_ext<9>::element_type buffer1[etl::bitset_ext<9>::Number_Of_Elements]; - etl::bitset_ext<9>::element_type buffer2[etl::bitset_ext<9>::Number_Of_Elements]; - etl::bitset_ext<9>::element_type buffer3[etl::bitset_ext<9>::Number_Of_Elements]; - etl::bitset_ext<9>::element_type buffer4[etl::bitset_ext<9>::Number_Of_Elements]; + etl::bitset_ext<16>::buffer_type buffer1; + etl::bitset_ext<16>::buffer_type buffer2; + etl::bitset_ext<16>::buffer_type buffer3; + etl::bitset_ext<16>::buffer_type buffer4; - etl::bitset_ext<9> compare1(0x2A, buffer1); - etl::bitset_ext<9> compare2(0x15, buffer2); - etl::bitset_ext<9> compare1a(0x2A, buffer3); - etl::bitset_ext<9> compare2a(0x15, buffer4); + etl::bitset_ext<16> compare1(0x2A, buffer1); + etl::bitset_ext<16> compare2(0x15, buffer2); + etl::bitset_ext<16> compare1a(0x2A, buffer3); + etl::bitset_ext<16> compare2a(0x15, buffer4); swap(compare1a, compare2a); @@ -2046,55 +1717,83 @@ namespace //************************************************************************* TEST(test_span) { - etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements]; + using bs32 = etl::bitset_ext<32>; + using span_t = bs32::span_type; - using span_t = etl::bitset_ext<32>::span_type; + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); - etl::bitset_ext<32> data(0x12345678UL, buffer); + span_t s = b.span(); - span_t s = data.span(); - CHECK_EQUAL(0x78U, s[0]); - CHECK_EQUAL(0x56U, s[1]); - CHECK_EQUAL(0x34U, s[2]); - CHECK_EQUAL(0x12U, s[3]); + if (etl::endianness::value() == etl::endian::little) + { + CHECK_EQUAL(0x78UL, s[0]); + CHECK_EQUAL(0x56UL, s[1]); + CHECK_EQUAL(0x34UL, s[2]); + CHECK_EQUAL(0x12UL, s[3]); + } + else + { + CHECK_EQUAL(0x78UL, s[3]); + CHECK_EQUAL(0x56UL, s[2]); + CHECK_EQUAL(0x34UL, s[1]); + CHECK_EQUAL(0x12UL, s[0]); + } + + s[2] = 0x9AU; + uint32_t value = b.value(); + CHECK_EQUAL(0x129A5678UL, value); } //************************************************************************* TEST(test_const_span) { - etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements]; + using bs32 = etl::bitset_ext<32>; + using span_t = etl::bitset<32>::const_span_type; - using span_t = etl::bitset_ext<32>::const_span_type; - - const etl::bitset_ext<32> b(0x12345678UL, buffer); + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); span_t s = b.span(); - CHECK_EQUAL(0x78U, s[0]); - CHECK_EQUAL(0x56U, s[1]); - CHECK_EQUAL(0x34U, s[2]); - CHECK_EQUAL(0x12U, s[3]); + if (etl::endianness::value() == etl::endian::little) + { + CHECK_EQUAL(0x78UL, s[0]); + CHECK_EQUAL(0x56UL, s[1]); + CHECK_EQUAL(0x34UL, s[2]); + CHECK_EQUAL(0x12UL, s[3]); + } + else + { + CHECK_EQUAL(0x78UL, s[3]); + CHECK_EQUAL(0x56UL, s[2]); + CHECK_EQUAL(0x34UL, s[1]); + CHECK_EQUAL(0x12UL, s[0]); + } } //************************************************************************* TEST(test_to_string) { - etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements]; + using bs32 = etl::bitset_ext<32>; - etl::bitset_ext<32> b(0x12345678UL, buffer); + bs32::buffer_type buffer; + bs32 data(0x12345678UL, buffer); - etl::string<32> text = b.to_string('.', '*'); - std::string stdtext = b.to_string('.', '*'); + etl::string<32> text = data.to_string('.', '*'); + std::string stdtext = data.to_string('.', '*'); - CHECK_EQUAL("...*..*...**.*...*.*.**..****...", text.c_str()); - CHECK_EQUAL("...*..*...**.*...*.*.**..****...", stdtext.c_str()); + //CHECK_THROW(b.to_string>('.', '*'), etl::bitset_ext_overflow); + CHECK_EQUAL(std::string("...*..*...**.*...*.*.**..****..."), std::string(text.c_str())); + CHECK_EQUAL(std::string("...*..*...**.*...*.*.**..****..."), std::string(stdtext.c_str())); } //************************************************************************* TEST(test_to_wstring) { - etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements]; + using bs32 = etl::bitset_ext<32>; - etl::bitset_ext<32> b(0x12345678UL, buffer); + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); etl::wstring<32> text = b.to_string>(L'.', L'*'); std::wstring stdtext = b.to_string(L'.', L'*'); @@ -2106,9 +1805,10 @@ namespace //************************************************************************* TEST(test_to_u16string) { - etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements]; + using bs32 = etl::bitset_ext<32>; - etl::bitset_ext<32> b(0x12345678UL, buffer); + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); etl::u16string<32> text = b.to_string>(u'.', u'*'); std::u16string stdtext = b.to_string(u'.', u'*'); @@ -2120,9 +1820,10 @@ namespace //************************************************************************* TEST(test_to_u32string) { - etl::bitset_ext<32>::element_type buffer[etl::bitset_ext<32>::Number_Of_Elements]; + using bs32 = etl::bitset_ext<32>; - etl::bitset_ext<32> b(0x12345678UL, buffer); + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); etl::u32string<32> text = b.to_string>(U'.', U'*'); std::u32string stdtext = b.to_string(U'.', U'*'); @@ -2130,5 +1831,567 @@ namespace CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(text.c_str())); CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str())); } + + //************************************************************************* + TEST(test_extract_6_bit_uint8_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract(0, 6))); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract(1, 6))); + CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract(2, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract(3, 6))); + CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract(4, 6))); + CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract(5, 6))); + CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract(6, 6))); + CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract(7, 6))); + CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract(8, 6))); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract(9, 6))); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract(10, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract(11, 6))); + CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract(12, 6))); + CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract(13, 6))); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract(14, 6))); + CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract(15, 6))); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract(16, 6))); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract(17, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract(18, 6))); + CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract(19, 6))); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract(20, 6))); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract(21, 6))); + CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract(22, 6))); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract(23, 6))); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract(24, 6))); + CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract(25, 6))); + CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract(26, 6))); + + CHECK_THROW(b.extract(26, 7), etl::bitset_overflow); + CHECK_THROW(b.extract(27, 6), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_6_bit_uint8_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract())); + + // The lines below should static assert. + //uint8_t v1 = b.extract(); + //uint8_t v1 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_6_bit_int8_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract(0, 6))); + CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract(1, 6))); + CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract(2, 6))); + CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract(3, 6))); + CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract(4, 6))); + CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract(5, 6))); + CHECK_EQUAL_HEX(int8_t(0x19), (b.extract(6, 6))); + CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract(7, 6))); + CHECK_EQUAL_HEX(int8_t(0x16), (b.extract(8, 6))); + CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract(9, 6))); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract(10, 6))); + CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract(11, 6))); + CHECK_EQUAL_HEX(int8_t(0x05), (b.extract(12, 6))); + CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract(13, 6))); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract(14, 6))); + CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract(15, 6))); + CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract(16, 6))); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract(17, 6))); + CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract(18, 6))); + CHECK_EQUAL_HEX(int8_t(0x06), (b.extract(19, 6))); + CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract(20, 6))); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract(21, 6))); + CHECK_EQUAL_HEX(int8_t(0x08), (b.extract(22, 6))); + CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract(23, 6))); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract(24, 6))); + CHECK_EQUAL_HEX(int8_t(0x09), (b.extract(25, 6))); + CHECK_EQUAL_HEX(int8_t(0x04), (b.extract(26, 6))); + + CHECK_THROW(b.extract(26, 7), etl::bitset_overflow); + CHECK_THROW(b.extract(27, 6), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_6_bit_int8_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x19), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x16), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x05), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x06), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x08), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x09), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x04), (b.extract())); + + // The lines below should static assert. + //uint8_t v1 = b.extract(); + //uint8_t v1 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_uint8_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint8_t(0x78), b.extract(0, 8)); + CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract(1, 8)); + CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract(2, 8)); + CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract(3, 8)); + CHECK_EQUAL_HEX(uint8_t(0x67), b.extract(4, 8)); + CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract(5, 8)); + CHECK_EQUAL_HEX(uint8_t(0x59), b.extract(6, 8)); + CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract(7, 8)); + CHECK_EQUAL_HEX(uint8_t(0x56), b.extract(8, 8)); + CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract(9, 8)); + CHECK_EQUAL_HEX(uint8_t(0x15), b.extract(10, 8)); + CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract(11, 8)); + CHECK_EQUAL_HEX(uint8_t(0x45), b.extract(12, 8)); + CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract(13, 8)); + CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract(14, 8)); + CHECK_EQUAL_HEX(uint8_t(0x68), b.extract(15, 8)); + CHECK_EQUAL_HEX(uint8_t(0x34), b.extract(16, 8)); + CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract(17, 8)); + CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract(18, 8)); + CHECK_EQUAL_HEX(uint8_t(0x46), b.extract(19, 8)); + CHECK_EQUAL_HEX(uint8_t(0x23), b.extract(20, 8)); + CHECK_EQUAL_HEX(uint8_t(0x91), b.extract(21, 8)); + CHECK_EQUAL_HEX(uint8_t(0x48), b.extract(22, 8)); + CHECK_EQUAL_HEX(uint8_t(0x24), b.extract(23, 8)); + CHECK_EQUAL_HEX(uint8_t(0x12), b.extract(24, 8)); + + CHECK_THROW(b.extract(24, 9), etl::bitset_overflow); + CHECK_THROW(b.extract(25, 8), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_uint8_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract())); + + // The lines below should static assert. + //uint8_t v1 = b.extract(); + //uint8_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_int8_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint8_t(0x78), b.extract(0, 8)); + CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract(1, 8)); + CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract(2, 8)); + CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract(3, 8)); + CHECK_EQUAL_HEX(uint8_t(0x67), b.extract(4, 8)); + CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract(5, 8)); + CHECK_EQUAL_HEX(uint8_t(0x59), b.extract(6, 8)); + CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract(7, 8)); + CHECK_EQUAL_HEX(uint8_t(0x56), b.extract(8, 8)); + CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract(9, 8)); + CHECK_EQUAL_HEX(uint8_t(0x15), b.extract(10, 8)); + CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract(11, 8)); + CHECK_EQUAL_HEX(uint8_t(0x45), b.extract(12, 8)); + CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract(13, 8)); + CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract(14, 8)); + CHECK_EQUAL_HEX(uint8_t(0x68), b.extract(15, 8)); + CHECK_EQUAL_HEX(uint8_t(0x34), b.extract(16, 8)); + CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract(17, 8)); + CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract(18, 8)); + CHECK_EQUAL_HEX(uint8_t(0x46), b.extract(19, 8)); + CHECK_EQUAL_HEX(uint8_t(0x23), b.extract(20, 8)); + CHECK_EQUAL_HEX(uint8_t(0x91), b.extract(21, 8)); + CHECK_EQUAL_HEX(uint8_t(0x48), b.extract(22, 8)); + CHECK_EQUAL_HEX(uint8_t(0x24), b.extract(23, 8)); + CHECK_EQUAL_HEX(uint8_t(0x12), b.extract(24, 8)); + + CHECK_THROW(b.extract(24, 9), etl::bitset_overflow); + CHECK_THROW(b.extract(25, 8), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_int8_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract())); + + // The lines below should static assert. + //uint8_t v1 = b.extract(); + //uint8_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_13_bits_uint16_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract(0, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract(1, 13)); + CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract(2, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract(3, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract(4, 13)); + CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract(5, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract(6, 13)); + CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract(7, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract(8, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract(9, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract(10, 13)); + CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract(11, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract(12, 13)); + CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract(13, 13)); + CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract(14, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract(15, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract(16, 13)); + CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract(17, 13)); + CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract(18, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract(19, 13)); + + CHECK_THROW(b.extract(19, 14), etl::bitset_overflow); + CHECK_THROW(b.extract(20, 13), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_13_bits_uint16_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract())); + + // The lines below should static assert. + //uint16_t v1 = b.extract; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract(0, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract(1, 16)); + CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract(2, 16)); + CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract(3, 16)); + CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract(4, 16)); + CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract(5, 16)); + CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract(6, 16)); + CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract(7, 16)); + CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract(8, 16)); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract(9, 16)); + CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract(10, 16)); + CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract(11, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract(12, 16)); + CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract(13, 16)); + CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract(14, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract(15, 16)); + CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract(16, 16)); + + CHECK_THROW(b.extract(16, 17), etl::bitset_overflow); + CHECK_THROW(b.extract(17, 16), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_uint16_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract())); + + // The lines below should static assert. + //uint16_t v1 = b.extract(); + //uint16_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_int16_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract(0, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract(1, 16)); + CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract(2, 16)); + CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract(3, 16)); + CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract(4, 16)); + CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract(5, 16)); + CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract(6, 16)); + CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract(7, 16)); + CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract(8, 16)); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract(9, 16)); + CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract(10, 16)); + CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract(11, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract(12, 16)); + CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract(13, 16)); + CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract(14, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract(15, 16)); + CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract(16, 16)); + + CHECK_THROW(b.extract(16, 17), etl::bitset_overflow); + CHECK_THROW(b.extract(17, 16), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_int16_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract())); + + // The lines below should static assert. + //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 0eaf1d19..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,10 +44,81 @@ 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) { - using BsExt = etl::bitset_ext<64, int64_t>; + using BsExt = etl::bitset_ext<64, uint64_t>; BsExt::buffer_type buffer; BsExt bs2a(buffer); @@ -64,9 +135,9 @@ namespace //************************************************************************* TEST(test_default_constructor_from_array) { - etl::bitset_ext<64, int64_t>::element_type buffer[etl::bitset_ext<64, int64_t>::Number_Of_Elements]; + etl::bitset_ext<64, uint64_t>::element_type buffer[etl::bitset_ext<64, uint64_t>::Number_Of_Elements]; std::bitset<64> compare; - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t> data(buffer); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -80,9 +151,9 @@ namespace //************************************************************************* TEST(test_default_constructor_from_buffer_type) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare; - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t> data(buffer); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -96,28 +167,38 @@ namespace //************************************************************************* TEST(test_default_constructor_single_element) { - etl::bitset_ext<8, int8_t>::buffer_type buffer8; - etl::bitset_ext<16, int16_t>::buffer_type buffer16; - etl::bitset_ext<32, int32_t>::buffer_type buffer32; - etl::bitset_ext<64, int64_t>::buffer_type buffer64; + etl::bitset_ext<8, uint8_t>::buffer_type buffer8; + etl::bitset_ext<16, uint16_t>::buffer_type buffer16; + etl::bitset_ext<32, uint32_t>::buffer_type buffer32; + etl::bitset_ext<64, uint64_t>::buffer_type buffer64; - etl::bitset_ext<8, int8_t> data8(buffer8); - etl::bitset_ext<16, int16_t> data16(buffer16); - etl::bitset_ext<32, int32_t> data32(buffer32); - etl::bitset_ext<64, int64_t> data64(buffer64); + etl::bitset_ext<8, uint8_t> data8(buffer8); + etl::bitset_ext<16, uint16_t> data16(buffer16); + etl::bitset_ext<32, uint32_t> data32(buffer32); + etl::bitset_ext<64, uint64_t> data64(buffer64); + + CHECK_EQUAL(8, data8.Size); + CHECK_EQUAL(16, data16.Size); + CHECK_EQUAL(32, data32.Size); + CHECK_EQUAL(64, data64.Size); CHECK_EQUAL(1U, data8.Number_Of_Elements); CHECK_EQUAL(1U, data16.Number_Of_Elements); CHECK_EQUAL(1U, data32.Number_Of_Elements); CHECK_EQUAL(1U, data64.Number_Of_Elements); + + CHECK_EQUAL(etl::bitset_storage_model::Single, data8.Storage_Model); + CHECK_EQUAL(etl::bitset_storage_model::Single, data16.Storage_Model); + CHECK_EQUAL(etl::bitset_storage_model::Single, data32.Storage_Model); + CHECK_EQUAL(etl::bitset_storage_model::Single, data64.Storage_Model); } //************************************************************************* TEST(test_construct_from_value) { - etl::bitset_ext<64, int64_t>::buffer_type buffer1; + etl::bitset_ext<64, uint64_t>::buffer_type buffer1; std::bitset<64> compare(0x123456731234567ULL); - etl::bitset_ext<64, int64_t> data(0x123456731234567ULL, buffer1); + etl::bitset_ext<64, uint64_t> data(0x123456731234567ULL, buffer1); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -132,11 +213,11 @@ namespace //************************************************************************* TEST(test_copy_construct) { - etl::bitset_ext<64, int64_t>::buffer_type buffer1; - etl::bitset_ext<64, int64_t>::buffer_type buffer2; + etl::bitset_ext<64, uint64_t>::buffer_type buffer1; + etl::bitset_ext<64, uint64_t>::buffer_type buffer2; std::bitset<64> compare(0x123456731234567ULL); - etl::bitset_ext<64, int64_t> data(0x123456731234567ULL, buffer1); - etl::bitset_ext<64, int64_t> data_copy(data, buffer2); + etl::bitset_ext<64, uint64_t> data(0x123456731234567ULL, buffer1); + etl::bitset_ext<64, uint64_t> data_copy(data, buffer2); CHECK_EQUAL(compare.size(), data_copy.size()); CHECK_EQUAL(compare.count(), data_copy.count()); @@ -150,9 +231,9 @@ namespace //************************************************************************* TEST(test_construct_from_excess_value) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare(0x8765432187654321ULL); - etl::bitset_ext<64, int64_t> data(0x8765432187654321ULL, buffer); + etl::bitset_ext<64, uint64_t> data(0x8765432187654321ULL, buffer); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -166,9 +247,9 @@ namespace //************************************************************************* TEST(test_construct_from_char_string) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<64, int64_t> data("110001001000110100010101100111001100010010001101000101011001", buffer); + etl::bitset_ext<64, uint64_t> data("110001001000110100010101100111001100010010001101000101011001", buffer); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -182,9 +263,9 @@ namespace //************************************************************************* TEST(test_construct_from_wchar_t_string) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<64, int64_t> data(L"110001001000110100010101100111001100010010001101000101011001", buffer); + etl::bitset_ext<64, uint64_t> data(L"110001001000110100010101100111001100010010001101000101011001", buffer); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -198,9 +279,9 @@ namespace //************************************************************************* TEST(test_construct_from_char16_t_string) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<64, int64_t> data(u"110001001000110100010101100111001100010010001101000101011001", buffer); + etl::bitset_ext<64, uint64_t> data(u"110001001000110100010101100111001100010010001101000101011001", buffer); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -214,9 +295,9 @@ namespace //************************************************************************* TEST(test_construct_from_char32_t_string) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<64, int64_t> data(U"110001001000110100010101100111001100010010001101000101011001", buffer); + etl::bitset_ext<64, uint64_t> data(U"110001001000110100010101100111001100010010001101000101011001", buffer); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -232,8 +313,8 @@ namespace { const char* s = nullptr; - etl::bitset_ext<60, int64_t>::buffer_type buffer; - etl::bitset_ext<60, int64_t> data(s, buffer); + etl::bitset_ext<60, uint64_t>::buffer_type buffer; + etl::bitset_ext<60, uint64_t> data(s, buffer); CHECK_EQUAL(60, data.size()); CHECK_EQUAL(0, data.count()); @@ -244,8 +325,8 @@ namespace { const wchar_t* s = nullptr; - etl::bitset_ext<60, int64_t>::buffer_type buffer; - etl::bitset_ext<60, int64_t> data(s, buffer); + etl::bitset_ext<60, uint64_t>::buffer_type buffer; + etl::bitset_ext<60, uint64_t> data(s, buffer); CHECK_EQUAL(60, data.size()); CHECK_EQUAL(0, data.count()); @@ -256,8 +337,8 @@ namespace { const char16_t* s = nullptr; - etl::bitset_ext<60, int64_t>::buffer_type buffer; - etl::bitset_ext<60, int64_t> data(s, buffer); + etl::bitset_ext<60, uint64_t>::buffer_type buffer; + etl::bitset_ext<60, uint64_t> data(s, buffer); CHECK_EQUAL(60, data.size()); CHECK_EQUAL(0, data.count()); @@ -268,8 +349,8 @@ namespace { const char32_t* s = nullptr; - etl::bitset_ext<60, int64_t>::buffer_type buffer; - etl::bitset_ext<60, int64_t> data(s, buffer); + etl::bitset_ext<60, uint64_t>::buffer_type buffer; + etl::bitset_ext<60, uint64_t> data(s, buffer); CHECK_EQUAL(60, data.size()); CHECK_EQUAL(0, data.count()); @@ -278,9 +359,9 @@ namespace //************************************************************************* TEST(test_construct_from_excess_string) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001111100001"); - etl::bitset_ext<64, int64_t> data("110001001000110100010101100111001100010010001101000101011001111100001", buffer); + etl::bitset_ext<64, uint64_t> data("110001001000110100010101100111001100010010001101000101011001111100001", buffer); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -299,9 +380,9 @@ namespace //************************************************************************* TEST(test_set) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare; - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t> data(buffer); compare.set(); data.set(); @@ -324,12 +405,285 @@ namespace } } + //************************************************************************* + TEST(test_set_less_than_full_size) + { + etl::bitset_ext<60, uint64_t>::buffer_type buffer; + std::bitset<60> compare; + etl::bitset_ext<60, uint64_t> data(buffer); + + compare.set(); + data.set(); + + 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_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) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t> data(buffer); data.set("110001001000110100010101100111001100010010001101000101011001"); @@ -348,9 +702,9 @@ namespace //************************************************************************* TEST(test_set_with_wchar_t_string) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t> data(buffer); data.set(L"110001001000110100010101100111001100010010001101000101011001"); @@ -369,9 +723,9 @@ namespace //************************************************************************* TEST(test_set_with_char16_t_string) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t> data(buffer); data.set(u"110001001000110100010101100111001100010010001101000101011001"); @@ -390,9 +744,9 @@ namespace //************************************************************************* TEST(test_set_with_char32_t_string) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t> data(buffer); data.set(U"110001001000110100010101100111001100010010001101000101011001"); @@ -413,8 +767,8 @@ namespace { const char* s = nullptr; - etl::bitset_ext<64, int64_t>::buffer_type buffer; - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t> data(buffer); data.set(s); CHECK_EQUAL(64, data.size()); @@ -426,8 +780,8 @@ namespace { const wchar_t* s = nullptr; - etl::bitset_ext<64, int64_t>::buffer_type buffer; - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t> data(buffer); data.set(s); CHECK_EQUAL(64, data.size()); @@ -439,8 +793,8 @@ namespace { const char16_t* s = nullptr; - etl::bitset_ext<64, int64_t>::buffer_type buffer; - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t> data(buffer); data.set(s); CHECK_EQUAL(64, data.size()); @@ -452,8 +806,8 @@ namespace { const char32_t* s = nullptr; - etl::bitset_ext<64, int64_t>::buffer_type buffer; - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t> data(buffer); data.set(s); CHECK_EQUAL(64, data.size()); @@ -463,9 +817,9 @@ namespace //************************************************************************* TEST(test_from_string_with_char) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t> data(buffer); data.from_string("110001001000110100010101100111001100010010001101000101011001"); @@ -484,9 +838,9 @@ namespace //************************************************************************* TEST(test_from_string_with_wchar_t) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t> data(buffer); data.from_string(L"110001001000110100010101100111001100010010001101000101011001"); @@ -505,9 +859,9 @@ namespace //************************************************************************* TEST(test_from_string_with_char16_t) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t> data(buffer); data.from_string(u"110001001000110100010101100111001100010010001101000101011001"); @@ -526,9 +880,9 @@ namespace //************************************************************************* TEST(test_from_string_with_char32_t) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t> data(buffer); data.from_string(U"110001001000110100010101100111001100010010001101000101011001"); @@ -549,8 +903,8 @@ namespace { const char* s = nullptr; - etl::bitset_ext<60, int64_t>::buffer_type buffer; - etl::bitset_ext<60, int64_t> data(buffer); + etl::bitset_ext<60, uint64_t>::buffer_type buffer; + etl::bitset_ext<60, uint64_t> data(buffer); data.from_string(s); CHECK_EQUAL(60, data.size()); @@ -562,8 +916,8 @@ namespace { const wchar_t* s = nullptr; - etl::bitset_ext<60, int64_t>::buffer_type buffer; - etl::bitset_ext<60, int64_t> data(buffer); + etl::bitset_ext<60, uint64_t>::buffer_type buffer; + etl::bitset_ext<60, uint64_t> data(buffer); data.from_string(s); CHECK_EQUAL(60, data.size()); @@ -575,8 +929,8 @@ namespace { const char16_t* s = nullptr; - etl::bitset_ext<60, int64_t>::buffer_type buffer; - etl::bitset_ext<60, int64_t> data(buffer); + etl::bitset_ext<60, uint64_t>::buffer_type buffer; + etl::bitset_ext<60, uint64_t> data(buffer); data.from_string(s); CHECK_EQUAL(60, data.size()); @@ -588,8 +942,8 @@ namespace { const char16_t* s = nullptr; - etl::bitset_ext<60, int64_t>::buffer_type buffer; - etl::bitset_ext<60, int64_t> data(buffer); + etl::bitset_ext<60, uint64_t>::buffer_type buffer; + etl::bitset_ext<60, uint64_t> data(buffer); data.from_string(s); CHECK_EQUAL(60, data.size()); @@ -599,8 +953,8 @@ namespace //************************************************************************* TEST(test_value_u8_min) { - etl::bitset_ext<8, int8_t>::buffer_type buffer; - etl::bitset_ext<8, int8_t> data((unsigned long long)etl::integral_limits::min, buffer); + etl::bitset_ext<8, uint8_t>::buffer_type buffer; + etl::bitset_ext<8, uint8_t> data((unsigned long long)etl::integral_limits::min, buffer); uint8_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); @@ -609,8 +963,8 @@ namespace //************************************************************************* TEST(test_value_u8_max) { - etl::bitset_ext<8, int8_t>::buffer_type buffer; - etl::bitset_ext<8, int8_t> data((unsigned long long)etl::integral_limits::max, buffer); + etl::bitset_ext<8, uint8_t>::buffer_type buffer; + etl::bitset_ext<8, uint8_t> data((unsigned long long)etl::integral_limits::max, buffer); uint8_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); @@ -619,28 +973,28 @@ namespace //************************************************************************* TEST(test_value_s8_min) { - etl::bitset_ext<8, int8_t>::buffer_type buffer; - etl::bitset_ext<8, int8_t> data((unsigned long long)etl::integral_limits::min, buffer); - int8_t value = data.value(); + etl::bitset_ext<8, uint8_t>::buffer_type buffer; + etl::bitset_ext<8, uint8_t> data((unsigned long long)etl::integral_limits::min, buffer); + uint8_t value = data.value(); - CHECK_EQUAL(std::numeric_limits::min(), value); + CHECK_EQUAL(std::numeric_limits::min(), value); } //************************************************************************* TEST(test_value_s8_max) { - etl::bitset_ext<8, int8_t>::buffer_type buffer; - etl::bitset_ext<8, int8_t> data((unsigned long long)etl::integral_limits::max, buffer); - int8_t value = data.value(); + etl::bitset_ext<8, uint8_t>::buffer_type buffer; + etl::bitset_ext<8, uint8_t> data((unsigned long long)etl::integral_limits::max, buffer); + uint8_t value = data.value(); - CHECK_EQUAL(std::numeric_limits::max(), value); + CHECK_EQUAL(std::numeric_limits::max(), value); } //************************************************************************* TEST(test_value_u16_min) { - etl::bitset_ext<16, int16_t>::buffer_type buffer; - etl::bitset_ext<16, int16_t> data((unsigned long long)etl::integral_limits::min, buffer); + etl::bitset_ext<16, uint16_t>::buffer_type buffer; + etl::bitset_ext<16, uint16_t> data((unsigned long long)etl::integral_limits::min, buffer); uint16_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); @@ -649,8 +1003,8 @@ namespace //************************************************************************* TEST(test_value_u16_max) { - etl::bitset_ext<16, int16_t>::buffer_type buffer; - etl::bitset_ext<16, int16_t> data((unsigned long long)etl::integral_limits::max, buffer); + etl::bitset_ext<16, uint16_t>::buffer_type buffer; + etl::bitset_ext<16, uint16_t> data((unsigned long long)etl::integral_limits::max, buffer); uint16_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); @@ -659,109 +1013,109 @@ namespace //************************************************************************* TEST(test_value_s16_min) { - etl::bitset_ext<16, int16_t>::buffer_type buffer; - etl::bitset_ext<16, int16_t> data((unsigned long long)etl::integral_limits::min, buffer); - int16_t value = data.value(); + etl::bitset_ext<16, uint16_t>::buffer_type buffer; + etl::bitset_ext<16, uint16_t> data((unsigned long long)etl::integral_limits::min, buffer); + uint16_t value = data.value(); - CHECK_EQUAL(std::numeric_limits::min(), value); + CHECK_EQUAL(std::numeric_limits::min(), value); } //************************************************************************* TEST(test_value_s16_max) { - etl::bitset_ext<16, int16_t>::buffer_type buffer; - etl::bitset_ext<16, int16_t> data((unsigned long long)etl::integral_limits::max, buffer); - int16_t value = data.value(); + etl::bitset_ext<16, uint16_t>::buffer_type buffer; + etl::bitset_ext<16, uint16_t> data((unsigned long long)etl::integral_limits::max, buffer); + uint16_t value = data.value(); - CHECK_EQUAL(std::numeric_limits::max(), value); + CHECK_EQUAL(std::numeric_limits::max(), value); } //************************************************************************* TEST(test_value_u32_min) { - etl::bitset_ext<32, int32_t>::buffer_type buffer; - etl::bitset_ext<32, int32_t> data((unsigned long long)etl::integral_limits::min, buffer); - int32_t value = data.value(); + etl::bitset_ext<32, uint32_t>::buffer_type buffer; + etl::bitset_ext<32, uint32_t> data((unsigned long long)etl::integral_limits::min, buffer); + uint32_t value = data.value(); - CHECK_EQUAL(std::numeric_limits::min(), value); + CHECK_EQUAL(std::numeric_limits::min(), value); } //************************************************************************* TEST(test_value_u32_max) { - etl::bitset_ext<32, int32_t>::buffer_type buffer; - etl::bitset_ext<32, int32_t> data((unsigned long long)etl::integral_limits::max, buffer); - int32_t value = data.value(); + etl::bitset_ext<32, uint32_t>::buffer_type buffer; + etl::bitset_ext<32, uint32_t> data((unsigned long long)etl::integral_limits::max, buffer); + uint32_t value = data.value(); - CHECK_EQUAL(std::numeric_limits::max(), value); + CHECK_EQUAL(std::numeric_limits::max(), value); } //************************************************************************* TEST(test_value_s32_min) { - etl::bitset_ext<32, int32_t>::buffer_type buffer; - etl::bitset_ext<32, int32_t> data((unsigned long long)etl::integral_limits::min, buffer); - int32_t value = data.value(); + etl::bitset_ext<32, uint32_t>::buffer_type buffer; + etl::bitset_ext<32, uint32_t> data((unsigned long long)etl::integral_limits::min, buffer); + uint32_t value = data.value(); - CHECK_EQUAL(std::numeric_limits::min(), value); + CHECK_EQUAL(std::numeric_limits::min(), value); } //************************************************************************* TEST(test_value_s32_max) { - etl::bitset_ext<32, int32_t>::buffer_type buffer; - etl::bitset_ext<32, int32_t> data((unsigned long long)etl::integral_limits::max, buffer); - int32_t value = data.value(); + etl::bitset_ext<32, uint32_t>::buffer_type buffer; + etl::bitset_ext<32, uint32_t> data((unsigned long long)etl::integral_limits::max, buffer); + uint32_t value = data.value(); - CHECK_EQUAL(std::numeric_limits::max(), value); + CHECK_EQUAL(std::numeric_limits::max(), value); } //************************************************************************* TEST(test_value_u64_min) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; - etl::bitset_ext<64, int64_t> data((unsigned long long)etl::integral_limits::min, buffer); - int64_t value = data.value(); + etl::bitset_ext<64, uint64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t> data((unsigned long long)etl::integral_limits::min, buffer); + uint64_t value = data.value(); - CHECK_EQUAL(std::numeric_limits::min(), value); + CHECK_EQUAL(std::numeric_limits::min(), value); } //************************************************************************* TEST(test_value_u64_max) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; - etl::bitset_ext<64, int64_t> data((unsigned long long)etl::integral_limits::max, buffer); - int64_t value = data.value(); + etl::bitset_ext<64, uint64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t> data((unsigned long long)etl::integral_limits::max, buffer); + uint64_t value = data.value(); - CHECK_EQUAL(std::numeric_limits::max(), value); + CHECK_EQUAL(std::numeric_limits::max(), value); } //************************************************************************* TEST(test_value_s64_min) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; - etl::bitset_ext<64, int64_t> data((unsigned long long)etl::integral_limits::min, buffer); - int64_t value = data.value(); + etl::bitset_ext<64, uint64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t> data((unsigned long long)etl::integral_limits::min, buffer); + uint64_t value = data.value(); - CHECK_EQUAL(std::numeric_limits::min(), value); + CHECK_EQUAL(std::numeric_limits::min(), value); } //************************************************************************* TEST(test_value_s64_max) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; - etl::bitset_ext<64, int64_t> data((unsigned long long)etl::integral_limits::max, buffer); - int64_t value = data.value(); + etl::bitset_ext<64, uint64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t> data((unsigned long long)etl::integral_limits::max, buffer); + uint64_t value = data.value(); - CHECK_EQUAL(std::numeric_limits::max(), value); + CHECK_EQUAL(std::numeric_limits::max(), value); } //************************************************************************* TEST(test_position_set) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare; - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t> data(buffer); for (size_t i = 0UL; i < data.size(); ++i) { @@ -793,9 +1147,9 @@ namespace //************************************************************************* TEST(test_reset) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); - etl::bitset_ext<64, int64_t> data(0xFFFFFFFFFFFFFFFULL, buffer); + etl::bitset_ext<64, uint64_t> data(0xFFFFFFFFFFFFFFFULL, buffer); compare.reset(); data.reset(); @@ -815,9 +1169,9 @@ namespace //************************************************************************* TEST(test_position_reset) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); - etl::bitset_ext<64, int64_t> data(0xFFFFFFFFFFFFFFFULL, buffer); + etl::bitset_ext<64, uint64_t> data(0xFFFFFFFFFFFFFFFULL, buffer); compare.reset(1); compare.reset(3); @@ -871,9 +1225,9 @@ namespace //************************************************************************* TEST(test_index_operator_read) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare(0x3123456731234567ULL); - etl::bitset_ext<64, int64_t> data(0x3123456731234567ULL, buffer); + etl::bitset_ext<64, uint64_t> data(0x3123456731234567ULL, buffer); bool bc0 = compare[1U]; bool bd0 = data[1U]; @@ -895,8 +1249,8 @@ namespace //************************************************************************* TEST(test_index_operator_write) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t> data(buffer); data[1U] = true; data[3U] = true; @@ -912,14 +1266,14 @@ namespace //************************************************************************* TEST(test_any) { - etl::bitset_ext<64, int64_t>::buffer_type buffer1; - etl::bitset_ext<64, int64_t>::buffer_type buffer2; - etl::bitset_ext<64, int64_t>::buffer_type buffer3; - etl::bitset_ext<64, int64_t>::buffer_type buffer4; - etl::bitset_ext<64, int64_t> data1(ull(0x0000000000000000), buffer1); - etl::bitset_ext<64, int64_t> data2(ull(0x0000010000000000), buffer2); - etl::bitset_ext<64, int64_t> data3(ull(0x1000010001000100), buffer3); - etl::bitset_ext<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); + etl::bitset_ext<64, uint64_t>::buffer_type buffer1; + etl::bitset_ext<64, uint64_t>::buffer_type buffer2; + etl::bitset_ext<64, uint64_t>::buffer_type buffer3; + etl::bitset_ext<64, uint64_t>::buffer_type buffer4; + etl::bitset_ext<64, uint64_t> data1(ull(0x0000000000000000), buffer1); + etl::bitset_ext<64, uint64_t> data2(ull(0x0000010000000000), buffer2); + etl::bitset_ext<64, uint64_t> data3(ull(0x1000010001000100), buffer3); + etl::bitset_ext<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); bool bd1 = data1.any(); bool bd2 = data2.any(); @@ -935,14 +1289,14 @@ namespace //************************************************************************* TEST(test_any_with_mask) { - etl::bitset_ext<64, int64_t>::buffer_type buffer1; - etl::bitset_ext<64, int64_t>::buffer_type buffer2; - etl::bitset_ext<64, int64_t>::buffer_type buffer3; - etl::bitset_ext<64, int64_t>::buffer_type buffer4; - etl::bitset_ext<64, int64_t> data1(ull(0xF000000000000000), buffer1); - etl::bitset_ext<64, int64_t> data2(ull(0x0000010000000000), buffer2); - etl::bitset_ext<64, int64_t> data3(ull(0x1000010001000100), buffer3); - etl::bitset_ext<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); + etl::bitset_ext<64, uint64_t>::buffer_type buffer1; + etl::bitset_ext<64, uint64_t>::buffer_type buffer2; + etl::bitset_ext<64, uint64_t>::buffer_type buffer3; + etl::bitset_ext<64, uint64_t>::buffer_type buffer4; + etl::bitset_ext<64, uint64_t> data1(ull(0xF000000000000000), buffer1); + etl::bitset_ext<64, uint64_t> data2(ull(0x0000010000000000), buffer2); + etl::bitset_ext<64, uint64_t> data3(ull(0x1000010001000100), buffer3); + etl::bitset_ext<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); ull mask = ull(0x0FFFFFFFFFFFFFFF); @@ -960,14 +1314,14 @@ namespace //************************************************************************* TEST(test_none) { - etl::bitset_ext<64, int64_t>::buffer_type buffer1; - etl::bitset_ext<64, int64_t>::buffer_type buffer2; - etl::bitset_ext<64, int64_t>::buffer_type buffer3; - etl::bitset_ext<64, int64_t>::buffer_type buffer4; - etl::bitset_ext<64, int64_t> data1(ull(0x0000000000000000), buffer1); - etl::bitset_ext<64, int64_t> data2(ull(0x0000010000000000), buffer2); - etl::bitset_ext<64, int64_t> data3(ull(0x1000010001000100), buffer3); - etl::bitset_ext<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); + etl::bitset_ext<64, uint64_t>::buffer_type buffer1; + etl::bitset_ext<64, uint64_t>::buffer_type buffer2; + etl::bitset_ext<64, uint64_t>::buffer_type buffer3; + etl::bitset_ext<64, uint64_t>::buffer_type buffer4; + etl::bitset_ext<64, uint64_t> data1(ull(0x0000000000000000), buffer1); + etl::bitset_ext<64, uint64_t> data2(ull(0x0000010000000000), buffer2); + etl::bitset_ext<64, uint64_t> data3(ull(0x1000010001000100), buffer3); + etl::bitset_ext<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); bool bd1 = data1.none(); bool bd2 = data2.none(); @@ -983,14 +1337,14 @@ namespace //************************************************************************* TEST(test_none_with_mask) { - etl::bitset_ext<64, int64_t>::buffer_type buffer1; - etl::bitset_ext<64, int64_t>::buffer_type buffer2; - etl::bitset_ext<64, int64_t>::buffer_type buffer3; - etl::bitset_ext<64, int64_t>::buffer_type buffer4; - etl::bitset_ext<64, int64_t> data1(ull(0xF000000000000000), buffer1); - etl::bitset_ext<64, int64_t> data2(ull(0x0000010000000000), buffer2); - etl::bitset_ext<64, int64_t> data3(ull(0x1000010001000100), buffer3); - etl::bitset_ext<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); + etl::bitset_ext<64, uint64_t>::buffer_type buffer1; + etl::bitset_ext<64, uint64_t>::buffer_type buffer2; + etl::bitset_ext<64, uint64_t>::buffer_type buffer3; + etl::bitset_ext<64, uint64_t>::buffer_type buffer4; + etl::bitset_ext<64, uint64_t> data1(ull(0xF000000000000000), buffer1); + etl::bitset_ext<64, uint64_t> data2(ull(0x0000010000000000), buffer2); + etl::bitset_ext<64, uint64_t> data3(ull(0x1000010001000100), buffer3); + etl::bitset_ext<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); ull mask = ull(0x0FFFFFFFFFFFFFFF); @@ -1008,14 +1362,14 @@ namespace //************************************************************************* TEST(test_all) { - etl::bitset_ext<64, int64_t>::buffer_type buffer1; - etl::bitset_ext<64, int64_t>::buffer_type buffer2; - etl::bitset_ext<64, int64_t>::buffer_type buffer3; - etl::bitset_ext<64, int64_t>::buffer_type buffer4; - etl::bitset_ext<64, int64_t> data1(ull(0x0000000000000000), buffer1); - etl::bitset_ext<64, int64_t> data2(ull(0x0000010000000000), buffer2); - etl::bitset_ext<64, int64_t> data3(ull(0x1000010001000100), buffer3); - etl::bitset_ext<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); + etl::bitset_ext<64, uint64_t>::buffer_type buffer1; + etl::bitset_ext<64, uint64_t>::buffer_type buffer2; + etl::bitset_ext<64, uint64_t>::buffer_type buffer3; + etl::bitset_ext<64, uint64_t>::buffer_type buffer4; + etl::bitset_ext<64, uint64_t> data1(ull(0x0000000000000000), buffer1); + etl::bitset_ext<64, uint64_t> data2(ull(0x0000010000000000), buffer2); + etl::bitset_ext<64, uint64_t> data3(ull(0x1000010001000100), buffer3); + etl::bitset_ext<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); bool bd1 = data1.all(); bool bd2 = data2.all(); @@ -1031,14 +1385,14 @@ namespace //************************************************************************* TEST(test_all_with_mask) { - etl::bitset_ext<64, int64_t>::buffer_type buffer1; - etl::bitset_ext<64, int64_t>::buffer_type buffer2; - etl::bitset_ext<64, int64_t>::buffer_type buffer3; - etl::bitset_ext<64, int64_t>::buffer_type buffer4; - etl::bitset_ext<64, int64_t> data1(ull(0x0000000000000000), buffer1); - etl::bitset_ext<64, int64_t> data2(ull(0x0000010000000000), buffer2); - etl::bitset_ext<64, int64_t> data3(ull(0x1000010001000100), buffer3); - etl::bitset_ext<64, int64_t> data4(ull(0x0FFFFFFFFFFFFFFF), buffer4); + etl::bitset_ext<64, uint64_t>::buffer_type buffer1; + etl::bitset_ext<64, uint64_t>::buffer_type buffer2; + etl::bitset_ext<64, uint64_t>::buffer_type buffer3; + etl::bitset_ext<64, uint64_t>::buffer_type buffer4; + etl::bitset_ext<64, uint64_t> data1(ull(0x0000000000000000), buffer1); + etl::bitset_ext<64, uint64_t> data2(ull(0x0000010000000000), buffer2); + etl::bitset_ext<64, uint64_t> data3(ull(0x1000010001000100), buffer3); + etl::bitset_ext<64, uint64_t> data4(ull(0x0FFFFFFFFFFFFFFF), buffer4); ull mask = ull(0x0FFFFFFFFFFFFFFF); @@ -1053,12 +1407,156 @@ namespace CHECK_TRUE(bd4); } + //************************************************************************* + TEST(test_any_with_reduced_active_bits) + { + etl::bitset_ext<60, uint64_t>::buffer_type buffer1; + etl::bitset_ext<60, uint64_t>::buffer_type buffer2; + etl::bitset_ext<60, uint64_t>::buffer_type buffer3; + etl::bitset_ext<60, uint64_t>::buffer_type buffer4; + etl::bitset_ext<60, uint64_t> data1(ull(0x0000000000000000), buffer1); + etl::bitset_ext<60, uint64_t> data2(ull(0x0000010000000000), buffer2); + etl::bitset_ext<60, uint64_t> data3(ull(0x1000010001000100), buffer3); + etl::bitset_ext<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); + + bool bd1 = data1.any(); + bool bd2 = data2.any(); + bool bd3 = data3.any(); + bool bd4 = data4.any(); + + CHECK_FALSE(bd1); + CHECK_TRUE(bd2); + CHECK_TRUE(bd3); + CHECK_TRUE(bd4); + } + + //************************************************************************* + TEST(test_any_with_mask_with_reduced_active_bits) + { + etl::bitset_ext<60, uint64_t>::buffer_type buffer1; + etl::bitset_ext<60, uint64_t>::buffer_type buffer2; + etl::bitset_ext<60, uint64_t>::buffer_type buffer3; + etl::bitset_ext<60, uint64_t>::buffer_type buffer4; + etl::bitset_ext<60, uint64_t> data1(ull(0x0000000000000000), buffer1); + etl::bitset_ext<60, uint64_t> data2(ull(0x0000010000000000), buffer2); + etl::bitset_ext<60, uint64_t> data3(ull(0x1000010001000100), buffer3); + etl::bitset_ext<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); + + ull mask = ull(0x0FFFFFFFFFFFFFFF); + + bool bd1 = data1.any(mask); + bool bd2 = data2.any(mask); + bool bd3 = data3.any(mask); + bool bd4 = data4.any(mask); + + CHECK_FALSE(bd1); + CHECK_TRUE(bd2); + CHECK_TRUE(bd3); + CHECK_TRUE(bd4); + } + + //************************************************************************* + TEST(test_none_with_reduced_active_bits) + { + etl::bitset_ext<60, uint64_t>::buffer_type buffer1; + etl::bitset_ext<60, uint64_t>::buffer_type buffer2; + etl::bitset_ext<60, uint64_t>::buffer_type buffer3; + etl::bitset_ext<60, uint64_t>::buffer_type buffer4; + etl::bitset_ext<60, uint64_t> data1(ull(0x0000000000000000), buffer1); + etl::bitset_ext<60, uint64_t> data2(ull(0x0000010000000000), buffer2); + etl::bitset_ext<60, uint64_t> data3(ull(0x1000010001000100), buffer3); + etl::bitset_ext<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); + + bool bd1 = data1.none(); + bool bd2 = data2.none(); + bool bd3 = data3.none(); + bool bd4 = data4.none(); + + CHECK_TRUE(bd1); + CHECK_FALSE(bd2); + CHECK_FALSE(bd3); + CHECK_FALSE(bd4); + } + + //************************************************************************* + TEST(test_none_with_mask_with_reduced_active_bits) + { + etl::bitset_ext<60, uint64_t>::buffer_type buffer1; + etl::bitset_ext<60, uint64_t>::buffer_type buffer2; + etl::bitset_ext<60, uint64_t>::buffer_type buffer3; + etl::bitset_ext<60, uint64_t>::buffer_type buffer4; + etl::bitset_ext<60, uint64_t> data1(ull(0x0000000000000000), buffer1); + etl::bitset_ext<60, uint64_t> data2(ull(0x0000010000000000), buffer2); + etl::bitset_ext<60, uint64_t> data3(ull(0x1000010001000100), buffer3); + etl::bitset_ext<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); + + ull mask = ull(0x0FFFFFFFFFFFFFFF); + + bool bd1 = data1.none(mask); + bool bd2 = data2.none(mask); + bool bd3 = data3.none(mask); + bool bd4 = data4.none(mask); + + CHECK_TRUE(bd1); + CHECK_FALSE(bd2); + CHECK_FALSE(bd3); + CHECK_FALSE(bd4); + } + + //************************************************************************* + TEST(test_all_with_reduced_active_bits) + { + etl::bitset_ext<60, uint64_t>::buffer_type buffer1; + etl::bitset_ext<60, uint64_t>::buffer_type buffer2; + etl::bitset_ext<60, uint64_t>::buffer_type buffer3; + etl::bitset_ext<60, uint64_t>::buffer_type buffer4; + etl::bitset_ext<60, uint64_t> data1(ull(0x0000000000000000), buffer1); + etl::bitset_ext<60, uint64_t> data2(ull(0x0000010000000000), buffer2); + etl::bitset_ext<60, uint64_t> data3(ull(0x1000010001000100), buffer3); + etl::bitset_ext<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); + + bool bd1 = data1.all(); + bool bd2 = data2.all(); + bool bd3 = data3.all(); + bool bd4 = data4.all(); + + CHECK_FALSE(bd1); + CHECK_FALSE(bd2); + CHECK_FALSE(bd3); + CHECK_TRUE(bd4); + } + + //************************************************************************* + TEST(test_all_with_mask_with_reduced_active_bits) + { + etl::bitset_ext<60, uint64_t>::buffer_type buffer1; + etl::bitset_ext<60, uint64_t>::buffer_type buffer2; + etl::bitset_ext<60, uint64_t>::buffer_type buffer3; + etl::bitset_ext<60, uint64_t>::buffer_type buffer4; + etl::bitset_ext<60, uint64_t> data1(ull(0x0000000000000000), buffer1); + etl::bitset_ext<60, uint64_t> data2(ull(0x0000010000000000), buffer2); + etl::bitset_ext<60, uint64_t> data3(ull(0x1000010001000100), buffer3); + etl::bitset_ext<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF), buffer4); + + ull mask = ull(0x00FFFFFFFFFFFFFF); + + bool bd1 = data1.all(mask); + bool bd2 = data2.all(mask); + bool bd3 = data3.all(mask); + bool bd4 = data4.all(mask); + + CHECK_FALSE(bd1); + CHECK_FALSE(bd2); + CHECK_FALSE(bd3); + CHECK_TRUE(bd4); + } + //************************************************************************* TEST(test_flip) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare; - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t> data(buffer); compare.flip(); data.flip(); @@ -1072,9 +1570,9 @@ namespace //************************************************************************* TEST(test_flip_position) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare; - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t> data(buffer); compare.flip(1); compare.flip(3); @@ -1095,9 +1593,9 @@ namespace //************************************************************************* TEST(test_flip_reference) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare; - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t> data(buffer); compare[1].flip(); compare[3].flip(); @@ -1118,9 +1616,9 @@ namespace //************************************************************************* TEST(test_invert_reference) { - etl::bitset_ext<64, int64_t>::buffer_type buffer; + etl::bitset_ext<64, uint64_t>::buffer_type buffer; std::bitset<64> compare; - etl::bitset_ext<64, int64_t> data(buffer); + etl::bitset_ext<64, uint64_t> data(buffer); bool bc = ~compare[3]; bool bd = ~data[3]; @@ -1128,18 +1626,18 @@ namespace } //************************************************************************* - void test_assignment_operator_helper(etl::bitset_ext<64, int64_t>& from, etl::bitset_ext<64, int64_t>& to) + void test_assignment_operator_helper(etl::bitset_ext<64, uint64_t>& from, etl::bitset_ext<64, uint64_t>& to) { to = from; } TEST(test_assignment_operator) { - etl::bitset_ext<64, int64_t>::buffer_type buffer1; - etl::bitset_ext<64, int64_t>::buffer_type buffer2; + etl::bitset_ext<64, uint64_t>::buffer_type buffer1; + etl::bitset_ext<64, uint64_t>::buffer_type buffer2; std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); - etl::bitset_ext<64, int64_t> data1(0xFFFFFFFFFFFFFFFULL, buffer1); - etl::bitset_ext<64, int64_t> data2(buffer2); + etl::bitset_ext<64, uint64_t> data1(0xFFFFFFFFFFFFFFFULL, buffer1); + etl::bitset_ext<64, uint64_t> data2(buffer2); test_assignment_operator_helper(data1, data2); @@ -1152,12 +1650,12 @@ namespace //************************************************************************* TEST(test_equality_operator) { - etl::bitset_ext<64, int64_t>::buffer_type buffer1; - etl::bitset_ext<64, int64_t>::buffer_type buffer2; - etl::bitset_ext<64, int64_t>::buffer_type buffer3; - etl::bitset_ext<64, int64_t> data1(0x123456781234567ULL, buffer1); - etl::bitset_ext<64, int64_t> data2(0x123456781234567ULL, buffer2); - etl::bitset_ext<64, int64_t> data3(buffer3); + etl::bitset_ext<64, uint64_t>::buffer_type buffer1; + etl::bitset_ext<64, uint64_t>::buffer_type buffer2; + etl::bitset_ext<64, uint64_t>::buffer_type buffer3; + etl::bitset_ext<64, uint64_t> data1(0x123456781234567ULL, buffer1); + etl::bitset_ext<64, uint64_t> data2(0x123456781234567ULL, buffer2); + etl::bitset_ext<64, uint64_t> data3(buffer3); bool equal = (data1 == data2); bool not_equal = !(data1 == data3); @@ -1169,12 +1667,12 @@ namespace //************************************************************************* TEST(test_inequality_operator) { - etl::bitset_ext<64, int64_t>::buffer_type buffer1; - etl::bitset_ext<64, int64_t>::buffer_type buffer2; - etl::bitset_ext<64, int64_t>::buffer_type buffer3; - etl::bitset_ext<64, int64_t> data1(0x123456781234567ULL, buffer1); - etl::bitset_ext<64, int64_t> data2(0x123456781234567ULL, buffer2); - etl::bitset_ext<64, int64_t> data3(buffer3); + etl::bitset_ext<64, uint64_t>::buffer_type buffer1; + etl::bitset_ext<64, uint64_t>::buffer_type buffer2; + etl::bitset_ext<64, uint64_t>::buffer_type buffer3; + etl::bitset_ext<64, uint64_t> data1(0x123456781234567ULL, buffer1); + etl::bitset_ext<64, uint64_t> data2(0x123456781234567ULL, buffer2); + etl::bitset_ext<64, uint64_t> data3(buffer3); bool equal = !(data1 != data2); bool not_equal = (data1 != data3); @@ -1186,71 +1684,71 @@ namespace //************************************************************************* TEST(test_shift_left_operator) { - int64_t value = 0x0123456789ABCDEFULL; + uint64_t value = 0x0123456789ABCDEFULL; uint64_t mask = 0xFFFFFFFFFFFFFFFFULL; - etl::bitset_ext<64, int64_t>::buffer_type buffer1; - etl::bitset_ext<64, int64_t>::buffer_type buffer2; + etl::bitset_ext<64, uint64_t>::buffer_type buffer1; + etl::bitset_ext<64, uint64_t>::buffer_type buffer2; - etl::bitset_ext<64, int64_t> original(0x0123456789ABCDEFULL, buffer1); + etl::bitset_ext<64, uint64_t> original(0x0123456789ABCDEFULL, buffer1); for (ull shift = 0U; shift < 64U; ++shift) { - etl::bitset_ext<64, int64_t> data(original, buffer2); - CHECK_EQUAL_HEX(((value & mask) << shift), (data <<= shift).value()); + etl::bitset_ext<64, uint64_t> data(original, buffer2); + CHECK_EQUAL_HEX(((value & mask) << shift), (data <<= shift).value()); mask >>= 1; } - etl::bitset_ext<64, int64_t> data(original, buffer2); - CHECK_EQUAL_HEX(0ULL, (data <<= 64U).value()); + etl::bitset_ext<64, uint64_t> data(original, buffer2); + CHECK_EQUAL_HEX(0ULL, (data <<= 64U).value()); } //************************************************************************* TEST(test_shift_left_operator_overflow) { - etl::bitset_ext<32, int32_t>::buffer_type buffer1; - etl::bitset_ext<32, int32_t>::buffer_type buffer2; + etl::bitset_ext<32, uint32_t>::buffer_type buffer1; + etl::bitset_ext<32, uint32_t>::buffer_type buffer2; - etl::bitset_ext<32, int32_t> data(0xFFFFFFFFULL, buffer1); + etl::bitset_ext<32, uint32_t> data(0xFFFFFFFFULL, buffer1); data <<= 1U; - etl::bitset_ext<32, int32_t> shifted(0xFFFFFFFEUL, buffer2); + etl::bitset_ext<32, uint32_t> shifted(0xFFFFFFFEUL, buffer2); - CHECK_EQUAL_HEX(shifted.value(), data.value()); + CHECK_EQUAL_HEX(shifted.value(), data.value()); } //************************************************************************* TEST(test_shift_right_operator) { - int64_t value = 0x0123456789ABCDEFULL; + uint64_t value = 0x0123456789ABCDEFULL; - etl::bitset_ext<64, int64_t>::buffer_type buffer1; - etl::bitset_ext<64, int64_t>::buffer_type buffer2; + etl::bitset_ext<64, uint64_t>::buffer_type buffer1; + etl::bitset_ext<64, uint64_t>::buffer_type buffer2; - etl::bitset_ext<64, int64_t> original(0x0123456789ABCDEFULL, buffer1); + etl::bitset_ext<64, uint64_t> original(0x0123456789ABCDEFULL, buffer1); for (ull shift = 0U; shift < 64U; ++shift) { - etl::bitset_ext<64, int64_t> data(original, buffer2); - CHECK_EQUAL_HEX((value >> shift), (data >>= shift).value()); + etl::bitset_ext<64, uint64_t> data(original, buffer2); + CHECK_EQUAL_HEX((value >> shift), (data >>= shift).value()); } - etl::bitset_ext<64, int64_t> data(original, buffer2); - CHECK_EQUAL_HEX(0ULL, (data >>= 64U).value()); + etl::bitset_ext<64, uint64_t> data(original, buffer2); + CHECK_EQUAL_HEX(0ULL, (data >>= 64U).value()); } //************************************************************************* TEST(test_and_equals_operator) { - etl::bitset_ext<64, int64_t>::buffer_type buffer1; - etl::bitset_ext<64, int64_t>::buffer_type buffer2; - etl::bitset_ext<64, int64_t>::buffer_type buffer3; - etl::bitset_ext<64, int64_t>::buffer_type buffer4; + etl::bitset_ext<64, uint64_t>::buffer_type buffer1; + etl::bitset_ext<64, uint64_t>::buffer_type buffer2; + etl::bitset_ext<64, uint64_t>::buffer_type buffer3; + etl::bitset_ext<64, uint64_t>::buffer_type buffer4; - etl::bitset_ext<64, int64_t> data1(0x12345678UL, buffer1); - etl::bitset_ext<64, int64_t> data2(0x23456789UL, buffer2); - etl::bitset_ext<64, int64_t> data3(0x12345678UL & 0x23456789UL, buffer3); + etl::bitset_ext<64, uint64_t> data1(0x12345678UL, buffer1); + etl::bitset_ext<64, uint64_t> data2(0x23456789UL, buffer2); + etl::bitset_ext<64, uint64_t> data3(0x12345678UL & 0x23456789UL, buffer3); - etl::bitset_ext<64, int64_t> data4(data1, buffer4); + etl::bitset_ext<64, uint64_t> data4(data1, buffer4); data4 &= data2; CHECK(data3 == data4); } @@ -1258,16 +1756,16 @@ namespace //************************************************************************* TEST(test_or_equals_operator) { - etl::bitset_ext<64, int64_t>::buffer_type buffer1; - etl::bitset_ext<64, int64_t>::buffer_type buffer2; - etl::bitset_ext<64, int64_t>::buffer_type buffer3; - etl::bitset_ext<64, int64_t>::buffer_type buffer4; + etl::bitset_ext<64, uint64_t>::buffer_type buffer1; + etl::bitset_ext<64, uint64_t>::buffer_type buffer2; + etl::bitset_ext<64, uint64_t>::buffer_type buffer3; + etl::bitset_ext<64, uint64_t>::buffer_type buffer4; - etl::bitset_ext<64, int64_t> data1(0x12345678UL, buffer1); - etl::bitset_ext<64, int64_t> data2(0x23456789UL, buffer2); - etl::bitset_ext<64, int64_t> data3(0x12345678UL | 0x23456789UL, buffer3); + etl::bitset_ext<64, uint64_t> data1(0x12345678UL, buffer1); + etl::bitset_ext<64, uint64_t> data2(0x23456789UL, buffer2); + etl::bitset_ext<64, uint64_t> data3(0x12345678UL | 0x23456789UL, buffer3); - etl::bitset_ext<64, int64_t> data4(data1, buffer4); + etl::bitset_ext<64, uint64_t> data4(data1, buffer4); data4 |= data2; CHECK(data3 == data4); } @@ -1275,16 +1773,16 @@ namespace //************************************************************************* TEST(test_xor_equals_operator) { - etl::bitset_ext<64, int64_t>::buffer_type buffer1; - etl::bitset_ext<64, int64_t>::buffer_type buffer2; - etl::bitset_ext<64, int64_t>::buffer_type buffer3; - etl::bitset_ext<64, int64_t>::buffer_type buffer4; + etl::bitset_ext<64, uint64_t>::buffer_type buffer1; + etl::bitset_ext<64, uint64_t>::buffer_type buffer2; + etl::bitset_ext<64, uint64_t>::buffer_type buffer3; + etl::bitset_ext<64, uint64_t>::buffer_type buffer4; - etl::bitset_ext<64, int64_t> data1(0x12345678UL, buffer1); - etl::bitset_ext<64, int64_t> data2(0x23456789UL, buffer2); - etl::bitset_ext<64, int64_t> data3(0x12345678UL ^ 0x23456789UL, buffer3); + etl::bitset_ext<64, uint64_t> data1(0x12345678UL, buffer1); + etl::bitset_ext<64, uint64_t> data2(0x23456789UL, buffer2); + etl::bitset_ext<64, uint64_t> data3(0x12345678UL ^ 0x23456789UL, buffer3); - etl::bitset_ext<64, int64_t> data4(data1, buffer4); + etl::bitset_ext<64, uint64_t> data4(data1, buffer4); data4 ^= data2; CHECK(data3 == data4); } @@ -1292,45 +1790,45 @@ namespace //************************************************************************* TEST(test_find_first) { - etl::bitset_ext<8, int8_t>::buffer_type buffer; + etl::bitset_ext<8, uint8_t>::buffer_type buffer; - etl::bitset_ext<8, int8_t> bs1(ull(0x00), buffer); + etl::bitset_ext<8, uint8_t> bs1(ull(0x00), buffer); size_t bs1fff = bs1.find_first(false); size_t bs1fft = bs1.find_first(true); CHECK_EQUAL(0U, bs1fff); CHECK_EQUAL(etl::bitset_ext<>::npos, bs1fft); - etl::bitset_ext<8, int8_t> bs2(ull(0xFF), buffer); + etl::bitset_ext<8, uint8_t> bs2(ull(0xFF), buffer); size_t bs2fff = bs2.find_first(false); size_t bs2fft = bs2.find_first(true); CHECK_EQUAL(etl::bitset_ext<>::npos, bs2fff); CHECK_EQUAL(0U, bs2fft); - etl::bitset_ext<8, int8_t> bs3(ull(0x01), buffer); + etl::bitset_ext<8, uint8_t> bs3(ull(0x01), buffer); size_t bs3fff = bs3.find_first(false); size_t bs3fft = bs3.find_first(true); CHECK_EQUAL(1U, bs3fff); CHECK_EQUAL(0U, bs3fft); - etl::bitset_ext<8, int8_t> bs4(ull(0x20), buffer); + etl::bitset_ext<8, uint8_t> bs4(ull(0x20), buffer); size_t bs4fff = bs4.find_first(false); size_t bs4fft = bs4.find_first(true); CHECK_EQUAL(0U, bs4fff); CHECK_EQUAL(5U, bs4fft); - etl::bitset_ext<8, int8_t> bs5(ull(0x21), buffer); + etl::bitset_ext<8, uint8_t> bs5(ull(0x21), buffer); size_t bs5fff = bs5.find_first(false); size_t bs5fft = bs5.find_first(true); CHECK_EQUAL(1U, bs5fff); CHECK_EQUAL(0U, bs5fft); - etl::bitset_ext<8, int8_t> bs6(ull(0x0E), buffer); + etl::bitset_ext<8, uint8_t> bs6(ull(0x0E), buffer); size_t bs6fff = bs6.find_first(false); size_t bs6fft = bs6.find_first(true); CHECK_EQUAL(0U, bs6fff); CHECK_EQUAL(1U, bs6fft); - etl::bitset_ext<8, int8_t> bs7(ull(0x31), buffer); + etl::bitset_ext<8, uint8_t> bs7(ull(0x31), buffer); size_t bs7fff = bs7.find_first(false); size_t bs7fft = bs7.find_first(true); CHECK_EQUAL(1U, bs7fff); @@ -1340,9 +1838,9 @@ namespace //************************************************************************* TEST(test_find_next) { - etl::bitset_ext<8, int8_t>::buffer_type buffer; + etl::bitset_ext<8, uint8_t>::buffer_type buffer; - etl::bitset_ext<8, int8_t> bs1(ull(0x00), buffer); + etl::bitset_ext<8, uint8_t> bs1(ull(0x00), buffer); size_t bs1fnf0 = bs1.find_next(false, 0); size_t bs1fnf1 = bs1.find_next(false, 1); size_t bs1fnt2 = bs1.find_next(true, 2); @@ -1350,7 +1848,7 @@ namespace CHECK_EQUAL(1U, bs1fnf1); CHECK_EQUAL(etl::bitset_ext<>::npos, bs1fnt2); - etl::bitset_ext<8, int8_t> bs2(ull(0xFF), buffer); + etl::bitset_ext<8, uint8_t> bs2(ull(0xFF), buffer); size_t bs2fnt0 = bs2.find_next(true, 0); size_t bs2fnt1 = bs2.find_next(true, 1); size_t bs2fnf2 = bs2.find_next(false, 2); @@ -1358,7 +1856,7 @@ namespace CHECK_EQUAL(1U, bs2fnt1); CHECK_EQUAL(etl::bitset_ext<>::npos, bs2fnf2); - etl::bitset_ext<8, int8_t> bs3(ull(0x0E), buffer); + etl::bitset_ext<8, uint8_t> bs3(ull(0x0E), buffer); size_t bs3fnf0 = bs3.find_next(false, 0); size_t bs3fnt1 = bs3.find_next(true, 1); size_t bs3fnf2 = bs3.find_next(false, 2); @@ -1366,7 +1864,7 @@ namespace CHECK_EQUAL(1U, bs3fnt1); CHECK_EQUAL(4U, bs3fnf2); - etl::bitset_ext<8, int8_t> bs4(ull(0x31), buffer); + etl::bitset_ext<8, uint8_t> bs4(ull(0x31), buffer); size_t bs4fnt0 = bs4.find_next(true, 0); size_t bs4fnf0 = bs4.find_next(false, 0); size_t bs4fnt1 = bs4.find_next(true, 1); @@ -1378,15 +1876,15 @@ namespace //************************************************************************* TEST(test_swap) { - etl::bitset_ext<16, int16_t>::buffer_type buffer1; - etl::bitset_ext<16, int16_t>::buffer_type buffer2; - etl::bitset_ext<16, int16_t>::buffer_type buffer3; - etl::bitset_ext<16, int16_t>::buffer_type buffer4; + etl::bitset_ext<16, uint16_t>::buffer_type buffer1; + etl::bitset_ext<16, uint16_t>::buffer_type buffer2; + etl::bitset_ext<16, uint16_t>::buffer_type buffer3; + etl::bitset_ext<16, uint16_t>::buffer_type buffer4; - etl::bitset_ext<16, int16_t> compare1(0x2A, buffer1); - etl::bitset_ext<16, int16_t> compare2(0x15, buffer2); - etl::bitset_ext<16, int16_t> compare1a(0x2A, buffer3); - etl::bitset_ext<16, int16_t> compare2a(0x15, buffer4); + etl::bitset_ext<16, uint16_t> compare1(0x2A, buffer1); + etl::bitset_ext<16, uint16_t> compare2(0x15, buffer2); + etl::bitset_ext<16, uint16_t> compare1a(0x2A, buffer3); + etl::bitset_ext<16, uint16_t> compare2a(0x15, buffer4); swap(compare1a, compare2a); @@ -1397,19 +1895,22 @@ namespace //************************************************************************* TEST(test_span) { - etl::bitset_ext<32, int32_t>::buffer_type buffer; + etl::bitset_ext<32, uint32_t>::buffer_type buffer; etl::bitset_ext<32, uint32_t> data(0x12345678UL, buffer); using span_t = etl::bitset_ext<32, uint32_t>::span_type; span_t s = data.span(); CHECK_EQUAL(0x12345678UL, s[0]); + + s[0] = 0x87654321UL; + CHECK_EQUAL(0x87654321UL, data.value()); } //************************************************************************* TEST(test_const_span) { - etl::bitset_ext<32, int32_t>::buffer_type buffer; + etl::bitset_ext<32, uint32_t>::buffer_type buffer; const etl::bitset_ext<32, uint32_t> data(0x12345678UL, buffer); using span_t = const etl::bitset_ext<32, uint32_t>::const_span_type; @@ -1421,7 +1922,7 @@ namespace //************************************************************************* TEST(test_to_string) { - using bs32 = etl::bitset_ext<32, int32_t>; + using bs32 = etl::bitset_ext<32, uint32_t>; bs32::buffer_type buffer; bs32 data(0x12345678UL, buffer); @@ -1437,7 +1938,7 @@ namespace //************************************************************************* TEST(test_to_wstring) { - using bs32 = etl::bitset_ext<32, int32_t>; + using bs32 = etl::bitset_ext<32, uint32_t>; bs32::buffer_type buffer; bs32 b(0x12345678UL, buffer); @@ -1452,7 +1953,7 @@ namespace //************************************************************************* TEST(test_to_u16string) { - using bs32 = etl::bitset_ext<32, int32_t>; + using bs32 = etl::bitset_ext<32, uint32_t>; bs32::buffer_type buffer; bs32 b(0x12345678UL, buffer); @@ -1467,7 +1968,7 @@ namespace //************************************************************************* TEST(test_to_u32string) { - using bs32 = etl::bitset_ext<32, int32_t>; + using bs32 = etl::bitset_ext<32, uint32_t>; bs32::buffer_type buffer; bs32 b(0x12345678UL, buffer); @@ -1478,5 +1979,567 @@ namespace CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(text.c_str())); CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str())); } + + //************************************************************************* + TEST(test_extract_6_bit_uint8_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract( 0, 6))); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract( 1, 6))); + CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract( 2, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract( 3, 6))); + CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract( 4, 6))); + CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract( 5, 6))); + CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract( 6, 6))); + CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract( 7, 6))); + CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract( 8, 6))); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract( 9, 6))); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract(10, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract(11, 6))); + CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract(12, 6))); + CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract(13, 6))); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract(14, 6))); + CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract(15, 6))); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract(16, 6))); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract(17, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract(18, 6))); + CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract(19, 6))); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract(20, 6))); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract(21, 6))); + CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract(22, 6))); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract(23, 6))); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract(24, 6))); + CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract(25, 6))); + CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract(26, 6))); + + CHECK_THROW(b.extract(26, 7), etl::bitset_overflow); + CHECK_THROW(b.extract(27, 6), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_6_bit_uint8_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract())); + + // The lines below should static assert. + //uint8_t v1 = b.extract(); + //uint8_t v1 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_6_bit_int8_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract(0, 6))); + CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract(1, 6))); + CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract(2, 6))); + CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract(3, 6))); + CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract(4, 6))); + CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract(5, 6))); + CHECK_EQUAL_HEX(int8_t(0x19), (b.extract(6, 6))); + CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract(7, 6))); + CHECK_EQUAL_HEX(int8_t(0x16), (b.extract(8, 6))); + CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract(9, 6))); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract(10, 6))); + CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract(11, 6))); + CHECK_EQUAL_HEX(int8_t(0x05), (b.extract(12, 6))); + CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract(13, 6))); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract(14, 6))); + CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract(15, 6))); + CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract(16, 6))); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract(17, 6))); + CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract(18, 6))); + CHECK_EQUAL_HEX(int8_t(0x06), (b.extract(19, 6))); + CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract(20, 6))); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract(21, 6))); + CHECK_EQUAL_HEX(int8_t(0x08), (b.extract(22, 6))); + CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract(23, 6))); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract(24, 6))); + CHECK_EQUAL_HEX(int8_t(0x09), (b.extract(25, 6))); + CHECK_EQUAL_HEX(int8_t(0x04), (b.extract(26, 6))); + + CHECK_THROW(b.extract(26, 7), etl::bitset_overflow); + CHECK_THROW(b.extract(27, 6), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_6_bit_int8_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x19), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x16), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x05), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x06), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x08), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x09), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x04), (b.extract())); + + // The lines below should static assert. + //uint8_t v1 = b.extract(); + //uint8_t v1 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_uint8_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint8_t(0x78), b.extract( 0, 8)); + CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract( 1, 8)); + CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract( 2, 8)); + CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract( 3, 8)); + CHECK_EQUAL_HEX(uint8_t(0x67), b.extract( 4, 8)); + CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract( 5, 8)); + CHECK_EQUAL_HEX(uint8_t(0x59), b.extract( 6, 8)); + CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract( 7, 8)); + CHECK_EQUAL_HEX(uint8_t(0x56), b.extract( 8, 8)); + CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract( 9, 8)); + CHECK_EQUAL_HEX(uint8_t(0x15), b.extract(10, 8)); + CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract(11, 8)); + CHECK_EQUAL_HEX(uint8_t(0x45), b.extract(12, 8)); + CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract(13, 8)); + CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract(14, 8)); + CHECK_EQUAL_HEX(uint8_t(0x68), b.extract(15, 8)); + CHECK_EQUAL_HEX(uint8_t(0x34), b.extract(16, 8)); + CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract(17, 8)); + CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract(18, 8)); + CHECK_EQUAL_HEX(uint8_t(0x46), b.extract(19, 8)); + CHECK_EQUAL_HEX(uint8_t(0x23), b.extract(20, 8)); + CHECK_EQUAL_HEX(uint8_t(0x91), b.extract(21, 8)); + CHECK_EQUAL_HEX(uint8_t(0x48), b.extract(22, 8)); + CHECK_EQUAL_HEX(uint8_t(0x24), b.extract(23, 8)); + CHECK_EQUAL_HEX(uint8_t(0x12), b.extract(24, 8)); + + CHECK_THROW(b.extract(24, 9), etl::bitset_overflow); + CHECK_THROW(b.extract(25, 8), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_uint8_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract())); + + // The lines below should static assert. + //uint8_t v1 = b.extract(); + //uint8_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_int8_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint8_t(0x78), b.extract( 0, 8)); + CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract( 1, 8)); + CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract( 2, 8)); + CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract( 3, 8)); + CHECK_EQUAL_HEX(uint8_t(0x67), b.extract( 4, 8)); + CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract( 5, 8)); + CHECK_EQUAL_HEX(uint8_t(0x59), b.extract( 6, 8)); + CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract( 7, 8)); + CHECK_EQUAL_HEX(uint8_t(0x56), b.extract( 8, 8)); + CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract( 9, 8)); + CHECK_EQUAL_HEX(uint8_t(0x15), b.extract(10, 8)); + CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract(11, 8)); + CHECK_EQUAL_HEX(uint8_t(0x45), b.extract(12, 8)); + CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract(13, 8)); + CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract(14, 8)); + CHECK_EQUAL_HEX(uint8_t(0x68), b.extract(15, 8)); + CHECK_EQUAL_HEX(uint8_t(0x34), b.extract(16, 8)); + CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract(17, 8)); + CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract(18, 8)); + CHECK_EQUAL_HEX(uint8_t(0x46), b.extract(19, 8)); + CHECK_EQUAL_HEX(uint8_t(0x23), b.extract(20, 8)); + CHECK_EQUAL_HEX(uint8_t(0x91), b.extract(21, 8)); + CHECK_EQUAL_HEX(uint8_t(0x48), b.extract(22, 8)); + CHECK_EQUAL_HEX(uint8_t(0x24), b.extract(23, 8)); + CHECK_EQUAL_HEX(uint8_t(0x12), b.extract(24, 8)); + + CHECK_THROW(b.extract(24, 9), etl::bitset_overflow); + CHECK_THROW(b.extract(25, 8), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_int8_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract())); + + // The lines below should static assert. + //uint8_t v1 = b.extract(); + //uint8_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_13_bits_uint16_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract( 0, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract( 1, 13)); + CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract( 2, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract( 3, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract( 4, 13)); + CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract( 5, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract( 6, 13)); + CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract( 7, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract( 8, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract( 9, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract(10, 13)); + CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract(11, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract(12, 13)); + CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract(13, 13)); + CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract(14, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract(15, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract(16, 13)); + CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract(17, 13)); + CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract(18, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract(19, 13)); + + CHECK_THROW(b.extract(19, 14), etl::bitset_overflow); + CHECK_THROW(b.extract(20, 13), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_13_bits_uint16_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract())); + + // The lines below should static assert. + //uint16_t v1 = b.extract; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract( 0, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract( 1, 16)); + CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract( 2, 16)); + CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract( 3, 16)); + CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract( 4, 16)); + CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract( 5, 16)); + CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract( 6, 16)); + CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract( 7, 16)); + CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract( 8, 16)); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract( 9, 16)); + CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract(10, 16)); + CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract(11, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract(12, 16)); + CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract(13, 16)); + CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract(14, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract(15, 16)); + CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract(16, 16)); + + CHECK_THROW(b.extract(16, 17), etl::bitset_overflow); + CHECK_THROW(b.extract(17, 16), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_uint16_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract())); + + // The lines below should static assert. + //uint16_t v1 = b.extract(); + //uint16_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_int16_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract( 0, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract( 1, 16)); + CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract( 2, 16)); + CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract( 3, 16)); + CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract( 4, 16)); + CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract( 5, 16)); + CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract( 6, 16)); + CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract( 7, 16)); + CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract( 8, 16)); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract( 9, 16)); + CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract(10, 16)); + CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract(11, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract(12, 16)); + CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract(13, 16)); + CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract(14, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract(15, 16)); + CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract(16, 16)); + + CHECK_THROW(b.extract(16, 17), etl::bitset_overflow); + CHECK_THROW(b.extract(17, 16), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_int16_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract())); + + // The lines below should static assert. + //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); + } }; } diff --git a/test/vs2022/etl.vcxproj b/test/vs2022/etl.vcxproj index 46b7b05c..3d746039 100644 --- a/test/vs2022/etl.vcxproj +++ b/test/vs2022/etl.vcxproj @@ -839,17 +839,17 @@ $(Configuration)\ - false + true true $(Configuration)\ - false + true true $(Configuration)\ - false + true true $(Configuration)\ @@ -859,37 +859,37 @@ $(Configuration)\ - false + true true $(Configuration)\ - false + true true $(Configuration)\ - false + true true $(Configuration)\ - false + true true $(Configuration)\ - false + true true $(Configuration)\ - false + true true $(Configuration)\ - false + true true $(Configuration)\ @@ -935,7 +935,7 @@ $(Configuration)\ - false + true true $(Configuration)\ @@ -7318,6 +7318,7 @@ + diff --git a/test/vs2022/etl.vcxproj.filters b/test/vs2022/etl.vcxproj.filters index cad865ea..6aa44b4e 100644 --- a/test/vs2022/etl.vcxproj.filters +++ b/test/vs2022/etl.vcxproj.filters @@ -3251,9 +3251,6 @@ Tests\Maths - - Tests\Maths - Tests\Strings @@ -3290,6 +3287,12 @@ Tests\CRC + + Tests\Binary + + + Tests\Syntax Checks\Source + Tests\Syntax Checks\Source