From dba681d94fcce9e9eacce8bb0e5d44d636965083 Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Mon, 15 Aug 2022 16:32:57 +0100 Subject: [PATCH] Work in progress Start single element optimisations --- include/etl/private/bitset_fast.h | 100 - include/etl/private/bitset_legacy.h | 24 +- include/etl/private/bitset_new.h | 995 +++++++-- test/test_bitset_new.cpp | 3118 ++++++++++++++------------- 4 files changed, 2336 insertions(+), 1901 deletions(-) delete mode 100644 include/etl/private/bitset_fast.h diff --git a/include/etl/private/bitset_fast.h b/include/etl/private/bitset_fast.h deleted file mode 100644 index fea94649..00000000 --- a/include/etl/private/bitset_fast.h +++ /dev/null @@ -1,100 +0,0 @@ -///\file - -/****************************************************************************** -The MIT License(MIT) - -Embedded Template Library. -https://github.com/ETLCPP/etl -https://www.etlcpp.com - -Copyright(c) 2022 John Wellbelove - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files(the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and / or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions : - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. -******************************************************************************/ - -//*************************************************************************** -/// Optimised specialisations. -//*************************************************************************** - -namespace etl -{ - namespace private_bitset - { - template - class bitset_fast; - - template - class bitset_fast - { - public: - - enum - { - npos = etl::integral_limits::max - }; - - typedef TElement element_type; - - ETL_CONSTEXPR14 bitset_fast() - : data(static_cast(0)) - { - } - - ETL_CONSTEXPR14 bitset_fast(unsigned long long v) - : data(static_cast(v)) - { - } - - ETL_CONSTEXPR14 bitset_fast(const char* text) - : data(0) - { - } - - ETL_CONSTEXPR14 bitset_fast(const wchar_t* text) - : data(0) - { - } - - ETL_CONSTEXPR14 bitset_fast(const char16_t* text) - : data(0) - { - } - - ETL_CONSTEXPR14 bitset_fast(const char32_t* text) - : data(0) - { - } - - ETL_CONSTEXPR14 bitset_fast(const bitset_fast& other) - : data(other.data) - { - } - - template - ETL_CONSTEXPR14 T value() const - { - return T(data); - } - - private: - - element_type data; - }; - } -} diff --git a/include/etl/private/bitset_legacy.h b/include/etl/private/bitset_legacy.h index 64d010aa..a8285fef 100644 --- a/include/etl/private/bitset_legacy.h +++ b/include/etl/private/bitset_legacy.h @@ -246,7 +246,7 @@ namespace etl //************************************************************************* size_t size() const { - return Total_Bits; + return Active_Bits; } //************************************************************************* @@ -344,7 +344,7 @@ namespace etl { reset(); - size_t i = etl::min(Total_Bits, etl::strlen(text)); + size_t i = etl::min(Active_Bits, etl::strlen(text)); while (i > 0) { @@ -361,7 +361,7 @@ namespace etl { reset(); - size_t i = etl::min(Total_Bits, etl::strlen(text)); + size_t i = etl::min(Active_Bits, etl::strlen(text)); while (i > 0) { @@ -378,7 +378,7 @@ namespace etl { reset(); - size_t i = etl::min(Total_Bits, etl::strlen(text)); + size_t i = etl::min(Active_Bits, etl::strlen(text)); while (i > 0) { @@ -395,7 +395,7 @@ namespace etl { reset(); - size_t i = etl::min(Total_Bits, etl::strlen(text)); + size_t i = etl::min(Active_Bits, etl::strlen(text)); while (i > 0) { @@ -551,7 +551,7 @@ namespace etl //************************************************************************* ibitset& flip(size_t position) { - if (position < Total_Bits) + if (position < Active_Bits) { size_t index; element_t bit; @@ -678,7 +678,7 @@ namespace etl (!state && (value != ALL_SET))) { // For each bit in the element... - while ((bit < Bits_Per_Element) && (position < Total_Bits)) + while ((bit < Bits_Per_Element) && (position < Active_Bits)) { // Equal to the required state? if (((value & mask) != 0) == state) @@ -767,7 +767,7 @@ namespace etl //************************************************************************* ibitset& operator<<=(size_t shift) { - if (shift >= Total_Bits) + if (shift >= Active_Bits) { reset(); } @@ -846,7 +846,7 @@ namespace etl //************************************************************************* ibitset& operator>>=(size_t shift) { - if (shift >= Total_Bits) + if (shift >= Active_Bits) { reset(); } @@ -1016,12 +1016,12 @@ namespace etl /// Constructor. //************************************************************************* ibitset(size_t nbits_, size_t size_, element_t* pdata_) - : Total_Bits(nbits_) + : Active_Bits(nbits_) , Number_Of_Elements(size_) , pdata(pdata_) { const size_t allocated_bits = Number_Of_Elements * Bits_Per_Element; - const size_t top_mask_shift = ((Bits_Per_Element - (allocated_bits - Total_Bits)) % Bits_Per_Element); + const size_t top_mask_shift = ((Bits_Per_Element - (allocated_bits - Active_Bits)) % Bits_Per_Element); Top_Mask = element_t(top_mask_shift == 0 ? ALL_SET : ~(ALL_SET << top_mask_shift)); } @@ -1048,7 +1048,7 @@ namespace etl // Disable copy construction. ibitset(const ibitset&); - const size_t Total_Bits; + const size_t Active_Bits; const size_t Number_Of_Elements; element_t* pdata; diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h index c1a46e23..f7b3587d 100644 --- a/include/etl/private/bitset_new.h +++ b/include/etl/private/bitset_new.h @@ -51,9 +51,6 @@ SOFTWARE. #include "../span.h" #include "../string.h" -// Optimised vversions for when to bitset size equals the number of bits in an integral type. -#include "bitset_fast.h" - #include "minmax_push.h" #if defined(ETL_COMPILER_KEIL) @@ -722,27 +719,6 @@ namespace etl pbuffer[i] ^= pbuffer2[i]; } } -// //************************************************************************* -// /// operator = -// //************************************************************************* -// ibitset& operator =(const ibitset& other) -// { -// if (this != &other) -// { -// etl::copy_n(other.pbuffer, Number_Of_Elements, pbuffer); -// } -// -// return *this; -// } -// -// //************************************************************************* -// /// swap -// //************************************************************************* -// void swap(ibitset& other) -// { -// etl::swap_ranges(pbuffer, pbuffer + Number_Of_Elements, other.pbuffer); -// } -// //************************************************************************* /// Initialise from an unsigned long long. @@ -774,51 +750,6 @@ namespace etl } } } - - ////************************************************************************* - ///// Invert - ////************************************************************************* - //void invert() - //{ - // for (size_t i = 0UL; i < Number_Of_Elements; ++i) - // { - // pbuffer[i] = ~pbuffer[i]; - // } - - // clear_unused_bits_in_msb(); - //} - - ////************************************************************************* - ///// Gets a reference to the specified bit. - ////************************************************************************* - //bit_reference get_bit_reference(size_t position) - //{ - // return bit_reference(*this, position); - //} - - //************************************************************************* - /// Constructor. - //************************************************************************* - //ibitset(size_t nbits_, size_t size_, element_type* pdata_) - // : Total_Bits(nbits_) - // , Number_Of_Elements(size_) - // , pbuffer(pdata_) - //{ - // const size_t allocated_bits = Number_Of_Elements * Bits_Per_Element; - // const size_t top_mask_shift = ((Bits_Per_Element - (allocated_bits - Total_Bits)) % Bits_Per_Element); - // Top_Mask = element_type(top_mask_shift == 0 ? ALL_SET : ~(ALL_SET << top_mask_shift)); - //} - - ////************************************************************************* - ///// Compare bitsets. - ////************************************************************************* - //static bool is_equal(const ibitset& lhs, const ibitset&rhs) - //{ - // return etl::equal(lhs.pbuffer, lhs.pbuffer + lhs.Number_Of_Elements, rhs.pbuffer); - //} - - //element_type Top_Mask; - //************************************************************************* ETL_CONSTEXPR14 void copy_elements(const_pointer sb, pointer db, size_t count) { @@ -830,70 +761,53 @@ namespace etl --count; } } - -// -// // Disable copy construction. -// ibitset(const ibitset&); -// -// size_t Total_Bits; -// const size_t Number_Of_Elements; -// element_type* pbuffer; -// -// //************************************************************************* -// /// Destructor. -// //************************************************************************* -//#if defined(ETL_POLYMORPHIC_BITSET) || defined(ETL_POLYMORPHIC_CONTAINERS) -// public: -// virtual ~ibitset() -// { -// } -//#else -// protected: -// ~ibitset() -// { -// } -//#endif }; namespace private_bitset { - template + //************************************************************************* + // Selects an implicit element type based on the required number of bits. + template struct select_element_type; - template - struct select_element_type + //************************************************************************* + template + struct select_element_type { - typedef typename etl::conditional::type>::type>::type>::type>::type type; + typedef typename etl::conditional::type>::type>::type>::type>::type type; }; - template - struct select_element_type + //************************************************************************* + template + struct select_element_type { - typedef typename etl::conditional::type>::type>::type>::type type; + typedef typename etl::conditional::type>::type>::type>::type type; }; - template - struct select_element_type + //************************************************************************* + template + struct select_element_type { - typedef typename etl::conditional::type>::type>::type>::type type; + typedef typename etl::conditional::type>::type>::type>::type type; }; - template - struct select_element_type + //************************************************************************* + template + struct select_element_type { - typedef typename etl::conditional::type>::type>::type type; + typedef typename etl::conditional::type>::type>::type type; }; } @@ -914,13 +828,12 @@ namespace etl //************************************************************************* /// The class emulates an array of bool elements, but optimized for space allocation. /// Will accommodate any number of bits. - ///\tparam Total_Bits The number of bits. ///\ingroup bitset //************************************************************************* - template ::type, - bool IsSingleElement = (etl::integral_limits::bits == Total_Bits), - bool HasSingleElementMask = IsSingleElement && (etl::integral_limits::bits != Total_Bits)> + template ::type, + bool IsSingleElement = (etl::integral_limits::bits >= Active_Bits), + bool Has_Element_Mask = IsSingleElement && (etl::integral_limits::bits != Active_Bits)> class bitset { public: @@ -932,13 +845,13 @@ namespace etl typedef etl::span span_type; typedef etl::span const_span_type; - static ETL_CONSTANT size_t Bits_Per_Element = etl::bitset_impl::Bits_Per_Element; - static ETL_CONSTANT size_t Number_Of_Elements = (Total_Bits % Bits_Per_Element == 0) ? Total_Bits / Bits_Per_Element : Total_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 - Total_Bits)) % Bits_Per_Element); - static ETL_CONSTANT element_type All_Set = etl::bitset_impl::All_Set; - static ETL_CONSTANT element_type All_Clear = etl::bitset_impl::All_Clear; - static ETL_CONSTANT element_type Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set : ~(All_Set << Top_Mask_Shift)); + static ETL_CONSTANT size_t Bits_Per_Element = etl::bitset_impl::Bits_Per_Element; + static ETL_CONSTANT size_t Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1; + static ETL_CONSTANT size_t Allocated_Bits = Number_Of_Elements * Bits_Per_Element; + static ETL_CONSTANT size_t Top_Mask_Shift = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element); + static ETL_CONSTANT element_type All_Set = etl::bitset_impl::All_Set; + static ETL_CONSTANT element_type All_Clear = etl::bitset_impl::All_Clear; + static ETL_CONSTANT element_type Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set : ~(All_Set << Top_Mask_Shift)); static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility. @@ -1008,14 +921,14 @@ namespace etl //******************************* /// Constructor. //******************************* - ETL_CONSTEXPR14 bit_reference(bitset& r_bitset, size_t position_) + ETL_CONSTEXPR14 bit_reference(bitset& r_bitset, size_t position_) : p_bitset(&r_bitset) , position(position_) { } - bitset* p_bitset; ///< The bitset. - size_t position; ///< The position in the bitset. + bitset* p_bitset; ///< The bitset. + size_t position; ///< The position in the bitset. }; //************************************************************************* @@ -1030,7 +943,7 @@ namespace etl //************************************************************************* /// Copy constructor. //************************************************************************* - ETL_CONSTEXPR14 bitset(const bitset& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset(const bitset& other) ETL_NOEXCEPT : buffer() { ibitset.copy_elements(other.buffer, buffer, Number_Of_Elements); @@ -1052,7 +965,7 @@ namespace etl bitset(const char* text) : buffer() { - ibitset.set(buffer, Number_Of_Elements, Total_Bits, text); + ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); clear_unused_bits_in_msb(); } @@ -1062,7 +975,7 @@ namespace etl bitset(const wchar_t* text) : buffer() { - ibitset.set(buffer, Number_Of_Elements, Total_Bits, text); + ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); clear_unused_bits_in_msb(); } @@ -1072,7 +985,7 @@ namespace etl bitset(const char16_t* text) : buffer() { - ibitset.set(buffer, Number_Of_Elements, Total_Bits, text); + ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); clear_unused_bits_in_msb(); } @@ -1082,14 +995,14 @@ namespace etl bitset(const char32_t* text) : buffer() { - ibitset.set(buffer, Number_Of_Elements, Total_Bits, text); + ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); clear_unused_bits_in_msb(); } //************************************************************************* /// Set all of the bits. //************************************************************************* - ETL_CONSTEXPR14 bitset& set() + ETL_CONSTEXPR14 bitset& set() { etl::fill_n(buffer, ETL_OR_STD::size(buffer), All_Set); clear_unused_bits_in_msb(); @@ -1100,7 +1013,7 @@ namespace etl //************************************************************************* /// Set the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 bitset& set(size_t position, bool value = true) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& set(size_t position, bool value = true) ETL_NOEXCEPT { ibitset.set(buffer, Number_Of_Elements, position, value); clear_unused_bits_in_msb(); @@ -1111,10 +1024,10 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - bitset& set(const char* text) + bitset& set(const char* text) { ETL_ASSERT_AND_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this); - ibitset.set(buffer, Number_Of_Elements, Total_Bits, text); + ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -1122,10 +1035,10 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - bitset& set(const wchar_t* text) + bitset& set(const wchar_t* text) { ETL_ASSERT_AND_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this); - ibitset.set(buffer, Number_Of_Elements, Total_Bits, text); + ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -1133,10 +1046,10 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - bitset& set(const char16_t* text) + bitset& set(const char16_t* text) { ETL_ASSERT_AND_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this); - ibitset.set(buffer, Number_Of_Elements, Total_Bits, text); + ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -1144,10 +1057,10 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - bitset& set(const char32_t* text) + bitset& set(const char32_t* text) { ETL_ASSERT_AND_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this); - ibitset.set(buffer, Number_Of_Elements, Total_Bits, text); + ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -1155,9 +1068,9 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - bitset& from_string(const char* text) + bitset& from_string(const char* text) { - ibitset.from_string(buffer, Number_Of_Elements, Total_Bits, text); + ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -1165,9 +1078,9 @@ namespace etl //************************************************************************* /// Set from a wide string. //************************************************************************* - bitset& from_string(const wchar_t* text) + bitset& from_string(const wchar_t* text) { - ibitset.from_string(buffer, Number_Of_Elements, Total_Bits, text); + ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -1175,9 +1088,9 @@ namespace etl //************************************************************************* /// Set from a u16 string. //************************************************************************* - bitset& from_string(const char16_t* text) + bitset& from_string(const char16_t* text) { - ibitset.from_string(buffer, Number_Of_Elements, Total_Bits, text); + ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -1185,9 +1098,9 @@ namespace etl //************************************************************************* /// Set from a u32 string. //************************************************************************* - bitset& from_string(const char32_t* text) + bitset& from_string(const char32_t* text) { - ibitset.from_string(buffer, Number_Of_Elements, Total_Bits, text); + ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -1224,7 +1137,7 @@ namespace etl //************************************************************************* /// Reset all of the bits. //************************************************************************* - ETL_CONSTEXPR14 bitset& reset() ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& reset() ETL_NOEXCEPT { etl::fill_n(buffer, Number_Of_Elements, All_Clear); @@ -1234,7 +1147,7 @@ namespace etl //************************************************************************* /// Reset the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 bitset& reset(size_t position) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& reset(size_t position) ETL_NOEXCEPT { ibitset.reset(buffer, Number_Of_Elements, position); return *this; @@ -1254,7 +1167,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR size_t size() const ETL_NOEXCEPT { - return Total_Bits; + return Active_Bits; } //************************************************************************* @@ -1292,7 +1205,7 @@ namespace etl //************************************************************************* /// Flip all of the bits. //************************************************************************* - ETL_CONSTEXPR14 bitset& flip() + ETL_CONSTEXPR14 bitset& flip() { ibitset.flip(buffer, Number_Of_Elements); clear_unused_bits_in_msb(); @@ -1303,9 +1216,9 @@ namespace etl //************************************************************************* /// Flip the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 bitset& flip(size_t position) + ETL_CONSTEXPR14 bitset& flip(size_t position) { - ibitset.flip(buffer, Number_Of_Elements, Total_Bits, position); + ibitset.flip(buffer, Number_Of_Elements, Active_Bits, position); return *this; } @@ -1330,7 +1243,7 @@ namespace etl /// Returns a string representing the bitset. //************************************************************************* #if ETL_USING_CPP11 - template > + template > #else template #endif @@ -1339,19 +1252,18 @@ namespace etl { TString result; - result.resize(Total_Bits, '\0'); + result.resize(Active_Bits, '\0'); - ETL_ASSERT_AND_RETURN_VALUE((result.size() == Total_Bits), ETL_ERROR(etl::bitset_overflow), result); + ETL_ASSERT_AND_RETURN_VALUE((result.size() == Active_Bits), ETL_ERROR(etl::bitset_overflow), result); - for (size_t i = Total_Bits; i > 0; --i) + for (size_t i = Active_Bits; i > 0; --i) { - result[Total_Bits - i] = test(i - 1) ? one : zero; + result[Active_Bits - i] = test(i - 1) ? one : zero; } return result; } - //************************************************************************* /// Finds the first bit in the specified state. ///\param state The state to search for. @@ -1359,7 +1271,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 size_t find_first(bool state) const { - return ibitset.find_next(buffer, Number_Of_Elements, Total_Bits, state, 0); + return ibitset.find_next(buffer, Number_Of_Elements, Active_Bits, state, 0); } //************************************************************************* @@ -1370,15 +1282,15 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const { - return ibitset.find_next(buffer, Number_Of_Elements, Total_Bits, state, position); + return ibitset.find_next(buffer, Number_Of_Elements, Active_Bits, state, position); } //************************************************************************* /// operator & //************************************************************************* - ETL_CONSTEXPR14 bitset operator &(const bitset& other) const + ETL_CONSTEXPR14 bitset operator &(const bitset& other) const { - etl::bitset temp(*this); + etl::bitset temp(*this); temp &= other; @@ -1388,7 +1300,7 @@ namespace etl //************************************************************************* /// operator &= //************************************************************************* - ETL_CONSTEXPR14 bitset& operator &=(const bitset& other) + ETL_CONSTEXPR14 bitset& operator &=(const bitset& other) { ibitset.and_equals(&buffer[0], &other.buffer[0], Number_Of_Elements); @@ -1398,9 +1310,9 @@ namespace etl //************************************************************************* /// operator | //************************************************************************* - ETL_CONSTEXPR14 bitset operator |(const bitset& other) const + ETL_CONSTEXPR14 bitset operator |(const bitset& other) const { - etl::bitset temp(*this); + etl::bitset temp(*this); temp |= other; @@ -1410,7 +1322,7 @@ namespace etl //************************************************************************* /// operator |= //************************************************************************* - ETL_CONSTEXPR14 bitset& operator |=(const bitset& other) + ETL_CONSTEXPR14 bitset& operator |=(const bitset& other) { ibitset.or_equals(&buffer[0], &other.buffer[0], Number_Of_Elements); @@ -1420,9 +1332,9 @@ namespace etl //************************************************************************* /// operator ^ //************************************************************************* - ETL_CONSTEXPR14 bitset operator ^(const bitset& other) const + ETL_CONSTEXPR14 bitset operator ^(const bitset& other) const { - etl::bitset temp(*this); + etl::bitset temp(*this); temp ^= other; @@ -1432,19 +1344,31 @@ namespace etl //************************************************************************* /// operator ^= //************************************************************************* - ETL_CONSTEXPR14 bitset& operator ^=(const bitset& other) + ETL_CONSTEXPR14 bitset& operator ^=(const bitset& other) { ibitset.xor_equals(&buffer[0], &other.buffer[0], Number_Of_Elements); return *this; } + //************************************************************************* + /// operator ~ + //************************************************************************* + bitset operator ~() const + { + etl::bitset temp(*this); + + temp.flip(); + + return temp; + } + //************************************************************************* /// operator << //************************************************************************* - ETL_CONSTEXPR14 bitset operator <<(size_t shift) const + ETL_CONSTEXPR14 bitset operator <<(size_t shift) const { - etl::bitset temp(*this); + etl::bitset temp(*this); temp <<= shift; @@ -1454,15 +1378,15 @@ namespace etl //************************************************************************* /// operator <<= //************************************************************************* - ETL_CONSTEXPR14 bitset& operator <<=(size_t shift) + ETL_CONSTEXPR14 bitset& operator <<=(size_t shift) { - if (shift >= Total_Bits) + if (shift >= Active_Bits) { reset(); } else { - ibitset.shift_left_equals(buffer, Number_Of_Elements, Total_Bits, shift); + ibitset.shift_left_equals(buffer, Number_Of_Elements, Active_Bits, shift); // Truncate any bits shifted to the left. clear_unused_bits_in_msb(); @@ -1474,9 +1398,9 @@ namespace etl //************************************************************************* /// operator >> //************************************************************************* - ETL_CONSTEXPR14 bitset operator >>(size_t shift) const + ETL_CONSTEXPR14 bitset operator >>(size_t shift) const { - bitset temp(*this); + bitset temp(*this); temp >>= shift; @@ -1486,15 +1410,15 @@ namespace etl //************************************************************************* /// operator >>= //************************************************************************* - ETL_CONSTEXPR14 bitset& operator >>=(size_t shift) + ETL_CONSTEXPR14 bitset& operator >>=(size_t shift) { - if (shift >= Total_Bits) + if (shift >= Active_Bits) { reset(); } else { - ibitset.shift_right_equals(buffer, Number_Of_Elements, Total_Bits, shift); + ibitset.shift_right_equals(buffer, Number_Of_Elements, Active_Bits, shift); } return *this; @@ -1503,7 +1427,7 @@ namespace etl //************************************************************************* /// operator == //************************************************************************* - friend ETL_CONSTEXPR14 bool operator ==(const bitset& lhs, const bitset& rhs) + friend ETL_CONSTEXPR14 bool operator ==(const bitset& lhs, const bitset& rhs) { return etl::equal(lhs.buffer, lhs.buffer + lhs.Number_Of_Elements, @@ -1513,7 +1437,7 @@ namespace etl //************************************************************************* /// swap //************************************************************************* - ETL_CONSTEXPR14 void swap(etl::bitset& other) + ETL_CONSTEXPR14 void swap(etl::bitset& other) { pointer p1 = buffer; pointer p1_end = buffer + Number_Of_Elements; @@ -1576,55 +1500,654 @@ namespace etl }; }; - //template - //class bitset<8U, uint8_t, true, HasSingleElementMask> : public etl::private_bitset::bitset_fast<8U, uint8_t, HasSingleElementMask> - //{ - //public: + //*************************************************************************** + /// Specialisation for when there is only one element. + //*************************************************************************** + template + class bitset + { + public: - // ETL_CONSTEXPR14 bitset() - // : bitset_fast<8U, uint8_t>() - // { - // } + typedef TElement element_type; + typedef TElement* pointer; + typedef const TElement* const_pointer; - // ETL_CONSTEXPR14 bitset(unsigned long long v) - // : bitset_fast<8U, uint8_t>(v) - // { - // } + typedef etl::span span_type; + typedef etl::span const_span_type; - // ETL_CONSTEXPR14 bitset(const char* text) - // : bitset_fast<8U, uint8_t>(text) - // { - // } + static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits::bits; + static ETL_CONSTANT size_t Number_Of_Elements = 1U; + static ETL_CONSTANT size_t Allocated_Bits = Bits_Per_Element; + static ETL_CONSTANT size_t Top_Mask_Shift = (Bits_Per_Element - (Allocated_Bits - Active_Bits)); + static ETL_CONSTANT element_type All_Set = etl::integral_limits::type>::max; + static ETL_CONSTANT element_type All_Clear = element_type(0); + static ETL_CONSTANT element_type Top_Mask = element_type(~(All_Set << Top_Mask_Shift)); - // ETL_CONSTEXPR14 bitset(const wchar_t* text) - // : bitset_fast<8U, uint8_t>(text) - // { - // } + //************************************************************************* + /// The reference type returned. + //************************************************************************* + class bit_reference + { + public: - // ETL_CONSTEXPR14 bitset(const char16_t* text) - // : bitset_fast<8U, uint8_t>(text) - // { - // } + friend class bitset; - // ETL_CONSTEXPR14 bitset(const char32_t* text) - // : bitset_fast<8U, uint8_t>(text) - // { - // } + //******************************* + /// Conversion operator. + //******************************* + ETL_CONSTEXPR14 operator bool() const + { + return p_bitset->test(position); + } - // ETL_CONSTEXPR14 bitset(const bitset<8U, uint8_t>& other) - // : bitset_fast<8U, uint8_t>(other) - // { - // } - //}; + //******************************* + /// Assignment operator. + //******************************* + ETL_CONSTEXPR14 bit_reference& operator = (bool b) + { + p_bitset->set(position, b); + return *this; + } + + //******************************* + /// Assignment operator. + //******************************* + ETL_CONSTEXPR14 bit_reference& operator = (const bit_reference& r) + { + p_bitset->set(position, bool(r)); + return *this; + } + + //******************************* + /// Flip the bit. + //******************************* + ETL_CONSTEXPR14 bit_reference& flip() + { + p_bitset->flip(position); + return *this; + } + + //******************************* + /// Return the logical inverse of the bit. + //******************************* + ETL_CONSTEXPR14 bool operator~() const + { + return !p_bitset->test(position); + } + + private: + + //******************************* + /// Default constructor. + //******************************* + ETL_CONSTEXPR14 bit_reference() + : p_bitset(ETL_NULLPTR) + , position(0) + { + } + + //******************************* + /// Constructor. + //******************************* + ETL_CONSTEXPR14 bit_reference(bitset& r_bitset, size_t position_) + : p_bitset(&r_bitset) + , position(position_) + { + } + + bitset* p_bitset; ///< The bitset. + size_t position; ///< The position in the bitset. + }; + + //************************************************************************* + /// Default constructor. + //************************************************************************* + ETL_CONSTEXPR14 bitset() ETL_NOEXCEPT + : buffer(All_Clear) + { + } + + //************************************************************************* + /// Copy constructor. + //************************************************************************* + ETL_CONSTEXPR14 bitset(const bitset& other) ETL_NOEXCEPT + : buffer(other.buffer) + { + } + + //************************************************************************* + /// Construct from a value. + //************************************************************************* + ETL_CONSTEXPR14 bitset(unsigned long long value) ETL_NOEXCEPT + : buffer(All_Clear) + { + //ibitset.initialise(buffer, Number_Of_Elements, value); + //clear_unused_bits_in_msb(); + } + + //************************************************************************* + /// Construct from a string. + //************************************************************************* + bitset(const char* text) + : buffer(All_Clear) + { + //ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); + //clear_unused_bits_in_msb(); + } + + //************************************************************************* + /// Construct from a string. + //************************************************************************* + bitset(const wchar_t* text) + : buffer(All_Clear) + { + //ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); + //clear_unused_bits_in_msb(); + } + + //************************************************************************* + /// Construct from a string. + //************************************************************************* + bitset(const char16_t* text) + : buffer(All_Clear) + { + // ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); + // clear_unused_bits_in_msb(); + } + + //************************************************************************* + /// Construct from a string. + //************************************************************************* + bitset(const char32_t* text) + : buffer(All_Clear) + { + //ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); + //clear_unused_bits_in_msb(); + } + + //************************************************************************* + /// Set all of the bits. + //************************************************************************* + ETL_CONSTEXPR14 bitset& set() + { + //etl::fill_n(buffer, ETL_OR_STD::size(buffer), All_Set); + //clear_unused_bits_in_msb(); + + return *this; + } + + //************************************************************************* + /// Set the bit at the position. + //************************************************************************* + ETL_CONSTEXPR14 bitset& set(size_t position, bool value = true) ETL_NOEXCEPT + { + //ibitset.set(buffer, Number_Of_Elements, position, value); + //clear_unused_bits_in_msb(); + + return *this; + } + + //************************************************************************* + /// Set from a string. + //************************************************************************* + bitset& set(const char* text) + { + //ETL_ASSERT_AND_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this); + //ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); + + return *this; + } + + //************************************************************************* + /// Set from a string. + //************************************************************************* + bitset& set(const wchar_t* text) + { + //ETL_ASSERT_AND_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this); + //ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); + + return *this; + } + + //************************************************************************* + /// Set from a string. + //************************************************************************* + bitset& set(const char16_t* text) + { + //ETL_ASSERT_AND_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this); + //ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); + + return *this; + } + + //************************************************************************* + /// Set from a string. + //************************************************************************* + bitset& set(const char32_t* text) + { + //ETL_ASSERT_AND_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this); + //ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); + + return *this; + } + + //************************************************************************* + /// Set from a string. + //************************************************************************* + bitset& from_string(const char* text) + { + //ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text); + + return *this; + } + + //************************************************************************* + /// Set from a wide string. + //************************************************************************* + bitset& from_string(const wchar_t* text) + { + //ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text); + + return *this; + } + + //************************************************************************* + /// Set from a u16 string. + //************************************************************************* + bitset& from_string(const char16_t* text) + { + //ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text); + + return *this; + } + + //************************************************************************* + /// Set from a u32 string. + //************************************************************************* + bitset& from_string(const char32_t* text) + { + //ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text); + + return *this; + } + + //************************************************************************* + /// Get as an integral value. + //************************************************************************* + template + ETL_CONSTEXPR14 + typename etl::enable_if::value, T>::type + value() const + { + //ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); + //ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Type too small"); + + //return ibitset.value(buffer, Number_Of_Elements); + return 0; + } + + //************************************************************************* + /// Get as an unsigned long. + //************************************************************************* + ETL_CONSTEXPR14 unsigned long to_ulong() const + { + //return value(); + return 0; + } + + //************************************************************************* + /// Get as an unsigned long long. + //************************************************************************* + ETL_CONSTEXPR14 unsigned long long to_ullong() const + { + //return value(); + return 0; + } + //************************************************************************* + /// Reset all of the bits. + //************************************************************************* + ETL_CONSTEXPR14 bitset& reset() ETL_NOEXCEPT + { + //etl::fill_n(buffer, Number_Of_Elements, All_Clear); + + return *this; + } + + //************************************************************************* + /// Reset the bit at the position. + //************************************************************************* + ETL_CONSTEXPR14 bitset& reset(size_t position) ETL_NOEXCEPT + { + //ibitset.reset(buffer, Number_Of_Elements, position); + return *this; + } + + //************************************************************************* + /// Tests a bit at a position. + /// Positions greater than the number of configured bits will return false. + //************************************************************************* + ETL_CONSTEXPR14 bool test(size_t position) const + { + //return ibitset.test(buffer, Number_Of_Elements, position); + return false; + } + + //************************************************************************* + /// The number of bits in the bitset. + //************************************************************************* + ETL_CONSTEXPR size_t size() const ETL_NOEXCEPT + { + return Active_Bits; + } + + //************************************************************************* + /// Count the number of bits set. + //************************************************************************* + ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT + { + //return ibitset.count(buffer, Number_Of_Elements); + return 0; + } + + //************************************************************************* + // Are all the bits sets? + //************************************************************************* + ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT + { + //return ibitset.all(buffer, Number_Of_Elements, Top_Mask); + return false; + } + + //************************************************************************* + /// Are none of the bits set? + //************************************************************************* + ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT + { + //return ibitset.none(buffer, Number_Of_Elements); + return false; + } + + //************************************************************************* + /// Are any of the bits set? + //************************************************************************* + ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT + { + return !none(); + } + + //************************************************************************* + /// Flip all of the bits. + //************************************************************************* + ETL_CONSTEXPR14 bitset& flip() + { + //ibitset.flip(buffer, Number_Of_Elements); + //clear_unused_bits_in_msb(); + + return *this; + } + + //************************************************************************* + /// Flip the bit at the position. + //************************************************************************* + ETL_CONSTEXPR14 bitset& flip(size_t position) + { + //ibitset.flip(buffer, Number_Of_Elements, Active_Bits, position); + + return *this; + } + + //************************************************************************* + /// Read [] operator. + //************************************************************************* + ETL_CONSTEXPR14 bool operator[] (size_t position) const + { + return ibitset.test(buffer, Number_Of_Elements, position); + } + + //************************************************************************* + /// Write [] operator. + //************************************************************************* + ETL_CONSTEXPR14 bit_reference operator [] (size_t position) + { + return bit_reference(*this, position); + } + + //************************************************************************* + /// Returns a string representing the bitset. + //************************************************************************* +#if ETL_USING_CPP11 + template > +#else + template +#endif + TString to_string(typename TString::value_type zero = typename TString::value_type('0'), + typename TString::value_type one = typename TString::value_type('1')) const + { + TString result; + + //result.resize(Active_Bits, '\0'); + + //ETL_ASSERT_AND_RETURN_VALUE((result.size() == Active_Bits), ETL_ERROR(etl::bitset_overflow), result); + + //for (size_t i = Active_Bits; i > 0; --i) + //{ + // result[Active_Bits - i] = test(i - 1) ? one : zero; + //} + + return result; + } + + //************************************************************************* + /// Finds the first bit in the specified state. + ///\param state The state to search for. + ///\returns The position of the bit or Number_Of_Elements if none were found. + //************************************************************************* + ETL_CONSTEXPR14 size_t find_first(bool state) const + { + //return ibitset.find_next(buffer, Number_Of_Elements, Active_Bits, state, 0); + return 0; + } + + //************************************************************************* + /// Finds the next bit in the specified state. + ///\param state The state to search for. + ///\param position The position to start from. + ///\returns The position of the bit or npos if none were found. + //************************************************************************* + ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const + { + //return ibitset.find_next(buffer, Number_Of_Elements, Active_Bits, state, position); + return 0; + } + + //************************************************************************* + /// operator & + //************************************************************************* + ETL_CONSTEXPR14 bitset operator &(const bitset& other) const + { + etl::bitset temp(*this); + + temp &= other; + + return temp; + } + + //************************************************************************* + /// operator &= + //************************************************************************* + ETL_CONSTEXPR14 bitset& operator &=(const bitset& other) + { + //ibitset.and_equals(&buffer[0], &other.buffer[0], Number_Of_Elements); + + return *this; + } + + //************************************************************************* + /// operator | + //************************************************************************* + ETL_CONSTEXPR14 bitset operator |(const bitset& other) const + { + etl::bitset temp(*this); + + temp |= other; + + return temp; + } + + //************************************************************************* + /// operator |= + //************************************************************************* + ETL_CONSTEXPR14 bitset& operator |=(const bitset& other) + { + //ibitset.or_equals(&buffer[0], &other.buffer[0], Number_Of_Elements); + + return *this; + } + + //************************************************************************* + /// operator ^ + //************************************************************************* + ETL_CONSTEXPR14 bitset operator ^(const bitset& other) const + { + etl::bitset temp(*this); + + temp ^= other; + + return temp; + } + + //************************************************************************* + /// operator ^= + //************************************************************************* + ETL_CONSTEXPR14 bitset& operator ^=(const bitset& other) + { + //ibitset.xor_equals(&buffer[0], &other.buffer[0], Number_Of_Elements); + + return *this; + } + + //************************************************************************* + /// operator ~ + //************************************************************************* + bitset operator ~() const + { + etl::bitset temp(*this); + + temp.flip(); + + return temp; + } + + //************************************************************************* + /// operator << + //************************************************************************* + ETL_CONSTEXPR14 bitset operator <<(size_t shift) const + { + etl::bitset temp(*this); + + temp <<= shift; + + return temp; + } + + //************************************************************************* + /// operator <<= + //************************************************************************* + ETL_CONSTEXPR14 bitset& operator <<=(size_t shift) + { + //if (shift >= Active_Bits) + //{ + // reset(); + //} + //else + //{ + // ibitset.shift_left_equals(buffer, Number_Of_Elements, Active_Bits, shift); + + // // Truncate any bits shifted to the left. + // clear_unused_bits_in_msb(); + //} + + return *this; + } + + //************************************************************************* + /// operator >> + //************************************************************************* + ETL_CONSTEXPR14 bitset operator >>(size_t shift) const + { + bitset temp(*this); + + temp >>= shift; + + return temp; + } + + //************************************************************************* + /// operator >>= + //************************************************************************* + ETL_CONSTEXPR14 bitset& operator >>=(size_t shift) + { + //if (shift >= Active_Bits) + //{ + // reset(); + //} + //else + //{ + // ibitset.shift_right_equals(buffer, Number_Of_Elements, Active_Bits, shift); + //} + + return *this; + } + + //************************************************************************* + /// operator == + //************************************************************************* + friend ETL_CONSTEXPR14 bool operator ==(const bitset& lhs, const bitset& rhs) + { + return (lhs.buffer == rhs.buffer); + } + + //************************************************************************* + /// swap + //************************************************************************* + ETL_CONSTEXPR14 void swap(etl::bitset& other) + { + element_type temp = *p1; + *p1 = *p2; + *p2 = temp; + } + + //************************************************************************* + /// span + /// Returns a span of the underlying buffer. + //************************************************************************* + ETL_CONSTEXPR14 span_type span() + { + return span_type(buffer, buffer + Number_Of_Elements); + } + + //************************************************************************* + /// span + /// Returns a const span of the underlying buffer. + //************************************************************************* + ETL_CONSTEXPR14 const_span_type span() const + { + return const_span_type(buffer, buffer + Number_Of_Elements); + } + + private: + + element_type buffer; + }; //*************************************************************************** /// operator & ///\ingroup bitset //*************************************************************************** - template - bitset operator & (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT + template + bitset operator & (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT { - bitset temp(lhs); + bitset temp(lhs); temp &= rhs; return temp; } @@ -1633,10 +2156,10 @@ namespace etl /// operator | ///\ingroup bitset //*************************************************************************** - template - bitset operator | (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT + template + bitset operator | (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT { - bitset temp(lhs); + bitset temp(lhs); temp |= rhs; return temp; } @@ -1645,10 +2168,10 @@ namespace etl /// operator ^ ///\ingroup bitset //*************************************************************************** - template - bitset operator ^ (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT + template + bitset operator ^ (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT { - bitset temp(lhs); + bitset temp(lhs); temp ^= rhs; return temp; } @@ -1657,8 +2180,8 @@ namespace etl /// operator != ///\ingroup bitset //*************************************************************************** - template - ETL_CONSTEXPR14 bool operator != (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 bool operator != (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT { return !(lhs == rhs); } @@ -1667,8 +2190,8 @@ namespace etl //************************************************************************* /// swap //************************************************************************* -template -ETL_CONSTEXPR14 void swap(etl::bitset& lhs, etl::bitset& rhs) ETL_NOEXCEPT +template +ETL_CONSTEXPR14 void swap(etl::bitset& lhs, etl::bitset& rhs) ETL_NOEXCEPT { lhs.swap(rhs); } diff --git a/test/test_bitset_new.cpp b/test/test_bitset_new.cpp index 76b8d0af..3caa1774 100644 --- a/test/test_bitset_new.cpp +++ b/test/test_bitset_new.cpp @@ -39,10 +39,10 @@ namespace using ull = unsigned long long; //************************************************************************* - template - constexpr etl::bitset generate_shift_left_bitset(ull value, size_t shift) + template + constexpr etl::bitset generate_shift_left_bitset(ull value, size_t shift) { - etl::bitset data(value); + etl::bitset data(value); if (shift != 0U) { @@ -53,11 +53,11 @@ namespace } //************************************************************************* - template - constexpr etl::bitset generate_shift_left_bitset_copy(ull value, size_t shift) + template + constexpr etl::bitset generate_shift_left_bitset_copy(ull value, size_t shift) { - etl::bitset data1(value); - etl::bitset data2; + etl::bitset data1(value); + etl::bitset data2; if (shift != 0U) { @@ -68,10 +68,10 @@ namespace } //************************************************************************* - template - constexpr etl::bitset generate_shift_right_bitset(ull value, size_t shift) + template + constexpr etl::bitset generate_shift_right_bitset(ull value, size_t shift) { - etl::bitset data(value); + etl::bitset data(value); if (shift != 0U) { @@ -82,11 +82,11 @@ namespace } //************************************************************************* - template - constexpr etl::bitset generate_shift_right_bitset_copy(ull value, size_t shift) + template + constexpr etl::bitset generate_shift_right_bitset_copy(ull value, size_t shift) { - etl::bitset data1(value); - etl::bitset data2; + etl::bitset data1(value); + etl::bitset data2; if (shift != 0U) { @@ -98,1573 +98,1585 @@ namespace SUITE(test_bitset_new) { - //************************************************************************* - TEST(test_default_constructor) - { - constexpr std::bitset<60> compare; - constexpr etl::bitset<60> data; - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - TEST(test_default_constructor_different_element_types) - { - constexpr etl::bitset<256, uint8_t> data8; - constexpr etl::bitset<256, uint16_t> data16; - constexpr etl::bitset<256, uint32_t> data32; - constexpr etl::bitset<256, uint64_t> data64; - - CHECK_EQUAL(32U, data8.Number_Of_Elements); - CHECK_EQUAL(16U, data16.Number_Of_Elements); - CHECK_EQUAL( 8U, data32.Number_Of_Elements); - CHECK_EQUAL( 4U, data64.Number_Of_Elements); - } - - //************************************************************************* - TEST(test_default_constructor_implicit_element_types) - { - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(16U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(16U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(16U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(16U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(16U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(16U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(16U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(16U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); - } - - //************************************************************************* - TEST(test_construct_from_value) - { - constexpr std::bitset<60> compare(0x123456731234567ULL); - constexpr etl::bitset<60> data(0x123456731234567ULL); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - TEST(test_copy_construct) - { - constexpr std::bitset<60> compare(0x123456731234567ULL); - constexpr etl::bitset<60> data(0x123456731234567ULL); - constexpr etl::bitset<60> data_copy(data); - - CHECK_EQUAL(compare.size(), data_copy.size()); - CHECK_EQUAL(compare.count(), data_copy.count()); - - for (size_t i = 0UL; i < data_copy.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data_copy.test(i)); - } - } - - //************************************************************************* - TEST(test_construct_from_excess_value) - { - constexpr std::bitset<60> compare(0x8765432187654321ULL); - constexpr etl::bitset<60> data(0x8765432187654321ULL); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - TEST(test_construct_from_char_string) - { - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data("110001001000110100010101100111001100010010001101000101011001"); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - TEST(test_construct_from_wchar_t_string) - { - std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data(L"110001001000110100010101100111001100010010001101000101011001"); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - TEST(test_construct_from_char16_t_string) - { - std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data(u"110001001000110100010101100111001100010010001101000101011001"); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - TEST(test_construct_from_char32_t_string) - { - std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data(U"110001001000110100010101100111001100010010001101000101011001"); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - TEST(test_construct_from_excess_string) - { - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001111100001"); - etl::bitset<60> data("110001001000110100010101100111001100010010001101000101011001111100001"); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - constexpr etl::bitset<60> test_set_helper() - { - etl::bitset<60> data; - data.set(); - - return data; - } - - TEST(test_set) - { - std::bitset<60> compare; - constexpr etl::bitset<60> data(test_set_helper()); - - compare.set(); - - constexpr auto size = data.size(); - constexpr auto count = data.count(); - constexpr auto none = data.none(); - constexpr auto any = data.any(); - constexpr 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_char_string_set) - { - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data; - - data.set("110001001000110100010101100111001100010010001101000101011001"); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - TEST(test_wchar_t_string_set) - { - std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data; - - data.set(L"110001001000110100010101100111001100010010001101000101011001"); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - TEST(test_char16_t_string_set) - { - std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data; - - data.set(u"110001001000110100010101100111001100010010001101000101011001"); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - TEST(test_char32_t_string_set) - { - std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data; - - data.set(U"110001001000110100010101100111001100010010001101000101011001"); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - TEST(test_from_char_string) - { - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data; - - data.from_string("110001001000110100010101100111001100010010001101000101011001"); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - TEST(test_from_wchar_t_string) - { - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data; - - data.from_string(L"110001001000110100010101100111001100010010001101000101011001"); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + ////************************************************************************* + //TEST(test_default_constructor) + //{ + // constexpr std::bitset<60> compare; + // constexpr etl::bitset<60> data; - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - TEST(test_from_char16_t_6string) - { - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data; - - data.from_string(u"110001001000110100010101100111001100010010001101000101011001"); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - TEST(test_from_char32_t_string) - { - std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<60> data; - - data.from_string(U"110001001000110100010101100111001100010010001101000101011001"); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); - //************************************************************************* - TEST(test_value_u8_min) - { - constexpr etl::bitset<8> data((unsigned long long)etl::integral_limits::min); - constexpr uint8_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::min(), value); - } - - //************************************************************************* - TEST(test_value_u8_max) - { - constexpr etl::bitset<8> data((unsigned long long)etl::integral_limits::max); - constexpr uint8_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::max(), value); - } - - //************************************************************************* - TEST(test_value_s8_min) - { - constexpr etl::bitset<8> data((unsigned long long)etl::integral_limits::min); - constexpr int8_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::min(), value); - } + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} //************************************************************************* - TEST(test_value_s8_max) + TEST(test_default_constructor_single_element_no_mask) { - constexpr etl::bitset<8> data((unsigned long long)etl::integral_limits::max); - constexpr int8_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::max(), value); - } - - //************************************************************************* - TEST(test_value_u16_min) - { - constexpr etl::bitset<16> data((unsigned long long)etl::integral_limits::min); - constexpr uint16_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::min(), value); - } - - //************************************************************************* - TEST(test_value_u16_max) - { - constexpr etl::bitset<16> data((unsigned long long)etl::integral_limits::max); - constexpr uint16_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::max(), value); - } - - //************************************************************************* - TEST(test_value_s16_min) - { - constexpr etl::bitset<16> data((unsigned long long)etl::integral_limits::min); - constexpr int16_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::min(), value); - } - - //************************************************************************* - TEST(test_value_s16_max) - { - etl::bitset<16> data((unsigned long long)etl::integral_limits::max); - int16_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::max(), value); - } - - //************************************************************************* - TEST(test_value_u32_min) - { - constexpr etl::bitset<32> data((unsigned long long)etl::integral_limits::min); - constexpr uint32_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::min(), value); - } - - //************************************************************************* - TEST(test_value_u32_max) - { - constexpr etl::bitset<32> data((unsigned long long)etl::integral_limits::max); - constexpr uint32_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::max(), value); - } - - //************************************************************************* - TEST(test_value_s32_min) - { - constexpr etl::bitset<32> data((unsigned long long)etl::integral_limits::min); - constexpr int32_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::min(), value); - } - - //************************************************************************* - TEST(test_value_s32_max) - { - constexpr etl::bitset<32> data((unsigned long long)etl::integral_limits::max); - constexpr int32_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::max(), value); - } - - //************************************************************************* - TEST(test_value_u64_min) - { - constexpr etl::bitset<64> data((unsigned long long)etl::integral_limits::min); - constexpr uint64_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::min(), value); - } - - //************************************************************************* - TEST(test_value_u64_max) - { - constexpr etl::bitset<64> data((unsigned long long)etl::integral_limits::max); - constexpr uint64_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::max(), value); - } - - //************************************************************************* - TEST(test_value_s64_min) - { - constexpr etl::bitset<64> data((unsigned long long)etl::integral_limits::min); - constexpr int64_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::min(), value); - } - - //************************************************************************* - TEST(test_value_s64_max) - { - constexpr etl::bitset<64> data((unsigned long long)etl::integral_limits::max); - constexpr int64_t value = data.value(); - - CHECK_EQUAL(std::numeric_limits::max(), value); - } - - //************************************************************************* - TEST(test_using_element_type_int8_t) - { - std::bitset<60> compare(ull(0x0C48D159CC48D159)); - etl::bitset<60, int8_t> data(ull(0x0C48D159CC48D159)); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - - CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong()); - } - - //************************************************************************* - TEST(test_using_element_type_int16_t) - { - std::bitset<60> compare(ull(0x0C48D159CC48D159)); - etl::bitset<60, int16_t> data(ull(0x0C48D159CC48D159)); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - - CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong()); - } - - //************************************************************************* - TEST(test_using_element_type_int32_t) - { - std::bitset<60> compare(ull(0x0C48D159CC48D159)); - etl::bitset<60, int32_t> data(ull(0x0C48D159CC48D159)); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - - CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong()); - } - - //************************************************************************* - TEST(test_using_element_type_int64_t) - { - std::bitset<60> compare(ull(0x0C48D159CC48D159)); - etl::bitset<60, int64_t> data(ull(0x0C48D159CC48D159)); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - - CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong()); - } - - //************************************************************************* - TEST(test_position_set) - { - std::bitset<60> compare; - etl::bitset<60> data; - - for (size_t i = 0UL; i < data.size(); ++i) - { - compare.set(i, (i % 2) == 0); - data.set(i, (i % 2) == 0); - } - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - constexpr etl::bitset<60> test_reset_helper() - { - etl::bitset<60> data(0xFFFFFFFFFFFFFFFULL); - data.reset(); - - return data; - } - - TEST(test_reset) - { - std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL); - constexpr etl::bitset<60> data(test_reset_helper()); - - compare.reset(); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - constexpr etl::bitset<60> test_position_reset_helper() - { - etl::bitset<60> data(0xFFFFFFFFFFFFFFFULL); - data.reset(1); - data.reset(3); - data.reset(7); - data.reset(13); - - return data; - } - - TEST(test_position_reset) - { - std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL); - constexpr etl::bitset<60> data(test_position_reset_helper()); - - compare.reset(1); - compare.reset(3); - compare.reset(7); - compare.reset(13); - - CHECK_EQUAL(compare.size(), data.size()); - CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - TEST(test_index_operator_read) - { - constexpr std::bitset<60> compare(0x3123456731234567ULL); - constexpr etl::bitset<60> data(0x3123456731234567ULL); - - constexpr bool bc0 = compare[1U]; - constexpr bool bd0 = data[1U]; - CHECK_EQUAL(bc0, bd0); - - constexpr bool bc3 = compare[3U]; - constexpr bool bd3 = data[3U]; - CHECK_EQUAL(bc3, bd3); - - constexpr bool bc7 = compare[7U]; - constexpr bool bd7 = data[7U]; - CHECK_EQUAL(bc7, bd7); - - constexpr bool bc13 = compare[13U]; - constexpr bool bd13 = data[13U]; - CHECK_EQUAL(bc7, bd7); - } - - //************************************************************************* - constexpr etl::bitset<60> test_index_operator_write_helper() - { - etl::bitset<60> data; - - data[1U] = true; - data[3U] = true; - data[7U] = true; - data[13U] = true; - - return data; - } - - TEST(test_index_operator_write) - { - constexpr etl::bitset<60> data(test_index_operator_write_helper()); - - CHECK(data[1U]); - CHECK(data[3U]); - CHECK(data[7U]); - CHECK(data[13U]); - } - - //************************************************************************* - TEST(test_any) - { - constexpr etl::bitset<60> data1(ull(0x0000000000000000)); - constexpr etl::bitset<60> data2(ull(0x0000010000000000)); - constexpr etl::bitset<60> data3(ull(0x0000010001000100)); - constexpr etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF)); - - constexpr bool bd1 = data1.any(); - constexpr bool bd2 = data2.any(); - constexpr bool bd3 = data3.any(); - constexpr bool bd4 = data4.any(); - - CHECK_FALSE(bd1); - CHECK_TRUE(bd2); - CHECK_TRUE(bd3); - CHECK_TRUE(bd4); - } - - //************************************************************************* - TEST(test_none) - { - constexpr etl::bitset<60> data1(ull(0x0000000000000000)); - constexpr etl::bitset<60> data2(ull(0x0000010000000000)); - constexpr etl::bitset<60> data3(ull(0x0000010001000100)); - constexpr etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF)); - - constexpr bool bd1 = data1.none(); - constexpr bool bd2 = data2.none(); - constexpr bool bd3 = data3.none(); - constexpr bool bd4 = data4.none(); - - CHECK_TRUE(bd1); - CHECK_FALSE(bd2); - CHECK_FALSE(bd3); - CHECK_FALSE(bd4); - } - - //************************************************************************* - TEST(test_all) - { - constexpr etl::bitset<60> data1(ull(0x0000000000000000)); - constexpr etl::bitset<60> data2(ull(0x0000010000000000)); - constexpr etl::bitset<60> data3(ull(0x0000010001000100)); - constexpr etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF)); - - constexpr bool bd1 = data1.all(); - constexpr bool bd2 = data2.all(); - constexpr bool bd3 = data3.all(); - constexpr bool bd4 = data4.all(); - - CHECK_FALSE(bd1); - CHECK_FALSE(bd2); - CHECK_FALSE(bd3); - CHECK_TRUE(bd4); - } - - //************************************************************************* - constexpr etl::bitset<60> test_flip_helper() - { - etl::bitset<60> data; - data.flip(); - - return data; - } - - TEST(test_flip) - { - std::bitset<60> compare; - constexpr etl::bitset<60> data(test_flip_helper()); - - compare.flip(); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - constexpr etl::bitset<60> test_flip_position_helper() - { - etl::bitset<60> data; - data.flip(1); - data.flip(3); - data.flip(7); - data.flip(13); - - return data; - } - - TEST(test_flip_position) - { - std::bitset<60> compare; - constexpr etl::bitset<60> data(test_flip_position_helper()); - - compare.flip(1); - compare.flip(3); - compare.flip(7); - compare.flip(13); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - constexpr etl::bitset<60> test_flip_reference_helper() - { - etl::bitset<60> data; - data[1].flip(); - data[3].flip(); - data[7].flip(); - data[13].flip(); - - return data; - } - - TEST(test_flip_reference) - { - std::bitset<60> compare; - constexpr etl::bitset<60> data(test_flip_reference_helper()); - - compare[1].flip(); - compare[3].flip(); - compare[7].flip(); - compare[13].flip(); - - for (size_t i = 0UL; i < data.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data.test(i)); - } - } - - //************************************************************************* - TEST(test_invert_reference) - { - std::bitset<60> compare; - etl::bitset<60> data; - - bool bc = ~compare[3]; - bool bd = ~data[3]; - CHECK_EQUAL(bc, bd); - } - - //************************************************************************* - constexpr etl::bitset<60> test_assignment_operator_helper(etl::bitset<60> to, const etl::bitset<60>& from) - { - to = from; - - return to; - } - - TEST(test_assignment_operator) - { - constexpr std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL); - constexpr etl::bitset<60> data1(0xFFFFFFFFFFFFFFFULL); - constexpr etl::bitset<60> data2(test_assignment_operator_helper(etl::bitset<60>(), data1)); - - for (size_t i = 0UL; i < data2.size(); ++i) - { - CHECK_EQUAL(compare.test(i), data2.test(i)); - } - } - - //************************************************************************* - TEST(test_equality_operator) - { - constexpr etl::bitset<60> data1(0x123456781234567ULL); - constexpr etl::bitset<60> data2(0x123456781234567ULL); - constexpr etl::bitset<60> data3; - - constexpr bool equal = (data1 == data2); - constexpr bool not_equal = !(data1 == data3); - - CHECK(equal); - CHECK(not_equal); - } - - //************************************************************************* - TEST(test_inequality_operator) - { - constexpr etl::bitset<60> data1(0x123456781234567ULL); - constexpr etl::bitset<60> data2(0x123456781234567ULL); - constexpr etl::bitset<60> data3; - - constexpr bool equal = !(data1 != data2); - constexpr bool not_equal = (data1 != data3); - - CHECK(!(data1 != data2)); - CHECK(data1 != data3); - } - - //************************************************************************* - TEST(test_shift_left_operator) - { - constexpr etl::bitset<60> shift1(0x2468ACF0ULL); - constexpr etl::bitset<60> shift2(0x48D159E0ULL); - constexpr etl::bitset<60> shift11(0x91A2B3C000ULL); - - CHECK(generate_shift_left_bitset<60>(0x12345678ULL, 1U) == shift1); - CHECK(generate_shift_left_bitset<60>(0x12345678ULL, 2U) == shift2); - CHECK(generate_shift_left_bitset<60>(0x12345678ULL, 11U) == shift11); - } - - //************************************************************************* - TEST(test_shift_left_operator_overflow) - { - constexpr etl::bitset<31> data(generate_shift_left_bitset<31>(0x7FFFFFFFULL, 1U)); - constexpr etl::bitset<31> shifted(0x7FFFFFFEUL); - - CHECK(data == shifted); - } - - //************************************************************************* - TEST(test_shift_left_copy_operator) - { - constexpr etl::bitset<60> shift8(0x1234567800ULL); - CHECK_EQUAL_HEX(shift8.value(), generate_shift_left_bitset_copy<60>(0x12345678UL, 8U).value()); - - constexpr etl::bitset<60> shift16(0x123456780000ULL); - CHECK_EQUAL_HEX(shift16.value(), generate_shift_left_bitset_copy<60>(0x12345678UL, 16U).value()); - - constexpr etl::bitset<60> shift24(0x12345678000000ULL); - CHECK_EQUAL_HEX(shift24.value(), generate_shift_left_bitset_copy<60>(0x12345678UL, 24U).value()); - - constexpr etl::bitset<60> shift60(0x0000000000000000ULL); - CHECK_EQUAL_HEX(shift60.value(), generate_shift_left_bitset_copy<60>(0x12345678UL, 60U).value()); - } - - //************************************************************************* - TEST(test_shift_left_operator_all_shifts_full_size) - { - uint64_t value = 0x0123456789ABCDEFULL; - - CHECK_EQUAL_HEX((value << 0U), (generate_shift_left_bitset<64>(value, 0U).value())); - CHECK_EQUAL_HEX((value << 1U), (generate_shift_left_bitset<64>(value, 1U).value())); - CHECK_EQUAL_HEX((value << 2U), (generate_shift_left_bitset<64>(value, 2U).value())); - CHECK_EQUAL_HEX((value << 3U), (generate_shift_left_bitset<64>(value, 3U).value())); - CHECK_EQUAL_HEX((value << 4U), (generate_shift_left_bitset<64>(value, 4U).value())); - CHECK_EQUAL_HEX((value << 5U), (generate_shift_left_bitset<64>(value, 5U).value())); - CHECK_EQUAL_HEX((value << 6U), (generate_shift_left_bitset<64>(value, 6U).value())); - CHECK_EQUAL_HEX((value << 7U), (generate_shift_left_bitset<64>(value, 7U).value())); - CHECK_EQUAL_HEX((value << 8U), (generate_shift_left_bitset<64>(value, 8U).value())); - CHECK_EQUAL_HEX((value << 9U), (generate_shift_left_bitset<64>(value, 9U).value())); - CHECK_EQUAL_HEX((value << 10U), (generate_shift_left_bitset<64>(value, 10U).value())); - CHECK_EQUAL_HEX((value << 11U), (generate_shift_left_bitset<64>(value, 11U).value())); - CHECK_EQUAL_HEX((value << 12U), (generate_shift_left_bitset<64>(value, 12U).value())); - CHECK_EQUAL_HEX((value << 13U), (generate_shift_left_bitset<64>(value, 13U).value())); - CHECK_EQUAL_HEX((value << 14U), (generate_shift_left_bitset<64>(value, 14U).value())); - CHECK_EQUAL_HEX((value << 15U), (generate_shift_left_bitset<64>(value, 15U).value())); - CHECK_EQUAL_HEX((value << 16U), (generate_shift_left_bitset<64>(value, 16U).value())); - CHECK_EQUAL_HEX((value << 17U), (generate_shift_left_bitset<64>(value, 17U).value())); - CHECK_EQUAL_HEX((value << 18U), (generate_shift_left_bitset<64>(value, 18U).value())); - CHECK_EQUAL_HEX((value << 19U), (generate_shift_left_bitset<64>(value, 19U).value())); - CHECK_EQUAL_HEX((value << 20U), (generate_shift_left_bitset<64>(value, 20U).value())); - CHECK_EQUAL_HEX((value << 21U), (generate_shift_left_bitset<64>(value, 21U).value())); - CHECK_EQUAL_HEX((value << 22U), (generate_shift_left_bitset<64>(value, 22U).value())); - CHECK_EQUAL_HEX((value << 23U), (generate_shift_left_bitset<64>(value, 23U).value())); - CHECK_EQUAL_HEX((value << 24U), (generate_shift_left_bitset<64>(value, 24U).value())); - CHECK_EQUAL_HEX((value << 25U), (generate_shift_left_bitset<64>(value, 25U).value())); - CHECK_EQUAL_HEX((value << 26U), (generate_shift_left_bitset<64>(value, 26U).value())); - CHECK_EQUAL_HEX((value << 27U), (generate_shift_left_bitset<64>(value, 27U).value())); - CHECK_EQUAL_HEX((value << 28U), (generate_shift_left_bitset<64>(value, 28U).value())); - CHECK_EQUAL_HEX((value << 29U), (generate_shift_left_bitset<64>(value, 29U).value())); - CHECK_EQUAL_HEX((value << 30U), (generate_shift_left_bitset<64>(value, 30U).value())); - CHECK_EQUAL_HEX((value << 31U), (generate_shift_left_bitset<64>(value, 31U).value())); - CHECK_EQUAL_HEX((value << 32U), (generate_shift_left_bitset<64>(value, 32U).value())); - CHECK_EQUAL_HEX((value << 33U), (generate_shift_left_bitset<64>(value, 33U).value())); - CHECK_EQUAL_HEX((value << 34U), (generate_shift_left_bitset<64>(value, 34U).value())); - CHECK_EQUAL_HEX((value << 35U), (generate_shift_left_bitset<64>(value, 35U).value())); - CHECK_EQUAL_HEX((value << 36U), (generate_shift_left_bitset<64>(value, 36U).value())); - CHECK_EQUAL_HEX((value << 37U), (generate_shift_left_bitset<64>(value, 37U).value())); - CHECK_EQUAL_HEX((value << 38U), (generate_shift_left_bitset<64>(value, 38U).value())); - CHECK_EQUAL_HEX((value << 39U), (generate_shift_left_bitset<64>(value, 39U).value())); - CHECK_EQUAL_HEX((value << 40U), (generate_shift_left_bitset<64>(value, 40U).value())); - CHECK_EQUAL_HEX((value << 41U), (generate_shift_left_bitset<64>(value, 41U).value())); - CHECK_EQUAL_HEX((value << 42U), (generate_shift_left_bitset<64>(value, 42U).value())); - CHECK_EQUAL_HEX((value << 43U), (generate_shift_left_bitset<64>(value, 43U).value())); - CHECK_EQUAL_HEX((value << 44U), (generate_shift_left_bitset<64>(value, 44U).value())); - CHECK_EQUAL_HEX((value << 45U), (generate_shift_left_bitset<64>(value, 45U).value())); - CHECK_EQUAL_HEX((value << 46U), (generate_shift_left_bitset<64>(value, 46U).value())); - CHECK_EQUAL_HEX((value << 47U), (generate_shift_left_bitset<64>(value, 47U).value())); - CHECK_EQUAL_HEX((value << 48U), (generate_shift_left_bitset<64>(value, 48U).value())); - CHECK_EQUAL_HEX((value << 49U), (generate_shift_left_bitset<64>(value, 49U).value())); - CHECK_EQUAL_HEX((value << 50U), (generate_shift_left_bitset<64>(value, 50U).value())); - CHECK_EQUAL_HEX((value << 51U), (generate_shift_left_bitset<64>(value, 51U).value())); - CHECK_EQUAL_HEX((value << 52U), (generate_shift_left_bitset<64>(value, 52U).value())); - CHECK_EQUAL_HEX((value << 53U), (generate_shift_left_bitset<64>(value, 53U).value())); - CHECK_EQUAL_HEX((value << 54U), (generate_shift_left_bitset<64>(value, 54U).value())); - CHECK_EQUAL_HEX((value << 55U), (generate_shift_left_bitset<64>(value, 55U).value())); - CHECK_EQUAL_HEX((value << 56U), (generate_shift_left_bitset<64>(value, 56U).value())); - CHECK_EQUAL_HEX((value << 57U), (generate_shift_left_bitset<64>(value, 57U).value())); - CHECK_EQUAL_HEX((value << 58U), (generate_shift_left_bitset<64>(value, 58U).value())); - CHECK_EQUAL_HEX((value << 59U), (generate_shift_left_bitset<64>(value, 59U).value())); - CHECK_EQUAL_HEX((value << 60U), (generate_shift_left_bitset<64>(value, 60U).value())); - CHECK_EQUAL_HEX((value << 61U), (generate_shift_left_bitset<64>(value, 61U).value())); - CHECK_EQUAL_HEX((value << 62U), (generate_shift_left_bitset<64>(value, 62U).value())); - CHECK_EQUAL_HEX((value << 63U), (generate_shift_left_bitset<64>(value, 63U).value())); - CHECK_EQUAL_HEX(0ULL, (generate_shift_left_bitset<64>(value, 64U).value())); - } - - //************************************************************************* - TEST(test_shift_left_operator_all_shifts_partial_size) - { - uint64_t value = 0x0123456789ABCDEFULL; - uint64_t mask = 0x0FFFFFFFFFFFFFFFULL; - - CHECK_EQUAL_HEX((value << 0U) & mask, (generate_shift_left_bitset<60>(value, 0U).value())); - CHECK_EQUAL_HEX((value << 1U) & mask, (generate_shift_left_bitset<60>(value, 1U).value())); - CHECK_EQUAL_HEX((value << 2U) & mask, (generate_shift_left_bitset<60>(value, 2U).value())); - CHECK_EQUAL_HEX((value << 3U) & mask, (generate_shift_left_bitset<60>(value, 3U).value())); - CHECK_EQUAL_HEX((value << 4U) & mask, (generate_shift_left_bitset<60>(value, 4U).value())); - CHECK_EQUAL_HEX((value << 5U) & mask, (generate_shift_left_bitset<60>(value, 5U).value())); - CHECK_EQUAL_HEX((value << 6U) & mask, (generate_shift_left_bitset<60>(value, 6U).value())); - CHECK_EQUAL_HEX((value << 7U) & mask, (generate_shift_left_bitset<60>(value, 7U).value())); - CHECK_EQUAL_HEX((value << 8U) & mask, (generate_shift_left_bitset<60>(value, 8U).value())); - CHECK_EQUAL_HEX((value << 9U) & mask, (generate_shift_left_bitset<60>(value, 9U).value())); - CHECK_EQUAL_HEX((value << 10U) & mask, (generate_shift_left_bitset<60>(value, 10U).value())); - CHECK_EQUAL_HEX((value << 11U) & mask, (generate_shift_left_bitset<60>(value, 11U).value())); - CHECK_EQUAL_HEX((value << 12U) & mask, (generate_shift_left_bitset<60>(value, 12U).value())); - CHECK_EQUAL_HEX((value << 13U) & mask, (generate_shift_left_bitset<60>(value, 13U).value())); - CHECK_EQUAL_HEX((value << 14U) & mask, (generate_shift_left_bitset<60>(value, 14U).value())); - CHECK_EQUAL_HEX((value << 15U) & mask, (generate_shift_left_bitset<60>(value, 15U).value())); - CHECK_EQUAL_HEX((value << 16U) & mask, (generate_shift_left_bitset<60>(value, 16U).value())); - CHECK_EQUAL_HEX((value << 17U) & mask, (generate_shift_left_bitset<60>(value, 17U).value())); - CHECK_EQUAL_HEX((value << 18U) & mask, (generate_shift_left_bitset<60>(value, 18U).value())); - CHECK_EQUAL_HEX((value << 19U) & mask, (generate_shift_left_bitset<60>(value, 19U).value())); - CHECK_EQUAL_HEX((value << 20U) & mask, (generate_shift_left_bitset<60>(value, 20U).value())); - CHECK_EQUAL_HEX((value << 21U) & mask, (generate_shift_left_bitset<60>(value, 21U).value())); - CHECK_EQUAL_HEX((value << 22U) & mask, (generate_shift_left_bitset<60>(value, 22U).value())); - CHECK_EQUAL_HEX((value << 23U) & mask, (generate_shift_left_bitset<60>(value, 23U).value())); - CHECK_EQUAL_HEX((value << 24U) & mask, (generate_shift_left_bitset<60>(value, 24U).value())); - CHECK_EQUAL_HEX((value << 25U) & mask, (generate_shift_left_bitset<60>(value, 25U).value())); - CHECK_EQUAL_HEX((value << 26U) & mask, (generate_shift_left_bitset<60>(value, 26U).value())); - CHECK_EQUAL_HEX((value << 27U) & mask, (generate_shift_left_bitset<60>(value, 27U).value())); - CHECK_EQUAL_HEX((value << 28U) & mask, (generate_shift_left_bitset<60>(value, 28U).value())); - CHECK_EQUAL_HEX((value << 29U) & mask, (generate_shift_left_bitset<60>(value, 29U).value())); - CHECK_EQUAL_HEX((value << 30U) & mask, (generate_shift_left_bitset<60>(value, 30U).value())); - CHECK_EQUAL_HEX((value << 31U) & mask, (generate_shift_left_bitset<60>(value, 31U).value())); - CHECK_EQUAL_HEX((value << 32U) & mask, (generate_shift_left_bitset<60>(value, 32U).value())); - CHECK_EQUAL_HEX((value << 33U) & mask, (generate_shift_left_bitset<60>(value, 33U).value())); - CHECK_EQUAL_HEX((value << 34U) & mask, (generate_shift_left_bitset<60>(value, 34U).value())); - CHECK_EQUAL_HEX((value << 35U) & mask, (generate_shift_left_bitset<60>(value, 35U).value())); - CHECK_EQUAL_HEX((value << 36U) & mask, (generate_shift_left_bitset<60>(value, 36U).value())); - CHECK_EQUAL_HEX((value << 37U) & mask, (generate_shift_left_bitset<60>(value, 37U).value())); - CHECK_EQUAL_HEX((value << 38U) & mask, (generate_shift_left_bitset<60>(value, 38U).value())); - CHECK_EQUAL_HEX((value << 39U) & mask, (generate_shift_left_bitset<60>(value, 39U).value())); - CHECK_EQUAL_HEX((value << 40U) & mask, (generate_shift_left_bitset<60>(value, 40U).value())); - CHECK_EQUAL_HEX((value << 41U) & mask, (generate_shift_left_bitset<60>(value, 41U).value())); - CHECK_EQUAL_HEX((value << 42U) & mask, (generate_shift_left_bitset<60>(value, 42U).value())); - CHECK_EQUAL_HEX((value << 43U) & mask, (generate_shift_left_bitset<60>(value, 43U).value())); - CHECK_EQUAL_HEX((value << 44U) & mask, (generate_shift_left_bitset<60>(value, 44U).value())); - CHECK_EQUAL_HEX((value << 45U) & mask, (generate_shift_left_bitset<60>(value, 45U).value())); - CHECK_EQUAL_HEX((value << 46U) & mask, (generate_shift_left_bitset<60>(value, 46U).value())); - CHECK_EQUAL_HEX((value << 47U) & mask, (generate_shift_left_bitset<60>(value, 47U).value())); - CHECK_EQUAL_HEX((value << 48U) & mask, (generate_shift_left_bitset<60>(value, 48U).value())); - CHECK_EQUAL_HEX((value << 49U) & mask, (generate_shift_left_bitset<60>(value, 49U).value())); - CHECK_EQUAL_HEX((value << 50U) & mask, (generate_shift_left_bitset<60>(value, 50U).value())); - CHECK_EQUAL_HEX((value << 51U) & mask, (generate_shift_left_bitset<60>(value, 51U).value())); - CHECK_EQUAL_HEX((value << 52U) & mask, (generate_shift_left_bitset<60>(value, 52U).value())); - CHECK_EQUAL_HEX((value << 53U) & mask, (generate_shift_left_bitset<60>(value, 53U).value())); - CHECK_EQUAL_HEX((value << 54U) & mask, (generate_shift_left_bitset<60>(value, 54U).value())); - CHECK_EQUAL_HEX((value << 55U) & mask, (generate_shift_left_bitset<60>(value, 55U).value())); - CHECK_EQUAL_HEX((value << 56U) & mask, (generate_shift_left_bitset<60>(value, 56U).value())); - CHECK_EQUAL_HEX((value << 57U) & mask, (generate_shift_left_bitset<60>(value, 57U).value())); - CHECK_EQUAL_HEX((value << 58U) & mask, (generate_shift_left_bitset<60>(value, 58U).value())); - CHECK_EQUAL_HEX((value << 59U) & mask, (generate_shift_left_bitset<60>(value, 59U).value())); - CHECK_EQUAL_HEX((value << 60U) & mask, (generate_shift_left_bitset<60>(value, 60U).value())); - CHECK_EQUAL_HEX((value << 61U) & mask, (generate_shift_left_bitset<60>(value, 61U).value())); - CHECK_EQUAL_HEX((value << 62U) & mask, (generate_shift_left_bitset<60>(value, 62U).value())); - CHECK_EQUAL_HEX((value << 63U) & mask, (generate_shift_left_bitset<60>(value, 63U).value())); - CHECK_EQUAL_HEX(0ULL, (generate_shift_left_bitset<60>(value, 64U).value())); - } - - //************************************************************************* - TEST(test_shift_right_operator) - { - constexpr etl::bitset<60> shift1(0x91A2B3CULL); - constexpr etl::bitset<60> shift2(0x48D159EULL); - constexpr etl::bitset<60> shift11(0x2468AULL); - - CHECK(generate_shift_right_bitset<60>(0x12345678ULL, 1U) == shift1); - CHECK(generate_shift_right_bitset<60>(0x12345678ULL, 2U) == shift2); - CHECK(generate_shift_right_bitset<60>(0x12345678ULL, 11U) == shift11); - } - - //************************************************************************* - TEST(test_shift_right_copy_operator) - { - constexpr etl::bitset<60> shift8(0x123456ULL); - CHECK_EQUAL_HEX(shift8.value(), generate_shift_right_bitset_copy<60>(0x12345678UL, 8U).value()); - - constexpr etl::bitset<60> shift16(0x1234ULL); - CHECK_EQUAL_HEX(shift16.value(), generate_shift_right_bitset_copy<60>(0x12345678UL, 16U).value()); - - constexpr etl::bitset<60> shift24(0x12ULL); - CHECK_EQUAL_HEX(shift24.value(), generate_shift_right_bitset_copy<60>(0x12345678UL, 24U).value()); - - constexpr etl::bitset<60> shift60(0x00ULL); - CHECK_EQUAL_HEX(shift60.value(), generate_shift_right_bitset_copy<60>(0x12345678UL, 60U).value()); - } - - //************************************************************************* - TEST(test_shift_right_operator_all_shifts_full_size) - { - uint64_t value = 0x0123456789ABCDEFULL; - - CHECK_EQUAL_HEX((value >> 0U), (generate_shift_right_bitset<64>(value, 0U).value())); - CHECK_EQUAL_HEX((value >> 1U), (generate_shift_right_bitset<64>(value, 1U).value())); - CHECK_EQUAL_HEX((value >> 2U), (generate_shift_right_bitset<64>(value, 2U).value())); - CHECK_EQUAL_HEX((value >> 3U), (generate_shift_right_bitset<64>(value, 3U).value())); - CHECK_EQUAL_HEX((value >> 4U), (generate_shift_right_bitset<64>(value, 4U).value())); - CHECK_EQUAL_HEX((value >> 5U), (generate_shift_right_bitset<64>(value, 5U).value())); - CHECK_EQUAL_HEX((value >> 6U), (generate_shift_right_bitset<64>(value, 6U).value())); - CHECK_EQUAL_HEX((value >> 7U), (generate_shift_right_bitset<64>(value, 7U).value())); - CHECK_EQUAL_HEX((value >> 8U), (generate_shift_right_bitset<64>(value, 8U).value())); - CHECK_EQUAL_HEX((value >> 9U), (generate_shift_right_bitset<64>(value, 9U).value())); - CHECK_EQUAL_HEX((value >> 10U), (generate_shift_right_bitset<64>(value, 10U).value())); - CHECK_EQUAL_HEX((value >> 11U), (generate_shift_right_bitset<64>(value, 11U).value())); - CHECK_EQUAL_HEX((value >> 12U), (generate_shift_right_bitset<64>(value, 12U).value())); - CHECK_EQUAL_HEX((value >> 13U), (generate_shift_right_bitset<64>(value, 13U).value())); - CHECK_EQUAL_HEX((value >> 14U), (generate_shift_right_bitset<64>(value, 14U).value())); - CHECK_EQUAL_HEX((value >> 15U), (generate_shift_right_bitset<64>(value, 15U).value())); - CHECK_EQUAL_HEX((value >> 16U), (generate_shift_right_bitset<64>(value, 16U).value())); - CHECK_EQUAL_HEX((value >> 17U), (generate_shift_right_bitset<64>(value, 17U).value())); - CHECK_EQUAL_HEX((value >> 18U), (generate_shift_right_bitset<64>(value, 18U).value())); - CHECK_EQUAL_HEX((value >> 19U), (generate_shift_right_bitset<64>(value, 19U).value())); - CHECK_EQUAL_HEX((value >> 20U), (generate_shift_right_bitset<64>(value, 20U).value())); - CHECK_EQUAL_HEX((value >> 21U), (generate_shift_right_bitset<64>(value, 21U).value())); - CHECK_EQUAL_HEX((value >> 22U), (generate_shift_right_bitset<64>(value, 22U).value())); - CHECK_EQUAL_HEX((value >> 23U), (generate_shift_right_bitset<64>(value, 23U).value())); - CHECK_EQUAL_HEX((value >> 24U), (generate_shift_right_bitset<64>(value, 24U).value())); - CHECK_EQUAL_HEX((value >> 25U), (generate_shift_right_bitset<64>(value, 25U).value())); - CHECK_EQUAL_HEX((value >> 26U), (generate_shift_right_bitset<64>(value, 26U).value())); - CHECK_EQUAL_HEX((value >> 27U), (generate_shift_right_bitset<64>(value, 27U).value())); - CHECK_EQUAL_HEX((value >> 28U), (generate_shift_right_bitset<64>(value, 28U).value())); - CHECK_EQUAL_HEX((value >> 29U), (generate_shift_right_bitset<64>(value, 29U).value())); - CHECK_EQUAL_HEX((value >> 30U), (generate_shift_right_bitset<64>(value, 30U).value())); - CHECK_EQUAL_HEX((value >> 31U), (generate_shift_right_bitset<64>(value, 31U).value())); - CHECK_EQUAL_HEX((value >> 32U), (generate_shift_right_bitset<64>(value, 32U).value())); - CHECK_EQUAL_HEX((value >> 33U), (generate_shift_right_bitset<64>(value, 33U).value())); - CHECK_EQUAL_HEX((value >> 34U), (generate_shift_right_bitset<64>(value, 34U).value())); - CHECK_EQUAL_HEX((value >> 35U), (generate_shift_right_bitset<64>(value, 35U).value())); - CHECK_EQUAL_HEX((value >> 36U), (generate_shift_right_bitset<64>(value, 36U).value())); - CHECK_EQUAL_HEX((value >> 37U), (generate_shift_right_bitset<64>(value, 37U).value())); - CHECK_EQUAL_HEX((value >> 38U), (generate_shift_right_bitset<64>(value, 38U).value())); - CHECK_EQUAL_HEX((value >> 39U), (generate_shift_right_bitset<64>(value, 39U).value())); - CHECK_EQUAL_HEX((value >> 40U), (generate_shift_right_bitset<64>(value, 40U).value())); - CHECK_EQUAL_HEX((value >> 41U), (generate_shift_right_bitset<64>(value, 41U).value())); - CHECK_EQUAL_HEX((value >> 42U), (generate_shift_right_bitset<64>(value, 42U).value())); - CHECK_EQUAL_HEX((value >> 43U), (generate_shift_right_bitset<64>(value, 43U).value())); - CHECK_EQUAL_HEX((value >> 44U), (generate_shift_right_bitset<64>(value, 44U).value())); - CHECK_EQUAL_HEX((value >> 45U), (generate_shift_right_bitset<64>(value, 45U).value())); - CHECK_EQUAL_HEX((value >> 46U), (generate_shift_right_bitset<64>(value, 46U).value())); - CHECK_EQUAL_HEX((value >> 47U), (generate_shift_right_bitset<64>(value, 47U).value())); - CHECK_EQUAL_HEX((value >> 48U), (generate_shift_right_bitset<64>(value, 48U).value())); - CHECK_EQUAL_HEX((value >> 49U), (generate_shift_right_bitset<64>(value, 49U).value())); - CHECK_EQUAL_HEX((value >> 50U), (generate_shift_right_bitset<64>(value, 50U).value())); - CHECK_EQUAL_HEX((value >> 51U), (generate_shift_right_bitset<64>(value, 51U).value())); - CHECK_EQUAL_HEX((value >> 52U), (generate_shift_right_bitset<64>(value, 52U).value())); - CHECK_EQUAL_HEX((value >> 53U), (generate_shift_right_bitset<64>(value, 53U).value())); - CHECK_EQUAL_HEX((value >> 54U), (generate_shift_right_bitset<64>(value, 54U).value())); - CHECK_EQUAL_HEX((value >> 55U), (generate_shift_right_bitset<64>(value, 55U).value())); - CHECK_EQUAL_HEX((value >> 56U), (generate_shift_right_bitset<64>(value, 56U).value())); - CHECK_EQUAL_HEX((value >> 57U), (generate_shift_right_bitset<64>(value, 57U).value())); - CHECK_EQUAL_HEX((value >> 58U), (generate_shift_right_bitset<64>(value, 58U).value())); - CHECK_EQUAL_HEX((value >> 59U), (generate_shift_right_bitset<64>(value, 59U).value())); - CHECK_EQUAL_HEX((value >> 60U), (generate_shift_right_bitset<64>(value, 60U).value())); - CHECK_EQUAL_HEX((value >> 61U), (generate_shift_right_bitset<64>(value, 61U).value())); - CHECK_EQUAL_HEX((value >> 62U), (generate_shift_right_bitset<64>(value, 62U).value())); - CHECK_EQUAL_HEX((value >> 63U), (generate_shift_right_bitset<64>(value, 63U).value())); - CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64>(value, 64U).value())); - } - - //************************************************************************* - TEST(test_shift_right_operator_all_shifts_partial_size) - { - uint64_t value = 0x0123456789ABCDEFULL; - uint64_t mask = 0x0FFFFFFFFFFFFFFFULL; - - CHECK_EQUAL_HEX((value >> 0U) & mask, (generate_shift_right_bitset<60>(value, 0U).value())); - CHECK_EQUAL_HEX((value >> 1U) & mask, (generate_shift_right_bitset<60>(value, 1U).value())); - CHECK_EQUAL_HEX((value >> 2U) & mask, (generate_shift_right_bitset<60>(value, 2U).value())); - CHECK_EQUAL_HEX((value >> 3U) & mask, (generate_shift_right_bitset<60>(value, 3U).value())); - CHECK_EQUAL_HEX((value >> 4U) & mask, (generate_shift_right_bitset<60>(value, 4U).value())); - CHECK_EQUAL_HEX((value >> 5U) & mask, (generate_shift_right_bitset<60>(value, 5U).value())); - CHECK_EQUAL_HEX((value >> 6U) & mask, (generate_shift_right_bitset<60>(value, 6U).value())); - CHECK_EQUAL_HEX((value >> 7U) & mask, (generate_shift_right_bitset<60>(value, 7U).value())); - CHECK_EQUAL_HEX((value >> 8U) & mask, (generate_shift_right_bitset<60>(value, 8U).value())); - CHECK_EQUAL_HEX((value >> 9U) & mask, (generate_shift_right_bitset<60>(value, 9U).value())); - CHECK_EQUAL_HEX((value >> 10U) & mask, (generate_shift_right_bitset<60>(value, 10U).value())); - CHECK_EQUAL_HEX((value >> 11U) & mask, (generate_shift_right_bitset<60>(value, 11U).value())); - CHECK_EQUAL_HEX((value >> 12U) & mask, (generate_shift_right_bitset<60>(value, 12U).value())); - CHECK_EQUAL_HEX((value >> 13U) & mask, (generate_shift_right_bitset<60>(value, 13U).value())); - CHECK_EQUAL_HEX((value >> 14U) & mask, (generate_shift_right_bitset<60>(value, 14U).value())); - CHECK_EQUAL_HEX((value >> 15U) & mask, (generate_shift_right_bitset<60>(value, 15U).value())); - CHECK_EQUAL_HEX((value >> 16U) & mask, (generate_shift_right_bitset<60>(value, 16U).value())); - CHECK_EQUAL_HEX((value >> 17U) & mask, (generate_shift_right_bitset<60>(value, 17U).value())); - CHECK_EQUAL_HEX((value >> 18U) & mask, (generate_shift_right_bitset<60>(value, 18U).value())); - CHECK_EQUAL_HEX((value >> 19U) & mask, (generate_shift_right_bitset<60>(value, 19U).value())); - CHECK_EQUAL_HEX((value >> 20U) & mask, (generate_shift_right_bitset<60>(value, 20U).value())); - CHECK_EQUAL_HEX((value >> 21U) & mask, (generate_shift_right_bitset<60>(value, 21U).value())); - CHECK_EQUAL_HEX((value >> 22U) & mask, (generate_shift_right_bitset<60>(value, 22U).value())); - CHECK_EQUAL_HEX((value >> 23U) & mask, (generate_shift_right_bitset<60>(value, 23U).value())); - CHECK_EQUAL_HEX((value >> 24U) & mask, (generate_shift_right_bitset<60>(value, 24U).value())); - CHECK_EQUAL_HEX((value >> 25U) & mask, (generate_shift_right_bitset<60>(value, 25U).value())); - CHECK_EQUAL_HEX((value >> 26U) & mask, (generate_shift_right_bitset<60>(value, 26U).value())); - CHECK_EQUAL_HEX((value >> 27U) & mask, (generate_shift_right_bitset<60>(value, 27U).value())); - CHECK_EQUAL_HEX((value >> 28U) & mask, (generate_shift_right_bitset<60>(value, 28U).value())); - CHECK_EQUAL_HEX((value >> 29U) & mask, (generate_shift_right_bitset<60>(value, 29U).value())); - CHECK_EQUAL_HEX((value >> 30U) & mask, (generate_shift_right_bitset<60>(value, 30U).value())); - CHECK_EQUAL_HEX((value >> 31U) & mask, (generate_shift_right_bitset<60>(value, 31U).value())); - CHECK_EQUAL_HEX((value >> 32U) & mask, (generate_shift_right_bitset<60>(value, 32U).value())); - CHECK_EQUAL_HEX((value >> 33U) & mask, (generate_shift_right_bitset<60>(value, 33U).value())); - CHECK_EQUAL_HEX((value >> 34U) & mask, (generate_shift_right_bitset<60>(value, 34U).value())); - CHECK_EQUAL_HEX((value >> 35U) & mask, (generate_shift_right_bitset<60>(value, 35U).value())); - CHECK_EQUAL_HEX((value >> 36U) & mask, (generate_shift_right_bitset<60>(value, 36U).value())); - CHECK_EQUAL_HEX((value >> 37U) & mask, (generate_shift_right_bitset<60>(value, 37U).value())); - CHECK_EQUAL_HEX((value >> 38U) & mask, (generate_shift_right_bitset<60>(value, 38U).value())); - CHECK_EQUAL_HEX((value >> 39U) & mask, (generate_shift_right_bitset<60>(value, 39U).value())); - CHECK_EQUAL_HEX((value >> 40U) & mask, (generate_shift_right_bitset<60>(value, 40U).value())); - CHECK_EQUAL_HEX((value >> 41U) & mask, (generate_shift_right_bitset<60>(value, 41U).value())); - CHECK_EQUAL_HEX((value >> 42U) & mask, (generate_shift_right_bitset<60>(value, 42U).value())); - CHECK_EQUAL_HEX((value >> 43U) & mask, (generate_shift_right_bitset<60>(value, 43U).value())); - CHECK_EQUAL_HEX((value >> 44U) & mask, (generate_shift_right_bitset<60>(value, 44U).value())); - CHECK_EQUAL_HEX((value >> 45U) & mask, (generate_shift_right_bitset<60>(value, 45U).value())); - CHECK_EQUAL_HEX((value >> 46U) & mask, (generate_shift_right_bitset<60>(value, 46U).value())); - CHECK_EQUAL_HEX((value >> 47U) & mask, (generate_shift_right_bitset<60>(value, 47U).value())); - CHECK_EQUAL_HEX((value >> 48U) & mask, (generate_shift_right_bitset<60>(value, 48U).value())); - CHECK_EQUAL_HEX((value >> 49U) & mask, (generate_shift_right_bitset<60>(value, 49U).value())); - CHECK_EQUAL_HEX((value >> 50U) & mask, (generate_shift_right_bitset<60>(value, 50U).value())); - CHECK_EQUAL_HEX((value >> 51U) & mask, (generate_shift_right_bitset<60>(value, 51U).value())); - CHECK_EQUAL_HEX((value >> 52U) & mask, (generate_shift_right_bitset<60>(value, 52U).value())); - CHECK_EQUAL_HEX((value >> 53U) & mask, (generate_shift_right_bitset<60>(value, 53U).value())); - CHECK_EQUAL_HEX((value >> 54U) & mask, (generate_shift_right_bitset<60>(value, 54U).value())); - CHECK_EQUAL_HEX((value >> 55U) & mask, (generate_shift_right_bitset<60>(value, 55U).value())); - CHECK_EQUAL_HEX((value >> 56U) & mask, (generate_shift_right_bitset<60>(value, 56U).value())); - CHECK_EQUAL_HEX((value >> 57U) & mask, (generate_shift_right_bitset<60>(value, 57U).value())); - CHECK_EQUAL_HEX((value >> 58U) & mask, (generate_shift_right_bitset<60>(value, 58U).value())); - CHECK_EQUAL_HEX((value >> 59U) & mask, (generate_shift_right_bitset<60>(value, 59U).value())); - CHECK_EQUAL_HEX((value >> 60U) & mask, (generate_shift_right_bitset<60>(value, 60U).value())); - CHECK_EQUAL_HEX((value >> 61U) & mask, (generate_shift_right_bitset<60>(value, 61U).value())); - CHECK_EQUAL_HEX((value >> 62U) & mask, (generate_shift_right_bitset<60>(value, 62U).value())); - CHECK_EQUAL_HEX((value >> 63U) & mask, (generate_shift_right_bitset<60>(value, 63U).value())); - CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<60>(value, 64U).value())); - } - - //************************************************************************* - TEST(test_and_operator) - { - constexpr etl::bitset<60> data1(0x12345678UL); - constexpr etl::bitset<60> data2(0x23456789UL); - constexpr etl::bitset<60> data4(0x12345678UL & 0x23456789UL); - - constexpr etl::bitset<60> data3 = data1 & data2; - CHECK(data3 == data4); - } - - //************************************************************************* - constexpr etl::bitset<60> test_and_equals_operator_helper(etl::bitset<60> data1, const etl::bitset<60>& data2) - { - data1 &= data2; - - return data1; - } - - TEST(test_and_equals_operator) - { - constexpr etl::bitset<60> data1(0x12345678UL); - constexpr etl::bitset<60> data2(0x23456789UL); - - constexpr etl::bitset<60> data3(test_and_equals_operator_helper(data1, data2)); - - CHECK((data1 & data2) == data3); - } - - //************************************************************************* - TEST(test_or_operator) - { - constexpr etl::bitset<60> data1(0x12345678UL); - constexpr etl::bitset<60> data2(0x23456789UL); - constexpr etl::bitset<60> data4(0x12345678UL | 0x23456789UL); - - constexpr etl::bitset<60> data3 = data1 | data2; - CHECK(data3 == data4); - } - - //************************************************************************* - constexpr etl::bitset<60> test_or_equals_operator_helper(etl::bitset<60> data1, const etl::bitset<60>& data2) - { - data1 |= data2; - - return data1; - } - - TEST(test_or_equals_operator) - { - constexpr etl::bitset<60> data1(0x12345678UL); - constexpr etl::bitset<60> data2(0x23456789UL); - - constexpr etl::bitset<60> data3(test_or_equals_operator_helper(data1, data2)); - - CHECK((data1 | data2) == data3); - } - - //************************************************************************* - TEST(test_xor_operator) - { - constexpr etl::bitset<60> data1(0x12345678UL); - constexpr etl::bitset<60> data2(0x23456789UL); - constexpr etl::bitset<60> data4(0x12345678UL | 0x23456789UL); - - constexpr etl::bitset<60> data3 = data1 | data2; - CHECK(data3 == data4); - } - - //************************************************************************* - constexpr etl::bitset<60> test_xor_equals_operator_helper(etl::bitset<60> data1, const etl::bitset<60>& data2) - { - data1 ^= data2; - - return data1; - } - - TEST(test_xor_equals_operator) - { - constexpr etl::bitset<60> data1(0x12345678UL); - constexpr etl::bitset<60> data2(0x23456789UL); - - constexpr etl::bitset<60> data3(test_xor_equals_operator_helper(data1, data2)); - - CHECK((data1 ^ data2) == data3); - } - - //************************************************************************* - TEST(test_find_first) - { - constexpr etl::bitset<6> bs1(ull(0x00)); - constexpr size_t bs1fff = bs1.find_first(false); - constexpr size_t bs1fft = bs1.find_first(true); - CHECK_EQUAL(0U, bs1fff); - CHECK_EQUAL(etl::bitset<>::npos, bs1fft); - - constexpr etl::bitset<6> bs2(ull(0x3F)); - constexpr size_t bs2fff = bs2.find_first(false); - constexpr size_t bs2fft = bs2.find_first(true); - CHECK_EQUAL(etl::bitset<>::npos, bs2fff); - CHECK_EQUAL(0U, bs2fft); - - constexpr etl::bitset<6> bs3(ull(0x01)); - constexpr size_t bs3fff = bs3.find_first(false); - constexpr size_t bs3fft = bs3.find_first(true); - CHECK_EQUAL(1U, bs3fff); - CHECK_EQUAL(0U, bs3fft); - - constexpr etl::bitset<6> bs4(ull(0x20)); - constexpr size_t bs4fff = bs4.find_first(false); - constexpr size_t bs4fft = bs4.find_first(true); - CHECK_EQUAL(0U, bs4fff); - CHECK_EQUAL(5U, bs4fft); - - constexpr etl::bitset<6> bs5(ull(0x21)); - constexpr size_t bs5fff = bs5.find_first(false); - constexpr size_t bs5fft = bs5.find_first(true); - CHECK_EQUAL(1U, bs5fff); - CHECK_EQUAL(0U, bs5fft); - - constexpr etl::bitset<6> bs6(ull(0x0E)); - constexpr size_t bs6fff = bs6.find_first(false); - constexpr size_t bs6fft = bs6.find_first(true); - CHECK_EQUAL(0U, bs6fff); - CHECK_EQUAL(1U, bs6fft); - - constexpr etl::bitset<6> bs7(ull(0x31)); - constexpr size_t bs7fff = bs7.find_first(false); - constexpr size_t bs7fft = bs7.find_first(true); - CHECK_EQUAL(1U, bs7fff); - CHECK_EQUAL(0U, bs7fft); + etl::bitset<8> data; } //************************************************************************* - TEST(test_find_next) + TEST(test_default_constructor_single_element_mask) { etl::bitset<6> data; - - constexpr etl::bitset<6> bs1(ull(0x00)); - constexpr size_t bs1fnf0 = bs1.find_next(false, 0); - constexpr size_t bs1fnf1 = bs1.find_next(false, 1); - constexpr size_t bs1fnt2 = bs1.find_next(true, 2); - CHECK_EQUAL(0U, bs1fnf0); - CHECK_EQUAL(1U, bs1fnf1); - CHECK_EQUAL(etl::bitset<>::npos, bs1fnt2); - - constexpr etl::bitset<6> bs2(ull(0x3F)); - constexpr size_t bs2fnt0 = bs2.find_next(true, 0); - constexpr size_t bs2fnt1 = bs2.find_next(true, 1); - constexpr size_t bs2fnf2 = bs2.find_next(false, 2); - CHECK_EQUAL(0U, bs2fnt0); - CHECK_EQUAL(1U, bs2fnt1); - CHECK_EQUAL(etl::bitset<>::npos, bs2fnf2); - - constexpr etl::bitset<6> bs3(ull(0x0E)); - constexpr size_t bs3fnf0 = bs3.find_next(false, 0); - constexpr size_t bs3fnt1 = bs3.find_next(true, 1); - constexpr size_t bs3fnf2 = bs3.find_next(false, 2); - CHECK_EQUAL(0U, bs3fnf0); - CHECK_EQUAL(1U, bs3fnt1); - CHECK_EQUAL(4U, bs3fnf2); - - constexpr etl::bitset<6> bs4(ull(0x31)); - constexpr size_t bs4fnt0 = bs4.find_next(true, 0); - constexpr size_t bs4fnf0 = bs4.find_next(false, 0); - constexpr size_t bs4fnt1 = bs4.find_next(true, 1); - CHECK_EQUAL(0U, bs4fnt0); - CHECK_EQUAL(1U, bs4fnf0); - CHECK_EQUAL(4U, bs4fnt1); } - //************************************************************************* - constexpr std::pair, etl::bitset<6>> test_swap_helper() - { - etl::bitset<6> data1(ull(0x2A)); - etl::bitset<6> data2(ull(0x15)); + ////************************************************************************* + //TEST(test_default_constructor_different_element_types) + //{ + // constexpr etl::bitset<256, uint8_t> data8; + // constexpr etl::bitset<256, uint16_t> data16; + // constexpr etl::bitset<256, uint32_t> data32; + // constexpr etl::bitset<256, uint64_t> data64; - swap(data1, data2); + // CHECK_EQUAL(32U, data8.Number_Of_Elements); + // CHECK_EQUAL(16U, data16.Number_Of_Elements); + // CHECK_EQUAL( 8U, data32.Number_Of_Elements); + // CHECK_EQUAL( 4U, data64.Number_Of_Elements); + //} - return std::pair, etl::bitset<6>>(data1, data2); - } + ////************************************************************************* + //TEST(test_default_constructor_implicit_element_types) + //{ + // CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(8U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(16U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(16U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(16U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(16U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(16U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(16U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(16U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(16U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(32U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + // CHECK_EQUAL(64U, etl::integral_limits::element_type>::bits); + //} - TEST(test_swap) - { - constexpr etl::bitset<6> compare1(0x2A); - constexpr etl::bitset<6> compare2(0x15); + ////************************************************************************* + //TEST(test_construct_from_value) + //{ + // constexpr std::bitset<60> compare(0x123456731234567ULL); + // constexpr etl::bitset<60> data(0x123456731234567ULL); - constexpr std::pair, etl::bitset<6>> swapped = test_swap_helper(); + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); - CHECK(swapped.first == compare2); - CHECK(swapped.second == compare1); - } + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} - //************************************************************************* - TEST(test_span) - { - using span_t = etl::bitset<32, char>::span_type; + ////************************************************************************* + //TEST(test_copy_construct) + //{ + // constexpr std::bitset<60> compare(0x123456731234567ULL); + // constexpr etl::bitset<60> data(0x123456731234567ULL); + // constexpr etl::bitset<60> data_copy(data); - etl::bitset<32, char> b(0x12345678UL); + // CHECK_EQUAL(compare.size(), data_copy.size()); + // CHECK_EQUAL(compare.count(), data_copy.count()); - span_t s = b.span(); - CHECK_EQUAL(0x78U, s[0]); - CHECK_EQUAL(0x56U, s[1]); - CHECK_EQUAL(0x34U, s[2]); - CHECK_EQUAL(0x12U, s[3]); - } + // for (size_t i = 0UL; i < data_copy.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data_copy.test(i)); + // } + //} - //************************************************************************* - TEST(test_const_span) - { - using span_t = etl::bitset<32, char>::const_span_type; + ////************************************************************************* + //TEST(test_construct_from_excess_value) + //{ + // constexpr std::bitset<60> compare(0x8765432187654321ULL); + // constexpr etl::bitset<60> data(0x8765432187654321ULL); - const etl::bitset<32, char> b(0x12345678UL); + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); - span_t s = b.span(); - CHECK_EQUAL(0x78U, s[0]); - CHECK_EQUAL(0x56U, s[1]); - CHECK_EQUAL(0x34U, s[2]); - CHECK_EQUAL(0x12U, s[3]); - } + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} - //************************************************************************* - TEST(test_span_constexpr) - { - using span_t = etl::bitset<32, char>::const_span_type; + ////************************************************************************* + //TEST(test_construct_from_char_string) + //{ + // std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); + // etl::bitset<60> data("110001001000110100010101100111001100010010001101000101011001"); - constexpr etl::bitset<32, char> b(0x12345678UL); + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); - constexpr span_t s = b.span(); - CHECK_EQUAL(0x78U, s[0]); - CHECK_EQUAL(0x56U, s[1]); - CHECK_EQUAL(0x34U, s[2]); - CHECK_EQUAL(0x12U, s[3]); - } + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} - //************************************************************************* - TEST(test_to_string) - { - constexpr etl::bitset<32> b(0x12345678UL); + ////************************************************************************* + //TEST(test_construct_from_wchar_t_string) + //{ + // std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001"); + // etl::bitset<60> data(L"110001001000110100010101100111001100010010001101000101011001"); - etl::string<32> text = b.to_string('.', '*'); - std::string stdtext = b.to_string('.', '*'); + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); - CHECK_THROW(etl::string<32> text1 = b.to_string>('.', '*'), etl::bitset_overflow); - CHECK_EQUAL("...*..*...**.*...*.*.**..****...", text.c_str()); - CHECK_EQUAL("...*..*...**.*...*.*.**..****...", stdtext.c_str()); - } + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} + + ////************************************************************************* + //TEST(test_construct_from_char16_t_string) + //{ + // std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001"); + // etl::bitset<60> data(u"110001001000110100010101100111001100010010001101000101011001"); + + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} + + ////************************************************************************* + //TEST(test_construct_from_char32_t_string) + //{ + // std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001"); + // etl::bitset<60> data(U"110001001000110100010101100111001100010010001101000101011001"); + + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} + + ////************************************************************************* + //TEST(test_construct_from_excess_string) + //{ + // std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001111100001"); + // etl::bitset<60> data("110001001000110100010101100111001100010010001101000101011001111100001"); + + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); + // CHECK_EQUAL(compare.none(), data.none()); + // CHECK_EQUAL(compare.any(), data.any()); + // CHECK_EQUAL(compare.all(), data.all()); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} + + ////************************************************************************* + //constexpr etl::bitset<60> test_set_helper() + //{ + // etl::bitset<60> data; + // data.set(); + + // return data; + //} + // + //TEST(test_set) + //{ + // std::bitset<60> compare; + // constexpr etl::bitset<60> data(test_set_helper()); + + // compare.set(); + + // constexpr auto size = data.size(); + // constexpr auto count = data.count(); + // constexpr auto none = data.none(); + // constexpr auto any = data.any(); + // constexpr 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_char_string_set) + //{ + // std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); + // etl::bitset<60> data; + + // data.set("110001001000110100010101100111001100010010001101000101011001"); + + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); + // CHECK_EQUAL(compare.none(), data.none()); + // CHECK_EQUAL(compare.any(), data.any()); + // CHECK_EQUAL(compare.all(), data.all()); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} + + ////************************************************************************* + //TEST(test_wchar_t_string_set) + //{ + // std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001"); + // etl::bitset<60> data; + + // data.set(L"110001001000110100010101100111001100010010001101000101011001"); + + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); + // CHECK_EQUAL(compare.none(), data.none()); + // CHECK_EQUAL(compare.any(), data.any()); + // CHECK_EQUAL(compare.all(), data.all()); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} + + ////************************************************************************* + //TEST(test_char16_t_string_set) + //{ + // std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001"); + // etl::bitset<60> data; + + // data.set(u"110001001000110100010101100111001100010010001101000101011001"); + + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); + // CHECK_EQUAL(compare.none(), data.none()); + // CHECK_EQUAL(compare.any(), data.any()); + // CHECK_EQUAL(compare.all(), data.all()); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} + + ////************************************************************************* + //TEST(test_char32_t_string_set) + //{ + // std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001"); + // etl::bitset<60> data; + + // data.set(U"110001001000110100010101100111001100010010001101000101011001"); + + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); + // CHECK_EQUAL(compare.none(), data.none()); + // CHECK_EQUAL(compare.any(), data.any()); + // CHECK_EQUAL(compare.all(), data.all()); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} + + ////************************************************************************* + //TEST(test_from_char_string) + //{ + // std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); + // etl::bitset<60> data; + + // data.from_string("110001001000110100010101100111001100010010001101000101011001"); + + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); + // CHECK_EQUAL(compare.none(), data.none()); + // CHECK_EQUAL(compare.any(), data.any()); + // CHECK_EQUAL(compare.all(), data.all()); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} + + ////************************************************************************* + //TEST(test_from_wchar_t_string) + //{ + // std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); + // etl::bitset<60> data; + + // data.from_string(L"110001001000110100010101100111001100010010001101000101011001"); + + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); + // CHECK_EQUAL(compare.none(), data.none()); + // CHECK_EQUAL(compare.any(), data.any()); + // CHECK_EQUAL(compare.all(), data.all()); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} + + ////************************************************************************* + //TEST(test_from_char16_t_6string) + //{ + // std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); + // etl::bitset<60> data; + + // data.from_string(u"110001001000110100010101100111001100010010001101000101011001"); + + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); + // CHECK_EQUAL(compare.none(), data.none()); + // CHECK_EQUAL(compare.any(), data.any()); + // CHECK_EQUAL(compare.all(), data.all()); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} + + ////************************************************************************* + //TEST(test_from_char32_t_string) + //{ + // std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001"); + // etl::bitset<60> data; + + // data.from_string(U"110001001000110100010101100111001100010010001101000101011001"); + + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); + // CHECK_EQUAL(compare.none(), data.none()); + // CHECK_EQUAL(compare.any(), data.any()); + // CHECK_EQUAL(compare.all(), data.all()); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} + + ////************************************************************************* + //TEST(test_value_u8_min) + //{ + // constexpr etl::bitset<8> data((unsigned long long)etl::integral_limits::min); + // constexpr uint8_t value = data.value(); + + // CHECK_EQUAL(std::numeric_limits::min(), value); + //} + + ////************************************************************************* + //TEST(test_value_u8_max) + //{ + // constexpr etl::bitset<8> data((unsigned long long)etl::integral_limits::max); + // constexpr uint8_t value = data.value(); + + // CHECK_EQUAL(std::numeric_limits::max(), value); + //} + + ////************************************************************************* + //TEST(test_value_s8_min) + //{ + // constexpr etl::bitset<8> data((unsigned long long)etl::integral_limits::min); + // constexpr int8_t value = data.value(); + + // CHECK_EQUAL(std::numeric_limits::min(), value); + //} + + ////************************************************************************* + //TEST(test_value_s8_max) + //{ + // constexpr etl::bitset<8> data((unsigned long long)etl::integral_limits::max); + // constexpr int8_t value = data.value(); + + // CHECK_EQUAL(std::numeric_limits::max(), value); + //} + + ////************************************************************************* + //TEST(test_value_u16_min) + //{ + // constexpr etl::bitset<16> data((unsigned long long)etl::integral_limits::min); + // constexpr uint16_t value = data.value(); + + // CHECK_EQUAL(std::numeric_limits::min(), value); + //} + + ////************************************************************************* + //TEST(test_value_u16_max) + //{ + // constexpr etl::bitset<16> data((unsigned long long)etl::integral_limits::max); + // constexpr uint16_t value = data.value(); + + // CHECK_EQUAL(std::numeric_limits::max(), value); + //} + + ////************************************************************************* + //TEST(test_value_s16_min) + //{ + // constexpr etl::bitset<16> data((unsigned long long)etl::integral_limits::min); + // constexpr int16_t value = data.value(); + + // CHECK_EQUAL(std::numeric_limits::min(), value); + //} + + ////************************************************************************* + //TEST(test_value_s16_max) + //{ + // etl::bitset<16> data((unsigned long long)etl::integral_limits::max); + // int16_t value = data.value(); + + // CHECK_EQUAL(std::numeric_limits::max(), value); + //} + + ////************************************************************************* + //TEST(test_value_u32_min) + //{ + // constexpr etl::bitset<32> data((unsigned long long)etl::integral_limits::min); + // constexpr uint32_t value = data.value(); + + // CHECK_EQUAL(std::numeric_limits::min(), value); + //} + + ////************************************************************************* + //TEST(test_value_u32_max) + //{ + // constexpr etl::bitset<32> data((unsigned long long)etl::integral_limits::max); + // constexpr uint32_t value = data.value(); + + // CHECK_EQUAL(std::numeric_limits::max(), value); + //} + + ////************************************************************************* + //TEST(test_value_s32_min) + //{ + // constexpr etl::bitset<32> data((unsigned long long)etl::integral_limits::min); + // constexpr int32_t value = data.value(); + + // CHECK_EQUAL(std::numeric_limits::min(), value); + //} + + ////************************************************************************* + //TEST(test_value_s32_max) + //{ + // constexpr etl::bitset<32> data((unsigned long long)etl::integral_limits::max); + // constexpr int32_t value = data.value(); + + // CHECK_EQUAL(std::numeric_limits::max(), value); + //} + + ////************************************************************************* + //TEST(test_value_u64_min) + //{ + // constexpr etl::bitset<64> data((unsigned long long)etl::integral_limits::min); + // constexpr uint64_t value = data.value(); + + // CHECK_EQUAL(std::numeric_limits::min(), value); + //} + + ////************************************************************************* + //TEST(test_value_u64_max) + //{ + // constexpr etl::bitset<64> data((unsigned long long)etl::integral_limits::max); + // constexpr uint64_t value = data.value(); + + // CHECK_EQUAL(std::numeric_limits::max(), value); + //} + + ////************************************************************************* + //TEST(test_value_s64_min) + //{ + // constexpr etl::bitset<64> data((unsigned long long)etl::integral_limits::min); + // constexpr int64_t value = data.value(); + + // CHECK_EQUAL(std::numeric_limits::min(), value); + //} + + ////************************************************************************* + //TEST(test_value_s64_max) + //{ + // constexpr etl::bitset<64> data((unsigned long long)etl::integral_limits::max); + // constexpr int64_t value = data.value(); + + // CHECK_EQUAL(std::numeric_limits::max(), value); + //} + + ////************************************************************************* + //TEST(test_using_element_type_int8_t) + //{ + // std::bitset<60> compare(ull(0x0C48D159CC48D159)); + // etl::bitset<60, int8_t> data(ull(0x0C48D159CC48D159)); + + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); + // CHECK_EQUAL(compare.none(), data.none()); + // CHECK_EQUAL(compare.any(), data.any()); + // CHECK_EQUAL(compare.all(), data.all()); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + + // CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong()); + //} + + ////************************************************************************* + //TEST(test_using_element_type_int16_t) + //{ + // std::bitset<60> compare(ull(0x0C48D159CC48D159)); + // etl::bitset<60, int16_t> data(ull(0x0C48D159CC48D159)); + + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); + // CHECK_EQUAL(compare.none(), data.none()); + // CHECK_EQUAL(compare.any(), data.any()); + // CHECK_EQUAL(compare.all(), data.all()); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + + // CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong()); + //} + + ////************************************************************************* + //TEST(test_using_element_type_int32_t) + //{ + // std::bitset<60> compare(ull(0x0C48D159CC48D159)); + // etl::bitset<60, int32_t> data(ull(0x0C48D159CC48D159)); + + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); + // CHECK_EQUAL(compare.none(), data.none()); + // CHECK_EQUAL(compare.any(), data.any()); + // CHECK_EQUAL(compare.all(), data.all()); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + + // CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong()); + //} + + ////************************************************************************* + //TEST(test_using_element_type_int64_t) + //{ + // std::bitset<60> compare(ull(0x0C48D159CC48D159)); + // etl::bitset<60, int64_t> data(ull(0x0C48D159CC48D159)); + + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); + // CHECK_EQUAL(compare.none(), data.none()); + // CHECK_EQUAL(compare.any(), data.any()); + // CHECK_EQUAL(compare.all(), data.all()); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + + // CHECK_EQUAL_HEX(compare.to_ullong(), data.to_ullong()); + //} + + ////************************************************************************* + //TEST(test_position_set) + //{ + // std::bitset<60> compare; + // etl::bitset<60> data; + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // compare.set(i, (i % 2) == 0); + // data.set(i, (i % 2) == 0); + // } + + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); + // CHECK_EQUAL(compare.none(), data.none()); + // CHECK_EQUAL(compare.any(), data.any()); + // CHECK_EQUAL(compare.all(), data.all()); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} + + ////************************************************************************* + //constexpr etl::bitset<60> test_reset_helper() + //{ + // etl::bitset<60> data(0xFFFFFFFFFFFFFFFULL); + // data.reset(); + + // return data; + //} + // + //TEST(test_reset) + //{ + // std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL); + // constexpr etl::bitset<60> data(test_reset_helper()); + + // compare.reset(); + // + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); + // CHECK_EQUAL(compare.none(), data.none()); + // CHECK_EQUAL(compare.any(), data.any()); + // CHECK_EQUAL(compare.all(), data.all()); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} + + ////************************************************************************* + //constexpr etl::bitset<60> test_position_reset_helper() + //{ + // etl::bitset<60> data(0xFFFFFFFFFFFFFFFULL); + // data.reset(1); + // data.reset(3); + // data.reset(7); + // data.reset(13); + + // return data; + //} + + //TEST(test_position_reset) + //{ + // std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL); + // constexpr etl::bitset<60> data(test_position_reset_helper()); + + // compare.reset(1); + // compare.reset(3); + // compare.reset(7); + // compare.reset(13); + + // CHECK_EQUAL(compare.size(), data.size()); + // CHECK_EQUAL(compare.count(), data.count()); + // CHECK_EQUAL(compare.none(), data.none()); + // CHECK_EQUAL(compare.any(), data.any()); + // CHECK_EQUAL(compare.all(), data.all()); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} + + ////************************************************************************* + //TEST(test_index_operator_read) + //{ + // constexpr std::bitset<60> compare(0x3123456731234567ULL); + // constexpr etl::bitset<60> data(0x3123456731234567ULL); + + // constexpr bool bc0 = compare[1U]; + // constexpr bool bd0 = data[1U]; + // CHECK_EQUAL(bc0, bd0); + + // constexpr bool bc3 = compare[3U]; + // constexpr bool bd3 = data[3U]; + // CHECK_EQUAL(bc3, bd3); + + // constexpr bool bc7 = compare[7U]; + // constexpr bool bd7 = data[7U]; + // CHECK_EQUAL(bc7, bd7); + + // constexpr bool bc13 = compare[13U]; + // constexpr bool bd13 = data[13U]; + // CHECK_EQUAL(bc7, bd7); + //} + + ////************************************************************************* + //constexpr etl::bitset<60> test_index_operator_write_helper() + //{ + // etl::bitset<60> data; + + // data[1U] = true; + // data[3U] = true; + // data[7U] = true; + // data[13U] = true; + + // return data; + //} + + //TEST(test_index_operator_write) + //{ + // constexpr etl::bitset<60> data(test_index_operator_write_helper()); + + // CHECK(data[1U]); + // CHECK(data[3U]); + // CHECK(data[7U]); + // CHECK(data[13U]); + //} + + ////************************************************************************* + //TEST(test_any) + //{ + // constexpr etl::bitset<60> data1(ull(0x0000000000000000)); + // constexpr etl::bitset<60> data2(ull(0x0000010000000000)); + // constexpr etl::bitset<60> data3(ull(0x0000010001000100)); + // constexpr etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF)); + + // constexpr bool bd1 = data1.any(); + // constexpr bool bd2 = data2.any(); + // constexpr bool bd3 = data3.any(); + // constexpr bool bd4 = data4.any(); + + // CHECK_FALSE(bd1); + // CHECK_TRUE(bd2); + // CHECK_TRUE(bd3); + // CHECK_TRUE(bd4); + //} + + ////************************************************************************* + //TEST(test_none) + //{ + // constexpr etl::bitset<60> data1(ull(0x0000000000000000)); + // constexpr etl::bitset<60> data2(ull(0x0000010000000000)); + // constexpr etl::bitset<60> data3(ull(0x0000010001000100)); + // constexpr etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF)); + + // constexpr bool bd1 = data1.none(); + // constexpr bool bd2 = data2.none(); + // constexpr bool bd3 = data3.none(); + // constexpr bool bd4 = data4.none(); + + // CHECK_TRUE(bd1); + // CHECK_FALSE(bd2); + // CHECK_FALSE(bd3); + // CHECK_FALSE(bd4); + //} + + ////************************************************************************* + //TEST(test_all) + //{ + // constexpr etl::bitset<60> data1(ull(0x0000000000000000)); + // constexpr etl::bitset<60> data2(ull(0x0000010000000000)); + // constexpr etl::bitset<60> data3(ull(0x0000010001000100)); + // constexpr etl::bitset<60> data4(ull(0x0FFFFFFFFFFFFFFF)); + + // constexpr bool bd1 = data1.all(); + // constexpr bool bd2 = data2.all(); + // constexpr bool bd3 = data3.all(); + // constexpr bool bd4 = data4.all(); + + // CHECK_FALSE(bd1); + // CHECK_FALSE(bd2); + // CHECK_FALSE(bd3); + // CHECK_TRUE(bd4); + //} + + ////************************************************************************* + //constexpr etl::bitset<60> test_flip_helper() + //{ + // etl::bitset<60> data; + // data.flip(); + + // return data; + //} + + //TEST(test_flip) + //{ + // std::bitset<60> compare; + // constexpr etl::bitset<60> data(test_flip_helper()); + + // compare.flip(); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} + + ////************************************************************************* + //constexpr etl::bitset<60> test_flip_position_helper() + //{ + // etl::bitset<60> data; + // data.flip(1); + // data.flip(3); + // data.flip(7); + // data.flip(13); + + // return data; + //} + // + //TEST(test_flip_position) + //{ + // std::bitset<60> compare; + // constexpr etl::bitset<60> data(test_flip_position_helper()); + + // compare.flip(1); + // compare.flip(3); + // compare.flip(7); + // compare.flip(13); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} + + ////************************************************************************* + //constexpr etl::bitset<60> test_flip_reference_helper() + //{ + // etl::bitset<60> data; + // data[1].flip(); + // data[3].flip(); + // data[7].flip(); + // data[13].flip(); + + // return data; + //} + + //TEST(test_flip_reference) + //{ + // std::bitset<60> compare; + // constexpr etl::bitset<60> data(test_flip_reference_helper()); + + // compare[1].flip(); + // compare[3].flip(); + // compare[7].flip(); + // compare[13].flip(); + + // for (size_t i = 0UL; i < data.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data.test(i)); + // } + //} + + ////************************************************************************* + //TEST(test_invert_reference) + //{ + // std::bitset<60> compare; + // etl::bitset<60> data; + + // bool bc = ~compare[3]; + // bool bd = ~data[3]; + // CHECK_EQUAL(bc, bd); + //} + + ////************************************************************************* + //constexpr etl::bitset<60> test_assignment_operator_helper(etl::bitset<60> to, const etl::bitset<60>& from) + //{ + // to = from; + + // return to; + //} + + //TEST(test_assignment_operator) + //{ + // constexpr std::bitset<60> compare(0xFFFFFFFFFFFFFFFULL); + // constexpr etl::bitset<60> data1(0xFFFFFFFFFFFFFFFULL); + // constexpr etl::bitset<60> data2(test_assignment_operator_helper(etl::bitset<60>(), data1)); + + // for (size_t i = 0UL; i < data2.size(); ++i) + // { + // CHECK_EQUAL(compare.test(i), data2.test(i)); + // } + //} + + ////************************************************************************* + //TEST(test_equality_operator) + //{ + // constexpr etl::bitset<60> data1(0x123456781234567ULL); + // constexpr etl::bitset<60> data2(0x123456781234567ULL); + // constexpr etl::bitset<60> data3; + + // constexpr bool equal = (data1 == data2); + // constexpr bool not_equal = !(data1 == data3); + + // CHECK(equal); + // CHECK(not_equal); + //} + + ////************************************************************************* + //TEST(test_inequality_operator) + //{ + // constexpr etl::bitset<60> data1(0x123456781234567ULL); + // constexpr etl::bitset<60> data2(0x123456781234567ULL); + // constexpr etl::bitset<60> data3; + + // constexpr bool equal = !(data1 != data2); + // constexpr bool not_equal = (data1 != data3); + + // CHECK(!(data1 != data2)); + // CHECK(data1 != data3); + //} + + ////************************************************************************* + //TEST(test_shift_left_operator) + //{ + // constexpr etl::bitset<60> shift1(0x2468ACF0ULL); + // constexpr etl::bitset<60> shift2(0x48D159E0ULL); + // constexpr etl::bitset<60> shift11(0x91A2B3C000ULL); + + // CHECK(generate_shift_left_bitset<60>(0x12345678ULL, 1U) == shift1); + // CHECK(generate_shift_left_bitset<60>(0x12345678ULL, 2U) == shift2); + // CHECK(generate_shift_left_bitset<60>(0x12345678ULL, 11U) == shift11); + //} + + ////************************************************************************* + //TEST(test_shift_left_operator_overflow) + //{ + // constexpr etl::bitset<31> data(generate_shift_left_bitset<31>(0x7FFFFFFFULL, 1U)); + // constexpr etl::bitset<31> shifted(0x7FFFFFFEUL); + + // CHECK(data == shifted); + //} + + ////************************************************************************* + //TEST(test_shift_left_copy_operator) + //{ + // constexpr etl::bitset<60> shift8(0x1234567800ULL); + // CHECK_EQUAL_HEX(shift8.value(), generate_shift_left_bitset_copy<60>(0x12345678UL, 8U).value()); + + // constexpr etl::bitset<60> shift16(0x123456780000ULL); + // CHECK_EQUAL_HEX(shift16.value(), generate_shift_left_bitset_copy<60>(0x12345678UL, 16U).value()); + + // constexpr etl::bitset<60> shift24(0x12345678000000ULL); + // CHECK_EQUAL_HEX(shift24.value(), generate_shift_left_bitset_copy<60>(0x12345678UL, 24U).value()); + + // constexpr etl::bitset<60> shift60(0x0000000000000000ULL); + // CHECK_EQUAL_HEX(shift60.value(), generate_shift_left_bitset_copy<60>(0x12345678UL, 60U).value()); + //} + + ////************************************************************************* + //TEST(test_shift_left_operator_all_shifts_full_size) + //{ + // uint64_t value = 0x0123456789ABCDEFULL; + + // //CHECK_EQUAL_HEX((value << 0U), (generate_shift_left_bitset<64>(value, 0U).value())); + // //CHECK_EQUAL_HEX((value << 1U), (generate_shift_left_bitset<64>(value, 1U).value())); + // //CHECK_EQUAL_HEX((value << 2U), (generate_shift_left_bitset<64>(value, 2U).value())); + // //CHECK_EQUAL_HEX((value << 3U), (generate_shift_left_bitset<64>(value, 3U).value())); + // //CHECK_EQUAL_HEX((value << 4U), (generate_shift_left_bitset<64>(value, 4U).value())); + // //CHECK_EQUAL_HEX((value << 5U), (generate_shift_left_bitset<64>(value, 5U).value())); + // //CHECK_EQUAL_HEX((value << 6U), (generate_shift_left_bitset<64>(value, 6U).value())); + // //CHECK_EQUAL_HEX((value << 7U), (generate_shift_left_bitset<64>(value, 7U).value())); + // //CHECK_EQUAL_HEX((value << 8U), (generate_shift_left_bitset<64>(value, 8U).value())); + // //CHECK_EQUAL_HEX((value << 9U), (generate_shift_left_bitset<64>(value, 9U).value())); + // //CHECK_EQUAL_HEX((value << 10U), (generate_shift_left_bitset<64>(value, 10U).value())); + // //CHECK_EQUAL_HEX((value << 11U), (generate_shift_left_bitset<64>(value, 11U).value())); + // //CHECK_EQUAL_HEX((value << 12U), (generate_shift_left_bitset<64>(value, 12U).value())); + // //CHECK_EQUAL_HEX((value << 13U), (generate_shift_left_bitset<64>(value, 13U).value())); + // //CHECK_EQUAL_HEX((value << 14U), (generate_shift_left_bitset<64>(value, 14U).value())); + // //CHECK_EQUAL_HEX((value << 15U), (generate_shift_left_bitset<64>(value, 15U).value())); + // //CHECK_EQUAL_HEX((value << 16U), (generate_shift_left_bitset<64>(value, 16U).value())); + // //CHECK_EQUAL_HEX((value << 17U), (generate_shift_left_bitset<64>(value, 17U).value())); + // //CHECK_EQUAL_HEX((value << 18U), (generate_shift_left_bitset<64>(value, 18U).value())); + // //CHECK_EQUAL_HEX((value << 19U), (generate_shift_left_bitset<64>(value, 19U).value())); + // //CHECK_EQUAL_HEX((value << 20U), (generate_shift_left_bitset<64>(value, 20U).value())); + // //CHECK_EQUAL_HEX((value << 21U), (generate_shift_left_bitset<64>(value, 21U).value())); + // //CHECK_EQUAL_HEX((value << 22U), (generate_shift_left_bitset<64>(value, 22U).value())); + // //CHECK_EQUAL_HEX((value << 23U), (generate_shift_left_bitset<64>(value, 23U).value())); + // //CHECK_EQUAL_HEX((value << 24U), (generate_shift_left_bitset<64>(value, 24U).value())); + // //CHECK_EQUAL_HEX((value << 25U), (generate_shift_left_bitset<64>(value, 25U).value())); + // //CHECK_EQUAL_HEX((value << 26U), (generate_shift_left_bitset<64>(value, 26U).value())); + // //CHECK_EQUAL_HEX((value << 27U), (generate_shift_left_bitset<64>(value, 27U).value())); + // //CHECK_EQUAL_HEX((value << 28U), (generate_shift_left_bitset<64>(value, 28U).value())); + // //CHECK_EQUAL_HEX((value << 29U), (generate_shift_left_bitset<64>(value, 29U).value())); + // //CHECK_EQUAL_HEX((value << 30U), (generate_shift_left_bitset<64>(value, 30U).value())); + // //CHECK_EQUAL_HEX((value << 31U), (generate_shift_left_bitset<64>(value, 31U).value())); + // //CHECK_EQUAL_HEX((value << 32U), (generate_shift_left_bitset<64>(value, 32U).value())); + // //CHECK_EQUAL_HEX((value << 33U), (generate_shift_left_bitset<64>(value, 33U).value())); + // //CHECK_EQUAL_HEX((value << 34U), (generate_shift_left_bitset<64>(value, 34U).value())); + // //CHECK_EQUAL_HEX((value << 35U), (generate_shift_left_bitset<64>(value, 35U).value())); + // //CHECK_EQUAL_HEX((value << 36U), (generate_shift_left_bitset<64>(value, 36U).value())); + // //CHECK_EQUAL_HEX((value << 37U), (generate_shift_left_bitset<64>(value, 37U).value())); + // //CHECK_EQUAL_HEX((value << 38U), (generate_shift_left_bitset<64>(value, 38U).value())); + // //CHECK_EQUAL_HEX((value << 39U), (generate_shift_left_bitset<64>(value, 39U).value())); + // //CHECK_EQUAL_HEX((value << 40U), (generate_shift_left_bitset<64>(value, 40U).value())); + // //CHECK_EQUAL_HEX((value << 41U), (generate_shift_left_bitset<64>(value, 41U).value())); + // //CHECK_EQUAL_HEX((value << 42U), (generate_shift_left_bitset<64>(value, 42U).value())); + // //CHECK_EQUAL_HEX((value << 43U), (generate_shift_left_bitset<64>(value, 43U).value())); + // //CHECK_EQUAL_HEX((value << 44U), (generate_shift_left_bitset<64>(value, 44U).value())); + // //CHECK_EQUAL_HEX((value << 45U), (generate_shift_left_bitset<64>(value, 45U).value())); + // //CHECK_EQUAL_HEX((value << 46U), (generate_shift_left_bitset<64>(value, 46U).value())); + // //CHECK_EQUAL_HEX((value << 47U), (generate_shift_left_bitset<64>(value, 47U).value())); + // //CHECK_EQUAL_HEX((value << 48U), (generate_shift_left_bitset<64>(value, 48U).value())); + // //CHECK_EQUAL_HEX((value << 49U), (generate_shift_left_bitset<64>(value, 49U).value())); + // //CHECK_EQUAL_HEX((value << 50U), (generate_shift_left_bitset<64>(value, 50U).value())); + // //CHECK_EQUAL_HEX((value << 51U), (generate_shift_left_bitset<64>(value, 51U).value())); + // //CHECK_EQUAL_HEX((value << 52U), (generate_shift_left_bitset<64>(value, 52U).value())); + // //CHECK_EQUAL_HEX((value << 53U), (generate_shift_left_bitset<64>(value, 53U).value())); + // //CHECK_EQUAL_HEX((value << 54U), (generate_shift_left_bitset<64>(value, 54U).value())); + // //CHECK_EQUAL_HEX((value << 55U), (generate_shift_left_bitset<64>(value, 55U).value())); + // //CHECK_EQUAL_HEX((value << 56U), (generate_shift_left_bitset<64>(value, 56U).value())); + // //CHECK_EQUAL_HEX((value << 57U), (generate_shift_left_bitset<64>(value, 57U).value())); + // //CHECK_EQUAL_HEX((value << 58U), (generate_shift_left_bitset<64>(value, 58U).value())); + // //CHECK_EQUAL_HEX((value << 59U), (generate_shift_left_bitset<64>(value, 59U).value())); + // //CHECK_EQUAL_HEX((value << 60U), (generate_shift_left_bitset<64>(value, 60U).value())); + // //CHECK_EQUAL_HEX((value << 61U), (generate_shift_left_bitset<64>(value, 61U).value())); + // //CHECK_EQUAL_HEX((value << 62U), (generate_shift_left_bitset<64>(value, 62U).value())); + // //CHECK_EQUAL_HEX((value << 63U), (generate_shift_left_bitset<64>(value, 63U).value())); + // //CHECK_EQUAL_HEX(0ULL, (generate_shift_left_bitset<64>(value, 64U).value())); + //} + + ////************************************************************************* + //TEST(test_shift_left_operator_all_shifts_partial_size) + //{ + // uint64_t value = 0x0123456789ABCDEFULL; + // uint64_t mask = 0x0FFFFFFFFFFFFFFFULL; + + // //CHECK_EQUAL_HEX((value << 0U) & mask, (generate_shift_left_bitset<60>(value, 0U).value())); + // //CHECK_EQUAL_HEX((value << 1U) & mask, (generate_shift_left_bitset<60>(value, 1U).value())); + // //CHECK_EQUAL_HEX((value << 2U) & mask, (generate_shift_left_bitset<60>(value, 2U).value())); + // //CHECK_EQUAL_HEX((value << 3U) & mask, (generate_shift_left_bitset<60>(value, 3U).value())); + // //CHECK_EQUAL_HEX((value << 4U) & mask, (generate_shift_left_bitset<60>(value, 4U).value())); + // //CHECK_EQUAL_HEX((value << 5U) & mask, (generate_shift_left_bitset<60>(value, 5U).value())); + // //CHECK_EQUAL_HEX((value << 6U) & mask, (generate_shift_left_bitset<60>(value, 6U).value())); + // //CHECK_EQUAL_HEX((value << 7U) & mask, (generate_shift_left_bitset<60>(value, 7U).value())); + // //CHECK_EQUAL_HEX((value << 8U) & mask, (generate_shift_left_bitset<60>(value, 8U).value())); + // //CHECK_EQUAL_HEX((value << 9U) & mask, (generate_shift_left_bitset<60>(value, 9U).value())); + // //CHECK_EQUAL_HEX((value << 10U) & mask, (generate_shift_left_bitset<60>(value, 10U).value())); + // //CHECK_EQUAL_HEX((value << 11U) & mask, (generate_shift_left_bitset<60>(value, 11U).value())); + // //CHECK_EQUAL_HEX((value << 12U) & mask, (generate_shift_left_bitset<60>(value, 12U).value())); + // //CHECK_EQUAL_HEX((value << 13U) & mask, (generate_shift_left_bitset<60>(value, 13U).value())); + // //CHECK_EQUAL_HEX((value << 14U) & mask, (generate_shift_left_bitset<60>(value, 14U).value())); + // //CHECK_EQUAL_HEX((value << 15U) & mask, (generate_shift_left_bitset<60>(value, 15U).value())); + // //CHECK_EQUAL_HEX((value << 16U) & mask, (generate_shift_left_bitset<60>(value, 16U).value())); + // //CHECK_EQUAL_HEX((value << 17U) & mask, (generate_shift_left_bitset<60>(value, 17U).value())); + // //CHECK_EQUAL_HEX((value << 18U) & mask, (generate_shift_left_bitset<60>(value, 18U).value())); + // //CHECK_EQUAL_HEX((value << 19U) & mask, (generate_shift_left_bitset<60>(value, 19U).value())); + // //CHECK_EQUAL_HEX((value << 20U) & mask, (generate_shift_left_bitset<60>(value, 20U).value())); + // //CHECK_EQUAL_HEX((value << 21U) & mask, (generate_shift_left_bitset<60>(value, 21U).value())); + // //CHECK_EQUAL_HEX((value << 22U) & mask, (generate_shift_left_bitset<60>(value, 22U).value())); + // //CHECK_EQUAL_HEX((value << 23U) & mask, (generate_shift_left_bitset<60>(value, 23U).value())); + // //CHECK_EQUAL_HEX((value << 24U) & mask, (generate_shift_left_bitset<60>(value, 24U).value())); + // //CHECK_EQUAL_HEX((value << 25U) & mask, (generate_shift_left_bitset<60>(value, 25U).value())); + // //CHECK_EQUAL_HEX((value << 26U) & mask, (generate_shift_left_bitset<60>(value, 26U).value())); + // //CHECK_EQUAL_HEX((value << 27U) & mask, (generate_shift_left_bitset<60>(value, 27U).value())); + // //CHECK_EQUAL_HEX((value << 28U) & mask, (generate_shift_left_bitset<60>(value, 28U).value())); + // //CHECK_EQUAL_HEX((value << 29U) & mask, (generate_shift_left_bitset<60>(value, 29U).value())); + // //CHECK_EQUAL_HEX((value << 30U) & mask, (generate_shift_left_bitset<60>(value, 30U).value())); + // //CHECK_EQUAL_HEX((value << 31U) & mask, (generate_shift_left_bitset<60>(value, 31U).value())); + // //CHECK_EQUAL_HEX((value << 32U) & mask, (generate_shift_left_bitset<60>(value, 32U).value())); + // //CHECK_EQUAL_HEX((value << 33U) & mask, (generate_shift_left_bitset<60>(value, 33U).value())); + // //CHECK_EQUAL_HEX((value << 34U) & mask, (generate_shift_left_bitset<60>(value, 34U).value())); + // //CHECK_EQUAL_HEX((value << 35U) & mask, (generate_shift_left_bitset<60>(value, 35U).value())); + // //CHECK_EQUAL_HEX((value << 36U) & mask, (generate_shift_left_bitset<60>(value, 36U).value())); + // //CHECK_EQUAL_HEX((value << 37U) & mask, (generate_shift_left_bitset<60>(value, 37U).value())); + // //CHECK_EQUAL_HEX((value << 38U) & mask, (generate_shift_left_bitset<60>(value, 38U).value())); + // //CHECK_EQUAL_HEX((value << 39U) & mask, (generate_shift_left_bitset<60>(value, 39U).value())); + // //CHECK_EQUAL_HEX((value << 40U) & mask, (generate_shift_left_bitset<60>(value, 40U).value())); + // //CHECK_EQUAL_HEX((value << 41U) & mask, (generate_shift_left_bitset<60>(value, 41U).value())); + // //CHECK_EQUAL_HEX((value << 42U) & mask, (generate_shift_left_bitset<60>(value, 42U).value())); + // //CHECK_EQUAL_HEX((value << 43U) & mask, (generate_shift_left_bitset<60>(value, 43U).value())); + // //CHECK_EQUAL_HEX((value << 44U) & mask, (generate_shift_left_bitset<60>(value, 44U).value())); + // //CHECK_EQUAL_HEX((value << 45U) & mask, (generate_shift_left_bitset<60>(value, 45U).value())); + // //CHECK_EQUAL_HEX((value << 46U) & mask, (generate_shift_left_bitset<60>(value, 46U).value())); + // //CHECK_EQUAL_HEX((value << 47U) & mask, (generate_shift_left_bitset<60>(value, 47U).value())); + // //CHECK_EQUAL_HEX((value << 48U) & mask, (generate_shift_left_bitset<60>(value, 48U).value())); + // //CHECK_EQUAL_HEX((value << 49U) & mask, (generate_shift_left_bitset<60>(value, 49U).value())); + // //CHECK_EQUAL_HEX((value << 50U) & mask, (generate_shift_left_bitset<60>(value, 50U).value())); + // //CHECK_EQUAL_HEX((value << 51U) & mask, (generate_shift_left_bitset<60>(value, 51U).value())); + // //CHECK_EQUAL_HEX((value << 52U) & mask, (generate_shift_left_bitset<60>(value, 52U).value())); + // //CHECK_EQUAL_HEX((value << 53U) & mask, (generate_shift_left_bitset<60>(value, 53U).value())); + // //CHECK_EQUAL_HEX((value << 54U) & mask, (generate_shift_left_bitset<60>(value, 54U).value())); + // //CHECK_EQUAL_HEX((value << 55U) & mask, (generate_shift_left_bitset<60>(value, 55U).value())); + // //CHECK_EQUAL_HEX((value << 56U) & mask, (generate_shift_left_bitset<60>(value, 56U).value())); + // //CHECK_EQUAL_HEX((value << 57U) & mask, (generate_shift_left_bitset<60>(value, 57U).value())); + // //CHECK_EQUAL_HEX((value << 58U) & mask, (generate_shift_left_bitset<60>(value, 58U).value())); + // //CHECK_EQUAL_HEX((value << 59U) & mask, (generate_shift_left_bitset<60>(value, 59U).value())); + // //CHECK_EQUAL_HEX((value << 60U) & mask, (generate_shift_left_bitset<60>(value, 60U).value())); + // //CHECK_EQUAL_HEX((value << 61U) & mask, (generate_shift_left_bitset<60>(value, 61U).value())); + // //CHECK_EQUAL_HEX((value << 62U) & mask, (generate_shift_left_bitset<60>(value, 62U).value())); + // //CHECK_EQUAL_HEX((value << 63U) & mask, (generate_shift_left_bitset<60>(value, 63U).value())); + // //CHECK_EQUAL_HEX(0ULL, (generate_shift_left_bitset<60>(value, 64U).value())); + //} + + ////************************************************************************* + //TEST(test_shift_right_operator) + //{ + // constexpr etl::bitset<60> shift1(0x91A2B3CULL); + // constexpr etl::bitset<60> shift2(0x48D159EULL); + // constexpr etl::bitset<60> shift11(0x2468AULL); + + // CHECK(generate_shift_right_bitset<60>(0x12345678ULL, 1U) == shift1); + // CHECK(generate_shift_right_bitset<60>(0x12345678ULL, 2U) == shift2); + // CHECK(generate_shift_right_bitset<60>(0x12345678ULL, 11U) == shift11); + //} + + ////************************************************************************* + //TEST(test_shift_right_copy_operator) + //{ + // constexpr etl::bitset<60> shift8(0x123456ULL); + // CHECK_EQUAL_HEX(shift8.value(), generate_shift_right_bitset_copy<60>(0x12345678UL, 8U).value()); + + // constexpr etl::bitset<60> shift16(0x1234ULL); + // CHECK_EQUAL_HEX(shift16.value(), generate_shift_right_bitset_copy<60>(0x12345678UL, 16U).value()); + + // constexpr etl::bitset<60> shift24(0x12ULL); + // CHECK_EQUAL_HEX(shift24.value(), generate_shift_right_bitset_copy<60>(0x12345678UL, 24U).value()); + + // constexpr etl::bitset<60> shift60(0x00ULL); + // CHECK_EQUAL_HEX(shift60.value(), generate_shift_right_bitset_copy<60>(0x12345678UL, 60U).value()); + //} + + ////************************************************************************* + //TEST(test_shift_right_operator_all_shifts_full_size) + //{ + // uint64_t value = 0x0123456789ABCDEFULL; + + // //CHECK_EQUAL_HEX((value >> 0U), (generate_shift_right_bitset<64>(value, 0U).value())); + // //CHECK_EQUAL_HEX((value >> 1U), (generate_shift_right_bitset<64>(value, 1U).value())); + // //CHECK_EQUAL_HEX((value >> 2U), (generate_shift_right_bitset<64>(value, 2U).value())); + // //CHECK_EQUAL_HEX((value >> 3U), (generate_shift_right_bitset<64>(value, 3U).value())); + // //CHECK_EQUAL_HEX((value >> 4U), (generate_shift_right_bitset<64>(value, 4U).value())); + // //CHECK_EQUAL_HEX((value >> 5U), (generate_shift_right_bitset<64>(value, 5U).value())); + // //CHECK_EQUAL_HEX((value >> 6U), (generate_shift_right_bitset<64>(value, 6U).value())); + // //CHECK_EQUAL_HEX((value >> 7U), (generate_shift_right_bitset<64>(value, 7U).value())); + // //CHECK_EQUAL_HEX((value >> 8U), (generate_shift_right_bitset<64>(value, 8U).value())); + // //CHECK_EQUAL_HEX((value >> 9U), (generate_shift_right_bitset<64>(value, 9U).value())); + // //CHECK_EQUAL_HEX((value >> 10U), (generate_shift_right_bitset<64>(value, 10U).value())); + // //CHECK_EQUAL_HEX((value >> 11U), (generate_shift_right_bitset<64>(value, 11U).value())); + // //CHECK_EQUAL_HEX((value >> 12U), (generate_shift_right_bitset<64>(value, 12U).value())); + // //CHECK_EQUAL_HEX((value >> 13U), (generate_shift_right_bitset<64>(value, 13U).value())); + // //CHECK_EQUAL_HEX((value >> 14U), (generate_shift_right_bitset<64>(value, 14U).value())); + // //CHECK_EQUAL_HEX((value >> 15U), (generate_shift_right_bitset<64>(value, 15U).value())); + // //CHECK_EQUAL_HEX((value >> 16U), (generate_shift_right_bitset<64>(value, 16U).value())); + // //CHECK_EQUAL_HEX((value >> 17U), (generate_shift_right_bitset<64>(value, 17U).value())); + // //CHECK_EQUAL_HEX((value >> 18U), (generate_shift_right_bitset<64>(value, 18U).value())); + // //CHECK_EQUAL_HEX((value >> 19U), (generate_shift_right_bitset<64>(value, 19U).value())); + // //CHECK_EQUAL_HEX((value >> 20U), (generate_shift_right_bitset<64>(value, 20U).value())); + // //CHECK_EQUAL_HEX((value >> 21U), (generate_shift_right_bitset<64>(value, 21U).value())); + // //CHECK_EQUAL_HEX((value >> 22U), (generate_shift_right_bitset<64>(value, 22U).value())); + // //CHECK_EQUAL_HEX((value >> 23U), (generate_shift_right_bitset<64>(value, 23U).value())); + // //CHECK_EQUAL_HEX((value >> 24U), (generate_shift_right_bitset<64>(value, 24U).value())); + // //CHECK_EQUAL_HEX((value >> 25U), (generate_shift_right_bitset<64>(value, 25U).value())); + // //CHECK_EQUAL_HEX((value >> 26U), (generate_shift_right_bitset<64>(value, 26U).value())); + // //CHECK_EQUAL_HEX((value >> 27U), (generate_shift_right_bitset<64>(value, 27U).value())); + // //CHECK_EQUAL_HEX((value >> 28U), (generate_shift_right_bitset<64>(value, 28U).value())); + // //CHECK_EQUAL_HEX((value >> 29U), (generate_shift_right_bitset<64>(value, 29U).value())); + // //CHECK_EQUAL_HEX((value >> 30U), (generate_shift_right_bitset<64>(value, 30U).value())); + // //CHECK_EQUAL_HEX((value >> 31U), (generate_shift_right_bitset<64>(value, 31U).value())); + // //CHECK_EQUAL_HEX((value >> 32U), (generate_shift_right_bitset<64>(value, 32U).value())); + // //CHECK_EQUAL_HEX((value >> 33U), (generate_shift_right_bitset<64>(value, 33U).value())); + // //CHECK_EQUAL_HEX((value >> 34U), (generate_shift_right_bitset<64>(value, 34U).value())); + // //CHECK_EQUAL_HEX((value >> 35U), (generate_shift_right_bitset<64>(value, 35U).value())); + // //CHECK_EQUAL_HEX((value >> 36U), (generate_shift_right_bitset<64>(value, 36U).value())); + // //CHECK_EQUAL_HEX((value >> 37U), (generate_shift_right_bitset<64>(value, 37U).value())); + // //CHECK_EQUAL_HEX((value >> 38U), (generate_shift_right_bitset<64>(value, 38U).value())); + // //CHECK_EQUAL_HEX((value >> 39U), (generate_shift_right_bitset<64>(value, 39U).value())); + // //CHECK_EQUAL_HEX((value >> 40U), (generate_shift_right_bitset<64>(value, 40U).value())); + // //CHECK_EQUAL_HEX((value >> 41U), (generate_shift_right_bitset<64>(value, 41U).value())); + // //CHECK_EQUAL_HEX((value >> 42U), (generate_shift_right_bitset<64>(value, 42U).value())); + // //CHECK_EQUAL_HEX((value >> 43U), (generate_shift_right_bitset<64>(value, 43U).value())); + // //CHECK_EQUAL_HEX((value >> 44U), (generate_shift_right_bitset<64>(value, 44U).value())); + // //CHECK_EQUAL_HEX((value >> 45U), (generate_shift_right_bitset<64>(value, 45U).value())); + // //CHECK_EQUAL_HEX((value >> 46U), (generate_shift_right_bitset<64>(value, 46U).value())); + // //CHECK_EQUAL_HEX((value >> 47U), (generate_shift_right_bitset<64>(value, 47U).value())); + // //CHECK_EQUAL_HEX((value >> 48U), (generate_shift_right_bitset<64>(value, 48U).value())); + // //CHECK_EQUAL_HEX((value >> 49U), (generate_shift_right_bitset<64>(value, 49U).value())); + // //CHECK_EQUAL_HEX((value >> 50U), (generate_shift_right_bitset<64>(value, 50U).value())); + // //CHECK_EQUAL_HEX((value >> 51U), (generate_shift_right_bitset<64>(value, 51U).value())); + // //CHECK_EQUAL_HEX((value >> 52U), (generate_shift_right_bitset<64>(value, 52U).value())); + // //CHECK_EQUAL_HEX((value >> 53U), (generate_shift_right_bitset<64>(value, 53U).value())); + // //CHECK_EQUAL_HEX((value >> 54U), (generate_shift_right_bitset<64>(value, 54U).value())); + // //CHECK_EQUAL_HEX((value >> 55U), (generate_shift_right_bitset<64>(value, 55U).value())); + // //CHECK_EQUAL_HEX((value >> 56U), (generate_shift_right_bitset<64>(value, 56U).value())); + // //CHECK_EQUAL_HEX((value >> 57U), (generate_shift_right_bitset<64>(value, 57U).value())); + // //CHECK_EQUAL_HEX((value >> 58U), (generate_shift_right_bitset<64>(value, 58U).value())); + // //CHECK_EQUAL_HEX((value >> 59U), (generate_shift_right_bitset<64>(value, 59U).value())); + // //CHECK_EQUAL_HEX((value >> 60U), (generate_shift_right_bitset<64>(value, 60U).value())); + // //CHECK_EQUAL_HEX((value >> 61U), (generate_shift_right_bitset<64>(value, 61U).value())); + // //CHECK_EQUAL_HEX((value >> 62U), (generate_shift_right_bitset<64>(value, 62U).value())); + // //CHECK_EQUAL_HEX((value >> 63U), (generate_shift_right_bitset<64>(value, 63U).value())); + // //CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64>(value, 64U).value())); + //} + + ////************************************************************************* + //TEST(test_shift_right_operator_all_shifts_partial_size) + //{ + // uint64_t value = 0x0123456789ABCDEFULL; + // uint64_t mask = 0x0FFFFFFFFFFFFFFFULL; + + // //CHECK_EQUAL_HEX((value >> 0U) & mask, (generate_shift_right_bitset<60>(value, 0U).value())); + // //CHECK_EQUAL_HEX((value >> 1U) & mask, (generate_shift_right_bitset<60>(value, 1U).value())); + // //CHECK_EQUAL_HEX((value >> 2U) & mask, (generate_shift_right_bitset<60>(value, 2U).value())); + // //CHECK_EQUAL_HEX((value >> 3U) & mask, (generate_shift_right_bitset<60>(value, 3U).value())); + // //CHECK_EQUAL_HEX((value >> 4U) & mask, (generate_shift_right_bitset<60>(value, 4U).value())); + // //CHECK_EQUAL_HEX((value >> 5U) & mask, (generate_shift_right_bitset<60>(value, 5U).value())); + // //CHECK_EQUAL_HEX((value >> 6U) & mask, (generate_shift_right_bitset<60>(value, 6U).value())); + // //CHECK_EQUAL_HEX((value >> 7U) & mask, (generate_shift_right_bitset<60>(value, 7U).value())); + // //CHECK_EQUAL_HEX((value >> 8U) & mask, (generate_shift_right_bitset<60>(value, 8U).value())); + // //CHECK_EQUAL_HEX((value >> 9U) & mask, (generate_shift_right_bitset<60>(value, 9U).value())); + // //CHECK_EQUAL_HEX((value >> 10U) & mask, (generate_shift_right_bitset<60>(value, 10U).value())); + // //CHECK_EQUAL_HEX((value >> 11U) & mask, (generate_shift_right_bitset<60>(value, 11U).value())); + // //CHECK_EQUAL_HEX((value >> 12U) & mask, (generate_shift_right_bitset<60>(value, 12U).value())); + // //CHECK_EQUAL_HEX((value >> 13U) & mask, (generate_shift_right_bitset<60>(value, 13U).value())); + // //CHECK_EQUAL_HEX((value >> 14U) & mask, (generate_shift_right_bitset<60>(value, 14U).value())); + // //CHECK_EQUAL_HEX((value >> 15U) & mask, (generate_shift_right_bitset<60>(value, 15U).value())); + // //CHECK_EQUAL_HEX((value >> 16U) & mask, (generate_shift_right_bitset<60>(value, 16U).value())); + // //CHECK_EQUAL_HEX((value >> 17U) & mask, (generate_shift_right_bitset<60>(value, 17U).value())); + // //CHECK_EQUAL_HEX((value >> 18U) & mask, (generate_shift_right_bitset<60>(value, 18U).value())); + // //CHECK_EQUAL_HEX((value >> 19U) & mask, (generate_shift_right_bitset<60>(value, 19U).value())); + // //CHECK_EQUAL_HEX((value >> 20U) & mask, (generate_shift_right_bitset<60>(value, 20U).value())); + // //CHECK_EQUAL_HEX((value >> 21U) & mask, (generate_shift_right_bitset<60>(value, 21U).value())); + // //CHECK_EQUAL_HEX((value >> 22U) & mask, (generate_shift_right_bitset<60>(value, 22U).value())); + // //CHECK_EQUAL_HEX((value >> 23U) & mask, (generate_shift_right_bitset<60>(value, 23U).value())); + // //CHECK_EQUAL_HEX((value >> 24U) & mask, (generate_shift_right_bitset<60>(value, 24U).value())); + // //CHECK_EQUAL_HEX((value >> 25U) & mask, (generate_shift_right_bitset<60>(value, 25U).value())); + // //CHECK_EQUAL_HEX((value >> 26U) & mask, (generate_shift_right_bitset<60>(value, 26U).value())); + // //CHECK_EQUAL_HEX((value >> 27U) & mask, (generate_shift_right_bitset<60>(value, 27U).value())); + // //CHECK_EQUAL_HEX((value >> 28U) & mask, (generate_shift_right_bitset<60>(value, 28U).value())); + // //CHECK_EQUAL_HEX((value >> 29U) & mask, (generate_shift_right_bitset<60>(value, 29U).value())); + // //CHECK_EQUAL_HEX((value >> 30U) & mask, (generate_shift_right_bitset<60>(value, 30U).value())); + // //CHECK_EQUAL_HEX((value >> 31U) & mask, (generate_shift_right_bitset<60>(value, 31U).value())); + // //CHECK_EQUAL_HEX((value >> 32U) & mask, (generate_shift_right_bitset<60>(value, 32U).value())); + // //CHECK_EQUAL_HEX((value >> 33U) & mask, (generate_shift_right_bitset<60>(value, 33U).value())); + // //CHECK_EQUAL_HEX((value >> 34U) & mask, (generate_shift_right_bitset<60>(value, 34U).value())); + // //CHECK_EQUAL_HEX((value >> 35U) & mask, (generate_shift_right_bitset<60>(value, 35U).value())); + // //CHECK_EQUAL_HEX((value >> 36U) & mask, (generate_shift_right_bitset<60>(value, 36U).value())); + // //CHECK_EQUAL_HEX((value >> 37U) & mask, (generate_shift_right_bitset<60>(value, 37U).value())); + // //CHECK_EQUAL_HEX((value >> 38U) & mask, (generate_shift_right_bitset<60>(value, 38U).value())); + // //CHECK_EQUAL_HEX((value >> 39U) & mask, (generate_shift_right_bitset<60>(value, 39U).value())); + // //CHECK_EQUAL_HEX((value >> 40U) & mask, (generate_shift_right_bitset<60>(value, 40U).value())); + // //CHECK_EQUAL_HEX((value >> 41U) & mask, (generate_shift_right_bitset<60>(value, 41U).value())); + // //CHECK_EQUAL_HEX((value >> 42U) & mask, (generate_shift_right_bitset<60>(value, 42U).value())); + // //CHECK_EQUAL_HEX((value >> 43U) & mask, (generate_shift_right_bitset<60>(value, 43U).value())); + // //CHECK_EQUAL_HEX((value >> 44U) & mask, (generate_shift_right_bitset<60>(value, 44U).value())); + // //CHECK_EQUAL_HEX((value >> 45U) & mask, (generate_shift_right_bitset<60>(value, 45U).value())); + // //CHECK_EQUAL_HEX((value >> 46U) & mask, (generate_shift_right_bitset<60>(value, 46U).value())); + // //CHECK_EQUAL_HEX((value >> 47U) & mask, (generate_shift_right_bitset<60>(value, 47U).value())); + // //CHECK_EQUAL_HEX((value >> 48U) & mask, (generate_shift_right_bitset<60>(value, 48U).value())); + // //CHECK_EQUAL_HEX((value >> 49U) & mask, (generate_shift_right_bitset<60>(value, 49U).value())); + // //CHECK_EQUAL_HEX((value >> 50U) & mask, (generate_shift_right_bitset<60>(value, 50U).value())); + // //CHECK_EQUAL_HEX((value >> 51U) & mask, (generate_shift_right_bitset<60>(value, 51U).value())); + // //CHECK_EQUAL_HEX((value >> 52U) & mask, (generate_shift_right_bitset<60>(value, 52U).value())); + // //CHECK_EQUAL_HEX((value >> 53U) & mask, (generate_shift_right_bitset<60>(value, 53U).value())); + // //CHECK_EQUAL_HEX((value >> 54U) & mask, (generate_shift_right_bitset<60>(value, 54U).value())); + // //CHECK_EQUAL_HEX((value >> 55U) & mask, (generate_shift_right_bitset<60>(value, 55U).value())); + // //CHECK_EQUAL_HEX((value >> 56U) & mask, (generate_shift_right_bitset<60>(value, 56U).value())); + // //CHECK_EQUAL_HEX((value >> 57U) & mask, (generate_shift_right_bitset<60>(value, 57U).value())); + // //CHECK_EQUAL_HEX((value >> 58U) & mask, (generate_shift_right_bitset<60>(value, 58U).value())); + // //CHECK_EQUAL_HEX((value >> 59U) & mask, (generate_shift_right_bitset<60>(value, 59U).value())); + // //CHECK_EQUAL_HEX((value >> 60U) & mask, (generate_shift_right_bitset<60>(value, 60U).value())); + // //CHECK_EQUAL_HEX((value >> 61U) & mask, (generate_shift_right_bitset<60>(value, 61U).value())); + // //CHECK_EQUAL_HEX((value >> 62U) & mask, (generate_shift_right_bitset<60>(value, 62U).value())); + // //CHECK_EQUAL_HEX((value >> 63U) & mask, (generate_shift_right_bitset<60>(value, 63U).value())); + // //CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<60>(value, 64U).value())); + //} + + ////************************************************************************* + //TEST(test_and_operator) + //{ + // constexpr etl::bitset<60> data1(0x12345678UL); + // constexpr etl::bitset<60> data2(0x23456789UL); + // constexpr etl::bitset<60> data4(0x12345678UL & 0x23456789UL); + + // constexpr etl::bitset<60> data3 = data1 & data2; + // CHECK(data3 == data4); + //} + + ////************************************************************************* + //constexpr etl::bitset<60> test_and_equals_operator_helper(etl::bitset<60> data1, const etl::bitset<60>& data2) + //{ + // data1 &= data2; + + // return data1; + //} + // + //TEST(test_and_equals_operator) + //{ + // constexpr etl::bitset<60> data1(0x12345678UL); + // constexpr etl::bitset<60> data2(0x23456789UL); + // + // constexpr etl::bitset<60> data3(test_and_equals_operator_helper(data1, data2)); + + // CHECK((data1 & data2) == data3); + //} + + ////************************************************************************* + //TEST(test_or_operator) + //{ + // constexpr etl::bitset<60> data1(0x12345678UL); + // constexpr etl::bitset<60> data2(0x23456789UL); + // constexpr etl::bitset<60> data4(0x12345678UL | 0x23456789UL); + + // constexpr etl::bitset<60> data3 = data1 | data2; + // CHECK(data3 == data4); + //} + + ////************************************************************************* + //constexpr etl::bitset<60> test_or_equals_operator_helper(etl::bitset<60> data1, const etl::bitset<60>& data2) + //{ + // data1 |= data2; + + // return data1; + //} + + //TEST(test_or_equals_operator) + //{ + // constexpr etl::bitset<60> data1(0x12345678UL); + // constexpr etl::bitset<60> data2(0x23456789UL); + + // constexpr etl::bitset<60> data3(test_or_equals_operator_helper(data1, data2)); + + // CHECK((data1 | data2) == data3); + //} + + ////************************************************************************* + //TEST(test_xor_operator) + //{ + // constexpr etl::bitset<60> data1(0x12345678UL); + // constexpr etl::bitset<60> data2(0x23456789UL); + // constexpr etl::bitset<60> data4(0x12345678UL | 0x23456789UL); + + // constexpr etl::bitset<60> data3 = data1 | data2; + // CHECK(data3 == data4); + //} + + ////************************************************************************* + //constexpr etl::bitset<60> test_xor_equals_operator_helper(etl::bitset<60> data1, const etl::bitset<60>& data2) + //{ + // data1 ^= data2; + + // return data1; + //} + + //TEST(test_xor_equals_operator) + //{ + // constexpr etl::bitset<60> data1(0x12345678UL); + // constexpr etl::bitset<60> data2(0x23456789UL); + + // constexpr etl::bitset<60> data3(test_xor_equals_operator_helper(data1, data2)); + + // CHECK((data1 ^ data2) == data3); + //} + + ////************************************************************************* + //TEST(test_find_first) + //{ + // constexpr etl::bitset<6> bs1(ull(0x00)); + // constexpr size_t bs1fff = bs1.find_first(false); + // constexpr size_t bs1fft = bs1.find_first(true); + // CHECK_EQUAL(0U, bs1fff); + // CHECK_EQUAL(etl::bitset<>::npos, bs1fft); + + // constexpr etl::bitset<6> bs2(ull(0x3F)); + // constexpr size_t bs2fff = bs2.find_first(false); + // constexpr size_t bs2fft = bs2.find_first(true); + // CHECK_EQUAL(etl::bitset<>::npos, bs2fff); + // CHECK_EQUAL(0U, bs2fft); + + // constexpr etl::bitset<6> bs3(ull(0x01)); + // constexpr size_t bs3fff = bs3.find_first(false); + // constexpr size_t bs3fft = bs3.find_first(true); + // CHECK_EQUAL(1U, bs3fff); + // CHECK_EQUAL(0U, bs3fft); + + // constexpr etl::bitset<6> bs4(ull(0x20)); + // constexpr size_t bs4fff = bs4.find_first(false); + // constexpr size_t bs4fft = bs4.find_first(true); + // CHECK_EQUAL(0U, bs4fff); + // CHECK_EQUAL(5U, bs4fft); + + // constexpr etl::bitset<6> bs5(ull(0x21)); + // constexpr size_t bs5fff = bs5.find_first(false); + // constexpr size_t bs5fft = bs5.find_first(true); + // CHECK_EQUAL(1U, bs5fff); + // CHECK_EQUAL(0U, bs5fft); + + // constexpr etl::bitset<6> bs6(ull(0x0E)); + // constexpr size_t bs6fff = bs6.find_first(false); + // constexpr size_t bs6fft = bs6.find_first(true); + // CHECK_EQUAL(0U, bs6fff); + // CHECK_EQUAL(1U, bs6fft); + + // constexpr etl::bitset<6> bs7(ull(0x31)); + // constexpr size_t bs7fff = bs7.find_first(false); + // constexpr size_t bs7fft = bs7.find_first(true); + // CHECK_EQUAL(1U, bs7fff); + // CHECK_EQUAL(0U, bs7fft); + //} + + ////************************************************************************* + //TEST(test_find_next) + //{ + // etl::bitset<6> data; + + // constexpr etl::bitset<6> bs1(ull(0x00)); + // constexpr size_t bs1fnf0 = bs1.find_next(false, 0); + // constexpr size_t bs1fnf1 = bs1.find_next(false, 1); + // constexpr size_t bs1fnt2 = bs1.find_next(true, 2); + // CHECK_EQUAL(0U, bs1fnf0); + // CHECK_EQUAL(1U, bs1fnf1); + // CHECK_EQUAL(etl::bitset<>::npos, bs1fnt2); + + // constexpr etl::bitset<6> bs2(ull(0x3F)); + // constexpr size_t bs2fnt0 = bs2.find_next(true, 0); + // constexpr size_t bs2fnt1 = bs2.find_next(true, 1); + // constexpr size_t bs2fnf2 = bs2.find_next(false, 2); + // CHECK_EQUAL(0U, bs2fnt0); + // CHECK_EQUAL(1U, bs2fnt1); + // CHECK_EQUAL(etl::bitset<>::npos, bs2fnf2); + + // constexpr etl::bitset<6> bs3(ull(0x0E)); + // constexpr size_t bs3fnf0 = bs3.find_next(false, 0); + // constexpr size_t bs3fnt1 = bs3.find_next(true, 1); + // constexpr size_t bs3fnf2 = bs3.find_next(false, 2); + // CHECK_EQUAL(0U, bs3fnf0); + // CHECK_EQUAL(1U, bs3fnt1); + // CHECK_EQUAL(4U, bs3fnf2); + + // constexpr etl::bitset<6> bs4(ull(0x31)); + // constexpr size_t bs4fnt0 = bs4.find_next(true, 0); + // constexpr size_t bs4fnf0 = bs4.find_next(false, 0); + // constexpr size_t bs4fnt1 = bs4.find_next(true, 1); + // CHECK_EQUAL(0U, bs4fnt0); + // CHECK_EQUAL(1U, bs4fnf0); + // CHECK_EQUAL(4U, bs4fnt1); + //} + + ////************************************************************************* + //constexpr std::pair, etl::bitset<6>> test_swap_helper() + //{ + // etl::bitset<6> data1(ull(0x2A)); + // etl::bitset<6> data2(ull(0x15)); + + // swap(data1, data2); + + // return std::pair, etl::bitset<6>>(data1, data2); + //} + + //TEST(test_swap) + //{ + // constexpr etl::bitset<6> compare1(0x2A); + // constexpr etl::bitset<6> compare2(0x15); + + // constexpr std::pair, etl::bitset<6>> swapped = test_swap_helper(); + + // CHECK(swapped.first == compare2); + // CHECK(swapped.second == compare1); + //} + + ////************************************************************************* + //TEST(test_span) + //{ + // using span_t = etl::bitset<32, char>::span_type; + + // etl::bitset<32, char> b(0x12345678UL); + + // span_t s = b.span(); + // CHECK_EQUAL(0x78U, s[0]); + // CHECK_EQUAL(0x56U, s[1]); + // CHECK_EQUAL(0x34U, s[2]); + // CHECK_EQUAL(0x12U, s[3]); + //} + + ////************************************************************************* + //TEST(test_const_span) + //{ + // using span_t = etl::bitset<32, char>::const_span_type; + + // const etl::bitset<32, char> b(0x12345678UL); + + // span_t s = b.span(); + // CHECK_EQUAL(0x78U, s[0]); + // CHECK_EQUAL(0x56U, s[1]); + // CHECK_EQUAL(0x34U, s[2]); + // CHECK_EQUAL(0x12U, s[3]); + //} + + ////************************************************************************* + //TEST(test_span_constexpr) + //{ + // using span_t = etl::bitset<32, char>::const_span_type; + + // constexpr etl::bitset<32, char> b(0x12345678UL); + + // constexpr span_t s = b.span(); + // CHECK_EQUAL(0x78U, s[0]); + // CHECK_EQUAL(0x56U, s[1]); + // CHECK_EQUAL(0x34U, s[2]); + // CHECK_EQUAL(0x12U, s[3]); + //} + + ////************************************************************************* + //TEST(test_to_string) + //{ + // //constexpr etl::bitset<32> b(0x12345678UL); + + // //etl::string<32> text = b.to_string('.', '*'); + // //std::string stdtext = b.to_string('.', '*'); + + // //CHECK_THROW(etl::string<32> text1 = b.to_string>('.', '*'), etl::bitset_overflow); + // //CHECK_EQUAL("...*..*...**.*...*.*.**..****...", text.c_str()); + // //CHECK_EQUAL("...*..*...**.*...*.*.**..****...", stdtext.c_str()); + //} }; }