libs/conversion/test/lexical_cast_inf_nan_test.cpp

   1 //  Unit test for boost::lexical_cast.
   2 //
   3 //  See http://www.boost.org for most recent version, including documentation.
   4 //
   5 //  Copyright Antony Polukhin, 2011.
   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/config.hpp>
  12
  13 #if defined(__INTEL_COMPILER)
  14 #pragma warning(disable: 193 383 488 981 1418 1419)
  15 #elif defined(BOOST_MSVC)
  16 #pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
  17 #endif
  18
  19 #include <boost/lexical_cast.hpp>
  20
  21
  22 #include <boost/math/special_functions/sign.hpp>
  23 #include <boost/math/special_functions/fpclassify.hpp>
  24 #include <boost/type_traits/is_same.hpp>
  25 #include <boost/test/unit_test.hpp>
  26 #include <boost/test/floating_point_comparison.hpp>
  27
  28 #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
  29 #define BOOST_LCAST_NO_WCHAR_T
  30 #endif
  31
  32 using namespace boost;
  33
  34 template <class T>
  35 bool is_pos_inf(T value)
  36 {
  37     return (boost::math::isinf)(value) && !(boost::math::signbit)(value);
  38 }
  39
  40 template <class T>
  41 bool is_neg_inf(T value)
  42 {
  43     return (boost::math::isinf)(value) && (boost::math::signbit)(value);
  44 }
  45
  46 template <class T>
  47 bool is_pos_nan(T value)
  48 {
  49     return (boost::math::isnan)(value) && !(boost::math::signbit)(value);
  50 }
  51
  52 template <class T>
  53 bool is_neg_nan(T value)
  54 {
  55     /* There is some strange behaviour on Itanium platform with -nan nuber for long double.
  56     * It is a IA64 feature, or it is a boost::math feature, not a lexical_cast bug */
  57 #if defined(__ia64__) || defined(_M_IA64)
  58     return (boost::math::isnan)(value)
  59             && ( boost::is_same<T, long double >::value || (boost::math::signbit)(value) );
  60 #else
  61     return (boost::math::isnan)(value) && (boost::math::signbit)(value);
  62 #endif
  63 }
  64
  65 template <class T>
  66 void test_inf_nan_templated()
  67 {
  68     typedef T test_t;
  69
  70     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("inf") ) );
  71     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("INF") ) );
  72
  73     BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-inf") ) );
  74     BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-INF") ) );
  75
  76     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+inf") ) );
  77     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+INF") ) );
  78
  79     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("infinity") ) );
  80     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("INFINITY") ) );
  81
  82     BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-infinity") ) );
  83     BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-INFINITY") ) );
  84
  85     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+infinity") ) );
  86     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("+INFINITY") ) );
  87
  88     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("iNfiNity") ) );
  89     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>("INfinity") ) );
  90
  91     BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-inFINITY") ) );
  92     BOOST_CHECK( is_neg_inf( lexical_cast<test_t>("-INFINITY") ) );
  93
  94     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("nan") ) );
  95     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("NAN") ) );
  96
  97     BOOST_CHECK( is_neg_nan( lexical_cast<test_t>("-nan") ) );
  98     BOOST_CHECK( is_neg_nan( lexical_cast<test_t>("-NAN") ) );
  99
 100     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+nan") ) );
 101     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+NAN") ) );
 102
 103     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("nAn") ) );
 104     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("NaN") ) );
 105
 106     BOOST_CHECK( is_neg_nan( lexical_cast<test_t>("-nAn") ) );
 107     BOOST_CHECK( is_neg_nan( lexical_cast<test_t>("-NaN") ) );
 108
 109     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+Nan") ) );
 110     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("+nAN") ) );
 111
 112     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("nan()") ) );
 113     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>("NAN(some string)") ) );
 114     BOOST_CHECK_THROW( lexical_cast<test_t>("NAN(some string"), bad_lexical_cast );
 115
 116     BOOST_CHECK(lexical_cast<std::string>( (boost::math::changesign)(std::numeric_limits<test_t >::infinity()))
 117                 == "-inf" );
 118     BOOST_CHECK(lexical_cast<std::string>( std::numeric_limits<test_t >::infinity()) == "inf" );
 119     BOOST_CHECK(lexical_cast<std::string>( std::numeric_limits<test_t >::quiet_NaN()) == "nan" );
 120 #if !defined(__ia64__) && !defined(_M_IA64)
 121     BOOST_CHECK(lexical_cast<std::string>(
 122                 (boost::math::changesign)(std::numeric_limits<test_t >::quiet_NaN()))
 123                 == "-nan" );
 124 #endif
 125
 126 #ifndef  BOOST_LCAST_NO_WCHAR_T
 127     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"inf") ) );
 128     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"INF") ) );
 129
 130     BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-inf") ) );
 131     BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-INF") ) );
 132
 133     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+inf") ) );
 134     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+INF") ) );
 135
 136     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"infinity") ) );
 137     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"INFINITY") ) );
 138
 139     BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-infinity") ) );
 140     BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-INFINITY") ) );
 141
 142     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+infinity") ) );
 143     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+INFINITY") ) );
 144
 145     BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-infINIty") ) );
 146     BOOST_CHECK( is_neg_inf( lexical_cast<test_t>(L"-INFiniTY") ) );
 147
 148     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+inFINIty") ) );
 149     BOOST_CHECK( is_pos_inf( lexical_cast<test_t>(L"+INfinITY") ) );
 150
 151     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"nan") ) );
 152     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"NAN") ) );
 153
 154     BOOST_CHECK( is_neg_nan( lexical_cast<test_t>(L"-nan") ) );
 155     BOOST_CHECK( is_neg_nan( lexical_cast<test_t>(L"-NAN") ) );
 156
 157     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"+nan") ) );
 158     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"+NAN") ) );
 159
 160     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"nan()") ) );
 161     BOOST_CHECK( is_pos_nan( lexical_cast<test_t>(L"NAN(some string)") ) );
 162     BOOST_CHECK_THROW( lexical_cast<test_t>(L"NAN(some string"), bad_lexical_cast );
 163
 164     BOOST_CHECK(lexical_cast<std::wstring>( (boost::math::changesign)(std::numeric_limits<test_t >::infinity()))
 165                 == L"-inf" );
 166     BOOST_CHECK(lexical_cast<std::wstring>( std::numeric_limits<test_t >::infinity()) == L"inf" );
 167     BOOST_CHECK(lexical_cast<std::wstring>( std::numeric_limits<test_t >::quiet_NaN()) == L"nan" );
 168 #if !defined(__ia64__) && !defined(_M_IA64)
 169     BOOST_CHECK(lexical_cast<std::wstring>(
 170                 (boost::math::changesign)(std::numeric_limits<test_t >::quiet_NaN()))
 171                 == L"-nan" );
 172 #endif
 173
 174 #endif
 175 }
 176
 177 void test_inf_nan_float()
 178 {
 179     test_inf_nan_templated<float >();
 180 }
 181
 182 void test_inf_nan_double()
 183 {
 184     test_inf_nan_templated<double >();
 185 }
 186
 187 void test_inf_nan_long_double()
 188 {
 189     test_inf_nan_templated<long double >();
 190 }
 191
 192 unit_test::test_suite *init_unit_test_suite(int, char *[])
 193 {
 194     unit_test::test_suite *suite =
 195         BOOST_TEST_SUITE("lexical_cast inf anf nan parsing unit test");
 196     suite->add(BOOST_TEST_CASE(&test_inf_nan_float));
 197     suite->add(BOOST_TEST_CASE(&test_inf_nan_double));
 198     suite->add(BOOST_TEST_CASE(&test_inf_nan_long_double));
 199
 200     return suite;
 201 }