[libc++] Fix several debug mode tests

[ldionne]

Summary

These tests were only being run when _LIBCPP_DEBUG was defined, which
isn't the case by default when we run the test suite. In other words,
all these debug mode tests were never being run. This commit makes sure
they are run, and in some cases, extracts them into a file under test/libcxx
to separate them from the Standard tests.

[ldionne]

Creating review to get the CI to run.

libcxx/test/libcxx/containers/sequences/vector/db_back.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Call back() on empty container.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <vector>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     C c(1);
     assert(c.back() == 0);
     c.clear();
     assert(c.back() == 0);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/sequences/vector/db_cback.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Call back() on empty const container.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <vector>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     typedef int T;
     typedef std::vector<T, min_allocator<T>> C;
     const C c;
     assert(c.back() == 0);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/sequences/vector/db_cfront.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Call front() on empty const container.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <vector>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     typedef int T;
     typedef std::vector<T, min_allocator<T>> C;
     const C c;
     assert(c.front() == 0);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/sequences/vector/db_cindex.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Index const vector out of bounds.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <vector>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     typedef std::vector<T, min_allocator<T>> C;
     const C c(1);
     assert(c[0] == 0);
     assert(c[1] == 0);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/sequences/vector/db_front.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Call front() on empty container.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <vector>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     C c(1);
     assert(c.front() == 0);
     c.clear();
     assert(c.front() == 0);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/sequences/vector/db_index.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Index vector out of bounds.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <vector>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     C c(1);
     assert(c[0] == 0);
     c.clear();
     assert(c[0] == 0);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/sequences/vector/db_iterators_2.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Compare iterators from different containers with <.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <vector>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef int T;
     typedef std::vector<T> C;
     C c1;
     C c2;
-    bool b = c1.begin() < c2.begin();
+    bool b = c1.begin() < c2.begin(); (void)b;
     assert(false);
     }
 #if TEST_STD_VER >= 11
     {
     typedef int T;
     typedef std::vector<T, min_allocator<T>> C;
     C c1;
     C c2;
-    bool b = c1.begin() < c2.begin();
+    bool b = c1.begin() < c2.begin(); (void)b;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/sequences/vector/db_iterators_3.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Subtract iterators from different containers.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <vector>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef int T;
     typedef std::vector<T> C;
     C c1;
     C c2;
-    int i = c1.begin() - c2.begin();
+    int i = c1.begin() - c2.begin(); (void)i;
     assert(false);
     }
 #if TEST_STD_VER >= 11
     {
     typedef int T;
     typedef std::vector<T, min_allocator<T>> C;
     C c1;
     C c2;
-    int i = c1.begin() - c2.begin();
+    int i = c1.begin() - c2.begin(); (void)i;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/sequences/vector/db_iterators_4.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Index iterator out of bounds.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <vector>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     C c(1);
     C::iterator i = c.begin();
     assert(i[0] == 0);
     assert(i[1] == 0);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/sequences/vector/db_iterators_5.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Add to iterator out of bounds.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <vector>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     i += 1;
     assert(i == c.end());
     i = c.begin();
     i += 2;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/sequences/vector/db_iterators_6.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Decrement iterator prior to begin.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <vector>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     C::iterator i = c.end();
     --i;
     assert(i == c.begin());
     --i;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/sequences/vector/db_iterators_7.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Increment iterator past end.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <vector>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     C::iterator i = c.begin();
     ++i;
     assert(i == c.end());
     ++i;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/sequences/vector/db_iterators_8.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Dereference non-dereferenceable iterator.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <vector>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     typedef int T;
     typedef std::vector<T> C;
     C c(1);
     C::iterator i = c.end();
-    T j = *i;
+    T j = *i; (void)j;
     assert(false);
     }
 #if TEST_STD_VER >= 11
     {
     typedef int T;
     typedef std::vector<T, min_allocator<T>> C;
     C c(1);
     C::iterator i = c.end();
-    T j = *i;
+    T j = *i; (void)j;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/sequences/vector/pop_back_empty.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // pop_back() more than the number of elements in a vector
 
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
+
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <cstdlib>
 #include <vector>
 
 #include "test_macros.h"
 
 
 int main(int, char**) {
     std::vector<int> v;
     v.push_back(0);
     v.pop_back();
     v.pop_back();
     std::exit(1);
 
     return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-// <string>
+// <unordered_map>
 
-// iterator insert(const_iterator p, charT c);
+// size_type bucket(const key_type& __k) const;
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
+
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
 
+#include <unordered_map>
 #include <string>
-#include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 
-
 int main(int, char**)
 {
-#if _LIBCPP_DEBUG >= 1
     {
-        typedef std::string S;
-        S s;
-        S s2;
-        s.insert(s2.begin(), '1');
+        typedef std::unordered_map<int, std::string> C;
+        C c;
+        (void) c.bucket(3);
         assert(false);
     }
-#endif
 
     return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // 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>
 
-// Call erase(const_iterator position) with iterator from another container
+// iterator insert(const_iterator p, const value_type& x);
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
-#include <cstdlib>
-#include <exception>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
-    typedef std::pair<int, int> P;
-    P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
-    std::unordered_map<int, int> l1(a1, a1+3);
-    std::unordered_map<int, int> l2(a1, a1+3);
-    std::unordered_map<int, int>::const_iterator i = l2.begin();
-    l1.erase(i);
+        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);
     }
-}
-
-#else
-
-int main(int, char**)
-{
 
     return 0;
 }
-
-#endif

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

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <unordered_map>
+
+// template <class P,
+//           class = typename enable_if<is_convertible<P, value_type>::value>::type>
+//     iterator insert(const_iterator p, P&& x);
+
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+
+#include <unordered_map>
+#include <cassert>
+
+#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);
+    }
+
+    return 0;
+}

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

 //===----------------------------------------------------------------------===//
 //
 // 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.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
#if TEST_STD_VER >= 11
     C::iterator i = c.begin();
     ++i;
     assert(i == c.end());
     ++i;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

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

 //===----------------------------------------------------------------------===//
 //
 // 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.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
#if TEST_STD_VER >= 11
     C c;
     c.insert(std::make_pair(1, "one"));
     C::iterator i = c.end();
     C::value_type j = *i;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

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

 //===----------------------------------------------------------------------===//
 //
 // 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 local_iterator past end.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
#if TEST_STD_VER >= 11
     C::local_iterator i = c.begin(0);
     ++i;
     ++i;
     assert(false);
     }
 #endif
 
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

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

 //===----------------------------------------------------------------------===//
 //
 // 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.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
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
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

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

 //===----------------------------------------------------------------------===//
 //
 // 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>
 
-// Call erase(const_iterator position) with end()
+// unordered_map(unordered_map&& u);
 
-#if _LIBCPP_DEBUG >= 1
+// UNSUPPORTED: c++03
 
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
+
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
-    typedef std::pair<int, int> P;
-    P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
-    std::unordered_map<int, int> l1(a1, a1+3);
-    std::unordered_map<int, int>::const_iterator i = l1.end();
-    l1.erase(i);
-    assert(false);
-    }
+        std::unordered_map<int, int> s1 = {{1, 1}, {2, 2}, {3, 3}};
+        std::unordered_map<int, int>::iterator i = s1.begin();
+        std::pair<const int, int> k = *i;
+        std::unordered_map<int, int> s2 = std::move(s1);
+        assert(*i == k);
+        s2.erase(i);
+        assert(s2.size() == 2);
     }
 
-#else
-
-int main(int, char**)
-{
-
     return 0;
 }
-
-#endif

libcxx/test/libcxx/containers/unord/unord.map/unord.map.modifiers/erase_iter_db1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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>
 
 // Call erase(const_iterator position) with end()
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
     P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
     std::unordered_map<int, int> l1(a1, a1+3);
     std::unordered_map<int, int>::const_iterator i = l1.end();
     l1.erase(i);
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.map/unord.map.modifiers/erase_iter_db2.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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>
 
 // Call erase(const_iterator position) with iterator from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
 #include <cstdlib>
 #include <exception>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
     P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
     std::unordered_map<int, int> l1(a1, a1+3);
     std::unordered_map<int, int> l2(a1, a1+3);
     std::unordered_map<int, int>::const_iterator i = l2.begin();
     l1.erase(i);
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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>
 
 // Call erase(const_iterator first, const_iterator last); with first iterator from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
     P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
     std::unordered_map<int, int> l1(a1, a1+3);
     std::unordered_map<int, int> l2(a1, a1+3);
     std::unordered_map<int, int>::iterator i = l1.erase(l2.cbegin(), next(l1.cbegin()));
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db2.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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>
 
 // Call erase(const_iterator first, const_iterator last); with second iterator from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
     P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
     std::unordered_map<int, int> l1(a1, a1+3);
     std::unordered_map<int, int> l2(a1, a1+3);
     std::unordered_map<int, int>::iterator i = l1.erase(l1.cbegin(), next(l2.cbegin()));
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db3.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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>
 
 // Call erase(const_iterator first, const_iterator last); with both iterators from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
     P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
     std::unordered_map<int, int> l1(a1, a1+3);
     std::unordered_map<int, int> l2(a1, a1+3);
     std::unordered_map<int, int>::iterator i = l1.erase(l2.cbegin(), next(l2.cbegin()));
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.map/unord.map.modifiers/erase_iter_iter_db4.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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>
 
 // Call erase(const_iterator first, const_iterator last); with a bad range
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
     P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
     std::unordered_map<int, int> l1(a1, a1+3);
     std::unordered_map<int, int>::iterator i = l1.erase(next(l1.cbegin()), l1.cbegin());
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.map/unord.map.swap/db_swap_1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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 Value, class Hash = hash<Key>, class Pred = equal_to<Key>,
 //           class Alloc = allocator<pair<const Key, Value>>>
 // class unordered_map
 
 // void swap(unordered_map& x, unordered_map& y);
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
+
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
 
 #include <unordered_map>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#if _LIBCPP_DEBUG >= 1
     {
         typedef std::pair<int, int> P;
         P a1[] = {P(1, 1), P(3, 3), P(7, 7), P(9, 9), P(10, 10)};
         P a2[] = {P(0, 0), P(2, 2), P(4, 4), P(5, 5), P(6, 6), P(8, 8), P(11, 11)};
         std::unordered_map<int, int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
         std::unordered_map<int, int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
         std::unordered_map<int, int>::iterator i1 = c1.begin();
         std::unordered_map<int, int>::iterator i2 = c2.begin();
         swap(c1, c2);
         c1.erase(i2);
         c2.erase(i1);
         std::unordered_map<int, int>::iterator j = i1;
         c1.erase(i1);
         assert(false);
     }
-#endif
 
     return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // 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>
 
-// Call erase(const_iterator position) with iterator from another container
+// iterator insert(const_iterator p, const value_type& x);
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
-#include <cstdlib>
-#include <exception>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
-    typedef std::pair<int, int> P;
-    P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
-    std::unordered_map<int, int> l1(a1, a1+3);
-    std::unordered_map<int, int> l2(a1, a1+3);
-    std::unordered_map<int, int>::const_iterator i = l2.begin();
-    l1.erase(i);
+        typedef std::unordered_multimap<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);
     }
-}
-
-#else
-
-int main(int, char**)
-{
 
     return 0;
 }
-
-#endif

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

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03
+
+// <unordered_map>
+
+// template <class P,
+//           class = typename enable_if<is_convertible<P, value_type>::value>::type>
+//     iterator insert(const_iterator p, P&& x);
+
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
+
+#define _LIBCPP_DEBUG 1
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+
+#include <unordered_map>
+#include <cassert>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    {
+        typedef std::unordered_multimap<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.multimap/db_iterators_7.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
#if TEST_STD_VER >= 11
     C::iterator i = c.begin();
     ++i;
     assert(i == c.end());
     ++i;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

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

 //===----------------------------------------------------------------------===//
 //
 // 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.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
#if TEST_STD_VER >= 11
     C c;
     c.insert(std::make_pair(1, "one"));
     C::iterator i = c.end();
     C::value_type j = *i;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

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

 //===----------------------------------------------------------------------===//
 //
 // 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 local_iterator past end.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
#if TEST_STD_VER >= 11
     C::local_iterator i = c.begin(0);
     ++i;
     ++i;
     assert(false);
     }
 #endif
 
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

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

 //===----------------------------------------------------------------------===//
 //
 // 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.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
typedef std::unordered_multimap<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
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.multimap/db_move.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03
+
 // <unordered_map>
 
-// Call erase(const_iterator position) with end()
+// unordered_multimap(unordered_multimap&& u);
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
+#include <utility>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
-    typedef std::pair<int, int> P;
-    P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
-    std::unordered_multimap<int, int> l1(a1, a1+3);
-    std::unordered_multimap<int, int>::const_iterator i = l1.end();
-    l1.erase(i);
-    assert(false);
-    }
+        std::unordered_multimap<int, int> s1 = {{1, 1}, {2, 2}, {3, 3}};
+        std::unordered_multimap<int, int>::iterator i = s1.begin();
+        std::pair<const int, int> k = *i;
+        std::unordered_multimap<int, int> s2 = std::move(s1);
+        assert(*i == k);
+        s2.erase(i);
+        assert(s2.size() == 2);
     }
 
-#else
-
-int main(int, char**)
-{
-
     return 0;
 }
-
-#endif

libcxx/test/libcxx/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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>
 
 // Call erase(const_iterator position) with end()
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
     P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
     std::unordered_multimap<int, int> l1(a1, a1+3);
     std::unordered_multimap<int, int>::const_iterator i = l1.end();
     l1.erase(i);
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_db2.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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>
 
 // Call erase(const_iterator position) with iterator from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
 #include <cstdlib>
 #include <exception>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
     P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
     std::unordered_multimap<int, int> l1(a1, a1+3);
     std::unordered_multimap<int, int> l2(a1, a1+3);
     std::unordered_multimap<int, int>::const_iterator i = l2.begin();
     l1.erase(i);
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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>
 
 // Call erase(const_iterator first, const_iterator last); with first iterator from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
     P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
     std::unordered_multimap<int, int> l1(a1, a1+3);
     std::unordered_multimap<int, int> l2(a1, a1+3);
     std::unordered_multimap<int, int>::iterator i = l1.erase(l2.cbegin(), next(l1.cbegin()));
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db2.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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>
 
 // Call erase(const_iterator first, const_iterator last); with second iterator from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
     P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
     std::unordered_multimap<int, int> l1(a1, a1+3);
     std::unordered_multimap<int, int> l2(a1, a1+3);
     std::unordered_multimap<int, int>::iterator i = l1.erase(l1.cbegin(), next(l2.cbegin()));
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db3.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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>
 
 // Call erase(const_iterator first, const_iterator last); with both iterators from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
     P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
     std::unordered_multimap<int, int> l1(a1, a1+3);
     std::unordered_multimap<int, int> l2(a1, a1+3);
     std::unordered_multimap<int, int>::iterator i = l1.erase(l2.cbegin(), next(l2.cbegin()));
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.multimap/unord.multimap.modifiers/erase_iter_iter_db4.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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>
 
 // Call erase(const_iterator first, const_iterator last); with a bad range
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     typedef std::pair<int, int> P;
     P a1[] = {P(1, 1), P(2, 2), P(3, 3)};
     std::unordered_multimap<int, int> l1(a1, a1+3);
     std::unordered_multimap<int, int>::iterator i = l1.erase(next(l1.cbegin()), l1.cbegin());
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.multimap/unord.multimap.swap/db_swap_1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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 Value, class Hash = hash<Key>, class Pred = equal_to<Key>,
 //           class Alloc = allocator<pair<const Key, Value>>>
 // class unordered_multimap
 
 // void swap(unordered_multimap& x, unordered_multimap& y);
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
+
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
 
 #include <unordered_map>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#if _LIBCPP_DEBUG >= 1
     {
         typedef std::pair<int, int> P;
         P a1[] = {P(1, 1), P(3, 3), P(7, 7), P(9, 9), P(10, 10)};
         P a2[] = {P(0, 0), P(2, 2), P(4, 4), P(5, 5), P(6, 6), P(8, 8), P(11, 11)};
         std::unordered_multimap<int, int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
         std::unordered_multimap<int, int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
         std::unordered_multimap<int, int>::iterator i1 = c1.begin();
         std::unordered_multimap<int, int>::iterator i2 = c2.begin();
         swap(c1, c2);
         c1.erase(i2);
         c2.erase(i1);
         std::unordered_multimap<int, int>::iterator j = i1;
         c1.erase(i1);
         assert(false);
     }
-#endif
 
     return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
-// Call erase(const_iterator position) with iterator from another container
+// iterator insert(const_iterator p, const value_type& x);
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
-#include <cstdlib>
-#include <exception>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
-    int a1[] = {1, 2, 3};
-    std::unordered_multiset<int> l1(a1, a1+3);
-    std::unordered_multiset<int> l2(a1, a1+3);
-    std::unordered_multiset<int>::const_iterator i = l2.begin();
-    l1.erase(i);
+        typedef std::unordered_multiset<double> C;
+        typedef C::iterator R;
+        typedef C::value_type P;
+        C c;
+        C c2;
+        C::const_iterator e = c2.end();
+        P v(3.5);
+        R r = c.insert(e, v);
         assert(false);
     }
-}
-
-#else
-
-int main(int, char**)
-{
 
     return 0;
 }
-
-#endif

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

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Increment iterator past end.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     C::iterator i = c.begin();
     ++i;
     assert(i == c.end());
     ++i;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

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

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Dereference non-dereferenceable iterator.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
     C c(1);
     C::iterator i = c.end();
     (void) *i;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

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

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Increment local_iterator past end.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     C::local_iterator i = c.begin(0);
     ++i;
     ++i;
     assert(false);
     }
 #endif
 
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

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

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Dereference non-dereferenceable iterator.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
     C c(1);
     C::local_iterator i = c.end(0);
     (void) *i;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.multiset/db_move.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03
+
 // <unordered_set>
 
-// Call erase(const_iterator first, const_iterator last); with second iterator from another container
+// unordered_multiset(unordered_multiset&& u);
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
-#include <exception>
-#include <cstdlib>
+#include <utility>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
-    int a1[] = {1, 2, 3};
-    std::unordered_multiset<int> l1(a1, a1+3);
-    std::unordered_multiset<int> l2(a1, a1+3);
-    std::unordered_multiset<int>::iterator i = l1.erase(l1.cbegin(), next(l2.cbegin()));
-    assert(false);
-    }
+        std::unordered_multiset<int> s1 = {1, 2, 3};
+        std::unordered_multiset<int>::iterator i = s1.begin();
+        int k = *i;
+        std::unordered_multiset<int> s2 = std::move(s1);
+        assert(*i == k);
+        s2.erase(i);
+        assert(s2.size() == 2);
     }
 
-#else
-
-int main(int, char**)
-{
-
     return 0;
 }
-
-#endif

libcxx/test/libcxx/containers/unord/unord.multiset/erase_iter_db1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Call erase(const_iterator position) with end()
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
     std::unordered_multiset<int> l1(a1, a1+3);
     std::unordered_multiset<int>::const_iterator i = l1.end();
     l1.erase(i);
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.multiset/erase_iter_db2.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Call erase(const_iterator position) with iterator from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 #include <cstdlib>
 #include <exception>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
     std::unordered_multiset<int> l1(a1, a1+3);
     std::unordered_multiset<int> l2(a1, a1+3);
     std::unordered_multiset<int>::const_iterator i = l2.begin();
     l1.erase(i);
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.multiset/erase_iter_iter_db1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Call erase(const_iterator first, const_iterator last); with first iterator from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
     std::unordered_multiset<int> l1(a1, a1+3);
     std::unordered_multiset<int> l2(a1, a1+3);
     std::unordered_multiset<int>::iterator i = l1.erase(l2.cbegin(), next(l1.cbegin()));
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.multiset/erase_iter_iter_db2.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Call erase(const_iterator first, const_iterator last); with second iterator from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
     std::unordered_multiset<int> l1(a1, a1+3);
     std::unordered_multiset<int> l2(a1, a1+3);
     std::unordered_multiset<int>::iterator i = l1.erase(l1.cbegin(), next(l2.cbegin()));
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.multiset/erase_iter_iter_db3.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Call erase(const_iterator first, const_iterator last); with both iterators from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
     std::unordered_multiset<int> l1(a1, a1+3);
     std::unordered_multiset<int> l2(a1, a1+3);
     std::unordered_multiset<int>::iterator i = l1.erase(l2.cbegin(), next(l2.cbegin()));
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.multiset/erase_iter_iter_db4.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Call erase(const_iterator first, const_iterator last); with a bad range
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
     std::unordered_multiset<int> l1(a1, a1+3);
     std::unordered_multiset<int>::iterator i = l1.erase(next(l1.cbegin()), l1.cbegin());
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.multiset/unord.multiset.swap/db_swap_1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
 //           class Alloc = allocator<Value>>
 // class unordered_multiset
 
 // void swap(unordered_multiset& x, unordered_multiset& y);
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
+
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
 
 #include <unordered_set>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#if _LIBCPP_DEBUG >= 1
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::unordered_multiset<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
         std::unordered_multiset<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
         std::unordered_multiset<int>::iterator i1 = c1.begin();
         std::unordered_multiset<int>::iterator i2 = c2.begin();
         swap(c1, c2);
         c1.erase(i2);
         c2.erase(i1);
         std::unordered_multiset<int>::iterator j = i1;
         c1.erase(i1);
         assert(false);
     }
-#endif
 
     return 0;
 }

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

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
-// Call erase(const_iterator position) with iterator from another container
+// iterator insert(const_iterator p, const value_type& x);
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
-#include <cstdlib>
-#include <exception>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
-    int a1[] = {1, 2, 3};
-    std::unordered_multiset<int> l1(a1, a1+3);
-    std::unordered_multiset<int> l2(a1, a1+3);
-    std::unordered_multiset<int>::const_iterator i = l2.begin();
-    l1.erase(i);
+        typedef std::unordered_set<double> C;
+        typedef C::iterator R;
+        typedef C::value_type P;
+        C c;
+        C c2;
+        C::const_iterator e = c2.end();
+        P v(3.5);
+        R r = c.insert(e, v);
         assert(false);
     }
-}
-
-#else
-
-int main(int, char**)
-{
 
     return 0;
 }
-
-#endif

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

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Increment iterator past end.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     C::iterator i = c.begin();
     ++i;
     assert(i == c.end());
     ++i;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

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

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Dereference non-dereferenceable iterator.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
     C c(1);
     C::iterator i = c.end();
     (void) *i;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

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

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Increment local_iterator past end.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     C::local_iterator i = c.begin(0);
     ++i;
     ++i;
     assert(false);
     }
 #endif
 
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

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

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Dereference non-dereferenceable iterator.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
     C c(1);
     C::local_iterator i = c.end(0);
     (void) *i;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.set/db_move.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++03
+
 // <unordered_set>
 
-// Call erase(const_iterator first, const_iterator last); with second iterator from another container
+// unordered_set(unordered_set&& u);
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
-#include <exception>
-#include <cstdlib>
+#include <utility>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
-    int a1[] = {1, 2, 3};
-    std::unordered_multiset<int> l1(a1, a1+3);
-    std::unordered_multiset<int> l2(a1, a1+3);
-    std::unordered_multiset<int>::iterator i = l1.erase(l1.cbegin(), next(l2.cbegin()));
-    assert(false);
-    }
+        std::unordered_set<int> s1 = {1, 2, 3};
+        std::unordered_set<int>::iterator i = s1.begin();
+        int k = *i;
+        std::unordered_set<int> s2 = std::move(s1);
+        assert(*i == k);
+        s2.erase(i);
+        assert(s2.size() == 2);
     }
 
-#else
-
-int main(int, char**)
-{
-
     return 0;
 }
-
-#endif

libcxx/test/libcxx/containers/unord/unord.set/erase_iter_db1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Call erase(const_iterator position) with end()
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
     std::unordered_set<int> l1(a1, a1+3);
     std::unordered_set<int>::const_iterator i = l1.end();
     l1.erase(i);
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.set/erase_iter_db2.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Call erase(const_iterator position) with iterator from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 #include <cstdlib>
 #include <exception>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
     std::unordered_set<int> l1(a1, a1+3);
     std::unordered_set<int> l2(a1, a1+3);
     std::unordered_set<int>::const_iterator i = l2.begin();
     l1.erase(i);
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.set/erase_iter_iter_db1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Call erase(const_iterator first, const_iterator last); with first iterator from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
     std::unordered_set<int> l1(a1, a1+3);
     std::unordered_set<int> l2(a1, a1+3);
     std::unordered_set<int>::iterator i = l1.erase(l2.cbegin(), next(l1.cbegin()));
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.set/erase_iter_iter_db2.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Call erase(const_iterator first, const_iterator last); with second iterator from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
     std::unordered_set<int> l1(a1, a1+3);
     std::unordered_set<int> l2(a1, a1+3);
     std::unordered_set<int>::iterator i = l1.erase(l1.cbegin(), next(l2.cbegin()));
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.set/erase_iter_iter_db3.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Call erase(const_iterator first, const_iterator last); with both iterators from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
     std::unordered_set<int> l1(a1, a1+3);
     std::unordered_set<int> l2(a1, a1+3);
     std::unordered_set<int>::iterator i = l1.erase(l2.cbegin(), next(l2.cbegin()));
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.set/erase_iter_iter_db4.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // Call erase(const_iterator first, const_iterator last); with a bad range
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     {
     int a1[] = {1, 2, 3};
     std::unordered_set<int> l1(a1, a1+3);
     std::unordered_set<int>::iterator i = l1.erase(next(l1.cbegin()), l1.cbegin());
     assert(false);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/containers/unord/unord.set/unord.set.swap/db_swap_1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
 //           class Alloc = allocator<Value>>
 // class unordered_set
 
 // void swap(unordered_set& x, unordered_set& y);
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
+
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
 
 #include <unordered_set>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#if _LIBCPP_DEBUG >= 1
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::unordered_set<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
         std::unordered_set<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
         std::unordered_set<int>::iterator i1 = c1.begin();
         std::unordered_set<int>::iterator i2 = c2.begin();
         swap(c1, c2);
         c1.erase(i2);
         c2.erase(i1);
         std::unordered_set<int>::iterator j = i1;
         c1.erase(i1);
         assert(false);
     }
-#endif
 
     return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.access/db_back.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Call back() on empty container.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     S s(1, '\0');
     assert(s.back() == 0);
     s.clear();
     assert(s.back() == 0);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.access/db_cback.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Call back() on empty const container.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     const S s;
     assert(s.back() == 0);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.access/db_cfront.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Call front() on empty const container.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     const S s;
     assert(s.front() == 0);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.access/db_cindex.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Index const string out of bounds.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     const S s;
     assert(s[0] == 0);
     assert(s[1] == 0);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.access/db_front.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Call front() on empty container.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     S s(1, '\0');
     assert(s.front() == 0);
     s.clear();
     assert(s.front() == 0);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.access/db_index.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Index string out of bounds.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S s;
     assert(s[0] == 0);
     assert(s[1] == 0);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_2.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Compare iterators from different containers with <.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     S s1;
     S s2;
     bool b = s1.begin() < s2.begin();
     (void) b;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_3.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Subtract iterators from different containers with <.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     S s1;
     S s2;
     int i = s1.begin() - s2.begin();
     (void) i;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_4.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Index iterator out of bounds.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     C c(1, '\0');
     C::iterator i = c.begin();
     assert(i[0] == 0);
     assert(i[1] == 0);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_5.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Add to iterator out of bounds.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     i += 1;
     assert(i == c.end());
     i = c.begin();
     i += 2;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_6.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Decrement iterator prior to begin.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     C::iterator i = c.end();
     --i;
     assert(i == c.begin());
     --i;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_7.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Increment iterator past end.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     C::iterator i = c.begin();
     ++i;
     assert(i == c.end());
     ++i;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_8.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Dereference non-dereferenceable iterator.
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
#if TEST_STD_VER >= 11
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> C;
     C c(1, '\0');
     C::iterator i = c.end();
     (void) *i;
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.modifiers/clear_and_shrink_db1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Call __clear_and_shrink() and ensure string invariants hold
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
int main(int, char**)
     {
     std::string::size_type cap = l.capacity();
     l.__clear_and_shrink();
     assert(l.__invariants());
     assert(l.size() == 0);
     assert(l.capacity() < cap);
     }
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Call erase(const_iterator position) with end()
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <cstdlib>
 #include <exception>
 
 #include "test_macros.h"
#if TEST_STD_VER >= 11
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S l1("123");
     S::const_iterator i = l1.end();
     l1.erase(i);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_db2.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Call erase(const_iterator position) with iterator from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <cstdlib>
 #include <exception>
 
 #include "test_macros.h"
#if TEST_STD_VER >= 11
     S l1("123");
     S l2("123");
     S::const_iterator i = l2.begin();
     l1.erase(i);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Call erase(const_iterator first, const_iterator last); with first iterator from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
#if TEST_STD_VER >= 11
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S l1("123");
     S l2("123");
     S::iterator i = l1.erase(l2.cbegin(), l1.cbegin()+1);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db2.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Call erase(const_iterator first, const_iterator last); with second iterator from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
#if TEST_STD_VER >= 11
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S l1("123");
     S l2("123");
     S::iterator i = l1.erase(l1.cbegin(), l2.cbegin()+1);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db3.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Call erase(const_iterator first, const_iterator last); with both iterators from another container
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
#if TEST_STD_VER >= 11
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S l1("123");
     S l2("123");
     S::iterator i = l1.erase(l2.cbegin(), l2.cbegin()+1);
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db4.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // Call erase(const_iterator first, const_iterator last); with a bad range
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
 
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "test_macros.h"
#if TEST_STD_VER >= 11
     {
     typedef std::basic_string<char, std::char_traits<char>, min_allocator<char>> S;
     S l1("123");
     S::iterator i = l1.erase(l1.cbegin()+1, l1.cbegin());
     assert(false);
     }
 #endif
 }
-
-#else
-
-int main(int, char**)
-{
-
-  return 0;
-}
-
-#endif

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_pop_back_db1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // void pop_back();
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
+
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#if _LIBCPP_DEBUG >= 1
     {
         std::string s;
         s.pop_back();
         assert(false);
     }
-#endif
 
     return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/insert_iter_char_db1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // iterator insert(const_iterator p, charT c);
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
+
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
 
 #include <string>
 #include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 
 
 int main(int, char**)
 {
-#if _LIBCPP_DEBUG >= 1
     {
         typedef std::string S;
         S s;
         S s2;
         s.insert(s2.begin(), '1');
         assert(false);
     }
-#endif
 
     return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/insert_iter_iter_iter_db1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
-// iterator insert(const_iterator p, charT c);
+// template<class InputIterator>
+//   iterator insert(const_iterator p, InputIterator first, InputIterator last);
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
+
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
 
 #include <string>
-#include <stdexcept>
 #include <cassert>
 
 #include "test_macros.h"
 
 
 int main(int, char**)
 {
-#if _LIBCPP_DEBUG >= 1
     {
-        typedef std::string S;
-        S s;
-        S s2;
-        s.insert(s2.begin(), '1');
+        std::string v;
+        std::string v2;
+        char a[] = "123";
+        const int N = sizeof(a)/sizeof(a[0]);
+        std::string::iterator i = v.insert(v2.cbegin() + 10, a, a+N);
         assert(false);
     }
-#endif
 
     return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/insert_iter_size_char_db1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // iterator insert(const_iterator p, size_type n, charT c);
 
-#if _LIBCPP_DEBUG >= 1
+// This test requires debug mode, which the library on macOS doesn't have.
+// UNSUPPORTED: with_system_cxx_lib=macosx
+
+#define _LIBCPP_DEBUG 1
 #define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-#if _LIBCPP_DEBUG >= 1
     {
         std::string s;
         std::string s2;
         s.insert(s2.begin(), 1, 'a');
         assert(false);
     }
-#endif
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.map/bucket.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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(const key_type& __k) const;
 
-#ifdef _LIBCPP_DEBUG
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <unordered_map>
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
#if TEST_STD_VER >= 11
         };
         const C c(std::begin(a), std::end(a));
         size_t bc = c.bucket_count();
         assert(bc >= 5);
         for (size_t i = 0; i < 13; ++i)
             LIBCPP_ASSERT(c.bucket(i) == i % bc);
     }
 #endif
-#if _LIBCPP_DEBUG_LEVEL >= 1
-    {
-        typedef std::unordered_map<int, std::string> C;
-        C c;
-        (void) c.bucket(3);
-        assert(false);
-    }
-#endif
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.map/unord.map.cnstr/move.pass.cpp

int main(int, char**)
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
         assert(c0.empty());
     }
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::unordered_map<int, int> s1 = {{1, 1}, {2, 2}, {3, 3}};
-        std::unordered_map<int, int>::iterator i = s1.begin();
-        std::pair<const int, int> k = *i;
-        std::unordered_map<int, int> s2 = std::move(s1);
-        assert(*i == k);
-        s2.erase(i);
-        assert(s2.size() == 2);
-    }
-#endif
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 
 // iterator insert(const_iterator p, const value_type& x);
 
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <unordered_map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template<class Container>
 void do_insert_hint_const_lvalue_test()

 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_map<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
 
         do_insert_hint_const_lvalue_test<C>();
     }
 #endif
-#if _LIBCPP_DEBUG >= 1
-    {
-        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);
-    }
-#endif
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp

 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_map
 
 // template <class P,
 //           class = typename enable_if<is_convertible<P, value_type>::value>::type>
 //     iterator insert(const_iterator p, P&& x);
 
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <unordered_map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
 int main(int, char**)
int main(int, char**)
         assert(r->first == 4.5);
         assert(r->second == 4);
 
         r = c.insert(c.end(), {5.5, 4});
         assert(c.size() == 3);
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
-#if _LIBCPP_DEBUG >= 1
-    {
-        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);
-    }
-#endif
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.cnstr/move.pass.cpp

int main(int, char**)
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
         assert(c.hash_function() == test_hash<std::hash<int> >(8));
         assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
         assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
 
         assert(c0.empty());
     }
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::unordered_multimap<int, int> s1 = {{1, 1}, {2, 2}, {3, 3}};
-        std::unordered_multimap<int, int>::iterator i = s1.begin();
-        std::pair<const int, int> k = *i;
-        std::unordered_multimap<int, int> s2 = std::move(s1);
-        assert(*i == k);
-        s2.erase(i);
-        assert(s2.size() == 2);
-    }
-#endif
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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_multimap
 
 // iterator insert(const_iterator p, const value_type& x);
 
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <unordered_map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template<class Container>
 void do_insert_const_lvalue_test()
int main(int, char**)
     do_insert_const_lvalue_test<std::unordered_multimap<double, int> >();
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multimap<double, int, std::hash<double>, std::equal_to<double>,
                             min_allocator<std::pair<const double, int>>> C;
         do_insert_const_lvalue_test<C>();
     }
 #endif
-#if _LIBCPP_DEBUG >= 1
-    {
-        typedef std::unordered_multimap<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);
-    }
-#endif
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_rvalue.pass.cpp

 // template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // template <class P,
 //           class = typename enable_if<is_convertible<P, value_type>::value>::type>
 //     iterator insert(const_iterator p, P&& x);
 
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <unordered_map>
 #include <cassert>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 #include "min_allocator.h"
 
 int main(int, char**)
int main(int, char**)
         assert(r->first == 4.5);
         assert(r->second == 4);
 
         r = c.insert(c.end(), {5.5, 4});
         assert(c.size() == 4);
         assert(r->first == 5.5);
         assert(r->second == 4);
     }
-#if _LIBCPP_DEBUG >= 1
-    {
-        typedef std::unordered_multimap<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);
-    }
-#endif
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
 //           class Alloc = allocator<Value>>
 // class unordered_multiset
 
 // iterator insert(const_iterator p, const value_type& x);
 
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <unordered_set>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template<class Container>
 void do_insert_hint_const_lvalue_test()
int main(int, char**)
     do_insert_hint_const_lvalue_test<std::unordered_multiset<double> >();
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_multiset<double, std::hash<double>,
             std::equal_to<double>, min_allocator<double>> C;
         do_insert_hint_const_lvalue_test<C>();
     }
 #endif
-#if _LIBCPP_DEBUG >= 1
-    {
-        typedef std::unordered_multiset<double> C;
-        typedef C::iterator R;
-        typedef C::value_type P;
-        C c;
-        C c2;
-        C::const_iterator e = c2.end();
-        P v(3.5);
-        R r = c.insert(e, v);
-        assert(false);
-    }
-#endif
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.multiset/unord.multiset.cnstr/move.pass.cpp

int main(int, char**)
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
         assert(c0.empty());
     }
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::unordered_multiset<int> s1 = {1, 2, 3};
-        std::unordered_multiset<int>::iterator i = s1.begin();
-        int k = *i;
-        std::unordered_multiset<int> s2 = std::move(s1);
-        assert(*i == k);
-        s2.erase(i);
-        assert(s2.size() == 2);
-    }
-#endif
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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_set>
 
 // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>,
 //           class Alloc = allocator<Value>>
 // class unordered_set
 
 // iterator insert(const_iterator p, const value_type& x);
 
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <unordered_set>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 template<class Container>
 void do_insert_hint_const_lvalue_test()
int main(int, char**)
     do_insert_hint_const_lvalue_test<std::unordered_set<double> >();
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<double, std::hash<double>,
                                 std::equal_to<double>, min_allocator<double>> C;
         do_insert_hint_const_lvalue_test<C>();
     }
 #endif
-#if _LIBCPP_DEBUG >= 1
-    {
-        typedef std::unordered_set<double> C;
-        typedef C::iterator R;
-        typedef C::value_type P;
-        C c;
-        C c2;
-        C::const_iterator e = c2.end();
-        P v(3.5);
-        R r = c.insert(e, v);
-        assert(false);
-    }
-#endif
 
     return 0;
 }

libcxx/test/std/containers/unord/unord.set/unord.set.cnstr/move.pass.cpp

int main(int, char**)
         assert(!c.empty());
         assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
         assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
         assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
         assert(c.max_load_factor() == 1);
 
         assert(c0.empty());
     }
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::unordered_set<int> s1 = {1, 2, 3};
-        std::unordered_set<int>::iterator i = s1.begin();
-        int k = *i;
-        std::unordered_set<int> s2 = std::move(s1);
-        assert(*i == k);
-        s2.erase(i);
-        assert(s2.size() == 2);
-    }
-#endif
 
     return 0;
 }

libcxx/test/std/strings/basic.string/string.modifiers/string_insert/iter_iter_iter.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // <string>
 
 // template<class InputIterator>
 //   iterator insert(const_iterator p, InputIterator first, InputIterator last);
 
-#if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
-#endif
-
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 
 template <class S, class It>
#ifndef TEST_HAS_NO_EXCEPTIONS
     test_exceptions(S(), 0, IIter(TIter(s, s+10, 5, TIter::TADereference)), IIter());
     test_exceptions(S(), 0, IIter(TIter(s, s+10, 6, TIter::TAComparison)), IIter());
 
     test_exceptions(S(), 0, TIter(s, s+10, 4, TIter::TAIncrement), TIter());
     test_exceptions(S(), 0, TIter(s, s+10, 5, TIter::TADereference), TIter());
     test_exceptions(S(), 0, TIter(s, s+10, 6, TIter::TAComparison), TIter());
     }
 #endif
-#if _LIBCPP_DEBUG >= 1
-    {
-        std::string v;
-        std::string v2;
-        char a[] = "123";
-        const int N = sizeof(a)/sizeof(a[0]);
-        std::string::iterator i = v.insert(v2.cbegin() + 10, a, a+N);
-        assert(false);
-    }
-#endif
 
     { // test inserting into self
     typedef std::string S;
     S s_short = "123/";
     S s_long  = "Lorem ipsum dolor sit amet, consectetur/";
 
     s_short.insert(s_short.begin(), s_short.begin(), s_short.end());
     assert(s_short == "123/123/");