1 | // switch_test.cpp -- The Boost Lambda Library -------------------------- |
2 | // |
3 | // Copyright (C) 2000-2003 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) |
4 | // Copyright (C) 2000-2003 Gary Powell (powellg@amazon.com) |
5 | // |
6 | // Distributed under the Boost Software License, Version 1.0. (See |
7 | // accompanying file LICENSE_1_0.txt or copy at |
8 | // http://www.boost.org/LICENSE_1_0.txt) |
9 | // |
10 | // For more information, see www.boost.org |
11 | |
12 | // ----------------------------------------------------------------------- |
13 | |
14 | |
15 | #include <boost/core/lightweight_test.hpp> |
16 | #define BOOST_CHECK BOOST_TEST |
17 | |
18 | |
19 | #include "boost/lambda/lambda.hpp" |
20 | #include "boost/lambda/if.hpp" |
21 | #include "boost/lambda/switch.hpp" |
22 | |
23 | #include <iostream> |
24 | #include <algorithm> |
25 | #include <vector> |
26 | #include <string> |
27 | |
28 | |
29 | |
30 | // Check that elements 0 -- index are 1, and the rest are 0 |
31 | bool check(const std::vector<int>& v, int index) { |
32 | using namespace boost::lambda; |
33 | int counter = 0; |
34 | std::vector<int>::const_iterator |
35 | result = std::find_if(first: v.begin(), last: v.end(), |
36 | pred: ! if_then_else_return( |
37 | a1: var(t&: counter)++ <= index, |
38 | a2: _1 == 1, |
39 | a3: _1 == 0) |
40 | ); |
41 | return result == v.end(); |
42 | } |
43 | |
44 | |
45 | |
46 | void do_switch_no_defaults_tests() { |
47 | |
48 | using namespace boost::lambda; |
49 | |
50 | int i = 0; |
51 | std::vector<int> v,w; |
52 | |
53 | // elements from 0 to 9 |
54 | std::generate_n(first: std::back_inserter(x&: v), |
55 | n: 10, |
56 | gen: var(t&: i)++); |
57 | std::fill_n(first: std::back_inserter(x&: w), n: 10, value: 0); |
58 | |
59 | // --- |
60 | std::for_each(first: v.begin(), last: v.end(), |
61 | f: switch_statement( |
62 | ta: _1, |
63 | a0: case_statement<0>(a: ++var(t&: w[0])) |
64 | ) |
65 | ); |
66 | |
67 | BOOST_CHECK(check(w, 0)); |
68 | std::fill_n(first: w.begin(), n: 10, value: 0); |
69 | |
70 | // --- |
71 | std::for_each(first: v.begin(), last: v.end(), |
72 | f: switch_statement( |
73 | ta: _1, |
74 | a0: case_statement<0>(a: ++var(t&: w[0])), |
75 | a1: case_statement<1>(a: ++var(t&: w[1])) |
76 | ) |
77 | ); |
78 | |
79 | BOOST_CHECK(check(w, 1)); |
80 | std::fill_n(first: w.begin(), n: 10, value: 0); |
81 | |
82 | // --- |
83 | std::for_each(first: v.begin(), last: v.end(), |
84 | f: switch_statement( |
85 | ta: _1, |
86 | a0: case_statement<0>(a: ++var(t&: w[0])), |
87 | a1: case_statement<1>(a: ++var(t&: w[1])), |
88 | a2: case_statement<2>(a: ++var(t&: w[2])) |
89 | ) |
90 | ); |
91 | |
92 | BOOST_CHECK(check(w, 2)); |
93 | std::fill_n(first: w.begin(), n: 10, value: 0); |
94 | |
95 | // --- |
96 | std::for_each(first: v.begin(), last: v.end(), |
97 | f: switch_statement( |
98 | ta: _1, |
99 | a0: case_statement<0>(a: ++var(t&: w[0])), |
100 | a1: case_statement<1>(a: ++var(t&: w[1])), |
101 | a2: case_statement<2>(a: ++var(t&: w[2])), |
102 | a3: case_statement<3>(a: ++var(t&: w[3])) |
103 | ) |
104 | ); |
105 | |
106 | BOOST_CHECK(check(w, 3)); |
107 | std::fill_n(first: w.begin(), n: 10, value: 0); |
108 | |
109 | // --- |
110 | std::for_each(first: v.begin(), last: v.end(), |
111 | f: switch_statement( |
112 | ta: _1, |
113 | a0: case_statement<0>(a: ++var(t&: w[0])), |
114 | a1: case_statement<1>(a: ++var(t&: w[1])), |
115 | a2: case_statement<2>(a: ++var(t&: w[2])), |
116 | a3: case_statement<3>(a: ++var(t&: w[3])), |
117 | a4: case_statement<4>(a: ++var(t&: w[4])) |
118 | ) |
119 | ); |
120 | |
121 | BOOST_CHECK(check(w, 4)); |
122 | std::fill_n(first: w.begin(), n: 10, value: 0); |
123 | |
124 | // --- |
125 | std::for_each(first: v.begin(), last: v.end(), |
126 | f: switch_statement( |
127 | ta: _1, |
128 | a0: case_statement<0>(a: ++var(t&: w[0])), |
129 | a1: case_statement<1>(a: ++var(t&: w[1])), |
130 | a2: case_statement<2>(a: ++var(t&: w[2])), |
131 | a3: case_statement<3>(a: ++var(t&: w[3])), |
132 | a4: case_statement<4>(a: ++var(t&: w[4])), |
133 | a5: case_statement<5>(a: ++var(t&: w[5])) |
134 | ) |
135 | ); |
136 | |
137 | BOOST_CHECK(check(w, 5)); |
138 | std::fill_n(first: w.begin(), n: 10, value: 0); |
139 | |
140 | // --- |
141 | std::for_each(first: v.begin(), last: v.end(), |
142 | f: switch_statement( |
143 | ta: _1, |
144 | a0: case_statement<0>(a: ++var(t&: w[0])), |
145 | a1: case_statement<1>(a: ++var(t&: w[1])), |
146 | a2: case_statement<2>(a: ++var(t&: w[2])), |
147 | a3: case_statement<3>(a: ++var(t&: w[3])), |
148 | a4: case_statement<4>(a: ++var(t&: w[4])), |
149 | a5: case_statement<5>(a: ++var(t&: w[5])), |
150 | a6: case_statement<6>(a: ++var(t&: w[6])) |
151 | ) |
152 | ); |
153 | |
154 | BOOST_CHECK(check(w, 6)); |
155 | std::fill_n(first: w.begin(), n: 10, value: 0); |
156 | |
157 | // --- |
158 | std::for_each(first: v.begin(), last: v.end(), |
159 | f: switch_statement( |
160 | ta: _1, |
161 | a0: case_statement<0>(a: ++var(t&: w[0])), |
162 | a1: case_statement<1>(a: ++var(t&: w[1])), |
163 | a2: case_statement<2>(a: ++var(t&: w[2])), |
164 | a3: case_statement<3>(a: ++var(t&: w[3])), |
165 | a4: case_statement<4>(a: ++var(t&: w[4])), |
166 | a5: case_statement<5>(a: ++var(t&: w[5])), |
167 | a6: case_statement<6>(a: ++var(t&: w[6])), |
168 | a7: case_statement<7>(a: ++var(t&: w[7])) |
169 | ) |
170 | ); |
171 | |
172 | BOOST_CHECK(check(w, 7)); |
173 | std::fill_n(first: w.begin(), n: 10, value: 0); |
174 | |
175 | // --- |
176 | std::for_each(first: v.begin(), last: v.end(), |
177 | f: switch_statement( |
178 | ta: _1, |
179 | a0: case_statement<0>(a: ++var(t&: w[0])), |
180 | a1: case_statement<1>(a: ++var(t&: w[1])), |
181 | a2: case_statement<2>(a: ++var(t&: w[2])), |
182 | a3: case_statement<3>(a: ++var(t&: w[3])), |
183 | a4: case_statement<4>(a: ++var(t&: w[4])), |
184 | a5: case_statement<5>(a: ++var(t&: w[5])), |
185 | a6: case_statement<6>(a: ++var(t&: w[6])), |
186 | a7: case_statement<7>(a: ++var(t&: w[7])), |
187 | a8: case_statement<8>(a: ++var(t&: w[8])) |
188 | ) |
189 | ); |
190 | |
191 | BOOST_CHECK(check(w, 8)); |
192 | std::fill_n(first: w.begin(), n: 10, value: 0); |
193 | |
194 | } |
195 | |
196 | |
197 | void do_switch_yes_defaults_tests() { |
198 | |
199 | using namespace boost::lambda; |
200 | |
201 | int i = 0; |
202 | std::vector<int> v,w; |
203 | |
204 | // elements from 0 to 9 |
205 | std::generate_n(first: std::back_inserter(x&: v), |
206 | n: 10, |
207 | gen: var(t&: i)++); |
208 | std::fill_n(first: std::back_inserter(x&: w), n: 10, value: 0); |
209 | |
210 | int default_count; |
211 | // --- |
212 | default_count = 0; |
213 | std::for_each(first: v.begin(), last: v.end(), |
214 | f: switch_statement( |
215 | ta: _1, |
216 | a0: default_statement(a: ++var(t&: default_count)) |
217 | ) |
218 | ); |
219 | |
220 | BOOST_CHECK(check(w, -1)); |
221 | BOOST_CHECK(default_count == 10); |
222 | std::fill_n(first: w.begin(), n: 10, value: 0); |
223 | |
224 | // --- |
225 | default_count = 0; |
226 | std::for_each(first: v.begin(), last: v.end(), |
227 | f: switch_statement( |
228 | ta: _1, |
229 | a0: case_statement<0>(a: ++var(t&: w[0])), |
230 | a1: default_statement(a: ++var(t&: default_count)) |
231 | ) |
232 | ); |
233 | |
234 | BOOST_CHECK(check(w, 0)); |
235 | BOOST_CHECK(default_count == 9); |
236 | std::fill_n(first: w.begin(), n: 10, value: 0); |
237 | |
238 | // --- |
239 | default_count = 0; |
240 | std::for_each(first: v.begin(), last: v.end(), |
241 | f: switch_statement( |
242 | ta: _1, |
243 | a0: case_statement<0>(a: ++var(t&: w[0])), |
244 | a1: case_statement<1>(a: ++var(t&: w[1])), |
245 | a2: default_statement(a: ++var(t&: default_count)) |
246 | ) |
247 | ); |
248 | |
249 | BOOST_CHECK(check(w, 1)); |
250 | BOOST_CHECK(default_count == 8); |
251 | std::fill_n(first: w.begin(), n: 10, value: 0); |
252 | |
253 | // --- |
254 | default_count = 0; |
255 | std::for_each(first: v.begin(), last: v.end(), |
256 | f: switch_statement( |
257 | ta: _1, |
258 | a0: case_statement<0>(a: ++var(t&: w[0])), |
259 | a1: case_statement<1>(a: ++var(t&: w[1])), |
260 | a2: case_statement<2>(a: ++var(t&: w[2])), |
261 | a3: default_statement(a: ++var(t&: default_count)) |
262 | ) |
263 | ); |
264 | |
265 | BOOST_CHECK(check(w, 2)); |
266 | BOOST_CHECK(default_count == 7); |
267 | std::fill_n(first: w.begin(), n: 10, value: 0); |
268 | |
269 | // --- |
270 | default_count = 0; |
271 | std::for_each(first: v.begin(), last: v.end(), |
272 | f: switch_statement( |
273 | ta: _1, |
274 | a0: case_statement<0>(a: ++var(t&: w[0])), |
275 | a1: case_statement<1>(a: ++var(t&: w[1])), |
276 | a2: case_statement<2>(a: ++var(t&: w[2])), |
277 | a3: case_statement<3>(a: ++var(t&: w[3])), |
278 | a4: default_statement(a: ++var(t&: default_count)) |
279 | ) |
280 | ); |
281 | |
282 | BOOST_CHECK(check(w, 3)); |
283 | BOOST_CHECK(default_count == 6); |
284 | std::fill_n(first: w.begin(), n: 10, value: 0); |
285 | |
286 | // --- |
287 | default_count = 0; |
288 | std::for_each(first: v.begin(), last: v.end(), |
289 | f: switch_statement( |
290 | ta: _1, |
291 | a0: case_statement<0>(a: ++var(t&: w[0])), |
292 | a1: case_statement<1>(a: ++var(t&: w[1])), |
293 | a2: case_statement<2>(a: ++var(t&: w[2])), |
294 | a3: case_statement<3>(a: ++var(t&: w[3])), |
295 | a4: case_statement<4>(a: ++var(t&: w[4])), |
296 | a5: default_statement(a: ++var(t&: default_count)) |
297 | ) |
298 | ); |
299 | |
300 | BOOST_CHECK(check(w, 4)); |
301 | BOOST_CHECK(default_count == 5); |
302 | std::fill_n(first: w.begin(), n: 10, value: 0); |
303 | |
304 | // --- |
305 | default_count = 0; |
306 | std::for_each(first: v.begin(), last: v.end(), |
307 | f: switch_statement( |
308 | ta: _1, |
309 | a0: case_statement<0>(a: ++var(t&: w[0])), |
310 | a1: case_statement<1>(a: ++var(t&: w[1])), |
311 | a2: case_statement<2>(a: ++var(t&: w[2])), |
312 | a3: case_statement<3>(a: ++var(t&: w[3])), |
313 | a4: case_statement<4>(a: ++var(t&: w[4])), |
314 | a5: case_statement<5>(a: ++var(t&: w[5])), |
315 | a6: default_statement(a: ++var(t&: default_count)) |
316 | ) |
317 | ); |
318 | |
319 | BOOST_CHECK(check(w, 5)); |
320 | BOOST_CHECK(default_count == 4); |
321 | std::fill_n(first: w.begin(), n: 10, value: 0); |
322 | |
323 | // --- |
324 | default_count = 0; |
325 | std::for_each(first: v.begin(), last: v.end(), |
326 | f: switch_statement( |
327 | ta: _1, |
328 | a0: case_statement<0>(a: ++var(t&: w[0])), |
329 | a1: case_statement<1>(a: ++var(t&: w[1])), |
330 | a2: case_statement<2>(a: ++var(t&: w[2])), |
331 | a3: case_statement<3>(a: ++var(t&: w[3])), |
332 | a4: case_statement<4>(a: ++var(t&: w[4])), |
333 | a5: case_statement<5>(a: ++var(t&: w[5])), |
334 | a6: case_statement<6>(a: ++var(t&: w[6])), |
335 | a7: default_statement(a: ++var(t&: default_count)) |
336 | ) |
337 | ); |
338 | |
339 | BOOST_CHECK(check(w, 6)); |
340 | BOOST_CHECK(default_count == 3); |
341 | std::fill_n(first: w.begin(), n: 10, value: 0); |
342 | |
343 | // --- |
344 | default_count = 0; |
345 | std::for_each(first: v.begin(), last: v.end(), |
346 | f: switch_statement( |
347 | ta: _1, |
348 | a0: case_statement<0>(a: ++var(t&: w[0])), |
349 | a1: case_statement<1>(a: ++var(t&: w[1])), |
350 | a2: case_statement<2>(a: ++var(t&: w[2])), |
351 | a3: case_statement<3>(a: ++var(t&: w[3])), |
352 | a4: case_statement<4>(a: ++var(t&: w[4])), |
353 | a5: case_statement<5>(a: ++var(t&: w[5])), |
354 | a6: case_statement<6>(a: ++var(t&: w[6])), |
355 | a7: case_statement<7>(a: ++var(t&: w[7])), |
356 | a8: default_statement(a: ++var(t&: default_count)) |
357 | ) |
358 | ); |
359 | |
360 | BOOST_CHECK(check(w, 7)); |
361 | BOOST_CHECK(default_count == 2); |
362 | std::fill_n(first: w.begin(), n: 10, value: 0); |
363 | |
364 | } |
365 | |
366 | void test_empty_cases() { |
367 | |
368 | using namespace boost::lambda; |
369 | |
370 | // --- |
371 | switch_statement( |
372 | ta: _1, |
373 | a0: default_statement() |
374 | )(make_const(t: 1)); |
375 | |
376 | switch_statement( |
377 | ta: _1, |
378 | a0: case_statement<1>() |
379 | )(make_const(t: 1)); |
380 | |
381 | } |
382 | |
383 | int main() { |
384 | |
385 | do_switch_no_defaults_tests(); |
386 | do_switch_yes_defaults_tests(); |
387 | |
388 | test_empty_cases(); |
389 | |
390 | return boost::report_errors(); |
391 | |
392 | } |
393 | |