]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Copyright (c) 2001-2011 Hartmut Kaiser |
2 | // | |
3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying | |
4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
5 | ||
1e59de90 | 6 | #include <boost/spirit/include/karma_kleene.hpp> |
7c673cae FG |
7 | |
8 | #include <boost/spirit/include/karma_char.hpp> | |
9 | #include <boost/spirit/include/karma_string.hpp> | |
10 | #include <boost/spirit/include/karma_numeric.hpp> | |
11 | #include <boost/spirit/include/karma_generate.hpp> | |
12 | #include <boost/spirit/include/karma_operator.hpp> | |
13 | #include <boost/spirit/include/karma_action.hpp> | |
14 | #include <boost/spirit/include/karma_nonterminal.hpp> | |
15 | #include <boost/spirit/include/karma_auxiliary.hpp> | |
16 | #include <boost/spirit/include/karma_directive.hpp> | |
7c673cae FG |
17 | |
18 | #include <boost/assign/std/vector.hpp> | |
1e59de90 TL |
19 | #include <boost/core/lightweight_test.hpp> |
20 | #include <boost/fusion/include/vector.hpp> | |
21 | #include <boost/phoenix/core.hpp> | |
22 | #include <boost/phoenix/operator.hpp> | |
23 | #include <boost/fusion/include/std_pair.hpp> | |
7c673cae FG |
24 | |
25 | #include "test.hpp" | |
26 | ||
27 | using namespace spirit_test; | |
28 | ||
29 | /////////////////////////////////////////////////////////////////////////////// | |
30 | struct action | |
31 | { | |
32 | action (std::vector<char>& vec) | |
33 | : vec(vec), it(vec.begin()) | |
34 | {} | |
35 | ||
36 | void operator()(unsigned& value, boost::spirit::unused_type, bool& pass) const | |
37 | { | |
38 | pass = (it != vec.end()); | |
39 | if (pass) | |
40 | value = *it++; | |
41 | } | |
42 | ||
43 | std::vector<char>& vec; | |
44 | mutable std::vector<char>::iterator it; | |
45 | }; | |
46 | ||
47 | struct A | |
48 | { | |
49 | double d1; | |
50 | double d2; | |
51 | }; | |
52 | ||
53 | BOOST_FUSION_ADAPT_STRUCT( | |
54 | A, | |
55 | (double, d1) | |
56 | (double, d2) | |
57 | ) | |
58 | ||
59 | /////////////////////////////////////////////////////////////////////////////// | |
60 | int main() | |
61 | { | |
62 | using namespace boost::spirit; | |
63 | using namespace boost::spirit::ascii; | |
64 | namespace fusion = boost::fusion; | |
65 | ||
66 | { | |
67 | std::string s1("aaaa"); | |
68 | BOOST_TEST(test("aaaa", *char_, s1)); | |
69 | BOOST_TEST(test_delimited("a a a a ", *char_, s1, ' ')); | |
70 | ||
71 | std::string s2(""); | |
72 | BOOST_TEST(test("", *char_, s2)); | |
73 | BOOST_TEST(test_delimited("", *char_, s2, ' ')); | |
74 | } | |
75 | ||
76 | { | |
77 | std::string s1("aaaaa"); | |
78 | BOOST_TEST(test("aaaaa", char_ << *(char_ << char_), s1)); | |
79 | BOOST_TEST(test_delimited("a a a a a ", | |
80 | char_ << *(char_ << char_), s1, ' ')); | |
81 | ||
82 | s1 = "a"; | |
83 | BOOST_TEST(test("a", char_ << *(char_ << char_), s1)); | |
84 | s1 = "aa"; | |
85 | BOOST_TEST(!test("", char_ << *(char_ << char_), s1)); | |
86 | // BOOST_TEST(test("aa", char_ << *buffer[char_ << char_] << char_, s1)); | |
87 | s1 = "aaaa"; | |
88 | BOOST_TEST(!test("", char_ << *(char_ << char_), s1)); | |
89 | // BOOST_TEST(test("aaaa", char_ << *buffer[char_ << char_] << char_, s1)); | |
90 | } | |
91 | ||
92 | { | |
93 | using boost::spirit::karma::strict; | |
94 | using boost::spirit::karma::relaxed; | |
95 | using namespace boost::assign; | |
96 | ||
97 | typedef std::pair<char, char> data; | |
98 | std::vector<data> v1; | |
99 | v1 += std::make_pair('a', 'a'), | |
100 | std::make_pair('b', 'b'), | |
101 | std::make_pair('c', 'c'), | |
102 | std::make_pair('d', 'd'), | |
103 | std::make_pair('e', 'e'), | |
104 | std::make_pair('f', 'f'), | |
105 | std::make_pair('g', 'g'); | |
106 | ||
107 | karma::rule<spirit_test::output_iterator<char>::type, data()> r; | |
108 | r = &char_('a') << char_; | |
109 | ||
110 | BOOST_TEST(test("a", r << *(r << r), v1)); | |
111 | BOOST_TEST(test("a", relaxed[r << *(r << r)], v1)); | |
112 | BOOST_TEST(!test("", strict[r << *(r << r)], v1)); | |
113 | ||
114 | v1 += std::make_pair('a', 'a'); | |
115 | ||
116 | BOOST_TEST(!test("", r << *(r << r), v1)); | |
117 | BOOST_TEST(!test("", relaxed[r << *(r << r)], v1)); | |
118 | BOOST_TEST(!test("", strict[r << *(r << r)], v1)); | |
119 | ||
120 | v1 += std::make_pair('a', 'a'); | |
121 | ||
122 | BOOST_TEST(test("aaa", r << *(r << r), v1)); | |
123 | BOOST_TEST(test("aaa", relaxed[r << *(r << r)], v1)); | |
124 | BOOST_TEST(!test("", strict[r << *(r << r)], v1)); | |
125 | } | |
126 | ||
127 | { | |
128 | using namespace boost::assign; | |
129 | ||
130 | std::vector<char> v; | |
131 | v += 'a', 'b', 'c'; | |
132 | ||
133 | BOOST_TEST(test("abc", *char_, v)); | |
134 | BOOST_TEST(test_delimited("a b c ", *char_, v, ' ')); | |
135 | } | |
136 | ||
137 | { | |
138 | using namespace boost::assign; | |
139 | ||
140 | std::vector<int> v; | |
141 | v += 10, 20, 30; | |
142 | ||
143 | BOOST_TEST(test("102030", *int_, v)); | |
144 | BOOST_TEST(test_delimited("10, 20, 30, ", *int_, v, lit(", "))); | |
145 | ||
146 | BOOST_TEST(test("10,20,30,", *(int_ << ','), v)); | |
147 | BOOST_TEST(test_delimited("10 , 20 , 30 , ", *(int_ << ','), v, lit(' '))); | |
148 | ||
149 | // leads to infinite loops | |
150 | // fusion::vector<char, char> cc ('a', 'c'); | |
151 | // BOOST_TEST(test("ac", char_ << *(lit(' ') << ',') << char_, cc)); | |
152 | // BOOST_TEST(test_delimited("a c ", | |
153 | // char_ << *(lit(' ') << ',') << char_, cc, " ")); | |
154 | } | |
155 | ||
156 | { // actions | |
157 | using namespace boost::assign; | |
158 | namespace phx = boost::phoenix; | |
159 | ||
160 | std::vector<char> v; | |
161 | v += 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'; | |
162 | ||
163 | BOOST_TEST(test("abcdefgh", (*char_)[_1 = phx::ref(v)])); | |
164 | BOOST_TEST(test_delimited("a b c d e f g h ", | |
165 | (*char_ )[_1 = phx::ref(v)], space)); | |
166 | } | |
167 | ||
168 | // failing sub-generators | |
169 | { | |
170 | using boost::spirit::karma::strict; | |
171 | using boost::spirit::karma::relaxed; | |
172 | ||
173 | using namespace boost::assign; | |
174 | ||
175 | typedef std::pair<char, char> data; | |
176 | std::vector<data> v2; | |
177 | v2 += std::make_pair('a', 'a'), | |
178 | std::make_pair('b', 'b'), | |
179 | std::make_pair('c', 'c'), | |
180 | std::make_pair('d', 'd'), | |
181 | std::make_pair('e', 'e'), | |
182 | std::make_pair('f', 'f'), | |
183 | std::make_pair('g', 'g'); | |
184 | ||
185 | karma::rule<spirit_test::output_iterator<char>::type, data()> r; | |
186 | ||
187 | r = &char_('d') << char_; | |
188 | BOOST_TEST(test("d", *r, v2)); | |
189 | BOOST_TEST(test("d", relaxed[*r], v2)); | |
190 | BOOST_TEST(test("", strict[*r], v2)); | |
191 | ||
192 | r = &char_('a') << char_; | |
193 | BOOST_TEST(test("a", *r, v2)); | |
194 | BOOST_TEST(test("a", relaxed[*r], v2)); | |
195 | BOOST_TEST(test("a", strict[*r], v2)); | |
196 | ||
197 | r = &char_('g') << char_; | |
198 | BOOST_TEST(test("g", *r, v2)); | |
199 | BOOST_TEST(test("g", relaxed[*r], v2)); | |
200 | BOOST_TEST(test("", strict[*r], v2)); | |
201 | ||
202 | r = !char_('d') << char_; | |
203 | BOOST_TEST(test("abcefg", *r, v2)); | |
204 | BOOST_TEST(test("abcefg", relaxed[*r], v2)); | |
205 | BOOST_TEST(test("abc", strict[*r], v2)); | |
206 | ||
207 | r = !char_('a') << char_; | |
208 | BOOST_TEST(test("bcdefg", *r, v2)); | |
209 | BOOST_TEST(test("bcdefg", relaxed[*r], v2)); | |
210 | BOOST_TEST(test("", strict[*r], v2)); | |
211 | ||
212 | r = !char_('g') << char_; | |
213 | BOOST_TEST(test("abcdef", *r, v2)); | |
214 | BOOST_TEST(test("abcdef", relaxed[*r], v2)); | |
215 | BOOST_TEST(test("abcdef", strict[*r], v2)); | |
216 | ||
217 | r = &char_('A') << char_; | |
218 | BOOST_TEST(test("", *r, v2)); | |
219 | } | |
220 | ||
221 | { | |
222 | // make sure user defined end condition is applied if no attribute | |
223 | // is passed in | |
224 | using namespace boost::assign; | |
225 | ||
226 | std::vector<char> v; | |
227 | v += 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'; | |
228 | BOOST_TEST(test("[6162636465666768]", '[' << *hex[action(v)] << ']')); | |
229 | } | |
230 | ||
231 | { | |
232 | using boost::spirit::karma::double_; | |
233 | ||
234 | std::vector<A> v(1); | |
235 | v[0].d1 = 1.0; | |
236 | v[0].d2 = 2.0; | |
237 | BOOST_TEST(test("A1.02.0", 'A' << *(double_ << double_), v)); | |
238 | } | |
239 | ||
240 | return boost::report_errors(); | |
241 | } | |
242 |