123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649 |
- // Unit test for boost::lexical_cast.
- //
- // See http://www.boost.org for most recent version, including documentation.
- //
- // Copyright Terje Sletteb and Kevlin Henney, 2005.
- // Copyright Alexander Nasonov, 2006.
- // Copyright Antony Polukhin, 2011-2019.
- //
- // 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).
- //
- // Note: The unit test no longer compile on MSVC 6, but lexical_cast itself works for it.
- //
- // We need this #define before any #includes: otherwise msvc will emit warnings
- // deep within std::string, resulting from our (perfectly legal) use of basic_string
- // with a custom traits class:
- //
- #define _SCL_SECURE_NO_WARNINGS
- #include <boost/config.hpp>
- #if defined(__INTEL_COMPILER)
- #pragma warning(disable: 193 383 488 981 1418 1419)
- #elif defined(BOOST_MSVC)
- #pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
- #endif
- #include <boost/lexical_cast.hpp>
- #include <boost/cstdint.hpp>
- #include <boost/test/unit_test.hpp>
- #include <boost/test/floating_point_comparison.hpp>
- #include <boost/type_traits/integral_promotion.hpp>
- #include <string>
- #include <vector>
- #include <algorithm> // std::transform
- #include <memory>
- #if (defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)) \
- && !(defined(BOOST_MSVC) && BOOST_MSVC < 1300)
- #define LCAST_TEST_LONGLONG
- #endif
- #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
- #define BOOST_LCAST_NO_WCHAR_T
- #endif
- template<class CharT>
- struct my_traits : std::char_traits<CharT>
- {
- };
- template<class CharT>
- struct my_allocator : std::allocator<CharT>
- {
- typedef std::allocator<CharT> base_t;
- my_allocator(){}
- template <class U> my_allocator(const my_allocator<U>& v) : base_t(v) {}
- template <class U> struct rebind { typedef my_allocator<U> other; };
- };
- using namespace boost;
- void test_conversion_to_char();
- void test_conversion_to_int();
- void test_conversion_to_double();
- void test_conversion_to_bool();
- void test_conversion_with_nonconst_char();
- void test_conversion_to_string();
- void test_conversion_from_to_wchar_t_alias();
- void test_conversion_from_wchar_t();
- void test_conversion_to_wchar_t();
- void test_conversion_from_wstring();
- void test_conversion_to_wstring();
- void test_bad_lexical_cast();
- void test_no_whitespace_stripping();
- void test_volatile_types_conversions();
- #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
- void test_traits();
- void test_wtraits();
- void test_allocator();
- void test_wallocator();
- #endif
- void test_char_types_conversions();
- void operators_overload_test();
- #if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
- void test_char16_conversions();
- #endif
- #if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
- void test_char32_conversions();
- #endif
- void test_getting_pointer_to_function();
- unit_test::test_suite *init_unit_test_suite(int, char *[])
- {
- unit_test::test_suite *suite =
- BOOST_TEST_SUITE("lexical_cast unit test");
- suite->add(BOOST_TEST_CASE(test_conversion_to_char));
- suite->add(BOOST_TEST_CASE(test_conversion_to_int));
- suite->add(BOOST_TEST_CASE(test_conversion_to_double));
- suite->add(BOOST_TEST_CASE(test_conversion_to_bool));
- suite->add(BOOST_TEST_CASE(test_conversion_from_to_wchar_t_alias));
- suite->add(BOOST_TEST_CASE(test_conversion_to_string));
- suite->add(BOOST_TEST_CASE(test_conversion_with_nonconst_char));
- #ifndef BOOST_LCAST_NO_WCHAR_T
- suite->add(BOOST_TEST_CASE(test_conversion_from_wchar_t));
- suite->add(BOOST_TEST_CASE(test_conversion_to_wchar_t));
- suite->add(BOOST_TEST_CASE(test_conversion_from_wstring));
- suite->add(BOOST_TEST_CASE(test_conversion_to_wstring));
- #endif
- suite->add(BOOST_TEST_CASE(test_bad_lexical_cast));
- suite->add(BOOST_TEST_CASE(test_no_whitespace_stripping));
- suite->add(BOOST_TEST_CASE(test_volatile_types_conversions));
- #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
- suite->add(BOOST_TEST_CASE(&test_traits));
- suite->add(BOOST_TEST_CASE(&test_wtraits));
- suite->add(BOOST_TEST_CASE(&test_allocator));
- suite->add(BOOST_TEST_CASE(&test_wallocator));
- #endif
- suite->add(BOOST_TEST_CASE(&test_char_types_conversions));
- suite->add(BOOST_TEST_CASE(&operators_overload_test));
- #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_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));
- return suite;
- }
- void test_conversion_to_char()
- {
- BOOST_CHECK_EQUAL('A', lexical_cast<char>('A'));
- BOOST_CHECK_EQUAL(' ', lexical_cast<char>(' '));
- BOOST_CHECK_EQUAL('1', lexical_cast<char>(1));
- BOOST_CHECK_EQUAL('0', lexical_cast<char>(0));
- BOOST_CHECK_THROW(lexical_cast<char>(123), bad_lexical_cast);
- BOOST_CHECK_EQUAL('1', lexical_cast<char>(1.0));
- BOOST_CHECK_EQUAL('1', lexical_cast<char>(true));
- BOOST_CHECK_EQUAL('0', lexical_cast<char>(false));
- BOOST_CHECK_EQUAL('A', lexical_cast<char>("A"));
- BOOST_CHECK_EQUAL(' ', lexical_cast<char>(" "));
- BOOST_CHECK_THROW(lexical_cast<char>(""), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<char>("Test"), bad_lexical_cast);
- BOOST_CHECK_EQUAL('A', lexical_cast<char>(std::string("A")));
- BOOST_CHECK_EQUAL(' ', lexical_cast<char>(std::string(" ")));
- BOOST_CHECK_THROW(
- lexical_cast<char>(std::string("")), bad_lexical_cast);
- BOOST_CHECK_THROW(
- lexical_cast<char>(std::string("Test")), bad_lexical_cast);
- }
- void test_conversion_to_int()
- {
- BOOST_CHECK_EQUAL(1, lexical_cast<int>('1'));
- BOOST_CHECK_EQUAL(0, lexical_cast<int>('0'));
- BOOST_CHECK_THROW(lexical_cast<int>('A'), bad_lexical_cast);
- BOOST_CHECK_EQUAL(1, lexical_cast<int>(1));
- BOOST_CHECK_EQUAL(1, lexical_cast<int>(1.0));
- BOOST_CHECK_EQUAL(
- (std::numeric_limits<int>::max)(),
- lexical_cast<int>((std::numeric_limits<int>::max)()));
- BOOST_CHECK_EQUAL(
- (std::numeric_limits<int>::min)(),
- lexical_cast<int>((std::numeric_limits<int>::min)()));
- BOOST_CHECK_THROW(lexical_cast<int>(1.23), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<int>(1e20), bad_lexical_cast);
- BOOST_CHECK_EQUAL(1, lexical_cast<int>(true));
- BOOST_CHECK_EQUAL(0, lexical_cast<int>(false));
- BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
- BOOST_CHECK_THROW(
- lexical_cast<int>(" 123"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<int>(""), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<int>("Test"), bad_lexical_cast);
- BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
- BOOST_CHECK_EQUAL(123, lexical_cast<int>(std::string("123")));
- BOOST_CHECK_THROW(
- lexical_cast<int>(std::string(" 123")), bad_lexical_cast);
- BOOST_CHECK_THROW(
- lexical_cast<int>(std::string("")), bad_lexical_cast);
- BOOST_CHECK_THROW(
- lexical_cast<int>(std::string("Test")), bad_lexical_cast);
- }
- void test_conversion_with_nonconst_char()
- {
- std::vector<char> buffer;
- buffer.push_back('1');
- buffer.push_back('\0');
- BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer[0]), 1);
- std::vector<unsigned char> buffer2;
- buffer2.push_back('1');
- buffer2.push_back('\0');
- BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer2[0]), 1);
- std::vector<unsigned char> buffer3;
- buffer3.push_back('1');
- buffer3.push_back('\0');
- BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer3[0]), 1);
- #ifndef BOOST_LCAST_NO_WCHAR_T
- std::vector<wchar_t> buffer4;
- buffer4.push_back(L'1');
- buffer4.push_back(L'\0');
- BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer4[0]), 1);
- #endif
- }
- void test_conversion_to_double()
- {
- BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<double>('1'), (std::numeric_limits<double>::epsilon()));
- BOOST_CHECK_THROW(lexical_cast<double>('A'), bad_lexical_cast);
- BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<double>(1), (std::numeric_limits<double>::epsilon()));
- BOOST_CHECK_CLOSE_FRACTION(1.23, lexical_cast<double>(1.23), (std::numeric_limits<double>::epsilon()));
- BOOST_CHECK_CLOSE_FRACTION(1.234567890, lexical_cast<double>(1.234567890), std::numeric_limits<double>::epsilon());
- BOOST_CHECK_CLOSE_FRACTION(1.234567890, lexical_cast<double>("1.234567890"), std::numeric_limits<double>::epsilon());
- BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<double>(true), (std::numeric_limits<double>::epsilon()));
- BOOST_CHECK_CLOSE_FRACTION(0.0, lexical_cast<double>(false), (std::numeric_limits<double>::epsilon()));
- BOOST_CHECK_CLOSE_FRACTION(1.23, lexical_cast<double>("1.23"), (std::numeric_limits<double>::epsilon()));
- BOOST_CHECK_THROW(lexical_cast<double>(""), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<double>("Test"), bad_lexical_cast);
- BOOST_CHECK_CLOSE_FRACTION(1.23, lexical_cast<double>(std::string("1.23")), (std::numeric_limits<double>::epsilon()));
- BOOST_CHECK_THROW(
- lexical_cast<double>(std::string("")), bad_lexical_cast);
- BOOST_CHECK_THROW(
- lexical_cast<double>(std::string("Test")), bad_lexical_cast);
- }
- void test_conversion_to_bool()
- {
- BOOST_CHECK_EQUAL(true, lexical_cast<bool>('1'));
- BOOST_CHECK_EQUAL(false, lexical_cast<bool>('0'));
- BOOST_CHECK_THROW(lexical_cast<bool>('A'), bad_lexical_cast);
- BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1));
- 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);
- BOOST_CHECK_THROW(lexical_cast<bool>("Test"), bad_lexical_cast);
- BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
- BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
- BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::string("1")));
- BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::string("0")));
- BOOST_CHECK_THROW(lexical_cast<bool>(1.0001L), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>(2), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>(2u), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>(-1), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>(-2), bad_lexical_cast);
- BOOST_CHECK_THROW(
- lexical_cast<bool>(std::string("")), bad_lexical_cast);
- BOOST_CHECK_THROW(
- lexical_cast<bool>(std::string("Test")), bad_lexical_cast);
- BOOST_CHECK(lexical_cast<bool>("+1") == true);
- BOOST_CHECK(lexical_cast<bool>("+0") == false);
- BOOST_CHECK(lexical_cast<bool>("-0") == false);
- BOOST_CHECK_THROW(lexical_cast<bool>("--0"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>("-+-0"), bad_lexical_cast);
- BOOST_CHECK(lexical_cast<bool>("0") == false);
- BOOST_CHECK(lexical_cast<bool>("1") == true);
- BOOST_CHECK(lexical_cast<bool>("00") == false);
- BOOST_CHECK(lexical_cast<bool>("00000000000") == false);
- BOOST_CHECK(lexical_cast<bool>("000000000001") == true);
- BOOST_CHECK(lexical_cast<bool>("+00") == false );
- BOOST_CHECK(lexical_cast<bool>("-00") == false );
- BOOST_CHECK(lexical_cast<bool>("+00000000001") == true );
- BOOST_CHECK_THROW(lexical_cast<bool>("020"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>("00200"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>("-00200"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>("+00200"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>("000000000002"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>("-1"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>("-0000000001"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>("00000000011"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>("001001"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>("-00000000010"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>("-000000000100"), bad_lexical_cast);
- }
- void test_conversion_to_string()
- {
- char buf[] = "hello";
- char* str = buf;
- BOOST_CHECK_EQUAL(str, lexical_cast<std::string>(str));
- BOOST_CHECK_EQUAL("A", lexical_cast<std::string>('A'));
- BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(' '));
- BOOST_CHECK_EQUAL("123", lexical_cast<std::string>(123));
- BOOST_CHECK_EQUAL("1.23", lexical_cast<std::string>(1.23));
- BOOST_CHECK_EQUAL("1.111111111", lexical_cast<std::string>(1.111111111));
- BOOST_CHECK_EQUAL("1", lexical_cast<std::string>(true));
- BOOST_CHECK_EQUAL("0", lexical_cast<std::string>(false));
- BOOST_CHECK_EQUAL("Test", lexical_cast<std::string>("Test"));
- BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(" "));
- BOOST_CHECK_EQUAL("", lexical_cast<std::string>(""));
- BOOST_CHECK_EQUAL("Test", lexical_cast<std::string>(std::string("Test")));
- BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(std::string(" ")));
- BOOST_CHECK_EQUAL("", lexical_cast<std::string>(std::string("")));
- }
- void test_conversion_from_to_wchar_t_alias()
- {
- BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned short>("123"));
- BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned int>("123"));
- BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned long>("123"));
- BOOST_CHECK_EQUAL(std::string("123"),
- lexical_cast<std::string>(static_cast<unsigned short>(123)));
- BOOST_CHECK_EQUAL(std::string("123"), lexical_cast<std::string>(123u));
- BOOST_CHECK_EQUAL(std::string("123"), lexical_cast<std::string>(123ul));
- }
- void test_conversion_from_wchar_t()
- {
- #ifndef BOOST_LCAST_NO_WCHAR_T
- #if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
- BOOST_CHECK_EQUAL(1, lexical_cast<int>(L'1'));
- BOOST_CHECK_THROW(lexical_cast<int>(L'A'), bad_lexical_cast);
- #endif
- BOOST_CHECK_EQUAL(123, lexical_cast<int>(L"123"));
- BOOST_CHECK_THROW(lexical_cast<int>(L""), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<int>(L"Test"), bad_lexical_cast);
- #if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
- BOOST_CHECK_EQUAL(1.0, lexical_cast<double>(L'1'));
- BOOST_CHECK_THROW(lexical_cast<double>(L'A'), bad_lexical_cast);
- #endif
- BOOST_CHECK_EQUAL(1.23, lexical_cast<double>(L"1.23"));
- BOOST_CHECK_THROW(lexical_cast<double>(L""), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<double>(L"Test"), bad_lexical_cast);
- #if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
- BOOST_CHECK_EQUAL(true, lexical_cast<bool>(L'1'));
- BOOST_CHECK_EQUAL(false, lexical_cast<bool>(L'0'));
- BOOST_CHECK_THROW(lexical_cast<bool>(L'A'), bad_lexical_cast);
- #endif
- BOOST_CHECK_EQUAL(true, lexical_cast<bool>(L"1"));
- BOOST_CHECK_EQUAL(false, lexical_cast<bool>(L"0"));
- BOOST_CHECK_THROW(lexical_cast<bool>(L""), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<bool>(L"Test"), bad_lexical_cast);
- #endif
- }
- void test_conversion_to_wchar_t()
- {
- #if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
- BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(1));
- BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(0));
- BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>('1'));
- BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>('0'));
- BOOST_CHECK_THROW(lexical_cast<wchar_t>(123), bad_lexical_cast);
- BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(1.0));
- BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(0.0));
- BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(true));
- BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(false));
- BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(L'A'));
- BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(L' '));
- BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(L"A"));
- BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(L" "));
- BOOST_CHECK_THROW(lexical_cast<wchar_t>(L""), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<wchar_t>(L"Test"), bad_lexical_cast);
- BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(std::wstring(L"A")));
- BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(std::wstring(L" ")));
- BOOST_CHECK_THROW(
- lexical_cast<wchar_t>(std::wstring(L"")), bad_lexical_cast);
- BOOST_CHECK_THROW(
- lexical_cast<wchar_t>(std::wstring(L"Test")), bad_lexical_cast);
- #endif
- BOOST_CHECK(true);
- }
- void test_conversion_from_wstring()
- {
- #ifndef BOOST_LCAST_NO_WCHAR_T
- BOOST_CHECK_EQUAL(123, lexical_cast<int>(std::wstring(L"123")));
- BOOST_CHECK_THROW(
- lexical_cast<int>(std::wstring(L"")), bad_lexical_cast);
- BOOST_CHECK_THROW(
- lexical_cast<int>(std::wstring(L"Test")), bad_lexical_cast);
- BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::wstring(L"1")));
- BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::wstring(L"0")));
- BOOST_CHECK_THROW(
- lexical_cast<bool>(std::wstring(L"")), bad_lexical_cast);
- BOOST_CHECK_THROW(
- lexical_cast<bool>(std::wstring(L"Test")), bad_lexical_cast);
- #endif
- BOOST_CHECK(true);
- }
- void test_conversion_to_wstring()
- {
- #ifndef BOOST_LCAST_NO_WCHAR_T
- wchar_t buf[] = L"hello";
- wchar_t* str = buf;
- BOOST_CHECK(str == lexical_cast<std::wstring>(str));
- BOOST_CHECK(L"123" == lexical_cast<std::wstring>(123));
- BOOST_CHECK(L"1.23" == lexical_cast<std::wstring>(1.23));
- BOOST_CHECK(L"1" == lexical_cast<std::wstring>(true));
- BOOST_CHECK(L"0" == lexical_cast<std::wstring>(false));
- #if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
- BOOST_CHECK(L"A" == lexical_cast<std::wstring>(L'A'));
- BOOST_CHECK(L" " == lexical_cast<std::wstring>(L' '));
- BOOST_CHECK(L"A" == lexical_cast<std::wstring>('A'));
- #endif
- BOOST_CHECK(L"Test" == lexical_cast<std::wstring>(L"Test"));
- BOOST_CHECK(L" " == lexical_cast<std::wstring>(L" "));
- BOOST_CHECK(L"" == lexical_cast<std::wstring>(L""));
- BOOST_CHECK(L"Test" == lexical_cast<std::wstring>(std::wstring(L"Test")));
- BOOST_CHECK(L" " == lexical_cast<std::wstring>(std::wstring(L" ")));
- BOOST_CHECK(L"" == lexical_cast<std::wstring>(std::wstring(L"")));
- #endif
- BOOST_CHECK(true);
- }
- void test_bad_lexical_cast()
- {
- try
- {
- lexical_cast<int>(std::string("Test"));
- BOOST_CHECK(false); // Exception expected
- }
- catch(const bad_lexical_cast &e)
- {
- BOOST_CHECK(e.source_type() == typeid(std::string));
- BOOST_CHECK(e.target_type() == typeid(int));
- }
- }
- void test_no_whitespace_stripping()
- {
- BOOST_CHECK_THROW(lexical_cast<int>(" 123"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<int>("123 "), bad_lexical_cast);
- }
- void test_volatile_types_conversions()
- {
- volatile int i1 = 100000;
- BOOST_CHECK_EQUAL("100000", boost::lexical_cast<std::string>(i1));
- volatile const int i2 = 100000;
- BOOST_CHECK_EQUAL("100000", boost::lexical_cast<std::string>(i2));
- volatile const long int i3 = 1000000;
- BOOST_CHECK_EQUAL("1000000", boost::lexical_cast<std::string>(i3));
- }
- #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
- void test_traits()
- {
- typedef std::basic_string<char, my_traits<char> > my_string;
- my_string const s("s");
- BOOST_CHECK(boost::lexical_cast<char>(s) == s[0]);
- BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
- BOOST_CHECK(boost::lexical_cast<my_string>(-1) == "-1");
- }
- void test_wtraits()
- {
- typedef std::basic_string<wchar_t, my_traits<wchar_t> > my_string;
- my_string const s(L"s");
- BOOST_CHECK(boost::lexical_cast<wchar_t>(s) == s[0]);
- BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
- //BOOST_CHECK(boost::lexical_cast<my_string>(-1) == L"-1");
- // Commented out because gcc 3.3 doesn't support this:
- // basic_ostream<wchar_t, my_traits<wchar_t> > o; o << -1;
- }
- void test_allocator()
- {
- // Following test cause compilation error on MSVC2012:
- // (Reason: cannot convert from 'std::_Wrap_alloc<_Alloc>' to 'const my_allocator<CharT>')
- //
- // MSVC developer is notified about this issue
- #if !defined(_MSC_VER) || (_MSC_VER < 1700)
- typedef std::basic_string< char
- , std::char_traits<char>
- , my_allocator<char>
- > my_string;
- my_string s("s");
- BOOST_CHECK(boost::lexical_cast<char>(s) == s[0]);
- BOOST_CHECK(boost::lexical_cast<std::string>(s) == "s");
- BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
- BOOST_CHECK(boost::lexical_cast<my_string>(1) == "1");
- BOOST_CHECK(boost::lexical_cast<my_string>("s") == s);
- BOOST_CHECK(boost::lexical_cast<my_string>(std::string("s")) == s);
- #endif
- }
- void test_wallocator()
- {
- // Following test cause compilation error on MSVC2012:
- // (Reason: cannot convert from 'std::_Wrap_alloc<_Alloc>' to 'const my_allocator<CharT>')
- //
- // MSVC developer is notified about this issue
- #if !defined(_MSC_VER) || (_MSC_VER < 1700)
- typedef std::basic_string< wchar_t
- , std::char_traits<wchar_t>
- , my_allocator<wchar_t>
- > my_string;
- my_string s(L"s");
- BOOST_CHECK(boost::lexical_cast<wchar_t>(s) == s[0]);
- BOOST_CHECK(boost::lexical_cast<std::wstring>(s) == L"s");
- BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
- BOOST_CHECK(boost::lexical_cast<my_string>(1) == L"1");
- BOOST_CHECK(boost::lexical_cast<my_string>(L"s") == s);
- BOOST_CHECK(boost::lexical_cast<my_string>(std::wstring(L"s")) == s);
- #endif
- }
- #endif
- void test_char_types_conversions()
- {
- const char c_arr[] = "Test array of chars";
- const unsigned char uc_arr[] = "Test array of chars";
- const signed char sc_arr[] = "Test array of chars";
- BOOST_CHECK(boost::lexical_cast<std::string>(c_arr) == std::string(c_arr));
- BOOST_CHECK(boost::lexical_cast<std::string>(uc_arr) == std::string(c_arr));
- BOOST_CHECK(boost::lexical_cast<std::string>(sc_arr) == std::string(c_arr));
- BOOST_CHECK(boost::lexical_cast<char>(c_arr[0]) == c_arr[0]);
- BOOST_CHECK(boost::lexical_cast<char>(uc_arr[0]) == c_arr[0]);
- BOOST_CHECK(boost::lexical_cast<char>(sc_arr[0]) == c_arr[0]);
- BOOST_CHECK(boost::lexical_cast<unsigned char>(c_arr[0]) == uc_arr[0]);
- BOOST_CHECK(boost::lexical_cast<unsigned char>(uc_arr[0]) == uc_arr[0]);
- BOOST_CHECK(boost::lexical_cast<unsigned char>(sc_arr[0]) == uc_arr[0]);
- BOOST_CHECK(boost::lexical_cast<signed char>(c_arr[0]) == sc_arr[0]);
- BOOST_CHECK(boost::lexical_cast<signed char>(uc_arr[0]) == sc_arr[0]);
- BOOST_CHECK(boost::lexical_cast<signed char>(sc_arr[0]) == sc_arr[0]);
- #ifndef BOOST_LCAST_NO_WCHAR_T
- const wchar_t wc_arr[]=L"Test array of chars";
- BOOST_CHECK(boost::lexical_cast<std::wstring>(wc_arr) == std::wstring(wc_arr));
- BOOST_CHECK(boost::lexical_cast<wchar_t>(wc_arr[0]) == wc_arr[0]);
- #endif
- }
- struct foo_operators_test
- {
- foo_operators_test() : f(2) {}
- int f;
- };
- template <typename OStream>
- OStream& operator<<(OStream& ostr, const foo_operators_test& foo)
- {
- ostr << foo.f;
- return ostr;
- }
- template <typename IStream>
- IStream& operator>>(IStream& istr, foo_operators_test& foo)
- {
- istr >> foo.f;
- return istr;
- }
- void operators_overload_test()
- {
- foo_operators_test foo;
- BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(foo), "2");
- BOOST_CHECK_EQUAL((boost::lexical_cast<foo_operators_test>("2")).f, 2);
- // Must compile
- (void)boost::lexical_cast<foo_operators_test>(foo);
- }
- #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"));
- BOOST_CHECK(u"1" == lexical_cast<std::u16string>(u'1'));
- }
- #endif
- #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"));
- BOOST_CHECK(U"1" == lexical_cast<std::u32string>(U'1'));
- }
- #endif
- void test_getting_pointer_to_function()
- {
- // Just checking that &lexical_cast<To, From> is not ambiguous
- 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);
- std::vector<int> values;
- std::vector<std::string> ret;
- std::transform(values.begin(), values.end(), ret.begin(), boost::lexical_cast<std::string, int>);
- }
|