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