diff options
Diffstat (limited to 'libs/endian/test/endian_test.cpp')
| -rw-r--r-- | libs/endian/test/endian_test.cpp | 812 |
1 files changed, 812 insertions, 0 deletions
diff --git a/libs/endian/test/endian_test.cpp b/libs/endian/test/endian_test.cpp new file mode 100644 index 000000000..82f2092df --- /dev/null +++ b/libs/endian/test/endian_test.cpp @@ -0,0 +1,812 @@ +// endian_test.cpp ---------------------------------------------------------// + +// Copyright Beman Dawes 1999-2008 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// See library home page at http://www.boost.org/libs/endian + +//----------------------------------------------------------------------------// + +// This test probes for correct endianess, size, and value. + +// See endian_operations_test for tests of operator correctness and interaction +// between operand types. + +//----------------------------------------------------------------------------// + +#include <boost/endian/detail/disable_warnings.hpp> + +#include <boost/endian/arithmetic.hpp> +#include <boost/cstdint.hpp> +#include <boost/detail/lightweight_main.hpp> + +#include <iostream> +#include <limits> +#include <climits> +#include <cstdlib> // for atoi(), exit() +#include <cstring> // for memcmp() + +using namespace std; // Not the best programming practice, but I +using namespace boost; // want to verify this combination of using +using namespace boost::endian; // namespaces works. See endian_operations_test +// // for tests that don't do "using namespace". + +#define VERIFY(predicate) verify( predicate, __LINE__ ) +#define VERIFY_SIZE(actual, expected) verify_size( actual, expected, __LINE__ ) +#define VERIFY_VALUE_AND_OPS(endian_t,expected_t,expected) verify_value_and_ops<endian_t, expected_t>( expected, __LINE__ ) +#define VERIFY_BIG_REPRESENTATION(t) verify_representation<t>( true, __LINE__ ) +#define VERIFY_LITTLE_REPRESENTATION(t) verify_representation<t>( false, __LINE__ ) +#define VERIFY_NATIVE_REPRESENTATION(t) verify_native_representation<t>( __LINE__ ) + +namespace +{ + int err_count; + + void verify( bool x, int line ) + { + if ( x ) return; + ++err_count; + cout << "Error: verify failed on line " << line << endl; + } + + void verify_size( size_t actual, size_t expected, int line ) + { + if ( actual == expected ) return; + ++err_count; + cout << "Error: verify size failed on line " << line << endl; + cout << " A structure with an expected sizeof() " << expected + << " had an actual sizeof() " << actual + << "\n This will cause uses of endian types to fail\n"; + } + + template <class Endian, class Base> + void verify_value_and_ops( const Base & expected, int line ) + { + Endian v( expected ); + verify( v == expected, line ); + + Endian v2; + v2.operator=( expected ); + verify( v2 == expected, line ); + + ++v; // verify integer_cover_operators being applied to this type - + // will fail to compile if no endian<> specialization is present + + Endian x(static_cast<typename Endian::value_type>(v+v)); + if ( x == x ) // silence warning + return; + } + + const char * big_rep = "\x12\x34\x56\x78\x9A\xBC\xDE\xF0"; + const char * little_rep = "\xF0\xDE\xBC\x9A\x78\x56\x34\x12"; + + template <class Endian> + void verify_representation( bool is_big, int line ) + { + int silence = 0; + Endian x ( static_cast<typename Endian::value_type> + (0x123456789abcdef0LL + silence) ); // will truncate + + if ( is_big ) + verify( memcmp( &x, + reinterpret_cast<const char*>(big_rep)+8-sizeof(Endian), + sizeof(Endian) ) == 0, line ); + else + verify( memcmp( &x, little_rep, sizeof(Endian) ) == 0, line ); + } + + template <class Endian> + inline void verify_native_representation( int line ) + { +# ifdef BOOST_BIG_ENDIAN + verify_representation<Endian>( true, line ); +# else + verify_representation<Endian>( false, line ); +# endif + } + + // detect_order -----------------------------------------------------// + + void detect_order() + { + union View + { + long long i; + unsigned char c[8]; + }; + + View v = { 0x0102030405060708LL }; // initialize v.i + + if ( memcmp( v.c, "\x8\7\6\5\4\3\2\1", 8) == 0 ) + { + cout << "This machine is little-endian.\n"; + # ifndef BOOST_LITTLE_ENDIAN + cout << "yet boost/detail/endian.hpp does not define BOOST_LITTLE_ENDIAN.\n" + "The Boost Endian library must be revised to work correctly on this system.\n" + "Please report this problem to the Boost mailing list.\n"; + exit(1); + # endif + } + else if ( memcmp( v.c, "\1\2\3\4\5\6\7\x8", 8) == 0 ) + { + cout << "This machine is big-endian.\n"; + # ifndef BOOST_BIG_ENDIAN + cout << "yet boost/detail/endian.hpp does not define BOOST_BIG_ENDIAN.\n" + "The Boost Endian library must be revised to work correctly on this system.\n" + "Please report this problem to the Boost mailing list.\n"; + exit(1); + # endif + } + else + { + cout << "This machine is neither strict big-endian nor strict little-endian\n" + "The Boost Endian library must be revised to work correctly on this system.\n" + "Please report this problem to the Boost mailing list.\n"; + exit(1); + } + cout << "That should not matter and is presented for your information only.\n"; + } // detect_order + + // check_data ------------------------------------------------------------// + + void check_data() + { + 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_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_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_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_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_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; + + big_int16_at big_align_int16; + big_int32_at big_align_int32; + big_int64_at big_align_int64; + + big_uint16_at big_align_uint16; + big_uint32_at big_align_uint32; + big_uint64_at big_align_uint64; + + little_int16_at little_align_int16; + little_int32_at little_align_int32; + little_int64_at little_align_int64; + + little_uint16_at little_align_uint16; + little_uint32_at little_align_uint32; + little_uint64_at little_align_uint64; + + VERIFY(big_8.data() == reinterpret_cast<const char *>(&big_8)); + VERIFY(big_16.data() == reinterpret_cast<const char *>(&big_16)); + VERIFY(big_24.data() == reinterpret_cast<const char *>(&big_24)); + VERIFY(big_32.data() == reinterpret_cast<const char *>(&big_32)); + VERIFY(big_40.data() == reinterpret_cast<const char *>(&big_40)); + VERIFY(big_48.data() == reinterpret_cast<const char *>(&big_48)); + VERIFY(big_56.data() == reinterpret_cast<const char *>(&big_56)); + VERIFY(big_64.data() == reinterpret_cast<const char *>(&big_64)); + + VERIFY(big_u8.data() == reinterpret_cast<const char *>(&big_u8)); + VERIFY(big_u16.data() == reinterpret_cast<const char *>(&big_u16)); + VERIFY(big_u24.data() == reinterpret_cast<const char *>(&big_u24)); + VERIFY(big_u32.data() == reinterpret_cast<const char *>(&big_u32)); + VERIFY(big_u40.data() == reinterpret_cast<const char *>(&big_u40)); + VERIFY(big_u48.data() == reinterpret_cast<const char *>(&big_u48)); + VERIFY(big_u56.data() == reinterpret_cast<const char *>(&big_u56)); + VERIFY(big_u64.data() == reinterpret_cast<const char *>(&big_u64)); + + VERIFY(little_8.data() == reinterpret_cast<const char *>(&little_8)); + VERIFY(little_16.data() == reinterpret_cast<const char *>(&little_16)); + VERIFY(little_24.data() == reinterpret_cast<const char *>(&little_24)); + VERIFY(little_32.data() == reinterpret_cast<const char *>(&little_32)); + VERIFY(little_40.data() == reinterpret_cast<const char *>(&little_40)); + VERIFY(little_48.data() == reinterpret_cast<const char *>(&little_48)); + VERIFY(little_56.data() == reinterpret_cast<const char *>(&little_56)); + VERIFY(little_64.data() == reinterpret_cast<const char *>(&little_64)); + + VERIFY(little_u8.data() == reinterpret_cast<const char *>(&little_u8)); + VERIFY(little_u16.data() == reinterpret_cast<const char *>(&little_u16)); + VERIFY(little_u24.data() == reinterpret_cast<const char *>(&little_u24)); + VERIFY(little_u32.data() == reinterpret_cast<const char *>(&little_u32)); + VERIFY(little_u40.data() == reinterpret_cast<const char *>(&little_u40)); + VERIFY(little_u48.data() == reinterpret_cast<const char *>(&little_u48)); + VERIFY(little_u56.data() == reinterpret_cast<const char *>(&little_u56)); + VERIFY(little_u64.data() == reinterpret_cast<const char *>(&little_u64)); + + VERIFY(native_8.data() == reinterpret_cast<const char *>(&native_8)); + VERIFY(native_16.data() == reinterpret_cast<const char *>(&native_16)); + VERIFY(native_24.data() == reinterpret_cast<const char *>(&native_24)); + VERIFY(native_32.data() == reinterpret_cast<const char *>(&native_32)); + VERIFY(native_40.data() == reinterpret_cast<const char *>(&native_40)); + VERIFY(native_48.data() == reinterpret_cast<const char *>(&native_48)); + VERIFY(native_56.data() == reinterpret_cast<const char *>(&native_56)); + VERIFY(native_64.data() == reinterpret_cast<const char *>(&native_64)); + + VERIFY(native_u8.data() == reinterpret_cast<const char *>(&native_u8)); + VERIFY(native_u16.data() == reinterpret_cast<const char *>(&native_u16)); + VERIFY(native_u24.data() == reinterpret_cast<const char *>(&native_u24)); + VERIFY(native_u32.data() == reinterpret_cast<const char *>(&native_u32)); + VERIFY(native_u40.data() == reinterpret_cast<const char *>(&native_u40)); + VERIFY(native_u48.data() == reinterpret_cast<const char *>(&native_u48)); + VERIFY(native_u56.data() == reinterpret_cast<const char *>(&native_u56)); + VERIFY(native_u64.data() == reinterpret_cast<const char *>(&native_u64)); + + VERIFY(big_align_int16.data() == reinterpret_cast<const char *>(&big_align_int16)); + VERIFY(big_align_int32.data() == reinterpret_cast<const char *>(&big_align_int32)); + VERIFY(big_align_int64.data() == reinterpret_cast<const char *>(&big_align_int64)); + + VERIFY(big_align_uint16.data() == reinterpret_cast<const char *>(&big_align_uint16)); + VERIFY(big_align_uint32.data() == reinterpret_cast<const char *>(&big_align_uint32)); + VERIFY(big_align_uint64.data() == reinterpret_cast<const char *>(&big_align_uint64)); + + VERIFY(little_align_int16.data() == reinterpret_cast<const char *>(&little_align_int16)); + VERIFY(little_align_int32.data() == reinterpret_cast<const char *>(&little_align_int32)); + VERIFY(little_align_int64.data() == reinterpret_cast<const char *>(&little_align_int64)); + + VERIFY(little_align_uint16.data() == reinterpret_cast<const char *>(&little_align_uint16)); + VERIFY(little_align_uint32.data() == reinterpret_cast<const char *>(&little_align_uint32)); + VERIFY(little_align_uint64.data() == reinterpret_cast<const char *>(&little_align_uint64)); + + } + + // check_size ------------------------------------------------------------// + + void check_size() + { + VERIFY( numeric_limits<signed char>::digits == 7 ); + VERIFY( numeric_limits<unsigned char>::digits == 8 ); + + VERIFY_SIZE( sizeof( big_int8_t ), 1 ); + VERIFY_SIZE( sizeof( big_int16_t ), 2 ); + VERIFY_SIZE( sizeof( big_int24_t ), 3 ); + VERIFY_SIZE( sizeof( big_int32_t ), 4 ); + VERIFY_SIZE( sizeof( big_int40_t ), 5 ); + VERIFY_SIZE( sizeof( big_int48_t ), 6 ); + VERIFY_SIZE( sizeof( big_int56_t ), 7 ); + VERIFY_SIZE( sizeof( big_int64_t ), 8 ); + + VERIFY_SIZE( sizeof( big_uint8_t ), 1 ); + VERIFY_SIZE( sizeof( big_uint16_t ), 2 ); + VERIFY_SIZE( sizeof( big_uint24_t ), 3 ); + VERIFY_SIZE( sizeof( big_uint32_t ), 4 ); + VERIFY_SIZE( sizeof( big_uint40_t ), 5 ); + VERIFY_SIZE( sizeof( big_uint48_t ), 6 ); + VERIFY_SIZE( sizeof( big_uint56_t ), 7 ); + VERIFY_SIZE( sizeof( big_uint64_t ), 8 ); + + VERIFY_SIZE( sizeof( little_int8_t ), 1 ); + VERIFY_SIZE( sizeof( little_int16_t ), 2 ); + VERIFY_SIZE( sizeof( little_int24_t ), 3 ); + VERIFY_SIZE( sizeof( little_int32_t ), 4 ); + VERIFY_SIZE( sizeof( little_int40_t ), 5 ); + VERIFY_SIZE( sizeof( little_int48_t ), 6 ); + VERIFY_SIZE( sizeof( little_int56_t ), 7 ); + VERIFY_SIZE( sizeof( little_int64_t ), 8 ); + + VERIFY_SIZE( sizeof( little_uint8_t ), 1 ); + VERIFY_SIZE( sizeof( little_uint16_t ), 2 ); + VERIFY_SIZE( sizeof( little_uint24_t ), 3 ); + VERIFY_SIZE( sizeof( little_uint32_t ), 4 ); + VERIFY_SIZE( sizeof( little_uint40_t ), 5 ); + VERIFY_SIZE( sizeof( little_uint48_t ), 6 ); + VERIFY_SIZE( sizeof( little_uint56_t ), 7 ); + VERIFY_SIZE( sizeof( little_uint64_t ), 8 ); + + VERIFY_SIZE( sizeof( native_int8_t ), 1 ); + VERIFY_SIZE( sizeof( native_int16_t ), 2 ); + VERIFY_SIZE( sizeof( native_int24_t ), 3 ); + VERIFY_SIZE( sizeof( native_int32_t ), 4 ); + VERIFY_SIZE( sizeof( native_int40_t ), 5 ); + VERIFY_SIZE( sizeof( native_int48_t ), 6 ); + VERIFY_SIZE( sizeof( native_int56_t ), 7 ); + VERIFY_SIZE( sizeof( native_int64_t ), 8 ); + + VERIFY_SIZE( sizeof( native_uint8_t ), 1 ); + VERIFY_SIZE( sizeof( native_uint16_t ), 2 ); + VERIFY_SIZE( sizeof( native_uint24_t ), 3 ); + VERIFY_SIZE( sizeof( native_uint32_t ), 4 ); + VERIFY_SIZE( sizeof( native_uint40_t ), 5 ); + VERIFY_SIZE( sizeof( native_uint48_t ), 6 ); + VERIFY_SIZE( sizeof( native_uint56_t ), 7 ); + VERIFY_SIZE( sizeof( native_uint64_t ), 8 ); + + VERIFY_SIZE(sizeof(big_int8_at), 1); + VERIFY_SIZE(sizeof(big_int16_at), 2); + VERIFY_SIZE( sizeof( big_int32_at ), 4 ); + VERIFY_SIZE( sizeof( big_int64_at ), 8 ); + + VERIFY_SIZE(sizeof(big_uint8_at), 1); + VERIFY_SIZE(sizeof(big_uint16_at), 2); + VERIFY_SIZE( sizeof( big_uint32_at ), 4 ); + VERIFY_SIZE( sizeof( big_uint64_at ), 8 ); + + VERIFY_SIZE(sizeof(little_int8_at), 1); + VERIFY_SIZE(sizeof(little_int16_at), 2); + VERIFY_SIZE( sizeof( little_int32_at ), 4 ); + VERIFY_SIZE( sizeof( little_int64_at ), 8 ); + + VERIFY_SIZE(sizeof(little_uint8_at), 1); + VERIFY_SIZE(sizeof(little_uint16_at), 2); + VERIFY_SIZE( sizeof( little_uint32_at ), 4 ); + VERIFY_SIZE( sizeof( little_uint64_at ), 8 ); + } // check_size + + // check_alignment -------------------------------------------------------// + + void check_alignment() + { + // structs with offsets % 2 == 1 for type of size > 1 to ensure no alignment + // bytes added for any size > 1 + + struct big_struct + { + big_int8_t v0; + big_int16_t v1; + big_int24_t v3; + char v6; + big_int32_t v7; + big_int40_t v11; + char v16; + big_int48_t v17; + big_int56_t v23; + char v30; + big_int64_t v31; + }; + + struct big_u_struct + { + big_uint8_t v0; + big_uint16_t v1; + big_uint24_t v3; + char v6; + big_uint32_t v7; + big_uint40_t v11; + char v16; + big_uint48_t v17; + big_uint56_t v23; + char v30; + big_uint64_t v31; + }; + + struct little_struct + { + little_int8_t v0; + little_int16_t v1; + little_int24_t v3; + char v6; + little_int32_t v7; + little_int40_t v11; + char v16; + little_int48_t v17; + little_int56_t v23; + char v30; + little_int64_t v31; + }; + + struct little_u_struct + { + little_uint8_t v0; + little_uint16_t v1; + little_uint24_t v3; + char v6; + little_uint32_t v7; + little_uint40_t v11; + char v16; + little_uint48_t v17; + little_uint56_t v23; + char v30; + little_uint64_t v31; + }; + + struct native_struct + { + native_int8_t v0; + native_int16_t v1; + native_int24_t v3; + char v6; + native_int32_t v7; + native_int40_t v11; + char v16; + native_int48_t v17; + native_int56_t v23; + char v30; + native_int64_t v31; + }; + + struct native_u_struct + { + native_uint8_t v0; + native_uint16_t v1; + native_uint24_t v3; + char v6; + native_uint32_t v7; + native_uint40_t v11; + char v16; + native_uint48_t v17; + native_uint56_t v23; + char v30; + native_uint64_t v31; + }; + + // aligned test cases + + struct big_aligned_struct + { + big_int16_at v0; + big_int32_at v1; + char v3; + // on a 32-bit system, the padding here may be 3 rather than 7 bytes + big_int64_at v4; + }; + + struct little_aligned_struct + { + little_int16_at v0; + little_int32_at v1; + char v3; + // on a 32-bit system, the padding here may be 3 rather than 7 bytes + little_int64_at v4; + }; + + int saved_err_count = err_count; + + VERIFY_SIZE( sizeof(big_struct), 39 ); + VERIFY_SIZE( sizeof(big_u_struct), 39 ); + VERIFY_SIZE( sizeof(little_struct), 39 ); + VERIFY_SIZE( sizeof(little_u_struct), 39 ); + VERIFY_SIZE( sizeof(native_struct), 39 ); + VERIFY_SIZE( sizeof(native_u_struct), 39 ); + VERIFY( sizeof(big_aligned_struct) <= 24 ); + VERIFY( sizeof(little_aligned_struct) <= 24 ); + + if ( saved_err_count == err_count ) + { + cout << + "Size and alignment for structures of endian types are as expected.\n"; + } + } // check_alignment + + // check_representation_and_range_and_ops --------------------------------// + + void check_representation_and_range_and_ops() + { + // unaligned integer types + VERIFY_BIG_REPRESENTATION( big_int8_t ); + VERIFY_VALUE_AND_OPS( big_int8_t, int_least8_t, 0x7f ); + VERIFY_VALUE_AND_OPS( big_int8_t, int_least8_t, -0x80 ); + + VERIFY_BIG_REPRESENTATION( big_int16_t ); + VERIFY_VALUE_AND_OPS( big_int16_t, int_least16_t, 0x7fff ); + VERIFY_VALUE_AND_OPS( big_int16_t, int_least16_t, -0x8000 ); + + VERIFY_BIG_REPRESENTATION( big_int24_t ); + VERIFY_VALUE_AND_OPS( big_int24_t, int_least32_t, 0x7fffff ); + VERIFY_VALUE_AND_OPS( big_int24_t, int_least32_t, -0x800000 ); + + VERIFY_BIG_REPRESENTATION( big_int32_t ); + VERIFY_VALUE_AND_OPS( big_int32_t, int_least32_t, 0x7fffffff ); + VERIFY_VALUE_AND_OPS( big_int32_t, int_least32_t, -0x7fffffff-1 ); + + VERIFY_BIG_REPRESENTATION( big_int40_t ); + VERIFY_VALUE_AND_OPS( big_int40_t, int_least64_t, 0x7fffffffffLL ); + VERIFY_VALUE_AND_OPS( big_int40_t, int_least64_t, -0x8000000000LL ); + + VERIFY_BIG_REPRESENTATION( big_int48_t ); + VERIFY_VALUE_AND_OPS( big_int48_t, int_least64_t, 0x7fffffffffffLL ); + VERIFY_VALUE_AND_OPS( big_int48_t, int_least64_t, -0x800000000000LL ); + + VERIFY_BIG_REPRESENTATION( big_int56_t ); + VERIFY_VALUE_AND_OPS( big_int56_t, int_least64_t, 0x7fffffffffffffLL ); + VERIFY_VALUE_AND_OPS( big_int56_t, int_least64_t, -0x80000000000000LL ); + + VERIFY_BIG_REPRESENTATION( big_int64_t ); + VERIFY_VALUE_AND_OPS( big_int64_t, int_least64_t, 0x7fffffffffffffffLL ); + VERIFY_VALUE_AND_OPS( big_int64_t, int_least64_t, -0x7fffffffffffffffLL-1 ); + + VERIFY_BIG_REPRESENTATION( big_uint8_t ); + VERIFY_VALUE_AND_OPS( big_uint8_t, uint_least8_t, 0xff ); + + VERIFY_BIG_REPRESENTATION( big_uint16_t ); + VERIFY_VALUE_AND_OPS( big_uint16_t, uint_least16_t, 0xffff ); + + VERIFY_BIG_REPRESENTATION( big_uint24_t ); + VERIFY_VALUE_AND_OPS( big_uint24_t, uint_least32_t, 0xffffff ); + + VERIFY_BIG_REPRESENTATION( big_uint32_t ); + VERIFY_VALUE_AND_OPS( big_uint32_t, uint_least32_t, 0xffffffff ); + + VERIFY_BIG_REPRESENTATION( big_uint40_t ); + VERIFY_VALUE_AND_OPS( big_uint40_t, uint_least64_t, 0xffffffffffLL ); + + VERIFY_BIG_REPRESENTATION( big_uint48_t ); + VERIFY_VALUE_AND_OPS( big_uint48_t, uint_least64_t, 0xffffffffffffLL ); + + VERIFY_BIG_REPRESENTATION( big_uint56_t ); + VERIFY_VALUE_AND_OPS( big_uint56_t, uint_least64_t, 0xffffffffffffffLL ); + + VERIFY_BIG_REPRESENTATION( big_uint64_t ); + VERIFY_VALUE_AND_OPS( big_uint64_t, uint_least64_t, 0xffffffffffffffffULL ); + + VERIFY_LITTLE_REPRESENTATION( little_int8_t ); + VERIFY_VALUE_AND_OPS( little_int8_t, int_least8_t, 0x7f ); + VERIFY_VALUE_AND_OPS( little_int8_t, int_least8_t, -0x80 ); + + VERIFY_LITTLE_REPRESENTATION( little_int16_t ); + VERIFY_VALUE_AND_OPS( little_int16_t, int_least16_t, 0x7fff ); + VERIFY_VALUE_AND_OPS( little_int16_t, int_least16_t, -0x8000 ); + + VERIFY_LITTLE_REPRESENTATION( little_int24_t ); + VERIFY_VALUE_AND_OPS( little_int24_t, int_least32_t, 0x7fffff ); + VERIFY_VALUE_AND_OPS( little_int24_t, int_least32_t, -0x800000 ); + + VERIFY_LITTLE_REPRESENTATION( little_int32_t ); + VERIFY_VALUE_AND_OPS( little_int32_t, int_least32_t, 0x7fffffff ); + VERIFY_VALUE_AND_OPS( little_int32_t, int_least32_t, -0x7fffffff-1 ); + + VERIFY_LITTLE_REPRESENTATION( little_int40_t ); + VERIFY_VALUE_AND_OPS( little_int40_t, int_least64_t, 0x7fffffffffLL ); + VERIFY_VALUE_AND_OPS( little_int40_t, int_least64_t, -0x8000000000LL ); + + VERIFY_LITTLE_REPRESENTATION( little_int48_t ); + VERIFY_VALUE_AND_OPS( little_int48_t, int_least64_t, 0x7fffffffffffLL ); + VERIFY_VALUE_AND_OPS( little_int48_t, int_least64_t, -0x800000000000LL ); + + VERIFY_LITTLE_REPRESENTATION( little_int56_t ); + VERIFY_VALUE_AND_OPS( little_int56_t, int_least64_t, 0x7fffffffffffffLL ); + VERIFY_VALUE_AND_OPS( little_int56_t, int_least64_t, -0x80000000000000LL ); + + VERIFY_LITTLE_REPRESENTATION( little_int64_t ); + VERIFY_VALUE_AND_OPS( little_int64_t, int_least64_t, 0x7fffffffffffffffLL ); + VERIFY_VALUE_AND_OPS( little_int64_t, int_least64_t, -0x7fffffffffffffffLL-1 ); + + VERIFY_LITTLE_REPRESENTATION( little_uint8_t ); + VERIFY_VALUE_AND_OPS( little_uint8_t, uint_least8_t, 0xff ); + + VERIFY_LITTLE_REPRESENTATION( little_uint16_t ); + VERIFY_VALUE_AND_OPS( little_uint16_t, uint_least16_t, 0xffff ); + + VERIFY_LITTLE_REPRESENTATION( little_uint24_t ); + VERIFY_VALUE_AND_OPS( little_uint24_t, uint_least32_t, 0xffffff ); + + VERIFY_LITTLE_REPRESENTATION( little_uint32_t ); + VERIFY_VALUE_AND_OPS( little_uint32_t, uint_least32_t, 0xffffffff ); + + VERIFY_LITTLE_REPRESENTATION( little_uint40_t ); + VERIFY_VALUE_AND_OPS( little_uint40_t, uint_least64_t, 0xffffffffffLL ); + + VERIFY_LITTLE_REPRESENTATION( little_uint48_t ); + VERIFY_VALUE_AND_OPS( little_uint48_t, uint_least64_t, 0xffffffffffffLL ); + + VERIFY_LITTLE_REPRESENTATION( little_uint56_t ); + VERIFY_VALUE_AND_OPS( little_uint56_t, uint_least64_t, 0xffffffffffffffLL ); + + VERIFY_LITTLE_REPRESENTATION( little_uint64_t ); + VERIFY_VALUE_AND_OPS( little_uint64_t, uint_least64_t, 0xffffffffffffffffULL ); + + VERIFY_NATIVE_REPRESENTATION( native_int8_t ); + VERIFY_VALUE_AND_OPS( native_int8_t, int_least8_t, 0x7f ); + VERIFY_VALUE_AND_OPS( native_int8_t, int_least8_t, -0x80 ); + + VERIFY_NATIVE_REPRESENTATION( native_int16_t ); + VERIFY_VALUE_AND_OPS( native_int16_t, int_least16_t, 0x7fff ); + VERIFY_VALUE_AND_OPS( native_int16_t, int_least16_t, -0x8000 ); + + VERIFY_NATIVE_REPRESENTATION( native_int24_t ); + VERIFY_VALUE_AND_OPS( native_int24_t, int_least32_t, 0x7fffff ); + VERIFY_VALUE_AND_OPS( native_int24_t, int_least32_t, -0x800000 ); + + VERIFY_NATIVE_REPRESENTATION( native_int32_t ); + VERIFY_VALUE_AND_OPS( native_int32_t, int_least32_t, 0x7fffffff ); + VERIFY_VALUE_AND_OPS( native_int32_t, int_least32_t, -0x7fffffff-1 ); + + VERIFY_NATIVE_REPRESENTATION( native_int40_t ); + VERIFY_VALUE_AND_OPS( native_int40_t, int_least64_t, 0x7fffffffffLL ); + VERIFY_VALUE_AND_OPS( native_int40_t, int_least64_t, -0x8000000000LL ); + + VERIFY_NATIVE_REPRESENTATION( native_int48_t ); + VERIFY_VALUE_AND_OPS( native_int48_t, int_least64_t, 0x7fffffffffffLL ); + VERIFY_VALUE_AND_OPS( native_int48_t, int_least64_t, -0x800000000000LL ); + + VERIFY_NATIVE_REPRESENTATION( native_int56_t ); + VERIFY_VALUE_AND_OPS( native_int56_t, int_least64_t, 0x7fffffffffffffLL ); + VERIFY_VALUE_AND_OPS( native_int56_t, int_least64_t, -0x80000000000000LL ); + + VERIFY_NATIVE_REPRESENTATION( native_int64_t ); + VERIFY_VALUE_AND_OPS( native_int64_t, int_least64_t, 0x7fffffffffffffffLL ); + VERIFY_VALUE_AND_OPS( native_int64_t, int_least64_t, -0x7fffffffffffffffLL-1 ); + + VERIFY_NATIVE_REPRESENTATION( native_uint8_t ); + VERIFY_VALUE_AND_OPS( native_uint8_t, uint_least8_t, 0xff ); + + VERIFY_NATIVE_REPRESENTATION( native_uint16_t ); + VERIFY_VALUE_AND_OPS( native_uint16_t, uint_least16_t, 0xffff ); + + VERIFY_NATIVE_REPRESENTATION( native_uint24_t ); + VERIFY_VALUE_AND_OPS( native_uint24_t, uint_least32_t, 0xffffff ); + + VERIFY_NATIVE_REPRESENTATION( native_uint32_t ); + VERIFY_VALUE_AND_OPS( native_uint32_t, uint_least32_t, 0xffffffff ); + + VERIFY_NATIVE_REPRESENTATION( native_uint40_t ); + VERIFY_VALUE_AND_OPS( native_uint40_t, uint_least64_t, 0xffffffffffLL ); + + VERIFY_NATIVE_REPRESENTATION( native_uint48_t ); + VERIFY_VALUE_AND_OPS( native_uint48_t, uint_least64_t, 0xffffffffffffLL ); + + VERIFY_NATIVE_REPRESENTATION( native_uint56_t ); + VERIFY_VALUE_AND_OPS( native_uint56_t, uint_least64_t, 0xffffffffffffffLL ); + + VERIFY_NATIVE_REPRESENTATION( native_uint64_t ); + VERIFY_VALUE_AND_OPS( native_uint64_t, uint_least64_t, 0xffffffffffffffffULL ); + + // aligned integer types + VERIFY_BIG_REPRESENTATION( big_int16_at ); + VERIFY_VALUE_AND_OPS( big_int16_at, int_least16_t, 0x7fff ); + VERIFY_VALUE_AND_OPS( big_int16_at, int_least16_t, -0x8000 ); + + VERIFY_BIG_REPRESENTATION( big_int32_at ); + VERIFY_VALUE_AND_OPS( big_int32_at, int_least32_t, 0x7fffffff ); + VERIFY_VALUE_AND_OPS( big_int32_at, int_least32_t, -0x7fffffff-1 ); + + VERIFY_BIG_REPRESENTATION( big_int64_at ); + VERIFY_VALUE_AND_OPS( big_int64_at, int_least64_t, 0x7fffffffffffffffLL ); + VERIFY_VALUE_AND_OPS( big_int64_at, int_least64_t, -0x7fffffffffffffffLL-1 ); + + VERIFY_BIG_REPRESENTATION( big_uint16_at ); + VERIFY_VALUE_AND_OPS( big_uint16_at, uint_least16_t, 0xffff ); + + VERIFY_BIG_REPRESENTATION( big_uint32_at ); + VERIFY_VALUE_AND_OPS( big_uint32_at, uint_least32_t, 0xffffffff ); + + VERIFY_BIG_REPRESENTATION( big_uint64_at ); + VERIFY_VALUE_AND_OPS( big_uint64_at, uint_least64_t, 0xffffffffffffffffULL ); + + VERIFY_LITTLE_REPRESENTATION( little_int16_at ); + VERIFY_VALUE_AND_OPS( little_int16_at, int_least16_t, 0x7fff ); + VERIFY_VALUE_AND_OPS( little_int16_at, int_least16_t, -0x8000 ); + + VERIFY_LITTLE_REPRESENTATION( little_int32_at ); + VERIFY_VALUE_AND_OPS( little_int32_at, int_least32_t, 0x7fffffff ); + VERIFY_VALUE_AND_OPS( little_int32_at, int_least32_t, -0x7fffffff-1 ); + + VERIFY_LITTLE_REPRESENTATION( little_int64_at ); + VERIFY_VALUE_AND_OPS( little_int64_at, int_least64_t, 0x7fffffffffffffffLL ); + VERIFY_VALUE_AND_OPS( little_int64_at, int_least64_t, -0x7fffffffffffffffLL-1 ); + + VERIFY_LITTLE_REPRESENTATION( little_uint16_at ); + VERIFY_VALUE_AND_OPS( little_uint16_at, uint_least16_t, 0xffff ); + + VERIFY_LITTLE_REPRESENTATION( little_uint32_at ); + VERIFY_VALUE_AND_OPS( little_uint32_at, uint_least32_t, 0xffffffff ); + + VERIFY_LITTLE_REPRESENTATION( little_uint64_at ); + VERIFY_VALUE_AND_OPS( little_uint64_at, uint_least64_t, 0xffffffffffffffffULL ); + + } // check_representation_and_range + + class MyInt + { + int32_t mx; + public: + MyInt(int32_t x) : mx(x) {} + operator int32_t() const {return mx;} + + //friend int32_t operator+(const MyInt& x) {return x;} + }; + + void check_udt() + { + typedef boost::endian::endian_arithmetic< order::big, MyInt, 32 > mybig_int32_ut; + + mybig_int32_ut v(10); + cout << "+v is " << +v << endl; + v += 1; + cout << "v is " << +v << endl; + v -= 2; + cout << "v is " << +v << endl; + v *= 2; + cout << "v is " << +v << endl; + ++v; + cout << "v is " << +v << endl; + --v; + cout << "v is " << +v << endl; +// cout << "v+v is " << +(v+v) << endl; + } + + long iterations = 10000; + + template< class Endian > + Endian timing_test( const char * s) + { + cout << s << " timing test, " << iterations << " iterations: "; +// progress_timer t; + + Endian v = 1; + for ( long i = 0; i < iterations; ++i ) + { + v += 1; + v *= 3; + ++v; + v *= i; + if ( i == 0 ) VERIFY_VALUE_AND_OPS( Endian, typename Endian::value_type, 21 ); + } + return v; + } + +} // unnamed namespace + +// main ------------------------------------------------------------------------------// + +int cpp_main( int argc, char * argv[] ) +{ + cout << "Usage: " + << argv[0] << " [#],\n where # specifies iteration count\n" + " default iteration count is " << iterations << endl; + + if ( argc > 1 ) + iterations = atol( argv[1] ); + if ( iterations < 1 ) iterations = 1; + + detect_order(); + check_size(); + check_alignment(); + check_representation_and_range_and_ops(); + check_data(); + check_udt(); + + //timing_test<big_int32_t> ( "big_int32_t" ); + //timing_test<big_int32_at>( "big_int32_at" ); + //timing_test<little_int32_t> ( "little_int32_t" ); + //timing_test<little_int32_at>( "little_int32_at" ); + + cout << "\n" << err_count << " errors detected\nTest " + << (err_count==0 ? "passed\n\n" : "failed\n\n"); + + return err_count ? 1 : 0; +} // main |