[libc++][tests] Fixing some issues in unordered container tests

[iid_iunknown]

Summary

Hi Eric,

Would you review these minor corrections for the issues found while running the libc++ tests with _LIBCPP_DEBUG, please?

Below is the summary explaining the motivation for the changes.

(1)

• test/std/containers/unord/unord.multimap/db_local_iterators_7.pass.cpp
• test/libcxx/containers/unord/unord.map/db_local_iterators_7.pass.cpp
  
  The tests expect the 1st iterator increment to be successful and the 2nd one to trigger _LIBCPP_ASSERT. Actually the assert is triggered by the 1st increment as the container contains no elements. Fix: initialize the container with one element.

(2)

• test/std/containers/unord/unord.multiset/db_iterators_8.pass.cpp
• test/std/containers/unord/unord.multiset/db_local_iterators_8.pass.cpp
• test/std/containers/unord/unord.set/db_iterators_8.pass.cpp
• test/std/containers/unord/unord.set/db_local_iterators_8.pass.cpp
  
  Container template instantiation passes the allocator type in the wrong place.

(3)

• test/std/containers/unord/unord.multiset/db_iterators_7.pass.cpp
• test/std/containers/unord/unord.multiset/db_local_iterators_7.pass.cpp
• test/std/containers/unord/unord.set/db_iterators_7.pass.cpp
• test/std/containers/unord/unord.set/db_local_iterators_7.pass.cpp
  
  Same as (1) + (2)

(4)

• test/std/containers/unord/unord.set/emplace_hint.pass.cpp
• test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp
• test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp
  
  Saves the end iterator and then modifies the container invalidating the iterator due to rehashing.

Thanks!

[EricWF]

Thanks for cleaning up our debug mode. I've added a couple of inline comments which need to be addressed.

If your interested there is much more work to do. For example moving all debug tests from test/std to test/libcxx, or fixing the debug tests to manually #define _LIBCPP_DEBUG 1.

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

0–1

This uses C++11 features but is required to work in C++03. Please make sure these changes don't break C++03 tests.

Side note: Wouldn't removing the second increment be simpler than changing the size?

0–1

All of the code below this is logically dead. Please either (A) remove it, or (B) define _LIBCPP_ASSERT so it doesn't exit when invoked. For example:

#define _LIBCPP_ASSERT(p, m) ((p) ? (void)0 : throw 0)
int main()
{
    typedef std::unordered_map<int, std::string> C;
    C c(1);
    C::local_iterator i = c.begin(0);
    try {
      ++i;
      assert(false);
    } catch(int) {}
    // More tests can be written below
}

0–1

Tests for debug mode should manually enable it, instead of requiring it already be enabled. If you want to do more cleanup please change this test to #define _LIBCPP_DEBUG 1 at the start of the file, and then remove the redundant empty main.

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

0–1

Nice fix. Thanks!

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

0–1

These fixes LGTM. Thanks.

[iid_iunknown]

Addressing the review remarks

[iid_iunknown]

In D24941#553200, @EricWF wrote:

Thanks for cleaning up our debug mode. I've added a couple of inline comments which need to be addressed.

Thank you for looking into this, Eric! Much appreciated.

Please find my inline answers below.

If your interested there is much more work to do. For example moving all debug tests from test/std to test/libcxx, or fixing the debug tests to manually #define _LIBCPP_DEBUG 1.

Yes, I can do this once I am done with my other tasks. May we do this refactoring in a separate review request to avoid a relatively big commit?

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

0–1

Done. Several other tests under test/libcxx have also been fixed.

0–1

This uses C++11 features but is required to work in C++03.

Thanks for catching this! Fixed.

Wouldn't removing the second increment be simpler than changing the size?

My thought was that these 2 increments were added intentinally to test successful and unsuccessful increment. On the other hand, other tests already check successful increments and retesting them here is superfluous. Removing element insertion and one increment according to your advice.

0–1

Agree. We build all the libc++ tests into a single executable binary to test on our system. We also have custom assert, exit() / abort() and _LIBCPP_ASSERT (similar to the one you suggested) so that test failures do not stop execution. Thus our testing env is not affected, which is why I didn't fix this. The usual test workflow does suffer from this however. Fixing these and some other tests according to your advice.

[iid_iunknown]

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

0–1

Agree. We build all the libc++ tests into a single executable binary to test on our system. We also have custom assert, exit() / abort() and _LIBCPP_ASSERT (similar to the one you suggested) so that test failures do not stop execution. Thus our testing env is not affected, which is why I didn't fix this. The usual test workflow does suffer from this however. Fixing these and some other tests according to your advice.

[EricWF]

This *almost* LGTM. The tests that have been converted to a throwing _LIBCPP_ASSERT need to be marked with // UNSUPPORTED: libcpp-no-exceptions

In D24941#554475, @iid_iunknown wrote:

Yes, I can do this once I am done with my other tasks. May we do this refactoring in a separate review request to avoid a relatively big commit?

Absolutely. Refactorings are always welcome as multiple smaller patches.

[iid_iunknown]

Addressing the review remarks.
"UNSUPPORTED: libcpp-no-exceptions" added.

[iid_iunknown]

In D24941#564984, @EricWF wrote:

This *almost* LGTM. The tests that have been converted to a throwing _LIBCPP_ASSERT need to be marked with // UNSUPPORTED: libcpp-no-exceptions

Yep, I was going to add UNSUPPORTED but accidentally missed them at the last moment.
Thanks for the reminder!

[EricWF]

This almost LGTM. I would like to see the remaining _db tests moved into the test/libcxx subdirectory and I would like to see them manually define _LIBCPP_DEBUG instead of guarding for when it is not defined.

Note this should only be done for tests that are entirely debug tests and which test no non-debug behavior.

test/std/containers/sequences/vector/vector.modifiers/erase_iter_db2.pass.cpp

16

For tests like this, where the entire test is a debug test (guarded by #if _LIBCPP_DEBUG >= N) please do two things:

1. Move the test from test/std/.../foo/... to test/libcxx/.../foo/....
2. Manually define _LIBCPP_DEBUG instead of checking for it. This way the debug test always run.

[EricWF]

Resigning as reviewer. I actually removed and entirely re-implemented these tests earlier today. This revision should be abandoned.

I'm very sorry about steamrolling over this. Thank you very much for the patch. I hope this doesn't discourage future contributions.

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_map>
 
 // Increment iterator past end.
 
-#if _LIBCPP_DEBUG >= 1
+// UNSUPPORTED: libcpp-no-exceptions
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_DEBUG 1
+
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     typedef std::unordered_map<int, std::string> C;
     C c;
     c.insert(std::make_pair(1, "one"));
     C::iterator i = c.begin();
     ++i;
     assert(i == c.end());
+    try
+    {
         ++i;
         assert(false);
     }
+    catch(int) {}
+    }
 #if __cplusplus >= 201103L
     {
     typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                         min_allocator<std::pair<const int, std::string>>> C;
     C c;
     c.insert(std::make_pair(1, "one"));
     C::iterator i = c.begin();
     ++i;
     assert(i == c.end());
+    try
+    {
         ++i;
         assert(false);
     }
-#endif
-}
-
-#else
-
-int main()
-{
+    catch(int) {}
     }
-
 #endif
+}

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_map>
 
 // Dereference non-dereferenceable iterator.
 
-#if _LIBCPP_DEBUG >= 1
+// UNSUPPORTED: libcpp-no-exceptions
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_DEBUG 1
+
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     typedef std::unordered_map<int, std::string> C;
     C c;
     c.insert(std::make_pair(1, "one"));
     C::iterator i = c.end();
+    try
+    {
         C::value_type j = *i;
         assert(false);
     }
+    catch(int) {}
+    }
 #if __cplusplus >= 201103L
     {
     typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                         min_allocator<std::pair<const int, std::string>>> C;
     C c;
     c.insert(std::make_pair(1, "one"));
     C::iterator i = c.end();
+    try
+    {
         C::value_type j = *i;
         assert(false);
     }
-#endif
-}
-
-#else
-
-int main()
-{
+    catch(int) {}
     }
-
 #endif
+}

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_map>
 
 // Increment local_iterator past end.
 
-#if _LIBCPP_DEBUG >= 1
+// UNSUPPORTED: libcpp-no-exceptions
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_DEBUG 1
+
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     typedef std::unordered_map<int, std::string> C;
     C c(1);
     C::local_iterator i = c.begin(0);
-    ++i;
+    try
+    {
         ++i;
         assert(false);
     }
+    catch(int) {}
+    }
 #if __cplusplus >= 201103L
     {
     typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                         min_allocator<std::pair<const int, std::string>>> C;
     C c(1);
     C::local_iterator i = c.begin(0);
-    ++i;
+    try
+    {
         ++i;
         assert(false);
     }
-#endif
-
+    catch(int) {}
     }
+#endif
 
-#else
-
-int main()
-{
 }
-
-#endif

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_map>
 
 // Dereference non-dereferenceable iterator.
 
-#if _LIBCPP_DEBUG >= 1
+// UNSUPPORTED: libcpp-no-exceptions
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_DEBUG 1
+
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     typedef std::unordered_map<int, std::string> C;
     C c(1);
     C::local_iterator i = c.end(0);
+    try
+    {
         C::value_type j = *i;
         assert(false);
     }
+    catch(int) {}
+    }
 #if __cplusplus >= 201103L
     {
     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);
+    try
+    {
         C::value_type j = *i;
         assert(false);
     }
-#endif
-}
-
-#else
-
-int main()
-{
+    catch(int) {}
     }
-
 #endif
+}

test/std/containers/sequences/vector/vector.modifiers/emplace.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // template <class... Args> iterator emplace(const_iterator pos, Args&&... args);
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 #endif
 
 #include <vector>
 #include <cassert>
 #include "../../../stack_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(c.back().geti() == 3);
         assert(c.back().getd() == 4.5);
         assert(is_contiguous_container_asan_correct(c));
     }
 #if _LIBCPP_DEBUG >= 1
     {
         std::vector<A> c1;
         std::vector<A> c2;
+        try
+        {
             std::vector<A>::iterator i = c1.emplace(c2.cbegin(), 2, 3.5);
             assert(false);
         }
+        catch(int) {}
+    }
 #endif
 #if TEST_STD_VER >= 11
     {
         std::vector<A, min_allocator<A>> c;
         std::vector<A, min_allocator<A>>::iterator i = c.emplace(c.cbegin(), 2, 3.5);
         assert(i == c.begin());
         assert(c.size() == 1);
         assert(c.front().geti() == 2);
#if TEST_STD_VER >= 11
         assert(c[1].getd() == 6.5);
         assert(c.back().geti() == 3);
         assert(c.back().getd() == 4.5);
     }
 #if _LIBCPP_DEBUG >= 1
     {
         std::vector<A, min_allocator<A>> c1;
         std::vector<A, min_allocator<A>> c2;
+        try
+        {
             std::vector<A, min_allocator<A>>::iterator i = c1.emplace(c2.cbegin(), 2, 3.5);
             assert(false);
         }
+        catch(int) {}
+    }
 #endif
 #endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }

test/std/containers/sequences/vector/vector.modifiers/erase_iter_db1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Call erase(const_iterator position) with end()
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <vector>
 #include <cassert>
 #include <cstdlib>
 #include <exception>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     int a1[] = {1, 2, 3};
     std::vector<int> l1(a1, a1+3);
     std::vector<int>::const_iterator i = l1.end();
+    try
+    {
         l1.erase(i);
         assert(false);
     }
+    catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3};
     std::vector<int, min_allocator<int>> l1(a1, a1+3);
     std::vector<int, min_allocator<int>>::const_iterator i = l1.end();
+    try
+    {
         l1.erase(i);
         assert(false);
     }
+    catch(int) {}
+    }
 #endif
 }
 
 #else
 
 int main()
 {
 }
 
 #endif

test/std/containers/sequences/vector/vector.modifiers/erase_iter_db2.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Call erase(const_iterator position) with iterator from another container
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <vector>
 #include <cassert>
 #include <cstdlib>
 #include <exception>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     int a1[] = {1, 2, 3};
     std::vector<int> l1(a1, a1+3);
     std::vector<int> l2(a1, a1+3);
     std::vector<int>::const_iterator i = l2.begin();
+    try
+    {
         l1.erase(i);
         assert(false);
     }
+    catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3};
     std::vector<int, min_allocator<int>> l1(a1, a1+3);
     std::vector<int, min_allocator<int>> l2(a1, a1+3);
     std::vector<int, min_allocator<int>>::const_iterator i = l2.begin();
+    try
+    {
         l1.erase(i);
         assert(false);
     }
+    catch(int) {}
+    }
 #endif
 }
 
 #else
 
 int main()
 {
 }
 
 #endif

test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Call erase(const_iterator first, const_iterator last); with first iterator from another container
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <vector>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     int a1[] = {1, 2, 3};
     std::vector<int> l1(a1, a1+3);
     std::vector<int> l2(a1, a1+3);
+    try
+    {
         std::vector<int>::iterator i = l1.erase(l2.cbegin(), l1.cbegin()+1);
         assert(false);
     }
+    catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3};
     std::vector<int, min_allocator<int>> l1(a1, a1+3);
     std::vector<int, min_allocator<int>> l2(a1, a1+3);
+    try
+    {
         std::vector<int, min_allocator<int>>::iterator i = l1.erase(l2.cbegin(), l1.cbegin()+1);
         assert(false);
     }
+    catch(int) {}
+    }
 #endif
 }
 
 #else
 
 int main()
 {
 }
 
 #endif

test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db2.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Call erase(const_iterator first, const_iterator last); with second iterator from another container
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <vector>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     int a1[] = {1, 2, 3};
     std::vector<int> l1(a1, a1+3);
     std::vector<int> l2(a1, a1+3);
+    try
+    {
         std::vector<int>::iterator i = l1.erase(l1.cbegin(), l2.cbegin()+1);
         assert(false);
     }
+    catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3};
     std::vector<int, min_allocator<int>> l1(a1, a1+3);
     std::vector<int, min_allocator<int>> l2(a1, a1+3);
+    try
+    {
         std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin(), l2.cbegin()+1);
         assert(false);
     }
+    catch(int) {}
+    }
 #endif
 }
 
 #else
 
 int main()
 {
 }
 
 #endif

test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db3.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Call erase(const_iterator first, const_iterator last); with both iterators from another container
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <vector>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     int a1[] = {1, 2, 3};
     std::vector<int> l1(a1, a1+3);
     std::vector<int> l2(a1, a1+3);
+    try
+    {
         std::vector<int>::iterator i = l1.erase(l2.cbegin(), l2.cbegin()+1);
         assert(false);
     }
+    catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3};
     std::vector<int, min_allocator<int>> l1(a1, a1+3);
     std::vector<int, min_allocator<int>> l2(a1, a1+3);
+    try
+    {
         std::vector<int, min_allocator<int>>::iterator i = l1.erase(l2.cbegin(), l2.cbegin()+1);
         assert(false);
     }
+    catch(int) {}
+    }
 #endif
 }
 
 #else
 
 int main()
 {
 }
 
 #endif

test/std/containers/sequences/vector/vector.modifiers/erase_iter_iter_db4.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // Call erase(const_iterator first, const_iterator last); with a bad range
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <vector>
 #include <cassert>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     int a1[] = {1, 2, 3};
     std::vector<int> l1(a1, a1+3);
+    try
+    {
         std::vector<int>::iterator i = l1.erase(l1.cbegin()+1, l1.cbegin());
         assert(false);
     }
+    catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
     int a1[] = {1, 2, 3};
     std::vector<int, min_allocator<int>> l1(a1, a1+3);
+    try
+    {
         std::vector<int, min_allocator<int>>::iterator i = l1.erase(l1.cbegin()+1, l1.cbegin());
         assert(false);
     }
+    catch(int) {}
+    }
 #endif
 }
 
 #else
 
 int main()
 {
 }
 
 #endif

test/std/containers/sequences/vector/vector.modifiers/insert_iter_iter_iter.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // template <class Iter>
 //   iterator insert(const_iterator position, Iter first, Iter last);
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 #endif
 
 #include <vector>
 #include <cassert>
 #include "../../../stack_allocator.h"
 #include "test_iterators.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
int main()
             assert(v[j] == 0);
     }
 #if _LIBCPP_DEBUG >= 1
     {
         std::vector<int> v(100);
         std::vector<int> v2(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
+        try
+        {
             std::vector<int>::iterator i = v.insert(v2.cbegin() + 10, input_iterator<const int*>(a),
                                             input_iterator<const int*>(a+N));
             assert(false);
         }
+        catch(int) {}
+    }
 #endif
 #if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> v(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
         std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, input_iterator<const int*>(a),
                                         input_iterator<const int*>(a+N));
#if TEST_STD_VER >= 11
             assert(v[j] == 0);
     }
 #if _LIBCPP_DEBUG >= 1
     {
         std::vector<int, min_allocator<int>> v(100);
         std::vector<int, min_allocator<int>> v2(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
+        try
+        {
             std::vector<int, min_allocator<int>>::iterator i = v.insert(v2.cbegin() + 10, input_iterator<const int*>(a),
                                             input_iterator<const int*>(a+N));
             assert(false);
         }
+        catch(int) {}
+    }
 #endif
 #endif
 }

test/std/containers/sequences/vector/vector.modifiers/insert_iter_rvalue.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // iterator insert(const_iterator position, value_type&& x);
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 #endif
 
 #include <vector>
 #include <cassert>
 #include "../../../stack_allocator.h"
 #include "MoveOnly.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         assert(v[j] == MoveOnly(3));
         for (++j; j < 101; ++j)
             assert(v[j] == MoveOnly());
     }
 #if _LIBCPP_DEBUG >= 1
     {
         std::vector<int> v1(3);
         std::vector<int> v2(3);
+        try
+        {
             v1.insert(v2.begin(), 4);
             assert(false);
         }
+        catch(int) {}
+    }
 #endif
 #if TEST_STD_VER >= 11
     {
         std::vector<MoveOnly, min_allocator<MoveOnly>> v(100);
         std::vector<MoveOnly, min_allocator<MoveOnly>>::iterator i = v.insert(v.cbegin() + 10, MoveOnly(3));
         assert(v.size() == 101);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == MoveOnly());
         assert(v[j] == MoveOnly(3));
         for (++j; j < 101; ++j)
             assert(v[j] == MoveOnly());
     }
 #if _LIBCPP_DEBUG >= 1
     {
         std::vector<int, min_allocator<int>> v1(3);
         std::vector<int, min_allocator<int>> v2(3);
+        try
+        {
             v1.insert(v2.begin(), 4);
             assert(false);
         }
+        catch(int) {}
+    }
 #endif
 #endif
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }

test/std/containers/sequences/vector/vector.modifiers/insert_iter_size_value.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // iterator insert(const_iterator position, size_type n, const value_type& x);
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 #endif
 
 #include <vector>
 #include <cassert>
 #include "../../../stack_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
int main()
             assert(v[j] == 1);
         for (++j; j < 105; ++j)
             assert(v[j] == 0);
     }
 #if _LIBCPP_DEBUG >= 1
     {
         std::vector<int> c1(100);
         std::vector<int> c2;
+        try
+        {
             std::vector<int>::iterator i = c1.insert(c2.cbegin() + 10, 5, 1);
             assert(false);
         }
+        catch(int) {}
+    }
 #endif
 #if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> v(100);
         std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, 5, 1);
         assert(v.size() == 105);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
#if TEST_STD_VER >= 11
             assert(v[j] == 1);
         for (++j; j < 105; ++j)
             assert(v[j] == 0);
     }
 #if _LIBCPP_DEBUG >= 1
     {
         std::vector<int, min_allocator<int>> c1(100);
         std::vector<int, min_allocator<int>> c2;
+        try
+        {
             std::vector<int, min_allocator<int>>::iterator i = c1.insert(c2.cbegin() + 10, 5, 1);
             assert(false);
         }
+        catch(int) {}
+    }
 #endif
 #endif
 }

test/std/containers/sequences/vector/vector.modifiers/insert_iter_value.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // iterator insert(const_iterator position, const value_type& x);
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 #endif
 
 #include <vector>
 #include <cassert>
 #include "../../../stack_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
int main()
         for (++j; j < 101; ++j)
             assert(v[j] == 0);
     }
 #if _LIBCPP_DEBUG >= 1
     {
         std::vector<int> v1(3);
         std::vector<int> v2(3);
         int i = 4;
+        try
+        {
             v1.insert(v2.begin(), i);
             assert(false);
         }
+        catch(int) {}
+    }
 #endif
 #if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> v(100);
         std::vector<int, min_allocator<int>>::iterator i = v.insert(v.cbegin() + 10, 1);
         assert(v.size() == 101);
         assert(is_contiguous_container_asan_correct(v));
         assert(i == v.begin() + 10);
         int j;
         for (j = 0; j < 10; ++j)
             assert(v[j] == 0);
         assert(v[j] == 1);
         for (++j; j < 101; ++j)
             assert(v[j] == 0);
     }
 #if _LIBCPP_DEBUG >= 1
     {
         std::vector<int, min_allocator<int>> v1(3);
         std::vector<int, min_allocator<int>> v2(3);
         int i = 4;
+        try
+        {
             v1.insert(v2.begin(), i);
             assert(false);
         }
+        catch(int) {}
+    }
 #endif
 #endif
 }

test/std/containers/sequences/vector/vector.modifiers/pop_back.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // void pop_back();
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 #endif
 
 #include <vector>
 #include <cassert>
 #include "../../../stack_allocator.h"
 #include "min_allocator.h"
 
 #if _LIBCPP_DEBUG >= 1
 #include <cstdlib>
 #include <exception>
 
 #endif
 
 int main()
 {
     {
         std::vector<int> c;
         c.push_back(1);
         assert(c.size() == 1);
         c.pop_back();
         assert(c.size() == 0);
 #if _LIBCPP_DEBUG >= 1
+        try
+        {
             c.pop_back();
             assert(false);
+        }
+        catch(int) {}
 #endif
     }
 #if TEST_STD_VER >= 11
     {
         std::vector<int, min_allocator<int>> c;
         c.push_back(1);
         assert(c.size() == 1);
         c.pop_back();
         assert(c.size() == 0);
 #if _LIBCPP_DEBUG >= 1
+        try
+        {
             c.pop_back();
             assert(false);
+        }
+        catch(int) {}
 #endif
     }
 #endif
 }

test/std/containers/sequences/vector/vector.special/db_swap_1.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // template <class T, class Alloc>
 //   void swap(vector<T,Alloc>& x, vector<T,Alloc>& y);
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 #endif
 
 #include <vector>
 #include <cassert>
 
 #include "min_allocator.h"
 
 int main()
 {
 #if _LIBCPP_DEBUG >= 1
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::vector<int> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
         std::vector<int> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
         std::vector<int>::iterator i1 = c1.begin();
         std::vector<int>::iterator i2 = c2.begin();
         swap(c1, c2);
         c1.erase(i2);
         c2.erase(i1);
+        try
+        {
             c1.erase(i1);
             assert(false);
         }
+        catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
         int a1[] = {1, 3, 7, 9, 10};
         int a2[] = {0, 2, 4, 5, 6, 8, 11};
         std::vector<int, min_allocator<int>> c1(a1, a1+sizeof(a1)/sizeof(a1[0]));
         std::vector<int, min_allocator<int>> c2(a2, a2+sizeof(a2)/sizeof(a2[0]));
         std::vector<int, min_allocator<int>>::iterator i1 = c1.begin();
         std::vector<int, min_allocator<int>>::iterator i2 = c2.begin();
         swap(c1, c2);
         c1.erase(i2);
         c2.erase(i1);
+        try
+        {
             c1.erase(i1);
             assert(false);
         }
+        catch(int) {}
+    }
 #endif
 #endif
 }

test/std/containers/unord/unord.multimap/db_iterators_7.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_map>
 
 // Increment iterator past end.
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     typedef std::unordered_multimap<int, std::string> C;
     C c;
     c.insert(std::make_pair(1, "one"));
     C::iterator i = c.begin();
     ++i;
     assert(i == c.end());
+    try
+    {
         ++i;
         assert(false);
     }
+    catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
     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;
     c.insert(std::make_pair(1, "one"));
     C::iterator i = c.begin();
     ++i;
     assert(i == c.end());
+    try
+    {
         ++i;
         assert(false);
     }
+    catch(int) {}
+    }
 #endif
 }
 
 #else
 
 int main()
 {
 }
 
 #endif

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_map>
 
 // Dereference non-dereferenceable iterator.
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     typedef std::unordered_multimap<int, std::string> C;
     C c;
     c.insert(std::make_pair(1, "one"));
     C::iterator i = c.end();
+    try
+    {
         C::value_type j = *i;
         assert(false);
     }
+    catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
     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;
     c.insert(std::make_pair(1, "one"));
     C::iterator i = c.end();
+    try
+    {
         C::value_type j = *i;
         assert(false);
     }
+    catch(int) {}
+    }
 #endif
 }
 
 #else
 
 int main()
 {
 }
 
 #endif

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_map>
 
 // Increment local_iterator past end.
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     typedef std::unordered_multimap<int, std::string> C;
     C c(1);
     C::local_iterator i = c.begin(0);
-    ++i;
+    try
+    {
         ++i;
         assert(false);
     }
+    catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
     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.begin(0);
-    ++i;
+    try
+    {
         ++i;
         assert(false);
     }
+    catch(int) {}
+    }
 #endif
 
 }
 
 #else
 
 int main()
 {
 }
 
 #endif

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_map>
 
 // Dereference non-dereferenceable iterator.
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     typedef std::unordered_multimap<int, std::string> C;
     C c(1);
     C::local_iterator i = c.end(0);
+    try
+    {
         C::value_type j = *i;
         assert(false);
     }
+    catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
     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);
+    try
+    {
         C::value_type j = *i;
         assert(false);
     }
+    catch(int) {}
+    }
 #endif
 }
 
 #else
 
 int main()
 {
 }
 
 #endif

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_set>
 
 // Increment iterator past end.
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <unordered_set>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     typedef int T;
     typedef std::unordered_multiset<T> C;
-    C c(1);
+    C c;
+    c.insert(T());
     C::iterator i = c.begin();
     ++i;
     assert(i == c.end());
+    try
+    {
         ++i;
         assert(false);
     }
+    catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
     typedef int T;
-    typedef std::unordered_multiset<T, min_allocator<T>> C;
-    C c(1);
+    typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
+    C c({T()});
     C::iterator i = c.begin();
     ++i;
     assert(i == c.end());
+    try
+    {
         ++i;
         assert(false);
     }
+    catch(int) {}
+    }
 #endif
 }
 
 #else
 
 int main()
 {
 }
 
 #endif

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_set>
 
 // Dereference non-dereferenceable iterator.
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <unordered_set>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     typedef int T;
     typedef std::unordered_multiset<T> C;
     C c(1);
     C::iterator i = c.end();
+    try
+    {
         T j = *i;
         assert(false);
     }
+    catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
     typedef int T;
-    typedef std::unordered_multiset<T, min_allocator<T>> C;
+    typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
     C c(1);
     C::iterator i = c.end();
+    try
+    {
         T j = *i;
         assert(false);
     }
+    catch(int) {}
+    }
 #endif
 }
 
 #else
 
 int main()
 {
 }
 
 #endif

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_set>
 
 // Increment local_iterator past end.
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <unordered_set>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
-{
+{
     {
     typedef int T;
     typedef std::unordered_multiset<T> C;
     C c(1);
     C::local_iterator i = c.begin(0);
-    ++i;
+    try
+    {
         ++i;
         assert(false);
     }
+    catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
     typedef int T;
-    typedef std::unordered_multiset<T, min_allocator<T>> C;
+    typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
     C c(1);
     C::local_iterator i = c.begin(0);
-    ++i;
+    try
+    {
         ++i;
         assert(false);
     }
+    catch(int) {}
+    }
 #endif
 
 }
 
 #else
 
 int main()
 {
 }
 
 #endif

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_set>
 
 // Dereference non-dereferenceable iterator.
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <unordered_set>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     typedef int T;
     typedef std::unordered_multiset<T> C;
     C c(1);
     C::local_iterator i = c.end(0);
+    try
+    {
         T j = *i;
         assert(false);
     }
+    catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
     typedef int T;
-    typedef std::unordered_multiset<T, min_allocator<T>> C;
+    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);
+    try
+    {
         T j = *i;
         assert(false);
     }
+    catch(int) {}
+    }
 #endif
 }
 
 #else
 
 int main()
 {
 }
 
 #endif

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_set>
 
 // Increment iterator past end.
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <unordered_set>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     typedef int T;
     typedef std::unordered_set<T> C;
-    C c(1);
+    C c;
+    c.insert(1);
     C::iterator i = c.begin();
     ++i;
     assert(i == c.end());
+    try
+    {
         ++i;
         assert(false);
     }
+    catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
     typedef int T;
-    typedef std::unordered_set<T, min_allocator<T>> C;
-    C c(1);
+    typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
+    C c({1});
     C::iterator i = c.begin();
     ++i;
     assert(i == c.end());
+    try
+    {
         ++i;
         assert(false);
     }
+    catch(int) {}
+    }
 #endif
 }
 
 #else
 
 int main()
 {
 }
 
 #endif

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_set>
 
 // Dereference non-dereferenceable iterator.
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <unordered_set>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     typedef int T;
     typedef std::unordered_set<T> C;
     C c(1);
     C::iterator i = c.end();
+    try
+    {
         T j = *i;
         assert(false);
     }
+    catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
     typedef int T;
-    typedef std::unordered_set<T, min_allocator<T>> C;
+    typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
     C c(1);
     C::iterator i = c.end();
+    try
+    {
         T j = *i;
         assert(false);
     }
+    catch(int) {}
+    }
 #endif
 }
 
 #else
 
 int main()
 {
 }
 
 #endif

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_set>
 
 // Increment local_iterator past end.
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <unordered_set>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     typedef int T;
     typedef std::unordered_set<T> C;
     C c(1);
     C::local_iterator i = c.begin(0);
-    ++i;
+    try
+    {
         ++i;
         assert(false);
     }
+    catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
     typedef int T;
-    typedef std::unordered_set<T, min_allocator<T>> C;
+    typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
     C c(1);
     C::local_iterator i = c.begin(0);
-    ++i;
+    try
+    {
         ++i;
         assert(false);
     }
+    catch(int) {}
+    }
 #endif
 
 }
 
 #else
 
 int main()
 {
 }
 
 #endif

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_set>
 
 // Dereference non-dereferenceable iterator.
 
+// UNSUPPORTED: libcpp-no-exceptions
+
 #if _LIBCPP_DEBUG >= 1
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : throw int())
 
 #include <unordered_set>
 #include <cassert>
 #include <iterator>
 #include <exception>
 #include <cstdlib>
 
 #include "min_allocator.h"
 
 int main()
 {
     {
     typedef int T;
     typedef std::unordered_set<T> C;
     C c(1);
     C::local_iterator i = c.end(0);
+    try
+    {
         T j = *i;
         assert(false);
     }
+    catch(int) {}
+    }
 #if TEST_STD_VER >= 11
     {
     typedef int T;
-    typedef std::unordered_set<T, min_allocator<T>> C;
+    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);
+    try
+    {
         T j = *i;
         assert(false);
     }
+    catch(int) {}
+    }
 #endif
 }
 
 #else
 
 int main()
 {
 }
 
 #endif

test/std/containers/unord/unord.set/emplace_hint.pass.cpp

#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
         typedef std::unordered_set<Emplaceable> C;
         typedef C::iterator R;
         C c;
         C::const_iterator e = c.end();
         R r = c.emplace_hint(e);
         assert(c.size() == 1);
         assert(*r == Emplaceable());
 
-        r = c.emplace_hint(e, Emplaceable(5, 6));
+        r = c.emplace_hint(c.end(), Emplaceable(5, 6));
         assert(c.size() == 2);
         assert(*r == Emplaceable(5, 6));
 
         r = c.emplace_hint(r, 5, 6);
         assert(c.size() == 2);
         assert(*r == Emplaceable(5, 6));
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<Emplaceable, std::hash<Emplaceable>,
                       std::equal_to<Emplaceable>, min_allocator<Emplaceable>> C;
         typedef C::iterator R;
         C c;
         C::const_iterator e = c.end();
         R r = c.emplace_hint(e);
         assert(c.size() == 1);
         assert(*r == Emplaceable());
 
-        r = c.emplace_hint(e, Emplaceable(5, 6));
+        r = c.emplace_hint(c.end(), Emplaceable(5, 6));
         assert(c.size() == 2);
         assert(*r == Emplaceable(5, 6));
 
         r = c.emplace_hint(r, 5, 6);
         assert(c.size() == 2);
         assert(*r == Emplaceable(5, 6));
     }
 #endif

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

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
int main()
         typedef C::iterator R;
         typedef C::value_type P;
         C c;
         C::const_iterator e = c.end();
         R r = c.insert(e, P(3.5));
         assert(c.size() == 1);
         assert(*r == 3.5);
 
-        r = c.insert(e, P(3.5));
+        r = c.insert(c.end(), P(3.5));
         assert(c.size() == 1);
         assert(*r == 3.5);
 
-        r = c.insert(e, P(4.5));
+        r = c.insert(c.end(), P(4.5));
         assert(c.size() == 2);
         assert(*r == 4.5);
 
-        r = c.insert(e, P(5.5));
+        r = c.insert(c.end(), P(5.5));
         assert(c.size() == 3);
         assert(*r == 5.5);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<double, std::hash<double>,
                                 std::equal_to<double>, min_allocator<double>> C;
         typedef C::iterator R;
         typedef C::value_type P;
         C c;
         C::const_iterator e = c.end();
         R r = c.insert(e, P(3.5));
         assert(c.size() == 1);
         assert(*r == 3.5);
 
-        r = c.insert(e, P(3.5));
+        r = c.insert(c.end(), P(3.5));
         assert(c.size() == 1);
         assert(*r == 3.5);
 
-        r = c.insert(e, P(4.5));
+        r = c.insert(c.end(), P(4.5));
         assert(c.size() == 2);
         assert(*r == 4.5);
 
-        r = c.insert(e, P(5.5));
+        r = c.insert(c.end(), P(5.5));
         assert(c.size() == 3);
         assert(*r == 5.5);
     }
 #endif
 #if _LIBCPP_DEBUG >= 1
     {
         typedef std::unordered_set<double> C;
         typedef C::iterator R;

test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp

int main()
         R r = c.insert(e, P(3.5));
         assert(c.size() == 1);
         assert(*r == 3.5);
 
         r = c.insert(r, P(3.5));
         assert(c.size() == 1);
         assert(*r == 3.5);
 
-        r = c.insert(e, P(4.5));
+        r = c.insert(c.end(), P(4.5));
         assert(c.size() == 2);
         assert(*r == 4.5);
 
-        r = c.insert(e, P(5.5));
+        r = c.insert(c.end(), P(5.5));
         assert(c.size() == 3);
         assert(*r == 5.5);
     }
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         typedef std::unordered_set<MoveOnly> C;
         typedef C::iterator R;
         typedef MoveOnly P;
         C c;
         C::const_iterator e = c.end();
         R r = c.insert(e, P(3));
         assert(c.size() == 1);
         assert(*r == 3);
 
         r = c.insert(r, P(3));
         assert(c.size() == 1);
         assert(*r == 3);
 
-        r = c.insert(e, P(4));
+        r = c.insert(c.end(), P(4));
         assert(c.size() == 2);
         assert(*r == 4);
 
-        r = c.insert(e, P(5));
+        r = c.insert(c.end(), P(5));
         assert(c.size() == 3);
         assert(*r == 5);
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<double, std::hash<double>,
                                 std::equal_to<double>, min_allocator<double>> C;
         typedef C::iterator R;
         typedef double P;
         C c;
         C::const_iterator e = c.end();
         R r = c.insert(e, P(3.5));
         assert(c.size() == 1);
         assert(*r == 3.5);
 
         r = c.insert(r, P(3.5));
         assert(c.size() == 1);
         assert(*r == 3.5);
 
-        r = c.insert(e, P(4.5));
+        r = c.insert(c.end(), P(4.5));
         assert(c.size() == 2);
         assert(*r == 4.5);
 
-        r = c.insert(e, P(5.5));
+        r = c.insert(c.end(), P(5.5));
         assert(c.size() == 3);
         assert(*r == 5.5);
     }
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     {
         typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
                             std::equal_to<MoveOnly>, min_allocator<MoveOnly>> C;
         typedef C::iterator R;
         typedef MoveOnly P;
         C c;
         C::const_iterator e = c.end();
         R r = c.insert(e, P(3));
         assert(c.size() == 1);
         assert(*r == 3);
 
         r = c.insert(r, P(3));
         assert(c.size() == 1);
         assert(*r == 3);
 
-        r = c.insert(e, P(4));
+        r = c.insert(c.end(), P(4));
         assert(c.size() == 2);
         assert(*r == 4);
 
-        r = c.insert(e, P(5));
+        r = c.insert(c.end(), P(5));
         assert(c.size() == 3);
         assert(*r == 5);
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #if _LIBCPP_DEBUG >= 1
     {
         typedef std::unordered_set<double> C;
         typedef C::iterator R;