本文整理汇总了C++中spirit_test::test_attr方法的典型用法代码示例。如果您正苦于以下问题:C++ spirit_test::test_attr方法的具体用法?C++ spirit_test::test_attr怎么用?C++ spirit_test::test_attr使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类spirit_test
的用法示例。
在下文中一共展示了spirit_test::test_attr方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: main
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();
}
示例2: main
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();
}
示例3: main
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();
}
示例4: main
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();
}
示例5: main
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();
}
示例6: main
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);
//.........这里部分代码省略.........
示例7: main
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;
//.........这里部分代码省略.........
示例8: main
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;
//.........这里部分代码省略.........
示例9: main
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));
//.........这里部分代码省略.........
示例10: main
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();
}
示例11: main
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));
//.........这里部分代码省略.........
示例12: main
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));
//.........这里部分代码省略.........
示例13: main
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"));
//.........这里部分代码省略.........
示例14: main
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();
}
示例15: main
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));
//.........这里部分代码省略.........