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

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