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
31bool 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
46void 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
197void 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
366void 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
383int 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

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