1 /*=============================================================================
2 Copyright (c) 2001-2011 Joel de Guzman
3
4 Distributed under the Boost Software License, Version 1.0. (See accompanying
5 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6 ==============================================================================*/
7 #include <iostream>
8 #include <cctype>
9 #include <boost/detail/lightweight_test.hpp>
10 #include <boost/spirit/home/support/char_set/range_run.hpp>
11 #include <boost/dynamic_bitset.hpp>
12 #include <boost/integer_traits.hpp>
13 #if defined(_MSC_VER) && _MSC_VER < 1700
14 # pragma warning(disable: 4127) // conditional expression is constant
15 #endif
16 #include <boost/random/mersenne_twister.hpp>
17 #include <boost/random/uniform_int.hpp>
18 #include <boost/random/variate_generator.hpp>
19
20 #if defined(_MSC_VER)
21 # pragma warning(disable: 4127) // conditional expression is constant
22 # pragma warning(disable: 4800) // 'int' : forcing value to bool 'true' or 'false' warning
23 #endif
24
25 template <typename Char>
acid_test()26 void acid_test()
27 {
28 if (sizeof(Char) == sizeof(unsigned))
29 return; // don't do this test if we have a Char that's very big.
30 // the smaller chars will suffice for testing.
31
32 using boost::spirit::support::detail::range_run;
33 using boost::spirit::support::detail::range;
34
35 typedef boost::integer_traits<Char> integer_traits;
36 Char const const_min = integer_traits::const_min;
37 Char const const_max = integer_traits::const_max;
38 unsigned bit_set_size = unsigned(const_max)-unsigned(const_min)+1;
39 int const test_size = 1000;
40
41 boost::mt19937 rng;
42 Char min = const_min;
43 Char max = const_max;
44 boost::uniform_int<Char> char_(min, max);
45 boost::variate_generator<boost::mt19937&, boost::uniform_int<Char> >
46 gen(rng, char_);
47 boost::uniform_int<Char> _1of10(1, 10);
48 boost::variate_generator<boost::mt19937&, boost::uniform_int<Char> >
49 on_or_off(rng, _1of10);
50
51 range_run<Char> rr;
52 boost::dynamic_bitset<unsigned> bset(bit_set_size);
53
54 for (int i = 0; i < test_size; ++i)
55 {
56 range<Char> r = range<Char>(gen(), gen());
57 if (r.first > r.last)
58 std::swap(r.first, r.last);
59
60 bool set = on_or_off() != 1;
61 if (set)
62 rr.set(r);
63 else
64 rr.clear(r);
65 for (int j = r.first; j <= int(r.last); ++j)
66 bset[j-const_min] = set;
67 }
68
69 for (int i = const_min; i <= int(const_max); ++i)
70 {
71 BOOST_TEST(rr.test(static_cast<Char>(i)) == bset[i-const_min]);
72 }
73 }
74
75 int
main()76 main()
77 {
78 using boost::spirit::support::detail::range_run;
79 using boost::spirit::support::detail::range;
80
81 {
82 range_run<char> rr;
83 rr.set(range<char>('a', 'a'));
84 for (char c = 0; c < 127; ++c)
85 {
86 BOOST_TEST((c == 'a') == rr.test(c));
87 }
88 }
89 {
90 range_run<char> rr;
91 rr.set(range<char>('a', 'z'));
92 rr.set(range<char>('A', 'Z'));
93 rr.clear(range<char>('A', 'Z'));
94 for (char c = 0; c < 127; ++c)
95 {
96 BOOST_TEST(bool(std::islower(c)) == rr.test(c));
97 }
98 }
99 {
100 range_run<char> rr;
101 rr.set(range<char>(0, 0));
102 for (char c = 0; c < 127; ++c)
103 {
104 BOOST_TEST((c == 0) == rr.test(c));
105 }
106 rr.set(range<char>(0, 50));
107 for (char c = 0; c < 127; ++c)
108 {
109 BOOST_TEST(((c >= 0) && (c <= 50)) == rr.test(c));
110 }
111 }
112 {
113 range_run<unsigned char> rr;
114 rr.set(range<unsigned char>(255, 255));
115 for (unsigned char c = 0; c < 255; ++c)
116 {
117 BOOST_TEST((c == 255) == rr.test(c));
118 }
119 rr.set(range<unsigned char>(250, 255));
120 for (unsigned char c = 0; c < 255; ++c)
121 {
122 BOOST_TEST((c >= 250) == rr.test(c));
123 }
124 }
125 {
126 range_run<char> rr;
127 rr.set(range<char>('a', 'z'));
128 rr.set(range<char>('A', 'Z'));
129 for (char c = 0; c < 127; ++c)
130 {
131 BOOST_TEST(bool(std::isalpha(c)) == rr.test(c));
132 }
133 }
134 {
135 range_run<char> rr;
136 rr.set(range<char>('a', 'z'));
137 rr.set(range<char>('A', 'Z'));
138 rr.clear(range<char>('J', 'j'));
139 for (char c = 0; c < 127; ++c)
140 {
141 BOOST_TEST((bool(std::isalpha(c)) && (c < 'J' || c > 'j')) == rr.test(c));
142 }
143 }
144 {
145 range_run<char> rr;
146 rr.set(range<char>(3, 3));
147 rr.set(range<char>(1, 5));
148 BOOST_TEST(rr.test(5));
149 }
150 {
151 range_run<char> rr;
152 for (char c = 0; c < 127; ++c)
153 {
154 if (c & 1)
155 {
156 rr.set(range<char>(c, c));
157 }
158 }
159 for (char c = 0; c < 127; ++c)
160 {
161 BOOST_TEST(bool((c & 1)) == rr.test(c));
162 }
163 rr.clear(range<char>(90, 105));
164 for (char c = 0; c < 127; ++c)
165 {
166 BOOST_TEST((bool((c & 1)) && (c < 90 || c > 105)) == rr.test(c));
167 }
168 }
169 {
170 range_run<char> rr;
171 rr.set(range<char>('c', 'e'));
172 rr.set(range<char>('g', 'i'));
173 rr.set(range<char>('d', 'k'));
174 for (char c = 'a'; c <= 'm'; ++c)
175 {
176 BOOST_TEST((c >= 'c' && c <= 'k') == rr.test(c));
177 }
178 }
179 {
180 typedef boost::integer_traits<char> traits;
181 char const const_min = traits::const_min;
182 range_run<char> rr;
183 rr.set(range<char>(const_min, const_min+16));
184 rr.clear(range<char>(const_min, const_min+8));
185 BOOST_TEST(!rr.test(const_min));
186 BOOST_TEST(!rr.test(const_min+8));
187 BOOST_TEST(rr.test(const_min+9));
188 BOOST_TEST(rr.test(const_min+16));
189 BOOST_TEST(!rr.test(const_min+17));
190 }
191 {
192 acid_test<char>();
193 acid_test<signed char>();
194 acid_test<unsigned char>();
195 acid_test<wchar_t>();
196 acid_test<short>();
197 acid_test<signed short>();
198 acid_test<unsigned short>();
199 }
200
201 return boost::report_errors();
202 }
203