1 | /*============================================================================= |
---|
2 | Copyright (c) 2003 Martin Wille |
---|
3 | http://spirit.sourceforge.net/ |
---|
4 | |
---|
5 | Use, modification and distribution is subject to the Boost Software |
---|
6 | License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at |
---|
7 | http://www.boost.org/LICENSE_1_0.txt) |
---|
8 | =============================================================================*/ |
---|
9 | // vi:ts=4:sw=4:et |
---|
10 | // Tests for spirit::for_p |
---|
11 | // [13-Jan-2003] |
---|
12 | //////////////////////////////////////////////////////////////////////////////// |
---|
13 | #define qDebug 0 |
---|
14 | #include <iostream> |
---|
15 | #include <cstring> |
---|
16 | #if qDebug |
---|
17 | #define SPIRIT_DEBUG |
---|
18 | #endif |
---|
19 | #include <string> |
---|
20 | #include <boost/spirit/core.hpp> |
---|
21 | #include <boost/spirit/actor/assign_actor.hpp> |
---|
22 | #include <boost/spirit/dynamic/for.hpp> |
---|
23 | #include <boost/ref.hpp> |
---|
24 | #include "impl/string_length.hpp" |
---|
25 | |
---|
26 | namespace local |
---|
27 | { |
---|
28 | template <typename T> |
---|
29 | struct var_wrapper |
---|
30 | : public ::boost::reference_wrapper<T> |
---|
31 | { |
---|
32 | typedef ::boost::reference_wrapper<T> parent; |
---|
33 | |
---|
34 | explicit inline var_wrapper(T& t) : parent(t) {} |
---|
35 | |
---|
36 | inline T& operator()() const { return parent::get(); } |
---|
37 | }; |
---|
38 | |
---|
39 | template <typename T> |
---|
40 | inline var_wrapper<T> |
---|
41 | var(T& t) |
---|
42 | { |
---|
43 | return var_wrapper<T>(t); |
---|
44 | } |
---|
45 | } |
---|
46 | |
---|
47 | namespace |
---|
48 | { |
---|
49 | template <typename T> |
---|
50 | class add_actor |
---|
51 | { |
---|
52 | public: |
---|
53 | explicit add_actor(T &ref_) : ref(ref_) {} |
---|
54 | |
---|
55 | template <typename T2> |
---|
56 | void operator()(T2 const &val) const |
---|
57 | { ref += val; } |
---|
58 | |
---|
59 | private: |
---|
60 | T& ref; |
---|
61 | }; |
---|
62 | |
---|
63 | template <typename T> |
---|
64 | inline add_actor<T> const |
---|
65 | add(T& ref) |
---|
66 | { |
---|
67 | return add_actor<T>(ref); |
---|
68 | } |
---|
69 | } |
---|
70 | |
---|
71 | typedef ::boost::spirit::rule<> rule_t; |
---|
72 | |
---|
73 | unsigned int test_count = 0; |
---|
74 | unsigned int error_count = 0; |
---|
75 | |
---|
76 | unsigned int iterations_performed; |
---|
77 | unsigned int iterations_desired; |
---|
78 | std::string input_matched; |
---|
79 | |
---|
80 | //static const unsigned int kError = 999; |
---|
81 | static const bool good = true; |
---|
82 | static const bool bad = false; |
---|
83 | |
---|
84 | rule_t for_rule; |
---|
85 | rule_t for_rule2; |
---|
86 | |
---|
87 | void |
---|
88 | test_for |
---|
89 | ( |
---|
90 | char const *s, |
---|
91 | bool succeed, |
---|
92 | rule_t const &r, |
---|
93 | unsigned int iterations_expected |
---|
94 | ) |
---|
95 | { |
---|
96 | using namespace std; |
---|
97 | |
---|
98 | ++test_count; |
---|
99 | |
---|
100 | iterations_performed = 0; |
---|
101 | |
---|
102 | ::boost::spirit::parse_info<> m = ::boost::spirit::parse(s, s + test_impl::string_length(s), r); |
---|
103 | |
---|
104 | bool result = (succeed==m.full)?good:bad; |
---|
105 | |
---|
106 | if (m.full && (m.length != test_impl::string_length(s))) |
---|
107 | result = bad; |
---|
108 | |
---|
109 | result &= iterations_expected == iterations_performed; |
---|
110 | |
---|
111 | if (result==good) |
---|
112 | cout << "PASSED"; |
---|
113 | else |
---|
114 | { |
---|
115 | ++error_count; |
---|
116 | cout << "FAILED"; |
---|
117 | } |
---|
118 | |
---|
119 | cout << ": \"" << s << "\" ==> "; |
---|
120 | if (!m.full) |
---|
121 | cout << "<error>"; |
---|
122 | else |
---|
123 | cout << '"' << input_matched << '"'; |
---|
124 | |
---|
125 | cout << " " << iterations_performed << " of " |
---|
126 | << iterations_desired << " iterations\n"; |
---|
127 | } |
---|
128 | |
---|
129 | namespace |
---|
130 | { |
---|
131 | void zero() { iterations_performed = 0; } |
---|
132 | |
---|
133 | struct inc |
---|
134 | { |
---|
135 | inline void operator()() const { ++iterations_performed; } |
---|
136 | }; |
---|
137 | struct cmp |
---|
138 | { |
---|
139 | inline bool operator()() const |
---|
140 | { |
---|
141 | return iterations_performed<iterations_desired; |
---|
142 | } |
---|
143 | }; |
---|
144 | } |
---|
145 | |
---|
146 | int |
---|
147 | main() |
---|
148 | { |
---|
149 | using namespace std; |
---|
150 | |
---|
151 | using boost::spirit::uint_p; |
---|
152 | using boost::spirit::for_p; |
---|
153 | using boost::spirit::assign_a; |
---|
154 | |
---|
155 | #if qDebug |
---|
156 | SPIRIT_DEBUG_RULE(for_rule); |
---|
157 | SPIRIT_DEBUG_RULE(for_rule2); |
---|
158 | #endif |
---|
159 | |
---|
160 | for_rule |
---|
161 | = uint_p[assign_a(iterations_desired)] >> ':' |
---|
162 | >> for_p(&zero, cmp(), inc())["xy"] |
---|
163 | [assign_a(input_matched)] |
---|
164 | ; |
---|
165 | |
---|
166 | for_rule2 |
---|
167 | = for_p(&zero, '.', inc())["xy"] |
---|
168 | [assign_a(input_matched)] |
---|
169 | ; |
---|
170 | |
---|
171 | cout << "/////////////////////////////////////////////////////////\n"; |
---|
172 | cout << "\n"; |
---|
173 | cout << " for_p test\n"; |
---|
174 | cout << "\n"; |
---|
175 | cout << "/////////////////////////////////////////////////////////\n"; |
---|
176 | cout << "\n"; |
---|
177 | |
---|
178 | test_for("3:xyxyxy", true, for_rule, 3); |
---|
179 | test_for("3:", false, for_rule, 0); |
---|
180 | test_for("3:xyxy", false, for_rule, 2); |
---|
181 | test_for("3:xyxyxyxy", false, for_rule, 3); |
---|
182 | |
---|
183 | test_for(".xy.xy.xy", true, for_rule2, 3); |
---|
184 | test_for(".xy.xy.xy.", false, for_rule2, 3); |
---|
185 | |
---|
186 | std::cout << "\n "; |
---|
187 | if (error_count==0) |
---|
188 | cout << "All " << test_count << " for_p-tests passed.\n" |
---|
189 | << "Test concluded successfully\n"; |
---|
190 | else |
---|
191 | cout << error_count << " of " << test_count << " for_p-tests failed\n" |
---|
192 | << "Test failed\n"; |
---|
193 | |
---|
194 | return error_count!=0; |
---|
195 | } |
---|
196 | |
---|