[ceph.git] / ceph / src / boost / libs / spirit / test / x3 / binary.cpp

/*=============================================================================
    Copyright (c) 2001-2011 Hartmut Kaiser

    Distributed under the Boost Software License, Version 1.0. (See accompanying
    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
==============================================================================*/
#include <boost/detail/lightweight_test.hpp>

#include <boost/spirit/home/x3/binary.hpp>
#include <boost/cstdint.hpp>
#include <boost/predef/other/endian.h>
#include "test.hpp"

///////////////////////////////////////////////////////////////////////////////
int main()
{
    using spirit_test::test_attr;
    using spirit_test::test;
    using spirit_test::binary_test;
    using spirit_test::binary_test_attr;

    using boost::spirit::x3::byte_;
    using boost::spirit::x3::word;
    using boost::spirit::x3::dword;
    using boost::spirit::x3::big_word;
    using boost::spirit::x3::big_dword;
    using boost::spirit::x3::little_word;
    using boost::spirit::x3::little_dword;
#ifdef BOOST_HAS_LONG_LONG
    using boost::spirit::x3::qword;
    using boost::spirit::x3::big_qword;
    using boost::spirit::x3::little_qword;
#endif
    using boost::spirit::x3::bin_float;
    using boost::spirit::x3::big_bin_float;
    using boost::spirit::x3::little_bin_float;
    using boost::spirit::x3::bin_double;
    using boost::spirit::x3::big_bin_double;
    using boost::spirit::x3::little_bin_double;

    boost::uint8_t uc;
    boost::uint16_t us;
    boost::uint32_t ui;
#ifdef BOOST_HAS_LONG_LONG
    boost::uint64_t ul;
#endif
    float f;
    double d;

    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(byte_);
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(word);
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(dword);
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_word);
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_dword);
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_word);
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_dword);
#ifdef BOOST_HAS_LONG_LONG
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(qword);
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_qword);
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_qword);
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(bin_float);
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_bin_float);
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_bin_float);
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(bin_double);
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_bin_double);
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_bin_double);
#endif

// TODO: boost::endian::endian_arithmetic value constructor is not constexpr
#if 0
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(byte_(1));
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(word(1));
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(dword(1));
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_word(1));
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_dword(1));
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_word(1));
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_dword(1));
#ifdef BOOST_HAS_LONG_LONG
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(qword(1));
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_qword(1));
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_qword(1));
#endif
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(bin_float(1.0f));
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_bin_float(1.0f));
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_bin_float(1.0f));
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(bin_double(1.0));
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_bin_double(1.0));
    BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_bin_double(1.0));
#endif

    {   // test native endian binaries
#if BOOST_ENDIAN_LITTLE_BYTE
        BOOST_TEST(test_attr("\x01", byte_, uc) && uc == 0x01);
        BOOST_TEST(test_attr("\x01\x02", word, us) && us == 0x0201);
        BOOST_TEST(test_attr("\x01\x02\x03\x04", dword, ui) && ui == 0x04030201);
#ifdef BOOST_HAS_LONG_LONG
        BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", qword, ul) &&
            ul == 0x0807060504030201LL);
#endif
        BOOST_TEST(binary_test_attr("\x00\x00\x80\x3f", 4, bin_float, f) &&
            f == 1.0f);
        BOOST_TEST(binary_test_attr("\x00\x00\x00\x00\x00\x00\xf0\x3f",
            8, bin_double, d) && f == 1.0);
#else
        BOOST_TEST(test_attr("\x01", byte_, uc) && uc == 0x01);
        BOOST_TEST(test_attr("\x01\x02", word, us) && us ==  0x0102);
        BOOST_TEST(test_attr("\x01\x02\x03\x04", dword, ui) && ui == 0x01020304);
#ifdef BOOST_HAS_LONG_LONG
        BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", qword, ul) &&
            ul == 0x0102030405060708LL);
#endif
        BOOST_TEST(binary_test_attr("\x3f\x80\x00\x00", 4, bin_float, f) &&
            f == 1.0f);
        BOOST_TEST(binary_test_attr("\x3f\xf0\x00\x00\x00\x00\x00\x00",
            8, bin_double, d) && f == 1.0);
#endif
    }

    {   // test native endian binaries
#if BOOST_ENDIAN_LITTLE_BYTE
        BOOST_TEST(test("\x01", byte_(0x01)));
        BOOST_TEST(test("\x01\x02", word(0x0201)));
        BOOST_TEST(test("\x01\x02\x03\x04", dword(0x04030201)));
#ifdef BOOST_HAS_LONG_LONG
        BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
            qword(0x0807060504030201LL)));
#endif
        BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, bin_float(1.0f)));
        BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8,
            bin_double(1.0)));
#else
        BOOST_TEST(test("\x01", byte_(0x01)));
        BOOST_TEST(test("\x01\x02", word(0x0102)));
        BOOST_TEST(test("\x01\x02\x03\x04", dword(0x01020304)));
#ifdef BOOST_HAS_LONG_LONG
        BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
            qword(0x0102030405060708LL)));
#endif
        BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, bin_float(1.0f)));
        BOOST_TEST(binary_test("\x3f\x80\x00\x00\x00\x00\x00\x00", 8,
            bin_double(1.0)));
#endif
    }

    {   // test big endian binaries
        BOOST_TEST(test_attr("\x01\x02", big_word, us) && us == 0x0102);
        BOOST_TEST(test_attr("\x01\x02\x03\x04", big_dword, ui) && ui == 0x01020304);
#ifdef BOOST_HAS_LONG_LONG
        BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", big_qword, ul)
            && ul == 0x0102030405060708LL);
#endif
        BOOST_TEST(binary_test_attr("\x3f\x80\x00\x00", 4, big_bin_float, f) &&
            f == 1.0f);
        BOOST_TEST(binary_test_attr("\x3f\xf0\x00\x00\x00\x00\x00\x00",
            8, big_bin_double, d) && f == 1.0);
    }

    {
        BOOST_TEST(test("\x01\x02", big_word(0x0102)));
        BOOST_TEST(test("\x01\x02\x03\x04", big_dword(0x01020304)));
#ifdef BOOST_HAS_LONG_LONG
        BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
            big_qword(0x0102030405060708LL)));
#endif
        BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, big_bin_float(1.0f)));
        BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8,
            big_bin_double(1.0)));
    }

    {   // test little endian binaries
        BOOST_TEST(test_attr("\x01\x02", little_word, us) && us == 0x0201);
        BOOST_TEST(test_attr("\x01\x02\x03\x04", little_dword, ui) && ui == 0x04030201);
#ifdef BOOST_HAS_LONG_LONG
        BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", little_qword, ul)
            && ul == 0x0807060504030201LL);
#endif
        BOOST_TEST(binary_test_attr("\x00\x00\x80\x3f", 4,
            little_bin_float, f) && f == 1.0f);
        BOOST_TEST(binary_test_attr("\x00\x00\x00\x00\x00\x00\xf0\x3f",
            8, little_bin_double, d) && f == 1.0);
    }

    {
        BOOST_TEST(test("\x01\x02", little_word(0x0201)));
        BOOST_TEST(test("\x01\x02\x03\x04", little_dword(0x04030201)));
#ifdef BOOST_HAS_LONG_LONG
        BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
            little_qword(0x0807060504030201LL)));
#endif
        BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, little_bin_float(1.0f)));
        BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8,
            little_bin_double(1.0)));
    }

    return boost::report_errors();
}
Commit	Line	Data
7c673cae FG	1	/*=============================================================================
	2	Copyright (c) 2001-2011 Hartmut Kaiser
	3
	4	Distributed under the Boost Software License, Version 1.0. (See accompanying
	5	file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
	6	==============================================================================*/
	7	#include <boost/detail/lightweight_test.hpp>
	8
7c673cae FG	9	#include <boost/spirit/home/x3/binary.hpp>
7c673cae FG	10	#include <boost/cstdint.hpp>
92f5a8d4	11	#include <boost/predef/other/endian.h>
7c673cae FG	12	#include "test.hpp"
	13
	14	///////////////////////////////////////////////////////////////////////////////
	15	int main()
	16	{
	17	using spirit_test::test_attr;
	18	using spirit_test::test;
	19	using spirit_test::binary_test;
	20	using spirit_test::binary_test_attr;
	21
	22	using boost::spirit::x3::byte_;
	23	using boost::spirit::x3::word;
	24	using boost::spirit::x3::dword;
	25	using boost::spirit::x3::big_word;
	26	using boost::spirit::x3::big_dword;
	27	using boost::spirit::x3::little_word;
	28	using boost::spirit::x3::little_dword;
	29	#ifdef BOOST_HAS_LONG_LONG
	30	using boost::spirit::x3::qword;
	31	using boost::spirit::x3::big_qword;
	32	using boost::spirit::x3::little_qword;
	33	#endif
20effc67 TL	34	using boost::spirit::x3::bin_float;
	35	using boost::spirit::x3::big_bin_float;
	36	using boost::spirit::x3::little_bin_float;
	37	using boost::spirit::x3::bin_double;
	38	using boost::spirit::x3::big_bin_double;
	39	using boost::spirit::x3::little_bin_double;
7c673cae FG	40
	41	boost::uint8_t uc;
	42	boost::uint16_t us;
	43	boost::uint32_t ui;
	44	#ifdef BOOST_HAS_LONG_LONG
	45	boost::uint64_t ul;
	46	#endif
20effc67 TL	47	float f;
20effc67 TL	48	double d;
7c673cae	49
f67539c2 TL	50	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(byte_);
	51	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(word);
	52	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(dword);
	53	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_word);
	54	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_dword);
	55	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_word);
	56	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_dword);
	57	#ifdef BOOST_HAS_LONG_LONG
	58	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(qword);
	59	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_qword);
	60	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_qword);
20effc67 TL	61	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(bin_float);
	62	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_bin_float);
	63	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_bin_float);
	64	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(bin_double);
	65	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_bin_double);
	66	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_bin_double);
f67539c2 TL	67	#endif
	68
	69	// TODO: boost::endian::endian_arithmetic value constructor is not constexpr
	70	#if 0
	71	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(byte_(1));
	72	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(word(1));
	73	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(dword(1));
	74	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_word(1));
	75	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_dword(1));
	76	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_word(1));
	77	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_dword(1));
	78	#ifdef BOOST_HAS_LONG_LONG
	79	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(qword(1));
	80	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_qword(1));
	81	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_qword(1));
	82	#endif
20effc67 TL	83	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(bin_float(1.0f));
	84	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_bin_float(1.0f));
	85	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_bin_float(1.0f));
	86	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(bin_double(1.0));
	87	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(big_bin_double(1.0));
	88	BOOST_SPIRIT_ASSERT_CONSTEXPR_CTORS(little_bin_double(1.0));
f67539c2 TL	89	#endif
f67539c2 TL	90
7c673cae	91	{ // test native endian binaries
92f5a8d4	92	#if BOOST_ENDIAN_LITTLE_BYTE
7c673cae FG	93	BOOST_TEST(test_attr("\x01", byte_, uc) && uc == 0x01);
	94	BOOST_TEST(test_attr("\x01\x02", word, us) && us == 0x0201);
	95	BOOST_TEST(test_attr("\x01\x02\x03\x04", dword, ui) && ui == 0x04030201);
	96	#ifdef BOOST_HAS_LONG_LONG
	97	BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", qword, ul) &&
	98	ul == 0x0807060504030201LL);
	99	#endif
20effc67 TL	100	BOOST_TEST(binary_test_attr("\x00\x00\x80\x3f", 4, bin_float, f) &&
	101	f == 1.0f);
	102	BOOST_TEST(binary_test_attr("\x00\x00\x00\x00\x00\x00\xf0\x3f",
	103	8, bin_double, d) && f == 1.0);
7c673cae FG	104	#else
	105	BOOST_TEST(test_attr("\x01", byte_, uc) && uc == 0x01);
	106	BOOST_TEST(test_attr("\x01\x02", word, us) && us == 0x0102);
	107	BOOST_TEST(test_attr("\x01\x02\x03\x04", dword, ui) && ui == 0x01020304);
	108	#ifdef BOOST_HAS_LONG_LONG
	109	BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", qword, ul) &&
	110	ul == 0x0102030405060708LL);
	111	#endif
20effc67 TL	112	BOOST_TEST(binary_test_attr("\x3f\x80\x00\x00", 4, bin_float, f) &&
	113	f == 1.0f);
	114	BOOST_TEST(binary_test_attr("\x3f\xf0\x00\x00\x00\x00\x00\x00",
	115	8, bin_double, d) && f == 1.0);
7c673cae FG	116	#endif
	117	}
	118
	119	{ // test native endian binaries
92f5a8d4	120	#if BOOST_ENDIAN_LITTLE_BYTE
7c673cae FG	121	BOOST_TEST(test("\x01", byte_(0x01)));
	122	BOOST_TEST(test("\x01\x02", word(0x0201)));
	123	BOOST_TEST(test("\x01\x02\x03\x04", dword(0x04030201)));
	124	#ifdef BOOST_HAS_LONG_LONG
	125	BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
	126	qword(0x0807060504030201LL)));
	127	#endif
20effc67 TL	128	BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, bin_float(1.0f)));
	129	BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8,
	130	bin_double(1.0)));
7c673cae FG	131	#else
	132	BOOST_TEST(test("\x01", byte_(0x01)));
	133	BOOST_TEST(test("\x01\x02", word(0x0102)));
	134	BOOST_TEST(test("\x01\x02\x03\x04", dword(0x01020304)));
	135	#ifdef BOOST_HAS_LONG_LONG
	136	BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
	137	qword(0x0102030405060708LL)));
	138	#endif
20effc67 TL	139	BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, bin_float(1.0f)));
	140	BOOST_TEST(binary_test("\x3f\x80\x00\x00\x00\x00\x00\x00", 8,
	141	bin_double(1.0)));
7c673cae FG	142	#endif
	143	}
	144
	145	{ // test big endian binaries
	146	BOOST_TEST(test_attr("\x01\x02", big_word, us) && us == 0x0102);
	147	BOOST_TEST(test_attr("\x01\x02\x03\x04", big_dword, ui) && ui == 0x01020304);
	148	#ifdef BOOST_HAS_LONG_LONG
	149	BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", big_qword, ul)
	150	&& ul == 0x0102030405060708LL);
	151	#endif
20effc67 TL	152	BOOST_TEST(binary_test_attr("\x3f\x80\x00\x00", 4, big_bin_float, f) &&
	153	f == 1.0f);
	154	BOOST_TEST(binary_test_attr("\x3f\xf0\x00\x00\x00\x00\x00\x00",
	155	8, big_bin_double, d) && f == 1.0);
7c673cae FG	156	}
	157
	158	{
	159	BOOST_TEST(test("\x01\x02", big_word(0x0102)));
	160	BOOST_TEST(test("\x01\x02\x03\x04", big_dword(0x01020304)));
	161	#ifdef BOOST_HAS_LONG_LONG
	162	BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
	163	big_qword(0x0102030405060708LL)));
	164	#endif
20effc67 TL	165	BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, big_bin_float(1.0f)));
	166	BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8,
	167	big_bin_double(1.0)));
7c673cae FG	168	}
	169
	170	{ // test little endian binaries
	171	BOOST_TEST(test_attr("\x01\x02", little_word, us) && us == 0x0201);
	172	BOOST_TEST(test_attr("\x01\x02\x03\x04", little_dword, ui) && ui == 0x04030201);
	173	#ifdef BOOST_HAS_LONG_LONG
	174	BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", little_qword, ul)
	175	&& ul == 0x0807060504030201LL);
	176	#endif
20effc67 TL	177	BOOST_TEST(binary_test_attr("\x00\x00\x80\x3f", 4,
	178	little_bin_float, f) && f == 1.0f);
	179	BOOST_TEST(binary_test_attr("\x00\x00\x00\x00\x00\x00\xf0\x3f",
	180	8, little_bin_double, d) && f == 1.0);
7c673cae FG	181	}
	182
	183	{
	184	BOOST_TEST(test("\x01\x02", little_word(0x0201)));
	185	BOOST_TEST(test("\x01\x02\x03\x04", little_dword(0x04030201)));
	186	#ifdef BOOST_HAS_LONG_LONG
	187	BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
	188	little_qword(0x0807060504030201LL)));
	189	#endif
20effc67 TL	190	BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, little_bin_float(1.0f)));
	191	BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8,
	192	little_bin_double(1.0)));
7c673cae FG	193	}
	194
	195	return boost::report_errors();
	196	}