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() |
20 | BOOST_TYPEOF_REGISTER_TEMPLATE(boost::mpl::int_, (int)) |
21 | BOOST_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 | |
26 | namespace xp = boost::xpressive; |
27 | |
28 | /////////////////////////////////////////////////////////////////////////////// |
29 | // test_misc1 |
30 | // miscelaneous regular expressions |
31 | static 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 |
57 | static 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 | |
106 | static 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 |
140 | static 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 |
173 | static 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 |
193 | static 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 |
213 | void test_actions(); |
214 | void test_symbols(); |
215 | void test_assert(); |
216 | |
217 | using namespace boost::unit_test; |
218 | |
219 | /////////////////////////////////////////////////////////////////////////////// |
220 | // init_unit_test_suite |
221 | // |
222 | test_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 | |