Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: downloads/boost_1_33_1/libs/conversion/lexical_cast_test.cpp @ 12

Last change on this file since 12 was 12, checked in by landauf, 17 years ago

added boost
File size: 13.3 KB
Line 
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//
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// Note: The unit test no longer compile on MSVC 6, but lexical_cast itself works for it.
12
13#include <boost/config.hpp>
14
15#if defined(__INTEL_COMPILER)
16#pragma warning(disable: 193 383 488 981 1418 1419)
17#elif defined(BOOST_MSVC)
18#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
19#endif
20
21#include <boost/lexical_cast.hpp>
22#include <boost/test/floating_point_comparison.hpp>
23#include <boost/test/included/unit_test_framework.hpp>
24
25#if defined(BOOST_NO_STRINGSTREAM) || \
26    defined(BOOST_NO_STD_WSTRING) || \
27    defined(BOOST_NO_STD_LOCALE)
28#define DISABLE_WIDE_CHAR_SUPPORT
29#endif
30
31using namespace boost;
32
33void test_conversion_to_char();
34void test_conversion_to_int();
35void test_conversion_to_double();
36void test_conversion_to_bool();
37void test_conversion_to_string();
38void test_conversion_from_to_wchar_t_alias();
39void test_conversion_to_pointer();
40void test_conversion_from_wchar_t();
41void test_conversion_to_wchar_t();
42void test_conversion_from_wstring();
43void test_conversion_to_wstring();
44void test_bad_lexical_cast();
45void test_no_whitespace_stripping();
46
47unit_test_framework::test_suite *init_unit_test_suite(int, char **)
48{
49    unit_test_framework::test_suite *suite =
50        BOOST_TEST_SUITE("lexical_cast unit test");
51    suite->add(BOOST_TEST_CASE(test_conversion_to_char));
52    suite->add(BOOST_TEST_CASE(test_conversion_to_int));
53    suite->add(BOOST_TEST_CASE(test_conversion_to_double));
54    suite->add(BOOST_TEST_CASE(test_conversion_to_bool));
55    suite->add(BOOST_TEST_CASE(test_conversion_from_to_wchar_t_alias));
56    suite->add(BOOST_TEST_CASE(test_conversion_to_pointer));
57    suite->add(BOOST_TEST_CASE(test_conversion_to_string));
58    #ifndef DISABLE_WIDE_CHAR_SUPPORT
59    suite->add(BOOST_TEST_CASE(test_conversion_from_wchar_t));
60    suite->add(BOOST_TEST_CASE(test_conversion_to_wchar_t));
61    suite->add(BOOST_TEST_CASE(test_conversion_from_wstring));
62    suite->add(BOOST_TEST_CASE(test_conversion_to_wstring));
63    #endif
64    suite->add(BOOST_TEST_CASE(test_bad_lexical_cast));
65    suite->add(BOOST_TEST_CASE(test_no_whitespace_stripping));
66    return suite;
67}
68
69void test_conversion_to_char()
70{
71    BOOST_CHECK_EQUAL('A', lexical_cast<char>('A'));
72    BOOST_CHECK_EQUAL(' ', lexical_cast<char>(' '));
73    BOOST_CHECK_EQUAL('1', lexical_cast<char>(1));
74    BOOST_CHECK_EQUAL('0', lexical_cast<char>(0));
75    BOOST_CHECK_THROW(lexical_cast<char>(123), bad_lexical_cast);
76    BOOST_CHECK_EQUAL('1', lexical_cast<char>(1.0));
77    BOOST_CHECK_EQUAL('1', lexical_cast<char>(true));
78    BOOST_CHECK_EQUAL('0', lexical_cast<char>(false));
79    BOOST_CHECK_EQUAL('A', lexical_cast<char>("A"));
80    BOOST_CHECK_EQUAL(' ', lexical_cast<char>(" "));
81    BOOST_CHECK_THROW(lexical_cast<char>(""), bad_lexical_cast);
82    BOOST_CHECK_THROW(lexical_cast<char>("Test"), bad_lexical_cast);
83    BOOST_CHECK_EQUAL('A', lexical_cast<char>(std::string("A")));
84    BOOST_CHECK_EQUAL(' ', lexical_cast<char>(std::string(" ")));
85    BOOST_CHECK_THROW(
86        lexical_cast<char>(std::string("")), bad_lexical_cast);
87    BOOST_CHECK_THROW(
88        lexical_cast<char>(std::string("Test")), bad_lexical_cast);
89}
90
91void test_conversion_to_int()
92{
93    BOOST_CHECK_EQUAL(1, lexical_cast<int>('1'));
94    BOOST_CHECK_EQUAL(0, lexical_cast<int>('0'));
95    BOOST_CHECK_THROW(lexical_cast<int>('A'), bad_lexical_cast);
96    BOOST_CHECK_EQUAL(1, lexical_cast<int>(1));
97    BOOST_CHECK_EQUAL(
98        (std::numeric_limits<int>::max)(),
99        lexical_cast<int>((std::numeric_limits<int>::max)()));
100    BOOST_CHECK_EQUAL(1, lexical_cast<int>(1.0));
101
102    BOOST_CHECK_THROW(lexical_cast<int>(1.23), bad_lexical_cast);
103
104    BOOST_CHECK_THROW(lexical_cast<int>(1e20), bad_lexical_cast);
105    BOOST_CHECK_EQUAL(1, lexical_cast<int>(true));
106    BOOST_CHECK_EQUAL(0, lexical_cast<int>(false));
107    BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
108    BOOST_CHECK_THROW(
109        lexical_cast<int>(" 123"), bad_lexical_cast);
110    BOOST_CHECK_THROW(lexical_cast<int>(""), bad_lexical_cast);
111    BOOST_CHECK_THROW(lexical_cast<int>("Test"), bad_lexical_cast);
112    BOOST_CHECK_EQUAL(123, lexical_cast<int>("123"));
113    BOOST_CHECK_EQUAL(123, lexical_cast<int>(std::string("123")));
114    BOOST_CHECK_THROW(
115        lexical_cast<int>(std::string(" 123")), bad_lexical_cast);
116    BOOST_CHECK_THROW(
117        lexical_cast<int>(std::string("")), bad_lexical_cast);
118    BOOST_CHECK_THROW(
119        lexical_cast<int>(std::string("Test")), bad_lexical_cast);
120}
121
122void test_conversion_to_double()
123{
124    BOOST_CHECK_CLOSE(1.0, lexical_cast<double>('1'), (std::numeric_limits<double>::epsilon()));
125    BOOST_CHECK_THROW(lexical_cast<double>('A'), bad_lexical_cast);
126    BOOST_CHECK_CLOSE(1.0, lexical_cast<double>(1), (std::numeric_limits<double>::epsilon()));
127    BOOST_CHECK_CLOSE(1.23, lexical_cast<double>(1.23), (std::numeric_limits<double>::epsilon()));
128    BOOST_CHECK_CLOSE(1.234567890, 1.234567890, std::numeric_limits<double>::epsilon());
129    BOOST_CHECK_CLOSE(1.0, lexical_cast<double>(true), (std::numeric_limits<double>::epsilon()));
130    BOOST_CHECK_CLOSE(0.0, lexical_cast<double>(false), (std::numeric_limits<double>::epsilon()));
131    BOOST_CHECK_CLOSE(1.23, lexical_cast<double>("1.23"), (std::numeric_limits<double>::epsilon()));
132    BOOST_CHECK_THROW(lexical_cast<double>(""), bad_lexical_cast);
133    BOOST_CHECK_THROW(lexical_cast<double>("Test"), bad_lexical_cast);
134    BOOST_CHECK_CLOSE(1.23, lexical_cast<double>(std::string("1.23")), (std::numeric_limits<double>::epsilon()));
135    BOOST_CHECK_THROW(
136        lexical_cast<double>(std::string("")), bad_lexical_cast);
137    BOOST_CHECK_THROW(
138        lexical_cast<double>(std::string("Test")), bad_lexical_cast);
139}
140
141void test_conversion_to_bool()
142{
143    BOOST_CHECK_EQUAL(true, lexical_cast<bool>('1'));
144    BOOST_CHECK_EQUAL(false, lexical_cast<bool>('0'));
145    BOOST_CHECK_THROW(lexical_cast<bool>('A'), bad_lexical_cast);
146    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1));
147    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0));
148    BOOST_CHECK_THROW(lexical_cast<bool>(123), bad_lexical_cast);
149    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(1.0));
150    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(0.0));
151    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(true));
152    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(false));
153    BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
154    BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
155    BOOST_CHECK_THROW(lexical_cast<bool>(""), bad_lexical_cast);
156    BOOST_CHECK_THROW(lexical_cast<bool>("Test"), bad_lexical_cast);
157    BOOST_CHECK_EQUAL(true, lexical_cast<bool>("1"));
158    BOOST_CHECK_EQUAL(false, lexical_cast<bool>("0"));
159    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::string("1")));
160    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::string("0")));
161    BOOST_CHECK_THROW(
162        lexical_cast<bool>(std::string("")), bad_lexical_cast);
163    BOOST_CHECK_THROW(
164        lexical_cast<bool>(std::string("Test")), bad_lexical_cast);
165}
166
167void test_conversion_to_string()
168{
169    BOOST_CHECK_EQUAL("A", lexical_cast<std::string>('A'));
170    BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(' '));
171    BOOST_CHECK_EQUAL("123", lexical_cast<std::string>(123));
172    BOOST_CHECK_EQUAL("1.23", lexical_cast<std::string>(1.23));
173    BOOST_CHECK_EQUAL("1.111111111", lexical_cast<std::string>(1.111111111));
174    BOOST_CHECK_EQUAL("1", lexical_cast<std::string>(true));
175    BOOST_CHECK_EQUAL("0", lexical_cast<std::string>(false));
176    BOOST_CHECK_EQUAL("Test", lexical_cast<std::string>("Test"));
177    BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(" "));
178    BOOST_CHECK_EQUAL("", lexical_cast<std::string>(""));
179    BOOST_CHECK_EQUAL("Test", lexical_cast<std::string>(std::string("Test")));
180    BOOST_CHECK_EQUAL(" ", lexical_cast<std::string>(std::string(" ")));
181    BOOST_CHECK_EQUAL("", lexical_cast<std::string>(std::string("")));
182}
183
184void test_conversion_from_to_wchar_t_alias()
185{
186    BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned short>("123"));
187    BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned int>("123"));
188    BOOST_CHECK_EQUAL(123u, lexical_cast<unsigned long>("123"));
189    BOOST_CHECK_EQUAL(std::string("123"),
190        lexical_cast<std::string>(static_cast<unsigned short>(123)));
191    BOOST_CHECK_EQUAL(std::string("123"), lexical_cast<std::string>(123u));
192    BOOST_CHECK_EQUAL(std::string("123"), lexical_cast<std::string>(123ul));
193}
194
195void test_conversion_to_pointer()
196{
197    BOOST_CHECK_THROW(lexical_cast<char *>("Test"), bad_lexical_cast);
198    #ifndef DISABLE_WIDE_CHAR_SUPPORT
199    BOOST_CHECK_THROW(lexical_cast<wchar_t *>("Test"), bad_lexical_cast);
200    #endif
201}
202
203void test_conversion_from_wchar_t()
204{
205#ifndef DISABLE_WIDE_CHAR_SUPPORT
206#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
207    BOOST_CHECK_EQUAL(1, lexical_cast<int>(L'1'));
208    BOOST_CHECK_THROW(lexical_cast<int>(L'A'), bad_lexical_cast);
209#endif
210
211    BOOST_CHECK_EQUAL(123, lexical_cast<int>(L"123"));
212    BOOST_CHECK_THROW(lexical_cast<int>(L""), bad_lexical_cast);
213    BOOST_CHECK_THROW(lexical_cast<int>(L"Test"), bad_lexical_cast);
214
215#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
216    BOOST_CHECK_EQUAL(1.0, lexical_cast<double>(L'1'));
217    BOOST_CHECK_THROW(lexical_cast<double>(L'A'), bad_lexical_cast);
218#endif
219
220    BOOST_CHECK_EQUAL(1.23, lexical_cast<double>(L"1.23"));
221    BOOST_CHECK_THROW(lexical_cast<double>(L""), bad_lexical_cast);
222    BOOST_CHECK_THROW(lexical_cast<double>(L"Test"), bad_lexical_cast);
223
224#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
225    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(L'1'));
226    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(L'0'));
227    BOOST_CHECK_THROW(lexical_cast<bool>(L'A'), bad_lexical_cast);
228#endif
229    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(L"1"));
230    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(L"0"));
231    BOOST_CHECK_THROW(lexical_cast<bool>(L""), bad_lexical_cast);
232    BOOST_CHECK_THROW(lexical_cast<bool>(L"Test"), bad_lexical_cast);
233#endif
234}
235
236void test_conversion_to_wchar_t()
237{
238#if !defined(DISABLE_WIDE_CHAR_SUPPORT) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
239    BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(1));
240    BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(0));
241    BOOST_CHECK_THROW(lexical_cast<wchar_t>(123), bad_lexical_cast);
242    BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(1.0));
243    BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(0.0));
244    BOOST_CHECK_EQUAL(L'1', lexical_cast<wchar_t>(true));
245    BOOST_CHECK_EQUAL(L'0', lexical_cast<wchar_t>(false));
246    BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(L'A'));
247    BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(L' '));
248    BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(L"A"));
249    BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(L" "));
250    BOOST_CHECK_THROW(lexical_cast<wchar_t>(L""), bad_lexical_cast);
251    BOOST_CHECK_THROW(lexical_cast<wchar_t>(L"Test"), bad_lexical_cast);
252    BOOST_CHECK_EQUAL(L'A', lexical_cast<wchar_t>(std::wstring(L"A")));
253    BOOST_CHECK_EQUAL(L' ', lexical_cast<wchar_t>(std::wstring(L" ")));
254    BOOST_CHECK_THROW(
255        lexical_cast<wchar_t>(std::wstring(L"")), bad_lexical_cast);
256    BOOST_CHECK_THROW(
257        lexical_cast<wchar_t>(std::wstring(L"Test")), bad_lexical_cast);
258    #endif
259}
260
261void test_conversion_from_wstring()
262{
263    #ifndef DISABLE_WIDE_CHAR_SUPPORT
264    BOOST_CHECK_EQUAL(123, lexical_cast<int>(std::wstring(L"123")));
265    BOOST_CHECK_THROW(
266        lexical_cast<int>(std::wstring(L"")), bad_lexical_cast);
267    BOOST_CHECK_THROW(
268        lexical_cast<int>(std::wstring(L"Test")), bad_lexical_cast);
269
270    BOOST_CHECK_EQUAL(true, lexical_cast<bool>(std::wstring(L"1")));
271    BOOST_CHECK_EQUAL(false, lexical_cast<bool>(std::wstring(L"0")));
272    BOOST_CHECK_THROW(
273        lexical_cast<bool>(std::wstring(L"")), bad_lexical_cast);
274    BOOST_CHECK_THROW(
275        lexical_cast<bool>(std::wstring(L"Test")), bad_lexical_cast);
276    #endif
277}
278
279void test_conversion_to_wstring()
280{
281    #ifndef DISABLE_WIDE_CHAR_SUPPORT
282    BOOST_CHECK(L"123" == lexical_cast<std::wstring>(123));
283    BOOST_CHECK(L"1.23" == lexical_cast<std::wstring>(1.23));
284    BOOST_CHECK(L"1.111111111" == lexical_cast<std::wstring>(1.111111111));
285    BOOST_CHECK(L"1" == lexical_cast<std::wstring>(true));
286    BOOST_CHECK(L"0" == lexical_cast<std::wstring>(false));
287#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
288    BOOST_CHECK(L"A" == lexical_cast<std::wstring>(L'A'));
289    BOOST_CHECK(L" " == lexical_cast<std::wstring>(L' '));
290#endif
291    BOOST_CHECK(L"Test" == lexical_cast<std::wstring>(L"Test"));
292    BOOST_CHECK(L" " == lexical_cast<std::wstring>(L" "));
293    BOOST_CHECK(L"" == lexical_cast<std::wstring>(L""));
294    BOOST_CHECK(L"Test" == lexical_cast<std::wstring>(std::wstring(L"Test")));
295    BOOST_CHECK(L" " == lexical_cast<std::wstring>(std::wstring(L" ")));
296    BOOST_CHECK(L"" == lexical_cast<std::wstring>(std::wstring(L"")));
297    #endif
298}
299
300void test_bad_lexical_cast()
301{
302    try
303    {
304        lexical_cast<int>(std::string("Test"));
305
306        BOOST_CHECK(false); // Exception expected
307    }
308    catch(const bad_lexical_cast &e)
309    {
310        BOOST_CHECK(e.source_type() == typeid(std::string));
311        BOOST_CHECK(e.target_type() == typeid(int));
312    }
313}
314
315void test_no_whitespace_stripping()
316{
317    BOOST_CHECK_THROW(lexical_cast<int>(" 123"), bad_lexical_cast);
318    BOOST_CHECK_THROW(lexical_cast<int>("123 "), bad_lexical_cast);
319}
Note: See TracBrowser for help on using the repository browser.