[libcxx][test] Attempt to make debug mode tests more bulletproof

[krisb]

Summary

The problem with debug mode tests is that it isn't known which particular
_LIBCPP_ASSERT causes the test to exit, and as shown by
https://reviews.llvm.org/D100029 and 2908eb20ba7 it might be not the
expected one.

This patch implements the appriach suggested by @Quuxplusone in D100029
that allows us to cautch only those _LIBCPP_ASSERTs that are going to be
tested; all others will produce an error.

[ldionne]

Thanks a lot for finding this out and trying to solve it! I think this is way superior to what we did previously, which was very naive indeed. I do have some comments, but I don't see a reason why we wouldn't move forward with this once they are resolved.

libcxx/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp

19 ↗

(On Diff #337874)

Why is this one not like the others? There's a few other files that do that too.

libcxx/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter_iter.pass.cpp

16

Any chance we can fix the issue in this patch or in a patch *before* we land this one?

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

20

Unnecessary break?

libcxx/test/support/debug_macros.h

2

This needs a header guard please!

11

You can #include <cstring> and then use std::strcmp & friends.

13

namespace {
  bool expected_fail = false;
}

Otherwise, we have ODR violations in tests where we compile multiple TUs.

15

You're evaluating x twice, which is wrong if there's a side effect. I suggest:

inline void test_libcpp_assert(bool expr, char const* actual_message, char const* expected_message) {
  if (!result) {                                                                 
    if (::expected_fail && std::strcmp(actual_message, expected_message) == 0) { 
      std::exit(0);                                                              
    } else {                                                                     
      assert(false && "test failed in an unexpected manner");                    
    }                                                                            
  }
}

Then, in the tests, you could use:

#define _LIBCPP_ASSERT(expr, message) ::test_libcpp_assert(expr, message, "Attempted to compare incomparable iterators")

17–20

Actually, another possibility which I think I like even more, is this:

template <typename F>
[[noreturn]] void xfail(F const& f) {
  expected_fail = true;
  f();
  assert(false); 
}

Then, you can call it like

int main(int, char**) {
  typedef std::string C;
  C c(1, '\0');
  C::iterator i = c.end();
  xfail([&i]{ (void*i; });
  return 0;
}

It requires C++11, however I think most of the debug tests already do anyway, so that might be acceptable.

[curdeius]

libcxx/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp

19 ↗

(On Diff #337874)

Isn't it because all those move tests actually check a correct, defined behaviour. I.e. moving a container doesn't invalidate the iterators that pointed to its elements (and IIUC only end iterator is invalidated in this situation but that seems logical)?

21 ↗

(On Diff #337874)

It seems to me that other headers are unnecessary here.

[• Quuxplusone]

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

27–28

You forgot to remove the assert here. (Grep XFAIL(assert for more instances.)

libcxx/test/support/debug_macros.h

13

Even better: static bool.
And it'd be good to name it something that connotes testiness and the fact that it's related to TEST_LIBCPP_ASSERT.
Finally, I suggest that this should actually be a const char * that we set to the expected message; that way, we don't need to redefine _LIBCPP_ASSERT differently in each different test file.

// copyright header
// header guard for "replace_libcpp_assert.h"

// This file must be included before any other files, even "test_macros.h",
// since it affects the contents of <__debug>.

static const char *test_expect_libcpp_assert = 0;
#define _LIBCPP_ASSERT(x, m) do { \
    if (!test_expect_libcpp_assert) { \
      _LIBCPP_ASSERT_IMPL(x, m); \
    } else if (x) { \
    } else if (std::strcmp(m, test_expect_libcpp_assert) == 0) { \
      std::exit(0); \
    } else { \
      _LIBCPP_ASSERT_IMPL(false, m); \
    } \
  } while (0)

Used like this:

// copyright header
#include "replace_libcpp_assert.h"
#include "test_macros.h"
~~~

int main(~~~) {
  C::iterator i = c.begin();
  ++i;
  assert(i == c.end());
  test_expect_libcpp_assert = "Attempted to increment non-incrementable iterator";
  ++i;
  assert(false);
}

17–20

I'm concerned that any variation on XFAIL is too easy to confuse with the notion of an XFAILed test case. Personally I would rather just see these three lines written out in each test case. I show above my suggestion on how to implement that.

[• Quuxplusone]

libcxx/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter_iter.pass.cpp

16

IMHO yes. It seems to be a very straightforwardly missing assertion, circa line 2099 of <list>.

[krisb]

Thank you all for your comments! But before proceeding, I want to ask a question.
It seems we have another approach for debug mode tests that was added in D59166, which I didn't notice before but which looks much better than we have now (except the facts that it is more complicated, has more requirements, and may suffer from the same problem because most tests don't check for the exact assertion just the fact that an assertion happened). So, the question is why the approach from D59166 didn't replace other (I mean the tests which this patch about) debug mode tests? Was the reason in the requirements? Should it finally become the only approach for debug mode tests or it is supposed to coexist with others?

Add @EricWF to help with this.

[krisb]

Address comments, switch to setting debug function instead of redefining _LIBCPP_ASSERT.

libcxx/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp

19 ↗

(On Diff #337874)

As @curdeius correctly mention below these tests are not expected to fail, so basically we do not need to redefine _LIBCPP_ASSERT for them at all. I'll clean this up (forgot about this).

libcxx/test/support/debug_macros.h

13

If to keep these tests in at least as a short-term solution, it may make sense to reuse the logic we already have in __debug/debug.cpp. I didn't notice it early, but it seems to be the best way to handle things. I'll attempt to implement an approach in the next update.

[krisb]

Rebase on main + D100029 + D100592, remove unused typedefs, update after D100728.

[• Quuxplusone]

Rebase on main + D100029 + D100592, remove unused typedefs, update after D100728

My impression was that D100029 was obsolete and should be abandoned, with any remaining bits rolled into D100595.
D100592 looks ready to land whenever you feel like it; I hope it's not blocked on D100029 (and if it is, I suggest you figure out how to extricate it from that dependency).

[ldionne]

libcxx/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp

21 ↗

(On Diff #337874)

Now this makes more sense to me - we just don't want to overwrite the _LIBCPP_ASSERT macro.

However, shouldn't we now rename this test since it's not related to the libc++ debug mode anymore? And while we're at it, maybe we don't need this test anymore if it's already tested in the tests for std::list?

[krisb]

In D100595#2698871, @Quuxplusone wrote:

Rebase on main + D100029 + D100592, remove unused typedefs, update after D100728

My impression was that D100029 was obsolete and should be abandoned, with any remaining bits rolled into D100595.
D100592 looks ready to land whenever you feel like it; I hope it's not blocked on D100029 (and if it is, I suggest you figure out how to extricate it from that dependency).

That's not quite right. D100029 is still actual, as it ensures that the tested containers have at least one element, which seems to be assumed when the tests were written. Otherwise, we would need to adjust the tests to check against empty containers.
D100592 isn't blocked by anything, so I'll land it once the pre-commit tests pass.

libcxx/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp

21 ↗

(On Diff #337874)

It doesn't seem like we have some normal mode tests that check that iterators keep valid after moving. But I think it can still be valuable in debug mode (I mean with -D_LIBCPP_DEBUG=1 defined) as it also checks that debug mode correctly handles cases like this and doesn't trigger any assertions (which would be triggered, for example, if there were two different containers). Does it make sense?

[curdeius]

libcxx/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp

21 ↗

(On Diff #337874)

I think it's important to keep these tests with -D_LIBCPP_DEBUG=1/2 as @krisb indicated because they should pass in debug mode. However, as their purpose isn't clear, it would be wise to add a comment.

[krisb]

Remove two more unused typedefs.

[krisb]

libcxx/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp

21 ↗

(On Diff #337874)

Well, from the perspective of D100866 it looks okay to switch these tests from debug to normal mode, so that 'debug mode tests' are assumed to be only negative tests. But if this is acceptable, I'd prefer to do this in a follow-up patch.

[• Quuxplusone]

libcxx/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp

21 ↗

(On Diff #337874)

I agree: once D100866 lands, these tests won't really have anything to do with a "debug mode." They simply test a property of the move-constructor of std::list (namely iterator non-invalidation), which is mandated by the Standard to work. And then the new buildkite job in D100866 will verify that this property holds both in regular mode and in debug mode.

This test should be removed, and we should add a legitimate test for iterator (and pointer) non-invalidation in-or-alongside these files:

• libcxx/test/std/containers/sequences/list/list.cons/move.pass.cpp
• libcxx/test/std/containers/sequences/list/list.special/swap.pass.cpp

I'm fine with saying that we can do that in a separate PR. However, honestly, I think it'd be good to submit that PR now, get it merged now, and then after that we can update this PR to simply delete this file.
If you really really want to defer that for later, then OK but please add a FIXME comment in this file explaining the situation and pointing at move.pass.cpp and swap.pass.cpp, so that we physically cannot forget about this.

[krisb]

Add FIXMEs to a few db_move.pass.cpp tests to not forget to convert them to regular mode.

[krisb]

libcxx/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp

21 ↗

(On Diff #337874)

Since we have a couple more similar tests that should be checked and converted to regular mode, I'd prefer to do this after D100866 gets landed, so we will be able to run new tests in both regular and debug modes with ease.
Having this, I'd not block this patch by D100866 and focus on issues in debug mode tests first. So, if you okay with this, I'd prefer to add FIXMEs and proceed with other changes from this patch.

[ldionne]

It seems we have another approach for debug mode tests that was added in D59166, which I didn't notice before but which looks much better than we have now (except the facts that it is more complicated, has more requirements, and may suffer from the same problem because most tests don't check for the exact assertion just the fact that an assertion happened). So, the question is why the approach from D59166 didn't replace other (I mean the tests which this patch about) debug mode tests? Was the reason in the requirements? Should it finally become the only approach for debug mode tests or it is supposed to coexist with others?

I think it's just that the work was not finished. I'm fine with this patch as-is, I think it's an improvement. If you want to convert everything to D59166 style, feel free to do it and you'll have my support too.

[ldionne]

@Quuxplusone Please approve once you're ok with that, and the author can ship-it then.

[• Quuxplusone]

LGTM % comments, but I'd like to
(A) wait until either-Kris-or-I have split off the tests-that-really-aren't-debug-mode-tests into a separate PR, and also
(B) see it updated to search-and-replace EXPECTED_FAIL into ASSERT_FAILS_WITH_MESSAGE (or something nicer, if we can find something nicer) and pass buildkite again

libcxx/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp

13–15 ↗

(On Diff #341325)

@krisb: D100866 has landed. Either you or I should make a separate PR for adding these tests as regular-mode tests. (I'm happy to do it. I should probably just do it.) I'd like to do that before landing this one, so that this one can be smaller.

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

35

I notice several of these messages are inconsistently missing the word "a" — "...increment a non-incrementable...". Should we fix them? I say yes.

Orthogonally, I notice there are no matching tests for --i "Attempted to decrement..." Do we care?

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

29–32

Nit: I would prefer not to break the string literal, so that it's easier to grep for. Break the line as

EXPECTED_FAIL(c.insert(e, v),
    "unordered_set::insert(const_iterator, const value_type&) called with an iterator not referring to this unordered_set");

and ignore clang-format's griping.

libcxx/test/support/debug_macros.h

26–32

I think the only remaining controversial point is what to name this macro. I don't really like EXPECTED_FAIL (in that it doesn't start with either ASSERT_ or TEST_, and it still reminds me of XFAIL, and technically it's a reserved identifier because <errno.h>).
I suggest ASSERT_FAILS_WITH_MESSAGE(expr, m) — what do you think of that name, @krisb?

[krisb]

In D100595#2730466, @ldionne wrote:

It seems we have another approach for debug mode tests that was added in D59166, which I didn't notice before but which looks much better than we have now (except the facts that it is more complicated, has more requirements, and may suffer from the same problem because most tests don't check for the exact assertion just the fact that an assertion happened). So, the question is why the approach from D59166 didn't replace other (I mean the tests which this patch about) debug mode tests? Was the reason in the requirements? Should it finally become the only approach for debug mode tests or it is supposed to coexist with others?

I think it's just that the work was not finished. I'm fine with this patch as-is, I think it's an improvement. If you want to convert everything to D59166 style, feel free to do it and you'll have my support too.

I'm still looking at D59166 but despite it's a great way to avoid implementing and maintaining dozens (maybe finally we need hundreds) debug tests, it doesn't look like a convenient way to test debug mode on different platforms, especially exotic ones. I'm thinking about something like a test generator that would create individual test files by a given template; it allows keeping the tests small and easy to understand. But I need more time to investigate options.

libcxx/test/libcxx/containers/sequences/list/list.cons/db_move.pass.cpp

13–15 ↗

(On Diff #341325)

Great! Do you want me to take care of these then or prefer to do it by yourself?

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

35

Good points, thank you!

I notice several of these messages are inconsistently missing the word "a" — "...increment a non-incrementable...". Should we fix them? I say yes.

Yes, and it is definitely better to do before this patch. Are you going to take care of this or want me to fix them?

Orthogonally, I notice there are no matching tests for --i "Attempted to decrement..." Do we care?

I think yes, it would be good to have such tests. Once this patch is landed I'll prepare a follow-up.

libcxx/test/support/debug_macros.h

26–32

ASSERT_FAILS_WITH_MESSAGE(expr, m) is okay to me, but I'd still prefer to start it with EXPECT/EXPECTED. Maybe we can find something better? Here are some options that came to my mind:

EXPECT_ASSERT_FAIL
EXPECT_LIBCPP_ASSERT_FAIL
EXPECT_ASSERT_FAIL_WITH_MESSAGE

EXPECT_DEATH_WITH_MESSAGE
EXPECT_EXIT_WITH_MESSAGE

EXPECTED_ERROR

LIBCPP_ASSERT_FAIL
LIBCPP_ASSERT_FAIL_WITH_MESSAGE

If nothing looks good to you, I'll stay with your variant.

[• Quuxplusone]

libcxx/test/support/debug_macros.h

26–32

I specifically want something that starts either with ASSERT_ or TEST_, for consistency with the other testing macros.
I do see how it's awkward that we want to express that we're "asserting" that "_LIBCPP_ASSERT" "assert-fails" — lots of potential repetition in there, that we're both trying to avoid somehow.

[krisb]

@Quuxplusone , just want to ask, are you going to do smth related to this patch, or prefer me to take care of all the dependencies (like missed articles and db_move tests issue)? Just want to avoid doing the same things twice.

libcxx/test/support/debug_macros.h

26–32

What about something like

TEST_EXIT_WITH_MESSAGE
TEST_ASSERT_FAILURE
TEST_LIBCPP_ASSERT_FAILURE

then?

[• Quuxplusone]

just want to ask, are you going to do smth related to this patch, or prefer me to take care of all the dependencies

Yes, sorry, it's on my to-do list. If we're lucky I'll get to it today. :)

libcxx/test/support/debug_macros.h

26–32

TEST_LIBCPP_ASSERT_FAILURE would be OK by me.
(The competitor is ASSERT_FAILS_WITH_MESSAGE. Either of these two is fine with me.)

[krisb]

Rebased on the top of main.
Extended the approach on all the debug mode tests.
Renamed EXPECTED_FAIL -> TEST_LIBCPP_ASSERT_FAILURE.

[krisb]

Restart tests

[• Quuxplusone]

These tests sure are tedious. :) I may have more comments later, but I figure I should post these for now.

libcxx/test/libcxx/containers/sequences/list/list.modifiers/emplace_db1.pass.cpp

23–36

Could we replace this whole bit with

struct A {
    explicit A(int i, double d) {}
};

libcxx/test/libcxx/containers/sequences/list/list.modifiers/erase_iter_iter_db1.pass.cpp

27–28

std::next (and ditto throughout)

libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_iter_iter_db1.pass.cpp

29–33

Let's make this simply

TEST_LIBCPP_ASSERT_FAILURE(v.insert(v2.cbegin(), a, a+5),
    "list::insert(iterator, range) called with an iterator not referring to this list");

(and remove test_iterators.h)
I see no reason for std::next, N, or cpp17_input_iterator to be involved here.

libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_db1.pass.cpp

26–28

Check me on this, but I'm pretty sure this is testing the wrong thing. It looks like it should be more like

c1.insert(c2.cbegin(), 5, 1)

with a message about an iterator not referring to this list.

libcxx/test/libcxx/containers/sequences/list/list.modifiers/pop_back_db1.pass.cpp

33

Now that we run the regular tests in debug mode (so that non-failing pop_backs are already well tested), we can simplify this test to just

int main(int, char**)
{
    std::list<int> c;
    TEST_LIBCPP_ASSERT_FAILURE(c.pop_back(), "list::pop_back() called on an empty list");

    return 0;
}

libcxx/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_iter.pass.cpp

29

FWIW, the error message here is still missing an article: "referring to the list argument"?
Ditto in "db_splice_pos_list_iter_iter.pass.cpp".

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

24–29

This can be just

int main(int, char**)
{
    std::vector<int> c;
    TEST_LIBCPP_ASSERT_FAILURE(c.back(), "back() called on an empty vector");

    return 0;
}

Please make the substitution throughout this directory, anywhere you see typedef int T; being used trivially.

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

24–30

This test seems the same as the previous...? Ah, I see, this one uses vector<int, min_allocator<int>> instead of vector<int>. However, IMHO we can just kill this test; it's not significantly different from the previous one. I recommend

git rm db_back_2.pass.cpp
git rm db_cback_2.pass.cpp
git rm db_front_2.pass.cpp
git rm db_cfront_2.pass.cpp
git rm db_index_2.pass.cpp
git rm db_cindex_2.pass.cpp

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

23–29

As above:

int main(int, char**)
{
    std::vector<int> c;
    TEST_LIBCPP_ASSERT_FAILURE(c.front(), "front() called on an empty vector");

    return 0;
}

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

29

On these operator[] tests, I'd prefer a non-empty vector: more like

int main(int, char**)
{
    std::vector<int> c(5);
    TEST_LIBCPP_ASSERT_FAILURE(c[5], "vector[] index out of bounds");

    return 0;
}

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

37–41

There's a couple of things wrong here IMHO:

• c2.erase(i1) invalidates iterator i1, so even trying to copy its value into j seems sketchy.
• j is unused.
• c1.erase(i1) uses an invalid iterator; I think it should use a valid iterator.

These issues could all be addressed by doing this:

int main(int, char**)
{
    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+5);
    std::unordered_multimap<int, int> c2(a2, a2+7);
    std::unordered_multimap<int, int>::iterator i1 = c1.begin();
    std::unordered_multimap<int, int>::iterator i2 = c2.begin();
    swap(c1, c2);
    c1.erase(i2);
    TEST_LIBCPP_ASSERT_FAILURE(c1.erase(i1),
        "unordered container erase(iterator) called with an iterator not referring to this container");

    return 0;
}

Ditto on the other unordered containers' db_swap_1 tests.

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/dereference_const_rvalue.pass.cpp

24–25

const std::optional<int> opt = std::nullopt;
Judging from the filename, the const should be there.

[krisb]

Addressed review comments.

[krisb]

libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_db1.pass.cpp

26–28

Agreed

libcxx/test/libcxx/containers/sequences/list/list.modifiers/pop_back_db1.pass.cpp

33

I'd leave this out of the scope of the patch. This patch is already large enough, so I'm not sure this is a good idea to include more NFCs here, especially those that are not closely related to the initial intent of the patch.
Except for the changes for TEST_LIBCPP_ASSERT_FAILURE macro I'd:

• fix correctness issues,
• remove redundant includes (since most became redundant because of this patch),
• simplify whatever within TEST_LIBCPP_ASSERT_FAILURE.

All other improvements/simplifications are good for follow-ups. What do you think?

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

24–30

I'd leave this out of the scope of this patch. We have similar tests for all the containers, and they tested the specific functionality at least at the moment they were added (I haven't checked how things are going now, though).

[• Quuxplusone]

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

24–30

OK. I also realize now that min_allocator uses fancy pointers, so that is probably good to have coverage on. :)

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/op_arrow_const.pass.cpp

24

Nit: remove constexpr here

[krisb]

Rebase & rerun tests.

libcxx/test/libcxx/containers/sequences/deque/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
 //
 //===----------------------------------------------------------------------===//
 
 // <deque>
 
 // pop_back() more than the number of elements in a deque
 
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
+// UNSUPPORTED: libcxx-no-debug-mode
+
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
 
-#include <cstdlib>
 #include <deque>
 
 #include "test_macros.h"
-
+#include "debug_macros.h"
 
 int main(int, char**) {
     std::deque<int> q;
     q.push_back(0);
     q.pop_back();
-    q.pop_back();
-    std::exit(1);
+    TEST_LIBCPP_ASSERT_FAILURE(q.pop_back(), "deque::pop_back called on an empty deque");
 
     return 0;
 }

libcxx/test/libcxx/containers/sequences/list/list.cons/db_copy.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
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // list(list&& c);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
-#include <cstdlib>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     std::list<int> l1;
     l1.push_back(1); l1.push_back(2); l1.push_back(3);
     std::list<int>::iterator i = l1.begin();
     std::list<int> l2 = l1;
-    l2.erase(i);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(l2.erase(i), "list::erase(iterator) called with an iterator not referring to this list");
 
     return 0;
 }

libcxx/test/libcxx/containers/sequences/list/list.modifiers/emplace_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
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // template <class... Args> void emplace(const_iterator p, Args&&... args);
 
 // UNSUPPORTED: c++03
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
-#include <cstdlib>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 class A
 {
     int i_;
     double d_;
 
     A(const A&);
     A& operator=(const A&);
 public:
     A(int i, double d)
         : i_(i), d_(d) {}
 
     int geti() const {return i_;}
     double getd() const {return d_;}
 };
 
 int main(int, char**)
 {
     std::list<A> c1;
     std::list<A> c2;
-    std::list<A>::iterator i = c1.emplace(c2.cbegin(), 2, 3.5);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(c1.emplace(c2.cbegin(), 2, 3.5),
+                               "list::emplace(iterator, args...) called with an iterator not referring to this list");
 
     return 0;
 }

libcxx/test/libcxx/containers/sequences/list/list.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
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // Call erase(const_iterator position) with end()
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
-#include <cassert>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int>::const_iterator i = l1.end();
-    l1.erase(i);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "list::erase(iterator) called with a non-dereferenceable iterator");
 
     return 0;
 }

libcxx/test/libcxx/containers/sequences/list/list.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
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // Call erase(const_iterator position) with iterator from another container
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
-#include <cassert>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int> l2(a1, a1+3);
     std::list<int>::const_iterator i = l2.begin();
-    l1.erase(i);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "list::erase(iterator) called with an iterator not referring to this list");
 
     return 0;
 }

libcxx/test/libcxx/containers/sequences/list/list.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
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // Call erase(const_iterator first, const_iterator last); with first iterator from another container
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
-#include <cassert>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int> l2(a1, a1+3);
-    std::list<int>::iterator i = l1.erase(l2.cbegin(), next(l1.cbegin()));
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l2.cbegin(), next(l1.cbegin())),
+                               "list::erase(iterator, iterator) called with an iterator not referring to this list");
 
     return 0;
 }

libcxx/test/libcxx/containers/sequences/list/list.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
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // Call erase(const_iterator first, const_iterator last); with second iterator from another container
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
-#include <cassert>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int> l2(a1, a1+3);
-    std::list<int>::iterator i = l1.erase(l1.cbegin(), next(l2.cbegin()));
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin(), next(l2.cbegin())),
+                               "list::erase(iterator, iterator) called with an iterator not referring to this list");
 
     return 0;
 }

libcxx/test/libcxx/containers/sequences/list/list.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
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // Call erase(const_iterator first, const_iterator last); with both iterators from another container
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
-#include <cassert>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
     std::list<int> l2(a1, a1+3);
-    std::list<int>::iterator i = l1.erase(l2.cbegin(), next(l2.cbegin()));
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l2.cbegin(), next(l2.cbegin())),
+                               "list::erase(iterator, iterator) called with an iterator not referring to this list");
 
     return 0;
 }

libcxx/test/libcxx/containers/sequences/list/list.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
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // Call erase(const_iterator first, const_iterator last); with a bad range
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
-#include <cassert>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     int a1[] = {1, 2, 3};
     std::list<int> l1(a1, a1+3);
-    std::list<int>::iterator i = l1.erase(next(l1.cbegin()), l1.cbegin());
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(next(l1.cbegin()), l1.cbegin()),
+                               "Attempted to increment a non-incrementable list::const_iterator");
 
     return 0;
 }

libcxx/test/libcxx/containers/sequences/list/list.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
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // template <InputIterator Iter>
 //   iterator insert(const_iterator position, Iter first, Iter last);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
-#include <cstdlib>
-#include <cassert>
 #include "test_macros.h"
 #include "test_iterators.h"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     {
         std::list<int> v(100);
         std::list<int> v2(100);
         int a[] = {1, 2, 3, 4, 5};
         const int N = sizeof(a)/sizeof(a[0]);
-        std::list<int>::iterator i = v.insert(next(v2.cbegin(), 10),
-                                        cpp17_input_iterator<const int*>(a),
-                                       cpp17_input_iterator<const int*>(a+N));
-        assert(false);
+        TEST_LIBCPP_ASSERT_FAILURE(v.insert(next(v2.cbegin(), 10), cpp17_input_iterator<const int*>(a),
+                                            cpp17_input_iterator<const int*>(a + N)),
+                                   "list::insert(iterator, range) called with an iterator not referring to this list");
     }
 
   return 0;
 }

libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_rvalue_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
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // iterator insert(const_iterator position, value_type&& x);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
-#include <cstdlib>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     std::list<int> v1(3);
     std::list<int> v2(3);
-    v1.insert(v2.begin(), 4);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(v1.insert(v2.begin(), 4),
+                               "list::insert(iterator, x) called with an iterator not referring to this list");
 
     return 0;
 }

libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_size_value_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
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // iterator insert(const_iterator position, size_type n, const value_type& x);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
-#include <cstdlib>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     std::list<int> c1(100);
     std::list<int> c2;
-    std::list<int>::iterator i = c1.insert(next(c2.cbegin(), 10), 5, 1);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(c1.insert(next(c2.cbegin(), 10), 5, 1),
+                               "Attempted to increment a non-incrementable list::const_iterator");
 
     return 0;
 }

libcxx/test/libcxx/containers/sequences/list/list.modifiers/insert_iter_value_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
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // iterator insert(const_iterator position, const value_type& x);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
-#include <cstdlib>
-#include <cassert>
 
 #include "test_macros.h"
-
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     std::list<int> v1(3);
     std::list<int> v2(3);
     int i = 4;
-    v1.insert(v2.begin(), i);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(v1.insert(v2.begin(), i),
+                               "list::insert(iterator, x) called with an iterator not referring to this list");
 
     return 0;
 }

libcxx/test/libcxx/containers/sequences/list/list.modifiers/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
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // void pop_back();
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
-#include <cstdlib>
 #include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     int a[] = {1, 2, 3};
     std::list<int> c(a, a+3);
     c.pop_back();
     assert(c == std::list<int>(a, a+2));
     c.pop_back();
     assert(c == std::list<int>(a, a+1));
     c.pop_back();
     assert(c.empty());
-    c.pop_back(); // operation under test
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(c.pop_back(), "list::pop_back() called on an empty list");
 
     return 0;
 }

libcxx/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list.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
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // void splice(const_iterator position, list& x);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
-#include <cstdlib>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     {
         std::list<int> v1(3);
         std::list<int> v2(3);
-        v1.splice(v2.begin(), v2);
-        assert(false);
+        TEST_LIBCPP_ASSERT_FAILURE(v1.splice(v2.begin(), v2),
+                                   "list::splice(iterator, list) called with an iterator not referring to this list");
     }
 
   return 0;
 }

libcxx/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_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
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // void splice(const_iterator position, list<T,Allocator>& x, iterator i);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
-#include <cstdlib>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     {
         std::list<int> v1(3);
         std::list<int> v2(3);
-        v1.splice(v1.begin(), v2, v1.begin());
-        assert(false);
+        TEST_LIBCPP_ASSERT_FAILURE(
+            v1.splice(v1.begin(), v2, v1.begin()),
+            "list::splice(iterator, list, iterator) called with the second iterator not referring to list argument");
     }
 
   return 0;
 }

libcxx/test/libcxx/containers/sequences/list/list.ops/db_splice_pos_list_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
 //
 //===----------------------------------------------------------------------===//
 
 // <list>
 
 // void splice(const_iterator position, list& x, iterator first, iterator last);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <list>
-#include <cstdlib>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     {
-        std::list<int> v1(3);
-        std::list<int> v2(3);
-        v1.splice(v1.begin(), v2, v2.begin(), v1.end());
-        assert(false);
+      TEST_LIBCPP_ASSERT_FAILURE(
+          v1.splice(v1.begin(), v2, v2.begin(), v1.end()),
+          "list::splice(iterator, list, iterator, iterator) called with third iterator not referring to list argument");
     }
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T> C;
   C c(1);
   assert(c.back() == 0);
   c.clear();
-  assert(c.back() == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(c.back(), "back() called on an empty vector");
 
   return 0;
 }

libcxx/test/libcxx/containers/sequences/vector/db_back_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>
 
 // Call back() on empty container.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T, min_allocator<T> > C;
   C c(1);
   assert(c.back() == 0);
   c.clear();
-  assert(c.back() == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(c.back(), "back() called on an empty vector");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T> C;
   const C c;
-  assert(c.back() == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(c.back(), "back() called on an empty vector");
 
   return 0;
 }

libcxx/test/libcxx/containers/sequences/vector/db_cback_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>
 
 // Call back() on empty const container.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T, min_allocator<T> > C;
   const C c;
-  assert(c.back() == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(c.back(), "back() called on an empty vector");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T> C;
   const C c;
-  assert(c.front() == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(c.front(), "front() called on an empty vector");
 
   return 0;
 }

libcxx/test/libcxx/containers/sequences/vector/db_cfront_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>
 
 // Call front() on empty const container.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T, min_allocator<T> > C;
   const C c;
-  assert(c.front() == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(c.front(), "front() called on an empty vector");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 #include "test_macros.h"
 
 int main(int, char**)
 {
     typedef int T;
     typedef std::vector<T> C;
     const C c(1);
     assert(c[0] == 0);
-    assert(c[1] == 0);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(c[1], "vector[] index out of bounds");
 
     return 0;
 }

libcxx/test/libcxx/containers/sequences/vector/db_cindex_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>
 
 // Index const vector out of bounds.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <vector>
 #include <cassert>
 
+#include "debug_macros.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T, min_allocator<T> > C;
   const C c(1);
   assert(c[0] == 0);
-  assert(c[1] == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(c[1], "vector[] index out of bounds");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T> C;
   C c(1);
   assert(c.front() == 0);
   c.clear();
-  assert(c.front() == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(c.front(), "front() called on an empty vector");
 
   return 0;
 }

libcxx/test/libcxx/containers/sequences/vector/db_front_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>
 
 // Call front() on empty container.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T, min_allocator<T> > C;
   C c(1);
   assert(c.front() == 0);
   c.clear();
-  assert(c.front() == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(c.front(), "front() called on an empty vector");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T> C;
   C c(1);
   assert(c[0] == 0);
   c.clear();
-  assert(c[0] == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(c[0], "vector[] index out of bounds");
 
   return 0;
 }

libcxx/test/libcxx/containers/sequences/vector/db_index_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>
 
 // Index vector out of bounds.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T, min_allocator<T> > C;
   C c(1);
   assert(c[0] == 0);
   c.clear();
-  assert(c[0] == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(c[0], "vector[] index out of bounds");
 
   return 0;
 }

libcxx/test/libcxx/containers/sequences/vector/db_iterators_10.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T, min_allocator<T> > C;
   C c1;
   C c2;
-  int i = c1.begin() - c2.begin();
-  (void)i;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(c1.begin() - c2.begin(), "Attempted to subtract incompatible iterators");
 
   return 0;
 }

libcxx/test/libcxx/containers/sequences/vector/db_iterators_11.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T, min_allocator<T> > C;
   C c(1);
   C::iterator i = c.begin();
   assert(i[0] == 0);
-  assert(i[1] == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(i[1], "Attempted to subscript an iterator outside its valid range");
 
   return 0;
 }

libcxx/test/libcxx/containers/sequences/vector/db_iterators_12.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T, min_allocator<T> > C;
   C c(1);
   C::iterator i = c.begin();
   i += 1;
   assert(i == c.end());
   i = c.begin();
-  i += 2;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(i + 2, "Attempted to add/subtract an iterator outside its valid range");
 
   return 0;
 }

libcxx/test/libcxx/containers/sequences/vector/db_iterators_13.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T, min_allocator<T> > C;
   C c(1);
   C::iterator i = c.end();
   --i;
   assert(i == c.begin());
-  --i;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(--i, "Attempted to decrement a non-decrementable iterator");
 
   return 0;
 }

libcxx/test/libcxx/containers/sequences/vector/db_iterators_14.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T, min_allocator<T> > C;
   C c(1);
   C::iterator i = c.begin();
   ++i;
   assert(i == c.end());
-  ++i;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable iterator");
 
   return 0;
 }

libcxx/test/libcxx/containers/sequences/vector/db_iterators_15.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T, min_allocator<T> > C;
   C c(1);
   C::iterator i = c.end();
-  T j = *i;
-  (void)j;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable iterator");
 
   return 0;
 }

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 <.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T> C;
   C c1;
   C c2;
-  bool b = c1.begin() < c2.begin();
-  (void)b;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(c1.begin() < c2.begin(), "Attempted to compare incomparable iterators");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T> C;
   C c1;
   C c2;
-  int i = c1.begin() - c2.begin();
-  (void)i;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(c1.begin() - c2.begin(), "Attempted to subtract incompatible iterators");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T> C;
   C c(1);
   C::iterator i = c.begin();
   assert(i[0] == 0);
-  assert(i[1] == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(i[1], "Attempted to subscript an iterator outside its valid range");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T> C;
   C c(1);
   C::iterator i = c.begin();
   i += 1;
   assert(i == c.end());
   i = c.begin();
-  i += 2;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(i + 2, "Attempted to add/subtract an iterator outside its valid range");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T> C;
   C c(1);
   C::iterator i = c.end();
   --i;
   assert(i == c.begin());
-  --i;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(--i, "Attempted to decrement a non-decrementable iterator");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T> C;
   C c(1);
   C::iterator i = c.begin();
   ++i;
   assert(i == c.end());
-  ++i;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable iterator");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T> C;
   C c(1);
   C::iterator i = c.end();
-  T j = *i;
-  (void)j;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable iterator");
 
   return 0;
 }

libcxx/test/libcxx/containers/sequences/vector/db_iterators_9.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 <.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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 "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef int T;
   typedef std::vector<T, min_allocator<T> > C;
   C c1;
   C c2;
-  bool b = c1.begin() < c2.begin();
-  (void)b;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(c1.begin() < c2.begin(), "Attempted to compare incomparable iterators");
 
   return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
-#include <cstdlib>
 #include <vector>
 
 #include "test_macros.h"
-
+#include "debug_macros.h"
 
 int main(int, char**) {
     std::vector<int> v;
     v.push_back(0);
     v.pop_back();
-    v.pop_back();
-    std::exit(1);
+    TEST_LIBCPP_ASSERT_FAILURE(v.pop_back(), "vector::pop_back called on an empty vector");
 
     return 0;
 }

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

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_map
 
 // size_type bucket_size(size_type n) const
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_map<int, std::string> C;
     C c;
-    (void) c.bucket_size(3);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(c.bucket_size(3), "unordered container::bucket_size(n) called with n >= bucket_count()");
 
     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
 //
 //===----------------------------------------------------------------------===//
 
 // <unordered_map>
 
 // size_type bucket(const key_type& __k) const;
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_map<int, std::string> C;
     C c;
-    (void) c.bucket(3);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(c.bucket(3), "unordered container::bucket(key) called when bucket_count() == 0");
 
     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>
 
 // iterator insert(const_iterator p, const value_type& x);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_map<double, int> C;
-    typedef C::iterator R;
     typedef C::value_type P;
     C c;
     C c2;
     C::const_iterator e = c2.end();
     P v(3.5, 3);
-    R r = c.insert(e, v);
-    assert(false);
+#if TEST_STD_VER < 11
+    TEST_LIBCPP_ASSERT_FAILURE(
+        c.insert(e, v),
+        "unordered_map::insert(const_iterator, const value_type&) called with an iterator not referring to this unordered_map");
+#else
+    TEST_LIBCPP_ASSERT_FAILURE(
+        c.insert(e, v),
+        "unordered_map::insert(const_iterator, value_type&&) called with an iterator not referring to this unordered_map");
+#endif
 
     return 0;
 }

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

 
 // template <class P,
 //           class = typename enable_if<is_convertible<P, value_type>::value>::type>
 //     iterator insert(const_iterator p, P&& x);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        c.insert(e, P(3.5, 3)),
+        "unordered_map::insert(const_iterator, const value_type&) called with an iterator not referring to this unordered_map");
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.map/db_iterators_10.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
-#include <cassert>
-#include <functional>
 #include <string>
-#include <utility>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
     typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                         min_allocator<std::pair<const int, std::string>>> C;
     C c;
     c.insert(std::make_pair(1, "one"));
     C::iterator i = c.end();
-    C::value_type j = *i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container iterator");
 
     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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
 #include <string>
-#include <utility>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_map<int, std::string> C;
     C c;
     c.insert(std::make_pair(1, "one"));
     C::iterator i = c.begin();
     ++i;
     assert(i == c.end());
-    ++i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container iterator");
 
     return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
-#include <cassert>
 #include <string>
-#include <utility>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_map<int, std::string> C;
     C c;
     c.insert(std::make_pair(1, "one"));
     C::iterator i = c.end();
-    C::value_type j = *i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container iterator");
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.map/db_iterators_9.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
-#include <functional>
 #include <string>
-#include <utility>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
     typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                         min_allocator<std::pair<const int, std::string>>> C;
     C c;
     c.insert(std::make_pair(1, "one"));
     C::iterator i = c.begin();
     ++i;
     assert(i == c.end());
-    ++i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container iterator");
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.map/db_local_iterators_10.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
-#include <cassert>
-#include <functional>
 #include <string>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
     typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                         min_allocator<std::pair<const int, std::string>>> C;
     C c(1);
     C::local_iterator i = c.end(0);
-    C::value_type j = *i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container local_iterator");
 
     return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_map<int, std::string> C;
     C c;
     c.insert(std::make_pair(42, std::string()));
     C::size_type b = c.bucket(42);
     C::local_iterator i = c.begin(b);
     assert(i != c.end(b));
     ++i;
     assert(i == c.end(b));
-    ++i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container local_iterator");
 
     return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_map<int, std::string> C;
     C c(1);
     C::local_iterator i = c.end(0);
-    C::value_type j = *i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container local_iterator");
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.map/db_local_iterators_9.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
-#include <cassert>
-#include <functional>
 #include <string>
+#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
     typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
                         min_allocator<std::pair<const int, std::string>>> C;
     C c({{42, std::string()}});
     C::size_type b = c.bucket(42);
     C::local_iterator i = c.begin(b);
     assert(i != c.end(b));
     ++i;
     assert(i == c.end(b));
-    ++i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container local_iterator");
 
     return 0;
 }

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

 //           class Alloc = allocator<pair<const Key, Value>>>
 // class unordered_map
 
 // void swap(unordered_map& x, unordered_map& y);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        c1.erase(i1), "unordered container erase(iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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

 // class unordered_map
 
 // float max_load_factor() const;
 // void max_load_factor(float mlf);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_map<int, std::string> C;
     C c;
-    c.max_load_factor(0);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(c.max_load_factor(0), "unordered container::max_load_factor(lf) called with lf <= 0");
 
     return 0;
 }

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()
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i),
+                               "unordered container erase(iterator) called with a non-dereferenceable iterator");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(i), "unordered container erase(iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l2.cbegin(), next(l1.cbegin())),
+        "unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l1.cbegin(), next(l2.cbegin())),
+        "unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l2.cbegin(), next(l2.cbegin())),
+        "unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(next(l1.cbegin()), l1.cbegin()),
+                               "Attempted to increment a non-incrementable unordered container const_iterator");
 
     return 0;
 }

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

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // size_type bucket(const key_type& __k) const;
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_multimap<int, std::string> C;
     C c;
-    (void) c.bucket(3);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(c.bucket(3), "unordered container::bucket(key) called when bucket_count() == 0");
 
     return 0;
 }

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

 //           class Alloc = allocator<pair<const Key, T>>>
 // class unordered_multimap
 
 // size_type bucket_size(size_type n) const
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_multimap<int, std::string> C;
     C c;
-    (void) c.bucket_size(3);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(c.bucket_size(3), "unordered container::bucket_size(n) called with n >= bucket_count()");
 
     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>
 
 // iterator insert(const_iterator p, const value_type& x);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_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();
     P v(3.5, 3);
-    R r = c.insert(e, v);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        c.insert(e, v),
+        "unordered container::emplace_hint(const_iterator, args...) called with an iterator not referring to this unordered container");
 
     return 0;
 }

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

 
 // template <class P,
 //           class = typename enable_if<is_convertible<P, value_type>::value>::type>
 //     iterator insert(const_iterator p, P&& x);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        c.insert(e, P(3.5, 3)),
+        "unordered container::emplace_hint(const_iterator, args...) called with an iterator not referring to this unordered container");
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.multimap/db_iterators_10.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
-#include <cassert>
-#include <functional>
 #include <string>
 #include <unordered_map>
-#include <utility>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
     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();
-    C::value_type j = *i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container iterator");
 
     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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
 #include <string>
-#include <utility>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     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());
-    ++i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container iterator");
 
     return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
-#include <cassert>
 #include <string>
 #include <unordered_map>
-#include <utility>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_multimap<int, std::string> C;
     C c;
     c.insert(std::make_pair(1, "one"));
     C::iterator i = c.end();
-    C::value_type j = *i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container iterator");
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.multimap/db_iterators_9.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <cassert>
-#include <functional>
 #include <string>
 #include <unordered_map>
-#include <utility>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
     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());
-    ++i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container iterator");
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.multimap/db_local_iterators_10.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
-#include <cassert>
-#include <functional>
 #include <string>
-#include <utility>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
     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);
+    TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container local_iterator");
 
     return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
 #include <string>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_multimap<int, std::string> C;
     C c;
     c.insert(std::make_pair(42, std::string()));
     C::size_type b = c.bucket(42);
     C::local_iterator i = c.begin(b);
     assert(i != c.end(b));
     ++i;
     assert(i == c.end(b));
-    ++i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container local_iterator");
 
     return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
-#include <cassert>
 #include <string>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_multimap<int, std::string> C;
     C c(1);
     C::local_iterator i = c.end(0);
-    C::value_type j = *i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container local_iterator");
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.multimap/db_local_iterators_9.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <cassert>
-#include <functional>
 #include <string>
-#include <utility>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
     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, std::string()}});
     c.insert(std::make_pair(42, std::string()));
     C::size_type b = c.bucket(42);
     C::local_iterator i = c.begin(b);
     assert(i != c.end(b));
     ++i;
     assert(i == c.end(b));
-    ++i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container local_iterator");
 
     return 0;
 }

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

 //           class Alloc = allocator<pair<const Key, Value>>>
 // class unordered_multimap
 
 // void swap(unordered_multimap& x, unordered_multimap& y);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        c1.erase(i1), "unordered container erase(iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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

 // class unordered_multimap
 
 // float max_load_factor() const;
 // void max_load_factor(float mlf);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_map>
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_multimap<int, std::string> C;
     C c;
-    c.max_load_factor(0);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(c.max_load_factor(0), "unordered container::max_load_factor(lf) called with lf <= 0");
 
     return 0;
 }

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()
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i),
+                               "unordered container erase(iterator) called with a non-dereferenceable iterator");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(i), "unordered container erase(iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l2.cbegin(), next(l1.cbegin())),
+        "unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l1.cbegin(), next(l2.cbegin())),
+        "unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l2.cbegin(), next(l2.cbegin())),
+        "unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(next(l1.cbegin()), l1.cbegin()),
+                               "Attempted to increment a non-incrementable unordered container const_iterator");
 
     return 0;
 }

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

 //           class Alloc = allocator<Value>>
 // class unordered_multiset
 
 // size_type bucket(const key_type& __k) const;
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_multiset<int> C;
     C c;
-    (void) c.bucket(3);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(c.bucket(3), "unordered container::bucket(key) called when bucket_count() == 0");
 
     return 0;
 }

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

 //           class Alloc = allocator<Value>>
 // class unordered_multiset
 
 // size_type bucket_size(size_type n) const
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_multiset<int> C;
     C c;
-    (void) c.bucket_size(3);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(c.bucket_size(3), "unordered container::bucket_size(n) called with n >= bucket_count()");
 
     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>
 
 // iterator insert(const_iterator p, const value_type& x);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        c.insert(e, v),
+        "unordered container::emplace_hint(const_iterator, args...) called with an iterator not referring to this unordered container");
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.multiset/db_iterators_10.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
-#include <functional>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
     typedef int T;
     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);
+    TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container const_iterator");
 
     return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef int T;
     typedef std::unordered_multiset<T> C;
     C c;
     c.insert(42);
     C::iterator i = c.begin();
     assert(i != c.end());
     ++i;
     assert(i == c.end());
-    ++i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container const_iterator");
 
     return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef int T;
     typedef std::unordered_multiset<T> C;
     C c(1);
     C::iterator i = c.end();
-    (void) *i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container const_iterator");
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.multiset/db_iterators_9.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
-#include <functional>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
     typedef int T;
     typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
     C c({42});
     C::iterator i = c.begin();
     assert(i != c.end());
     ++i;
     assert(i == c.end());
-    ++i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container const_iterator");
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.multiset/db_local_iterators_10.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
-#include <functional>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
     typedef int T;
     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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        *i, "Attempted to dereference a non-dereferenceable unordered container const_local_iterator");
 
     return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef int T;
     typedef std::unordered_multiset<T> C;
     C c;
     c.insert(42);
     C::size_type b = c.bucket(42);
     C::local_iterator i = c.begin(b);
     assert(i != c.end(b));
     ++i;
     assert(i == c.end(b));
-    ++i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(++i,
+                               "Attempted to increment a non-incrementable unordered container const_local_iterator");
 
     return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef int T;
     typedef std::unordered_multiset<T> C;
     C c(1);
     C::local_iterator i = c.end(0);
-    (void) *i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        *i, "Attempted to dereference a non-dereferenceable unordered container const_local_iterator");
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.multiset/db_local_iterators_9.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
-#include <functional>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
     typedef int T;
     typedef std::unordered_multiset<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
     C c({42});
     C::size_type b = c.bucket(42);
     C::local_iterator i = c.begin(b);
     assert(i != c.end(b));
     ++i;
     assert(i == c.end(b));
-    ++i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(++i,
+                               "Attempted to increment a non-incrementable unordered container const_local_iterator");
 
     return 0;
 }

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

 //           class Alloc = allocator<Value>>
 // class unordered_multiset
 
 // void swap(unordered_multiset& x, unordered_multiset& y);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        c1.erase(i1), "unordered container erase(iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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()
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i),
+                               "unordered container erase(iterator) called with a non-dereferenceable iterator");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(i), "unordered container erase(iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l2.cbegin(), next(l1.cbegin())),
+        "unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l1.cbegin(), next(l2.cbegin())),
+        "unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l2.cbegin(), next(l2.cbegin())),
+        "unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(next(l1.cbegin()), l1.cbegin()),
+                               "Attempted to increment a non-incrementable unordered container const_iterator");
 
     return 0;
 }

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

 // class unordered_multiset
 
 // float max_load_factor() const;
 // void max_load_factor(float mlf);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_multiset<int> C;
     C c;
-    c.max_load_factor(0);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(c.max_load_factor(0), "unordered container::max_load_factor(lf) called with lf <= 0");
 
     return 0;
 }

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

 //           class Alloc = allocator<Value>>
 // class unordered_set
 
 // size_type bucket(const key_type& __k) const;
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_set<int> C;
     C c;
-    (void) c.bucket(3);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(c.bucket(3), "unordered container::bucket(key) called when bucket_count() == 0");
 
     return 0;
 }

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

 //           class Alloc = allocator<Value>>
 // class unordered_set
 
 // size_type bucket_size(size_type n) const
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_set<int> C;
     C c;
-    (void) c.bucket_size(3);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(c.bucket_size(3), "unordered container::bucket_size(n) called with n >= bucket_count()");
 
     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>
 
 // iterator insert(const_iterator p, const value_type& x);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        c.insert(e, v),
+        "unordered_set::insert(const_iterator, const value_type&) called with an iterator not referring to this unordered_set");
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.set/db_iterators_10.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
-#include <functional>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
     typedef int T;
     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);
+    TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container const_iterator");
 
     return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef int T;
     typedef std::unordered_set<T> C;
     C c;
     c.insert(42);
     C::iterator i = c.begin();
     assert(i != c.end());
     ++i;
     assert(i == c.end());
-    ++i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container const_iterator");
 
     return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef int T;
     typedef std::unordered_set<T> C;
     C c(1);
     C::iterator i = c.end();
-    (void) *i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable unordered container const_iterator");
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.set/db_iterators_9.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
-#include <functional>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
     typedef int T;
     typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
     C c({42});
     C::iterator i = c.begin();
     assert(i != c.end());
     ++i;
     assert(i == c.end());
-    ++i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable unordered container const_iterator");
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.set/db_local_iterators_10.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
-#include <functional>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
     typedef int T;
     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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        *i, "Attempted to dereference a non-dereferenceable unordered container const_local_iterator");
 
     return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef int T;
     typedef std::unordered_set<T> C;
     C c;
     c.insert(42);
     C::size_type b = c.bucket(42);
     C::local_iterator i = c.begin(b);
     assert(i != c.end(b));
     ++i;
     assert(i == c.end(b));
-    ++i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(++i,
+                               "Attempted to increment a non-incrementable unordered container const_local_iterator");
 
     return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef int T;
     typedef std::unordered_set<T> C;
     C c(1);
     C::local_iterator i = c.end(0);
-    (void) *i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        *i, "Attempted to dereference a non-dereferenceable unordered container const_local_iterator");
 
     return 0;
 }

libcxx/test/libcxx/containers/unord/unord.set/db_local_iterators_9.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 // UNSUPPORTED: c++03
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
 #include <cassert>
-#include <functional>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
     typedef int T;
     typedef std::unordered_set<T, std::hash<T>, std::equal_to<T>, min_allocator<T>> C;
     C c({42});
     C::size_type b = c.bucket(42);
     C::local_iterator i = c.begin(b);
     assert(i != c.end(b));
     ++i;
     assert(i == c.end(b));
-    ++i;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(++i,
+                               "Attempted to increment a non-incrementable unordered container const_local_iterator");
 
     return 0;
 }

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

 //           class Alloc = allocator<Value>>
 // class unordered_set
 
 // void swap(unordered_set& x, unordered_set& y);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        c1.erase(i1), "unordered container erase(iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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()
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i),
+                               "unordered container erase(iterator) called with a non-dereferenceable iterator");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(i), "unordered container erase(iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l2.cbegin(), next(l1.cbegin())),
+        "unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l1.cbegin(), next(l2.cbegin())),
+        "unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l2.cbegin(), next(l2.cbegin())),
+        "unordered container::erase(iterator, iterator) called with an iterator not referring to this container");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_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);
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(next(l1.cbegin()), l1.cbegin()),
+                               "Attempted to increment a non-incrementable unordered container const_iterator");
 
     return 0;
 }

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

 // class unordered_set
 
 // float max_load_factor() const;
 // void max_load_factor(float mlf);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <unordered_set>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     typedef std::unordered_set<int> C;
     C c;
-    c.max_load_factor(-0.5f);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(c.max_load_factor(-0.5f),
+                               "unordered container::max_load_factor(lf) called with lf <= 0");
 
     return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.access/back.const.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>
 
 // const charT& back() const;
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     std::string const s;
-    (void) s.back();
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
     return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.access/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>
 
 //       charT& back();
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     std::string s;
-    (void) s.back();
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
     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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
   typedef std::string S;
   S s(1, '\0');
   assert(s.back() == 0);
   s.clear();
-  assert(s.back() == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.access/db_back_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>
 
 // Call back() on empty container.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
   S s(1, '\0');
   assert(s.back() == 0);
   s.clear();
-  assert(s.back() == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
   typedef std::string S;
   const S s;
-  assert(s.back() == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.access/db_cback_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>
 
 // Call back() on empty const container.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
+#include "debug_macros.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
   const S s;
-  assert(s.back() == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(s.back(), "string::back(): string is empty");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
   typedef std::string S;
   const S s;
-  assert(s.front() == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.access/db_cfront_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>
 
 // Call front() on empty const container.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
+#include "debug_macros.h"
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
   const S s;
-  assert(s.front() == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
   typedef std::string S;
   const S s;
   assert(s[0] == 0);
-  assert(s[1] == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.access/db_cindex_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>
 
 // Index const string out of bounds.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   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);
+  TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
   typedef std::string S;
   S s(1, '\0');
   assert(s.front() == 0);
   s.clear();
-  assert(s.front() == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.access/db_front_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>
 
 // Call front() on empty container.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
   S s(1, '\0');
   assert(s.front() == 0);
   s.clear();
-  assert(s.front() == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
   typedef std::string S;
   S s;
   assert(s[0] == 0);
-  assert(s[1] == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.access/db_index_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>
 
 // Index string out of bounds.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   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);
+  TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.access/front.const.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>
 
 // const charT& front() const;
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     std::string const s;
-    (void) s.front();
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
 
     return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.access/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>
 
 //       charT& front();
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     std::string s;
-    (void) s.front();
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(s.front(), "string::front(): string is empty");
 
     return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.access/index.const.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>
 
 // const_reference operator[](size_type pos) const;
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     std::string const s;
     char c = s[0];
     assert(c == '\0');
-    c = s[1];
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
 
     return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.access/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>
 
 //       reference operator[](size_type pos);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     std::string s;
     char c = s[0];
     assert(c == '\0');
-    c = s[1];
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(s[1], "string index out of bounds");
 
     return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_10.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 <.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
   S s1;
   S s2;
-  int i = s1.begin() - s2.begin();
-  (void)i;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(s1.begin() - s2.begin(), "Attempted to subtract incompatible iterators");
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_11.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C;
   C c(1, '\0');
   C::iterator i = c.begin();
   assert(i[0] == 0);
-  assert(i[1] == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(i[1], "Attempted to subscript an iterator outside its valid range");
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_12.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C;
   C c(1, '\0');
   C::iterator i = c.begin();
   i += 1;
   assert(i == c.end());
   i = c.begin();
-  i += 2;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(i += 2, "Attempted to add/subtract an iterator outside its valid range");
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_13.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C;
   C c(1, '\0');
   C::iterator i = c.end();
   --i;
   assert(i == c.begin());
-  --i;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(--i, "Attempted to decrement a non-decrementable iterator");
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_14.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > C;
   C c(1, '\0');
   C::iterator i = c.begin();
   ++i;
   assert(i == c.end());
-  ++i;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable iterator");
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_15.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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   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);
+  TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable iterator");
 
   return 0;
 }

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 <.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
   typedef std::string S;
   S s1;
   S s2;
-  bool b = s1.begin() < s2.begin();
-  (void)b;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(s1.begin() < s2.begin(), "Attempted to compare incomparable iterators");
 
   return 0;
 }

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 <.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
   typedef std::string S;
   S s1;
   S s2;
-  int i = s1.begin() - s2.begin();
-  (void)i;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(s1.begin() - s2.begin(), "Attempted to subtract incompatible iterators");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
   typedef std::string C;
   C c(1, '\0');
   C::iterator i = c.begin();
   assert(i[0] == 0);
-  assert(i[1] == 0);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(i[1], "Attempted to subscript an iterator outside its valid range");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
   typedef std::string C;
   C c(1, '\0');
   C::iterator i = c.begin();
   i += 1;
   assert(i == c.end());
   i = c.begin();
-  i += 2;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(i += 2, "Attempted to add/subtract an iterator outside its valid range");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
   typedef std::string C;
   C c(1, '\0');
   C::iterator i = c.end();
   --i;
   assert(i == c.begin());
-  --i;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(--i, "Attempted to decrement a non-decrementable iterator");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
 #include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
   typedef std::string C;
   C c(1, '\0');
   C::iterator i = c.begin();
   ++i;
   assert(i == c.end());
-  ++i;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(++i, "Attempted to increment a non-incrementable iterator");
 
   return 0;
 }

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.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
   typedef std::string C;
   C c(1, '\0');
   C::iterator i = c.end();
-  (void)*i;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(*i, "Attempted to dereference a non-dereferenceable iterator");
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.iterators/db_iterators_9.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 <.
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
-#include <iterator>
-#include <exception>
-#include <cstdlib>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
   S s1;
   S s2;
-  bool b = s1.begin() < s2.begin();
-  (void)b;
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(s1.begin() < s2.begin(), "Attempted to compare incomparable iterators");
 
   return 0;
 }

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()
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     std::string l1("123");
     std::string::const_iterator i = l1.end();
-    l1.erase(i);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "string::erase(iterator) called with a non-dereferenceable iterator");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     std::string l1("123");
     std::string l2("123");
     std::string::const_iterator i = l2.begin();
-    l1.erase(i);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i),
+                               "string::erase(iterator) called with an iterator not referring to this string");
 
     return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_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 position) with end()
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   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);
+  TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i), "string::erase(iterator) called with a non-dereferenceable iterator");
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_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 position) with iterator from another container
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   typedef std::basic_string<char, std::char_traits<char>, min_allocator<char> > S;
   S l1("123");
   S l2("123");
   S::const_iterator i = l2.begin();
-  l1.erase(i);
-  assert(false);
+  TEST_LIBCPP_ASSERT_FAILURE(l1.erase(i),
+                             "string::erase(iterator) called with an iterator not referring to this string");
 
   return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     std::string l1("123");
     std::string l2("123");
-    std::string::iterator i = l1.erase(l2.cbegin(), l1.cbegin()+1);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l2.cbegin(), l1.cbegin() + 1),
+        "string::erase(iterator,  iterator) called with an iterator not referring to this string");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     std::string l1("123");
     std::string l2("123");
-    std::string::iterator i = l1.erase(l1.cbegin(), l2.cbegin()+1);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin(), l2.cbegin() + 1), "Attempted to compare incomparable iterators");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     std::string l1("123");
     std::string l2("123");
-    std::string::iterator i = l1.erase(l2.cbegin(), l2.cbegin()+1);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(
+        l1.erase(l2.cbegin(), l2.cbegin() + 1),
+        "string::erase(iterator,  iterator) called with an iterator not referring to this string");
 
     return 0;
 }

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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_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"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
     std::string l1("123");
-    std::string::iterator i = l1.erase(l1.cbegin()+1, l1.cbegin());
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin() + 1, l1.cbegin()),
+                               "string::erase(first, last) called with invalid range");
 
     return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db5.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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   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);
+  TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l2.cbegin(), l1.cbegin() + 1),
+                             "string::erase(iterator,  iterator) called with an iterator not referring to this string");
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db6.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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   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);
+  TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin(), l2.cbegin() + 1), "Attempted to compare incomparable iterators");
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db7.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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   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);
+  TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin() + 1, l1.cbegin()),
+                             "string::erase(first, last) called with invalid range");
 
   return 0;
 }

libcxx/test/libcxx/strings/basic.string/string.modifiers/erase_iter_iter_db8.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
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**) {
   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);
+  TEST_LIBCPP_ASSERT_FAILURE(l1.erase(l1.cbegin() + 1, l1.cbegin()),
+                             "string::erase(first, last) called with invalid range");
 
   return 0;
 }

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();
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
-    {
-        std::string s;
-        s.pop_back();
-        assert(false);
-    }
+    TEST_LIBCPP_ASSERT_FAILURE(s.pop_back(), "string::pop_back(): string is already empty");
 
     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);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <stdexcept>
-#include <cassert>
 
 #include "test_macros.h"
-
+#include "debug_macros.h"
 
 int main(int, char**)
 {
-    {
-        typedef std::string S;
-        S s;
-        S s2;
-        s.insert(s2.begin(), '1');
-        assert(false);
-    }
+    TEST_LIBCPP_ASSERT_FAILURE(s.insert(s2.begin(), '1'), "Attempted to subtract incompatible iterators");
 
     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>
 
 // template<class InputIterator>
 //   iterator insert(const_iterator p, InputIterator first, InputIterator last);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
-
+#include "debug_macros.h"
 
 int main(int, char**)
 {
-    {
-        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);
-    }
+    TEST_LIBCPP_ASSERT_FAILURE(v.insert(v2.cbegin() + 10, a, a + N),
+                               "Attempted to add/subtract an iterator outside its valid range");
 
     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);
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <string>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**)
 {
-    {
-        std::string s;
-        std::string s2;
-        s.insert(s2.begin(), 1, 'a');
-        assert(false);
-    }
+    TEST_LIBCPP_ASSERT_FAILURE(
+        s.insert(s2.begin(), 1, 'a'),
+        "string::insert(iterator, n, value) called with an iterator not referring to this string");
 
     return 0;
 }

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/dereference.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, c++11, c++14
 // <optional>
 
 // constexpr T& optional<T>::operator*() &;
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <optional>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     std::optional<int> opt;
-    int x = *opt; (void)x;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(*opt, "optional operator* called on a disengaged value");
 
     return 0;
 }

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/dereference_const.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, c++11, c++14
 // <optional>
 
 // constexpr const T& optional<T>::operator*() const &;
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <optional>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     const std::optional<int> opt;
-    int x = *opt; (void)x;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(*opt, "optional operator* called on a disengaged value");
 
     return 0;
 }

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/dereference_const_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, c++11, c++14
 // <optional>
 
 // constexpr T&& optional<T>::operator*() const &&;
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <optional>
-#include <cassert>
-#include <utility>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 int main(int, char**) {
     std::optional<int> opt;
-    int x = *std::move(opt); (void)x;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(*std::move(opt), "optional operator* called on a disengaged value");
 
     return 0;
 }

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/dereference_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, c++11, c++14
 // <optional>
 
 // constexpr T&& optional<T>::operator*() &&;
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <optional>
-#include <cassert>
-#include <utility>
 
 #include "test_macros.h"
-
+#include "debug_macros.h"
 
 int main(int, char**) {
     std::optional<int> opt;
-    int x = *std::move(opt); (void)x;
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(*std::move(opt), "optional operator* called on a disengaged value");
 
     return 0;
 }

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/op_arrow.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, c++11, c++14
 // <optional>
 
 // constexpr T* optional<T>::operator->();
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <optional>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 struct X {
     int test() noexcept {return 3;}
 };
 
 int main(int, char**) {
     std::optional<X> opt;
-    assert(opt->test() == 3);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(opt->test(), "optional operator-> called on a disengaged value");
 
     return 0;
 }

libcxx/test/libcxx/utilities/optional/optional.object/optional.object.observe/op_arrow_const.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, c++11, c++14
 // <optional>
 
 // constexpr const T* optional<T>::operator->() const;
 
 // UNSUPPORTED: libcxx-no-debug-mode
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DEBUG=1
-#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
 
 #include <optional>
-#include <cassert>
 
 #include "test_macros.h"
+#include "debug_macros.h"
 
 struct X {
     constexpr int test() const {return 3;}
 };
 
 int main(int, char**) {
     const std::optional<X> opt;
-    assert(opt->test() == 3);
-    assert(false);
+    TEST_LIBCPP_ASSERT_FAILURE(opt->test(), "optional operator-> called on a disengaged value");
 
     return 0;
 }

libcxx/test/support/debug_macros.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TEST_SUPPORT_DEBUG_MACROS_H
+#define TEST_SUPPORT_DEBUG_MACROS_H
+
+#include <__debug>
+#include <cassert>
+#include <string>
+
+static const char* expected_libcpp_assert_message = 0;
+
+static void test_debug_function(std::__libcpp_debug_info const& info) {
+  if (0 == std::strcmp(info.__msg_, expected_libcpp_assert_message))
+    std::exit(0);
+  std::fprintf(stderr, "%s\n", info.what().c_str());
+  std::abort();
+}
+
+#define TEST_LIBCPP_ASSERT_FAILURE(expr, m)                                                                            \
+  do {                                                                                                                 \
+    ::expected_libcpp_assert_message = m;                                                                              \
+    std::__libcpp_set_debug_function(&::test_debug_function);                                                          \
+    (void)(expr);                                                                                                      \
+    assert(false);                                                                                                     \
+  } while (false)
+
+#endif // TEST_SUPPORT_DEBUG_MACROS_H