Ne.app NeANT
The Ne.app NeANT User module of the NeANT distribution.
23.bitset.cons.cpp
Go to the documentation of this file.
1
29#include <bitset> // for bitset
30#include <stdexcept> // for invalid_argument, out_of_range
31#include <string> // for basic_string
32
33#include <cstddef> // for size_t
34
35#include <rw_char.h> // for UserChar, UserTraits
36#include <rw_driver.h> // for rw_test(), ...
37
38
40int opt_char; // for --no-char
41int opt_wchar; // for --no-wchar_t
42int opt_userchar; // for --no-UserChar
43int opt_no_exceptions; // for --no-exceptions
44
45
47template <std::size_t N>
48int bcmp (const std::bitset<N> &bset,
49 const char *str)
50{
51 RW_ASSERT (0 != str);
52
53 for (std::size_t i = 0; i != N; ++i) {
54
55 const char bit = bset [i] ? '1' : '0';
56
57 if (bit != str [N - i - 1])
58 return -1;
59 }
60
61 return 0;
62}
63
64
66// equivalent to the result of std::bitset<bits>(val).to_string<char>()
67const char*
68ulong_to_bitstring (unsigned long val, std::size_t bits)
69{
70 const std::size_t ulongbits = sizeof (unsigned long) * 8;
71
72 static char bitstr [1024];
73
74 for (std::size_t i = 0; i != bits; ++i) {
75 if (i < ulongbits)
76 bitstr [bits - i - 1] = val & (1UL << i) ? '1' : '0';
77 else
78 bitstr [bits - i - 1] = '0';
79 }
80
81 bitstr [bits] = '\0';
82 return bitstr;
83}
84
85
87// exercises the effects of the default bitset ctor
88template <std::size_t N>
89void test_default_ctor (std::bitset<N>*)
90{
91 rw_info (0, 0, __LINE__, "std::bitset<%u>::bitset()", N);
92
93 const std::bitset<N> bset;
94
95 char all_zeros [N + 1];
96 for (std::size_t i = 0; i != N; ++i) all_zeros [i] = '0';
97 all_zeros [N] = '\0';
98
99 rw_assert (!bcmp (bset, all_zeros), 0, __LINE__,
100 "bitset<%u>::bitset() expected 0, got { %.*b }",
101 N, int (N), &bset);
102}
103
104
106// exercises the effects of bitset<N>::bitset(unsigned long)
107template <std::size_t N>
108void test_long_ctor (std::bitset<N>*)
109{
110 rw_info (0, 0, __LINE__, "std::bitset<%u>::bitset(unsigned long)", N);
111
112#undef DO_TEST
113#define DO_TEST(T, val) \
114 do { \
115 const T v = val; \
116 const std::bitset<N> bset (v); \
117 const char* const bstr = ulong_to_bitstring (val, N); \
118 rw_assert (!bcmp (bset, (const char*)bstr), 0, __LINE__, \
119 "bitset<%u>::bitset(%zu) == { %{.*b} }, " \
120 "got { %{.*b} }", N, val, bstr, int (N), &bset); \
121 } while (0)
122
123 DO_TEST (unsigned long, 0);
124 DO_TEST (unsigned long, 1);
125 DO_TEST (unsigned long, 2);
126 DO_TEST (unsigned long, 3);
127 DO_TEST (unsigned long, 4);
128 DO_TEST (unsigned long, 5);
129 DO_TEST (unsigned long, 6);
130 DO_TEST (unsigned long, 7);
131 DO_TEST (unsigned long, 8);
132 DO_TEST (unsigned long, 9);
133 DO_TEST (unsigned long, 10);
134 DO_TEST (unsigned long, 11);
135 DO_TEST (unsigned long, 12);
136 DO_TEST (unsigned long, 13);
137 DO_TEST (unsigned long, 14);
138 DO_TEST (unsigned long, 15);
139 DO_TEST (unsigned long, _RWSTD_LONG_MAX / 16);
140 DO_TEST (unsigned long, _RWSTD_LONG_MAX / 8);
141 DO_TEST (unsigned long, _RWSTD_LONG_MAX / 4);
142 DO_TEST (unsigned long, _RWSTD_LONG_MAX / 2);
143 DO_TEST (unsigned long, _RWSTD_LONG_MAX - 2);
144 DO_TEST (unsigned long, _RWSTD_LONG_MAX - 1);
145 DO_TEST (unsigned long, _RWSTD_LONG_MAX);
146
147 // exercise calls to the ctor with arguments of other integer types
148 DO_TEST (char, 16);
149 DO_TEST (signed char, 17);
150 DO_TEST (unsigned char, 18);
151 DO_TEST (short, 19);
152 DO_TEST (unsigned short, 20);
153 DO_TEST (int, 21);
154 DO_TEST (unsigned int, 22);
155 DO_TEST (long, 23);
156}
157
158
160// invokes coverting bitset ctor from basic_string<char, ...>
161template <std::size_t N, class Traits, class Allocator>
162std::bitset<N>
163bitset_ctor (std::bitset<N>*,
164 const std::basic_string<char, Traits, Allocator> *bstr,
165 const char *str,
166 std::size_t pos, std::size_t n, const char bin_digits [2])
167{
168 if (bstr) {
169 if (std::size_t (-1) == pos)
170 return std::bitset<N>(*bstr);
171
172 if (std::size_t (-1) == n)
173 return std::bitset<N>(*bstr, pos);
174
175 if (0 == bin_digits)
176 return std::bitset<N>(*bstr, pos, n);
177
178 if (Traits::eq (bin_digits [0], bin_digits [1]))
179 return std::bitset<N>(*bstr, pos, n, bin_digits [0]);
180
181 return std::bitset<N>(*bstr, pos, n, bin_digits [0], bin_digits [1]);
182 }
183
184#if !defined (_RWSTD_NO_EXT_BITSET_CTOR_CHAR_ARRAY) \
185 && !defined (_RWSTD_NO_EXT_BITSET_CTOR_STRING)
186
187 if (std::size_t (-1) == pos)
188 return std::bitset<N>(str);
189
190 if (std::size_t (-1) == n)
191 return std::bitset<N>(str, pos);
192
193 if (0 == bin_digits)
194 return std::bitset<N>(str, pos, n);
195
196 if (Traits::eq (bin_digits [0], bin_digits [1]))
197 return std::bitset<N>(str, pos, n, bin_digits [0]);
198
199 return std::bitset<N>(str, pos, n, bin_digits [0], bin_digits [1]);
200
201#else
202
203 RW_ASSERT (!"test logic error");
204
205 return std::bitset<N>();
206
207#endif // _RWSTD_NO_EXT_BITSET_CTOR_{CHAR_ARRAY,STRING)
208
209}
210
211
212#ifndef _RWSTD_NO_WCHAR_T
213
214// invokes coverting bitset ctor from basic_string<wchar_t, ...>
215template <std::size_t N, class Traits, class Allocator>
216std::bitset<N>
217bitset_ctor (std::bitset<N>*,
218 const std::basic_string<wchar_t, Traits, Allocator> *bstr,
219 const wchar_t *wstr,
220 std::size_t pos, std::size_t n, const wchar_t bin_digits [2])
221{
222 if (bstr) {
223 if (std::size_t (-1) == pos)
224 return std::bitset<N>(*bstr);
225
226 if (std::size_t (-1) == n)
227 return std::bitset<N>(*bstr, pos);
228
229 if (0 == bin_digits)
230 return std::bitset<N>(*bstr, pos, n);
231
232 if (Traits::eq (bin_digits [0], bin_digits [1]))
233 return std::bitset<N>(*bstr, pos, n, bin_digits [0]);
234
235 return std::bitset<N>(*bstr, pos, n, bin_digits [0], bin_digits [1]);
236 }
237
238#if !defined (_RWSTD_NO_EXT_BITSET_CTOR_CHAR_ARRAY) \
239 && !defined (_RWSTD_NO_EXT_BITSET_CTOR_STRING)
240
241 if (std::size_t (-1) == pos)
242 return std::bitset<N>(wstr);
243
244 if (std::size_t (-1) == n)
245 return std::bitset<N>(wstr, pos);
246
247 if (0 == bin_digits)
248 return std::bitset<N>(wstr, pos, n);
249
250 if (Traits::eq (bin_digits [0], bin_digits [1]))
251 return std::bitset<N>(wstr, pos, n, bin_digits [0]);
252
253 return std::bitset<N>(wstr, pos, n, bin_digits [0], bin_digits [1]);
254
255#else
256
257 RW_ASSERT (!"test logic error");
258
259 return std::bitset<N>();
260
261#endif // _RWSTD_NO_EXT_BITSET_CTOR_{CHAR_ARRAY,STRING)
262
263}
264
265#endif // _RWSTD_NO_WCHAR_T
266
267
268// invokes coverting bitset ctor from basic_string<UserChar, ...>
269template <std::size_t N, class Traits, class Allocator>
270std::bitset<N>
271bitset_ctor (std::bitset<N>*,
272 const std::basic_string<UserChar, Traits, Allocator> *bstr,
273 const UserChar* /* intentionally unused */,
274 std::size_t pos, std::size_t n, const UserChar bin_digits [2])
275{
276 if (std::size_t (-1) == pos)
277 pos = 0;
278
279 if (0 == bin_digits) {
280 static const UserChar zero_one[] = { { 0.0, '0' }, { 0.0, '1' } };
281
282 bin_digits = zero_one;
283 }
284
285 if (bstr)
286 return std::bitset<N>(*bstr, pos, n, bin_digits [0], bin_digits [1]);
287
288 // cannot invoke std::bitset<N>(const UserChar*) without providing
289 // an explicit specialization of std::char_traits<UserChar> that
290 // implements eq() and length()
291 RW_ASSERT (!"test logic error");
292
293 return std::bitset<N>();
294}
295
296
297// constructs a bitset object by invoking one of the overloaded ctors
298template <std::size_t N, class charT, class Traits, class Allocator>
299std::bitset<N>
300bitset_ctor (std::bitset<N>*,
301 std::basic_string<charT, Traits, Allocator> *p,
302 const char *str, std::size_t pos, std::size_t n)
303{
304 charT wstr [1024];
305
306 for (std::size_t i = 0; i != sizeof wstr / sizeof *wstr; ++i) {
307 if (str [i])
308 Traits::assign (wstr [i], make_char (str [i], (charT*)0));
309 else {
310 Traits::assign (wstr [i], charT ());
311 break;
312 }
313 }
314
315 typedef std::bitset<N> Bitset;
316 typedef std::basic_string<charT, Traits, Allocator> String;
317
318 if (p) { // use one of the const basic_string& overloads
319
320 const String bstr (wstr);
321
322 return bitset_ctor ((Bitset*)0, &bstr, 0, pos, n, (charT*)0);
323 }
324 else { // invoke one of the const charT* overloads
325
326 return bitset_ctor ((Bitset*)0, (String*)0, wstr, pos, n, (charT*)0);
327 }
328}
329
330
331template <class charT>
332const char* type_prefix (charT) { return ""; }
333
334#ifndef _RWSTD_NO_WCHAR_T
335
336const char* type_prefix (wchar_t) { return "L"; }
337
338#endif // _RWSTD_NO_WCHAR_T
339
340enum { InvalidArgument = 1, OutOfRange };
341
342template <std::size_t N, class charT, class Traits, class Allocator>
343void test_string_ctor (std::bitset<N>*,
344 std::basic_string<charT, Traits, Allocator> *p,
345 int line,
346 const char *str, std::size_t pos, std::size_t n,
347 const char *bitstr)
348{
349 static const char* const tpfx = type_prefix (charT ());
350
351 typedef std::bitset<N> Bitset;
352 typedef std::basic_string<charT, Traits, Allocator> String;
353
354 static const char* const exstr[] = {
355 "failed to throw",
356 "caught std::invalid_argument",
357 "caught std::out_of_range",
358 "caught unknown exception"
359 };
360
361 // compute which exception, if any, the ctor is expected to throw
362 const int except = int (bitstr - (char*)0) < 3 ?
363 int (bitstr - (char*)0) : 0;
364
365 if (except && opt_no_exceptions)
366 return;
367
368 int caught = 0;
369
370
371 _TRY {
372 // invoke one of the overloads of the constructor
373 const Bitset bset = bitset_ctor ((Bitset*)0, p, str, pos, n);
374
375 if (!except)
376 rw_assert (!bcmp (bset, bitstr), 0, line,
377 "line %d: bitset<%u>::bitset(%s\"%s\""
378 "%{?}, %zu%{?}, %zu%{;}%{;}) "
379 "== { %s }, got { %{.*b} }",
380 __LINE__, N, tpfx, str,
381 pos != std::size_t (-1), pos,
382 n != std::size_t (-1), n,
383 bitstr, int (N), &bset);
384 }
385
386#ifndef _RWSTD_NO_EXCEPTIONS
387
388 catch (const std::out_of_range&) {
389 caught = OutOfRange;
390 }
391 catch (const std::invalid_argument&) {
392 caught = InvalidArgument;
393 }
394 catch (...) {
395 caught = 3;
396 }
397#endif // _RWSTD_NO_EXCEPTIONS
398
399 rw_assert (except == caught, 0, line,
400 "line %d: bitset<%u>::bitset(%s\"%s\", %u, %u) "
401 "unexpectedly %s", __LINE__, N, tpfx, str, pos, n,
402 exstr [caught]);
403}
404
405
406std::string
407fillstr (const char *pfx, int bit, std::size_t count, const char *sfx)
408{
409 std::string str (pfx);
410 str.append (count, char ('0' + bit));
411 str.append (sfx);
412 return str;
413}
414
415
416template <class charT, class Traits, class Allocator>
417void test_string_ctor (std::basic_string<charT, Traits, Allocator> *p,
418 const char *cname)
419{
420#undef DO_TEST
421#define DO_TEST(N, str, pos, n, except) \
422 test_string_ctor ((std::bitset<N>*)0, p, __LINE__, \
423 str, std::size_t (pos), std::size_t (n), \
424 (const char*)except)
425
427
428#define CTOR_INFO(N) \
429 rw_info (0, 0, __LINE__, "std::bitset<%i>::bitset(const " \
430 "%{?}std::basic_string<%s>&%{:}%3$s%{;})", \
431 N, 0 != p, cname)
432
433 CTOR_INFO (0);
434
435#define TEST_1(N, str, except) DO_TEST(N, str, -1, -1, except)
436
437 // +----------- bitset size
438 // | +-------- string argument
439 // | | +-- result or exception
440 // v v v
441 TEST_1 (0, "", "");
442 TEST_1 (0, "0", "");
443 TEST_1 (0, "1", "");
444 TEST_1 (0, "2", InvalidArgument);
445 TEST_1 (0, "00", "");
446 TEST_1 (0, "01", "");
447 TEST_1 (0, "02", InvalidArgument);
448
449 CTOR_INFO (1);
450
451 TEST_1 (1, "", "0");
452 TEST_1 (1, "0", "0");
453 TEST_1 (1, "1", "1");
454 TEST_1 (1, "2", InvalidArgument);
455 TEST_1 (1, "00", "0");
456 TEST_1 (1, "01", "0");
457 TEST_1 (1, "02", InvalidArgument);
458
459 CTOR_INFO (2);
460
461 TEST_1 (2, "", "00");
462 TEST_1 (2, "0", "00");
463 TEST_1 (2, "1", "01");
464 TEST_1 (2, "2", InvalidArgument);
465 TEST_1 (2, "00", "00");
466 TEST_1 (2, "01", "01");
467 TEST_1 (2, "02", InvalidArgument);
468 TEST_1 (2, "10", "10");
469 TEST_1 (2, "11", "11");
470 TEST_1 (2, "12", InvalidArgument);
471 TEST_1 (2, "20", InvalidArgument);
472 TEST_1 (2, "21", InvalidArgument);
473 TEST_1 (2, "22", InvalidArgument);
474 TEST_1 (2, "000", "00");
475 TEST_1 (2, "001", "00");
476 TEST_1 (2, "002", InvalidArgument);
477 TEST_1 (2, "010", "01");
478 TEST_1 (2, "011", "01");
479 TEST_1 (2, "012", InvalidArgument);
480 TEST_1 (2, "020", InvalidArgument);
481 TEST_1 (2, "100", "10");
482 TEST_1 (2, "101", "10");
483 TEST_1 (2, "110", "11");
484 TEST_1 (2, "111", "11");
485 TEST_1 (2, "112", InvalidArgument);
486 TEST_1 (2, "200", InvalidArgument);
487 TEST_1 (2, "201", InvalidArgument);
488 TEST_1 (2, "202", InvalidArgument);
489
490 CTOR_INFO (3);
491
492 TEST_1 (3, "", "000");
493 TEST_1 (3, "0", "000");
494 TEST_1 (3, "1", "001");
495 TEST_1 (3, "2", InvalidArgument);
496 TEST_1 (3, "00", "000");
497 TEST_1 (3, "01", "001");
498 TEST_1 (3, "02", InvalidArgument);
499 TEST_1 (3, "10", "010");
500 TEST_1 (3, "11", "011");
501 TEST_1 (3, "12", InvalidArgument);
502 TEST_1 (3, "000", "000");
503 TEST_1 (3, "001", "001");
504 TEST_1 (3, "002", InvalidArgument);
505 TEST_1 (3, "010", "010");
506 TEST_1 (3, "011", "011");
507 TEST_1 (3, "012", InvalidArgument);
508 TEST_1 (3, "100", "100");
509 TEST_1 (3, "101", "101");
510 TEST_1 (3, "102", InvalidArgument);
511 TEST_1 (3, "100", "100");
512 TEST_1 (3, "101", "101");
513 TEST_1 (3, "102", InvalidArgument);
514
515 TEST_1 (3, "0001", "000");
516 TEST_1 (3, "0010", "001");
517 TEST_1 (3, "0100", "010");
518 TEST_1 (3, "1000", "100");
519 TEST_1 (3, "1001", "100");
520
521 TEST_1 (3, "0001", "000");
522 TEST_1 (3, "0010", "001");
523 TEST_1 (3, "0100", "010");
524 TEST_1 (3, "1000", "100");
525 TEST_1 (3, "1001", "100");
526 TEST_1 (3, "1002", InvalidArgument);
527 TEST_1 (3, "2000", InvalidArgument);
528
529 TEST_1 (3, "10010", "100");
530 TEST_1 (3, "10011", "100");
531 TEST_1 (3, "10012", InvalidArgument);
532 TEST_1 (3, "100102", InvalidArgument);
533
534 // macro to insert N zeros or ones in between two string literals
535#define FILL(pfx, bit, N, sfx) fillstr (pfx, bit, N, sfx).c_str ()
536
537 CTOR_INFO (33);
538
539 // +------------- preceded by these characters
540 // | +--------- binary digit (0 or 1)
541 // | | +------ repeated this many times
542 // | | | +-- followed by these characters
543 // | | | |
544 // v v v v
545 TEST_1 (33, "", FILL ("", 0, 33, ""));
546 TEST_1 (33, "0", FILL ("", 0, 33, ""));
547 TEST_1 (33, "1", FILL ("", 0, 32, "1"));
548 TEST_1 (33, "00", FILL ("", 0, 31, "00"));
549 TEST_1 (33, "01", FILL ("", 0, 31, "01"));
550 TEST_1 (33, "10", FILL ("", 0, 31, "10"));
551 TEST_1 (33, "11", FILL ("", 0, 31, "11"));
552 TEST_1 (33, "100", FILL ("", 0, 30, "100"));
553 TEST_1 (33, "101", FILL ("", 0, 30, "101"));
554
555 TEST_1 (33, FILL ("1", 0, 32, ""), FILL ("10", 0, 30, "0"));
556 TEST_1 (33, FILL ("1", 0, 31, "1"), FILL ("10", 0, 30, "1"));
557 TEST_1 (33, FILL ("1", 0, 31, "2"), InvalidArgument);
558
559 TEST_1 (33, FILL ("", 1, 33, ""), FILL ("", 1, 33, ""));
560 TEST_1 (33, FILL ("", 1, 32, "0"), FILL ("", 1, 32, "0"));
561 TEST_1 (33, FILL ("", 1, 31, "00"), FILL ("", 1, 31, "00"));
562 TEST_1 (33, FILL ("", 1, 30, "000"), FILL ("", 1, 30, "000"));
563 TEST_1 (33, FILL ("", 1, 29, "0000"), FILL ("", 1, 29, "0000"));
564 TEST_1 (33, FILL ("", 1, 28, "00000"), FILL ("", 1, 28, "00000"));
565 TEST_1 (33, FILL ("", 1, 28, "00001"), FILL ("", 1, 28, "00001"));
566 TEST_1 (33, FILL ("", 1, 28, "00010"), FILL ("", 1, 28, "00010"));
567 TEST_1 (33, FILL ("", 1, 28, "00100"), FILL ("", 1, 28, "00100"));
568 TEST_1 (33, FILL ("", 1, 28, "01000"), FILL ("", 1, 28, "01000"));
569 TEST_1 (33, FILL ("", 1, 28, "02000"), InvalidArgument);
570
571 TEST_1 (33, FILL ("", 1, 33, "0"), FILL ("", 1, 33, ""));
572 TEST_1 (33, FILL ("", 1, 33, "1"), FILL ("", 1, 33, ""));
573 TEST_1 (33, FILL ("", 1, 33, "2"), InvalidArgument);
574 TEST_1 (33, FILL ("2", 1, 33, ""), InvalidArgument);
575
576 CTOR_INFO (80);
577
578 TEST_1 (80, FILL ("" , 1, 80, ""), FILL ("" , 1, 80, ""));
579 TEST_1 (80, FILL ("1", 0, 78, "1"), FILL ("1" , 0, 78, "1"));
580 TEST_1 (80, FILL ("1", 0, 77, "10"), FILL ("1" , 0, 77, "10"));
581 TEST_1 (80, FILL ("1", 0, 77, "20"), InvalidArgument);
582 TEST_1 (80, FILL ("2", 0, 77, "00"), InvalidArgument);
583 TEST_1 (80, FILL ("02", 0, 76, "00"), InvalidArgument);
584 TEST_1 (80, FILL ("12", 0, 76, "00"), InvalidArgument);
585
587#undef CTOR_INFO
588#define CTOR_INFO(N) \
589 rw_info (0, 0, __LINE__, "std::bitset<%i>::bitset(const " \
590 "%{?}std::basic_string<%s>&%{:}%3$s%{;}, size_t)", \
591 N, 0 != p, cname)
592
593#define TEST_2(N, str, pos, except) DO_TEST(N, str, pos, -1, except)
594
595 CTOR_INFO (0);
596
597 TEST_2 (0, "", 0, "");
598 TEST_2 (0, "", 1, OutOfRange);
599 TEST_2 (0, "0", 0, "");
600 TEST_2 (0, "1", 0, "");
601 TEST_2 (0, "2", 0, InvalidArgument);
602 TEST_2 (0, "0", 1, "");
603 TEST_2 (0, "1", 1, "");
604 TEST_2 (0, "2", 1, "");
605
606 CTOR_INFO (1);
607
608 TEST_2 (1, "", 0, "0");
609 TEST_2 (1, "0", 0, "0");
610 TEST_2 (1, "1", 0, "1");
611 TEST_2 (1, "2", 0, InvalidArgument);
612
613 TEST_2 (1, "00", 0, "0");
614 TEST_2 (1, "01", 0, "0");
615 TEST_2 (1, "02", 0, InvalidArgument);
616 TEST_2 (1, "10", 0, "1");
617 TEST_2 (1, "11", 0, "1");
618 TEST_2 (1, "12", 0, InvalidArgument);
619
620 TEST_2 (1, "00", 1, "0");
621 TEST_2 (1, "01", 1, "1");
622 TEST_2 (1, "02", 1, InvalidArgument);
623 TEST_2 (1, "10", 1, "0");
624 TEST_2 (1, "11", 1, "1");
625 TEST_2 (1, "12", 1, InvalidArgument);
626 TEST_2 (1, "20", 1, "0");
627 TEST_2 (1, "21", 1, "1");
628 TEST_2 (1, "22", 1, InvalidArgument);
629
630 TEST_2 (1, "000", 1, "0");
631 TEST_2 (1, "001", 1, "0");
632 TEST_2 (1, "002", 1, InvalidArgument);
633 TEST_2 (1, "010", 1, "1");
634 TEST_2 (1, "011", 1, "1");
635 TEST_2 (1, "012", 1, InvalidArgument);
636 TEST_2 (1, "020", 1, InvalidArgument);
637 TEST_2 (1, "021", 1, InvalidArgument);
638 TEST_2 (1, "022", 1, InvalidArgument);
639 TEST_2 (1, "120", 1, InvalidArgument);
640 TEST_2 (1, "121", 1, InvalidArgument);
641 TEST_2 (1, "122", 1, InvalidArgument);
642 TEST_2 (1, "200", 1, "0");
643 TEST_2 (1, "201", 1, "0");
644 TEST_2 (1, "202", 1, InvalidArgument);
645
646 TEST_2 (1, "320", 2, "0");
647 TEST_2 (1, "321", 2, "1");
648 TEST_2 (1, "322", 2, InvalidArgument);
649 TEST_2 (1, "3200", 2, "0");
650 TEST_2 (1, "3201", 2, "0");
651 TEST_2 (1, "3202", 2, InvalidArgument);
652 TEST_2 (1, "3210", 2, "1");
653 TEST_2 (1, "3211", 2, "1");
654 TEST_2 (1, "3212", 2, InvalidArgument);
655
656 TEST_2 (1, "", 1, OutOfRange);
657
659#undef CTOR_INFO
660#define CTOR_INFO(N) \
661 rw_info (0, 0, __LINE__, "std::bitset<%i>::bitset(const " \
662 "%{?}std::basic_string<%s>&%{:}%3$s%{;}, size_t, size_t)", \
663 N, 0 != p, cname)
664
665 CTOR_INFO (0);
666
667#define TEST_3(N, str, pos, n, except) DO_TEST(N, str, pos, n, except)
668
669 // +-------------------- bitset size
670 // | +----------------- string argument
671 // | | +---------- pos
672 // | | | +------ n
673 // | | | | +--- result or exception
674 // | | | | |
675 // v v v v v
676 TEST_3 (0, "", 0, 0, "");
677 TEST_3 (0, "", 1, 0, OutOfRange);
678 TEST_3 (0, "02", 0, 0, "");
679
680 CTOR_INFO (1);
681
682 TEST_3 (1, "012", 0, 1, "0");
683 TEST_3 (1, "012", 1, 1, "1");
684 TEST_3 (1, "012", 2, 1, InvalidArgument);
685
686 TEST_3 (1, "", 0, 0, "0");
687 TEST_3 (1, "", 1, 0, OutOfRange);
688
689 CTOR_INFO (8);
690
691 TEST_3 (8, "11111111", 0, 8, FILL ("", 1, 8, ""));
692 TEST_3 (8, "11111111", 1, 7, FILL ("0", 1, 7, ""));
693 TEST_3 (8, "11111111", 2, 6, FILL ("00", 1, 6, ""));
694 TEST_3 (8, "11111111", 3, 5, FILL ("000", 1, 5, ""));
695 TEST_3 (8, "11111111", 4, 4, FILL ("0000", 1, 4, ""));
696 TEST_3 (8, "11111111", 5, 3, FILL ("00000", 1, 3, ""));
697 TEST_3 (8, "11111111", 6, 2, FILL ("000000", 1, 2, ""));
698 TEST_3 (8, "11111111", 7, 1, FILL ("0000000", 1, 1, ""));
699 TEST_3 (8, "11111111", 8, 0, FILL ("00000000", 1, 0, ""));
700 TEST_3 (8, "11111111", 9, 0, OutOfRange);
701 TEST_3 (8, "11111111", 9, 1, OutOfRange);
702 TEST_3 (8, "111111112", 7, 1, FILL ("0000000", 1, 1, ""));
703 TEST_3 (8, "111111112", 7, 2, InvalidArgument);
704
705 TEST_3 (8, "211111112", 1, 7, FILL ("0", 1, 7, ""));
706 TEST_3 (8, "210111112", 1, 7, FILL ("010", 1, 5, ""));
707 TEST_3 (8, "211111012", 1, 7, FILL ("0", 1, 5, "01"));
708
709 CTOR_INFO (40);
710
711 TEST_3 (40, FILL ("", 0, 40, ""), 0, 0, FILL ("", 0, 40, ""));
712 TEST_3 (40, FILL ("", 0, 40, "1"), 0, 40, FILL ("", 0, 40, ""));
713 TEST_3 (40, FILL ("", 0, 40, "1"), 0, 41, FILL ("", 0, 40, ""));
714 TEST_3 (40, FILL ("", 0, 39, "1"), 0, 39, FILL ("", 0, 40, ""));
715 TEST_3 (40, FILL ("", 0, 39, "1"), 0, 40, FILL ("", 0, 39, "1"));
716 TEST_3 (40, FILL ("1", 0, 40, "1"), 0, 0, FILL ("", 0, 40, ""));
717 TEST_3 (40, FILL ("1", 0, 38, "1"), 0, 40, FILL ("1", 0, 38, "1"));
718 TEST_3 (40, FILL ("1", 0, 38, "1"), 0, 40, FILL ("1", 0, 38, "1"));
719 TEST_3 (40, FILL ("2", 0, 40, "2"), 1, 40, FILL ("", 0, 40, ""));
720}
721
722
724template <std::size_t N>
725void test_ctors (std::bitset<N>* pb)
726{
727 test_default_ctor (pb);
728 test_long_ctor (pb);
729}
730
731
733template <class Traits>
734void test_ctors (const Traits*, const char *cname)
735{
736 typedef typename Traits::char_type char_type;
737 typedef std::allocator<char_type> Allocator;
738 typedef std::basic_string<char_type, Traits, Allocator> String;
739
740 // exercise const std::string& overloads
741 test_string_ctor ((String*)1, cname);
742
743#if !defined (_RWSTD_NO_EXT_BITSET_CTOR_CHAR_ARRAY) \
744 && !defined (_RWSTD_NO_EXT_BITSET_CTOR_STRING)
745
746 // exercise const char* and const wchar_t* extensions
747 // but avoid calling the bitset(const UserChar*) overload in order
748 if (sizeof (char_type) != sizeof (UserChar))
749 test_string_ctor ((String*)0, cname);
750
751#endif // _RWSTD_NO_EXT_BITSET_CTOR_{CHAR_ARRAY,STRING}
752
753}
754
755
757static int
758run_test (int, char**)
759{
760#ifdef _RWSTD_NO_EXCEPTIONS
761 opt_no_exceptions = 1;
762#endif // _RWSTD_NO_EXCEPTIONS
763
764 if (opt_no_exceptions)
765 rw_note (0, 0, 0, "exception tests disabled");
766
767#undef DO_TEST
768#define DO_TEST(N) test_ctors ((std::bitset<N>*)0)
769
770 DO_TEST ( 0); // interesting case
771 DO_TEST ( 1); // interesting case
772 DO_TEST ( 2);
773 DO_TEST ( 31);
774 DO_TEST ( 32); // interesting case
775 DO_TEST ( 33); // interesting case
776 DO_TEST ( 34);
777 DO_TEST ( 63);
778 DO_TEST ( 64); // interesting case
779 DO_TEST ( 65); // interesting case
780 DO_TEST ( 66);
781
782 DO_TEST ( 123);
783
784 DO_TEST ( 127); // interesting case
785 DO_TEST ( 128); // interesting case
786 DO_TEST ( 129);
787 DO_TEST ( 130);
788 DO_TEST ( 255);
789 DO_TEST ( 256); // interesting case
790
791#if !defined(_MSC_VER) || _MSC_VER != 1300
792 // FIXME: MSVC can't compile bitset<257>!
793 DO_TEST ( 257); // interesting case
794#endif
795
796 DO_TEST ( 258); // interesting case
797 DO_TEST ( 333);
798
799 if (0 <= opt_char) {
800 typedef std::char_traits<char> NarrowTraits;
801
802 test_ctors ((NarrowTraits*)0, "char");
803 }
804 else {
805 rw_note (0, 0, __LINE__, "tests of char specialization disabled");
806 }
807
808#ifndef _RWSTD_NO_WCHAR_T
809
810 if (0 <= opt_wchar) {
811 typedef std::char_traits<wchar_t> WideTraits;
812
813 test_ctors ((WideTraits*)0, "wchar_t");
814 }
815 else {
816 rw_note (0, 0, __LINE__, "tests of wchar_t specialization disabled");
817 }
818
819#endif // _RWSTD_NO_WCHAR_T
820
821 if (0 <= opt_userchar) {
822 test_ctors ((UserTraits<UserChar>*)0, "UserChar");
823 }
824 else {
825 rw_note (0, 0, __LINE__, "tests of UserChar specialization disabled");
826 }
827
828 return 0;
829}
830
831
833int main (int argc, char *argv[])
834{
835 return rw_test (argc, argv, __FILE__,
836 "lib.bitset.cons",
837 0 /* no comment */,
838 run_test,
839 "|-char~ "
840 "|-wchar_t~ "
841 "|-UserChar~ "
842 "|-no-exceptions# ",
843 &opt_char,
844 &opt_wchar,
845 &opt_userchar,
846 &opt_no_exceptions,
847 (void*)0 /* sentinel */);
848}
count
void count(T, T, const U &,...)
Definition 17.extensions.cpp:120
N
#define N
Definition 17.names.cpp:157
i
#define i
Definition 17.names.cpp:126
line
#define line
Definition 17.names.cpp:490
Allocator
#define Allocator
Definition 17.names.cpp:440
charT
#define charT
Definition 17.names.cpp:456
n
#define n
Definition 17.names.cpp:130
val
#define val
Definition 17.names.cpp:570
p
#define p
Definition 17.names.cpp:132
pos
#define pos
Definition 17.names.cpp:518
fillstr
std::string fillstr(const char *pfx, int bit, std::size_t count, const char *sfx)
Definition 23.bitset.cons.cpp:407
DO_TEST
#define DO_TEST(T, val)
bitset_ctor
std::bitset< N > bitset_ctor(std::bitset< N > *, const std::basic_string< char, Traits, Allocator > *bstr, const char *str, std::size_t pos, std::size_t n, const char bin_digits[2])
Definition 23.bitset.cons.cpp:163
test_long_ctor
void test_long_ctor(std::bitset< N > *)
Definition 23.bitset.cons.cpp:108
OutOfRange
@ OutOfRange
Definition 23.bitset.cons.cpp:340
InvalidArgument
@ InvalidArgument
Definition 23.bitset.cons.cpp:340
CTOR_INFO
#define CTOR_INFO(N)
FILL
#define FILL(pfx, bit, N, sfx)
TEST_2
#define TEST_2(N, str, pos, except)
test_default_ctor
void test_default_ctor(std::bitset< N > *)
Definition 23.bitset.cons.cpp:89
ulong_to_bitstring
const char * ulong_to_bitstring(unsigned long val, std::size_t bits)
Definition 23.bitset.cons.cpp:68
opt_wchar
int opt_wchar
Definition 23.bitset.cons.cpp:41
opt_char
int opt_char
Definition 23.bitset.cons.cpp:40
opt_userchar
int opt_userchar
Definition 23.bitset.cons.cpp:42
opt_no_exceptions
int opt_no_exceptions
Definition 23.bitset.cons.cpp:43
bcmp
int bcmp(const std::bitset< N > &bset, const char *str)
Definition 23.bitset.cons.cpp:48
TEST_3
#define TEST_3(N, str, pos, n, except)
TEST_1
#define TEST_1(N, str, except)
test_string_ctor
void test_string_ctor(std::bitset< N > *, std::basic_string< charT, Traits, Allocator > *p, int line, const char *str, std::size_t pos, std::size_t n, const char *bitstr)
Definition 23.bitset.cons.cpp:343
type_prefix
const char * type_prefix(charT)
Definition 23.bitset.cons.cpp:332
test_ctors
void test_ctors()
Definition 23.vector.cons.cpp:298
run_test
void run_test(const ForwardIterator &dummy, T *, Predicate *pred)
Definition 25.find.first.cpp:275
Traits
std::char_traits< S > Traits
Definition 27.basic.ios.cpp:64
main
#define main
Definition BAD_ALLOC_COPY_CTOR.cpp:32
caught
int caught
Definition FUNCTION_TRY_BLOCK.cpp:26
_TRY
#define _TRY
Definition _defs.h:850
str
const char * str
Definition exec.cpp:170
rw_char.h
make_char
UserChar make_char(char c, UserChar *)
Definition rw_char.h:74
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_note
_TEST_EXPORT int rw_note(int, const char *, int, const char *,...)
Definition driver.cpp:1664
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