]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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> | |
7c673cae FG |
11 | #include <boost/dynamic_bitset.hpp> |
12 | #include <boost/integer_traits.hpp> | |
92f5a8d4 TL |
13 | #if defined(_MSC_VER) && _MSC_VER < 1700 |
14 | # pragma warning(disable: 4127) // conditional expression is constant | |
15 | #endif | |
20effc67 TL |
16 | #include <boost/random/mersenne_twister.hpp> |
17 | #include <boost/random/uniform_int.hpp> | |
18 | #include <boost/random/variate_generator.hpp> | |
7c673cae | 19 | |
92f5a8d4 TL |
20 | #if defined(_MSC_VER) |
21 | # pragma warning(disable: 4127) // conditional expression is constant | |
7c673cae FG |
22 | # pragma warning(disable: 4800) // 'int' : forcing value to bool 'true' or 'false' warning |
23 | #endif | |
24 | ||
25 | template <typename Char> | |
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 | |
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 | } |