| /*************************************************************************** |
| * |
| * 23.bitset.cons.cpp - test exercising [lib.bitset.cons] |
| * |
| * $Id$ |
| * |
| *************************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed |
| * with this work for additional information regarding copyright |
| * ownership. The ASF licenses this file to you under the Apache |
| * License, Version 2.0 (the "License"); you may not use this file |
| * except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| * implied. See the License for the specific language governing |
| * permissions and limitations under the License. |
| * |
| * Copyright 2004-2006 Rogue Wave Software. |
| * |
| **************************************************************************/ |
| |
| #include <bitset> // for bitset |
| #include <stdexcept> // for invalid_argument, out_of_range |
| #include <string> // for basic_string |
| |
| #include <cstddef> // for size_t |
| |
| #include <rw_char.h> // for UserChar, UserTraits |
| #include <rw_driver.h> // for rw_test(), ... |
| |
| /**************************************************************************/ |
| |
| int opt_char; // for --no-char |
| int opt_wchar; // for --no-wchar_t |
| int opt_userchar; // for --no-UserChar |
| int opt_no_exceptions; // for --no-exceptions |
| |
| /**************************************************************************/ |
| |
| template <std::size_t N> |
| int bcmp (const std::bitset<N> &bset, |
| const char *str) |
| { |
| RW_ASSERT (0 != str); |
| |
| for (std::size_t i = 0; i != N; ++i) { |
| |
| const char bit = bset [i] ? '1' : '0'; |
| |
| if (bit != str [N - i - 1]) |
| return -1; |
| } |
| |
| return 0; |
| } |
| |
| /**************************************************************************/ |
| |
| // equivalent to the result of std::bitset<bits>(val).to_string<char>() |
| const char* |
| ulong_to_bitstring (unsigned long val, std::size_t bits) |
| { |
| const std::size_t ulongbits = sizeof (unsigned long) * 8; |
| |
| static char bitstr [1024]; |
| |
| for (std::size_t i = 0; i != bits; ++i) { |
| if (i < ulongbits) |
| bitstr [bits - i - 1] = val & (1UL << i) ? '1' : '0'; |
| else |
| bitstr [bits - i - 1] = '0'; |
| } |
| |
| bitstr [bits] = '\0'; |
| return bitstr; |
| } |
| |
| /**************************************************************************/ |
| |
| // exercises the effects of the default bitset ctor |
| template <std::size_t N> |
| void test_default_ctor (std::bitset<N>*) |
| { |
| rw_info (0, 0, __LINE__, "std::bitset<%u>::bitset()", N); |
| |
| const std::bitset<N> bset; |
| |
| char all_zeros [N + 1]; |
| for (std::size_t i = 0; i != N; ++i) all_zeros [i] = '0'; |
| all_zeros [N] = '\0'; |
| |
| rw_assert (!bcmp (bset, all_zeros), 0, __LINE__, |
| "bitset<%u>::bitset() expected 0, got { %.*b }", |
| N, int (N), &bset); |
| } |
| |
| /**************************************************************************/ |
| |
| // exercises the effects of bitset<N>::bitset(unsigned long) |
| template <std::size_t N> |
| void test_long_ctor (std::bitset<N>*) |
| { |
| rw_info (0, 0, __LINE__, "std::bitset<%u>::bitset(unsigned long)", N); |
| |
| #undef DO_TEST |
| #define DO_TEST(T, val) \ |
| do { \ |
| const T v = val; \ |
| const std::bitset<N> bset (v); \ |
| const char* const bstr = ulong_to_bitstring (val, N); \ |
| rw_assert (!bcmp (bset, (const char*)bstr), 0, __LINE__, \ |
| "bitset<%u>::bitset(%zu) == { %{.*b} }, " \ |
| "got { %{.*b} }", N, val, bstr, int (N), &bset); \ |
| } while (0) |
| |
| DO_TEST (unsigned long, 0); |
| DO_TEST (unsigned long, 1); |
| DO_TEST (unsigned long, 2); |
| DO_TEST (unsigned long, 3); |
| DO_TEST (unsigned long, 4); |
| DO_TEST (unsigned long, 5); |
| DO_TEST (unsigned long, 6); |
| DO_TEST (unsigned long, 7); |
| DO_TEST (unsigned long, 8); |
| DO_TEST (unsigned long, 9); |
| DO_TEST (unsigned long, 10); |
| DO_TEST (unsigned long, 11); |
| DO_TEST (unsigned long, 12); |
| DO_TEST (unsigned long, 13); |
| DO_TEST (unsigned long, 14); |
| DO_TEST (unsigned long, 15); |
| DO_TEST (unsigned long, _RWSTD_LONG_MAX / 16); |
| DO_TEST (unsigned long, _RWSTD_LONG_MAX / 8); |
| DO_TEST (unsigned long, _RWSTD_LONG_MAX / 4); |
| DO_TEST (unsigned long, _RWSTD_LONG_MAX / 2); |
| DO_TEST (unsigned long, _RWSTD_LONG_MAX - 2); |
| DO_TEST (unsigned long, _RWSTD_LONG_MAX - 1); |
| DO_TEST (unsigned long, _RWSTD_LONG_MAX); |
| |
| // exercise calls to the ctor with arguments of other integer types |
| DO_TEST (char, 16); |
| DO_TEST (signed char, 17); |
| DO_TEST (unsigned char, 18); |
| DO_TEST (short, 19); |
| DO_TEST (unsigned short, 20); |
| DO_TEST (int, 21); |
| DO_TEST (unsigned int, 22); |
| DO_TEST (long, 23); |
| } |
| |
| /**************************************************************************/ |
| |
| // invokes coverting bitset ctor from basic_string<char, ...> |
| template <std::size_t N, class Traits, class Allocator> |
| 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]) |
| { |
| if (bstr) { |
| if (std::size_t (-1) == pos) |
| return std::bitset<N>(*bstr); |
| |
| if (std::size_t (-1) == n) |
| return std::bitset<N>(*bstr, pos); |
| |
| if (0 == bin_digits) |
| return std::bitset<N>(*bstr, pos, n); |
| |
| if (Traits::eq (bin_digits [0], bin_digits [1])) |
| return std::bitset<N>(*bstr, pos, n, bin_digits [0]); |
| |
| return std::bitset<N>(*bstr, pos, n, bin_digits [0], bin_digits [1]); |
| } |
| |
| #if !defined (_RWSTD_NO_EXT_BITSET_CTOR_CHAR_ARRAY) \ |
| && !defined (_RWSTD_NO_EXT_BITSET_CTOR_STRING) |
| |
| if (std::size_t (-1) == pos) |
| return std::bitset<N>(str); |
| |
| if (std::size_t (-1) == n) |
| return std::bitset<N>(str, pos); |
| |
| if (0 == bin_digits) |
| return std::bitset<N>(str, pos, n); |
| |
| if (Traits::eq (bin_digits [0], bin_digits [1])) |
| return std::bitset<N>(str, pos, n, bin_digits [0]); |
| |
| return std::bitset<N>(str, pos, n, bin_digits [0], bin_digits [1]); |
| |
| #else |
| |
| RW_ASSERT (!"test logic error"); |
| |
| return std::bitset<N>(); |
| |
| #endif // _RWSTD_NO_EXT_BITSET_CTOR_{CHAR_ARRAY,STRING) |
| |
| } |
| |
| |
| #ifndef _RWSTD_NO_WCHAR_T |
| |
| // invokes coverting bitset ctor from basic_string<wchar_t, ...> |
| template <std::size_t N, class Traits, class Allocator> |
| std::bitset<N> |
| bitset_ctor (std::bitset<N>*, |
| const std::basic_string<wchar_t, Traits, Allocator> *bstr, |
| const wchar_t *wstr, |
| std::size_t pos, std::size_t n, const wchar_t bin_digits [2]) |
| { |
| if (bstr) { |
| if (std::size_t (-1) == pos) |
| return std::bitset<N>(*bstr); |
| |
| if (std::size_t (-1) == n) |
| return std::bitset<N>(*bstr, pos); |
| |
| if (0 == bin_digits) |
| return std::bitset<N>(*bstr, pos, n); |
| |
| if (Traits::eq (bin_digits [0], bin_digits [1])) |
| return std::bitset<N>(*bstr, pos, n, bin_digits [0]); |
| |
| return std::bitset<N>(*bstr, pos, n, bin_digits [0], bin_digits [1]); |
| } |
| |
| #if !defined (_RWSTD_NO_EXT_BITSET_CTOR_CHAR_ARRAY) \ |
| && !defined (_RWSTD_NO_EXT_BITSET_CTOR_STRING) |
| |
| if (std::size_t (-1) == pos) |
| return std::bitset<N>(wstr); |
| |
| if (std::size_t (-1) == n) |
| return std::bitset<N>(wstr, pos); |
| |
| if (0 == bin_digits) |
| return std::bitset<N>(wstr, pos, n); |
| |
| if (Traits::eq (bin_digits [0], bin_digits [1])) |
| return std::bitset<N>(wstr, pos, n, bin_digits [0]); |
| |
| return std::bitset<N>(wstr, pos, n, bin_digits [0], bin_digits [1]); |
| |
| #else |
| |
| RW_ASSERT (!"test logic error"); |
| |
| return std::bitset<N>(); |
| |
| #endif // _RWSTD_NO_EXT_BITSET_CTOR_{CHAR_ARRAY,STRING) |
| |
| } |
| |
| #endif // _RWSTD_NO_WCHAR_T |
| |
| |
| // invokes coverting bitset ctor from basic_string<UserChar, ...> |
| template <std::size_t N, class Traits, class Allocator> |
| std::bitset<N> |
| bitset_ctor (std::bitset<N>*, |
| const std::basic_string<UserChar, Traits, Allocator> *bstr, |
| const UserChar* /* intentionally unused */, |
| std::size_t pos, std::size_t n, const UserChar bin_digits [2]) |
| { |
| if (std::size_t (-1) == pos) |
| pos = 0; |
| |
| if (0 == bin_digits) { |
| static const UserChar zero_one[] = { { 0.0, '0' }, { 0.0, '1' } }; |
| |
| bin_digits = zero_one; |
| } |
| |
| if (bstr) |
| return std::bitset<N>(*bstr, pos, n, bin_digits [0], bin_digits [1]); |
| |
| // cannot invoke std::bitset<N>(const UserChar*) without providing |
| // an explicit specialization of std::char_traits<UserChar> that |
| // implements eq() and length() |
| RW_ASSERT (!"test logic error"); |
| |
| return std::bitset<N>(); |
| } |
| |
| |
| // constructs a bitset object by invoking one of the overloaded ctors |
| template <std::size_t N, class charT, class Traits, class Allocator> |
| std::bitset<N> |
| bitset_ctor (std::bitset<N>*, |
| std::basic_string<charT, Traits, Allocator> *p, |
| const char *str, std::size_t pos, std::size_t n) |
| { |
| charT wstr [1024]; |
| |
| for (std::size_t i = 0; i != sizeof wstr / sizeof *wstr; ++i) { |
| if (str [i]) |
| Traits::assign (wstr [i], make_char (str [i], (charT*)0)); |
| else { |
| Traits::assign (wstr [i], charT ()); |
| break; |
| } |
| } |
| |
| typedef std::bitset<N> Bitset; |
| typedef std::basic_string<charT, Traits, Allocator> String; |
| |
| if (p) { // use one of the const basic_string& overloads |
| |
| const String bstr (wstr); |
| |
| return bitset_ctor ((Bitset*)0, &bstr, 0, pos, n, (charT*)0); |
| } |
| else { // invoke one of the const charT* overloads |
| |
| return bitset_ctor ((Bitset*)0, (String*)0, wstr, pos, n, (charT*)0); |
| } |
| } |
| |
| |
| template <class charT> |
| const char* type_prefix (charT) { return ""; } |
| |
| #ifndef _RWSTD_NO_WCHAR_T |
| |
| const char* type_prefix (wchar_t) { return "L"; } |
| |
| #endif // _RWSTD_NO_WCHAR_T |
| |
| enum { InvalidArgument = 1, OutOfRange }; |
| |
| template <std::size_t N, class charT, class Traits, class Allocator> |
| 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) |
| { |
| static const char* const tpfx = type_prefix (charT ()); |
| |
| typedef std::bitset<N> Bitset; |
| typedef std::basic_string<charT, Traits, Allocator> String; |
| |
| static const char* const exstr[] = { |
| "failed to throw", |
| "caught std::invalid_argument", |
| "caught std::out_of_range", |
| "caught unknown exception" |
| }; |
| |
| // compute which exception, if any, the ctor is expected to throw |
| const int except = int (bitstr - (char*)0) < 3 ? |
| int (bitstr - (char*)0) : 0; |
| |
| if (except && opt_no_exceptions) |
| return; |
| |
| int caught = 0; |
| |
| |
| _TRY { |
| // invoke one of the overloads of the constructor |
| const Bitset bset = bitset_ctor ((Bitset*)0, p, str, pos, n); |
| |
| if (!except) |
| rw_assert (!bcmp (bset, bitstr), 0, line, |
| "line %d: bitset<%u>::bitset(%s\"%s\"" |
| "%{?}, %zu%{?}, %zu%{;}%{;}) " |
| "== { %s }, got { %{.*b} }", |
| __LINE__, N, tpfx, str, |
| pos != std::size_t (-1), pos, |
| n != std::size_t (-1), n, |
| bitstr, int (N), &bset); |
| } |
| |
| #ifndef _RWSTD_NO_EXCEPTIONS |
| |
| catch (const std::out_of_range&) { |
| caught = OutOfRange; |
| } |
| catch (const std::invalid_argument&) { |
| caught = InvalidArgument; |
| } |
| catch (...) { |
| caught = 3; |
| } |
| #endif // _RWSTD_NO_EXCEPTIONS |
| |
| rw_assert (except == caught, 0, line, |
| "line %d: bitset<%u>::bitset(%s\"%s\", %u, %u) " |
| "unexpectedly %s", __LINE__, N, tpfx, str, pos, n, |
| exstr [caught]); |
| } |
| |
| |
| std::string |
| fillstr (const char *pfx, int bit, std::size_t count, const char *sfx) |
| { |
| std::string str (pfx); |
| str.append (count, char ('0' + bit)); |
| str.append (sfx); |
| return str; |
| } |
| |
| |
| template <class charT, class Traits, class Allocator> |
| void test_string_ctor (std::basic_string<charT, Traits, Allocator> *p, |
| const char *cname) |
| { |
| #undef DO_TEST |
| #define DO_TEST(N, str, pos, n, except) \ |
| test_string_ctor ((std::bitset<N>*)0, p, __LINE__, \ |
| str, std::size_t (pos), std::size_t (n), \ |
| (const char*)except) |
| |
| ////////////////////////////////////////////////////////////////// |
| |
| #define CTOR_INFO(N) \ |
| rw_info (0, 0, __LINE__, "std::bitset<%i>::bitset(const " \ |
| "%{?}std::basic_string<%s>&%{:}%3$s%{;})", \ |
| N, 0 != p, cname) |
| |
| CTOR_INFO (0); |
| |
| #define TEST_1(N, str, except) DO_TEST(N, str, -1, -1, except) |
| |
| // +----------- bitset size |
| // | +-------- string argument |
| // | | +-- result or exception |
| // v v v |
| TEST_1 (0, "", ""); |
| TEST_1 (0, "0", ""); |
| TEST_1 (0, "1", ""); |
| TEST_1 (0, "2", InvalidArgument); |
| TEST_1 (0, "00", ""); |
| TEST_1 (0, "01", ""); |
| TEST_1 (0, "02", InvalidArgument); |
| |
| CTOR_INFO (1); |
| |
| TEST_1 (1, "", "0"); |
| TEST_1 (1, "0", "0"); |
| TEST_1 (1, "1", "1"); |
| TEST_1 (1, "2", InvalidArgument); |
| TEST_1 (1, "00", "0"); |
| TEST_1 (1, "01", "0"); |
| TEST_1 (1, "02", InvalidArgument); |
| |
| CTOR_INFO (2); |
| |
| TEST_1 (2, "", "00"); |
| TEST_1 (2, "0", "00"); |
| TEST_1 (2, "1", "01"); |
| TEST_1 (2, "2", InvalidArgument); |
| TEST_1 (2, "00", "00"); |
| TEST_1 (2, "01", "01"); |
| TEST_1 (2, "02", InvalidArgument); |
| TEST_1 (2, "10", "10"); |
| TEST_1 (2, "11", "11"); |
| TEST_1 (2, "12", InvalidArgument); |
| TEST_1 (2, "20", InvalidArgument); |
| TEST_1 (2, "21", InvalidArgument); |
| TEST_1 (2, "22", InvalidArgument); |
| TEST_1 (2, "000", "00"); |
| TEST_1 (2, "001", "00"); |
| TEST_1 (2, "002", InvalidArgument); |
| TEST_1 (2, "010", "01"); |
| TEST_1 (2, "011", "01"); |
| TEST_1 (2, "012", InvalidArgument); |
| TEST_1 (2, "020", InvalidArgument); |
| TEST_1 (2, "100", "10"); |
| TEST_1 (2, "101", "10"); |
| TEST_1 (2, "110", "11"); |
| TEST_1 (2, "111", "11"); |
| TEST_1 (2, "112", InvalidArgument); |
| TEST_1 (2, "200", InvalidArgument); |
| TEST_1 (2, "201", InvalidArgument); |
| TEST_1 (2, "202", InvalidArgument); |
| |
| CTOR_INFO (3); |
| |
| TEST_1 (3, "", "000"); |
| TEST_1 (3, "0", "000"); |
| TEST_1 (3, "1", "001"); |
| TEST_1 (3, "2", InvalidArgument); |
| TEST_1 (3, "00", "000"); |
| TEST_1 (3, "01", "001"); |
| TEST_1 (3, "02", InvalidArgument); |
| TEST_1 (3, "10", "010"); |
| TEST_1 (3, "11", "011"); |
| TEST_1 (3, "12", InvalidArgument); |
| TEST_1 (3, "000", "000"); |
| TEST_1 (3, "001", "001"); |
| TEST_1 (3, "002", InvalidArgument); |
| TEST_1 (3, "010", "010"); |
| TEST_1 (3, "011", "011"); |
| TEST_1 (3, "012", InvalidArgument); |
| TEST_1 (3, "100", "100"); |
| TEST_1 (3, "101", "101"); |
| TEST_1 (3, "102", InvalidArgument); |
| TEST_1 (3, "100", "100"); |
| TEST_1 (3, "101", "101"); |
| TEST_1 (3, "102", InvalidArgument); |
| |
| TEST_1 (3, "0001", "000"); |
| TEST_1 (3, "0010", "001"); |
| TEST_1 (3, "0100", "010"); |
| TEST_1 (3, "1000", "100"); |
| TEST_1 (3, "1001", "100"); |
| |
| TEST_1 (3, "0001", "000"); |
| TEST_1 (3, "0010", "001"); |
| TEST_1 (3, "0100", "010"); |
| TEST_1 (3, "1000", "100"); |
| TEST_1 (3, "1001", "100"); |
| TEST_1 (3, "1002", InvalidArgument); |
| TEST_1 (3, "2000", InvalidArgument); |
| |
| TEST_1 (3, "10010", "100"); |
| TEST_1 (3, "10011", "100"); |
| TEST_1 (3, "10012", InvalidArgument); |
| TEST_1 (3, "100102", InvalidArgument); |
| |
| // macro to insert N zeros or ones in between two string literals |
| #define FILL(pfx, bit, N, sfx) fillstr (pfx, bit, N, sfx).c_str () |
| |
| CTOR_INFO (33); |
| |
| // +------------- preceded by these characters |
| // | +--------- binary digit (0 or 1) |
| // | | +------ repeated this many times |
| // | | | +-- followed by these characters |
| // | | | | |
| // v v v v |
| TEST_1 (33, "", FILL ("", 0, 33, "")); |
| TEST_1 (33, "0", FILL ("", 0, 33, "")); |
| TEST_1 (33, "1", FILL ("", 0, 32, "1")); |
| TEST_1 (33, "00", FILL ("", 0, 31, "00")); |
| TEST_1 (33, "01", FILL ("", 0, 31, "01")); |
| TEST_1 (33, "10", FILL ("", 0, 31, "10")); |
| TEST_1 (33, "11", FILL ("", 0, 31, "11")); |
| TEST_1 (33, "100", FILL ("", 0, 30, "100")); |
| TEST_1 (33, "101", FILL ("", 0, 30, "101")); |
| |
| TEST_1 (33, FILL ("1", 0, 32, ""), FILL ("10", 0, 30, "0")); |
| TEST_1 (33, FILL ("1", 0, 31, "1"), FILL ("10", 0, 30, "1")); |
| TEST_1 (33, FILL ("1", 0, 31, "2"), InvalidArgument); |
| |
| TEST_1 (33, FILL ("", 1, 33, ""), FILL ("", 1, 33, "")); |
| TEST_1 (33, FILL ("", 1, 32, "0"), FILL ("", 1, 32, "0")); |
| TEST_1 (33, FILL ("", 1, 31, "00"), FILL ("", 1, 31, "00")); |
| TEST_1 (33, FILL ("", 1, 30, "000"), FILL ("", 1, 30, "000")); |
| TEST_1 (33, FILL ("", 1, 29, "0000"), FILL ("", 1, 29, "0000")); |
| TEST_1 (33, FILL ("", 1, 28, "00000"), FILL ("", 1, 28, "00000")); |
| TEST_1 (33, FILL ("", 1, 28, "00001"), FILL ("", 1, 28, "00001")); |
| TEST_1 (33, FILL ("", 1, 28, "00010"), FILL ("", 1, 28, "00010")); |
| TEST_1 (33, FILL ("", 1, 28, "00100"), FILL ("", 1, 28, "00100")); |
| TEST_1 (33, FILL ("", 1, 28, "01000"), FILL ("", 1, 28, "01000")); |
| TEST_1 (33, FILL ("", 1, 28, "02000"), InvalidArgument); |
| |
| TEST_1 (33, FILL ("", 1, 33, "0"), FILL ("", 1, 33, "")); |
| TEST_1 (33, FILL ("", 1, 33, "1"), FILL ("", 1, 33, "")); |
| TEST_1 (33, FILL ("", 1, 33, "2"), InvalidArgument); |
| TEST_1 (33, FILL ("2", 1, 33, ""), InvalidArgument); |
| |
| CTOR_INFO (80); |
| |
| TEST_1 (80, FILL ("" , 1, 80, ""), FILL ("" , 1, 80, "")); |
| TEST_1 (80, FILL ("1", 0, 78, "1"), FILL ("1" , 0, 78, "1")); |
| TEST_1 (80, FILL ("1", 0, 77, "10"), FILL ("1" , 0, 77, "10")); |
| TEST_1 (80, FILL ("1", 0, 77, "20"), InvalidArgument); |
| TEST_1 (80, FILL ("2", 0, 77, "00"), InvalidArgument); |
| TEST_1 (80, FILL ("02", 0, 76, "00"), InvalidArgument); |
| TEST_1 (80, FILL ("12", 0, 76, "00"), InvalidArgument); |
| |
| ////////////////////////////////////////////////////////////////// |
| #undef CTOR_INFO |
| #define CTOR_INFO(N) \ |
| rw_info (0, 0, __LINE__, "std::bitset<%i>::bitset(const " \ |
| "%{?}std::basic_string<%s>&%{:}%3$s%{;}, size_t)", \ |
| N, 0 != p, cname) |
| |
| #define TEST_2(N, str, pos, except) DO_TEST(N, str, pos, -1, except) |
| |
| CTOR_INFO (0); |
| |
| TEST_2 (0, "", 0, ""); |
| TEST_2 (0, "", 1, OutOfRange); |
| TEST_2 (0, "0", 0, ""); |
| TEST_2 (0, "1", 0, ""); |
| TEST_2 (0, "2", 0, InvalidArgument); |
| TEST_2 (0, "0", 1, ""); |
| TEST_2 (0, "1", 1, ""); |
| TEST_2 (0, "2", 1, ""); |
| |
| CTOR_INFO (1); |
| |
| TEST_2 (1, "", 0, "0"); |
| TEST_2 (1, "0", 0, "0"); |
| TEST_2 (1, "1", 0, "1"); |
| TEST_2 (1, "2", 0, InvalidArgument); |
| |
| TEST_2 (1, "00", 0, "0"); |
| TEST_2 (1, "01", 0, "0"); |
| TEST_2 (1, "02", 0, InvalidArgument); |
| TEST_2 (1, "10", 0, "1"); |
| TEST_2 (1, "11", 0, "1"); |
| TEST_2 (1, "12", 0, InvalidArgument); |
| |
| TEST_2 (1, "00", 1, "0"); |
| TEST_2 (1, "01", 1, "1"); |
| TEST_2 (1, "02", 1, InvalidArgument); |
| TEST_2 (1, "10", 1, "0"); |
| TEST_2 (1, "11", 1, "1"); |
| TEST_2 (1, "12", 1, InvalidArgument); |
| TEST_2 (1, "20", 1, "0"); |
| TEST_2 (1, "21", 1, "1"); |
| TEST_2 (1, "22", 1, InvalidArgument); |
| |
| TEST_2 (1, "000", 1, "0"); |
| TEST_2 (1, "001", 1, "0"); |
| TEST_2 (1, "002", 1, InvalidArgument); |
| TEST_2 (1, "010", 1, "1"); |
| TEST_2 (1, "011", 1, "1"); |
| TEST_2 (1, "012", 1, InvalidArgument); |
| TEST_2 (1, "020", 1, InvalidArgument); |
| TEST_2 (1, "021", 1, InvalidArgument); |
| TEST_2 (1, "022", 1, InvalidArgument); |
| TEST_2 (1, "120", 1, InvalidArgument); |
| TEST_2 (1, "121", 1, InvalidArgument); |
| TEST_2 (1, "122", 1, InvalidArgument); |
| TEST_2 (1, "200", 1, "0"); |
| TEST_2 (1, "201", 1, "0"); |
| TEST_2 (1, "202", 1, InvalidArgument); |
| |
| TEST_2 (1, "320", 2, "0"); |
| TEST_2 (1, "321", 2, "1"); |
| TEST_2 (1, "322", 2, InvalidArgument); |
| TEST_2 (1, "3200", 2, "0"); |
| TEST_2 (1, "3201", 2, "0"); |
| TEST_2 (1, "3202", 2, InvalidArgument); |
| TEST_2 (1, "3210", 2, "1"); |
| TEST_2 (1, "3211", 2, "1"); |
| TEST_2 (1, "3212", 2, InvalidArgument); |
| |
| TEST_2 (1, "", 1, OutOfRange); |
| |
| ////////////////////////////////////////////////////////////////// |
| #undef CTOR_INFO |
| #define CTOR_INFO(N) \ |
| rw_info (0, 0, __LINE__, "std::bitset<%i>::bitset(const " \ |
| "%{?}std::basic_string<%s>&%{:}%3$s%{;}, size_t, size_t)", \ |
| N, 0 != p, cname) |
| |
| CTOR_INFO (0); |
| |
| #define TEST_3(N, str, pos, n, except) DO_TEST(N, str, pos, n, except) |
| |
| // +-------------------- bitset size |
| // | +----------------- string argument |
| // | | +---------- pos |
| // | | | +------ n |
| // | | | | +--- result or exception |
| // | | | | | |
| // v v v v v |
| TEST_3 (0, "", 0, 0, ""); |
| TEST_3 (0, "", 1, 0, OutOfRange); |
| TEST_3 (0, "02", 0, 0, ""); |
| |
| CTOR_INFO (1); |
| |
| TEST_3 (1, "012", 0, 1, "0"); |
| TEST_3 (1, "012", 1, 1, "1"); |
| TEST_3 (1, "012", 2, 1, InvalidArgument); |
| |
| TEST_3 (1, "", 0, 0, "0"); |
| TEST_3 (1, "", 1, 0, OutOfRange); |
| |
| CTOR_INFO (8); |
| |
| TEST_3 (8, "11111111", 0, 8, FILL ("", 1, 8, "")); |
| TEST_3 (8, "11111111", 1, 7, FILL ("0", 1, 7, "")); |
| TEST_3 (8, "11111111", 2, 6, FILL ("00", 1, 6, "")); |
| TEST_3 (8, "11111111", 3, 5, FILL ("000", 1, 5, "")); |
| TEST_3 (8, "11111111", 4, 4, FILL ("0000", 1, 4, "")); |
| TEST_3 (8, "11111111", 5, 3, FILL ("00000", 1, 3, "")); |
| TEST_3 (8, "11111111", 6, 2, FILL ("000000", 1, 2, "")); |
| TEST_3 (8, "11111111", 7, 1, FILL ("0000000", 1, 1, "")); |
| TEST_3 (8, "11111111", 8, 0, FILL ("00000000", 1, 0, "")); |
| TEST_3 (8, "11111111", 9, 0, OutOfRange); |
| TEST_3 (8, "11111111", 9, 1, OutOfRange); |
| TEST_3 (8, "111111112", 7, 1, FILL ("0000000", 1, 1, "")); |
| TEST_3 (8, "111111112", 7, 2, InvalidArgument); |
| |
| TEST_3 (8, "211111112", 1, 7, FILL ("0", 1, 7, "")); |
| TEST_3 (8, "210111112", 1, 7, FILL ("010", 1, 5, "")); |
| TEST_3 (8, "211111012", 1, 7, FILL ("0", 1, 5, "01")); |
| |
| CTOR_INFO (40); |
| |
| TEST_3 (40, FILL ("", 0, 40, ""), 0, 0, FILL ("", 0, 40, "")); |
| TEST_3 (40, FILL ("", 0, 40, "1"), 0, 40, FILL ("", 0, 40, "")); |
| TEST_3 (40, FILL ("", 0, 40, "1"), 0, 41, FILL ("", 0, 40, "")); |
| TEST_3 (40, FILL ("", 0, 39, "1"), 0, 39, FILL ("", 0, 40, "")); |
| TEST_3 (40, FILL ("", 0, 39, "1"), 0, 40, FILL ("", 0, 39, "1")); |
| TEST_3 (40, FILL ("1", 0, 40, "1"), 0, 0, FILL ("", 0, 40, "")); |
| TEST_3 (40, FILL ("1", 0, 38, "1"), 0, 40, FILL ("1", 0, 38, "1")); |
| TEST_3 (40, FILL ("1", 0, 38, "1"), 0, 40, FILL ("1", 0, 38, "1")); |
| TEST_3 (40, FILL ("2", 0, 40, "2"), 1, 40, FILL ("", 0, 40, "")); |
| } |
| |
| /**************************************************************************/ |
| |
| template <std::size_t N> |
| void test_ctors (std::bitset<N>* pb) |
| { |
| test_default_ctor (pb); |
| test_long_ctor (pb); |
| } |
| |
| /**************************************************************************/ |
| |
| template <class Traits> |
| void test_ctors (const Traits*, const char *cname) |
| { |
| typedef typename Traits::char_type char_type; |
| typedef std::allocator<char_type> Allocator; |
| typedef std::basic_string<char_type, Traits, Allocator> String; |
| |
| // exercise const std::string& overloads |
| test_string_ctor ((String*)1, cname); |
| |
| #if !defined (_RWSTD_NO_EXT_BITSET_CTOR_CHAR_ARRAY) \ |
| && !defined (_RWSTD_NO_EXT_BITSET_CTOR_STRING) |
| |
| // exercise const char* and const wchar_t* extensions |
| // but avoid calling the bitset(const UserChar*) overload in order |
| if (sizeof (char_type) != sizeof (UserChar)) |
| test_string_ctor ((String*)0, cname); |
| |
| #endif // _RWSTD_NO_EXT_BITSET_CTOR_{CHAR_ARRAY,STRING} |
| |
| } |
| |
| /**************************************************************************/ |
| |
| static int |
| run_test (int, char**) |
| { |
| #ifdef _RWSTD_NO_EXCEPTIONS |
| opt_no_exceptions = 1; |
| #endif // _RWSTD_NO_EXCEPTIONS |
| |
| if (opt_no_exceptions) |
| rw_note (0, 0, 0, "exception tests disabled"); |
| |
| #undef DO_TEST |
| #define DO_TEST(N) test_ctors ((std::bitset<N>*)0) |
| |
| DO_TEST ( 0); // interesting case |
| DO_TEST ( 1); // interesting case |
| DO_TEST ( 2); |
| DO_TEST ( 31); |
| DO_TEST ( 32); // interesting case |
| DO_TEST ( 33); // interesting case |
| DO_TEST ( 34); |
| DO_TEST ( 63); |
| DO_TEST ( 64); // interesting case |
| DO_TEST ( 65); // interesting case |
| DO_TEST ( 66); |
| |
| DO_TEST ( 123); |
| |
| DO_TEST ( 127); // interesting case |
| DO_TEST ( 128); // interesting case |
| DO_TEST ( 129); |
| DO_TEST ( 130); |
| DO_TEST ( 255); |
| DO_TEST ( 256); // interesting case |
| |
| #if !defined(_MSC_VER) || _MSC_VER != 1300 |
| // FIXME: MSVC can't compile bitset<257>! |
| DO_TEST ( 257); // interesting case |
| #endif |
| |
| DO_TEST ( 258); // interesting case |
| DO_TEST ( 333); |
| |
| if (0 <= opt_char) { |
| typedef std::char_traits<char> NarrowTraits; |
| |
| test_ctors ((NarrowTraits*)0, "char"); |
| } |
| else { |
| rw_note (0, 0, __LINE__, "tests of char specialization disabled"); |
| } |
| |
| #ifndef _RWSTD_NO_WCHAR_T |
| |
| if (0 <= opt_wchar) { |
| typedef std::char_traits<wchar_t> WideTraits; |
| |
| test_ctors ((WideTraits*)0, "wchar_t"); |
| } |
| else { |
| rw_note (0, 0, __LINE__, "tests of wchar_t specialization disabled"); |
| } |
| |
| #endif // _RWSTD_NO_WCHAR_T |
| |
| if (0 <= opt_userchar) { |
| test_ctors ((UserTraits<UserChar>*)0, "UserChar"); |
| } |
| else { |
| rw_note (0, 0, __LINE__, "tests of UserChar specialization disabled"); |
| } |
| |
| return 0; |
| } |
| |
| /**************************************************************************/ |
| |
| int main (int argc, char *argv[]) |
| { |
| return rw_test (argc, argv, __FILE__, |
| "lib.bitset.cons", |
| 0 /* no comment */, |
| run_test, |
| "|-char~ " |
| "|-wchar_t~ " |
| "|-UserChar~ " |
| "|-no-exceptions# ", |
| &opt_char, |
| &opt_wchar, |
| &opt_userchar, |
| &opt_no_exceptions, |
| (void*)0 /* sentinel */); |
| } |
