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