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 | |
19 | int |
20 | main() |
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 | |