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(); }