1 // Copyright (c) 2001-2011 Hartmut Kaiser
2 // Copyright (c) 2001-2011 Joel de Guzman
3 // Copyright (c)      2010 Bryce Lelbach
4 //
5 // Distributed under the Boost Software License, Version 1.0. (See accompanying
6 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7 
8 #include <boost/config/warning_disable.hpp>
9 #include <boost/detail/lightweight_test.hpp>
10 
11 #include <boost/spirit/include/qi.hpp>
12 #include <boost/spirit/include/support_utree.hpp>
13 #include <boost/mpl/print.hpp>
14 
15 #include <sstream>
16 
17 #include "test.hpp"
18 
check(boost::spirit::utree const & val,std::string expected)19 inline bool check(boost::spirit::utree const& val, std::string expected)
20 {
21     std::stringstream s;
22     s << val;
23     if (s.str() == expected + " ")
24         return true;
25 
26     std::cerr << "got result: " << s.str()
27               << ", expected: " << expected << std::endl;
28     return false;
29 }
30 
main()31 int main()
32 {
33     using spirit_test::test_attr;
34     using boost::spirit::utree;
35     using boost::spirit::utree_type;
36     using boost::spirit::utf8_string_range_type;
37     using boost::spirit::utf8_symbol_type;
38     using boost::spirit::utf8_string_type;
39 
40     using boost::spirit::qi::real_parser;
41     using boost::spirit::qi::strict_real_policies;
42     using boost::spirit::qi::digit;
43     using boost::spirit::qi::char_;
44     using boost::spirit::qi::string;
45     using boost::spirit::qi::int_;
46     using boost::spirit::qi::double_;
47     using boost::spirit::qi::space;
48     using boost::spirit::qi::space_type;
49     using boost::spirit::qi::rule;
50     using boost::spirit::qi::as;
51     using boost::spirit::qi::lexeme;
52 
53     // alternatives
54     {
55         typedef real_parser<double, strict_real_policies<double> >
56             strict_double_type;
57         strict_double_type const strict_double = strict_double_type();
58 
59         utree ut;
60         BOOST_TEST(test_attr("10", strict_double | int_, ut) &&
61             ut.which() == utree_type::int_type && check(ut, "10"));
62         ut.clear();
63         BOOST_TEST(test_attr("10.2", strict_double | int_, ut) &&
64             ut.which() == utree_type::double_type && check(ut, "10.2"));
65 
66         rule<char const*, boost::variant<int, double>()> r1 = strict_double | int_;
67         ut.clear();
68         BOOST_TEST(test_attr("10", r1, ut) &&
69             ut.which() == utree_type::int_type && check(ut, "10"));
70         ut.clear();
71         BOOST_TEST(test_attr("10.2", r1, ut) &&
72             ut.which() == utree_type::double_type && check(ut, "10.2"));
73 
74         rule<char const*, utree()> r2 = strict_double | int_;
75         ut.clear();
76         BOOST_TEST(test_attr("10", r2, ut) &&
77             ut.which() == utree_type::int_type && check(ut, "10"));
78         ut.clear();
79         BOOST_TEST(test_attr("10.2", r2, ut) &&
80             ut.which() == utree_type::double_type && check(ut, "10.2"));
81 
82         rule<char const*, utree::list_type()> r3 = strict_double | int_;
83         ut.clear();
84         BOOST_TEST(test_attr("10", r3, ut) &&
85             ut.which() == utree_type::list_type && check(ut, "( 10 )"));
86         ut.clear();
87         BOOST_TEST(test_attr("10.2", r3, ut) &&
88             ut.which() == utree_type::list_type && check(ut, "( 10.2 )"));
89     }
90 
91     // optionals
92     {
93         utree ut;
94 
95         BOOST_TEST(test_attr("x", -char_, ut));
96         BOOST_TEST(ut.which() == utree_type::string_type);
97         BOOST_TEST(check(ut, "\"x\""));
98         ut.clear();
99 
100         BOOST_TEST(test_attr("", -char_, ut));
101         BOOST_TEST(ut.which() == utree_type::invalid_type);
102         BOOST_TEST(check(ut, "<invalid>"));
103         ut.clear();
104 
105         BOOST_TEST(test_attr("1x", int_ >> -char_, ut));
106         BOOST_TEST(ut.which() == utree_type::list_type);
107         BOOST_TEST(check(ut, "( 1 \"x\" )"));
108         ut.clear();
109 
110         BOOST_TEST(test_attr("1", int_ >> -char_, ut));
111         BOOST_TEST(ut.which() == utree_type::list_type);
112         BOOST_TEST(check(ut, "( 1 )"));
113         ut.clear();
114 
115         BOOST_TEST(test_attr("1x", -int_ >> char_, ut));
116         BOOST_TEST(ut.which() == utree_type::list_type);
117         BOOST_TEST(check(ut, "( 1 \"x\" )"));
118         ut.clear();
119 
120         BOOST_TEST(test_attr("x", -int_ >> char_, ut));
121         BOOST_TEST(ut.which() == utree_type::list_type);
122         BOOST_TEST(check(ut, "( \"x\" )"));
123         ut.clear();
124 
125         rule<char const*, utree::list_type()> r1 = int_ >> -char_;
126 
127         BOOST_TEST(test_attr("1x", r1, ut));
128         BOOST_TEST(ut.which() == utree_type::list_type);
129         BOOST_TEST(check(ut, "( 1 \"x\" )"));
130         ut.clear();
131 
132         BOOST_TEST(test_attr("1", r1, ut));
133         BOOST_TEST(ut.which() == utree_type::list_type);
134         BOOST_TEST(check(ut, "( 1 )"));
135         ut.clear();
136 
137         rule<char const*, utree::list_type()> r2 = -int_ >> char_;
138 
139         BOOST_TEST(test_attr("1x", r2, ut));
140         BOOST_TEST(ut.which() == utree_type::list_type);
141         BOOST_TEST(check(ut, "( 1 \"x\" )"));
142         ut.clear();
143 
144         BOOST_TEST(test_attr("x", r2, ut));
145         BOOST_TEST(ut.which() == utree_type::list_type);
146         BOOST_TEST(check(ut, "( \"x\" )"));
147         ut.clear();
148 
149         rule<char const*, utree()> r3 = int_;
150 
151         BOOST_TEST(test_attr("1", -r3, ut));
152         BOOST_TEST(ut.which() == utree_type::int_type);
153         BOOST_TEST(check(ut, "1"));
154         ut.clear();
155 
156         BOOST_TEST(test_attr("", -r3, ut));
157         BOOST_TEST(ut.which() == utree_type::invalid_type);
158         BOOST_TEST(check(ut, "<invalid>"));
159         ut.clear();
160     }
161 
162     // as_string
163     {
164         using boost::spirit::qi::as_string;
165 
166         utree ut;
167         BOOST_TEST(test_attr("xy", as_string[char_ >> char_], ut) &&
168             ut.which() == utree_type::string_type && check(ut, "\"xy\""));
169         ut.clear();
170 
171         BOOST_TEST(test_attr("ab1.2", as_string[*~digit] >> double_, ut) &&
172             ut.which() == utree_type::list_type && check(ut, "( \"ab\" 1.2 )"));
173         ut.clear();
174 
175         BOOST_TEST(test_attr("xy", as_string[*char_], ut) &&
176             ut.which() == utree_type::string_type && check(ut, "\"xy\""));
177         ut.clear();
178 
179         BOOST_TEST(test_attr("x,y", as_string[char_ >> ',' >> char_], ut) &&
180             ut.which() == utree_type::string_type && check(ut, "\"xy\""));
181         ut.clear();
182 
183         BOOST_TEST(test_attr("x,y", char_ >> ',' >> char_, ut) &&
184             ut.which() == utree_type::list_type && check(ut, "( \"x\" \"y\" )"));
185         ut.clear();
186 
187         BOOST_TEST(test_attr("a,b1.2", as_string[~digit % ','] >> double_, ut) &&
188             ut.which() == utree_type::list_type && check(ut, "( \"ab\" 1.2 )"));
189         ut.clear();
190 
191         BOOST_TEST(test_attr("a,b1.2", ~digit % ',' >> double_, ut) &&
192             ut.which() == utree_type::list_type && check(ut, "( \"a\" \"b\" 1.2 )"));
193         ut.clear();
194     }
195 
196     return boost::report_errors();
197 }
198