1 /*=============================================================================
2 Copyright (c) 2011 Jan Frederick Eick
3
4 Distributed under the Boost Software License, Version 1.0. (See accompanying
5 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6 =============================================================================*/
7
8 #include <boost/config/warning_disable.hpp>
9 #include <boost/detail/lightweight_test.hpp>
10 #include <boost/spirit/home/x3.hpp>
11 //~ #include <boost/phoenix/core.hpp>
12 //~ #include <boost/phoenix/operator.hpp>
13
14 #include <climits>
15 #include <cstring>
16 #include "test.hpp"
17
18 #include "uint_radix.hpp"
19
20 int
main()21 main()
22 {
23 using spirit_test::test;
24 using spirit_test::test_attr;
25
26 using boost::spirit::x3::uint_;
27 using boost::spirit::x3::uint_parser;
28
29 ///////////////////////////////////////////////////////////////////////////
30 // arbitrary radix test (base 3)
31 ///////////////////////////////////////////////////////////////////////////
32 {
33 unsigned int u;
34 uint_parser<unsigned int, 3, 1, -1> base3_parser;
35
36 BOOST_TEST(test("210112221200", base3_parser));
37 BOOST_TEST(test_attr("210112221200", base3_parser, u));
38 BOOST_TEST(424242 == u);
39
40 BOOST_TEST(!test("1231", base3_parser));
41 BOOST_TEST(!test_attr("1231", base3_parser, u));
42
43 BOOST_TEST(test(max_unsigned_base3, base3_parser));
44 BOOST_TEST(test_attr(max_unsigned_base3, base3_parser, u));
45
46 BOOST_TEST(!test(unsigned_overflow_base3, base3_parser));
47 BOOST_TEST(!test_attr(unsigned_overflow_base3, base3_parser, u));
48 BOOST_TEST(!test(digit_overflow_base3, base3_parser));
49 BOOST_TEST(!test_attr(digit_overflow_base3, base3_parser, u));
50 }
51
52 ///////////////////////////////////////////////////////////////////////////
53 // arbitrary radix test (base 4)
54 ///////////////////////////////////////////////////////////////////////////
55 {
56 unsigned int u;
57
58 uint_parser<unsigned int, 4, 1, -1> base4_parser;
59
60 BOOST_TEST(test("1213210302", base4_parser));
61 BOOST_TEST(test_attr("1213210302", base4_parser, u));
62 BOOST_TEST(424242 == u);
63
64 BOOST_TEST(!test("1234", base4_parser));
65 BOOST_TEST(!test_attr("1234", base4_parser, u));
66
67 BOOST_TEST(test(max_unsigned_base4, base4_parser));
68 BOOST_TEST(test_attr(max_unsigned_base4, base4_parser, u));
69 BOOST_TEST(!test(digit_overflow_base4, base4_parser));
70 BOOST_TEST(!test_attr(digit_overflow_base4, base4_parser, u));
71 }
72
73 ///////////////////////////////////////////////////////////////////////////
74 // arbitrary radix test (base 5)
75 ///////////////////////////////////////////////////////////////////////////
76 {
77 unsigned int u;
78
79 uint_parser<unsigned int, 5, 1, -1> base5_parser;
80
81 BOOST_TEST(test("102033432", base5_parser));
82 BOOST_TEST(test_attr("102033432", base5_parser, u));
83 BOOST_TEST(424242 == u);
84
85 BOOST_TEST(!test("2345", base5_parser));
86 BOOST_TEST(!test_attr("2345", base5_parser, u));
87
88 BOOST_TEST(test(max_unsigned_base5, base5_parser));
89 BOOST_TEST(test_attr(max_unsigned_base5, base5_parser, u));
90
91 BOOST_TEST(!test(unsigned_overflow_base5, base5_parser));
92 BOOST_TEST(!test_attr(unsigned_overflow_base5, base5_parser, u));
93 BOOST_TEST(!test(digit_overflow_base5, base5_parser));
94 BOOST_TEST(!test_attr(digit_overflow_base5, base5_parser, u));
95 }
96
97 ///////////////////////////////////////////////////////////////////////////
98 // arbitrary radix test (base 6)
99 ///////////////////////////////////////////////////////////////////////////
100 {
101 unsigned int u;
102
103 uint_parser<unsigned int, 6, 1, -1> base6_parser;
104
105 BOOST_TEST(test("13032030", base6_parser));
106 BOOST_TEST(test_attr("13032030", base6_parser, u));
107 BOOST_TEST(424242 == u);
108
109 BOOST_TEST(!test("3456", base6_parser));
110 BOOST_TEST(!test_attr("3456", base6_parser, u));
111
112 BOOST_TEST(test(max_unsigned_base6, base6_parser));
113 BOOST_TEST(test_attr(max_unsigned_base6, base6_parser, u));
114
115 BOOST_TEST(!test(unsigned_overflow_base6, base6_parser));
116 BOOST_TEST(!test_attr(unsigned_overflow_base6, base6_parser, u));
117 BOOST_TEST(!test(digit_overflow_base6, base6_parser));
118 BOOST_TEST(!test_attr(digit_overflow_base6, base6_parser, u));
119 }
120
121 ///////////////////////////////////////////////////////////////////////////
122 // arbitrary radix test (base 7)
123 ///////////////////////////////////////////////////////////////////////////
124 {
125 unsigned int u;
126
127 uint_parser<unsigned int, 7, 1, -1> base7_parser;
128
129 BOOST_TEST(test("3414600", base7_parser));
130 BOOST_TEST(test_attr("3414600", base7_parser, u));
131 BOOST_TEST(424242 == u);
132
133 BOOST_TEST(!test("4567", base7_parser));
134 BOOST_TEST(!test_attr("4567", base7_parser, u));
135
136 BOOST_TEST(test(max_unsigned_base7, base7_parser));
137 BOOST_TEST(test_attr(max_unsigned_base7, base7_parser, u));
138
139 BOOST_TEST(!test(unsigned_overflow_base7, base7_parser));
140 BOOST_TEST(!test_attr(unsigned_overflow_base7, base7_parser, u));
141 BOOST_TEST(!test(digit_overflow_base7, base7_parser));
142 BOOST_TEST(!test_attr(digit_overflow_base7, base7_parser, u));
143 }
144
145 ///////////////////////////////////////////////////////////////////////////
146 // arbitrary radix test (base 9)
147 ///////////////////////////////////////////////////////////////////////////
148 {
149 unsigned int u;
150
151 uint_parser<unsigned int, 9, 1, -1> base9_parser;
152
153 BOOST_TEST(test("715850", base9_parser));
154 BOOST_TEST(test_attr("715850", base9_parser, u));
155 BOOST_TEST(424242 == u);
156
157 BOOST_TEST(!test("6789", base9_parser));
158 BOOST_TEST(!test_attr("6789", base9_parser, u));
159
160 BOOST_TEST(test(max_unsigned_base9, base9_parser));
161 BOOST_TEST(test_attr(max_unsigned_base9, base9_parser, u));
162
163 BOOST_TEST(!test(unsigned_overflow_base9, base9_parser));
164 BOOST_TEST(!test_attr(unsigned_overflow_base9, base9_parser, u));
165 BOOST_TEST(!test(digit_overflow_base9, base9_parser));
166 BOOST_TEST(!test_attr(digit_overflow_base9, base9_parser, u));
167 }
168
169 ///////////////////////////////////////////////////////////////////////////
170 // arbitrary radix test (base 11)
171 ///////////////////////////////////////////////////////////////////////////
172 {
173 unsigned int u;
174
175 uint_parser<unsigned int, 11, 1, -1> base11_parser;
176
177 BOOST_TEST(test("26a815", base11_parser));
178 BOOST_TEST(test_attr("26a815", base11_parser, u));
179 BOOST_TEST(424242 == u);
180
181 BOOST_TEST(!test("90ab", base11_parser));
182 BOOST_TEST(!test_attr("90AB", base11_parser, u));
183
184 BOOST_TEST(test(max_unsigned_base11, base11_parser));
185 BOOST_TEST(test_attr(max_unsigned_base11, base11_parser, u));
186
187 BOOST_TEST(!test(unsigned_overflow_base11, base11_parser));
188 BOOST_TEST(!test_attr(unsigned_overflow_base11, base11_parser, u));
189 BOOST_TEST(!test(digit_overflow_base11, base11_parser));
190 BOOST_TEST(!test_attr(digit_overflow_base11, base11_parser, u));
191 }
192
193 ///////////////////////////////////////////////////////////////////////////
194 // arbitrary radix test (base 12)
195 ///////////////////////////////////////////////////////////////////////////
196 {
197 unsigned int u;
198 uint_parser<unsigned int, 12, 1, -1> base12_parser;
199
200 BOOST_TEST(test("185616", base12_parser));
201 BOOST_TEST(test_attr("185616", base12_parser, u));
202 BOOST_TEST(424242 == u);
203
204 BOOST_TEST(!test("9abc", base12_parser));
205 BOOST_TEST(!test_attr("9ABC", base12_parser, u));
206
207 BOOST_TEST(test(max_unsigned_base12, base12_parser));
208 BOOST_TEST(test_attr(max_unsigned_base12, base12_parser, u));
209
210 BOOST_TEST(!test(unsigned_overflow_base12, base12_parser));
211 BOOST_TEST(!test_attr(unsigned_overflow_base12, base12_parser, u));
212 BOOST_TEST(!test(digit_overflow_base12, base12_parser));
213 BOOST_TEST(!test_attr(digit_overflow_base12, base12_parser, u));
214 }
215
216 ///////////////////////////////////////////////////////////////////////////
217 // arbitrary radix test (base 13)
218 ///////////////////////////////////////////////////////////////////////////
219 {
220 unsigned int u;
221 uint_parser<unsigned int, 13, 1, -1> base13_parser;
222
223 BOOST_TEST(test("11b140", base13_parser));
224 BOOST_TEST(test_attr("11b140", base13_parser, u));
225 BOOST_TEST(424242 == u);
226
227 BOOST_TEST(!test("abcd", base13_parser));
228 BOOST_TEST(!test_attr("ABCD", base13_parser, u));
229
230 BOOST_TEST(test(max_unsigned_base13, base13_parser));
231 BOOST_TEST(test_attr(max_unsigned_base13, base13_parser, u));
232
233 BOOST_TEST(!test(unsigned_overflow_base13, base13_parser));
234 BOOST_TEST(!test_attr(unsigned_overflow_base13, base13_parser, u));
235 BOOST_TEST(!test(digit_overflow_base13, base13_parser));
236 BOOST_TEST(!test_attr(digit_overflow_base13, base13_parser, u));
237 }
238
239 ///////////////////////////////////////////////////////////////////////////
240 // arbitrary radix test (base 14)
241 ///////////////////////////////////////////////////////////////////////////
242 {
243 unsigned int u;
244 uint_parser<unsigned int, 14, 1, -1> base14_parser;
245
246 BOOST_TEST(test("b0870", base14_parser));
247 BOOST_TEST(test_attr("b0870", base14_parser, u));
248 BOOST_TEST(424242 == u);
249
250 BOOST_TEST(!test("bcde", base14_parser));
251 BOOST_TEST(!test_attr("BCDE", base14_parser, u));
252
253 BOOST_TEST(test(max_unsigned_base14, base14_parser));
254 BOOST_TEST(test_attr(max_unsigned_base14, base14_parser, u));
255
256 BOOST_TEST(!test(unsigned_overflow_base14, base14_parser));
257 BOOST_TEST(!test_attr(unsigned_overflow_base14, base14_parser, u));
258 BOOST_TEST(!test(digit_overflow_base14, base14_parser));
259 BOOST_TEST(!test_attr(digit_overflow_base14, base14_parser, u));
260 }
261
262 ///////////////////////////////////////////////////////////////////////////
263 // arbitrary radix test (base 15)
264 ///////////////////////////////////////////////////////////////////////////
265 {
266 unsigned int u;
267 uint_parser<unsigned int, 15, 1, -1> base15_parser;
268
269 BOOST_TEST(test("85a7c", base15_parser));
270 BOOST_TEST(test_attr("85a7c", base15_parser, u));
271 BOOST_TEST(424242 == u);
272
273 BOOST_TEST(!test("cdef", base15_parser));
274 BOOST_TEST(!test_attr("CDEF", base15_parser, u));
275
276 BOOST_TEST(test(max_unsigned_base15, base15_parser));
277 BOOST_TEST(test_attr(max_unsigned_base15, base15_parser, u));
278
279 BOOST_TEST(!test(unsigned_overflow_base15, base15_parser));
280 BOOST_TEST(!test_attr(unsigned_overflow_base15, base15_parser, u));
281 BOOST_TEST(!test(digit_overflow_base15, base15_parser));
282 BOOST_TEST(!test_attr(digit_overflow_base15, base15_parser, u));
283 }
284
285 ///////////////////////////////////////////////////////////////////////////
286 // arbitrary radix test (base 17)
287 ///////////////////////////////////////////////////////////////////////////
288 {
289 unsigned int u;
290 uint_parser<unsigned int, 17, 1, -1> base17_parser;
291
292 BOOST_TEST(test("515g7", base17_parser));
293 BOOST_TEST(test_attr("515g7", base17_parser, u));
294 BOOST_TEST(424242 == u);
295
296 BOOST_TEST(!test("efgh", base17_parser));
297 BOOST_TEST(!test_attr("EFGH", base17_parser, u));
298
299 BOOST_TEST(test(max_unsigned_base17, base17_parser));
300 BOOST_TEST(test_attr(max_unsigned_base17, base17_parser, u));
301
302 BOOST_TEST(!test(unsigned_overflow_base17, base17_parser));
303 BOOST_TEST(!test_attr(unsigned_overflow_base17, base17_parser, u));
304 BOOST_TEST(!test(digit_overflow_base17, base17_parser));
305 BOOST_TEST(!test_attr(digit_overflow_base17, base17_parser, u));
306 }
307
308 ///////////////////////////////////////////////////////////////////////////
309 // arbitrary radix test (base 18)
310 ///////////////////////////////////////////////////////////////////////////
311 {
312 unsigned int u;
313 uint_parser<unsigned int, 18, 1, -1> base18_parser;
314
315 BOOST_TEST(test("40d70", base18_parser));
316 BOOST_TEST(test_attr("40d70", base18_parser, u));
317 BOOST_TEST(424242 == u);
318
319 BOOST_TEST(!test("fghi", base18_parser));
320 BOOST_TEST(!test_attr("FGHI", base18_parser, u));
321
322 BOOST_TEST(test(max_unsigned_base18, base18_parser));
323 BOOST_TEST(test_attr(max_unsigned_base18, base18_parser, u));
324
325 BOOST_TEST(!test(unsigned_overflow_base18, base18_parser));
326 BOOST_TEST(!test_attr(unsigned_overflow_base18, base18_parser, u));
327 BOOST_TEST(!test(digit_overflow_base18, base18_parser));
328 BOOST_TEST(!test_attr(digit_overflow_base18, base18_parser, u));
329 }
330
331 ///////////////////////////////////////////////////////////////////////////
332 // arbitrary radix test (base 19)
333 ///////////////////////////////////////////////////////////////////////////
334 {
335 unsigned int u;
336 uint_parser<unsigned int, 19, 1, -1> base19_parser;
337
338 BOOST_TEST(test("34g3a", base19_parser));
339 BOOST_TEST(test_attr("34g3a", base19_parser, u));
340 BOOST_TEST(424242 == u);
341
342 BOOST_TEST(!test("ghij", base19_parser));
343 BOOST_TEST(!test_attr("GHIJ", base19_parser, u));
344
345 BOOST_TEST(test(max_unsigned_base19, base19_parser));
346 BOOST_TEST(test_attr(max_unsigned_base19, base19_parser, u));
347
348 BOOST_TEST(!test(unsigned_overflow_base19, base19_parser));
349 BOOST_TEST(!test_attr(unsigned_overflow_base19, base19_parser, u));
350 BOOST_TEST(!test(digit_overflow_base19, base19_parser));
351 BOOST_TEST(!test_attr(digit_overflow_base19, base19_parser, u));
352 }
353
354 ///////////////////////////////////////////////////////////////////////////
355 // arbitrary radix test (base 20)
356 ///////////////////////////////////////////////////////////////////////////
357 {
358 unsigned int u;
359 uint_parser<unsigned int, 20, 1, -1> base20_parser;
360
361 BOOST_TEST(test("2d0c2", base20_parser));
362 BOOST_TEST(test_attr("2d0c2", base20_parser, u));
363 BOOST_TEST(424242 == u);
364
365 BOOST_TEST(!test("hijk", base20_parser));
366 BOOST_TEST(!test_attr("HIJK", base20_parser, u));
367
368 BOOST_TEST(test(max_unsigned_base20, base20_parser));
369 BOOST_TEST(test_attr(max_unsigned_base20, base20_parser, u));
370
371 BOOST_TEST(!test(unsigned_overflow_base20, base20_parser));
372 BOOST_TEST(!test_attr(unsigned_overflow_base20, base20_parser, u));
373 BOOST_TEST(!test(digit_overflow_base20, base20_parser));
374 BOOST_TEST(!test_attr(digit_overflow_base20, base20_parser, u));
375 }
376
377 ///////////////////////////////////////////////////////////////////////////
378 // arbitrary radix test (base 21)
379 ///////////////////////////////////////////////////////////////////////////
380 {
381 unsigned int u;
382 uint_parser<unsigned int, 21, 1, -1> base21_parser;
383
384 BOOST_TEST(test("23h00", base21_parser));
385 BOOST_TEST(test_attr("23h00", base21_parser, u));
386 BOOST_TEST(424242 == u);
387
388 BOOST_TEST(!test("ijkl", base21_parser));
389 BOOST_TEST(!test_attr("IJKL", base21_parser, u));
390
391 BOOST_TEST(test(max_unsigned_base21, base21_parser));
392 BOOST_TEST(test_attr(max_unsigned_base21, base21_parser, u));
393
394 BOOST_TEST(!test(unsigned_overflow_base21, base21_parser));
395 BOOST_TEST(!test_attr(unsigned_overflow_base21, base21_parser, u));
396 BOOST_TEST(!test(digit_overflow_base21, base21_parser));
397 BOOST_TEST(!test_attr(digit_overflow_base21, base21_parser, u));
398 }
399
400 ///////////////////////////////////////////////////////////////////////////
401 // arbitrary radix test (base 22)
402 ///////////////////////////////////////////////////////////////////////////
403 {
404 unsigned int u;
405 uint_parser<unsigned int, 22, 1, -1> base22_parser;
406
407 BOOST_TEST(test("1hibg", base22_parser));
408 BOOST_TEST(test_attr("1hibg", base22_parser, u));
409 BOOST_TEST(424242 == u);
410
411 BOOST_TEST(!test("jklm", base22_parser));
412 BOOST_TEST(!test_attr("JKLM", base22_parser, u));
413
414 BOOST_TEST(test(max_unsigned_base22, base22_parser));
415 BOOST_TEST(test_attr(max_unsigned_base22, base22_parser, u));
416
417 BOOST_TEST(!test(unsigned_overflow_base22, base22_parser));
418 BOOST_TEST(!test_attr(unsigned_overflow_base22, base22_parser, u));
419 BOOST_TEST(!test(digit_overflow_base22, base22_parser));
420 BOOST_TEST(!test_attr(digit_overflow_base22, base22_parser, u));
421 }
422
423 ///////////////////////////////////////////////////////////////////////////
424 // arbitrary radix test (base 23)
425 ///////////////////////////////////////////////////////////////////////////
426 {
427 unsigned int u;
428 uint_parser<unsigned int, 23, 1, -1> base23_parser;
429
430 BOOST_TEST(test("1bjm7", base23_parser));
431 BOOST_TEST(test_attr("1bjm7", base23_parser, u));
432 BOOST_TEST(424242 == u);
433
434 BOOST_TEST(!test("klmn", base23_parser));
435 BOOST_TEST(!test_attr("KLMN", base23_parser, u));
436
437 BOOST_TEST(test(max_unsigned_base23, base23_parser));
438 BOOST_TEST(test_attr(max_unsigned_base23, base23_parser, u));
439
440 BOOST_TEST(!test(unsigned_overflow_base23, base23_parser));
441 BOOST_TEST(!test_attr(unsigned_overflow_base23, base23_parser, u));
442 BOOST_TEST(!test(digit_overflow_base23, base23_parser));
443 BOOST_TEST(!test_attr(digit_overflow_base23, base23_parser, u));
444 }
445
446 ///////////////////////////////////////////////////////////////////////////
447 // arbitrary radix test (base 24)
448 ///////////////////////////////////////////////////////////////////////////
449 {
450 unsigned int u;
451 uint_parser<unsigned int, 24, 1, -1> base24_parser;
452
453 BOOST_TEST(test("16gci", base24_parser));
454 BOOST_TEST(test_attr("16gci", base24_parser, u));
455 BOOST_TEST(424242 == u);
456
457 BOOST_TEST(!test("lmno", base24_parser));
458 BOOST_TEST(!test_attr("LMNO", base24_parser, u));
459
460 BOOST_TEST(test(max_unsigned_base24, base24_parser));
461 BOOST_TEST(test_attr(max_unsigned_base24, base24_parser, u));
462
463 BOOST_TEST(!test(unsigned_overflow_base24, base24_parser));
464 BOOST_TEST(!test_attr(unsigned_overflow_base24, base24_parser, u));
465 BOOST_TEST(!test(digit_overflow_base24, base24_parser));
466 BOOST_TEST(!test_attr(digit_overflow_base24, base24_parser, u));
467 }
468
469 ///////////////////////////////////////////////////////////////////////////
470 // arbitrary radix test (base 25)
471 ///////////////////////////////////////////////////////////////////////////
472 {
473 unsigned int u;
474 uint_parser<unsigned int, 25, 1, -1> base25_parser;
475
476 BOOST_TEST(test("123jh", base25_parser));
477 BOOST_TEST(test_attr("123jh", base25_parser, u));
478 BOOST_TEST(424242 == u);
479
480 BOOST_TEST(!test("mnop", base25_parser));
481 BOOST_TEST(!test_attr("MNOP", base25_parser, u));
482
483 BOOST_TEST(test(max_unsigned_base25, base25_parser));
484 BOOST_TEST(test_attr(max_unsigned_base25, base25_parser, u));
485
486 BOOST_TEST(!test(unsigned_overflow_base25, base25_parser));
487 BOOST_TEST(!test_attr(unsigned_overflow_base25, base25_parser, u));
488 BOOST_TEST(!test(digit_overflow_base25, base25_parser));
489 BOOST_TEST(!test_attr(digit_overflow_base25, base25_parser, u));
490 }
491
492 ///////////////////////////////////////////////////////////////////////////
493 // arbitrary radix test (base 26)
494 ///////////////////////////////////////////////////////////////////////////
495 {
496 unsigned int u;
497 uint_parser<unsigned int, 26, 1, -1> base26_parser;
498
499 BOOST_TEST(test("o3f0", base26_parser));
500 BOOST_TEST(test_attr("o3f0", base26_parser, u));
501 BOOST_TEST(424242 == u);
502
503 BOOST_TEST(!test("nopq", base26_parser));
504 BOOST_TEST(!test_attr("NOPQ", base26_parser, u));
505
506 BOOST_TEST(test(max_unsigned_base26, base26_parser));
507 BOOST_TEST(test_attr(max_unsigned_base26, base26_parser, u));
508
509 BOOST_TEST(!test(unsigned_overflow_base26, base26_parser));
510 BOOST_TEST(!test_attr(unsigned_overflow_base26, base26_parser, u));
511 BOOST_TEST(!test(digit_overflow_base26, base26_parser));
512 BOOST_TEST(!test_attr(digit_overflow_base26, base26_parser, u));
513 }
514
515 ///////////////////////////////////////////////////////////////////////////
516 // arbitrary radix test (base 27)
517 ///////////////////////////////////////////////////////////////////////////
518 {
519 unsigned int u;
520 uint_parser<unsigned int, 27, 1, -1> base27_parser;
521
522 BOOST_TEST(test("lepi", base27_parser));
523 BOOST_TEST(test_attr("lepi", base27_parser, u));
524 BOOST_TEST(424242 == u);
525
526 BOOST_TEST(!test("opqr", base27_parser));
527 BOOST_TEST(!test_attr("OPQR", base27_parser, u));
528
529 BOOST_TEST(test(max_unsigned_base27, base27_parser));
530 BOOST_TEST(test_attr(max_unsigned_base27, base27_parser, u));
531
532 BOOST_TEST(!test(unsigned_overflow_base27, base27_parser));
533 BOOST_TEST(!test_attr(unsigned_overflow_base27, base27_parser, u));
534 BOOST_TEST(!test(digit_overflow_base27, base27_parser));
535 BOOST_TEST(!test_attr(digit_overflow_base27, base27_parser, u));
536 }
537
538 ///////////////////////////////////////////////////////////////////////////
539 // arbitrary radix test (base 28)
540 ///////////////////////////////////////////////////////////////////////////
541 {
542 unsigned int u;
543 uint_parser<unsigned int, 28, 1, -1> base28_parser;
544
545 BOOST_TEST(test("j93e", base28_parser));
546 BOOST_TEST(test_attr("j93e", base28_parser, u));
547 BOOST_TEST(424242 == u);
548
549 BOOST_TEST(!test("pqrs", base28_parser));
550 BOOST_TEST(!test_attr("PQRS", base28_parser, u));
551
552 BOOST_TEST(test(max_unsigned_base28, base28_parser));
553 BOOST_TEST(test_attr(max_unsigned_base28, base28_parser, u));
554
555 BOOST_TEST(!test(unsigned_overflow_base28, base28_parser));
556 BOOST_TEST(!test_attr(unsigned_overflow_base28, base28_parser, u));
557 BOOST_TEST(!test(digit_overflow_base28, base28_parser));
558 BOOST_TEST(!test_attr(digit_overflow_base28, base28_parser, u));
559 }
560
561 ///////////////////////////////////////////////////////////////////////////
562 // arbitrary radix test (base 29)
563 ///////////////////////////////////////////////////////////////////////////
564 {
565 unsigned int u;
566 uint_parser<unsigned int, 29, 1, -1> base29_parser;
567
568 BOOST_TEST(test("hbd1", base29_parser));
569 BOOST_TEST(test_attr("hbd1", base29_parser, u));
570 BOOST_TEST(424242 == u);
571
572 BOOST_TEST(!test("qrst", base29_parser));
573 BOOST_TEST(!test_attr("QRST", base29_parser, u));
574
575 BOOST_TEST(test(max_unsigned_base29, base29_parser));
576 BOOST_TEST(test_attr(max_unsigned_base29, base29_parser, u));
577
578 BOOST_TEST(!test(unsigned_overflow_base29, base29_parser));
579 BOOST_TEST(!test_attr(unsigned_overflow_base29, base29_parser, u));
580 BOOST_TEST(!test(digit_overflow_base29, base29_parser));
581 BOOST_TEST(!test_attr(digit_overflow_base29, base29_parser, u));
582 }
583
584 ///////////////////////////////////////////////////////////////////////////
585 // arbitrary radix test (base 30)
586 ///////////////////////////////////////////////////////////////////////////
587 {
588 unsigned int u;
589 uint_parser<unsigned int, 30, 1, -1> base30_parser;
590
591 BOOST_TEST(test("flbc", base30_parser));
592 BOOST_TEST(test_attr("flbc", base30_parser, u));
593 BOOST_TEST(424242 == u);
594
595 BOOST_TEST(!test("rstu", base30_parser));
596 BOOST_TEST(!test_attr("RSTU", base30_parser, u));
597
598 BOOST_TEST(test(max_unsigned_base30, base30_parser));
599 BOOST_TEST(test_attr(max_unsigned_base30, base30_parser, u));
600
601 BOOST_TEST(!test(unsigned_overflow_base30, base30_parser));
602 BOOST_TEST(!test_attr(unsigned_overflow_base30, base30_parser, u));
603 BOOST_TEST(!test(digit_overflow_base30, base30_parser));
604 BOOST_TEST(!test_attr(digit_overflow_base30, base30_parser, u));
605 }
606
607 ///////////////////////////////////////////////////////////////////////////
608 // arbitrary radix test (base 31)
609 ///////////////////////////////////////////////////////////////////////////
610 {
611 unsigned int u;
612 uint_parser<unsigned int, 31, 1, -1> base31_parser;
613
614 BOOST_TEST(test("e7e7", base31_parser));
615 BOOST_TEST(test_attr("e7e7", base31_parser, u));
616 BOOST_TEST(424242 == u);
617
618 BOOST_TEST(!test("stuv", base31_parser));
619 BOOST_TEST(!test_attr("STUV", base31_parser, u));
620
621 BOOST_TEST(test(max_unsigned_base31, base31_parser));
622 BOOST_TEST(test_attr(max_unsigned_base31, base31_parser, u));
623
624 BOOST_TEST(!test(unsigned_overflow_base31, base31_parser));
625 BOOST_TEST(!test_attr(unsigned_overflow_base31, base31_parser, u));
626 BOOST_TEST(!test(digit_overflow_base31, base31_parser));
627 BOOST_TEST(!test_attr(digit_overflow_base31, base31_parser, u));
628 }
629
630 ///////////////////////////////////////////////////////////////////////////
631 // arbitrary radix test (base 32)
632 ///////////////////////////////////////////////////////////////////////////
633 {
634 unsigned int u;
635 uint_parser<unsigned int, 32, 1, -1> base32_parser;
636
637 BOOST_TEST(test("cu9i", base32_parser));
638 BOOST_TEST(test_attr("cu9i", base32_parser, u));
639 BOOST_TEST(424242 == u);
640
641 BOOST_TEST(!test("tuvw", base32_parser));
642 BOOST_TEST(!test_attr("TUVW", base32_parser, u));
643
644 BOOST_TEST(test(max_unsigned_base32, base32_parser));
645 BOOST_TEST(test_attr(max_unsigned_base32, base32_parser, u));
646
647 BOOST_TEST(!test(unsigned_overflow_base32, base32_parser));
648 BOOST_TEST(!test_attr(unsigned_overflow_base32, base32_parser, u));
649 BOOST_TEST(!test(digit_overflow_base32, base32_parser));
650 BOOST_TEST(!test_attr(digit_overflow_base32, base32_parser, u));
651 }
652
653 ///////////////////////////////////////////////////////////////////////////
654 // arbitrary radix test (base 33)
655 ///////////////////////////////////////////////////////////////////////////
656 {
657 unsigned int u;
658 uint_parser<unsigned int, 33, 1, -1> base33_parser;
659
660 BOOST_TEST(test("bqir", base33_parser));
661 BOOST_TEST(test_attr("bqir", base33_parser, u));
662 BOOST_TEST(424242 == u);
663
664 BOOST_TEST(!test("uvwx", base33_parser));
665 BOOST_TEST(!test_attr("UVWX", base33_parser, u));
666
667 BOOST_TEST(test(max_unsigned_base33, base33_parser));
668 BOOST_TEST(test_attr(max_unsigned_base33, base33_parser, u));
669
670 BOOST_TEST(!test(unsigned_overflow_base33, base33_parser));
671 BOOST_TEST(!test_attr(unsigned_overflow_base33, base33_parser, u));
672 BOOST_TEST(!test(digit_overflow_base33, base33_parser));
673 BOOST_TEST(!test_attr(digit_overflow_base33, base33_parser, u));
674 }
675
676 ///////////////////////////////////////////////////////////////////////////
677 // arbitrary radix test (base 34)
678 ///////////////////////////////////////////////////////////////////////////
679 {
680 unsigned int u;
681 uint_parser<unsigned int, 34, 1, -1> base34_parser;
682
683 BOOST_TEST(test("aqxo", base34_parser));
684 BOOST_TEST(test_attr("aqxo", base34_parser, u));
685 BOOST_TEST(424242 == u);
686
687 BOOST_TEST(!test("vwxy", base34_parser));
688 BOOST_TEST(!test_attr("VWXY", base34_parser, u));
689
690 BOOST_TEST(test(max_unsigned_base34, base34_parser));
691 BOOST_TEST(test_attr(max_unsigned_base34, base34_parser, u));
692
693 BOOST_TEST(!test(unsigned_overflow_base34, base34_parser));
694 BOOST_TEST(!test_attr(unsigned_overflow_base34, base34_parser, u));
695 BOOST_TEST(!test(digit_overflow_base34, base34_parser));
696 BOOST_TEST(!test_attr(digit_overflow_base34, base34_parser, u));
697 }
698
699 ///////////////////////////////////////////////////////////////////////////
700 // arbitrary radix test (base 35)
701 ///////////////////////////////////////////////////////////////////////////
702 {
703 unsigned int u;
704 uint_parser<unsigned int, 35, 1, -1> base35_parser;
705
706 BOOST_TEST(test("9vb7", base35_parser));
707 BOOST_TEST(test_attr("9vb7", base35_parser, u));
708 BOOST_TEST(424242 == u);
709
710 BOOST_TEST(!test("wxyz", base35_parser));
711 BOOST_TEST(!test_attr("WXYZ", base35_parser, u));
712
713 BOOST_TEST(test(max_unsigned_base35, base35_parser));
714 BOOST_TEST(test_attr(max_unsigned_base35, base35_parser, u));
715
716 BOOST_TEST(!test(unsigned_overflow_base35, base35_parser));
717 BOOST_TEST(!test_attr(unsigned_overflow_base35, base35_parser, u));
718 BOOST_TEST(!test(digit_overflow_base35, base35_parser));
719 BOOST_TEST(!test_attr(digit_overflow_base35, base35_parser, u));
720 }
721
722 ///////////////////////////////////////////////////////////////////////////
723 // arbitrary radix test (base 36)
724 ///////////////////////////////////////////////////////////////////////////
725 {
726 unsigned int u;
727 uint_parser<unsigned int, 36, 1, -1> base36_parser;
728
729 BOOST_TEST(test("93ci", base36_parser));
730 BOOST_TEST(test_attr("93ci", base36_parser, u));
731 BOOST_TEST(424242 == u);
732
733 BOOST_TEST(test(max_unsigned_base36, base36_parser));
734 BOOST_TEST(test_attr(max_unsigned_base36, base36_parser, u));
735
736 BOOST_TEST(!test(unsigned_overflow_base36, base36_parser));
737 BOOST_TEST(!test_attr(unsigned_overflow_base36, base36_parser, u));
738 BOOST_TEST(!test(digit_overflow_base36, base36_parser));
739 BOOST_TEST(!test_attr(digit_overflow_base36, base36_parser, u));
740 }
741
742 return boost::report_errors();
743 }
744