forked from boostorg/conversion
Merge lexical_cast from trunk:
* Deduce stream character type for user defined classes (fixes #6786) * Deprecated macros replaced with new ones (thanks to Marshall Clow) * Updated documentation (refs #6786, fixes #7582) * More tests and minor bugfixes [SVN r81668]
This commit is contained in:
Antony Polukhin
@@ -119,15 +119,14 @@ The requirements on the argument and result types for both functions are:
|
||||
* Target is CopyConstructible [20.1.3].
|
||||
* Target is DefaultConstructible, meaning that it is possible to default-initialize an object of that type [8.5, 20.1.4].
|
||||
|
||||
The character type of the underlying stream is assumed to be `char` unless either the `Source` or the `Target` requires wide-character streaming, in which case the underlying stream uses `wchar_t`, `char16_t` or `char32_t`. Wide-character streaming is currently detected for:
|
||||
The character type of the underlying stream is assumed to be `char` unless either the `Source` or the `Target` requires wide-character streaming, in which case the underlying stream uses `wchar_t`. Following types also can use `char16_t` or `char32_t` for wide-character streaming:
|
||||
|
||||
* Single character: `wchar_t`, `char16_t`, `char32_t`
|
||||
* Arrays of characters: `wchar_t *`, `char16_t *`, `char32_t *`, `const wchar_t *`, `const char16_t *`, `const char32_t *`
|
||||
* Single character: `char16_t`, `char32_t`
|
||||
* Arrays of characters: `char16_t *`, `char32_t *`, `const char16_t *`, `const char32_t *`
|
||||
* Strings: `std::basic_string`, `boost::containers::basic_string`
|
||||
* `boost::iterator_range<WideCharPtr>`, where `WideCharPtr` is a pointer to wide-character or pointer to const wide-character
|
||||
* `boost::array<CharT, N>` and `std::array<CharT, N>`, `boost::array<const CharT, N>` and `std::array<const CharT, N>`
|
||||
|
||||
|
||||
[important Many compilers and runtime libraries fail to make conversions using new Unicode characters. Make sure that the following code compiles and outputs nonzero values, before using new types:
|
||||
``
|
||||
std::cout
|
||||
@@ -235,7 +234,7 @@ It breaks my `operator>>` that works only in presence of this flag. Can you remo
|
||||
* [*Answer:] May be in a future version. There is no requirement in
|
||||
__proposallong__ to reset the flag but
|
||||
remember that __proposalshort__ is not yet accepted by the committee. By the way, it's a great opportunity to
|
||||
make your `operator>>` conform to the standard.
|
||||
make your `operator>>` more general.
|
||||
Read a good C++ book, study `std::sentry` and [@boost:libs/io/doc/ios_state.html `ios_state_saver`].
|
||||
|
||||
[pre
|
||||
@@ -273,6 +272,10 @@ limitation of compiler options that you use.
|
||||
|
||||
[section Changes]
|
||||
|
||||
* [*boost 1.53.0 :]
|
||||
|
||||
* Much better input and output streams detection for user defined types.
|
||||
|
||||
* [*boost 1.52.0 :]
|
||||
|
||||
* Restored compilation on MSVC-2003 (was broken in 1.51.0).
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -82,10 +82,10 @@ void test_wallocator();
|
||||
#endif
|
||||
void test_char_types_conversions();
|
||||
void operators_overload_test();
|
||||
#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
void test_char16_conversions();
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
void test_char32_conversions();
|
||||
#endif
|
||||
void test_getting_pointer_to_function();
|
||||
@@ -120,10 +120,10 @@ unit_test::test_suite *init_unit_test_suite(int, char *[])
|
||||
|
||||
suite->add(BOOST_TEST_CASE(&test_char_types_conversions));
|
||||
suite->add(BOOST_TEST_CASE(&operators_overload_test));
|
||||
#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
suite->add(BOOST_TEST_CASE(&test_char16_conversions));
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
suite->add(BOOST_TEST_CASE(&test_char32_conversions));
|
||||
#endif
|
||||
suite->add(BOOST_TEST_CASE(&test_getting_pointer_to_function));
|
||||
@@ -243,9 +243,15 @@ void test_conversion_to_bool()
|
||||
BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0));
|
||||
BOOST_CHECK_THROW(lexical_cast<bool>(123), bad_lexical_cast);
|
||||
BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1.0));
|
||||
BOOST_CHECK_THROW(lexical_cast<bool>(-123), bad_lexical_cast);
|
||||
BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0.0));
|
||||
BOOST_CHECK_THROW(lexical_cast<bool>(1234), bad_lexical_cast);
|
||||
#if !defined(_CRAYC)
|
||||
// Looks like a bug in CRAY compiler (throws bad_lexical_cast)
|
||||
// TODO: localize the bug and report it to developers.
|
||||
BOOST_CHECK_EQUAL(true, lexical_cast<bool>(true));
|
||||
BOOST_CHECK_EQUAL(false, lexical_cast<bool>(false));
|
||||
#endif
|
||||
BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
|
||||
BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
|
||||
BOOST_CHECK_THROW(lexical_cast<bool>(""), bad_lexical_cast);
|
||||
@@ -585,7 +591,7 @@ void operators_overload_test()
|
||||
}
|
||||
|
||||
|
||||
#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
void test_char16_conversions()
|
||||
{
|
||||
BOOST_CHECK(u"100" == lexical_cast<std::u16string>(u"100"));
|
||||
@@ -593,7 +599,7 @@ void test_char16_conversions()
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
void test_char32_conversions()
|
||||
{
|
||||
BOOST_CHECK(U"100" == lexical_cast<std::u32string>(U"100"));
|
||||
@@ -601,17 +607,21 @@ void test_char32_conversions()
|
||||
}
|
||||
#endif
|
||||
|
||||
template <class To, class From, class Func>
|
||||
To try_cast_by_ptr(const From& from, const Func& f) {
|
||||
return f(from);
|
||||
};
|
||||
|
||||
void test_getting_pointer_to_function()
|
||||
{
|
||||
// Just checking that &lexical_cast<To, From> is not ambiguous
|
||||
BOOST_CHECK_EQUAL(100, try_cast_by_ptr<int>("100", &boost::lexical_cast<int, const char[4]>));
|
||||
BOOST_CHECK_EQUAL(100, try_cast_by_ptr<int>("100", &boost::lexical_cast<int, std::string>));
|
||||
BOOST_CHECK_EQUAL(std::string("100"), try_cast_by_ptr<std::string>(100, &boost::lexical_cast<std::string, int>));
|
||||
typedef char char_arr[4];
|
||||
typedef int(*f1)(const char_arr&);
|
||||
f1 p1 = &boost::lexical_cast<int, char_arr>;
|
||||
BOOST_CHECK(p1);
|
||||
|
||||
typedef int(*f2)(const std::string&);
|
||||
f2 p2 = &boost::lexical_cast<int, std::string>;
|
||||
BOOST_CHECK(p2);
|
||||
|
||||
typedef std::string(*f3)(const int&);
|
||||
f3 p3 = &boost::lexical_cast<std::string, int>;
|
||||
BOOST_CHECK(p3);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -49,5 +49,7 @@ test-suite conversion
|
||||
[ run lexical_cast_iterator_range_test.cpp ]
|
||||
[ run lexical_cast_arrays_test.cpp ]
|
||||
[ run lexical_cast_integral_types_test.cpp ]
|
||||
[ run lexical_cast_stream_detection_test.cpp ]
|
||||
[ run lexical_cast_stream_traits_test.cpp ]
|
||||
;
|
||||
|
||||
|
||||
@@ -91,7 +91,7 @@ static void testing_template_array_output_on_spec_value(T val)
|
||||
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
typedef ArrayT<char16_t, 300> u16arr_type;
|
||||
typedef ArrayT<char16_t, 3> u16short_arr_type;
|
||||
std::u16string u16ethalon(u"100");
|
||||
@@ -109,7 +109,7 @@ static void testing_template_array_output_on_spec_value(T val)
|
||||
BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), boost::bad_lexical_cast);
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
typedef ArrayT<char32_t, 300> u32arr_type;
|
||||
typedef ArrayT<char32_t, 3> u32short_arr_type;
|
||||
std::u32string u32ethalon(U"100");
|
||||
@@ -190,7 +190,7 @@ static void testing_template_array_output_on_char_value()
|
||||
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
typedef ArrayT<char16_t, 300> u16arr_type;
|
||||
typedef ArrayT<char16_t, 3> u16short_arr_type;
|
||||
std::u16string u16ethalon(u"100");
|
||||
@@ -217,7 +217,7 @@ static void testing_template_array_output_on_char_value()
|
||||
BOOST_CHECK_THROW(lexical_cast<u16short_arr_type>(val), boost::bad_lexical_cast);
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
typedef ArrayT<char32_t, 300> u32arr_type;
|
||||
typedef ArrayT<char32_t, 3> u32short_arr_type;
|
||||
std::u32string u32ethalon(U"100");
|
||||
@@ -328,7 +328,7 @@ static void testing_generic_array_input_conversion()
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
{
|
||||
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");
|
||||
@@ -339,7 +339,7 @@ static void testing_generic_array_input_conversion()
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
{
|
||||
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");
|
||||
|
||||
@@ -71,12 +71,12 @@ void testing_boost_containers_string_widening()
|
||||
BOOST_CHECK(boost::lexical_cast<boost::container::wstring>(char_array) == wchar_array);
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
const char16_t char16_array[] = u"Test string";
|
||||
BOOST_CHECK(boost::lexical_cast<boost::container::basic_string<char16_t> >(char_array) == char16_array);
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
const char32_t char32_array[] = U"Test string";
|
||||
BOOST_CHECK(boost::lexical_cast<boost::container::basic_string<char32_t> >(char_array) == char32_array);
|
||||
#endif
|
||||
|
||||
@@ -84,12 +84,12 @@ void test_empty_string()
|
||||
#endif
|
||||
|
||||
// Currently, no compiler and STL library fully support char16_t and char32_t
|
||||
//#ifndef BOOST_NO_CHAR16_T
|
||||
//#ifndef BOOST_NO_CXX11_CHAR16_T
|
||||
// std::basic_string<char16_t> v16w;
|
||||
// do_test_on_empty_input(v16w);
|
||||
// BOOST_CHECK_THROW(lexical_cast<char16_t>(v16w), bad_lexical_cast);
|
||||
//#endif
|
||||
//#ifndef BOOST_NO_CHAR32_T
|
||||
//#ifndef BOOST_NO_CXX11_CHAR32_T
|
||||
// std::basic_string<char32_t> v32w;
|
||||
// do_test_on_empty_input(v32w);
|
||||
// BOOST_CHECK_THROW(lexical_cast<char32_t>(v32w), bad_lexical_cast);
|
||||
|
||||
@@ -505,7 +505,11 @@ void test_conversion_from_to_double()
|
||||
}
|
||||
void test_conversion_from_to_long_double()
|
||||
{
|
||||
// We do not run tests on compilers with bugs
|
||||
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
|
||||
test_conversion_from_to_float<long double>();
|
||||
#endif
|
||||
BOOST_CHECK(true);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -186,7 +186,11 @@ void test_inf_nan_double()
|
||||
|
||||
void test_inf_nan_long_double()
|
||||
{
|
||||
// We do not run tests on compilers with bugs
|
||||
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
|
||||
test_inf_nan_templated<long double >();
|
||||
#endif
|
||||
BOOST_CHECK(true);
|
||||
}
|
||||
|
||||
unit_test::test_suite *init_unit_test_suite(int, char *[])
|
||||
|
||||
@@ -386,12 +386,12 @@ void test_conversion_from_to_integral()
|
||||
test_conversion_from_integral_to_char<T>(wzero);
|
||||
test_conversion_from_char_to_integral<T>(wzero);
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
char16_t const u16zero = u'0';
|
||||
test_conversion_from_integral_to_char<T>(u16zero);
|
||||
test_conversion_from_char_to_integral<T>(u16zero);
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
char32_t const u32zero = u'0';
|
||||
test_conversion_from_integral_to_char<T>(u32zero);
|
||||
test_conversion_from_char_to_integral<T>(u32zero);
|
||||
|
||||
@@ -134,7 +134,7 @@ void test_it_range_using_char(CharT* one, CharT* eleven)
|
||||
BOOST_CHECK(lexical_cast<std::wstring>(crng2) == L"1");
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
typedef std::basic_string<char16_t> my_char16_string;
|
||||
BOOST_CHECK(lexical_cast<my_char16_string>(rng1) == u"1");
|
||||
BOOST_CHECK(lexical_cast<my_char16_string>(crng1) == u"1");
|
||||
@@ -142,7 +142,7 @@ void test_it_range_using_char(CharT* one, CharT* eleven)
|
||||
BOOST_CHECK(lexical_cast<my_char16_string>(crng2) == u"1");
|
||||
#endif
|
||||
|
||||
#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
typedef std::basic_string<char32_t> my_char32_string;
|
||||
BOOST_CHECK(lexical_cast<my_char32_string>(rng1) == U"1");
|
||||
BOOST_CHECK(lexical_cast<my_char32_string>(crng1) == U"1");
|
||||
@@ -194,7 +194,7 @@ void test_wchar_iterator_ranges()
|
||||
|
||||
void test_char16_iterator_ranges()
|
||||
{
|
||||
#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
typedef char16_t test_char_type;
|
||||
test_char_type data1[] = u"1";
|
||||
test_char_type data2[] = u"11";
|
||||
@@ -206,7 +206,7 @@ void test_char16_iterator_ranges()
|
||||
|
||||
void test_char32_iterator_ranges()
|
||||
{
|
||||
#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
|
||||
typedef char32_t test_char_type;
|
||||
test_char_type data1[] = U"1";
|
||||
test_char_type data2[] = U"11";
|
||||
|
||||
@@ -86,7 +86,11 @@ void test_round_conversion_double()
|
||||
|
||||
void test_round_conversion_long_double()
|
||||
{
|
||||
// We do not run tests on compilers with bugs
|
||||
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
|
||||
test_round_conversion<long double>();
|
||||
test_msvc_magic_values<long double>();
|
||||
#endif
|
||||
BOOST_CHECK(true);
|
||||
}
|
||||
|
||||
|
||||
307
test/lexical_cast_stream_detection_test.cpp
Normal file
307
test/lexical_cast_stream_detection_test.cpp
Normal file
@@ -0,0 +1,307 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// See http://www.boost.org for most recent version, including documentation.
|
||||
//
|
||||
// Copyright Antony Polukhin, 2011-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/config.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#include <iostream>
|
||||
|
||||
|
||||
///////////////////////// char streamable classes ///////////////////////////////////////////
|
||||
|
||||
struct streamable_easy { enum ENU {value = 0}; };
|
||||
std::ostream& operator << (std::ostream& ostr, const streamable_easy&) {
|
||||
return ostr << streamable_easy::value;
|
||||
}
|
||||
std::istream& operator >> (std::istream& istr, const streamable_easy&) {
|
||||
int i; istr >> i; BOOST_CHECK_EQUAL(i, streamable_easy::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct streamable_medium { enum ENU {value = 1}; };
|
||||
template <class CharT>
|
||||
typename boost::enable_if<boost::is_same<CharT, char>, std::basic_ostream<CharT>&>::type
|
||||
operator << (std::basic_ostream<CharT>& ostr, const streamable_medium&) {
|
||||
return ostr << streamable_medium::value;
|
||||
}
|
||||
template <class CharT>
|
||||
typename boost::enable_if<boost::is_same<CharT, char>, std::basic_istream<CharT>&>::type
|
||||
operator >> (std::basic_istream<CharT>& istr, const streamable_medium&) {
|
||||
int i; istr >> i; BOOST_CHECK_EQUAL(i, streamable_medium::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct streamable_hard { enum ENU {value = 2}; };
|
||||
template <class CharT, class TraitsT>
|
||||
typename boost::enable_if<boost::is_same<CharT, char>, std::basic_ostream<CharT, TraitsT>&>::type
|
||||
operator << (std::basic_ostream<CharT, TraitsT>& ostr, const streamable_hard&) {
|
||||
return ostr << streamable_hard::value;
|
||||
}
|
||||
template <class CharT, class TraitsT>
|
||||
typename boost::enable_if<boost::is_same<CharT, char>, std::basic_istream<CharT, TraitsT>&>::type
|
||||
operator >> (std::basic_istream<CharT, TraitsT>& istr, const streamable_hard&) {
|
||||
int i; istr >> i; BOOST_CHECK_EQUAL(i, streamable_hard::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct streamable_hard2 { enum ENU {value = 3}; };
|
||||
template <class TraitsT>
|
||||
std::basic_ostream<char, TraitsT>& operator << (std::basic_ostream<char, TraitsT>& ostr, const streamable_hard2&) {
|
||||
return ostr << streamable_hard2::value;
|
||||
}
|
||||
template <class TraitsT>
|
||||
std::basic_istream<char, TraitsT>& operator >> (std::basic_istream<char, TraitsT>& istr, const streamable_hard2&) {
|
||||
int i; istr >> i; BOOST_CHECK_EQUAL(i, streamable_hard2::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
|
||||
///////////////////////// wchar_t streamable classes ///////////////////////////////////////////
|
||||
|
||||
struct wstreamable_easy { enum ENU {value = 4}; };
|
||||
std::wostream& operator << (std::wostream& ostr, const wstreamable_easy&) {
|
||||
return ostr << wstreamable_easy::value;
|
||||
}
|
||||
std::wistream& operator >> (std::wistream& istr, const wstreamable_easy&) {
|
||||
int i; istr >> i; BOOST_CHECK_EQUAL(i, wstreamable_easy::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct wstreamable_medium { enum ENU {value = 5}; };
|
||||
template <class CharT>
|
||||
typename boost::enable_if<boost::is_same<CharT, wchar_t>, std::basic_ostream<CharT>& >::type
|
||||
operator << (std::basic_ostream<CharT>& ostr, const wstreamable_medium&) {
|
||||
return ostr << wstreamable_medium::value;
|
||||
}
|
||||
template <class CharT>
|
||||
typename boost::enable_if<boost::is_same<CharT, wchar_t>, std::basic_istream<CharT>& >::type
|
||||
operator >> (std::basic_istream<CharT>& istr, const wstreamable_medium&) {
|
||||
int i; istr >> i; BOOST_CHECK_EQUAL(i, wstreamable_medium::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct wstreamable_hard { enum ENU {value = 6}; };
|
||||
template <class CharT, class TraitsT>
|
||||
typename boost::enable_if<boost::is_same<CharT, wchar_t>, std::basic_ostream<CharT, TraitsT>&>::type
|
||||
operator << (std::basic_ostream<CharT, TraitsT>& ostr, const wstreamable_hard&) {
|
||||
return ostr << wstreamable_hard::value;
|
||||
}
|
||||
template <class CharT, class TraitsT>
|
||||
typename boost::enable_if<boost::is_same<CharT, wchar_t>, std::basic_istream<CharT, TraitsT>&>::type
|
||||
operator >> (std::basic_istream<CharT, TraitsT>& istr, const wstreamable_hard&) {
|
||||
int i; istr >> i; BOOST_CHECK_EQUAL(i, wstreamable_hard::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct wstreamable_hard2 { enum ENU {value = 7}; };
|
||||
template <class TraitsT>
|
||||
std::basic_ostream<wchar_t, TraitsT>& operator << (std::basic_ostream<wchar_t, TraitsT>& ostr, const wstreamable_hard2&) {
|
||||
return ostr << wstreamable_hard2::value;
|
||||
}
|
||||
template <class TraitsT>
|
||||
std::basic_istream<wchar_t, TraitsT>& operator >> (std::basic_istream<wchar_t, TraitsT>& istr, const wstreamable_hard2&) {
|
||||
int i; istr >> i; BOOST_CHECK_EQUAL(i, wstreamable_hard2::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
///////////////////////// char and wchar_t streamable classes ///////////////////////////////////////////
|
||||
|
||||
|
||||
struct bistreamable_easy { enum ENU {value = 8}; };
|
||||
std::ostream& operator << (std::ostream& ostr, const bistreamable_easy&) {
|
||||
return ostr << bistreamable_easy::value;
|
||||
}
|
||||
std::istream& operator >> (std::istream& istr, const bistreamable_easy&) {
|
||||
int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_easy::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
std::wostream& operator << (std::wostream& ostr, const bistreamable_easy&) {
|
||||
return ostr << bistreamable_easy::value + 100;
|
||||
}
|
||||
std::wistream& operator >> (std::wistream& istr, const bistreamable_easy&) {
|
||||
int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_easy::value + 100);
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct bistreamable_medium { enum ENU {value = 9}; };
|
||||
template <class CharT>
|
||||
std::basic_ostream<CharT>& operator << (std::basic_ostream<CharT>& ostr, const bistreamable_medium&) {
|
||||
return ostr << bistreamable_medium::value + (sizeof(CharT) == 1 ? 0 : 100);
|
||||
}
|
||||
template <class CharT>
|
||||
std::basic_istream<CharT>& operator >> (std::basic_istream<CharT>& istr, const bistreamable_medium&) {
|
||||
int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_medium::value + (sizeof(CharT) == 1 ? 0 : 100));
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct bistreamable_hard { enum ENU {value = 10}; };
|
||||
template <class CharT, class TraitsT>
|
||||
std::basic_ostream<CharT, TraitsT>& operator << (std::basic_ostream<CharT, TraitsT>& ostr, const bistreamable_hard&) {
|
||||
return ostr << bistreamable_hard::value + (sizeof(CharT) == 1 ? 0 : 100);
|
||||
}
|
||||
template <class CharT, class TraitsT>
|
||||
std::basic_istream<CharT, TraitsT>& operator >> (std::basic_istream<CharT, TraitsT>& istr, const bistreamable_hard&) {
|
||||
int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_hard::value + (sizeof(CharT) == 1 ? 0 : 100));
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct bistreamable_hard2 { enum ENU {value = 11}; };
|
||||
template <class TraitsT>
|
||||
std::basic_ostream<char, TraitsT>& operator << (std::basic_ostream<char, TraitsT>& ostr, const bistreamable_hard2&) {
|
||||
return ostr << bistreamable_hard2::value;
|
||||
}
|
||||
template <class TraitsT>
|
||||
std::basic_istream<char, TraitsT>& operator >> (std::basic_istream<char, TraitsT>& istr, const bistreamable_hard2&) {
|
||||
int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_hard2::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
template <class TraitsT>
|
||||
std::basic_ostream<wchar_t, TraitsT>& operator << (std::basic_ostream<wchar_t, TraitsT>& ostr, const bistreamable_hard2&) {
|
||||
return ostr << bistreamable_hard2::value + 100;
|
||||
}
|
||||
template <class TraitsT>
|
||||
std::basic_istream<wchar_t, TraitsT>& operator >> (std::basic_istream<wchar_t, TraitsT>& istr, const bistreamable_hard2&) {
|
||||
int i; istr >> i; BOOST_CHECK_EQUAL(i, bistreamable_hard2::value + 100);
|
||||
return istr;
|
||||
}
|
||||
|
||||
|
||||
void test_ostream_character_detection();
|
||||
void test_istream_character_detection();
|
||||
void test_mixed_stream_character_detection();
|
||||
|
||||
boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
|
||||
{
|
||||
boost::unit_test::test_suite *suite =
|
||||
BOOST_TEST_SUITE("lexical_cast stream character detection");
|
||||
suite->add(BOOST_TEST_CASE(&test_ostream_character_detection));
|
||||
suite->add(BOOST_TEST_CASE(&test_istream_character_detection));
|
||||
suite->add(BOOST_TEST_CASE(&test_mixed_stream_character_detection));
|
||||
|
||||
return suite;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
static void test_ostr_impl() {
|
||||
T streamable;
|
||||
BOOST_CHECK_EQUAL(T::value, boost::lexical_cast<int>(streamable));
|
||||
BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(T::value), boost::lexical_cast<std::string>(streamable));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
static void test_wostr_impl() {
|
||||
T streamable;
|
||||
BOOST_CHECK_EQUAL(T::value, boost::lexical_cast<int>(streamable));
|
||||
// BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(T::value), boost::lexical_cast<std::string>(streamable)); // Shall not compile???
|
||||
BOOST_CHECK(boost::lexical_cast<std::wstring>(T::value) == boost::lexical_cast<std::wstring>(streamable));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
static void test_bistr_impl() {
|
||||
T streamable;
|
||||
|
||||
BOOST_CHECK_EQUAL(T::value, boost::lexical_cast<int>(streamable));
|
||||
BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(T::value), boost::lexical_cast<std::string>(streamable));
|
||||
|
||||
BOOST_CHECK(boost::lexical_cast<std::wstring>(T::value + 100) == boost::lexical_cast<std::wstring>(streamable));
|
||||
}
|
||||
|
||||
void test_ostream_character_detection() {
|
||||
test_ostr_impl<streamable_easy>();
|
||||
test_ostr_impl<streamable_medium>();
|
||||
test_ostr_impl<streamable_hard>();
|
||||
test_ostr_impl<streamable_hard2>();
|
||||
|
||||
test_wostr_impl<wstreamable_easy>();
|
||||
test_wostr_impl<wstreamable_medium>();
|
||||
test_wostr_impl<wstreamable_hard>();
|
||||
test_wostr_impl<wstreamable_hard2>();
|
||||
|
||||
test_bistr_impl<bistreamable_easy>();
|
||||
test_bistr_impl<bistreamable_medium>();
|
||||
test_bistr_impl<bistreamable_hard>();
|
||||
test_bistr_impl<bistreamable_hard2>();
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
static void test_istr_impl() {
|
||||
boost::lexical_cast<T>(T::value);
|
||||
boost::lexical_cast<T>(boost::lexical_cast<std::string>(T::value));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
static void test_wistr_impl() {
|
||||
boost::lexical_cast<T>(T::value);
|
||||
//boost::lexical_cast<T>(boost::lexical_cast<std::string>(T::value)); // Shall not compile???
|
||||
boost::lexical_cast<T>(boost::lexical_cast<std::wstring>(T::value));
|
||||
}
|
||||
|
||||
template <class T>
|
||||
static void test_bistr_instr_impl() {
|
||||
boost::lexical_cast<T>(T::value);
|
||||
boost::lexical_cast<T>(boost::lexical_cast<std::string>(T::value));
|
||||
boost::lexical_cast<T>(boost::lexical_cast<std::wstring>(T::value + 100));
|
||||
}
|
||||
|
||||
void test_istream_character_detection() {
|
||||
test_istr_impl<streamable_easy>();
|
||||
test_istr_impl<streamable_medium>();
|
||||
test_istr_impl<streamable_hard>();
|
||||
test_istr_impl<streamable_hard2>();
|
||||
|
||||
test_wistr_impl<wstreamable_easy>();
|
||||
test_wistr_impl<wstreamable_medium>();
|
||||
test_wistr_impl<wstreamable_hard>();
|
||||
test_wistr_impl<wstreamable_hard2>();
|
||||
|
||||
test_bistr_instr_impl<bistreamable_easy>();
|
||||
test_bistr_instr_impl<bistreamable_medium>();
|
||||
test_bistr_instr_impl<bistreamable_hard>();
|
||||
test_bistr_instr_impl<bistreamable_hard2>();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
struct wistreamble_ostreamable { enum ENU {value = 200}; };
|
||||
std::ostream& operator << (std::ostream& ostr, const wistreamble_ostreamable&) {
|
||||
return ostr << wistreamble_ostreamable::value;
|
||||
}
|
||||
std::wistream& operator >> (std::wistream& istr, const wistreamble_ostreamable&) {
|
||||
int i; istr >> i; BOOST_CHECK_EQUAL(i, wistreamble_ostreamable::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
struct istreamble_wostreamable { enum ENU {value = 201}; };
|
||||
std::wostream& operator << (std::wostream& ostr, const istreamble_wostreamable&) {
|
||||
return ostr << istreamble_wostreamable::value;
|
||||
}
|
||||
std::istream& operator >> (std::istream& istr, const istreamble_wostreamable&) {
|
||||
int i; istr >> i; BOOST_CHECK_EQUAL(i, istreamble_wostreamable::value);
|
||||
return istr;
|
||||
}
|
||||
|
||||
void test_mixed_stream_character_detection() {
|
||||
//boost::lexical_cast<std::wstring>(std::string("qwe")); // TODO: ALLOW IT AS EXTENSION!
|
||||
|
||||
boost::lexical_cast<wistreamble_ostreamable>(wistreamble_ostreamable::value);
|
||||
BOOST_CHECK_EQUAL(boost::lexical_cast<int>(wistreamble_ostreamable()), wistreamble_ostreamable::value);
|
||||
|
||||
boost::lexical_cast<istreamble_wostreamable>(istreamble_wostreamable::value);
|
||||
BOOST_CHECK_EQUAL(boost::lexical_cast<int>(istreamble_wostreamable()), istreamble_wostreamable::value);
|
||||
}
|
||||
155
test/lexical_cast_stream_traits_test.cpp
Normal file
155
test/lexical_cast_stream_traits_test.cpp
Normal file
@@ -0,0 +1,155 @@
|
||||
// Unit test for boost::lexical_cast.
|
||||
//
|
||||
// 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/config.hpp>
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
template <class T>
|
||||
static void test_optimized_types_to_string_const()
|
||||
{
|
||||
namespace de = boost::detail;
|
||||
typedef de::lexical_cast_stream_traits<T, std::string> trait_1;
|
||||
BOOST_CHECK(!trait_1::is_source_input_not_optimized_t::value);
|
||||
BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_1::src_char_t, char>::value));
|
||||
BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_1::target_char_t, char>::value));
|
||||
BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_1::char_type, char>::value));
|
||||
BOOST_CHECK(!trait_1::is_string_widening_required_t::value);
|
||||
BOOST_CHECK(!trait_1::is_source_input_not_optimized_t::value);
|
||||
|
||||
typedef de::lexical_cast_stream_traits<const T, std::string> trait_2;
|
||||
BOOST_CHECK(!trait_2::is_source_input_not_optimized_t::value);
|
||||
BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_2::src_char_t, char>::value));
|
||||
BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_2::target_char_t, char>::value));
|
||||
BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_2::char_type, char>::value));
|
||||
BOOST_CHECK(!trait_2::is_string_widening_required_t::value);
|
||||
BOOST_CHECK(!trait_2::is_source_input_not_optimized_t::value);
|
||||
|
||||
typedef de::lexical_cast_stream_traits<T, std::wstring> trait_3;
|
||||
BOOST_CHECK(!trait_3::is_source_input_not_optimized_t::value);
|
||||
BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_3::src_char_t, char>::value));
|
||||
BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_3::target_char_t, wchar_t>::value));
|
||||
BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_3::char_type, wchar_t>::value));
|
||||
|
||||
BOOST_CHECK((boost::detail::is_char_or_wchar<BOOST_DEDUCED_TYPENAME trait_3::no_cv_src>::value != trait_3::is_string_widening_required_t::value));
|
||||
|
||||
BOOST_CHECK(!trait_3::is_source_input_not_optimized_t::value);
|
||||
}
|
||||
|
||||
|
||||
template <class T>
|
||||
static void test_optimized_types_to_string()
|
||||
{
|
||||
test_optimized_types_to_string_const<T>();
|
||||
|
||||
namespace de = boost::detail;
|
||||
typedef de::lexical_cast_stream_traits<std::string, T> trait_4;
|
||||
BOOST_CHECK(!trait_4::is_source_input_not_optimized_t::value);
|
||||
BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_4::src_char_t, char>::value));
|
||||
BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_4::target_char_t, char>::value));
|
||||
BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_4::char_type, char>::value));
|
||||
BOOST_CHECK(!trait_4::is_string_widening_required_t::value);
|
||||
BOOST_CHECK(!trait_4::is_source_input_not_optimized_t::value);
|
||||
|
||||
typedef de::lexical_cast_stream_traits<const std::string, T> trait_5;
|
||||
BOOST_CHECK(!trait_5::is_source_input_not_optimized_t::value);
|
||||
BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_5::src_char_t, char>::value));
|
||||
BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_5::target_char_t, char>::value));
|
||||
BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_5::char_type, char>::value));
|
||||
BOOST_CHECK(!trait_5::is_string_widening_required_t::value);
|
||||
BOOST_CHECK(!trait_5::is_source_input_not_optimized_t::value);
|
||||
|
||||
typedef de::lexical_cast_stream_traits<const std::wstring, T> trait_6;
|
||||
BOOST_CHECK(!trait_6::is_source_input_not_optimized_t::value);
|
||||
BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_6::src_char_t, wchar_t>::value));
|
||||
BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_6::target_char_t, char>::value));
|
||||
BOOST_CHECK((boost::is_same<BOOST_DEDUCED_TYPENAME trait_6::char_type, wchar_t>::value));
|
||||
BOOST_CHECK(!trait_6::is_string_widening_required_t::value);
|
||||
}
|
||||
|
||||
void test_metafunctions()
|
||||
{
|
||||
test_optimized_types_to_string<bool>();
|
||||
test_optimized_types_to_string<char>();
|
||||
test_optimized_types_to_string<unsigned char>();
|
||||
test_optimized_types_to_string<signed char>();
|
||||
test_optimized_types_to_string<short>();
|
||||
test_optimized_types_to_string<unsigned short>();
|
||||
test_optimized_types_to_string<int>();
|
||||
test_optimized_types_to_string<unsigned int>();
|
||||
test_optimized_types_to_string<long>();
|
||||
test_optimized_types_to_string<unsigned long>();
|
||||
|
||||
#if defined(BOOST_HAS_LONG_LONG)
|
||||
test_optimized_types_to_string<boost::ulong_long_type>();
|
||||
test_optimized_types_to_string<boost::long_long_type>();
|
||||
#elif defined(BOOST_HAS_MS_INT64)
|
||||
test_optimized_types_to_string<unsigned __int64>();
|
||||
test_optimized_types_to_string<__int64>();
|
||||
#endif
|
||||
|
||||
test_optimized_types_to_string<float>();
|
||||
test_optimized_types_to_string<std::string>();
|
||||
test_optimized_types_to_string<char*>();
|
||||
//test_optimized_types_to_string<char[5]>();
|
||||
//test_optimized_types_to_string<char[1]>();
|
||||
test_optimized_types_to_string<unsigned char*>();
|
||||
//test_optimized_types_to_string<unsigned char[5]>();
|
||||
//test_optimized_types_to_string<unsigned char[1]>();
|
||||
test_optimized_types_to_string<signed char*>();
|
||||
//test_optimized_types_to_string<signed char[5]>();
|
||||
//test_optimized_types_to_string<signed char[1]>();
|
||||
test_optimized_types_to_string<boost::array<char, 1> >();
|
||||
test_optimized_types_to_string<boost::array<char, 5> >();
|
||||
test_optimized_types_to_string<boost::array<unsigned char, 1> >();
|
||||
test_optimized_types_to_string<boost::array<unsigned char, 5> >();
|
||||
test_optimized_types_to_string<boost::array<signed char, 1> >();
|
||||
test_optimized_types_to_string<boost::array<signed char, 5> >();
|
||||
test_optimized_types_to_string<boost::iterator_range<char*> >();
|
||||
test_optimized_types_to_string<boost::iterator_range<unsigned char*> >();
|
||||
test_optimized_types_to_string<boost::iterator_range<signed char*> >();
|
||||
|
||||
test_optimized_types_to_string_const<boost::array<const char, 1> >();
|
||||
test_optimized_types_to_string_const<boost::array<const char, 5> >();
|
||||
test_optimized_types_to_string_const<boost::array<const unsigned char, 1> >();
|
||||
test_optimized_types_to_string_const<boost::array<const unsigned char, 5> >();
|
||||
test_optimized_types_to_string_const<boost::array<const signed char, 1> >();
|
||||
test_optimized_types_to_string_const<boost::array<const signed char, 5> >();
|
||||
test_optimized_types_to_string_const<boost::iterator_range<const char*> >();
|
||||
test_optimized_types_to_string_const<boost::iterator_range<const unsigned char*> >();
|
||||
test_optimized_types_to_string_const<boost::iterator_range<const signed char*> >();
|
||||
|
||||
#if !defined(BOOST_NO_CXX11_HDR_ARRAY) && defined(BOOST_HAS_TR1_ARRAY)
|
||||
test_optimized_types_to_string<std::array<char, 1> >();
|
||||
test_optimized_types_to_string<std::array<char, 5> >();
|
||||
test_optimized_types_to_string<std::array<unsigned char, 1> >();
|
||||
test_optimized_types_to_string<std::array<unsigned char, 5> >();
|
||||
test_optimized_types_to_string<std::array<signed char, 1> >();
|
||||
test_optimized_types_to_string<std::array<signed char, 5> >();
|
||||
|
||||
test_optimized_types_to_string_const<std::array<const char, 1> >();
|
||||
test_optimized_types_to_string_const<std::array<const char, 5> >();
|
||||
test_optimized_types_to_string_const<std::array<const unsigned char, 1> >();
|
||||
test_optimized_types_to_string_const<std::array<const unsigned char, 5> >();
|
||||
test_optimized_types_to_string_const<std::array<const signed char, 1> >();
|
||||
test_optimized_types_to_string_const<std::array<const signed char, 5> >();
|
||||
#endif
|
||||
}
|
||||
|
||||
boost::unit_test::test_suite *init_unit_test_suite(int, char *[])
|
||||
{
|
||||
boost::unit_test::test_suite *suite =
|
||||
BOOST_TEST_SUITE("lexical_cast traits tests");
|
||||
suite->add(BOOST_TEST_CASE(&test_metafunctions));
|
||||
return suite;
|
||||
}
|
||||
|
||||
@@ -58,7 +58,7 @@ void test_char_types_conversions_wchar_t()
|
||||
|
||||
void test_char_types_conversions_char16_t()
|
||||
{
|
||||
#if !defined(BOOST_NO_CHAR16_T) && !defined(BOOST_NO_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
test_impl(u"Test array of chars");
|
||||
#endif
|
||||
|
||||
@@ -67,7 +67,7 @@ void test_char_types_conversions_char16_t()
|
||||
|
||||
void test_char_types_conversions_char32_t()
|
||||
{
|
||||
#if !defined(BOOST_NO_CHAR32_T) && !defined(BOOST_NO_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && defined(BOOST_STL_SUPPORTS_NEW_UNICODE_LOCALES)
|
||||
test_impl(U"Test array of chars");
|
||||
#endif
|
||||
|
||||
|
||||
Reference in New Issue
Block a user