[ceph.git] / ceph / src / boost / libs / lexical_cast / test / lexical_cast_arrays_test.cpp

//  Testing boost::lexical_cast with boost::container::string.
//
//  See http://www.boost.org for most recent version, including documentation.
//
//  Copyright Antony Polukhin, 2012.
//
//  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/lexical_cast.hpp>

#include <boost/test/unit_test.hpp>
    
#include <boost/array.hpp>

void testing_boost_array_output_conversion();
void testing_std_array_output_conversion();

void testing_boost_array_input_conversion();
void testing_std_array_input_conversion();

using namespace boost;

#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION) && !defined(BOOST_MSVC)
#define BOOST_LC_RUNU16
#endif

#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION) && !defined(BOOST_MSVC)
#define BOOST_LC_RUNU32
#endif

boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
{
    unit_test::test_suite *suite =
        BOOST_TEST_SUITE("Testing boost::lexical_cast with boost::array and std::array");

    suite->add(BOOST_TEST_CASE(testing_boost_array_output_conversion));
    suite->add(BOOST_TEST_CASE(testing_std_array_output_conversion));
    suite->add(BOOST_TEST_CASE(testing_boost_array_input_conversion));
    suite->add(BOOST_TEST_CASE(testing_std_array_input_conversion));

    return suite;
}

template <template <class, std::size_t> class ArrayT, class T>
static void testing_template_array_output_on_spec_value(T val) 
{
    typedef ArrayT<char, 300>             arr_type;
    typedef ArrayT<char, 1>               short_arr_type;
    typedef ArrayT<unsigned char, 300>    uarr_type;
    typedef ArrayT<unsigned char, 1>      ushort_arr_type;
    typedef ArrayT<signed char, 4>        sarr_type;
    typedef ArrayT<signed char, 3>        sshort_arr_type;

    std::string ethalon("100");
    using namespace std;

    {
        arr_type res1 = lexical_cast<arr_type>(val);
        BOOST_CHECK_EQUAL(&res1[0], ethalon);
        const arr_type res2 = lexical_cast<arr_type>(val);
        BOOST_CHECK_EQUAL(&res2[0], ethalon);
        BOOST_CHECK_THROW(lexical_cast<short_arr_type>(val), boost::bad_lexical_cast);
    }
    
    {
        uarr_type res1 = lexical_cast<uarr_type>(val);
        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
        const uarr_type res2 = lexical_cast<uarr_type>(val);
        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
        BOOST_CHECK_THROW(lexical_cast<ushort_arr_type>(val), boost::bad_lexical_cast);
    }
    
    {
        sarr_type res1 = lexical_cast<sarr_type>(val);
        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
        const sarr_type res2 = lexical_cast<sarr_type>(val);
        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
        BOOST_CHECK_THROW(lexical_cast<sshort_arr_type>(val), boost::bad_lexical_cast);
    }

#if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
    typedef ArrayT<wchar_t, 300> warr_type;
    typedef ArrayT<wchar_t, 3> wshort_arr_type;
    std::wstring wethalon(L"100");

    {
        warr_type res = lexical_cast<warr_type>(val);
        BOOST_CHECK(&res[0] == wethalon);
    }

    {
        const warr_type res = lexical_cast<warr_type>(val);
        BOOST_CHECK(&res[0] == wethalon);
    }
    
    BOOST_CHECK_THROW(lexical_cast<wshort_arr_type>(val), boost::bad_lexical_cast);

#endif

#ifdef BOOST_LC_RUNU16
    typedef ArrayT<char16_t, 300> u16arr_type;
    typedef ArrayT<char16_t, 3> u16short_arr_type;
    std::u16string u16ethalon(u"100");

    {
        u16arr_type res = lexical_cast<u16arr_type>(val);
        BOOST_CHECK(&res[0] == u16ethalon);
    }

    {
        const u16arr_type res = lexical_cast<u16arr_type>(val);
        BOOST_CHECK(&res[0] == u16ethalon);
    }
    
    BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), boost::bad_lexical_cast);
#endif

#ifdef BOOST_LC_RUNU32
    typedef ArrayT<char32_t, 300> u32arr_type;
    typedef ArrayT<char32_t, 3> u32short_arr_type;
    std::u32string u32ethalon(U"100");

    {
        u32arr_type res = lexical_cast<u32arr_type>(val);
        BOOST_CHECK(&res[0] == u32ethalon);
    }

    {
        const u32arr_type res = lexical_cast<u32arr_type>(val);
        BOOST_CHECK(&res[0] == u32ethalon);
    }
    
    BOOST_CHECK_THROW(lexical_cast<u32short_arr_type>(val), boost::bad_lexical_cast);
#endif
}


template <template <class, std::size_t> class ArrayT>
static void testing_template_array_output_on_char_value() 
{
    typedef ArrayT<char, 300>             arr_type;
    typedef ArrayT<char, 1>               short_arr_type;
    typedef ArrayT<unsigned char, 300>    uarr_type;
    typedef ArrayT<unsigned char, 1>      ushort_arr_type;
    typedef ArrayT<signed char, 4>        sarr_type;
    typedef ArrayT<signed char, 3>        sshort_arr_type;

    const char val[] = "100";
    std::string ethalon("100");
    using namespace std;

    {
        arr_type res1 = lexical_cast<arr_type>(val);
        BOOST_CHECK_EQUAL(&res1[0], ethalon);
        const arr_type res2 = lexical_cast<arr_type>(val);
        BOOST_CHECK_EQUAL(&res2[0], ethalon);
        BOOST_CHECK_THROW(lexical_cast<short_arr_type>(val), boost::bad_lexical_cast);
    }
    
    {
        uarr_type res1 = lexical_cast<uarr_type>(val);
        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
        const uarr_type res2 = lexical_cast<uarr_type>(val);
        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
        BOOST_CHECK_THROW(lexical_cast<ushort_arr_type>(val), boost::bad_lexical_cast);
    }
    
    {
        sarr_type res1 = lexical_cast<sarr_type>(val);
        BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
        const sarr_type res2 = lexical_cast<sarr_type>(val);
        BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
        BOOST_CHECK_THROW(lexical_cast<sshort_arr_type>(val), boost::bad_lexical_cast);
    }

#if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
    typedef ArrayT<wchar_t, 4> warr_type;
    typedef ArrayT<wchar_t, 3> wshort_arr_type;
    std::wstring wethalon(L"100");

    {
        warr_type res = lexical_cast<warr_type>(val);
        BOOST_CHECK(&res[0] == wethalon);
        warr_type res3 = lexical_cast<warr_type>(wethalon);
        BOOST_CHECK(&res3[0] == wethalon);
    }

    {
        const warr_type res = lexical_cast<warr_type>(val);
        BOOST_CHECK(&res[0] == wethalon);
        const warr_type res3 = lexical_cast<warr_type>(wethalon);
        BOOST_CHECK(&res3[0] == wethalon);
    }
    
    BOOST_CHECK_THROW(lexical_cast<wshort_arr_type>(val), boost::bad_lexical_cast);

#endif

#ifdef BOOST_LC_RUNU16
    typedef ArrayT<char16_t, 300> u16arr_type;
    typedef ArrayT<char16_t, 3> u16short_arr_type;
    std::u16string u16ethalon(u"100");

    {
#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
        u16arr_type res = lexical_cast<u16arr_type>(val);
        BOOST_CHECK(&res[0] == u16ethalon);  
#endif

        u16arr_type res3 = lexical_cast<u16arr_type>(u16ethalon);
        BOOST_CHECK(&res3[0] == u16ethalon);
    }

    {
#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
        const u16arr_type res = lexical_cast<u16arr_type>(val);
        BOOST_CHECK(&res[0] == u16ethalon);
#endif
        const u16arr_type res3 = lexical_cast<u16arr_type>(u16ethalon);
        BOOST_CHECK(&res3[0] == u16ethalon);
    }
    
    // Some compillers may throw std::bad_alloc here
    BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), std::exception); 
#endif

#ifdef BOOST_LC_RUNU32
    typedef ArrayT<char32_t, 300> u32arr_type;
    typedef ArrayT<char32_t, 3> u32short_arr_type;
    std::u32string u32ethalon(U"100");

    {
#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
        u32arr_type res = lexical_cast<u32arr_type>(val);
        BOOST_CHECK(&res[0] == u32ethalon);
#endif
        u32arr_type res3 = lexical_cast<u32arr_type>(u32ethalon);
        BOOST_CHECK(&res3[0] == u32ethalon);
    }

    {
#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
        const u32arr_type res = lexical_cast<u32arr_type>(val);
        BOOST_CHECK(&res[0] == u32ethalon);
#endif
        const u32arr_type res3 = lexical_cast<u32arr_type>(u32ethalon);
        BOOST_CHECK(&res3[0] == u32ethalon);
    }
    
    // Some compillers may throw std::bad_alloc here
    BOOST_CHECK_THROW(lexical_cast<u32short_arr_type>(val), std::exception);
#endif
}


void testing_boost_array_output_conversion()
{   
    testing_template_array_output_on_char_value<boost::array>();
    testing_template_array_output_on_spec_value<boost::array>(100);
    testing_template_array_output_on_spec_value<boost::array>(static_cast<short>(100));
    testing_template_array_output_on_spec_value<boost::array>(static_cast<unsigned short>(100));
    testing_template_array_output_on_spec_value<boost::array>(static_cast<unsigned int>(100));
}

void testing_std_array_output_conversion()
{
#ifndef BOOST_NO_CXX11_HDR_ARRAY
    testing_template_array_output_on_char_value<std::array>();
    testing_template_array_output_on_spec_value<std::array>(100);
    testing_template_array_output_on_spec_value<std::array>(static_cast<short>(100));
    testing_template_array_output_on_spec_value<std::array>(static_cast<unsigned short>(100));
    testing_template_array_output_on_spec_value<std::array>(static_cast<unsigned int>(100));
#endif

    BOOST_CHECK(true);
}

template <template <class, std::size_t> class ArrayT>
static void testing_generic_array_input_conversion()
{
    {
        ArrayT<char, 4> var_zero_terminated = {{ '1', '0', '0', '\0'}}; 
        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated), "100");
        BOOST_CHECK_EQUAL(lexical_cast<int>(var_zero_terminated), 100);

        ArrayT<char, 3> var_none_terminated = {{ '1', '0', '0'}}; 
        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated), "100");
        BOOST_CHECK_EQUAL(lexical_cast<short>(var_none_terminated), static_cast<short>(100));

        ArrayT<const char, 4> var_zero_terminated_const_char = {{ '1', '0', '0', '\0'}}; 
        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_char), "100");

        ArrayT<const char, 3> var_none_terminated_const_char = {{ '1', '0', '0'}}; 
        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_char), "100");

        const ArrayT<char, 4> var_zero_terminated_const_var = {{ '1', '0', '0', '\0'}}; 
        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var), "100");

        const ArrayT<char, 3> var_none_terminated_const_var = {{ '1', '0', '0'}}; 
        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var), "100");

        const ArrayT<const char, 4> var_zero_terminated_const_var_const_char = {{ '1', '0', '0', '\0'}}; 
        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");

        const ArrayT<const char, 3> var_none_terminated_const_var_const_char = {{ '1', '0', '0'}}; 
        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
        BOOST_CHECK_EQUAL(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
    }

    {
        const ArrayT<const unsigned char, 4> var_zero_terminated_const_var_const_char = {{ '1', '0', '0', '\0'}}; 
        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");

        const ArrayT<const unsigned char, 3> var_none_terminated_const_var_const_char = {{ '1', '0', '0'}}; 
        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
    }

    {
        const ArrayT<const signed char, 4> var_zero_terminated_const_var_const_char = {{ '1', '0', '0', '\0'}}; 
        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");

        const ArrayT<const signed char, 3> var_none_terminated_const_var_const_char = {{ '1', '0', '0'}}; 
        BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
        BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(var_none_terminated_const_var_const_char), 100u);
    }


#if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
    {
        const ArrayT<const wchar_t, 4> var_zero_terminated_const_var_const_char = {{ L'1', L'0', L'0', L'\0'}}; 
        BOOST_CHECK(lexical_cast<std::wstring>(var_zero_terminated_const_var_const_char) == L"100");

        const ArrayT<const wchar_t, 3> var_none_terminated_const_var_const_char = {{ L'1', L'0', L'0'}}; 
        BOOST_CHECK(lexical_cast<std::wstring>(var_none_terminated_const_var_const_char) == L"100");
        BOOST_CHECK_EQUAL(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
    }
#endif

#ifdef BOOST_LC_RUNU16
    {
        const ArrayT<const char16_t, 4> var_zero_terminated_const_var_const_char = {{ u'1', u'0', u'0', u'\0'}}; 
        BOOST_CHECK(lexical_cast<std::u16string>(var_zero_terminated_const_var_const_char) == u"100");
        BOOST_CHECK_EQUAL(lexical_cast<unsigned short>(var_zero_terminated_const_var_const_char), static_cast<unsigned short>(100));

        const ArrayT<const char16_t, 3> var_none_terminated_const_var_const_char = {{ u'1', u'0', u'0'}}; 
        BOOST_CHECK(lexical_cast<std::u16string>(var_none_terminated_const_var_const_char) == u"100");
    }
#endif

#ifdef BOOST_LC_RUNU32
    {
        const ArrayT<const char32_t, 4> var_zero_terminated_const_var_const_char = {{ U'1', U'0', U'0', U'\0'}}; 
        BOOST_CHECK(lexical_cast<std::u32string>(var_zero_terminated_const_var_const_char) == U"100");

        const ArrayT<const char32_t, 3> var_none_terminated_const_var_const_char = {{ U'1', U'0', U'0'}}; 
        BOOST_CHECK(lexical_cast<std::u32string>(var_none_terminated_const_var_const_char) == U"100");
        BOOST_CHECK_EQUAL(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
    }
#endif
}

void testing_boost_array_input_conversion()
{
    testing_generic_array_input_conversion<boost::array>();
}

void testing_std_array_input_conversion()
{
#ifndef BOOST_NO_CXX11_HDR_ARRAY
    testing_generic_array_input_conversion<std::array>();
#endif

    BOOST_CHECK(true);
}
Commit	Line	Data
7c673cae FG	1	// Testing boost::lexical_cast with boost::container::string.
	2	//
	3	// See http://www.boost.org for most recent version, including documentation.
	4	//
	5	// Copyright Antony Polukhin, 2012.
	6	//
	7	// Distributed under the Boost
	8	// Software License, Version 1.0. (See accompanying file
	9	// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
	10
	11	#include <boost/lexical_cast.hpp>
	12
	13	#include <boost/test/unit_test.hpp>
	14
	15	#include <boost/array.hpp>
	16
	17	void testing_boost_array_output_conversion();
	18	void testing_std_array_output_conversion();
	19
	20	void testing_boost_array_input_conversion();
	21	void testing_std_array_input_conversion();
	22
	23	using namespace boost;
	24
b32b8144	25	#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION) && !defined(BOOST_MSVC)
7c673cae FG	26	#define BOOST_LC_RUNU16
	27	#endif
	28
b32b8144	29	#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION) && !defined(BOOST_MSVC)
7c673cae FG	30	#define BOOST_LC_RUNU32
	31	#endif
	32
	33	boost::unit_test::test_suite init_unit_test_suite(int, char [])
	34	{
	35	unit_test::test_suite *suite =
	36	BOOST_TEST_SUITE("Testing boost::lexical_cast with boost::array and std::array");
	37
	38	suite->add(BOOST_TEST_CASE(testing_boost_array_output_conversion));
	39	suite->add(BOOST_TEST_CASE(testing_std_array_output_conversion));
	40	suite->add(BOOST_TEST_CASE(testing_boost_array_input_conversion));
	41	suite->add(BOOST_TEST_CASE(testing_std_array_input_conversion));
	42
	43	return suite;
	44	}
	45
	46	template <template <class, std::size_t> class ArrayT, class T>
	47	static void testing_template_array_output_on_spec_value(T val)
	48	{
	49	typedef ArrayT<char, 300> arr_type;
	50	typedef ArrayT<char, 1> short_arr_type;
	51	typedef ArrayT<unsigned char, 300> uarr_type;
	52	typedef ArrayT<unsigned char, 1> ushort_arr_type;
	53	typedef ArrayT<signed char, 4> sarr_type;
	54	typedef ArrayT<signed char, 3> sshort_arr_type;
	55
	56	std::string ethalon("100");
	57	using namespace std;
	58
	59	{
	60	arr_type res1 = lexical_cast<arr_type>(val);
	61	BOOST_CHECK_EQUAL(&res1[0], ethalon);
	62	const arr_type res2 = lexical_cast<arr_type>(val);
	63	BOOST_CHECK_EQUAL(&res2[0], ethalon);
	64	BOOST_CHECK_THROW(lexical_cast<short_arr_type>(val), boost::bad_lexical_cast);
	65	}
	66
	67	{
	68	uarr_type res1 = lexical_cast<uarr_type>(val);
	69	BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
	70	const uarr_type res2 = lexical_cast<uarr_type>(val);
	71	BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
	72	BOOST_CHECK_THROW(lexical_cast<ushort_arr_type>(val), boost::bad_lexical_cast);
	73	}
	74
	75	{
	76	sarr_type res1 = lexical_cast<sarr_type>(val);
	77	BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
	78	const sarr_type res2 = lexical_cast<sarr_type>(val);
	79	BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
	80	BOOST_CHECK_THROW(lexical_cast<sshort_arr_type>(val), boost::bad_lexical_cast);
	81	}
	82
	83	#if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
	84	typedef ArrayT<wchar_t, 300> warr_type;
	85	typedef ArrayT<wchar_t, 3> wshort_arr_type;
	86	std::wstring wethalon(L"100");
	87
	88	{
	89	warr_type res = lexical_cast<warr_type>(val);
	90	BOOST_CHECK(&res[0] == wethalon);
	91	}
	92
	93	{
94	const warr_type res = lexical_cast<warr_type>(val);
95	BOOST_CHECK(&res[0] == wethalon);
96	}
97
98	BOOST_CHECK_THROW(lexical_cast<wshort_arr_type>(val), boost::bad_lexical_cast);
99
100	#endif
101
102	#ifdef BOOST_LC_RUNU16
103	typedef ArrayT<char16_t, 300> u16arr_type;
104	typedef ArrayT<char16_t, 3> u16short_arr_type;
105	std::u16string u16ethalon(u"100");
106
107	{
108	u16arr_type res = lexical_cast<u16arr_type>(val);
109	BOOST_CHECK(&res[0] == u16ethalon);
110	}
111
112	{
113	const u16arr_type res = lexical_cast<u16arr_type>(val);
114	BOOST_CHECK(&res[0] == u16ethalon);
115	}
116
117	BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), boost::bad_lexical_cast);
118	#endif
119
120	#ifdef BOOST_LC_RUNU32
121	typedef ArrayT<char32_t, 300> u32arr_type;
122	typedef ArrayT<char32_t, 3> u32short_arr_type;
123	std::u32string u32ethalon(U"100");
124
125	{
126	u32arr_type res = lexical_cast<u32arr_type>(val);
127	BOOST_CHECK(&res[0] == u32ethalon);
128	}
129
130	{
131	const u32arr_type res = lexical_cast<u32arr_type>(val);
132	BOOST_CHECK(&res[0] == u32ethalon);
133	}
134
135	BOOST_CHECK_THROW(lexical_cast<u32short_arr_type>(val), boost::bad_lexical_cast);
136	#endif
137	}
138
139
140	template <template <class, std::size_t> class ArrayT>
141	static void testing_template_array_output_on_char_value()
142	{
143	typedef ArrayT<char, 300> arr_type;
144	typedef ArrayT<char, 1> short_arr_type;
145	typedef ArrayT<unsigned char, 300> uarr_type;
146	typedef ArrayT<unsigned char, 1> ushort_arr_type;
147	typedef ArrayT<signed char, 4> sarr_type;
148	typedef ArrayT<signed char, 3> sshort_arr_type;
149
150	const char val[] = "100";
151	std::string ethalon("100");
152	using namespace std;
153
154	{
155	arr_type res1 = lexical_cast<arr_type>(val);
156	BOOST_CHECK_EQUAL(&res1[0], ethalon);
157	const arr_type res2 = lexical_cast<arr_type>(val);
158	BOOST_CHECK_EQUAL(&res2[0], ethalon);
159	BOOST_CHECK_THROW(lexical_cast<short_arr_type>(val), boost::bad_lexical_cast);
160	}
161
162	{
163	uarr_type res1 = lexical_cast<uarr_type>(val);
164	BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
165	const uarr_type res2 = lexical_cast<uarr_type>(val);
166	BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
167	BOOST_CHECK_THROW(lexical_cast<ushort_arr_type>(val), boost::bad_lexical_cast);
168	}
169
170	{
171	sarr_type res1 = lexical_cast<sarr_type>(val);
172	BOOST_CHECK_EQUAL(reinterpret_cast<char*>(&res1[0]), ethalon);
173	const sarr_type res2 = lexical_cast<sarr_type>(val);
174	BOOST_CHECK_EQUAL(reinterpret_cast<const char*>(&res2[0]), ethalon);
175	BOOST_CHECK_THROW(lexical_cast<sshort_arr_type>(val), boost::bad_lexical_cast);
176	}
177
178	#if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
179	typedef ArrayT<wchar_t, 4> warr_type;
180	typedef ArrayT<wchar_t, 3> wshort_arr_type;
181	std::wstring wethalon(L"100");
182
183	{
184	warr_type res = lexical_cast<warr_type>(val);
185	BOOST_CHECK(&res[0] == wethalon);
186	warr_type res3 = lexical_cast<warr_type>(wethalon);
187	BOOST_CHECK(&res3[0] == wethalon);
188	}
189
190	{
191	const warr_type res = lexical_cast<warr_type>(val);
192	BOOST_CHECK(&res[0] == wethalon);
193	const warr_type res3 = lexical_cast<warr_type>(wethalon);
194	BOOST_CHECK(&res3[0] == wethalon);
195	}
196
197	BOOST_CHECK_THROW(lexical_cast<wshort_arr_type>(val), boost::bad_lexical_cast);
198
199	#endif
200
201	#ifdef BOOST_LC_RUNU16
202	typedef ArrayT<char16_t, 300> u16arr_type;
203	typedef ArrayT<char16_t, 3> u16short_arr_type;
204	std::u16string u16ethalon(u"100");
205
206	{
207	#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
208	u16arr_type res = lexical_cast<u16arr_type>(val);
209	BOOST_CHECK(&res[0] == u16ethalon);
210	#endif
211
212	u16arr_type res3 = lexical_cast<u16arr_type>(u16ethalon);
213	BOOST_CHECK(&res3[0] == u16ethalon);
214	}
215
216	{
217	#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
218	const u16arr_type res = lexical_cast<u16arr_type>(val);
219	BOOST_CHECK(&res[0] == u16ethalon);
220	#endif
221	const u16arr_type res3 = lexical_cast<u16arr_type>(u16ethalon);
222	BOOST_CHECK(&res3[0] == u16ethalon);
223	}
224
225	// Some compillers may throw std::bad_alloc here
226	BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), std::exception);
227	#endif
228
229	#ifdef BOOST_LC_RUNU32
230	typedef ArrayT<char32_t, 300> u32arr_type;
231	typedef ArrayT<char32_t, 3> u32short_arr_type;
232	std::u32string u32ethalon(U"100");
233
234	{
235	#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
236	u32arr_type res = lexical_cast<u32arr_type>(val);
237	BOOST_CHECK(&res[0] == u32ethalon);
238	#endif
239	u32arr_type res3 = lexical_cast<u32arr_type>(u32ethalon);
240	BOOST_CHECK(&res3[0] == u32ethalon);
241	}
242
243	{
244	#ifdef BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES
245	const u32arr_type res = lexical_cast<u32arr_type>(val);
246	BOOST_CHECK(&res[0] == u32ethalon);
247	#endif
248	const u32arr_type res3 = lexical_cast<u32arr_type>(u32ethalon);
249	BOOST_CHECK(&res3[0] == u32ethalon);
250	}
251
252	// Some compillers may throw std::bad_alloc here
253	BOOST_CHECK_THROW(lexical_cast<u32short_arr_type>(val), std::exception);
254	#endif
255	}
256
257
258	void testing_boost_array_output_conversion()
259	{
260	testing_template_array_output_on_char_value<boost::array>();
261	testing_template_array_output_on_spec_value<boost::array>(100);
262	testing_template_array_output_on_spec_value<boost::array>(static_cast<short>(100));
263	testing_template_array_output_on_spec_value<boost::array>(static_cast<unsigned short>(100));
264	testing_template_array_output_on_spec_value<boost::array>(static_cast<unsigned int>(100));
265	}
266
267	void testing_std_array_output_conversion()
268	{
269	#ifndef BOOST_NO_CXX11_HDR_ARRAY
270	testing_template_array_output_on_char_value<std::array>();
271	testing_template_array_output_on_spec_value<std::array>(100);
272	testing_template_array_output_on_spec_value<std::array>(static_cast<short>(100));
273	testing_template_array_output_on_spec_value<std::array>(static_cast<unsigned short>(100));
274	testing_template_array_output_on_spec_value<std::array>(static_cast<unsigned int>(100));
275	#endif
276
277	BOOST_CHECK(true);
278	}
279
280	template <template <class, std::size_t> class ArrayT>
281	static void testing_generic_array_input_conversion()
282	{
283	{
284	ArrayT<char, 4> var_zero_terminated = {{ '1', '0', '0', '\0'}};
285	BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated), "100");
286	BOOST_CHECK_EQUAL(lexical_cast<int>(var_zero_terminated), 100);
287
288	ArrayT<char, 3> var_none_terminated = {{ '1', '0', '0'}};
289	BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated), "100");
290	BOOST_CHECK_EQUAL(lexical_cast<short>(var_none_terminated), static_cast<short>(100));
291
292	ArrayT<const char, 4> var_zero_terminated_const_char = {{ '1', '0', '0', '\0'}};
293	BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_char), "100");
294
295	ArrayT<const char, 3> var_none_terminated_const_char = {{ '1', '0', '0'}};
296	BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_char), "100");
297
298	const ArrayT<char, 4> var_zero_terminated_const_var = {{ '1', '0', '0', '\0'}};
299	BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var), "100");
300
301	const ArrayT<char, 3> var_none_terminated_const_var = {{ '1', '0', '0'}};
302	BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var), "100");
303
304	const ArrayT<const char, 4> var_zero_terminated_const_var_const_char = {{ '1', '0', '0', '\0'}};
305	BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");
306
307	const ArrayT<const char, 3> var_none_terminated_const_var_const_char = {{ '1', '0', '0'}};
308	BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
309	BOOST_CHECK_EQUAL(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
310	}
311
312	{
313	const ArrayT<const unsigned char, 4> var_zero_terminated_const_var_const_char = {{ '1', '0', '0', '\0'}};
314	BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");
315
316	const ArrayT<const unsigned char, 3> var_none_terminated_const_var_const_char = {{ '1', '0', '0'}};
317	BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
318	}
319
320	{
321	const ArrayT<const signed char, 4> var_zero_terminated_const_var_const_char = {{ '1', '0', '0', '\0'}};
322	BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_zero_terminated_const_var_const_char), "100");
323
324	const ArrayT<const signed char, 3> var_none_terminated_const_var_const_char = {{ '1', '0', '0'}};
325	BOOST_CHECK_EQUAL(lexical_cast<std::string>(var_none_terminated_const_var_const_char), "100");
326	BOOST_CHECK_EQUAL(lexical_cast<unsigned int>(var_none_terminated_const_var_const_char), 100u);
327	}
328
329
330	#if !defined(BOOST_NO_STRINGSTREAM) && !defined(BOOST_NO_STD_WSTRING)
331	{
332	const ArrayT<const wchar_t, 4> var_zero_terminated_const_var_const_char = {{ L'1', L'0', L'0', L'\0'}};
333	BOOST_CHECK(lexical_cast<std::wstring>(var_zero_terminated_const_var_const_char) == L"100");
334
335	const ArrayT<const wchar_t, 3> var_none_terminated_const_var_const_char = {{ L'1', L'0', L'0'}};
336	BOOST_CHECK(lexical_cast<std::wstring>(var_none_terminated_const_var_const_char) == L"100");
337	BOOST_CHECK_EQUAL(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
338	}
339	#endif
340
341	#ifdef BOOST_LC_RUNU16
342	{
343	const ArrayT<const char16_t, 4> var_zero_terminated_const_var_const_char = {{ u'1', u'0', u'0', u'\0'}};
344	BOOST_CHECK(lexical_cast<std::u16string>(var_zero_terminated_const_var_const_char) == u"100");
345	BOOST_CHECK_EQUAL(lexical_cast<unsigned short>(var_zero_terminated_const_var_const_char), static_cast<unsigned short>(100));
346
347	const ArrayT<const char16_t, 3> var_none_terminated_const_var_const_char = {{ u'1', u'0', u'0'}};
348	BOOST_CHECK(lexical_cast<std::u16string>(var_none_terminated_const_var_const_char) == u"100");
349	}
350	#endif
351
352	#ifdef BOOST_LC_RUNU32
353	{
354	const ArrayT<const char32_t, 4> var_zero_terminated_const_var_const_char = {{ U'1', U'0', U'0', U'\0'}};
355	BOOST_CHECK(lexical_cast<std::u32string>(var_zero_terminated_const_var_const_char) == U"100");
356
357	const ArrayT<const char32_t, 3> var_none_terminated_const_var_const_char = {{ U'1', U'0', U'0'}};
358	BOOST_CHECK(lexical_cast<std::u32string>(var_none_terminated_const_var_const_char) == U"100");
359	BOOST_CHECK_EQUAL(lexical_cast<int>(var_none_terminated_const_var_const_char), 100);
360	}
361	#endif
362	}
363
364	void testing_boost_array_input_conversion()
365	{
366	testing_generic_array_input_conversion<boost::array>();
367	}
368
369	void testing_std_array_input_conversion()
370	{
371	#ifndef BOOST_NO_CXX11_HDR_ARRAY
372	testing_generic_array_input_conversion<std::array>();
373	#endif
374
375	BOOST_CHECK(true);
376	}
377