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

source code of boost/libs/lambda/test/switch_construct.cpp