Ne.app NeANT
The Ne.app NeANT User module of the NeANT distribution.
26.mask.array.cpp
Go to the documentation of this file.
1
28#include <cstdlib> // for strtol(), size_t
29#include <valarray> // for mask_array, valarray
30
31#include <rw_driver.h>
32
33
35// returns a valarray constructed from a string of comma-separated values
36// if there are fewer than n values in the string the remaining values are
37// taken to be the same as the last one, i.e., the call
38// make_array("1,2,3", 5) returns valarray({1,2,3,3})
39template <class T>
40std::valarray<T>
41make_array (const char *s, std::size_t n = 0)
42{
43 if (0 == s || '\0' == *s)
44 return n ? std::valarray<T>(T (), n) : std::valarray<T>();
45
46 T buf [256];
47
48 for (std::size_t i = 0; ; ++i) {
49
50 char *end;
51 long val = std::strtol (s, &end, 0);
52
53 RW_ASSERT (s < end);
54 RW_ASSERT ('\0' == *end || ',' == *end);
55
56 buf [i] = T (val);
57
58 if ('\0' == *end) {
59 while (++i < n)
60 buf [i] = buf [i - 1];
61
62 return std::valarray<T>(buf, i);
63 }
64
65 s = end + 1;
66 }
67}
68
69
70std::valarray<bool>
71make_bool_array (const char *s, std::size_t n = 0)
72{
73 typedef std::valarray<bool> BoolArray;
74
75 if (0 == s || '\0' == *s)
76 return n ? BoolArray(false, n) : BoolArray ();
77
78 bool buf [256];
79
80 for (std::size_t i = 0; ; ++i) {
81
82 RW_ASSERT ('0' == *s || '1' == *s);
83
84 buf [i] = '1' == *s++;
85
86 if ('\0' == *s) {
87 while (++i < n)
88 buf [i] = buf [i - 1];
89
90 return BoolArray (buf, i);
91 }
92 }
93}
94
95
97static void
98test_mask_array (int line,
99 const char *array,
100 const char *mask,
101 const char *opname,
102 const char *args,
103 const char *result,
104 int nmatch)
105
106{
107 typedef int T;
108
109 const char tname[] = "int";
110
111 /* */ std::valarray<T> asrc (make_array<int>(array));
112 const std::valarray<bool> amask (make_bool_array (mask));
113 const std::valarray<T> aarg (make_array<int>(args));
114
115 if (0 == opname)
116 opname = "";
117
118 // construct the expected result
119 const std::valarray<T> expect =
120 make_array<int>(result, *opname ? 0 : asrc.size ());
121
122 // create an mask array object from the source array
123 // and the array of indices
124 const std::mask_array<T> ia (asrc [amask]);
125
126 // iterate over the series of assignment operators, invoking
127 // each in sequence on the source array, modifying it in place
128 for (const char *op = opname; *op; ) {
129
130 // skip optional whitespace
131 for ( ; ' ' == *op; ++op);
132
133 switch (*op) {
134 // invoke fill assignment embedded within a series
135 // of compound assignments, e.g., "*=,,+=" meaning
136 // ia *= aarg; ia = aarg [0]; ia += aarg
137 case ',': ia = aarg.size () ? aarg [0] : 0; break;
138
139 // invoke ordinary assignment
140 case '=': ia = aarg; op += 1; break;
141
142 // invoke computed assignment
143 case '*': ia *= aarg; RW_ASSERT ('=' == op [1]); op += 2; break;
144 case '/': ia /= aarg; RW_ASSERT ('=' == op [1]); op += 2; break;
145 case '%': ia %= aarg; RW_ASSERT ('=' == op [1]); op += 2; break;
146 case '+': ia += aarg; RW_ASSERT ('=' == op [1]); op += 2; break;
147 case '-': ia -= aarg; RW_ASSERT ('=' == op [1]); op += 2; break;
148 case '^': ia ^= aarg; RW_ASSERT ('=' == op [1]); op += 2; break;
149 case '&': ia &= aarg; RW_ASSERT ('=' == op [1]); op += 2; break;
150 case '|': ia |= aarg; RW_ASSERT ('=' == op [1]); op += 2; break;
151 case '<': ia <<= aarg; RW_ASSERT ('=' == op [2]); op += 3; break;
152 case '>': ia >>= aarg; RW_ASSERT ('=' == op [2]); op += 3; break;
153 default:
154 RW_ASSERT (!"unknown operator");
155 }
156
157 // skip optional whitespace
158 for ( ; ' ' == *op; ++op);
159
160 // assignment operators are separated by commas
161 if (',' == *op)
162 ++op;
163 else
164 break;
165 }
166
167 if ('\0' == *opname) {
168 // fill assignment
169 ia = aarg.size () ? aarg [0] : 0;
170 }
171
172 int nequal = 0;
173 for (std::size_t i = 0; i != asrc.size (); ++i, ++nequal) {
174 if (asrc [i] != expect [i])
175 break;
176 }
177
178 if (-1 == nmatch)
179 nmatch = int (asrc.size ());
180
181 const int* const expect_begin = expect.size () ? &expect [0] : 0;
182 const int* const actual_begin = asrc.size () ? &asrc [0] : 0;
183
184 if ('=' == opname [0] && '\0' == opname [1]) {
185 rw_assert (nequal == nmatch, 0, line,
186 "valarray<%s>({%s})[valarray<bool>({%s})] %s "
187 "%d %c= {%{*.*Ad}}, got {%{*.*Ad}}",
188 tname, array, mask, opname,
189 aarg.size () ? aarg [0] : 0,
190 nmatch == int (asrc.size ()) ? '=' : '!',
191 int (sizeof (int)), int (expect.size ()), expect_begin,
192 int (sizeof (int)), int (asrc.size ()), actual_begin);
193 }
194 else {
195 rw_assert (nequal == nmatch, 0, line,
196 "valarray<%s>({%s})[valarray<bool>({%s})] %s "
197 "valarray<%1$s>({%s}) %c= {%{*.*Ad}}, got {%{*.*Ad}}",
198 tname, array, mask, opname, result,
199 nmatch == int (asrc.size ()) ? '=' : '!',
200 int (sizeof (int)), int (expect.size ()), expect_begin,
201 int (sizeof (int)), int (asrc.size ()), actual_begin);
202 }
203}
204
205
207static int
208run_test (int, char**)
209{
210#define TEST(array, mask, op, arg, res) \
211 test_mask_array (__LINE__, array, mask, op, arg, res, -1)
212
214 // exercise mask_array<T>::operator=(T), fill assignment
215 rw_info (0, 0, __LINE__,
216 "std::mask_array<int>::operator=(int)");
217
218 // +-- source array
219 // | +-- mask array (bitset of 0's and 1's)
220 // | | +-- zero for fill assignment
221 // | | | +-- argument of fill assignment
222 // | | | | +-- expected result
223 // | | | | |
224 // | | | | |
225 // V V V V V
226 TEST ("", "", 0, "0", "");
227 TEST ("1", "", 0, "0", "1");
228
229 TEST ("1", "1", 0, "2", "2");
230 TEST ("1,2", "10", 0, "3", "3,2");
231 TEST ("1,2,3", "100", 0, "4", "4,2,3");
232 TEST ("1,2,3,4", "1000", 0, "5", "5,2,3,4");
233 TEST ("1,2,3,4,5", "10000", 0, "6", "6,2,3,4,5");
234
235 TEST ("1,2,3,4,5", "11000", 0, "6", "6,6,3,4,5");
236 TEST ("1,2,3,4,5", "10100", 0, "6", "6,2,6,4,5");
237 TEST ("1,2,3,4,5", "10010", 0, "6", "6,2,3,6,5");
238 TEST ("1,2,3,4,5", "10001", 0, "6", "6,2,3,4,6");
239
240 TEST ("1,2,3,4,5", "11100", 0, "6", "6,6,6,4,5");
241 TEST ("1,2,3,4,5", "11010", 0, "6", "6,6,3,6,5");
242 TEST ("1,2,3,4,5", "11001", 0, "6", "6,6,3,4,6");
243
244 TEST ("1,2,3,4,5", "10110", 0, "6", "6,2,6,6,5");
245 TEST ("1,2,3,4,5", "10101", 0, "6", "6,2,6,4,6");
246
247 TEST ("1,2,3,4,5", "11010", 0, "6", "6,6,3,6,5");
248 TEST ("1,2,3,4,5", "10110", 0, "6", "6,2,6,6,5");
249 TEST ("1,2,3,4,5", "10011", 0, "6", "6,2,3,6,6");
250
251#define INFO(op) \
252 rw_info (0, 0, __LINE__, \
253 "std::mask_array<int>::operator%s(std::valarray<int>)", op);
254
255 INFO ("=");
256
257 // +-- source array
258 // | +-- array of indices (mask_array ctor argument)
259 // | | +-- assignment operators to test (0 for none)
260 // | | | +-- argument of assignment (0 for none)
261 // | | | | +-- expected result
262 // | | | | |
263 // | | | | |
264 // V V V V V
265 TEST ("", "", "=", "", "");
266 TEST ("1", "", "=", "", "1");
267 TEST ("1", "1", "=", "2", "2");
268 TEST ("1", "1", "=", "3", "3");
269 TEST ("2", "1", "=", "4", "4");
270
271 TEST ("1,2", "", "=", "", "1,2");
272 TEST ("1,2", "01", "=", "3", "1,3");
273 TEST ("1,2", "10", "=", "3", "3,2");
274 TEST ("1,2", "11", "=", "3,4", "3,4");
275
276 TEST ("1,2,3", "", "=", "", "1,2,3");
277 TEST ("1,2,3", "000", "=", "", "1,2,3");
278 TEST ("1,2,3", "001", "=", "6", "1,2,6");
279 TEST ("1,2,3", "010", "=", "6", "1,6,3");
280 TEST ("1,2,3", "011", "=", "6,5", "1,6,5");
281 TEST ("1,2,3", "100", "=", "6", "6,2,3");
282 TEST ("1,2,3", "101", "=", "6,5", "6,2,5");
283 TEST ("1,2,3", "110", "=", "6,5", "6,5,3");
284 TEST ("1,2,3", "111", "=", "6,5,4", "6,5,4");
285
286 TEST ("1,2,3,4", "", "=", "", "1,2,3,4");
287 TEST ("1,2,3,4", "0", "=", "", "1,2,3,4");
288 TEST ("1,2,3,4", "1", "=", "5", "5,2,3,4");
289 TEST ("1,2,3,4", "00", "=", "", "1,2,3,4");
290 TEST ("1,2,3,4", "01", "=", "5", "1,5,3,4");
291 TEST ("1,2,3,4", "10", "=", "5", "5,2,3,4");
292 TEST ("1,2,3,4", "11", "=", "5,6", "5,6,3,4");
293
294 TEST ("1,2,3,4", "000", "=", "", "1,2,3,4");
295 TEST ("1,2,3,4", "001", "=", "5", "1,2,5,4");
296 TEST ("1,2,3,4", "010", "=", "5", "1,5,3,4");
297 TEST ("1,2,3,4", "011", "=", "5,6", "1,5,6,4");
298 TEST ("1,2,3,4", "100", "=", "5", "5,2,3,4");
299 TEST ("1,2,3,4", "101", "=", "5,6", "5,2,6,4");
300 TEST ("1,2,3,4", "110", "=", "5,6", "5,6,3,4");
301 TEST ("1,2,3,4", "111", "=", "5,6,7", "5,6,7,4");
302
303 TEST ("1,2,3,4", "0000", "=", "", "1,2,3,4");
304 TEST ("1,2,3,4", "0001", "=", "5", "1,2,3,5");
305 TEST ("1,2,3,4", "0010", "=", "5", "1,2,5,4");
306 TEST ("1,2,3,4", "0011", "=", "5,6", "1,2,5,6");
307 TEST ("1,2,3,4", "0100", "=", "5", "1,5,3,4");
308 TEST ("1,2,3,4", "0101", "=", "5,6", "1,5,3,6");
309 TEST ("1,2,3,4", "0110", "=", "5,6", "1,5,6,4");
310 TEST ("1,2,3,4", "0111", "=", "5,6,7", "1,5,6,7");
311
312 TEST ("1,2,3,4", "1000", "=", "5", "5,2,3,4");
313 TEST ("1,2,3,4", "1001", "=", "5,6", "5,2,3,6");
314 TEST ("1,2,3,4", "1010", "=", "5,6", "5,2,6,4");
315 TEST ("1,2,3,4", "1011", "=", "5,6,7", "5,2,6,7");
316 TEST ("1,2,3,4", "1100", "=", "5,6", "5,6,3,4");
317 TEST ("1,2,3,4", "1101", "=", "5,6,7", "5,6,3,7");
318 TEST ("1,2,3,4", "1110", "=", "5,6,7", "5,6,7,4");
319 TEST ("1,2,3,4", "1111", "=", "5,6,7,8", "5,6,7,8");
320
322 // exercise mask_array::operator*=()
323 INFO ("*=");
324
325 TEST ("", "", "*=", "", "");
326 TEST ("1", "", "*=", "", "1");
327 TEST ("1", "0", "*=", "", "1");
328 TEST ("1", "0", "*=", "5", "1");
329 TEST ("1", "1", "*=", "5", "5");
330
331 TEST ("1,2", "", "*=", "", "1, 2");
332 TEST ("1,2", "0", "*=", "", "1, 2");
333 TEST ("1,2", "00", "*=", "", "1, 2");
334 TEST ("1,2", "01", "*=", "5", "1,10");
335 TEST ("1,2", "10", "*=", "5", "5, 2");
336 TEST ("1,2", "11", "*=", "5,6", "5,12");
337
338 TEST ("1,2,3", "", "*=", "", "1, 2, 3");
339 TEST ("1,2,3", "0", "*=", "", "1, 2, 3");
340 TEST ("1,2,3", "00", "*=", "", "1, 2, 3");
341 TEST ("1,2,3", "000", "*=", "", "1, 2, 3");
342 TEST ("1,2,3", "001", "*=", "5", "1, 2,15");
343 TEST ("1,2,3", "010", "*=", "5", "1,10, 3");
344 TEST ("1,2,3", "011", "*=", "5,6", "1,10,18");
345 TEST ("1,2,3", "100", "*=", "5", "5, 2, 3");
346 TEST ("1,2,3", "101", "*=", "5,6", "5, 2,18");
347 TEST ("1,2,3", "110", "*=", "5,6", "5,12, 3");
348 TEST ("1,2,3", "111", "*=", "5,6,7", "5,12,21");
349
350 TEST ("1,2,3,4", "", "*=", "", "1, 2, 3, 4");
351 TEST ("1,2,3,4", "0", "*=", "", "1, 2, 3, 4");
352 TEST ("1,2,3,4", "00", "*=", "", "1, 2, 3, 4");
353 TEST ("1,2,3,4", "000", "*=", "", "1, 2, 3, 4");
354 TEST ("1,2,3,4", "0000", "*=", "", "1, 2, 3, 4");
355 TEST ("1,2,3,4", "0001", "*=", "5", "1, 2, 3,20");
356 TEST ("1,2,3,4", "0010", "*=", "5", "1, 2,15, 4");
357 TEST ("1,2,3,4", "0011", "*=", "5,6", "1, 2,15,24");
358 TEST ("1,2,3,4", "0100", "*=", "5", "1,10, 3, 4");
359 TEST ("1,2,3,4", "0101", "*=", "5,6", "1,10, 3,24");
360 TEST ("1,2,3,4", "0110", "*=", "5,6", "1,10,18, 4");
361 TEST ("1,2,3,4", "0111", "*=", "5,6,7", "1,10,18,28");
362 TEST ("1,2,3,4", "1001", "*=", "5,6", "5, 2, 3,24");
363 TEST ("1,2,3,4", "1010", "*=", "5,6", "5, 2,18, 4");
364 TEST ("1,2,3,4", "1011", "*=", "5,6,7", "5, 2,18,28");
365 TEST ("1,2,3,4", "1100", "*=", "5,6", "5,12, 3, 4");
366 TEST ("1,2,3,4", "1101", "*=", "5,6,7", "5,12, 3,28");
367 TEST ("1,2,3,4", "1110", "*=", "5,6,7", "5,12,21, 4");
368 TEST ("1,2,3,4", "1111", "*=", "5,6,7,8", "5,12,21,32");
369
370 // exercise compound assignment, i.e.,
371 // ({1,2,3,4,5,6}[{0,1,0,1,0,1}] *= {0,1,2}) *= {0,1,2}
372 TEST ("1,2,3,4,5,6", "010101", "*=,*=", "0,1,2", "1,0,3,4,5,24");
373
375 // exercise mask_array::operator/=()
376 INFO ("/=");
377
378 TEST ("", "", "/=", "", "");
379 TEST ("10", "", "/=", "", "10");
380 TEST ("10", "0", "/=", "", "10");
381 TEST ("10", "0", "/=", "5", "10");
382 TEST ("10", "1", "/=", "5", " 2");
383
384 TEST ("10,20", "", "/=", "", "10,20");
385 TEST ("10,20", "0", "/=", "", "10,20");
386 TEST ("10,20", "00", "/=", "", "10,20");
387 TEST ("10,20", "01", "/=", "5", "10, 4");
388 TEST ("10,20", "10", "/=", "5", " 2,20");
389 TEST ("10,20", "11", "/=", "5,6", " 2, 3");
390
391 TEST ("10,20,30", "", "/=", "", "10,20,30");
392 TEST ("10,20,30", "0", "/=", "", "10,20,30");
393 TEST ("10,20,30", "00", "/=", "", "10,20,30");
394 TEST ("10,20,30", "000", "/=", "", "10,20,30");
395 TEST ("10,20,30", "001", "/=", "5", "10,20, 6");
396 TEST ("10,20,30", "010", "/=", "5", "10, 4,30");
397 TEST ("10,20,30", "011", "/=", "5,6", "10, 4, 5");
398 TEST ("10,20,30", "100", "/=", "5", " 2,20,30");
399 TEST ("10,20,30", "101", "/=", "5,6", " 2,20, 5");
400 TEST ("10,20,30", "110", "/=", "5,6", " 2, 3,30");
401 TEST ("10,20,30", "111", "/=", "5,6,7", " 2, 3, 4");
402
403 TEST ("10,20,30,40", "", "/=", "", "10,20,30,40");
404 TEST ("10,20,30,40", "0", "/=", "", "10,20,30,40");
405 TEST ("10,20,30,40", "00", "/=", "", "10,20,30,40");
406 TEST ("10,20,30,40", "000", "/=", "", "10,20,30,40");
407 TEST ("10,20,30,40", "0000", "/=", "", "10,20,30,40");
408 TEST ("10,20,30,40", "0001", "/=", "5", "10,20,30, 8");
409 TEST ("10,20,30,40", "0010", "/=", "5", "10,20, 6,40");
410 TEST ("10,20,30,40", "0011", "/=", "5,6", "10,20, 6, 6");
411 TEST ("10,20,30,40", "0100", "/=", "5", "10, 4,30,40");
412 TEST ("10,20,30,40", "0101", "/=", "5,6", "10, 4,30, 6");
413 TEST ("10,20,30,40", "0110", "/=", "5,6", "10, 4, 5,40");
414 TEST ("10,20,30,40", "0111", "/=", "5,6,7", "10, 4, 5, 5");
415 TEST ("10,20,30,40", "1000", "/=", "5", " 2,20,30,40");
416 TEST ("10,20,30,40", "1001", "/=", "5,6", " 2,20,30, 6");
417 TEST ("10,20,30,40", "1010", "/=", "5,6", " 2,20, 5,40");
418 TEST ("10,20,30,40", "1011", "/=", "5,6,7", " 2,20, 5, 5");
419 TEST ("10,20,30,40", "1100", "/=", "5,6", " 2, 3,30,40");
420 TEST ("10,20,30,40", "1101", "/=", "5,6,7", " 2, 3,30, 5");
421 TEST ("10,20,30,40", "1110", "/=", "5,6,7", " 2, 3, 4,40");
422 TEST ("10,20,30,40", "1111", "/=", "5,6,7,8", " 2, 3, 4, 5");
423
424 // exercise compound assignment, i.e.,
425 // ({1,2,3,4,5,6}[{0,1,0,1,0,1}] *= {7,8,9}) /= {7,8,9}
426 TEST ("1,2,3,4,5,6", "010101", "*=,/=", "7,8,9", "1,2,3,4,5,6");
427 // ({1,20,3,40,5,60}[{0,1,0,1,0,1}] /= {7,8,9}) *= {7,8,9}
428 TEST ("1,20,3,40,5,60", "010101", "/=,*=", "7,8,9", "1,14,3,40,5,54");
429
431 // exercise mask_array::operator%=()
432 INFO ("%=");
433
434 TEST ("1, 2,3, 4,5, 6", "010101", "%=", "3,5,7", "1,2,3,4,5,6");
435 TEST ("1,11,2,13,4,15", "010101", "%=", "6,7,8", "1,5,2,6,4,7");
436
438 // exercise mask_array::operator+=()
439 INFO ("+=");
440
441 TEST ("1,2,3,4,5,6", "010101", "+=", "7,8,9", "1,9,3,12,5,15");
442 TEST ("1,2,3,4,5,6", "010101", "+=,+=", "1,2,3", "1,4,3, 8,5,12");
443
445 // exercise mask_array::operator-=()
446 INFO ("-=");
447
448 TEST ("9,8,7,6,5,4", "111000", "-=", "9,8,7", "0,0,0,6,5,4");
449 TEST ("9,8,7,6,5,4", "011100", "-=", "8,7,6", "9,0,0,0,5,4");
450 TEST ("9,8,7,6,5,4", "001110", "-=", "7,6,5", "9,8,0,0,0,4");
451 TEST ("9,8,7,6,5,4", "000111", "-=", "6,5,4", "9,8,7,0,0,0");
452 TEST ("9,8,7,6,5,4", "010101", "-=", "3,2,1", "9,5,7,4,5,3");
453
455 // exercise mask_array::operator^=()
456 INFO ("^=");
457
458 TEST ("1,3,5,7,9", "10101", "^=", "2,4,5", "3,3,1,7,12");
459
461 // exercise mask_array::operator&=()
462 INFO ("&=");
463
464 TEST ("1,3,5,7,9", "10101", "&=", "3,1,7", "1,3,1,7,1");
465 TEST ("1,2,3,4,5", "01010", "&=", "1,1", "1,0,3,0,5");
466
468 // exercise mask_array::operator|=()
469 INFO ("|=");
470
471 TEST ("1,3,5,7,9", "10101", "|=", "3,1,7", "3,3,5,7,15");
472 TEST ("1,2,3,4,5", "01010", "|=", "1,1", "1,3,3,5, 5");
473
475 // exercise mask_array::operator<<=()
476 INFO ("<<=");
477
478 TEST ("1,3,5,7,9", "11100", "<<=", "1,1,1", " 2, 6,10, 7, 9");
479 TEST ("1,3,5,7,9", "01110", "<<=", "1,1,1", " 1, 6,10,14, 9");
480 TEST ("1,3,5,7,9", "00111", "<<=", "1,1,1", " 1, 3,10,14,18");
481 TEST ("1,3,5,7,9", "11111", "<<=", "5,4,3,2,1", "32,48,40,28,18");
482
483 // exercise a compound assignment, i.e.,
484 // ({1,3,5,7,9}[{2,3,4}] <<= {1,1,1}) >>= {1,1,1}
485 TEST ("1,3,5,7,9", "00111", "<<=,>>=", "1,1,1", "1,3,5,7,9");
486
488 // exercise mask_array::operator>>=()
489 INFO (">>=");
490
491 TEST ("2,6,10, 7, 9", "11100", ">>=", "1,1,1", "1,3,5,7,9");
492 TEST ("1,6,10,14, 9", "01110", ">>=", "1,1,1", "1,3,5,7,9");
493 TEST ("1,3,10,14,18", "00111", ">>=", "1,1,1", "1,3,5,7,9");
494
495 // exercise a compound assignment, i.e.,
496 // ({10,20,30,40,50}[{1,3,5}] >>= {1,1,1}) <<= {1,1,1}
497 TEST ("10,11,12,13,14", "10101", ">>=,<<=", "1,2,3", "10,11,12,13,8");
498
499 return 0;
500}
501
502
504int main (int argc, char *argv[])
505{
506 // FIXME: add command line options to enable/disable each operator
507 return rw_test (argc, argv, __FILE__,
508 "valarray.mask.array",
509 0 /* no comment */,
510 run_test,
511 "",
512 (void*)0 /* sentinel */);
513}
i
#define i
Definition 17.names.cpp:126
T
#define T
Definition 17.names.cpp:163
line
#define line
Definition 17.names.cpp:490
buf
#define buf
Definition 17.names.cpp:452
s
#define s
Definition rw_alg_test.h:221
n
#define n
Definition 17.names.cpp:130
val
#define val
Definition 17.names.cpp:570
result
volatile int result
Definition 18.limits.traps.stdcxx-624.cpp:35
run_test
void run_test(const ForwardIterator &dummy, T *, Predicate *pred)
Definition 25.find.first.cpp:275
INFO
#define INFO(op)
make_array
std::valarray< T > make_array(const char *s, std::size_t n=0)
Definition 26.mask.array.cpp:41
TEST
#define TEST(array, mask, op, arg, res)
make_bool_array
std::valarray< bool > make_bool_array(const char *s, std::size_t n=0)
Definition 26.mask.array.cpp:71
end
const int end
Definition 27.stringbuf.virtuals.cpp:447
main
#define main
Definition BAD_ALLOC_COPY_CTOR.cpp:32
size
int size
Definition TEMPLATE_ON_RETURN_TYPE.cpp:45
array
A TOML array.
Definition array.hpp:258
array::size
TOML_NODISCARD size_t size() const noexcept
Returns the number of elements in the array.
Definition array.hpp:936
rw_driver.h
rw_test
_TEST_EXPORT int rw_test(int argc, char *argv[], const char *filename, const char *clause, const char *comment, int(*testfun)(int, char **), const char *optspec,...)
rw_info
_TEST_EXPORT int rw_info(int, const char *, int, const char *,...)
Definition driver.cpp:1681
rw_assert
_TEST_EXPORT int rw_assert(int, const char *, int, const char *,...)
Definition driver.cpp:1630
RW_ASSERT
#define RW_ASSERT(expr)
Definition rw_testdefs.h:143
Generated by doxygen 1.9.8