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
test_misc1()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
test_misc2()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( +~(set='(',')') ) | by_ref(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 
test_misc3()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
test_misc4()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
test_misc5()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
test_misc6()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 //
init_unit_test_suite(int argc,char * argv[])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