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/config/warning_disable.hpp>
7 #include <boost/detail/lightweight_test.hpp>
8
9 #include <boost/spirit/include/karma_operator.hpp>
10 #include <boost/spirit/include/karma_char.hpp>
11 #include <boost/spirit/include/karma_auxiliary.hpp>
12 #include <boost/spirit/include/karma_string.hpp>
13 #include <boost/spirit/include/karma_numeric.hpp>
14 #include <boost/spirit/include/karma_nonterminal.hpp>
15 #include <boost/spirit/include/karma_action.hpp>
16 #include <boost/spirit/include/phoenix_core.hpp>
17 #include <boost/spirit/include/phoenix_operator.hpp>
18
19 #include "test.hpp"
20
21 using namespace spirit_test;
22
23 ///////////////////////////////////////////////////////////////////////////////
main()24 int main()
25 {
26 using namespace boost;
27 using namespace boost::spirit;
28 using namespace boost::spirit::ascii;
29
30 typedef spirit_test::output_iterator<char>::type outiter_type;
31
32 // basic tests
33 {
34 karma::rule<outiter_type> start;
35
36 start = char_[_1 = 'a'] << int_[_1 = 10] << double_[_1 = 12.4];
37 BOOST_TEST(test("a1012.4", start));
38
39 start = (char_ << int_ << double_)[(_1 = 'a', _2 = 10, _3 = 12.4)];
40 BOOST_TEST(test("a1012.4", start));
41
42 karma::rule<outiter_type> a, b, c;
43 a = char_[_1 = 'a'];
44 b = int_[_1 = 10];
45 c = double_[_1 = 12.4];
46
47 start = a << b << c;
48 BOOST_TEST(test("a1012.4", start));
49 }
50
51 // basic tests with delimiter
52 {
53 karma::rule<outiter_type, space_type> start;
54
55 start = char_[_1 = 'a'] << int_[_1 = 10] << double_[_1 = 12.4];
56 BOOST_TEST(test_delimited("a 10 12.4 ", start, space));
57
58 start = (char_ << int_ << double_)[(_1 = 'a', _2 = 10, _3 = 12.4)];
59 BOOST_TEST(test_delimited("a 10 12.4 ", start, space));
60
61 karma::rule<outiter_type, space_type> a, b, c;
62 a = char_[_1 = 'a'];
63 b = int_[_1 = 10];
64 c = double_[_1 = 12.4];
65
66 start = a << b << c;
67 BOOST_TEST(test_delimited("a 10 12.4 ", start, space));
68 }
69
70 // basic tests involving a direct parameter
71 {
72 typedef variant<char, int, double> var_type;
73
74 karma::rule<outiter_type, var_type()> start;
75
76 start = (char_ | int_ | double_)[_1 = _r0];
77
78 var_type v ('a');
79 BOOST_TEST(test("a", start, v));
80 v = 10;
81 BOOST_TEST(test("10", start, v));
82 v = 12.4;
83 BOOST_TEST(test("12.4", start, v));
84 }
85
86 {
87 typedef variant<char, int, double> var_type;
88
89 karma::rule<outiter_type, space_type, var_type()> start;
90
91 start = (char_ | int_ | double_)[_1 = _r0];
92
93 var_type v ('a');
94 BOOST_TEST(test_delimited("a ", start, v, space));
95 v = 10;
96 BOOST_TEST(test_delimited("10 ", start, v, space));
97 v = 12.4;
98 BOOST_TEST(test_delimited("12.4 ", start, v, space));
99 }
100
101 // test handling of single element fusion sequences
102 {
103 using boost::fusion::vector;
104 karma::rule<outiter_type, vector<int>()> r = int_;
105
106 vector<int> v(1);
107 BOOST_TEST(test("1", r, v));
108 }
109
110 {
111 using boost::fusion::vector;
112 karma::rule<outiter_type, space_type, vector<int>()> r = int_;
113
114 vector<int> v(1);
115 BOOST_TEST(test_delimited("1 ", r, v, space));
116 }
117
118 return boost::report_errors();
119 }
120
121