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
6#include <boost/spirit/include/karma_kleene.hpp>
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>
17
18#include <boost/assign/std/vector.hpp>
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>
24
25#include "test.hpp"
26
27using namespace spirit_test;
28
29///////////////////////////////////////////////////////////////////////////////
30struct 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
47struct A
48{
49 double d1;
50 double d2;
51};
52
53BOOST_FUSION_ADAPT_STRUCT(
54 A,
55 (double, d1)
56 (double, d2)
57)
58
59///////////////////////////////////////////////////////////////////////////////
60int 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(x: 'a', y: 'a'),
100 std::make_pair(x: 'b', y: 'b'),
101 std::make_pair(x: 'c', y: 'c'),
102 std::make_pair(x: 'd', y: 'd'),
103 std::make_pair(x: 'e', y: 'e'),
104 std::make_pair(x: 'f', y: 'f'),
105 std::make_pair(x: 'g', y: '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(x: 'a', y: '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(x: 'a', y: '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(x: 'a', y: 'a'),
178 std::make_pair(x: 'b', y: 'b'),
179 std::make_pair(x: 'c', y: 'c'),
180 std::make_pair(x: 'd', y: 'd'),
181 std::make_pair(x: 'e', y: 'e'),
182 std::make_pair(x: 'f', y: 'f'),
183 std::make_pair(x: 'g', y: '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
243

source code of boost/libs/spirit/test/karma/kleene.cpp