123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528 |
- // Unit test for boost::lexical_cast.
- //
- // See http://www.boost.org for most recent version, including documentation.
- //
- // 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).
- #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/math/tools/precision.hpp>
- void test_conversion_from_to_float();
- void test_conversion_from_to_double();
- void test_conversion_from_to_long_double();
- using namespace boost;
- unit_test::test_suite *init_unit_test_suite(int, char *[])
- {
- unit_test::test_suite *suite =
- BOOST_TEST_SUITE("lexical_cast float types unit test");
- suite->add(BOOST_TEST_CASE(&test_conversion_from_to_float));
- suite->add(BOOST_TEST_CASE(&test_conversion_from_to_double));
- suite->add(BOOST_TEST_CASE(&test_conversion_from_to_long_double));
- return suite;
- }
- // Replace "-,999" with "-999".
- template<class CharT>
- std::basic_string<CharT> to_str_gcc_workaround(std::basic_string<CharT> str)
- {
- std::locale loc;
- std::numpunct<CharT> const& np = BOOST_USE_FACET(std::numpunct<CharT>, loc);
- std::ctype<CharT> const& ct = BOOST_USE_FACET(std::ctype<CharT>, loc);
- if(np.grouping().empty())
- return str;
- CharT prefix[3] = { ct.widen('-'), np.thousands_sep(), CharT() };
- if(str.find(prefix) != 0)
- return str;
- prefix[1] = CharT();
- str.replace(0, 2, prefix);
- return str;
- }
- template<class CharT, class T>
- std::basic_string<CharT> to_str(T t)
- {
- std::basic_ostringstream<CharT> o;
- o << t;
- return to_str_gcc_workaround(o.str());
- }
- template<class T>
- void test_conversion_from_to_float_for_locale()
- {
- std::locale current_locale;
- typedef std::numpunct<char> numpunct;
- numpunct const& np = BOOST_USE_FACET(numpunct, current_locale);
- if ( !np.grouping().empty() )
- {
- BOOST_CHECK_THROW(
- lexical_cast<T>( std::string("100") + np.thousands_sep() + np.thousands_sep() + "0" )
- , bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<T>( std::string("100") + np.thousands_sep() ), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<T>( np.thousands_sep() + std::string("100") ), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<T>( std::string("1") + np.thousands_sep() + np.decimal_point() + "e10" ), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<T>( std::string("1e10") + np.thousands_sep() ), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<T>( std::string("1") + np.thousands_sep() + "e10" ), bad_lexical_cast);
- BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(100000) ), 100000, (boost::math::tools::epsilon<T>()) );
- BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(10000000u) ), 10000000u, (boost::math::tools::epsilon<T>()) );
- BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< char >(100) ), 100, (boost::math::tools::epsilon<T>()) );
- #if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
- BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(100000) ), 100000, (boost::math::tools::epsilon<T>()) );
- BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(10000000u) ), 10000000u, (boost::math::tools::epsilon<T>()) );
- BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( to_str< wchar_t >(100) ), 100, (boost::math::tools::epsilon<T>()) );
- #endif
- // Exception must not be thrown, when we are using no separators at all
- BOOST_CHECK_CLOSE_FRACTION( lexical_cast<T>("30000"), static_cast<T>(30000), (boost::math::tools::epsilon<T>()) );
- }
- }
- /*
- * Converts char* [and wchar_t*] to float number type and checks, that generated
- * number does not exceeds allowed epsilon.
- */
- #ifndef BOOST_LCAST_NO_WCHAR_T
- #define CHECK_CLOSE_ABS_DIFF(VAL,PREFIX) \
- converted_val = lexical_cast<test_t>(#VAL); \
- BOOST_CHECK_CLOSE_FRACTION( (static_cast<bool>(VAL ## L)? VAL ## L : boost::math::tools::epsilon<test_t>()), \
- (converted_val ? converted_val : boost::math::tools::epsilon<test_t>()),\
- boost::math::tools::epsilon<test_t>() \
- ); \
- BOOST_CHECK_EQUAL(converted_val, lexical_cast<test_t>(L## #VAL) );
- #else
- #define CHECK_CLOSE_ABS_DIFF(VAL,TYPE) \
- converted_val = lexical_cast<test_t>(#VAL); \
- BOOST_CHECK_CLOSE_FRACTION( (static_cast<bool>(VAL ## L)? VAL ## L : boost::math::tools::epsilon<test_t>()), \
- (converted_val ? converted_val : boost::math::tools::epsilon<test_t>()),\
- boost::math::tools::epsilon<test_t>() \
- );
- #endif
- template <class TestType>
- void test_converion_to_float_types()
- {
- typedef TestType test_t;
- test_t converted_val;
- BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<test_t>('1'), (boost::math::tools::epsilon<test_t>()));
- BOOST_CHECK_EQUAL(0.0, lexical_cast<test_t>('0'));
- unsigned char const uc_one = '1';
- unsigned char const uc_zero ='0';
- BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<test_t>(uc_one), (boost::math::tools::epsilon<test_t>()));
- BOOST_CHECK_EQUAL(0.0, lexical_cast<test_t>(uc_zero));
- signed char const sc_one = '1';
- signed char const sc_zero ='0';
- BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<test_t>(sc_one), (boost::math::tools::epsilon<test_t>()));
- BOOST_CHECK_EQUAL(0.0, lexical_cast<test_t>(sc_zero));
- BOOST_CHECK_CLOSE_FRACTION(1e34L, lexical_cast<test_t>( "10000000000000000000000000000000000"), (boost::math::tools::epsilon<test_t>()) );
- // VC failes the next test
- // BOOST_CHECK_CLOSE_FRACTION(1e-35L, lexical_cast<test_t>("0.00000000000000000000000000000000001"), (boost::math::tools::epsilon<test_t>()) );
- BOOST_CHECK_CLOSE_FRACTION(
- 0.1111111111111111111111111111111111111111111111111111111111111111111111111L
- , lexical_cast<test_t>("0.1111111111111111111111111111111111111111111111111111111111111111111111111")
- , (boost::math::tools::epsilon<test_t>()) );
- CHECK_CLOSE_ABS_DIFF(1,test_t);
- BOOST_CHECK_EQUAL(0,lexical_cast<test_t>("0"));
- CHECK_CLOSE_ABS_DIFF(-1,test_t);
- CHECK_CLOSE_ABS_DIFF(1.0, test_t);
- CHECK_CLOSE_ABS_DIFF(0.0, test_t);
- CHECK_CLOSE_ABS_DIFF(-1.0,test_t);
- CHECK_CLOSE_ABS_DIFF(1e1, test_t);
- CHECK_CLOSE_ABS_DIFF(0e1, test_t);
- CHECK_CLOSE_ABS_DIFF(-1e1,test_t);
- CHECK_CLOSE_ABS_DIFF(1.0e1, test_t);
- CHECK_CLOSE_ABS_DIFF(0.0e1, test_t);
- CHECK_CLOSE_ABS_DIFF(-1.0e1,test_t);
- CHECK_CLOSE_ABS_DIFF(1e-1, test_t);
- CHECK_CLOSE_ABS_DIFF(0e-1, test_t);
- CHECK_CLOSE_ABS_DIFF(-1e-1,test_t);
- CHECK_CLOSE_ABS_DIFF(1.0e-1, test_t);
- CHECK_CLOSE_ABS_DIFF(0.0e-1, test_t);
- CHECK_CLOSE_ABS_DIFF(-1.0e-1,test_t);
- CHECK_CLOSE_ABS_DIFF(1E1, test_t);
- CHECK_CLOSE_ABS_DIFF(0E1, test_t);
- CHECK_CLOSE_ABS_DIFF(-1E1,test_t);
- CHECK_CLOSE_ABS_DIFF(1.0E1, test_t);
- CHECK_CLOSE_ABS_DIFF(0.0E1, test_t);
- CHECK_CLOSE_ABS_DIFF(-1.0E1,test_t);
- CHECK_CLOSE_ABS_DIFF(1E-1, test_t);
- CHECK_CLOSE_ABS_DIFF(0E-1, test_t);
- CHECK_CLOSE_ABS_DIFF(-1E-1,test_t);
- CHECK_CLOSE_ABS_DIFF(1.0E-1, test_t);
- CHECK_CLOSE_ABS_DIFF(0.0E-1, test_t);
- CHECK_CLOSE_ABS_DIFF(-1.0E-1, test_t);
- CHECK_CLOSE_ABS_DIFF(.0E-1, test_t);
- CHECK_CLOSE_ABS_DIFF(.0E-1, test_t);
- CHECK_CLOSE_ABS_DIFF(-.0E-1, test_t);
- CHECK_CLOSE_ABS_DIFF(10.0, test_t);
- CHECK_CLOSE_ABS_DIFF(00.0, test_t);
- CHECK_CLOSE_ABS_DIFF(-10.0,test_t);
- CHECK_CLOSE_ABS_DIFF(10e1, test_t);
- CHECK_CLOSE_ABS_DIFF(00e1, test_t);
- CHECK_CLOSE_ABS_DIFF(-10e1,test_t);
- CHECK_CLOSE_ABS_DIFF(10.0e1, test_t);
- CHECK_CLOSE_ABS_DIFF(00.0e1, test_t);
- CHECK_CLOSE_ABS_DIFF(-10.0e1,test_t);
- CHECK_CLOSE_ABS_DIFF(10e-1, test_t);
- CHECK_CLOSE_ABS_DIFF(00e-1, test_t);
- CHECK_CLOSE_ABS_DIFF(-10e-1,test_t);
- CHECK_CLOSE_ABS_DIFF(10.0e-1, test_t);
- CHECK_CLOSE_ABS_DIFF(00.0e-1, test_t);
- CHECK_CLOSE_ABS_DIFF(-10.0e-1,test_t);
- CHECK_CLOSE_ABS_DIFF(10E1, test_t);
- CHECK_CLOSE_ABS_DIFF(00E1, test_t);
- CHECK_CLOSE_ABS_DIFF(-10E1,test_t);
- CHECK_CLOSE_ABS_DIFF(10.0E1, test_t);
- CHECK_CLOSE_ABS_DIFF(00.0E1, test_t);
- CHECK_CLOSE_ABS_DIFF(-10.0E1,test_t);
- CHECK_CLOSE_ABS_DIFF(10E-1, test_t);
- CHECK_CLOSE_ABS_DIFF(00E-1, test_t);
- CHECK_CLOSE_ABS_DIFF(-10E-1,test_t);
- CHECK_CLOSE_ABS_DIFF(10.0E-1, test_t);
- CHECK_CLOSE_ABS_DIFF(00.0E-1, test_t);
- CHECK_CLOSE_ABS_DIFF(-10.0E-1, test_t);
- CHECK_CLOSE_ABS_DIFF(-10101.0E-011, test_t);
- CHECK_CLOSE_ABS_DIFF(-10101093, test_t);
- CHECK_CLOSE_ABS_DIFF(10101093, test_t);
- CHECK_CLOSE_ABS_DIFF(-.34, test_t);
- CHECK_CLOSE_ABS_DIFF(.34, test_t);
- CHECK_CLOSE_ABS_DIFF(.34e10, test_t);
- BOOST_CHECK_THROW(lexical_cast<test_t>("-1.e"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("-1.E"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("1.e"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("1.E"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("1.0E"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("10E"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("10e"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e-"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("1.0E-"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("10E-"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("10e-"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("e1"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("e-1"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("e-"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>(".e"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>(".11111111111111111111111111111111111111111111111111111111111111111111ee"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>(".11111111111111111111111111111111111111111111111111111111111111111111e-"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("."), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("-B"), bad_lexical_cast);
- // Following two tests are not valid for C++11 compilers
- //BOOST_CHECK_THROW(lexical_cast<test_t>("0xB"), bad_lexical_cast);
- //BOOST_CHECK_THROW(lexical_cast<test_t>("0x0"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("--1.0"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e--1"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("1.0.0"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("1e1e1"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("1.0e-1e-1"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>(" 1.0"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("1.0 "), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>(""), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("-"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>('\0'), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>('-'), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>('.'), bad_lexical_cast);
- }
- template <class T>
- void test_float_typess_for_overflows()
- {
- typedef T test_t;
- test_t minvalue = (std::numeric_limits<test_t>::min)();
- std::string s_min_value = lexical_cast<std::string>(minvalue);
- BOOST_CHECK_CLOSE_FRACTION(minvalue, lexical_cast<test_t>(minvalue), (boost::math::tools::epsilon<test_t>()));
- BOOST_CHECK_CLOSE_FRACTION(minvalue, lexical_cast<test_t>(s_min_value), (boost::math::tools::epsilon<test_t>() * 2));
- test_t maxvalue = (std::numeric_limits<test_t>::max)();
- std::string s_max_value = lexical_cast<std::string>(maxvalue);
- BOOST_CHECK_CLOSE_FRACTION(maxvalue, lexical_cast<test_t>(maxvalue), (boost::math::tools::epsilon<test_t>()));
- BOOST_CHECK_CLOSE_FRACTION(maxvalue, lexical_cast<test_t>(s_max_value), (boost::math::tools::epsilon<test_t>()));
- #ifndef _LIBCPP_VERSION
- // libc++ had a bug in implementation of stream conversions for values that must be represented as infinity.
- // http://llvm.org/bugs/show_bug.cgi?id=15723#c4
- BOOST_CHECK_THROW(lexical_cast<test_t>(s_max_value+"1"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>(s_max_value+"9"), bad_lexical_cast);
- // VC9 can fail the following tests on floats and doubles when using stingstream...
- BOOST_CHECK_THROW(lexical_cast<test_t>("1"+s_max_value), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<test_t>("9"+s_max_value), bad_lexical_cast);
- #endif
- if ( is_same<test_t,float>::value )
- {
- BOOST_CHECK_THROW(lexical_cast<test_t>( (std::numeric_limits<double>::max)() ), bad_lexical_cast);
- BOOST_CHECK(
- (std::numeric_limits<double>::min)() - boost::math::tools::epsilon<test_t>()
- <= lexical_cast<test_t>( (std::numeric_limits<double>::min)() )
- && lexical_cast<test_t>( (std::numeric_limits<double>::min)() )
- <= (std::numeric_limits<double>::min)() + boost::math::tools::epsilon<test_t>()
- );
- }
- if ( sizeof(test_t) < sizeof(long double) )
- {
- BOOST_CHECK_THROW(lexical_cast<test_t>( (std::numeric_limits<long double>::max)() ), bad_lexical_cast);
- BOOST_CHECK(
- (std::numeric_limits<long double>::min)() - boost::math::tools::epsilon<test_t>()
- <= lexical_cast<test_t>( (std::numeric_limits<long double>::min)() )
- && lexical_cast<test_t>( (std::numeric_limits<long double>::min)() )
- <= (std::numeric_limits<long double>::min)() + boost::math::tools::epsilon<test_t>()
- );
- }
- }
- #undef CHECK_CLOSE_ABS_DIFF
- // Epsilon is multiplied by 2 because of two lexical conversions
- #define TEST_TO_FROM_CAST_AROUND_TYPED(VAL,STRING_TYPE) \
- test_value = VAL + boost::math::tools::epsilon<test_t>() * i ; \
- converted_val = lexical_cast<test_t>( lexical_cast<STRING_TYPE>(test_value) ); \
- BOOST_CHECK_CLOSE_FRACTION( \
- test_value, \
- converted_val, \
- boost::math::tools::epsilon<test_t>() * 2 \
- );
- /*
- * For interval [ from_mult*epsilon+VAL, to_mult*epsilon+VAL ], converts float type
- * numbers to string[wstring] and then back to float type, then compares initial
- * values and generated.
- * Step is epsilon
- */
- #ifndef BOOST_LCAST_NO_WCHAR_T
- # define TEST_TO_FROM_CAST_AROUND(VAL) \
- for(i=from_mult; i<=to_mult; ++i) { \
- TEST_TO_FROM_CAST_AROUND_TYPED(VAL, std::string) \
- TEST_TO_FROM_CAST_AROUND_TYPED(VAL, std::wstring) \
- }
- #else
- # define TEST_TO_FROM_CAST_AROUND(VAL) \
- for(i=from_mult; i<=to_mult; ++i) { \
- TEST_TO_FROM_CAST_AROUND_TYPED(VAL, std::string) \
- }
- #endif
- template <class TestType>
- void test_converion_from_to_float_types()
- {
- typedef TestType test_t;
- test_t test_value;
- test_t converted_val;
- int i;
- int from_mult = -50;
- int to_mult = 50;
- TEST_TO_FROM_CAST_AROUND( 0.0 );
- long double val1;
- for(val1 = 1.0e-10L; val1 < 1e11; val1*=10 )
- TEST_TO_FROM_CAST_AROUND( val1 );
- long double val2;
- for(val2 = -1.0e-10L; val2 > -1e11; val2*=10 )
- TEST_TO_FROM_CAST_AROUND( val2 );
- from_mult = -100;
- to_mult = 0;
- TEST_TO_FROM_CAST_AROUND( (std::numeric_limits<test_t>::max)() );
- from_mult = 0;
- to_mult = 100;
- TEST_TO_FROM_CAST_AROUND( (std::numeric_limits<test_t>::min)() );
- }
- #undef TEST_TO_FROM_CAST_AROUND
- #undef TEST_TO_FROM_CAST_AROUND_TYPED
- template<class T, class CharT>
- void test_conversion_from_float_to_char(CharT zero)
- {
- BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(0)) == zero + 0);
- BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(1)) == zero + 1);
- BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(2)) == zero + 2);
- BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(3)) == zero + 3);
- BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(4)) == zero + 4);
- BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(5)) == zero + 5);
- BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(6)) == zero + 6);
- BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(7)) == zero + 7);
- BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(8)) == zero + 8);
- BOOST_CHECK(lexical_cast<CharT>(static_cast<T>(9)) == zero + 9);
- BOOST_CHECK_THROW(lexical_cast<CharT>(static_cast<T>(10)), bad_lexical_cast);
- T t = (std::numeric_limits<T>::max)();
- BOOST_CHECK_THROW(lexical_cast<CharT>(t), bad_lexical_cast);
- }
- template<class T, class CharT>
- void test_conversion_from_char_to_float(CharT zero)
- {
- BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 0)), static_cast<T>(0), (boost::math::tools::epsilon<T>()) );
- BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 1)), static_cast<T>(1), (boost::math::tools::epsilon<T>()) );
- BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 2)), static_cast<T>(2), (boost::math::tools::epsilon<T>()) );
- BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 3)), static_cast<T>(3), (boost::math::tools::epsilon<T>()) );
- BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 4)), static_cast<T>(4), (boost::math::tools::epsilon<T>()) );
- BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 5)), static_cast<T>(5), (boost::math::tools::epsilon<T>()) );
- BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 6)), static_cast<T>(6), (boost::math::tools::epsilon<T>()) );
- BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 7)), static_cast<T>(7), (boost::math::tools::epsilon<T>()) );
- BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 8)), static_cast<T>(8), (boost::math::tools::epsilon<T>()) );
- BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>( static_cast<CharT>(zero + 9)), static_cast<T>(9), (boost::math::tools::epsilon<T>()) );
- BOOST_CHECK_THROW(lexical_cast<T>( static_cast<CharT>(zero + 10)), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<T>( static_cast<CharT>(zero - 1)), bad_lexical_cast);
- }
- struct restore_oldloc
- {
- std::locale oldloc;
- ~restore_oldloc() { std::locale::global(oldloc); }
- };
- template<class T>
- void test_conversion_from_to_float()
- { char const zero = '0';
- signed char const szero = '0';
- unsigned char const uzero = '0';
- test_conversion_from_float_to_char<T>(zero);
- test_conversion_from_char_to_float<T>(zero);
- test_conversion_from_float_to_char<T>(szero);
- test_conversion_from_char_to_float<T>(szero);
- test_conversion_from_float_to_char<T>(uzero);
- test_conversion_from_char_to_float<T>(uzero);
- #if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
- wchar_t const wzero = L'0';
- test_conversion_from_float_to_char<T>(wzero);
- test_conversion_from_char_to_float<T>(wzero);
- #endif
- BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>("+1"), 1, boost::math::tools::epsilon<T>());
- BOOST_CHECK_CLOSE_FRACTION(lexical_cast<T>("+9"), 9, boost::math::tools::epsilon<T>());
- BOOST_CHECK_THROW(lexical_cast<T>("++1"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<T>("-+9"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<T>("--1"), bad_lexical_cast);
- BOOST_CHECK_THROW(lexical_cast<T>("+-9"), bad_lexical_cast);
- test_converion_to_float_types<T>();
- test_float_typess_for_overflows<T>();
- test_converion_from_to_float_types<T>();
- typedef std::numpunct<char> numpunct;
- restore_oldloc guard;
- std::locale const& oldloc = guard.oldloc;
- std::string grouping1 = BOOST_USE_FACET(numpunct, oldloc).grouping();
- std::string grouping2(grouping1);
- test_conversion_from_to_float_for_locale<T>();
- try
- {
- std::locale newloc("");
- std::locale::global(newloc);
- grouping2 = BOOST_USE_FACET(numpunct, newloc).grouping();
- }
- catch(std::exception const& ex)
- {
- std::string msg("Failed to set system locale: ");
- msg += ex.what();
- BOOST_TEST_MESSAGE(msg);
- }
- if(grouping1 != grouping2)
- test_conversion_from_to_float_for_locale<T>();
- if(grouping1.empty() && grouping2.empty())
- BOOST_TEST_MESSAGE("Formatting with thousands_sep has not been tested");
- }
- void test_conversion_from_to_float()
- {
- test_conversion_from_to_float<float>();
- }
- void test_conversion_from_to_double()
- {
- test_conversion_from_to_float<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);
- }
|