1///////////////////////////////////////////////////////////////////////////////
2// test_typeof.cpp
3//
4// Copyright 2008 David Jenkins. Distributed under the Boost
5// Software License, Version 1.0. (See accompanying file
6// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7
8#define BOOST_TYPEOF_LIMIT_SIZE 200
9#define BOOST_TYPEOF_EMULATION 1
10
11#include <string>
12#include <boost/version.hpp>
13#include <boost/xpressive/xpressive_static.hpp>
14#include <boost/xpressive/xpressive_typeof.hpp>
15#include <boost/test/unit_test.hpp>
16
17// I couldn't find these registrations anywhere else, so I put them here
18// They are necessary for this program to compile
19#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
20BOOST_TYPEOF_REGISTER_TEMPLATE(boost::mpl::int_, (int))
21BOOST_TYPEOF_REGISTER_TEMPLATE(boost::reference_wrapper, (typename))
22
23// Here's the test for typeof registration, to be used on static regular expressions
24#define TYPEOF_TEST(Expr) { BOOST_PROTO_AUTO(Dummy, Expr); }
25
26namespace xp = boost::xpressive;
27
28///////////////////////////////////////////////////////////////////////////////
29// test_misc1
30// miscelaneous regular expressions
31static void test_misc1()
32{
33 using namespace boost::xpressive;
34
35 TYPEOF_TEST(epsilon);
36 TYPEOF_TEST(nil);
37 TYPEOF_TEST(alnum);
38 TYPEOF_TEST(bos);
39 TYPEOF_TEST(eos);
40 TYPEOF_TEST(bol);
41 TYPEOF_TEST(eol);
42 TYPEOF_TEST(bow);
43 TYPEOF_TEST(eow);
44 TYPEOF_TEST(_b);
45 TYPEOF_TEST(_w);
46 TYPEOF_TEST(_d);
47 TYPEOF_TEST(_s);
48 TYPEOF_TEST(_n);
49 TYPEOF_TEST(_ln);
50 TYPEOF_TEST(_);
51 TYPEOF_TEST(self);
52}
53
54///////////////////////////////////////////////////////////////////////////////
55// test_misc2
56// miscelaneous regular expressions
57static void test_misc2()
58{
59 using namespace boost::xpressive;
60
61 TYPEOF_TEST(+set[_d | '-' | 'g']);
62 TYPEOF_TEST(+set['g' | as_xpr('-') | _d]);
63 TYPEOF_TEST(icase(+range('a','g')));
64 TYPEOF_TEST(+range('-','/'));
65 TYPEOF_TEST(+range('+','-'));
66 TYPEOF_TEST(+range('b','b'));
67 TYPEOF_TEST(icase((s1= "foo") >> *_ >> '\15'));
68 TYPEOF_TEST(repeat<2>(repeat<3>(_d) >> '-') >> repeat<4>(_d));
69 TYPEOF_TEST('f' >> +as_xpr('o'));
70 TYPEOF_TEST(icase(+(s1= "foo") >> "foobar"));
71 cregex parens = '(' >> *( keep( expr: +~(set='(',')') ) | by_ref(rex: parens) ) >> ')';
72 TYPEOF_TEST(_b >> "sublist" >> parens);
73 TYPEOF_TEST(bos >> "baz" | "bar");
74 TYPEOF_TEST(icase(*_ >> "foo"));
75 TYPEOF_TEST(icase(*_ >> "boo" | "bar"));
76 TYPEOF_TEST(icase("bar"));
77
78 TYPEOF_TEST(('f' >> repeat<1,repeat_max>('o')));
79 TYPEOF_TEST("This " >> (s1= "(has)") >> ' ' >> (s2= "parens"));
80 TYPEOF_TEST(as_xpr("This (has parens"));
81 TYPEOF_TEST(+_d);
82 TYPEOF_TEST(+~_d);
83 TYPEOF_TEST(+set[_d]);
84 TYPEOF_TEST(+set[~_d]);
85 TYPEOF_TEST(+~set[~_d]);
86 TYPEOF_TEST(+~set[_d]);
87 TYPEOF_TEST(+set[~_w | ~_d]);
88 TYPEOF_TEST(+~set[_w | _d]);
89 TYPEOF_TEST((s1= '(' >> (s2= nil) | '[' >> (s3= nil)) >> -*_ >> (s4= ')') >> s2 | ']' >> s3);
90 TYPEOF_TEST(after("foo") >> "bar");
91 TYPEOF_TEST(after(s1= 'f' >> _ >> 'o') >> "bar");
92 TYPEOF_TEST(icase(after(s1= "fo") >> 'o'));
93 TYPEOF_TEST(icase(~after(s1= "fo") >> 'o'));
94 TYPEOF_TEST(+alpha);
95 TYPEOF_TEST(+set[alpha | digit]);
96 TYPEOF_TEST(after(s1= nil) >> 'a');
97 TYPEOF_TEST(after(s1= "abc" >> repeat<3>(_d)) >> "foo");
98 TYPEOF_TEST(~before(bol) >> 'x');
99 TYPEOF_TEST(~before(bos) >> 'x');
100}
101
102///////////////////////////////////////////////////////////////////////////////
103// test_misc3
104// miscelaneous regular expressions
105
106static void test_misc3()
107{
108 using namespace boost::xpressive;
109
110 TYPEOF_TEST(as_xpr("foo"));
111 TYPEOF_TEST('b' >> *_ >> "ar");
112 TYPEOF_TEST('b' >> *_ >> 'r');
113 TYPEOF_TEST('b' >> +_ >> "ar");
114 TYPEOF_TEST('b' >> +_ >> 'r');
115 TYPEOF_TEST('b' >> +_ >> "oo");
116 TYPEOF_TEST(bos >> "foo");
117 TYPEOF_TEST(bos >> 'b' >> *_ >> "ar");
118 TYPEOF_TEST('b' >> +_ >> "ar" >> eos);
119 TYPEOF_TEST('b' >> +_ >> 'o' >> eos);
120 TYPEOF_TEST(bos >> (s1= !(set='-','+') >> +range('0','9')
121 >> !(s2= '.' >> *range('0','9')))
122 >> (s3= (set='C','F')) >> eos);
123 TYPEOF_TEST( !(s1= as_xpr('+')|'-') >> (s2= +range('0','9') >> !as_xpr('.') >> *range('0','9') |
124 '.' >> +range('0','9')) >> !(s3= (set='e','E') >> !(s4= as_xpr('+')|'-') >> +range('0','9')));
125 TYPEOF_TEST('f' | icase('g'));
126 TYPEOF_TEST(icase(+lower));
127 TYPEOF_TEST(icase(+as_xpr('\x61')));
128 TYPEOF_TEST(icase(+set['\x61']));
129 TYPEOF_TEST(icase(+as_xpr('\x0061')));
130 TYPEOF_TEST(icase(+set['\x0061']));
131 TYPEOF_TEST('a' >> +(s1= 'b' | (s2= *(s3= 'c'))) >> 'd');
132 TYPEOF_TEST('a' >> +(s1= 'b' | (s2= !(s3= 'c'))) >> 'd');
133 TYPEOF_TEST(*as_xpr('a') >> *as_xpr('a') >> *as_xpr('a') >> *as_xpr('a') >> *as_xpr('a') >> 'b');
134 TYPEOF_TEST(*set[range('a','z') | range('A','Z')]);
135}
136
137///////////////////////////////////////////////////////////////////////////////
138// test_misc4
139// miscelaneous regular expressions
140static void test_misc4()
141{
142 using namespace boost::xpressive;
143 TYPEOF_TEST('a' >> bos >> 'b');
144 TYPEOF_TEST(as_xpr("a^b"));
145 TYPEOF_TEST('a' >> ~set[' '] >> 'b');
146 TYPEOF_TEST('a' >> ~set['^'] >> 'b');
147 TYPEOF_TEST('a' >> ~set['^'] >> 'b');
148 TYPEOF_TEST('a' >> set['^'] >> 'b');
149 TYPEOF_TEST(icase("foo" >> before("bar")));
150 TYPEOF_TEST(icase("foo" >> ~before("bar")));
151 TYPEOF_TEST(icase("foo" >> ~before("bar")));
152 TYPEOF_TEST(icase(+(s1= keep(s2= "foo") >> "bar")));
153 TYPEOF_TEST(+(s1= "bar" | (s2= "foo")));
154 TYPEOF_TEST(+(s1= (s2= "bar") | "foo"));
155 TYPEOF_TEST(+(s1= "foo" | (s2= "bar")));
156 TYPEOF_TEST(+(s1= (s2= "foo") | "bar"));
157 TYPEOF_TEST((s1= icase("FOO")) >> (s2= -*_) >> s1);
158 TYPEOF_TEST((s1= icase("FOO")) >> (s2= -*_) >> icase(s1));
159 TYPEOF_TEST(+(s1= "foo" | icase(s1 >> 'O')));
160 TYPEOF_TEST((bos >> set[range('A','Z') | range('a','m')]));
161 TYPEOF_TEST(('f' >> repeat<2,5>('o')));
162 TYPEOF_TEST(('f' >> -repeat<2,5>('o')));
163 TYPEOF_TEST(('f' >> repeat<2,5>('o') >> 'o'));
164 TYPEOF_TEST(('f' >> -repeat<2,5>('o') >> 'o'));
165 TYPEOF_TEST(bos >> '{' >> *_ >> '}' >> eos);
166 TYPEOF_TEST(+(set='+','-'));
167 TYPEOF_TEST(+(set='-','+'));
168}
169
170///////////////////////////////////////////////////////////////////////////////
171// test_misc5
172// miscelaneous regular expressions
173static void test_misc5()
174{
175 using namespace boost::xpressive;
176 TYPEOF_TEST(bos >> ('(' >> (s1= nil) | (s2= nil)) >> +_w >> (')' >> s1 | s2) >> eos);
177 TYPEOF_TEST(+~alpha);
178 TYPEOF_TEST(+set[alpha | ~alpha]);
179 TYPEOF_TEST(+~set[~alpha]);
180 TYPEOF_TEST(as_xpr("[[:alpha:]\\y]+"));
181 TYPEOF_TEST(+~set[~alnum | ~digit]);
182 TYPEOF_TEST(icase(bos >> repeat<4>(s1= 'a' >> !s1) >> eos));
183 TYPEOF_TEST(as_xpr("foo") >> /*This is a comment[*/ "bar");
184 TYPEOF_TEST(bos >> "foobar" >> eos);
185 TYPEOF_TEST(bos >> 'f' >> *as_xpr('o'));
186 TYPEOF_TEST(bos >> 'f' >> *as_xpr('\157'));
187 TYPEOF_TEST(bos >> ("foo" >> set[' '] >> "bar") >> eos /*This is a comment*/);
188}
189
190///////////////////////////////////////////////////////////////////////////////
191// test_misc6
192// miscelaneous regular expressions
193static void test_misc6()
194{
195 using namespace boost::xpressive;
196 TYPEOF_TEST(bos >> *(s1= optional('a')) >> eos);
197 TYPEOF_TEST(bos >> -*(s1= optional('a')) >> eos);
198 TYPEOF_TEST(bos >> repeat<2>(s1= optional('b')) >> "bc" >> eos);
199 TYPEOF_TEST(bos >> *(s1= optional('b')) >> 'd' >> eos);
200 TYPEOF_TEST(bos >> -repeat<2>(s1= optional('b')) >> "bc" >> eos);
201 TYPEOF_TEST(bos >> -*(s1= optional('b')) >> 'd' >> eos);
202 TYPEOF_TEST(bos >> repeat<2>(s1= -optional('b')) >> "bc" >> eos);
203 TYPEOF_TEST(bos >> *(s1= -optional('b')) >> 'd' >> eos);
204 TYPEOF_TEST(bos >> -repeat<2>(s1= -optional('b')) >> "bc" >> eos);
205 TYPEOF_TEST(bos >> -*(s1= -optional('b')) >> 'd' >> eos);
206 TYPEOF_TEST(bos >> *(s1= nil | nil | nil | 'b') >> "bc" >> eos);
207 TYPEOF_TEST(bos >> -*(s1= nil | nil | nil | 'b') >> "bc" >> eos);
208 TYPEOF_TEST(icase(+range('Z','a')));
209 TYPEOF_TEST(+range('Z','a'));
210}
211
212// These functions are defined in test_typeof2.cpp
213void test_actions();
214void test_symbols();
215void test_assert();
216
217using namespace boost::unit_test;
218
219///////////////////////////////////////////////////////////////////////////////
220// init_unit_test_suite
221//
222test_suite* init_unit_test_suite( int argc, char* argv[] )
223{
224 test_suite *test = BOOST_TEST_SUITE("test_typeof");
225 test->add(BOOST_TEST_CASE(&test_misc1));
226 test->add(BOOST_TEST_CASE(&test_misc2));
227 test->add(BOOST_TEST_CASE(&test_misc3));
228 test->add(BOOST_TEST_CASE(&test_misc4));
229 test->add(BOOST_TEST_CASE(&test_misc5));
230 test->add(BOOST_TEST_CASE(&test_misc6));
231 test->add(BOOST_TEST_CASE(&test_actions));
232 test->add(BOOST_TEST_CASE(&test_symbols));
233 test->add(BOOST_TEST_CASE(&test_assert));
234 return test;
235}
236

source code of boost/libs/xpressive/test/test_typeof.cpp