Move test into test/std subdirectory.

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@224658 91177308-0d34-0410-b5e6-96231b3b80d8

test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp

@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// template <class charT>
+//     explicit bitset(const charT* str,
+//                     typename basic_string<charT>::size_type n = basic_string<charT>::npos,
+//                     charT zero = charT('0'), charT one = charT('1'));
+
+#include <bitset>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+template <std::size_t N>
+void test_char_pointer_ctor()
+{
+    {
+    try
+    {
+        std::bitset<N> v("xxx1010101010xxxx");
+        assert(false);
+    }
+    catch (std::invalid_argument&)
+    {
+    }
+    }
+
+    {
+    const char str[] ="1010101010";
+    std::bitset<N> v(str);
+    std::size_t M = std::min<std::size_t>(N, 10);
+    for (std::size_t i = 0; i < M; ++i)
+        assert(v[i] == (str[M - 1 - i] == '1'));
+    for (std::size_t i = 10; i < N; ++i)
+        assert(v[i] == false);
+    }
+}
+
+int main()
+{
+    test_char_pointer_ctor<0>();
+    test_char_pointer_ctor<1>();
+    test_char_pointer_ctor<31>();
+    test_char_pointer_ctor<32>();
+    test_char_pointer_ctor<33>();
+    test_char_pointer_ctor<63>();
+    test_char_pointer_ctor<64>();
+    test_char_pointer_ctor<65>();
+    test_char_pointer_ctor<1000>();
+}

test/std/utilities/template.bitset/bitset.cons/default.pass.cpp

@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test default ctor
+
+#include <bitset>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+template <std::size_t N>
+void test_default_ctor()
+{
+    {
+    _LIBCPP_CONSTEXPR std::bitset<N> v1;
+    assert(v1.size() == N);
+    for (std::size_t i = 0; i < N; ++i)
+        assert(v1[i] == false);
+    }
+}
+
+int main()
+{
+    test_default_ctor<0>();
+    test_default_ctor<1>();
+    test_default_ctor<31>();
+    test_default_ctor<32>();
+    test_default_ctor<33>();
+    test_default_ctor<63>();
+    test_default_ctor<64>();
+    test_default_ctor<65>();
+    test_default_ctor<1000>();
+}

test/std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp

@@ -0,0 +1,88 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset(string, pos, n, zero, one);
+
+#include <bitset>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+template <std::size_t N>
+void test_string_ctor()
+{
+    {
+    try
+    {
+        std::string str("xxx1010101010xxxx");
+        std::bitset<N> v(str, str.size()+1, 10);
+        assert(false);
+    }
+    catch (std::out_of_range&)
+    {
+    }
+    }
+
+    {
+    try
+    {
+        std::string str("xxx1010101010xxxx");
+        std::bitset<N> v(str, 2, 10);
+        assert(false);
+    }
+    catch (std::invalid_argument&)
+    {
+    }
+    }
+
+    {
+    std::string str("xxx1010101010xxxx");
+    std::bitset<N> v(str, 3, 10);
+    std::size_t M = std::min<std::size_t>(N, 10);
+    for (std::size_t i = 0; i < M; ++i)
+        assert(v[i] == (str[3 + M - 1 - i] == '1'));
+    for (std::size_t i = 10; i < N; ++i)
+        assert(v[i] == false);
+    }
+
+    {
+    try
+    {
+        std::string str("xxxbababababaxxxx");
+        std::bitset<N> v(str, 2, 10, 'a', 'b');
+        assert(false);
+    }
+    catch (std::invalid_argument&)
+    {
+    }
+    }
+
+    {
+    std::string str("xxxbababababaxxxx");
+    std::bitset<N> v(str, 3, 10, 'a', 'b');
+    std::size_t M = std::min<std::size_t>(N, 10);
+    for (std::size_t i = 0; i < M; ++i)
+        assert(v[i] == (str[3 + M - 1 - i] == 'b'));
+    for (std::size_t i = 10; i < N; ++i)
+        assert(v[i] == false);
+    }
+}
+
+int main()
+{
+    test_string_ctor<0>();
+    test_string_ctor<1>();
+    test_string_ctor<31>();
+    test_string_ctor<32>();
+    test_string_ctor<33>();
+    test_string_ctor<63>();
+    test_string_ctor<64>();
+    test_string_ctor<65>();
+    test_string_ctor<1000>();
+}

test/std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp

@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset(unsigned long long val);
+
+#include <bitset>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+template <std::size_t N>
+void test_val_ctor()
+{
+    {
+    _LIBCPP_CONSTEXPR std::bitset<N> v(0xAAAAAAAAAAAAAAAAULL);
+    assert(v.size() == N);
+    unsigned M = std::min<std::size_t>(N, 64);
+    for (std::size_t i = 0; i < M; ++i)
+        assert(v[i] == (i & 1));
+    for (std::size_t i = M; i < N; ++i)
+        assert(v[i] == false);
+    }
+}
+
+int main()
+{
+    test_val_ctor<0>();
+    test_val_ctor<1>();
+    test_val_ctor<31>();
+    test_val_ctor<32>();
+    test_val_ctor<33>();
+    test_val_ctor<63>();
+    test_val_ctor<64>();
+    test_val_ctor<65>();
+    test_val_ctor<1000>();
+}

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

@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <functional>
+
+// template <class T>
+// struct hash
+//     : public unary_function<T, size_t>
+// {
+//     size_t operator()(T val) const;
+// };
+
+// Not very portable
+
+#include <bitset>
+#include <cassert>
+#include <type_traits>
+
+template <std::size_t N>
+void
+test()
+{
+    typedef std::bitset<N> T;
+    typedef std::hash<T> H;
+    static_assert((std::is_base_of<std::unary_function<T, std::size_t>,
+                                   H>::value), "");
+    H h;
+    T bs(static_cast<unsigned long long>(N));
+    assert(h(bs) == N);
+}
+
+int main()
+{
+    test<0>();
+    test<10>();
+    test<100>();
+    test<1000>();
+}

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

@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bool all() const;
+
+#include <bitset>
+#include <cassert>
+
+template <std::size_t N>
+void test_all()
+{
+    std::bitset<N> v;
+    v.reset();
+    assert(v.all() == (N == 0));
+    v.set();
+    assert(v.all() == true);
+    if (N > 1)
+    {
+        v[N/2] = false;
+        assert(v.all() == false);
+    }
+}
+
+int main()
+{
+    test_all<0>();
+    test_all<1>();
+    test_all<31>();
+    test_all<32>();
+    test_all<33>();
+    test_all<63>();
+    test_all<64>();
+    test_all<65>();
+    test_all<1000>();
+}

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

@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bool any() const;
+
+#include <bitset>
+#include <cassert>
+
+template <std::size_t N>
+void test_any()
+{
+    std::bitset<N> v;
+    v.reset();
+    assert(v.any() == false);
+    v.set();
+    assert(v.any() == (N != 0));
+    if (N > 1)
+    {
+        v[N/2] = false;
+        assert(v.any() == true);
+        v.reset();
+        v[N/2] = true;
+        assert(v.any() == true);
+    }
+}
+
+int main()
+{
+    test_any<0>();
+    test_any<1>();
+    test_any<31>();
+    test_any<32>();
+    test_any<33>();
+    test_any<63>();
+    test_any<64>();
+    test_any<65>();
+    test_any<1000>();
+}

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

@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test size_t count() const;
+
+#include <bitset>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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_count()
+{
+    const std::bitset<N> v = make_bitset<N>();
+    std::size_t c1 = v.count();
+    std::size_t c2 = 0;
+    for (std::size_t i = 0; i < N; ++i)
+        if (v[i])
+            ++c2;
+    assert(c1 == c2);
+}
+
+int main()
+{
+    test_count<0>();
+    test_count<1>();
+    test_count<31>();
+    test_count<32>();
+    test_count<33>();
+    test_count<63>();
+    test_count<64>();
+    test_count<65>();
+    test_count<1000>();
+}

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

@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset<N>& flip();
+
+#include <bitset>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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_all()
+{
+    std::bitset<N> v1 = make_bitset<N>();
+    std::bitset<N> v2 = v1;
+    v2.flip();
+    for (std::size_t i = 0; i < N; ++i)
+        assert(v2[i] == ~v1[i]);
+}
+
+int main()
+{
+    test_flip_all<0>();
+    test_flip_all<1>();
+    test_flip_all<31>();
+    test_flip_all<32>();
+    test_flip_all<33>();
+    test_flip_all<63>();
+    test_flip_all<64>();
+    test_flip_all<65>();
+    test_flip_all<1000>();
+}

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

@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset<N>& flip(size_t pos);
+
+#include <bitset>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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()
+{
+    std::bitset<N> v = make_bitset<N>();
+    try
+    {
+        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);
+    }
+    catch (std::out_of_range&)
+    {
+    }
+}
+
+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/std/utilities/template.bitset/bitset.members/index.pass.cpp

@@ -0,0 +1,67 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset<N>::reference operator[](size_t pos);
+
+#include <bitset>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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_index_const()
+{
+    std::bitset<N> v1 = make_bitset<N>();
+    if (N > 0)
+    {
+        assert(v1[N/2] == v1.test(N/2));
+        typename std::bitset<N>::reference r = v1[N/2];
+        assert(r == v1.test(N/2));
+        typename std::bitset<N>::reference r2 = v1[N/2];
+        r = r2;
+        assert(r == v1.test(N/2));
+        r = false;
+        assert(r == false);
+        assert(v1.test(N/2) == false);
+        r = true;
+        assert(r == true);
+        assert(v1.test(N/2) == true);
+        bool b = ~r;
+        assert(r == true);
+        assert(v1.test(N/2) == true);
+        assert(b == false);
+        r.flip();
+        assert(r == false);
+        assert(v1.test(N/2) == false);
+    }
+}
+
+int main()
+{
+    test_index_const<0>();
+    test_index_const<1>();
+    test_index_const<31>();
+    test_index_const<32>();
+    test_index_const<33>();
+    test_index_const<63>();
+    test_index_const<64>();
+    test_index_const<65>();
+    test_index_const<1000>();
+}

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

@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test constexpr bool operator[](size_t pos) const;
+
+#include <bitset>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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_index_const()
+{
+    const std::bitset<N> v1 = make_bitset<N>();
+    if (N > 0)
+    {
+        assert(v1[N/2] == v1.test(N/2));
+    }
+}
+
+int main()
+{
+    test_index_const<0>();
+    test_index_const<1>();
+    test_index_const<31>();
+    test_index_const<32>();
+    test_index_const<33>();
+    test_index_const<63>();
+    test_index_const<64>();
+    test_index_const<65>();
+    test_index_const<1000>();
+}

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

@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset<N> operator<<(size_t pos) const;
+
+#include <bitset>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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_left_shift()
+{
+    for (std::size_t s = 0; s <= N+1; ++s)
+    {
+        std::bitset<N> v1 = make_bitset<N>();
+        std::bitset<N> v2 = v1;
+        assert((v1 <<= s) == (v2 << s));
+    }
+}
+
+int main()
+{
+    test_left_shift<0>();
+    test_left_shift<1>();
+    test_left_shift<31>();
+    test_left_shift<32>();
+    test_left_shift<33>();
+    test_left_shift<63>();
+    test_left_shift<64>();
+    test_left_shift<65>();
+    test_left_shift<1000>();
+}

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

@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset<N>& operator<<=(size_t pos);
+
+#include <bitset>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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_left_shift()
+{
+    for (std::size_t s = 0; s <= N+1; ++s)
+    {
+        std::bitset<N> v1 = make_bitset<N>();
+        std::bitset<N> v2 = v1;
+        v1 <<= s;
+        for (std::size_t i = 0; i < N; ++i)
+            if (i < s)
+                assert(v1[i] == 0);
+            else
+                assert(v1[i] == v2[i-s]);
+    }
+}
+
+int main()
+{
+    test_left_shift<0>();
+    test_left_shift<1>();
+    test_left_shift<31>();
+    test_left_shift<32>();
+    test_left_shift<33>();
+    test_left_shift<63>();
+    test_left_shift<64>();
+    test_left_shift<65>();
+    test_left_shift<1000>();
+}

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

@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bool none() const;
+
+#include <bitset>
+#include <cassert>
+
+template <std::size_t N>
+void test_none()
+{
+    std::bitset<N> v;
+    v.reset();
+    assert(v.none() == true);
+    v.set();
+    assert(v.none() == (N == 0));
+    if (N > 1)
+    {
+        v[N/2] = false;
+        assert(v.none() == false);
+        v.reset();
+        v[N/2] = true;
+        assert(v.none() == false);
+    }
+}
+
+int main()
+{
+    test_none<0>();
+    test_none<1>();
+    test_none<31>();
+    test_none<32>();
+    test_none<33>();
+    test_none<63>();
+    test_none<64>();
+    test_none<65>();
+    test_none<1000>();
+}

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

@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset<N> operator~() const;
+
+#include <bitset>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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_not_all()
+{
+    std::bitset<N> v1 = make_bitset<N>();
+    std::bitset<N> v2 = ~v1;
+    for (std::size_t i = 0; i < N; ++i)
+        assert(v2[i] == ~v1[i]);
+}
+
+int main()
+{
+    test_not_all<0>();
+    test_not_all<1>();
+    test_not_all<31>();
+    test_not_all<32>();
+    test_not_all<33>();
+    test_not_all<63>();
+    test_not_all<64>();
+    test_not_all<65>();
+    test_not_all<1000>();
+}

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

@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset<N>& operator&=(const bitset<N>& rhs);
+
+#include <bitset>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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_op_and_eq()
+{
+    std::bitset<N> v1 = make_bitset<N>();
+    std::bitset<N> v2 = make_bitset<N>();
+    std::bitset<N> v3 = v1;
+    v1 &= v2;
+    for (std::size_t i = 0; i < N; ++i)
+        assert(v1[i] == (v3[i] && v2[i]));
+}
+
+int main()
+{
+    test_op_and_eq<0>();
+    test_op_and_eq<1>();
+    test_op_and_eq<31>();
+    test_op_and_eq<32>();
+    test_op_and_eq<33>();
+    test_op_and_eq<63>();
+    test_op_and_eq<64>();
+    test_op_and_eq<65>();
+    test_op_and_eq<1000>();
+}

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

@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test:
+
+// bool operator==(const bitset<N>& rhs) const;
+// bool operator!=(const bitset<N>& rhs) const;
+
+#include <bitset>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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_equality()
+{
+    const std::bitset<N> v1 = make_bitset<N>();
+    std::bitset<N> v2 = v1;
+    assert(v1 == v2);
+    if (N > 0)
+    {
+        v2[N/2].flip();
+        assert(v1 != v2);
+    }
+}
+
+int main()
+{
+    test_equality<0>();
+    test_equality<1>();
+    test_equality<31>();
+    test_equality<32>();
+    test_equality<33>();
+    test_equality<63>();
+    test_equality<64>();
+    test_equality<65>();
+    test_equality<1000>();
+}

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

@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset<N>& operator|=(const bitset<N>& rhs);
+
+#include <bitset>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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_op_or_eq()
+{
+    std::bitset<N> v1 = make_bitset<N>();
+    std::bitset<N> v2 = make_bitset<N>();
+    std::bitset<N> v3 = v1;
+    v1 |= v2;
+    for (std::size_t i = 0; i < N; ++i)
+        assert(v1[i] == (v3[i] || v2[i]));
+}
+
+int main()
+{
+    test_op_or_eq<0>();
+    test_op_or_eq<1>();
+    test_op_or_eq<31>();
+    test_op_or_eq<32>();
+    test_op_or_eq<33>();
+    test_op_or_eq<63>();
+    test_op_or_eq<64>();
+    test_op_or_eq<65>();
+    test_op_or_eq<1000>();
+}

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

@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset<N>& operator^=(const bitset<N>& rhs);
+
+#include <bitset>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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_op_xor_eq()
+{
+    std::bitset<N> v1 = make_bitset<N>();
+    std::bitset<N> v2 = make_bitset<N>();
+    std::bitset<N> v3 = v1;
+    v1 ^= v2;
+    for (std::size_t i = 0; i < N; ++i)
+        assert(v1[i] == (v3[i] != v2[i]));
+}
+
+int main()
+{
+    test_op_xor_eq<0>();
+    test_op_xor_eq<1>();
+    test_op_xor_eq<31>();
+    test_op_xor_eq<32>();
+    test_op_xor_eq<33>();
+    test_op_xor_eq<63>();
+    test_op_xor_eq<64>();
+    test_op_xor_eq<65>();
+    test_op_xor_eq<1000>();
+}

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

@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset<N>& reset();
+
+#include <bitset>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+template <std::size_t N>
+void test_reset_all()
+{
+    std::bitset<N> v;
+    v.set();
+    v.reset();
+    for (std::size_t i = 0; i < N; ++i)
+        assert(!v[i]);
+}
+
+int main()
+{
+    test_reset_all<0>();
+    test_reset_all<1>();
+    test_reset_all<31>();
+    test_reset_all<32>();
+    test_reset_all<33>();
+    test_reset_all<63>();
+    test_reset_all<64>();
+    test_reset_all<65>();
+    test_reset_all<1000>();
+}

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

@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset<N>& reset(size_t pos);
+
+#include <bitset>
+#include <cassert>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+template <std::size_t N>
+void test_reset_one()
+{
+    std::bitset<N> v;
+    try
+    {
+        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]);
+    }
+    catch (std::out_of_range&)
+    {
+    }
+}
+
+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/std/utilities/template.bitset/bitset.members/right_shift.pass.cpp

@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset<N> operator>>(size_t pos) const;
+
+#include <bitset>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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_right_shift()
+{
+    for (std::size_t s = 0; s <= N+1; ++s)
+    {
+        std::bitset<N> v1 = make_bitset<N>();
+        std::bitset<N> v2 = v1;
+        assert((v1 >>= s) == (v2 >> s));
+    }
+}
+
+int main()
+{
+    test_right_shift<0>();
+    test_right_shift<1>();
+    test_right_shift<31>();
+    test_right_shift<32>();
+    test_right_shift<33>();
+    test_right_shift<63>();
+    test_right_shift<64>();
+    test_right_shift<65>();
+    test_right_shift<1000>();
+}

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

@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset<N>& operator<<=(size_t pos);
+
+#include <bitset>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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_right_shift()
+{
+    for (std::size_t s = 0; s <= N+1; ++s)
+    {
+        std::bitset<N> v1 = make_bitset<N>();
+        std::bitset<N> v2 = v1;
+        v1 >>= s;
+        for (std::size_t i = 0; i < N; ++i)
+            if (i + s < N)
+                assert(v1[i] == v2[i + s]);
+            else
+                assert(v1[i] == 0);
+    }
+}
+
+int main()
+{
+    test_right_shift<0>();
+    test_right_shift<1>();
+    test_right_shift<31>();
+    test_right_shift<32>();
+    test_right_shift<33>();
+    test_right_shift<63>();
+    test_right_shift<64>();
+    test_right_shift<65>();
+    test_right_shift<1000>();
+}

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

@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset<N>& set();
+
+#include <bitset>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+template <std::size_t N>
+void test_set_all()
+{
+    std::bitset<N> v;
+    v.set();
+    for (std::size_t i = 0; i < N; ++i)
+        assert(v[i]);
+}
+
+int main()
+{
+    test_set_all<0>();
+    test_set_all<1>();
+    test_set_all<31>();
+    test_set_all<32>();
+    test_set_all<33>();
+    test_set_all<63>();
+    test_set_all<64>();
+    test_set_all<65>();
+    test_set_all<1000>();
+}

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

@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset<N>& set(size_t pos, bool val = true);
+
+#include <bitset>
+#include <cassert>
+
+template <std::size_t N>
+void test_set_one()
+{
+    std::bitset<N> v;
+    try
+    {
+        v.set(50);
+        if (50 >= v.size())
+            assert(false);
+        assert(v[50]);
+    }
+    catch (std::out_of_range&)
+    {
+    }
+    try
+    {
+        v.set(50, false);
+        if (50 >= v.size())
+            assert(false);
+        assert(!v[50]);
+    }
+    catch (std::out_of_range&)
+    {
+    }
+}
+
+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/std/utilities/template.bitset/bitset.members/size.pass.cpp

@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test size_t count() const;
+
+#include <bitset>
+#include <cassert>
+
+template <std::size_t N>
+void test_size()
+{
+    const std::bitset<N> v;
+    assert(v.size() == N);
+}
+
+int main()
+{
+    test_size<0>();
+    test_size<1>();
+    test_size<31>();
+    test_size<32>();
+    test_size<33>();
+    test_size<63>();
+    test_size<64>();
+    test_size<65>();
+    test_size<1000>();
+}

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

@@ -0,0 +1,55 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test constexpr bool test(size_t pos) const;
+
+#include <bitset>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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()
+{
+    const std::bitset<N> v1 = make_bitset<N>();
+    try
+    {
+        bool b = v1.test(50);
+        if (50 >= v1.size())
+            assert(false);
+        assert(b == v1[50]);
+    }
+    catch (std::out_of_range&)
+    {
+    }
+}
+
+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/std/utilities/template.bitset/bitset.members/to_string.pass.cpp

@@ -0,0 +1,162 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test:
+
+// template <class charT, class traits, class Allocator>
+// basic_string<charT, traits, Allocator>
+// to_string(charT zero = charT('0'), charT one = charT('1')) const;
+//
+// template <class charT, class traits>
+// basic_string<charT, traits, allocator<charT> > to_string() const;
+//
+// template <class charT>
+// basic_string<charT, char_traits<charT>, allocator<charT> > to_string() const;
+//
+// basic_string<char, char_traits<char>, allocator<char> > to_string() const;
+
+#include <bitset>
+#include <string>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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_to_string()
+{
+{
+    std::bitset<N> v = make_bitset<N>();
+    {
+    std::wstring s = v.template to_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >();
+    for (std::size_t i = 0; i < N; ++i)
+        if (v[i])
+            assert(s[N - 1 - i] == '1');
+        else
+            assert(s[N - 1 - i] == '0');
+    }
+    {
+    std::wstring s = v.template to_string<wchar_t, std::char_traits<wchar_t> >();
+    for (std::size_t i = 0; i < N; ++i)
+        if (v[i])
+            assert(s[N - 1 - i] == '1');
+        else
+            assert(s[N - 1 - i] == '0');
+    }
+    {
+    std::string s = v.template to_string<char>();
+    for (std::size_t i = 0; i < N; ++i)
+        if (v[i])
+            assert(s[N - 1 - i] == '1');
+        else
+            assert(s[N - 1 - i] == '0');
+    }
+    {
+    std::string s = v.to_string();
+    for (std::size_t i = 0; i < N; ++i)
+        if (v[i])
+            assert(s[N - 1 - i] == '1');
+        else
+            assert(s[N - 1 - i] == '0');
+    }
+}
+{
+    std::bitset<N> v = make_bitset<N>();
+    {
+    std::wstring s = v.template to_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >('0');
+    for (std::size_t i = 0; i < N; ++i)
+        if (v[i])
+            assert(s[N - 1 - i] == '1');
+        else
+            assert(s[N - 1 - i] == '0');
+    }
+    {
+    std::wstring s = v.template to_string<wchar_t, std::char_traits<wchar_t> >('0');
+    for (std::size_t i = 0; i < N; ++i)
+        if (v[i])
+            assert(s[N - 1 - i] == '1');
+        else
+            assert(s[N - 1 - i] == '0');
+    }
+    {
+    std::string s = v.template to_string<char>('0');
+    for (std::size_t i = 0; i < N; ++i)
+        if (v[i])
+            assert(s[N - 1 - i] == '1');
+        else
+            assert(s[N - 1 - i] == '0');
+    }
+    {
+    std::string s = v.to_string('0');
+    for (std::size_t i = 0; i < N; ++i)
+        if (v[i])
+            assert(s[N - 1 - i] == '1');
+        else
+            assert(s[N - 1 - i] == '0');
+    }
+}
+{
+    std::bitset<N> v = make_bitset<N>();
+    {
+    std::wstring s = v.template to_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t> >('0', '1');
+    for (std::size_t i = 0; i < N; ++i)
+        if (v[i])
+            assert(s[N - 1 - i] == '1');
+        else
+            assert(s[N - 1 - i] == '0');
+    }
+    {
+    std::wstring s = v.template to_string<wchar_t, std::char_traits<wchar_t> >('0', '1');
+    for (std::size_t i = 0; i < N; ++i)
+        if (v[i])
+            assert(s[N - 1 - i] == '1');
+        else
+            assert(s[N - 1 - i] == '0');
+    }
+    {
+    std::string s = v.template to_string<char>('0', '1');
+    for (std::size_t i = 0; i < N; ++i)
+        if (v[i])
+            assert(s[N - 1 - i] == '1');
+        else
+            assert(s[N - 1 - i] == '0');
+    }
+    {
+    std::string s = v.to_string('0', '1');
+    for (std::size_t i = 0; i < N; ++i)
+        if (v[i])
+            assert(s[N - 1 - i] == '1');
+        else
+            assert(s[N - 1 - i] == '0');
+    }
+}
+}
+
+int main()
+{
+    test_to_string<0>();
+    test_to_string<1>();
+    test_to_string<31>();
+    test_to_string<32>();
+    test_to_string<33>();
+    test_to_string<63>();
+    test_to_string<64>();
+    test_to_string<65>();
+    test_to_string<1000>();
+}

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

@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test unsigned long long to_ullong() const;
+
+#include <bitset>
+#include <algorithm>
+#include <climits>
+#include <cassert>
+
+template <std::size_t N>
+void test_to_ullong()
+{
+    const std::size_t M = sizeof(unsigned long long) * CHAR_BIT < N ? sizeof(unsigned long long) * CHAR_BIT : N;
+    const std::size_t X = M == 0 ? sizeof(unsigned long long) * CHAR_BIT - 1 : sizeof(unsigned long long) * CHAR_BIT - M;
+    const unsigned long long max = M == 0 ? 0 : (unsigned long long)(-1) >> X;
+    unsigned long long tests[] = {0,
+                           std::min<unsigned long long>(1, max),
+                           std::min<unsigned long long>(2, max),
+                           std::min<unsigned long long>(3, max),
+                           std::min(max, max-3),
+                           std::min(max, max-2),
+                           std::min(max, max-1),
+                           max};
+    for (std::size_t i = 0; i < sizeof(tests)/sizeof(tests[0]); ++i)
+    {
+        unsigned long long j = tests[i];
+        std::bitset<N> v(j);
+        assert(j == v.to_ullong());
+    }
+}
+
+int main()
+{
+    test_to_ullong<0>();
+    test_to_ullong<1>();
+    test_to_ullong<31>();
+    test_to_ullong<32>();
+    test_to_ullong<33>();
+    test_to_ullong<63>();
+    test_to_ullong<64>();
+    test_to_ullong<65>();
+    test_to_ullong<1000>();
+}

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

@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test unsigned long to_ulong() const;
+
+#include <bitset>
+#include <algorithm>
+#include <limits>
+#include <climits>
+#include <cassert>
+
+template <std::size_t N>
+void test_to_ulong()
+{
+    const std::size_t M = sizeof(unsigned long) * CHAR_BIT < N ? sizeof(unsigned long) * CHAR_BIT : N;
+    const std::size_t X = M == 0 ? sizeof(unsigned long) * CHAR_BIT - 1 : sizeof(unsigned long) * CHAR_BIT - M;
+    const std::size_t max = M == 0 ? 0 : std::size_t(std::numeric_limits<unsigned long>::max()) >> X;
+    std::size_t tests[] = {0,
+                           std::min<std::size_t>(1, max),
+                           std::min<std::size_t>(2, max),
+                           std::min<std::size_t>(3, max),
+                           std::min(max, max-3),
+                           std::min(max, max-2),
+                           std::min(max, max-1),
+                           max};
+    for (std::size_t i = 0; i < sizeof(tests)/sizeof(tests[0]); ++i)
+    {
+        std::size_t j = tests[i];
+        std::bitset<N> v(j);
+        assert(j == v.to_ulong());
+    }
+}
+
+int main()
+{
+    test_to_ulong<0>();
+    test_to_ulong<1>();
+    test_to_ulong<31>();
+    test_to_ulong<32>();
+    test_to_ulong<33>();
+    test_to_ulong<63>();
+    test_to_ulong<64>();
+    test_to_ulong<65>();
+    test_to_ulong<1000>();
+}

test/std/utilities/template.bitset/bitset.operators/op_and.pass.cpp

@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset<N> operator&(const bitset<N>& lhs, const bitset<N>& rhs);
+
+#include <bitset>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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_op_and()
+{
+    std::bitset<N> v1 = make_bitset<N>();
+    std::bitset<N> v2 = make_bitset<N>();
+    std::bitset<N> v3 = v1;
+    assert((v1 & v2) == (v3 &= v2));;
+}
+
+int main()
+{
+    test_op_and<0>();
+    test_op_and<1>();
+    test_op_and<31>();
+    test_op_and<32>();
+    test_op_and<33>();
+    test_op_and<63>();
+    test_op_and<64>();
+    test_op_and<65>();
+    test_op_and<1000>();
+}

test/std/utilities/template.bitset/bitset.operators/op_not.pass.cpp

@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset<N> operator^(const bitset<N>& lhs, const bitset<N>& rhs);
+
+#include <bitset>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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_op_not()
+{
+    std::bitset<N> v1 = make_bitset<N>();
+    std::bitset<N> v2 = make_bitset<N>();
+    std::bitset<N> v3 = v1;
+    assert((v1 ^ v2) == (v3 ^= v2));;
+}
+
+int main()
+{
+    test_op_not<0>();
+    test_op_not<1>();
+    test_op_not<31>();
+    test_op_not<32>();
+    test_op_not<33>();
+    test_op_not<63>();
+    test_op_not<64>();
+    test_op_not<65>();
+    test_op_not<1000>();
+}

test/std/utilities/template.bitset/bitset.operators/op_or.pass.cpp

@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test bitset<N> operator|(const bitset<N>& lhs, const bitset<N>& rhs);
+
+#include <bitset>
+#include <cstdlib>
+#include <cassert>
+
+#pragma clang diagnostic ignored "-Wtautological-compare"
+
+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_op_or()
+{
+    std::bitset<N> v1 = make_bitset<N>();
+    std::bitset<N> v2 = make_bitset<N>();
+    std::bitset<N> v3 = v1;
+    assert((v1 | v2) == (v3 |= v2));;
+}
+
+int main()
+{
+    test_op_or<0>();
+    test_op_or<1>();
+    test_op_or<31>();
+    test_op_or<32>();
+    test_op_or<33>();
+    test_op_or<63>();
+    test_op_or<64>();
+    test_op_or<65>();
+    test_op_or<1000>();
+}

test/std/utilities/template.bitset/bitset.operators/stream_in.pass.cpp

@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test:
+
+// template <class charT, class traits, size_t N>
+// basic_ostream<charT, traits>&
+// operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x);
+
+#include <bitset>
+#include <sstream>
+#include <cassert>
+
+int main()
+{
+    std::istringstream in("01011010");
+    std::bitset<8> b;
+    in >> b;
+    assert(b.to_ulong() == 0x5A);
+}

test/std/utilities/template.bitset/bitset.operators/stream_out.pass.cpp

@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test:
+
+// template <class charT, class traits, size_t N>
+// basic_istream<charT, traits>&
+// operator>>(basic_istream<charT, traits>& is, bitset<N>& x);
+
+#include <bitset>
+#include <sstream>
+#include <cassert>
+
+int main()
+{
+    std::ostringstream os;
+    std::bitset<8> b(0x5A);
+    os << b;
+    assert(os.str() == "01011010");
+}

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

@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// test that <bitset> includes <cstddef>, <string>, <stdexcept> and <iosfwd>
+
+#include <bitset>
+
+#ifndef _LIBCPP_CSTDDEF
+#error <cstddef> has not been included
+#endif
+
+#ifndef _LIBCPP_STRING
+#error <string> has not been included
+#endif
+
+#ifndef _LIBCPP_STDEXCEPT
+#error <stdexcept> has not been included
+#endif
+
+#ifndef _LIBCPP_IOSFWD
+#error <iosfwd> has not been included
+#endif
+
+int main()
+{
+}

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

@@ -0,0 +1,20 @@
+//===----------------------------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+
+// <bitset>
+
+#include <bitset>
+
+#ifndef _LIBCPP_VERSION
+#error _LIBCPP_VERSION not defined
+#endif
+
+int main()
+{
+}