[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/include/support_argument.hpp>
#include <boost/spirit/home/x3/binary.hpp>
#include <boost/cstdint.hpp>
#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;

    {   // test native endian binaries
#ifdef BOOST_LITTLE_ENDIAN
        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
#ifdef BOOST_LITTLE_ENDIAN
        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
	9	#include <boost/spirit/include/support_argument.hpp>
	10	#include <boost/spirit/home/x3/binary.hpp>
	11	#include <boost/cstdint.hpp>
	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
	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;
	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
	47	float f;
	48	double d;
	49
	50	{ // test native endian binaries
	51	#ifdef BOOST_LITTLE_ENDIAN
	52	BOOST_TEST(test_attr("\x01", byte_, uc) && uc == 0x01);
	53	BOOST_TEST(test_attr("\x01\x02", word, us) && us == 0x0201);
	54	BOOST_TEST(test_attr("\x01\x02\x03\x04", dword, ui) && ui == 0x04030201);
	55	#ifdef BOOST_HAS_LONG_LONG
	56	BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", qword, ul) &&
	57	ul == 0x0807060504030201LL);
	58	#endif
	59	// BOOST_TEST(binary_test_attr("\x00\x00\x80\x3f", 4, bin_float, f) &&
	60	// f == 1.0f);
	61	// BOOST_TEST(binary_test_attr("\x00\x00\x00\x00\x00\x00\xf0\x3f",
	62	// 8, bin_double, d) && f == 1.0);
	63	#else
	64	BOOST_TEST(test_attr("\x01", byte_, uc) && uc == 0x01);
65	BOOST_TEST(test_attr("\x01\x02", word, us) && us == 0x0102);
66	BOOST_TEST(test_attr("\x01\x02\x03\x04", dword, ui) && ui == 0x01020304);
67	#ifdef BOOST_HAS_LONG_LONG
68	BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", qword, ul) &&
69	ul == 0x0102030405060708LL);
70	#endif
71	// BOOST_TEST(binary_test_attr("\x3f\x80\x00\x00", 4, bin_float, f) &&
72	// f == 1.0f);
73	// BOOST_TEST(binary_test_attr("\x3f\xf0\x00\x00\x00\x00\x00\x00",
74	// 8, bin_double, d) && f == 1.0);
75	#endif
76	}
77
78	{ // test native endian binaries
79	#ifdef BOOST_LITTLE_ENDIAN
80	BOOST_TEST(test("\x01", byte_(0x01)));
81	BOOST_TEST(test("\x01\x02", word(0x0201)));
82	BOOST_TEST(test("\x01\x02\x03\x04", dword(0x04030201)));
83	#ifdef BOOST_HAS_LONG_LONG
84	BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
85	qword(0x0807060504030201LL)));
86	#endif
87	// BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, bin_float(1.0f)));
88	// BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8,
89	// bin_double(1.0)));
90	#else
91	BOOST_TEST(test("\x01", byte_(0x01)));
92	BOOST_TEST(test("\x01\x02", word(0x0102)));
93	BOOST_TEST(test("\x01\x02\x03\x04", dword(0x01020304)));
94	#ifdef BOOST_HAS_LONG_LONG
95	BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
96	qword(0x0102030405060708LL)));
97	#endif
98	// BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, bin_float(1.0f)));
99	// BOOST_TEST(binary_test("\x3f\x80\x00\x00\x00\x00\x00\x00", 8,
100	// bin_double(1.0)));
101	#endif
102	}
103
104	{ // test big endian binaries
105	BOOST_TEST(test_attr("\x01\x02", big_word, us) && us == 0x0102);
106	BOOST_TEST(test_attr("\x01\x02\x03\x04", big_dword, ui) && ui == 0x01020304);
107	#ifdef BOOST_HAS_LONG_LONG
108	BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", big_qword, ul)
109	&& ul == 0x0102030405060708LL);
110	#endif
111	// BOOST_TEST(binary_test_attr("\x3f\x80\x00\x00", 4, big_bin_float, f) &&
112	// f == 1.0f);
113	// BOOST_TEST(binary_test_attr("\x3f\xf0\x00\x00\x00\x00\x00\x00",
114	// 8, big_bin_double, d) && f == 1.0);
115	}
116
117	{
118	BOOST_TEST(test("\x01\x02", big_word(0x0102)));
119	BOOST_TEST(test("\x01\x02\x03\x04", big_dword(0x01020304)));
120	#ifdef BOOST_HAS_LONG_LONG
121	BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
122	big_qword(0x0102030405060708LL)));
123	#endif
124	// BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, big_bin_float(1.0f)));
125	// BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8,
126	// big_bin_double(1.0)));
127	}
128
129	{ // test little endian binaries
130	BOOST_TEST(test_attr("\x01\x02", little_word, us) && us == 0x0201);
131	BOOST_TEST(test_attr("\x01\x02\x03\x04", little_dword, ui) && ui == 0x04030201);
132	#ifdef BOOST_HAS_LONG_LONG
133	BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", little_qword, ul)
134	&& ul == 0x0807060504030201LL);
135	#endif
136	// BOOST_TEST(binary_test_attr("\x00\x00\x80\x3f", 4,
137	// little_bin_float, f) && f == 1.0f);
138	// BOOST_TEST(binary_test_attr("\x00\x00\x00\x00\x00\x00\xf0\x3f",
139	// 8, little_bin_double, d) && f == 1.0);
140	}
141
142	{
143	BOOST_TEST(test("\x01\x02", little_word(0x0201)));
144	BOOST_TEST(test("\x01\x02\x03\x04", little_dword(0x04030201)));
145	#ifdef BOOST_HAS_LONG_LONG
146	BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
147	little_qword(0x0807060504030201LL)));
148	#endif
149	// BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, little_bin_float(1.0f)));
150	// BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8,
151	// little_bin_double(1.0)));
152	}
153
154	return boost::report_errors();
155	}