int main()
{
using spirit_test::test_attr;
using spirit_test::test;
using namespace boost::spirit::x3::ascii;
using boost::spirit::x3::rule;
using boost::spirit::x3::int_;
using boost::spirit::x3::lit;
{ // synth attribute value-init
std::string s;
typedef rule<class r, std::string> rule_type;
auto rdef = rule_type()
= alpha [f()]
;
BOOST_TEST(test_attr("abcdef", +rdef, s));
BOOST_TEST(s == "abcdef");
}
{ // synth attribute value-init
std::string s;
typedef rule<class r, std::string> rule_type;
auto rdef = rule_type() =
alpha /
[](auto& ctx)
{
_val(ctx) += _attr(ctx);
}
;
BOOST_TEST(test_attr("abcdef", +rdef, s));
BOOST_TEST(s == "abcdef");
}
return boost::report_errors();
}
int main()
{
using spirit_test::test;
using spirit_test::test_attr;
using namespace boost::spirit::x3::ascii;
using boost::spirit::x3::raw;
using boost::spirit::x3::eps;
using boost::spirit::x3::_attr;
{
boost::iterator_range<char const*> range;
std::string str;
BOOST_TEST((test_attr("spirit_test_123", raw[alpha >> *(alnum | '_')], range)));
BOOST_TEST((std::string(range.begin(), range.end()) == "spirit_test_123"));
BOOST_TEST((test_attr(" spirit", raw[*alpha], range, space)));
BOOST_TEST((range.size() == 6));
}
{
std::string str;
BOOST_TEST((test_attr("spirit_test_123", raw[alpha >> *(alnum | '_')], str)));
BOOST_TEST((str == "spirit_test_123"));
}
{
boost::iterator_range<char const*> range;
BOOST_TEST((test("x", raw[alpha])));
BOOST_TEST((test_attr("x", raw[alpha], range)));
}
{
boost::iterator_range<char const*> range;
BOOST_TEST((test("x", raw[alpha][ ([&](auto& ctx){ range = _attr(ctx); }) ])));
BOOST_TEST(range.size() == 1 && *range.begin() == 'x');
}
return boost::report_errors();
}
int main()
{
namespace qi = boost::spirit::qi;
namespace phoenix = boost::phoenix;
using spirit_test::test_attr;
{
qi::rule<char const*, std::string()> r;
r %= (+qi::char_)[phoenix::bind(&f, qi::_1)];
std::string attr;
BOOST_TEST(test_attr("abcdef", r, attr));
BOOST_TEST(attr == "abcdef");
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
using boost::spirit::x3::ascii::space;
using boost::spirit::x3::ascii::space_type;
using boost::spirit::x3::ascii::char_;
using boost::spirit::x3::ascii::alpha;
using boost::spirit::x3::lexeme;
using boost::spirit::x3::skip;
using boost::spirit::x3::lit;
{
BOOST_TEST((test("a b c d", skip(space)[*char_])));
}
{ // test attribute
std::string s;
BOOST_TEST((test_attr("a b c d", skip(space)[*char_], s)));
BOOST_TEST(s == "abcd");
}
{ // reskip
BOOST_TEST((test("ab c d", lexeme[lit('a') >> 'b' >> skip[lit('c') >> 'd']], space)));
BOOST_TEST((test("abcd", lexeme[lit('a') >> 'b' >> skip[lit('c') >> 'd']], space)));
BOOST_TEST(!(test("a bcd", lexeme[lit('a') >> 'b' >> skip[lit('c') >> 'd']], space)));
BOOST_TEST((test("ab c d", lexeme[lexeme[lit('a') >> 'b' >> skip[lit('c') >> 'd']]], space)));
BOOST_TEST((test("abcd", lexeme[lexeme[lit('a') >> 'b' >> skip[lit('c') >> 'd']]], space)));
BOOST_TEST(!(test("a bcd", lexeme[lexeme[lit('a') >> 'b' >> skip[lit('c') >> 'd']]], space)));
}
//~ { // lazy skip
//~ using boost::phoenix::val;
//~ BOOST_TEST((test("a b c d", skip(val(space))[*char_])));
//~ }
return boost::report_errors();
}
int
main()
{
using spirit_test::test_attr;
namespace qi = boost::spirit::qi;
using qi::attr;
using qi::double_;
{
double d = 0.0;
BOOST_TEST(test_attr("", attr(1.0), d) && d == 1.0);
double d1 = 1.0;
BOOST_TEST(test_attr("", attr(d1), d) && d == 1.0);
std::pair<double, double> p;
BOOST_TEST(test_attr("1.0", double_ >> attr(1.0), p) &&
p.first == 1.0 && p.second == 1.0);
char c = '\0';
BOOST_TEST(test_attr("", attr('a'), c) && c == 'a');
std::string str;
BOOST_TEST(test_attr("", attr("test"), str) && str == "test");
}
{ // testing lazy constructs
using boost::phoenix::val;
using boost::phoenix::ref;
double d = 0.0;
BOOST_TEST(test_attr("", attr(val(1.0)), d) && d == 1.0);
double d1 = 2.0;
BOOST_TEST(test_attr("", attr(ref(d1)), d) && d == 2.0);
}
{
std::string s;
BOOST_TEST(test_attr("s", "s" >> qi::attr(std::string("123")), s) &&
s == "123");
}
return boost::report_errors();
}
int main()
{
using spirit_test::test_attr;
using spirit_test::test;
using spirit_test::binary_test;
using spirit_test::binary_test_attr;
using boost::spirit::qi::byte_;
using boost::spirit::qi::word;
using boost::spirit::qi::dword;
using boost::spirit::qi::big_word;
using boost::spirit::qi::big_dword;
using boost::spirit::qi::little_word;
using boost::spirit::qi::little_dword;
#ifdef BOOST_HAS_LONG_LONG
using boost::spirit::qi::qword;
using boost::spirit::qi::big_qword;
using boost::spirit::qi::little_qword;
#endif
using boost::spirit::qi::bin_float;
using boost::spirit::qi::big_bin_float;
using boost::spirit::qi::little_bin_float;
using boost::spirit::qi::bin_double;
using boost::spirit::qi::big_bin_double;
using boost::spirit::qi::little_bin_double;
boost::uint8_t uc;
boost::uint16_t us;
boost::uint32_t ui;
#ifdef BOOST_HAS_LONG_LONG
boost::uint64_t ul;
#endif
float f;
double d;
{ // test native endian binaries
#ifdef BOOST_LITTLE_ENDIAN
BOOST_TEST(test_attr("\x01", byte_, uc) && uc == 0x01);
BOOST_TEST(test_attr("\x01\x02", word, us) && us == 0x0201);
BOOST_TEST(test_attr("\x01\x02\x03\x04", dword, ui) && ui == 0x04030201);
#ifdef BOOST_HAS_LONG_LONG
BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", qword, ul) &&
ul == 0x0807060504030201LL);
#endif
BOOST_TEST(binary_test_attr("\x00\x00\x80\x3f", 4, bin_float, f) &&
f == 1.0f);
BOOST_TEST(binary_test_attr("\x00\x00\x00\x00\x00\x00\xf0\x3f",
8, bin_double, d) && f == 1.0);
#else
BOOST_TEST(test_attr("\x01", byte_, uc) && uc == 0x01);
BOOST_TEST(test_attr("\x01\x02", word, us) && us == 0x0102);
BOOST_TEST(test_attr("\x01\x02\x03\x04", dword, ui) && ui == 0x01020304);
#ifdef BOOST_HAS_LONG_LONG
BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", qword, ul) &&
ul == 0x0102030405060708LL);
#endif
BOOST_TEST(binary_test_attr("\x3f\x80\x00\x00", 4, bin_float, f) &&
f == 1.0f);
BOOST_TEST(binary_test_attr("\x3f\xf0\x00\x00\x00\x00\x00\x00",
8, bin_double, d) && f == 1.0);
#endif
}
{ // test native endian binaries
#ifdef BOOST_LITTLE_ENDIAN
BOOST_TEST(test("\x01", byte_(0x01)));
BOOST_TEST(test("\x01\x02", word(0x0201)));
BOOST_TEST(test("\x01\x02\x03\x04", dword(0x04030201)));
#ifdef BOOST_HAS_LONG_LONG
BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
qword(0x0807060504030201LL)));
#endif
BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, bin_float(1.0f)));
BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8,
bin_double(1.0)));
#else
BOOST_TEST(test("\x01", byte_(0x01)));
BOOST_TEST(test("\x01\x02", word(0x0102)));
BOOST_TEST(test("\x01\x02\x03\x04", dword(0x01020304)));
#ifdef BOOST_HAS_LONG_LONG
BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
qword(0x0102030405060708LL)));
#endif
BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, bin_float(1.0f)));
BOOST_TEST(binary_test("\x3f\x80\x00\x00\x00\x00\x00\x00", 8,
bin_double(1.0)));
#endif
}
{ // test big endian binaries
BOOST_TEST(test_attr("\x01\x02", big_word, us) && us == 0x0102);
BOOST_TEST(test_attr("\x01\x02\x03\x04", big_dword, ui) && ui == 0x01020304);
#ifdef BOOST_HAS_LONG_LONG
BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", big_qword, ul)
&& ul == 0x0102030405060708LL);
#endif
BOOST_TEST(binary_test_attr("\x3f\x80\x00\x00", 4, big_bin_float, f) &&
f == 1.0f);
BOOST_TEST(binary_test_attr("\x3f\xf0\x00\x00\x00\x00\x00\x00",
8, big_bin_double, d) && f == 1.0);
}
{
BOOST_TEST(test("\x01\x02", big_word(0x0102)));
BOOST_TEST(test("\x01\x02\x03\x04", big_dword(0x01020304)));
#ifdef BOOST_HAS_LONG_LONG
BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
big_qword(0x0102030405060708LL)));
#endif
BOOST_TEST(binary_test("\x3f\x80\x00\x00", 4, big_bin_float(1.0f)));
BOOST_TEST(binary_test("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8,
big_bin_double(1.0)));
}
{ // test little endian binaries
BOOST_TEST(test_attr("\x01\x02", little_word, us) && us == 0x0201);
BOOST_TEST(test_attr("\x01\x02\x03\x04", little_dword, ui) && ui == 0x04030201);
#ifdef BOOST_HAS_LONG_LONG
BOOST_TEST(test_attr("\x01\x02\x03\x04\x05\x06\x07\x08", little_qword, ul)
&& ul == 0x0807060504030201LL);
#endif
BOOST_TEST(binary_test_attr("\x00\x00\x80\x3f", 4,
little_bin_float, f) && f == 1.0f);
BOOST_TEST(binary_test_attr("\x00\x00\x00\x00\x00\x00\xf0\x3f",
8, little_bin_double, d) && f == 1.0);
}
{
BOOST_TEST(test("\x01\x02", little_word(0x0201)));
BOOST_TEST(test("\x01\x02\x03\x04", little_dword(0x04030201)));
#ifdef BOOST_HAS_LONG_LONG
BOOST_TEST(test("\x01\x02\x03\x04\x05\x06\x07\x08",
little_qword(0x0807060504030201LL)));
#endif
BOOST_TEST(binary_test("\x00\x00\x80\x3f", 4, little_bin_float(1.0f)));
BOOST_TEST(binary_test("\x00\x00\x00\x00\x00\x00\xf0\x3f", 8,
little_bin_double(1.0)));
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
{
using namespace boost::spirit::ascii;
BOOST_TEST(test("1", alnum));
BOOST_TEST(!test(" ", alnum));
BOOST_TEST(!test("1", alpha));
BOOST_TEST(test("x", alpha));
BOOST_TEST(test(" ", blank));
BOOST_TEST(!test("x", blank));
BOOST_TEST(test("1", digit));
BOOST_TEST(!test("x", digit));
BOOST_TEST(test("a", lower));
BOOST_TEST(!test("A", lower));
BOOST_TEST(test("!", punct));
BOOST_TEST(!test("x", punct));
BOOST_TEST(test(" ", space));
BOOST_TEST(test("\n", space));
BOOST_TEST(test("\r", space));
BOOST_TEST(test("\t", space));
BOOST_TEST(test("A", upper));
BOOST_TEST(!test("a", upper));
BOOST_TEST(test("A", xdigit));
BOOST_TEST(test("0", xdigit));
BOOST_TEST(test("f", xdigit));
BOOST_TEST(!test("g", xdigit));
}
{
using namespace boost::spirit::iso8859_1;
BOOST_TEST(test("1", alnum));
BOOST_TEST(!test(" ", alnum));
BOOST_TEST(!test("1", alpha));
BOOST_TEST(test("x", alpha));
BOOST_TEST(test(" ", blank));
BOOST_TEST(!test("x", blank));
BOOST_TEST(test("1", digit));
BOOST_TEST(!test("x", digit));
BOOST_TEST(test("a", lower));
BOOST_TEST(!test("A", lower));
BOOST_TEST(test("!", punct));
BOOST_TEST(!test("x", punct));
BOOST_TEST(test(" ", space));
BOOST_TEST(test("\n", space));
BOOST_TEST(test("\r", space));
BOOST_TEST(test("\t", space));
BOOST_TEST(test("A", upper));
BOOST_TEST(!test("a", upper));
BOOST_TEST(test("A", xdigit));
BOOST_TEST(test("0", xdigit));
BOOST_TEST(test("f", xdigit));
BOOST_TEST(!test("g", xdigit));
BOOST_TEST(test("é", alpha));
BOOST_TEST(test("é", lower));
BOOST_TEST(!test("é", upper));
}
{
using namespace boost::spirit::standard;
BOOST_TEST(test("1", alnum));
BOOST_TEST(!test(" ", alnum));
BOOST_TEST(!test("1", alpha));
BOOST_TEST(test("x", alpha));
BOOST_TEST(test(" ", blank));
BOOST_TEST(!test("x", blank));
BOOST_TEST(test("1", digit));
BOOST_TEST(!test("x", digit));
BOOST_TEST(test("a", lower));
BOOST_TEST(!test("A", lower));
BOOST_TEST(test("!", punct));
BOOST_TEST(!test("x", punct));
BOOST_TEST(test(" ", space));
BOOST_TEST(test("\n", space));
BOOST_TEST(test("\r", space));
BOOST_TEST(test("\t", space));
BOOST_TEST(test("A", upper));
BOOST_TEST(!test("a", upper));
BOOST_TEST(test("A", xdigit));
BOOST_TEST(test("0", xdigit));
BOOST_TEST(test("f", xdigit));
BOOST_TEST(!test("g", xdigit));
}
{
using namespace boost::spirit::standard_wide;
BOOST_TEST(test(L"1", alnum));
BOOST_TEST(!test(L" ", alnum));
BOOST_TEST(!test(L"1", alpha));
BOOST_TEST(test(L"x", alpha));
BOOST_TEST(test(L" ", blank));
BOOST_TEST(!test(L"x", blank));
BOOST_TEST(test(L"1", digit));
BOOST_TEST(!test(L"x", digit));
BOOST_TEST(test(L"a", lower));
BOOST_TEST(!test(L"A", lower));
BOOST_TEST(test(L"!", punct));
BOOST_TEST(!test(L"x", punct));
BOOST_TEST(test(L" ", space));
BOOST_TEST(test(L"\n", space));
BOOST_TEST(test(L"\r", space));
BOOST_TEST(test(L"\t", space));
BOOST_TEST(test(L"A", upper));
BOOST_TEST(!test(L"a", upper));
BOOST_TEST(test(L"A", xdigit));
BOOST_TEST(test(L"0", xdigit));
BOOST_TEST(test(L"f", xdigit));
BOOST_TEST(!test(L"g", xdigit));
}
{ // test attribute extraction
using boost::spirit::qi::domain;
using boost::spirit::traits::attribute_of;
using boost::spirit::iso8859_1::alpha;
using boost::spirit::iso8859_1::alpha_type;
BOOST_STATIC_ASSERT((
boost::is_same<
attribute_of<domain, alpha_type, char const*, int>::type
, unsigned char>::value));
int attr = 0;
BOOST_TEST(test_attr("a", alpha, attr));
BOOST_TEST(attr == 'a');
}
{ // test attribute extraction
using boost::spirit::iso8859_1::alpha;
using boost::spirit::iso8859_1::space;
char attr = 0;
BOOST_TEST(test_attr(" a", alpha, attr, space));
BOOST_TEST(attr == 'a');
}
{ // test action
using namespace boost::phoenix;
using namespace boost::spirit::ascii;
using boost::spirit::arg_names::_1;
char ch;
BOOST_TEST(test("x", alnum[ref(ch) = _1]));
BOOST_TEST(ch == 'x');
BOOST_TEST(test(" A", alnum[ref(ch) = _1], space));
BOOST_TEST(ch == 'A');
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test_attr;
using spirit_test::test;
using namespace boost::spirit::ascii;
using namespace boost::spirit::qi::labels;
using boost::spirit::qi::locals;
using boost::spirit::qi::rule;
using boost::spirit::qi::int_;
using boost::spirit::qi::uint_;
using boost::spirit::qi::fail;
using boost::spirit::qi::on_error;
using boost::spirit::qi::debug;
using boost::spirit::qi::lit;
namespace phx = boost::phoenix;
{ // synth attribute value-init
std::string s;
rule<char const*, char()> r;
r = alpha[_val += _1];
BOOST_TEST(test_attr("abcdef", +r, s));
BOOST_TEST(s == "abcdef");
}
{ // auto rules aliasing tests
char ch = '\0';
rule<char const*, char()> a, b;
a %= b;
b %= alpha;
BOOST_TEST(test("x", a[phx::ref(ch) = _1]));
BOOST_TEST(ch == 'x');
ch = '\0';
BOOST_TEST(test_attr("z", a, ch)); // attribute is given.
BOOST_TEST(ch == 'z');
a = b; // test deduced auto rule behavior
b = alpha;
ch = '\0';
BOOST_TEST(test("x", a[phx::ref(ch) = _1]));
BOOST_TEST(ch == 'x');
ch = '\0';
BOOST_TEST(test_attr("z", a, ch)); // attribute is given.
BOOST_TEST(ch == 'z');
}
{ // context (w/arg) tests
char ch;
rule<char const*, char(int)> a; // 1 arg
a = alpha[_val = _1 + _r1];
BOOST_TEST(test("x", a(phx::val(1))[phx::ref(ch) = _1]));
BOOST_TEST(ch == 'x' + 1);
BOOST_TEST(test_attr("a", a(1), ch)); // allow scalars as rule args too.
BOOST_TEST(ch == 'a' + 1);
rule<char const*, char(int, int)> b; // 2 args
b = alpha[_val = _1 + _r1 + _r2];
BOOST_TEST(test_attr("a", b(1, 2), ch));
BOOST_TEST(ch == 'a' + 1 + 2);
}
{ // context (w/ reference arg) tests
char ch;
rule<char const*, void(char&)> a; // 1 arg (reference)
a = alpha[_r1 = _1];
BOOST_TEST(test("x", a(phx::ref(ch))));
BOOST_TEST(ch == 'x');
}
{ // context (w/locals) tests
rule<char const*, locals<char> > a; // 1 local
a = alpha[_a = _1] >> char_(_a);
BOOST_TEST(test("aa", a));
BOOST_TEST(!test("ax", a));
}
{ // context (w/args and locals) tests
rule<char const*, void(int), locals<char> > a; // 1 arg + 1 local
a = alpha[_a = _1 + _r1] >> char_(_a);
BOOST_TEST(test("ab", a(phx::val(1))));
BOOST_TEST(test("xy", a(phx::val(1))));
BOOST_TEST(!test("ax", a(phx::val(1))));
}
{ // void() has unused type (void == unused_type)
std::pair<int, char> attr;
rule<char const*, void()> r;
r = char_;
BOOST_TEST(test_attr("123ax", int_ >> char_ >> r, attr));
BOOST_TEST(attr.first == 123);
BOOST_TEST(attr.second == 'a');
}
{ // bug: test that injected attributes are ok
rule<char const*, char(int) > r;
// problem code:
r = char_(_r1)[_val = _1];
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
using boost::spirit::qi::symbols;
using boost::spirit::qi::rule;
using boost::spirit::qi::lazy;
using boost::spirit::qi::_r1;
{ // basics
symbols<char, int> sym;
sym.add
("Joel")
("Ruby")
("Tenji")
("Tutit")
("Kim")
("Joey")
;
boost::mpl::true_ f = boost::mpl::bool_<boost::spirit::traits::is_parser<symbols<char, int> >::value>();
// silence stupid compiler warnings
// i.e. MSVC warning C4189: 'f' : local variable is initialized but not referenced
BOOST_TEST((f.value));
BOOST_TEST((test("Joel", sym)));
BOOST_TEST((test("Ruby", sym)));
BOOST_TEST((test("Tenji", sym)));
BOOST_TEST((test("Tutit", sym)));
BOOST_TEST((test("Kim", sym)));
BOOST_TEST((test("Joey", sym)));
BOOST_TEST((!test("XXX", sym)));
// test copy
symbols<char, int> sym2;
sym2 = sym;
BOOST_TEST((test("Joel", sym2)));
BOOST_TEST((test("Ruby", sym2)));
BOOST_TEST((test("Tenji", sym2)));
BOOST_TEST((test("Tutit", sym2)));
BOOST_TEST((test("Kim", sym2)));
BOOST_TEST((test("Joey", sym2)));
BOOST_TEST((!test("XXX", sym2)));
// make sure it plays well with other parsers
BOOST_TEST((test("Joelyo", sym >> "yo")));
sym.remove
("Joel")
("Ruby")
;
BOOST_TEST((!test("Joel", sym)));
BOOST_TEST((!test("Ruby", sym)));
}
{ // comma syntax
symbols<char, int> sym;
sym += "Joel", "Ruby", "Tenji", "Tutit", "Kim", "Joey";
BOOST_TEST((test("Joel", sym)));
BOOST_TEST((test("Ruby", sym)));
BOOST_TEST((test("Tenji", sym)));
BOOST_TEST((test("Tutit", sym)));
BOOST_TEST((test("Kim", sym)));
BOOST_TEST((test("Joey", sym)));
BOOST_TEST((!test("XXX", sym)));
sym -= "Joel", "Ruby";
BOOST_TEST((!test("Joel", sym)));
BOOST_TEST((!test("Ruby", sym)));
}
{ // no-case handling
using namespace boost::spirit::ascii;
symbols<char, int> sym;
// NOTE: make sure all entries are in lower-case!!!
sym = "joel", "ruby", "tenji", "tutit", "kim", "joey";
BOOST_TEST((test("joel", no_case[sym])));
BOOST_TEST((test("ruby", no_case[sym])));
BOOST_TEST((test("tenji", no_case[sym])));
BOOST_TEST((test("tutit", no_case[sym])));
BOOST_TEST((test("kim", no_case[sym])));
BOOST_TEST((test("joey", no_case[sym])));
BOOST_TEST((test("JOEL", no_case[sym])));
BOOST_TEST((test("RUBY", no_case[sym])));
BOOST_TEST((test("TENJI", no_case[sym])));
BOOST_TEST((test("TUTIT", no_case[sym])));
BOOST_TEST((test("KIM", no_case[sym])));
BOOST_TEST((test("JOEY", no_case[sym])));
// make sure it plays well with other parsers
BOOST_TEST((test("Joelyo", no_case[sym] >> "yo")));
}
{ // attributes
symbols<char, int> sym;
sym.add
("Joel", 1)
("Ruby", 2)
("Tenji", 3)
("Tutit", 4)
("Kim", 5)
("Joey", 6)
;
int i;
BOOST_TEST((test_attr("Joel", sym, i)));
BOOST_TEST(i == 1);
BOOST_TEST((test_attr("Ruby", sym, i)));
BOOST_TEST(i == 2);
BOOST_TEST((test_attr("Tenji", sym, i)));
BOOST_TEST(i == 3);
BOOST_TEST((test_attr("Tutit", sym, i)));
BOOST_TEST(i == 4);
BOOST_TEST((test_attr("Kim", sym, i)));
BOOST_TEST(i == 5);
BOOST_TEST((test_attr("Joey", sym, i)));
BOOST_TEST(i == 6);
BOOST_TEST((!test_attr("XXX", sym, i)));
// double add:
sym.add("Joel", 265);
BOOST_TEST((test_attr("Joel", sym, i)));
BOOST_TEST(i == 1);
}
{ // actions
namespace phx = boost::phoenix;
using boost::spirit::_1;
symbols<char, int> sym;
sym.add
("Joel", 1)
("Ruby", 2)
("Tenji", 3)
("Tutit", 4)
("Kim", 5)
("Joey", 6)
;
int i;
BOOST_TEST((test("Joel", sym[phx::ref(i) = _1])));
BOOST_TEST(i == 1);
BOOST_TEST((test("Ruby", sym[phx::ref(i) = _1])));
BOOST_TEST(i == 2);
BOOST_TEST((test("Tenji", sym[phx::ref(i) = _1])));
BOOST_TEST(i == 3);
BOOST_TEST((test("Tutit", sym[phx::ref(i) = _1])));
BOOST_TEST(i == 4);
BOOST_TEST((test("Kim", sym[phx::ref(i) = _1])));
BOOST_TEST(i == 5);
BOOST_TEST((test("Joey", sym[phx::ref(i) = _1])));
BOOST_TEST(i == 6);
BOOST_TEST((!test("XXX", sym[phx::ref(i) = _1])));
}
{ // construction from symbol array
char const* syms[] = {"Joel","Ruby","Tenji","Tutit","Kim","Joey"};
symbols<char, int> sym(syms);
BOOST_TEST((test("Joel", sym)));
BOOST_TEST((test("Ruby", sym)));
BOOST_TEST((test("Tenji", sym)));
BOOST_TEST((test("Tutit", sym)));
BOOST_TEST((test("Kim", sym)));
BOOST_TEST((test("Joey", sym)));
BOOST_TEST((!test("XXX", sym)));
}
{ // construction from 2 arrays
char const* syms[] = {"Joel","Ruby","Tenji","Tutit","Kim","Joey"};
int data[] = {1,2,3,4,5,6};
symbols<char, int> sym(syms, data);
int i;
BOOST_TEST((test_attr("Joel", sym, i)));
BOOST_TEST(i == 1);
BOOST_TEST((test_attr("Ruby", sym, i)));
BOOST_TEST(i == 2);
BOOST_TEST((test_attr("Tenji", sym, i)));
BOOST_TEST(i == 3);
BOOST_TEST((test_attr("Tutit", sym, i)));
BOOST_TEST(i == 4);
BOOST_TEST((test_attr("Kim", sym, i)));
BOOST_TEST(i == 5);
BOOST_TEST((test_attr("Joey", sym, i)));
BOOST_TEST(i == 6);
BOOST_TEST((!test_attr("XXX", sym, i)));
}
{ // allow std::string and other string types
symbols<> sym;
// const and non-const std::string
std::string a("abc");
std::string const b("def");
sym += a;
sym += b;
BOOST_TEST((test("abc", sym)));
BOOST_TEST((test("def", sym)));
sym = a;
BOOST_TEST((test("abc", sym)));
BOOST_TEST((!test("def", sym)));
// non-const C-style string
char arr[2]; arr[0] = 'a'; arr[1] = '\0';
sym = arr;
BOOST_TEST((test("a", sym)));
BOOST_TEST((!test("b", sym)));
// const and non-const custom string type
custom_string_c c('x');
custom_string_c const cc('y');
sym = c, cc;
BOOST_TEST((test("x", sym)));
BOOST_TEST((test("y", sym)));
BOOST_TEST((!test("z", sym)));
}
{
namespace phx = boost::phoenix;
symbols<char, int> sym;
sym.add
("a", 1)
("b", 2)
;
rule<char const*, int(symbols<char, int>&)> r;
r %= lazy(_r1);
int i = 0;
BOOST_TEST(test_attr("a", r(phx::ref(sym)), i));
BOOST_TEST(i == 1);
BOOST_TEST(test_attr("b", r(phx::ref(sym)), i));
BOOST_TEST(i == 2);
BOOST_TEST(!test("c", r(phx::ref(sym))));
}
{ // find
symbols<char, int> sym;
sym.add("a", 1)("b", 2);
BOOST_TEST(!sym.find("c"));
BOOST_TEST(sym.find("a") && *sym.find("a") == 1);
BOOST_TEST(sym.find("b") && *sym.find("b") == 2);
BOOST_TEST(sym.at("a") == 1);
BOOST_TEST(sym.at("b") == 2);
BOOST_TEST(sym.at("c") == 0);
BOOST_TEST(sym.find("a") && *sym.find("a") == 1);
BOOST_TEST(sym.find("b") && *sym.find("b") == 2);
BOOST_TEST(sym.find("c") && *sym.find("c") == 0);
symbols<char, int> const_sym(sym);
BOOST_TEST(const_sym.find("a") && *const_sym.find("a") == 1);
BOOST_TEST(const_sym.find("b") && *const_sym.find("b") == 2);
BOOST_TEST(const_sym.find("c") && *const_sym.find("c") == 0);
BOOST_TEST(!const_sym.find("d"));
}
return boost::report_errors();
}
int main()
{
{
BOOST_TEST((!traits::meta_create_exists<qi::domain, my_type>::value));
}
{
// test primitive types
bool b = false;
BOOST_TEST(test_create_parser("true", b) && b == true);
int i = 0;
BOOST_TEST(test_create_parser("1", i) && i == 1);
double d = 0;
BOOST_TEST(test_create_parser("1.1", d) && d == 1.1);
char c = '\0';
BOOST_TEST(test_create_parser("a", c) && c == 'a');
wchar_t wc = L'\0';
BOOST_TEST(test_create_parser(L"a", wc) && wc == L'a');
// test containers
std::vector<int> v;
BOOST_TEST(test_create_parser("0 1 2", v) && v.size() == 3 &&
v[0] == 0 && v[1] == 1 && v[2] == 2);
std::list<int> l;
BOOST_TEST(test_create_parser("0 1 2", l) && l.size() == 3 &&
*l.begin() == 0 && *(++l.begin()) == 1 && *(++ ++l.begin()) == 2);
// test optional
boost::optional<int> o;
BOOST_TEST(test_create_parser("", o) && !o);
BOOST_TEST(test_create_parser("1", o) && !!o && boost::get<int>(o) == 1);
// test alternative
boost::variant<double, bool, std::vector<char> > vv;
BOOST_TEST(test_create_parser("true", vv) && vv.which() == 1 &&
boost::get<bool>(vv) == true);
BOOST_TEST(test_create_parser("1.0", vv) && vv.which() == 0 &&
boost::get<double>(vv) == 1.0);
BOOST_TEST(test_create_parser("some_string", vv) && vv.which() == 2 &&
boost::equals(boost::get<std::vector<char> >(vv), "some_string"));
// test fusion sequence
std::pair<int, double> p;
BOOST_TEST(test_create_parser("1 2.0", p) &&
p.first == 1 && p.second == 2.0);
}
{
// test containers
std::vector<int> v;
BOOST_TEST(test_create_parser_auto("0 1 2", v) && v.size() == 3 &&
v[0] == 0 && v[1] == 1 && v[2] == 2);
std::list<int> l;
BOOST_TEST(test_create_parser_auto("0 1 2", l) && l.size() == 3 &&
*l.begin() == 0 && *(++l.begin()) == 1 && *(++ ++l.begin()) == 2);
// test optional
boost::optional<int> o;
BOOST_TEST(test_create_parser_auto("", o) && !o);
BOOST_TEST(test_create_parser_auto("1", o) && !!o && boost::get<int>(o) == 1);
// test alternative
boost::variant<double, bool, std::vector<char> > vv;
BOOST_TEST(test_create_parser_auto("true", vv) && vv.which() == 1 &&
boost::get<bool>(vv) == true);
BOOST_TEST(test_create_parser_auto("1.0", vv) && vv.which() == 0 &&
boost::get<double>(vv) == 1.0);
BOOST_TEST(test_create_parser_auto("some_string", vv) && vv.which() == 2 &&
boost::equals(boost::get<std::vector<char> >(vv), "some_string"));
// test fusion sequence
std::pair<int, double> p;
BOOST_TEST(test_create_parser_auto("1 2.0", p) &&
p.first == 1 && p.second == 2.0);
}
{
using qi::auto_;
using qi::no_case;
using spirit_test::test_attr;
// test primitive types
bool b = false;
BOOST_TEST(test_attr("true", auto_, b) && b == true);
int i = 0;
BOOST_TEST(test_attr("1", auto_, i) && i == 1);
double d = 0;
BOOST_TEST(test_attr("1.1", auto_, d) && d == 1.1);
char c = '\0';
BOOST_TEST(test_attr("a", auto_, c) && c == 'a');
wchar_t wc = L'\0';
BOOST_TEST(test_attr(L"a", auto_, wc) && wc == L'a');
b = false;
BOOST_TEST(test_attr("TRUE", no_case[auto_], b) && b == true);
// test containers
std::vector<int> v;
BOOST_TEST(test_attr("0 1 2", auto_, v, qi::space) && v.size() == 3 &&
v[0] == 0 && v[1] == 1 && v[2] == 2);
v.clear();
BOOST_TEST(test_attr("0,1,2", auto_ % ',', v) && v.size() == 3 &&
v[0] == 0 && v[1] == 1 && v[2] == 2);
std::list<int> l;
BOOST_TEST(test_attr("0 1 2", auto_, l, qi::space) && l.size() == 3 &&
*l.begin() == 0 && *(++l.begin()) == 1 && *(++ ++l.begin()) == 2);
l.clear();
BOOST_TEST(test_attr("0,1,2", auto_ % ',', l) && l.size() == 3 &&
*l.begin() == 0 && *(++l.begin()) == 1 && *(++ ++l.begin()) == 2);
// test optional
boost::optional<int> o;
BOOST_TEST(test_attr("", auto_, o) && !o);
BOOST_TEST(test_attr("1", auto_, o) && !!o && boost::get<int>(o) == 1);
// test alternative
boost::variant<double, bool, std::vector<char> > vv;
BOOST_TEST(test_attr("true", auto_, vv) && vv.which() == 1 &&
boost::get<bool>(vv) == true);
BOOST_TEST(test_attr("1.0", auto_, vv) && vv.which() == 0 &&
boost::get<double>(vv) == 1.0);
BOOST_TEST(test_create_parser("some_string", vv) && vv.which() == 2 &&
boost::equals(boost::get<std::vector<char> >(vv), "some_string"));
// test fusion sequence
std::pair<int, double> p;
BOOST_TEST(test_attr("1 2.0", auto_, p, qi::space) &&
p.first == 1 && p.second == 2.0);
}
{
// test primitive types
BOOST_TEST(test_rule("true", true));
BOOST_TEST(test_rule("1", 1));
BOOST_TEST(test_rule("1.1", 1.1));
// test containers
std::vector<int> v;
v.push_back(0);
v.push_back(1);
v.push_back(2);
BOOST_TEST(test_rule("0 1 2", v, qi::space));
std::list<int> l;
l.push_back(0);
l.push_back(1);
l.push_back(2);
BOOST_TEST(test_rule("0 1 2", l, qi::space));
// test optional
boost::optional<int> o;
BOOST_TEST(test_rule("", o));
o = 1;
BOOST_TEST(test_rule("1", o));
// test alternative
// boost::variant<int, double, float, std::string> vv;
// vv = 1;
// BOOST_TEST(test_rule("1", vv));
// vv = 1.0;
// BOOST_TEST(test_rule("1.0", vv));
// vv = 1.0f;
// BOOST_TEST(test_rule("1.0", vv));
// vv = "some string";
// BOOST_TEST(test_rule("some string", vv));
// test fusion sequence
std::pair<int, double> p (1, 2.0);
BOOST_TEST(test_rule("1 2.0", p, qi::space));
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
///////////////////////////////////////////////////////////////////////////
// unsigned tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::x3::uint_;
unsigned u;
BOOST_TEST(test("123456", uint_));
BOOST_TEST(test_attr("123456", uint_, u));
BOOST_TEST(u == 123456);
BOOST_TEST(test(max_unsigned, uint_));
BOOST_TEST(test_attr(max_unsigned, uint_, u));
BOOST_TEST(u == UINT_MAX);
BOOST_TEST(!test(unsigned_overflow, uint_));
BOOST_TEST(!test_attr(unsigned_overflow, uint_, u));
}
///////////////////////////////////////////////////////////////////////////
// binary tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::x3::bin;
unsigned u;
BOOST_TEST(test("11111110", bin));
BOOST_TEST(test_attr("11111110", bin, u));
BOOST_TEST(u == 0xFE);
BOOST_TEST(test(max_binary, bin));
BOOST_TEST(test_attr(max_binary, bin, u));
BOOST_TEST(u == UINT_MAX);
BOOST_TEST(!test(binary_overflow, bin));
BOOST_TEST(!test_attr(binary_overflow, bin, u));
}
///////////////////////////////////////////////////////////////////////////
// octal tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::x3::oct;
unsigned u;
BOOST_TEST(test("12545674515", oct));
BOOST_TEST(test_attr("12545674515", oct, u));
BOOST_TEST(u == 012545674515);
BOOST_TEST(test(max_octal, oct));
BOOST_TEST(test_attr(max_octal, oct, u));
BOOST_TEST(u == UINT_MAX);
BOOST_TEST(!test(octal_overflow, oct));
BOOST_TEST(!test_attr(octal_overflow, oct, u));
}
///////////////////////////////////////////////////////////////////////////
// hex tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::x3::hex;
unsigned u;
BOOST_TEST(test("95BC8DF", hex));
BOOST_TEST(test_attr("95BC8DF", hex, u));
BOOST_TEST(u == 0x95BC8DF);
BOOST_TEST(test("abcdef12", hex));
BOOST_TEST(test_attr("abcdef12", hex, u));
BOOST_TEST(u == 0xabcdef12);
BOOST_TEST(test(max_hex, hex));
BOOST_TEST(test_attr(max_hex, hex, u));
BOOST_TEST(u == UINT_MAX);
BOOST_TEST(!test(hex_overflow, hex));
BOOST_TEST(!test_attr(hex_overflow, hex, u));
}
///////////////////////////////////////////////////////////////////////////
// limited fieldwidth
///////////////////////////////////////////////////////////////////////////
{
unsigned u;
using boost::spirit::x3::uint_parser;
uint_parser<unsigned, 10, 1, 3> uint3;
BOOST_TEST(test("123456", uint3, false));
BOOST_TEST(test_attr("123456", uint3, u, false));
BOOST_TEST(u == 123);
uint_parser<unsigned, 10, 2, 4> uint4;
BOOST_TEST(test("123456", uint4, false));
BOOST_TEST(test_attr("123456", uint4, u, false));
BOOST_TEST(u == 1234);
char const * first = "0000000";
char const * last = first + std::strlen(first);
uint_parser<unsigned, 10, 4, 4> uint_exact4;
BOOST_TEST(boost::spirit::x3::parse(first, last, uint_exact4, u)
&& first != last && (last-first == 3) && u == 0);
first = "0001400";
last = first + std::strlen(first);
BOOST_TEST(boost::spirit::x3::parse(first, last, uint_exact4, u)
&& first != last && (last-first == 3) && u == 1);
BOOST_TEST(!test("1", uint4));
BOOST_TEST(!test_attr("1", uint4, u));
BOOST_TEST(test_attr("014567", uint4, u, false) && u == 145);
}
///////////////////////////////////////////////////////////////////////////
// action tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::x3::_attr;
using boost::spirit::x3::uint_;
using boost::spirit::x3::ascii::space;
int n;
auto f = [&](auto& ctx){ n = _attr(ctx); };
BOOST_TEST(test("123", uint_[f]));
BOOST_TEST(n == 123);
BOOST_TEST(test(" 456", uint_[f], space));
BOOST_TEST(n == 456);
}
///////////////////////////////////////////////////////////////////////////
// Check overflow is parse error
///////////////////////////////////////////////////////////////////////////
{
boost::spirit::x3::uint_parser<boost::uint8_t> uint8_;
boost::uint8_t u8;
BOOST_TEST(!test_attr("999", uint8_, u8));
BOOST_TEST(!test_attr("256", uint8_, u8));
BOOST_TEST(test_attr("255", uint8_, u8));
boost::spirit::x3::uint_parser<boost::uint16_t> uint16_;
boost::uint16_t u16;
BOOST_TEST(!test_attr("99999", uint16_, u16));
BOOST_TEST(!test_attr("65536", uint16_, u16));
BOOST_TEST(test_attr("65535", uint16_, u16));
boost::spirit::x3::uint_parser<boost::uint32_t> uint32_;
boost::uint32_t u32;
BOOST_TEST(!test_attr("9999999999", uint32_, u32));
BOOST_TEST(!test_attr("4294967296", uint32_, u32));
BOOST_TEST(test_attr("4294967295", uint32_, u32));
}
///////////////////////////////////////////////////////////////////////////
// custom uint tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::x3::uint_;
using boost::spirit::x3::uint_parser;
custom_uint u;
BOOST_TEST(test_attr("123456", uint_, u));
uint_parser<custom_uint, 10, 1, 2> uint2;
BOOST_TEST(test_attr("12", uint2, u));
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
using boost::spirit::x3::char_;
using boost::spirit::x3::alpha;
using boost::spirit::x3::upper;
using boost::spirit::x3::space;
using boost::spirit::x3::digit;
//~ using boost::spirit::x3::no_case;
using boost::spirit::x3::int_;
using boost::spirit::x3::omit;
using boost::spirit::x3::lit;
//~ using boost::spirit::x3::_1;
using boost::spirit::x3::lexeme;
{
BOOST_TEST(test("aaaaaaaa", +char_));
BOOST_TEST(test("a", +char_));
BOOST_TEST(!test("", +char_));
BOOST_TEST(test("aaaaaaaa", +alpha));
BOOST_TEST(!test("aaaaaaaa", +upper));
}
{
BOOST_TEST(test(" a a aaa aa", +char_, space));
BOOST_TEST(test("12345 678 9 ", +digit, space));
}
//~ {
//~ BOOST_TEST(test("aBcdeFGH", no_case[+char_]));
//~ BOOST_TEST(test("a B cde FGH ", no_case[+char_], space));
//~ }
{
std::vector<int> v;
BOOST_TEST(test_attr("123 456 789 10", +int_, v, space) && 4 == v.size() &&
v[0] == 123 && v[1] == 456 && v[2] == 789 && v[3] == 10);
}
{
std::vector<std::string> v;
BOOST_TEST(test_attr("a b c d", +lexeme[+alpha], v, space) && 4 == v.size() &&
v[0] == "a" && v[1] == "b" && v[2] == "c" && v[3] == "d");
}
{
BOOST_TEST(test("Kim Kim Kim", +lit("Kim"), space));
}
// $$$ Fixme $$$
/*{
// The following 2 tests show that omit does not inhibit explicit attributes
std::string s;
BOOST_TEST(test_attr("bbbb", omit[+char_('b')], s) && s == "bbbb");
s.clear();
BOOST_TEST(test_attr("b b b b ", omit[+char_('b')], s, space) && s == "bbbb");
}*/
{ // actions
std::string v;
auto f = [&](auto& ctx){ v = _attr(ctx); };
BOOST_TEST(test("bbbb", (+char_)[f]) && 4 == v.size() &&
v[0] == 'b' && v[1] == 'b' && v[2] == 'b' && v[3] == 'b');
}
{ // more actions
std::vector<int> v;
auto f = [&](auto& ctx){ v = _attr(ctx); };
BOOST_TEST(test("1 2 3", (+int_)[f], space) && 3 == v.size() &&
v[0] == 1 && v[1] == 2 && v[2] == 3);
}
{ // attribute customization
x_attr x;
test_attr("abcde", +char_, x);
}
// single-element fusion vector tests
{
boost::fusion::vector<std::string> fs;
BOOST_TEST((test_attr("12345", +char_, fs))); // ok
BOOST_TEST(boost::fusion::at_c<0>(fs) == "12345");
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test_attr;
using spirit_test::test;
using namespace boost::spirit::x3::ascii;
using boost::spirit::x3::repeat;
using boost::spirit::x3::inf;
using boost::spirit::x3::omit;
using boost::spirit::x3::int_;
using boost::spirit::x3::lexeme;
using boost::spirit::x3::char_;
{
BOOST_TEST(test("aaaaaaaa", repeat[char_])); // kleene synonym
BOOST_TEST(test("aaaaaaaa", repeat(8)[char_]));
BOOST_TEST(!test("aa", repeat(3)[char_]));
BOOST_TEST(test("aaa", repeat(3, 5)[char_]));
BOOST_TEST(test("aaaaa", repeat(3, 5)[char_]));
BOOST_TEST(!test("aaaaaa", repeat(3, 5)[char_]));
BOOST_TEST(!test("aa", repeat(3, 5)[char_]));
BOOST_TEST(test("aaa", repeat(3, inf)[char_]));
BOOST_TEST(test("aaaaa", repeat(3, inf)[char_]));
BOOST_TEST(test("aaaaaa", repeat(3, inf)[char_]));
BOOST_TEST(!test("aa", repeat(3, inf)[char_]));
}
{
std::string s;
BOOST_TEST(test_attr("aaaaaaaa", repeat[char_ >> char_], s)); // kleene synonym
BOOST_TEST(s == "aaaaaaaa");
s.clear();
BOOST_TEST(test_attr("aaaaaaaa", repeat(4)[char_ >> char_], s));
BOOST_TEST(s == "aaaaaaaa");
BOOST_TEST(!test("aa", repeat(3)[char_ >> char_]));
BOOST_TEST(!test("a", repeat(1)[char_ >> char_]));
s.clear();
BOOST_TEST(test_attr("aa", repeat(1, 3)[char_ >> char_], s));
BOOST_TEST(s == "aa");
s.clear();
BOOST_TEST(test_attr("aaaaaa", repeat(1, 3)[char_ >> char_], s));
BOOST_TEST(s == "aaaaaa");
BOOST_TEST(!test("aaaaaaa", repeat(1, 3)[char_ >> char_]));
BOOST_TEST(!test("a", repeat(1, 3)[char_ >> char_]));
s.clear();
BOOST_TEST(test_attr("aaaa", repeat(2, inf)[char_ >> char_], s));
BOOST_TEST(s == "aaaa");
s.clear();
BOOST_TEST(test_attr("aaaaaa", repeat(2, inf)[char_ >> char_], s));
BOOST_TEST(s == "aaaaaa");
BOOST_TEST(!test("aa", repeat(2, inf)[char_ >> char_]));
}
{ // from classic spirit tests
BOOST_TEST(test("", repeat(0, inf)['x']));
// repeat exact 8
#define rep8 repeat(8)[alpha] >> 'X'
BOOST_TEST(!test("abcdefgX", rep8, false));
BOOST_TEST(test("abcdefghX", rep8));
BOOST_TEST(!test("abcdefghiX", rep8, false));
BOOST_TEST(!test("abcdefgX", rep8, false));
BOOST_TEST(!test("aX", rep8, false));
// repeat 2 to 8
#define rep28 repeat(2, 8)[alpha] >> '*'
BOOST_TEST(test("abcdefg*", rep28));
BOOST_TEST(test("abcdefgh*", rep28));
BOOST_TEST(!test("abcdefghi*", rep28, false));
BOOST_TEST(!test("a*", rep28, false));
// repeat 2 or more
#define rep2_ repeat(2, inf)[alpha] >> '+'
BOOST_TEST(test("abcdefg+", rep2_));
BOOST_TEST(test("abcdefgh+", rep2_));
BOOST_TEST(test("abcdefghi+", rep2_));
BOOST_TEST(test("abcdefg+", rep2_));
BOOST_TEST(!test("a+", rep2_, false));
// repeat 0
#define rep0 repeat(0)[alpha] >> '/'
BOOST_TEST(test("/", rep0));
BOOST_TEST(!test("a/", rep0, false));
// repeat 0 or 1
#define rep01 repeat(0, 1)[alpha >> digit] >> '?'
BOOST_TEST(!test("abcdefg?", rep01, false));
BOOST_TEST(!test("a?", rep01, false));
BOOST_TEST(!test("1?", rep01, false));
BOOST_TEST(!test("11?", rep01, false));
BOOST_TEST(!test("aa?", rep01, false));
BOOST_TEST(test("?", rep01));
BOOST_TEST(test("a1?", rep01));
}
{
BOOST_TEST(test(" a a aaa aa", repeat(7)[char_], space));
BOOST_TEST(test("12345 678 9", repeat(9)[digit], space));
}
{
//~ BOOST_TEST(test("aBcdeFGH", no_case[repeat(8)[lower]]));
//~ BOOST_TEST(test("a B cde FGH", no_case[repeat(8)[lower]], space));
}
{
std::vector<std::string> v;
BOOST_TEST(test_attr("a b c d", repeat(4)[lexeme[+alpha]], v, space) && 4 == v.size() &&
v[0] == "a" && v[1] == "b" && v[2] == "c" && v[3] == "d");
}
{
//~ std::string s;
//~ BOOST_TEST(test_attr("bbbb", repeat(4)[char_], s) && s == "bbbb");
//~
//~ s.clear();
//~ BOOST_TEST(test_attr("b b b b", repeat(4)[char_], s, space) && s == "bbbb");
//~
//~ // The following 2 tests show that omit does not inhibit explicit attributes
//~ s.clear();
//~ BOOST_TEST(test_attr("bbbb", omit[repeat(4)[char_('b')]], s) && s == "bbbb");
//~
//~ s.clear();
//~ BOOST_TEST(test_attr("b b b b", omit[repeat(4)[char_('b')]], s, space) && s == "bbbb");
}
{
BOOST_TEST(test("1 2 3", int_ >> repeat(2)[int_], space));
BOOST_TEST(!test("1 2", int_ >> repeat(2)[int_], space));
}
{
std::vector<char> v;
BOOST_TEST(test_attr("1 2 3", int_ >> repeat(2)[int_], v, space));
BOOST_TEST(v.size() == 3 && v[0] == 1 && v[1] == 2 && v[2] == 3);
BOOST_TEST(!test("1 2", int_ >> repeat(2)[int_], space));
}
//~ { // actions
//~ std::vector<char> v;
//~ BOOST_TEST(test("bbbb", repeat(4)[char_]/ [&v]( auto &ctx, const std::vector<char> &attr) { v = attr; }) && 4 == v.size() &&
//~ v[0] == 'b' && v[1] == 'b' && v[2] == 'b' && v[3] == 'b');
//~ }
//~ { // more actions
//~ namespace phx = boost::phoenix;
//~
//~ std::vector<int> v;
//~ BOOST_TEST(test("123 456 789", repeat(3)[int_][phx::ref(v) = _1], space) && 3 == v.size() &&
//~ v[0] == 123 && v[1] == 456 && v[2] == 789);
//~ }
//~
//~ { // lazy repeats
//~ using boost::phoenix::val;
//~
//~ BOOST_TEST(test("aaaaaaaa", repeat(val(8))[char_]));
//~ BOOST_TEST(!test("aa", repeat(val(3))[char_]));
//~
//~ BOOST_TEST(test("aaa", repeat(val(3), val(5))[char_]));
//~ BOOST_TEST(test("aaaaa", repeat(val(3), val(5))[char_]));
//~ BOOST_TEST(!test("aaaaaa", repeat(val(3), val(5))[char_]));
//~ BOOST_TEST(!test("aa", repeat(val(3), val(5))[char_]));
//~
//~ BOOST_TEST(test("aaa", repeat(val(3), val(inf))[char_]));
//~ BOOST_TEST(test("aaaaa", repeat(val(3), val(inf))[char_]));
//~ BOOST_TEST(test("aaaaaa", repeat(val(3), val(inf))[char_]));
//~ BOOST_TEST(!test("aa", repeat(val(3), val(inf))[char_]));
//~ }
//~
//~ { // more lazy repeats
//~ using boost::phoenix::val;
//~
//~ BOOST_TEST(test("aaa", repeat(3, val(5))[char_]));
//~ BOOST_TEST(test("aaaaa", repeat(val(3), 5)[char_]));
//~ BOOST_TEST(!test("aaaaaa", repeat(3, val(5))[char_]));
//~ BOOST_TEST(!test("aa", repeat(val(3), 5)[char_]));
//~
//~//#warning "testcase commented out"
//~ BOOST_TEST(test("aaa", repeat(val(3), inf)[char_]));
//~ BOOST_TEST(test("aaaaa", repeat(3, val(inf))[char_]));
//~ BOOST_TEST(test("aaaaaa", repeat(val(3), inf)[char_]));
//~ BOOST_TEST(!test("aa", repeat(3, val(inf))[char_]));
//~ }
//~
//~ { // attribute customization
//~
//~ x_attr x;
//~ test_attr("abcde", repeat[char_], x);
//~ test_attr("abcde", repeat(5)[char_], x);
//~ test_attr("abcde", repeat(1, 5)[char_], x);
//~ test_attr("abcde", repeat(1, inf)[char_], x);
//~ }
return boost::report_errors();
}
int main()
{
using spirit_test::test_attr;
using spirit_test::test;
using boost::spirit::qi::bool_;
{
BOOST_TEST(test("true", bool_));
BOOST_TEST(test("false", bool_));
BOOST_TEST(!test("fasle", bool_));
}
{
using boost::spirit::qi::true_;
using boost::spirit::qi::false_;
BOOST_TEST(test("true", true_));
BOOST_TEST(!test("true", false_));
BOOST_TEST(test("false", false_));
BOOST_TEST(!test("false", true_));
}
{
using boost::spirit::qi::true_;
using boost::spirit::qi::false_;
using boost::spirit::qi::no_case;
BOOST_TEST(test("True", no_case[bool_]));
BOOST_TEST(test("False", no_case[bool_]));
BOOST_TEST(test("True", no_case[true_]));
BOOST_TEST(test("False", no_case[false_]));
}
{
bool b = false;
BOOST_TEST(test_attr("true", bool_, b) && b);
BOOST_TEST(test_attr("false", bool_, b) && !b);
BOOST_TEST(!test_attr("fasle", bool_, b));
}
{
typedef boost::spirit::qi::bool_parser<bool, backwards_bool_policies>
backwards_bool_type;
backwards_bool_type const backwards_bool = backwards_bool_type();
BOOST_TEST(test("true", backwards_bool));
BOOST_TEST(test("eurt", backwards_bool));
BOOST_TEST(!test("false", backwards_bool));
BOOST_TEST(!test("fasle", backwards_bool));
bool b = false;
BOOST_TEST(test_attr("true", backwards_bool, b) && b);
BOOST_TEST(test_attr("eurt", backwards_bool, b) && !b);
BOOST_TEST(!test_attr("false", backwards_bool, b));
BOOST_TEST(!test_attr("fasle", backwards_bool, b));
}
{
typedef boost::spirit::qi::bool_parser<test_bool_type>
bool_test_type;
bool_test_type const test_bool = bool_test_type();
BOOST_TEST(test("true", test_bool));
BOOST_TEST(test("false", test_bool));
BOOST_TEST(!test("fasle", test_bool));
test_bool_type b = false;
BOOST_TEST(test_attr("true", test_bool, b) && b.b);
BOOST_TEST(test_attr("false", test_bool, b) && !b.b);
BOOST_TEST(!test_attr("fasle", test_bool, b));
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
///////////////////////////////////////////////////////////////////////////
// parameterized unsigned tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::qi::uint_;
unsigned u;
BOOST_TEST(test("123456", uint_(123456)));
BOOST_TEST(!test("123456", uint_(654321)));
BOOST_TEST(test_attr("123456", uint_(123456), u));
BOOST_TEST(u == 123456);
BOOST_TEST(!test_attr("123456", uint_(654321), u));
BOOST_TEST(test(max_unsigned, uint_(UINT_MAX)));
BOOST_TEST(test_attr(max_unsigned, uint_(UINT_MAX), u));
BOOST_TEST(u == UINT_MAX);
}
///////////////////////////////////////////////////////////////////////////
// parameterized binary tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::qi::bin;
unsigned u;
BOOST_TEST(test("11111110", bin(0xFE)));
BOOST_TEST(!test("11111110", bin(0xEF)));
BOOST_TEST(test_attr("11111110", bin(0xFE), u));
BOOST_TEST(u == 0xFE);
BOOST_TEST(!test_attr("11111110", bin(0xEF), u));
BOOST_TEST(test(max_binary, bin(UINT_MAX)));
BOOST_TEST(test_attr(max_binary, bin(UINT_MAX), u));
BOOST_TEST(u == UINT_MAX);
}
///////////////////////////////////////////////////////////////////////////
// parameterized octal tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::qi::oct;
unsigned u;
BOOST_TEST(test("12545674515", oct(012545674515)));
BOOST_TEST(!test("12545674515", oct(051547654521)));
BOOST_TEST(test_attr("12545674515", oct(012545674515), u));
BOOST_TEST(u == 012545674515);
BOOST_TEST(!test_attr("12545674515", oct(051547654521), u));
BOOST_TEST(test(max_octal, oct(UINT_MAX)));
BOOST_TEST(test_attr(max_octal, oct(UINT_MAX), u));
BOOST_TEST(u == UINT_MAX);
}
///////////////////////////////////////////////////////////////////////////
// parameterized hex tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::qi::hex;
unsigned u;
BOOST_TEST(test("95BC8DF", hex(0x95BC8DF)));
BOOST_TEST(!test("95BC8DF", hex(0xFD8CB59)));
BOOST_TEST(test_attr("95BC8DF", hex(0x95BC8DF), u));
BOOST_TEST(u == 0x95BC8DF);
BOOST_TEST(!test_attr("95BC8DF", hex(0xFD8CB59), u));
BOOST_TEST(test("abcdef12", hex(0xabcdef12)));
BOOST_TEST(!test("abcdef12", hex(0x12fedcba)));
BOOST_TEST(test_attr("abcdef12", hex(0xabcdef12), u));
BOOST_TEST(u == 0xabcdef12);
BOOST_TEST(!test_attr("abcdef12", hex(0x12fedcba), u));
BOOST_TEST(test(max_hex, hex(UINT_MAX)));
BOOST_TEST(test_attr(max_hex, hex(UINT_MAX), u));
BOOST_TEST(u == UINT_MAX);
}
///////////////////////////////////////////////////////////////////////////
// parameterized action tests
///////////////////////////////////////////////////////////////////////////
{
using boost::phoenix::ref;
using boost::spirit::ascii::space;
using boost::spirit::qi::uint_;
using boost::spirit::qi::_1;
unsigned n, m;
BOOST_TEST(test("123", uint_(123)[ref(n) = _1]));
BOOST_TEST(n == 123);
BOOST_TEST(!test("123", uint_(321)[ref(n) = _1]));
BOOST_TEST(test_attr("789", uint_(789)[ref(n) = _1], m));
BOOST_TEST(n == 789 && m == 789);
BOOST_TEST(!test_attr("789", uint_(987)[ref(n) = _1], m));
BOOST_TEST(test(" 456", uint_(456)[ref(n) = _1], space));
BOOST_TEST(n == 456);
BOOST_TEST(!test(" 456", uint_(654)[ref(n) = _1], space));
}
///////////////////////////////////////////////////////////////////////////
// parameterized lazy tests
///////////////////////////////////////////////////////////////////////////
{
using boost::phoenix::ref;
using boost::spirit::qi::uint_;
unsigned n = 123, m = 321;
BOOST_TEST(test("123", uint_(ref(n))));
BOOST_TEST(!test("123", uint_(ref(m))));
}
///////////////////////////////////////////////////////////////////////////
// parameterized custom uint tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::qi::uint_;
using boost::spirit::qi::uint_parser;
custom_uint u;
BOOST_TEST(test_attr("123456", uint_(123456), u));
uint_parser<custom_uint, 10, 1, 2> uint2;
BOOST_TEST(test_attr("12", uint2(12), u));
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
using boost::spirit::qi::symbols;
using boost::spirit::qi::rule;
using boost::spirit::qi::lazy;
using boost::spirit::qi::_r1;
{ // construction from symbol array
char const* syms[] = {"Joel","Ruby","Tenji","Tutit","Kim","Joey"};
symbols<char, int> sym(syms);
BOOST_TEST((test("Joel", sym)));
BOOST_TEST((test("Ruby", sym)));
BOOST_TEST((test("Tenji", sym)));
BOOST_TEST((test("Tutit", sym)));
BOOST_TEST((test("Kim", sym)));
BOOST_TEST((test("Joey", sym)));
BOOST_TEST((!test("XXX", sym)));
}
{ // construction from 2 arrays
char const* syms[] = {"Joel","Ruby","Tenji","Tutit","Kim","Joey"};
int data[] = {1,2,3,4,5,6};
symbols<char, int> sym(syms, data);
int i;
BOOST_TEST((test_attr("Joel", sym, i)));
BOOST_TEST(i == 1);
BOOST_TEST((test_attr("Ruby", sym, i)));
BOOST_TEST(i == 2);
BOOST_TEST((test_attr("Tenji", sym, i)));
BOOST_TEST(i == 3);
BOOST_TEST((test_attr("Tutit", sym, i)));
BOOST_TEST(i == 4);
BOOST_TEST((test_attr("Kim", sym, i)));
BOOST_TEST(i == 5);
BOOST_TEST((test_attr("Joey", sym, i)));
BOOST_TEST(i == 6);
BOOST_TEST((!test_attr("XXX", sym, i)));
}
{ // allow std::string and other string types
symbols<> sym;
// const and non-const std::string
std::string a("abc");
std::string const b("def");
sym += a;
sym += b;
BOOST_TEST((test("abc", sym)));
BOOST_TEST((test("def", sym)));
sym = a;
BOOST_TEST((test("abc", sym)));
BOOST_TEST((!test("def", sym)));
// non-const C-style string
char arr[2]; arr[0] = 'a'; arr[1] = '\0';
sym = arr;
BOOST_TEST((test("a", sym)));
BOOST_TEST((!test("b", sym)));
// const and non-const custom string type
custom_string_c c('x');
custom_string_c const cc('y');
sym = c, cc;
BOOST_TEST((test("x", sym)));
BOOST_TEST((test("y", sym)));
BOOST_TEST((!test("z", sym)));
}
{
namespace phx = boost::phoenix;
symbols<char, int> sym;
sym.add
("a", 1)
("b", 2)
;
rule<char const*, int(symbols<char, int>&)> r;
r %= lazy(_r1);
int i = 0;
BOOST_TEST(test_attr("a", r(phx::ref(sym)), i));
BOOST_TEST(i == 1);
BOOST_TEST(test_attr("b", r(phx::ref(sym)), i));
BOOST_TEST(i == 2);
BOOST_TEST(!test("c", r(phx::ref(sym))));
}
{ // find
symbols<char, int> sym;
sym.add("a", 1)("b", 2);
BOOST_TEST(!sym.find("c"));
BOOST_TEST(sym.find("a") && *sym.find("a") == 1);
BOOST_TEST(sym.find("b") && *sym.find("b") == 2);
BOOST_TEST(sym.at("a") == 1);
BOOST_TEST(sym.at("b") == 2);
BOOST_TEST(sym.at("c") == 0);
BOOST_TEST(sym.find("a") && *sym.find("a") == 1);
BOOST_TEST(sym.find("b") && *sym.find("b") == 2);
BOOST_TEST(sym.find("c") && *sym.find("c") == 0);
symbols<char, int> const_sym(sym);
BOOST_TEST(const_sym.find("a") && *const_sym.find("a") == 1);
BOOST_TEST(const_sym.find("b") && *const_sym.find("b") == 2);
BOOST_TEST(const_sym.find("c") && *const_sym.find("c") == 0);
BOOST_TEST(!const_sym.find("d"));
char const *str1 = "all";
char const *first = str1, *last = str1 + 3;
BOOST_TEST(*sym.prefix_find(first, last) == 1 && first == str1 + 1);
char const *str2 = "dart";
first = str2; last = str2 + 4;
BOOST_TEST(!sym.prefix_find(first, last) && first == str2);
}
{ // name
symbols <char, int> sym,sym2;
sym.name("test");
BOOST_TEST(sym.name()=="test");
sym2 = sym;
BOOST_TEST(sym2.name()=="test");
symbols <char,int> sym3(sym);
BOOST_TEST(sym3.name()=="test");
}
{ // Substrings
symbols<char, int> sym;
BOOST_TEST(sym.at("foo") == 0);
sym.at("foo") = 1;
BOOST_TEST(sym.at("foo") == 1);
BOOST_TEST(sym.at("fool") == 0);
sym.at("fool") = 2;
BOOST_TEST(sym.find("foo") && *sym.find("foo") == 1);
BOOST_TEST(sym.find("fool") && *sym.find("fool") == 2);
BOOST_TEST(!sym.find("foolish"));
BOOST_TEST(!sym.find("foot"));
BOOST_TEST(!sym.find("afoot"));
char const *str, *first, *last;
str = "foolish"; first = str; last = str + 7;
BOOST_TEST(*sym.prefix_find(first, last) == 2 && first == str + 4);
first = str; last = str + 4;
BOOST_TEST(*sym.prefix_find(first, last) == 2 && first == str + 4);
str = "food"; first = str; last = str + 4;
BOOST_TEST(*sym.prefix_find(first, last) == 1 && first == str + 3);
first = str; last = str + 3;
BOOST_TEST(*sym.prefix_find(first, last) == 1 && first == str + 3);
first = str; last = str + 2;
BOOST_TEST(!sym.prefix_find(first, last) && first == str);
}
{
// remove bug
std::string s;
symbols<char, double> vars;
vars.add("l1", 12.0);
vars.add("l2", 0.0);
vars.remove("l2");
vars.find("l1");
double* d = vars.find("l1");
BOOST_TEST(d != 0);
}
{ // test for proto problem with rvalue references (10-11-2011)
symbols<char, int> sym;
sym += get_str("Joel");
sym += get_str("Ruby");
BOOST_TEST((test("Joel", sym)));
BOOST_TEST((test("Ruby", sym)));
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
using boost::spirit::x3::char_;
using boost::spirit::x3::alpha;
using boost::spirit::x3::upper;
using boost::spirit::x3::space;
using boost::spirit::x3::digit;
using boost::spirit::x3::int_;
using boost::spirit::x3::lexeme;
{
BOOST_TEST(test("aaaaaaaa", *char_));
BOOST_TEST(test("a", *char_));
BOOST_TEST(test("", *char_));
BOOST_TEST(test("aaaaaaaa", *alpha));
BOOST_TEST(!test("aaaaaaaa", *upper));
}
{
BOOST_TEST(test(" a a aaa aa", *char_, space));
BOOST_TEST(test("12345 678 9", *digit, space));
}
{
std::string s;
BOOST_TEST(test_attr("bbbb", *char_, s) && 4 == s.size() && s == "bbbb");
s.clear();
BOOST_TEST(test_attr("b b b b ", *char_, s, space) && s == "bbbb");
}
{
std::vector<int> v;
BOOST_TEST(test_attr("123 456 789 10", *int_, v, space) && 4 == v.size() &&
v[0] == 123 && v[1] == 456 && v[2] == 789 && v[3] == 10);
}
{
std::vector<std::string> v;
BOOST_TEST(test_attr("a b c d", *lexeme[+alpha], v, space) && 4 == v.size() &&
v[0] == "a" && v[1] == "b" && v[2] == "c" && v[3] == "d");
}
{
std::vector<int> v;
BOOST_TEST(test_attr("123 456 789", *int_, v, space) && 3 == v.size() &&
v[0] == 123 && v[1] == 456 && v[2] == 789);
}
{ // actions
using boost::spirit::x3::_attr;
std::string v;
auto f = [&](auto& ctx){ v = _attr(ctx); };
BOOST_TEST(test("bbbb", (*char_)[f]) && 4 == v.size() &&
v[0] == 'b' && v[1] == 'b' && v[2] == 'b' && v[3] == 'b');
}
{ // more actions
using boost::spirit::x3::_attr;
std::vector<int> v;
auto f = [&](auto& ctx){ v = _attr(ctx); };
BOOST_TEST(test("123 456 789", (*int_)[f], space) && 3 == v.size() &&
v[0] == 123 && v[1] == 456 && v[2] == 789);
}
{ // attribute customization
x_attr x;
test_attr("abcde", *char_, x);
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
{
using namespace boost::spirit::x3::ascii;
BOOST_TEST(test("1", alnum));
BOOST_TEST(!test(" ", alnum));
BOOST_TEST(!test("1", alpha));
BOOST_TEST(test("x", alpha));
BOOST_TEST(test(" ", blank));
BOOST_TEST(!test("x", blank));
BOOST_TEST(test("1", digit));
BOOST_TEST(!test("x", digit));
BOOST_TEST(test("a", lower));
BOOST_TEST(!test("A", lower));
BOOST_TEST(test("!", punct));
BOOST_TEST(!test("x", punct));
BOOST_TEST(test(" ", space));
BOOST_TEST(test("\n", space));
BOOST_TEST(test("\r", space));
BOOST_TEST(test("\t", space));
BOOST_TEST(test("A", upper));
BOOST_TEST(!test("a", upper));
BOOST_TEST(test("A", xdigit));
BOOST_TEST(test("0", xdigit));
BOOST_TEST(test("f", xdigit));
BOOST_TEST(!test("g", xdigit));
}
{
using namespace boost::spirit::x3::ascii;
BOOST_TEST(!test("1", ~alnum));
BOOST_TEST(test(" ", ~alnum));
BOOST_TEST(test("1", ~alpha));
BOOST_TEST(!test("x", ~alpha));
BOOST_TEST(!test(" ", ~blank));
BOOST_TEST(test("x", ~blank));
BOOST_TEST(!test("1", ~digit));
BOOST_TEST(test("x", ~digit));
BOOST_TEST(!test("a", ~lower));
BOOST_TEST(test("A", ~lower));
BOOST_TEST(!test("!", ~punct));
BOOST_TEST(test("x", ~punct));
BOOST_TEST(!test(" ", ~space));
BOOST_TEST(!test("\n", ~space));
BOOST_TEST(!test("\r", ~space));
BOOST_TEST(!test("\t", ~space));
BOOST_TEST(!test("A", ~upper));
BOOST_TEST(test("a", ~upper));
BOOST_TEST(!test("A", ~xdigit));
BOOST_TEST(!test("0", ~xdigit));
BOOST_TEST(!test("f", ~xdigit));
BOOST_TEST(test("g", ~xdigit));
}
{
using namespace boost::spirit::x3::iso8859_1;
BOOST_TEST(test("1", alnum));
BOOST_TEST(!test(" ", alnum));
BOOST_TEST(!test("1", alpha));
BOOST_TEST(test("x", alpha));
BOOST_TEST(test(" ", blank));
BOOST_TEST(!test("x", blank));
BOOST_TEST(test("1", digit));
BOOST_TEST(!test("x", digit));
BOOST_TEST(test("a", lower));
BOOST_TEST(!test("A", lower));
BOOST_TEST(test("!", punct));
BOOST_TEST(!test("x", punct));
BOOST_TEST(test(" ", space));
BOOST_TEST(test("\n", space));
BOOST_TEST(test("\r", space));
BOOST_TEST(test("\t", space));
BOOST_TEST(test("A", upper));
BOOST_TEST(!test("a", upper));
BOOST_TEST(test("A", xdigit));
BOOST_TEST(test("0", xdigit));
BOOST_TEST(test("f", xdigit));
BOOST_TEST(!test("g", xdigit));
// needed for VC7.1 only
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
#pragma setlocale("german")
#endif
BOOST_TEST(test("é", alpha));
BOOST_TEST(test("é", lower));
BOOST_TEST(!test("é", upper));
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
#pragma setlocale("")
#endif
}
{
using namespace boost::spirit::x3::standard;
BOOST_TEST(test("1", alnum));
BOOST_TEST(!test(" ", alnum));
BOOST_TEST(!test("1", alpha));
BOOST_TEST(test("x", alpha));
BOOST_TEST(test(" ", blank));
BOOST_TEST(!test("x", blank));
BOOST_TEST(test("1", digit));
BOOST_TEST(!test("x", digit));
BOOST_TEST(test("a", lower));
BOOST_TEST(!test("A", lower));
BOOST_TEST(test("!", punct));
BOOST_TEST(!test("x", punct));
BOOST_TEST(test(" ", space));
BOOST_TEST(test("\n", space));
BOOST_TEST(test("\r", space));
BOOST_TEST(test("\t", space));
BOOST_TEST(test("A", upper));
BOOST_TEST(!test("a", upper));
BOOST_TEST(test("A", xdigit));
BOOST_TEST(test("0", xdigit));
BOOST_TEST(test("f", xdigit));
BOOST_TEST(!test("g", xdigit));
}
{
using namespace boost::spirit::x3::standard_wide;
BOOST_TEST(test(L"1", alnum));
BOOST_TEST(!test(L" ", alnum));
BOOST_TEST(!test(L"1", alpha));
BOOST_TEST(test(L"x", alpha));
BOOST_TEST(test(L" ", blank));
BOOST_TEST(!test(L"x", blank));
BOOST_TEST(test(L"1", digit));
BOOST_TEST(!test(L"x", digit));
BOOST_TEST(test(L"a", lower));
BOOST_TEST(!test(L"A", lower));
BOOST_TEST(test(L"!", punct));
BOOST_TEST(!test(L"x", punct));
BOOST_TEST(test(L" ", space));
BOOST_TEST(test(L"\n", space));
BOOST_TEST(test(L"\r", space));
BOOST_TEST(test(L"\t", space));
BOOST_TEST(test(L"A", upper));
BOOST_TEST(!test(L"a", upper));
BOOST_TEST(test(L"A", xdigit));
BOOST_TEST(test(L"0", xdigit));
BOOST_TEST(test(L"f", xdigit));
BOOST_TEST(!test(L"g", xdigit));
}
{
using namespace boost::spirit::x3::unicode;
BOOST_TEST(test(L"1", alnum));
BOOST_TEST(!test(L" ", alnum));
BOOST_TEST(!test(L"1", alpha));
BOOST_TEST(test(L"x", alpha));
BOOST_TEST(test(L" ", blank));
BOOST_TEST(!test(L"x", blank));
BOOST_TEST(test(L"1", digit));
BOOST_TEST(!test(L"x", digit));
BOOST_TEST(test(L"a", lower));
BOOST_TEST(!test(L"A", lower));
BOOST_TEST(test(L"!", punct));
BOOST_TEST(!test(L"x", punct));
BOOST_TEST(test(L" ", space));
BOOST_TEST(test(L"\n", space));
BOOST_TEST(test(L"\r", space));
BOOST_TEST(test(L"\t", space));
BOOST_TEST(test(L"A", upper));
BOOST_TEST(!test(L"a", upper));
BOOST_TEST(test(L"A", xdigit));
BOOST_TEST(test(L"0", xdigit));
BOOST_TEST(test(L"f", xdigit));
BOOST_TEST(!test(L"g", xdigit));
BOOST_TEST(test(L"A", alphabetic));
BOOST_TEST(test(L"9", decimal_number));
// $$$ TODO $$$ Add more unicode tests
// needed for VC7.1 only
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
#pragma setlocale("german")
#endif
BOOST_TEST(test("é", alpha));
BOOST_TEST(test("é", lower));
BOOST_TEST(!test("é", upper));
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
#pragma setlocale("")
#endif
}
{ // test attribute extraction
using boost::spirit::traits::attribute_of;
using boost::spirit::x3::iso8859_1::alpha;
using boost::spirit::x3::iso8859_1::alpha_type;
static_assert(
boost::is_same<
attribute_of<alpha_type>::type
, unsigned char>::value
, "Wrong attribute type!"
);
int attr = 0;
BOOST_TEST(test_attr("a", alpha, attr));
BOOST_TEST(attr == 'a');
}
{ // test attribute extraction
using boost::spirit::x3::iso8859_1::alpha;
using boost::spirit::x3::iso8859_1::space;
char attr = 0;
BOOST_TEST(test_attr(" a", alpha, attr, space));
BOOST_TEST(attr == 'a');
}
// $$$ Not yet implemented $$$
//~ { // test action
//~ using namespace boost::spirit::x3::ascii;
//~ using boost::phoenix::ref;
//~ using boost::spirit::_1;
//~ char ch;
//~ BOOST_TEST(test("x", alnum[ref(ch) = _1]));
//~ BOOST_TEST(ch == 'x');
//~ BOOST_TEST(test(" A", alnum[ref(ch) = _1], space));
//~ BOOST_TEST(ch == 'A');
//~ }
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
///////////////////////////////////////////////////////////////////////////
// signed real number tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::x3::double_;
using boost::spirit::x3::parse;
double d;
BOOST_TEST(test("-1234", double_));
BOOST_TEST(test_attr("-1234", double_, d) && compare(d, -1234));
BOOST_TEST(test("-1.2e3", double_));
BOOST_TEST(test_attr("-1.2e3", double_, d) && compare(d, -1.2e3));
BOOST_TEST(test("+1.2e3", double_));
BOOST_TEST(test_attr("+1.2e3", double_, d) && compare(d, 1.2e3));
BOOST_TEST(test("-0.1", double_));
BOOST_TEST(test_attr("-0.1", double_, d) && compare(d, -0.1));
BOOST_TEST(test("-1.2e-3", double_));
BOOST_TEST(test_attr("-1.2e-3", double_, d) && compare(d, -1.2e-3));
BOOST_TEST(test("-1.e2", double_));
BOOST_TEST(test_attr("-1.e2", double_, d) && compare(d, -1.e2));
BOOST_TEST(test("-.2e3", double_));
BOOST_TEST(test_attr("-.2e3", double_, d) && compare(d, -.2e3));
BOOST_TEST(test("-2e3", double_));
BOOST_TEST(test_attr("-2e3", double_, d) && compare(d, -2e3));
BOOST_TEST(!test("-e3", double_));
BOOST_TEST(!test_attr("-e3", double_, d));
BOOST_TEST(!test("-1.2e", double_));
BOOST_TEST(!test_attr("-1.2e", double_, d));
#if defined(BOOST_SPIRIT_TEST_REAL_PRECISION)
BOOST_TEST(test_attr("-5.7222349715140557e+307", double_, d));
BOOST_TEST(d == -5.7222349715140557e+307); // exact!
BOOST_TEST(test_attr("2.0332938517515416e-308", double_, d));
BOOST_TEST(d == 2.0332938517515416e-308); // exact!
BOOST_TEST(test_attr("20332938517515416e291", double_, d));
BOOST_TEST(d == 20332938517515416e291); // exact!
BOOST_TEST(test_attr("2.0332938517515416e307", double_, d));
BOOST_TEST(d == 2.0332938517515416e307); // exact!
#endif
using boost::math::fpclassify;
using boost::spirit::x3::signbit; // Boost version is broken
BOOST_TEST(test("-inf", double_));
BOOST_TEST(test("-infinity", double_));
BOOST_TEST(test_attr("-inf", double_, d) &&
FP_INFINITE == fpclassify(d) && signbit(d));
BOOST_TEST(test_attr("-infinity", double_, d) &&
FP_INFINITE == fpclassify(d) && signbit(d));
BOOST_TEST(test("-INF", double_));
BOOST_TEST(test("-INFINITY", double_));
BOOST_TEST(test_attr("-INF", double_, d) &&
FP_INFINITE == fpclassify(d) && signbit(d));
BOOST_TEST(test_attr("-INFINITY", double_, d) &&
FP_INFINITE == fpclassify(d) && signbit(d));
BOOST_TEST(test("-nan", double_));
BOOST_TEST(test_attr("-nan", double_, d) &&
FP_NAN == fpclassify(d) && signbit(d));
BOOST_TEST(test("-NAN", double_));
BOOST_TEST(test_attr("-NAN", double_, d) &&
FP_NAN == fpclassify(d) && signbit(d));
BOOST_TEST(test("-nan(...)", double_));
BOOST_TEST(test_attr("-nan(...)", double_, d) &&
FP_NAN == fpclassify(d) && signbit(d));
BOOST_TEST(test("-NAN(...)", double_));
BOOST_TEST(test_attr("-NAN(...)", double_, d) &&
FP_NAN == fpclassify(d) && signbit(d));
}
return boost::report_errors();
}
int main()
{
using spirit_test::test_attr;
using boost::spirit::utree;
using boost::spirit::utree_type;
using boost::spirit::utf8_string_range_type;
using boost::spirit::utf8_symbol_type;
using boost::spirit::utf8_string_type;
using boost::spirit::qi::real_parser;
using boost::spirit::qi::strict_real_policies;
using boost::spirit::qi::digit;
using boost::spirit::qi::char_;
using boost::spirit::qi::string;
using boost::spirit::qi::int_;
using boost::spirit::qi::double_;
using boost::spirit::qi::space;
using boost::spirit::qi::space_type;
using boost::spirit::qi::rule;
using boost::spirit::qi::as;
using boost::spirit::qi::lexeme;
// as
{
typedef as<std::string> as_string_type;
as_string_type const as_string = as_string_type();
typedef as<utf8_symbol_type> as_symbol_type;
as_symbol_type const as_symbol = as_symbol_type();
utree ut;
BOOST_TEST(test_attr("xy", as_string[char_ >> char_], ut) &&
ut.which() == utree_type::string_type && check(ut, "\"xy\""));
ut.clear();
BOOST_TEST(test_attr("ab1.2", as_string[*~digit] >> double_, ut) &&
ut.which() == utree_type::list_type && check(ut, "( \"ab\" 1.2 )"));
ut.clear();
BOOST_TEST(test_attr("xy", as_string[*char_], ut) &&
ut.which() == utree_type::string_type && check(ut, "\"xy\""));
ut.clear();
BOOST_TEST(test_attr("x,y", as_string[char_ >> ',' >> char_], ut) &&
ut.which() == utree_type::string_type && check(ut, "\"xy\""));
ut.clear();
BOOST_TEST(test_attr("x,y", char_ >> ',' >> char_, ut) &&
ut.which() == utree_type::list_type && check(ut, "( \"x\" \"y\" )"));
ut.clear();
BOOST_TEST(test_attr("a,b1.2", as_string[~digit % ','] >> double_, ut) &&
ut.which() == utree_type::list_type && check(ut, "( \"ab\" 1.2 )"));
ut.clear();
BOOST_TEST(test_attr("a,b1.2", ~digit % ',' >> double_, ut) &&
ut.which() == utree_type::list_type && check(ut, "( \"a\" \"b\" 1.2 )"));
ut.clear();
BOOST_TEST(test_attr("xy", as_symbol[char_ >> char_], ut) &&
ut.which() == utree_type::symbol_type && check(ut, "xy"));
ut.clear();
BOOST_TEST(test_attr("ab1.2", as_symbol[*~digit] >> double_, ut) &&
ut.which() == utree_type::list_type && check(ut, "( ab 1.2 )"));
ut.clear();
BOOST_TEST(test_attr("xy", as_symbol[*char_], ut) &&
ut.which() == utree_type::symbol_type && check(ut, "xy"));
ut.clear();
BOOST_TEST(test_attr("x,y", as_symbol[char_ >> ',' >> char_], ut) &&
ut.which() == utree_type::symbol_type && check(ut, "xy"));
ut.clear();
BOOST_TEST(test_attr("a,b1.2", as_symbol[~digit % ','] >> double_, ut) &&
ut.which() == utree_type::list_type && check(ut, "( ab 1.2 )"));
ut.clear();
}
// subtrees
{
// -(+int_) is forcing a subtree
utree ut;
BOOST_TEST(test_attr("1 2", int_ >> ' ' >> -(+int_), ut) &&
ut.which() == utree_type::list_type && check(ut, "( 1 2 )"));
ut.clear();
BOOST_TEST(test_attr("1 2", int_ >> ' ' >> *int_, ut) &&
ut.which() == utree_type::list_type && check(ut, "( 1 2 )"));
ut.clear();
rule<char const*, std::vector<int>()> r1 = int_ % ',';
BOOST_TEST(test_attr("1 2,3", int_ >> ' ' >> r1, ut) &&
ut.which() == utree_type::list_type && check(ut, "( 1 2 3 )"));
ut.clear();
BOOST_TEST(test_attr("1,2 2,3", r1 >> ' ' >> r1, ut) &&
ut.which() == utree_type::list_type && check(ut, "( 1 2 2 3 )"));
ut.clear();
rule<char const*, utree()> r2 = int_ % ',';
BOOST_TEST(test_attr("1 2,3", int_ >> ' ' >> r2, ut) &&
ut.which() == utree_type::list_type && check(ut, "( 1 2 3 )"));
ut.clear();
BOOST_TEST(test_attr("1,2 2,3", r2 >> ' ' >> r2, ut) &&
ut.which() == utree_type::list_type && check(ut, "( 1 2 2 3 )"));
ut.clear();
rule<char const*, utree::list_type()> r3 = int_ % ',';
BOOST_TEST(test_attr("1 2,3", int_ >> ' ' >> r3, ut) &&
ut.which() == utree_type::list_type && check(ut, "( 1 ( 2 3 ) )"));
ut.clear();
BOOST_TEST(test_attr("1,2 2,3", r3 >> ' ' >> r3, ut) &&
ut.which() == utree_type::list_type && check(ut, "( ( 1 2 ) ( 2 3 ) )"));
ut.clear();
rule<char const*, utree()> r4 = int_;
BOOST_TEST(test_attr("1 1", int_ >> ' ' >> -r4, ut) &&
ut.which() == utree_type::list_type && check(ut, "( 1 1 )"));
ut.clear();
BOOST_TEST(test_attr("1 ", int_ >> ' ' >> -r4, ut) &&
ut.which() == utree_type::list_type && check(ut, "( 1 )"));
ut.clear();
rule<char const*, utree::list_type()> r5 = -r4;
BOOST_TEST(test_attr("1", r5, ut) &&
ut.which() == utree_type::list_type && check(ut, "( 1 )"));
ut.clear();
BOOST_TEST(test_attr("", r5, ut) &&
ut.which() == utree_type::list_type && check(ut, "( )"));
ut.clear();
BOOST_TEST(test_attr("1 1", r5 >> ' ' >> r5, ut) &&
ut.which() == utree_type::list_type && check(ut, "( ( 1 ) ( 1 ) )"));
ut.clear();
rule<char const*, utree::list_type()> r6 = int_;
rule<char const*, utree()> r7 = -r6;
BOOST_TEST(test_attr("1", r7, ut) &&
ut.which() == utree_type::list_type && check(ut, "( 1 )"));
ut.clear();
rule<char const*, utree::list_type()> r8 = r6 >> ' ' >> r6;
BOOST_TEST(test_attr("1 1", r8, ut) &&
ut.which() == utree_type::list_type && check(ut, "( ( 1 ) ( 1 ) )"));
ut.clear();
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
{
using namespace boost::spirit::ascii;
BOOST_TEST(test("1", alnum));
BOOST_TEST(!test(" ", alnum));
BOOST_TEST(!test("1", alpha));
BOOST_TEST(test("x", alpha));
BOOST_TEST(test(" ", blank));
BOOST_TEST(!test("x", blank));
BOOST_TEST(test("1", digit));
BOOST_TEST(!test("x", digit));
BOOST_TEST(test("a", lower));
BOOST_TEST(!test("A", lower));
BOOST_TEST(test("!", punct));
BOOST_TEST(!test("x", punct));
BOOST_TEST(test(" ", space));
BOOST_TEST(test("\n", space));
BOOST_TEST(test("\r", space));
BOOST_TEST(test("\t", space));
BOOST_TEST(test("A", upper));
BOOST_TEST(!test("a", upper));
BOOST_TEST(test("A", xdigit));
BOOST_TEST(test("0", xdigit));
BOOST_TEST(test("f", xdigit));
BOOST_TEST(!test("g", xdigit));
// should fail, not assert!
// $$$ Removing this test for now $$$
// BOOST_TEST(!test("\265", space));
}
{
using namespace boost::spirit::ascii;
BOOST_TEST(!test("1", ~alnum));
BOOST_TEST(test(" ", ~alnum));
BOOST_TEST(test("1", ~alpha));
BOOST_TEST(!test("x", ~alpha));
BOOST_TEST(!test(" ", ~blank));
BOOST_TEST(test("x", ~blank));
BOOST_TEST(!test("1", ~digit));
BOOST_TEST(test("x", ~digit));
BOOST_TEST(!test("a", ~lower));
BOOST_TEST(test("A", ~lower));
BOOST_TEST(!test("!", ~punct));
BOOST_TEST(test("x", ~punct));
BOOST_TEST(!test(" ", ~space));
BOOST_TEST(!test("\n", ~space));
BOOST_TEST(!test("\r", ~space));
BOOST_TEST(!test("\t", ~space));
BOOST_TEST(!test("A", ~upper));
BOOST_TEST(test("a", ~upper));
BOOST_TEST(!test("A", ~xdigit));
BOOST_TEST(!test("0", ~xdigit));
BOOST_TEST(!test("f", ~xdigit));
BOOST_TEST(test("g", ~xdigit));
}
{
// we use the hoisted qi namespace this time
using namespace boost::spirit::qi::iso8859_1;
BOOST_TEST(test("1", alnum));
BOOST_TEST(!test(" ", alnum));
BOOST_TEST(!test("1", alpha));
BOOST_TEST(test("x", alpha));
BOOST_TEST(test(" ", blank));
BOOST_TEST(!test("x", blank));
BOOST_TEST(test("1", digit));
BOOST_TEST(!test("x", digit));
BOOST_TEST(test("a", lower));
BOOST_TEST(!test("A", lower));
BOOST_TEST(test("!", punct));
BOOST_TEST(!test("x", punct));
BOOST_TEST(test(" ", space));
BOOST_TEST(test("\n", space));
BOOST_TEST(test("\r", space));
BOOST_TEST(test("\t", space));
BOOST_TEST(test("A", upper));
BOOST_TEST(!test("a", upper));
BOOST_TEST(test("A", xdigit));
BOOST_TEST(test("0", xdigit));
BOOST_TEST(test("f", xdigit));
BOOST_TEST(!test("g", xdigit));
// needed for VC7.1 only
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
#pragma setlocale("german")
#endif
BOOST_TEST(test("é", alpha));
BOOST_TEST(test("é", lower));
BOOST_TEST(!test("é", upper));
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
#pragma setlocale("")
#endif
}
{
using namespace boost::spirit::standard;
BOOST_TEST(test("1", alnum));
BOOST_TEST(!test(" ", alnum));
BOOST_TEST(!test("1", alpha));
BOOST_TEST(test("x", alpha));
BOOST_TEST(test(" ", blank));
BOOST_TEST(!test("x", blank));
BOOST_TEST(test("1", digit));
BOOST_TEST(!test("x", digit));
BOOST_TEST(test("a", lower));
BOOST_TEST(!test("A", lower));
BOOST_TEST(test("!", punct));
BOOST_TEST(!test("x", punct));
BOOST_TEST(test(" ", space));
BOOST_TEST(test("\n", space));
BOOST_TEST(test("\r", space));
BOOST_TEST(test("\t", space));
BOOST_TEST(test("A", upper));
BOOST_TEST(!test("a", upper));
BOOST_TEST(test("A", xdigit));
BOOST_TEST(test("0", xdigit));
BOOST_TEST(test("f", xdigit));
BOOST_TEST(!test("g", xdigit));
}
{
using namespace boost::spirit::standard_wide;
BOOST_TEST(test(L"1", alnum));
BOOST_TEST(!test(L" ", alnum));
BOOST_TEST(!test(L"1", alpha));
BOOST_TEST(test(L"x", alpha));
BOOST_TEST(test(L" ", blank));
BOOST_TEST(!test(L"x", blank));
BOOST_TEST(test(L"1", digit));
BOOST_TEST(!test(L"x", digit));
BOOST_TEST(test(L"a", lower));
BOOST_TEST(!test(L"A", lower));
BOOST_TEST(test(L"!", punct));
BOOST_TEST(!test(L"x", punct));
BOOST_TEST(test(L" ", space));
BOOST_TEST(test(L"\n", space));
BOOST_TEST(test(L"\r", space));
BOOST_TEST(test(L"\t", space));
BOOST_TEST(test(L"A", upper));
BOOST_TEST(!test(L"a", upper));
BOOST_TEST(test(L"A", xdigit));
BOOST_TEST(test(L"0", xdigit));
BOOST_TEST(test(L"f", xdigit));
BOOST_TEST(!test(L"g", xdigit));
}
{
using namespace boost::spirit::unicode;
BOOST_TEST(test(L"1", alnum));
BOOST_TEST(!test(L" ", alnum));
BOOST_TEST(!test(L"1", alpha));
BOOST_TEST(test(L"x", alpha));
BOOST_TEST(test(L" ", blank));
BOOST_TEST(!test(L"x", blank));
BOOST_TEST(test(L"1", digit));
BOOST_TEST(!test(L"x", digit));
BOOST_TEST(test(L"a", lower));
BOOST_TEST(!test(L"A", lower));
BOOST_TEST(test(L"!", punct));
BOOST_TEST(!test(L"x", punct));
BOOST_TEST(test(L" ", space));
BOOST_TEST(test(L"\n", space));
BOOST_TEST(test(L"\r", space));
BOOST_TEST(test(L"\t", space));
BOOST_TEST(test(L"A", upper));
BOOST_TEST(!test(L"a", upper));
BOOST_TEST(test(L"A", xdigit));
BOOST_TEST(test(L"0", xdigit));
BOOST_TEST(test(L"f", xdigit));
BOOST_TEST(!test(L"g", xdigit));
// needed for VC7.1 only
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
#pragma setlocale("german")
#endif
BOOST_TEST(test("é", alpha));
BOOST_TEST(test("é", lower));
BOOST_TEST(!test("é", upper));
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1310))
#pragma setlocale("")
#endif
}
{ // test attribute extraction
using boost::spirit::qi::domain;
using boost::spirit::traits::attribute_of;
using boost::spirit::iso8859_1::alpha;
using boost::spirit::iso8859_1::alpha_type;
using boost::spirit::result_of::compile;
BOOST_STATIC_ASSERT((
boost::is_same<
attribute_of<compile<domain, alpha_type>::type>::type
, unsigned char>::value));
int attr = 0;
BOOST_TEST(test_attr("a", alpha, attr));
BOOST_TEST(attr == 'a');
}
{ // test attribute extraction
using boost::spirit::iso8859_1::alpha;
using boost::spirit::iso8859_1::space;
char attr = 0;
BOOST_TEST(test_attr(" a", alpha, attr, space));
BOOST_TEST(attr == 'a');
}
{ // test action
using namespace boost::spirit::ascii;
using boost::phoenix::ref;
using boost::spirit::_1;
char ch;
BOOST_TEST(test("x", alnum[ref(ch) = _1]));
BOOST_TEST(ch == 'x');
BOOST_TEST(test(" A", alnum[ref(ch) = _1], space));
BOOST_TEST(ch == 'A');
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
///////////////////////////////////////////////////////////////////////////
// signed integer tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::x3::int_;
int i;
BOOST_TEST(test("123456", int_));
BOOST_TEST(test_attr("123456", int_, i));
BOOST_TEST(i == 123456);
BOOST_TEST(test("+123456", int_));
BOOST_TEST(test_attr("+123456", int_, i));
BOOST_TEST(i == 123456);
BOOST_TEST(test("-123456", int_));
BOOST_TEST(test_attr("-123456", int_, i));
BOOST_TEST(i == -123456);
BOOST_TEST(test(max_int, int_));
BOOST_TEST(test_attr(max_int, int_, i));
BOOST_TEST(i == INT_MAX);
BOOST_TEST(test(min_int, int_));
BOOST_TEST(test_attr(min_int, int_, i));
BOOST_TEST(i == INT_MIN);
BOOST_TEST(!test(int_overflow, int_));
BOOST_TEST(!test_attr(int_overflow, int_, i));
BOOST_TEST(!test(int_underflow, int_));
BOOST_TEST(!test_attr(int_underflow, int_, i));
BOOST_TEST(!test("-", int_));
BOOST_TEST(!test_attr("-", int_, i));
BOOST_TEST(!test("+", int_));
BOOST_TEST(!test_attr("+", int_, i));
// Bug report from Steve Nutt
BOOST_TEST(!test_attr("5368709120", int_, i));
// with leading zeros
BOOST_TEST(test("0000000000123456", int_));
BOOST_TEST(test_attr("0000000000123456", int_, i));
BOOST_TEST(i == 123456);
}
///////////////////////////////////////////////////////////////////////////
// long long tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::x3::long_long;
boost::long_long_type ll;
BOOST_TEST(test("1234567890123456789", long_long));
BOOST_TEST(test_attr("1234567890123456789", long_long, ll));
BOOST_TEST(ll == 1234567890123456789LL);
BOOST_TEST(test("-1234567890123456789", long_long));
BOOST_TEST(test_attr("-1234567890123456789", long_long, ll));
BOOST_TEST(ll == -1234567890123456789LL);
BOOST_TEST(test(max_long_long, long_long));
BOOST_TEST(test_attr(max_long_long, long_long, ll));
BOOST_TEST(ll == LLONG_MAX);
BOOST_TEST(test(min_long_long, long_long));
BOOST_TEST(test_attr(min_long_long, long_long, ll));
BOOST_TEST(ll == LLONG_MIN);
BOOST_TEST(!test(long_long_overflow, long_long));
BOOST_TEST(!test_attr(long_long_overflow, long_long, ll));
BOOST_TEST(!test(long_long_underflow, long_long));
BOOST_TEST(!test_attr(long_long_underflow, long_long, ll));
}
///////////////////////////////////////////////////////////////////////////
// short_ and long_ tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::x3::short_;
using boost::spirit::x3::long_;
int i;
BOOST_TEST(test("12345", short_));
BOOST_TEST(test_attr("12345", short_, i));
BOOST_TEST(i == 12345);
BOOST_TEST(test("1234567890", long_));
BOOST_TEST(test_attr("1234567890", long_, i));
BOOST_TEST(i == 1234567890);
}
///////////////////////////////////////////////////////////////////////////
// Check overflow is parse error
///////////////////////////////////////////////////////////////////////////
{
boost::spirit::x3::int_parser<boost::int8_t> int8_;
char c;
BOOST_TEST(!test_attr("999", int8_, c));
int i;
using boost::spirit::x3::short_;
BOOST_TEST(!test_attr("32769", short_, i, false));
BOOST_TEST(!test_attr("41234", short_, i, false));
}
///////////////////////////////////////////////////////////////////////////
// int_parser<unused_type> tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::x3::int_parser;
using boost::spirit::x3::unused_type;
int_parser<unused_type> any_int;
BOOST_TEST(test("123456", any_int));
BOOST_TEST(test("-123456", any_int));
BOOST_TEST(test("-1234567890123456789", any_int));
}
///////////////////////////////////////////////////////////////////////////
// action tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::x3::_attr;
using boost::spirit::x3::ascii::space;
using boost::spirit::x3::int_;
int n, m;
auto f = [&](auto& ctx){ n = _attr(ctx); };
BOOST_TEST(test("123", int_[f]));
BOOST_TEST(n == 123);
BOOST_TEST(test_attr("789", int_[f], m));
BOOST_TEST(n == 789 && m == 789);
BOOST_TEST(test(" 456", int_[f], space));
BOOST_TEST(n == 456);
}
///////////////////////////////////////////////////////////////////////////
// custom int tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::x3::int_;
using boost::spirit::x3::int_parser;
custom_int i;
BOOST_TEST(test_attr("-123456", int_, i));
int_parser<custom_int, 10, 1, 2> int2;
BOOST_TEST(test_attr("-12", int2, i));
}
///////////////////////////////////////////////////////////////////////////
// single-element fusion vector tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::x3::int_;
using boost::spirit::x3::int_parser;
boost::fusion::vector<int> i;
BOOST_TEST(test_attr("-123456", int_, i));
BOOST_TEST(boost::fusion::at_c<0>(i) == -123456);
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
///////////////////////////////////////////////////////////////////////////
// strict real number tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::x3::real_parser;
using boost::spirit::x3::parse;
using boost::spirit::x3::strict_ureal_policies;
using boost::spirit::x3::strict_real_policies;
real_parser<double, strict_ureal_policies<double> > strict_udouble;
real_parser<double, strict_real_policies<double> > strict_double;
double d;
BOOST_TEST(!test("1234", strict_udouble));
BOOST_TEST(!test_attr("1234", strict_udouble, d));
BOOST_TEST(test("1.2", strict_udouble));
BOOST_TEST(test_attr("1.2", strict_udouble, d) && compare(d, 1.2));
BOOST_TEST(!test("-1234", strict_double));
BOOST_TEST(!test_attr("-1234", strict_double, d));
BOOST_TEST(test("123.", strict_double));
BOOST_TEST(test_attr("123.", strict_double, d) && compare(d, 123));
BOOST_TEST(test("3.E6", strict_double));
BOOST_TEST(test_attr("3.E6", strict_double, d) && compare(d, 3e6));
real_parser<double, no_trailing_dot_policy<double> > notrdot_real;
real_parser<double, no_leading_dot_policy<double> > nolddot_real;
BOOST_TEST(!test("1234.", notrdot_real)); // Bad trailing dot
BOOST_TEST(!test(".1234", nolddot_real)); // Bad leading dot
}
///////////////////////////////////////////////////////////////////////////
// Special thousands separated numbers
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::x3::real_parser;
using boost::spirit::x3::parse;
real_parser<double, ts_real_policies<double> > ts_real;
double d;
BOOST_TEST(test("123,456,789.01", ts_real));
BOOST_TEST(test_attr("123,456,789.01", ts_real, d)
&& compare(d, 123456789.01));
BOOST_TEST(test("12,345,678.90", ts_real));
BOOST_TEST(test_attr("12,345,678.90", ts_real, d)
&& compare(d, 12345678.90));
BOOST_TEST(test("1,234,567.89", ts_real));
BOOST_TEST(test_attr("1,234,567.89", ts_real, d)
&& compare(d, 1234567.89));
BOOST_TEST(!test("1234,567,890", ts_real));
BOOST_TEST(!test("1,234,5678,9", ts_real));
BOOST_TEST(!test("1,234,567.89e6", ts_real));
BOOST_TEST(!test("1,66", ts_real));
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
///////////////////////////////////////////////////////////////////////////
// thousand separated numbers
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::qi::uint_parser;
using boost::spirit::qi::parse;
uint_parser<unsigned, 10, 1, 3> uint3;
uint_parser<unsigned, 10, 3, 3> uint3_3;
#define r (uint3 >> *(',' >> uint3_3))
BOOST_TEST(test("1,234,567,890", r));
BOOST_TEST(test("12,345,678,900", r));
BOOST_TEST(test("123,456,789,000", r));
BOOST_TEST(!test("1000,234,567,890", r));
BOOST_TEST(!test("1,234,56,890", r));
BOOST_TEST(!test("1,66", r));
}
///////////////////////////////////////////////////////////////////////////
// unsigned real number tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::qi::real_parser;
using boost::spirit::qi::parse;
using boost::spirit::qi::ureal_policies;
real_parser<double, ureal_policies<double> > udouble;
double d;
BOOST_TEST(test("1234", udouble));
BOOST_TEST(test_attr("1234", udouble, d) && compare(d, 1234));
BOOST_TEST(test("1.2e3", udouble));
BOOST_TEST(test_attr("1.2e3", udouble, d) && compare(d, 1.2e3));
BOOST_TEST(test("1.2e-3", udouble));
BOOST_TEST(test_attr("1.2e-3", udouble, d) && compare(d, 1.2e-3));
BOOST_TEST(test("1.e2", udouble));
BOOST_TEST(test_attr("1.e2", udouble, d) && compare(d, 1.e2));
BOOST_TEST(test("1.", udouble));
BOOST_TEST(test_attr("1.", udouble, d) && compare(d, 1.));
BOOST_TEST(test(".2e3", udouble));
BOOST_TEST(test_attr(".2e3", udouble, d) && compare(d, .2e3));
BOOST_TEST(test("2e3", udouble));
BOOST_TEST(test_attr("2e3", udouble, d) && compare(d, 2e3));
BOOST_TEST(test("2", udouble));
BOOST_TEST(test_attr("2", udouble, d) && compare(d, 2));
using boost::math::fpclassify;
BOOST_TEST(test("inf", udouble));
BOOST_TEST(test("infinity", udouble));
BOOST_TEST(test("INF", udouble));
BOOST_TEST(test("INFINITY", udouble));
BOOST_TEST(test_attr("inf", udouble, d)
&& FP_INFINITE == fpclassify(d));
BOOST_TEST(test_attr("INF", udouble, d)
&& FP_INFINITE == fpclassify(d));
BOOST_TEST(test_attr("infinity", udouble, d)
&& FP_INFINITE == fpclassify(d));
BOOST_TEST(test_attr("INFINITY", udouble, d)
&& FP_INFINITE == fpclassify(d));
BOOST_TEST(test("nan", udouble));
BOOST_TEST(test_attr("nan", udouble, d)
&& FP_NAN == fpclassify(d));
BOOST_TEST(test("NAN", udouble));
BOOST_TEST(test_attr("NAN", udouble, d)
&& FP_NAN == fpclassify(d));
BOOST_TEST(test("nan(...)", udouble));
BOOST_TEST(test_attr("nan(...)", udouble, d)
&& FP_NAN == fpclassify(d));
BOOST_TEST(test("NAN(...)", udouble));
BOOST_TEST(test_attr("NAN(...)", udouble, d)
&& FP_NAN == fpclassify(d));
BOOST_TEST(!test("e3", udouble));
BOOST_TEST(!test_attr("e3", udouble, d));
BOOST_TEST(!test("-1.2e3", udouble));
BOOST_TEST(!test_attr("-1.2e3", udouble, d));
BOOST_TEST(!test("+1.2e3", udouble));
BOOST_TEST(!test_attr("+1.2e3", udouble, d));
BOOST_TEST(!test("1.2e", udouble));
BOOST_TEST(!test_attr("1.2e", udouble, d));
BOOST_TEST(!test("-.3", udouble));
BOOST_TEST(!test_attr("-.3", udouble, d));
BOOST_TEST(test("4em", udouble, false));
BOOST_TEST(test_attr("4em", udouble, d, false) && compare(d, 4.0));
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
using namespace boost::spirit::ascii;
using boost::spirit::qi::int_;
using boost::spirit::qi::omit;
using boost::spirit::qi::lit;
using boost::spirit::qi::_1;
using boost::spirit::qi::lexeme;
{
BOOST_TEST(test("aaaaaaaa", +char_));
BOOST_TEST(test("a", +char_));
BOOST_TEST(!test("", +char_));
BOOST_TEST(test("aaaaaaaa", +alpha));
BOOST_TEST(!test("aaaaaaaa", +upper));
}
{
BOOST_TEST(test(" a a aaa aa", +char_, space));
BOOST_TEST(test("12345 678 9 ", +digit, space));
}
{
BOOST_TEST(test("aBcdeFGH", no_case[+char_]));
BOOST_TEST(test("a B cde FGH ", no_case[+char_], space));
}
{
std::vector<int> v;
BOOST_TEST(test_attr("123 456 789 10", +int_, v, space) && 4 == v.size() &&
v[0] == 123 && v[1] == 456 && v[2] == 789 && v[3] == 10);
}
{
std::vector<std::string> v;
BOOST_TEST(test_attr("a b c d", +lexeme[+alpha], v, space) && 4 == v.size() &&
v[0] == "a" && v[1] == "b" && v[2] == "c" && v[3] == "d");
}
{
BOOST_TEST(test("Kim Kim Kim", +lit("Kim"), space));
}
{
// The following 4 tests show that omit does not inhibit explicit attributes
std::string s;
BOOST_TEST(test_attr("bbbb", +omit[char_('b')], s) && s == "bbbb");
s.clear();
BOOST_TEST(test_attr("bbbb", omit[+char_('b')], s) && s == "bbbb");
s.clear();
BOOST_TEST(test_attr("b b b b ", +omit[char_('b')], s, space) && s == "bbbb");
s.clear();
BOOST_TEST(test_attr("b b b b ", omit[+char_('b')], s, space) && s == "bbbb");
}
{ // actions
namespace phx = boost::phoenix;
std::vector<char> v;
BOOST_TEST(test("bbbb", (+char_)[phx::ref(v) = _1]) && 4 == v.size() &&
v[0] == 'b' && v[1] == 'b' && v[2] == 'b' && v[3] == 'b');
}
{ // more actions
namespace phx = boost::phoenix;
std::vector<int> v;
BOOST_TEST(test("1 2 3", (+int_)[phx::ref(v) = _1], space) && 3 == v.size() &&
v[0] == 1 && v[1] == 2 && v[2] == 3);
}
{ // attribute customization
x_attr x;
test_attr("abcde", +char_, x);
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
///////////////////////////////////////////////////////////////////////////
// parameterized signed real number tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::qi::double_;
double d;
BOOST_TEST(test("+1234", double_(1234)));
BOOST_TEST(!test("+1234", double_(-1234)));
BOOST_TEST(test_attr("+1234", double_(1234), d));
BOOST_TEST(compare(d, 1234));
BOOST_TEST(!test_attr("+1234", double_(-1234), d));
BOOST_TEST(test("-1234", double_(-1234)));
BOOST_TEST(!test("-1234", double_(1234)));
BOOST_TEST(test_attr("-1234", double_(-1234), d));
BOOST_TEST(compare(d, -1234));
BOOST_TEST(!test_attr("-1234", double_(1234), d));
BOOST_TEST(test("+1.2e3", double_(1.2e3)));
BOOST_TEST(!test("+1.2e3", double_(-1.2e3)));
BOOST_TEST(test_attr("+1.2e3", double_(1.2e3), d));
BOOST_TEST(compare(d, 1.2e3));
BOOST_TEST(!test_attr("+1.2e3", double_(-1.2e3), d));
BOOST_TEST(test("-1.2e3", double_(-1.2e3)));
BOOST_TEST(!test("-1.2e3", double_(1.2e3)));
BOOST_TEST(test_attr("-1.2e3", double_(-1.2e3), d));
BOOST_TEST(compare(d, -1.2e3));
BOOST_TEST(!test_attr("-1.2e3", double_(1.2e3), d));
}
///////////////////////////////////////////////////////////////////////////
// parameterized unsigned real number tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::qi::real_parser;
using boost::spirit::qi::ureal_policies;
double d;
real_parser<double, ureal_policies<double> > udouble;
BOOST_TEST(test("1234", udouble(1234)));
BOOST_TEST(!test("1234", udouble(4321)));
BOOST_TEST(test_attr("1234", udouble(1234), d));
BOOST_TEST(compare(d, 1234));
BOOST_TEST(!test_attr("1234", udouble(4321), d));
BOOST_TEST(test("1.2e3", udouble(1.2e3)));
BOOST_TEST(!test("1.2e3", udouble(3.2e1)));
BOOST_TEST(test_attr("1.2e3", udouble(1.2e3), d));
BOOST_TEST(compare(d, 1.2e3));
BOOST_TEST(!test_attr("1.2e3", udouble(3.2e1), d));
}
///////////////////////////////////////////////////////////////////////////
// parameterized custom data type
///////////////////////////////////////////////////////////////////////////
{
using boost::math::concepts::real_concept;
using boost::spirit::qi::real_parser;
using boost::spirit::qi::real_policies;
real_parser<real_concept, real_policies<real_concept> > custom_real;
real_concept d;
BOOST_TEST(test("-1234", custom_real(-1234)));
BOOST_TEST(!test("-1234", custom_real(4321)));
BOOST_TEST(test_attr("-1234", custom_real(-1234), d));
BOOST_TEST(compare(d, -1234));
BOOST_TEST(!test_attr("-1234", custom_real(-4321), d));
BOOST_TEST(test("1.2e3", custom_real(1.2e3)));
BOOST_TEST(!test("1.2e3", custom_real(-1.2e3)));
BOOST_TEST(test_attr("1.2e3", custom_real(1.2e3), d));
BOOST_TEST(compare(d, 1.2e3));
BOOST_TEST(!test_attr("1.2e3", custom_real(-3.2e1), d));
}
///////////////////////////////////////////////////////////////////////////
// parameterized lazy tests
///////////////////////////////////////////////////////////////////////////
{
using boost::phoenix::ref;
using boost::spirit::qi::double_;
double n = 1.2e3, m = 3.2e1;
BOOST_TEST(test("1.2e3", double_(ref(n))));
BOOST_TEST(!test("1.2e3", double_(ref(m))));
}
///////////////////////////////////////////////////////////////////////////
// literal real number tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::qi::lit;
BOOST_TEST(test("+1.2e3", lit(1.2e3)));
BOOST_TEST(!test("+1.2e3", lit(-1.2e3)));
BOOST_TEST(test("-1.2e3", lit(-1.2e3)));
BOOST_TEST(!test("-1.2e3", lit(1.2e3)));
BOOST_TEST(test("1.2e3", lit(1.2e3)));
BOOST_TEST(!test("1.2e3", lit(3.2e1)));
}
///////////////////////////////////////////////////////////////////////////
// literal lazy tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::qi::lit;
using boost::phoenix::ref;
double n = 1.2e3, m = 3.2e1;
BOOST_TEST(test("1.2e3", lit(ref(n))));
BOOST_TEST(!test("1.2e3", lit(ref(m))));
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
///////////////////////////////////////////////////////////////////////////
// parameterized signed integer tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::int_;
int i;
BOOST_TEST(test("123456", int_(123456)));
BOOST_TEST(!test("123456", int_(654321)));
BOOST_TEST(test_attr("123456", int_(123456), i));
BOOST_TEST(i == 123456);
BOOST_TEST(!test_attr("123456", int_(654321), i));
BOOST_TEST(test("+123456", int_(123456)));
BOOST_TEST(!test("+123456", int_(654321)));
BOOST_TEST(test_attr("+123456", int_(123456), i));
BOOST_TEST(i == 123456);
BOOST_TEST(!test_attr("+123456", int_(654321), i));
BOOST_TEST(test("-123456", int_(-123456)));
BOOST_TEST(!test("-123456", int_(123456)));
BOOST_TEST(test_attr("-123456", int_(-123456), i));
BOOST_TEST(i == -123456);
BOOST_TEST(!test_attr("-123456", int_(123456), i));
BOOST_TEST(test(max_int, int_(INT_MAX)));
BOOST_TEST(test_attr(max_int, int_(INT_MAX), i));
BOOST_TEST(i == INT_MAX);
BOOST_TEST(test(min_int, int_(INT_MIN)));
BOOST_TEST(test_attr(min_int, int_(INT_MIN), i));
BOOST_TEST(i == INT_MIN);
// with leading zeros
BOOST_TEST(test("0000000000123456", int_(123456)));
BOOST_TEST(test_attr("0000000000123456", int_(123456), i));
BOOST_TEST(i == 123456);
}
///////////////////////////////////////////////////////////////////////////
// parameterized long long tests
///////////////////////////////////////////////////////////////////////////
#ifdef BOOST_HAS_LONG_LONG
{
using boost::spirit::long_long;
boost::long_long_type ll;
BOOST_TEST(test("1234567890123456789"
, long_long(1234567890123456789LL)));
BOOST_TEST(!test("1234567890123456789"
, long_long(0)));
BOOST_TEST(test_attr("1234567890123456789"
, long_long(1234567890123456789LL), ll));
BOOST_TEST(ll == 1234567890123456789LL);
BOOST_TEST(!test_attr("1234567890123456789"
, long_long(0), ll));
BOOST_TEST(test("-1234567890123456789"
, long_long(-1234567890123456789LL)));
BOOST_TEST(!test("-1234567890123456789"
, long_long(1234567890123456789LL)));
BOOST_TEST(test_attr("-1234567890123456789"
, long_long(-1234567890123456789LL), ll));
BOOST_TEST(ll == -1234567890123456789LL);
BOOST_TEST(!test_attr("-1234567890123456789"
, long_long(1234567890123456789LL), ll));
BOOST_TEST(test(max_long_long, long_long(LONG_LONG_MAX)));
BOOST_TEST(test_attr(max_long_long, long_long(LONG_LONG_MAX), ll));
BOOST_TEST(ll == LONG_LONG_MAX);
BOOST_TEST(test(min_long_long, long_long(LONG_LONG_MIN)));
BOOST_TEST(test_attr(min_long_long, long_long(LONG_LONG_MIN), ll));
BOOST_TEST(ll == LONG_LONG_MIN);
}
#endif
///////////////////////////////////////////////////////////////////////////
// parameterized short_ and long_ tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::short_;
using boost::spirit::long_;
int i;
BOOST_TEST(test("12345", short_(12345)));
BOOST_TEST(!test("12345", short_(54321)));
BOOST_TEST(test_attr("12345", short_(12345), i));
BOOST_TEST(i == 12345);
BOOST_TEST(!test_attr("12345", short_(54321), i));
BOOST_TEST(test("1234567890", long_(1234567890L)));
BOOST_TEST(!test("1234567890", long_(987654321L)));
BOOST_TEST(test_attr("1234567890", long_(1234567890L), i));
BOOST_TEST(i == 1234567890);
BOOST_TEST(!test_attr("1234567890", long_(987654321L), i));
}
///////////////////////////////////////////////////////////////////////////
// parameterized action tests
///////////////////////////////////////////////////////////////////////////
{
using boost::phoenix::ref;
using boost::spirit::ascii::space;
using boost::spirit::qi::int_;
using boost::spirit::qi::_1;
int n, m;
BOOST_TEST(test("123", int_(123)[ref(n) = _1]));
BOOST_TEST(n == 123);
BOOST_TEST(!test("123", int_(321)[ref(n) = _1]));
BOOST_TEST(test_attr("789", int_(789)[ref(n) = _1], m));
BOOST_TEST(n == 789 && m == 789);
BOOST_TEST(!test_attr("789", int_(987)[ref(n) = _1], m));
BOOST_TEST(test(" 456", int_(456)[ref(n) = _1], space));
BOOST_TEST(n == 456);
BOOST_TEST(!test(" 456", int_(654)[ref(n) = _1], space));
}
///////////////////////////////////////////////////////////////////////////
// parameterized lazy tests
///////////////////////////////////////////////////////////////////////////
{
using boost::phoenix::ref;
using boost::spirit::qi::int_;
int n = 123, m = 321;
BOOST_TEST(test("123", int_(ref(n))));
BOOST_TEST(!test("123", int_(ref(m))));
}
///////////////////////////////////////////////////////////////////////////
// parameterized custom int tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::qi::int_;
using boost::spirit::qi::int_parser;
custom_int i;
BOOST_TEST(test_attr("-123456", int_(-123456), i));
int_parser<custom_int, 10, 1, 2> int2;
BOOST_TEST(test_attr("-12", int2(-12), i));
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
///////////////////////////////////////////////////////////////////////////
// Custom data type
///////////////////////////////////////////////////////////////////////////
{
using boost::math::concepts::real_concept;
using boost::spirit::x3::real_parser;
using boost::spirit::x3::real_policies;
using boost::spirit::x3::parse;
real_parser<real_concept, real_policies<real_concept> > custom_real;
real_concept d;
BOOST_TEST(test("-1234", custom_real));
BOOST_TEST(test_attr("-1234", custom_real, d) && compare(d, -1234));
BOOST_TEST(test("-1.2e3", custom_real));
BOOST_TEST(test_attr("-1.2e3", custom_real, d) && compare(d, -1.2e3));
BOOST_TEST(test("+1.2e3", custom_real));
BOOST_TEST(test_attr("+1.2e3", custom_real, d) && compare(d, 1.2e3));
BOOST_TEST(test("-0.1", custom_real));
BOOST_TEST(test_attr("-0.1", custom_real, d) && compare(d, -0.1));
BOOST_TEST(test("-1.2e-3", custom_real));
BOOST_TEST(test_attr("-1.2e-3", custom_real, d) && compare(d, -1.2e-3));
BOOST_TEST(test("-1.e2", custom_real));
BOOST_TEST(test_attr("-1.e2", custom_real, d) && compare(d, -1.e2));
BOOST_TEST(test("-.2e3", custom_real));
BOOST_TEST(test_attr("-.2e3", custom_real, d) && compare(d, -.2e3));
BOOST_TEST(test("-2e3", custom_real));
BOOST_TEST(test_attr("-2e3", custom_real, d) && compare(d, -2e3));
BOOST_TEST(!test("-e3", custom_real));
BOOST_TEST(!test_attr("-e3", custom_real, d));
BOOST_TEST(!test("-1.2e", custom_real));
BOOST_TEST(!test_attr("-1.2e", custom_real, d));
}
///////////////////////////////////////////////////////////////////////////
// custom real tests
///////////////////////////////////////////////////////////////////////////
{
using boost::spirit::x3::double_;
custom_real n;
BOOST_TEST(test_attr("-123456e6", double_, n));
}
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
using boost::spirit::x3::symbols;
//~ using boost::spirit::x3::lazy;
{ // basics
symbols<char, int> sym;
sym.add
("Joel")
("Ruby")
("Tenji")
("Tutit")
("Kim")
("Joey")
("Joeyboy")
;
// $$$ Hat is this??? $$$
//~ boost::mpl::true_ f = boost::mpl::bool_<boost::spirit::x3::traits::is_parser<symbols<char, int> >::value>();
// silence stupid compiler warnings
// i.e. MSVC warning C4189: 'f' : local variable is initialized but not referenced
//~ BOOST_TEST((f.value));
BOOST_TEST((test("Joel", sym)));
BOOST_TEST((test("Ruby", sym)));
BOOST_TEST((test("Tenji", sym)));
BOOST_TEST((test("Tutit", sym)));
BOOST_TEST((test("Kim", sym)));
BOOST_TEST((test("Joey", sym)));
BOOST_TEST((test("Joeyboy", sym)));
BOOST_TEST((!test("XXX", sym)));
// test copy
symbols<char, int> sym2;
sym2 = sym;
BOOST_TEST((test("Joel", sym2)));
BOOST_TEST((test("Ruby", sym2)));
BOOST_TEST((test("Tenji", sym2)));
BOOST_TEST((test("Tutit", sym2)));
BOOST_TEST((test("Kim", sym2)));
BOOST_TEST((test("Joey", sym2)));
BOOST_TEST((!test("XXX", sym2)));
// make sure it plays well with other parsers
BOOST_TEST((test("Joelyo", sym >> "yo")));
sym.remove
("Joel")
("Ruby")
;
BOOST_TEST((!test("Joel", sym)));
BOOST_TEST((!test("Ruby", sym)));
}
{ // comma syntax
symbols<char, int> sym;
sym += "Joel", "Ruby", "Tenji", "Tutit", "Kim", "Joey";
BOOST_TEST((test("Joel", sym)));
BOOST_TEST((test("Ruby", sym)));
BOOST_TEST((test("Tenji", sym)));
BOOST_TEST((test("Tutit", sym)));
BOOST_TEST((test("Kim", sym)));
BOOST_TEST((test("Joey", sym)));
BOOST_TEST((!test("XXX", sym)));
sym -= "Joel", "Ruby";
BOOST_TEST((!test("Joel", sym)));
BOOST_TEST((!test("Ruby", sym)));
}
/// $$$ Not yet implemented $$$
//~ { // no-case handling
//~ using namespace boost::spirit::x3::ascii;
//~ symbols<char, int> sym;
//~ // NOTE: make sure all entries are in lower-case!!!
//~ sym = "joel", "ruby", "tenji", "tutit", "kim", "joey";
//~ BOOST_TEST((test("joel", no_case[sym])));
//~ BOOST_TEST((test("ruby", no_case[sym])));
//~ BOOST_TEST((test("tenji", no_case[sym])));
//~ BOOST_TEST((test("tutit", no_case[sym])));
//~ BOOST_TEST((test("kim", no_case[sym])));
//~ BOOST_TEST((test("joey", no_case[sym])));
//~ BOOST_TEST((test("JOEL", no_case[sym])));
//~ BOOST_TEST((test("RUBY", no_case[sym])));
//~ BOOST_TEST((test("TENJI", no_case[sym])));
//~ BOOST_TEST((test("TUTIT", no_case[sym])));
//~ BOOST_TEST((test("KIM", no_case[sym])));
//~ BOOST_TEST((test("JOEY", no_case[sym])));
//~ // make sure it plays well with other parsers
//~ BOOST_TEST((test("Joelyo", no_case[sym] >> "yo")));
//~ }
{ // attributes
symbols<char, int> sym;
sym.add
("Joel", 1)
("Ruby", 2)
("Tenji", 3)
("Tutit", 4)
("Kim", 5)
("Joey", 6)
;
int i;
BOOST_TEST((test_attr("Joel", sym, i)));
BOOST_TEST(i == 1);
BOOST_TEST((test_attr("Ruby", sym, i)));
BOOST_TEST(i == 2);
BOOST_TEST((test_attr("Tenji", sym, i)));
BOOST_TEST(i == 3);
BOOST_TEST((test_attr("Tutit", sym, i)));
BOOST_TEST(i == 4);
BOOST_TEST((test_attr("Kim", sym, i)));
BOOST_TEST(i == 5);
BOOST_TEST((test_attr("Joey", sym, i)));
BOOST_TEST(i == 6);
BOOST_TEST((!test_attr("XXX", sym, i)));
// double add:
sym.add("Joel", 265);
BOOST_TEST((test_attr("Joel", sym, i)));
BOOST_TEST(i == 1);
}
//~ { // actions
//~ namespace phx = boost::phoenix;
//~ using boost::spirit::x3::_1;
//~ symbols<char, int> sym;
//~ sym.add
//~ ("Joel", 1)
//~ ("Ruby", 2)
//~ ("Tenji", 3)
//~ ("Tutit", 4)
//~ ("Kim", 5)
//~ ("Joey", 6)
//~ ;
//~ int i;
//~ BOOST_TEST((test("Joel", sym[phx::ref(i) = _1])));
//~ BOOST_TEST(i == 1);
//~ BOOST_TEST((test("Ruby", sym[phx::ref(i) = _1])));
//~ BOOST_TEST(i == 2);
//~ BOOST_TEST((test("Tenji", sym[phx::ref(i) = _1])));
//~ BOOST_TEST(i == 3);
//~ BOOST_TEST((test("Tutit", sym[phx::ref(i) = _1])));
//~ BOOST_TEST(i == 4);
//~ BOOST_TEST((test("Kim", sym[phx::ref(i) = _1])));
//~ BOOST_TEST(i == 5);
//~ BOOST_TEST((test("Joey", sym[phx::ref(i) = _1])));
//~ BOOST_TEST(i == 6);
//~ BOOST_TEST((!test("XXX", sym[phx::ref(i) = _1])));
//~ }
return boost::report_errors();
}
int
main()
{
using spirit_test::test;
using spirit_test::test_attr;
//~ using boost::spirit::x3::omit;
using boost::spirit::x3::char_;
using boost::spirit::x3::alpha;
using boost::spirit::x3::upper;
using boost::spirit::x3::space;
using boost::spirit::x3::digit;
//~ using boost::spirit::x3::no_case;
//~ using boost::spirit::x3::uint_;
using boost::spirit::x3::int_;
using boost::spirit::x3::lexeme;
{
BOOST_TEST(test("aaaaaaaa", *char_));
BOOST_TEST(test("a", *char_));
BOOST_TEST(test("", *char_));
BOOST_TEST(test("aaaaaaaa", *alpha));
BOOST_TEST(!test("aaaaaaaa", *upper));
}
{
BOOST_TEST(test(" a a aaa aa", *char_, space));
BOOST_TEST(test("12345 678 9", *digit, space));
}
//~ {
//~ BOOST_TEST(test("aBcdeFGH", no_case[*char_]));
//~ BOOST_TEST(test("a B cde FGH", no_case[*char_], space));
//~ }
//~ {
//~ BOOST_TEST(test("12345 678 955 987", *uint_, space));
//~ BOOST_TEST(test("12345, 678, 955, 987", uint_ >> *(',' >> uint_), space));
//~ }
{
std::string s;
BOOST_TEST(test_attr("bbbb", *char_, s) && 4 == s.size() && s == "bbbb");
s.clear();
BOOST_TEST(test_attr("b b b b ", *char_, s, space) && s == "bbbb");
//~ // The following 2 tests show that omit does not inhibit explicit attributes
//~ s.clear();
//~ BOOST_TEST(test_attr("bbbb", omit[*char_('b')], s) && s == "bbbb");
//~ s.clear();
//~ BOOST_TEST(test_attr("b b b b", omit[*char_('b')], s, space) && s == "bbbb");
}
{
std::vector<int> v;
BOOST_TEST(test_attr("123 456 789 10", *int_, v, space) && 4 == v.size() &&
v[0] == 123 && v[1] == 456 && v[2] == 789 && v[3] == 10);
}
{
std::vector<std::string> v;
BOOST_TEST(test_attr("a b c d", *lexeme[+alpha], v, space) && 4 == v.size() &&
v[0] == "a" && v[1] == "b" && v[2] == "c" && v[3] == "d");
}
{
std::vector<int> v;
BOOST_TEST(test_attr("123 456 789", *int_, v, space) && 3 == v.size() &&
v[0] == 123 && v[1] == 456 && v[2] == 789);
}
/*
{ // actions
namespace phx = boost::phoenix;
using boost::spirit::x3::_1;
std::vector<char> v;
BOOST_TEST(test("bbbb", (*char_)[phx::ref(v) = _1]) && 4 == v.size() &&
v[0] == 'b' && v[1] == 'b' && v[2] == 'b' && v[3] == 'b');
}
{ // more actions
namespace phx = boost::phoenix;
using boost::spirit::x3::_1;
std::vector<int> v;
BOOST_TEST(test("123 456 789", (*int_)[phx::ref(v) = _1], space) && 3 == v.size() &&
v[0] == 123 && v[1] == 456 && v[2] == 789);
}
*/
{ // attribute customization
x_attr x;
test_attr("abcde", *char_, x);
}
return boost::report_errors();
}
