stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From se...@apache.org
Subject svn commit: r453820 - /incubator/stdcxx/trunk/tests/containers/23.bitset.cpp
Date Sat, 07 Oct 2006 00:38:21 GMT
Author: sebor
Date: Fri Oct  6 17:38:20 2006
New Revision: 453820

URL: http://svn.apache.org/viewvc?view=rev&rev=453820
Log:
2006-10-06  Martin Sebor  <sebor@roguewave.com>

	STDCXX-4
	* 23.bitset.cpp: New test exercising lib.bitset.

Added:
    incubator/stdcxx/trunk/tests/containers/23.bitset.cpp   (with props)

Added: incubator/stdcxx/trunk/tests/containers/23.bitset.cpp
URL: http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/containers/23.bitset.cpp?view=auto&rev=453820
==============================================================================
--- incubator/stdcxx/trunk/tests/containers/23.bitset.cpp (added)
+++ incubator/stdcxx/trunk/tests/containers/23.bitset.cpp Fri Oct  6 17:38:20 2006
@@ -0,0 +1,1365 @@
+/***************************************************************************
+ *
+ * 23.bitset.cpp - test exercising [lib.bitset]
+ *
+ * $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 2001-2006 Rogue Wave Software.
+ * 
+ **************************************************************************/
+
+#include <bitset>
+#include <istream>
+#include <ostream>
+
+#include <cstdio>     // for sprintf()
+#include <climits>
+
+#include <rw_char.h>  // for UserChar
+#include <rw_rand.h>  // for rw_rand()
+#include <driver.h>   // for rw_test(), ...
+
+
+#define NLOOPS 128
+
+/**************************************************************************/
+
+// sets the `n' least significant bits
+std::size_t
+bitmax (std::size_t n)
+{
+    std::size_t result = 0;
+    while (n--)
+        result = result << 1 | 1U;
+    return result;
+}
+
+/**************************************************************************/
+
+// fake bitset class, bit pattern represented as a character string
+template <std::size_t N>
+struct test_set
+{
+    char bits_ [N + 1];
+
+    test_set () {
+        reset ();
+        bits_ [N] = '\0';   // null-terminate
+    }
+
+    _EXPLICIT test_set (unsigned long val) {
+        for (std::size_t i = 0; i != N; ++i)
+            set (i, !!(val & (1UL << i)));
+        bits_ [N] = '\0';   // NUL-terminate
+    }
+
+    _EXPLICIT test_set (const std::bitset<N> &rhs) {
+        for (std::size_t i = 0; i != N; ++i)
+            set (i, rhs.test (i));
+        bits_ [N] = '\0';   // NUL-terminate
+    }
+
+    // accessor function provided to work around
+    // a MIPSpro 7.3.1.1 bug (PR #25682)
+    const char* bits () const {
+        return bits_;
+    }
+
+    test_set& random () {
+        for (std::size_t i = 0; i != N; ++i)
+            bits_ [i] = char ('0' + rw_rand (2U));
+        return *this;
+    }
+
+    std::bitset<N> to_bitset () const {
+        std::bitset<N> tmp;
+        for (std::size_t i = 0; i != N; ++i)
+            tmp.set (i, test (i));
+        return tmp;
+    }
+
+    test_set& operator&= (const test_set &rhs) {
+        for (std::size_t i = 0; i != N; ++i)
+            bits_ [i] = '0' + ('1' == bits_ [i] && '1' == rhs.bits_ [i]);
+        return *this;
+    }
+
+    test_set& operator|= (const test_set &rhs) {
+        for (std::size_t i = 0; i != N; ++i)
+            bits_ [i] = '0' + ('1' == bits_ [i] || '1' == rhs.bits_ [i]);
+        return *this;
+    }
+
+    test_set& operator^= (const test_set &rhs) {
+        for (std::size_t i = 0; i != N; ++i)
+            bits_ [i] = '0' + !!(bits_ [i] - rhs.bits_ [i]);
+        return *this;
+    }
+
+    test_set& operator<<= (std::size_t n) {
+        for (std::size_t i = 0; i < N - n && i + n + 1 < N + 1; ++i)
+            bits_ [i] = bits_ [i + n];
+        for (std::size_t j = N - n; j != N; ++j)
+            bits_ [j] = '0';
+        return *this;
+    }
+
+    test_set& operator>>= (std::size_t n) {
+        for (std::size_t i = N - 1; i != n - 1; --i)
+            bits_ [i] = bits_ [i - n];
+        for (std::size_t j = n; j != 0; )
+            bits_ [--j] = '0';
+        return *this;
+    }
+
+    test_set& set () {
+        for (std::size_t i = 0; i != N; ++i)
+            bits_ [i] = '1';
+        return *this;
+    }
+
+    test_set& set (std::size_t pos, bool val) {
+        bits_ [N - pos - 1] = '0' + val;
+        return *this;
+    }
+
+    test_set& reset () {
+        for (std::size_t i = 0; i != N; ++i)
+            bits_ [i] = '0';
+        return *this;
+    }
+
+    test_set& reset (std::size_t pos) {
+        return bits_ [N - pos - 1] = '0', *this;
+    }
+
+    test_set operator~ () const {
+        return test_set (*this).flip ();
+    }
+
+    test_set& flip () {
+        for (std::size_t i = 0; i != N; ++i)
+            bits_ [i] = '0' + ('0' == bits_ [i]);
+        return *this;
+    }
+
+    test_set& flip (std::size_t pos) {
+        bits_ [N - pos - 1] = '0' + ('0' == bits_ [N - pos - 1]);
+        return *this;
+    }
+
+    std::size_t count () const {
+        std::size_t n = 0;
+        for (std::size_t i = 0; i != N; ++i)
+            n += bits_ [i] != '0';
+        return n;
+    }
+
+    bool operator== (const test_set &rhs) const {
+        for (std::size_t i = 0; i != N; ++i)
+            if (bits_ [i] != rhs.bits_ [i])
+                return false;
+        return true;
+    }
+
+    bool test (std::size_t pos) const {
+        return '0' != bits_ [N - pos - 1];
+    }
+};
+
+/**************************************************************************/
+
+#ifndef _RWSTD_NO_EXPLICIT
+
+// helper to verify that bitset ctor is explicit
+// not defined since it must not be referenced if test is successful
+// static commented out to prevent gcc warning: function declared
+// 'static' but never defined
+/* static */ void
+is_explicit (const std::bitset<0>&);
+
+struct has_implicit_ctor
+{
+    // NOT explicit
+    has_implicit_ctor (const std::string&) { }
+};
+
+// calls to the overloaded is_explicit() resolve to the function below
+static void
+is_explicit (const has_implicit_ctor&) { }
+
+#endif   // _RWSTD_NO_EXPLICIT
+
+
+static void
+test_synopsis (std::bitset<0>*)
+{
+    // prevent warnings about unreachable code
+    volatile bool dummy = false;
+
+    if (!dummy)
+        return;
+
+    typedef std::bitset<0>    Bitset;
+    typedef Bitset::reference Reference;
+
+    Bitset::reference *pr = (Bitset::reference*)0;
+    _RWSTD_UNUSED (pr);
+
+// verify that a member function is accessible and has the appropriate
+// signature, including return type and exception specification
+#define MEMFUN(result, name, arg_list) do {                                   \
+        result (Bitset::reference::*pf) arg_list = &Bitset::reference::name;  \
+        _RWSTD_UNUSED (pf);                                                   \
+    } while (0)
+
+    // exercise bitset::reference members
+    MEMFUN (Reference&, operator=, (bool));
+    MEMFUN (Reference&, operator=, (const Reference&));
+    MEMFUN (bool, operator~, () const);
+    MEMFUN (bool, operator bool, () const);
+    MEMFUN (Reference&, flip, ());
+
+    // 23.3.5.1 - verify bitset ctors
+#if    !defined (_RWSTD_NO_EXPLICIT) \
+    && (!defined (__SUNPRO_CC) || __SUNPRO_CC > 0x530) \
+    && (!defined (__GNUG__) || __GNUG__ >= 3)
+    // working around a SunPro 5.2 bug (see PR #25959)
+
+    // verify that bitset ctor is declared explicit
+    is_explicit (std::string ());
+
+#endif   // _RWSTD_NO_EXPLICIT && SunPro > 5.3
+
+    // verify default arguments
+    (void)Bitset (std::string ());
+    (void)Bitset (std::string (), std::string::size_type ());
+
+// verify that a member function is accessible and has the appropriate
+// signature, including return type and exception specification
+#undef MEMFUN
+#define MEMFUN(result, name, arg_list) do {              \
+        result (Bitset::*pf) arg_list = &Bitset::name;   \
+        _RWSTD_UNUSED (pf);                              \
+    } while (0)
+
+    MEMFUN (Bitset&, operator&=, (const Bitset&));
+    MEMFUN (Bitset&, operator|=, (const Bitset&));
+    MEMFUN (Bitset&, operator^=, (const Bitset&));
+    MEMFUN (Bitset&, operator<<=, (std::size_t));
+    MEMFUN (Bitset&, operator>>=, (std::size_t));
+
+    MEMFUN (Bitset&, set, ());
+    MEMFUN (Bitset&, set, (std::size_t, bool));   // lwg issue 186
+    Bitset ().set (0);   // verify default argument
+
+    MEMFUN (Bitset&, reset, ());
+    MEMFUN (Bitset&, reset, (std::size_t));
+    
+    MEMFUN (Bitset, operator~, () const);
+    MEMFUN (Bitset&, flip, ());
+    MEMFUN (Bitset&, flip, (std::size_t));
+
+    MEMFUN (Bitset::reference, operator[], (std::size_t));
+    MEMFUN (bool, operator[], (std::size_t) const);
+
+    MEMFUN (unsigned long, to_ulong, () const);
+
+#ifndef _RWSTD_NO_MEMBER_TEMPLATES
+#  if !defined (__HP_aCC) || __HP_aCC >= 60000
+
+     // working around HP aCC bugs PR #23312 and bug #503
+
+#    define PARAMLIST_3(T)   T, std::char_traits<T>, std::allocator<T>
+#    define PARAMLIST_2(T)   T, std::char_traits<T>
+
+    // exercise the overloaded member template function and ordinary
+    // member function to_string()
+    MEMFUN (std::basic_string<PARAMLIST_3 (char) >,
+            to_string<PARAMLIST_3 (char) >, (char, char) const);
+    MEMFUN (std::basic_string<PARAMLIST_3 (char) >,
+            to_string, (char, char) const);
+
+#    ifndef _RWSTD_NO_WCHAR_T
+
+    MEMFUN (std::basic_string<PARAMLIST_3 (wchar_t) >,
+            to_string<PARAMLIST_3 (wchar_t) >, (wchar_t, wchar_t) const);
+
+#    endif   // _RWSTD_NO_WCHAR_T
+
+    MEMFUN (std::basic_string<PARAMLIST_3 (int) >,
+            to_string<PARAMLIST_3 (int) >, (int, int) const);
+
+#    undef PARAMLIST_3
+#    undef PARAMLIST_2
+
+#  endif   // !__HP_aCC || __HP_aCC >= 60000
+#endif   // _RWSTD_NO_MEMBER_TEMPLATES
+
+    MEMFUN (std::size_t, size, () const);
+    MEMFUN (std::size_t, count, () const);
+
+    MEMFUN (bool, operator==, (const Bitset&) const);
+    MEMFUN (bool, operator!=, (const Bitset&) const);
+
+    MEMFUN (bool, test, (std::size_t) const);
+    MEMFUN (bool, any, () const);
+    MEMFUN (bool, none, () const);
+    
+    MEMFUN (Bitset, operator>>, (std::size_t) const);
+    MEMFUN (Bitset, operator<<, (std::size_t) const);
+
+#define FUN(result, name, arg_list) do {  \
+        result (*pf) arg_list = &name;    \
+        _RWSTD_UNUSED (pf);               \
+    } while (0)
+
+#if !defined (__IBMCPP__) || __IBMCPP__ > 502
+    FUN (Bitset, std::operator&, (const Bitset&, const Bitset&));
+    FUN (Bitset, std::operator|, (const Bitset&, const Bitset&));
+    FUN (Bitset, std::operator^, (const Bitset&, const Bitset&));
+
+#else
+    // working around xlC 5.0.2.0 bug: PR #26561
+
+    FUN (Bitset, std::operator&,(const Bitset&,const Bitset&) _PTR_THROWS(()));
+    FUN (Bitset, std::operator|,(const Bitset&,const Bitset&) _PTR_THROWS(()));
+    FUN (Bitset, std::operator^,(const Bitset&,const Bitset&) _PTR_THROWS(()));
+#endif    
+
+
+#define PARAMLIST(T)   T, std::char_traits<T>
+
+    FUN (std::basic_istream< PARAMLIST (char) >&, std::operator>>,
+         (std::basic_istream< PARAMLIST (char) >&, Bitset&));
+    FUN (std::basic_ostream< PARAMLIST (char) >&, std::operator<<,
+         (std::basic_ostream< PARAMLIST (char) >&, const Bitset&));
+
+#ifndef _RWSTD_NO_MEMBER_TEMPLATES
+#  ifndef _RWSTD_NO_WCHAR_T
+
+    FUN (std::basic_istream< PARAMLIST (wchar_t) >&, std::operator>>,
+         (std::basic_istream< PARAMLIST (wchar_t) >&, Bitset&));
+    FUN (std::basic_ostream< PARAMLIST (wchar_t) >&, std::operator<<,
+         (std::basic_ostream< PARAMLIST (wchar_t) >&, const Bitset&));
+
+#  endif   // _RWSTD_NO_WCHAR_T
+
+#  if !defined (_MSC_VER) || _MSC_VER > 1300
+
+    // MSVC is too dumb to handle bitset inserters and extractors
+    // parametrized on multiple template paramenters
+    FUN (std::basic_istream< PARAMLIST (int) >&, std::operator>>,
+         (std::basic_istream< PARAMLIST (int) >&, Bitset&));
+    FUN (std::basic_ostream< PARAMLIST (int) >&, std::operator<<,
+         (std::basic_ostream< PARAMLIST (int) >&, const Bitset&));
+
+#  endif   // !defined (_MSC_VER) || _MSC_VER > 1300
+#endif   // _RWSTD_NO_MEMBER_TEMPLATES
+
+#undef PARAMLIST
+
+}
+
+/**************************************************************************/
+
+template <std::size_t N>
+void test_ctors (const std::bitset<N>*)
+{
+    const std::size_t bmask = ::bitmax (N);
+
+    {   // bitset::bitset()
+        rw_info (0, 0, __LINE__, "std::bitset<%d>::bitset()", N);
+
+        const std::bitset<N> b;
+        rw_assert (0 == b.to_ulong (), 0, __LINE__,
+                   "bitset<%d>::bitset ().to_ulong() == 0, got %#lx",
+                   b.to_ulong ());
+    }
+    
+    {   // bitset::bitset (unsigned long)
+        rw_info (0, 0, __LINE__, "std::bitset<%d>::bitset (unsigned long)", N);
+
+        const std::bitset<N> b (ULONG_MAX & bmask);
+        rw_assert ((ULONG_MAX & bmask) == b.to_ulong (), 0, __LINE__,
+                   "bitset<%d>::bitset (%#lx).to_ulong() == 0, got %#lx",
+                   N, ULONG_MAX & bmask, b.to_ulong ());
+    }
+
+    {   // bitset (const string& str, size_t pos = 0, size_t n = (size_t)-1);
+        rw_info (0, 0, __LINE__, "std::bitset<%d>::bitset (string)", N);
+
+        test_set<N> ts;
+        ts.set ();
+
+        _TRY {
+            const std::bitset<N> b = std::bitset<N>(std::string (ts.bits ()));
+
+            if (N <= sizeof (unsigned long) * CHAR_BIT)
+                rw_assert (b == bmask, 0, __LINE__,
+                           "bitset<%d>::bitset(string(\"%s\").to_ulong()"
+                           " == %#x, got %#x", N, ts.bits (), bmask,
+                           b.to_ulong ());
+            else
+                rw_assert (test_set<N>(b) == ts, 0, __LINE__,
+                           "bitset<%d>::bitset(string(\"111...111\")"
+                           " == 111...111, got %s",
+                           N, test_set<N>(b).bits ());
+
+        }
+        _CATCH (...) {
+            rw_assert (false,  0, __LINE__, (""));
+        }
+    }
+
+    {   // bitset (const bitset<N>& rhs)
+        rw_info (0, 0, __LINE__, "std::bitset<%d>::bitset (const bitset&)", N);
+
+        const std::bitset<N> b1 (12345);
+        const std::bitset<N> b2 (b1);
+
+        rw_assert (b1.to_ulong () == b2.to_ulong (), 0, __LINE__,
+                   "bitset<%d>::bitset (bitset<%d>(%#lx)).to_ulong() == %#lx,"
+                   " got %#lx", N, b1.to_ulong (), b2.to_ulong ());
+
+        rw_info (0, 0, __LINE__,
+                 "std::bitset<%d>::operator=(const bitset&)", N);
+
+        std::bitset<N> b3;
+        b3 = b1;
+
+        rw_assert (b1.to_ulong () == b3.to_ulong (), 0, __LINE__,
+                   "bitset<%d>::bitset (bitset<%d>(%#lx)).to_ulong() == %#lx,"
+                   " got %#lx", N, b1.to_ulong (), b3.to_ulong ());
+    }
+}
+
+/**************************************************************************/
+
+template <std::size_t N>
+void stress_ctors (const std::bitset<N>*)
+{
+    rw_info (0, 0, __LINE__, "std::bitset<%d>::bitset (string)", N);
+
+    const std::size_t max_mask = bitmax (N);
+
+    for (std::size_t i = 0; i != 1000U; i++) {
+
+        typedef unsigned long ULong;
+
+        // exercise 23.3.5.1, p2
+        const ULong n = ULong (rw_rand (0) & max_mask);
+        const std::bitset<N> b1 (n);
+
+        rw_assert (n == b1.to_ulong (), 0, __LINE__,
+                   "bitset<%d>::bitset(%#lx).to_ulong() == %#lx, got %#lx",
+                   N, n, n, b1.to_ulong ());
+
+        test_set<N> ts;
+        ts.random ();
+
+        // exercise 23.3.5.1, p3
+        std::bitset<N> b2 = std::bitset<N>(std::string (ts.bits ()));
+        rw_assert (test_set<N>(b2) == ts, 0, __LINE__,
+                   "bitset<%d>::bitset (\"%s\") got %s",
+                   N, ts.bits (), b2.to_string ().c_str ());
+    }
+}
+
+/**************************************************************************/
+
+template <std::size_t N>
+void test_operators (const std::bitset<N>*)
+{
+#define TEST_OP(op) do {                                                   \
+   rw_info (!i, 0, __LINE__, "std::bitset<%d>::operator" #op               \
+                             "= (const bitset&)", N);                      \
+                                                                           \
+          test_set<N> lhs = test_set<N>().random ();                       \
+    const test_set<N> rhs = test_set<N>().random ();                       \
+          std::bitset<N> b_lhs = std::bitset<N>(std::string (lhs.bits ()));\
+    const std::bitset<N> b_rhs = std::bitset<N>(std::string (rhs.bits ()));\
+    const test_set<N> res = lhs op ## = rhs;                               \
+    const std::bitset<N> b_res = b_lhs op ## = b_rhs;                      \
+                                                                           \
+    rw_assert (res == test_set<N>(b_res), 0, __LINE__,                     \
+               "bitset<%lu>::operator" #op "= (const bitset<%lu>&):"       \
+               " %s " #op " %s == %s, got %s",                             \
+               N, N, lhs.bits (), rhs.bits (), res.bits (),                \
+               test_set<N>(b_res).bits ());                                \
+                                                                           \
+    rw_info (!i, 0, __LINE__, "std::bitset<%d>::operator" #op              \
+                              " (const bitset&)", N);                      \
+    lhs.random ();                                                         \
+    b_lhs = std::bitset<N>(std::string (lhs.bits ()));                     \
+                                                                           \
+    const test_set<N> res2 = lhs op ## = rhs;                              \
+    const std::bitset<N> b_res2 = b_lhs op b_rhs;                          \
+                                                                           \
+    rw_assert (res2 == test_set<N>(b_res2), 0, __LINE__,                   \
+               "bitset<%lu>::operator" #op " (const bitset<%lu>&):"        \
+               " %s " #op " %s == %s, got %s",                             \
+               N, N, lhs.bits (), rhs.bits (), res2.bits (),               \
+               test_set<N>(b_res2).bits ());                               \
+  } while (0)
+
+    // prevent division by zero errors, also exercise shifting by
+    // N bits (operation must zero out the first operand)
+    // especially important is shifting bitset<N> by N bits where
+    // N >= sizeof (unsigned long) * CHAR_BIT, since this operation
+    // is undefined for unsigned longs but defined for bitset
+
+    const std::size_t M = N + 1;
+
+    for (int i = 0; i != NLOOPS; ++i) {
+
+        // 23.3.5.2, p1 and 23.3.5.3, p1
+        TEST_OP (&);
+        // 23.3.5.2, p3 and 23.3.5.3, p2
+        TEST_OP (|);
+        // 23.3.5.2, p5 and 23.3.5.3, p3
+        TEST_OP (^);
+
+        rw_info (!i, 0, __LINE__, "std::bitset<%d>::operator<<=(size_t)", N);
+
+        const test_set<N> ts1 = test_set<N>().random ();
+        const test_set<N> ts2 = test_set<N>(ts1) <<= i % M;
+
+        std::bitset<N> b1 = std::bitset<N> (std::string (ts1.bits ()));
+
+        // 23.3.5.2, p7
+        b1 <<= i % M;
+
+        rw_assert (test_set<N>(b1) == ts2, 0, __LINE__,
+                   "bitset<%d>::operator<<=(%lu): %s << %lu == %s, got %s",
+                   N, i % M, ts1.bits (), i % M, ts2.bits (),
+                   test_set<N>(b1).bits ());
+
+        rw_info (!i, 0, __LINE__, "std::bitset<%d>::operator>>=(size_t)", N);
+
+        const test_set<N> ts3 = test_set<N>(ts1) >>= i % M;
+        std::bitset<N> b2 = std::bitset<N>(std::string (ts1.bits ()));
+
+        // 23.3.5.2, p9
+        b2 >>= i % M;
+
+        rw_assert (test_set<N>(b2) == ts3, 0, __LINE__,
+                   "bitset<%d>::operator>>=(%lu): %s >> %lu == %s, got %s",
+                   N, i % M, ts1.bits (), i % M, ts3.bits (),
+                   test_set<N>(b2).bits ());
+
+        rw_info (!i, 0, __LINE__,
+                 "std::bitset<%d>::operator<<=(size_t) (unused bits)", N);
+
+        if (N) {
+            b1.set (N - 1);
+            std::size_t first  = b1.count ();
+            std::size_t second = (b1 <<= 1).count ();
+            rw_assert (!(first == second), 0, __LINE__,
+                       "bitset<%lu>::operator<<=(1): "
+                       "after <<= 1: expected %lu, got %lu",
+                       N, first - 1, second);
+        }
+
+        rw_info (!i, 0, __LINE__,
+                 "std::bitset<%d>::operator>>=(size_t) (unused bits)", N);
+
+        if (N) {
+            b2.set ();
+            std::size_t first  = b2.count ();
+            std::size_t second = (b2 >>= 1).count ();
+            rw_assert (first - 1 == second, 0, __LINE__,
+                       "bitset<%lu>::operator>>=(1): "
+                       "after >>= 1: expected %lu, got %lu",
+                       N, first - 1, second);
+        }
+    }
+}
+
+/**************************************************************************/
+
+template <std::size_t N>
+void test_other (const std::bitset<N>*)
+{
+    for (std::size_t i = 0; i != NLOOPS; ++i) {
+
+        // 23.3.5.2, p23
+        test_set<N> ts1;
+        ts1.random ();
+
+        test_set<N> ts2 = ~ts1;
+
+        std::bitset<N> b1 = std::bitset<N>(std::string (ts1.bits ()));
+        std::bitset<N> b2 = ~b1;
+
+        rw_assert (ts2 == test_set<N>(b2), 0, __LINE__,
+                   "bitset<%d>::operator~(): ~%s == %s, got %s",
+                   N, ts1.bits (), ts2.bits (), test_set<N>(b2).bits ());
+
+        // 23.3.5.2, p25
+        b2.flip ();
+        rw_assert (ts1 == test_set<N>(b2), 0, __LINE__,
+                   "bitset<%d>::flip (): ~%s == %s, got %s",
+                   N, ts1.bits (), ts2.bits (), test_set<N>(b2).bits ());
+
+        // 23.3.5.2, p27
+        for (std::size_t _j = 0; _j != N; ++_j)
+            b2.flip (_j);
+
+        rw_assert (ts2 == test_set<N>(b2), 0, __LINE__,
+            "bitset<%d>::flip () == %s, got %s",
+            N, ts2.bits (), test_set<N>(b2).bits ());
+
+        // 23.3.5.3, p35
+        rw_assert (ts2.count () == b2.count (), 0, __LINE__,
+                   "bitset<%d>::count () == %d, got %d [%s]",
+                   N, ts2.count (), b2.count (), test_set<N>(b2).bits());
+               
+        // 23.3.5.3, p37
+        rw_assert (b2 == b2 && (N && !(b1 == b2) || !N && b1 == b2),
+                   0, __LINE__,
+                   "bitset<%d>::operator==(const bitset<%ul>&) [%s]",
+                   N, N, N ? test_set<N>(b2).bits () : "<empty>");
+    
+        // 23.3.5.3, p38
+        rw_assert ((N && b1 != b2 || !N && !(b1 != b2)) && !(b2 != b2),
+                   0, __LINE__,
+                   "bitset<%d>::operator!=(const bitset<%ul>&) [%s]",
+                   N, N, N ? test_set<N>(b2).bits () : "<empty>");
+    
+        // 23.3.5.3, p42
+        rw_assert (b2.count() && b2.any() || !b2.count() && !b2.any(),
+                   0, __LINE__,
+                   "bitset<%d>::any () [%s]",
+                   N, test_set<N>(b2).bits ());
+
+        // 23.3.5.3, p43
+        rw_assert (b2.count() && !b2.none() || !b2.count() && b2.none(),
+                   0, __LINE__,
+                   "bitset<%d>::none () [%s]",
+                   N, test_set<N>(b2).bits ());
+
+        for (std::size_t k = 0; k != N; ++k) {
+            test_set<N>    ts3 = test_set<N>(ts1) <<= k;
+            std::bitset<N> b3  = b1 << k;
+
+            rw_assert (test_set<N>(b3) == ts3,  0, __LINE__,
+                       "bitset<%lu>::operator<<(%lu)", N, k);
+
+            ts3 = test_set<N>(ts1) >>= k;
+            b3  = b1 >> k;
+
+            rw_assert (test_set<N>(b3) == ts3, 0, __LINE__,
+                       "bitset<%lu>::operator>>(%lu)", N, k);
+        }
+    }
+}
+
+/**************************************************************************/
+
+template <std::size_t N>
+void stress_count (const std::bitset<N>*)
+{
+    rw_info (0, 0, __LINE__, "std::bitset<%lu>::count()", N);
+
+    for (std::size_t i = 0; i != N; i++) {
+        std::bitset<N> b;
+
+        for (std::size_t j = 0; j != i; j++)
+            b.set (j);
+
+        rw_assert (b.count () == i,  0, __LINE__,
+                   "%lu. std::bitset<%lu>::count()", i, N);
+    }
+}
+
+/**************************************************************************/
+
+template <std::size_t N>
+void test_elem_access (const std::bitset<N>*)
+{
+    rw_info (0, 0, __LINE__, "std::bitset<%lu>::test(size_t)", N);
+    rw_info (0, 0, __LINE__, "std::bitset<%lu>::operator[](size_t)", N);
+    rw_info (0, 0, __LINE__, "std::bitset<%lu>::operator[](size_t) const", N);
+
+    for (std::size_t i = 0; i != NLOOPS; ++i) {
+
+        const test_set<N> ts = test_set<N>().random ();
+        std::bitset<N>    b  = std::bitset<N>(std::string (ts.bits ()));
+
+        for (std::size_t _j = 0; _j != N; ++_j) {
+            // 23.3.5.2, p39
+            rw_assert (b.test (_j) == ts.test (_j), 0, __LINE__,
+                       "bitset<%lu>::test (%lu): %s",
+                       N, _j, test_set<N>(b).bits ());
+
+            // 23.3.5.2, p??: see lwg issue 11
+            rw_assert (b [_j] == ts.test (_j), 0, __LINE__,
+                       "bitset<%lu>::operator[](%lu): %s",
+                       N, _j, test_set<N>(b).bits ());
+
+            // 23.3.5.2, p??: see lwg issue 11
+            rw_assert (((const std::bitset<N>&)b) [_j] == ts.test (_j),
+                       0, __LINE__,
+                       "bitset<%lu>::operator[](%lu) const: %s",
+                       N, _j, test_set<N>(b).bits ());
+
+            // exercise std::bitset<N>::reference
+            _TYPENAME std::bitset<N>::reference r = b [_j];
+
+            // std::bitset<N>::reference::flip()
+            r.flip ();
+            rw_assert (r == !ts.test (_j), 0, __LINE__,
+                       "bitset<%lu>::reference::flip()", N);
+
+            // std::bitset<N>::reference::operator~()
+            bool toggled = ~r;
+            rw_assert (toggled == ts.test (_j), 0, __LINE__,
+                       "bitset<%lu>::reference::operator~()", N);
+
+            // std::bitset<N>::reference::operator=(bool)
+            r = toggled;
+            rw_assert (r == ts.test (_j) && b.test (_j) == ts.test (_j),
+                       0, __LINE__,
+                       "bitset<%lu>::reference::operator=(bool)", N);
+        }
+    }
+}
+
+
+/**************************************************************************/
+
+_RWSTD_NAMESPACE (std) {
+
+_RWSTD_SPECIALIZED_CLASS
+struct char_traits<UserChar>: UserTraits<UserChar> { };
+
+}   // namespace std
+
+
+const char* type_name (char) { return "char"; }
+
+#ifndef _RWSTD_NO_WCHAR_T
+const char* type_name (wchar_t) { return "wchar_t"; }
+#endif   // _RWSTD_NO_WCHAR_T
+
+const char* type_name (const UserChar&)
+{
+    return "UserChar";
+}
+
+template <class charT>
+const char* traits_name (const std::char_traits<charT>*)
+{
+    static char name [64];
+    std::sprintf (name, "std::char_traits<%s>", type_name (charT ()));
+    return name;
+}
+
+const char* traits_name (const UserTraits<UserChar>*)
+{
+    return "UserTraits";
+}
+
+template <class charT>
+struct MyAlloc: std::allocator<charT> { };
+
+template <class charT>
+const char* alloc_name (const std::allocator<charT>&)
+{
+    static char name [64];
+    std::sprintf (name, "std::allocator<%s>", type_name (charT ()));
+    return name;
+}
+
+template <class charT>
+const char* alloc_name (const MyAlloc<charT>&)
+{
+    static char name [64];
+    std::sprintf (name, "MyAlloc<%s>", type_name (charT ()));
+    return name;
+}
+
+template <class charT>
+charT& assign (charT &lhs, char rhs)
+{
+    return lhs = rhs;
+}
+
+UserChar& assign (UserChar &lhs, char rhs)
+{
+    lhs.c = _RWSTD_STATIC_CAST (unsigned char, rhs);
+
+    return lhs;
+}
+
+// compare two strings, return the offset of the first mismatch
+// or -1 when the strings are equal
+template <class charT>
+int compare (const charT str[], const char s[], const char bits [2])
+{
+    const char* const beg = s;
+
+    for ( ; *s; ++s, ++str) {
+
+        if (*str != bits ['1' == *s])
+            return int (s - beg);
+    }
+
+    return *str ? s - beg : -1;
+}
+
+// compare two strings, return the offset of the first mismatch
+// or -1 when the strings are equal
+int compare (const UserChar str[], const char s[], const char bits [2])
+{
+    const char* const beg = s;
+
+    for (; *s; ++s, ++str) {
+
+        if (char (str->c) != bits ['1' == *s])
+            return int (s - beg);
+    }
+
+    return str->c ? s - beg : -1;
+}
+
+
+#ifndef _RWSTD_NO_MEMBER_TEMPLATES
+
+// call the bitset<N>::to_string() member function template,
+// explicitly specifying all three template arguments,
+// and 2, 1, or 0 of the two default function arguments
+template <std::size_t N, class charT, class Traits, class Alloc>
+std::basic_string<charT, Traits, Alloc>
+bitset_to_string_3 (const std::bitset<N> &bs, int nfargs,
+                    charT zero, charT one,
+                    std::basic_string<charT, Traits, Alloc>*)
+{
+    // invoke to_string with the number of function arguments specified
+    switch (nfargs) {
+    case 1:
+        return bs.template to_string<charT, Traits, Alloc>(zero);
+    case 0:
+        return bs.template to_string<charT, Traits, Alloc>();
+    }
+
+    return bs.template to_string<charT, Traits, Alloc>(zero, one);
+}
+
+template <std::size_t N, class Traits, class Alloc>
+std::basic_string<UserChar, Traits, Alloc>
+bitset_to_string_3 (const std::bitset<N> &bs, int nfargs,
+                    UserChar zero, UserChar one,
+                    std::basic_string<UserChar, Traits, Alloc>*)
+{
+    // UserChar digits zero and one
+    static const UserChar dig[] = { { 0, '0' }, { 0, '1' } };
+
+    // invoke to_string with the number of function arguments specified
+    switch (nfargs) {
+    case 1:
+        return bs.template to_string<UserChar, Traits, Alloc>(zero, dig [1]);
+    case 0:
+        return bs.template to_string<UserChar, Traits, Alloc>(dig [0], dig [1]);
+    }
+
+    return bs.template to_string<UserChar, Traits, Alloc>(zero, one);
+}
+
+// call the bitset<N>::to_string() member function template,
+// explicitly specifying two of the three template arguments,
+// and 2, 1, or 0 of the two default function arguments
+template <std::size_t N, class charT, class Traits>
+std::basic_string<charT, Traits, std::allocator<charT> >
+bitset_to_string_2 (const std::bitset<N> &bs, int nfargs,
+                    charT zero, charT one,
+                    std::basic_string<charT, Traits,
+                                      std::allocator<charT> >*)
+{
+    // invoke to_string with the number of function arguments specified
+    switch (nfargs) {
+    case 1:
+        return bs.template to_string<charT, Traits>(zero);
+    case 0:
+        return bs.template to_string<charT, Traits>();
+    }
+
+    return bs.template to_string<charT, Traits>(zero, one);
+}
+
+template <std::size_t N, class Traits>
+std::basic_string<UserChar, Traits, std::allocator<UserChar> >
+bitset_to_string_2 (const std::bitset<N> &bs, int nfargs,
+                    UserChar zero, UserChar one,
+                    std::basic_string<UserChar, Traits,
+                                      std::allocator<UserChar> >*)
+{
+    static const UserChar dig[] = { { 0, '0' }, { 0, '1' } };
+
+    // invoke to_string with the number of function arguments specified
+    switch (nfargs) {
+    case 1:
+        return bs.template to_string<UserChar, Traits>(zero, dig [1]);
+    case 0:
+        return bs.template to_string<UserChar, Traits>(dig [0], dig [1]);
+    }
+
+    return bs.template to_string<UserChar, Traits>(zero, one);
+}
+
+// call the bitset<N>::to_string() member function template,
+// explicitly specifying one of the three template arguments,
+// and 2, 1, or 0 of the two default function arguments
+template <std::size_t N, class charT>
+std::basic_string<charT, std::char_traits<charT>, std::allocator<charT> >
+bitset_to_string_1 (const std::bitset<N> &bs, int nfargs,
+                    charT zero, charT one,
+                    std::basic_string<charT,
+                                      std::char_traits<charT>,
+                                      std::allocator<charT> >*)
+{
+    // invoke to_string with the number of function arguments specified
+    switch (nfargs) {
+    case 1:
+        return bs.template to_string<charT>(zero);
+    case 0:
+        return bs.template to_string<charT>();
+    }
+
+    return bs.template to_string<charT>(zero, one);
+}
+
+template <std::size_t N>
+std::basic_string<UserChar, std::char_traits<UserChar>,
+                  std::allocator<UserChar> >
+bitset_to_string_1 (const std::bitset<N> &bs, int nfargs,
+                    UserChar zero, UserChar one,
+                    std::basic_string<UserChar,
+                                      std::char_traits<UserChar>,
+                                      std::allocator<UserChar> >*)
+{
+    // UserChar digits zero and one
+    static const UserChar dig[] = { { 0, '0' }, { 0, '1' } };
+
+    // invoke to_string with the number of function arguments specified
+    switch (nfargs) {
+    case 1:
+        return bs.template to_string<UserChar>(zero, dig [1]);
+    case 0:
+        return bs.template to_string<UserChar>(dig [0], dig [1]);
+    }
+
+    return bs.template to_string<UserChar>(zero, one);
+}
+
+#endif   // _RWSTD_NO_MEMBER_TEMPLATES
+
+
+// call the bitset<N>::to_string() ordinary member function,
+// explicitly specifying none of the three template arguments,
+// and 2, 1, or 0 of the two default function arguments
+template <std::size_t N>
+std::basic_string<char, std::char_traits<char>, std::allocator<char> >
+bitset_to_string_0 (const std::bitset<N> &bs, int nfargs,
+                    char zero, char one,
+                    std::basic_string<char, std::char_traits<char>,
+                                      std::allocator<char> >*)
+{
+    // invoke to_string with the number of function arguments specified
+    switch (nfargs) {
+    case 1:
+        return bs.to_string (zero);
+    case 0:
+        return bs.to_string ();
+    }
+
+    return bs.to_string (zero, one);
+}
+
+
+inline char to_char (char ch) { return ch; }
+inline char to_char (UserChar ch) { return ch.c; }
+
+#ifndef _RWSTD_NO_WCHAR_T
+inline char to_char (wchar_t ch) { return char (ch); }
+#endif   // _RWSTD_NO_WCHAR_T
+
+
+// convert a basic_string object to a tempstr object for diagnostics
+template <class charT, class Traits, class Alloc>
+std::string narrow_string (const std::basic_string<charT, Traits, Alloc> &str)
+{
+    std::string res;
+
+    for (std::size_t i = 0; i != str.size (); ++i)
+        res += to_char (str [i]);
+
+    return res;
+}
+
+#define TO_STR(s)   narrow_string (s).c_str ()
+
+
+// convert an ordinary string to a tempstr object for diagnostics
+// using the binary digits specified by `bits'
+std::string to_string (const char *str, const char bits [2])
+{
+    std::string res;
+
+    std::size_t i;
+
+    for (i = 0; str [i]; ++i)
+        res += bits ['1' == str [i]];
+
+    return res;
+}
+
+
+template <std::size_t N, class charT, class Traits, class Alloc>
+void test_to_string (std::bitset<N>*, charT*, Traits*, Alloc*,
+                     bool nontemplate_done)
+{
+    static const char* const cname = type_name (charT ());
+    static const char* const tname = traits_name ((Traits*)0);
+    static const char* const aname = alloc_name (Alloc ());
+
+    rw_info (0, 0, __LINE__,
+             "std::bitset<%lu>::to_string<%s, %s, %s >()",
+             N, cname, tname, aname);
+
+    test_set<N> ts;
+
+    ts.random ();
+
+    const std::bitset<N> bs = ts.to_bitset ();
+
+    charT zero;
+    charT one;
+
+    assign (zero, 'o');
+    assign (one, 'x');
+
+    int pos;
+
+#ifndef _RWSTD_NO_MEMBER_TEMPLATES
+
+    ////////////////////////////////////////////////////////////////////////
+    // exercise the overload of the to_string() member function template
+    // that takes all three template parameters different from char,
+    // char_traits<char>, and allocator<char>
+
+    typedef std::basic_string<charT, Traits, Alloc> String3;
+
+    String3 str3;
+
+    // specify none of the two function arguments (exercise defaults
+    // or the respective overloads)
+    str3 = bitset_to_string_3 (bs, 0, zero, one, (String3*)0);
+    pos  = compare (str3.data (), ts.bits (), "01");
+
+    rw_assert (-1 == pos, 0, __LINE__,
+               "bitset<%lu>::to_string () == \"%s\", got \"%s\": "
+               "mismatch at bit %d",
+               N, ts.bits (), TO_STR (str3), pos);
+
+
+    // specify one of the two function arguments (exercise the default
+    // or the respective overload)
+    rw_info (0, 0, __LINE__,
+             "std::bitset<%lu>::to_string<%s, %s, %s >(\"%s\")",
+             N, cname, tname, aname, cname);
+
+    str3 = bitset_to_string_3 (bs, 1, zero, one, (String3*)0);
+    pos  = compare (str3.data (), ts.bits (), "o1");
+
+    rw_assert (-1 == pos, 0, __LINE__,
+               "bitset<%lu>::to_string ('o') == %s, got %s: "
+               "mismatch at bit %d", N,
+               to_string (ts.bits (), "o1").c_str (),
+               TO_STR (str3), pos);
+
+
+    // specify both of the two function arguments
+    rw_info (0, 0, __LINE__,
+             "std::bitset<%lu>::to_string<%s, %s, %s >(%s, %s)",
+             N, cname, tname, aname, cname, cname);
+
+    str3 = bitset_to_string_3 (bs, 2, zero, one, (String3*)0);
+    pos  = compare (str3.data (), ts.bits (), "ox");
+
+    rw_assert (-1 == pos, 0, __LINE__,
+               "bitset<%lu>::to_string ('o', 'x') == %s, got %s: "
+               "mismatch at bit %d", N,
+               to_string (ts.bits (), "ox").c_str (),
+               TO_STR (str3), pos);
+
+
+    ////////////////////////////////////////////////////////////////////////
+    // exercise the overload of the to_string() member function template
+    // that takes the first two template parameters different from char,
+    // and char_traits<char>
+    rw_info (0, 0, __LINE__, "std::bitset<%lu>::to_string<%s, %s >()",
+             N, cname, tname);
+
+    typedef std::allocator<charT>                        CharTAlloc;
+    typedef std::basic_string<charT, Traits, CharTAlloc> String2;
+
+    String2 str2;
+
+    // specify none of the two function arguments (exercise defaults
+    // or the respective overloads)
+    str2 = bitset_to_string_2 (bs, 0, zero, one, (String2*)0);
+    pos  = compare (str2.data (), ts.bits (), "01");
+
+    rw_assert (-1 == pos, 0, __LINE__,
+               "bitset<%lu>::to_string () == %s, got %s: mismatch at bit %d",
+               N, ts.bits (), TO_STR (str2), pos);
+
+
+    // specify one of the two function arguments (exercise the default
+    // or the respective overload)
+    rw_info (0, 0, __LINE__,
+             "std::bitset<%lu>::to_string<%s, %s >(%s)",
+             N, cname, tname, cname);
+
+    str2 = bitset_to_string_2 (bs, 1, zero, one, (String2*)0);
+    pos  = compare (str2.data (), ts.bits (), "o1");
+
+    rw_assert (-1 == pos, 0, __LINE__,
+               "bitset<%lu>::to_string ('o') == %s, got %s: "
+               "mismatch at bit %d", N,
+               to_string (ts.bits (), "o1").c_str (),
+               TO_STR (str2), pos);
+
+
+    // specify both of the two function arguments
+    rw_info (0, 0, __LINE__,
+             "std::bitset<%lu>::to_string<%s, %s >(%s, %s)",
+             N, cname, tname, cname, cname);
+
+    str2 = bitset_to_string_2 (bs, 2, zero, one, (String2*)0);
+    pos  = compare (str2.data (), ts.bits (), "ox");
+
+    rw_assert (-1 == pos, 0, __LINE__,
+               "bitset<%lu>::to_string ('o', 'x') == %s, got %s: "
+               "mismatch at bit %d", N,
+               to_string (ts.bits (), "ox").c_str (),
+               TO_STR (str2), pos);
+
+
+    ////////////////////////////////////////////////////////////////////////
+    // exercise the overload of the to_string() member function template
+    // that takes the first template parameter different from char
+    rw_info (0, 0, __LINE__, "std::bitset<%lu>::to_string<%s>()",
+             N, cname);
+
+    typedef std::char_traits<charT>                          CharTraits;
+    typedef std::basic_string<charT, CharTraits, CharTAlloc> String1;
+
+    String1 str1;
+
+    // specify none of the two function arguments (exercise defaults
+    // or the respective overloads)
+    str1 = bitset_to_string_1 (bs, 0, zero, one, (String1*)0);
+    pos  = compare (str1.data (), ts.bits (), "01");
+
+    rw_assert (-1 == pos, 0, __LINE__,
+               "bitset<%lu>::to_string () == %s, got %s: mismatch at bit %d",
+               N, ts.bits (), TO_STR (str1), pos);
+
+
+    // specify one of the two function arguments (exercise the default
+    // or the respective overload)
+    rw_info (0, 0, __LINE__, "std::bitset<%lu>::to_string<%s>(%s)",
+             N, cname, cname);
+
+    str1 = bitset_to_string_1 (bs, 1, zero, one, (String1*)0);
+    pos  = compare (str1.data (), ts.bits (), "o1");
+
+    rw_assert (-1 == pos, 0, __LINE__,
+               "bitset<%lu>::to_string ('o') == %s, got %s: "
+               "mismatch at bit %d", N,
+               to_string (ts.bits (), "o1").c_str (),
+               TO_STR (str1), pos);
+
+
+    // specify both of the two function arguments
+    rw_info (0, 0, __LINE__,
+             "std::bitset<%lu>::to_string<%s>(%s, %s)",
+             N, cname, cname, cname);
+
+    str1 = bitset_to_string_1 (bs, 2, zero, one, (String1*)0);
+    pos  = compare (str1.data (), ts.bits (), "ox");
+
+    rw_assert (-1 == pos, 0, __LINE__,
+               "bitset<%lu>::to_string ('o', 'x') == %s, got %s: "
+               "mismatch at bit %d", N,
+               to_string (ts.bits (), "ox").c_str (),
+               TO_STR (str1), pos);
+
+#endif   // _RWSTD_NO_MEMBER_TEMPLATES
+
+
+    ////////////////////////////////////////////////////////////////////////
+    // exercise the non-template overload of the to_string() member
+
+    if (nontemplate_done)
+        return;
+
+    rw_info (0, 0, __LINE__, "std::bitset<%lu>::to_string ()", N);
+
+    typedef std::string String0;
+
+    String0 str0;
+
+    // specify none of the two function arguments (exercise defaults
+    // or the respective overloads)
+    str0 = bitset_to_string_0 (bs, 0, 'o', 'x', (String0*)0);
+    pos  = compare (str0.data (), ts.bits (), "01");
+
+    rw_assert (-1 == pos, 0, __LINE__,
+               "bitset<%lu>::to_string () == %s, got %s: mismatch at bit %d",
+               N, ts.bits (), str0.c_str (), pos);
+
+
+    // specify one of the two function arguments (exercise the default
+    // or the respective overload)
+    rw_info (0, 0, __LINE__, "std::bitset<%lu>::to_string (char)", N);
+
+    str0 = bitset_to_string_0 (bs, 1, 'o', 'x', (String0*)0);
+    pos  = compare (str0.data (), ts.bits (), "o1");
+
+    rw_assert (-1 == pos, 0, __LINE__,
+               "bitset<%lu>::to_string ('o') == %s, got %s: "
+               "mismatch at bit %d", N,
+               to_string (ts.bits (), "o1").c_str (),
+               str0.c_str (), pos);
+
+
+    // specify both of the two function arguments
+    rw_info (0, 0, __LINE__, "std::bitset<%lu>::to_string (char, char)", N);
+
+    str0 = bitset_to_string_0 (bs, 2, 'o', 'x', (String0*)0);
+    pos  = compare (str0.data (), ts.bits (), "ox");
+
+    rw_assert (-1 == pos, 0, __LINE__,
+               "bitset<%lu>::to_string ('o', 'x') == %s, got %s: "
+               "mismatch at bit %d", N,
+               to_string (ts.bits (), "ox").c_str (),
+               str0.c_str (), pos);
+}
+
+
+template <std::size_t N>
+void test_to_string (const std::bitset<N>*)
+{
+    test_to_string ((std::bitset<N>*)0,
+                    (char*)0,
+                    (std::char_traits<char>*)0,
+                    (std::allocator<char>*)0,
+                    false);
+
+#ifndef _RWSTD_NO_WCHAR_T
+
+    test_to_string ((std::bitset<N>*)0,
+                    (wchar_t*)0,
+                    (std::char_traits<wchar_t>*)0,
+                    (std::allocator<wchar_t>*)0,
+                    true);
+
+#endif   // _RWSTD_NO_WCHAR_T
+
+    test_to_string ((std::bitset<N>*)0,
+                    (UserChar*)0,
+                    (UserTraits<UserChar>*)0,
+                    (std::allocator<UserChar>*)0,
+                    true);
+}
+
+/**************************************************************************/
+
+template <std::size_t N>
+void run_test (const std::bitset<N>*)
+{
+    test_ctors ((std::bitset<N>*)0);
+    stress_ctors ((std::bitset<N>*)0);
+    test_elem_access ((std::bitset<N>*)0);
+    test_operators ((std::bitset<N>*)0);
+    test_other ((std::bitset<N>*)0);
+    stress_count ((std::bitset<N>*)0);
+
+    test_to_string ((std::bitset<N>*)0);
+}
+
+/**************************************************************************/
+
+static int
+run_test (int, char**)
+{
+    test_synopsis ((std::bitset<0>*)0);
+
+#define  DO_TEST(N)   run_test ((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 514 can't compile bitset<257>!
+    DO_TEST ( 257);   // interesting case
+#endif
+
+    DO_TEST ( 258);   // interesting case
+    DO_TEST ( 333);
+
+    return 0;
+}
+
+/**************************************************************************/
+
+int main (int argc, char *argv[])
+{
+    // TODO: add command line options to control tested functionality
+    return rw_test (argc, argv, __FILE__,
+                    "lib.bitset",
+                    0 /* no comment */,
+                    run_test,
+                    "",
+                    (void*)0   /* sentinel */);
+}

Propchange: incubator/stdcxx/trunk/tests/containers/23.bitset.cpp
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: incubator/stdcxx/trunk/tests/containers/23.bitset.cpp
------------------------------------------------------------------------------
    svn:keywords = Id



Mime
View raw message