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

source code of boost/libs/spirit/test/qi/uint_radix.cpp