1 // Unit test for boost::lexical_cast.
3 // See http://www.boost.org for most recent version, including documentation.
5 // Copyright Terje Sletteb and Kevlin Henney, 2005.
6 // Copyright Alexander Nasonov, 2006.
7 // Copyright Antony Polukhin, 2011-2019.
9 // Distributed under the Boost
10 // Software License, Version 1.0. (See accompanying file
11 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
13 // Note: The unit test no longer compile on MSVC 6, but lexical_cast itself works for it.
16 // We need this #define before any #includes: otherwise msvc will emit warnings
17 // deep within std::string, resulting from our (perfectly legal) use of basic_string
18 // with a custom traits class:
20 #define _SCL_SECURE_NO_WARNINGS
22 #include <boost/config.hpp>
24 #if defined(__INTEL_COMPILER)
25 #pragma warning(disable: 193 383 488 981 1418 1419)
26 #elif defined(BOOST_MSVC)
27 #pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
30 #include <boost/lexical_cast.hpp>
32 #include <boost/cstdint.hpp>
33 #include <boost/test/unit_test.hpp>
34 #include <boost/test/floating_point_comparison.hpp>
36 #include <boost/type_traits/integral_promotion.hpp>
37 #include <boost/type_traits/make_unsigned.hpp>
42 #if (defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)) \
43 && !(defined(BOOST_MSVC) && BOOST_MSVC < 1300)
44 #define LCAST_TEST_LONGLONG
47 #if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
48 #define BOOST_LCAST_NO_WCHAR_T
51 // Test all 65536 values if true:
52 bool const lcast_test_small_integral_types_completely
= false;
54 // lcast_integral_test_counter: use when testing all values of an integral
55 // types is not possible. Max. portable value is 32767.
56 int const lcast_integral_test_counter
=500;
58 using namespace boost
;
62 void test_conversion_from_to_short();
63 void test_conversion_from_to_ushort();
64 void test_conversion_from_to_int();
65 void test_conversion_from_to_uint();
66 void test_conversion_from_to_long();
67 void test_conversion_from_to_ulong();
68 void test_conversion_from_to_intmax_t();
69 void test_conversion_from_to_uintmax_t();
70 #ifdef LCAST_TEST_LONGLONG
71 void test_conversion_from_to_longlong();
72 void test_conversion_from_to_ulonglong();
74 #ifdef BOOST_HAS_INT128
75 void test_conversion_from_to_int128();
76 void test_conversion_from_to_uint128();
78 void test_integral_conversions_on_min_max();
81 unit_test::test_suite
*init_unit_test_suite(int, char *[])
83 unit_test::test_suite
*suite
=
84 BOOST_TEST_SUITE("lexical_cast unit test on integral types");
86 suite
->add(BOOST_TEST_CASE(&test_conversion_from_to_short
));
87 suite
->add(BOOST_TEST_CASE(&test_conversion_from_to_ushort
));
88 suite
->add(BOOST_TEST_CASE(&test_conversion_from_to_int
));
89 suite
->add(BOOST_TEST_CASE(&test_conversion_from_to_uint
));
90 suite
->add(BOOST_TEST_CASE(&test_conversion_from_to_long
));
91 suite
->add(BOOST_TEST_CASE(&test_conversion_from_to_ulong
));
92 suite
->add(BOOST_TEST_CASE(&test_conversion_from_to_intmax_t
));
93 suite
->add(BOOST_TEST_CASE(&test_conversion_from_to_uintmax_t
));
94 #ifdef LCAST_TEST_LONGLONG
95 suite
->add(BOOST_TEST_CASE(&test_conversion_from_to_longlong
));
96 suite
->add(BOOST_TEST_CASE(&test_conversion_from_to_ulonglong
));
98 #ifdef BOOST_HAS_INT128
99 suite
->add(BOOST_TEST_CASE(&test_conversion_from_to_int128
));
100 suite
->add(BOOST_TEST_CASE(&test_conversion_from_to_uint128
));
102 suite
->add(BOOST_TEST_CASE(&test_integral_conversions_on_min_max
));
107 template<class T
, class CharT
>
108 void test_conversion_from_integral_to_char(CharT zero
)
110 BOOST_CHECK(lexical_cast
<CharT
>(static_cast<T
>(0)) == zero
+ 0);
111 BOOST_CHECK(lexical_cast
<CharT
>(static_cast<T
>(1)) == zero
+ 1);
112 BOOST_CHECK(lexical_cast
<CharT
>(static_cast<T
>(2)) == zero
+ 2);
113 BOOST_CHECK(lexical_cast
<CharT
>(static_cast<T
>(3)) == zero
+ 3);
114 BOOST_CHECK(lexical_cast
<CharT
>(static_cast<T
>(4)) == zero
+ 4);
115 BOOST_CHECK(lexical_cast
<CharT
>(static_cast<T
>(5)) == zero
+ 5);
116 BOOST_CHECK(lexical_cast
<CharT
>(static_cast<T
>(6)) == zero
+ 6);
117 BOOST_CHECK(lexical_cast
<CharT
>(static_cast<T
>(7)) == zero
+ 7);
118 BOOST_CHECK(lexical_cast
<CharT
>(static_cast<T
>(8)) == zero
+ 8);
119 BOOST_CHECK(lexical_cast
<CharT
>(static_cast<T
>(9)) == zero
+ 9);
121 BOOST_CHECK_THROW(lexical_cast
<CharT
>(static_cast<T
>(10)), bad_lexical_cast
);
123 T t
= (std::numeric_limits
<T
>::max
)();
124 BOOST_CHECK_THROW(lexical_cast
<CharT
>(t
), bad_lexical_cast
);
127 template<class T
, class CharT
>
128 void test_conversion_from_char_to_integral(CharT zero
)
130 BOOST_CHECK(lexical_cast
<T
>( static_cast<CharT
>(zero
+ 0)) == static_cast<T
>(0) );
131 BOOST_CHECK(lexical_cast
<T
>( static_cast<CharT
>(zero
+ 1)) == static_cast<T
>(1) );
132 BOOST_CHECK(lexical_cast
<T
>( static_cast<CharT
>(zero
+ 2)) == static_cast<T
>(2) );
133 BOOST_CHECK(lexical_cast
<T
>( static_cast<CharT
>(zero
+ 3)) == static_cast<T
>(3) );
134 BOOST_CHECK(lexical_cast
<T
>( static_cast<CharT
>(zero
+ 4)) == static_cast<T
>(4) );
135 BOOST_CHECK(lexical_cast
<T
>( static_cast<CharT
>(zero
+ 5)) == static_cast<T
>(5) );
136 BOOST_CHECK(lexical_cast
<T
>( static_cast<CharT
>(zero
+ 6)) == static_cast<T
>(6) );
137 BOOST_CHECK(lexical_cast
<T
>( static_cast<CharT
>(zero
+ 7)) == static_cast<T
>(7) );
138 BOOST_CHECK(lexical_cast
<T
>( static_cast<CharT
>(zero
+ 8)) == static_cast<T
>(8) );
139 BOOST_CHECK(lexical_cast
<T
>( static_cast<CharT
>(zero
+ 9)) == static_cast<T
>(9) );
141 BOOST_CHECK_THROW(lexical_cast
<T
>( static_cast<CharT
>(zero
+ 10)), bad_lexical_cast
);
142 BOOST_CHECK_THROW(lexical_cast
<T
>( static_cast<CharT
>(zero
- 1)), bad_lexical_cast
);
146 void test_conversion_from_integral_to_integral()
149 BOOST_CHECK(lexical_cast
<T
>(t
) == t
);
151 // Next two variables are used to suppress warnings.
152 int st
= 32767; unsigned int ut
= st
;
154 BOOST_CHECK(lexical_cast
<short>(t
) == st
);
155 BOOST_CHECK(lexical_cast
<unsigned short>(t
) == ut
);
156 BOOST_CHECK(lexical_cast
<int>(t
) == st
);
157 BOOST_CHECK(lexical_cast
<unsigned int>(t
) == ut
);
158 BOOST_CHECK(lexical_cast
<long>(t
) == st
);
159 BOOST_CHECK(lexical_cast
<unsigned long>(t
) == ut
);
161 t
= (std::numeric_limits
<T
>::max
)();
162 BOOST_CHECK(lexical_cast
<T
>(t
) == t
);
164 t
= (std::numeric_limits
<T
>::min
)();
165 BOOST_CHECK(lexical_cast
<T
>(t
) == t
);
171 // Replace "-,999" with "-999".
172 template<class CharT
>
173 std::basic_string
<CharT
> to_str_gcc_workaround(std::basic_string
<CharT
> str
)
176 std::numpunct
<CharT
> const& np
= BOOST_USE_FACET(std::numpunct
<CharT
>, loc
);
177 std::ctype
<CharT
> const& ct
= BOOST_USE_FACET(std::ctype
<CharT
>, loc
);
179 if(np
.grouping().empty())
182 CharT prefix
[3] = { ct
.widen('-'), np
.thousands_sep(), CharT() };
184 if(str
.find(prefix
) != 0)
188 str
.replace(0, 2, prefix
);
192 template<class CharT
, class T
>
193 std::basic_string
<CharT
> to_str(T t
)
195 std::basic_ostringstream
<CharT
> o
;
197 return to_str_gcc_workaround(o
.str());
201 template<class T
, class CharT
>
202 void test_conversion_from_integral_to_string(CharT
)
204 typedef std::numeric_limits
<T
> limits
;
205 typedef std::basic_string
<CharT
> string_type
;
210 BOOST_CHECK(lexical_cast
<string_type
>(t
) == to_str
<CharT
>(t
));
213 BOOST_CHECK(lexical_cast
<string_type
>(t
) == to_str
<CharT
>(t
));
215 if(limits::digits
<= 16 && lcast_test_small_integral_types_completely
)
216 // min and max have already been tested.
217 for(t
= 1 + (limits::min
)(); t
!= (limits::max
)(); ++t
)
218 BOOST_CHECK(lexical_cast
<string_type
>(t
) == to_str
<CharT
>(t
));
221 T
const min_val
= (limits::min
)();
222 T
const max_val
= (limits::max
)();
223 T
const half_max_val
= max_val
/ 2;
224 T
const cnt
= lcast_integral_test_counter
; // to suppress warnings
225 unsigned int const counter
= cnt
< half_max_val
? cnt
: half_max_val
;
229 // Test values around min:
231 for(i
= 0; i
< counter
; ++i
, ++t
)
232 BOOST_CHECK(lexical_cast
<string_type
>(t
) == to_str
<CharT
>(t
));
234 // Test values around max:
236 for(i
= 0; i
< counter
; ++i
, --t
)
237 BOOST_CHECK(lexical_cast
<string_type
>(t
) == to_str
<CharT
>(t
));
239 // Test values around zero:
240 if(limits::is_signed
)
241 for(t
= static_cast<T
>(-counter
); t
< static_cast<T
>(counter
); ++t
)
242 BOOST_CHECK(lexical_cast
<string_type
>(t
) == to_str
<CharT
>(t
));
244 // Test values around 100, 1000, 10000, ...
246 for(int e
= 2; e
< limits::digits10
; ++e
, ten_power
*= 10)
248 // ten_power + 100 probably never overflows
249 for(t
= ten_power
- 100; t
!= ten_power
+ 100; ++t
)
250 BOOST_CHECK(lexical_cast
<string_type
>(t
) == to_str
<CharT
>(t
));
255 template<class T
, class CharT
>
256 void test_conversion_from_string_to_integral(CharT
)
258 typedef std::numeric_limits
<T
> limits
;
259 typedef std::basic_string
<CharT
> string_type
;
262 string_type
const zero
= to_str
<CharT
>(0);
263 string_type
const nine
= to_str
<CharT
>(9);
264 T
const min_val
= (limits::min
)();
265 T
const max_val
= (limits::max
)();
267 s
= to_str
<CharT
>(min_val
);
268 BOOST_CHECK_EQUAL(lexical_cast
<T
>(s
), min_val
);
269 if(limits::is_signed
)
271 BOOST_CHECK_THROW(lexical_cast
<T
>(s
+ zero
), bad_lexical_cast
);
272 BOOST_CHECK_THROW(lexical_cast
<T
>(s
+ nine
), bad_lexical_cast
);
275 s
= to_str
<CharT
>(max_val
);
276 BOOST_CHECK_EQUAL(lexical_cast
<T
>(s
), max_val
);
278 BOOST_CHECK_THROW(lexical_cast
<T
>(s
+ zero
), bad_lexical_cast
);
279 BOOST_CHECK_THROW(lexical_cast
<T
>(s
+ nine
), bad_lexical_cast
);
281 s
= to_str
<CharT
>(max_val
);
282 for (int i
=1; i
<=10; ++i
) {
284 BOOST_CHECK_THROW(lexical_cast
<T
>( s
), bad_lexical_cast
);
287 s
= to_str
<CharT
>(max_val
);
289 typedef std::numpunct
<char> numpunct
;
290 if ( BOOST_USE_FACET(numpunct
, loc
).grouping().empty() ) {
291 // Following tests work well for locale C
292 BOOST_CHECK_EQUAL(lexical_cast
<T
>(to_str
<CharT
>(0)+s
), max_val
);
293 BOOST_CHECK_EQUAL(lexical_cast
<T
>(to_str
<CharT
>(0)+to_str
<CharT
>(0)+s
), max_val
);
294 BOOST_CHECK_EQUAL(lexical_cast
<T
>(to_str
<CharT
>(0)+to_str
<CharT
>(0)+to_str
<CharT
>(0)+s
), max_val
);
297 for (int i
=1; i
<=256; ++i
) {
298 BOOST_CHECK_THROW(lexical_cast
<T
>( to_str
<CharT
>(i
)+s
), bad_lexical_cast
);
301 typedef BOOST_DEDUCED_TYPENAME
boost::integral_promotion
<T
>::type promoted
;
302 if ( !(boost::is_same
<T
, promoted
>::value
) )
304 promoted prom
= max_val
;
305 s
= to_str
<CharT
>(max_val
);
306 for (int i
=1; i
<=256; ++i
) {
307 BOOST_CHECK_THROW(lexical_cast
<T
>( to_str
<CharT
>(prom
+i
) ), bad_lexical_cast
);
308 BOOST_CHECK_THROW(lexical_cast
<T
>( to_str
<CharT
>(i
)+s
), bad_lexical_cast
);
313 if(limits::digits
<= 16 && lcast_test_small_integral_types_completely
)
314 // min and max have already been tested.
315 for(T t
= 1 + min_val
; t
!= max_val
; ++t
)
316 BOOST_CHECK(lexical_cast
<T
>(to_str
<CharT
>(t
)) == t
);
319 T
const half_max_val
= max_val
/ 2;
320 T
const cnt
= lcast_integral_test_counter
; // to suppress warnings
321 unsigned int const counter
= cnt
< half_max_val
? cnt
: half_max_val
;
326 // Test values around min:
328 for(i
= 0; i
< counter
; ++i
, ++t
)
329 BOOST_CHECK(lexical_cast
<T
>(to_str
<CharT
>(t
)) == t
);
331 // Test values around max:
333 for(i
= 0; i
< counter
; ++i
, --t
)
334 BOOST_CHECK(lexical_cast
<T
>(to_str
<CharT
>(t
)) == t
);
336 // Test values around zero:
337 if(limits::is_signed
)
338 for(t
= static_cast<T
>(-counter
); t
< static_cast<T
>(counter
); ++t
)
339 BOOST_CHECK(lexical_cast
<T
>(to_str
<CharT
>(t
)) == t
);
341 // Test values around 100, 1000, 10000, ...
343 for(int e
= 2; e
< limits::digits10
; ++e
, ten_power
*= 10)
345 // ten_power + 100 probably never overflows
346 for(t
= ten_power
- 100; t
!= ten_power
+ 100; ++t
)
347 BOOST_CHECK(lexical_cast
<T
>(to_str
<CharT
>(t
)) == t
);
353 void test_conversion_from_to_integral_for_locale()
355 std::locale current_locale
;
356 typedef std::numpunct
<char> numpunct
;
357 numpunct
const& np
= BOOST_USE_FACET(numpunct
, current_locale
);
358 if ( !np
.grouping().empty() )
361 lexical_cast
<T
>( std::string("100") + np
.thousands_sep() + np
.thousands_sep() + "0" )
363 BOOST_CHECK_THROW(lexical_cast
<T
>( std::string("100") + np
.thousands_sep() ), bad_lexical_cast
);
364 BOOST_CHECK_THROW(lexical_cast
<T
>( np
.thousands_sep() + std::string("100") ), bad_lexical_cast
);
366 // Exception must not be thrown, when we are using no separators at all
367 BOOST_CHECK( lexical_cast
<T
>("30000") == static_cast<T
>(30000) );
371 test_conversion_from_integral_to_integral
<T
>();
373 // This is a part of test_conversion_from_integral_to_string<T>('0') method,
374 // but with BOOST_CHECK_EQUAL instead of BOOST_CHECK. It is required to see
375 // what is produced by the to_str<char>(t) method in situations when result
376 // is different. BOOST_CHECK does not work with wchar_t.
377 typedef std::numeric_limits
<T
> limits
;
378 T t
= (limits::min
)();
379 BOOST_CHECK_EQUAL(lexical_cast
<std::string
>(t
), to_str
<char>(t
));
381 test_conversion_from_integral_to_string
<T
>('0');
382 test_conversion_from_string_to_integral
<T
>('0');
383 #if !defined(BOOST_LCAST_NO_WCHAR_T)
384 if (lexical_cast
<std::wstring
>(t
) != to_str
<wchar_t>(t
)) {
385 // Something went wrong, and now we are attempting to find and print the
387 std::wstring wstr
= to_str
<wchar_t>(t
);
388 std::string lcast_str
= lexical_cast
<std::string
>(t
);
390 str
.reserve(wstr
.size());
391 for (std::size_t i
= 0; i
< wstr
.size(); ++i
) {
392 str
.push_back(static_cast<char>(wstr
[i
]));
395 BOOST_CHECK_EQUAL(lcast_str
.length(), lexical_cast
<std::wstring
>(t
).length());
396 BOOST_CHECK_EQUAL(to_str
<char>(t
), str
);
397 BOOST_CHECK_EQUAL(lcast_str
, str
);
400 test_conversion_from_integral_to_string
<T
>(L
'0');
401 test_conversion_from_string_to_integral
<T
>(L
'0');
405 struct restore_oldloc
408 ~restore_oldloc() { std::locale::global(oldloc
); }
412 void test_conversion_from_to_integral_minimal()
414 char const zero
= '0';
415 signed char const szero
= '0';
416 unsigned char const uzero
= '0';
417 test_conversion_from_integral_to_char
<T
>(zero
);
418 test_conversion_from_char_to_integral
<T
>(zero
);
419 test_conversion_from_integral_to_char
<T
>(szero
);
420 test_conversion_from_char_to_integral
<T
>(szero
);
421 test_conversion_from_integral_to_char
<T
>(uzero
);
422 test_conversion_from_char_to_integral
<T
>(uzero
);
423 #if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
424 wchar_t const wzero
= L
'0';
425 test_conversion_from_integral_to_char
<T
>(wzero
);
426 test_conversion_from_char_to_integral
<T
>(wzero
);
428 #if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION) && !defined(BOOST_MSVC)
429 char16_t
const u16zero
= u
'0';
430 test_conversion_from_integral_to_char
<T
>(u16zero
);
431 test_conversion_from_char_to_integral
<T
>(u16zero
);
433 #if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS) && !defined(_LIBCPP_VERSION) && !defined(BOOST_MSVC)
434 char32_t
const u32zero
= u
'0';
435 test_conversion_from_integral_to_char
<T
>(u32zero
);
436 test_conversion_from_char_to_integral
<T
>(u32zero
);
439 BOOST_CHECK(lexical_cast
<T
>("-1") == static_cast<T
>(-1));
440 BOOST_CHECK(lexical_cast
<T
>("-9") == static_cast<T
>(-9));
441 BOOST_CHECK(lexical_cast
<T
>(-1) == static_cast<T
>(-1));
442 BOOST_CHECK(lexical_cast
<T
>(-9) == static_cast<T
>(-9));
444 BOOST_CHECK_THROW(lexical_cast
<T
>("-1.0"), bad_lexical_cast
);
445 BOOST_CHECK_THROW(lexical_cast
<T
>("-9.0"), bad_lexical_cast
);
446 BOOST_CHECK(lexical_cast
<T
>(-1.0) == static_cast<T
>(-1));
447 BOOST_CHECK(lexical_cast
<T
>(-9.0) == static_cast<T
>(-9));
449 BOOST_CHECK(lexical_cast
<T
>(static_cast<T
>(1)) == static_cast<T
>(1));
450 BOOST_CHECK(lexical_cast
<T
>(static_cast<T
>(9)) == static_cast<T
>(9));
451 BOOST_CHECK_THROW(lexical_cast
<T
>(1.1f
), bad_lexical_cast
);
452 BOOST_CHECK_THROW(lexical_cast
<T
>(1.1), bad_lexical_cast
);
453 BOOST_CHECK_THROW(lexical_cast
<T
>(1.1L), bad_lexical_cast
);
454 BOOST_CHECK_THROW(lexical_cast
<T
>(1.0001f
), bad_lexical_cast
);
455 BOOST_CHECK_THROW(lexical_cast
<T
>(1.0001), bad_lexical_cast
);
456 BOOST_CHECK_THROW(lexical_cast
<T
>(1.0001L), bad_lexical_cast
);
458 BOOST_CHECK(lexical_cast
<T
>("+1") == static_cast<T
>(1) );
459 BOOST_CHECK(lexical_cast
<T
>("+9") == static_cast<T
>(9) );
460 BOOST_CHECK(lexical_cast
<T
>("+10") == static_cast<T
>(10) );
461 BOOST_CHECK(lexical_cast
<T
>("+90") == static_cast<T
>(90) );
462 BOOST_CHECK_THROW(lexical_cast
<T
>("++1"), bad_lexical_cast
);
463 BOOST_CHECK_THROW(lexical_cast
<T
>("-+9"), bad_lexical_cast
);
464 BOOST_CHECK_THROW(lexical_cast
<T
>("--1"), bad_lexical_cast
);
465 BOOST_CHECK_THROW(lexical_cast
<T
>("+-9"), bad_lexical_cast
);
466 // test_conversion_from_to_integral_for_locale
468 // Overflow test case from David W. Birdsall
469 std::string must_owerflow_str
= (sizeof(T
) < 16 ? "160000000000000000000" : "1600000000000000000000000000000000000000");
470 std::string must_owerflow_negative_str
= (sizeof(T
) < 16 ? "-160000000000000000000" : "-1600000000000000000000000000000000000000");
471 for (int i
= 0; i
< 15; ++i
) {
472 BOOST_CHECK_THROW(lexical_cast
<T
>(must_owerflow_str
), bad_lexical_cast
);
473 BOOST_CHECK_THROW(lexical_cast
<T
>(must_owerflow_negative_str
), bad_lexical_cast
);
475 must_owerflow_str
+= '0';
476 must_owerflow_negative_str
+= '0';
481 void test_conversion_from_to_integral()
483 test_conversion_from_to_integral_minimal
<T
>();
484 typedef std::numpunct
<char> numpunct
;
486 restore_oldloc guard
;
487 std::locale
const& oldloc
= guard
.oldloc
;
489 std::string grouping1
= BOOST_USE_FACET(numpunct
, oldloc
).grouping();
490 std::string
grouping2(grouping1
);
492 test_conversion_from_to_integral_for_locale
<T
>();
496 std::locale
newloc("");
497 std::locale::global(newloc
);
499 grouping2
= BOOST_USE_FACET(numpunct
, newloc
).grouping();
501 catch(std::exception
const& ex
)
503 std::string
msg("Failed to set system locale: ");
505 BOOST_TEST_MESSAGE(msg
);
508 if(grouping1
!= grouping2
)
509 test_conversion_from_to_integral_for_locale
<T
>();
511 if(grouping1
.empty() && grouping2
.empty())
512 BOOST_TEST_MESSAGE("Formatting with thousands_sep has not been tested");
515 void test_conversion_from_to_short()
517 test_conversion_from_to_integral
<short>();
520 void test_conversion_from_to_ushort()
522 test_conversion_from_to_integral
<unsigned short>();
525 void test_conversion_from_to_int()
527 test_conversion_from_to_integral
<int>();
530 void test_conversion_from_to_uint()
532 test_conversion_from_to_integral
<unsigned int>();
535 void test_conversion_from_to_long()
537 test_conversion_from_to_integral
<long>();
540 void test_conversion_from_to_ulong()
542 test_conversion_from_to_integral
<unsigned long>();
545 void test_conversion_from_to_intmax_t()
547 test_conversion_from_to_integral
<boost::intmax_t>();
550 void test_conversion_from_to_uintmax_t()
552 test_conversion_from_to_integral
<boost::uintmax_t>();
555 #if defined(BOOST_HAS_LONG_LONG)
557 void test_conversion_from_to_longlong()
559 test_conversion_from_to_integral
<boost::long_long_type
>();
562 void test_conversion_from_to_ulonglong()
564 test_conversion_from_to_integral
<boost::ulong_long_type
>();
567 #elif defined(BOOST_HAS_MS_INT64)
569 void test_conversion_from_to_longlong()
571 test_conversion_from_to_integral
<__int64
>();
574 void test_conversion_from_to_ulonglong()
576 test_conversion_from_to_integral
<unsigned __int64
>();
582 #ifdef BOOST_HAS_INT128
584 template <bool Specialized
, class T
>
585 struct test_if_specialized
{
586 static void test() {}
590 struct test_if_specialized
<true, T
> {
592 test_conversion_from_to_integral_minimal
<T
>();
596 void test_conversion_from_to_int128()
599 std::numeric_limits
<boost::int128_type
>::is_specialized
,
604 void test_conversion_from_to_uint128()
607 std::numeric_limits
<boost::int128_type
>::is_specialized
,
613 template <typename SignedT
>
614 void test_integral_conversions_on_min_max_impl()
616 typedef SignedT signed_t
;
617 typedef BOOST_DEDUCED_TYPENAME
boost::make_unsigned
<signed_t
>::type unsigned_t
;
619 typedef std::numeric_limits
<signed_t
> s_limits
;
620 typedef std::numeric_limits
<unsigned_t
> uns_limits
;
622 BOOST_CHECK_EQUAL(lexical_cast
<unsigned_t
>((uns_limits::max
)()), (uns_limits::max
)());
623 BOOST_CHECK_EQUAL(lexical_cast
<unsigned_t
>((uns_limits::min
)()), (uns_limits::min
)());
625 BOOST_CHECK_EQUAL(lexical_cast
<signed_t
>((s_limits::max
)()), (s_limits::max
)());
626 BOOST_CHECK_EQUAL(lexical_cast
<signed_t
>((uns_limits::min
)()), static_cast<signed_t
>((uns_limits::min
)()));
628 BOOST_CHECK_EQUAL(lexical_cast
<unsigned_t
>((s_limits::max
)()), static_cast<unsigned_t
>((s_limits::max
)()));
629 BOOST_CHECK_EQUAL(lexical_cast
<unsigned_t
>((s_limits::min
)()), static_cast<unsigned_t
>((s_limits::min
)()));
632 void test_integral_conversions_on_min_max()
634 test_integral_conversions_on_min_max_impl
<int>();
635 test_integral_conversions_on_min_max_impl
<short>();
638 test_integral_conversions_on_min_max_impl
<long int>();
640 #if defined(BOOST_HAS_LONG_LONG)
641 test_integral_conversions_on_min_max_impl
<boost::long_long_type
>();
642 #elif defined(BOOST_HAS_MS_INT64)
643 test_integral_conversions_on_min_max_impl
<__int64
>();
646 #ifdef BOOST_HAS_INT128
647 test_integral_conversions_on_min_max_impl
<boost::int128_type
>();