Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: downloads/boost_1_34_1/libs/conversion/lexical_cast_test.cpp @ 33

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

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