mirror of
https://github.com/ETLCPP/etl.git
synced 2026-04-30 19:09:10 +08:00
Add asserts in to_string
This commit is contained in:
John Wellbelove
parent
ec4fb59b89
commit
2e7b635bfd
@ -7,7 +7,7 @@ Embedded Template Library.
|
||||
https://github.com/ETLCPP/etl
|
||||
https://www.etlcpp.com
|
||||
|
||||
Copyright(c) 2014 John Wellbelove
|
||||
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
|
||||
@ -77,6 +77,34 @@ SOFTWARE.
|
||||
|
||||
namespace etl
|
||||
{
|
||||
//***************************************************************************
|
||||
/// Exception base for bitset
|
||||
///\ingroup bitset
|
||||
//***************************************************************************
|
||||
class bitset_exception : public etl::exception
|
||||
{
|
||||
public:
|
||||
|
||||
bitset_exception(string_type reason_, string_type file_name_, numeric_type line_number_)
|
||||
: exception(reason_, file_name_, line_number_)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
//***************************************************************************
|
||||
/// Bitset type_too_small exception.
|
||||
///\ingroup bitset
|
||||
//***************************************************************************
|
||||
class bitset_string_too_small : public bitset_exception
|
||||
{
|
||||
public:
|
||||
|
||||
bitset_string_too_small(string_type file_name_, numeric_type line_number_)
|
||||
: bitset_exception(ETL_ERROR_TEXT("bitset:type_too_small", ETL_BITSET_FILE_ID"A"), file_name_, line_number_)
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
//*************************************************************************
|
||||
/// The implementation class for multi-element etl::bitset
|
||||
///\ingroup bitset
|
||||
@ -527,10 +555,35 @@ namespace etl
|
||||
return npos;
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
/// Returns a string representing the bitset.
|
||||
//*************************************************************************
|
||||
template <typename TString>
|
||||
TString to_string(const_pointer pbuffer,
|
||||
size_t number_of_elements,
|
||||
size_t active_bits,
|
||||
typename TString::value_type zero,
|
||||
typename TString::value_type one) const
|
||||
{
|
||||
TString result;
|
||||
|
||||
result.resize(active_bits, '\0');
|
||||
|
||||
// Check that the string type can contain the digits.
|
||||
ETL_ASSERT_AND_RETURN_VALUE(result.size() == active_bits, ETL_ERROR(etl::bitset_string_too_small), result);
|
||||
|
||||
for (size_t i = active_bits; i > 0; --i)
|
||||
{
|
||||
result[active_bits - i] = test(pbuffer, number_of_elements, i - 1) ? one : zero;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
/// shift_left_equals
|
||||
//*************************************************************************
|
||||
ETL_CONSTEXPR14 void shift_left_equals(pointer pbuffer, size_t number_of_elements, size_t total_bits, size_t shift) ETL_NOEXCEPT
|
||||
ETL_CONSTEXPR14 void shift_left_equals(pointer pbuffer, size_t number_of_elements, size_t shift) ETL_NOEXCEPT
|
||||
{
|
||||
if ((shift % Bits_Per_Element) == 0U)
|
||||
{
|
||||
@ -593,7 +646,7 @@ namespace etl
|
||||
//*************************************************************************
|
||||
/// shift_right_equals
|
||||
//*************************************************************************
|
||||
ETL_CONSTEXPR14 void shift_right_equals(pointer pbuffer, size_t number_of_elements, size_t total_bits, size_t shift) ETL_NOEXCEPT
|
||||
ETL_CONSTEXPR14 void shift_right_equals(pointer pbuffer, size_t number_of_elements, size_t shift) ETL_NOEXCEPT
|
||||
{
|
||||
if ((shift % Bits_Per_Element) == 0U)
|
||||
{
|
||||
@ -912,6 +965,16 @@ namespace etl
|
||||
set(text);
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
/// Assignment operator.
|
||||
//*************************************************************************
|
||||
ETL_CONSTEXPR14 bitset& operator =(const bitset<Active_Bits, TElement, true>& other) ETL_NOEXCEPT
|
||||
{
|
||||
buffer = other.buffer;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
/// Set all of the bits.
|
||||
//*************************************************************************
|
||||
@ -1003,7 +1066,7 @@ namespace etl
|
||||
|
||||
for (size_t i = 0U; i < string_length; ++i)
|
||||
{
|
||||
if (text[i] == '1')
|
||||
if (text[i] == ETL_STR('1'))
|
||||
{
|
||||
buffer |= mask;
|
||||
}
|
||||
@ -1039,7 +1102,7 @@ namespace etl
|
||||
|
||||
for (size_t i = 0U; i < string_length; ++i)
|
||||
{
|
||||
if (text[i] == L'1')
|
||||
if (text[i] == ETL_STRL('1'))
|
||||
{
|
||||
buffer |= mask;
|
||||
}
|
||||
@ -1075,7 +1138,7 @@ namespace etl
|
||||
|
||||
for (size_t i = 0U; i < string_length; ++i)
|
||||
{
|
||||
if (text[i] == u'1')
|
||||
if (text[i] == ETL_STRu('1'))
|
||||
{
|
||||
buffer |= mask;
|
||||
}
|
||||
@ -1111,7 +1174,7 @@ namespace etl
|
||||
|
||||
for (size_t i = 0U; i < string_length; ++i)
|
||||
{
|
||||
if (text[i] == U'1')
|
||||
if (text[i] == ETL_STRU('1'))
|
||||
{
|
||||
buffer |= mask;
|
||||
}
|
||||
@ -1334,12 +1397,15 @@ namespace etl
|
||||
template <typename TString>
|
||||
#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 ETL_NOEXCEPT
|
||||
typename TString::value_type one = typename TString::value_type('1')) const
|
||||
{
|
||||
TString result;
|
||||
|
||||
result.resize(Active_Bits, '\0');
|
||||
|
||||
// Check that the string type can contain the digits.
|
||||
ETL_ASSERT_AND_RETURN_VALUE(result.size() == Active_Bits, ETL_ERROR(etl::bitset_string_too_small), result);
|
||||
|
||||
for (size_t i = Active_Bits; i > 0; --i)
|
||||
{
|
||||
result[Active_Bits - i] = test(i - 1) ? one : zero;
|
||||
@ -1554,7 +1620,7 @@ namespace etl
|
||||
/// span
|
||||
/// Returns a span of the underlying buffer.
|
||||
//*************************************************************************
|
||||
ETL_CONSTEXPR14 span_type span() ETL_NOEXCEPT
|
||||
span_type span() ETL_NOEXCEPT
|
||||
{
|
||||
return span_type(&buffer, 1);
|
||||
}
|
||||
@ -1585,17 +1651,16 @@ namespace etl
|
||||
// If the 'TElement' is the default 'void', then use 'char', otherwise uses
|
||||
// the unsigned variant of 'TElement'.
|
||||
//*************************************************************************
|
||||
template <typename TElement>
|
||||
struct select_element_type
|
||||
{
|
||||
typedef typename typename etl::make_unsigned<typename etl::conditional<etl::is_same<void, TElement>::value, char, TElement>::type>::type type;
|
||||
typedef typename etl::make_unsigned<typename etl::conditional<etl::is_same<void, TElement>::value, char, TElement>::type>::type type;
|
||||
};
|
||||
|
||||
public:
|
||||
|
||||
typedef typename select_element_type<TElement>::type element_type;
|
||||
typedef typename element_type* pointer;
|
||||
typedef typename const element_type* const_pointer;
|
||||
typedef typename select_element_type::type element_type;
|
||||
typedef element_type* pointer;
|
||||
typedef const element_type* const_pointer;
|
||||
|
||||
static ETL_CONSTANT size_t Bits_Per_Element = etl::bitset_impl<element_type>::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;
|
||||
@ -1754,12 +1819,22 @@ namespace etl
|
||||
clear_unused_bits_in_msb();
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
/// Assignment operator.
|
||||
//*************************************************************************
|
||||
ETL_CONSTEXPR14 bitset& operator =(const bitset<Active_Bits, TElement, false>& other) ETL_NOEXCEPT
|
||||
{
|
||||
ibitset.copy_elements(other.buffer, buffer, Number_Of_Elements);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
/// Set all of the bits.
|
||||
//*************************************************************************
|
||||
ETL_CONSTEXPR14 bitset<Active_Bits, TElement, false>& set() ETL_NOEXCEPT
|
||||
{
|
||||
etl::fill_n(buffer, ETL_OR_STD::size(buffer), All_Set);
|
||||
etl::fill_n(buffer, Number_Of_Elements, All_Set);
|
||||
clear_unused_bits_in_msb();
|
||||
|
||||
return *this;
|
||||
@ -1867,7 +1942,7 @@ namespace etl
|
||||
ETL_STATIC_ASSERT(etl::is_integral<T>::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<T>(buffer, Number_Of_Elements);
|
||||
return ibitset.template value<T>(buffer, Number_Of_Elements);
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
@ -1999,18 +2074,9 @@ namespace etl
|
||||
template <typename TString>
|
||||
#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 ETL_NOEXCEPT
|
||||
typename TString::value_type one = typename TString::value_type('1')) const
|
||||
{
|
||||
TString result;
|
||||
|
||||
result.resize(Active_Bits, '\0');
|
||||
|
||||
for (size_t i = Active_Bits; i > 0; --i)
|
||||
{
|
||||
result[Active_Bits - i] = test(i - 1) ? one : zero;
|
||||
}
|
||||
|
||||
return result;
|
||||
return ibitset.template to_string<TString>(buffer, Number_Of_Elements, Active_Bits, zero, one);
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
@ -2135,7 +2201,7 @@ namespace etl
|
||||
}
|
||||
else
|
||||
{
|
||||
ibitset.shift_left_equals(buffer, Number_Of_Elements, Active_Bits, shift);
|
||||
ibitset.shift_left_equals(buffer, Number_Of_Elements, shift);
|
||||
|
||||
// Truncate any bits shifted to the left.
|
||||
clear_unused_bits_in_msb();
|
||||
@ -2167,7 +2233,7 @@ namespace etl
|
||||
}
|
||||
else
|
||||
{
|
||||
ibitset.shift_right_equals(buffer, Number_Of_Elements, Active_Bits, shift);
|
||||
ibitset.shift_right_equals(buffer, Number_Of_Elements, shift);
|
||||
}
|
||||
|
||||
return *this;
|
||||
@ -2206,7 +2272,7 @@ namespace etl
|
||||
/// span
|
||||
/// Returns a span of the underlying buffer.
|
||||
//*************************************************************************
|
||||
ETL_CONSTEXPR14 span_type span() ETL_NOEXCEPT
|
||||
span_type span() ETL_NOEXCEPT
|
||||
{
|
||||
return span_type(buffer, Number_Of_Elements);
|
||||
}
|
||||
|
||||
@ -45,7 +45,8 @@ set(TEST_SOURCE_FILES
|
||||
test_bip_buffer_spsc_atomic.cpp
|
||||
test_bit.cpp
|
||||
test_bitset_legacy.cpp
|
||||
test_bitset_new.cpp
|
||||
test_bitset_new_default_element_type.cpp
|
||||
test_bitset_new_explicit_single_element_type.cpp
|
||||
test_bit_stream.cpp
|
||||
test_bit_stream_reader_big_endian.cpp
|
||||
test_bit_stream_reader_little_endian.cpp
|
||||
|
||||
@ -1351,7 +1351,7 @@ namespace
|
||||
|
||||
constexpr bool bc13 = compare[13U];
|
||||
constexpr bool bd13 = data[13U];
|
||||
CHECK_EQUAL(bc7, bd7);
|
||||
CHECK_EQUAL(bc13, bd13);
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
@ -1524,7 +1524,7 @@ namespace
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
constexpr etl::bitset<60> test_assignment_operator_helper(etl::bitset<60> to, const etl::bitset<60>& from)
|
||||
constexpr etl::bitset<60> test_assignment_operator_helper(etl::bitset<60> to, etl::bitset<60> from)
|
||||
{
|
||||
to = from;
|
||||
|
||||
@ -1567,8 +1567,8 @@ namespace
|
||||
constexpr bool equal = !(data1 != data2);
|
||||
constexpr bool not_equal = (data1 != data3);
|
||||
|
||||
CHECK(!(data1 != data2));
|
||||
CHECK(data1 != data3);
|
||||
CHECK(equal);
|
||||
CHECK(not_equal);
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
@ -1990,8 +1990,6 @@ namespace
|
||||
//*************************************************************************
|
||||
TEST(test_find_next)
|
||||
{
|
||||
etl::bitset<9> data;
|
||||
|
||||
constexpr etl::bitset<9> bs1(ull(0x0000));
|
||||
constexpr size_t bs1fnf0 = bs1.find_next(false, 0);
|
||||
constexpr size_t bs1fnf1 = bs1.find_next(false, 1);
|
||||
@ -2075,20 +2073,6 @@ namespace
|
||||
CHECK_EQUAL(0x12U, s[3]);
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
TEST(test_span_constexpr)
|
||||
{
|
||||
using span_t = etl::bitset<32>::const_span_type;
|
||||
|
||||
constexpr etl::bitset<32> 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)
|
||||
{
|
||||
|
||||
@ -46,9 +46,22 @@ namespace
|
||||
template <size_t Active_Bits, typename TElement>
|
||||
constexpr etl::bitset<Active_Bits, TElement> generate_shift_left_bitset(ull value, size_t shift)
|
||||
{
|
||||
ull mask = 0ULL;
|
||||
|
||||
if (shift < 64U)
|
||||
{
|
||||
mask = etl::integral_limits<ull>::max >> shift;
|
||||
}
|
||||
|
||||
value &= mask;
|
||||
|
||||
etl::bitset<Active_Bits, TElement> data(value);
|
||||
|
||||
if (shift != 0U)
|
||||
if (shift >= 64U)
|
||||
{
|
||||
data.reset();
|
||||
}
|
||||
else if (shift != 0U)
|
||||
{
|
||||
data <<= shift;
|
||||
}
|
||||
@ -63,7 +76,7 @@ namespace
|
||||
etl::bitset<Active_Bits, TElement> data1(value);
|
||||
etl::bitset<Active_Bits, TElement> data2;
|
||||
|
||||
if (shift != 0U)
|
||||
if ((shift != 0U) && (shift != 64U))
|
||||
{
|
||||
data2 = data1 << shift;
|
||||
}
|
||||
@ -77,7 +90,11 @@ namespace
|
||||
{
|
||||
etl::bitset<Active_Bits, TElement> data(value);
|
||||
|
||||
if (shift != 0U)
|
||||
if (shift >= 64U)
|
||||
{
|
||||
data.reset();
|
||||
}
|
||||
else if (shift != 0U)
|
||||
{
|
||||
data >>= shift;
|
||||
}
|
||||
@ -702,7 +719,7 @@ namespace
|
||||
|
||||
constexpr bool bc13 = compare[13U];
|
||||
constexpr bool bd13 = data[13U];
|
||||
CHECK_EQUAL(bc7, bd7);
|
||||
CHECK_EQUAL(bc13, bd13);
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
@ -981,8 +998,8 @@ namespace
|
||||
constexpr bool equal = !(data1 != data2);
|
||||
constexpr bool not_equal = (data1 != data3);
|
||||
|
||||
CHECK(!(data1 != data2));
|
||||
CHECK(data1 != data3);
|
||||
CHECK(equal);
|
||||
CHECK(not_equal);
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
@ -1025,73 +1042,73 @@ namespace
|
||||
//*************************************************************************
|
||||
TEST(test_shift_left_operator_all_shifts_full_size)
|
||||
{
|
||||
int64_t value = 0x0123456789ABCDEFULL;
|
||||
uint64_t value = 0x0123456789ABCDEFULL;
|
||||
|
||||
CHECK_EQUAL_HEX((value << 0U), (generate_shift_left_bitset<64, int64_t>(value, 0U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 1U), (generate_shift_left_bitset<64, int64_t>(value, 1U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 2U), (generate_shift_left_bitset<64, int64_t>(value, 2U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 3U), (generate_shift_left_bitset<64, int64_t>(value, 3U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 4U), (generate_shift_left_bitset<64, int64_t>(value, 4U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 5U), (generate_shift_left_bitset<64, int64_t>(value, 5U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 6U), (generate_shift_left_bitset<64, int64_t>(value, 6U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 7U), (generate_shift_left_bitset<64, int64_t>(value, 7U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 8U), (generate_shift_left_bitset<64, int64_t>(value, 8U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 9U), (generate_shift_left_bitset<64, int64_t>(value, 9U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 10U), (generate_shift_left_bitset<64, int64_t>(value, 10U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 11U), (generate_shift_left_bitset<64, int64_t>(value, 11U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 12U), (generate_shift_left_bitset<64, int64_t>(value, 12U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 13U), (generate_shift_left_bitset<64, int64_t>(value, 13U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 14U), (generate_shift_left_bitset<64, int64_t>(value, 14U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 15U), (generate_shift_left_bitset<64, int64_t>(value, 15U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 16U), (generate_shift_left_bitset<64, int64_t>(value, 16U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 17U), (generate_shift_left_bitset<64, int64_t>(value, 17U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 18U), (generate_shift_left_bitset<64, int64_t>(value, 18U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 19U), (generate_shift_left_bitset<64, int64_t>(value, 19U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 20U), (generate_shift_left_bitset<64, int64_t>(value, 20U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 21U), (generate_shift_left_bitset<64, int64_t>(value, 21U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 22U), (generate_shift_left_bitset<64, int64_t>(value, 22U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 23U), (generate_shift_left_bitset<64, int64_t>(value, 23U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 24U), (generate_shift_left_bitset<64, int64_t>(value, 24U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 25U), (generate_shift_left_bitset<64, int64_t>(value, 25U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 26U), (generate_shift_left_bitset<64, int64_t>(value, 26U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 27U), (generate_shift_left_bitset<64, int64_t>(value, 27U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 28U), (generate_shift_left_bitset<64, int64_t>(value, 28U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 29U), (generate_shift_left_bitset<64, int64_t>(value, 29U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 30U), (generate_shift_left_bitset<64, int64_t>(value, 30U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 31U), (generate_shift_left_bitset<64, int64_t>(value, 31U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 32U), (generate_shift_left_bitset<64, int64_t>(value, 32U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 33U), (generate_shift_left_bitset<64, int64_t>(value, 33U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 34U), (generate_shift_left_bitset<64, int64_t>(value, 34U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 35U), (generate_shift_left_bitset<64, int64_t>(value, 35U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 36U), (generate_shift_left_bitset<64, int64_t>(value, 36U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 37U), (generate_shift_left_bitset<64, int64_t>(value, 37U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 38U), (generate_shift_left_bitset<64, int64_t>(value, 38U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 39U), (generate_shift_left_bitset<64, int64_t>(value, 39U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 40U), (generate_shift_left_bitset<64, int64_t>(value, 40U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 41U), (generate_shift_left_bitset<64, int64_t>(value, 41U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 42U), (generate_shift_left_bitset<64, int64_t>(value, 42U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 43U), (generate_shift_left_bitset<64, int64_t>(value, 43U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 44U), (generate_shift_left_bitset<64, int64_t>(value, 44U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 45U), (generate_shift_left_bitset<64, int64_t>(value, 45U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 46U), (generate_shift_left_bitset<64, int64_t>(value, 46U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 47U), (generate_shift_left_bitset<64, int64_t>(value, 47U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 48U), (generate_shift_left_bitset<64, int64_t>(value, 48U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 49U), (generate_shift_left_bitset<64, int64_t>(value, 49U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 50U), (generate_shift_left_bitset<64, int64_t>(value, 50U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 51U), (generate_shift_left_bitset<64, int64_t>(value, 51U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 52U), (generate_shift_left_bitset<64, int64_t>(value, 52U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 53U), (generate_shift_left_bitset<64, int64_t>(value, 53U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 54U), (generate_shift_left_bitset<64, int64_t>(value, 54U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 55U), (generate_shift_left_bitset<64, int64_t>(value, 55U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 56U), (generate_shift_left_bitset<64, int64_t>(value, 56U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 57U), (generate_shift_left_bitset<64, int64_t>(value, 57U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 58U), (generate_shift_left_bitset<64, int64_t>(value, 58U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 59U), (generate_shift_left_bitset<64, int64_t>(value, 59U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 60U), (generate_shift_left_bitset<64, int64_t>(value, 60U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 61U), (generate_shift_left_bitset<64, int64_t>(value, 61U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 62U), (generate_shift_left_bitset<64, int64_t>(value, 62U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 63U), (generate_shift_left_bitset<64, int64_t>(value, 63U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX(0ULL, (generate_shift_left_bitset<64, int64_t>(value, 64U).value<int64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 0U), (generate_shift_left_bitset<64, uint64_t>(value, 0U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 1U), (generate_shift_left_bitset<64, uint64_t>(value, 1U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 2U), (generate_shift_left_bitset<64, uint64_t>(value, 2U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 3U), (generate_shift_left_bitset<64, uint64_t>(value, 3U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 4U), (generate_shift_left_bitset<64, uint64_t>(value, 4U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 5U), (generate_shift_left_bitset<64, uint64_t>(value, 5U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 6U), (generate_shift_left_bitset<64, uint64_t>(value, 6U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 7U), (generate_shift_left_bitset<64, uint64_t>(value, 7U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 8U), (generate_shift_left_bitset<64, uint64_t>(value, 8U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 9U), (generate_shift_left_bitset<64, uint64_t>(value, 9U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 10U), (generate_shift_left_bitset<64, uint64_t>(value, 10U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 11U), (generate_shift_left_bitset<64, uint64_t>(value, 11U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 12U), (generate_shift_left_bitset<64, uint64_t>(value, 12U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 13U), (generate_shift_left_bitset<64, uint64_t>(value, 13U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 14U), (generate_shift_left_bitset<64, uint64_t>(value, 14U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 15U), (generate_shift_left_bitset<64, uint64_t>(value, 15U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 16U), (generate_shift_left_bitset<64, uint64_t>(value, 16U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 17U), (generate_shift_left_bitset<64, uint64_t>(value, 17U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 18U), (generate_shift_left_bitset<64, uint64_t>(value, 18U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 19U), (generate_shift_left_bitset<64, uint64_t>(value, 19U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 20U), (generate_shift_left_bitset<64, uint64_t>(value, 20U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 21U), (generate_shift_left_bitset<64, uint64_t>(value, 21U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 22U), (generate_shift_left_bitset<64, uint64_t>(value, 22U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 23U), (generate_shift_left_bitset<64, uint64_t>(value, 23U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 24U), (generate_shift_left_bitset<64, uint64_t>(value, 24U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 25U), (generate_shift_left_bitset<64, uint64_t>(value, 25U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 26U), (generate_shift_left_bitset<64, uint64_t>(value, 26U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 27U), (generate_shift_left_bitset<64, uint64_t>(value, 27U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 28U), (generate_shift_left_bitset<64, uint64_t>(value, 28U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 29U), (generate_shift_left_bitset<64, uint64_t>(value, 29U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 30U), (generate_shift_left_bitset<64, uint64_t>(value, 30U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 31U), (generate_shift_left_bitset<64, uint64_t>(value, 31U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 32U), (generate_shift_left_bitset<64, uint64_t>(value, 32U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 33U), (generate_shift_left_bitset<64, uint64_t>(value, 33U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 34U), (generate_shift_left_bitset<64, uint64_t>(value, 34U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 35U), (generate_shift_left_bitset<64, uint64_t>(value, 35U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 36U), (generate_shift_left_bitset<64, uint64_t>(value, 36U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 37U), (generate_shift_left_bitset<64, uint64_t>(value, 37U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 38U), (generate_shift_left_bitset<64, uint64_t>(value, 38U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 39U), (generate_shift_left_bitset<64, uint64_t>(value, 39U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 40U), (generate_shift_left_bitset<64, uint64_t>(value, 40U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 41U), (generate_shift_left_bitset<64, uint64_t>(value, 41U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 42U), (generate_shift_left_bitset<64, uint64_t>(value, 42U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 43U), (generate_shift_left_bitset<64, uint64_t>(value, 43U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 44U), (generate_shift_left_bitset<64, uint64_t>(value, 44U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 45U), (generate_shift_left_bitset<64, uint64_t>(value, 45U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 46U), (generate_shift_left_bitset<64, uint64_t>(value, 46U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 47U), (generate_shift_left_bitset<64, uint64_t>(value, 47U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 48U), (generate_shift_left_bitset<64, uint64_t>(value, 48U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 49U), (generate_shift_left_bitset<64, uint64_t>(value, 49U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 50U), (generate_shift_left_bitset<64, uint64_t>(value, 50U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 51U), (generate_shift_left_bitset<64, uint64_t>(value, 51U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 52U), (generate_shift_left_bitset<64, uint64_t>(value, 52U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 53U), (generate_shift_left_bitset<64, uint64_t>(value, 53U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 54U), (generate_shift_left_bitset<64, uint64_t>(value, 54U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 55U), (generate_shift_left_bitset<64, uint64_t>(value, 55U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 56U), (generate_shift_left_bitset<64, uint64_t>(value, 56U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 57U), (generate_shift_left_bitset<64, uint64_t>(value, 57U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 58U), (generate_shift_left_bitset<64, uint64_t>(value, 58U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 59U), (generate_shift_left_bitset<64, uint64_t>(value, 59U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 60U), (generate_shift_left_bitset<64, uint64_t>(value, 60U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 61U), (generate_shift_left_bitset<64, uint64_t>(value, 61U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 62U), (generate_shift_left_bitset<64, uint64_t>(value, 62U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX((value << 63U), (generate_shift_left_bitset<64, uint64_t>(value, 63U).value<uint64_t>()));
|
||||
CHECK_EQUAL_HEX(0ULL, (generate_shift_left_bitset<64, uint64_t>(value, 64U).value<uint64_t>()));
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
@ -1403,8 +1420,6 @@ namespace
|
||||
//*************************************************************************
|
||||
TEST(test_find_next)
|
||||
{
|
||||
etl::bitset<8> data;
|
||||
|
||||
constexpr etl::bitset<8, int8_t> bs1(ull(0x00));
|
||||
constexpr size_t bs1fnf0 = bs1.find_next(false, 0);
|
||||
constexpr size_t bs1fnf1 = bs1.find_next(false, 1);
|
||||
@ -1482,17 +1497,6 @@ namespace
|
||||
CHECK_EQUAL(0x12345678UL, s[0]);
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
TEST(test_span_constexpr)
|
||||
{
|
||||
using span_t = etl::bitset<32, int32_t>::const_span_type;
|
||||
|
||||
constexpr etl::bitset<32, int32_t> b(0x12345678UL);
|
||||
|
||||
constexpr span_t s = b.span();
|
||||
CHECK_EQUAL(0x12345678UL, s[0]);
|
||||
}
|
||||
|
||||
//*************************************************************************
|
||||
TEST(test_to_string)
|
||||
{
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user