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

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