coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-05-01 03:19:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

#807 Change in legacy etl::bitset with nullptr construction + error handling

Browse Source 
Harmonised operation of legacy and new etl::bitset
Added ETL_ASSERT checks for nullptr buffer pointers for etl::bitset_ext
This commit is contained in:
John Wellbelove 2023-12-16 12:57:36 +00:00
parent 8f88aa0141
commit 59cd9e66d7
11 changed files with 882 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
include/etl/private/bitset_legacy.h
View File

@ -429,7 +429,14 @@ namespace etl
//*************************************************************************
ibitset& set(const char* text)
{
from_string(text);
if (text == ETL_NULLPTR)
{
reset();
}
else
{
from_string(text);
}
return *this;
}
@ -439,7 +446,14 @@ namespace etl
//*************************************************************************
ibitset& set(const wchar_t* text)
{
from_string(text);
if (text == ETL_NULLPTR)
{
reset();
}
else
{
from_string(text);
}
return *this;
}
@ -449,7 +463,14 @@ namespace etl
//*************************************************************************
ibitset& set(const char16_t* text)
{
from_string(text);
if (text == ETL_NULLPTR)
{
reset();
}
else
{
from_string(text);
}
return *this;
}
@ -459,7 +480,14 @@ namespace etl
//*************************************************************************
ibitset& set(const char32_t* text)
{
from_string(text);
if (text == ETL_NULLPTR)
{
reset();
}
else
{
from_string(text);
}
return *this;
}
@ -512,7 +540,7 @@ namespace etl
//*************************************************************************
ibitset& reset()
{
::memset(pdata, 0x00, Number_Of_Elements);
::memset(pdata, 0, Number_Of_Elements * sizeof(element_type));
return *this;
}
@ -1194,7 +1222,6 @@ namespace etl
//*************************************************************************
bitset<MaxN>& set(const char* text)
{
ETL_ASSERT_OR_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this);
etl::ibitset::set(text);
return *this;
@ -1205,7 +1232,6 @@ namespace etl
//*************************************************************************
bitset<MaxN>& set(const wchar_t* text)
{
ETL_ASSERT_OR_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this);
etl::ibitset::set(text);
return *this;
@ -1216,7 +1242,6 @@ namespace etl
//*************************************************************************
bitset<MaxN>& set(const char16_t* text)
{
ETL_ASSERT_OR_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this);
etl::ibitset::set(text);
return *this;
@ -1227,7 +1252,6 @@ namespace etl
//*************************************************************************
bitset<MaxN>& set(const char32_t* text)
{
ETL_ASSERT_OR_RETURN_VALUE(text != 0, ETL_ERROR(bitset_nullptr), *this);
etl::ibitset::set(text);
return *this;

63
include/etl/private/bitset_new.h
View File

@ -127,6 +127,20 @@ namespace etl
}
};
//***************************************************************************
/// Bitset nullptr buffer exception.
///\ingroup bitset
//***************************************************************************
class bitset_invalid_buffer : public bitset_exception
{
public:
bitset_invalid_buffer(string_type file_name_, numeric_type line_number_)
: bitset_exception(ETL_ERROR_TEXT("bitset:invalid buffer", ETL_BITSET_FILE_ID"D"), file_name_, line_number_)
{
}
};
//*************************************************************************
/// The implementation class for multi-element etl::bitset
///\ingroup bitset
@ -2598,16 +2612,17 @@ namespace etl
//*************************************************************************
/// Default constructor.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext(element_type* pbuffer_) ETL_NOEXCEPT
ETL_CONSTEXPR14 explicit bitset_ext(element_type* pbuffer_)
: pbuffer(pbuffer_)
{
ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
*pbuffer = All_Clear_Element;
}
//*************************************************************************
/// Default constructor.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext(buffer_type& buffer) ETL_NOEXCEPT
ETL_CONSTEXPR14 explicit bitset_ext(buffer_type& buffer) ETL_NOEXCEPT
: pbuffer(&buffer)
{
*pbuffer = All_Clear_Element;
@ -2616,9 +2631,10 @@ namespace etl
//*************************************************************************
/// Construct copy.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, true>& other, element_type* pbuffer_) ETL_NOEXCEPT
ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, true>& other, element_type* pbuffer_)
: pbuffer(pbuffer_)
{
ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
*pbuffer = *other.pbuffer;
}
@ -2639,9 +2655,10 @@ namespace etl
//*************************************************************************
/// Construct from a value.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext(unsigned long long value, element_type* pbuffer_) ETL_NOEXCEPT
ETL_CONSTEXPR14 bitset_ext(unsigned long long value, element_type* pbuffer_)
: pbuffer(pbuffer_)
{
ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
*pbuffer = element_type(value);
}
@ -2657,9 +2674,10 @@ namespace etl
//*************************************************************************
/// Construct from a string.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext(const char* text, element_type* pbuffer_) ETL_NOEXCEPT
ETL_CONSTEXPR14 bitset_ext(const char* text, element_type* pbuffer_)
: pbuffer(pbuffer_)
{
ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
*pbuffer = All_Clear_Element;
set(text);
}
@ -2677,9 +2695,10 @@ namespace etl
//*************************************************************************
/// Construct from a string.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, element_type* pbuffer_) ETL_NOEXCEPT
ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, element_type* pbuffer_)
: pbuffer(pbuffer_)
{
ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
*pbuffer = All_Clear_Element;
set(text);
}
@ -2697,9 +2716,10 @@ namespace etl
//*************************************************************************
/// Construct from a string.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext(const char16_t* text, element_type* pbuffer_) ETL_NOEXCEPT
ETL_CONSTEXPR14 bitset_ext(const char16_t* text, element_type* pbuffer_)
: pbuffer(pbuffer_)
{
ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
*pbuffer = All_Clear_Element;
set(text);
}
@ -2717,9 +2737,10 @@ namespace etl
//*************************************************************************
/// Construct from a string.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext(const char32_t* text, element_type* pbuffer_) ETL_NOEXCEPT
ETL_CONSTEXPR14 bitset_ext(const char32_t* text, element_type* pbuffer_)
: pbuffer(pbuffer_)
{
ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
*pbuffer = All_Clear_Element;
set(text);
}
@ -2963,7 +2984,7 @@ namespace etl
//*************************************************************************
template <typename T>
ETL_CONSTEXPR14
typename etl::enable_if<etl::is_integral<T>::value, T>::type
typename etl::enable_if<etl::is_integral<T>::value, T>::type
value() const ETL_NOEXCEPT
{
ETL_STATIC_ASSERT(etl::is_integral<T>::value, "Only integral types are supported");
@ -3476,27 +3497,30 @@ namespace etl
//*************************************************************************
/// Default constructor.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext(element_type* pbuffer_) ETL_NOEXCEPT
ETL_CONSTEXPR14 explicit bitset_ext(element_type* pbuffer_)
: pbuffer(pbuffer_)
{
ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
reset();
}
//*************************************************************************
/// Default constructor.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext(buffer_type& buffer) ETL_NOEXCEPT
ETL_CONSTEXPR14 explicit bitset_ext(buffer_type& buffer)
: pbuffer(buffer.data())
{
ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
reset();
}
//*************************************************************************
/// Construct copy.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, false>& other, element_type* pbuffer_) ETL_NOEXCEPT
ETL_CONSTEXPR14 bitset_ext(const bitset_ext<Active_Bits, TElement, false>& other, element_type* pbuffer_)
: pbuffer(pbuffer_)
{
ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
etl::copy_n(other.pbuffer, Number_Of_Elements, pbuffer);
}
@ -3517,9 +3541,10 @@ namespace etl
//*************************************************************************
/// Construct from a value.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext(unsigned long long value, element_type* pbuffer_) ETL_NOEXCEPT
ETL_CONSTEXPR14 bitset_ext(unsigned long long value, element_type* pbuffer_)
: pbuffer(pbuffer_)
{
ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
ibitset.initialise(pbuffer, Number_Of_Elements, value);
clear_unused_bits_in_msb();
}
@ -3537,9 +3562,10 @@ namespace etl
//*************************************************************************
/// Construct from a string.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext(const char* text, element_type* pbuffer_) ETL_NOEXCEPT
ETL_CONSTEXPR14 bitset_ext(const char* text, element_type* pbuffer_)
: pbuffer(pbuffer_)
{
ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
clear_unused_bits_in_msb();
}
@ -3557,9 +3583,10 @@ namespace etl
//*************************************************************************
/// Construct from a string.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, element_type* pbuffer_) ETL_NOEXCEPT
ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, element_type* pbuffer_)
: pbuffer(pbuffer_)
{
ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
clear_unused_bits_in_msb();
}
@ -3577,9 +3604,10 @@ namespace etl
//*************************************************************************
/// Construct from a string.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext(const char16_t* text, element_type* pbuffer_) ETL_NOEXCEPT
ETL_CONSTEXPR14 bitset_ext(const char16_t* text, element_type* pbuffer_)
: pbuffer(pbuffer_)
{
ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
clear_unused_bits_in_msb();
}
@ -3597,9 +3625,10 @@ namespace etl
//*************************************************************************
/// Construct from a string.
//*************************************************************************
ETL_CONSTEXPR14 bitset_ext(const char32_t* text, element_type* pbuffer_) ETL_NOEXCEPT
ETL_CONSTEXPR14 bitset_ext(const char32_t* text, element_type* pbuffer_)
: pbuffer(pbuffer_)
{
ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer));
ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text);
clear_unused_bits_in_msb();
}

2
test/test_bit_stream_reader_big_endian.cpp
View File

@ -94,7 +94,7 @@ namespace etl
namespace
{
SUITE(test_bit_stream_reader)
SUITE(test_bit_stream_reader_big_endian)
{
//*************************************************************************
TEST(test_read_bool)

2
test/test_bit_stream_reader_little_endian.cpp
View File

@ -95,7 +95,7 @@ namespace etl
namespace
{
SUITE(test_bit_stream_reader)
SUITE(test_bit_stream_reader_little_endian)
{
//*************************************************************************
TEST(test_read_bool)

2
test/test_bit_stream_writer_big_endian.cpp
View File

@ -114,7 +114,7 @@ namespace
std::vector<char> data;
};
SUITE(test_bit_stream_big_endian)
SUITE(test_bit_stream_writer_big_endian)
{
//*************************************************************************
TEST(test_bit_stream_writer_construction)

2
test/test_bit_stream_writer_little_endian.cpp
View File

@ -114,7 +114,7 @@ namespace
std::vector<char> data;
};
SUITE(test_bit_stream_little_endian)
SUITE(test_bit_stream_writer_little_endian)
{
//*************************************************************************
TEST(test_bit_stream_writer_construction)

154
test/test_bitset_legacy.cpp
View File

@ -143,6 +143,50 @@ namespace
}
}
//*************************************************************************
TEST(test_construct_from_nullptr_char_string)
{
const char* s = nullptr;
etl::bitset<60> data(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_nullptr_wchar_t_string)
{
const wchar_t* s = nullptr;
etl::bitset<60> data(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_nullptr_char16_t_string)
{
const char16_t* s = nullptr;
etl::bitset<60> data(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_nullptr_char32_t_string)
{
const char32_t* s = nullptr;
etl::bitset<60> data(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_excess_string)
{
@ -206,7 +250,7 @@ namespace
}
//*************************************************************************
TEST(test_char_string_set)
TEST(test_set_with_char_string)
{
std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
etl::bitset<60> data;
@ -226,7 +270,7 @@ namespace
}
//*************************************************************************
TEST(test_wchar_t_string_set)
TEST(test_set_with_wchar_t_string)
{
std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001");
etl::bitset<60> data;
@ -246,7 +290,7 @@ namespace
}
//*************************************************************************
TEST(test_char16_t_string_set)
TEST(test_set_with_char16_t_string)
{
std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001");
etl::bitset<60> data;
@ -266,7 +310,7 @@ namespace
}
//*************************************************************************
TEST(test_char32_t_string_set)
TEST(test_set_with_char32_t_string)
{
std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001");
etl::bitset<60> data;
@ -286,7 +330,55 @@ namespace
}
//*************************************************************************
TEST(test_from_char_string)
TEST(test_set_from_char_nullptr)
{
const char* s = nullptr;
etl::bitset<60> data;
data.set(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_set_from_wchar_t_nullptr)
{
const wchar_t* s = nullptr;
etl::bitset<60> data;
data.set(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_set_from_char16_t_nullptr)
{
const char16_t* s = nullptr;
etl::bitset<60> data;
data.set(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_set_from_char32_t_nullptr)
{
const char32_t* s = nullptr;
etl::bitset<60> data;
data.set(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_char)
{
std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
etl::bitset<60> data;
@ -306,7 +398,7 @@ namespace
}
//*************************************************************************
TEST(test_from_wchar_t_string)
TEST(test_from_string_with_wchar_t)
{
std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
etl::bitset<60> data;
@ -346,7 +438,7 @@ namespace
}
//*************************************************************************
TEST(test_from_char32_t_string)
TEST(test_from_string_with_char32_t)
{
std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
etl::bitset<60> data;
@ -365,6 +457,54 @@ namespace
}
}
//*************************************************************************
TEST(test_from_string_with_char_nullptr)
{
const char* s = nullptr;
etl::bitset<60> data;
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_wchar_t_nullptr)
{
const wchar_t* s = nullptr;
etl::bitset<60> data;
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_char16_t_nullptr)
{
const char16_t* s = nullptr;
etl::bitset<60> data;
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_char32_t_nullptr)
{
const char32_t* s = nullptr;
etl::bitset<60> data;
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_value_u8_min)
{

155
test/test_bitset_new_default_element_type.cpp
View File

@ -925,6 +925,51 @@ namespace
}
}
//*************************************************************************
TEST(test_construct_from_nullptr_char_string)
{
const char* s = nullptr;
etl::bitset<60> data(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_nullptr_wchar_t_string)
{
const wchar_t* s = nullptr;
etl::bitset<60> data(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_nullptr_char16_t_string)
{
const char16_t* s = nullptr;
etl::bitset<60> data(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_nullptr_char32_t_string)
{
const char32_t* s = nullptr;
etl::bitset<60> data(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_excess_string)
{
@ -965,7 +1010,7 @@ namespace
}
//*************************************************************************
TEST(test_char_string_set)
TEST(test_set_with_char_string)
{
std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
etl::bitset<60> data;
@ -985,7 +1030,7 @@ namespace
}
//*************************************************************************
TEST(test_wchar_t_string_set)
TEST(test_set_with_wchar_t_string)
{
std::bitset<60> compare(L"110001001000110100010101100111001100010010001101000101011001");
etl::bitset<60> data;
@ -1005,7 +1050,7 @@ namespace
}
//*************************************************************************
TEST(test_char16_t_string_set)
TEST(test_set_with_char16_t_string)
{
std::bitset<60> compare(u"110001001000110100010101100111001100010010001101000101011001");
etl::bitset<60> data;
@ -1025,7 +1070,7 @@ namespace
}
//*************************************************************************
TEST(test_char32_t_string_set)
TEST(test_set_with_char32_t_string)
{
std::bitset<60> compare(U"110001001000110100010101100111001100010010001101000101011001");
etl::bitset<60> data;
@ -1045,7 +1090,55 @@ namespace
}
//*************************************************************************
TEST(test_from_char_string)
TEST(test_set_from_char_nullptr)
{
const char* s = nullptr;
etl::bitset<60> data;
data.set(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_set_from_wchar_t_nullptr)
{
const wchar_t* s = nullptr;
etl::bitset<60> data;
data.set(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_set_from_char16_t_nullptr)
{
const char16_t* s = nullptr;
etl::bitset<60> data;
data.set(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_set_from_char32_t_nullptr)
{
const char32_t* s = nullptr;
etl::bitset<60> data;
data.set(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_char)
{
std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
etl::bitset<60> data;
@ -1065,7 +1158,7 @@ namespace
}
//*************************************************************************
TEST(test_from_wchar_t_string)
TEST(test_from_string_with_wchar_t)
{
std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
etl::bitset<60> data;
@ -1105,7 +1198,7 @@ namespace
}
//*************************************************************************
TEST(test_from_char32_t_string)
TEST(test_from_string_with_char32_t)
{
std::bitset<60> compare("110001001000110100010101100111001100010010001101000101011001");
etl::bitset<60> data;
@ -1124,6 +1217,54 @@ namespace
}
}
//*************************************************************************
TEST(test_from_string_with_char_nullptr)
{
const char* s = nullptr;
etl::bitset<60> data;
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_wchar_t_nullptr)
{
const wchar_t* s = nullptr;
etl::bitset<60> data;
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_char16_t_nullptr)
{
const char16_t* s = nullptr;
etl::bitset<60> data;
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_char32_t_nullptr)
{
const char32_t* s = nullptr;
etl::bitset<60> data;
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_value_u16_min)
{

154
test/test_bitset_new_explicit_single_element_type.cpp
View File

@ -255,6 +255,50 @@ namespace
}
}
//*************************************************************************
TEST(test_construct_from_nullptr_char_string)
{
const char* s = nullptr;
etl::bitset<60, int64_t> data(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_nullptr_wchar_t_string)
{
const wchar_t* s = nullptr;
etl::bitset<60, int64_t> data(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_nullptr_char16_t_string)
{
const char16_t* s = nullptr;
etl::bitset<60, int64_t> data(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_nullptr_char32_t_string)
{
const char32_t* s = nullptr;
etl::bitset<60, int64_t> data(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_excess_string)
{
@ -310,7 +354,7 @@ namespace
}
//*************************************************************************
TEST(test_char_string_set)
TEST(test_set_with_char_string)
{
std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
etl::bitset<64, int64_t> data;
@ -330,7 +374,7 @@ namespace
}
//*************************************************************************
TEST(test_wchar_t_string_set)
TEST(test_set_with_wchar_t_string)
{
std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001");
etl::bitset<64, int64_t> data;
@ -350,7 +394,7 @@ namespace
}
//*************************************************************************
TEST(test_char16_t_string_set)
TEST(test_set_with_char16_t_string)
{
std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001");
etl::bitset<64, int64_t> data;
@ -370,7 +414,7 @@ namespace
}
//*************************************************************************
TEST(test_char32_t_string_set)
TEST(test_set_with_char32_t_string)
{
std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001");
etl::bitset<64, int64_t> data;
@ -390,7 +434,55 @@ namespace
}
//*************************************************************************
TEST(test_from_char_string)
TEST(test_set_from_char_nullptr)
{
const char* s = nullptr;
etl::bitset<60, int64_t> data;
data.set(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_set_from_wchar_t_nullptr)
{
const wchar_t* s = nullptr;
etl::bitset<60, int64_t> data;
data.set(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_set_from_char16_t_nullptr)
{
const char16_t* s = nullptr;
etl::bitset<60, int64_t> data;
data.set(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_set_from_char32_t_nullptr)
{
const char32_t* s = nullptr;
etl::bitset<60, int64_t> data;
data.set(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_char)
{
std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
etl::bitset<64, int64_t> data;
@ -410,7 +502,7 @@ namespace
}
//*************************************************************************
TEST(test_from_wchar_t_string)
TEST(test_from_string_with_wchar_t)
{
std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
etl::bitset<64, int64_t> data;
@ -450,7 +542,7 @@ namespace
}
//*************************************************************************
TEST(test_from_char32_t_string)
TEST(test_from_string_with_char32_t)
{
std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
etl::bitset<64, int64_t> data;
@ -469,6 +561,54 @@ namespace
}
}
//*************************************************************************
TEST(test_from_string_with_char_nullptr)
{
const char* s = nullptr;
etl::bitset<60, int64_t> data;
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_wchar_t_nullptr)
{
const wchar_t* s = nullptr;
etl::bitset<60, int64_t> data;
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_char16_t_nullptr)
{
const char16_t* s = nullptr;
etl::bitset<60, int64_t> data;
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_char32_t_nullptr)
{
const char32_t* s = nullptr;
etl::bitset<60, int64_t> data;
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_value_u8_min)
{

187
test/test_bitset_new_ext_default_element_type.cpp
View File

@ -767,6 +767,23 @@ namespace
CHECK_EQUAL(1U, (etl::bitset_ext<64, int64_t>::Number_Of_Elements));
}
//*************************************************************************
TEST(test_construct_from_nullptr_buffer)
{
using BsExt = etl::bitset_ext<64>;
BsExt::buffer_type buffer;
BsExt bs2a(buffer);
CHECK_THROW(BsExt bs1(nullptr), etl::bitset_invalid_buffer);
CHECK_THROW(BsExt bs2b(bs2a, nullptr), etl::bitset_invalid_buffer);
CHECK_THROW(BsExt bs3(0ULL, nullptr), etl::bitset_invalid_buffer);
CHECK_THROW(BsExt bs4("0", nullptr), etl::bitset_invalid_buffer);
CHECK_THROW(BsExt bs5(L"0", nullptr), etl::bitset_invalid_buffer);
CHECK_THROW(BsExt bs6(u"0", nullptr), etl::bitset_invalid_buffer);
CHECK_THROW(BsExt bs7(U"0", nullptr), etl::bitset_invalid_buffer);
}
//*************************************************************************
TEST(test_construct_from_value)
{
@ -888,6 +905,58 @@ namespace
}
}
//*************************************************************************
TEST(test_construct_from_nullptr_char_string)
{
etl::bitset_ext<60>::buffer_type buffer;
const char* s = nullptr;
etl::bitset_ext<60> data(s, buffer);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_nullptr_wchar_t_string)
{
etl::bitset_ext<60>::buffer_type buffer;
const wchar_t* s = nullptr;
etl::bitset_ext<60> data(s, buffer);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_nullptr_char16_t_string)
{
etl::bitset_ext<60>::buffer_type buffer;
const char16_t* s = nullptr;
etl::bitset_ext<60> data(s, buffer);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_nullptr_char32_t_string)
{
etl::bitset_ext<60>::buffer_type buffer;
const char32_t* s = nullptr;
etl::bitset_ext<60> data(s, buffer);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_excess_string)
{
@ -932,7 +1001,7 @@ namespace
}
//*************************************************************************
TEST(test_char_string_set)
TEST(test_set_with_char_string)
{
etl::bitset_ext<60>::buffer_type buffer;
@ -954,7 +1023,7 @@ namespace
}
//*************************************************************************
TEST(test_wchar_t_string_set)
TEST(test_set_with_wchar_t_string)
{
etl::bitset_ext<60>::buffer_type buffer;
@ -976,7 +1045,7 @@ namespace
}
//*************************************************************************
TEST(test_char16_t_string_set)
TEST(test_set_with_char16_t_string)
{
etl::bitset_ext<60>::buffer_type buffer;
@ -998,7 +1067,7 @@ namespace
}
//*************************************************************************
TEST(test_char32_t_string_set)
TEST(test_set_with_char32_t_string)
{
etl::bitset_ext<60>::buffer_type buffer;
@ -1020,7 +1089,59 @@ namespace
}
//*************************************************************************
TEST(test_from_char_string)
TEST(test_set_from_char_nullptr)
{
const char* s = nullptr;
etl::bitset_ext<60>::buffer_type buffer;
etl::bitset_ext<60> data(buffer);
data.set(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_set_from_wchar_t_nullptr)
{
const wchar_t* s = nullptr;
etl::bitset_ext<60>::buffer_type buffer;
etl::bitset_ext<60> data(buffer);
data.set(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_set_from_char16_t_nullptr)
{
const char16_t* s = nullptr;
etl::bitset_ext<60>::buffer_type buffer;
etl::bitset_ext<60> data(buffer);
data.set(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_set_from_char32_t_nullptr)
{
const char32_t* s = nullptr;
etl::bitset_ext<60>::buffer_type buffer;
etl::bitset_ext<60> data(buffer);
data.set(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_char)
{
etl::bitset_ext<60>::buffer_type buffer;
@ -1042,7 +1163,7 @@ namespace
}
//*************************************************************************
TEST(test_from_wchar_t_string)
TEST(test_from_string_with_wchar_t)
{
etl::bitset_ext<60>::buffer_type buffer;
@ -1086,7 +1207,7 @@ namespace
}
//*************************************************************************
TEST(test_from_char32_t_string)
TEST(test_from_string_with_char32_t)
{
etl::bitset_ext<60>::buffer_type buffer;
@ -1107,6 +1228,58 @@ namespace
}
}
//*************************************************************************
TEST(test_from_string_with_char_nullptr)
{
const char* s = nullptr;
etl::bitset_ext<60>::buffer_type buffer;
etl::bitset_ext<60> data(buffer);
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_wchar_t_nullptr)
{
const wchar_t* s = nullptr;
etl::bitset_ext<60>::buffer_type buffer;
etl::bitset_ext<60> data(buffer);
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_char16_t_nullptr)
{
const char16_t* s = nullptr;
etl::bitset_ext<60>::buffer_type buffer;
etl::bitset_ext<60> data(buffer);
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_char32_t_nullptr)
{
const char16_t* s = nullptr;
etl::bitset_ext<60>::buffer_type buffer;
etl::bitset_ext<60> data(buffer);
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_value_u16_min)
{

185
test/test_bitset_new_ext_explicit_single_element_type.cpp
View File

@ -44,6 +44,23 @@ namespace
SUITE(test_bitset_new_ext_explicit_element_type)
{
//*************************************************************************
TEST(test_construct_from_nullptr_buffer)
{
using BsExt = etl::bitset_ext<64, int64_t>;
BsExt::buffer_type buffer;
BsExt bs2a(buffer);
CHECK_THROW(BsExt bs1(nullptr) , etl::bitset_invalid_buffer);
CHECK_THROW(BsExt bs2b(bs2a, nullptr), etl::bitset_invalid_buffer);
CHECK_THROW(BsExt bs3(0ULL, nullptr), etl::bitset_invalid_buffer);
CHECK_THROW(BsExt bs4("0", nullptr), etl::bitset_invalid_buffer);
CHECK_THROW(BsExt bs5(L"0", nullptr), etl::bitset_invalid_buffer);
CHECK_THROW(BsExt bs6(u"0", nullptr), etl::bitset_invalid_buffer);
CHECK_THROW(BsExt bs7(U"0", nullptr), etl::bitset_invalid_buffer);
}
//*************************************************************************
TEST(test_default_constructor_from_array)
{
@ -210,6 +227,54 @@ namespace
}
}
//*************************************************************************
TEST(test_construct_from_nullptr_char_string)
{
const char* s = nullptr;
etl::bitset_ext<60, int64_t>::buffer_type buffer;
etl::bitset_ext<60, int64_t> data(s, buffer);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_nullptr_wchar_t_string)
{
const wchar_t* s = nullptr;
etl::bitset_ext<60, int64_t>::buffer_type buffer;
etl::bitset_ext<60, int64_t> data(s, buffer);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_nullptr_char16_t_string)
{
const char16_t* s = nullptr;
etl::bitset_ext<60, int64_t>::buffer_type buffer;
etl::bitset_ext<60, int64_t> data(s, buffer);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_nullptr_char32_t_string)
{
const char32_t* s = nullptr;
etl::bitset_ext<60, int64_t>::buffer_type buffer;
etl::bitset_ext<60, int64_t> data(s, buffer);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_construct_from_excess_string)
{
@ -260,7 +325,7 @@ namespace
}
//*************************************************************************
TEST(test_char_string_set)
TEST(test_set_with_char_string)
{
etl::bitset_ext<64, int64_t>::buffer_type buffer;
std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
@ -281,7 +346,7 @@ namespace
}
//*************************************************************************
TEST(test_wchar_t_string_set)
TEST(test_set_with_wchar_t_string)
{
etl::bitset_ext<64, int64_t>::buffer_type buffer;
std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001");
@ -302,7 +367,7 @@ namespace
}
//*************************************************************************
TEST(test_char16_t_string_set)
TEST(test_set_with_char16_t_string)
{
etl::bitset_ext<64, int64_t>::buffer_type buffer;
std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001");
@ -323,7 +388,7 @@ namespace
}
//*************************************************************************
TEST(test_char32_t_string_set)
TEST(test_set_with_char32_t_string)
{
etl::bitset_ext<64, int64_t>::buffer_type buffer;
std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001");
@ -344,7 +409,59 @@ namespace
}
//*************************************************************************
TEST(test_from_char_string)
TEST(test_set_from_char_nullptr)
{
const char* s = nullptr;
etl::bitset_ext<64, int64_t>::buffer_type buffer;
etl::bitset_ext<64, int64_t> data(buffer);
data.set(s);
CHECK_EQUAL(64, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_set_from_wchar_t_nullptr)
{
const wchar_t* s = nullptr;
etl::bitset_ext<64, int64_t>::buffer_type buffer;
etl::bitset_ext<64, int64_t> data(buffer);
data.set(s);
CHECK_EQUAL(64, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_set_from_char16_t_nullptr)
{
const char16_t* s = nullptr;
etl::bitset_ext<64, int64_t>::buffer_type buffer;
etl::bitset_ext<64, int64_t> data(buffer);
data.set(s);
CHECK_EQUAL(64, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_set_from_char32_t_nullptr)
{
const char32_t* s = nullptr;
etl::bitset_ext<64, int64_t>::buffer_type buffer;
etl::bitset_ext<64, int64_t> data(buffer);
data.set(s);
CHECK_EQUAL(64, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_char)
{
etl::bitset_ext<64, int64_t>::buffer_type buffer;
std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
@ -365,7 +482,7 @@ namespace
}
//*************************************************************************
TEST(test_from_wchar_t_string)
TEST(test_from_string_with_wchar_t)
{
etl::bitset_ext<64, int64_t>::buffer_type buffer;
std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
@ -386,7 +503,7 @@ namespace
}
//*************************************************************************
TEST(test_from_char16_t_6string)
TEST(test_from_string_with_char16_t)
{
etl::bitset_ext<64, int64_t>::buffer_type buffer;
std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
@ -407,7 +524,7 @@ namespace
}
//*************************************************************************
TEST(test_from_char32_t_string)
TEST(test_from_string_with_char32_t)
{
etl::bitset_ext<64, int64_t>::buffer_type buffer;
std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001");
@ -427,6 +544,58 @@ namespace
}
}
//*************************************************************************
TEST(test_from_string_with_char_nullptr)
{
const char* s = nullptr;
etl::bitset_ext<60, int64_t>::buffer_type buffer;
etl::bitset_ext<60, int64_t> data(buffer);
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_wchar_t_nullptr)
{
const wchar_t* s = nullptr;
etl::bitset_ext<60, int64_t>::buffer_type buffer;
etl::bitset_ext<60, int64_t> data(buffer);
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_char16_t_nullptr)
{
const char16_t* s = nullptr;
etl::bitset_ext<60, int64_t>::buffer_type buffer;
etl::bitset_ext<60, int64_t> data(buffer);
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_from_string_with_char32_t_nullptr)
{
const char16_t* s = nullptr;
etl::bitset_ext<60, int64_t>::buffer_type buffer;
etl::bitset_ext<60, int64_t> data(buffer);
data.from_string(s);
CHECK_EQUAL(60, data.size());
CHECK_EQUAL(0, data.count());
}
//*************************************************************************
TEST(test_value_u8_min)
{