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

Added endianness to bit_stream_writer

Browse Source
This commit is contained in:
John Wellbelove 2022-06-18 20:57:26 +01:00
parent c83b222690
commit fefe6d3975
8 changed files with 1488 additions and 283 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

305
include/etl/bit_stream.h
View File

@ -554,6 +554,7 @@ namespace etl
public:
typedef char value_type;
typedef value_type* iterator;
typedef const value_type* const_iterator;
typedef etl::span<value_type> callback_parameter_type;
typedef etl::delegate<void(callback_parameter_type)> callback_type;
@ -561,9 +562,10 @@ namespace etl
//***************************************************************************
/// Construct from span.
//***************************************************************************
bit_stream_writer(etl::span<char> span_, callback_type callback_ = callback_type())
bit_stream_writer(etl::span<char> span_, etl::endian buffer_endianness_, callback_type callback_ = callback_type())
: pdata(span_.begin())
, length_chars(span_.size_bytes())
, stream_endianness(buffer_endianness_)
, callback(callback_)
{
restart();
@ -572,9 +574,10 @@ namespace etl
//***************************************************************************
/// Construct from span.
//***************************************************************************
bit_stream_writer(etl::span<unsigned char> span_, callback_type callback_ = callback_type())
bit_stream_writer(etl::span<unsigned char> span_, etl::endian buffer_endianness_, callback_type callback_ = callback_type())
: pdata(reinterpret_cast<char*>(span_.begin()))
, length_chars(span_.size_bytes())
, stream_endianness(buffer_endianness_)
, callback(callback_)
{
restart();
@ -583,9 +586,10 @@ namespace etl
//***************************************************************************
/// Construct from range.
//***************************************************************************
bit_stream_writer(void* begin_, void* end_, callback_type callback_ = callback_type())
bit_stream_writer(void* begin_, void* end_, etl::endian buffer_endianness_, callback_type callback_ = callback_type())
: pdata(reinterpret_cast<char*>(begin_))
, length_chars(etl::distance(reinterpret_cast<unsigned char*>(begin_), reinterpret_cast<unsigned char*>(end_)))
, stream_endianness(buffer_endianness_)
, callback(callback_)
{
restart();
@ -594,9 +598,10 @@ namespace etl
//***************************************************************************
/// Construct from begin and length.
//***************************************************************************
bit_stream_writer(void* begin_, size_t length_chars_, callback_type callback_ = callback_type())
bit_stream_writer(void* begin_, size_t length_chars_, etl::endian buffer_endianness_, callback_type callback_ = callback_type())
: pdata(reinterpret_cast<char*>(begin_))
, length_chars(length_chars_)
, stream_endianness(buffer_endianness_)
, callback(callback_)
{
restart();
@ -677,6 +682,12 @@ namespace etl
typename etl::enable_if<etl::is_integral<T>::value, void>::type
write_unchecked(T value, uint_least8_t nbits = CHAR_BIT * sizeof(T))
{
if (stream_endianness == etl::endian::little)
{
value = etl::reverse_bits(value);
value = value >> ((CHAR_BIT * sizeof(T)) - nbits);
}
write_integral(static_cast<uint32_t>(value), nbits);
}
@ -707,6 +718,12 @@ namespace etl
//***************************************************************************
void write_unchecked(int64_t value, uint_least8_t nbits = CHAR_BIT * sizeof(int64_t))
{
if (stream_endianness == etl::endian::little)
{
value = etl::reverse_bits(value);
value = value >> ((CHAR_BIT * sizeof(int64_t)) - nbits);
}
write_integral(uint64_t(value), nbits);
}
@ -734,6 +751,12 @@ namespace etl
//***************************************************************************
void write_unchecked(uint64_t value, uint_least8_t nbits = CHAR_BIT * sizeof(int64_t))
{
if (stream_endianness == etl::endian::little)
{
value = etl::reverse_bits(value);
value = value >> ((CHAR_BIT * sizeof(int64_t)) - nbits);
}
write_integral(uint64_t(value), nbits);
}
@ -757,43 +780,6 @@ namespace etl
}
#endif
//***************************************************************************
/// For floating point types
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_floating_point<T>::value, void>::type
write_unchecked(T value)
{
unsigned char data[sizeof(T)];
to_bytes(value, data);
for (size_t i = 0UL; i < sizeof(T); ++i)
{
write_integral(uint32_t(data[i]), CHAR_BIT);
}
}
//***************************************************************************
/// For floating point types
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_floating_point<T>::value, bool>::type
write(T value)
{
bool success = available<T>();
if (success)
{
write_unchecked(value);
}
else
{
ETL_ASSERT_FAIL(ETL_ERROR(etl::bit_stream_overflow));
}
return success;
}
//***************************************************************************
/// Skip n bits, up to the maximum space available.
/// Returns <b>true</b> if the skip was possible.
@ -885,6 +871,14 @@ namespace etl
return bits_available;
}
//***************************************************************************
/// Returns start of the stream.
//***************************************************************************
iterator begin()
{
return pdata;
}
//***************************************************************************
/// Returns start of the stream.
//***************************************************************************
@ -901,6 +895,14 @@ namespace etl
return pdata;
}
//***************************************************************************
/// Returns end of the stream.
//***************************************************************************
iterator end()
{
return pdata + size_bytes();
}
//***************************************************************************
/// Returns end of the stream.
//***************************************************************************
@ -920,19 +922,35 @@ namespace etl
//***************************************************************************
/// Returns a span of the used portion of the stream.
//***************************************************************************
etl::span<char> used_data() const
etl::span<char> used_data()
{
return etl::span<char>(pdata, pdata + size_bytes());
}
//***************************************************************************
/// Returns a span of the used portion of the stream.
//***************************************************************************
etl::span<const char> used_data() const
{
return etl::span<const char>(pdata, pdata + size_bytes());
}
//***************************************************************************
/// Returns a span of whole the stream.
//***************************************************************************
etl::span<char> data() const
etl::span<char> data()
{
return etl::span<char>(pdata, pdata + length_chars);
}
//***************************************************************************
/// Returns a span of whole the stream.
//***************************************************************************
etl::span<const char> data() const
{
return etl::span<const char>(pdata, pdata + length_chars);
}
//***************************************************************************
/// Flush the last byte, if partially filled, to the callback, if valid.
//***************************************************************************
@ -1097,32 +1115,53 @@ namespace etl
bits_available -= nbits;
}
char* const pdata; ///< The start of the bitstream buffer.
const size_t length_chars; ///< The length of the bitstream buffer.
unsigned char bits_available_in_char; ///< The number of available bits in the current char.
size_t char_index; ///< The index of the current char in the bitstream buffer.
size_t bits_available; ///< The number of bits still available in the bitstream buffer.
callback_type callback; ///< An optional callback on every filled byte in buffer.
char* const pdata; ///< The start of the bitstream buffer.
const size_t length_chars; ///< The length of the bitstream buffer.
const etl::endian stream_endianness; ///< The endianness of the stream data.
unsigned char bits_available_in_char; ///< The number of available bits in the current char.
size_t char_index; ///< The index of the current char in the bitstream buffer.
size_t bits_available; ///< The number of bits still available in the bitstream buffer.
callback_type callback; ///< An optional callback on every filled byte in buffer.
};
//***************************************************************************
/// Implementation of the write function.
/// For bool types only.
//***************************************************************************
inline void write_unchecked(etl::bit_stream_writer& stream, bool value)
{
stream.write_unchecked(value);
}
//***************************************************************************
/// Implementation of the write function.
/// For bool types only.
//***************************************************************************
inline bool write(etl::bit_stream_writer& stream, bool value)
{
return stream.write(value);
}
//***************************************************************************
/// Default implementation of the write function.
/// For integral and floating point types only.
/// For integral types only (but not bool).
/// Overload this to support custom types.
//***************************************************************************
template <typename T>
void write_unchecked(etl::bit_stream_writer& stream, const T& value, uint_least8_t nbits = CHAR_BIT * sizeof(T))
typename etl::enable_if<etl::is_integral<T>::value, void>::type
write_unchecked(etl::bit_stream_writer& stream, const T& value, uint_least8_t nbits = CHAR_BIT * sizeof(T))
{
stream.write_unchecked(value, nbits);
}
//***************************************************************************
/// Default implementation of the write function.
/// For integral and floating point types only.
/// For integral types only (but not bool).
/// Overload this to support custom types.
//***************************************************************************
template <typename T>
bool write(etl::bit_stream_writer& stream, const T& value, uint_least8_t nbits = CHAR_BIT * sizeof(T))
typename etl::enable_if<etl::is_integral<T>::value, bool>::type
write(etl::bit_stream_writer& stream, const T& value, uint_least8_t nbits = CHAR_BIT * sizeof(T))
{
return stream.write(value, nbits);
}
@ -1139,9 +1178,10 @@ namespace etl
//***************************************************************************
/// Construct from span.
//***************************************************************************
bit_stream_reader(etl::span<char> span_)
bit_stream_reader(etl::span<char> span_, etl::endian buffer_endianness_)
: pdata(span_.begin())
, length_chars(span_.size_bytes())
, stream_endianness(etl::endian::big)
{
restart();
}
@ -1149,9 +1189,10 @@ namespace etl
//***************************************************************************
/// Construct from span.
//***************************************************************************
bit_stream_reader(etl::span<unsigned char> span_)
bit_stream_reader(etl::span<unsigned char> span_, etl::endian buffer_endianness_)
: pdata(reinterpret_cast<char*>(span_.begin()))
, length_chars(span_.size_bytes())
, stream_endianness(etl::endian::big)
{
restart();
}
@ -1159,9 +1200,10 @@ namespace etl
//***************************************************************************
/// Construct from range.
//***************************************************************************
bit_stream_reader(void* begin_, void* end_)
bit_stream_reader(void* begin_, void* end_, etl::endian buffer_endianness_)
: pdata(reinterpret_cast<char*>(begin_))
, length_chars(etl::distance(reinterpret_cast<char*>(begin_), reinterpret_cast<char*>(end_)))
, stream_endianness(etl::endian::big)
{
restart();
}
@ -1169,9 +1211,10 @@ namespace etl
//***************************************************************************
/// Construct from begin and length.
//***************************************************************************
bit_stream_reader(void* begin_, size_t length_)
bit_stream_reader(void* begin_, size_t length_, etl::endian buffer_endianness_)
: pdata(reinterpret_cast<char*>(begin_))
, length_chars(length_)
, stream_endianness(etl::endian::big)
{
restart();
}
@ -1271,74 +1314,12 @@ namespace etl
return result;
}
//***************************************************************************
/// For floating point types
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_floating_point<T>::value, T>::type
read_unchecked()
{
T value = 0;
// Temporary storage.
etl::uninitialized_buffer_of<T, 1U> data;
for (size_t i = 0UL; i < sizeof(T); ++i)
{
data.raw[i] = read_unchecked<char>();
}
from_bytes(reinterpret_cast<const unsigned char*>(data.raw), value);
return value;
}
//***************************************************************************
/// For floating point types
//***************************************************************************
template <typename T>
typename etl::enable_if<etl::is_floating_point<T>::value, etl::optional<T>>::type
read()
{
uint_least8_t nbits = CHAR_BIT * sizeof(T);
etl::optional<T> result;
// Do we have enough bits?
if (bits_available >= nbits)
{
result = read_unchecked<T>();
}
else
{
ETL_ASSERT_FAIL(ETL_ERROR(etl::bit_stream_overflow));
}
return result;
}
//***************************************************************************
/// Returns the number of bytes used in the stream.
//***************************************************************************
size_t size_bytes() const
{
//size_t s = char_index;
//// Current byte is used?
//if (bits_available_in_char != CHAR_BIT)
//{
// ++s;
//}
//return s;
}
//***************************************************************************
/// Returns the number of bits used in the stream.
//***************************************************************************
size_t size_bits() const
{
return (length_chars * CHAR_BIT) - bits_available;
return length_chars;
}
//***************************************************************************
@ -1349,6 +1330,14 @@ namespace etl
return pdata;
}
//***************************************************************************
/// Returns start of the stream.
//***************************************************************************
const_iterator cbegin() const
{
return pdata;
}
//***************************************************************************
/// Returns end of the stream.
//***************************************************************************
@ -1357,6 +1346,22 @@ namespace etl
return pdata + size_bytes();
}
//***************************************************************************
/// Returns end of the stream.
//***************************************************************************
const_iterator cend() const
{
return pdata + size_bytes();
}
//***************************************************************************
/// Returns a span of whole the stream.
//***************************************************************************
etl::span<const char> data() const
{
return etl::span<const char>(pdata, pdata + length_chars);
}
private:
//***************************************************************************
@ -1365,7 +1370,6 @@ namespace etl
unsigned char get_chunk(unsigned char nbits)
{
unsigned char value = pdata[char_index];
value >>= (bits_available_in_char - nbits);
unsigned char mask;
@ -1436,12 +1440,61 @@ namespace etl
bits_available -= nbits;
}
char* pdata; ///< The start of the bitstream buffer.
size_t length_chars; ///< The length, in char, of the bitstream buffer.
unsigned char bits_available_in_char; ///< The number of available bits in the current char.
size_t char_index; ///< The index of the char in the bitstream buffer.
size_t bits_available; ///< The number of bits still available in the bitstream buffer.
char* pdata; ///< The start of the bitstream buffer.
size_t length_chars; ///< The length, in char, of the bitstream buffer.
const etl::endian stream_endianness; ///< The endianness of the stream data.
unsigned char bits_available_in_char; ///< The number of available bits in the current char.
size_t char_index; ///< The index of the char in the bitstream buffer.
size_t bits_available; ///< The number of bits still available in the bitstream buffer.
};
//***************************************************************************
/// Read an unchecked type from a stream.
//***************************************************************************
template <typename T>
T read_unchecked(etl::bit_stream_reader& stream)
{
return stream.read_unchecked<T>();
}
template <typename T>
T read_unchecked(etl::bit_stream_reader& stream, uint_least8_t nbits)
{
return stream.read_unchecked<T>(nbits);
}
//***************************************************************************
/// Read a checked type from a stream.
//***************************************************************************
template <typename T>
etl::optional<T> read(etl::bit_stream_reader& stream)
{
return stream.read<T>();
}
template <typename T>
etl::optional<T> read(etl::bit_stream_reader& stream, uint_least8_t nbits)
{
return stream.read<T>(nbits);
}
//***************************************************************************
/// Read an unchecked bool from a stream.
//***************************************************************************
template <>
inline bool read_unchecked<bool>(etl::bit_stream_reader& stream)
{
return stream.read_unchecked<bool>();
}
//***************************************************************************
/// Read a bool from a stream.
//***************************************************************************
template <>
inline etl::optional<bool> read<bool>(etl::bit_stream_reader& stream)
{
return stream.read<bool>();
}
}
#include "private/minmax_pop.h"

80
include/etl/byte_stream.h
View File

@ -85,6 +85,7 @@ namespace etl
{
public:
typedef char* iterator;
typedef const char* const_iterator;
typedef etl::span<char> callback_parameter_type;
typedef etl::delegate<void(callback_parameter_type)> callback_type;
@ -96,7 +97,7 @@ namespace etl
: pdata(span_.begin())
, pcurrent(span_.begin())
, length(span_.size_bytes())
, buffer_endianness(buffer_endianness_)
, stream_endianness(buffer_endianness_)
, callback(callback_)
{
}
@ -108,7 +109,7 @@ namespace etl
: pdata(reinterpret_cast<char*>(span_.begin()))
, pcurrent(reinterpret_cast<char*>(span_.begin()))
, length(span_.size_bytes())
, buffer_endianness(buffer_endianness_)
, stream_endianness(buffer_endianness_)
, callback(callback_)
{
}
@ -120,7 +121,7 @@ namespace etl
: pdata(reinterpret_cast<char*>(begin_))
, pcurrent(reinterpret_cast<char*>(begin_))
, length(etl::distance(reinterpret_cast<char*>(begin_), reinterpret_cast<char*>(end_)))
, buffer_endianness(buffer_endianness_)
, stream_endianness(buffer_endianness_)
, callback(callback_)
{
}
@ -132,7 +133,7 @@ namespace etl
: pdata(reinterpret_cast<char*>(begin_))
, pcurrent(reinterpret_cast<char*>(begin_))
, length(length_)
, buffer_endianness(buffer_endianness_)
, stream_endianness(buffer_endianness_)
, callback(callback_)
{
}
@ -145,7 +146,7 @@ namespace etl
: pdata(begin_)
, pcurrent(begin_)
, length(begin_ + (Size * sizeof(T)))
, buffer_endianness(buffer_endianness_)
, stream_endianness(buffer_endianness_)
, callback(callback_)
{
}
@ -310,6 +311,14 @@ namespace etl
pcurrent = const_cast<char*>(pdata + n);
}
//***************************************************************************
/// Returns start of the stream.
//***************************************************************************
iterator begin()
{
return pdata;
}
//***************************************************************************
/// Returns start of the stream.
//***************************************************************************
@ -318,6 +327,14 @@ namespace etl
return pdata;
}
//***************************************************************************
/// Returns end of the stream.
//***************************************************************************
iterator end()
{
return pcurrent;
}
//***************************************************************************
/// Returns end of the stream.
//***************************************************************************
@ -345,27 +362,51 @@ namespace etl
//***************************************************************************
/// Returns a span of the used portion of the stream.
//***************************************************************************
etl::span<char> used_data() const
etl::span<char> used_data()
{
return etl::span<char>(pdata, pcurrent);
}
//***************************************************************************
/// Returns a span of the used portion of the stream.
//***************************************************************************
etl::span<const char> used_data() const
{
return etl::span<const char>(pdata, pcurrent);
}
//***************************************************************************
/// Returns a span of the free portion of the stream.
//***************************************************************************
etl::span<char> free_data() const
etl::span<char> free_data()
{
return etl::span<char>(pcurrent, pdata + length);
}
//***************************************************************************
/// Returns a span of the free portion of the stream.
//***************************************************************************
etl::span<const char> free_data() const
{
return etl::span<const char>(pcurrent, pdata + length);
}
//***************************************************************************
/// Returns a span of whole the stream.
//***************************************************************************
etl::span<char> data() const
etl::span<char> data()
{
return etl::span<char>(pdata, pdata + length);
}
//***************************************************************************
/// Returns a span of whole the stream.
//***************************************************************************
etl::span<const char> data() const
{
return etl::span<const char>(pdata, pdata + length);
}
//***************************************************************************
/// Returns <b>true</b> if the byte stream index has reached the end.
//***************************************************************************
@ -436,7 +477,7 @@ namespace etl
//***************************************************************************
etl::endian get_endianness() const
{
return buffer_endianness;
return stream_endianness;
}
private:
@ -475,7 +516,7 @@ namespace etl
{
const etl::endian platform_endianness = etl::endianness::value();
if (buffer_endianness == platform_endianness)
if (stream_endianness == platform_endianness)
{
etl::copy(source, source + length, destination);
}
@ -488,7 +529,7 @@ namespace etl
char* const pdata; ///< The start of the byte stream buffer.
char* pcurrent; ///< The current position in the byte stream buffer.
const size_t length; ///< The length of the byte stream buffer.
const etl::endian buffer_endianness; ///< The endianness of the buffer data.
const etl::endian stream_endianness; ///< The endianness of the stream data.
callback_type callback; ///< An optional callback on every step on the write buffer.
};
@ -500,6 +541,7 @@ namespace etl
{
public:
typedef char* iterator;
typedef const char* const_iterator;
//***************************************************************************
@ -509,7 +551,7 @@ namespace etl
: pdata(span_.begin())
, pcurrent(span_.begin())
, length(span_.size_bytes())
, buffer_endianness(buffer_endianness_)
, stream_endianness(buffer_endianness_)
{
}
@ -520,7 +562,7 @@ namespace etl
: pdata(span_.begin())
, pcurrent(span_.begin())
, length(span_.size_bytes())
, buffer_endianness(buffer_endianness_)
, stream_endianness(buffer_endianness_)
{
}
@ -531,7 +573,7 @@ namespace etl
: pdata(reinterpret_cast<const char*>(begin_))
, pcurrent(reinterpret_cast<const char*>(begin_))
, length(etl::distance(reinterpret_cast<const char*>(begin_), reinterpret_cast<const char*>(end_)))
, buffer_endianness(buffer_endianness_)
, stream_endianness(buffer_endianness_)
{
}
@ -542,7 +584,7 @@ namespace etl
: pdata(reinterpret_cast<const char*>(begin_))
, pcurrent(reinterpret_cast<const char*>(begin_))
, length(length_)
, buffer_endianness(buffer_endianness_)
, stream_endianness(buffer_endianness_)
{
}
@ -554,7 +596,7 @@ namespace etl
: pdata(begin_)
, pcurrent(begin_)
, length(begin_ + (Size * sizeof(T)))
, buffer_endianness(buffer_endianness_)
, stream_endianness(buffer_endianness_)
{
}
@ -566,7 +608,7 @@ namespace etl
: pdata(begin_)
, pcurrent(begin_)
, length(begin_ + (Size * sizeof(T)))
, buffer_endianness(buffer_endianness_)
, stream_endianness(buffer_endianness_)
{
}
@ -851,7 +893,7 @@ namespace etl
{
const etl::endian platform_endianness = etl::endianness::value();
if (buffer_endianness == platform_endianness)
if (stream_endianness == platform_endianness)
{
etl::copy(source, source + length, destination);
}
@ -864,7 +906,7 @@ namespace etl
const char* const pdata; ///< The start of the byte stream buffer.
const char* pcurrent; ///< The current position in the byte stream buffer.
const size_t length; ///< The length of the byte stream buffer.
const etl::endian buffer_endianness; ///< The endianness of the buffer data.
const etl::endian stream_endianness; ///< The endianness of the stream data.
};
//***************************************************************************

403
test/test_bit_stream_reader.cpp → test/test_bit_stream_reader_big_endian.cpp
View File

@ -55,31 +55,45 @@ namespace
os << object.s << "," << object.i << "," << (int)object.c;
return os;
}
struct Object2
{
};
}
namespace etl
{
//***********************************
bool read(etl::bit_stream_reader& stream, Object& object)
template <>
Object read_unchecked<Object>(etl::bit_stream_reader& stream)
{
bool success = true;
//if (!stream.object.i, 14))
//{
// success = false;
//}
int16_t result_s = stream.read_unchecked<int16_t>(14);
int32_t result_i = stream.read_unchecked<int32_t>(23);
uint8_t result_c = stream.read_unchecked<uint8_t>();
//if (!stream.get(object.d))
//{
// success = false;
//}
return Object{ result_s, result_i, result_c };
}
//if (!stream.get(object.c))
//{
// success = false;
//}
//***********************************
template <>
optional<Object> read<Object>(etl::bit_stream_reader& stream)
{
optional<Object> result;
return success;
etl::optional<int16_t> result_s = stream.read<int16_t>(14);
etl::optional<int32_t> result_i = stream.read<int32_t>(23);
etl::optional<uint8_t> result_c = stream.read<uint8_t>();
if (result_s.has_value() && result_i.has_value() && result_c.has_value())
{
result = Object{ result_s.value(), result_i.value(), result_c.value() };
}
return result;
}
}
@ -92,7 +106,9 @@ namespace
{
char storage = 0x5AU;
etl::bit_stream_reader bit_stream(&storage, 1);
etl::bit_stream_reader bit_stream(&storage, 1, etl::endian::big);
CHECK_EQUAL(1U, bit_stream.size_bytes());
etl::optional<bool> result;
@ -140,13 +156,70 @@ namespace
CHECK_THROW(bit_stream.read<bool>(), etl::bit_stream_overflow);
}
//*************************************************************************
TEST(test_read_bool_using_non_member_function)
{
char storage = 0x5AU;
etl::bit_stream_reader bit_stream(&storage, 1, etl::endian::big);
CHECK_EQUAL(1U, bit_stream.size_bytes());
etl::optional<bool> result;
result.reset();
result = etl::read<bool>(bit_stream);
CHECK(result.has_value());
CHECK_EQUAL(false, result.value());
result.reset();
result = etl::read<bool>(bit_stream);
CHECK(result.has_value());
CHECK_EQUAL(true, result.value());
result.reset();
result = etl::read<bool>(bit_stream);
CHECK(result.has_value());
CHECK_EQUAL(false, result.value());
result.reset();
result = etl::read<bool>(bit_stream);
CHECK(result.has_value());
CHECK_EQUAL(true, result.value());
result.reset();
result = etl::read<bool>(bit_stream);
CHECK(result.has_value());
CHECK_EQUAL(true, result.value());
result.reset();
result = etl::read<bool>(bit_stream);
CHECK(result.has_value());
CHECK_EQUAL(false, result.value());
result.reset();
result = etl::read<bool>(bit_stream);
CHECK(result.has_value());
CHECK_EQUAL(true, result.value());
result.reset();
result = etl::read<bool>(bit_stream);
CHECK(result.has_value());
CHECK_EQUAL(false, result.value());
// One too many.
CHECK_THROW(etl::read<bool>(bit_stream), etl::bit_stream_overflow);
}
//*************************************************************************
TEST(test_read_int8_t)
{
std::array storage = { char(0x01), char(0x5A), char(0xA5), char(0xFF) };
std::array expected = { int8_t(0x01), int8_t(0x5A), int8_t(0xA5), int8_t(0xFF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
etl::optional<int8_t> result;
@ -173,6 +246,67 @@ namespace
// One too many.
CHECK_THROW(bit_stream.read<int8_t>(), etl::bit_stream_overflow);
}
//*************************************************************************
TEST(test_read_checked_int8_t_using_non_member_function)
{
std::array storage = { char(0x01), char(0x5A), char(0xA5), char(0xFF) };
std::array expected = { int8_t(0x01), int8_t(0x5A), int8_t(0xA5), int8_t(0xFF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
etl::optional<int8_t> result;
result.reset();
result = etl::read<int8_t>(bit_stream);
CHECK(result.has_value());
CHECK_EQUAL(int(expected[0]), int(result.value()));
result.reset();
result = etl::read<int8_t>(bit_stream);
CHECK(result.has_value());
CHECK_EQUAL(int(expected[1]), int(result.value()));
result.reset();
result = etl::read<int8_t>(bit_stream);
CHECK(result.has_value());
CHECK_EQUAL(int(expected[2]), int(result.value()));
result.reset();
result = etl::read<int8_t>(bit_stream);
CHECK(result.has_value());
CHECK_EQUAL(int(expected[3]), int(result.value()));
// One too many.
CHECK_THROW(etl::read<int8_t>(bit_stream), etl::bit_stream_overflow);
}
//*************************************************************************
TEST(test_read_unchecked_int8_t_using_non_member_function)
{
std::array storage = { char(0x01), char(0x5A), char(0xA5), char(0xFF) };
std::array expected = { int8_t(0x01), int8_t(0x5A), int8_t(0xA5), int8_t(0xFF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
int8_t result;
result = etl::read_unchecked<int8_t>(bit_stream);
CHECK_EQUAL(int(expected[0]), int(result));
result = etl::read_unchecked<int8_t>(bit_stream);
CHECK_EQUAL(int(expected[1]), int(result));
result = etl::read_unchecked<int8_t>(bit_stream);
CHECK_EQUAL(int(expected[2]), int(result));
result = etl::read_unchecked<int8_t>(bit_stream);
CHECK_EQUAL(int(expected[3]), int(result));
}
//*************************************************************************
TEST(test_read_int8_t_5bits)
@ -180,7 +314,9 @@ namespace
std::array storage = { char(0x0E), char(0x8B), char(0xF0) };
std::array expected = { int8_t(0x01), int8_t(0xFA), int8_t(0x05), int8_t(0xFF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
etl::optional<int8_t> result;
@ -208,13 +344,76 @@ namespace
CHECK_THROW(bit_stream.read<int8_t>(5U), etl::bit_stream_overflow);
}
//*************************************************************************
TEST(test_read_checked_int8_t_5bits_using_non_member_function)
{
std::array storage = { char(0x0E), char(0x8B), char(0xF0) };
std::array expected = { int8_t(0x01), int8_t(0xFA), int8_t(0x05), int8_t(0xFF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
etl::optional<int8_t> result;
result.reset();
result = etl::read<int8_t>(bit_stream, 5U);
CHECK(result.has_value());
CHECK_EQUAL(int(expected[0]), int(result.value()));
result.reset();
result = etl::read<int8_t>(bit_stream, 5U);
CHECK(result.has_value());
CHECK_EQUAL(int(expected[1]), int(result.value()));
result.reset();
result = etl::read<int8_t>(bit_stream, 5U);
CHECK(result.has_value());
CHECK_EQUAL(int(expected[2]), int(result.value()));
result.reset();
result = etl::read<int8_t>(bit_stream, 5U);
CHECK(result.has_value());
CHECK_EQUAL(int(expected[3]), int(result.value()));
// One too many.
CHECK_THROW(etl::read<int8_t>(bit_stream, 5U), etl::bit_stream_overflow);
}
//*************************************************************************
TEST(test_read_unchecked_int8_t_5bits_using_non_member_function)
{
std::array storage = { char(0x0E), char(0x8B), char(0xF0) };
std::array expected = { int8_t(0x01), int8_t(0xFA), int8_t(0x05), int8_t(0xFF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
int8_t result;
result = etl::read_unchecked<int8_t>(bit_stream, 5U);
CHECK_EQUAL(int(expected[0]), int(result));
result = etl::read_unchecked<int8_t>(bit_stream, 5U);
CHECK_EQUAL(int(expected[1]), int(result));
result = etl::read_unchecked<int8_t>(bit_stream, 5U);
CHECK_EQUAL(int(expected[2]), int(result));
result = etl::read_unchecked<int8_t>(bit_stream, 5U);
CHECK_EQUAL(int(expected[3]), int(result));
}
//*************************************************************************
TEST(test_read_uint8_t)
{
std::array storage = { char(0x01), char(0x5A), char(0xA5), char(0xFF) };
std::array expected = { uint8_t(0x01), uint8_t(0x5A), uint8_t(0xA5), uint8_t(0xFF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
etl::optional<uint8_t> result;
@ -248,7 +447,9 @@ namespace
std::array storage = { char(0x0E), char(0x8B), char(0xF0) };
std::array expected = { uint8_t(0x01), uint8_t(0x1A), uint8_t(0x05), uint8_t(0x1F) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
etl::optional<uint8_t> result;
@ -282,7 +483,9 @@ namespace
std::array storage = { char(0x00), char(0x01), char(0xA5), char(0x5A), char(0x5A), char(0xA5), char(0xFF), char(0xFF) };
std::array expected = { int16_t(0x0001), int16_t(0xA55A), int16_t(0x5AA5), int16_t(0xFFFF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
etl::optional<int16_t> result;
@ -316,7 +519,9 @@ namespace
std::array storage = { char(0x00), char(0x55), char(0xAA), char(0x97), char(0xFF) };
std::array expected = { int16_t(0x0001), int16_t(0x015A), int16_t(0xFEA5), int16_t(0xFFFF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
etl::optional<int16_t> result;
@ -350,7 +555,9 @@ namespace
std::array storage = { char(0x00), char(0x01), char(0xA5), char(0x5A), char(0x5A), char(0xA5), char(0xFF), char(0xFF) };
std::array expected = { uint16_t(0x0001), uint16_t(0xA55A), uint16_t(0x5AA5), uint16_t(0xFFFF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
etl::optional<uint16_t> result;
@ -384,7 +591,9 @@ namespace
std::array storage = { char(0x00), char(0x55), char(0xAA), char(0x97), char(0xFF) };
std::array expected = { uint16_t(0x0001), uint16_t(0x015A), uint16_t(0x02A5), uint16_t(0x03FF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
etl::optional<uint16_t> result;
@ -421,7 +630,9 @@ namespace
char(0xFF), char(0xFF), char(0xFF), char(0xFF) };
std::array expected = { int32_t(0x00000001), int32_t(0xA55AA55A), int32_t(0x5AA55AA5), int32_t(0xFFFFFFFF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
etl::optional<int32_t> result;
@ -457,7 +668,9 @@ namespace
char(0x7F), char(0xFF), char(0xFF) };
std::array expected = { int32_t(0x00000001), int32_t(0x001AA55A), int32_t(0xFFE55AA5), int32_t(0xFFFFFFFF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
etl::optional<int32_t> result;
@ -494,7 +707,9 @@ namespace
char(0xFF), char(0xFF), char(0xFF), char(0xFF) };
std::array expected = { uint32_t(0x00000001), uint32_t(0xA55AA55A), uint32_t(0x5AA55AA5), uint32_t(0xFFFFFFFF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
etl::optional<uint32_t> result;
@ -530,7 +745,9 @@ namespace
char(0x7F), char(0xFF), char(0xFF) };
std::array expected = { uint32_t(0x00000001), uint32_t(0x001AA55A), uint32_t(0x00255AA5), uint32_t(0x003FFFFF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
etl::optional<uint32_t> result;
@ -567,7 +784,9 @@ namespace
char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xFF) };
std::array expected = { int64_t(0x0000000000000001), int64_t(0xA55AA55AA55AA55A), int64_t(0x5AA55AA55AA55AA5), int64_t(0xFFFFFFFFFFFFFFFF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
etl::optional<int64_t> result;
@ -603,7 +822,9 @@ namespace
char(0xD5), char(0x2F), char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xF0) };
std::array expected = { int64_t(0x0000000000000001), int64_t(0x0000255AA55AA55A), int64_t(0xFFFFDAA55AA55AA5), int64_t(0xFFFFFFFFFFFFFFFF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
etl::optional<int64_t> result;
@ -640,7 +861,9 @@ namespace
char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xFF) };
std::array expected = { uint64_t(0x0000000000000001), uint64_t(0xA55AA55AA55AA55A), uint64_t(0x5AA55AA55AA55AA5), uint64_t(0xFFFFFFFFFFFFFFFF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
etl::optional<uint64_t> result;
@ -676,7 +899,9 @@ namespace
char(0xD5), char(0x2F), char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xF0) };
std::array expected = { uint64_t(0x0000000000000001), uint64_t(0x0000255AA55AA55A), uint64_t(0x00005AA55AA55AA5), uint64_t(0x00007FFFFFFFFFFF) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
etl::optional<uint64_t> result;
@ -721,7 +946,9 @@ namespace
char(0x56), char(0x78),
char(0xA5) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
auto result_c1 = bit_stream.read<int8_t>();
CHECK(result_c1.has_value());
@ -762,7 +989,9 @@ namespace
char(0x7B), char(0xDB), char(0x97), char(0x53),
char(0x19), char(0xE1), char(0x28) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
auto result_c1 = bit_stream.read<int8_t>(6U);
CHECK(result_c1.has_value());
@ -790,57 +1019,101 @@ namespace
}
//*************************************************************************
TEST(test_read_object)
TEST(test_read_multiple_variable_size_using_non_member_functions)
{
int8_t c1 = 90; // 0x5A 6 bits
uint16_t s1 = 4660; // 0x1234 13 bits
int32_t i1 = 2309737967L; // 0x89ABCDEF 23 bits
int32_t i2 = 4275878552L; // 0xFEDCBA98 25 bits
uint16_t s2 = 22136; // 0x5678 11 bits
int8_t c2 = -91; // 0xA5 7 bits
std::array storage = { char(0x6A), char(0x46), char(0x8A), char(0xF3),
char(0x7B), char(0xDB), char(0x97), char(0x53),
char(0x19), char(0xE1), char(0x28) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
auto result_c1 = etl::read<int8_t>(bit_stream, 6U);
CHECK(result_c1.has_value());
CHECK_EQUAL(int8_t(0x1A), result_c1.value());
auto result_s1 = etl::read<uint16_t>(bit_stream, 13U);
CHECK(result_s1.has_value());
CHECK_EQUAL(uint16_t(0x1234), result_s1.value());
auto result_i1 = etl::read<int32_t>(bit_stream, 23U);
CHECK(result_i1.has_value());
CHECK_EQUAL(int32_t(0x002BCDEF), result_i1.value());
auto result_i2 = etl::read<int32_t>(bit_stream, 25U);
CHECK(result_i2.has_value());
CHECK_EQUAL(int32_t(0x00DCBA98), result_i2.value());
auto result_s2 = etl::read<uint16_t>(bit_stream, 11U);
CHECK(result_s2.has_value());
CHECK_EQUAL(uint16_t(0x0678), result_s2.value());
auto result_c2 = etl::read<int8_t>(bit_stream, 7U);
CHECK(result_c2.has_value());
CHECK_EQUAL(int8_t(0x25), result_c2.value());
}
//*************************************************************************
TEST(test_read_checked_object)
{
std::array storage = { char(0xEC), char(0xBA), char(0xDE), char(0x68),
char(0xAF), char(0xD2), char(0xC5), char(0xC8),
char(0x65), char(0xD3), char(0xDF), char(0x80) };
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
Object object1 = { -1234, 123456789, 250 };
Object object2 = { 5678, -987654321, 126 };
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
CHECK(etl::read(bit_stream, object1));
CHECK(etl::read(bit_stream, object2));
Object object1 = { -1234, -2372331, 250 };
Object object2 = { 5678, 2201423, 126 };
CHECK_EQUAL(-1234, object1.s);
CHECK_EQUAL(123456789, object1.i);
CHECK_EQUAL(250, object1.c);
etl::optional<Object> result1 = etl::read<Object>(bit_stream);
etl::optional<Object> result2 = etl::read<Object>(bit_stream);
CHECK_EQUAL(5678, object2.s);
CHECK_EQUAL(-987654321, object2.i);
CHECK_EQUAL(126, object2.c);
CHECK(result1.has_value());
CHECK(result2.has_value());
CHECK_EQUAL(object1.s, result1.value().s);
CHECK_EQUAL(object1.i, result1.value().i);
CHECK_EQUAL(object1.c, result1.value().c);
CHECK_EQUAL(object2.s, result2.value().s);
CHECK_EQUAL(object2.i, result2.value().i);
CHECK_EQUAL(object2.c, result2.value().c);
}
//*************************************************************************
TEST(test_read_multiple_floating_point)
TEST(test_read_unchecked_object)
{
float f = 3.1415927f;
double d = 3.1415927;
long double ld = 3.1415927l;
std::array storage = { char(0xEC), char(0xBA), char(0xDE), char(0x68),
char(0xAF), char(0xD2), char(0xC5), char(0xC8),
char(0x65), char(0xD3), char(0xDF), char(0x80) };
std::array<char, sizeof(float) + sizeof(double) + sizeof(long double)> storage;
storage.fill(0);
etl::bit_stream_reader bit_stream(storage.data(), storage.size(), etl::endian::big);
memcpy(storage.data(), &f, sizeof(float));
std::reverse(storage.data(), storage.data() + sizeof(float));
CHECK_EQUAL(storage.size(), bit_stream.size_bytes());
memcpy(storage.data() + sizeof(float), &d, sizeof(double));
std::reverse(storage.data() + sizeof(float), storage.data() + sizeof(float) + sizeof(double));
Object object1 = { -1234, -2372331, 250 };
Object object2 = { 5678, 2201423, 126 };
memcpy(storage.data() + sizeof(float) + sizeof(double), &d, sizeof(long double));
std::reverse(storage.data() + sizeof(float) + sizeof(double), storage.data() + sizeof(float) + sizeof(double) + sizeof(long double));
Object result1 = etl::read_unchecked<Object>(bit_stream);
Object result2 = etl::read_unchecked<Object>(bit_stream);
etl::bit_stream_reader bit_stream(storage.data(), storage.size());
CHECK_EQUAL(object1.s, result1.s);
CHECK_EQUAL(object1.i, result1.i);
CHECK_EQUAL(object1.c, result1.c);
auto result_f = bit_stream.read<float>();
auto result_d = bit_stream.read<double>();
auto result_ld = bit_stream.read<long double>();
CHECK_CLOSE(3.1415927f, result_f.value(), 0.0000001f);
CHECK_CLOSE(3.1415927, result_d.value(), 0.0000001);
CHECK_CLOSE(3.1415927l, result_ld.value(), 0.0000001);
CHECK_EQUAL(object2.s, result2.s);
CHECK_EQUAL(object2.i, result2.i);
CHECK_EQUAL(object2.c, result2.c);
}
};
}

80
test/test_bit_stream_writer.cpp → test/test_bit_stream_writer_big_endian.cpp
View File

@ -110,14 +110,14 @@ namespace
std::vector<char> data;
};
SUITE(test_bit_stream)
SUITE(test_bit_stream_big_endian)
{
//*************************************************************************
TEST(test_bit_stream_writer_construction)
{
std::array<char, 256> storage;
etl::bit_stream_writer bit_stream(storage.data(), storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK_EQUAL(storage.size(), bit_stream.available(CHAR_BIT));
CHECK_EQUAL(storage.size(), bit_stream.available<CHAR_BIT>());
@ -138,7 +138,7 @@ namespace
unsigned char storage = 0;
unsigned char expected = 0x5AU;
etl::bit_stream_writer bit_stream(&storage, 1U);
etl::bit_stream_writer bit_stream(&storage, 1U, etl::endian::big);
CHECK(bit_stream.write(false));
CHECK_EQUAL(1U, bit_stream.used_data().size());
@ -174,7 +174,7 @@ namespace
std::array<char, 256U> expected;
std::iota(expected.begin(), expected.end(), 0);
etl::bit_stream_writer bit_stream(storage.data(), storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::big);
for (size_t i = 0UL; i < 256UL; ++i)
{
@ -202,7 +202,7 @@ namespace
std::array<char, 256> expected;
std::iota(expected.begin(), expected.end(), 0);
etl::bit_stream_writer bit_stream(storage.data(), storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::big);
for (size_t i = 0UL; i < 256UL; ++i)
{
@ -225,7 +225,6 @@ namespace
//*************************************************************************
TEST(test_write_int16_t)
{
// Tests assume big endian.
std::array<char, sizeof(int16_t) * 4> storage;
std::array<char, sizeof(int16_t) * 4> expected = { char(0x00), char(0x01),
char(0x5A), char(0xA5),
@ -234,7 +233,7 @@ namespace
CHECK(expected.size() == storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK(bit_stream.write(int16_t(0x0001)));
CHECK_EQUAL(sizeof(int16_t) * 1, bit_stream.used_data().size());
@ -260,7 +259,6 @@ namespace
//*************************************************************************
TEST(test_write_uint16_t)
{
// Tests assume big endian.
std::array<char, sizeof(uint16_t) * 4> storage;
std::array<char, sizeof(uint16_t) * 4> expected = { char(0x00), char(0x01),
char(0x5A), char(0xA5),
@ -269,7 +267,7 @@ namespace
CHECK(expected.size() == storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK(bit_stream.write(uint16_t(0x0001)));
CHECK_EQUAL(sizeof(uint16_t) * 1, bit_stream.used_data().size());
@ -295,7 +293,6 @@ namespace
//*************************************************************************
TEST(test_write_int32_t)
{
// Tests assume big endian.
std::array<char, sizeof(int32_t) * 4> storage;
std::array<char, sizeof(int32_t) * 4> expected = { char(0x00), char(0x00), char(0x00), char(0x01),
char(0x5A), char(0xA5), char(0xA5), char(0x5A),
@ -304,7 +301,7 @@ namespace
CHECK(expected.size() == storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK(bit_stream.write(int32_t(0x00000001)));
CHECK_EQUAL(sizeof(int32_t) * 1, bit_stream.used_data().size());
@ -330,7 +327,6 @@ namespace
//*************************************************************************
TEST(test_write_uint32_t)
{
// Tests assume big endian.
std::array<char, sizeof(uint32_t) * 4> storage;
std::array<char, sizeof(uint32_t) * 4> expected = { char(0x00), char(0x00), char(0x00), char(0x01),
char(0x5A), char(0xA5), char(0xA5), char(0x5A),
@ -339,7 +335,7 @@ namespace
CHECK(expected.size() == storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK(bit_stream.write(uint32_t(0x00000001)));
CHECK_EQUAL(sizeof(uint32_t) * 1, bit_stream.used_data().size());
@ -365,7 +361,6 @@ namespace
//*************************************************************************
TEST(test_write_int64_t)
{
// Tests assume big endian.
std::array<char, sizeof(int64_t) * 4> storage;
std::array<char, sizeof(int64_t) * 4> expected = { char(0x00), char(0x00), char(0x00), char(0x00), char(0x00), char(0x00), char(0x00), char(0x01),
char(0x5A), char(0xA5), char(0xA5), char(0x5A), char(0xA5), char(0x5A), char(0x5A), char(0xA5),
@ -374,7 +369,7 @@ namespace
CHECK(expected.size() == storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK(bit_stream.write(int64_t(0x0000000000000001LL)));
CHECK_EQUAL(sizeof(int64_t) * 1, bit_stream.used_data().size());
@ -400,7 +395,6 @@ namespace
//*************************************************************************
TEST(test_write_uint64_t)
{
// Tests assume big endian.
std::array<char, sizeof(uint64_t) * 4> storage;
std::array<char, sizeof(uint64_t) * 4> expected = { char(0x00), char(0x00), char(0x00), char(0x00), char(0x00), char(0x00), char(0x00), char(0x01),
char(0x5A), char(0xA5), char(0xA5), char(0x5A), char(0xA5), char(0x5A), char(0x5A), char(0xA5),
@ -409,7 +403,7 @@ namespace
CHECK(expected.size() == storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::big);
CHECK(bit_stream.write(uint64_t(0x0000000000000001LL)));
CHECK_EQUAL(sizeof(uint64_t) * 1, bit_stream.used_data().size());
@ -439,7 +433,7 @@ namespace
std::array<int8_t, 4> write_data = { int8_t(0x01), int8_t(0xF5), int8_t(0x05), int8_t(0xFF) }; // 1, -11, 10, -1
std::array<char, 4> expected = { char(0x0D), char(0x4B), char(0xF0), char(0x00) }; // 1, -11, 10, -1
etl::bit_stream_writer bit_stream(storage.data(), storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::big);
// Insert into the stream
CHECK(bit_stream.write(write_data[0], 5));
@ -465,7 +459,7 @@ namespace
std::array<char, 4 * sizeof(int16_t)> expected = { char(0x00), char(0x55), char(0xAA), char(0x97),
char(0xFF), char(0x00), char(0x00), char(0x00) };
etl::bit_stream_writer bit_stream(storage.data(), storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::big);
// Insert into the stream
CHECK(bit_stream.write(write_data[0], 10));
@ -495,7 +489,7 @@ namespace
char(0x7F), char(0xFF), char(0xFF), char(0x00),
char(0x00), char(0x00), char(0x00), char(0x00) };
etl::bit_stream_writer bit_stream(storage.data(), storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::big);
// Insert into the stream
CHECK(bit_stream.write(write_data[0], 22));
@ -533,7 +527,7 @@ namespace
char(0xD5), char(0x2F), char(0xFF), char(0xFF),
char(0xFF), char(0xFF), char(0xFF), char(0xF0) };
etl::bit_stream_writer bit_stream(storage.data(), storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::big);
// Insert into the stream
bit_stream.write(write_data[0], 47);
@ -584,7 +578,7 @@ namespace
char(0xD5), char(0x2F), char(0xFF), char(0xFF),
char(0xFF), char(0xFF), char(0xFF), char(0xF0) };
etl::bit_stream_writer bit_stream(storage.data(), storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::big);
// Insert into the stream
bit_stream.write(write_data[0], 47);
@ -641,7 +635,7 @@ namespace
char(0x56), char(0x78),
char(0xA5) };
etl::bit_stream_writer bit_stream(storage.data(), storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::big);
// Insert into the stream.
bit_stream.write(c1);
@ -688,7 +682,7 @@ namespace
char(0x7B), char(0xDB), char(0x97), char(0x53),
char(0x19), char(0xE1), char(0x28) };
etl::bit_stream_writer bit_stream(storage.data(), storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::big);
// Insert into the stream.
bit_stream.write(c1, 6);
@ -737,7 +731,7 @@ namespace
auto callback = etl::bit_stream_writer::callback_type::create<Accumulator, &Accumulator::Add>(accumulator);
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), callback);
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::big, callback);
// Insert into the stream.
bit_stream.write(c1, 6);
@ -774,7 +768,7 @@ namespace
char(0xAF), char(0xD2), char(0xC5), char(0xC8),
char(0x65), char(0xD3), char(0xDF), char(0x80) };
etl::bit_stream_writer bit_stream(storage.data(), storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::big);
Object object1 = { -1234, 123456789, 250 };
Object object2 = { 5678, -987654321, 126 };
@ -795,39 +789,5 @@ namespace
CHECK_EQUAL((int)expected[10], (int)storage[10]);
CHECK_EQUAL((int)expected[11], (int)storage[11]);
}
//*************************************************************************
TEST(test_write_multiple_floating_point)
{
float f = 3.1415927f;
double d = 3.1415927;
long double ld = 3.1415927l;
std::array<char, sizeof(float) + sizeof(double) + sizeof(long double)> storage;
storage.fill(0);
std::array<char, sizeof(float) + sizeof(double) + sizeof(long double)> expected;
expected.fill(0);
memcpy(expected.data(), &f, sizeof(float));
std::reverse(expected.data(), expected.data() + sizeof(float));
memcpy(expected.data() + sizeof(float), &d, sizeof(double));
std::reverse(expected.data() + sizeof(float), expected.data() + sizeof(float) + sizeof(double));
memcpy(expected.data() + sizeof(float) + sizeof(double), &d, sizeof(double));
std::reverse(expected.data() + sizeof(float) + sizeof(double), expected.data() + sizeof(float) + sizeof(double) + sizeof(long double));
etl::bit_stream_writer bit_stream(storage.data(), storage.size());
bit_stream.write(f);
bit_stream.write(d);
bit_stream.write(ld);
for (size_t i = 0; i < storage.size(); ++i)
{
CHECK_EQUAL(int(expected[i]), int(storage[i]));
}
}
};
}

881
test/test_bit_stream_writer_little_endian.cpp Normal file
View File

@ -0,0 +1,881 @@
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
https://www.etlcpp.com
Copyright(c) 2022 jwellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#include "unit_test_framework.h"
#include "etl/bit_stream.h"
#include <array>
#include <vector>
#include <numeric>
namespace
{
//***********************************
struct Object
{
int16_t s;
int32_t i;
uint8_t c;
};
bool operator ==(const Object& lhs, const Object& rhs)
{
return (lhs.s == rhs.s) &&
(lhs.i == rhs.i) &&
(lhs.c == rhs.c);
}
std::ostream& operator << (std::ostream& os, const Object& object)
{
os << object.s << "," << object.i << "," << (int)object.c;
return os;
}
}
namespace etl
{
//***********************************
bool write(etl::bit_stream_writer& stream, const Object& object)
{
bool success = true;
if (!stream.write(object.s, 14))
{
success = false;
}
if (!stream.write(object.i, 23))
{
success = false;
}
if (!stream.write(object.c))
{
success = false;
}
return success;
}
}
namespace
{
class Accumulator
{
public:
void Add(etl::bit_stream_writer::callback_parameter_type s)
{
data.insert(data.end(), s.begin(), s.end());
}
void Clear()
{
data.clear();
}
const std::vector<char>& GetData() const
{
return data;
}
private:
std::vector<char> data;
};
SUITE(test_bit_stream_little_endian)
{
//*************************************************************************
TEST(test_bit_stream_writer_construction)
{
std::array<char, 256> storage;
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
CHECK_EQUAL(storage.size(), bit_stream.available(CHAR_BIT));
CHECK_EQUAL(storage.size(), bit_stream.available<CHAR_BIT>());
CHECK_EQUAL(storage.size(), bit_stream.available<unsigned char>());
CHECK_EQUAL(storage.size() * CHAR_BIT, bit_stream.available_bits());
CHECK_EQUAL(0U, bit_stream.size_bits());
CHECK_EQUAL(0U, bit_stream.size_bytes());
CHECK_EQUAL(storage.size(), bit_stream.data().size());
CHECK_EQUAL(0U, bit_stream.used_data().size());
}
//*************************************************************************
TEST(test_write_bool)
{
unsigned char storage = 0;
unsigned char expected = 0x5AU;
etl::bit_stream_writer bit_stream(&storage, 1U, etl::endian::little);
CHECK(bit_stream.write(false));
CHECK_EQUAL(1U, bit_stream.used_data().size());
CHECK(bit_stream.write(true));
CHECK_EQUAL(1U, bit_stream.used_data().size());
CHECK(bit_stream.write(false));
CHECK_EQUAL(1U, bit_stream.used_data().size());
CHECK(bit_stream.write(true));
CHECK_EQUAL(1U, bit_stream.used_data().size());
CHECK(bit_stream.write(true));
CHECK_EQUAL(1U, bit_stream.used_data().size());
CHECK(bit_stream.write(false));
CHECK_EQUAL(1U, bit_stream.used_data().size());
CHECK(bit_stream.write(true));
CHECK_EQUAL(1U, bit_stream.used_data().size());
CHECK(bit_stream.write(false));
CHECK_EQUAL(1U, bit_stream.used_data().size());
// One too many.
CHECK_THROW(bit_stream.write(true), etl::bit_stream_overflow);
CHECK_EQUAL(1U, bit_stream.data().size());
CHECK_EQUAL(1U, bit_stream.used_data().size());
CHECK_EQUAL(int(expected), int(storage));
}
//*************************************************************************
TEST(test_write_int8_t)
{
std::array<char, 256U> storage;
std::array<char, 256U> expected;
std::iota(expected.begin(), expected.end(), 0);
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
for (size_t i = 0UL; i < 256UL; ++i)
{
CHECK(bit_stream.write(int8_t(i)));
CHECK_EQUAL(i + 1U, bit_stream.used_data().size());
}
// One too many.
CHECK_THROW(bit_stream.write(int8_t(0)), etl::bit_stream_overflow);
CHECK_EQUAL(256U, bit_stream.data().size());
CHECK_EQUAL(256U, bit_stream.used_data().size());
for (size_t i = 0UL; i < storage.size(); ++i)
{
CHECK_EQUAL(int(etl::reverse_bits(expected[i])), int(storage[i]));
}
}
//*************************************************************************
TEST(test_write_uint8_t)
{
std::array<char, 256> storage;
std::array<char, 256> expected;
std::iota(expected.begin(), expected.end(), 0);
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
for (size_t i = 0UL; i < 256UL; ++i)
{
CHECK(bit_stream.write(uint8_t(i)));
CHECK_EQUAL(i + 1U, bit_stream.used_data().size());
}
// One too many.
CHECK_THROW(bit_stream.write(int8_t(0)), etl::bit_stream_overflow);
CHECK_EQUAL(256U, bit_stream.data().size());
CHECK_EQUAL(256U, bit_stream.used_data().size());
for (size_t i = 0UL; i < storage.size(); ++i)
{
CHECK_EQUAL(int(etl::reverse_bits(expected[i])), int(storage[i]));
}
}
//*************************************************************************
TEST(test_write_int16_t)
{
std::array<char, sizeof(int16_t) * 4> storage;
std::array<char, sizeof(int16_t) * 4> expected = { char(0x80), char(0x00),
char(0xA5), char(0x5A),
char(0x5A), char(0xA5),
char(0xFF), char(0xFF) };
CHECK(expected.size() == storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
CHECK(bit_stream.write(int16_t(0x0001)));
CHECK_EQUAL(sizeof(int16_t) * 1, bit_stream.used_data().size());
CHECK(bit_stream.write(int16_t(0x5AA5)));
CHECK_EQUAL(sizeof(int16_t) * 2, bit_stream.used_data().size());
CHECK(bit_stream.write(int16_t(0xA55A)));
CHECK_EQUAL(sizeof(int16_t) * 3, bit_stream.used_data().size());
CHECK(bit_stream.write(int16_t(0xFFFF)));
CHECK_EQUAL(sizeof(int16_t) * 4, bit_stream.used_data().size());
// One too many.
CHECK_THROW(bit_stream.write(int16_t(0)), etl::bit_stream_overflow);
CHECK_EQUAL(sizeof(int16_t) * 4, bit_stream.data().size());
CHECK_EQUAL(sizeof(int16_t) * 4, bit_stream.used_data().size());
for (size_t i = 0UL; i < storage.size(); ++i)
{
CHECK_EQUAL(int(expected[i]), int(storage[i]));
}
}
//*************************************************************************
TEST(test_write_uint16_t)
{
std::array<char, sizeof(uint16_t) * 4> storage;
std::array<char, sizeof(uint16_t) * 4> expected = { char(0x80), char(0x00),
char(0xA5), char(0x5A),
char(0x5A), char(0xA5),
char(0xFF), char(0xFF) };
CHECK(expected.size() == storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
CHECK(bit_stream.write(uint16_t(0x0001)));
CHECK_EQUAL(sizeof(uint16_t) * 1, bit_stream.used_data().size());
CHECK(bit_stream.write(uint16_t(0x5AA5)));
CHECK_EQUAL(sizeof(uint16_t) * 2, bit_stream.used_data().size());
CHECK(bit_stream.write(uint16_t(0xA55A)));
CHECK_EQUAL(sizeof(uint16_t) * 3, bit_stream.used_data().size());
CHECK(bit_stream.write(uint16_t(0xFFFF)));
CHECK_EQUAL(sizeof(uint16_t) * 4, bit_stream.used_data().size());
// One too many.
CHECK_THROW(bit_stream.write(uint16_t(0)), etl::bit_stream_overflow);
CHECK_EQUAL(sizeof(uint16_t) * 4, bit_stream.data().size());
CHECK_EQUAL(sizeof(uint16_t) * 4, bit_stream.used_data().size());
for (size_t i = 0UL; i < storage.size(); ++i)
{
CHECK_EQUAL(int(expected[i]), int(storage[i]));
}
}
//*************************************************************************
TEST(test_write_int32_t)
{
std::array<char, sizeof(int32_t) * 4> storage;
std::array<char, sizeof(int32_t) * 4> expected = { char(0x80), char(0x00), char(0x00), char(0x00),
char(0x5A), char(0xA5), char(0xA5), char(0x5A),
char(0xA5), char(0x5A), char(0x5A), char(0xA5),
char(0xFF), char(0xFF), char(0xFF), char(0xFF) };
CHECK(expected.size() == storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
CHECK(bit_stream.write(int32_t(0x00000001)));
CHECK_EQUAL(sizeof(int32_t) * 1, bit_stream.used_data().size());
CHECK(bit_stream.write(int32_t(0x5AA5A55A)));
CHECK_EQUAL(sizeof(int32_t) * 2, bit_stream.used_data().size());
CHECK(bit_stream.write(int32_t(0xA55A5AA5)));
CHECK_EQUAL(sizeof(int32_t) * 3, bit_stream.used_data().size());
CHECK(bit_stream.write(int32_t(0xFFFFFFFF)));
CHECK_EQUAL(sizeof(int32_t) * 4, bit_stream.used_data().size());
// One too many.
CHECK_THROW(bit_stream.write(int32_t(0)), etl::bit_stream_overflow);
CHECK_EQUAL(sizeof(int32_t) * 4, bit_stream.data().size());
CHECK_EQUAL(sizeof(int32_t) * 4, bit_stream.used_data().size());
for (size_t i = 0UL; i < storage.size(); ++i)
{
CHECK_EQUAL(int(expected[i]), int(storage[i]));
}
}
//*************************************************************************
TEST(test_write_uint32_t)
{
std::array<char, sizeof(uint32_t) * 4> storage;
std::array<char, sizeof(uint32_t) * 4> expected = { char(0x80), char(0x00), char(0x00), char(0x00),
char(0x5A), char(0xA5), char(0xA5), char(0x5A),
char(0xA5), char(0x5A), char(0x5A), char(0xA5),
char(0xFF), char(0xFF), char(0xFF), char(0xFF) };
CHECK(expected.size() == storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
CHECK(bit_stream.write(uint32_t(0x00000001)));
CHECK_EQUAL(sizeof(uint32_t) * 1, bit_stream.used_data().size());
CHECK(bit_stream.write(uint32_t(0x5AA5A55A)));
CHECK_EQUAL(sizeof(uint32_t) * 2, bit_stream.used_data().size());
CHECK(bit_stream.write(uint32_t(0xA55A5AA5)));
CHECK_EQUAL(sizeof(uint32_t) * 3, bit_stream.used_data().size());
CHECK(bit_stream.write(uint32_t(0xFFFFFFFF)));
CHECK_EQUAL(sizeof(uint32_t) * 4, bit_stream.used_data().size());
// One too many.
CHECK_THROW(bit_stream.write(uint32_t(0)), etl::bit_stream_overflow);
CHECK_EQUAL(sizeof(uint32_t) * 4, bit_stream.data().size());
CHECK_EQUAL(sizeof(uint32_t) * 4, bit_stream.used_data().size());
for (size_t i = 0UL; i < storage.size(); ++i)
{
CHECK_EQUAL(int(expected[i]), int(storage[i]));
}
}
//*************************************************************************
TEST(test_write_int64_t)
{
std::array<char, sizeof(int64_t) * 4> storage;
std::array<char, sizeof(int64_t) * 4> expected = { char(0x80), char(0x00), char(0x00), char(0x00), char(0x00), char(0x00), char(0x00), char(0x00),
char(0xA5), char(0x5A), char(0x5A), char(0xA5), char(0x5A), char(0xA5), char(0xA5), char(0x5A),
char(0x5A), char(0xA5), char(0xA5), char(0x5A), char(0xA5), char(0x5A), char(0x5A), char(0xA5),
char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xFF) };
CHECK(expected.size() == storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
CHECK(bit_stream.write(int64_t(0x0000000000000001LL)));
CHECK_EQUAL(sizeof(int64_t) * 1, bit_stream.used_data().size());
CHECK(bit_stream.write(int64_t(0x5AA5A55AA55A5AA5LL)));
CHECK_EQUAL(sizeof(int64_t) * 2, bit_stream.used_data().size());
CHECK(bit_stream.write(int64_t(0xA55A5AA55AA5A55ALL)));
CHECK_EQUAL(sizeof(int64_t) * 3, bit_stream.used_data().size());
CHECK(bit_stream.write(int64_t(0xFFFFFFFFFFFFFFFFLL)));
CHECK_EQUAL(sizeof(int64_t) * 4, bit_stream.used_data().size());
// One too many.
CHECK_THROW(bit_stream.write(int64_t(0)), etl::bit_stream_overflow);
CHECK_EQUAL(sizeof(int64_t) * 4, bit_stream.data().size());
CHECK_EQUAL(sizeof(int64_t) * 4, bit_stream.used_data().size());
for (size_t i = 0UL; i < storage.size(); ++i)
{
CHECK_EQUAL(int(expected[i]), int(storage[i]));
}
}
//*************************************************************************
TEST(test_write_uint64_t)
{
std::array<char, sizeof(uint64_t) * 4> storage;
std::array<char, sizeof(uint64_t) * 4> expected = { char(0x80), char(0x00), char(0x00), char(0x00), char(0x00), char(0x00), char(0x00), char(0x00),
char(0xA5), char(0x5A), char(0x5A), char(0xA5), char(0x5A), char(0xA5), char(0xA5), char(0x5A),
char(0x5A), char(0xA5), char(0xA5), char(0x5A), char(0xA5), char(0x5A), char(0x5A), char(0xA5),
char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xFF), char(0xFF) };
CHECK(expected.size() == storage.size());
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
CHECK(bit_stream.write(uint64_t(0x0000000000000001LL)));
CHECK_EQUAL(sizeof(uint64_t) * 1, bit_stream.used_data().size());
CHECK(bit_stream.write(uint64_t(0x5AA5A55AA55A5AA5LL)));
CHECK_EQUAL(sizeof(uint64_t) * 2, bit_stream.used_data().size());
CHECK(bit_stream.write(uint64_t(0xA55A5AA55AA5A55ALL)));
CHECK_EQUAL(sizeof(uint64_t) * 3, bit_stream.used_data().size());
CHECK(bit_stream.write(uint64_t(0xFFFFFFFFFFFFFFFFLL)));
CHECK_EQUAL(sizeof(uint64_t) * 4, bit_stream.used_data().size());
// One too many.
CHECK_THROW(bit_stream.write(uint64_t(0)), etl::bit_stream_overflow);
CHECK_EQUAL(sizeof(uint64_t) * 4, bit_stream.data().size());
CHECK_EQUAL(sizeof(uint64_t) * 4, bit_stream.used_data().size());
for (size_t i = 0UL; i < storage.size(); ++i)
{
CHECK_EQUAL(int(expected[i]), int(storage[i]));
}
}
//*************************************************************************
TEST(test_write_int8_t_5bits)
{
std::array<char, 4 * sizeof(char)> storage;
std::array<int8_t, 4> write_data = { int8_t(0x01), int8_t(0xF5), int8_t(0x05), int8_t(0xFF) }; // 1, -11, 10, -1
std::array<char, 4> expected = { char(0x85), char(0x69), char(0xF0), char(0x00) }; // 1, -11, 10, -1
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
// Insert into the stream
CHECK(bit_stream.write(write_data[0], 5));
CHECK_EQUAL(1, bit_stream.used_data().size());
CHECK(bit_stream.write(write_data[1], 5));
CHECK_EQUAL(2, bit_stream.used_data().size());
CHECK(bit_stream.write(write_data[2], 5));
CHECK_EQUAL(2, bit_stream.used_data().size());
CHECK(bit_stream.write(write_data[3], 5));
CHECK_EQUAL(3, bit_stream.used_data().size());
CHECK_EQUAL((int)expected[0], (int)storage[0]);
CHECK_EQUAL((int)expected[1], (int)storage[1]);
CHECK_EQUAL((int)expected[2], (int)storage[2]);
// 4th byte not used.
}
//*************************************************************************
TEST(test_write_uint8_t_5bits)
{
std::array<char, 4 * sizeof(char)> storage;
std::array<uint8_t, 4> write_data = { uint8_t(0x01), uint8_t(0xF5), uint8_t(0x05), uint8_t(0xFF) }; // 1, -11, 10, -1
std::array<char, 4> expected = { char(0x85), char(0x69), char(0xF0), char(0x00) }; // 1, -11, 10, -1
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
// Insert into the stream
CHECK(bit_stream.write(write_data[0], 5));
CHECK_EQUAL(1, bit_stream.used_data().size());
CHECK(bit_stream.write(write_data[1], 5));
CHECK_EQUAL(2, bit_stream.used_data().size());
CHECK(bit_stream.write(write_data[2], 5));
CHECK_EQUAL(2, bit_stream.used_data().size());
CHECK(bit_stream.write(write_data[3], 5));
CHECK_EQUAL(3, bit_stream.used_data().size());
CHECK_EQUAL((int)expected[0], (int)storage[0]);
CHECK_EQUAL((int)expected[1], (int)storage[1]);
CHECK_EQUAL((int)expected[2], (int)storage[2]);
// 4th byte not used.
}
//*************************************************************************
TEST(test_write_int16_t_10bits)
{
std::array<char, 4 * sizeof(int16_t)> storage;
std::array<int16_t, 4> write_data = { int16_t(0x0001), int16_t(0xA55A), int16_t(0x5AA5), int16_t(0xFFFF) };
std::array<char, 4 * sizeof(int16_t)> expected = { char(0x80), char(0x16), char(0xAA), char(0x57),
char(0xFF), char(0x00), char(0x00), char(0x00) };
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
// Insert into the stream
CHECK(bit_stream.write(write_data[0], 10));
CHECK_EQUAL(2, bit_stream.used_data().size());
CHECK(bit_stream.write(write_data[1], 10));
CHECK_EQUAL(3, bit_stream.used_data().size());
CHECK(bit_stream.write(write_data[2], 10));
CHECK_EQUAL(4, bit_stream.used_data().size());
CHECK(bit_stream.write(write_data[3], 10));
CHECK_EQUAL(5, bit_stream.used_data().size());
CHECK_EQUAL((int)expected[0], (int)storage[0]);
CHECK_EQUAL((int)expected[1], (int)storage[1]);
CHECK_EQUAL((int)expected[2], (int)storage[2]);
CHECK_EQUAL((int)expected[3], (int)storage[3]);
CHECK_EQUAL((int)expected[4], (int)storage[4]);
// 6th to 8th bytes not used.
}
//*************************************************************************
TEST(test_write_uint16_t_10bits)
{
std::array<char, 4 * sizeof(uint16_t)> storage;
std::array<uint16_t, 4> write_data = { uint16_t(0x0001), uint16_t(0xA55A), uint16_t(0x5AA5), uint16_t(0xFFFF) };
std::array<char, 4 * sizeof(uint16_t)> expected = { char(0x80), char(0x16), char(0xAA), char(0x57),
char(0xFF), char(0x00), char(0x00), char(0x00) };
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
// Insert into the stream
CHECK(bit_stream.write(write_data[0], 10));
CHECK_EQUAL(2, bit_stream.used_data().size());
CHECK(bit_stream.write(write_data[1], 10));
CHECK_EQUAL(3, bit_stream.used_data().size());
CHECK(bit_stream.write(write_data[2], 10));
CHECK_EQUAL(4, bit_stream.used_data().size());
CHECK(bit_stream.write(write_data[3], 10));
CHECK_EQUAL(5, bit_stream.used_data().size());
CHECK_EQUAL((int)expected[0], (int)storage[0]);
CHECK_EQUAL((int)expected[1], (int)storage[1]);
CHECK_EQUAL((int)expected[2], (int)storage[2]);
CHECK_EQUAL((int)expected[3], (int)storage[3]);
CHECK_EQUAL((int)expected[4], (int)storage[4]);
// 6th to 8th bytes not used.
}
//*************************************************************************
TEST(test_write_int32_t_22bits)
{
std::array<char, 4 * sizeof(uint32_t)> storage;
std::array<int32_t, 4> write_data = { int32_t(0x00000001UL), int32_t(0xA55AA55AUL), int32_t(0x5AA55AA5UL), int32_t(0xFFFFFFFFUL) };
std::array<char, 4 * sizeof(uint32_t)> expected = { char(0x80), char(0x00), char(0x01), char(0x6A),
char(0x95), char(0x6A), char(0x55), char(0xAA),
char(0x7F), char(0xFF), char(0xFF), char(0x00),
char(0x00), char(0x00), char(0x00), char(0x00) };
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
// Insert into the stream
CHECK(bit_stream.write(write_data[0], 22));
CHECK_EQUAL(3, bit_stream.used_data().size());
CHECK(bit_stream.write(write_data[1], 22));
CHECK_EQUAL(6, bit_stream.used_data().size());
CHECK(bit_stream.write(write_data[2], 22));
CHECK_EQUAL(9, bit_stream.used_data().size());
CHECK(bit_stream.write(write_data[3], 22));
CHECK_EQUAL(11, bit_stream.used_data().size());
CHECK_EQUAL((int)expected[0], (int)storage[0]);
CHECK_EQUAL((int)expected[1], (int)storage[1]);
CHECK_EQUAL((int)expected[2], (int)storage[2]);
CHECK_EQUAL((int)expected[3], (int)storage[3]);
CHECK_EQUAL((int)expected[4], (int)storage[4]);
CHECK_EQUAL((int)expected[5], (int)storage[5]);
CHECK_EQUAL((int)expected[6], (int)storage[6]);
CHECK_EQUAL((int)expected[7], (int)storage[7]);
CHECK_EQUAL((int)expected[8], (int)storage[8]);
CHECK_EQUAL((int)expected[9], (int)storage[9]);
CHECK_EQUAL((int)expected[10], (int)storage[10]);
// 12th to 16th to bytes not used.
}
//*************************************************************************
TEST(test_write_uint32_t_22bits)
{
std::array<char, 4 * sizeof(uint32_t)> storage;
std::array<uint32_t, 4> write_data = { uint32_t(0x00000001UL), uint32_t(0xA55AA55AUL), uint32_t(0x5AA55AA5UL), uint32_t(0xFFFFFFFFUL) };
std::array<char, 4 * sizeof(uint32_t)> expected = { char(0x80), char(0x00), char(0x01), char(0x6A),
char(0x95), char(0x6A), char(0x55), char(0xAA),
char(0x7F), char(0xFF), char(0xFF), char(0x00),
char(0x00), char(0x00), char(0x00), char(0x00) };
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
// Insert into the stream
CHECK(bit_stream.write(write_data[0], 22));
CHECK_EQUAL(3, bit_stream.used_data().size());
CHECK(bit_stream.write(write_data[1], 22));
CHECK_EQUAL(6, bit_stream.used_data().size());
CHECK(bit_stream.write(write_data[2], 22));
CHECK_EQUAL(9, bit_stream.used_data().size());
CHECK(bit_stream.write(write_data[3], 22));
CHECK_EQUAL(11, bit_stream.used_data().size());
CHECK_EQUAL((int)expected[0], (int)storage[0]);
CHECK_EQUAL((int)expected[1], (int)storage[1]);
CHECK_EQUAL((int)expected[2], (int)storage[2]);
CHECK_EQUAL((int)expected[3], (int)storage[3]);
CHECK_EQUAL((int)expected[4], (int)storage[4]);
CHECK_EQUAL((int)expected[5], (int)storage[5]);
CHECK_EQUAL((int)expected[6], (int)storage[6]);
CHECK_EQUAL((int)expected[7], (int)storage[7]);
CHECK_EQUAL((int)expected[8], (int)storage[8]);
CHECK_EQUAL((int)expected[9], (int)storage[9]);
CHECK_EQUAL((int)expected[10], (int)storage[10]);
// 12th to 16th to bytes not used.
}
//*************************************************************************
TEST(test_write_int64_t_47bits)
{
std::array<char, 4 * sizeof(int64_t)> storage;
std::array<int64_t, 4> write_data = { int64_t(0x0000000000000001LL), int64_t(0xA55AA55AA55AA55ALL), int64_t(0x5AA55AA55AA55AA5LL), int64_t(0xFFFFFFFFFFFFFFFFLL) };
std::array<char, 4 * sizeof(int64_t)> expected = { char(0x80), char(0x00), char(0x00), char(0x00),
char(0x00), char(0x00), char(0xB5), char(0x4A),
char(0xB5), char(0x4A), char(0xB5), char(0x4A),
char(0x95), char(0x6A), char(0x95), char(0x6A),
char(0x95), char(0x6F), char(0xFF), char(0xFF),
char(0xFF), char(0xFF), char(0xFF), char(0xF0) };
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
// Insert into the stream
bit_stream.write(write_data[0], 47);
CHECK_EQUAL(6, bit_stream.used_data().size());
bit_stream.write(write_data[1], 47);
CHECK_EQUAL(12, bit_stream.used_data().size());
bit_stream.write(write_data[2], 47);
CHECK_EQUAL(18, bit_stream.used_data().size());
bit_stream.write(write_data[3], 47);
CHECK_EQUAL(24, bit_stream.used_data().size());
CHECK_EQUAL((int)expected[0], (int)storage[0]);
CHECK_EQUAL((int)expected[1], (int)storage[1]);
CHECK_EQUAL((int)expected[2], (int)storage[2]);
CHECK_EQUAL((int)expected[3], (int)storage[3]);
CHECK_EQUAL((int)expected[4], (int)storage[4]);
CHECK_EQUAL((int)expected[5], (int)storage[5]);
CHECK_EQUAL((int)expected[6], (int)storage[6]);
CHECK_EQUAL((int)expected[7], (int)storage[7]);
CHECK_EQUAL((int)expected[8], (int)storage[8]);
CHECK_EQUAL((int)expected[9], (int)storage[9]);
CHECK_EQUAL((int)expected[10], (int)storage[10]);
CHECK_EQUAL((int)expected[11], (int)storage[11]);
CHECK_EQUAL((int)expected[12], (int)storage[12]);
CHECK_EQUAL((int)expected[13], (int)storage[13]);
CHECK_EQUAL((int)expected[14], (int)storage[14]);
CHECK_EQUAL((int)expected[15], (int)storage[15]);
CHECK_EQUAL((int)expected[16], (int)storage[16]);
CHECK_EQUAL((int)expected[17], (int)storage[17]);
CHECK_EQUAL((int)expected[18], (int)storage[18]);
CHECK_EQUAL((int)expected[19], (int)storage[19]);
CHECK_EQUAL((int)expected[20], (int)storage[20]);
CHECK_EQUAL((int)expected[21], (int)storage[21]);
CHECK_EQUAL((int)expected[22], (int)storage[22]);
CHECK_EQUAL((int)expected[23], (int)storage[23]);
// 25th to 32nd bytes not used.
}
//*************************************************************************
TEST(test_write_uint64_t_47bits)
{
std::array<char, 4 * sizeof(uint64_t)> storage;
std::array<uint64_t, 4> write_data = { uint64_t(0x0000000000000001LL), uint64_t(0xA55AA55AA55AA55ALL), uint64_t(0x5AA55AA55AA55AA5LL), uint64_t(0xFFFFFFFFFFFFFFFFLL) };
std::array<char, 4 * sizeof(uint64_t)> expected = { char(0x80), char(0x00), char(0x00), char(0x00),
char(0x00), char(0x00), char(0xB5), char(0x4A),
char(0xB5), char(0x4A), char(0xB5), char(0x4A),
char(0x95), char(0x6A), char(0x95), char(0x6A),
char(0x95), char(0x6F), char(0xFF), char(0xFF),
char(0xFF), char(0xFF), char(0xFF), char(0xF0) };
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
// Insert into the stream
bit_stream.write(write_data[0], 47);
CHECK_EQUAL(6, bit_stream.used_data().size());
bit_stream.write(write_data[1], 47);
CHECK_EQUAL(12, bit_stream.used_data().size());
bit_stream.write(write_data[2], 47);
CHECK_EQUAL(18, bit_stream.used_data().size());
bit_stream.write(write_data[3], 47);
CHECK_EQUAL(24, bit_stream.used_data().size());
CHECK_EQUAL((int)expected[0], (int)storage[0]);
CHECK_EQUAL((int)expected[1], (int)storage[1]);
CHECK_EQUAL((int)expected[2], (int)storage[2]);
CHECK_EQUAL((int)expected[3], (int)storage[3]);
CHECK_EQUAL((int)expected[4], (int)storage[4]);
CHECK_EQUAL((int)expected[5], (int)storage[5]);
CHECK_EQUAL((int)expected[6], (int)storage[6]);
CHECK_EQUAL((int)expected[7], (int)storage[7]);
CHECK_EQUAL((int)expected[8], (int)storage[8]);
CHECK_EQUAL((int)expected[9], (int)storage[9]);
CHECK_EQUAL((int)expected[10], (int)storage[10]);
CHECK_EQUAL((int)expected[11], (int)storage[11]);
CHECK_EQUAL((int)expected[12], (int)storage[12]);
CHECK_EQUAL((int)expected[13], (int)storage[13]);
CHECK_EQUAL((int)expected[14], (int)storage[14]);
CHECK_EQUAL((int)expected[15], (int)storage[15]);
CHECK_EQUAL((int)expected[16], (int)storage[16]);
CHECK_EQUAL((int)expected[17], (int)storage[17]);
CHECK_EQUAL((int)expected[18], (int)storage[18]);
CHECK_EQUAL((int)expected[19], (int)storage[19]);
CHECK_EQUAL((int)expected[20], (int)storage[20]);
CHECK_EQUAL((int)expected[21], (int)storage[21]);
CHECK_EQUAL((int)expected[22], (int)storage[22]);
CHECK_EQUAL((int)expected[23], (int)storage[23]);
// 25th to 32nd bytes not used.
}
//*************************************************************************
TEST(test_write_multiple_full_size)
{
char c1 = 90; // 0x5A
char c2 = -91; // 0xA5
unsigned short s1 = 4660; // 0x1234
unsigned short s2 = 22136; // 0x5678
int32_t i1 = 2309737967L; // 0x89ABCDEF
int32_t i2 = 4275878552L; // 0xFEDCBA98
std::array<char, 14> storage;
std::array<char, 14> expected = { char(0x5A),
char(0x2C), char(0x48),
char(0xF7), char(0xB3), char(0xD5), char(0x91),
char(0x19), char(0x5D), char(0x3B), char(0x7F),
char(0x1E), char(0x6A),
char(0xA5) };
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
// Insert into the stream.
bit_stream.write(c1);
CHECK_EQUAL(1, bit_stream.used_data().size());
bit_stream.write(s1);
CHECK_EQUAL(3, bit_stream.used_data().size());
bit_stream.write(i1);
CHECK_EQUAL(7, bit_stream.used_data().size());
bit_stream.write(i2);
CHECK_EQUAL(11, bit_stream.used_data().size());
bit_stream.write(s2);
CHECK_EQUAL(13, bit_stream.used_data().size());
bit_stream.write(c2);
CHECK_EQUAL(14, bit_stream.used_data().size());
CHECK_EQUAL((int)expected[0], (int)storage[0]);
CHECK_EQUAL((int)expected[1], (int)storage[1]);
CHECK_EQUAL((int)expected[2], (int)storage[2]);
CHECK_EQUAL((int)expected[3], (int)storage[3]);
CHECK_EQUAL((int)expected[4], (int)storage[4]);
CHECK_EQUAL((int)expected[5], (int)storage[5]);
CHECK_EQUAL((int)expected[6], (int)storage[6]);
CHECK_EQUAL((int)expected[7], (int)storage[7]);
CHECK_EQUAL((int)expected[8], (int)storage[8]);
CHECK_EQUAL((int)expected[9], (int)storage[9]);
CHECK_EQUAL((int)expected[10], (int)storage[10]);
CHECK_EQUAL((int)expected[11], (int)storage[11]);
CHECK_EQUAL((int)expected[12], (int)storage[12]);
CHECK_EQUAL((int)expected[13], (int)storage[13]);
}
//*************************************************************************
TEST(test_write_multiple_variable_size)
{
char c1 = 90; // 0x5A 6 bits
char c2 = -91; // 0xA5 7 bits
unsigned short s1 = 4660; // 0x1234 13 bits
unsigned short s2 = 22136; // 0x5678 11 bits
int32_t i1 = 2309737967L; // 0x89ABCDEF 23 bits
int32_t i2 = 4275878552L; // 0xFEDCBA98 25 bits
std::array<char, 14> storage;
std::array<char, 14> expected = { char(0x58), char(0xB1), char(0x3E), char(0xF6),
char(0x7A), char(0x86), char(0x57), char(0x4E),
char(0xC3), char(0xCE), char(0x90) };
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
// Insert into the stream.
bit_stream.write(c1, 6);
CHECK_EQUAL(1, bit_stream.used_data().size());
bit_stream.write(s1, 13);
CHECK_EQUAL(3, bit_stream.used_data().size());
bit_stream.write(i1, 23);
CHECK_EQUAL(6, bit_stream.used_data().size());
bit_stream.write(i2, 25);
CHECK_EQUAL(9, bit_stream.used_data().size());
bit_stream.write(s2, 11);
CHECK_EQUAL(10, bit_stream.used_data().size());
bit_stream.write(c2, 7);
CHECK_EQUAL(11, bit_stream.used_data().size());
CHECK_EQUAL((int)expected[0], (int)storage[0]);
CHECK_EQUAL((int)expected[1], (int)storage[1]);
CHECK_EQUAL((int)expected[2], (int)storage[2]);
CHECK_EQUAL((int)expected[3], (int)storage[3]);
CHECK_EQUAL((int)expected[4], (int)storage[4]);
CHECK_EQUAL((int)expected[5], (int)storage[5]);
CHECK_EQUAL((int)expected[6], (int)storage[6]);
CHECK_EQUAL((int)expected[7], (int)storage[7]);
CHECK_EQUAL((int)expected[8], (int)storage[8]);
CHECK_EQUAL((int)expected[9], (int)storage[9]);
CHECK_EQUAL((int)expected[10], (int)storage[10]);
}
//*************************************************************************
TEST(test_write_multiple_variable_size_with_callback)
{
char c1 = 90; // 0x5A 6 bits
char c2 = -91; // 0xA5 7 bits
unsigned short s1 = 4660; // 0x1234 13 bits
unsigned short s2 = 22136; // 0x5678 11 bits
int32_t i1 = 2309737967L; // 0x89ABCDEF 23 bits
int32_t i2 = 4275878552L; // 0xFEDCBA98 25 bits
std::array<char, 14> storage;
std::array<char, 14> expected = { char(0x58), char(0xB1), char(0x3E), char(0xF6),
char(0x7A), char(0x86), char(0x57), char(0x4E),
char(0xC3), char(0xCE), char(0x90) };
Accumulator accumulator;
auto callback = etl::bit_stream_writer::callback_type::create<Accumulator, &Accumulator::Add>(accumulator);
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little, callback);
// Insert into the stream.
bit_stream.write(c1, 6);
bit_stream.write(s1, 13);
bit_stream.write(i1, 23);
bit_stream.write(i2, 25);
bit_stream.write(s2, 11);
bit_stream.write(c2, 7);
bit_stream.flush();
CHECK_EQUAL(bit_stream.capacity_bytes(), bit_stream.available<char>());
CHECK_EQUAL(11U, accumulator.GetData().size());
CHECK_EQUAL((int)expected[0], (int)accumulator.GetData()[0]);
CHECK_EQUAL((int)expected[1], (int)accumulator.GetData()[1]);
CHECK_EQUAL((int)expected[2], (int)accumulator.GetData()[2]);
CHECK_EQUAL((int)expected[3], (int)accumulator.GetData()[3]);
CHECK_EQUAL((int)expected[4], (int)accumulator.GetData()[4]);
CHECK_EQUAL((int)expected[5], (int)accumulator.GetData()[5]);
CHECK_EQUAL((int)expected[6], (int)accumulator.GetData()[6]);
CHECK_EQUAL((int)expected[7], (int)accumulator.GetData()[7]);
CHECK_EQUAL((int)expected[8], (int)accumulator.GetData()[8]);
CHECK_EQUAL((int)expected[9], (int)accumulator.GetData()[9]);
CHECK_EQUAL((int)expected[10], (int)accumulator.GetData()[10]);
}
//*************************************************************************
TEST(test_write_object)
{
std::array<char, 2 * sizeof(Object)> storage;
storage.fill(0);
std::array expected{ char(0x74), char(0xDE), char(0xA2), char(0xCF),
char(0x6A), char(0xFB), char(0xA3), char(0x5E),
char(0x5D), char(0x30), char(0x9F), char(0x80) };
etl::bit_stream_writer bit_stream(storage.data(), storage.size(), etl::endian::little);
Object object1 = { -1234, 123456789, 250 };
Object object2 = { 5678, -987654321, 126 };
CHECK(etl::write(bit_stream, object1));
CHECK(etl::write(bit_stream, object2));
CHECK_EQUAL((int)expected[0], (int)storage[0]);
CHECK_EQUAL((int)expected[1], (int)storage[1]);
CHECK_EQUAL((int)expected[2], (int)storage[2]);
CHECK_EQUAL((int)expected[3], (int)storage[3]);
CHECK_EQUAL((int)expected[4], (int)storage[4]);
CHECK_EQUAL((int)expected[5], (int)storage[5]);
CHECK_EQUAL((int)expected[6], (int)storage[6]);
CHECK_EQUAL((int)expected[7], (int)storage[7]);
CHECK_EQUAL((int)expected[8], (int)storage[8]);
CHECK_EQUAL((int)expected[9], (int)storage[9]);
CHECK_EQUAL((int)expected[10], (int)storage[10]);
CHECK_EQUAL((int)expected[11], (int)storage[11]);
}
};
}

8
test/test_byte_stream.cpp
View File

@ -242,7 +242,6 @@ namespace
//*************************************************************************
TEST(write_int16_t)
{
// Tests assume big endian.
std::array<char, sizeof(int16_t) * 4> storage;
std::array<char, sizeof(int16_t) * 4> compare_data = { char(0x00), char(0x01), char(0x5A), char(0xA5), char(0xA5), char(0x5A), char(0xFF), char(0xFF) };
@ -267,7 +266,6 @@ namespace
//*************************************************************************
TEST(write_uint16_t)
{
// Tests assume big endian.
std::array<char, sizeof(uint16_t) * 4> storage;
std::array<char, sizeof(uint16_t) * 4> compare_data = { char(0x00), char(0x01), char(0x5A), char(0xA5), char(0xA5), char(0x5A), char(0xFF), char(0xFF) };
@ -292,7 +290,6 @@ namespace
//*************************************************************************
TEST(write_int32_t)
{
// Tests assume big endian.
std::array<char, sizeof(int32_t) * 4> storage;
std::array<char, sizeof(int32_t) * 4> compare_data = { char(0x00), char(0x00), char(0x00), char(0x01),
char(0x5A), char(0xA5), char(0xA5), char(0x5A),
@ -320,7 +317,6 @@ namespace
//*************************************************************************
TEST(write_uint32_t)
{
// Tests assume big endian.
std::array<char, sizeof(uint32_t) * 4> storage;
std::array<char, sizeof(uint32_t) * 4> compare_data = { char(0x00), char(0x00), char(0x00), char(0x01),
char(0x5A), char(0xA5), char(0xA5), char(0x5A),
@ -348,7 +344,6 @@ namespace
//*************************************************************************
TEST(write_int64_t)
{
// Tests assume big endian.
std::array<char, sizeof(int64_t) * 4> storage;
std::array<char, sizeof(int64_t) * 4> compare_data = { char(0x00), char(0x00), char(0x00), char(0x00), char(0x00), char(0x00), char(0x00), char(0x01),
char(0x5A), char(0xA5), char(0xA5), char(0x5A), char(0xA5), char(0x5A), char(0x5A), char(0xA5),
@ -376,7 +371,6 @@ namespace
//*************************************************************************
TEST(write_uint64_t)
{
// Tests assume big endian.
std::array<char, sizeof(uint64_t) * 4> storage;
std::array<char, sizeof(uint64_t) * 4> compare_data = { char(0x00), char(0x00), char(0x00), char(0x00), char(0x00), char(0x00), char(0x00), char(0x01),
char(0x5A), char(0xA5), char(0xA5), char(0x5A), char(0xA5), char(0x5A), char(0x5A), char(0xA5),
@ -404,7 +398,6 @@ namespace
//*************************************************************************
TEST(write_and_skip_int32_t)
{
// Tests assume big endian.
std::array<char, sizeof(int32_t) * 4> storage = { char(0xF0), char(0xF1), char(0xF2), char(0xF3),
char(0xF4), char(0xF5), char(0xF6), char(0xF7),
char(0xF8), char(0xF9), char(0xFA), char(0xFB),
@ -431,7 +424,6 @@ namespace
//*************************************************************************
TEST(read_and_skip_int32_t)
{
// Tests assume big endian.
std::array<char, sizeof(int32_t) * 4> storage = { char(0x01), char(0x02), char(0x03), char(0x04),
char(0xF4), char(0xF5), char(0xF6), char(0xF7),
char(0xF8), char(0xF9), char(0xFA), char(0xFB),

5
test/vs2019/etl.vcxproj
View File

@ -10911,8 +10911,9 @@
<ClCompile Include="..\test_alignment.cpp" />
<ClCompile Include="..\test_atomic.cpp" />
<ClCompile Include="..\test_bit.cpp" />
<ClCompile Include="..\test_bit_stream_reader.cpp" />
<ClCompile Include="..\test_bit_stream_writer.cpp" />
<ClCompile Include="..\test_bit_stream_reader_big_endian.cpp" />
<ClCompile Include="..\test_bit_stream_writer_big_endian.cpp" />
<ClCompile Include="..\test_bit_stream_writer_little_endian.cpp" />
<ClCompile Include="..\test_bresenham_line.cpp" />
<ClCompile Include="..\test_buffer_descriptors.cpp" />
<ClCompile Include="..\test_byte.cpp" />

9
test/vs2019/etl.vcxproj.filters
View File

@ -3242,7 +3242,7 @@
<ClCompile Include="..\sanity-check\delegate_cpp03.h.t.cpp">
<Filter>Tests\Sanity Checks\Source</Filter>
</ClCompile>
<ClCompile Include="..\test_bit_stream_writer.cpp">
<ClCompile Include="..\test_bit_stream_writer_big_endian.cpp">
<Filter>Tests\Binary</Filter>
</ClCompile>
<ClCompile Include="..\test_variant_legacy.cpp">
@ -3251,7 +3251,10 @@
<ClCompile Include="..\test_atomic.cpp">
<Filter>Tests\Atomic</Filter>
</ClCompile>
<ClCompile Include="..\test_bit_stream_reader.cpp">
<ClCompile Include="..\test_bit_stream_reader_big_endian.cpp">
<Filter>Tests\Binary</Filter>
</ClCompile>
<ClCompile Include="..\test_bit_stream_writer_little_endian.cpp">
<Filter>Tests\Binary</Filter>
</ClCompile>
</ItemGroup>
@ -3416,4 +3419,4 @@
<Filter>Resource Files</Filter>
</Natvis>
</ItemGroup>
</Project>
</Project>