Protect bitset tests under libcpp-no-exceptions

[rogfer01]

Summary

Bitset tests feature a sequence of tests of increasing bitset sizes,
but these tests rely on exceptions when the bitset size is less than
50 elements. So under libcpp-no-exceptions do not run the
smaller-than-50 tests.

[EricWF]

Instead of just #ifdef-ing out the tests that throw I would rather see something like this:

template <std::size_t N>
void test_test(bool test_throws)
{
    const std::bitset<N> v1 = make_bitset<N>();
#ifdef TEST_HAS_NO_EXCEPTIONS
  if (test_throws) return;
#else
    try
    {
#endif
        bool b = v1.test(50);
        if (50 >= v1.size())
            assert(false);
        assert(b == v1[50]);
       assert(!test_throws);
#ifndef TEST_HAS_NO_EXCEPTIONS
    }
    catch (std::out_of_range&)
    {
       assert(test_throws);
    }
#endif
}

int main()
{
  // Throwing cases
   test_test<33>(true);
  // Non-throwing cases
    test_test<63>(false);
}

[rogfer01]

Do not "ifdef" out tests that throw, use a runtime flag for them instead.

test/std/utilities/template.bitset/bitset.members/flip_one.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // test bitset<N>& flip(size_t pos);
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);
     return v;
 }
 
 template <std::size_t N>
-void test_flip_one()
+void test_flip_one(bool test_throws)
 {
     std::bitset<N> v = make_bitset<N>();
+#ifdef TEST_HAS_NO_EXCEPTIONS
+    if (test_throws) return;
+#else
     try
     {
+#endif
         v.flip(50);
         bool b = v[50];
         if (50 >= v.size())
             assert(false);
         assert(v[50] == b);
         v.flip(50);
         assert(v[50] != b);
         v.flip(50);
         assert(v[50] == b);
+        assert(!test_throws);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     }
     catch (std::out_of_range&)
     {
+        assert(test_throws);
     }
+#endif
 }
 
 int main()
 {
-    test_flip_one<0>();
-    test_flip_one<1>();
-    test_flip_one<31>();
-    test_flip_one<32>();
-    test_flip_one<33>();
-    test_flip_one<63>();
-    test_flip_one<64>();
-    test_flip_one<65>();
-    test_flip_one<1000>();
+    test_flip_one<0>(true);
+    test_flip_one<1>(true);
+    test_flip_one<31>(true);
+    test_flip_one<32>(true);
+    test_flip_one<33>(true);
+    test_flip_one<63>(false);
+    test_flip_one<64>(false);
+    test_flip_one<65>(false);
+    test_flip_one<1000>(false);
 }

test/std/utilities/template.bitset/bitset.members/reset_one.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // test bitset<N>& reset(size_t pos);
 
 #include <bitset>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <std::size_t N>
-void test_reset_one()
+void test_reset_one(bool test_throws)
 {
     std::bitset<N> v;
+#ifdef TEST_HAS_NO_EXCEPTIONS
+    if (test_throws) return;
+#else
     try
     {
+#endif
         v.set();
         v.reset(50);
         if (50 >= v.size())
             assert(false);
         for (unsigned i = 0; i < v.size(); ++i)
             if (i == 50)
                 assert(!v[i]);
             else
                 assert(v[i]);
+        assert(!test_throws);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     }
     catch (std::out_of_range&)
     {
+        assert(test_throws);
     }
+#endif
 }
 
 int main()
 {
-    test_reset_one<0>();
-    test_reset_one<1>();
-    test_reset_one<31>();
-    test_reset_one<32>();
-    test_reset_one<33>();
-    test_reset_one<63>();
-    test_reset_one<64>();
-    test_reset_one<65>();
-    test_reset_one<1000>();
+    test_reset_one<0>(true);
+    test_reset_one<1>(true);
+    test_reset_one<31>(true);
+    test_reset_one<32>(true);
+    test_reset_one<33>(true);
+    test_reset_one<63>(false);
+    test_reset_one<64>(false);
+    test_reset_one<65>(false);
+    test_reset_one<1000>(false);
 }

test/std/utilities/template.bitset/bitset.members/set_one.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // test bitset<N>& set(size_t pos, bool val = true);
 
 #include <bitset>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <std::size_t N>
-void test_set_one()
+void test_set_one(bool test_throws)
 {
     std::bitset<N> v;
+#ifdef TEST_HAS_NO_EXCEPTIONS
+    if (test_throws) return;
+#else
     try
+#endif
     {
         v.set(50);
         if (50 >= v.size())
             assert(false);
         assert(v[50]);
+        assert(!test_throws);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (std::out_of_range&)
     {
+        assert(test_throws);
     }
     try
+#endif
     {
         v.set(50, false);
         if (50 >= v.size())
             assert(false);
         assert(!v[50]);
+        assert(!test_throws);
     }
+#ifndef TEST_HAS_NO_EXCEPTIONS
     catch (std::out_of_range&)
     {
+        assert(test_throws);
     }
+#endif
 }
 
 int main()
 {
-    test_set_one<0>();
-    test_set_one<1>();
-    test_set_one<31>();
-    test_set_one<32>();
-    test_set_one<33>();
-    test_set_one<63>();
-    test_set_one<64>();
-    test_set_one<65>();
-    test_set_one<1000>();
+    test_set_one<0>(true);
+    test_set_one<1>(true);
+    test_set_one<31>(true);
+    test_set_one<32>(true);
+    test_set_one<33>(true);
+    test_set_one<63>(false);
+    test_set_one<64>(false);
+    test_set_one<65>(false);
+    test_set_one<1000>(false);
 }

test/std/utilities/template.bitset/bitset.members/test.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-// XFAIL: libcpp-no-exceptions
 // test constexpr bool test(size_t pos) const;
 
 #include <bitset>
 #include <cstdlib>
 #include <cassert>
 
+#include "test_macros.h"
+
 template <std::size_t N>
 std::bitset<N>
 make_bitset()
 {
     std::bitset<N> v;
     for (std::size_t i = 0; i < N; ++i)
         v[i] = static_cast<bool>(std::rand() & 1);
     return v;
 }
 
 template <std::size_t N>
-void test_test()
+void test_test(bool test_throws)
 {
     const std::bitset<N> v1 = make_bitset<N>();
+#ifdef TEST_HAS_NO_EXCEPTIONS
+    if (test_throws) return;
+#else
     try
     {
+#endif
         bool b = v1.test(50);
         if (50 >= v1.size())
             assert(false);
         assert(b == v1[50]);
+        assert(!test_throws);
+#ifndef TEST_HAS_NO_EXCEPTIONS
     }
     catch (std::out_of_range&)
     {
+        assert(test_throws);
     }
+#endif
 }
 
 int main()
 {
-    test_test<0>();
-    test_test<1>();
-    test_test<31>();
-    test_test<32>();
-    test_test<33>();
-    test_test<63>();
-    test_test<64>();
-    test_test<65>();
-    test_test<1000>();
+    test_test<0>(true);
+    test_test<1>(true);
+    test_test<31>(true);
+    test_test<32>(true);
+    test_test<33>(true);
+    test_test<63>(false);
+    test_test<64>(false);
+    test_test<65>(false);
+    test_test<1000>(false);
 }