]> git.proxmox.com Git - ceph.git/blame - ceph/src/boost/libs/lexical_cast/test/lexical_cast_test.cpp
projects / ceph.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
import new upstream nautilus stable release 14.2.8
[ceph.git] / ceph / src / boost / libs / lexical_cast / test / lexical_cast_test.cpp
CommitLineData
7c673cae
FG		 1// Unit test for boost::lexical_cast.
2//
3// See http://www.boost.org for most recent version, including documentation.
4//
5// Copyright Terje Sletteb and Kevlin Henney, 2005.
6// Copyright Alexander Nasonov, 2006.
92f5a8d4 7// Copyright Antony Polukhin, 2011-2019.
7c673cae
FG		 8//
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).
12//
13// Note: The unit test no longer compile on MSVC 6, but lexical_cast itself works for it.
14
15//
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:
19//
20#define _SCL_SECURE_NO_WARNINGS
21
22#include <boost/config.hpp>
23
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)
28#endif
29
30#include <boost/lexical_cast.hpp>
31
32#include <boost/cstdint.hpp>
33#include <boost/test/unit_test.hpp>
34#include <boost/test/floating_point_comparison.hpp>
35
36#include <boost/type_traits/integral_promotion.hpp>
37#include <string>
38#include <vector>
39#include <algorithm> // std::transform
40#include <memory>
41
42#if (defined(BOOST_HAS_LONG_LONG) || defined(BOOST_HAS_MS_INT64)) \
43 && !(defined(BOOST_MSVC) && BOOST_MSVC < 1300)
44#define LCAST_TEST_LONGLONG
45#endif
46
47#if defined(BOOST_NO_STRINGSTREAM) || defined(BOOST_NO_STD_WSTRING)
48#define BOOST_LCAST_NO_WCHAR_T
49#endif
50
51template<class CharT>
52struct my_traits : std::char_traits<CharT>
53{
54};
55
56template<class CharT>
57struct my_allocator : std::allocator<CharT>
58{
59 typedef std::allocator<CharT> base_t;
60
61 my_allocator(){}
62 template <class U> my_allocator(const my_allocator<U>& v) : base_t(v) {}
63
64 template <class U> struct rebind { typedef my_allocator<U> other; };
65};
66
67using namespace boost;
68
69void test_conversion_to_char();
70void test_conversion_to_int();
71void test_conversion_to_double();
72void test_conversion_to_bool();
73void test_conversion_with_nonconst_char();
74void test_conversion_to_string();
75void test_conversion_from_to_wchar_t_alias();
76void test_conversion_from_wchar_t();
77void test_conversion_to_wchar_t();
78void test_conversion_from_wstring();
79void test_conversion_to_wstring();
80void test_bad_lexical_cast();
81void test_no_whitespace_stripping();
82void test_volatile_types_conversions();
83#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
84void test_traits();
85void test_wtraits();
86void test_allocator();
87void test_wallocator();
88#endif
89void test_char_types_conversions();
90void operators_overload_test();
91#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
92void test_char16_conversions();
93#endif
94#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
95void test_char32_conversions();
96#endif
97void test_getting_pointer_to_function();
98
99unit_test::test_suite *init_unit_test_suite(int, char *[])
100{
101 unit_test::test_suite *suite =
102 BOOST_TEST_SUITE("lexical_cast unit test");
103 suite->add(BOOST_TEST_CASE(test_conversion_to_char));
104 suite->add(BOOST_TEST_CASE(test_conversion_to_int));
105 suite->add(BOOST_TEST_CASE(test_conversion_to_double));
106 suite->add(BOOST_TEST_CASE(test_conversion_to_bool));
107 suite->add(BOOST_TEST_CASE(test_conversion_from_to_wchar_t_alias));
108 suite->add(BOOST_TEST_CASE(test_conversion_to_string));
109 suite->add(BOOST_TEST_CASE(test_conversion_with_nonconst_char));
110#ifndef BOOST_LCAST_NO_WCHAR_T
111 suite->add(BOOST_TEST_CASE(test_conversion_from_wchar_t));
112 suite->add(BOOST_TEST_CASE(test_conversion_to_wchar_t));
113 suite->add(BOOST_TEST_CASE(test_conversion_from_wstring));
114 suite->add(BOOST_TEST_CASE(test_conversion_to_wstring));
115#endif
116 suite->add(BOOST_TEST_CASE(test_bad_lexical_cast));
117 suite->add(BOOST_TEST_CASE(test_no_whitespace_stripping));
118 suite->add(BOOST_TEST_CASE(test_volatile_types_conversions));
119#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
120 suite->add(BOOST_TEST_CASE(&test_traits));
121 suite->add(BOOST_TEST_CASE(&test_wtraits));
122 suite->add(BOOST_TEST_CASE(&test_allocator));
123 suite->add(BOOST_TEST_CASE(&test_wallocator));
124#endif
125
126 suite->add(BOOST_TEST_CASE(&test_char_types_conversions));
127 suite->add(BOOST_TEST_CASE(&operators_overload_test));
128#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
129 suite->add(BOOST_TEST_CASE(&test_char16_conversions));
130#endif
131#if !defined(BOOST_NO_CXX11_CHAR32_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
132 suite->add(BOOST_TEST_CASE(&test_char32_conversions));
133#endif
134 suite->add(BOOST_TEST_CASE(&test_getting_pointer_to_function));
135
136 return suite;
137}
138
139void test_conversion_to_char()
140{
141 BOOST_CHECK_EQUAL('A', lexical_cast<char>('A'));
142 BOOST_CHECK_EQUAL(' ', lexical_cast<char>(' '));
143 BOOST_CHECK_EQUAL('1', lexical_cast<char>(1));
144 BOOST_CHECK_EQUAL('0', lexical_cast<char>(0));
145 BOOST_CHECK_THROW(lexical_cast<char>(123), bad_lexical_cast);
146 BOOST_CHECK_EQUAL('1', lexical_cast<char>(1.0));
147 BOOST_CHECK_EQUAL('1', lexical_cast<char>(true));
148 BOOST_CHECK_EQUAL('0', lexical_cast<char>(false));
149 BOOST_CHECK_EQUAL('A', lexical_cast<char>("A"));
150 BOOST_CHECK_EQUAL(' ', lexical_cast<char>(" "));
151 BOOST_CHECK_THROW(lexical_cast<char>(""), bad_lexical_cast);
152 BOOST_CHECK_THROW(lexical_cast<char>("Test"), bad_lexical_cast);
153 BOOST_CHECK_EQUAL('A', lexical_cast<char>(std::string("A")));
154 BOOST_CHECK_EQUAL(' ', lexical_cast<char>(std::string(" ")));
155 BOOST_CHECK_THROW(
156 lexical_cast<char>(std::string("")), bad_lexical_cast);
157 BOOST_CHECK_THROW(
158 lexical_cast<char>(std::string("Test")), bad_lexical_cast);
159}
160
161void test_conversion_to_int()
162{
163 BOOST_CHECK_EQUAL(1, lexical_cast<int>('1'));
164 BOOST_CHECK_EQUAL(0, lexical_cast<int>('0'));
165 BOOST_CHECK_THROW(lexical_cast<int>('A'), bad_lexical_cast);
166 BOOST_CHECK_EQUAL(1, lexical_cast<int>(1));
167 BOOST_CHECK_EQUAL(1, lexical_cast<int>(1.0));
168
169 BOOST_CHECK_EQUAL(
170 (std::numeric_limits<int>::max)(),
171 lexical_cast<int>((std::numeric_limits<int>::max)()));
172
173 BOOST_CHECK_EQUAL(
174 (std::numeric_limits<int>::min)(),
175 lexical_cast<int>((std::numeric_limits<int>::min)()));
176
177 BOOST_CHECK_THROW(lexical_cast<int>(1.23), bad_lexical_cast);
178
179 BOOST_CHECK_THROW(lexical_cast<int>(1e20), bad_lexical_cast);
180 BOOST_CHECK_EQUAL(1, lexical_cast<int>(true));
181 BOOST_CHECK_EQUAL(0, lexical_cast<int>(false));
182 BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
183 BOOST_CHECK_THROW(
184 lexical_cast<int>(" 123"), bad_lexical_cast);
185 BOOST_CHECK_THROW(lexical_cast<int>(""), bad_lexical_cast);
186 BOOST_CHECK_THROW(lexical_cast<int>("Test"), bad_lexical_cast);
187 BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
188 BOOST_CHECK_EQUAL(123, lexical_cast<int>(std::string("123")));
189 BOOST_CHECK_THROW(
190 lexical_cast<int>(std::string(" 123")), bad_lexical_cast);
191 BOOST_CHECK_THROW(
192 lexical_cast<int>(std::string("")), bad_lexical_cast);
193 BOOST_CHECK_THROW(
194 lexical_cast<int>(std::string("Test")), bad_lexical_cast);
195}
196
197void test_conversion_with_nonconst_char()
198{
199 std::vector<char> buffer;
200 buffer.push_back('1');
201 buffer.push_back('\0');
202 BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer[0]), 1);
203
204 std::vector<unsigned char> buffer2;
205 buffer2.push_back('1');
206 buffer2.push_back('\0');
207 BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer2[0]), 1);
208
209 std::vector<unsigned char> buffer3;
210 buffer3.push_back('1');
211 buffer3.push_back('\0');
212 BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer3[0]), 1);
213
214#ifndef BOOST_LCAST_NO_WCHAR_T
215 std::vector<wchar_t> buffer4;
216 buffer4.push_back(L'1');
217 buffer4.push_back(L'\0');
218 BOOST_CHECK_EQUAL(boost::lexical_cast<int>(&buffer4[0]), 1);
219#endif
220}
221
222void test_conversion_to_double()
223{
224 BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<double>('1'), (std::numeric_limits<double>::epsilon()));
225 BOOST_CHECK_THROW(lexical_cast<double>('A'), bad_lexical_cast);
226 BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<double>(1), (std::numeric_limits<double>::epsilon()));
227 BOOST_CHECK_CLOSE_FRACTION(1.23, lexical_cast<double>(1.23), (std::numeric_limits<double>::epsilon()));
228 BOOST_CHECK_CLOSE_FRACTION(1.234567890, lexical_cast<double>(1.234567890), std::numeric_limits<double>::epsilon());
229 BOOST_CHECK_CLOSE_FRACTION(1.234567890, lexical_cast<double>("1.234567890"), std::numeric_limits<double>::epsilon());
230 BOOST_CHECK_CLOSE_FRACTION(1.0, lexical_cast<double>(true), (std::numeric_limits<double>::epsilon()));
231 BOOST_CHECK_CLOSE_FRACTION(0.0, lexical_cast<double>(false), (std::numeric_limits<double>::epsilon()));
232 BOOST_CHECK_CLOSE_FRACTION(1.23, lexical_cast<double>("1.23"), (std::numeric_limits<double>::epsilon()));
233 BOOST_CHECK_THROW(lexical_cast<double>(""), bad_lexical_cast);
234 BOOST_CHECK_THROW(lexical_cast<double>("Test"), bad_lexical_cast);
235 BOOST_CHECK_CLOSE_FRACTION(1.23, lexical_cast<double>(std::string("1.23")), (std::numeric_limits<double>::epsilon()));
236 BOOST_CHECK_THROW(
237 lexical_cast<double>(std::string("")), bad_lexical_cast);
238 BOOST_CHECK_THROW(
239 lexical_cast<double>(std::string("Test")), bad_lexical_cast);
240}
241
242void test_conversion_to_bool()
243{
244 BOOST_CHECK_EQUAL(true, lexical_cast<bool>('1'));
245 BOOST_CHECK_EQUAL(false, lexical_cast<bool>('0'));
246 BOOST_CHECK_THROW(lexical_cast<bool>('A'), bad_lexical_cast);
247 BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1));
248 BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0));
249 BOOST_CHECK_THROW(lexical_cast<bool>(123), bad_lexical_cast);
250 BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1.0));
251 BOOST_CHECK_THROW(lexical_cast<bool>(-123), bad_lexical_cast);
252 BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0.0));
253 BOOST_CHECK_THROW(lexical_cast<bool>(1234), bad_lexical_cast);
254#if !defined(_CRAYC)
255 // Looks like a bug in CRAY compiler (throws bad_lexical_cast)
256 // TODO: localize the bug and report it to developers.
257 BOOST_CHECK_EQUAL(true, lexical_cast<bool>(true));
258 BOOST_CHECK_EQUAL(false, lexical_cast<bool>(false));
259#endif
260 BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
261 BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
262 BOOST_CHECK_THROW(lexical_cast<bool>(""), bad_lexical_cast);
263 BOOST_CHECK_THROW(lexical_cast<bool>("Test"), bad_lexical_cast);
264 BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
265 BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
266 BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::string("1")));
267 BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::string("0")));
268
269 BOOST_CHECK_THROW(lexical_cast<bool>(1.0001L), bad_lexical_cast);
270 BOOST_CHECK_THROW(lexical_cast<bool>(2), bad_lexical_cast);
271 BOOST_CHECK_THROW(lexical_cast<bool>(2u), bad_lexical_cast);
272 BOOST_CHECK_THROW(lexical_cast<bool>(-1), bad_lexical_cast);
273 BOOST_CHECK_THROW(lexical_cast<bool>(-2), bad_lexical_cast);
274
275
276 BOOST_CHECK_THROW(
277 lexical_cast<bool>(std::string("")), bad_lexical_cast);
278 BOOST_CHECK_THROW(
279 lexical_cast<bool>(std::string("Test")), bad_lexical_cast);
280
281 BOOST_CHECK(lexical_cast<bool>("+1") == true);
282 BOOST_CHECK(lexical_cast<bool>("+0") == false);
283 BOOST_CHECK(lexical_cast<bool>("-0") == false);
284 BOOST_CHECK_THROW(lexical_cast<bool>("--0"), bad_lexical_cast);
285 BOOST_CHECK_THROW(lexical_cast<bool>("-+-0"), bad_lexical_cast);
286
287 BOOST_CHECK(lexical_cast<bool>("0") == false);
288 BOOST_CHECK(lexical_cast<bool>("1") == true);
289 BOOST_CHECK(lexical_cast<bool>("00") == false);
290 BOOST_CHECK(lexical_cast<bool>("00000000000") == false);
291 BOOST_CHECK(lexical_cast<bool>("000000000001") == true);
292 BOOST_CHECK(lexical_cast<bool>("+00") == false );
293 BOOST_CHECK(lexical_cast<bool>("-00") == false );
294 BOOST_CHECK(lexical_cast<bool>("+00000000001") == true );
295
296 BOOST_CHECK_THROW(lexical_cast<bool>("020"), bad_lexical_cast);
297 BOOST_CHECK_THROW(lexical_cast<bool>("00200"), bad_lexical_cast);
298 BOOST_CHECK_THROW(lexical_cast<bool>("-00200"), bad_lexical_cast);
299 BOOST_CHECK_THROW(lexical_cast<bool>("+00200"), bad_lexical_cast);
300 BOOST_CHECK_THROW(lexical_cast<bool>("000000000002"), bad_lexical_cast);
301 BOOST_CHECK_THROW(lexical_cast<bool>("-1"), bad_lexical_cast);
302 BOOST_CHECK_THROW(lexical_cast<bool>("-0000000001"), bad_lexical_cast);
303 BOOST_CHECK_THROW(lexical_cast<bool>("00000000011"), bad_lexical_cast);
304 BOOST_CHECK_THROW(lexical_cast<bool>("001001"), bad_lexical_cast);
305 BOOST_CHECK_THROW(lexical_cast<bool>("-00000000010"), bad_lexical_cast);
306 BOOST_CHECK_THROW(lexical_cast<bool>("-000000000100"), bad_lexical_cast);
307}
308
309void test_conversion_to_string()
310{
311 char buf[] = "hello";
312 char* str = buf;
313 BOOST_CHECK_EQUAL(str, lexical_cast<std::string>(str));
314 BOOST_CHECK_EQUAL("A", lexical_cast<std::string>('A'));
315 BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(' '));
316 BOOST_CHECK_EQUAL("123", lexical_cast<std::string>(123));
317 BOOST_CHECK_EQUAL("1.23", lexical_cast<std::string>(1.23));
318 BOOST_CHECK_EQUAL("1.111111111", lexical_cast<std::string>(1.111111111));
319 BOOST_CHECK_EQUAL("1", lexical_cast<std::string>(true));
320 BOOST_CHECK_EQUAL("0", lexical_cast<std::string>(false));
321 BOOST_CHECK_EQUAL("Test", lexical_cast<std::string>("Test"));
322 BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(" "));
323 BOOST_CHECK_EQUAL("", lexical_cast<std::string>(""));
324 BOOST_CHECK_EQUAL("Test", lexical_cast<std::string>(std::string("Test")));
325 BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(std::string(" ")));
326 BOOST_CHECK_EQUAL("", lexical_cast<std::string>(std::string("")));
327}
328
329void test_conversion_from_to_wchar_t_alias()
330{
331 BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned short>("123"));
332 BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned int>("123"));
333 BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned long>("123"));
334 BOOST_CHECK_EQUAL(std::string("123"),
335 lexical_cast<std::string>(static_cast<unsigned short>(123)));
336 BOOST_CHECK_EQUAL(std::string("123"), lexical_cast<std::string>(123u));
337 BOOST_CHECK_EQUAL(std::string("123"), lexical_cast<std::string>(123ul));
338}
339
340void test_conversion_from_wchar_t()
341{
342#ifndef BOOST_LCAST_NO_WCHAR_T
343#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
344 BOOST_CHECK_EQUAL(1, lexical_cast<int>(L'1'));
345 BOOST_CHECK_THROW(lexical_cast<int>(L'A'), bad_lexical_cast);
346#endif
347
348 BOOST_CHECK_EQUAL(123, lexical_cast<int>(L"123"));
349 BOOST_CHECK_THROW(lexical_cast<int>(L""), bad_lexical_cast);
350 BOOST_CHECK_THROW(lexical_cast<int>(L"Test"), bad_lexical_cast);
351
352#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
353 BOOST_CHECK_EQUAL(1.0, lexical_cast<double>(L'1'));
354 BOOST_CHECK_THROW(lexical_cast<double>(L'A'), bad_lexical_cast);
355#endif
356
357 BOOST_CHECK_EQUAL(1.23, lexical_cast<double>(L"1.23"));
358 BOOST_CHECK_THROW(lexical_cast<double>(L""), bad_lexical_cast);
359 BOOST_CHECK_THROW(lexical_cast<double>(L"Test"), bad_lexical_cast);
360
361#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
362 BOOST_CHECK_EQUAL(true, lexical_cast<bool>(L'1'));
363 BOOST_CHECK_EQUAL(false, lexical_cast<bool>(L'0'));
364 BOOST_CHECK_THROW(lexical_cast<bool>(L'A'), bad_lexical_cast);
365#endif
366 BOOST_CHECK_EQUAL(true, lexical_cast<bool>(L"1"));
367 BOOST_CHECK_EQUAL(false, lexical_cast<bool>(L"0"));
368 BOOST_CHECK_THROW(lexical_cast<bool>(L""), bad_lexical_cast);
369 BOOST_CHECK_THROW(lexical_cast<bool>(L"Test"), bad_lexical_cast);
370#endif
371}
372
373void test_conversion_to_wchar_t()
374{
375#if !defined(BOOST_LCAST_NO_WCHAR_T) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
376 BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(1));
377 BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(0));
378 BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>('1'));
379 BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>('0'));
380 BOOST_CHECK_THROW(lexical_cast<wchar_t>(123), bad_lexical_cast);
381 BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(1.0));
382 BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(0.0));
383 BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(true));
384 BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(false));
385 BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(L'A'));
386 BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(L' '));
387 BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(L"A"));
388 BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(L" "));
389 BOOST_CHECK_THROW(lexical_cast<wchar_t>(L""), bad_lexical_cast);
390 BOOST_CHECK_THROW(lexical_cast<wchar_t>(L"Test"), bad_lexical_cast);
391 BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(std::wstring(L"A")));
392 BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(std::wstring(L" ")));
393 BOOST_CHECK_THROW(
394 lexical_cast<wchar_t>(std::wstring(L"")), bad_lexical_cast);
395 BOOST_CHECK_THROW(
396 lexical_cast<wchar_t>(std::wstring(L"Test")), bad_lexical_cast);
397#endif
398 BOOST_CHECK(true);
399}
400
401void test_conversion_from_wstring()
402{
403#ifndef BOOST_LCAST_NO_WCHAR_T
404 BOOST_CHECK_EQUAL(123, lexical_cast<int>(std::wstring(L"123")));
405 BOOST_CHECK_THROW(
406 lexical_cast<int>(std::wstring(L"")), bad_lexical_cast);
407 BOOST_CHECK_THROW(
408 lexical_cast<int>(std::wstring(L"Test")), bad_lexical_cast);
409
410 BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::wstring(L"1")));
411 BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::wstring(L"0")));
412 BOOST_CHECK_THROW(
413 lexical_cast<bool>(std::wstring(L"")), bad_lexical_cast);
414 BOOST_CHECK_THROW(
415 lexical_cast<bool>(std::wstring(L"Test")), bad_lexical_cast);
416#endif
417 BOOST_CHECK(true);
418}
419
420void test_conversion_to_wstring()
421{
422#ifndef BOOST_LCAST_NO_WCHAR_T
423 wchar_t buf[] = L"hello";
424 wchar_t* str = buf;
425 BOOST_CHECK(str == lexical_cast<std::wstring>(str));
426 BOOST_CHECK(L"123" == lexical_cast<std::wstring>(123));
427 BOOST_CHECK(L"1.23" == lexical_cast<std::wstring>(1.23));
428 BOOST_CHECK(L"1" == lexical_cast<std::wstring>(true));
429 BOOST_CHECK(L"0" == lexical_cast<std::wstring>(false));
430#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
431 BOOST_CHECK(L"A" == lexical_cast<std::wstring>(L'A'));
432 BOOST_CHECK(L" " == lexical_cast<std::wstring>(L' '));
433 BOOST_CHECK(L"A" == lexical_cast<std::wstring>('A'));
434#endif
435 BOOST_CHECK(L"Test" == lexical_cast<std::wstring>(L"Test"));
436 BOOST_CHECK(L" " == lexical_cast<std::wstring>(L" "));
437 BOOST_CHECK(L"" == lexical_cast<std::wstring>(L""));
438 BOOST_CHECK(L"Test" == lexical_cast<std::wstring>(std::wstring(L"Test")));
439 BOOST_CHECK(L" " == lexical_cast<std::wstring>(std::wstring(L" ")));
440 BOOST_CHECK(L"" == lexical_cast<std::wstring>(std::wstring(L"")));
441#endif
442 BOOST_CHECK(true);
443}
444
445void test_bad_lexical_cast()
446{
447 try
448 {
449 lexical_cast<int>(std::string("Test"));
450
451 BOOST_CHECK(false); // Exception expected
452 }
453 catch(const bad_lexical_cast &e)
454 {
455 BOOST_CHECK(e.source_type() == typeid(std::string));
456 BOOST_CHECK(e.target_type() == typeid(int));
457 }
458}
459
460void test_no_whitespace_stripping()
461{
462 BOOST_CHECK_THROW(lexical_cast<int>(" 123"), bad_lexical_cast);
463 BOOST_CHECK_THROW(lexical_cast<int>("123 "), bad_lexical_cast);
464}
465
466void test_volatile_types_conversions()
467{
468 volatile int i1 = 100000;
469 BOOST_CHECK_EQUAL("100000", boost::lexical_cast<std::string>(i1));
470
471 volatile const int i2 = 100000;
472 BOOST_CHECK_EQUAL("100000", boost::lexical_cast<std::string>(i2));
473
474 volatile const long int i3 = 1000000;
475 BOOST_CHECK_EQUAL("1000000", boost::lexical_cast<std::string>(i3));
476}
477
478#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
479void test_traits()
480{
481 typedef std::basic_string<char, my_traits<char> > my_string;
482
483 my_string const s("s");
484 BOOST_CHECK(boost::lexical_cast<char>(s) == s[0]);
485 BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
486 BOOST_CHECK(boost::lexical_cast<my_string>(-1) == "-1");
487}
488
489void test_wtraits()
490{
491 typedef std::basic_string<wchar_t, my_traits<wchar_t> > my_string;
492
493 my_string const s(L"s");
494 BOOST_CHECK(boost::lexical_cast<wchar_t>(s) == s[0]);
495 BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
496 //BOOST_CHECK(boost::lexical_cast<my_string>(-1) == L"-1");
497 // Commented out because gcc 3.3 doesn't support this:
498 // basic_ostream<wchar_t, my_traits<wchar_t> > o; o << -1;
499}
500
501void test_allocator()
502{
503// Following test cause compilation error on MSVC2012:
504// (Reason: cannot convert from 'std::_Wrap_alloc<_Alloc>' to 'const my_allocator<CharT>')
505//
506// MSVC developer is notified about this issue
507#if !defined(_MSC_VER) || (_MSC_VER < 1700)
508 typedef std::basic_string< char
509 , std::char_traits<char>
510 , my_allocator<char>
511 > my_string;
512
513 my_string s("s");
514 BOOST_CHECK(boost::lexical_cast<char>(s) == s[0]);
515 BOOST_CHECK(boost::lexical_cast<std::string>(s) == "s");
516 BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
517 BOOST_CHECK(boost::lexical_cast<my_string>(1) == "1");
518 BOOST_CHECK(boost::lexical_cast<my_string>("s") == s);
519 BOOST_CHECK(boost::lexical_cast<my_string>(std::string("s")) == s);
520#endif
521}
522
523void test_wallocator()
524{
525// Following test cause compilation error on MSVC2012:
526// (Reason: cannot convert from 'std::_Wrap_alloc<_Alloc>' to 'const my_allocator<CharT>')
527//
528// MSVC developer is notified about this issue
529#if !defined(_MSC_VER) || (_MSC_VER < 1700)
530 typedef std::basic_string< wchar_t
531 , std::char_traits<wchar_t>
532 , my_allocator<wchar_t>
533 > my_string;
534
535 my_string s(L"s");
536 BOOST_CHECK(boost::lexical_cast<wchar_t>(s) == s[0]);
537 BOOST_CHECK(boost::lexical_cast<std::wstring>(s) == L"s");
538 BOOST_CHECK(boost::lexical_cast<my_string>(s) == s);
539 BOOST_CHECK(boost::lexical_cast<my_string>(1) == L"1");
540 BOOST_CHECK(boost::lexical_cast<my_string>(L"s") == s);
541 BOOST_CHECK(boost::lexical_cast<my_string>(std::wstring(L"s")) == s);
542#endif
543}
544
545#endif
546
547
548void test_char_types_conversions()
549{
550 const char c_arr[] = "Test array of chars";
551 const unsigned char uc_arr[] = "Test array of chars";
552 const signed char sc_arr[] = "Test array of chars";
553
554 BOOST_CHECK(boost::lexical_cast<std::string>(c_arr) == std::string(c_arr));
555 BOOST_CHECK(boost::lexical_cast<std::string>(uc_arr) == std::string(c_arr));
556 BOOST_CHECK(boost::lexical_cast<std::string>(sc_arr) == std::string(c_arr));
557
558 BOOST_CHECK(boost::lexical_cast<char>(c_arr[0]) == c_arr[0]);
559 BOOST_CHECK(boost::lexical_cast<char>(uc_arr[0]) == c_arr[0]);
560 BOOST_CHECK(boost::lexical_cast<char>(sc_arr[0]) == c_arr[0]);
561
562 BOOST_CHECK(boost::lexical_cast<unsigned char>(c_arr[0]) == uc_arr[0]);
563 BOOST_CHECK(boost::lexical_cast<unsigned char>(uc_arr[0]) == uc_arr[0]);
564 BOOST_CHECK(boost::lexical_cast<unsigned char>(sc_arr[0]) == uc_arr[0]);
565
566 BOOST_CHECK(boost::lexical_cast<signed char>(c_arr[0]) == sc_arr[0]);
567 BOOST_CHECK(boost::lexical_cast<signed char>(uc_arr[0]) == sc_arr[0]);
568 BOOST_CHECK(boost::lexical_cast<signed char>(sc_arr[0]) == sc_arr[0]);
569
570#ifndef BOOST_LCAST_NO_WCHAR_T
571 const wchar_t wc_arr[]=L"Test array of chars";
572
573 BOOST_CHECK(boost::lexical_cast<std::wstring>(wc_arr) == std::wstring(wc_arr));
574 BOOST_CHECK(boost::lexical_cast<wchar_t>(wc_arr[0]) == wc_arr[0]);
575
576#endif
577}
578
579
580
581struct foo_operators_test
582{
583 foo_operators_test() : f(2) {}
584 int f;
585};
586
587template <typename OStream>
588OStream& operator<<(OStream& ostr, const foo_operators_test& foo)
589{
590 ostr << foo.f;
591 return ostr;
592}
593
594template <typename IStream>
595IStream& operator>>(IStream& istr, foo_operators_test& foo)
596{
597 istr >> foo.f;
598 return istr;
599}
600
601void operators_overload_test()
602{
603 foo_operators_test foo;
604 BOOST_CHECK_EQUAL(boost::lexical_cast<std::string>(foo), "2");
605 BOOST_CHECK_EQUAL((boost::lexical_cast<foo_operators_test>("2")).f, 2);
606
607 // Must compile
608 (void)boost::lexical_cast<foo_operators_test>(foo);
609}
610
611
612#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
613void test_char16_conversions()
614{
615 BOOST_CHECK(u"100" == lexical_cast<std::u16string>(u"100"));
616 BOOST_CHECK(u"1" == lexical_cast<std::u16string>(u'1'));
617}
618#endif
619
620#if !defined(BOOST_NO_CXX11_CHAR16_T) && !defined(BOOST_NO_CXX11_UNICODE_LITERALS)
621void test_char32_conversions()
622{
623 BOOST_CHECK(U"100" == lexical_cast<std::u32string>(U"100"));
624 BOOST_CHECK(U"1" == lexical_cast<std::u32string>(U'1'));
625}
626#endif
627
628void test_getting_pointer_to_function()
629{
630 // Just checking that &lexical_cast<To, From> is not ambiguous
631 typedef char char_arr[4];
632 typedef int(*f1)(const char_arr&);
633 f1 p1 = &boost::lexical_cast<int, char_arr>;
634 BOOST_CHECK(p1);
635
636 typedef int(*f2)(const std::string&);
637 f2 p2 = &boost::lexical_cast<int, std::string>;
638 BOOST_CHECK(p2);
639
640 typedef std::string(*f3)(const int&);
641 f3 p3 = &boost::lexical_cast<std::string, int>;
642 BOOST_CHECK(p3);
643
644 std::vector<int> values;
645 std::vector<std::string> ret;
646 std::transform(values.begin(), values.end(), ret.begin(), boost::lexical_cast<std::string, int>);
647}
648
649
Ceph