[libc++] Split off debug tests that were missed by ce1365f into test/libcxx

Also, some tests had multiple death tests in them, so split them into
separate tests instead. The second death test would obviously never
get run, because the first one would kill the program before.

Author: ldionne

libcxx/test/libcxx/containers/unord/unord.map/bucket_size.pass.cpp

@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
+//           class Alloc = allocator<pair<const Key, T>>>
+// class unordered_map
+
+// size_type bucket_size(size_type n) const
+
+// UNSUPPORTED: libcxx-no-debug-mode
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+
+#include <unordered_map>
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**) {
+    typedef std::unordered_map<int, std::string> C;
+    C c;
+    (void) c.bucket_size(3);
+    assert(false);
+
+    return 0;
+}

libcxx/test/libcxx/containers/unord/unord.map/db_bucket.pass.cpp

@@ -21,14 +21,11 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        typedef std::unordered_map<int, std::string> C;
-        C c;
-        (void) c.bucket(3);
-        assert(false);
-    }
+int main(int, char**) {
+    typedef std::unordered_map<int, std::string> C;
+    C c;
+    (void) c.bucket(3);
+    assert(false);
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.map/db_insert_hint_const_lvalue.pass.cpp

@@ -20,19 +20,16 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        typedef std::unordered_map<double, int> C;
-        typedef C::iterator R;
-        typedef C::value_type P;
-        C c;
-        C c2;
-        C::const_iterator e = c2.end();
-        P v(3.5, 3);
-        R r = c.insert(e, v);
-        assert(false);
-    }
+int main(int, char**) {
+    typedef std::unordered_map<double, int> C;
+    typedef C::iterator R;
+    typedef C::value_type P;
+    C c;
+    C c2;
+    C::const_iterator e = c2.end();
+    P v(3.5, 3);
+    R r = c.insert(e, v);
+    assert(false);
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.map/db_insert_hint_rvalue.pass.cpp

@@ -24,18 +24,15 @@
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        typedef std::unordered_map<double, int> C;
-        typedef C::iterator R;
-        typedef C::value_type P;
-        C c;
-        C c2;
-        C::const_iterator e = c2.end();
-        R r = c.insert(e, P(3.5, 3));
-        assert(false);
-    }
+int main(int, char**) {
+    typedef std::unordered_map<double, int> C;
+    typedef C::iterator R;
+    typedef C::value_type P;
+    C c;
+    C c2;
+    C::const_iterator e = c2.end();
+    R r = c.insert(e, P(3.5, 3));
+    assert(false);
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.map/db_iterators_10.pass.cpp

@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// Dereference non-dereferenceable iterator.
+
+// UNSUPPORTED: libcxx-no-debug-mode
+// UNSUPPORTED: c++03
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+
+#include <unordered_map>
+#include <cassert>
+#include <functional>
+#include <string>
+#include <utility>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main(int, char**) {
+    typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
+                        min_allocator<std::pair<const int, std::string>>> C;
+    C c;
+    c.insert(std::make_pair(1, "one"));
+    C::iterator i = c.end();
+    C::value_type j = *i;
+    assert(false);
+
+    return 0;
+}

libcxx/test/libcxx/containers/unord/unord.map/db_iterators_7.pass.cpp

@@ -16,18 +16,13 @@
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
-#include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
+#include <string>
+#include <utility>
 
 #include "test_macros.h"
-#include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
+int main(int, char**) {
     typedef std::unordered_map<int, std::string> C;
     C c;
     c.insert(std::make_pair(1, "one"));
@@ -36,18 +31,6 @@ int main(int, char**)
     assert(i == c.end());
     ++i;
     assert(false);
-    }
-#if TEST_STD_VER >= 11
-    {
-    typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
-                        min_allocator<std::pair<const int, std::string>>> C;
-    C c;
-    c.insert(std::make_pair(1, "one"));
-    C::iterator i = c.begin();
-    ++i;
-    assert(i == c.end());
-    ++i;
-    assert(false);
-    }
-#endif
+
+    return 0;
 }

libcxx/test/libcxx/containers/unord/unord.map/db_iterators_8.pass.cpp

@@ -16,34 +16,19 @@
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
-#include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
+#include <string>
+#include <utility>
 
 #include "test_macros.h"
-#include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
+int main(int, char**) {
     typedef std::unordered_map<int, std::string> C;
     C c;
     c.insert(std::make_pair(1, "one"));
     C::iterator i = c.end();
     C::value_type j = *i;
     assert(false);
-    }
-#if TEST_STD_VER >= 11
-    {
-    typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
-                        min_allocator<std::pair<const int, std::string>>> C;
-    C c;
-    c.insert(std::make_pair(1, "one"));
-    C::iterator i = c.end();
-    C::value_type j = *i;
-    assert(false);
-    }
-#endif
+
+    return 0;
 }

libcxx/test/libcxx/containers/unord/unord.map/db_iterators_9.pass.cpp

@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// Increment iterator past end.
+
+// UNSUPPORTED: libcxx-no-debug-mode
+// UNSUPPORTED: c++03
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+
+#include <unordered_map>
+#include <cassert>
+#include <functional>
+#include <string>
+#include <utility>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main(int, char**) {
+    typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
+                        min_allocator<std::pair<const int, std::string>>> C;
+    C c;
+    c.insert(std::make_pair(1, "one"));
+    C::iterator i = c.begin();
+    ++i;
+    assert(i == c.end());
+    ++i;
+    assert(false);
+
+    return 0;
+}

libcxx/test/libcxx/containers/unord/unord.map/db_local_iterators_10.pass.cpp

@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <unordered_map>
+
+// Dereference non-dereferenceable iterator.
+
+// UNSUPPORTED: libcxx-no-debug-mode
+// UNSUPPORTED: c++03
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+
+#include <unordered_map>
+#include <cassert>
+#include <functional>
+#include <string>
+
+#include "test_macros.h"
+#include "min_allocator.h"
+
+int main(int, char**) {
+    typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
+                        min_allocator<std::pair<const int, std::string>>> C;
+    C c(1);
+    C::local_iterator i = c.end(0);
+    C::value_type j = *i;
+    assert(false);
+
+    return 0;
+}

libcxx/test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp

@@ -18,33 +18,16 @@
 #include <unordered_map>
 #include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
-#include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
+int main(int, char**) {
     typedef std::unordered_map<int, std::string> C;
     C c(1);
     C::local_iterator i = c.begin(0);
     ++i;
     ++i;
     assert(false);
-    }
-#if TEST_STD_VER >= 11
-    {
-    typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
-                        min_allocator<std::pair<const int, std::string>>> C;
-    C c(1);
-    C::local_iterator i = c.begin(0);
-    ++i;
-    ++i;
-    assert(false);
-    }
-#endif
 
+    return 0;
 }

libcxx/test/libcxx/containers/unord/unord.map/db_local_iterators_8.pass.cpp

@@ -18,30 +18,15 @@
 #include <unordered_map>
 #include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
-#include "min_allocator.h"
 
-int main(int, char**)
-{
-    {
+int main(int, char**) {
     typedef std::unordered_map<int, std::string> C;
     C c(1);
     C::local_iterator i = c.end(0);
     C::value_type j = *i;
     assert(false);
-    }
-#if TEST_STD_VER >= 11
-    {
-    typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
-                        min_allocator<std::pair<const int, std::string>>> C;
-    C c(1);
-    C::local_iterator i = c.end(0);
-    C::value_type j = *i;
-    assert(false);
-    }
-#endif
+
+    return 0;
 }