]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Boost.Convert test and usage example |
2 | // Copyright (c) 2009-2016 Vladimir Batov. | |
3 | // Use, modification and distribution are subject to the Boost Software License, | |
4 | // Version 1.0. See http://www.boost.org/LICENSE_1_0.txt. | |
5 | ||
6 | #include "./test.hpp" | |
7 | ||
b32b8144 | 8 | #if defined(BOOST_CONVERT_IS_NOT_SUPPORTED) |
7c673cae FG |
9 | int main(int, char const* []) { return 0; } |
10 | #else | |
11 | ||
12 | #include <boost/convert.hpp> | |
13 | #include <boost/convert/printf.hpp> | |
14 | #include <boost/convert/stream.hpp> | |
15 | #include <boost/detail/lightweight_test.hpp> | |
16 | #include <boost/random/mersenne_twister.hpp> | |
17 | #include <boost/random/uniform_int_distribution.hpp> | |
18 | #include <boost/random/uniform_01.hpp> | |
19 | #include <boost/lexical_cast.hpp> | |
b32b8144 | 20 | #include <boost/utility/string_view.hpp> |
7c673cae FG |
21 | |
22 | //[strtol_basic_deployment_header | |
23 | #include <boost/convert.hpp> | |
24 | #include <boost/convert/strtol.hpp> | |
25 | ||
26 | using std::string; | |
27 | using std::wstring; | |
28 | using boost::convert; | |
29 | ||
b32b8144 | 30 | struct boost::cnv::by_default : boost::cnv::strtol {}; |
7c673cae FG |
31 | //] |
32 | ||
33 | static | |
34 | void | |
35 | test_str_to_uint() | |
36 | { | |
37 | string const bad_str = "not an int"; | |
38 | string const neg_str = "-11"; | |
39 | string const std_str = "11"; | |
40 | char const* const c_str = "12"; | |
b32b8144 | 41 | boost::string_view v_str = boost::string_view(c_str, 1); |
7c673cae FG |
42 | unsigned int const imax = (std::numeric_limits<unsigned int>::max)(); |
43 | unsigned long int const lmax = (std::numeric_limits<unsigned long int>::max)(); | |
44 | std::string const imax_str = boost::lexical_cast<std::string>(imax); | |
45 | std::string const lmax_str = boost::lexical_cast<std::string>(lmax); | |
46 | ||
47 | BOOST_TEST( 0 == convert<unsigned int>(bad_str).value_or(0)); | |
48 | BOOST_TEST( 0 == convert<unsigned int>(neg_str).value_or(0)); | |
49 | BOOST_TEST( 0 == convert<unsigned long int>(neg_str).value_or(0)); | |
50 | BOOST_TEST( 0 == convert<unsigned long int>(neg_str).value_or(0)); | |
51 | BOOST_TEST(11 == convert<unsigned int>(std_str).value()); | |
52 | BOOST_TEST(12 == convert<unsigned int>( c_str).value()); | |
b32b8144 | 53 | BOOST_TEST( 1 == convert<unsigned int>( v_str).value_or(0)); |
7c673cae FG |
54 | BOOST_TEST(11 == convert<unsigned long int>(std_str).value()); |
55 | BOOST_TEST(12 == convert<unsigned long int>( c_str).value()); | |
56 | BOOST_TEST(imax == convert< unsigned int>(imax_str).value()); | |
57 | BOOST_TEST(lmax == convert<unsigned long int>(lmax_str).value()); | |
58 | } | |
59 | ||
60 | static | |
61 | void | |
62 | test_str_to_int() | |
63 | { | |
64 | //[strtol_basic_deployment | |
b32b8144 FG |
65 | string const bad_str = "not an int"; |
66 | string const std_str = "-11"; | |
67 | char const* const c_str = "-12"; | |
68 | boost::string_view v_str = boost::string_view(c_str, 2); | |
7c673cae FG |
69 | |
70 | BOOST_TEST( -1 == convert<int>(bad_str).value_or(-1)); | |
71 | BOOST_TEST(-11 == convert<int>(std_str).value()); | |
72 | BOOST_TEST(-12 == convert<int>( c_str).value()); | |
b32b8144 | 73 | BOOST_TEST( -1 == convert<int>( v_str).value_or(0)); |
7c673cae FG |
74 | //] |
75 | wstring const bad_wstr = L"not an int"; | |
76 | wstring const wstd_str = L"-11"; | |
77 | wchar_t const* const wc_str = L"-12"; | |
78 | ||
79 | BOOST_TEST( -1 == convert<int>(bad_wstr).value_or(-1)); | |
80 | BOOST_TEST(-11 == convert<int>(wstd_str).value()); | |
81 | BOOST_TEST(-12 == convert<int>( wc_str).value()); | |
82 | } | |
83 | ||
84 | static | |
85 | void | |
86 | test_int_to_str() | |
87 | { | |
88 | short const s_int = -123; | |
89 | int const i_int = -123; | |
90 | long const l_int = -123; | |
91 | long long const ll_int = -123; | |
92 | ||
93 | BOOST_TEST( "-123" == convert< std::string> ( s_int).value()); | |
94 | BOOST_TEST( "-123" == convert< std::string> ( i_int).value()); | |
95 | BOOST_TEST( "-123" == convert< std::string> ( l_int).value()); | |
96 | BOOST_TEST( "-123" == convert< std::string> (ll_int).value()); | |
97 | ||
98 | BOOST_TEST(L"-123" == convert<std::wstring> ( s_int).value()); | |
99 | BOOST_TEST(L"-123" == convert<std::wstring> ( i_int).value()); | |
100 | BOOST_TEST(L"-123" == convert<std::wstring> ( l_int).value()); | |
101 | BOOST_TEST(L"-123" == convert<std::wstring> (ll_int).value()); | |
102 | ||
103 | int const imin = std::numeric_limits<int>::min(); | |
104 | int const imax = std::numeric_limits<int>::max(); | |
105 | long int const lmin = std::numeric_limits<long int>::min(); | |
106 | long int const lmax = std::numeric_limits<long int>::max(); | |
107 | long long int const llmin = std::numeric_limits<long long int>::min(); | |
108 | long long int const llmax = std::numeric_limits<long long int>::max(); | |
109 | ||
110 | std::string const imin_str = boost::lexical_cast<std::string>(imin); | |
111 | std::string const imax_str = boost::lexical_cast<std::string>(imax); | |
112 | std::string const lmin_str = boost::lexical_cast<std::string>(lmin); | |
113 | std::string const lmax_str = boost::lexical_cast<std::string>(lmax); | |
114 | std::string const llmin_str = boost::lexical_cast<std::string>(llmin); | |
115 | std::string const llmax_str = boost::lexical_cast<std::string>(llmax); | |
116 | ||
117 | BOOST_TEST( imin_str == convert<std::string>( imin).value()); | |
118 | BOOST_TEST( imax_str == convert<std::string>( imax).value()); | |
119 | BOOST_TEST( lmin_str == convert<std::string>( lmin).value()); | |
120 | BOOST_TEST( lmax_str == convert<std::string>( lmax).value()); | |
121 | BOOST_TEST(llmin_str == convert<std::string>(llmin).value()); | |
122 | BOOST_TEST(llmax_str == convert<std::string>(llmax).value()); | |
123 | } | |
124 | ||
125 | static | |
126 | void | |
127 | test_uint_to_str() | |
128 | { | |
129 | unsigned short const us_int = 123; | |
130 | unsigned int const ui_int = 123; | |
131 | unsigned long const ul_int = 123; | |
132 | unsigned long long const ull_int = 123; | |
133 | ||
134 | BOOST_TEST( "123" == convert< std::string> ( us_int).value()); | |
135 | BOOST_TEST( "123" == convert< std::string> ( ui_int).value()); | |
136 | BOOST_TEST( "123" == convert< std::string> ( ul_int).value()); | |
137 | BOOST_TEST( "123" == convert< std::string> (ull_int).value()); | |
138 | ||
139 | BOOST_TEST(L"123" == convert<std::wstring> ( us_int).value()); | |
140 | BOOST_TEST(L"123" == convert<std::wstring> ( ui_int).value()); | |
141 | BOOST_TEST(L"123" == convert<std::wstring> ( ul_int).value()); | |
142 | BOOST_TEST(L"123" == convert<std::wstring> (ull_int).value()); | |
143 | ||
144 | unsigned int const uimax = (std::numeric_limits<unsigned int>::max)(); | |
145 | unsigned long int const ulmax = (std::numeric_limits<unsigned long int>::max)(); | |
146 | unsigned long long int const ullmax = (std::numeric_limits<unsigned long long int>::max)(); | |
147 | ||
148 | std::string const uimax_str = boost::lexical_cast<std::string>( uimax); | |
149 | std::string const ulmax_str = boost::lexical_cast<std::string>( ulmax); | |
150 | std::string const ullmax_str = boost::lexical_cast<std::string>(ullmax); | |
151 | ||
152 | BOOST_TEST( uimax_str == convert<std::string>( uimax).value()); | |
153 | BOOST_TEST( ulmax_str == convert<std::string>( ulmax).value()); | |
154 | BOOST_TEST(ullmax_str == convert<std::string>(ullmax).value()); | |
155 | } | |
156 | ||
157 | //[strtol_numeric_base_header | |
158 | #include <boost/convert.hpp> | |
159 | #include <boost/convert/strtol.hpp> | |
160 | ||
161 | using std::string; | |
162 | using std::wstring; | |
163 | using boost::convert; | |
164 | ||
165 | namespace cnv = boost::cnv; | |
166 | namespace arg = boost::cnv::parameter; | |
167 | //] | |
168 | static | |
169 | void | |
170 | test_width() | |
171 | { | |
172 | //[strtol_width | |
173 | boost::cnv::strtol cnv; | |
174 | ||
175 | string s01 = convert<string>( 12, cnv(arg::width = 4)).value(); | |
176 | string s02 = convert<string>( 12, cnv(arg::width = 5) | |
177 | (arg::fill = '*')).value(); | |
178 | string s03 = convert<string>( 12, cnv(arg::width = 5) | |
179 | (arg::fill = 'x') | |
180 | (arg::adjust = cnv::adjust::left)).value(); | |
181 | string s04 = convert<string>(-98, cnv(arg::width = 6) | |
182 | (arg::fill = 'Z') | |
183 | (arg::adjust = cnv::adjust::right)).value(); | |
184 | ||
185 | string s05 = convert<string>(-12.3451, cnv(arg::precision = 2) | |
186 | (arg::width = 10) | |
187 | (arg::fill = '*') | |
188 | (arg::adjust = cnv::adjust::left)).value(); | |
189 | string s06 = convert<string>(-12.3450, cnv(arg::adjust = cnv::adjust::right)).value(); | |
190 | string s07 = convert<string>(-12.3450, cnv(arg::adjust = cnv::adjust::center)).value(); | |
191 | ||
192 | BOOST_TEST(s01 == " 12"); | |
193 | BOOST_TEST(s02 == "***12"); | |
194 | BOOST_TEST(s03 == "12xxx"); | |
195 | BOOST_TEST(s04 == "ZZZ-98"); | |
196 | BOOST_TEST(s05 == "-12.35****"); | |
197 | BOOST_TEST(s06 == "****-12.35"); | |
198 | BOOST_TEST(s07 == "**-12.35**"); | |
199 | //] | |
200 | } | |
201 | ||
202 | static | |
203 | void | |
204 | test_base() | |
205 | { | |
206 | //[strtol_numeric_base | |
207 | boost::cnv::strtol cnv; | |
208 | ||
209 | BOOST_TEST( "11111110" == convert< string>(254, cnv(arg::base = cnv::base::bin)).value()); | |
210 | BOOST_TEST( "254" == convert< string>(254, cnv(arg::base = cnv::base::dec)).value()); | |
211 | BOOST_TEST( "FE" == convert< string>(254, cnv(arg::base = cnv::base::hex)).value()); | |
212 | BOOST_TEST( "376" == convert< string>(254, cnv(arg::base = cnv::base::oct)).value()); | |
213 | //] | |
214 | //[wide_strtol_numeric_base | |
215 | BOOST_TEST(L"11111110" == convert<wstring>(254, cnv(arg::base = cnv::base::bin)).value()); | |
216 | BOOST_TEST( L"254" == convert<wstring>(254, cnv(arg::base = cnv::base::dec)).value()); | |
217 | BOOST_TEST( L"FE" == convert<wstring>(254, cnv(arg::base = cnv::base::hex)).value()); | |
218 | BOOST_TEST( L"376" == convert<wstring>(254, cnv(arg::base = cnv::base::oct)).value()); | |
219 | //] | |
220 | } | |
221 | ||
b32b8144 FG |
222 | static |
223 | void | |
224 | test_upper() | |
225 | { | |
226 | // boost::cnv::strtol cnv; | |
227 | // char const* c_lcase = "abcde"; | |
228 | // char const* c_ucase = "ABCDE"; | |
229 | // wchar_t const* w_lcase = L"abcde"; | |
230 | // wchar_t const* w_ucase = L"ABCDE"; | |
231 | // | |
232 | // BOOST_TEST(c_lcase == convert< string>(c_lcase, cnv(arg::uppercase = false)).value_or("")); | |
233 | // BOOST_TEST(c_ucase == convert< string>(c_lcase, cnv(arg::uppercase = true)).value_or("")); | |
234 | // BOOST_TEST(w_ucase == convert<wstring>(w_lcase, cnv(arg::uppercase = false)).value_or("")); | |
235 | // BOOST_TEST(w_ucase == convert<wstring>(w_lcase, cnv(arg::uppercase = true)).value_or("")); | |
236 | } | |
237 | ||
7c673cae FG |
238 | static |
239 | void | |
240 | test_skipws() | |
241 | { | |
242 | //[strtol_skipws | |
243 | boost::cnv::strtol cnv; | |
244 | ||
245 | BOOST_TEST(-1 == convert<int>( " 12", cnv(arg::skipws = false)).value_or(-1)); | |
246 | BOOST_TEST(12 == convert<int>( " 12", cnv(arg::skipws = true)).value_or(-1)); | |
247 | //] | |
248 | //[wide_strtol_skipws | |
249 | BOOST_TEST(-1 == convert<int>(L" 12", cnv(arg::skipws = false)).value_or(-1)); | |
250 | BOOST_TEST(12 == convert<int>(L" 12", cnv(arg::skipws = true)).value_or(-1)); | |
251 | //] | |
252 | } | |
253 | ||
254 | static | |
255 | void | |
256 | dbl_to_str_example() | |
257 | { | |
258 | //[strtol_precision | |
259 | boost::cnv::strtol cnv; | |
260 | ||
261 | BOOST_TEST( "12.3" == convert<string>(12.3456, cnv(arg::precision = 1)).value()); | |
262 | BOOST_TEST( "12.35" == convert<string>(12.3456, cnv(arg::precision = 2)).value()); | |
263 | BOOST_TEST("12.346" == convert<string>(12.3456, cnv(arg::precision = 3)).value()); | |
264 | ||
265 | BOOST_TEST( "-12.3" == convert<string>(-12.3456, cnv(arg::precision = 1)).value()); | |
266 | BOOST_TEST( "-12.35" == convert<string>(-12.3456, cnv(arg::precision = 2)).value()); | |
267 | BOOST_TEST("-12.346" == convert<string>(-12.3456, cnv(arg::precision = 3)).value()); | |
268 | //] | |
269 | } | |
270 | ||
271 | static | |
272 | std::pair<double, int> | |
273 | get_random() | |
274 | { | |
b32b8144 FG |
275 | namespace rdm = boost::random; |
276 | ||
277 | static rdm::mt19937 gen (::time(0)); | |
278 | static rdm::uniform_int_distribution<> precision (0, 6); | |
279 | static rdm::uniform_int_distribution<> int_part (0, SHRT_MAX); | |
280 | static rdm::uniform_01<double> fraction; // uniform double in [0,1) | |
281 | static bool sign; | |
7c673cae FG |
282 | |
283 | double dbl = (int_part(gen) + fraction(gen)) * ((sign = !sign) ? 1 : -1); | |
284 | ||
285 | // printf("%.12f\n", dbl); | |
286 | ||
287 | return std::make_pair(dbl, precision(gen)); | |
288 | } | |
289 | ||
290 | static | |
291 | void | |
292 | compare(std::pair<double, int> pair) | |
293 | { | |
294 | boost::cnv::strtol cnv1; | |
295 | boost::cnv::printf cnv2; | |
296 | ||
297 | string s1 = convert<string>(pair.first, cnv1(arg::precision = pair.second)).value(); | |
298 | string s2 = convert<string>(pair.first, cnv2(arg::precision = pair.second)).value(); | |
299 | ||
300 | if (s1 != s2) | |
301 | printf("dbl=%.12f(%d).strtol/printf=%s/%s.\n", pair.first, pair.second, s1.c_str(), s2.c_str()); | |
302 | } | |
303 | ||
b32b8144 FG |
304 | static |
305 | void | |
306 | test_str_to_dbl() | |
307 | { | |
308 | char const* const c_str = "1.23456"; | |
309 | ||
310 | BOOST_TEST(1.2 == convert<double>(boost::string_view(c_str, 3)).value_or(0)); | |
311 | BOOST_TEST(1.23 == convert<double>(boost::string_view(c_str, 4)).value_or(0)); | |
312 | } | |
313 | ||
7c673cae FG |
314 | static |
315 | void | |
316 | test_dbl_to_str() | |
317 | { | |
318 | // double round_up_abs01 = ::rint(-0.5); | |
319 | // double round_up_abs02 = ::round(-0.5); | |
320 | // double round_up_abs11 = ::rint(0.5); | |
321 | // double round_up_abs12 = ::round(0.5); | |
322 | ||
323 | // double huge_v = 987654321098765432109.123; | |
324 | // | |
325 | // printf("%f\n", huge_v); | |
326 | // string huge = convert<string>(huge_v, cnv1(arg::precision = 2)).value(); | |
327 | // printf("%s\n", huge.c_str()); | |
328 | ||
329 | int const num_tries = 1000000; | |
330 | double const dbls[] = { 0.90, 1.0, 1.1, 0.94, 0.96, 1.04, 1.05, 1.06, 9.654, 999.888 }; | |
331 | int const num_dbls = sizeof(dbls) / sizeof(dbls[0]); | |
332 | ||
333 | printf("cnv::strtol::%s: started with %d random numbers...\n", __FUNCTION__, num_tries); | |
334 | ||
335 | BOOST_TEST( "0" == convert<string>( 0.0, cnv::strtol()(arg::precision = 0)).value()); | |
336 | BOOST_TEST( "0.0" == convert<string>( 0.0, cnv::strtol()(arg::precision = 1)).value()); | |
337 | BOOST_TEST("0.00" == convert<string>( 0.0, cnv::strtol()(arg::precision = 2)).value()); | |
338 | BOOST_TEST( "1" == convert<string>(0.95, cnv::strtol()(arg::precision = 0)).value()); | |
339 | BOOST_TEST( "1.0" == convert<string>(0.95, cnv::strtol()(arg::precision = 1)).value()); | |
340 | BOOST_TEST("0.95" == convert<string>(0.95, cnv::strtol()(arg::precision = 2)).value()); | |
341 | ||
342 | for (int k = 0; k < num_tries; ++k) | |
343 | compare(get_random()); | |
344 | ||
345 | for (int k = 0; k < num_dbls; ++k) | |
346 | for (int precision = 0; precision < 3; ++precision) | |
347 | { | |
348 | compare(std::make_pair( dbls[k], precision)); | |
349 | compare(std::make_pair(-dbls[k], precision)); | |
350 | } | |
351 | ||
352 | printf("cnv::strtol::%s: finished.\n", __FUNCTION__); | |
353 | } | |
354 | ||
355 | static | |
356 | void | |
357 | test_user_string() | |
358 | { | |
359 | //[strtol_user_string | |
360 | boost::cnv::strtol cnv; | |
361 | ||
362 | BOOST_TEST( "12" == convert<my_string>(12, cnv).value()); | |
363 | BOOST_TEST("0.95" == convert<my_string>(0.95, cnv(arg::precision = 2)).value()); | |
364 | //] | |
365 | } | |
366 | ||
367 | static | |
368 | void | |
369 | test_user_type() | |
370 | { | |
371 | //[strtol_user_type | |
372 | boost::cnv::strtol cnv; | |
373 | change up_chg = change::up; | |
374 | change dn_chg = change::dn; | |
375 | ||
376 | BOOST_TEST(convert<std::string>(up_chg, cnv, "bad") == "up"); | |
377 | BOOST_TEST(convert<std::string>(dn_chg, cnv, "bad") == "dn"); | |
378 | BOOST_TEST(convert<std::string>( 12, cnv, "bad") == "12"); | |
379 | ||
380 | BOOST_TEST(convert<change>("up", cnv, change::no) == change::up); | |
381 | BOOST_TEST(convert<change>("dn", cnv, change::no) == change::dn); | |
382 | BOOST_TEST(convert< int>("12", cnv, -1) == 12); | |
383 | //] | |
384 | } | |
385 | ||
386 | int | |
387 | main(int, char const* []) | |
388 | { | |
389 | dbl_to_str_example(); | |
390 | ||
391 | test_str_to_int(); | |
392 | test_str_to_uint(); | |
393 | test_int_to_str(); | |
394 | test_uint_to_str(); | |
395 | test_base(); | |
b32b8144 | 396 | test_upper(); |
7c673cae | 397 | test_skipws(); |
b32b8144 | 398 | test_str_to_dbl(); |
7c673cae FG |
399 | test_dbl_to_str(); |
400 | test_width(); | |
401 | test_user_string(); | |
402 | test_user_type(); | |
403 | ||
404 | return boost::report_errors(); | |
405 | } | |
406 | ||
407 | #endif |