From 305f34fbede50ffa2927c198ca27da6b230a66ba Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Mon, 4 Dec 2023 08:37:59 +0000 Subject: [PATCH] Work in progress for etl::bitset::extract --- include/etl/private/bitset_new.h | 100 +++- test/test_bitset_new_default_element_type.cpp | 82 ++- ...itset_new_explicit_single_element_type.cpp | 498 ++++++++++++++++-- ...st_bitset_new_ext_default_element_type.cpp | 437 ++++++++++++++- ...t_new_ext_explicit_single_element_type.cpp | 441 +++++++++++++++- 5 files changed, 1432 insertions(+), 126 deletions(-) diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h index 65128c75..6894feb9 100644 --- a/include/etl/private/bitset_new.h +++ b/include/etl/private/bitset_new.h @@ -418,7 +418,7 @@ namespace etl // Extract the first element, if partially filled. if (active_bits_in_msb < Bits_Per_Element) { - element_type mask = ~(~element_type(0) << active_bits_in_msb); + element_type mask = etl::make_lsb_mask< element_type>(active_bits_in_msb); value = pbuffer[element_index] & mask; length -= active_bits_in_msb; if (length >= Bits_Per_Element) @@ -444,7 +444,7 @@ namespace etl if (length != 0) { value = value << length; - element_type mask = ~(~element_type(0) << length); + element_type mask = etl::make_lsb_mask< element_type>(length); value |= (pbuffer[element_index] >> (Bits_Per_Element - length)) & mask; } @@ -468,7 +468,7 @@ namespace etl // Is the value contained within one element? if (Msb_Element_Index == Lsb_Element_Index) { - const unsigned_t Mask = ~(~0 << length); + const unsigned_t Mask = etl::make_lsb_mask< unsigned_t>(length); const unsigned_t Shift = position % Bits_Per_Element; value = static_cast(pbuffer[Msb_Element_Index] >> Shift) & Mask; @@ -498,7 +498,7 @@ namespace etl typedef typename etl::make_unsigned::type unsigned_t; const int Element_Index = (Position + Length - 1) >> etl::log2::value; - const unsigned_t Mask = ~(~0 << Length); + const unsigned_t Mask = etl::lsb_mask::value; const unsigned_t Shift = Position % Bits_Per_Element; return static_cast(pbuffer[Element_Index] >> Shift) & Mask; @@ -511,9 +511,7 @@ namespace etl ETL_CONSTEXPR14 typename etl::enable_if::value, typename etl::make_unsigned::type>::type extract_from_buffer(const_pointer pbuffer) const - { - typedef typename etl::make_unsigned::type unsigned_t; - + { const int Msb_Element_Index = (Position + Length - 1) >> etl::log2::value; // Start with index of the element containing the msb. @@ -978,7 +976,7 @@ namespace etl /// Specialisation that uses a single element if the element type is the /// same size as the number of active bits. //*************************************************************************** - template + template class bitset : public bitset_constants<> { public: @@ -1413,10 +1411,19 @@ namespace etl ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits::bits, ETL_ERROR(bitset_overflow), 0); ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0); - element_type mask = (~(~0u << length) << position); - T value((buffer & mask) >> position); + typedef typename etl::make_unsigned::type unsigned_t; - return value; + const unsigned_t Mask = etl::make_lsb_mask< unsigned_t>(length); + const unsigned_t Shift = position % Bits_Per_Element; + + unsigned_t value = static_cast(buffer >> Shift) & Mask; + + if ((length != etl::integral_limits::bits) && etl::integral_limits::is_signed) + { + value = etl::sign_extend(value, length); + } + + return static_cast(value); } //************************************************************************* @@ -1430,10 +1437,19 @@ namespace etl ETL_STATIC_ASSERT(Length <= etl::integral_limits::bits, "Length is larger that the required type"); ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset"); - element_type mask = (~(~0u << Length) << Position); - T value((buffer & mask) >> Position); + typedef typename etl::make_unsigned::type unsigned_t; - return value; + const unsigned_t Mask = etl::make_lsb_mask(); + const unsigned_t Shift = Position % Bits_Per_Element; + + unsigned_t value = static_cast(buffer >> Shift) & Mask; + + if ETL_IF_CONSTEXPR((Length != etl::integral_limits::bits) && etl::integral_limits::is_signed) + { + value = etl::sign_extend(value); + } + + return static_cast(value); } //************************************************************************* @@ -2213,7 +2229,7 @@ namespace etl value = etl::sign_extend(value, length); } - return value; + return static_cast(value); } //************************************************************************* @@ -2235,7 +2251,7 @@ namespace etl value = etl::sign_extend(value); } - return value; + return static_cast(value); } //************************************************************************* @@ -3202,10 +3218,19 @@ namespace etl { ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0); - element_type mask = (~(~0u << length) << position); - T v((*pbuffer & mask) >> position); + typedef typename etl::make_unsigned::type unsigned_t; - return v; + const unsigned_t Mask = etl::make_lsb_mask(length); + const unsigned_t Shift = position % Bits_Per_Element; + + unsigned_t value = static_cast(*pbuffer >> Shift) & Mask; + + if ((length != etl::integral_limits::bits) && etl::integral_limits::is_signed) + { + value = etl::sign_extend(value, length); + } + + return static_cast(value); } //************************************************************************* @@ -3218,10 +3243,19 @@ namespace etl { ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset"); - element_type mask = (~(~0u << Length) << Position); - T v((*pbuffer & mask) >> Position); + typedef typename etl::make_unsigned::type unsigned_t; - return v; + const unsigned_t Mask = etl::make_lsb_mask(); + const unsigned_t Shift = Position % Bits_Per_Element; + + unsigned_t value = static_cast(*pbuffer >> Shift) & Mask; + + if ETL_IF_CONSTEXPR((Length != etl::integral_limits::bits) && etl::integral_limits::is_signed) + { + value = etl::sign_extend(value); + } + + return static_cast(value); } //************************************************************************* @@ -3995,7 +4029,16 @@ namespace etl { ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0); - return ibitset.template extract_from_buffer(pbuffer, position, length); + typedef typename etl::make_unsigned::type unsigned_t; + + unsigned_t value = ibitset.template extract_from_buffer(pbuffer, position, length); + + if ((length != etl::integral_limits::bits) && etl::integral_limits::is_signed) + { + value = etl::sign_extend(value, length); + } + + return static_cast(value); } //************************************************************************* @@ -4008,7 +4051,16 @@ namespace etl { ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset"); - return ibitset.template extract_from_buffer(pbuffer); + typedef typename etl::make_unsigned::type unsigned_t; + + unsigned_t value = ibitset.template extract_from_buffer(pbuffer); + + if ETL_IF_CONSTEXPR((Length != etl::integral_limits::bits) && etl::integral_limits::is_signed) + { + value = etl::sign_extend(value); + } + + return static_cast(value); } //************************************************************************* diff --git a/test/test_bitset_new_default_element_type.cpp b/test/test_bitset_new_default_element_type.cpp index a0980425..266243f7 100644 --- a/test/test_bitset_new_default_element_type.cpp +++ b/test/test_bitset_new_default_element_type.cpp @@ -2177,18 +2177,16 @@ namespace { ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); - auto v = b.extract(1, 6); - - CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract(0, 6))); - CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract(1, 6))); - CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract(2, 6))); - CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract(3, 6))); - CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract(4, 6))); - CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract(5, 6))); - CHECK_EQUAL_HEX(int8_t(0x19), (b.extract(6, 6))); - CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract(7, 6))); - CHECK_EQUAL_HEX(int8_t(0x16), (b.extract(8, 6))); - CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract(9, 6))); + CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract( 0, 6))); + CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract( 1, 6))); + CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract( 2, 6))); + CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract( 3, 6))); + CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract( 4, 6))); + CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract( 5, 6))); + CHECK_EQUAL_HEX(int8_t(0x19), (b.extract( 6, 6))); + CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract( 7, 6))); + CHECK_EQUAL_HEX(int8_t(0x16), (b.extract( 8, 6))); + CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract( 9, 6))); CHECK_EQUAL_HEX(int8_t(0x15), (b.extract(10, 6))); CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract(11, 6))); CHECK_EQUAL_HEX(int8_t(0x05), (b.extract(12, 6))); @@ -2216,16 +2214,16 @@ namespace { ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); - CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract())); - CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract())); - CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract())); - CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract())); - CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract())); - CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract())); - CHECK_EQUAL_HEX(int8_t(0x19), (b.extract())); - CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract())); - CHECK_EQUAL_HEX(int8_t(0x16), (b.extract())); - CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x19), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x16), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract())); CHECK_EQUAL_HEX(int8_t(0x15), (b.extract())); CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract())); CHECK_EQUAL_HEX(int8_t(0x05), (b.extract())); @@ -2512,16 +2510,16 @@ namespace { ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); - CHECK_EQUAL_HEX(int16_t(0x5678), b.extract(0, 16)); - CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract(1, 16)); - CHECK_EQUAL_HEX(int16_t(0x159E), b.extract(2, 16)); - CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract(3, 16)); - CHECK_EQUAL_HEX(int16_t(0x4567), b.extract(4, 16)); - CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract(5, 16)); - CHECK_EQUAL_HEX(int16_t(0xD159), b.extract(6, 16)); - CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract(7, 16)); - CHECK_EQUAL_HEX(int16_t(0x3456), b.extract(8, 16)); - CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract(9, 16)); + CHECK_EQUAL_HEX(int16_t(0x5678), b.extract( 0, 16)); + CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract( 1, 16)); + CHECK_EQUAL_HEX(int16_t(0x159E), b.extract( 2, 16)); + CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract( 3, 16)); + CHECK_EQUAL_HEX(int16_t(0x4567), b.extract( 4, 16)); + CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract( 5, 16)); + CHECK_EQUAL_HEX(int16_t(0xD159), b.extract( 6, 16)); + CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract( 7, 16)); + CHECK_EQUAL_HEX(int16_t(0x3456), b.extract( 8, 16)); + CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract( 9, 16)); CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract(10, 16)); CHECK_EQUAL_HEX(int16_t(0x468A), b.extract(11, 16)); CHECK_EQUAL_HEX(int16_t(0x2345), b.extract(12, 16)); @@ -2539,16 +2537,16 @@ namespace { ETL_CONSTEXPR14 etl::bitset<32> b(0x12345678UL); - CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract())); - CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract())); - CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract())); - CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract())); - CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract())); - CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract())); - CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract())); - CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract())); - CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract())); - CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract())); CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract())); CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract())); CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract())); diff --git a/test/test_bitset_new_explicit_single_element_type.cpp b/test/test_bitset_new_explicit_single_element_type.cpp index 8e161389..ad8f8fe1 100644 --- a/test/test_bitset_new_explicit_single_element_type.cpp +++ b/test/test_bitset_new_explicit_single_element_type.cpp @@ -1586,36 +1586,188 @@ namespace CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str())); } + //************************************************************************* + TEST(test_extract_6_bit_uint8_t_with_run_time_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract( 0, 6))); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract( 1, 6))); + CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract( 2, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract( 3, 6))); + CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract( 4, 6))); + CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract( 5, 6))); + CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract( 6, 6))); + CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract( 7, 6))); + CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract( 8, 6))); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract( 9, 6))); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract(10, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract(11, 6))); + CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract(12, 6))); + CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract(13, 6))); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract(14, 6))); + CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract(15, 6))); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract(16, 6))); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract(17, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract(18, 6))); + CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract(19, 6))); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract(20, 6))); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract(21, 6))); + CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract(22, 6))); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract(23, 6))); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract(24, 6))); + CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract(25, 6))); + CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract(26, 6))); + + CHECK_THROW(b.extract(26, 7), etl::bitset_overflow); + CHECK_THROW(b.extract(27, 6), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_6_bit_uint8_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract())); + + // The lines below should static assert. + //uint8_t v1 = b.extract(); + //uint8_t v1 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_6_bit_int8_t_with_run_time_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract( 0, 6))); + CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract( 1, 6))); + CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract( 2, 6))); + CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract( 3, 6))); + CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract( 4, 6))); + CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract( 5, 6))); + CHECK_EQUAL_HEX(int8_t(0x19), (b.extract( 6, 6))); + CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract( 7, 6))); + CHECK_EQUAL_HEX(int8_t(0x16), (b.extract( 8, 6))); + CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract( 9, 6))); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract(10, 6))); + CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract(11, 6))); + CHECK_EQUAL_HEX(int8_t(0x05), (b.extract(12, 6))); + CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract(13, 6))); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract(14, 6))); + CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract(15, 6))); + CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract(16, 6))); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract(17, 6))); + CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract(18, 6))); + CHECK_EQUAL_HEX(int8_t(0x06), (b.extract(19, 6))); + CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract(20, 6))); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract(21, 6))); + CHECK_EQUAL_HEX(int8_t(0x08), (b.extract(22, 6))); + CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract(23, 6))); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract(24, 6))); + CHECK_EQUAL_HEX(int8_t(0x09), (b.extract(25, 6))); + CHECK_EQUAL_HEX(int8_t(0x04), (b.extract(26, 6))); + + CHECK_THROW(b.extract(26, 7), etl::bitset_overflow); + CHECK_THROW(b.extract(27, 6), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_6_bit_int8_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x19), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x16), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x05), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x06), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x08), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x09), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x04), (b.extract())); + + // The lines below should static assert. + //int8_t v1 = b.extract(); + //int8_t v1 = b.extract(); + } + //************************************************************************* TEST(test_extract_uint8_t_with_run_time_parameters) { ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); - CHECK_EQUAL(0x78, b.extract(0, 8)); - CHECK_EQUAL(0x3C, b.extract(1, 8)); - CHECK_EQUAL(0x9E, b.extract(2, 8)); - CHECK_EQUAL(0xCF, b.extract(3, 8)); - CHECK_EQUAL(0x67, b.extract(4, 8)); - CHECK_EQUAL(0xB3, b.extract(5, 8)); - CHECK_EQUAL(0x59, b.extract(6, 8)); - CHECK_EQUAL(0xAC, b.extract(7, 8)); - CHECK_EQUAL(0x56, b.extract(8, 8)); - CHECK_EQUAL(0x2B, b.extract(9, 8)); - CHECK_EQUAL(0x15, b.extract(10, 8)); - CHECK_EQUAL(0x8A, b.extract(11, 8)); - CHECK_EQUAL(0x45, b.extract(12, 8)); - CHECK_EQUAL(0xA2, b.extract(13, 8)); - CHECK_EQUAL(0xD1, b.extract(14, 8)); - CHECK_EQUAL(0x68, b.extract(15, 8)); - CHECK_EQUAL(0x34, b.extract(16, 8)); - CHECK_EQUAL(0x1A, b.extract(17, 8)); - CHECK_EQUAL(0x8D, b.extract(18, 8)); - CHECK_EQUAL(0x46, b.extract(19, 8)); - CHECK_EQUAL(0x23, b.extract(20, 8)); - CHECK_EQUAL(0x91, b.extract(21, 8)); - CHECK_EQUAL(0x48, b.extract(22, 8)); - CHECK_EQUAL(0x24, b.extract(23, 8)); - CHECK_EQUAL(0x12, b.extract(24, 8)); + CHECK_EQUAL_HEX(uint8_t(0x78), b.extract( 0, 8)); + CHECK_EQUAL_HEX(uint8_t(0x3C), b.extract( 1, 8)); + CHECK_EQUAL_HEX(uint8_t(0x9E), b.extract( 2, 8)); + CHECK_EQUAL_HEX(uint8_t(0xCF), b.extract( 3, 8)); + CHECK_EQUAL_HEX(uint8_t(0x67), b.extract( 4, 8)); + CHECK_EQUAL_HEX(uint8_t(0xB3), b.extract( 5, 8)); + CHECK_EQUAL_HEX(uint8_t(0x59), b.extract( 6, 8)); + CHECK_EQUAL_HEX(uint8_t(0xAC), b.extract( 7, 8)); + CHECK_EQUAL_HEX(uint8_t(0x56), b.extract( 8, 8)); + CHECK_EQUAL_HEX(uint8_t(0x2B), b.extract( 9, 8)); + CHECK_EQUAL_HEX(uint8_t(0x15), b.extract(10, 8)); + CHECK_EQUAL_HEX(uint8_t(0x8A), b.extract(11, 8)); + CHECK_EQUAL_HEX(uint8_t(0x45), b.extract(12, 8)); + CHECK_EQUAL_HEX(uint8_t(0xA2), b.extract(13, 8)); + CHECK_EQUAL_HEX(uint8_t(0xD1), b.extract(14, 8)); + CHECK_EQUAL_HEX(uint8_t(0x68), b.extract(15, 8)); + CHECK_EQUAL_HEX(uint8_t(0x34), b.extract(16, 8)); + CHECK_EQUAL_HEX(uint8_t(0x1A), b.extract(17, 8)); + CHECK_EQUAL_HEX(uint8_t(0x8D), b.extract(18, 8)); + CHECK_EQUAL_HEX(uint8_t(0x46), b.extract(19, 8)); + CHECK_EQUAL_HEX(uint8_t(0x23), b.extract(20, 8)); + CHECK_EQUAL_HEX(uint8_t(0x91), b.extract(21, 8)); + CHECK_EQUAL_HEX(uint8_t(0x48), b.extract(22, 8)); + CHECK_EQUAL_HEX(uint8_t(0x24), b.extract(23, 8)); + CHECK_EQUAL_HEX(uint8_t(0x12), b.extract(24, 8)); + + CHECK_THROW(b.extract(24, 9), etl::bitset_overflow); CHECK_THROW(b.extract(25, 8), etl::bitset_overflow); } @@ -1624,35 +1776,277 @@ namespace { ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); - CHECK_EQUAL(0x78, (b.extract())); - CHECK_EQUAL(0x3C, (b.extract())); - CHECK_EQUAL(0x9E, (b.extract())); - CHECK_EQUAL(0xCF, (b.extract())); - CHECK_EQUAL(0x67, (b.extract())); - CHECK_EQUAL(0xB3, (b.extract())); - CHECK_EQUAL(0x59, (b.extract())); - CHECK_EQUAL(0xAC, (b.extract())); - CHECK_EQUAL(0x56, (b.extract())); - CHECK_EQUAL(0x2B, (b.extract())); - CHECK_EQUAL(0x15, (b.extract())); - CHECK_EQUAL(0x8A, (b.extract())); - CHECK_EQUAL(0x45, (b.extract())); - CHECK_EQUAL(0xA2, (b.extract())); - CHECK_EQUAL(0xD1, (b.extract())); - CHECK_EQUAL(0x68, (b.extract())); - CHECK_EQUAL(0x34, (b.extract())); - CHECK_EQUAL(0x1A, (b.extract())); - CHECK_EQUAL(0x8D, (b.extract())); - CHECK_EQUAL(0x46, (b.extract())); - CHECK_EQUAL(0x23, (b.extract())); - CHECK_EQUAL(0x91, (b.extract())); - CHECK_EQUAL(0x48, (b.extract())); - CHECK_EQUAL(0x24, (b.extract())); - CHECK_EQUAL(0x12, (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x78), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x9E), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xCF), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x67), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xB3), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x59), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xAC), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x56), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x8A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x45), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xA2), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0xD1), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x68), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x8D), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x46), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x91), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x48), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract())); // The lines below should static assert. - //uint8_t v = b.extract(); - //uint8_t v = b.extract(); + //uint8_t v1 = b.extract(); + //uint8_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_int8_t_with_run_time_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(int8_t(0x78), b.extract( 0, 8)); + CHECK_EQUAL_HEX(int8_t(0x3C), b.extract( 1, 8)); + CHECK_EQUAL_HEX(int8_t(0x9E), b.extract( 2, 8)); + CHECK_EQUAL_HEX(int8_t(0xCF), b.extract( 3, 8)); + CHECK_EQUAL_HEX(int8_t(0x67), b.extract( 4, 8)); + CHECK_EQUAL_HEX(int8_t(0xB3), b.extract( 5, 8)); + CHECK_EQUAL_HEX(int8_t(0x59), b.extract( 6, 8)); + CHECK_EQUAL_HEX(int8_t(0xAC), b.extract( 7, 8)); + CHECK_EQUAL_HEX(int8_t(0x56), b.extract( 8, 8)); + CHECK_EQUAL_HEX(int8_t(0x2B), b.extract( 9, 8)); + CHECK_EQUAL_HEX(int8_t(0x15), b.extract(10, 8)); + CHECK_EQUAL_HEX(int8_t(0x8A), b.extract(11, 8)); + CHECK_EQUAL_HEX(int8_t(0x45), b.extract(12, 8)); + CHECK_EQUAL_HEX(int8_t(0xA2), b.extract(13, 8)); + CHECK_EQUAL_HEX(int8_t(0xD1), b.extract(14, 8)); + CHECK_EQUAL_HEX(int8_t(0x68), b.extract(15, 8)); + CHECK_EQUAL_HEX(int8_t(0x34), b.extract(16, 8)); + CHECK_EQUAL_HEX(int8_t(0x1A), b.extract(17, 8)); + CHECK_EQUAL_HEX(int8_t(0x8D), b.extract(18, 8)); + CHECK_EQUAL_HEX(int8_t(0x46), b.extract(19, 8)); + CHECK_EQUAL_HEX(int8_t(0x23), b.extract(20, 8)); + CHECK_EQUAL_HEX(int8_t(0x91), b.extract(21, 8)); + CHECK_EQUAL_HEX(int8_t(0x48), b.extract(22, 8)); + CHECK_EQUAL_HEX(int8_t(0x24), b.extract(23, 8)); + CHECK_EQUAL_HEX(int8_t(0x12), b.extract(24, 8)); + + CHECK_THROW(b.extract(24, 9), etl::bitset_overflow); + CHECK_THROW(b.extract(25, 8), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_int8_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(int8_t(0x78), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x67), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x59), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x56), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x8A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x45), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xA2), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xD1), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x68), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x8D), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x46), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x91), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x48), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract())); + + // The lines below should static assert. + //int8_t v1 = b.extract(); + //int8_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_13_bits_uint16_t_with_run_time_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract( 0, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract( 1, 13)); + CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract( 2, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract( 3, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract( 4, 13)); + CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract( 5, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract( 6, 13)); + CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract( 7, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract( 8, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract( 9, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract(10, 13)); + CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract(11, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract(12, 13)); + CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract(13, 13)); + CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract(14, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract(15, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract(16, 13)); + CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract(17, 13)); + CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract(18, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract(19, 13)); + + CHECK_THROW(b.extract(19, 14), etl::bitset_overflow); + CHECK_THROW(b.extract(20, 13), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_13_bits_uint16_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract())); + + // The lines below should static assert. + //uint16_t v1 = b.extract b(0x12345678UL); + + CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract( 0, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract( 1, 16)); + CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract( 2, 16)); + CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract( 3, 16)); + CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract( 4, 16)); + CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract( 5, 16)); + CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract( 6, 16)); + CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract( 7, 16)); + CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract( 8, 16)); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract( 9, 16)); + CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract(10, 16)); + CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract(11, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract(12, 16)); + CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract(13, 16)); + CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract(14, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract(15, 16)); + CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract(16, 16)); + + CHECK_THROW(b.extract(16, 17), etl::bitset_overflow); + CHECK_THROW(b.extract(17, 16), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_uint16_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract())); + + // The lines below should static assert. + //uint16_t v1 = b.extract(); + //uint16_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_int16_t_with_run_time_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(int16_t(0x5678), b.extract( 0, 16)); + CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract( 1, 16)); + CHECK_EQUAL_HEX(int16_t(0x159E), b.extract( 2, 16)); + CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract( 3, 16)); + CHECK_EQUAL_HEX(int16_t(0x4567), b.extract( 4, 16)); + CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract( 5, 16)); + CHECK_EQUAL_HEX(int16_t(0xD159), b.extract( 6, 16)); + CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract( 7, 16)); + CHECK_EQUAL_HEX(int16_t(0x3456), b.extract( 8, 16)); + CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract( 9, 16)); + CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract(10, 16)); + CHECK_EQUAL_HEX(int16_t(0x468A), b.extract(11, 16)); + CHECK_EQUAL_HEX(int16_t(0x2345), b.extract(12, 16)); + CHECK_EQUAL_HEX(int16_t(0x91A2), b.extract(13, 16)); + CHECK_EQUAL_HEX(int16_t(0x48D1), b.extract(14, 16)); + CHECK_EQUAL_HEX(int16_t(0x2468), b.extract(15, 16)); + CHECK_EQUAL_HEX(int16_t(0x1234), b.extract(16, 16)); + + CHECK_THROW(b.extract(16, 17), etl::bitset_overflow); + CHECK_THROW(b.extract(17, 16), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_int16_t_with_template_parameters) + { + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL); + + CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x91A2), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x48D1), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x2468), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x1234), (b.extract())); + + // The lines below should static assert. + //int16_t v1 = b.extract()); + //int16_t v2 = b.extract()); } }; } diff --git a/test/test_bitset_new_ext_default_element_type.cpp b/test/test_bitset_new_ext_default_element_type.cpp index 7e377a95..201e98e6 100644 --- a/test/test_bitset_new_ext_default_element_type.cpp +++ b/test/test_bitset_new_ext_default_element_type.cpp @@ -1958,6 +1958,168 @@ namespace CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str())); } + //************************************************************************* + TEST(test_extract_6_bit_uint8_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract( 0, 6))); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract( 1, 6))); + CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract( 2, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract( 3, 6))); + CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract( 4, 6))); + CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract( 5, 6))); + CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract( 6, 6))); + CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract( 7, 6))); + CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract( 8, 6))); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract( 9, 6))); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract(10, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract(11, 6))); + CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract(12, 6))); + CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract(13, 6))); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract(14, 6))); + CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract(15, 6))); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract(16, 6))); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract(17, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract(18, 6))); + CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract(19, 6))); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract(20, 6))); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract(21, 6))); + CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract(22, 6))); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract(23, 6))); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract(24, 6))); + CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract(25, 6))); + CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract(26, 6))); + + CHECK_THROW(b.extract(26, 7), etl::bitset_overflow); + CHECK_THROW(b.extract(27, 6), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_6_bit_uint8_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract())); + + // The lines below should static assert. + //uint8_t v1 = b.extract(); + //uint8_t v1 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_6_bit_int8_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract( 0, 6))); + CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract( 1, 6))); + CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract( 2, 6))); + CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract( 3, 6))); + CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract( 4, 6))); + CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract( 5, 6))); + CHECK_EQUAL_HEX(int8_t(0x19), (b.extract( 6, 6))); + CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract( 7, 6))); + CHECK_EQUAL_HEX(int8_t(0x16), (b.extract( 8, 6))); + CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract( 9, 6))); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract(10, 6))); + CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract(11, 6))); + CHECK_EQUAL_HEX(int8_t(0x05), (b.extract(12, 6))); + CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract(13, 6))); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract(14, 6))); + CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract(15, 6))); + CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract(16, 6))); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract(17, 6))); + CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract(18, 6))); + CHECK_EQUAL_HEX(int8_t(0x06), (b.extract(19, 6))); + CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract(20, 6))); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract(21, 6))); + CHECK_EQUAL_HEX(int8_t(0x08), (b.extract(22, 6))); + CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract(23, 6))); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract(24, 6))); + CHECK_EQUAL_HEX(int8_t(0x09), (b.extract(25, 6))); + CHECK_EQUAL_HEX(int8_t(0x04), (b.extract(26, 6))); + + CHECK_THROW(b.extract(26, 7), etl::bitset_overflow); + CHECK_THROW(b.extract(27, 6), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_6_bit_int8_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x19), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x16), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x05), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x06), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x08), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x09), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x04), (b.extract())); + + // The lines below should static assert. + //int8_t v1 = b.extract(); + //int8_t v1 = b.extract(); + } + //************************************************************************* TEST(test_extract_uint8_t_with_run_time_parameters) { @@ -1991,6 +2153,9 @@ namespace CHECK_EQUAL_HEX(uint8_t(0x48), b.extract(22, 8)); CHECK_EQUAL_HEX(uint8_t(0x24), b.extract(23, 8)); CHECK_EQUAL_HEX(uint8_t(0x12), b.extract(24, 8)); + + CHECK_THROW(b.extract(24, 9), etl::bitset_overflow); + CHECK_THROW(b.extract(25, 8), etl::bitset_overflow); } //************************************************************************* @@ -2027,9 +2192,275 @@ namespace CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract())); CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract())); - // The line below should static assert. - //uint8_t v = b.extract(); - //uint8_t v = b.extract(); + // The lines below should static assert. + //uint8_t v1 = b.extract(); + //uint8_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_int8_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(int8_t(0x78), b.extract( 0, 8)); + CHECK_EQUAL_HEX(int8_t(0x3C), b.extract( 1, 8)); + CHECK_EQUAL_HEX(int8_t(0x9E), b.extract( 2, 8)); + CHECK_EQUAL_HEX(int8_t(0xCF), b.extract( 3, 8)); + CHECK_EQUAL_HEX(int8_t(0x67), b.extract( 4, 8)); + CHECK_EQUAL_HEX(int8_t(0xB3), b.extract( 5, 8)); + CHECK_EQUAL_HEX(int8_t(0x59), b.extract( 6, 8)); + CHECK_EQUAL_HEX(int8_t(0xAC), b.extract( 7, 8)); + CHECK_EQUAL_HEX(int8_t(0x56), b.extract( 8, 8)); + CHECK_EQUAL_HEX(int8_t(0x2B), b.extract( 9, 8)); + CHECK_EQUAL_HEX(int8_t(0x15), b.extract(10, 8)); + CHECK_EQUAL_HEX(int8_t(0x8A), b.extract(11, 8)); + CHECK_EQUAL_HEX(int8_t(0x45), b.extract(12, 8)); + CHECK_EQUAL_HEX(int8_t(0xA2), b.extract(13, 8)); + CHECK_EQUAL_HEX(int8_t(0xD1), b.extract(14, 8)); + CHECK_EQUAL_HEX(int8_t(0x68), b.extract(15, 8)); + CHECK_EQUAL_HEX(int8_t(0x34), b.extract(16, 8)); + CHECK_EQUAL_HEX(int8_t(0x1A), b.extract(17, 8)); + CHECK_EQUAL_HEX(int8_t(0x8D), b.extract(18, 8)); + CHECK_EQUAL_HEX(int8_t(0x46), b.extract(19, 8)); + CHECK_EQUAL_HEX(int8_t(0x23), b.extract(20, 8)); + CHECK_EQUAL_HEX(int8_t(0x91), b.extract(21, 8)); + CHECK_EQUAL_HEX(int8_t(0x48), b.extract(22, 8)); + CHECK_EQUAL_HEX(int8_t(0x24), b.extract(23, 8)); + CHECK_EQUAL_HEX(int8_t(0x12), b.extract(24, 8)); + + CHECK_THROW(b.extract(24, 9), etl::bitset_overflow); + CHECK_THROW(b.extract(25, 8), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_int8_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(int8_t(0x78), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x67), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x59), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x56), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x8A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x45), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xA2), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xD1), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x68), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x8D), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x46), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x91), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x48), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract())); + + // The lines below should static assert. + //int8_t v1 = b.extract(); + //int8_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_13_bits_uint16_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract( 0, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract( 1, 13)); + CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract( 2, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract( 3, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract( 4, 13)); + CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract( 5, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract( 6, 13)); + CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract( 7, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract( 8, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract( 9, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract(10, 13)); + CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract(11, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract(12, 13)); + CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract(13, 13)); + CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract(14, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract(15, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract(16, 13)); + CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract(17, 13)); + CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract(18, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract(19, 13)); + + CHECK_THROW(b.extract(19, 14), etl::bitset_overflow); + CHECK_THROW(b.extract(20, 13), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_13_bits_uint16_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract())); + + // The lines below should static assert. + //uint16_t v1 = b.extract; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract( 0, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract( 1, 16)); + CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract( 2, 16)); + CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract( 3, 16)); + CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract( 4, 16)); + CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract( 5, 16)); + CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract( 6, 16)); + CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract( 7, 16)); + CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract( 8, 16)); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract( 9, 16)); + CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract(10, 16)); + CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract(11, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract(12, 16)); + CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract(13, 16)); + CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract(14, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract(15, 16)); + CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract(16, 16)); + + CHECK_THROW(b.extract(16, 17), etl::bitset_overflow); + CHECK_THROW(b.extract(17, 16), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_uint16_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract())); + + // The lines below should static assert. + //uint16_t v1 = b.extract(); + //uint16_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_int16_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(int16_t(0x5678), b.extract( 0, 16)); + CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract( 1, 16)); + CHECK_EQUAL_HEX(int16_t(0x159E), b.extract( 2, 16)); + CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract( 3, 16)); + CHECK_EQUAL_HEX(int16_t(0x4567), b.extract( 4, 16)); + CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract( 5, 16)); + CHECK_EQUAL_HEX(int16_t(0xD159), b.extract( 6, 16)); + CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract( 7, 16)); + CHECK_EQUAL_HEX(int16_t(0x3456), b.extract( 8, 16)); + CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract( 9, 16)); + CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract(10, 16)); + CHECK_EQUAL_HEX(int16_t(0x468A), b.extract(11, 16)); + CHECK_EQUAL_HEX(int16_t(0x2345), b.extract(12, 16)); + CHECK_EQUAL_HEX(int16_t(0x91A2), b.extract(13, 16)); + CHECK_EQUAL_HEX(int16_t(0x48D1), b.extract(14, 16)); + CHECK_EQUAL_HEX(int16_t(0x2468), b.extract(15, 16)); + CHECK_EQUAL_HEX(int16_t(0x1234), b.extract(16, 16)); + + CHECK_THROW(b.extract(16, 17), etl::bitset_overflow); + CHECK_THROW(b.extract(17, 16), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_int16_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x91A2), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x48D1), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x2468), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x1234), (b.extract())); + + // The lines below should static assert. + //int16_t v1 = b.extract()); + //int16_t v2 = b.extract()); } }; } diff --git a/test/test_bitset_new_ext_explicit_single_element_type.cpp b/test/test_bitset_new_ext_explicit_single_element_type.cpp index d0b489be..163d1865 100644 --- a/test/test_bitset_new_ext_explicit_single_element_type.cpp +++ b/test/test_bitset_new_ext_explicit_single_element_type.cpp @@ -1310,10 +1310,172 @@ namespace CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str())); } + //************************************************************************* + TEST(test_extract_6_bit_uint8_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract( 0, 6))); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract( 1, 6))); + CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract( 2, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract( 3, 6))); + CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract( 4, 6))); + CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract( 5, 6))); + CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract( 6, 6))); + CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract( 7, 6))); + CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract( 8, 6))); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract( 9, 6))); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract(10, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract(11, 6))); + CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract(12, 6))); + CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract(13, 6))); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract(14, 6))); + CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract(15, 6))); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract(16, 6))); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract(17, 6))); + CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract(18, 6))); + CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract(19, 6))); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract(20, 6))); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract(21, 6))); + CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract(22, 6))); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract(23, 6))); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract(24, 6))); + CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract(25, 6))); + CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract(26, 6))); + + CHECK_THROW(b.extract(26, 7), etl::bitset_overflow); + CHECK_THROW(b.extract(27, 6), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_6_bit_uint8_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint8_t(0x38), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1E), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0F), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x27), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x33), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x19), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2C), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x16), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x05), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x22), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x28), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x0D), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x06), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x08), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x09), (b.extract())); + CHECK_EQUAL_HEX(uint8_t(0x04), (b.extract())); + + // The lines below should static assert. + //uint8_t v1 = b.extract(); + //uint8_t v1 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_6_bit_int8_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract( 0, 6))); + CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract( 1, 6))); + CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract( 2, 6))); + CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract( 3, 6))); + CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract( 4, 6))); + CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract( 5, 6))); + CHECK_EQUAL_HEX(int8_t(0x19), (b.extract( 6, 6))); + CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract( 7, 6))); + CHECK_EQUAL_HEX(int8_t(0x16), (b.extract( 8, 6))); + CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract( 9, 6))); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract(10, 6))); + CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract(11, 6))); + CHECK_EQUAL_HEX(int8_t(0x05), (b.extract(12, 6))); + CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract(13, 6))); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract(14, 6))); + CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract(15, 6))); + CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract(16, 6))); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract(17, 6))); + CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract(18, 6))); + CHECK_EQUAL_HEX(int8_t(0x06), (b.extract(19, 6))); + CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract(20, 6))); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract(21, 6))); + CHECK_EQUAL_HEX(int8_t(0x08), (b.extract(22, 6))); + CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract(23, 6))); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract(24, 6))); + CHECK_EQUAL_HEX(int8_t(0x09), (b.extract(25, 6))); + CHECK_EQUAL_HEX(int8_t(0x04), (b.extract(26, 6))); + + CHECK_THROW(b.extract(26, 7), etl::bitset_overflow); + CHECK_THROW(b.extract(27, 6), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_6_bit_int8_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(int8_t(0xF8), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xFC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1E), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0F), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE7), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xF3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x19), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xEC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x16), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xEB), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x05), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE2), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE8), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xF4), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x0D), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x06), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x11), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x08), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xE4), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x09), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x04), (b.extract())); + + // The lines below should static assert. + //int8_t v1 = b.extract(); + //int8_t v1 = b.extract(); + } + //************************************************************************* TEST(test_extract_uint8_t_with_run_time_parameters) { - using bs32 = etl::bitset_ext<32, int32_t>; + using bs32 = etl::bitset_ext<32, uint32_t>; bs32::buffer_type buffer; bs32 b(0x12345678UL, buffer); @@ -1343,12 +1505,15 @@ namespace CHECK_EQUAL_HEX(uint8_t(0x48), b.extract(22, 8)); CHECK_EQUAL_HEX(uint8_t(0x24), b.extract(23, 8)); CHECK_EQUAL_HEX(uint8_t(0x12), b.extract(24, 8)); + + CHECK_THROW(b.extract(24, 9), etl::bitset_overflow); + CHECK_THROW(b.extract(25, 8), etl::bitset_overflow); } //************************************************************************* TEST(test_extract_uint8_t_with_template_parameters) { - using bs32 = etl::bitset_ext<32, int32_t>; + using bs32 = etl::bitset_ext<32, uint32_t>; bs32::buffer_type buffer; bs32 b(0x12345678UL, buffer); @@ -1379,9 +1544,275 @@ namespace CHECK_EQUAL_HEX(uint8_t(0x24), (b.extract())); CHECK_EQUAL_HEX(uint8_t(0x12), (b.extract())); - // The line below should static assert. - //uint8_t v = b.extract(); - //uint8_t v = b.extract(); + // The lines below should static assert. + //uint8_t v1 = b.extract(); + //uint8_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_int8_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(int8_t(0x78), b.extract( 0, 8)); + CHECK_EQUAL_HEX(int8_t(0x3C), b.extract( 1, 8)); + CHECK_EQUAL_HEX(int8_t(0x9E), b.extract( 2, 8)); + CHECK_EQUAL_HEX(int8_t(0xCF), b.extract( 3, 8)); + CHECK_EQUAL_HEX(int8_t(0x67), b.extract( 4, 8)); + CHECK_EQUAL_HEX(int8_t(0xB3), b.extract( 5, 8)); + CHECK_EQUAL_HEX(int8_t(0x59), b.extract( 6, 8)); + CHECK_EQUAL_HEX(int8_t(0xAC), b.extract( 7, 8)); + CHECK_EQUAL_HEX(int8_t(0x56), b.extract( 8, 8)); + CHECK_EQUAL_HEX(int8_t(0x2B), b.extract( 9, 8)); + CHECK_EQUAL_HEX(int8_t(0x15), b.extract(10, 8)); + CHECK_EQUAL_HEX(int8_t(0x8A), b.extract(11, 8)); + CHECK_EQUAL_HEX(int8_t(0x45), b.extract(12, 8)); + CHECK_EQUAL_HEX(int8_t(0xA2), b.extract(13, 8)); + CHECK_EQUAL_HEX(int8_t(0xD1), b.extract(14, 8)); + CHECK_EQUAL_HEX(int8_t(0x68), b.extract(15, 8)); + CHECK_EQUAL_HEX(int8_t(0x34), b.extract(16, 8)); + CHECK_EQUAL_HEX(int8_t(0x1A), b.extract(17, 8)); + CHECK_EQUAL_HEX(int8_t(0x8D), b.extract(18, 8)); + CHECK_EQUAL_HEX(int8_t(0x46), b.extract(19, 8)); + CHECK_EQUAL_HEX(int8_t(0x23), b.extract(20, 8)); + CHECK_EQUAL_HEX(int8_t(0x91), b.extract(21, 8)); + CHECK_EQUAL_HEX(int8_t(0x48), b.extract(22, 8)); + CHECK_EQUAL_HEX(int8_t(0x24), b.extract(23, 8)); + CHECK_EQUAL_HEX(int8_t(0x12), b.extract(24, 8)); + + CHECK_THROW(b.extract(24, 9), etl::bitset_overflow); + CHECK_THROW(b.extract(25, 8), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_int8_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(int8_t(0x78), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x3C), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x9E), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xCF), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x67), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xB3), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x59), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xAC), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x56), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x2B), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x15), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x8A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x45), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xA2), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0xD1), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x68), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x34), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x1A), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x8D), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x46), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x23), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x91), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x48), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x24), (b.extract())); + CHECK_EQUAL_HEX(int8_t(0x12), (b.extract())); + + // The lines below should static assert. + //int8_t v1 = b.extract(); + //int8_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_13_bits_uint16_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x1678), b.extract( 0, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0B3C), b.extract( 1, 13)); + CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract( 2, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0ACF), b.extract( 3, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0567), b.extract( 4, 13)); + CHECK_EQUAL_HEX(uint16_t(0x02B3), b.extract( 5, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1159), b.extract( 6, 13)); + CHECK_EQUAL_HEX(uint16_t(0x08AC), b.extract( 7, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1456), b.extract( 8, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract( 9, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0D15), b.extract(10, 13)); + CHECK_EQUAL_HEX(uint16_t(0x068A), b.extract(11, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0345), b.extract(12, 13)); + CHECK_EQUAL_HEX(uint16_t(0x11A2), b.extract(13, 13)); + CHECK_EQUAL_HEX(uint16_t(0x08D1), b.extract(14, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0468), b.extract(15, 13)); + CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract(16, 13)); + CHECK_EQUAL_HEX(uint16_t(0x091A), b.extract(17, 13)); + CHECK_EQUAL_HEX(uint16_t(0x048D), b.extract(18, 13)); + CHECK_EQUAL_HEX(uint16_t(0x0246), b.extract(19, 13)); + + CHECK_THROW(b.extract(19, 14), etl::bitset_overflow); + CHECK_THROW(b.extract(20, 13), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_13_bits_uint16_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x1678), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0B3C), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0ACF), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0567), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x02B3), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1159), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x08AC), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1456), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0D15), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x068A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0345), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x11A2), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x08D1), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0468), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x091A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x048D), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x0246), (b.extract())); + + // The lines below should static assert. + //uint16_t v1 = b.extract; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x5678), b.extract( 0, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2B3C), b.extract( 1, 16)); + CHECK_EQUAL_HEX(uint16_t(0x159E), b.extract( 2, 16)); + CHECK_EQUAL_HEX(uint16_t(0x8ACF), b.extract( 3, 16)); + CHECK_EQUAL_HEX(uint16_t(0x4567), b.extract( 4, 16)); + CHECK_EQUAL_HEX(uint16_t(0xA2B3), b.extract( 5, 16)); + CHECK_EQUAL_HEX(uint16_t(0xD159), b.extract( 6, 16)); + CHECK_EQUAL_HEX(uint16_t(0x68AC), b.extract( 7, 16)); + CHECK_EQUAL_HEX(uint16_t(0x3456), b.extract( 8, 16)); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), b.extract( 9, 16)); + CHECK_EQUAL_HEX(uint16_t(0x8D15), b.extract(10, 16)); + CHECK_EQUAL_HEX(uint16_t(0x468A), b.extract(11, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2345), b.extract(12, 16)); + CHECK_EQUAL_HEX(uint16_t(0x91A2), b.extract(13, 16)); + CHECK_EQUAL_HEX(uint16_t(0x48D1), b.extract(14, 16)); + CHECK_EQUAL_HEX(uint16_t(0x2468), b.extract(15, 16)); + CHECK_EQUAL_HEX(uint16_t(0x1234), b.extract(16, 16)); + + CHECK_THROW(b.extract(16, 17), etl::bitset_overflow); + CHECK_THROW(b.extract(17, 16), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_uint16_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(uint16_t(0x5678), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2B3C), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x8ACF), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x4567), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0xA2B3), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0xD159), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x68AC), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x3456), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x8D15), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x468A), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2345), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x91A2), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x48D1), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x2468), (b.extract())); + CHECK_EQUAL_HEX(uint16_t(0x1234), (b.extract())); + + // The lines below should static assert. + //uint16_t v1 = b.extract(); + //uint16_t v2 = b.extract(); + } + + //************************************************************************* + TEST(test_extract_int16_t_with_run_time_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(int16_t(0x5678), b.extract( 0, 16)); + CHECK_EQUAL_HEX(int16_t(0x2B3C), b.extract( 1, 16)); + CHECK_EQUAL_HEX(int16_t(0x159E), b.extract( 2, 16)); + CHECK_EQUAL_HEX(int16_t(0x8ACF), b.extract( 3, 16)); + CHECK_EQUAL_HEX(int16_t(0x4567), b.extract( 4, 16)); + CHECK_EQUAL_HEX(int16_t(0xA2B3), b.extract( 5, 16)); + CHECK_EQUAL_HEX(int16_t(0xD159), b.extract( 6, 16)); + CHECK_EQUAL_HEX(int16_t(0x68AC), b.extract( 7, 16)); + CHECK_EQUAL_HEX(int16_t(0x3456), b.extract( 8, 16)); + CHECK_EQUAL_HEX(int16_t(0x1A2B), b.extract( 9, 16)); + CHECK_EQUAL_HEX(int16_t(0x8D15), b.extract(10, 16)); + CHECK_EQUAL_HEX(int16_t(0x468A), b.extract(11, 16)); + CHECK_EQUAL_HEX(int16_t(0x2345), b.extract(12, 16)); + CHECK_EQUAL_HEX(int16_t(0x91A2), b.extract(13, 16)); + CHECK_EQUAL_HEX(int16_t(0x48D1), b.extract(14, 16)); + CHECK_EQUAL_HEX(int16_t(0x2468), b.extract(15, 16)); + CHECK_EQUAL_HEX(int16_t(0x1234), b.extract(16, 16)); + + CHECK_THROW(b.extract(16, 17), etl::bitset_overflow); + CHECK_THROW(b.extract(17, 16), etl::bitset_overflow); + } + + //************************************************************************* + TEST(test_extract_int16_t_with_template_parameters) + { + using bs32 = etl::bitset_ext<32, uint32_t>; + + bs32::buffer_type buffer; + bs32 b(0x12345678UL, buffer); + + CHECK_EQUAL_HEX(int16_t(0x5678), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x2B3C), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x159E), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x8ACF), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x4567), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0xA2B3), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0xD159), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x68AC), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x3456), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x1A2B), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x8D15), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x468A), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x2345), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x91A2), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x48D1), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x2468), (b.extract())); + CHECK_EQUAL_HEX(int16_t(0x1234), (b.extract())); + + // The lines below should static assert. + //int16_t v1 = b.extract()); + //int16_t v2 = b.extract()); } }; }