libs/endian/test/buffer_test.cpp

   1 //  buffer_test.cpp  -------------------------------------------------------------------//
   2
   3 //  Copyright Beman Dawes 2014
   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 #include <boost/endian/detail/disable_warnings.hpp>
  13
  14 #include <boost/endian/buffers.hpp>
  15 #include <boost/detail/lightweight_main.hpp>
  16 #include <boost/core/lightweight_test.hpp>
  17 #include <boost/cstdint.hpp>
  18 #include <iostream>
  19 #include <sstream>
  20 #include <limits>
  21
  22 using namespace boost::endian;
  23 using std::cout;
  24 using std::endl;
  25
  26 namespace
  27 {
  28
  29   //  check_size  ------------------------------------------------------------//
  30
  31   void check_size()
  32   {
  33
  34     BOOST_TEST_EQ(sizeof(big_int8_buf_t), 1u);
  35     BOOST_TEST_EQ(sizeof(big_int16_buf_t), 2u);
  36     BOOST_TEST_EQ(sizeof(big_int24_buf_t), 3u);
  37     BOOST_TEST_EQ(sizeof(big_int32_buf_t), 4u);
  38     BOOST_TEST_EQ(sizeof(big_int40_buf_t), 5u);
  39     BOOST_TEST_EQ(sizeof(big_int48_buf_t), 6u);
  40     BOOST_TEST_EQ(sizeof(big_int56_buf_t), 7u);
  41     BOOST_TEST_EQ(sizeof(big_int64_buf_t), 8u);
  42
  43     BOOST_TEST_EQ(sizeof(big_uint8_buf_t), 1u);
  44     BOOST_TEST_EQ(sizeof(big_uint16_buf_t), 2u);
  45     BOOST_TEST_EQ(sizeof(big_uint24_buf_t), 3u);
  46     BOOST_TEST_EQ(sizeof(big_uint32_buf_t), 4u);
  47     BOOST_TEST_EQ(sizeof(big_uint40_buf_t), 5u);
  48     BOOST_TEST_EQ(sizeof(big_uint48_buf_t), 6u);
  49     BOOST_TEST_EQ(sizeof(big_uint56_buf_t), 7u);
  50     BOOST_TEST_EQ(sizeof(big_uint64_buf_t), 8u);
  51
  52     BOOST_TEST_EQ(sizeof(big_float32_buf_t), 4u);
  53     BOOST_TEST_EQ(sizeof(big_float64_buf_t), 8u);
  54
  55     BOOST_TEST_EQ(sizeof(little_int8_buf_t), 1u);
  56     BOOST_TEST_EQ(sizeof(little_int16_buf_t), 2u);
  57     BOOST_TEST_EQ(sizeof(little_int24_buf_t), 3u);
  58     BOOST_TEST_EQ(sizeof(little_int32_buf_t), 4u);
  59     BOOST_TEST_EQ(sizeof(little_int40_buf_t), 5u);
  60     BOOST_TEST_EQ(sizeof(little_int48_buf_t), 6u);
  61     BOOST_TEST_EQ(sizeof(little_int56_buf_t), 7u);
  62     BOOST_TEST_EQ(sizeof(little_int64_buf_t), 8u);
  63
  64     BOOST_TEST_EQ(sizeof(little_uint8_buf_t), 1u);
  65     BOOST_TEST_EQ(sizeof(little_uint16_buf_t), 2u);
  66     BOOST_TEST_EQ(sizeof(little_uint24_buf_t), 3u);
  67     BOOST_TEST_EQ(sizeof(little_uint32_buf_t), 4u);
  68     BOOST_TEST_EQ(sizeof(little_uint40_buf_t), 5u);
  69     BOOST_TEST_EQ(sizeof(little_uint48_buf_t), 6u);
  70     BOOST_TEST_EQ(sizeof(little_uint56_buf_t), 7u);
  71     BOOST_TEST_EQ(sizeof(little_uint64_buf_t), 8u);
  72
  73     BOOST_TEST_EQ(sizeof(little_float32_buf_t), 4u);
  74     BOOST_TEST_EQ(sizeof(little_float64_buf_t), 8u);
  75
  76     BOOST_TEST_EQ(sizeof(native_int8_buf_t), 1u);
  77     BOOST_TEST_EQ(sizeof(native_int16_buf_t), 2u);
  78     BOOST_TEST_EQ(sizeof(native_int24_buf_t), 3u);
  79     BOOST_TEST_EQ(sizeof(native_int32_buf_t), 4u);
  80     BOOST_TEST_EQ(sizeof(native_int40_buf_t), 5u);
  81     BOOST_TEST_EQ(sizeof(native_int48_buf_t), 6u);
  82     BOOST_TEST_EQ(sizeof(native_int56_buf_t), 7u);
  83     BOOST_TEST_EQ(sizeof(native_int64_buf_t), 8u);
  84
  85     BOOST_TEST_EQ(sizeof(native_uint8_buf_t), 1u);
  86     BOOST_TEST_EQ(sizeof(native_uint16_buf_t), 2u);
  87     BOOST_TEST_EQ(sizeof(native_uint24_buf_t), 3u);
  88     BOOST_TEST_EQ(sizeof(native_uint32_buf_t), 4u);
  89     BOOST_TEST_EQ(sizeof(native_uint40_buf_t), 5u);
  90     BOOST_TEST_EQ(sizeof(native_uint48_buf_t), 6u);
  91     BOOST_TEST_EQ(sizeof(native_uint56_buf_t), 7u);
  92     BOOST_TEST_EQ(sizeof(native_uint64_buf_t), 8u);
  93
  94     BOOST_TEST_EQ(sizeof(native_float32_buf_t), 4u);
  95     BOOST_TEST_EQ(sizeof(native_float64_buf_t), 8u);
  96
  97     BOOST_TEST_EQ(sizeof(big_int8_buf_at), 1u);
  98     BOOST_TEST_EQ(sizeof(big_int16_buf_at), 2u);
  99     BOOST_TEST_EQ(sizeof(big_int32_buf_at), 4u);
 100     BOOST_TEST_EQ(sizeof(big_int64_buf_at), 8u);
 101
 102     BOOST_TEST_EQ(sizeof(big_uint8_buf_at), 1u);
 103     BOOST_TEST_EQ(sizeof(big_uint16_buf_at), 2u);
 104     BOOST_TEST_EQ(sizeof(big_uint32_buf_at), 4u);
 105     BOOST_TEST_EQ(sizeof(big_uint64_buf_at), 8u);
 106
 107     BOOST_TEST_EQ(sizeof(big_float32_buf_at), 4u);
 108     BOOST_TEST_EQ(sizeof(big_float64_buf_at), 8u);
 109
 110     BOOST_TEST_EQ(sizeof(little_int8_buf_at), 1u);
 111     BOOST_TEST_EQ(sizeof(little_int16_buf_at), 2u);
 112     BOOST_TEST_EQ(sizeof(little_int32_buf_at), 4u);
 113     BOOST_TEST_EQ(sizeof(little_int64_buf_at), 8u);
 114
 115     BOOST_TEST_EQ(sizeof(little_uint8_buf_at), 1u);
 116     BOOST_TEST_EQ(sizeof(little_uint16_buf_at), 2u);
 117     BOOST_TEST_EQ(sizeof(little_uint32_buf_at), 4u);
 118     BOOST_TEST_EQ(sizeof(little_uint64_buf_at), 8u);
 119
 120     BOOST_TEST_EQ(sizeof(little_float32_buf_at), 4u);
 121     BOOST_TEST_EQ(sizeof(little_float64_buf_at), 8u);
 122
 123   } // check_size
 124
 125   //  test_inserter_and_extractor  -----------------------------------------------------//
 126
 127   void test_inserter_and_extractor()
 128   {
 129     std::cout << "test inserter and extractor..." << std::endl;
 130
 131     big_uint64_buf_t bu64(0x010203040506070ULL);
 132     little_uint64_buf_t lu64(0x010203040506070ULL);
 133
 134     boost::uint64_t x;
 135
 136     std::stringstream ss;
 137
 138     ss << bu64;
 139     ss >> x;
 140     BOOST_TEST_EQ(x, 0x010203040506070ULL);
 141
 142     ss.clear();
 143     ss << lu64;
 144     ss >> x;
 145     BOOST_TEST_EQ(x, 0x010203040506070ULL);
 146
 147     ss.clear();
 148     ss << 0x010203040506070ULL;
 149     big_uint64_buf_t bu64z(0);
 150     ss >> bu64z;
 151     BOOST_TEST_EQ(bu64z.value(), bu64.value());
 152
 153     ss.clear();
 154     ss << 0x010203040506070ULL;
 155     little_uint64_buf_t lu64z(0);
 156     ss >> lu64z;
 157     BOOST_TEST_EQ(lu64z.value(), lu64.value());
 158
 159     std::cout << "test inserter and extractor complete" << std::endl;
 160
 161   }
 162
 163   template<class T> struct unaligned
 164   {
 165     char x;
 166     T y;
 167   };
 168
 169   template<class T> void test_buffer_type( typename T::value_type v1, typename T::value_type v2 )
 170   {
 171     T buffer( v1 );
 172     BOOST_TEST_EQ( buffer.value(), v1 );
 173
 174     buffer = v2;
 175     BOOST_TEST_EQ( buffer.value(), v2 );
 176
 177     unaligned<T> buffer2 = { 0, T( v1 ) };
 178     BOOST_TEST_EQ( buffer2.y.value(), v1 );
 179
 180     buffer2.y = v2;
 181     BOOST_TEST_EQ( buffer2.y.value(), v2 );
 182   }
 183
 184   void test_construction_and_assignment()
 185   {
 186     std::cout << "test construction and assignment..." << std::endl;
 187
 188     test_buffer_type< big_int8_buf_at>( 0x01, -0x01 );
 189     test_buffer_type<big_int16_buf_at>( 0x0102, -0x0102 );
 190     test_buffer_type<big_int32_buf_at>( 0x01020304, -0x01020304 );
 191     test_buffer_type<big_int64_buf_at>( 0x0102030405060708LL, -0x0102030405060708LL );
 192
 193     test_buffer_type< big_uint8_buf_at>( 0x01, 0xFE );
 194     test_buffer_type<big_uint16_buf_at>( 0x0102, 0xFE02 );
 195     test_buffer_type<big_uint32_buf_at>( 0x01020304, 0xFE020304 );
 196     test_buffer_type<big_uint64_buf_at>( 0x0102030405060708ULL, 0xFE02030405060708ULL );
 197
 198     test_buffer_type<big_float32_buf_at>( +1.5f, -3.14f );
 199     test_buffer_type<big_float64_buf_at>( +1.5, -3.14 );
 200
 201     test_buffer_type< little_int8_buf_at>( 0x01, -0x01 );
 202     test_buffer_type<little_int16_buf_at>( 0x0102, -0x0102 );
 203     test_buffer_type<little_int32_buf_at>( 0x01020304, -0x01020304 );
 204     test_buffer_type<little_int64_buf_at>( 0x0102030405060708LL, -0x0102030405060708LL );
 205
 206     test_buffer_type< little_uint8_buf_at>( 0x01, 0xFE );
 207     test_buffer_type<little_uint16_buf_at>( 0x0102, 0xFE02 );
 208     test_buffer_type<little_uint32_buf_at>( 0x01020304, 0xFE020304 );
 209     test_buffer_type<little_uint64_buf_at>( 0x0102030405060708ULL, 0xFE02030405060708ULL );
 210
 211     test_buffer_type<little_float32_buf_at>( +1.5f, -3.14f );
 212     test_buffer_type<little_float64_buf_at>( +1.5, -3.14 );
 213
 214     test_buffer_type< big_int8_buf_t>( 0x01, -0x01 );
 215     test_buffer_type<big_int16_buf_t>( 0x0102, -0x0102 );
 216     test_buffer_type<big_int24_buf_t>( 0x010203, -0x010203 );
 217     test_buffer_type<big_int32_buf_t>( 0x01020304, -0x01020304 );
 218     test_buffer_type<big_int40_buf_t>( 0x0102030405LL, -0x0102030405LL );
 219     test_buffer_type<big_int48_buf_t>( 0x010203040506LL, -0x010203040506LL );
 220     test_buffer_type<big_int56_buf_t>( 0x01020304050607LL, -0x01020304050607LL );
 221     test_buffer_type<big_int64_buf_t>( 0x0102030405060708LL, -0x0102030405060708LL );
 222
 223     test_buffer_type<big_float32_buf_t>( +1.5f, -3.14f );
 224     test_buffer_type<big_float64_buf_t>( +1.5, -3.14 );
 225
 226     test_buffer_type< little_uint8_buf_t>( 0x01, 0xFE );
 227     test_buffer_type<little_uint16_buf_t>( 0x0102, 0xFE02 );
 228     test_buffer_type<little_uint24_buf_t>( 0x010203, 0xFE0203 );
 229     test_buffer_type<little_uint32_buf_t>( 0x01020304, 0xFE020304 );
 230     test_buffer_type<little_uint40_buf_t>( 0x0102030405ULL, 0xFE02030405ULL );
 231     test_buffer_type<little_uint48_buf_t>( 0x010203040506ULL, 0xFE0203040506ULL );
 232     test_buffer_type<little_uint56_buf_t>( 0x01020304050607ULL, 0xFE020304050607ULL );
 233     test_buffer_type<little_uint64_buf_t>( 0x0102030405060708ULL, 0xFE02030405060708ULL );
 234
 235     test_buffer_type<little_float32_buf_t>( +1.5f, -3.14f );
 236     test_buffer_type<little_float64_buf_t>( +1.5, -3.14 );
 237
 238     std::cout << "test construction and assignment complete" << std::endl;
 239   }
 240
 241   template <typename T>
 242   void test_boundary_values_()
 243   {
 244     test_buffer_type< endian_buffer<order::big,    T, sizeof(T) * CHAR_BIT, align::no > >( std::numeric_limits<T>::min(), std::numeric_limits<T>::max() );
 245     test_buffer_type< endian_buffer<order::little, T, sizeof(T) * CHAR_BIT, align::no > >( std::numeric_limits<T>::min(), std::numeric_limits<T>::max() );
 246     test_buffer_type< endian_buffer<order::big,    T, sizeof(T) * CHAR_BIT, align::yes> >( std::numeric_limits<T>::min(), std::numeric_limits<T>::max() );
 247     test_buffer_type< endian_buffer<order::little, T, sizeof(T) * CHAR_BIT, align::yes> >( std::numeric_limits<T>::min(), std::numeric_limits<T>::max() );
 248   }
 249
 250   void test_boundary_values()
 251   {
 252     std::cout << "test boundary values..." << std::endl;
 253
 254     // integer types
 255
 256     test_boundary_values_<signed char>();
 257     test_boundary_values_<unsigned char>();
 258     test_boundary_values_<signed short>();
 259     test_boundary_values_<unsigned short>();
 260     test_boundary_values_<signed int>();
 261     test_boundary_values_<unsigned int>();
 262     test_boundary_values_<signed long>();
 263     test_boundary_values_<unsigned long>();
 264     test_boundary_values_<signed long long>();
 265     test_boundary_values_<unsigned long long>();
 266
 267     // character types
 268
 269     test_boundary_values_<char>();
 270
 271 #if !defined(BOOST_NO_CXX11_CHAR16_T)
 272     test_boundary_values_<char16_t>();
 273 #endif
 274
 275 #if !defined(BOOST_NO_CXX11_CHAR32_T)
 276     test_boundary_values_<char32_t>();
 277 #endif
 278
 279     // floating-point types
 280
 281     test_boundary_values_<float>();
 282     test_boundary_values_<double>();
 283
 284     std::cout << "test boundary values complete" << std::endl;
 285   }
 286
 287 }  // unnamed namespace
 288
 289 //--------------------------------------------------------------------------------------//
 290
 291 int cpp_main(int, char *[])
 292 {
 293   cout << "byte swap intrinsics: " BOOST_ENDIAN_INTRINSIC_MSG << endl;
 294
 295   cout << "  construct big endian aligned" << endl;
 296   big_int32_buf_at x(1122334455);
 297
 298   cout << "  assign to buffer from built-in integer" << endl;
 299   x = 1234567890;
 300
 301   cout << "  operator==(buffer.value(), built-in)" << endl;
 302   bool b1(x.value() == 1234567890);
 303   BOOST_TEST(b1);
 304
 305   cout << "  construct little endian unaligned" << endl;
 306   little_int32_buf_t x2(1122334455);
 307
 308   cout << "  assign to buffer from built-in integer" << endl;
 309   x2 = 1234567890;
 310
 311   cout << "  operator==(buffer.value(), built-in)" << endl;
 312   bool b2(x2.value() == 1234567890);
 313   BOOST_TEST(b2);
 314
 315   check_size();
 316   test_inserter_and_extractor();
 317   test_construction_and_assignment();
 318   test_boundary_values();
 319
 320   cout << "  done" << endl;
 321
 322   return ::boost::report_errors();
 323 }
 324
 325 #include <boost/endian/detail/disable_warnings_pop.hpp>