1/*=============================================================================
2 Copyright (c) 2001-2010 Joel de Guzman
3
4 Distributed under the Boost Software License, Version 1.0. (See accompanying
5 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6=============================================================================*/
7#include <boost/spirit/include/qi_permutation.hpp>
8
9#include <boost/spirit/include/qi_operator.hpp>
10#include <boost/spirit/include/qi_char.hpp>
11#include <boost/spirit/include/qi_string.hpp>
12#include <boost/spirit/include/qi_numeric.hpp>
13#include <boost/spirit/include/qi_action.hpp>
14#include <boost/spirit/include/qi_nonterminal.hpp>
15#include <boost/spirit/include/support_argument.hpp>
16#include <boost/fusion/include/vector.hpp>
17#include <boost/fusion/include/at.hpp>
18#include <boost/phoenix/core.hpp>
19#include <boost/phoenix/operator.hpp>
20#include <boost/optional.hpp>
21
22#include <string>
23#include <iostream>
24#include "test.hpp"
25
26using namespace spirit_test;
27
28int
29main()
30{
31 using boost::spirit::qi::int_;
32 using boost::spirit::qi::_1;
33 using boost::spirit::qi::_2;
34 using boost::spirit::qi::rule;
35 using boost::spirit::ascii::alpha;
36 using boost::spirit::ascii::char_;
37
38 using boost::fusion::vector;
39 using boost::fusion::at_c;
40 using boost::optional;
41
42 {
43 BOOST_TEST((test("a", char_('a') ^ char_('b') ^ char_('c'))));
44 BOOST_TEST((test("b", char_('a') ^ char_('b') ^ char_('c'))));
45 BOOST_TEST((test("ab", char_('a') ^ char_('b') ^ char_('c'))));
46 BOOST_TEST((test("ba", char_('a') ^ char_('b') ^ char_('c'))));
47 BOOST_TEST((test("abc", char_('a') ^ char_('b') ^ char_('c'))));
48 BOOST_TEST((test("acb", char_('a') ^ char_('b') ^ char_('c'))));
49 BOOST_TEST((test("bca", char_('a') ^ char_('b') ^ char_('c'))));
50 BOOST_TEST((test("bac", char_('a') ^ char_('b') ^ char_('c'))));
51 BOOST_TEST((test("cab", char_('a') ^ char_('b') ^ char_('c'))));
52 BOOST_TEST((test("cba", char_('a') ^ char_('b') ^ char_('c'))));
53
54 BOOST_TEST((!test("cca", char_('a') ^ char_('b') ^ char_('c'))));
55 }
56
57 { // test optional must stay uninitialized
58 optional<int> i;
59 BOOST_TEST((test_attr("", -int_ ^ int_, i)));
60 BOOST_TEST(!i);
61 }
62
63 {
64 vector<optional<int>, optional<char> > attr;
65
66 BOOST_TEST((test_attr("a", int_ ^ alpha, attr)));
67 BOOST_TEST((!at_c<0>(attr)));
68 BOOST_TEST((at_c<1>(attr).get() == 'a'));
69
70 at_c<1>(seq&: attr) = optional<char>(); // clear the optional
71 BOOST_TEST((test_attr("123", int_ ^ alpha, attr)));
72 BOOST_TEST((at_c<0>(attr).get() == 123));
73 BOOST_TEST((!at_c<1>(attr)));
74
75 at_c<0>(seq&: attr) = optional<int>(); // clear the optional
76 BOOST_TEST((test_attr("123a", int_ ^ alpha, attr)));
77 BOOST_TEST((at_c<0>(attr).get() == 123));
78 BOOST_TEST((at_c<1>(attr).get() == 'a'));
79
80 at_c<0>(seq&: attr) = optional<int>(); // clear the optional
81 at_c<1>(seq&: attr) = optional<char>(); // clear the optional
82 BOOST_TEST((test_attr("a123", int_ ^ alpha, attr)));
83 BOOST_TEST((at_c<0>(attr).get() == 123));
84 BOOST_TEST((at_c<1>(attr).get() == 'a'));
85 }
86
87 { // test action
88 using namespace boost::phoenix;
89 namespace phx = boost::phoenix;
90
91 optional<int> i;
92 optional<char> c;
93
94 BOOST_TEST((test("123a", (int_ ^ alpha)[(phx::ref(i) = _1, phx::ref(c) = _2)])));
95 BOOST_TEST((i.get() == 123));
96 BOOST_TEST((c.get() == 'a'));
97 }
98
99 { // test rule %=
100
101 typedef vector<optional<int>, optional<char> > attr_type;
102 attr_type attr;
103
104 rule<char const*, attr_type()> r;
105 r %= int_ ^ alpha;
106
107 BOOST_TEST((test_attr("a", r, attr)));
108 BOOST_TEST((!at_c<0>(attr)));
109 BOOST_TEST((at_c<1>(attr).get() == 'a'));
110
111 at_c<1>(seq&: attr) = optional<char>(); // clear the optional
112 BOOST_TEST((test_attr("123", r, attr)));
113 BOOST_TEST((at_c<0>(attr).get() == 123));
114 BOOST_TEST((!at_c<1>(attr)));
115
116 at_c<0>(seq&: attr) = optional<int>(); // clear the optional
117 BOOST_TEST((test_attr("123a", r, attr)));
118 BOOST_TEST((at_c<0>(attr).get() == 123));
119 BOOST_TEST((at_c<1>(attr).get() == 'a'));
120
121 at_c<0>(seq&: attr) = optional<int>(); // clear the optional
122 at_c<1>(seq&: attr) = optional<char>(); // clear the optional
123 BOOST_TEST((test_attr("a123", r, attr)));
124 BOOST_TEST((at_c<0>(attr).get() == 123));
125 BOOST_TEST((at_c<1>(attr).get() == 'a'));
126 }
127
128 return boost::report_errors();
129}
130
131

source code of boost/libs/spirit/test/qi/permutation.cpp