[ceph.git] / ceph / src / boost / libs / endian / test / buffer_test.cpp

//  buffer_test.cpp  -------------------------------------------------------------------//

//  Copyright Beman Dawes 2014

//  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

//--------------------------------------------------------------------------------------//

#include <boost/endian/detail/disable_warnings.hpp>

#include <boost/endian/buffers.hpp>
#include <boost/detail/lightweight_main.hpp>
#include <boost/core/lightweight_test.hpp>
#include <boost/cstdint.hpp>
#include <iostream>
#include <sstream>
#include <limits>

using namespace boost::endian;
using std::cout;
using std::endl;

namespace
{

  //  check_size  ------------------------------------------------------------//

  void check_size()
  {

    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(big_float32_buf_t), 4u);
    BOOST_TEST_EQ(sizeof(big_float64_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(little_float32_buf_t), 4u);
    BOOST_TEST_EQ(sizeof(little_float64_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(native_float32_buf_t), 4u);
    BOOST_TEST_EQ(sizeof(native_float64_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(big_float32_buf_at), 4u);
    BOOST_TEST_EQ(sizeof(big_float64_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);

    BOOST_TEST_EQ(sizeof(little_float32_buf_at), 4u);
    BOOST_TEST_EQ(sizeof(little_float64_buf_at), 8u);

  } // check_size

  //  test_inserter_and_extractor  -----------------------------------------------------//

  void test_inserter_and_extractor()
  {
    std::cout << "test inserter and extractor..." << std::endl;

    big_uint64_buf_t bu64(0x010203040506070ULL);
    little_uint64_buf_t lu64(0x010203040506070ULL);

    boost::uint64_t x;

    std::stringstream ss;

    ss << bu64;
    ss >> x;
    BOOST_TEST_EQ(x, 0x010203040506070ULL);

    ss.clear();
    ss << lu64;
    ss >> x;
    BOOST_TEST_EQ(x, 0x010203040506070ULL);

    ss.clear();
    ss << 0x010203040506070ULL;
    big_uint64_buf_t bu64z(0);
    ss >> bu64z;
    BOOST_TEST_EQ(bu64z.value(), bu64.value());

    ss.clear();
    ss << 0x010203040506070ULL;
    little_uint64_buf_t lu64z(0);
    ss >> lu64z;
    BOOST_TEST_EQ(lu64z.value(), lu64.value());

    std::cout << "test inserter and extractor complete" << std::endl;

  }

  template<class T> struct unaligned
  {
    char x;
    T y;
  };

  template<class T> void test_buffer_type( typename T::value_type v1, typename T::value_type v2 )
  {
    T buffer( v1 );
    BOOST_TEST_EQ( buffer.value(), v1 );

    buffer = v2;
    BOOST_TEST_EQ( buffer.value(), v2 );

    unaligned<T> buffer2 = { 0, T( v1 ) };
    BOOST_TEST_EQ( buffer2.y.value(), v1 );

    buffer2.y = v2;
    BOOST_TEST_EQ( buffer2.y.value(), v2 );
  }

  void test_construction_and_assignment()
  {
    std::cout << "test construction and assignment..." << std::endl;

    test_buffer_type< big_int8_buf_at>( 0x01, -0x01 );
    test_buffer_type<big_int16_buf_at>( 0x0102, -0x0102 );
    test_buffer_type<big_int32_buf_at>( 0x01020304, -0x01020304 );
    test_buffer_type<big_int64_buf_at>( 0x0102030405060708LL, -0x0102030405060708LL );

    test_buffer_type< big_uint8_buf_at>( 0x01, 0xFE );
    test_buffer_type<big_uint16_buf_at>( 0x0102, 0xFE02 );
    test_buffer_type<big_uint32_buf_at>( 0x01020304, 0xFE020304 );
    test_buffer_type<big_uint64_buf_at>( 0x0102030405060708ULL, 0xFE02030405060708ULL );

    test_buffer_type<big_float32_buf_at>( +1.5f, -3.14f );
    test_buffer_type<big_float64_buf_at>( +1.5, -3.14 );

    test_buffer_type< little_int8_buf_at>( 0x01, -0x01 );
    test_buffer_type<little_int16_buf_at>( 0x0102, -0x0102 );
    test_buffer_type<little_int32_buf_at>( 0x01020304, -0x01020304 );
    test_buffer_type<little_int64_buf_at>( 0x0102030405060708LL, -0x0102030405060708LL );

    test_buffer_type< little_uint8_buf_at>( 0x01, 0xFE );
    test_buffer_type<little_uint16_buf_at>( 0x0102, 0xFE02 );
    test_buffer_type<little_uint32_buf_at>( 0x01020304, 0xFE020304 );
    test_buffer_type<little_uint64_buf_at>( 0x0102030405060708ULL, 0xFE02030405060708ULL );

    test_buffer_type<little_float32_buf_at>( +1.5f, -3.14f );
    test_buffer_type<little_float64_buf_at>( +1.5, -3.14 );

    test_buffer_type< big_int8_buf_t>( 0x01, -0x01 );
    test_buffer_type<big_int16_buf_t>( 0x0102, -0x0102 );
    test_buffer_type<big_int24_buf_t>( 0x010203, -0x010203 );
    test_buffer_type<big_int32_buf_t>( 0x01020304, -0x01020304 );
    test_buffer_type<big_int40_buf_t>( 0x0102030405LL, -0x0102030405LL );
    test_buffer_type<big_int48_buf_t>( 0x010203040506LL, -0x010203040506LL );
    test_buffer_type<big_int56_buf_t>( 0x01020304050607LL, -0x01020304050607LL );
    test_buffer_type<big_int64_buf_t>( 0x0102030405060708LL, -0x0102030405060708LL );

    test_buffer_type<big_float32_buf_t>( +1.5f, -3.14f );
    test_buffer_type<big_float64_buf_t>( +1.5, -3.14 );

    test_buffer_type< little_uint8_buf_t>( 0x01, 0xFE );
    test_buffer_type<little_uint16_buf_t>( 0x0102, 0xFE02 );
    test_buffer_type<little_uint24_buf_t>( 0x010203, 0xFE0203 );
    test_buffer_type<little_uint32_buf_t>( 0x01020304, 0xFE020304 );
    test_buffer_type<little_uint40_buf_t>( 0x0102030405ULL, 0xFE02030405ULL );
    test_buffer_type<little_uint48_buf_t>( 0x010203040506ULL, 0xFE0203040506ULL );
    test_buffer_type<little_uint56_buf_t>( 0x01020304050607ULL, 0xFE020304050607ULL );
    test_buffer_type<little_uint64_buf_t>( 0x0102030405060708ULL, 0xFE02030405060708ULL );

    test_buffer_type<little_float32_buf_t>( +1.5f, -3.14f );
    test_buffer_type<little_float64_buf_t>( +1.5, -3.14 );

    std::cout << "test construction and assignment complete" << std::endl;
  }

  template <typename T>
  void test_boundary_values_()
  {
    test_buffer_type< endian_buffer<order::big,    T, sizeof(T) * CHAR_BIT, align::no > >( std::numeric_limits<T>::min(), std::numeric_limits<T>::max() );
    test_buffer_type< endian_buffer<order::little, T, sizeof(T) * CHAR_BIT, align::no > >( std::numeric_limits<T>::min(), std::numeric_limits<T>::max() );
    test_buffer_type< endian_buffer<order::big,    T, sizeof(T) * CHAR_BIT, align::yes> >( std::numeric_limits<T>::min(), std::numeric_limits<T>::max() );
    test_buffer_type< endian_buffer<order::little, T, sizeof(T) * CHAR_BIT, align::yes> >( std::numeric_limits<T>::min(), std::numeric_limits<T>::max() );
  }

  void test_boundary_values()
  {
    std::cout << "test boundary values..." << std::endl;

    // integer types

    test_boundary_values_<signed char>();
    test_boundary_values_<unsigned char>();
    test_boundary_values_<signed short>();
    test_boundary_values_<unsigned short>();
    test_boundary_values_<signed int>();
    test_boundary_values_<unsigned int>();
    test_boundary_values_<signed long>();
    test_boundary_values_<unsigned long>();
    test_boundary_values_<signed long long>();
    test_boundary_values_<unsigned long long>();

    // character types

    test_boundary_values_<char>();

#if !defined(BOOST_NO_CXX11_CHAR16_T)
    test_boundary_values_<char16_t>();
#endif

#if !defined(BOOST_NO_CXX11_CHAR32_T)
    test_boundary_values_<char32_t>();
#endif

    // floating-point types

    test_boundary_values_<float>();
    test_boundary_values_<double>();

    std::cout << "test boundary values complete" << std::endl;
  }

}  // unnamed namespace

//--------------------------------------------------------------------------------------//

int cpp_main(int, char *[])
{
  cout << "byte swap intrinsics: " BOOST_ENDIAN_INTRINSIC_MSG << endl;

  cout << "  construct big endian aligned" << endl;
  big_int32_buf_at x(1122334455);

  cout << "  assign to buffer from built-in integer" << endl;
  x = 1234567890;

  cout << "  operator==(buffer.value(), built-in)" << endl;
  bool b1(x.value() == 1234567890);
  BOOST_TEST(b1);

  cout << "  construct little endian unaligned" << endl;
  little_int32_buf_t x2(1122334455);

  cout << "  assign to buffer from built-in integer" << endl;
  x2 = 1234567890;

  cout << "  operator==(buffer.value(), built-in)" << endl;
  bool b2(x2.value() == 1234567890);
  BOOST_TEST(b2);

  check_size();
  test_inserter_and_extractor();
  test_construction_and_assignment();
  test_boundary_values();

  cout << "  done" << endl;

  return ::boost::report_errors();
}

#include <boost/endian/detail/disable_warnings_pop.hpp>
Commit	Line	Data
7c673cae FG	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
7c673cae FG	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>
11fdf7f2	20	#include <limits>
7c673cae FG	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
92f5a8d4 TL	52	BOOST_TEST_EQ(sizeof(big_float32_buf_t), 4u);
	53	BOOST_TEST_EQ(sizeof(big_float64_buf_t), 8u);
	54
7c673cae FG	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
92f5a8d4 TL	73	BOOST_TEST_EQ(sizeof(little_float32_buf_t), 4u);
	74	BOOST_TEST_EQ(sizeof(little_float64_buf_t), 8u);
	75
7c673cae FG	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
92f5a8d4 TL	94	BOOST_TEST_EQ(sizeof(native_float32_buf_t), 4u);
	95	BOOST_TEST_EQ(sizeof(native_float64_buf_t), 8u);
	96
7c673cae FG	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
92f5a8d4 TL	107	BOOST_TEST_EQ(sizeof(big_float32_buf_at), 4u);
	108	BOOST_TEST_EQ(sizeof(big_float64_buf_at), 8u);
	109
7c673cae FG	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);
92f5a8d4 TL	119
	120	BOOST_TEST_EQ(sizeof(little_float32_buf_at), 4u);
	121	BOOST_TEST_EQ(sizeof(little_float64_buf_at), 8u);
	122
7c673cae FG	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
11fdf7f2 TL	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 );
92f5a8d4 TL	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 );
11fdf7f2 TL	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 );
92f5a8d4 TL	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 );
11fdf7f2 TL	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
92f5a8d4 TL	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
11fdf7f2 TL	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 );
92f5a8d4 TL	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 );
11fdf7f2 TL	237
	238	std::cout << "test construction and assignment complete" << std::endl;
	239	}
	240
92f5a8d4	241	template <typename T>
11fdf7f2 TL	242	void test_boundary_values_()
11fdf7f2 TL	243	{
92f5a8d4 TL	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() );
11fdf7f2 TL	248	}
	249
	250	void test_boundary_values()
	251	{
	252	std::cout << "test boundary values..." << std::endl;
	253
92f5a8d4 TL	254	// integer types
92f5a8d4 TL	255
11fdf7f2 TL	256	test_boundary_values_<signed char>();
11fdf7f2 TL	257	test_boundary_values_<unsigned char>();
92f5a8d4 TL	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>();
11fdf7f2 TL	283
	284	std::cout << "test boundary values complete" << std::endl;
	285	}
	286
7c673cae FG	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();
11fdf7f2 TL	317	test_construction_and_assignment();
11fdf7f2 TL	318	test_boundary_values();
7c673cae FG	319
	320	cout << " done" << endl;
	321
	322	return ::boost::report_errors();
	323	}
	324
	325	#include <boost/endian/detail/disable_warnings_pop.hpp>