MadeOfJelly/MushMachine
MadeOfJelly
/
MushMachine
mirror of https://github.com/MadeOfJelly/MushMachine.git
2
2
Fork 0
Code Issues Projects Releases Wiki Activity
MushMachine/framework/s6zer/test/test.cpp

554 lines
19 KiB
C++
Raw Blame History

#include <mm/s6zer/serialize.hpp>
#include <array>
#include <ostream>
#include <mm/random/srng.hpp>
#include <mm/scalar_range2.hpp>
#include <gtest/gtest.h>
namespace MM {
template<typename Char, typename T>
std::basic_ostream<Char>& operator<<(std::basic_ostream<Char>& out, const MM::ScalarRange2<T>& range) {
return out << "{ min: " << static_cast<int64_t>(range.min()) << ", max: " << static_cast<int64_t>(range.max()) << " }";
}
} // MM
TEST(s6zer, bits_required_static) {
static_assert(MM::s6zer::bits_required(0)== 0);
static_assert(MM::s6zer::bits_required(1)== 1);
static_assert(MM::s6zer::bits_required(2)== 2);
static_assert(MM::s6zer::bits_required(3)== 2);
static_assert(MM::s6zer::bits_required(4)== 3);
static_assert(MM::s6zer::bits_required(32)== 6);
static_assert(MM::s6zer::bits_required(0xffffffff)== 32);
static_assert(MM::s6zer::bits_required(0xffffff00)== 32);
static_assert(MM::s6zer::bits_required(0xf0000a00)== 32);
static_assert(MM::s6zer::bits_required(0x0f000000)== 28);
static_assert(MM::s6zer::bits_required(0x0000f000)== 16);
}
TEST(s6zer, byte_swap) {
static_assert(MM::s6zer::detail::byte_swap(static_cast<uint8_t>(0x00)) == 0x00);
static_assert(MM::s6zer::detail::byte_swap(static_cast<uint8_t>(0xff)) == 0xff);
static_assert(MM::s6zer::detail::byte_swap(static_cast<uint8_t>(0x10)) == 0x10);
static_assert(MM::s6zer::detail::byte_swap(static_cast<uint8_t>(0xfe)) == 0xfe);
static_assert(MM::s6zer::detail::byte_swap(static_cast<uint16_t>(0x0000)) == 0x0000);
static_assert(MM::s6zer::detail::byte_swap(static_cast<uint16_t>(0xffff)) == 0xffff);
static_assert(MM::s6zer::detail::byte_swap(static_cast<uint16_t>(0x00fe)) == 0xfe00);
static_assert(MM::s6zer::detail::byte_swap(static_cast<uint16_t>(0xfefe)) == 0xfefe);
static_assert(MM::s6zer::detail::byte_swap(static_cast<uint32_t>(0x00000000)) == 0x00000000);
static_assert(MM::s6zer::detail::byte_swap(static_cast<uint32_t>(0xffffffff)) == 0xffffffff);
static_assert(MM::s6zer::detail::byte_swap(static_cast<uint32_t>(0xf0f00000)) == 0x0000f0f0);
static_assert(MM::s6zer::detail::byte_swap(static_cast<uint32_t>(0xfe0000ef)) == 0xef0000fe);
}
TEST(s6zer, stream_normalcase1) {
const uint32_t num1_orig {0b111};
const uint32_t num1_orig_bits {3};
const uint32_t num2_orig {0b1111111111};
const uint32_t num2_orig_bits {10};
const uint32_t num3_orig {0b111111111111111111111111};
const uint32_t num3_orig_bits {24};
std::array<uint32_t, 2> buffer;
size_t buffer_size = buffer.size()*sizeof(uint32_t);
{
MM::s6zer::StreamWriter writer{buffer.data(), buffer_size};
bool r = false;
ASSERT_EQ(writer._scratch, 0x0);
ASSERT_EQ(writer._scratch_bits, 0);
ASSERT_EQ(writer._word_index, 0);
ASSERT_EQ(writer._bits_written, 0);
ASSERT_EQ(writer.bytesWritten(), 0);
r = writer.serializeBits(num1_orig, num1_orig_bits);
ASSERT_TRUE(r);
ASSERT_EQ(writer._scratch, 0b0000000000000000000000000000000000000000000000000000000000000'111);
ASSERT_EQ(writer._scratch_bits, 3);
ASSERT_EQ(writer._word_index, 0);
ASSERT_EQ(writer._bits_written, num1_orig_bits);
r = writer.serializeBits(num2_orig, num2_orig_bits);
ASSERT_TRUE(r);
ASSERT_EQ(writer._scratch, 0b000000000000000000000000000000000000000000000000000'111'1111111111);
ASSERT_EQ(writer._scratch_bits, 3+10);
ASSERT_EQ(writer._word_index, 0);
ASSERT_EQ(writer._bits_written, num1_orig_bits+num2_orig_bits);
r = writer.serializeBits(num3_orig, num3_orig_bits);
ASSERT_TRUE(r);
ASSERT_EQ(writer._scratch, 0b00000000000000000000000000000000000000000000000000000000000'11111);
ASSERT_EQ(writer._scratch_bits, (3+10+24)-32);
ASSERT_EQ(writer._word_index, 1);
ASSERT_EQ(writer._bits_written, num1_orig_bits+num2_orig_bits+num3_orig_bits);
r = writer.flush();
ASSERT_TRUE(r);
ASSERT_EQ(writer._scratch, 0);
ASSERT_EQ(writer._scratch_bits, 0);
ASSERT_EQ(writer._word_index, 2);
ASSERT_EQ(writer._bits_written, num1_orig_bits+num2_orig_bits+num3_orig_bits); // flush does not change bits written
ASSERT_EQ(writer.bytesWritten(), 5); // 4.625 , so ceil
buffer_size = writer.bytesWritten();
}
std::cout << "buffer_size: " << buffer_size << "\n";
ASSERT_EQ(buffer[0], 0xffffffff);
ASSERT_EQ(buffer[1], 0b000000000000000000000000000'11111);
{
MM::s6zer::StreamReader reader{buffer.data(), buffer_size};
bool r = false;
ASSERT_EQ(reader._scratch, 0x0);
ASSERT_EQ(reader._scratch_bits, 0);
ASSERT_EQ(reader._word_index, 0);
uint32_t num1 {0};
r = reader.serializeBits(num1, num1_orig_bits);
ASSERT_TRUE(r);
ASSERT_EQ(num1, num1_orig);
ASSERT_EQ(reader._scratch, 0b00000000'00000000'00000000'00000000'000'11111111111111111111111111111);
ASSERT_EQ(reader._scratch_bits, 29);
ASSERT_EQ(reader._word_index, 1); // index refers to next dword
uint32_t num2 {0};
r = reader.serializeBits(num2, num2_orig_bits);
ASSERT_TRUE(r);
ASSERT_EQ(num2, num2_orig);
ASSERT_EQ(reader._scratch, 0b00000000'00000000'00000000'00000000'000'00000'00000'1111111111111111111);
ASSERT_EQ(reader._scratch_bits, 19);
ASSERT_EQ(reader._word_index, 1); // <=32, so should not yet have read next dword
uint32_t num3 {0};
r = reader.serializeBits(num3, num3_orig_bits);
ASSERT_TRUE(r);
ASSERT_EQ(num3, num3_orig);
ASSERT_EQ(reader._scratch, 0x0); // no data left
ASSERT_EQ(reader._scratch_bits, 27);
ASSERT_EQ(reader._word_index, 2);
// error case
uint32_t num4 {0};
r = reader.serializeBits(num4, 32);
ASSERT_FALSE(r);
}
}
TEST(s6zer, stream_normalcase1_1) {
const uint32_t num1_orig {0b101};
const uint32_t num1_orig_bits {3};
const uint32_t num2_orig {0b1010101010};
const uint32_t num2_orig_bits {10};
const uint32_t num3_orig {0b101010101010101010101010};
const uint32_t num3_orig_bits {24};
std::array<uint32_t, 2> buffer;
size_t buffer_size = buffer.size()*sizeof(uint32_t);
{
MM::s6zer::StreamWriter writer{buffer.data(), buffer_size};
bool r = false;
ASSERT_EQ(writer._scratch, 0x0);
ASSERT_EQ(writer._scratch_bits, 0);
ASSERT_EQ(writer._word_index, 0);
ASSERT_EQ(writer._bits_written, 0);
ASSERT_EQ(writer.bytesWritten(), 0);
r = writer.serializeBits(num1_orig, num1_orig_bits);
ASSERT_TRUE(r);
ASSERT_EQ(writer._scratch, 0b0000000000000000000000000000000000000000000000000000000000000'101);
ASSERT_EQ(writer._scratch_bits, 3);
ASSERT_EQ(writer._word_index, 0);
ASSERT_EQ(writer._bits_written, num1_orig_bits);
r = writer.serializeBits(num2_orig, num2_orig_bits);
ASSERT_TRUE(r);
ASSERT_EQ(writer._scratch, 0b000000000000000000000000000000000000000000000000000'1010101010'101);
ASSERT_EQ(writer._scratch_bits, 3+10);
ASSERT_EQ(writer._word_index, 0);
ASSERT_EQ(writer._bits_written, num1_orig_bits+num2_orig_bits);
r = writer.serializeBits(num3_orig, num3_orig_bits);
ASSERT_TRUE(r);
ASSERT_EQ(writer._scratch, 0b00000000000000000000000000000000000000000000000000000000000'10101); // the high bits of the 24
ASSERT_EQ(writer._scratch_bits, (3+10+24)-32);
ASSERT_EQ(writer._word_index, 1);
ASSERT_EQ(writer._bits_written, num1_orig_bits+num2_orig_bits+num3_orig_bits);
r = writer.flush();
ASSERT_TRUE(r);
ASSERT_EQ(writer._scratch, 0);
ASSERT_EQ(writer._scratch_bits, 0);
ASSERT_EQ(writer._word_index, 2);
ASSERT_EQ(writer._bits_written, num1_orig_bits+num2_orig_bits+num3_orig_bits); // flush does not change bits written
ASSERT_EQ(writer.bytesWritten(), 5); // 4.625 , so ceil
buffer_size = writer.bytesWritten();
}
std::cout << "buffer_size: " << buffer_size << "\n";
ASSERT_EQ(buffer[0], 0b0101010101010101010'1010101010'101);
ASSERT_EQ(buffer[1], 0b000000000000000000000000000'10101);
{
MM::s6zer::StreamReader reader{buffer.data(), buffer_size};
bool r = false;
ASSERT_EQ(reader._scratch, 0x0);
ASSERT_EQ(reader._scratch_bits, 0);
ASSERT_EQ(reader._word_index, 0);
uint32_t num1 {0};
r = reader.serializeBits(num1, num1_orig_bits);
ASSERT_TRUE(r);
ASSERT_EQ(num1, num1_orig);
ASSERT_EQ(reader._scratch, 0b00000000'00000000'00000000'00000000'000'0101010101010101010'1010101010);
ASSERT_EQ(reader._scratch_bits, 29);
ASSERT_EQ(reader._word_index, 1); // index refers to next dword
uint32_t num2 {0};
r = reader.serializeBits(num2, num2_orig_bits);
ASSERT_TRUE(r);
ASSERT_EQ(num2, num2_orig);
ASSERT_EQ(reader._scratch, 0b00000000'00000000'00000000'00000000'000'00000'00000'0101010101010101010);
ASSERT_EQ(reader._scratch_bits, 19);
ASSERT_EQ(reader._word_index, 1); // <=32, so should not yet have read next dword
uint32_t num3 {0};
r = reader.serializeBits(num3, num3_orig_bits);
ASSERT_TRUE(r);
ASSERT_EQ(num3, num3_orig);
ASSERT_EQ(reader._scratch, 0x0); // no data left
ASSERT_EQ(reader._scratch_bits, 27);
ASSERT_EQ(reader._word_index, 2);
// error case
uint32_t num4 {0};
r = reader.serializeBits(num4, 32);
ASSERT_FALSE(r);
}
}
TEST(s6zer, stream_normalcase2) {
// we now take each number as its maximum, synthetic for testing
const uint32_t num1_orig {17};
const uint32_t num1_orig_bits {MM::s6zer::bits_required(num1_orig)};
const uint32_t num2_orig {1};
const uint32_t num2_orig_bits {MM::s6zer::bits_required(num2_orig)};
const uint32_t num3_orig {1298989};
const uint32_t num3_orig_bits {MM::s6zer::bits_required(num3_orig)};
std::array<uint32_t, 2> buffer;
size_t buffer_size = buffer.size()*sizeof(uint32_t);
{
MM::s6zer::StreamWriter writer{buffer.data(), buffer_size};
// fewer asserts
bool r = false;
ASSERT_EQ(writer._scratch, 0x0);
ASSERT_EQ(writer._scratch_bits, 0);
ASSERT_EQ(writer._word_index, 0);
ASSERT_EQ(writer._bits_written, 0);
ASSERT_EQ(writer.bytesWritten(), 0);
r = writer.serializeBits(num1_orig, num1_orig_bits);
ASSERT_TRUE(r);
ASSERT_EQ(writer._bits_written, num1_orig_bits);
r = writer.serializeBits(num2_orig, num2_orig_bits);
ASSERT_TRUE(r);
ASSERT_EQ(writer._bits_written, num1_orig_bits+num2_orig_bits);
r = writer.serializeBits(num3_orig, num3_orig_bits);
ASSERT_TRUE(r);
ASSERT_EQ(writer._bits_written, num1_orig_bits+num2_orig_bits+num3_orig_bits);
r = writer.flush();
ASSERT_TRUE(r);
ASSERT_EQ(writer._scratch, 0);
ASSERT_EQ(writer._scratch_bits, 0);
ASSERT_EQ(writer._bits_written, num1_orig_bits+num2_orig_bits+num3_orig_bits); // flush does not change bits written
buffer_size = writer.bytesWritten();
}
std::cout << "buffer_size: " << buffer_size << "\n";
{
MM::s6zer::StreamReader reader{buffer.data(), buffer_size};
bool r = false;
ASSERT_EQ(reader._scratch, 0x0);
ASSERT_EQ(reader._scratch_bits, 0);
ASSERT_EQ(reader._word_index, 0);
ASSERT_EQ(reader._bits_read, 0);
uint32_t num1 {0};
r = reader.serializeBits(num1, num1_orig_bits);
ASSERT_TRUE(r);
ASSERT_EQ(num1, num1_orig);
uint32_t num2 {0};
r = reader.serializeBits(num2, num2_orig_bits);
ASSERT_TRUE(r);
ASSERT_EQ(num2, num2_orig);
uint32_t num3 {0};
r = reader.serializeBits(num3, num3_orig_bits);
ASSERT_TRUE(r);
ASSERT_EQ(num3, num3_orig);
// error case
uint32_t num4 {0};
r = reader.serializeBits(num4, 32);
ASSERT_FALSE(r);
}
}
// emscripten cant do this
#ifndef __EMSCRIPTEN__
bool serialize_int_death_fn(void) {
std::array<uint32_t, 32> dummy_buffer;
MM::s6zer::StreamReader reader{dummy_buffer.data(), dummy_buffer.size()*sizeof(uint32_t)};
int32_t value{0};
MM_S6ZER_BAIL(reader.serializeInt(value, 20, -20)); // wrong order
return true;
}
TEST(s6zer, serialize_int_death) {
ASSERT_DEATH({
[[maybe_unused]] bool ret = serialize_int_death_fn();
}, "failed");
}
#endif
TEST(s6zer, reader_bits_bug1) {
const std::array<uint32_t, 2> buffer {
0x27'5c'19'a1,
0x00'00'3a'c3
};
const size_t buffer_size {6};
MM::s6zer::StreamReader reader{buffer.data(), buffer_size};
uint8_t value_0 {0};
ASSERT_TRUE(reader.serializeBits(value_0));
ASSERT_EQ(value_0, 0xa1);
ASSERT_EQ(reader._scratch_bits, 24);
ASSERT_EQ(reader._scratch, 0x0000000000'27'5c'19);
uint32_t value_1 {0};
ASSERT_TRUE(reader.serializeBits(value_1));
ASSERT_EQ(value_1, 0xc3'27'5c'19);
ASSERT_EQ(reader._scratch_bits, 24);
ASSERT_EQ(reader._scratch, 0x00000000000000'3a);
uint8_t value_2 {0};
ASSERT_TRUE(reader.serializeBits(value_2));
ASSERT_EQ(value_2, 0x3a);
ASSERT_EQ(reader._scratch, 0x0000000000000000);
}
struct TestStruct {
// integers bits
uint8_t u8 {0};
uint16_t u16 {0};
uint32_t u32 {0};
//uint64_t u64 {0};
bool b1 {false};
// integers ranges
uint8_t r_u8 {0};
constexpr static MM::ScalarRange2<uint8_t> r_u8_r{10, 60};
int8_t r_i8 {0};
constexpr static MM::ScalarRange2<int8_t> r_i8_r{-10, 5};
uint16_t r_u16 {0};
constexpr static MM::ScalarRange2<uint16_t> r_u16_r{1, 1026};
int16_t r_i16 {0};
constexpr static MM::ScalarRange2<int16_t> r_i16_r{-1, 1026};
uint32_t r_u32 {0};
constexpr static MM::ScalarRange2<uint32_t> r_u32_r{0, 12341234};
int32_t r_i32 {0};
constexpr static MM::ScalarRange2<int32_t> r_i32_r{-12341234, 10};
// floats
float f32 {0.f};
double f64 {0.};
// float compressed [0; 1] range
constexpr static float c0_f32_resolution = 0.001;
constexpr static MM::ScalarRange2<float> c0_f32_r{0.f, 1.f};
float c0_f32_0 {0.f};
float c0_f32_1 {0.f};
float c0_f32_2 {0.f};
float c0_f32_3 {0.f};
// float compressed [-1; 1] range
constexpr static float c1_f32_resolution = 0.05;
constexpr static MM::ScalarRange2<float> c1_f32_r{-1.f, 1.f};
float c1_f32_0 {0.f};
float c1_f32_1 {0.f};
float c1_f32_2 {0.f};
float c1_f32_3 {0.f};
// float compressed [-1000; 1000] range
constexpr static float c2_f32_resolution = 0.01;
constexpr static MM::ScalarRange2<float> c2_f32_r{-1000.f, 1000.f};
float c2_f32_0 {0.f};
float c2_f32_1 {0.f};
float c2_f32_2 {0.f};
float c2_f32_3 {0.f};
};
MM_DEFINE_SERIALIZE(TestStruct,
MM_S6ZER_BAIL(stream.serializeBits(data.u8))
MM_S6ZER_BAIL(stream.serializeBits(data.u16))
MM_S6ZER_BAIL(stream.serializeBits(data.u32))
MM_S6ZER_BAIL(stream.serializeBool(data.b1))
MM_S6ZER_BAIL(stream.serializeInt(data.r_u8, data.r_u8_r.min(), data.r_u8_r.max()))
MM_S6ZER_BAIL(stream.serializeInt(data.r_i8, data.r_i8_r.min(), data.r_i8_r.max()))
MM_S6ZER_BAIL(stream.serializeInt(data.r_u16, data.r_u16_r.min(), data.r_u16_r.max()))
MM_S6ZER_BAIL(stream.serializeInt(data.r_i16, data.r_i16_r.min(), data.r_i16_r.max()))
MM_S6ZER_BAIL(stream.serializeInt(data.r_u32, data.r_u32_r.min(), data.r_u32_r.max()))
MM_S6ZER_BAIL(stream.serializeInt(data.r_i32, data.r_i32_r.min(), data.r_i32_r.max()))
MM_S6ZER_BAIL(stream.serializeFloat(data.f32))
MM_S6ZER_BAIL(stream.serializeDouble(data.f64))
MM_S6ZER_BAIL(stream.serializeFloatCompressed(data.c0_f32_0, data.c0_f32_r.min(), data.c0_f32_r.max(), data.c0_f32_resolution))
MM_S6ZER_BAIL(stream.serializeFloatCompressed(data.c0_f32_1, data.c0_f32_r.min(), data.c0_f32_r.max(), data.c0_f32_resolution))
MM_S6ZER_BAIL(stream.serializeFloatCompressed(data.c0_f32_2, data.c0_f32_r.min(), data.c0_f32_r.max(), data.c0_f32_resolution))
MM_S6ZER_BAIL(stream.serializeFloatCompressed(data.c0_f32_3, data.c0_f32_r.min(), data.c0_f32_r.max(), data.c0_f32_resolution))
MM_S6ZER_BAIL(stream.serializeFloatCompressed(data.c1_f32_0, data.c1_f32_r.min(), data.c1_f32_r.max(), data.c1_f32_resolution))
MM_S6ZER_BAIL(stream.serializeFloatCompressed(data.c1_f32_1, data.c1_f32_r.min(), data.c1_f32_r.max(), data.c1_f32_resolution))
MM_S6ZER_BAIL(stream.serializeFloatCompressed(data.c1_f32_2, data.c1_f32_r.min(), data.c1_f32_r.max(), data.c1_f32_resolution))
MM_S6ZER_BAIL(stream.serializeFloatCompressed(data.c1_f32_3, data.c1_f32_r.min(), data.c1_f32_r.max(), data.c1_f32_resolution))
MM_S6ZER_BAIL(stream.serializeFloatCompressed(data.c2_f32_0, data.c2_f32_r.min(), data.c2_f32_r.max(), data.c2_f32_resolution))
MM_S6ZER_BAIL(stream.serializeFloatCompressed(data.c2_f32_1, data.c2_f32_r.min(), data.c2_f32_r.max(), data.c2_f32_resolution))
MM_S6ZER_BAIL(stream.serializeFloatCompressed(data.c2_f32_2, data.c2_f32_r.min(), data.c2_f32_r.max(), data.c2_f32_resolution))
MM_S6ZER_BAIL(stream.serializeFloatCompressed(data.c2_f32_3, data.c2_f32_r.min(), data.c2_f32_r.max(), data.c2_f32_resolution))
)
TEST(s6zer, stream_normalfull) {
std::array<uint32_t, 128> buffer;
size_t buffer_size = buffer.size()*sizeof(uint32_t);
MM::Random::SRNG rng{1337, 0};
const TestStruct data_in{
static_cast<uint8_t>(rng()),
static_cast<uint16_t>(rng()),
static_cast<uint32_t>(rng()),
rng.roll(0.5f),
rng.range(TestStruct::r_u8_r),
rng.range(TestStruct::r_i8_r),
rng.range(TestStruct::r_u16_r),
rng.range(TestStruct::r_i16_r),
rng.range(TestStruct::r_u32_r),
rng.range(TestStruct::r_i32_r),
rng.negOneToOne() * 10000000.f,
rng.negOneToOne() * 10000000.,
rng.range(TestStruct::c0_f32_r),
rng.range(TestStruct::c0_f32_r),
rng.range(TestStruct::c0_f32_r),
rng.range(TestStruct::c0_f32_r),
rng.range(TestStruct::c1_f32_r),
rng.range(TestStruct::c1_f32_r),
rng.range(TestStruct::c1_f32_r),
rng.range(TestStruct::c1_f32_r),
rng.range(TestStruct::c2_f32_r),
rng.range(TestStruct::c2_f32_r),
rng.range(TestStruct::c2_f32_r),
rng.range(TestStruct::c2_f32_r),
};
std::cout << "struct size: " << sizeof(TestStruct) << "\n";
{
MM::s6zer::StreamWriter writer{buffer.data(), buffer_size};
ASSERT_TRUE(mm_serialize(writer, data_in));
ASSERT_TRUE(writer.flush());
buffer_size = writer.bytesWritten();
}
std::cout << "buffer_size: " << buffer_size << "\n";
TestStruct data_out{}; // all zero
{
MM::s6zer::StreamReader reader{buffer.data(), buffer_size};
ASSERT_TRUE(mm_serialize(reader, data_out));
ASSERT_EQ(reader._scratch, 0x0000000000000000);
}
std::cout << "buffer: ";
for (size_t i = 0; i < buffer_size; i++) {
std::cout << std::hex << static_cast<uint32_t>(reinterpret_cast<uint8_t*>(buffer.data())[i]) << "'";
}
std::cout << "\n";
//std::cout << "data_out: \n" << data_out;
ASSERT_EQ(data_in.u8, data_out.u8);
ASSERT_EQ(data_in.u16, data_out.u16);
ASSERT_EQ(data_in.u32, data_out.u32);
ASSERT_EQ(data_in.b1, data_out.b1);
ASSERT_EQ(data_in.r_u8, data_out.r_u8) << "value range: " << TestStruct::r_u8_r;
ASSERT_EQ(data_in.r_i8, data_out.r_i8) << "value range: " << TestStruct::r_i8_r;
ASSERT_EQ(data_in.r_u16, data_out.r_u16) << "value range: " << TestStruct::r_u16_r;
ASSERT_EQ(data_in.r_i16, data_out.r_i16) << "value range: " << TestStruct::r_i16_r;
ASSERT_EQ(data_in.r_u32, data_out.r_u32) << "value range: " << TestStruct::r_u32_r;
ASSERT_EQ(data_in.r_i32, data_out.r_i32) << "value range: " << TestStruct::r_i32_r;
// bit perfect copies, can have wrong results for special values <.<
ASSERT_EQ(data_in.f32, data_out.f32);
ASSERT_EQ(data_in.f64, data_out.f64);
ASSERT_NEAR(data_in.c0_f32_0, data_out.c0_f32_0, TestStruct::c0_f32_resolution);
ASSERT_NEAR(data_in.c0_f32_1, data_out.c0_f32_1, TestStruct::c0_f32_resolution);
ASSERT_NEAR(data_in.c0_f32_2, data_out.c0_f32_2, TestStruct::c0_f32_resolution);
ASSERT_NEAR(data_in.c0_f32_3, data_out.c0_f32_3, TestStruct::c0_f32_resolution);
ASSERT_NEAR(data_in.c1_f32_0, data_out.c1_f32_0, TestStruct::c1_f32_resolution);
ASSERT_NEAR(data_in.c1_f32_1, data_out.c1_f32_1, TestStruct::c1_f32_resolution);
ASSERT_NEAR(data_in.c1_f32_2, data_out.c1_f32_2, TestStruct::c1_f32_resolution);
ASSERT_NEAR(data_in.c1_f32_3, data_out.c1_f32_3, TestStruct::c1_f32_resolution);
ASSERT_NEAR(data_in.c2_f32_0, data_out.c2_f32_0, TestStruct::c2_f32_resolution);
ASSERT_NEAR(data_in.c2_f32_1, data_out.c2_f32_1, TestStruct::c2_f32_resolution);
ASSERT_NEAR(data_in.c2_f32_2, data_out.c2_f32_2, TestStruct::c2_f32_resolution);
ASSERT_NEAR(data_in.c2_f32_3, data_out.c2_f32_3, TestStruct::c2_f32_resolution);
}
Reference in New Issue View Git Blame Copy Permalink