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-2020.
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/tools/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>
is_pos_inf(T value)35 bool is_pos_inf(T value)
36 {
37 return (boost::math::isinf)(value) && !(boost::math::signbit)(value);
38 }
39
40 template <class T>
is_neg_inf(T value)41 bool is_neg_inf(T value)
42 {
43 return (boost::math::isinf)(value) && (boost::math::signbit)(value);
44 }
45
46 template <class T>
is_pos_nan(T value)47 bool is_pos_nan(T value)
48 {
49 return (boost::math::isnan)(value) && !(boost::math::signbit)(value);
50 }
51
52 template <class T>
is_neg_nan(T value)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>
test_inf_nan_templated()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
test_inf_nan_float()177 void test_inf_nan_float()
178 {
179 test_inf_nan_templated<float >();
180 }
181
test_inf_nan_double()182 void test_inf_nan_double()
183 {
184 test_inf_nan_templated<double >();
185 }
186
test_inf_nan_long_double()187 void test_inf_nan_long_double()
188 {
189 // We do not run tests on compilers with bugs
190 #ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
191 test_inf_nan_templated<long double >();
192 #endif
193 BOOST_CHECK(true);
194 }
195
init_unit_test_suite(int,char * [])196 unit_test::test_suite *init_unit_test_suite(int, char *[])
197 {
198 unit_test::test_suite *suite =
199 BOOST_TEST_SUITE("lexical_cast inf anf nan parsing unit test");
200 suite->add(BOOST_TEST_CASE(&test_inf_nan_float));
201 suite->add(BOOST_TEST_CASE(&test_inf_nan_double));
202 suite->add(BOOST_TEST_CASE(&test_inf_nan_long_double));
203
204 return suite;
205 }
206