diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h index 7a766f64..7a4a7fa1 100644 --- a/include/etl/private/bitset_new.h +++ b/include/etl/private/bitset_new.h @@ -45,11 +45,16 @@ SOFTWARE. #include "../error_handler.h" #include "../span.h" #include "../string.h" +#include "../enum_type.h" #include #include #include +#if ETL_USING_STL +#include +#endif + #include "minmax_push.h" #if defined(ETL_COMPILER_KEIL) @@ -76,71 +81,6 @@ SOFTWARE. namespace etl { - //namespace private_bitset - //{ - // //*************************************************************************** - // /// Common definitions for etl::bitset_impl - // ///\ingroup bitset - // //*************************************************************************** - // template - // struct bitset_impl_common - // { - // typedef TElement element_type; - // typedef element_type* pointer; - // typedef const element_type* 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 element_type All_Set_Element = etl::integral_limits::max; - // static ETL_CONSTANT element_type 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; - - // //*************************************************************************** - // /// Common definitions for etl::bitset - // ///\ingroup bitset - // //*************************************************************************** - // template - // struct bitset_common : public bitset_impl_common - // { - // typedef TElement element_type; - - // 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 Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift)); - - // static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility. - - // typedef etl::span span_type; - // typedef etl::span const_span_type; - // }; - - // template - // ETL_CONSTANT size_t bitset_common::Number_Of_Elements; - - // template - // ETL_CONSTANT size_t bitset_common::Allocated_Bits; - - // template - // ETL_CONSTANT size_t bitset_common::Top_Mask_Shift; - - // template - // ETL_CONSTANT typename bitset_common::element_type private_bitset::bitset_common::Top_Mask; - //} - //*************************************************************************** /// Flags to indicate whether the bitset is contained in a single element /// or spread over an array of elements. @@ -148,8 +88,9 @@ namespace etl //*************************************************************************** struct bitset_layout { - static ETL_CONSTANT bool Single = true; - static ETL_CONSTANT bool Multi = false; + static ETL_CONSTANT char Undefined = 0; + static ETL_CONSTANT char Single = 1; + static ETL_CONSTANT char Multi = 2; }; //*************************************************************************** @@ -212,7 +153,7 @@ namespace etl /// Bitset implementation declaration. ///\ingroup bitset //************************************************************************* - template + template class bitset_impl; //************************************************************************* @@ -224,16 +165,14 @@ namespace etl { public: - //static ETL_CONSTANT bool Element_Layout = etl::bitset_layout::Single; - typedef TElement element_type; typedef element_type* pointer; typedef const element_type* 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 element_type All_Set_Element = etl::integral_limits::max; + static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits::bits; + static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits::max; static ETL_CONSTANT element_type All_Clear_Element = element_type(0); //************************************************************************* @@ -241,10 +180,11 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 static - void set(pointer pbuffer, - size_t /*number_of_elements*/) ETL_NOEXCEPT + void set(pointer pbuffer, + size_t /*number_of_elements*/, + element_type top_mask) ETL_NOEXCEPT { - *pbuffer = All_Set_Element; + *pbuffer = All_Set_Element & top_mask; } //************************************************************************* @@ -303,11 +243,9 @@ namespace etl size_t active_bits, const char* text) ETL_NOEXCEPT { - if (text == ETL_NULLPTR) - { - reset(pbuffer, 1U); - } - else + reset(pbuffer, 1U); + + if (text != ETL_NULLPTR) { size_t string_length = etl::strlen(text); @@ -322,10 +260,6 @@ namespace etl { *pbuffer |= mask; } - else - { - *pbuffer &= ~mask; - } mask >>= 1U; } @@ -342,11 +276,9 @@ namespace etl size_t active_bits, const wchar_t* text) ETL_NOEXCEPT { - if (text == ETL_NULLPTR) - { - reset(pbuffer, 1U); - } - else + reset(pbuffer, 1U); + + if (text != ETL_NULLPTR) { size_t string_length = etl::strlen(text); @@ -361,10 +293,6 @@ namespace etl { *pbuffer |= mask; } - else - { - *pbuffer &= ~mask; - } mask >>= 1U; } @@ -381,11 +309,9 @@ namespace etl size_t active_bits, const char16_t* text) ETL_NOEXCEPT { - if (text == ETL_NULLPTR) - { - reset(pbuffer, 1U); - } - else + reset(pbuffer, 1U); + + if (text != ETL_NULLPTR) { size_t string_length = etl::strlen(text); @@ -400,10 +326,6 @@ namespace etl { *pbuffer |= mask; } - else - { - *pbuffer &= ~mask; - } mask >>= 1U; } @@ -420,11 +342,9 @@ namespace etl size_t active_bits, const char32_t* text) ETL_NOEXCEPT { - if (text == ETL_NULLPTR) - { - reset(pbuffer, 1U); - } - else + reset(pbuffer, 1U); + + if (text != ETL_NULLPTR) { size_t string_length = etl::strlen(text); @@ -439,10 +359,6 @@ namespace etl { *pbuffer |= mask; } - else - { - *pbuffer &= ~mask; - } mask >>= 1U; } @@ -725,6 +641,7 @@ namespace etl //************************************************************************* /// operator assignment + /// Assigns rhs to lhs //************************************************************************* ETL_CONSTEXPR14 static @@ -737,6 +654,7 @@ namespace etl //************************************************************************* /// operator and + /// AND lhs and rhs and put the result in lhs //************************************************************************* ETL_CONSTEXPR14 static @@ -749,6 +667,7 @@ namespace etl //************************************************************************* /// operator or + /// OR lhs and rhs and put the result in lhs //************************************************************************* ETL_CONSTEXPR14 static @@ -761,6 +680,7 @@ namespace etl //************************************************************************* /// operator xor + /// XOR lhs and rhs and put the result in lhs //************************************************************************* ETL_CONSTEXPR14 static @@ -773,6 +693,7 @@ namespace etl //************************************************************************* /// operator ~ + /// NOT the value in the buffer //************************************************************************* ETL_CONSTEXPR14 static @@ -855,15 +776,12 @@ namespace etl pointer rhs_pbuffer, size_t /*number_of_elements*/) ETL_NOEXCEPT { - using ETL_OR_STD::iter_swap; - - iter_swap(lhs_pbuffer, rhs_pbuffer); + element_type temp = *lhs_pbuffer; + *lhs_pbuffer = *rhs_pbuffer; + *rhs_pbuffer = temp; } }; - //template - //ETL_CONSTANT bool etl::bitset_impl::Element_Layout; - //************************************************************************* /// The implementation class for multi element etl::bitset ///\ingroup bitset @@ -883,8 +801,6 @@ namespace etl static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits::max; static ETL_CONSTANT element_type All_Clear_Element = element_type(0); - //static ETL_CONSTANT bool Element_Layout = etl::bitset_layout::Multi; - //************************************************************************* /// Check to see if the requested extract is contained within one element. //************************************************************************* @@ -1756,9 +1672,6 @@ namespace etl } }; - //template - //ETL_CONSTANT bool etl::bitset_impl::Element_Layout; - //*************************************************************************** /// Bitset forward declaration //*************************************************************************** @@ -1784,8 +1697,7 @@ namespace etl static ETL_CONSTANT size_t Allocated_Bits = 0U; static ETL_CONSTANT element_type All_Set_Element = 0U; static ETL_CONSTANT element_type All_Clear_Element = 0U; - static ETL_CONSTANT size_t Top_Mask_Shift = 0U; - static ETL_CONSTANT element_type Top_Mask = 0U; + static ETL_CONSTANT char Element_Layout = etl::bitset_layout::Undefined; static ETL_CONSTANT size_t npos = etl::integral_limits::max; }; @@ -1806,15 +1718,19 @@ namespace etl static ETL_CONSTANT size_t npos = etl::integral_limits::max; - //static ETL_CONSTANT bool Element_Layout = implementation::Element_Layout; - static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits::bits; static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits::max; static ETL_CONSTANT element_type All_Clear_Element = element_type(0); static ETL_CONSTANT size_t Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1; static ETL_CONSTANT size_t Allocated_Bits = Number_Of_Elements * Bits_Per_Element; - static ETL_CONSTANT size_t Top_Mask_Shift = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element); - static ETL_CONSTANT element_type Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift)); + static ETL_CONSTANT char Element_Layout = (Number_Of_Elements == 1U) ? etl::bitset_layout::Single : etl::bitset_layout::Multi; + + private: + + static ETL_CONSTANT size_t Top_Mask_Shift = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element); + static ETL_CONSTANT element_type Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift)); + + public: static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility. @@ -1910,6 +1826,7 @@ namespace etl /// Default constructor. //************************************************************************* ETL_CONSTEXPR14 bitset() ETL_NOEXCEPT + : buffer() { implementation::reset(buffer, Number_Of_Elements); } @@ -1973,7 +1890,7 @@ namespace etl //************************************************************************* 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; } @@ -1983,7 +1900,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bitset& set() ETL_NOEXCEPT { - implementation::set(buffer, Number_Of_Elements); + implementation::set(buffer, Number_Of_Elements, Top_Mask); return *this; } @@ -2454,9 +2371,7 @@ namespace etl //************************************************************************* 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); } //************************************************************************* @@ -2586,8 +2501,7 @@ namespace etl static ETL_CONSTANT size_t Allocated_Bits = 0U; static ETL_CONSTANT element_type All_Set_Element = 0U; static ETL_CONSTANT element_type All_Clear_Element = 0U; - static ETL_CONSTANT size_t Top_Mask_Shift = 0U; - static ETL_CONSTANT element_type Top_Mask = 0U; + static ETL_CONSTANT char Element_Layout = etl::bitset_layout::Undefined; static ETL_CONSTANT size_t npos = etl::integral_limits::max; }; @@ -2596,7 +2510,7 @@ namespace etl /// The specialisation that uses an array of the default element type. //************************************************************************* template - class bitset_ext// : public etl::private_bitset::bitset_common + class bitset_ext { public: @@ -2608,15 +2522,19 @@ namespace etl static ETL_CONSTANT size_t npos = etl::integral_limits::max; - //static ETL_CONSTANT bool Element_Layout = implementation::Element_Layout; - static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits::bits; static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits::max; static ETL_CONSTANT element_type All_Clear_Element = element_type(0); static ETL_CONSTANT size_t Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1; static ETL_CONSTANT size_t Allocated_Bits = Number_Of_Elements * Bits_Per_Element; - static ETL_CONSTANT size_t Top_Mask_Shift = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element); - static ETL_CONSTANT element_type Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift)); + static ETL_CONSTANT char Element_Layout = (Number_Of_Elements == 1U) ? etl::bitset_layout::Single : etl::bitset_layout::Multi; + + private: + + static ETL_CONSTANT size_t Top_Mask_Shift = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element); + static ETL_CONSTANT element_type Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift)); + + public: static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility. @@ -2716,7 +2634,7 @@ namespace etl : pbuffer(pbuffer_) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - reset(); + implementation::reset(pbuffer, Number_Of_Elements); } //************************************************************************* @@ -2726,7 +2644,7 @@ namespace etl : pbuffer(buffer.data()) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - reset(); + implementation::reset(pbuffer, Number_Of_Elements); } //************************************************************************* @@ -2736,7 +2654,7 @@ namespace etl : 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); } //************************************************************************* @@ -2745,7 +2663,7 @@ namespace etl 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); } //************************************************************************* @@ -2779,7 +2697,7 @@ namespace etl : pbuffer(pbuffer_) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -2788,7 +2706,7 @@ namespace etl ETL_CONSTEXPR14 bitset_ext(const char* text, buffer_type& buffer) ETL_NOEXCEPT : pbuffer(buffer.data()) { - implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -2798,7 +2716,7 @@ namespace etl : pbuffer(pbuffer_) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -2807,7 +2725,7 @@ namespace etl ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, buffer_type& buffer) ETL_NOEXCEPT : pbuffer(buffer.data()) { - implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -2817,7 +2735,7 @@ namespace etl : pbuffer(pbuffer_) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -2826,7 +2744,7 @@ namespace etl ETL_CONSTEXPR14 bitset_ext(const char16_t* text, buffer_type& buffer) ETL_NOEXCEPT : pbuffer(buffer.data()) { - implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -2836,7 +2754,7 @@ namespace etl : pbuffer(pbuffer_) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -2845,7 +2763,7 @@ namespace etl ETL_CONSTEXPR14 bitset_ext(const char32_t* text, buffer_type& buffer) ETL_NOEXCEPT : pbuffer(buffer.data()) { - implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -2863,7 +2781,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bitset_ext& set() ETL_NOEXCEPT { - implementation::set(pbuffer, Number_Of_Elements, All_Set_Element); + implementation::set(pbuffer, Number_Of_Elements, Top_Mask); return *this; } @@ -2885,7 +2803,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bitset_ext& set(const char* text) ETL_NOEXCEPT { - implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -2895,7 +2813,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bitset_ext& set(const wchar_t* text) ETL_NOEXCEPT { - implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -2905,7 +2823,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bitset_ext& set(const char16_t* text) ETL_NOEXCEPT { - implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -2915,7 +2833,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bitset_ext& set(const char32_t* text) ETL_NOEXCEPT { - implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -3108,7 +3026,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT { - return implementation::any(pbuffer, Number_Of_Elements, Top_Mask); + return implementation::any(pbuffer, Number_Of_Elements); } //************************************************************************* @@ -3116,7 +3034,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT { - return implementation::any(pbuffer, Number_Of_Elements, Top_Mask, mask); + return implementation::any(pbuffer, Number_Of_Elements, mask); } //************************************************************************* @@ -3217,7 +3135,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bitset_ext& operator ^=(const bitset_ext& other) ETL_NOEXCEPT { - implementation::xoperator_or(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements); + implementation::operator_xor(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements); return *this; } @@ -3247,7 +3165,7 @@ namespace etl //************************************************************************* 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); } //************************************************************************* diff --git a/test/test_bitset_new_explicit_single_element_type.cpp b/test/test_bitset_new_explicit_single_element_type.cpp index 291c6836..18d19157 100644 --- a/test/test_bitset_new_explicit_single_element_type.cpp +++ b/test/test_bitset_new_explicit_single_element_type.cpp @@ -146,6 +146,11 @@ namespace 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_layout::Single, data8.Element_Layout); + CHECK_EQUAL(etl::bitset_layout::Single, data16.Element_Layout); + CHECK_EQUAL(etl::bitset_layout::Single, data32.Element_Layout); + CHECK_EQUAL(etl::bitset_layout::Single, data64.Element_Layout); } //************************************************************************* @@ -353,6 +358,33 @@ 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)); + } + } + //************************************************************************* TEST(test_set_with_char_string) { 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 4b3d3948..cbba1ed4 100644 --- a/test/test_bitset_new_ext_explicit_single_element_type.cpp +++ b/test/test_bitset_new_ext_explicit_single_element_type.cpp @@ -47,7 +47,7 @@ namespace //************************************************************************* 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 +64,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 +80,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 +96,33 @@ 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(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_layout::Single, data8.Element_Layout); + CHECK_EQUAL(etl::bitset_layout::Single, data16.Element_Layout); + CHECK_EQUAL(etl::bitset_layout::Single, data32.Element_Layout); + CHECK_EQUAL(etl::bitset_layout::Single, data64.Element_Layout); } //************************************************************************* 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 +137,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 +155,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 +171,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 +187,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 +203,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 +219,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 +237,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 +249,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 +261,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 +273,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 +283,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 +304,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 +329,40 @@ 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_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 +381,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 +402,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 +423,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 +446,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 +459,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 +472,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 +485,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 +496,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 +517,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 +538,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 +559,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 +582,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 +595,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 +608,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 +621,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 +632,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 +642,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 +652,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 +682,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 +692,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 +826,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 +848,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 +904,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 +928,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 +945,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 +968,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 +993,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 +1016,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 +1041,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 +1064,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 +1086,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 +1249,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 +1272,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 +1295,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 +1305,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 +1329,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 +1346,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 +1363,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 +1435,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 +1452,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 +1469,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 +1517,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 +1527,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 +1535,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 +1543,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 +1555,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,7 +1574,7 @@ 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; @@ -1409,7 +1586,7 @@ namespace //************************************************************************* 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 +1598,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 +1614,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 +1629,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 +1644,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); @@ -1568,16 +1745,16 @@ namespace 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(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))); @@ -1596,8 +1773,8 @@ namespace 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); + CHECK_THROW(b.extract(26, 7), etl::bitset_overflow); + CHECK_THROW(b.extract(27, 6), etl::bitset_overflow); } //************************************************************************* @@ -1608,16 +1785,16 @@ namespace 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(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())); @@ -1637,8 +1814,8 @@ namespace CHECK_EQUAL_HEX(int8_t(0x04), (b.extract())); // The lines below should static assert. - //int8_t v1 = b.extract(); - //int8_t v1 = b.extract(); + //uint8_t v1 = b.extract(); + //uint8_t v1 = b.extract(); } //************************************************************************* @@ -1726,34 +1903,34 @@ namespace bs32::buffer_type buffer; bs32 b(0x12345678UL, buffer); - 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_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); + CHECK_THROW(b.extract(24, 9), etl::bitset_overflow); + CHECK_THROW(b.extract(25, 8), etl::bitset_overflow); } //************************************************************************* @@ -1764,35 +1941,35 @@ namespace bs32::buffer_type buffer; bs32 b(0x12345678UL, buffer); - 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())); + 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. - //int8_t v1 = b.extract(); - //int8_t v2 = b.extract(); + //uint8_t v1 = b.extract(); + //uint8_t v2 = b.extract(); } //************************************************************************* @@ -1931,26 +2108,26 @@ namespace bs32::buffer_type buffer; bs32 b(0x12345678UL, buffer); - 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_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); + CHECK_THROW(b.extract(16, 17), etl::bitset_overflow); + CHECK_THROW(b.extract(17, 16), etl::bitset_overflow); } //************************************************************************* @@ -1961,27 +2138,27 @@ namespace bs32::buffer_type buffer; bs32 b(0x12345678UL, buffer); - 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())); + 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. - //int16_t v1 = b.extract()); - //int16_t v2 = b.extract()); + //uint16_t v1 = b.extract()); + //uint16_t v2 = b.extract()); } }; }