feedc0de/boost_endian
1
0 Fork 0
forked from boostorg/endian
Code Pull Requests Activity

Revert the default (*_t) types to unaligned, and used *_at to identify the aligned types. See mini-review thread for rationale.

Browse Source
This commit is contained in:
Beman committed 2015-02-23 07:24:17 -05:00
1 parent b6b03ea900
commit 9c0cbae556
11 files changed
+1070 -1070
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

test/buffer_test.cpp
+67 -67
View File
@@ -30,6 +30,13 @@ namespace
void check_size()
{
BOOST_TEST_EQ(sizeof(big_float32_buf_at), 4u);
BOOST_TEST_EQ(sizeof(big_float64_buf_at), 8u);
BOOST_TEST_EQ(sizeof(little_float32_buf_at), 4u);
BOOST_TEST_EQ(sizeof(little_float64_buf_at), 8u);
BOOST_TEST_EQ(sizeof(native_float32_buf_at), 4u);
BOOST_TEST_EQ(sizeof(native_float64_buf_at), 8u);
BOOST_TEST_EQ(sizeof(big_float32_buf_t), 4u);
BOOST_TEST_EQ(sizeof(big_float64_buf_t), 8u);
BOOST_TEST_EQ(sizeof(little_float32_buf_t), 4u);
@@ -37,86 +44,79 @@ namespace
BOOST_TEST_EQ(sizeof(native_float32_buf_t), 4u);
BOOST_TEST_EQ(sizeof(native_float64_buf_t), 8u);
BOOST_TEST_EQ(sizeof(big_float32_buf_ut), 4u);
BOOST_TEST_EQ(sizeof(big_float64_buf_ut), 8u);
BOOST_TEST_EQ(sizeof(little_float32_buf_ut), 4u);
BOOST_TEST_EQ(sizeof(little_float64_buf_ut), 8u);
BOOST_TEST_EQ(sizeof(native_float32_buf_ut), 4u);
BOOST_TEST_EQ(sizeof(native_float64_buf_ut), 8u);
BOOST_TEST_EQ(sizeof(big_int8_buf_ut), 1u);
BOOST_TEST_EQ(sizeof(big_int16_buf_ut), 2u);
BOOST_TEST_EQ(sizeof(big_int24_buf_ut), 3u);
BOOST_TEST_EQ(sizeof(big_int32_buf_ut), 4u);
BOOST_TEST_EQ(sizeof(big_int40_buf_ut), 5u);
BOOST_TEST_EQ(sizeof(big_int48_buf_ut), 6u);
BOOST_TEST_EQ(sizeof(big_int56_buf_ut), 7u);
BOOST_TEST_EQ(sizeof(big_int64_buf_ut), 8u);
BOOST_TEST_EQ(sizeof(big_uint8_buf_ut), 1u);
BOOST_TEST_EQ(sizeof(big_uint16_buf_ut), 2u);
BOOST_TEST_EQ(sizeof(big_uint24_buf_ut), 3u);
BOOST_TEST_EQ(sizeof(big_uint32_buf_ut), 4u);
BOOST_TEST_EQ(sizeof(big_uint40_buf_ut), 5u);
BOOST_TEST_EQ(sizeof(big_uint48_buf_ut), 6u);
BOOST_TEST_EQ(sizeof(big_uint56_buf_ut), 7u);
BOOST_TEST_EQ(sizeof(big_uint64_buf_ut), 8u);
BOOST_TEST_EQ(sizeof(little_int8_buf_ut), 1u);
BOOST_TEST_EQ(sizeof(little_int16_buf_ut), 2u);
BOOST_TEST_EQ(sizeof(little_int24_buf_ut), 3u);
BOOST_TEST_EQ(sizeof(little_int32_buf_ut), 4u);
BOOST_TEST_EQ(sizeof(little_int40_buf_ut), 5u);
BOOST_TEST_EQ(sizeof(little_int48_buf_ut), 6u);
BOOST_TEST_EQ(sizeof(little_int56_buf_ut), 7u);
BOOST_TEST_EQ(sizeof(little_int64_buf_ut), 8u);
BOOST_TEST_EQ(sizeof(little_uint8_buf_ut), 1u);
BOOST_TEST_EQ(sizeof(little_uint16_buf_ut), 2u);
BOOST_TEST_EQ(sizeof(little_uint24_buf_ut), 3u);
BOOST_TEST_EQ(sizeof(little_uint32_buf_ut), 4u);
BOOST_TEST_EQ(sizeof(little_uint40_buf_ut), 5u);
BOOST_TEST_EQ(sizeof(little_uint48_buf_ut), 6u);
BOOST_TEST_EQ(sizeof(little_uint56_buf_ut), 7u);
BOOST_TEST_EQ(sizeof(little_uint64_buf_ut), 8u);
BOOST_TEST_EQ(sizeof(native_int8_buf_ut), 1u);
BOOST_TEST_EQ(sizeof(native_int16_buf_ut), 2u);
BOOST_TEST_EQ(sizeof(native_int24_buf_ut), 3u);
BOOST_TEST_EQ(sizeof(native_int32_buf_ut), 4u);
BOOST_TEST_EQ(sizeof(native_int40_buf_ut), 5u);
BOOST_TEST_EQ(sizeof(native_int48_buf_ut), 6u);
BOOST_TEST_EQ(sizeof(native_int56_buf_ut), 7u);
BOOST_TEST_EQ(sizeof(native_int64_buf_ut), 8u);
BOOST_TEST_EQ(sizeof(native_uint8_buf_ut), 1u);
BOOST_TEST_EQ(sizeof(native_uint16_buf_ut), 2u);
BOOST_TEST_EQ(sizeof(native_uint24_buf_ut), 3u);
BOOST_TEST_EQ(sizeof(native_uint32_buf_ut), 4u);
BOOST_TEST_EQ(sizeof(native_uint40_buf_ut), 5u);
BOOST_TEST_EQ(sizeof(native_uint48_buf_ut), 6u);
BOOST_TEST_EQ(sizeof(native_uint56_buf_ut), 7u);
BOOST_TEST_EQ(sizeof(native_uint64_buf_ut), 8u);
BOOST_TEST_EQ(sizeof(big_int8_buf_t), 1u);
BOOST_TEST_EQ(sizeof(big_int16_buf_t), 2u);
BOOST_TEST_EQ(sizeof(big_int24_buf_t), 3u);
BOOST_TEST_EQ(sizeof(big_int32_buf_t), 4u);
BOOST_TEST_EQ(sizeof(big_int40_buf_t), 5u);
BOOST_TEST_EQ(sizeof(big_int48_buf_t), 6u);
BOOST_TEST_EQ(sizeof(big_int56_buf_t), 7u);
BOOST_TEST_EQ(sizeof(big_int64_buf_t), 8u);
BOOST_TEST_EQ(sizeof(big_uint8_buf_t), 1u);
BOOST_TEST_EQ(sizeof(big_uint16_buf_t), 2u);
BOOST_TEST_EQ(sizeof(big_uint24_buf_t), 3u);
BOOST_TEST_EQ(sizeof(big_uint32_buf_t), 4u);
BOOST_TEST_EQ(sizeof(big_uint40_buf_t), 5u);
BOOST_TEST_EQ(sizeof(big_uint48_buf_t), 6u);
BOOST_TEST_EQ(sizeof(big_uint56_buf_t), 7u);
BOOST_TEST_EQ(sizeof(big_uint64_buf_t), 8u);
BOOST_TEST_EQ(sizeof(little_int8_buf_t), 1u);
BOOST_TEST_EQ(sizeof(little_int16_buf_t), 2u);
BOOST_TEST_EQ(sizeof(little_int24_buf_t), 3u);
BOOST_TEST_EQ(sizeof(little_int32_buf_t), 4u);
BOOST_TEST_EQ(sizeof(little_int40_buf_t), 5u);
BOOST_TEST_EQ(sizeof(little_int48_buf_t), 6u);
BOOST_TEST_EQ(sizeof(little_int56_buf_t), 7u);
BOOST_TEST_EQ(sizeof(little_int64_buf_t), 8u);
BOOST_TEST_EQ(sizeof(little_uint8_buf_t), 1u);
BOOST_TEST_EQ(sizeof(little_uint16_buf_t), 2u);
BOOST_TEST_EQ(sizeof(little_uint24_buf_t), 3u);
BOOST_TEST_EQ(sizeof(little_uint32_buf_t), 4u);
BOOST_TEST_EQ(sizeof(little_uint40_buf_t), 5u);
BOOST_TEST_EQ(sizeof(little_uint48_buf_t), 6u);
BOOST_TEST_EQ(sizeof(little_uint56_buf_t), 7u);
BOOST_TEST_EQ(sizeof(little_uint64_buf_t), 8u);
BOOST_TEST_EQ(sizeof(native_int8_buf_t), 1u);
BOOST_TEST_EQ(sizeof(native_int16_buf_t), 2u);
BOOST_TEST_EQ(sizeof(native_int24_buf_t), 3u);
BOOST_TEST_EQ(sizeof(native_int32_buf_t), 4u);
BOOST_TEST_EQ(sizeof(native_int40_buf_t), 5u);
BOOST_TEST_EQ(sizeof(native_int48_buf_t), 6u);
BOOST_TEST_EQ(sizeof(native_int56_buf_t), 7u);
BOOST_TEST_EQ(sizeof(native_int64_buf_t), 8u);
BOOST_TEST_EQ(sizeof(native_uint8_buf_t), 1u);
BOOST_TEST_EQ(sizeof(native_uint16_buf_t), 2u);
BOOST_TEST_EQ(sizeof(native_uint24_buf_t), 3u);
BOOST_TEST_EQ(sizeof(native_uint32_buf_t), 4u);
BOOST_TEST_EQ(sizeof(native_uint40_buf_t), 5u);
BOOST_TEST_EQ(sizeof(native_uint48_buf_t), 6u);
BOOST_TEST_EQ(sizeof(native_uint56_buf_t), 7u);
BOOST_TEST_EQ(sizeof(native_uint64_buf_t), 8u);
BOOST_TEST_EQ(sizeof(big_int8_buf_at), 1u);
BOOST_TEST_EQ(sizeof(big_int16_buf_at), 2u);
BOOST_TEST_EQ(sizeof(big_int32_buf_at), 4u);
BOOST_TEST_EQ(sizeof(big_int64_buf_at), 8u);
BOOST_TEST_EQ(sizeof(big_uint8_buf_at), 1u);
BOOST_TEST_EQ(sizeof(big_uint16_buf_at), 2u);
BOOST_TEST_EQ(sizeof(big_uint32_buf_at), 4u);
BOOST_TEST_EQ(sizeof(big_uint64_buf_at), 8u);
BOOST_TEST_EQ(sizeof(little_int8_buf_at), 1u);
BOOST_TEST_EQ(sizeof(little_int16_buf_at), 2u);
BOOST_TEST_EQ(sizeof(little_int32_buf_at), 4u);
BOOST_TEST_EQ(sizeof(little_int64_buf_at), 8u);
BOOST_TEST_EQ(sizeof(little_uint8_buf_at), 1u);
BOOST_TEST_EQ(sizeof(little_uint16_buf_at), 2u);
BOOST_TEST_EQ(sizeof(little_uint32_buf_at), 4u);
BOOST_TEST_EQ(sizeof(little_uint64_buf_at), 8u);
} // check_size
// test_inserter_and_extractor -----------------------------------------------------//
@@ -125,8 +125,8 @@ namespace
{
std::cout << "test inserter and extractor..." << std::endl;
big_uint64_buf_ut bu64(0x010203040506070ULL);
little_uint64_buf_ut lu64(0x010203040506070ULL);
big_uint64_buf_t bu64(0x010203040506070ULL);
little_uint64_buf_t lu64(0x010203040506070ULL);
uint64_t x;
@@ -143,13 +143,13 @@ namespace
ss.clear();
ss << 0x010203040506070ULL;
big_uint64_buf_ut bu64z(0);
big_uint64_buf_t bu64z(0);
ss >> bu64z;
BOOST_TEST_EQ(bu64z.value(), bu64.value());
ss.clear();
ss << 0x010203040506070ULL;
little_uint64_buf_ut lu64z(0);
little_uint64_buf_t lu64z(0);
ss >> lu64z;
BOOST_TEST_EQ(lu64z.value(), lu64.value());
@@ -166,7 +166,7 @@ int cpp_main(int, char *[])
cout << "byte swap intrinsics: " BOOST_ENDIAN_INTRINSIC_MSG << endl;
cout << " construct big endian aligned" << endl;
big_int32_buf_t x(1122334455);
big_int32_buf_at x(1122334455);
cout << " assign to buffer from built-in integer" << endl;
x = 1234567890;
@@ -176,7 +176,7 @@ int cpp_main(int, char *[])
BOOST_TEST(b1);
cout << " construct little endian unaligned" << endl;
little_int32_buf_ut x2(1122334455);
little_int32_buf_t x2(1122334455);
cout << " assign to buffer from built-in integer" << endl;
x2 = 1234567890;
test/endian_in_union_test.cpp
+48 -48
View File
@@ -21,59 +21,59 @@ using namespace boost::endian;
union U
{
big_int8_ut big_8;
big_int16_ut big_16;
big_int24_ut big_24;
big_int32_ut big_32;
big_int40_ut big_40;
big_int48_ut big_48;
big_int56_ut big_56;
big_int64_ut big_64;
big_int8_t big_8;
big_int16_t big_16;
big_int24_t big_24;
big_int32_t big_32;
big_int40_t big_40;
big_int48_t big_48;
big_int56_t big_56;
big_int64_t big_64;
big_uint8_ut big_u8;
big_uint16_ut big_u16;
big_uint24_ut big_u24;
big_uint32_ut big_u32;
big_uint40_ut big_u40;
big_uint48_ut big_u48;
big_uint56_ut big_u56;
big_uint64_ut big_u64;
big_uint8_t big_u8;
big_uint16_t big_u16;
big_uint24_t big_u24;
big_uint32_t big_u32;
big_uint40_t big_u40;
big_uint48_t big_u48;
big_uint56_t big_u56;
big_uint64_t big_u64;
little_int8_ut little_8;
little_int16_ut little_16;
little_int24_ut little_24;
little_int32_ut little_32;
little_int40_ut little_40;
little_int48_ut little_48;
little_int56_ut little_56;
little_int64_ut little_64;
little_int8_t little_8;
little_int16_t little_16;
little_int24_t little_24;
little_int32_t little_32;
little_int40_t little_40;
little_int48_t little_48;
little_int56_t little_56;
little_int64_t little_64;
little_uint8_ut little_u8;
little_uint16_ut little_u16;
little_uint24_ut little_u24;
little_uint32_ut little_u32;
little_uint40_ut little_u40;
little_uint48_ut little_u48;
little_uint56_ut little_u56;
little_uint64_ut little_u64;
little_uint8_t little_u8;
little_uint16_t little_u16;
little_uint24_t little_u24;
little_uint32_t little_u32;
little_uint40_t little_u40;
little_uint48_t little_u48;
little_uint56_t little_u56;
little_uint64_t little_u64;
native_int8_ut native_8;
native_int16_ut native_16;
native_int24_ut native_24;
native_int32_ut native_32;
native_int40_ut native_40;
native_int48_ut native_48;
native_int56_ut native_56;
native_int64_ut native_64;
native_int8_t native_8;
native_int16_t native_16;
native_int24_t native_24;
native_int32_t native_32;
native_int40_t native_40;
native_int48_t native_48;
native_int56_t native_56;
native_int64_t native_64;
native_uint8_ut native_u8;
native_uint16_ut native_u16;
native_uint24_ut native_u24;
native_uint32_ut native_u32;
native_uint40_ut native_u40;
native_uint48_ut native_u48;
native_uint56_ut native_u56;
native_uint64_ut native_u64;
native_uint8_t native_u8;
native_uint16_t native_u16;
native_uint24_t native_u24;
native_uint32_t native_u32;
native_uint40_t native_u40;
native_uint48_t native_u48;
native_uint56_t native_u56;
native_uint64_t native_u64;
};
U foo;
test/endian_operations_test.cpp
+119 -119
View File
@@ -194,67 +194,67 @@ void op_test_aux()
Test<T1, unsigned long>::test();
Test<T1, long long>::test();
Test<T1, unsigned long long>::test();
Test<T1, be::big_int16_at>::test();
Test<T1, be::big_int32_at>::test();
Test<T1, be::big_int64_at>::test();
Test<T1, be::big_uint16_at>::test();
Test<T1, be::big_uint32_at>::test();
Test<T1, be::big_uint64_at>::test();
Test<T1, be::little_int16_at>::test();
Test<T1, be::little_int32_at>::test();
Test<T1, be::little_int64_at>::test();
Test<T1, be::little_uint16_at>::test();
Test<T1, be::little_uint32_at>::test();
Test<T1, be::little_uint64_at>::test();
Test<T1, be::big_int8_t>::test();
Test<T1, be::big_int16_t>::test();
Test<T1, be::big_int24_t>::test();
Test<T1, be::big_int32_t>::test();
Test<T1, be::big_int40_t>::test();
Test<T1, be::big_int48_t>::test();
Test<T1, be::big_int56_t>::test();
Test<T1, be::big_int64_t>::test();
Test<T1, be::big_uint8_t>::test();
Test<T1, be::big_uint16_t>::test();
Test<T1, be::big_uint24_t>::test();
Test<T1, be::big_uint32_t>::test();
Test<T1, be::big_uint40_t>::test();
Test<T1, be::big_uint64_t>::test();
Test<T1, be::little_int16_t>::test();
Test<T1, be::little_int24_t>::test();
Test<T1, be::little_int32_t>::test();
Test<T1, be::little_int64_t>::test();
Test<T1, be::little_uint16_t>::test();
Test<T1, be::little_uint32_t>::test();
Test<T1, be::little_uint56_t>::test();
Test<T1, be::little_uint64_t>::test();
Test<T1, be::big_int8_ut>::test();
Test<T1, be::big_int16_ut>::test();
Test<T1, be::big_int24_ut>::test();
Test<T1, be::big_int32_ut>::test();
Test<T1, be::big_int40_ut>::test();
Test<T1, be::big_int48_ut>::test();
Test<T1, be::big_int56_ut>::test();
Test<T1, be::big_int64_ut>::test();
Test<T1, be::big_uint8_ut>::test();
Test<T1, be::big_uint16_ut>::test();
Test<T1, be::big_uint24_ut>::test();
Test<T1, be::big_uint32_ut>::test();
Test<T1, be::big_uint40_ut>::test();
Test<T1, be::big_uint64_ut>::test();
Test<T1, be::little_int16_ut>::test();
Test<T1, be::little_int24_ut>::test();
Test<T1, be::little_int32_ut>::test();
Test<T1, be::little_int64_ut>::test();
Test<T1, be::little_uint16_ut>::test();
Test<T1, be::little_uint32_ut>::test();
Test<T1, be::little_uint56_ut>::test();
Test<T1, be::little_uint64_ut>::test();
Test<T1, be::native_int16_ut>::test();
Test<T1, be::native_int24_ut>::test();
Test<T1, be::native_int32_ut>::test();
Test<T1, be::native_int64_ut>::test();
Test<T1, be::native_int16_t>::test();
Test<T1, be::native_int24_t>::test();
Test<T1, be::native_int32_t>::test();
Test<T1, be::native_int64_t>::test();
#ifdef BOOST_LONG_ENDIAN_TEST
Test<T1, be::native_uint16_ut>::test();
Test<T1, be::native_uint24_ut>::test();
Test<T1, be::native_uint32_ut>::test();
Test<T1, be::native_uint48_ut>::test();
Test<T1, be::native_uint64_ut>::test();
Test<T1, be::big_uint48_ut>::test();
Test<T1, be::big_uint56_ut>::test();
Test<T1, be::little_int8_ut>::test();
Test<T1, be::little_int56_ut>::test();
Test<T1, be::little_int40_ut>::test();
Test<T1, be::little_int48_ut>::test();
Test<T1, be::little_uint8_ut>::test();
Test<T1, be::little_uint24_ut>::test();
Test<T1, be::little_uint40_ut>::test();
Test<T1, be::little_uint48_ut>::test();
Test<T1, be::native_int8_ut>::test();
Test<T1, be::native_int40_ut>::test();
Test<T1, be::native_int48_ut>::test();
Test<T1, be::native_int56_ut>::test();
Test<T1, be::native_uint8_ut>::test();
Test<T1, be::native_uint40_ut>::test();
Test<T1, be::native_uint56_ut>::test();
Test<T1, be::native_uint16_t>::test();
Test<T1, be::native_uint24_t>::test();
Test<T1, be::native_uint32_t>::test();
Test<T1, be::native_uint48_t>::test();
Test<T1, be::native_uint64_t>::test();
Test<T1, be::big_uint48_t>::test();
Test<T1, be::big_uint56_t>::test();
Test<T1, be::little_int8_t>::test();
Test<T1, be::little_int56_t>::test();
Test<T1, be::little_int40_t>::test();
Test<T1, be::little_int48_t>::test();
Test<T1, be::little_uint8_t>::test();
Test<T1, be::little_uint24_t>::test();
Test<T1, be::little_uint40_t>::test();
Test<T1, be::little_uint48_t>::test();
Test<T1, be::native_int8_t>::test();
Test<T1, be::native_int40_t>::test();
Test<T1, be::native_int48_t>::test();
Test<T1, be::native_int56_t>::test();
Test<T1, be::native_uint8_t>::test();
Test<T1, be::native_uint40_t>::test();
Test<T1, be::native_uint56_t>::test();
#endif
}
@@ -272,61 +272,61 @@ void op_test()
op_test_aux<Test, unsigned long>();
op_test_aux<Test, long long>();
op_test_aux<Test, unsigned long long>();
op_test_aux<Test, be::big_int16_t>();
op_test_aux<Test, be::big_int32_t>();
op_test_aux<Test, be::big_int64_t>();
op_test_aux<Test, be::little_int16_t>();
op_test_aux<Test, be::little_int32_t>();
op_test_aux<Test, be::little_int64_t>();
op_test_aux<Test, be::big_int16_at>();
op_test_aux<Test, be::big_int32_at>();
op_test_aux<Test, be::big_int64_at>();
op_test_aux<Test, be::little_int16_at>();
op_test_aux<Test, be::little_int32_at>();
op_test_aux<Test, be::little_int64_at>();
#ifdef BOOST_LONG_ENDIAN_TEST
op_test_aux<Test, be::big_int8_ut>();
op_test_aux<Test, be::big_int16_ut>();
op_test_aux<Test, be::big_int24_ut>();
op_test_aux<Test, be::big_int32_ut>();
op_test_aux<Test, be::big_int40_ut>();
op_test_aux<Test, be::big_int48_ut>();
op_test_aux<Test, be::big_int56_ut>();
op_test_aux<Test, be::big_int64_ut>();
op_test_aux<Test, be::big_uint8_ut>();
op_test_aux<Test, be::big_uint16_ut>();
op_test_aux<Test, be::big_uint24_ut>();
op_test_aux<Test, be::big_uint32_ut>();
op_test_aux<Test, be::big_uint40_ut>();
op_test_aux<Test, be::big_uint48_ut>();
op_test_aux<Test, be::big_uint56_ut>();
op_test_aux<Test, be::big_uint64_ut>();
op_test_aux<Test, be::little_int8_ut>();
op_test_aux<Test, be::little_int16_ut>();
op_test_aux<Test, be::little_int24_ut>();
op_test_aux<Test, be::little_int32_ut>();
op_test_aux<Test, be::little_int40_ut>();
op_test_aux<Test, be::little_int48_ut>();
op_test_aux<Test, be::little_int56_ut>();
op_test_aux<Test, be::little_int64_ut>();
op_test_aux<Test, be::little_uint8_ut>();
op_test_aux<Test, be::little_uint16_ut>();
op_test_aux<Test, be::little_uint24_ut>();
op_test_aux<Test, be::little_uint32_ut>();
op_test_aux<Test, be::little_uint40_ut>();
op_test_aux<Test, be::little_uint48_ut>();
op_test_aux<Test, be::little_uint56_ut>();
op_test_aux<Test, be::little_uint64_ut>();
op_test_aux<Test, be::native_int8_ut>();
op_test_aux<Test, be::native_int16_ut>();
op_test_aux<Test, be::native_int24_ut>();
op_test_aux<Test, be::native_int32_ut>();
op_test_aux<Test, be::native_int40_ut>();
op_test_aux<Test, be::native_int48_ut>();
op_test_aux<Test, be::native_int56_ut>();
op_test_aux<Test, be::native_int64_ut>();
op_test_aux<Test, be::native_uint8_ut>();
op_test_aux<Test, be::native_uint16_ut>();
op_test_aux<Test, be::native_uint24_ut>();
op_test_aux<Test, be::native_uint32_ut>();
op_test_aux<Test, be::native_uint40_ut>();
op_test_aux<Test, be::native_uint48_ut>();
op_test_aux<Test, be::native_uint56_ut>();
op_test_aux<Test, be::native_uint64_ut>();
op_test_aux<Test, be::big_int8_t>();
op_test_aux<Test, be::big_int16_t>();
op_test_aux<Test, be::big_int24_t>();
op_test_aux<Test, be::big_int32_t>();
op_test_aux<Test, be::big_int40_t>();
op_test_aux<Test, be::big_int48_t>();
op_test_aux<Test, be::big_int56_t>();
op_test_aux<Test, be::big_int64_t>();
op_test_aux<Test, be::big_uint8_t>();
op_test_aux<Test, be::big_uint16_t>();
op_test_aux<Test, be::big_uint24_t>();
op_test_aux<Test, be::big_uint32_t>();
op_test_aux<Test, be::big_uint40_t>();
op_test_aux<Test, be::big_uint48_t>();
op_test_aux<Test, be::big_uint56_t>();
op_test_aux<Test, be::big_uint64_t>();
op_test_aux<Test, be::little_int8_t>();
op_test_aux<Test, be::little_int16_t>();
op_test_aux<Test, be::little_int24_t>();
op_test_aux<Test, be::little_int32_t>();
op_test_aux<Test, be::little_int40_t>();
op_test_aux<Test, be::little_int48_t>();
op_test_aux<Test, be::little_int56_t>();
op_test_aux<Test, be::little_int64_t>();
op_test_aux<Test, be::little_uint8_t>();
op_test_aux<Test, be::little_uint16_t>();
op_test_aux<Test, be::little_uint24_t>();
op_test_aux<Test, be::little_uint32_t>();
op_test_aux<Test, be::little_uint40_t>();
op_test_aux<Test, be::little_uint48_t>();
op_test_aux<Test, be::little_uint56_t>();
op_test_aux<Test, be::little_uint64_t>();
op_test_aux<Test, be::native_int8_t>();
op_test_aux<Test, be::native_int16_t>();
op_test_aux<Test, be::native_int24_t>();
op_test_aux<Test, be::native_int32_t>();
op_test_aux<Test, be::native_int40_t>();
op_test_aux<Test, be::native_int48_t>();
op_test_aux<Test, be::native_int56_t>();
op_test_aux<Test, be::native_int64_t>();
op_test_aux<Test, be::native_uint8_t>();
op_test_aux<Test, be::native_uint16_t>();
op_test_aux<Test, be::native_uint24_t>();
op_test_aux<Test, be::native_uint32_t>();
op_test_aux<Test, be::native_uint40_t>();
op_test_aux<Test, be::native_uint48_t>();
op_test_aux<Test, be::native_uint56_t>();
op_test_aux<Test, be::native_uint64_t>();
#endif
}
@@ -336,8 +336,8 @@ void test_inserter_and_extractor()
{
std::cout << "test inserter and extractor..." << std::endl;
be::big_uint64_ut bu64(0x010203040506070ULL);
be::little_uint64_ut lu64(0x010203040506070ULL);
be::big_uint64_t bu64(0x010203040506070ULL);
be::little_uint64_t lu64(0x010203040506070ULL);
uint64_t x;
@@ -354,13 +354,13 @@ void test_inserter_and_extractor()
ss.clear();
ss << 0x010203040506070ULL;
be::big_uint64_ut bu64z(0);
be::big_uint64_t bu64z(0);
ss >> bu64z;
BOOST_TEST_EQ(bu64z, bu64);
ss.clear();
ss << 0x010203040506070ULL;
be::little_uint64_ut lu64z(0);
be::little_uint64_t lu64z(0);
ss >> lu64z;
BOOST_TEST_EQ(lu64z, lu64);
@@ -368,7 +368,7 @@ void test_inserter_and_extractor()
}
void f_big_int32_ut(be::big_int32_ut) {}
void f_big_int32_ut(be::big_int32_t) {}
// main ------------------------------------------------------------------------------//
@@ -378,10 +378,10 @@ int cpp_main(int, char * [])
// make sure some simple things work
be::big_int32_ut o1(1);
be::big_int32_ut o2(2L);
be::big_int32_ut o3(3LL);
be::big_int64_ut o4(1);
be::big_int32_t o1(1);
be::big_int32_t o2(2L);
be::big_int32_t o3(3LL);
be::big_int64_t o4(1);
// use cases; if BOOST_ENDIAN_LOG is defined, will output to clog info on
// what overloads and conversions are actually being performed.
@@ -389,13 +389,13 @@ int cpp_main(int, char * [])
be::endian_log = true;
std::clog << "set up test values\n";
be::big_int32_ut big(12345);
be::little_uint16_ut little_u(10);
be::big_int64_ut result;
be::big_int32_t big(12345);
be::little_uint16_t little_u(10);
be::big_int64_t result;
// this is the use case that is so irritating that it caused the endian
// constructors to be made non-explicit
std::clog << "\nf(1234) where f(big_int32_ut)\n";
std::clog << "\nf(1234) where f(big_int32_t)\n";
f_big_int32_ut(1234);
std::clog << "\nresult = big\n";
@@ -456,8 +456,8 @@ int cpp_main(int, char * [])
// test from Roland Schwarz that detected ambiguities; these ambiguities
// were eliminated by BOOST_ENDIAN_MINIMAL_COVER_OPERATORS
unsigned u;
be::little_uint32_ut u1;
be::little_uint32_ut u2;
be::little_uint32_t u1;
be::little_uint32_t u2;
u = 9;
u1 = 1;
@@ -467,7 +467,7 @@ int cpp_main(int, char * [])
// variations to detect ambiguities
be::little_uint32_ut u3 = u1 + 5;
be::little_uint32_t u3 = u1 + 5;
u3 = u1 + 5u;
if (u1 == 5)
@@ -482,7 +482,7 @@ int cpp_main(int, char * [])
u2 = u1 + 5u;
// one more wrinkle
be::little_uint16_ut u4(3);
be::little_uint16_t u4(3);
u4 = 3;
std::clog << "\nu2 = u1 + u4\n";
u2 = u1 + u4;
test/endian_test.cpp
+401 -401
View File
File diff suppressed because it is too large. Load diff
test/loop_time_test.cpp
+12 -12
View File
@@ -162,84 +162,84 @@ namespace
void test_big_align_int16()
{
cout << "<tr><td>16-bit aligned big endian</td>";
time<int16_t, big_int16_t>();
time<int16_t, big_int16_at>();
cout << "</tr>\n";
}
void test_little_align_int16()
{
cout << "<tr><td>16-bit aligned little endian</td>";
time<int16_t, little_int16_t>();
time<int16_t, little_int16_at>();
cout << "</tr>\n";
}
void test_big_int16()
{
cout << "<tr><td>16-bit unaligned big endian</td>";
time<int16_t, big_int16_ut>();
time<int16_t, big_int16_t>();
cout << "</tr>\n";
}
void test_little_int16()
{
cout << "<tr><td>16-bit unaligned little endian</td>";
time<int16_t, little_int16_ut>();
time<int16_t, little_int16_t>();
cout << "</tr>\n";
}
void test_big_align_int32()
{
cout << "<tr><td>32-bit aligned big endian</td>";
time<int32_t, big_int32_t>();
time<int32_t, big_int32_at>();
cout << "</tr>\n";
}
void test_little_align_int32()
{
cout << "<tr><td>32-bit aligned little endian</td>";
time<int32_t, little_int32_t>();
time<int32_t, little_int32_at>();
cout << "</tr>\n";
}
void test_big_int32()
{
cout << "<tr><td>32-bit unaligned big endian</td>";
time<int32_t, big_int32_ut>();
time<int32_t, big_int32_t>();
cout << "</tr>\n";
}
void test_little_int32()
{
cout << "<tr><td>32-bit unaligned little endian</td>";
time<int32_t, little_int32_ut>();
time<int32_t, little_int32_t>();
cout << "</tr>\n";
}
void test_big_align_int64()
{
cout << "<tr><td>64-bit aligned big endian</td>";
time<int64_t, big_int64_t>();
time<int64_t, big_int64_at>();
cout << "</tr>\n";
}
void test_little_align_int64()
{
cout << "<tr><td>64-bit aligned little endian</td>";
time<int64_t, little_int64_t>();
time<int64_t, little_int64_at>();
cout << "</tr>\n";
}
void test_big_int64()
{
cout << "<tr><td>64-bit unaligned big endian</td>";
time<int64_t, big_int64_ut>();
time<int64_t, big_int64_t>();
cout << "</tr>\n";
}
void test_little_int64()
{
cout << "<tr><td>64-bit unaligned little endian</td>";
time<int64_t, little_int64_ut>();
time<int64_t, little_int64_t>();
cout << "</tr>\n";
}