boost/spirit_x4
2
0
Fork 0
mirror of https://github.com/boostorg/spirit_x4.git synced 2026-01-29 20:12:07 +00:00
Code Issues Projects Releases Wiki Activity
Files
develop
spirit_x4/test/x4/uint_radix.cpp
Nana Sakisaka 05bf2eb30b Migrate to Catch2 (#48) 
* Migrate to Catch2

* Enable colors in Catch2

* CI: Cache Catch2

* Remove unused variable

* Supply compiler flags to `Catch2WithMain`

* CI: Fix Catch2 cache

* Fix styling
2025-09-25 17:26:35 +09:00

813 lines
34 KiB
C++
Raw Permalink Blame History

/*=============================================================================
Copyright (c) 2011 Jan Frederick Eick
Copyright (c) 2025 Nana Sakisaka
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#include "test.hpp"
#include <boost/spirit/x4/numeric/uint.hpp>
#include <string_view>
#include <climits>
#include <cstring>
namespace {
//
// BEWARE PLATFORM DEPENDENT!!!
// The following assumes 32-bit integers and 64-bit long longs.
// Modify these constant strings when appropriate.
//
constexpr std::string_view max_unsigned_base3 = "102002022201221111210";
constexpr std::string_view unsigned_overflow_base3 = "102002022201221111211";
constexpr std::string_view digit_overflow_base3 = "1020020222012211112100";
constexpr std::string_view max_unsigned_base4 = "3333333333333333";
constexpr std::string_view digit_overflow_base4 = "33333333333333330";
constexpr std::string_view max_unsigned_base5 = "32244002423140";
constexpr std::string_view unsigned_overflow_base5 = "32244002423141";
constexpr std::string_view digit_overflow_base5 = "322440024231400";
constexpr std::string_view max_unsigned_base6 = "1550104015503";
constexpr std::string_view unsigned_overflow_base6 = "1550104015504";
constexpr std::string_view digit_overflow_base6 = "15501040155030";
constexpr std::string_view max_unsigned_base7 = "211301422353";
constexpr std::string_view unsigned_overflow_base7 = "211301422354";
constexpr std::string_view digit_overflow_base7 = "2113014223530";
constexpr std::string_view max_unsigned_base9 = "12068657453";
constexpr std::string_view unsigned_overflow_base9 = "12068657454";
constexpr std::string_view digit_overflow_base9 = "120686574530";
constexpr std::string_view max_unsigned_base11 = "1904440553";
constexpr std::string_view unsigned_overflow_base11 = "1904440554";
constexpr std::string_view digit_overflow_base11 = "19044405530";
constexpr std::string_view max_unsigned_base12 = "9BA461593";
constexpr std::string_view unsigned_overflow_base12 = "9BA461594";
constexpr std::string_view digit_overflow_base12 = "9BA4615930";
constexpr std::string_view max_unsigned_base13 = "535A79888";
constexpr std::string_view unsigned_overflow_base13 = "535A79889";
constexpr std::string_view digit_overflow_base13 = "535A798880";
constexpr std::string_view max_unsigned_base14 = "2CA5B7463";
constexpr std::string_view unsigned_overflow_base14 = "2CA5B7464";
constexpr std::string_view digit_overflow_base14 = "2CA5B74630";
constexpr std::string_view max_unsigned_base15 = "1A20DCD80";
constexpr std::string_view unsigned_overflow_base15 = "1A20DCD81";
constexpr std::string_view digit_overflow_base15 = "1A20DCD800";
constexpr std::string_view max_unsigned_base17 = "A7FFDA90";
constexpr std::string_view unsigned_overflow_base17 = "A7FFDA91";
constexpr std::string_view digit_overflow_base17 = "A7FFDA900";
constexpr std::string_view max_unsigned_base18 = "704HE7G3";
constexpr std::string_view unsigned_overflow_base18 = "704HE7G4";
constexpr std::string_view digit_overflow_base18 = "704HE7G30";
constexpr std::string_view max_unsigned_base19 = "4F5AFF65";
constexpr std::string_view unsigned_overflow_base19 = "4F5AFF66";
constexpr std::string_view digit_overflow_base19 = "4F5AFF650";
constexpr std::string_view max_unsigned_base20 = "3723AI4F";
constexpr std::string_view unsigned_overflow_base20 = "3723AI4G";
constexpr std::string_view digit_overflow_base20 = "3723AI4G0";
constexpr std::string_view max_unsigned_base21 = "281D55I3";
constexpr std::string_view unsigned_overflow_base21 = "281D55I4";
constexpr std::string_view digit_overflow_base21 = "281D55I30";
constexpr std::string_view max_unsigned_base22 = "1FJ8B183";
constexpr std::string_view unsigned_overflow_base22 = "1FJ8B184";
constexpr std::string_view digit_overflow_base22 = "1FJ8B1830";
constexpr std::string_view max_unsigned_base23 = "1606K7IB";
constexpr std::string_view unsigned_overflow_base23 = "1606K7IC";
constexpr std::string_view digit_overflow_base23 = "1606K7IB0";
constexpr std::string_view max_unsigned_base24 = "MB994AF";
constexpr std::string_view unsigned_overflow_base24 = "MB994AG";
constexpr std::string_view digit_overflow_base24 = "MB994AF0";
constexpr std::string_view max_unsigned_base25 = "HEK2MGK";
constexpr std::string_view unsigned_overflow_base25 = "HEK2MGL";
constexpr std::string_view digit_overflow_base25 = "HEK2MGK0";
constexpr std::string_view max_unsigned_base26 = "DNCHBNL";
constexpr std::string_view unsigned_overflow_base26 = "DNCHBNM";
constexpr std::string_view digit_overflow_base26 = "DNCHBNL0";
constexpr std::string_view max_unsigned_base27 = "B28JPDL";
constexpr std::string_view unsigned_overflow_base27 = "B28JPDM";
constexpr std::string_view digit_overflow_base27 = "B28JPDL0";
constexpr std::string_view max_unsigned_base28 = "8PFGIH3";
constexpr std::string_view unsigned_overflow_base28 = "8PFGIH4";
constexpr std::string_view digit_overflow_base28 = "8PFGIH30";
constexpr std::string_view max_unsigned_base29 = "76BEIGF";
constexpr std::string_view unsigned_overflow_base29 = "76BEIGH";
constexpr std::string_view digit_overflow_base29 = "76BEIGF0";
constexpr std::string_view max_unsigned_base30 = "5QMCPQF";
constexpr std::string_view unsigned_overflow_base30 = "5QMCPQG";
constexpr std::string_view digit_overflow_base30 = "5QMCPQF0";
constexpr std::string_view max_unsigned_base31 = "4Q0JTO3";
constexpr std::string_view unsigned_overflow_base31 = "4Q0JTO4";
constexpr std::string_view digit_overflow_base31 = "4Q0JTO30";
constexpr std::string_view max_unsigned_base32 = "3VVVVVV";
constexpr std::string_view unsigned_overflow_base32 = "3VVVVVW";
constexpr std::string_view digit_overflow_base32 = "3VVVVVV0";
constexpr std::string_view max_unsigned_base33 = "3AOKQ93";
constexpr std::string_view unsigned_overflow_base33 = "3AOKQ94";
constexpr std::string_view digit_overflow_base33 = "3AOKQ930";
constexpr std::string_view max_unsigned_base34 = "2QHXJLH";
constexpr std::string_view unsigned_overflow_base34 = "2QHXJLI";
constexpr std::string_view digit_overflow_base34 = "2QHXJLH0";
constexpr std::string_view max_unsigned_base35 = "2BR45QA";
constexpr std::string_view unsigned_overflow_base35 = "2BR45QB";
constexpr std::string_view digit_overflow_base35 = "2BR45QA0";
constexpr std::string_view max_unsigned_base36 = "1Z141Z3";
constexpr std::string_view unsigned_overflow_base36 = "1Z141Z4";
constexpr std::string_view digit_overflow_base36 = "1Z141Z30";
using x4::uint_parser;
} // anonymous
TEST_CASE("uint_radix_3-15")
{
// arbitrary radix test (base 3)
{
unsigned int u = 0;
uint_parser<unsigned int, 3, 1, -1> base3_parser;
CHECK(parse("210112221200", base3_parser));
REQUIRE(parse("210112221200", base3_parser, u));
CHECK(424242 == u);
CHECK(!parse("1231", base3_parser));
CHECK(!parse("1231", base3_parser, u));
CHECK(parse(max_unsigned_base3, base3_parser));
CHECK(parse(max_unsigned_base3, base3_parser, u));
CHECK(!parse(unsigned_overflow_base3, base3_parser));
CHECK(!parse(unsigned_overflow_base3, base3_parser, u));
CHECK(!parse(digit_overflow_base3, base3_parser));
CHECK(!parse(digit_overflow_base3, base3_parser, u));
}
// arbitrary radix test (base 4)
{
unsigned int u = 0;
uint_parser<unsigned int, 4, 1, -1> base4_parser;
CHECK(parse("1213210302", base4_parser));
REQUIRE(parse("1213210302", base4_parser, u));
CHECK(424242 == u);
CHECK(!parse("1234", base4_parser));
CHECK(!parse("1234", base4_parser, u));
CHECK(parse(max_unsigned_base4, base4_parser));
CHECK(parse(max_unsigned_base4, base4_parser, u));
CHECK(!parse(digit_overflow_base4, base4_parser));
CHECK(!parse(digit_overflow_base4, base4_parser, u));
}
// arbitrary radix test (base 5)
{
unsigned int u = 0;
uint_parser<unsigned int, 5, 1, -1> base5_parser;
CHECK(parse("102033432", base5_parser));
REQUIRE(parse("102033432", base5_parser, u));
CHECK(424242 == u);
CHECK(!parse("2345", base5_parser));
CHECK(!parse("2345", base5_parser, u));
CHECK(parse(max_unsigned_base5, base5_parser));
CHECK(parse(max_unsigned_base5, base5_parser, u));
CHECK(!parse(unsigned_overflow_base5, base5_parser));
CHECK(!parse(unsigned_overflow_base5, base5_parser, u));
CHECK(!parse(digit_overflow_base5, base5_parser));
CHECK(!parse(digit_overflow_base5, base5_parser, u));
}
// arbitrary radix test (base 6)
{
unsigned int u = 0;
uint_parser<unsigned int, 6, 1, -1> base6_parser;
CHECK(parse("13032030", base6_parser));
REQUIRE(parse("13032030", base6_parser, u));
CHECK(424242 == u);
CHECK(!parse("3456", base6_parser));
CHECK(!parse("3456", base6_parser, u));
CHECK(parse(max_unsigned_base6, base6_parser));
CHECK(parse(max_unsigned_base6, base6_parser, u));
CHECK(!parse(unsigned_overflow_base6, base6_parser));
CHECK(!parse(unsigned_overflow_base6, base6_parser, u));
CHECK(!parse(digit_overflow_base6, base6_parser));
CHECK(!parse(digit_overflow_base6, base6_parser, u));
}
// arbitrary radix test (base 7)
{
unsigned int u = 0;
uint_parser<unsigned int, 7, 1, -1> base7_parser;
CHECK(parse("3414600", base7_parser));
REQUIRE(parse("3414600", base7_parser, u));
CHECK(424242 == u);
CHECK(!parse("4567", base7_parser));
CHECK(!parse("4567", base7_parser, u));
CHECK(parse(max_unsigned_base7, base7_parser));
CHECK(parse(max_unsigned_base7, base7_parser, u));
CHECK(!parse(unsigned_overflow_base7, base7_parser));
CHECK(!parse(unsigned_overflow_base7, base7_parser, u));
CHECK(!parse(digit_overflow_base7, base7_parser));
CHECK(!parse(digit_overflow_base7, base7_parser, u));
}
// arbitrary radix test (base 9)
{
unsigned int u = 0;
uint_parser<unsigned int, 9, 1, -1> base9_parser;
CHECK(parse("715850", base9_parser));
REQUIRE(parse("715850", base9_parser, u));
CHECK(424242 == u);
CHECK(!parse("6789", base9_parser));
CHECK(!parse("6789", base9_parser, u));
CHECK(parse(max_unsigned_base9, base9_parser));
CHECK(parse(max_unsigned_base9, base9_parser, u));
CHECK(!parse(unsigned_overflow_base9, base9_parser));
CHECK(!parse(unsigned_overflow_base9, base9_parser, u));
CHECK(!parse(digit_overflow_base9, base9_parser));
CHECK(!parse(digit_overflow_base9, base9_parser, u));
}
// arbitrary radix test (base 11)
{
unsigned int u = 0;
uint_parser<unsigned int, 11, 1, -1> base11_parser;
CHECK(parse("26a815", base11_parser));
REQUIRE(parse("26a815", base11_parser, u));
CHECK(424242 == u);
CHECK(!parse("90ab", base11_parser));
CHECK(!parse("90AB", base11_parser, u));
CHECK(parse(max_unsigned_base11, base11_parser));
CHECK(parse(max_unsigned_base11, base11_parser, u));
CHECK(!parse(unsigned_overflow_base11, base11_parser));
CHECK(!parse(unsigned_overflow_base11, base11_parser, u));
CHECK(!parse(digit_overflow_base11, base11_parser));
CHECK(!parse(digit_overflow_base11, base11_parser, u));
}
// arbitrary radix test (base 12)
{
unsigned int u = 0;
uint_parser<unsigned int, 12, 1, -1> base12_parser;
CHECK(parse("185616", base12_parser));
REQUIRE(parse("185616", base12_parser, u));
CHECK(424242 == u);
CHECK(!parse("9abc", base12_parser));
CHECK(!parse("9ABC", base12_parser, u));
CHECK(parse(max_unsigned_base12, base12_parser));
CHECK(parse(max_unsigned_base12, base12_parser, u));
CHECK(!parse(unsigned_overflow_base12, base12_parser));
CHECK(!parse(unsigned_overflow_base12, base12_parser, u));
CHECK(!parse(digit_overflow_base12, base12_parser));
CHECK(!parse(digit_overflow_base12, base12_parser, u));
}
// arbitrary radix test (base 13)
{
unsigned int u = 0;
uint_parser<unsigned int, 13, 1, -1> base13_parser;
CHECK(parse("11b140", base13_parser));
REQUIRE(parse("11b140", base13_parser, u));
CHECK(424242 == u);
CHECK(!parse("abcd", base13_parser));
CHECK(!parse("ABCD", base13_parser, u));
CHECK(parse(max_unsigned_base13, base13_parser));
CHECK(parse(max_unsigned_base13, base13_parser, u));
CHECK(!parse(unsigned_overflow_base13, base13_parser));
CHECK(!parse(unsigned_overflow_base13, base13_parser, u));
CHECK(!parse(digit_overflow_base13, base13_parser));
CHECK(!parse(digit_overflow_base13, base13_parser, u));
}
// arbitrary radix test (base 14)
{
unsigned int u = 0;
uint_parser<unsigned int, 14, 1, -1> base14_parser;
CHECK(parse("b0870", base14_parser));
REQUIRE(parse("b0870", base14_parser, u));
CHECK(424242 == u);
CHECK(!parse("bcde", base14_parser));
CHECK(!parse("BCDE", base14_parser, u));
CHECK(parse(max_unsigned_base14, base14_parser));
CHECK(parse(max_unsigned_base14, base14_parser, u));
CHECK(!parse(unsigned_overflow_base14, base14_parser));
CHECK(!parse(unsigned_overflow_base14, base14_parser, u));
CHECK(!parse(digit_overflow_base14, base14_parser));
CHECK(!parse(digit_overflow_base14, base14_parser, u));
}
// arbitrary radix test (base 15)
{
unsigned int u = 0;
uint_parser<unsigned int, 15, 1, -1> base15_parser;
CHECK(parse("85a7c", base15_parser));
REQUIRE(parse("85a7c", base15_parser, u));
CHECK(424242 == u);
CHECK(!parse("cdef", base15_parser));
CHECK(!parse("CDEF", base15_parser, u));
CHECK(parse(max_unsigned_base15, base15_parser));
CHECK(parse(max_unsigned_base15, base15_parser, u));
CHECK(!parse(unsigned_overflow_base15, base15_parser));
CHECK(!parse(unsigned_overflow_base15, base15_parser, u));
CHECK(!parse(digit_overflow_base15, base15_parser));
CHECK(!parse(digit_overflow_base15, base15_parser, u));
}
}
TEST_CASE("uint_radix_17-31")
{
// arbitrary radix test (base 17)
{
unsigned int u = 0;
uint_parser<unsigned int, 17, 1, -1> base17_parser;
CHECK(parse("515g7", base17_parser));
REQUIRE(parse("515g7", base17_parser, u));
CHECK(424242 == u);
CHECK(!parse("efgh", base17_parser));
CHECK(!parse("EFGH", base17_parser, u));
CHECK(parse(max_unsigned_base17, base17_parser));
CHECK(parse(max_unsigned_base17, base17_parser, u));
CHECK(!parse(unsigned_overflow_base17, base17_parser));
CHECK(!parse(unsigned_overflow_base17, base17_parser, u));
CHECK(!parse(digit_overflow_base17, base17_parser));
CHECK(!parse(digit_overflow_base17, base17_parser, u));
}
// arbitrary radix test (base 18)
{
unsigned int u = 0;
uint_parser<unsigned int, 18, 1, -1> base18_parser;
CHECK(parse("40d70", base18_parser));
REQUIRE(parse("40d70", base18_parser, u));
CHECK(424242 == u);
CHECK(!parse("fghi", base18_parser));
CHECK(!parse("FGHI", base18_parser, u));
CHECK(parse(max_unsigned_base18, base18_parser));
CHECK(parse(max_unsigned_base18, base18_parser, u));
CHECK(!parse(unsigned_overflow_base18, base18_parser));
CHECK(!parse(unsigned_overflow_base18, base18_parser, u));
CHECK(!parse(digit_overflow_base18, base18_parser));
CHECK(!parse(digit_overflow_base18, base18_parser, u));
}
// arbitrary radix test (base 19)
{
unsigned int u = 0;
uint_parser<unsigned int, 19, 1, -1> base19_parser;
CHECK(parse("34g3a", base19_parser));
REQUIRE(parse("34g3a", base19_parser, u));
CHECK(424242 == u);
CHECK(!parse("ghij", base19_parser));
CHECK(!parse("GHIJ", base19_parser, u));
CHECK(parse(max_unsigned_base19, base19_parser));
CHECK(parse(max_unsigned_base19, base19_parser, u));
CHECK(!parse(unsigned_overflow_base19, base19_parser));
CHECK(!parse(unsigned_overflow_base19, base19_parser, u));
CHECK(!parse(digit_overflow_base19, base19_parser));
CHECK(!parse(digit_overflow_base19, base19_parser, u));
}
// arbitrary radix test (base 20)
{
unsigned int u = 0;
uint_parser<unsigned int, 20, 1, -1> base20_parser;
CHECK(parse("2d0c2", base20_parser));
REQUIRE(parse("2d0c2", base20_parser, u));
CHECK(424242 == u);
CHECK(!parse("hijk", base20_parser));
CHECK(!parse("HIJK", base20_parser, u));
CHECK(parse(max_unsigned_base20, base20_parser));
CHECK(parse(max_unsigned_base20, base20_parser, u));
CHECK(!parse(unsigned_overflow_base20, base20_parser));
CHECK(!parse(unsigned_overflow_base20, base20_parser, u));
CHECK(!parse(digit_overflow_base20, base20_parser));
CHECK(!parse(digit_overflow_base20, base20_parser, u));
}
// arbitrary radix test (base 21)
{
unsigned int u = 0;
uint_parser<unsigned int, 21, 1, -1> base21_parser;
CHECK(parse("23h00", base21_parser));
REQUIRE(parse("23h00", base21_parser, u));
CHECK(424242 == u);
CHECK(!parse("ijkl", base21_parser));
CHECK(!parse("IJKL", base21_parser, u));
CHECK(parse(max_unsigned_base21, base21_parser));
CHECK(parse(max_unsigned_base21, base21_parser, u));
CHECK(!parse(unsigned_overflow_base21, base21_parser));
CHECK(!parse(unsigned_overflow_base21, base21_parser, u));
CHECK(!parse(digit_overflow_base21, base21_parser));
CHECK(!parse(digit_overflow_base21, base21_parser, u));
}
// arbitrary radix test (base 22)
{
unsigned int u = 0;
uint_parser<unsigned int, 22, 1, -1> base22_parser;
CHECK(parse("1hibg", base22_parser));
REQUIRE(parse("1hibg", base22_parser, u));
CHECK(424242 == u);
CHECK(!parse("jklm", base22_parser));
CHECK(!parse("JKLM", base22_parser, u));
CHECK(parse(max_unsigned_base22, base22_parser));
CHECK(parse(max_unsigned_base22, base22_parser, u));
CHECK(!parse(unsigned_overflow_base22, base22_parser));
CHECK(!parse(unsigned_overflow_base22, base22_parser, u));
CHECK(!parse(digit_overflow_base22, base22_parser));
CHECK(!parse(digit_overflow_base22, base22_parser, u));
}
// arbitrary radix test (base 23)
{
unsigned int u = 0;
uint_parser<unsigned int, 23, 1, -1> base23_parser;
CHECK(parse("1bjm7", base23_parser));
REQUIRE(parse("1bjm7", base23_parser, u));
CHECK(424242 == u);
CHECK(!parse("klmn", base23_parser));
CHECK(!parse("KLMN", base23_parser, u));
CHECK(parse(max_unsigned_base23, base23_parser));
CHECK(parse(max_unsigned_base23, base23_parser, u));
CHECK(!parse(unsigned_overflow_base23, base23_parser));
CHECK(!parse(unsigned_overflow_base23, base23_parser, u));
CHECK(!parse(digit_overflow_base23, base23_parser));
CHECK(!parse(digit_overflow_base23, base23_parser, u));
}
// arbitrary radix test (base 24)
{
unsigned int u = 0;
uint_parser<unsigned int, 24, 1, -1> base24_parser;
CHECK(parse("16gci", base24_parser));
REQUIRE(parse("16gci", base24_parser, u));
CHECK(424242 == u);
CHECK(!parse("lmno", base24_parser));
CHECK(!parse("LMNO", base24_parser, u));
CHECK(parse(max_unsigned_base24, base24_parser));
CHECK(parse(max_unsigned_base24, base24_parser, u));
CHECK(!parse(unsigned_overflow_base24, base24_parser));
CHECK(!parse(unsigned_overflow_base24, base24_parser, u));
CHECK(!parse(digit_overflow_base24, base24_parser));
CHECK(!parse(digit_overflow_base24, base24_parser, u));
}
// arbitrary radix test (base 25)
{
unsigned int u = 0;
uint_parser<unsigned int, 25, 1, -1> base25_parser;
CHECK(parse("123jh", base25_parser));
REQUIRE(parse("123jh", base25_parser, u));
CHECK(424242 == u);
CHECK(!parse("mnop", base25_parser));
CHECK(!parse("MNOP", base25_parser, u));
CHECK(parse(max_unsigned_base25, base25_parser));
CHECK(parse(max_unsigned_base25, base25_parser, u));
CHECK(!parse(unsigned_overflow_base25, base25_parser));
CHECK(!parse(unsigned_overflow_base25, base25_parser, u));
CHECK(!parse(digit_overflow_base25, base25_parser));
CHECK(!parse(digit_overflow_base25, base25_parser, u));
}
// arbitrary radix test (base 26)
{
unsigned int u = 0;
uint_parser<unsigned int, 26, 1, -1> base26_parser;
CHECK(parse("o3f0", base26_parser));
REQUIRE(parse("o3f0", base26_parser, u));
CHECK(424242 == u);
CHECK(!parse("nopq", base26_parser));
CHECK(!parse("NOPQ", base26_parser, u));
CHECK(parse(max_unsigned_base26, base26_parser));
CHECK(parse(max_unsigned_base26, base26_parser, u));
CHECK(!parse(unsigned_overflow_base26, base26_parser));
CHECK(!parse(unsigned_overflow_base26, base26_parser, u));
CHECK(!parse(digit_overflow_base26, base26_parser));
CHECK(!parse(digit_overflow_base26, base26_parser, u));
}
// arbitrary radix test (base 27)
{
unsigned int u = 0;
uint_parser<unsigned int, 27, 1, -1> base27_parser;
CHECK(parse("lepi", base27_parser));
REQUIRE(parse("lepi", base27_parser, u));
CHECK(424242 == u);
CHECK(!parse("opqr", base27_parser));
CHECK(!parse("OPQR", base27_parser, u));
CHECK(parse(max_unsigned_base27, base27_parser));
CHECK(parse(max_unsigned_base27, base27_parser, u));
CHECK(!parse(unsigned_overflow_base27, base27_parser));
CHECK(!parse(unsigned_overflow_base27, base27_parser, u));
CHECK(!parse(digit_overflow_base27, base27_parser));
CHECK(!parse(digit_overflow_base27, base27_parser, u));
}
// arbitrary radix test (base 28)
{
unsigned int u = 0;
uint_parser<unsigned int, 28, 1, -1> base28_parser;
CHECK(parse("j93e", base28_parser));
REQUIRE(parse("j93e", base28_parser, u));
CHECK(424242 == u);
CHECK(!parse("pqrs", base28_parser));
CHECK(!parse("PQRS", base28_parser, u));
CHECK(parse(max_unsigned_base28, base28_parser));
CHECK(parse(max_unsigned_base28, base28_parser, u));
CHECK(!parse(unsigned_overflow_base28, base28_parser));
CHECK(!parse(unsigned_overflow_base28, base28_parser, u));
CHECK(!parse(digit_overflow_base28, base28_parser));
CHECK(!parse(digit_overflow_base28, base28_parser, u));
}
// arbitrary radix test (base 29)
{
unsigned int u = 0;
uint_parser<unsigned int, 29, 1, -1> base29_parser;
CHECK(parse("hbd1", base29_parser));
REQUIRE(parse("hbd1", base29_parser, u));
CHECK(424242 == u);
CHECK(!parse("qrst", base29_parser));
CHECK(!parse("QRST", base29_parser, u));
CHECK(parse(max_unsigned_base29, base29_parser));
CHECK(parse(max_unsigned_base29, base29_parser, u));
CHECK(!parse(unsigned_overflow_base29, base29_parser));
CHECK(!parse(unsigned_overflow_base29, base29_parser, u));
CHECK(!parse(digit_overflow_base29, base29_parser));
CHECK(!parse(digit_overflow_base29, base29_parser, u));
}
// arbitrary radix test (base 30)
{
unsigned int u = 0;
uint_parser<unsigned int, 30, 1, -1> base30_parser;
CHECK(parse("flbc", base30_parser));
REQUIRE(parse("flbc", base30_parser, u));
CHECK(424242 == u);
CHECK(!parse("rstu", base30_parser));
CHECK(!parse("RSTU", base30_parser, u));
CHECK(parse(max_unsigned_base30, base30_parser));
CHECK(parse(max_unsigned_base30, base30_parser, u));
CHECK(!parse(unsigned_overflow_base30, base30_parser));
CHECK(!parse(unsigned_overflow_base30, base30_parser, u));
CHECK(!parse(digit_overflow_base30, base30_parser));
CHECK(!parse(digit_overflow_base30, base30_parser, u));
}
// arbitrary radix test (base 31)
{
unsigned int u = 0;
uint_parser<unsigned int, 31, 1, -1> base31_parser;
CHECK(parse("e7e7", base31_parser));
REQUIRE(parse("e7e7", base31_parser, u));
CHECK(424242 == u);
CHECK(!parse("stuv", base31_parser));
CHECK(!parse("STUV", base31_parser, u));
CHECK(parse(max_unsigned_base31, base31_parser));
CHECK(parse(max_unsigned_base31, base31_parser, u));
CHECK(!parse(unsigned_overflow_base31, base31_parser));
CHECK(!parse(unsigned_overflow_base31, base31_parser, u));
CHECK(!parse(digit_overflow_base31, base31_parser));
CHECK(!parse(digit_overflow_base31, base31_parser, u));
}
}
TEST_CASE("uint_radix_32-36")
{
// arbitrary radix test (base 32)
{
unsigned int u = 0;
uint_parser<unsigned int, 32, 1, -1> base32_parser;
CHECK(parse("cu9i", base32_parser));
REQUIRE(parse("cu9i", base32_parser, u));
CHECK(424242 == u);
CHECK(!parse("tuvw", base32_parser));
CHECK(!parse("TUVW", base32_parser, u));
CHECK(parse(max_unsigned_base32, base32_parser));
CHECK(parse(max_unsigned_base32, base32_parser, u));
CHECK(!parse(unsigned_overflow_base32, base32_parser));
CHECK(!parse(unsigned_overflow_base32, base32_parser, u));
CHECK(!parse(digit_overflow_base32, base32_parser));
CHECK(!parse(digit_overflow_base32, base32_parser, u));
}
// arbitrary radix test (base 33)
{
unsigned int u = 0;
uint_parser<unsigned int, 33, 1, -1> base33_parser;
CHECK(parse("bqir", base33_parser));
REQUIRE(parse("bqir", base33_parser, u));
CHECK(424242 == u);
CHECK(!parse("uvwx", base33_parser));
CHECK(!parse("UVWX", base33_parser, u));
CHECK(parse(max_unsigned_base33, base33_parser));
CHECK(parse(max_unsigned_base33, base33_parser, u));
CHECK(!parse(unsigned_overflow_base33, base33_parser));
CHECK(!parse(unsigned_overflow_base33, base33_parser, u));
CHECK(!parse(digit_overflow_base33, base33_parser));
CHECK(!parse(digit_overflow_base33, base33_parser, u));
}
// arbitrary radix test (base 34)
{
unsigned int u = 0;
uint_parser<unsigned int, 34, 1, -1> base34_parser;
CHECK(parse("aqxo", base34_parser));
REQUIRE(parse("aqxo", base34_parser, u));
CHECK(424242 == u);
CHECK(!parse("vwxy", base34_parser));
CHECK(!parse("VWXY", base34_parser, u));
CHECK(parse(max_unsigned_base34, base34_parser));
CHECK(parse(max_unsigned_base34, base34_parser, u));
CHECK(!parse(unsigned_overflow_base34, base34_parser));
CHECK(!parse(unsigned_overflow_base34, base34_parser, u));
CHECK(!parse(digit_overflow_base34, base34_parser));
CHECK(!parse(digit_overflow_base34, base34_parser, u));
}
// arbitrary radix test (base 35)
{
unsigned int u = 0;
uint_parser<unsigned int, 35, 1, -1> base35_parser;
CHECK(parse("9vb7", base35_parser));
REQUIRE(parse("9vb7", base35_parser, u));
CHECK(424242 == u);
CHECK(!parse("wxyz", base35_parser));
CHECK(!parse("WXYZ", base35_parser, u));
CHECK(parse(max_unsigned_base35, base35_parser));
CHECK(parse(max_unsigned_base35, base35_parser, u));
CHECK(!parse(unsigned_overflow_base35, base35_parser));
CHECK(!parse(unsigned_overflow_base35, base35_parser, u));
CHECK(!parse(digit_overflow_base35, base35_parser));
CHECK(!parse(digit_overflow_base35, base35_parser, u));
}
// arbitrary radix test (base 36)
{
unsigned int u = 0;
uint_parser<unsigned int, 36, 1, -1> base36_parser;
CHECK(parse("93ci", base36_parser));
REQUIRE(parse("93ci", base36_parser, u));
CHECK(424242 == u);
CHECK(parse(max_unsigned_base36, base36_parser));
CHECK(parse(max_unsigned_base36, base36_parser, u));
CHECK(!parse(unsigned_overflow_base36, base36_parser));
CHECK(!parse(unsigned_overflow_base36, base36_parser, u));
CHECK(!parse(digit_overflow_base36, base36_parser));
CHECK(!parse(digit_overflow_base36, base36_parser, u));
}
}
Reference in New Issue View Git Blame Copy Permalink