external_libraries/boost_endian/libs/integer/test/endian_test.cpp

   1 //  endian_test.cpp  ---------------------------------------------------------//
   2
   3 //  Copyright Beman Dawes 1999-2008
   4
   5 //  Distributed under the Boost Software License, Version 1.0.
   6 //  See http://www.boost.org/LICENSE_1_0.txt
   7
   8 //  See library home page at http://www.boost.org/libs/endian
   9
  10 //----------------------------------------------------------------------------//
  11
  12 //  This test probes for correct endianess, size, and value.
  13
  14 //  See endian_operations_test for tests of operator correctness and interaction
  15 //  between operand types.
  16
  17 //----------------------------------------------------------------------------//
  18
  19 #include <boost/integer/endian.hpp>
  20 #include <boost/cstdint.hpp>
  21 #include <boost/progress.hpp>
  22
  23 #include <iostream>
  24 #include <limits>
  25 #include <climits>
  26 #include <cstdlib>    // for atoi(), exit()
  27 #include <cstring>    // for memcmp()
  28
  29 using namespace std;             // Not the best programming practice, but I
  30 using namespace boost;           //   want to verify this combination of using
  31 using namespace boost::integer;  //   namespaces works. See endian_operations_test
  32 //                               //   for tests that don't do "using namespace".
  33
  34 #define VERIFY(predicate) verify( predicate, __LINE__ )
  35 #define VERIFY_SIZE(actual, expected) verify_size( actual, expected, __LINE__ )
  36 #define VERIFY_VALUE_AND_OPS(endian_t,expected_t,expected) verify_value_and_ops<endian_t, expected_t>( expected, __LINE__ )
  37 #define VERIFY_BIG_REPRESENTATION(t) verify_representation<t>( true, __LINE__ )
  38 #define VERIFY_LITTLE_REPRESENTATION(t) verify_representation<t>( false, __LINE__ )
  39 #define VERIFY_NATIVE_REPRESENTATION(t) verify_native_representation<t>( __LINE__ )
  40
  41 namespace
  42 {
  43   int err_count;
  44
  45   void verify( bool x, int line )
  46   {
  47     if ( x ) return;
  48     ++err_count;
  49     cout << "Error: verify failed on line " << line << endl;
  50   }
  51
  52   void verify_size( size_t actual, size_t expected, int line )
  53   {
  54     if ( actual == expected ) return;
  55     ++err_count;
  56     cout << "Error: verify size failed on line " << line << endl;
  57     cout << " A structure with an expected sizeof() " << expected
  58          << " had an actual sizeof() " << actual
  59          << "\n This will cause common uses of <boost/endian.hpp> to fail\n";
  60   }
  61
  62   template <class Endian, class Base>
  63   void verify_value_and_ops( const Base & expected, int line )
  64   {
  65     Endian v( expected );
  66     verify( v == expected, line );
  67
  68     Endian v2;
  69     v2.operator=( expected );
  70     verify( v2 == expected, line );
  71
  72     ++v; // verify integer_cover_operators being applied to this type -
  73          // will fail to compile if no endian<> specialization is present
  74   }
  75
  76   const char * big_rep    = "\x12\x34\x56\x78\x9A\xBC\xDE\xF0";
  77   const char * little_rep = "\xF0\xDE\xBC\x9A\x78\x56\x34\x12";
  78
  79   template <class Endian>
  80   void verify_representation( bool is_big, int line )
  81   {
  82     int silence = 0;
  83     Endian x ( static_cast<typename Endian::value_type>
  84       (0x123456789abcdef0LL + silence) ); // will truncate
  85
  86     if ( is_big )
  87       verify( memcmp( &x,
  88         reinterpret_cast<const char*>(big_rep)+8-sizeof(Endian),
  89           sizeof(Endian) ) == 0, line );
  90     else
  91       verify( memcmp( &x, little_rep, sizeof(Endian) ) == 0, line );
  92   }
  93
  94   template <class Endian>
  95   inline void verify_native_representation( int line )
  96   {
  97 #   ifdef BOOST_BIG_ENDIAN
  98       verify_representation<Endian>( true, line );
  99 #   else
 100       verify_representation<Endian>( false, line );
 101 #   endif
 102   }
 103
 104   //  detect_endianness  -----------------------------------------------------//
 105
 106   void detect_endianness()
 107   {
 108     union View
 109     {
 110       long long i;
 111       unsigned char c[8];
 112     };
 113
 114     View v = { 0x0102030405060708LL };  // initialize v.i
 115
 116     if ( memcmp( v.c, "\10\7\6\5\4\3\2\1", 8) == 0 )
 117     {
 118       cout << "This machine is little-endian.\n";
 119   #   ifdef BOOST_BIG_INTEGER_OPERATORS
 120         cout << "yet boost/detail/endian.hpp defines BOOST_BIG_INTEGER_OPERATORS.\n"
 121           "You must fix boost/detail/endian.hpp for boost/endian.hpp to work correctly.\n"
 122           "Please report the fix to the Boost mailing list.\n";
 123         exit(1);
 124   #   endif
 125     }
 126     else if ( memcmp( v.c, "\1\2\3\4\5\6\7\10", 8) == 0 )
 127     {
 128       cout << "This machine is big-endian.\n";
 129   #   ifdef BOOST_LITTLE_INTEGER_OPERATORS
 130         cout << "yet boost/detail/endian.hpp defines BOOST__LITTLE_INTEGER_OPERATORS.\n"
 131           "You must fix boost/detail/endian.hpp for boost/endian.hpp to work correctly.\n"
 132           "Please report the fix to the Boost mailing list.\n";
 133         exit(1);
 134   #   endif
 135     }
 136     else
 137     {
 138       cout << "This machine is neither strict big-endian nor strict little-endian\n"
 139         "You must modify boost/endian.hpp for it to work correctly.\n";
 140       exit(1);
 141     }
 142     cout << "That should not matter and is presented for your information only.\n";
 143   } // detect_endianness
 144
 145   //  check_size  ------------------------------------------------------------//
 146
 147   void check_size()
 148   {
 149     VERIFY( numeric_limits<signed char>::digits == 7 );
 150     VERIFY( numeric_limits<unsigned char>::digits == 8 );
 151
 152     VERIFY_SIZE( sizeof( big8_t ), 1 );
 153     VERIFY_SIZE( sizeof( big16_t ), 2 );
 154     VERIFY_SIZE( sizeof( big24_t ), 3 );
 155     VERIFY_SIZE( sizeof( big32_t ), 4 );
 156     VERIFY_SIZE( sizeof( big40_t ), 5 );
 157     VERIFY_SIZE( sizeof( big48_t ), 6 );
 158     VERIFY_SIZE( sizeof( big56_t ), 7 );
 159     VERIFY_SIZE( sizeof( big64_t ), 8 );
 160
 161     VERIFY_SIZE( sizeof( ubig8_t ), 1 );
 162     VERIFY_SIZE( sizeof( ubig16_t ), 2 );
 163     VERIFY_SIZE( sizeof( ubig24_t ), 3 );
 164     VERIFY_SIZE( sizeof( ubig32_t ), 4 );
 165     VERIFY_SIZE( sizeof( ubig40_t ), 5 );
 166     VERIFY_SIZE( sizeof( ubig48_t ), 6 );
 167     VERIFY_SIZE( sizeof( ubig56_t ), 7 );
 168     VERIFY_SIZE( sizeof( ubig64_t ), 8 );
 169
 170     VERIFY_SIZE( sizeof( little8_t ), 1 );
 171     VERIFY_SIZE( sizeof( little16_t ), 2 );
 172     VERIFY_SIZE( sizeof( little24_t ), 3 );
 173     VERIFY_SIZE( sizeof( little32_t ), 4 );
 174     VERIFY_SIZE( sizeof( little40_t ), 5 );
 175     VERIFY_SIZE( sizeof( little48_t ), 6 );
 176     VERIFY_SIZE( sizeof( little56_t ), 7 );
 177     VERIFY_SIZE( sizeof( little64_t ), 8 );
 178
 179     VERIFY_SIZE( sizeof( ulittle8_t ), 1 );
 180     VERIFY_SIZE( sizeof( ulittle16_t ), 2 );
 181     VERIFY_SIZE( sizeof( ulittle24_t ), 3 );
 182     VERIFY_SIZE( sizeof( ulittle32_t ), 4 );
 183     VERIFY_SIZE( sizeof( ulittle40_t ), 5 );
 184     VERIFY_SIZE( sizeof( ulittle48_t ), 6 );
 185     VERIFY_SIZE( sizeof( ulittle56_t ), 7 );
 186     VERIFY_SIZE( sizeof( ulittle64_t ), 8 );
 187
 188     VERIFY_SIZE( sizeof( native8_t ), 1 );
 189     VERIFY_SIZE( sizeof( native16_t ), 2 );
 190     VERIFY_SIZE( sizeof( native24_t ), 3 );
 191     VERIFY_SIZE( sizeof( native32_t ), 4 );
 192     VERIFY_SIZE( sizeof( native40_t ), 5 );
 193     VERIFY_SIZE( sizeof( native48_t ), 6 );
 194     VERIFY_SIZE( sizeof( native56_t ), 7 );
 195     VERIFY_SIZE( sizeof( native64_t ), 8 );
 196
 197     VERIFY_SIZE( sizeof( unative8_t ), 1 );
 198     VERIFY_SIZE( sizeof( unative16_t ), 2 );
 199     VERIFY_SIZE( sizeof( unative24_t ), 3 );
 200     VERIFY_SIZE( sizeof( unative32_t ), 4 );
 201     VERIFY_SIZE( sizeof( unative40_t ), 5 );
 202     VERIFY_SIZE( sizeof( unative48_t ), 6 );
 203     VERIFY_SIZE( sizeof( unative56_t ), 7 );
 204     VERIFY_SIZE( sizeof( unative64_t ), 8 );
 205
 206     VERIFY_SIZE( sizeof( aligned_big16_t ), 2 );
 207     VERIFY_SIZE( sizeof( aligned_big32_t ), 4 );
 208     VERIFY_SIZE( sizeof( aligned_big64_t ), 8 );
 209
 210     VERIFY_SIZE( sizeof( aligned_ubig16_t ), 2 );
 211     VERIFY_SIZE( sizeof( aligned_ubig32_t ), 4 );
 212     VERIFY_SIZE( sizeof( aligned_ubig64_t ), 8 );
 213
 214     VERIFY_SIZE( sizeof( aligned_little16_t ), 2 );
 215     VERIFY_SIZE( sizeof( aligned_little32_t ), 4 );
 216     VERIFY_SIZE( sizeof( aligned_little64_t ), 8 );
 217
 218     VERIFY_SIZE( sizeof( aligned_ulittle16_t ), 2 );
 219     VERIFY_SIZE( sizeof( aligned_ulittle32_t ), 4 );
 220     VERIFY_SIZE( sizeof( aligned_ulittle64_t ), 8 );
 221   } // check_size
 222
 223   //  check_alignment  -------------------------------------------------------//
 224
 225   void check_alignment()
 226   {
 227     // structs with offsets % 2 == 1 for type of size > 1 to ensure no alignment
 228     // bytes added for any size > 1
 229
 230     struct big_struct
 231     {
 232       big8_t    v0;
 233       big16_t    v1;
 234       big24_t    v3;
 235       char      v6;
 236       big32_t    v7;
 237       big40_t    v11;
 238       char      v16;
 239       big48_t    v17;
 240       big56_t    v23;
 241       char      v30;
 242       big64_t    v31;
 243     };
 244
 245     struct ubig_struct
 246     {
 247       ubig8_t    v0;
 248       ubig16_t    v1;
 249       ubig24_t    v3;
 250       char       v6;
 251       ubig32_t    v7;
 252       ubig40_t    v11;
 253       char       v16;
 254       ubig48_t    v17;
 255       ubig56_t    v23;
 256       char       v30;
 257       ubig64_t    v31;
 258     };
 259
 260     struct little_struct
 261     {
 262       little8_t    v0;
 263       little16_t    v1;
 264       little24_t    v3;
 265       char         v6;
 266       little32_t    v7;
 267       little40_t    v11;
 268       char         v16;
 269       little48_t    v17;
 270       little56_t    v23;
 271       char         v30;
 272       little64_t    v31;
 273     };
 274
 275     struct ulittle_struct
 276     {
 277       ulittle8_t    v0;
 278       ulittle16_t    v1;
 279       ulittle24_t    v3;
 280       char          v6;
 281       ulittle32_t    v7;
 282       ulittle40_t    v11;
 283       char          v16;
 284       ulittle48_t    v17;
 285       ulittle56_t    v23;
 286       char          v30;
 287       ulittle64_t    v31;
 288     };
 289
 290     struct native_struct
 291     {
 292       native8_t    v0;
 293       native16_t    v1;
 294       native24_t    v3;
 295       char         v6;
 296       native32_t    v7;
 297       native40_t    v11;
 298       char         v16;
 299       native48_t    v17;
 300       native56_t    v23;
 301       char         v30;
 302       native64_t    v31;
 303     };
 304
 305     struct unative_struct
 306     {
 307       unative8_t    v0;
 308       unative16_t    v1;
 309       unative24_t    v3;
 310       char          v6;
 311       unative32_t    v7;
 312       unative40_t    v11;
 313       char          v16;
 314       unative48_t    v17;
 315       unative56_t    v23;
 316       char          v30;
 317       unative64_t    v31;
 318     };
 319
 320     int saved_err_count = err_count;
 321
 322     VERIFY_SIZE( sizeof(big_struct), 39 );
 323     VERIFY_SIZE( sizeof(ubig_struct), 39 );
 324     VERIFY_SIZE( sizeof(little_struct), 39 );
 325     VERIFY_SIZE( sizeof(ulittle_struct), 39 );
 326     VERIFY_SIZE( sizeof(native_struct), 39 );
 327     VERIFY_SIZE( sizeof(unative_struct), 39 );
 328
 329     if ( saved_err_count == err_count )
 330     {
 331       cout <<
 332         "Size and alignment for structures of endian types are as expected.\n";
 333     }
 334   } // check_alignment
 335
 336   //  check_representation_and_range_and_ops  --------------------------------//
 337
 338   void check_representation_and_range_and_ops()
 339   {
 340
 341     VERIFY_BIG_REPRESENTATION( big8_t );
 342     VERIFY_VALUE_AND_OPS( big8_t, int_least8_t,  0x7f );
 343     VERIFY_VALUE_AND_OPS( big8_t, int_least8_t, -0x80 );
 344
 345     VERIFY_BIG_REPRESENTATION( big16_t );
 346     VERIFY_VALUE_AND_OPS( big16_t, int_least16_t,  0x7fff );
 347     VERIFY_VALUE_AND_OPS( big16_t, int_least16_t, -0x8000 );
 348
 349     VERIFY_BIG_REPRESENTATION( big24_t );
 350     VERIFY_VALUE_AND_OPS( big24_t, int_least32_t,  0x7fffff );
 351     VERIFY_VALUE_AND_OPS( big24_t, int_least32_t, -0x800000 );
 352
 353     VERIFY_BIG_REPRESENTATION( big32_t );
 354     VERIFY_VALUE_AND_OPS( big32_t, int_least32_t,  0x7fffffff );
 355     VERIFY_VALUE_AND_OPS( big32_t, int_least32_t, -0x7fffffff-1 );
 356
 357     VERIFY_BIG_REPRESENTATION( big40_t );
 358     VERIFY_VALUE_AND_OPS( big40_t, int_least64_t,  0x7fffffffffLL );
 359     VERIFY_VALUE_AND_OPS( big40_t, int_least64_t, -0x8000000000LL );
 360
 361     VERIFY_BIG_REPRESENTATION( big48_t );
 362     VERIFY_VALUE_AND_OPS( big48_t, int_least64_t,  0x7fffffffffffLL );
 363     VERIFY_VALUE_AND_OPS( big48_t, int_least64_t, -0x800000000000LL );
 364
 365     VERIFY_BIG_REPRESENTATION( big56_t );
 366     VERIFY_VALUE_AND_OPS( big56_t, int_least64_t,  0x7fffffffffffffLL );
 367     VERIFY_VALUE_AND_OPS( big56_t, int_least64_t, -0x80000000000000LL );
 368
 369     VERIFY_BIG_REPRESENTATION( big64_t );
 370     VERIFY_VALUE_AND_OPS( big64_t, int_least64_t,  0x7fffffffffffffffLL );
 371     VERIFY_VALUE_AND_OPS( big64_t, int_least64_t, -0x7fffffffffffffffLL-1 );
 372
 373     VERIFY_BIG_REPRESENTATION( ubig8_t );
 374     VERIFY_VALUE_AND_OPS( ubig8_t, uint_least8_t,  0xff );
 375
 376     VERIFY_BIG_REPRESENTATION( ubig16_t );
 377     VERIFY_VALUE_AND_OPS( ubig16_t, uint_least16_t, 0xffff );
 378
 379     VERIFY_BIG_REPRESENTATION( ubig24_t );
 380     VERIFY_VALUE_AND_OPS( ubig24_t, uint_least32_t, 0xffffff );
 381
 382     VERIFY_BIG_REPRESENTATION( ubig32_t );
 383     VERIFY_VALUE_AND_OPS( ubig32_t, uint_least32_t, 0xffffffff );
 384
 385     VERIFY_BIG_REPRESENTATION( ubig40_t );
 386     VERIFY_VALUE_AND_OPS( ubig40_t, uint_least64_t, 0xffffffffffLL );
 387
 388     VERIFY_BIG_REPRESENTATION( ubig48_t );
 389     VERIFY_VALUE_AND_OPS( ubig48_t, uint_least64_t, 0xffffffffffffLL );
 390
 391     VERIFY_BIG_REPRESENTATION( ubig56_t );
 392     VERIFY_VALUE_AND_OPS( ubig56_t, uint_least64_t, 0xffffffffffffffLL );
 393
 394     VERIFY_BIG_REPRESENTATION( ubig64_t );
 395     VERIFY_VALUE_AND_OPS( ubig64_t, uint_least64_t, 0xffffffffffffffffLL );
 396
 397     VERIFY_LITTLE_REPRESENTATION( little8_t );
 398     VERIFY_VALUE_AND_OPS( little8_t, int_least8_t,   0x7f );
 399     VERIFY_VALUE_AND_OPS( little8_t, int_least8_t,  -0x80 );
 400
 401     VERIFY_LITTLE_REPRESENTATION( little16_t );
 402     VERIFY_VALUE_AND_OPS( little16_t, int_least16_t,  0x7fff );
 403     VERIFY_VALUE_AND_OPS( little16_t, int_least16_t, -0x8000 );
 404
 405     VERIFY_LITTLE_REPRESENTATION( little24_t );
 406     VERIFY_VALUE_AND_OPS( little24_t, int_least32_t,  0x7fffff );
 407     VERIFY_VALUE_AND_OPS( little24_t, int_least32_t, -0x800000 );
 408
 409     VERIFY_LITTLE_REPRESENTATION( little32_t );
 410     VERIFY_VALUE_AND_OPS( little32_t, int_least32_t,  0x7fffffff );
 411     VERIFY_VALUE_AND_OPS( little32_t, int_least32_t, -0x7fffffff-1 );
 412
 413     VERIFY_LITTLE_REPRESENTATION( little40_t );
 414     VERIFY_VALUE_AND_OPS( little40_t, int_least64_t,  0x7fffffffffLL );
 415     VERIFY_VALUE_AND_OPS( little40_t, int_least64_t, -0x8000000000LL );
 416
 417     VERIFY_LITTLE_REPRESENTATION( little48_t );
 418     VERIFY_VALUE_AND_OPS( little48_t, int_least64_t,  0x7fffffffffffLL );
 419     VERIFY_VALUE_AND_OPS( little48_t, int_least64_t, -0x800000000000LL );
 420
 421     VERIFY_LITTLE_REPRESENTATION( little56_t );
 422     VERIFY_VALUE_AND_OPS( little56_t, int_least64_t,  0x7fffffffffffffLL );
 423     VERIFY_VALUE_AND_OPS( little56_t, int_least64_t, -0x80000000000000LL );
 424
 425     VERIFY_LITTLE_REPRESENTATION( little64_t );
 426     VERIFY_VALUE_AND_OPS( little64_t, int_least64_t,  0x7fffffffffffffffLL );
 427     VERIFY_VALUE_AND_OPS( little64_t, int_least64_t, -0x7fffffffffffffffLL-1 );
 428
 429     VERIFY_LITTLE_REPRESENTATION( ulittle8_t );
 430     VERIFY_VALUE_AND_OPS( ulittle8_t, uint_least8_t, 0xff );
 431
 432     VERIFY_LITTLE_REPRESENTATION( ulittle16_t );
 433     VERIFY_VALUE_AND_OPS( ulittle16_t, uint_least16_t, 0xffff );
 434
 435     VERIFY_LITTLE_REPRESENTATION( ulittle24_t );
 436     VERIFY_VALUE_AND_OPS( ulittle24_t, uint_least32_t, 0xffffff );
 437
 438     VERIFY_LITTLE_REPRESENTATION( ulittle32_t );
 439     VERIFY_VALUE_AND_OPS( ulittle32_t, uint_least32_t, 0xffffffff );
 440
 441     VERIFY_LITTLE_REPRESENTATION( ulittle40_t );
 442     VERIFY_VALUE_AND_OPS( ulittle40_t, uint_least64_t, 0xffffffffffLL );
 443
 444     VERIFY_LITTLE_REPRESENTATION( ulittle48_t );
 445     VERIFY_VALUE_AND_OPS( ulittle48_t, uint_least64_t, 0xffffffffffffLL );
 446
 447     VERIFY_LITTLE_REPRESENTATION( ulittle56_t );
 448     VERIFY_VALUE_AND_OPS( ulittle56_t, uint_least64_t, 0xffffffffffffffLL );
 449
 450     VERIFY_LITTLE_REPRESENTATION( ulittle64_t );
 451     VERIFY_VALUE_AND_OPS( ulittle64_t, uint_least64_t, 0xffffffffffffffffLL );
 452
 453     VERIFY_NATIVE_REPRESENTATION( native8_t );
 454     VERIFY_VALUE_AND_OPS( native8_t, int_least8_t,   0x7f );
 455     VERIFY_VALUE_AND_OPS( native8_t, int_least8_t,  -0x80 );
 456
 457     VERIFY_NATIVE_REPRESENTATION( native16_t );
 458     VERIFY_VALUE_AND_OPS( native16_t, int_least16_t,  0x7fff );
 459     VERIFY_VALUE_AND_OPS( native16_t, int_least16_t, -0x8000 );
 460
 461     VERIFY_NATIVE_REPRESENTATION( native24_t );
 462     VERIFY_VALUE_AND_OPS( native24_t, int_least32_t,  0x7fffff );
 463     VERIFY_VALUE_AND_OPS( native24_t, int_least32_t, -0x800000 );
 464
 465     VERIFY_NATIVE_REPRESENTATION( native32_t );
 466     VERIFY_VALUE_AND_OPS( native32_t, int_least32_t,  0x7fffffff );
 467     VERIFY_VALUE_AND_OPS( native32_t, int_least32_t, -0x7fffffff-1 );
 468
 469     VERIFY_NATIVE_REPRESENTATION( native40_t );
 470     VERIFY_VALUE_AND_OPS( native40_t, int_least64_t,  0x7fffffffffLL );
 471     VERIFY_VALUE_AND_OPS( native40_t, int_least64_t, -0x8000000000LL );
 472
 473     VERIFY_NATIVE_REPRESENTATION( native48_t );
 474     VERIFY_VALUE_AND_OPS( native48_t, int_least64_t,  0x7fffffffffffLL );
 475     VERIFY_VALUE_AND_OPS( native48_t, int_least64_t, -0x800000000000LL );
 476
 477     VERIFY_NATIVE_REPRESENTATION( native56_t );
 478     VERIFY_VALUE_AND_OPS( native56_t, int_least64_t,  0x7fffffffffffffLL );
 479     VERIFY_VALUE_AND_OPS( native56_t, int_least64_t, -0x80000000000000LL );
 480
 481     VERIFY_NATIVE_REPRESENTATION( native64_t );
 482     VERIFY_VALUE_AND_OPS( native64_t, int_least64_t,  0x7fffffffffffffffLL );
 483     VERIFY_VALUE_AND_OPS( native64_t, int_least64_t, -0x7fffffffffffffffLL-1 );
 484
 485     VERIFY_NATIVE_REPRESENTATION( unative8_t );
 486     VERIFY_VALUE_AND_OPS( unative8_t, uint_least8_t, 0xff );
 487
 488     VERIFY_NATIVE_REPRESENTATION( unative16_t );
 489     VERIFY_VALUE_AND_OPS( unative16_t, uint_least16_t, 0xffff );
 490
 491     VERIFY_NATIVE_REPRESENTATION( unative24_t );
 492     VERIFY_VALUE_AND_OPS( unative24_t, uint_least32_t, 0xffffff );
 493
 494     VERIFY_NATIVE_REPRESENTATION( unative32_t );
 495     VERIFY_VALUE_AND_OPS( unative32_t, uint_least32_t, 0xffffffff );
 496
 497     VERIFY_NATIVE_REPRESENTATION( unative40_t );
 498     VERIFY_VALUE_AND_OPS( unative40_t, uint_least64_t, 0xffffffffffLL );
 499
 500     VERIFY_NATIVE_REPRESENTATION( unative48_t );
 501     VERIFY_VALUE_AND_OPS( unative48_t, uint_least64_t, 0xffffffffffffLL );
 502
 503     VERIFY_NATIVE_REPRESENTATION( unative56_t );
 504     VERIFY_VALUE_AND_OPS( unative56_t, uint_least64_t, 0xffffffffffffffLL );
 505
 506     VERIFY_NATIVE_REPRESENTATION( unative64_t );
 507     VERIFY_VALUE_AND_OPS( unative64_t, uint_least64_t, 0xffffffffffffffffLL );
 508
 509     VERIFY_BIG_REPRESENTATION( aligned_big16_t );
 510     VERIFY_VALUE_AND_OPS( aligned_big16_t, int_least16_t,  0x7fff );
 511     VERIFY_VALUE_AND_OPS( aligned_big16_t, int_least16_t, -0x8000 );
 512
 513     VERIFY_BIG_REPRESENTATION( aligned_big32_t );
 514     VERIFY_VALUE_AND_OPS( aligned_big32_t, int_least32_t,  0x7fffffff );
 515     VERIFY_VALUE_AND_OPS( aligned_big32_t, int_least32_t, -0x7fffffff-1 );
 516
 517     VERIFY_BIG_REPRESENTATION( aligned_big64_t );
 518     VERIFY_VALUE_AND_OPS( aligned_big64_t, int_least64_t,  0x7fffffffffffffffLL );
 519     VERIFY_VALUE_AND_OPS( aligned_big64_t, int_least64_t, -0x7fffffffffffffffLL-1 );
 520
 521     VERIFY_BIG_REPRESENTATION( aligned_ubig16_t );
 522     VERIFY_VALUE_AND_OPS( aligned_ubig16_t, uint_least16_t, 0xffff );
 523
 524     VERIFY_BIG_REPRESENTATION( aligned_ubig32_t );
 525     VERIFY_VALUE_AND_OPS( aligned_ubig32_t, uint_least32_t, 0xffffffff );
 526
 527     VERIFY_BIG_REPRESENTATION( aligned_ubig64_t );
 528     VERIFY_VALUE_AND_OPS( aligned_ubig64_t, uint_least64_t, 0xffffffffffffffffLL );
 529
 530     VERIFY_LITTLE_REPRESENTATION( aligned_little16_t );
 531     VERIFY_VALUE_AND_OPS( aligned_little16_t, int_least16_t,  0x7fff );
 532     VERIFY_VALUE_AND_OPS( aligned_little16_t, int_least16_t, -0x8000 );
 533
 534     VERIFY_LITTLE_REPRESENTATION( aligned_little32_t );
 535     VERIFY_VALUE_AND_OPS( aligned_little32_t, int_least32_t,  0x7fffffff );
 536     VERIFY_VALUE_AND_OPS( aligned_little32_t, int_least32_t, -0x7fffffff-1 );
 537
 538     VERIFY_LITTLE_REPRESENTATION( aligned_little64_t );
 539     VERIFY_VALUE_AND_OPS( aligned_little64_t, int_least64_t,  0x7fffffffffffffffLL );
 540     VERIFY_VALUE_AND_OPS( aligned_little64_t, int_least64_t, -0x7fffffffffffffffLL-1 );
 541
 542     VERIFY_LITTLE_REPRESENTATION( aligned_ulittle16_t );
 543     VERIFY_VALUE_AND_OPS( aligned_ulittle16_t, uint_least16_t, 0xffff );
 544
 545     VERIFY_LITTLE_REPRESENTATION( aligned_ulittle32_t );
 546     VERIFY_VALUE_AND_OPS( aligned_ulittle32_t, uint_least32_t, 0xffffffff );
 547
 548     VERIFY_LITTLE_REPRESENTATION( aligned_ulittle64_t );
 549     VERIFY_VALUE_AND_OPS( aligned_ulittle64_t, uint_least64_t, 0xffffffffffffffffLL );
 550
 551   } // check_representation_and_range
 552
 553   long iterations = 10000000;
 554
 555   template< class Endian >
 556   Endian timing_test( const char * s)
 557   {
 558     cout << s << " timing test, " << iterations << " iterations: ";
 559     progress_timer t;
 560
 561     Endian v = 1;
 562     for ( long i = 0; i < iterations; ++i )
 563     {
 564       v += 1;
 565       v *= 3;
 566       ++v;
 567       v *= i;
 568       if ( i == 0 ) VERIFY_VALUE_AND_OPS( Endian, typename Endian::value_type, 21 );
 569     }
 570     return v;
 571   }
 572
 573 } // unnamed namespace
 574
 575 int main( int argc, char * argv[] )
 576 {
 577   cout << "Usage: "
 578        << argv[0] << " [#],\n where # specifies iteration count\n"
 579           " default iteration count is 1000000" << endl;
 580
 581   if ( argc > 1 )
 582     iterations = atol( argv[1] );
 583   if ( iterations < 1 ) iterations = 1;
 584
 585   detect_endianness();
 586   check_size();
 587   check_alignment();
 588   check_representation_and_range_and_ops();
 589
 590   //timing_test<big32_t> ( "big32_t" );
 591   //timing_test<aligned_big32_t>( "aligned_big32_t" );
 592   //timing_test<little32_t> ( "little32_t" );
 593   //timing_test<aligned_little32_t>( "aligned_little32_t" );
 594
 595   cout << "\n" << err_count << " errors detected\nTest "
 596        << (err_count==0 ? "passed\n\n" : "failed\n\n");
 597
 598   return err_count ? 1 : 0;
 599 } // main