[libc++][test] Adds more generic test macros.

[Mordante]

Summary

These macros are intended to replace the macros in rapid-cxx-test.h.

[Mordante]

Fixes CI,

[ldionne]

libcxx/test/support/assert_macros.h

37–38

I would use abort instead of exit -- some platforms can provide abort but can't provide exit, because exit has to be able to terminate the program successfully, which doesn't make sense on some platforms. abort() should be available on more platforms than exit.

41

It would also be nice to avoid mentioning std::cerr here. Would it make sense to pass a file descriptor like stderr to the functor being called so it can use std::fprintf(descriptor, ...) directly?

56–58

I would separate the exit out of the logging function. It would look like this ^.

58–62

67–70

82

Why not define this conditionally to nothing or to test_require? That would allow getting rid of test_libcpp_require above.

90

98

Please fully qualify throughout.

112

I feel that the filesystem order of arguments is clearer: exception type, exception predicate and finally the expression. Not a super strong opinion though.

120

To avoid using a non-reserved name?

[Mordante]

Thanks for the review!

libcxx/test/support/assert_macros.h

41

I don't think it makes sense to provide a descriptor. This should only log messages when an error occurs. Using printf(stderr, ...) instead of std::cerr, probably makes sense.

82

Good point!

120

I wouldn't mind using exception, but we shouldn't use reserved names in our tests. This would break the test when a standard library uses __exception.

[Mordante]

Addresses review comments.

[Mordante]

CI fixes

[Mordante]

CI fixes.

[Mordante]

Rebased and a bit of polishing.

[Mordante]

Rebased on D143203 and added documentation.

[Mordante]

CI fixes.

[Mordante]

Remove fs and unneeded format changes to keep this review to its basics.

[ldionne]

libcxx/docs/TestingLibcxx.rst

153 ↗

(On Diff #495071)

156–158 ↗

(On Diff #495071)

159 ↗

(On Diff #495071)

Etc.. It's less confusing for people if we consistently use paths from the root of the monorepo.

162–163 ↗

(On Diff #495071)

164–169 ↗

(On Diff #495071)

170–172 ↗

(On Diff #495071)

I would avoid documenting that, since it's only useful for frequent contributors and they pretty much already know where to find those. I am a bit worried about some of this information becoming out of date.

228 ↗

(On Diff #495071)

231 ↗

(On Diff #495071)

279 ↗

(On Diff #495071)

282 ↗

(On Diff #495071)

303–309 ↗

(On Diff #495071)

This looks like a footgun to me, I would not provide that. Hiding this sort of mechanism behind a macro seems like a bad idea to me.

I would instead return manually and add a comment. This isn't great, but the real solution would be to have a way to integrate this into lit so that lit can show us the test as being UNSUPPORTED based on a runtime condition, which is a much more involved thing to do.

libcxx/test/support/assert_macros.h

37–38

I don't think you actually need the string overload. That would allow you to drop the header dependency.

[Mordante]

Thanks for the review. I will look at the other comments after testing locally.

libcxx/docs/TestingLibcxx.rst

170–172 ↗

(On Diff #495071)

I'm a bit on the fence. It's indeed most useful for frequent contributors, but not documented makes it harder for new contributors to become frequent contributors. Since I already have a link to libcxx/utils/libcxx/test/format.py it's quite easy to find this directory. So I'll remove it.

303–309 ↗

(On Diff #495071)

As mentioned in our 1:1, this is added as compatibility with the existing rapid tests. As agreed I will remove this and update the test using this macro to use that approach.

[Mordante]

libcxx/test/support/assert_macros.h

37–38

Good catch, you're correct. I also tested the follow-up patches and they keep working when removing the std::string overloads.

[Mordante]

Addresses review comments.

[ldionne]

LGTM, but let's take a look at TEST_VALIDATE_EXCEPTION separately to see if we really want to keep it, and if so, under what form. This is good to commit, we can address it separately.

[Mordante]

In D142808#4133009, @ldionne wrote:

LGTM, but let's take a look at TEST_VALIDATE_EXCEPTION separately to see if we really want to keep it, and if so, under what form. This is good to commit, we can address it separately.

Thanks for the review! Let's discuss it in our next 1:1.

libcxx/test/libcxx/containers/sequences/deque/spare_block_handling.pass.cpp

 
 // <deque>
 
 // Test how deque manages the spare blocks it keeps. The exact values it tests
 // for are not always important, but are sometimes needed to ensure the container
 // resizes or shrinks at the correct time.
 
 #include <deque>
+#include <cassert>
 #include <cstdio>
 #include <memory>
 #include <queue>
 #include <stack>
+#include <string>
+
+//xxx test without localization enable
+
 
 #include "min_allocator.h"
-#include "rapid-cxx-test.h"
+#include "assert_macros.h"
 
 template <class Adaptor>
 struct ContainerAdaptor : public Adaptor {
   using Adaptor::Adaptor;
   typename Adaptor::container_type& GetContainer() { return Adaptor::c; }
 };
 
 template <class Deque>

 };
 static_assert(BlockSize<LargeT>::value == 16, "");
 
 const auto& AllocBytes = malloc_allocator_base::outstanding_bytes;
 
 template <class Deque>
 struct PrintOnFailure {
    explicit PrintOnFailure(Deque const& deque) : deque_(&deque) {}
-
-  ~PrintOnFailure() {
-    if (::rapid_cxx_test::get_reporter().current_failure().type
-        != ::rapid_cxx_test::failure_type::none) {
-      print(*deque_);
-    }
-  }
+   void operator()() const { print(*deque_); }
 private:
   const Deque* deque_;
 
   PrintOnFailure(PrintOnFailure const&) = delete;
 };
 
-TEST_SUITE(deque_spare_tests)
 
-TEST_CASE(push_back) {
+static void push_back() {
   const auto BS = BlockSize<LargeT>::value;
   std::unique_ptr<Deque<LargeT>> dp(new Deque<LargeT>);
   auto& d = *dp;
   PrintOnFailure<Deque<LargeT>> on_fail(d);
 
   // Test nothing is allocated after default construction.
   {
-    TEST_REQUIRE(d.size() == 0);
-    TEST_REQUIRE(d.__capacity() == 0);
-    TEST_REQUIRE(d.__block_count() == 0);
+    TEST_REQUIRE(d.size() == 0, on_fail);
+    TEST_REQUIRE(d.__capacity() == 0, on_fail);
+    TEST_REQUIRE(d.__block_count() == 0, on_fail);
   }
   // First push back allocates one block.
   d.push_back({});
   {
-    TEST_REQUIRE(d.size() == 1);
-    TEST_REQUIRE(d.__front_spare() == 0);
-    TEST_REQUIRE(d.__back_spare() == 14);
-    TEST_REQUIRE(d.__back_spare_blocks() == 0);
-    TEST_REQUIRE(d.__capacity() == BS - 1);
-    TEST_REQUIRE(d.__block_count() == 1);
+    TEST_REQUIRE(d.size() == 1, on_fail);
+    TEST_REQUIRE(d.__front_spare() == 0, on_fail);
+    TEST_REQUIRE(d.__back_spare() == 14, on_fail);
+    TEST_REQUIRE(d.__back_spare_blocks() == 0, on_fail);
+    TEST_REQUIRE(d.__capacity() == BS - 1, on_fail);
+    TEST_REQUIRE(d.__block_count() == 1, on_fail);
   }
 
   d.push_back({});
   {
-    TEST_REQUIRE(d.size() == 2);
-    TEST_REQUIRE(d.__front_spare() == 0);
-    TEST_REQUIRE(d.__back_spare() == 13);
-    TEST_REQUIRE(d.__back_spare_blocks() == 0);
+    TEST_REQUIRE(d.size() == 2, on_fail);
+    TEST_REQUIRE(d.__front_spare() == 0, on_fail);
+    TEST_REQUIRE(d.__back_spare() == 13, on_fail);
+    TEST_REQUIRE(d.__back_spare_blocks() == 0, on_fail);
   }
   // Push back until we need a new block.
   for (int RemainingCap = d.__capacity() - d.size(); RemainingCap >= 0; --RemainingCap)
     d.push_back({});
   {
-    TEST_REQUIRE(d.__block_count() == 2);
-    TEST_REQUIRE(d.__front_spare_blocks() == 0);
-    TEST_REQUIRE(d.__back_spare_blocks() == 0);
-    TEST_REQUIRE(d.__back_spare() == 15);
+    TEST_REQUIRE(d.__block_count() == 2, on_fail);
+    TEST_REQUIRE(d.__front_spare_blocks() == 0, on_fail);
+    TEST_REQUIRE(d.__back_spare_blocks() == 0, on_fail);
+    TEST_REQUIRE(d.__back_spare() == 15, on_fail);
   }
 
   // Remove the only element in the new block. Test that we keep the empty
   // block as a spare.
   d.pop_back();
   {
-    TEST_REQUIRE(d.__block_count() == 2);
-    TEST_REQUIRE(d.__front_spare_blocks() == 0);
-    TEST_REQUIRE(d.__back_spare_blocks() == 1);
-    TEST_REQUIRE(d.__back_spare() == 16);
+    TEST_REQUIRE(d.__block_count() == 2, on_fail);
+    TEST_REQUIRE(d.__front_spare_blocks() == 0, on_fail);
+    TEST_REQUIRE(d.__back_spare_blocks() == 1, on_fail);
+    TEST_REQUIRE(d.__back_spare() == 16, on_fail);
   }
 
   // Pop back again, keep the spare.
   d.pop_back();
   {
-    TEST_REQUIRE(d.__block_count() == 2);
-    TEST_REQUIRE(d.__front_spare() == 0);
-    TEST_REQUIRE(d.__back_spare() == 17);
-    TEST_REQUIRE(d.__back_spare_blocks() == 1);
+    TEST_REQUIRE(d.__block_count() == 2, on_fail);
+    TEST_REQUIRE(d.__front_spare() == 0, on_fail);
+    TEST_REQUIRE(d.__back_spare() == 17, on_fail);
+    TEST_REQUIRE(d.__back_spare_blocks() == 1, on_fail);
   }
 
   dp.reset();
-  TEST_REQUIRE(AllocBytes == 0);
+  TEST_REQUIRE(AllocBytes == 0, on_fail);
 }
 
-TEST_CASE(push_front) {
+static void push_front() {
   std::unique_ptr<Deque<LargeT>> dp(new Deque<LargeT>);
   auto& d = *dp;
   PrintOnFailure<Deque<LargeT>> on_fail(d);
 
   // Test nothing is allocated after default construction.
   {
-    TEST_REQUIRE(d.size() == 0);
-    TEST_REQUIRE(d.__capacity() == 0);
-    TEST_REQUIRE(d.__block_count() == 0);
+    TEST_REQUIRE(d.size() == 0, on_fail);
+    TEST_REQUIRE(d.__capacity() == 0, on_fail);
+    TEST_REQUIRE(d.__block_count() == 0, on_fail);
   }
   // First push front allocates one block, and we start the sequence in the
   // middle.
   d.push_front({});
   {
-    TEST_REQUIRE(d.size() == 1);
-    TEST_REQUIRE(d.__front_spare() == 7);
-    TEST_REQUIRE(d.__back_spare() == 7);
-    TEST_REQUIRE(d.__front_spare_blocks() == 0);
-    TEST_REQUIRE(d.__back_spare_blocks() == 0);
-    TEST_REQUIRE(d.__block_count() == 1);
+    TEST_REQUIRE(d.size() == 1, on_fail);
+    TEST_REQUIRE(d.__front_spare() == 7, on_fail);
+    TEST_REQUIRE(d.__back_spare() == 7, on_fail);
+    TEST_REQUIRE(d.__front_spare_blocks() == 0, on_fail);
+    TEST_REQUIRE(d.__back_spare_blocks() == 0, on_fail);
+    TEST_REQUIRE(d.__block_count() == 1, on_fail);
   }
 
   d.push_front({});
   {
-    TEST_REQUIRE(d.size() == 2);
-    TEST_REQUIRE(d.__front_spare() == 6);
-    TEST_REQUIRE(d.__back_spare() == 7);
-    TEST_REQUIRE(d.__front_spare_blocks() == 0);
-    TEST_REQUIRE(d.__back_spare_blocks() == 0);
+    TEST_REQUIRE(d.size() == 2, on_fail);
+    TEST_REQUIRE(d.__front_spare() == 6, on_fail);
+    TEST_REQUIRE(d.__back_spare() == 7, on_fail);
+    TEST_REQUIRE(d.__front_spare_blocks() == 0, on_fail);
+    TEST_REQUIRE(d.__back_spare_blocks() == 0, on_fail);
   }
   // Push front until we need a new block.
   for (int RemainingCap = d.__front_spare(); RemainingCap >= 0; --RemainingCap)
     d.push_front({});
   {
-    TEST_REQUIRE(d.__block_count() == 2);
-    TEST_REQUIRE(d.__front_spare() == 15);
-    TEST_REQUIRE(d.__back_spare() == 7);
-    TEST_REQUIRE(d.__front_spare_blocks() == 0);
-    TEST_REQUIRE(d.__back_spare_blocks() == 0);
+    TEST_REQUIRE(d.__block_count() == 2, on_fail);
+    TEST_REQUIRE(d.__front_spare() == 15, on_fail);
+    TEST_REQUIRE(d.__back_spare() == 7, on_fail);
+    TEST_REQUIRE(d.__front_spare_blocks() == 0, on_fail);
+    TEST_REQUIRE(d.__back_spare_blocks() == 0, on_fail);
   }
 
   // Remove the only element in the new block. Test that we keep the empty
   // block as a spare.
   d.pop_front();
   {
-    TEST_REQUIRE(d.__block_count() == 2);
-    TEST_REQUIRE(d.__front_spare_blocks() == 1);
-    TEST_REQUIRE(d.__back_spare_blocks() == 0);
-    TEST_REQUIRE(d.__back_spare() == 7);
+    TEST_REQUIRE(d.__block_count() == 2, on_fail);
+    TEST_REQUIRE(d.__front_spare_blocks() == 1, on_fail);
+    TEST_REQUIRE(d.__back_spare_blocks() == 0, on_fail);
+    TEST_REQUIRE(d.__back_spare() == 7, on_fail);
   }
 
   // Pop back again, keep the spare.
   d.pop_front();
   {
-    TEST_REQUIRE(d.__block_count() == 2);
-    TEST_REQUIRE(d.__front_spare_blocks() == 1);
-    TEST_REQUIRE(d.__back_spare() == 7);
+    TEST_REQUIRE(d.__block_count() == 2, on_fail);
+    TEST_REQUIRE(d.__front_spare_blocks() == 1, on_fail);
+    TEST_REQUIRE(d.__back_spare() == 7, on_fail);
   }
 
   dp.reset();
-  TEST_REQUIRE(AllocBytes == 0);
+  TEST_REQUIRE(AllocBytes == 0, on_fail);
 }
 
-TEST_CASE(std_queue) {
+static void std_queue() {
   using D = Deque<LargeT>;
   using Queue = std::queue<LargeT, D>;
   ContainerAdaptor<Queue> CA;
   const D& d = CA.GetContainer();
   Queue &q = CA;
   PrintOnFailure<Deque<LargeT>> on_fail(d);
 
   while (d.__block_count() < 4)
     q.push({});
   {
-    TEST_REQUIRE(d.__block_count() == 4);
-    TEST_REQUIRE(d.__front_spare() == 0);
-    TEST_REQUIRE(d.__back_spare() == 15);
-    TEST_REQUIRE(d.__back_spare_blocks() == 0);
+    TEST_REQUIRE(d.__block_count() == 4, on_fail);
+    TEST_REQUIRE(d.__front_spare() == 0, on_fail);
+    TEST_REQUIRE(d.__back_spare() == 15, on_fail);
+    TEST_REQUIRE(d.__back_spare_blocks() == 0, on_fail);
   }
   while (d.__back_spare()) {
     q.push({});
   }
   {
-    TEST_REQUIRE(d.__block_count() == 4);
-    TEST_REQUIRE(d.__front_spare() == 0);
-    TEST_REQUIRE(d.__back_spare() == 0);
+    TEST_REQUIRE(d.__block_count() == 4, on_fail);
+    TEST_REQUIRE(d.__front_spare() == 0, on_fail);
+    TEST_REQUIRE(d.__back_spare() == 0, on_fail);
   }
   q.pop();
   {
-    TEST_REQUIRE(d.__block_count() == 4);
-    TEST_REQUIRE(d.__front_spare() == 1);
-    TEST_REQUIRE(d.__back_spare() == 0);
+    TEST_REQUIRE(d.__block_count() == 4, on_fail);
+    TEST_REQUIRE(d.__front_spare() == 1, on_fail);
+    TEST_REQUIRE(d.__back_spare() == 0, on_fail);
   }
 
   // Pop until we create a spare block at the front.
   while (d.__front_spare() <= 15)
     q.pop();
 
   {
-    TEST_REQUIRE(d.__block_count() == 4);
-    TEST_REQUIRE(d.__front_spare_blocks() == 1);
-    TEST_REQUIRE(d.__front_spare() == 16);
-    TEST_REQUIRE(d.__back_spare() == 0);
+    TEST_REQUIRE(d.__block_count() == 4, on_fail);
+    TEST_REQUIRE(d.__front_spare_blocks() == 1, on_fail);
+    TEST_REQUIRE(d.__front_spare() == 16, on_fail);
+    TEST_REQUIRE(d.__back_spare() == 0, on_fail);
   }
 
   // Push at the end -- should re-use new spare block at front
   q.push({});
 
   {
-    TEST_REQUIRE(d.__block_count() == 4);
-    TEST_REQUIRE(d.__front_spare_blocks() == 0);
-    TEST_REQUIRE(d.__front_spare() == 0);
-    TEST_REQUIRE(d.__back_spare() == 15);
+    TEST_REQUIRE(d.__block_count() == 4, on_fail);
+    TEST_REQUIRE(d.__front_spare_blocks() == 0, on_fail);
+    TEST_REQUIRE(d.__front_spare() == 0, on_fail);
+    TEST_REQUIRE(d.__back_spare() == 15, on_fail);
   }
   while (!q.empty()) {
     q.pop();
-    TEST_REQUIRE(d.__front_spare_blocks() + d.__back_spare_blocks() <= 2);
+    TEST_REQUIRE(d.__front_spare_blocks() + d.__back_spare_blocks() <= 2, on_fail);
   }
 
   // The empty state has two blocks
   {
-    TEST_REQUIRE(d.__front_spare() == 16);
-    TEST_REQUIRE(d.__back_spare() == 15);
-    TEST_REQUIRE(d.__capacity() == 31);
+    TEST_REQUIRE(d.__front_spare() == 16, on_fail);
+    TEST_REQUIRE(d.__back_spare() == 15, on_fail);
+    TEST_REQUIRE(d.__capacity() == 31, on_fail);
   }
 }
 
-TEST_CASE(pop_front_push_back) {
+static void pop_front_push_back() {
   Deque<char> d(32 * 1024, 'a');
   bool take_from_front = true;
   while (d.size() > 0) {
     if (take_from_front) {
       d.pop_front();
       take_from_front = false;
     } else {
       d.pop_back();
       take_from_front = true;
     }
     if (d.size() % 1000 == 0 || d.size() < 50) {
       print(d);
     }
   }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+  push_back();
+  push_front();
+  std_queue();
+  pop_front_push_back();
+
+  return 0;
+}

libcxx/test/libcxx/input.output/filesystems/class.directory_entry/directory_entry.mods/last_write_time.pass.cpp

 
 // class directory_entry
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 #include "filesystem_common.h"
 
 using namespace fs::detail;
 
-TEST_SUITE(directory_entry_mods_suite)
-
-TEST_CASE(last_write_time_not_representable_error) {
+static void last_write_time_not_representable_error() {
   using namespace fs;
   using namespace std::chrono;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
 
   TimeSpec ToTime;
   ToTime.tv_sec = std::numeric_limits<decltype(ToTime.tv_sec)>::max();
   ToTime.tv_nsec = duration_cast<nanoseconds>(seconds(1)).count() - 1;
 
   std::array<TimeSpec, 2> TS = {ToTime, ToTime};
 
   file_time_type old_time = last_write_time(file);
   directory_entry ent(file);
 
   file_time_type start_time = file_time_type::clock::now() - hours(1);
   last_write_time(file, start_time);
 
-  TEST_CHECK(ent.last_write_time() == old_time);
+  assert(ent.last_write_time() == old_time);
 
   bool IsRepresentable = true;
   file_time_type rep_value;
   {
     std::error_code ec;
-    TEST_REQUIRE(!set_file_times(file, TS, ec));
+    assert(!set_file_times(file, TS, ec));
     ec.clear();
     rep_value = last_write_time(file, ec);
     IsRepresentable = !bool(ec);
   }
 
   if (!IsRepresentable) {
     std::error_code rec = GetTestEC();
     ent.refresh(rec);
-    TEST_CHECK(!rec);
+    assert(!rec);
 
     const std::errc expected_err = std::errc::value_too_large;
 
     std::error_code ec = GetTestEC();
-    TEST_CHECK(ent.last_write_time(ec) == file_time_type::min());
-    TEST_CHECK(ErrorIs(ec, expected_err));
+    assert(ent.last_write_time(ec) == file_time_type::min());
+    assert(ErrorIs(ec, expected_err));
 
     ec = GetTestEC();
-    TEST_CHECK(last_write_time(file, ec) == file_time_type::min());
-    TEST_CHECK(ErrorIs(ec, expected_err));
+    assert(last_write_time(file, ec) == file_time_type::min());
+    assert(ErrorIs(ec, expected_err));
 
     ExceptionChecker CheckExcept(file, expected_err,
                                  "directory_entry::last_write_time");
-    TEST_CHECK_THROW_RESULT(filesystem_error, CheckExcept,
+    TEST_VALIDATE_EXCEPTION(filesystem_error, CheckExcept,
                             ent.last_write_time());
 
   } else {
     ent.refresh();
 
     std::error_code ec = GetTestEC();
-    TEST_CHECK(ent.last_write_time(ec) == rep_value);
-    TEST_CHECK(!ec);
+    assert(ent.last_write_time(ec) == rep_value);
+    assert(!ec);
   }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+  last_write_time_not_representable_error();
+
+  return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/copy.pass.cpp

 
 // directory_entry(const directory_entry&) = default;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 #include "test_convertible.h"
 
-TEST_SUITE(directory_entry_path_ctor_suite)
-
-TEST_CASE(copy_ctor) {
+static void copy_ctor() {
   using namespace fs;
   // Copy
   {
     static_assert(std::is_copy_constructible<directory_entry>::value,
                   "directory_entry must be copy constructible");
     static_assert(!std::is_nothrow_copy_constructible<directory_entry>::value,
                   "directory_entry's copy constructor cannot be noexcept");
     const path p("foo/bar/baz");
     const directory_entry e(p);
     assert(e.path() == p);
     directory_entry e2(e);
     assert(e.path() == p);
     assert(e2.path() == p);
   }
 }
 
-TEST_CASE(copy_ctor_copies_cache) {
+static void copy_ctor_copies_cache() {
   using namespace fs;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path sym = env.create_symlink("dir/file", "sym");
 
   {
     directory_entry ent(sym);
 
     fs::remove(sym);
 
     directory_entry ent_cp(ent);
-    TEST_CHECK(ent_cp.path() == sym);
-    TEST_CHECK(ent_cp.is_symlink());
+    assert(ent_cp.path() == sym);
+    assert(ent_cp.is_symlink());
   }
 
   {
     directory_entry ent(file);
 
     fs::remove(file);
 
     directory_entry ent_cp(ent);
-    TEST_CHECK(ent_cp.path() == file);
-    TEST_CHECK(ent_cp.is_regular_file());
+    assert(ent_cp.path() == file);
+    assert(ent_cp.is_regular_file());
   }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+  copy_ctor();
+  copy_ctor_copies_cache();
+
+  return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/copy_assign.pass.cpp

 // void assign(path const&);
 // void replace_filename(path const&);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
-TEST_SUITE(directory_entry_ctor_suite)
-
-TEST_CASE(test_copy_assign_operator) {
+static void test_copy_assign_operator() {
   using namespace fs;
   // Copy
   {
     static_assert(std::is_copy_assignable<directory_entry>::value,
                   "directory_entry must be copy assignable");
     static_assert(!std::is_nothrow_copy_assignable<directory_entry>::value,
                   "directory_entry's copy assignment cannot be noexcept");
     const path p("foo/bar/baz");
     const path p2("abc");
     const directory_entry e(p);
     directory_entry e2;
     assert(e.path() == p && e2.path() == path());
     e2 = e;
     assert(e.path() == p && e2.path() == p);
     directory_entry e3(p2);
     e2 = e3;
     assert(e2.path() == p2 && e3.path() == p2);
   }
 }
 
-TEST_CASE(copy_assign_copies_cache) {
+static void copy_assign_copies_cache() {
   using namespace fs;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path sym = env.create_symlink("dir/file", "sym");
 
   {
     directory_entry ent(sym);
 
     fs::remove(sym);
 
     directory_entry ent_cp;
     ent_cp = ent;
-    TEST_CHECK(ent_cp.path() == sym);
-    TEST_CHECK(ent_cp.is_symlink());
+    assert(ent_cp.path() == sym);
+    assert(ent_cp.is_symlink());
   }
 
   {
     directory_entry ent(file);
 
     fs::remove(file);
 
     directory_entry ent_cp;
     ent_cp = ent;
-    TEST_CHECK(ent_cp.path() == file);
-    TEST_CHECK(ent_cp.is_regular_file());
+    assert(ent_cp.path() == file);
+    assert(ent_cp.is_regular_file());
   }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+  test_copy_assign_operator();
+  copy_assign_copies_cache();
+
+  return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/move.pass.cpp

 
 // directory_entry(directory_entry&&) noexcept = default;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 #include "test_convertible.h"
 
-TEST_SUITE(directory_entry_path_ctor_suite)
-
-TEST_CASE(move_ctor) {
+static void move_ctor() {
   using namespace fs;
   // Move
   {
     static_assert(std::is_nothrow_move_constructible<directory_entry>::value,
                   "directory_entry must be nothrow move constructible");
     const path p("foo/bar/baz");
     directory_entry e(p);
     assert(e.path() == p);
     directory_entry e2(std::move(e));
     assert(e2.path() == p);
     assert(e.path() != p); // Testing moved from state.
   }
 }
 
-TEST_CASE(move_ctor_copies_cache) {
+static void move_ctor_copies_cache() {
   using namespace fs;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path sym = env.create_symlink("dir/file", "sym");
 
   {
     directory_entry ent(sym);
 
     fs::remove(sym);
 
     directory_entry ent_cp(std::move(ent));
-    TEST_CHECK(ent_cp.path() == sym);
-    TEST_CHECK(ent_cp.is_symlink());
+    assert(ent_cp.path() == sym);
+    assert(ent_cp.is_symlink());
   }
 
   {
     directory_entry ent(file);
 
     fs::remove(file);
 
     directory_entry ent_cp(std::move(ent));
-    TEST_CHECK(ent_cp.path() == file);
-    TEST_CHECK(ent_cp.is_regular_file());
+    assert(ent_cp.path() == file);
+    assert(ent_cp.is_regular_file());
   }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+  move_ctor();
+  move_ctor_copies_cache();
+
+  return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/move_assign.pass.cpp

 // void assign(path const&);
 // void replace_filename(path const&);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
-TEST_SUITE(directory_entry_ctor_suite)
-
-TEST_CASE(test_move_assign_operator) {
+static void test_move_assign_operator() {
   using namespace fs;
   // Copy
   {
     static_assert(std::is_nothrow_move_assignable<directory_entry>::value,
                   "directory_entry is noexcept move assignable");
     const path p("foo/bar/baz");
     const path p2("abc");
     directory_entry e(p);
     directory_entry e2(p2);
     assert(e.path() == p && e2.path() == p2);
     e2 = std::move(e);
     assert(e2.path() == p);
     assert(e.path() != p); // testing moved from state
   }
 }
 
-TEST_CASE(move_assign_copies_cache) {
+static void move_assign_copies_cache() {
   using namespace fs;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path sym = env.create_symlink("dir/file", "sym");
 
   {
     directory_entry ent(sym);
 
     fs::remove(sym);
 
     directory_entry ent_cp;
     ent_cp = std::move(ent);
-    TEST_CHECK(ent_cp.path() == sym);
-    TEST_CHECK(ent_cp.is_symlink());
+    assert(ent_cp.path() == sym);
+    assert(ent_cp.is_symlink());
   }
 
   {
     directory_entry ent(file);
 
     fs::remove(file);
 
     directory_entry ent_cp;
     ent_cp = std::move(ent);
-    TEST_CHECK(ent_cp.path() == file);
-    TEST_CHECK(ent_cp.is_regular_file());
+    assert(ent_cp.path() == file);
+    assert(ent_cp.is_regular_file());
   }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+  test_move_assign_operator();
+  move_assign_copies_cache();
+
+  return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.cons/path.pass.cpp

 // explicit directory_entry(const path);
 // directory_entry(const path&, error_code& ec);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 #include "test_convertible.h"
 
-TEST_SUITE(directory_entry_path_ctor_suite)
-
-TEST_CASE(path_ctor) {
+static void path_ctor() {
   using namespace fs;
   {
     static_assert(std::is_constructible<directory_entry, const path&>::value,
                   "directory_entry must be constructible from path");
     static_assert(
         !std::is_nothrow_constructible<directory_entry, const path&>::value,
         "directory_entry constructor should not be noexcept");
     static_assert(!std::is_convertible<path const&, directory_entry>::value,
                   "directory_entry constructor should be explicit");
   }
   {
     const path p("foo/bar/baz");
     const directory_entry e(p);
-    TEST_CHECK(e.path() == p);
+    assert(e.path() == p);
   }
 }
 
-TEST_CASE(path_ec_ctor) {
+static void path_ec_ctor() {
   static_test_env static_env;
   using namespace fs;
   {
     static_assert(
         std::is_constructible<directory_entry, const path&,
                               std::error_code&>::value,
         "directory_entry must be constructible from path and error_code");
     static_assert(!std::is_nothrow_constructible<directory_entry, const path&,
                                                  std::error_code&>::value,
                   "directory_entry constructor should not be noexcept");
     static_assert(
         test_convertible<directory_entry, const path&, std::error_code&>(),
         "directory_entry constructor should not be explicit");
   }
   {
     std::error_code ec = GetTestEC();
     const directory_entry e(static_env.File, ec);
-    TEST_CHECK(e.path() == static_env.File);
-    TEST_CHECK(!ec);
+    assert(e.path() == static_env.File);
+    assert(!ec);
   }
   {
     const path p("foo/bar/baz");
     std::error_code ec = GetTestEC();
     const directory_entry e(p, ec);
-    TEST_CHECK(e.path() == p);
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(e.path() == p);
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
   }
 }
 
-TEST_CASE(path_ctor_calls_refresh) {
+static void path_ctor_calls_refresh() {
   using namespace fs;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path sym = env.create_symlink("dir/file", "sym");
 
   {
     directory_entry ent(file);
     std::error_code ec = GetTestEC();
     directory_entry ent_ec(file, ec);
-    TEST_CHECK(!ec);
+    assert(!ec);
 
     LIBCPP_ONLY(remove(file));
 
-    TEST_CHECK(ent.exists());
-    TEST_CHECK(ent_ec.exists());
+    assert(ent.exists());
+    assert(ent_ec.exists());
 
-    TEST_CHECK(ent.file_size() == 42);
-    TEST_CHECK(ent_ec.file_size() == 42);
+    assert(ent.file_size() == 42);
+    assert(ent_ec.file_size() == 42);
   }
 
   env.create_file("dir/file", 101);
 
   {
     directory_entry ent(sym);
     std::error_code ec = GetTestEC();
     directory_entry ent_ec(sym, ec);
-    TEST_CHECK(!ec);
+    assert(!ec);
 
     LIBCPP_ONLY(remove(file));
     LIBCPP_ONLY(remove(sym));
 
-    TEST_CHECK(ent.is_symlink());
-    TEST_CHECK(ent_ec.is_symlink());
+    assert(ent.is_symlink());
+    assert(ent_ec.is_symlink());
 
-    TEST_CHECK(ent.is_regular_file());
-    TEST_CHECK(ent_ec.is_regular_file());
+    assert(ent.is_regular_file());
+    assert(ent_ec.is_regular_file());
 
-    TEST_CHECK(ent.file_size() == 101);
-    TEST_CHECK(ent_ec.file_size() == 101);
+    assert(ent.file_size() == 101);
+    assert(ent_ec.file_size() == 101);
   }
 }
 
-TEST_CASE(path_ctor_dne) {
+static void path_ctor_dne() {
   using namespace fs;
 
   static_test_env static_env;
 
   {
     std::error_code ec = GetTestEC();
     directory_entry ent(static_env.DNE, ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
-    TEST_CHECK(ent.path() == static_env.DNE);
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(ent.path() == static_env.DNE);
   }
   // don't report dead symlinks as an error.
   {
     std::error_code ec = GetTestEC();
     directory_entry ent(static_env.BadSymlink, ec);
-    TEST_CHECK(!ec);
-    TEST_CHECK(ent.path() == static_env.BadSymlink);
+    assert(!ec);
+    assert(ent.path() == static_env.BadSymlink);
   }
   // DNE does not cause the constructor to throw
   {
     directory_entry ent(static_env.DNE);
-    TEST_CHECK(ent.path() == static_env.DNE);
+    assert(ent.path() == static_env.DNE);
 
     directory_entry ent_two(static_env.BadSymlink);
-    TEST_CHECK(ent_two.path() == static_env.BadSymlink);
+    assert(ent_two.path() == static_env.BadSymlink);
   }
 }
 
-TEST_CASE(path_ctor_cannot_resolve) {
+static void path_ctor_cannot_resolve() {
   using namespace fs;
 #ifdef _WIN32
   // Windows doesn't support setting perms::none to trigger failures
   // reading directories; test using a special inaccessible directory
   // instead.
   const path dir = GetWindowsInaccessibleDir();
   if (dir.empty())
-    TEST_UNSUPPORTED();
+    TEST_IS_UNSUPPORTED();
   const path file = dir / "file";
   {
     std::error_code ec = GetTestEC();
     directory_entry ent(file, ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
-    TEST_CHECK(ent.path() == file);
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(ent.path() == file);
   }
   {
-    TEST_CHECK_NO_THROW(directory_entry(file));
+    TEST_DOES_NOT_THROW(directory_entry(file));
   }
 #else
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path file_out_of_dir = env.create_file("file1", 101);
   const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
   const path sym_in_dir = env.create_symlink("dir/file1", "dir/sym2");
   permissions(dir, perms::none);
 
   {
     std::error_code ec = GetTestEC();
     directory_entry ent(file, ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
-    TEST_CHECK(ent.path() == file);
+    assert(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.path() == file);
   }
   {
     std::error_code ec = GetTestEC();
     directory_entry ent(sym_in_dir, ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
-    TEST_CHECK(ent.path() == sym_in_dir);
+    assert(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.path() == sym_in_dir);
   }
   {
     std::error_code ec = GetTestEC();
     directory_entry ent(sym_out_of_dir, ec);
-    TEST_CHECK(!ec);
-    TEST_CHECK(ent.path() == sym_out_of_dir);
+    assert(!ec);
+    assert(ent.path() == sym_out_of_dir);
   }
   {
-    TEST_CHECK_NO_THROW(directory_entry(file));
-    TEST_CHECK_NO_THROW(directory_entry(sym_in_dir));
-    TEST_CHECK_NO_THROW(directory_entry(sym_out_of_dir));
+    TEST_DOES_NOT_THROW(directory_entry(file));
+    TEST_DOES_NOT_THROW(directory_entry(sym_in_dir));
+    TEST_DOES_NOT_THROW(directory_entry(sym_out_of_dir));
   }
 #endif
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+  path_ctor();
+  path_ec_ctor();
+  path_ctor_calls_refresh();
+  path_ctor_dne();
+  path_ctor_cannot_resolve();
+
+  return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/assign.pass.cpp

 // void assign(path const&);
 // void replace_filename(path const&);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
-TEST_SUITE(directory_entry_mods_suite)
-
-TEST_CASE(test_path_assign_method) {
+static void test_path_assign_method() {
   using namespace fs;
   const path p("foo/bar/baz");
   const path p2("abc");
   directory_entry e(p);
   {
     static_assert(std::is_same<decltype(e.assign(p)), void>::value,
                   "return type should be void");
     static_assert(noexcept(e.assign(p)) == false,
                   "operation must not be noexcept");
   }
   {
-    TEST_CHECK(e.path() == p);
+    assert(e.path() == p);
     e.assign(p2);
-    TEST_CHECK(e.path() == p2 && e.path() != p);
+    assert(e.path() == p2 && e.path() != p);
     e.assign(p);
-    TEST_CHECK(e.path() == p && e.path() != p2);
+    assert(e.path() == p && e.path() != p2);
   }
 }
 
-TEST_CASE(test_path_assign_ec_method) {
+static void test_path_assign_ec_method() {
   using namespace fs;
   const path p("foo/bar/baz");
   const path p2("abc");
   {
     std::error_code ec;
     directory_entry e(p);
     static_assert(std::is_same<decltype(e.assign(p, ec)), void>::value,
                   "return type should be void");
     static_assert(noexcept(e.assign(p, ec)) == false,
                   "operation must not be noexcept");
   }
   {
     directory_entry ent(p);
     std::error_code ec = GetTestEC();
     ent.assign(p2, ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
-    TEST_CHECK(ent.path() == p2);
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(ent.path() == p2);
   }
 }
 
-TEST_CASE(test_assign_calls_refresh) {
+static void test_assign_calls_refresh() {
   using namespace fs;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path sym = env.create_symlink("dir/file", "sym");
 
   {
     directory_entry ent;
     ent.assign(file);
 
     // removing the file demonstrates that the values where cached previously.
     LIBCPP_ONLY(remove(file));
 
-    TEST_CHECK(ent.is_regular_file());
+    assert(ent.is_regular_file());
   }
   env.create_file("dir/file", 101);
   {
     directory_entry ent;
     ent.assign(sym);
 
     LIBCPP_ONLY(remove(file));
     LIBCPP_ONLY(remove(sym));
 
-    TEST_CHECK(ent.is_symlink());
-    TEST_CHECK(ent.is_regular_file());
+    assert(ent.is_symlink());
+    assert(ent.is_regular_file());
   }
 }
 
-TEST_CASE(test_assign_propagates_error) {
+static void test_assign_propagates_error() {
   using namespace fs;
   scoped_test_env env;
 #ifdef _WIN32
   // Windows doesn't support setting perms::none to trigger failures
   // reading directories; test using a special inaccessible directory
   // instead.
   const path dir = GetWindowsInaccessibleDir();
   if (dir.empty())
-    TEST_UNSUPPORTED();
+    TEST_IS_UNSUPPORTED();
   const path file = dir / "inaccessible_file";
   // We can't create files in the inaccessible directory, so this doesn't
   // test exactly the same as the code below.
   const path sym_out_of_dir = env.create_symlink(file, "sym");
   {
     directory_entry ent;
     std::error_code ec = GetTestEC();
     ent.assign(file, ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
   }
 #else
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
   const path file_out_of_dir = env.create_file("file1");
   const path sym_in_dir = env.create_symlink("file1", "dir/sym1");
 
   permissions(dir, perms::none);
 
   {
     directory_entry ent;
     std::error_code ec = GetTestEC();
     ent.assign(file, ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ErrorIs(ec, std::errc::permission_denied));
   }
   {
     directory_entry ent;
     std::error_code ec = GetTestEC();
     ent.assign(sym_in_dir, ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ErrorIs(ec, std::errc::permission_denied));
   }
 #endif
   {
     directory_entry ent;
     std::error_code ec = GetTestEC();
     ent.assign(sym_out_of_dir, ec);
-    TEST_CHECK(!ec);
+    assert(!ec);
   }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+  test_path_assign_method();
+  test_path_assign_ec_method();
+  test_assign_calls_refresh();
+  test_assign_propagates_error();
+
+  return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/refresh.pass.cpp

 // void assign(path const&);
 // void replace_filename(path const&);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
-TEST_SUITE(directory_entry_mods_suite)
-
-TEST_CASE(test_refresh_method) {
+static void test_refresh_method() {
   using namespace fs;
   {
     directory_entry e;
     static_assert(noexcept(e.refresh()) == false,
                   "operation cannot be noexcept");
     static_assert(std::is_same<decltype(e.refresh()), void>::value,
                   "operation must return void");
   }
   {
     directory_entry e;
     e.refresh();
-    TEST_CHECK(!e.exists());
+    assert(!e.exists());
   }
 }
 
-TEST_CASE(test_refresh_ec_method) {
+static void test_refresh_ec_method() {
   using namespace fs;
   {
     directory_entry e;
     std::error_code ec;
     static_assert(noexcept(e.refresh(ec)), "operation should be noexcept");
     static_assert(std::is_same<decltype(e.refresh(ec)), void>::value,
                   "operation must return void");
   }
   {
     directory_entry e;
     std::error_code ec = GetTestEC();
     e.refresh(ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
   }
 }
 
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
 // Windows doesn't support setting perms::none to trigger failures
 // reading directories.
-TEST_CASE(refresh_on_file_dne) {
+static void refresh_on_file_dne() {
   using namespace fs;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
 
   const perms old_perms = status(dir).permissions();
 
   // test file doesn't exist
   {
     directory_entry ent(file);
     remove(file);
-    TEST_CHECK(ent.exists());
+    assert(ent.exists());
 
     ent.refresh();
 
     permissions(dir, perms::none);
-    TEST_CHECK(!ent.exists());
+    assert(!ent.exists());
   }
   permissions(dir, old_perms);
   env.create_file("dir/file", 101);
   {
     directory_entry ent(file);
     remove(file);
-    TEST_CHECK(ent.exists());
+    assert(ent.exists());
 
     std::error_code ec = GetTestEC();
     ent.refresh(ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     permissions(dir, perms::none);
-    TEST_CHECK(!ent.exists());
+    assert(!ent.exists());
   }
 }
-#endif
+#endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
 
 void remove_if_exists(const fs::path& p) {
   std::error_code ec;
   remove(p, ec);
 }
 
-TEST_CASE(refresh_on_bad_symlink) {
+static void refresh_on_bad_symlink() {
   using namespace fs;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path sym = env.create_symlink("dir/file", "sym");
 
   const perms old_perms = status(dir).permissions();
 
   // test file doesn't exist
   {
     directory_entry ent(sym);
     LIBCPP_ONLY(remove(file));
-    TEST_CHECK(ent.is_symlink());
-    TEST_CHECK(ent.is_regular_file());
-    TEST_CHECK(ent.exists());
+    assert(ent.is_symlink());
+    assert(ent.is_regular_file());
+    assert(ent.exists());
 
     remove_if_exists(file);
     ent.refresh();
 
     LIBCPP_ONLY(permissions(dir, perms::none));
-    TEST_CHECK(ent.is_symlink());
+    assert(ent.is_symlink());
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
-    TEST_CHECK(!ent.is_regular_file());
-    TEST_CHECK(!ent.exists());
+    assert(!ent.is_regular_file());
+    assert(!ent.exists());
 #endif
   }
   permissions(dir, old_perms);
   env.create_file("dir/file", 101);
   {
     directory_entry ent(sym);
     LIBCPP_ONLY(remove(file));
-    TEST_CHECK(ent.is_symlink());
-    TEST_CHECK(ent.is_regular_file());
-    TEST_CHECK(ent.exists());
+    assert(ent.is_symlink());
+    assert(ent.is_regular_file());
+    assert(ent.exists());
 
     remove_if_exists(file);
 
     std::error_code ec = GetTestEC();
     ent.refresh(ec);
-    TEST_CHECK(!ec); // we don't report bad symlinks as an error.
+    assert(!ec); // we don't report bad symlinks as an error.
 
     LIBCPP_ONLY(permissions(dir, perms::none));
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
-    TEST_CHECK(!ent.exists());
+    assert(!ent.exists());
 #endif
   }
 }
 
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
 // Windows doesn't support setting perms::none to trigger failures
 // reading directories.
-TEST_CASE(refresh_cannot_resolve) {
+static void refresh_cannot_resolve() {
   using namespace fs;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path file_out_of_dir = env.create_file("file1", 99);
   const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
   const path sym_in_dir = env.create_symlink("file1", "dir/sym1");
   perms old_perms = status(dir).permissions();
 
   {
     directory_entry ent(file);
     permissions(dir, perms::none);
 
-    TEST_CHECK(ent.is_regular_file());
+    assert(ent.is_regular_file());
 
     std::error_code ec = GetTestEC();
     ent.refresh(ec);
 
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
-    TEST_CHECK(ent.path() == file);
+    assert(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.path() == file);
 
     ExceptionChecker Checker(file, std::errc::permission_denied,
                              "directory_entry::refresh");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.refresh());
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.refresh());
   }
   permissions(dir, old_perms);
   {
     directory_entry ent(sym_in_dir);
     permissions(dir, perms::none);
-    TEST_CHECK(ent.is_symlink());
+    assert(ent.is_symlink());
 
     std::error_code ec = GetTestEC();
     ent.refresh(ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
-    TEST_CHECK(ent.path() == sym_in_dir);
+    assert(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.path() == sym_in_dir);
 
     ExceptionChecker Checker(sym_in_dir, std::errc::permission_denied,
                              "directory_entry::refresh");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.refresh());
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.refresh());
   }
   permissions(dir, old_perms);
   {
     directory_entry ent(sym_out_of_dir);
     permissions(dir, perms::none);
-    TEST_CHECK(ent.is_symlink());
+    assert(ent.is_symlink());
 
     // Failure to resolve the linked entity due to permissions is not
     // reported as an error.
     std::error_code ec = GetTestEC();
     ent.refresh(ec);
-    TEST_CHECK(!ec);
-    TEST_CHECK(ent.is_symlink());
+    assert(!ec);
+    assert(ent.is_symlink());
 
     ec = GetTestEC();
-    TEST_CHECK(ent.exists(ec) == false);
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
-    TEST_CHECK(ent.path() == sym_out_of_dir);
+    assert(ent.exists(ec) == false);
+    assert(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.path() == sym_out_of_dir);
   }
   permissions(dir, old_perms);
   {
     directory_entry ent_file(file);
     directory_entry ent_sym(sym_in_dir);
     directory_entry ent_sym2(sym_out_of_dir);
     permissions(dir, perms::none);
     ((void)ent_file);
     ((void)ent_sym);
 
-    TEST_CHECK_THROW(filesystem_error, ent_file.refresh());
-    TEST_CHECK_THROW(filesystem_error, ent_sym.refresh());
-    TEST_CHECK_NO_THROW(ent_sym2);
+    TEST_THROWS_TYPE(filesystem_error, ent_file.refresh());
+    TEST_THROWS_TYPE(filesystem_error, ent_sym.refresh());
   }
 }
-#endif
+#endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
 
-TEST_CASE(refresh_doesnt_throw_on_dne_but_reports_it) {
+static void refresh_doesnt_throw_on_dne_but_reports_it() {
   using namespace fs;
   scoped_test_env env;
 
   const path file = env.create_file("file1", 42);
   const path sym = env.create_symlink("file1", "sym");
 
   {
     directory_entry ent(file);
-    TEST_CHECK(ent.file_size() == 42);
+    assert(ent.file_size() == 42);
 
     remove(file);
 
     std::error_code ec = GetTestEC();
     ent.refresh(ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
-    TEST_CHECK_NO_THROW(ent.refresh());
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    TEST_DOES_NOT_THROW(ent.refresh());
 
     ec = GetTestEC();
-    TEST_CHECK(ent.file_size(ec) == uintmax_t(-1));
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(ent.file_size(ec) == uintmax_t(-1));
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     // doesn't throw!
-    TEST_CHECK_THROW(filesystem_error, ent.file_size());
+    //
+    //
+    //
+    //TEST_THROWS_TYPE(filesystem_error, ent.file_size());
   }
   env.create_file("file1", 99);
   {
     directory_entry ent(sym);
-    TEST_CHECK(ent.is_symlink());
-    TEST_CHECK(ent.is_regular_file());
-    TEST_CHECK(ent.file_size() == 99);
+    assert(ent.is_symlink());
+    assert(ent.is_regular_file());
+    assert(ent.file_size() == 99);
 
     remove(file);
 
     std::error_code ec = GetTestEC();
     ent.refresh(ec);
-    TEST_CHECK(!ec);
+    assert(!ec);
 
     ec = GetTestEC();
-    TEST_CHECK(ent.file_size(ec) == uintmax_t(-1));
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(ent.file_size(ec) == uintmax_t(-1));
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
-    TEST_CHECK_THROW(filesystem_error, ent.file_size());
+    TEST_THROWS_TYPE(filesystem_error, ent.file_size());
   }
 }
 
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
 // Windows doesn't support setting perms::none to trigger failures
 // reading directories.
-TEST_CASE(access_cache_after_refresh_fails) {
+static void access_cache_after_refresh_fails() {
   using namespace fs;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path file_out_of_dir = env.create_file("file1", 101);
   const path sym = env.create_symlink("dir/file", "sym");
   const path sym_in_dir = env.create_symlink("dir/file", "dir/sym2");
 
   const perms old_perms = status(dir).permissions();
 
 #define CHECK_ACCESS(func, expect)                                             \
   ec = GetTestEC();                                                            \
-  TEST_CHECK(ent.func(ec) == expect);                                          \
-  TEST_CHECK(ErrorIs(ec, std::errc::permission_denied))
+  assert(ent.func(ec) == expect);                                          \
+  assert(ErrorIs(ec, std::errc::permission_denied))
 
   // test file doesn't exist
   {
     directory_entry ent(file);
 
-    TEST_CHECK(!ent.is_symlink());
-    TEST_CHECK(ent.is_regular_file());
-    TEST_CHECK(ent.exists());
+    assert(!ent.is_symlink());
+    assert(ent.is_regular_file());
+    assert(ent.exists());
 
     permissions(dir, perms::none);
     std::error_code ec = GetTestEC();
     ent.refresh(ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ErrorIs(ec, std::errc::permission_denied));
 
     CHECK_ACCESS(exists, false);
     CHECK_ACCESS(is_symlink, false);
     CHECK_ACCESS(last_write_time, file_time_type::min());
     CHECK_ACCESS(hard_link_count, uintmax_t(-1));
   }
   permissions(dir, old_perms);
   {
     directory_entry ent(sym_in_dir);
-    TEST_CHECK(ent.is_symlink());
-    TEST_CHECK(ent.is_regular_file());
-    TEST_CHECK(ent.exists());
+    assert(ent.is_symlink());
+    assert(ent.is_regular_file());
+    assert(ent.exists());
 
     permissions(dir, perms::none);
     std::error_code ec = GetTestEC();
     ent.refresh(ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ErrorIs(ec, std::errc::permission_denied));
 
     CHECK_ACCESS(exists, false);
     CHECK_ACCESS(is_symlink, false);
     CHECK_ACCESS(last_write_time, file_time_type::min());
     CHECK_ACCESS(hard_link_count, uintmax_t(-1));
   }
   permissions(dir, old_perms);
   {
     directory_entry ent(sym);
-    TEST_CHECK(ent.is_symlink());
-    TEST_CHECK(ent.is_regular_file());
-    TEST_CHECK(ent.exists());
+    assert(ent.is_symlink());
+    assert(ent.is_regular_file());
+    assert(ent.exists());
 
     permissions(dir, perms::none);
     std::error_code ec = GetTestEC();
     ent.refresh(ec);
-    TEST_CHECK(!ec);
-    TEST_CHECK(ent.is_symlink());
+    assert(!ec);
+    assert(ent.is_symlink());
 
     CHECK_ACCESS(exists, false);
     CHECK_ACCESS(is_regular_file, false);
     CHECK_ACCESS(last_write_time, file_time_type::min());
     CHECK_ACCESS(hard_link_count, uintmax_t(-1));
   }
 #undef CHECK_ACCESS
 }
-#endif
+#endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
 
-TEST_SUITE_END()
+int main(int, char**) {
+  test_refresh_method();
+  test_refresh_ec_method();
+#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
+  refresh_on_file_dne();
+#endif
+  refresh_on_bad_symlink();
+#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
+  refresh_cannot_resolve();
+#endif
+  refresh_doesnt_throw_on_dne_but_reports_it();
+#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
+  access_cache_after_refresh_fails();
+#endif
+  return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.mods/replace_filename.pass.cpp

 // void assign(path const&);
 // void replace_filename(path const&);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
-TEST_SUITE(directory_entry_mods_suite)
-
-TEST_CASE(test_replace_filename_method) {
+static void test_replace_filename_method() {
   using namespace fs;
 
   {
     directory_entry e;
     path replace;
     static_assert(noexcept(e.replace_filename(replace)) == false,
                   "operation cannot be noexcept");
     static_assert(
         std::is_same<decltype(e.replace_filename(replace)), void>::value,
         "operation must return void");
   }
   {
     const path p("/path/to/foo.exe");
     const path replace("bar.out");
     const path expect("/path/to/bar.out");
     directory_entry e(p);
-    TEST_CHECK(e.path() == p);
+    assert(e.path() == p);
     e.replace_filename(replace);
-    TEST_CHECK(e.path() == expect);
+    assert(e.path() == expect);
   }
 }
 
-TEST_CASE(test_replace_filename_ec_method) {
+static void test_replace_filename_ec_method() {
   using namespace fs;
 
   static_test_env static_env;
   {
     directory_entry e;
     path replace;
     std::error_code ec;
     static_assert(noexcept(e.replace_filename(replace, ec)) == false,
                   "operation cannot be noexcept");
     static_assert(
         std::is_same<decltype(e.replace_filename(replace, ec)), void>::value,
         "operation must return void");
   }
   {
     const path p("/path/to/foo.exe");
     const path replace("bar.out");
     const path expect("/path/to/bar.out");
     directory_entry e(p);
-    TEST_CHECK(e.path() == p);
+    assert(e.path() == p);
     std::error_code ec = GetTestEC();
     e.replace_filename(replace, ec);
-    TEST_CHECK(e.path() == expect);
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(e.path() == expect);
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
   }
   {
     const path p = static_env.EmptyFile;
     const path expect = static_env.NonEmptyFile;
     const path replace = static_env.NonEmptyFile.filename();
-    TEST_REQUIRE(expect.parent_path() == p.parent_path());
+    assert(expect.parent_path() == p.parent_path());
     directory_entry e(p);
-    TEST_CHECK(e.path() == p);
+    assert(e.path() == p);
     std::error_code ec = GetTestEC();
     e.replace_filename(replace, ec);
-    TEST_CHECK(e.path() == expect);
-    TEST_CHECK(!ec);
+    assert(e.path() == expect);
+    assert(!ec);
   }
 }
 
-TEST_CASE(test_replace_filename_calls_refresh) {
+static void test_replace_filename_calls_refresh() {
   using namespace fs;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path file_two = env.create_file("dir/file_two", 101);
   const path sym = env.create_symlink("dir/file", "sym");
   const path sym_two = env.create_symlink("dir/file_two", "sym_two");
 
   {
     directory_entry ent(file);
     ent.replace_filename(file_two.filename());
-    TEST_REQUIRE(ent.path() == file_two);
+    assert(ent.path() == file_two);
 
     // removing the file demonstrates that the values where cached previously.
     LIBCPP_ONLY(remove(file_two));
 
-    TEST_CHECK(ent.file_size() == 101);
+    assert(ent.file_size() == 101);
   }
   env.create_file("dir/file_two", 99);
   {
     directory_entry ent(sym);
     ent.replace_filename(sym_two.filename());
-    TEST_REQUIRE(ent.path() == sym_two);
+    assert(ent.path() == sym_two);
 
     LIBCPP_ONLY(remove(file_two));
     LIBCPP_ONLY(remove(sym_two));
 
-    TEST_CHECK(ent.is_symlink());
-    TEST_CHECK(ent.is_regular_file());
-    TEST_CHECK(ent.file_size() == 99);
+    assert(ent.is_symlink());
+    assert(ent.is_regular_file());
+    assert(ent.file_size() == 99);
   }
 }
 
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
 // Windows doesn't support setting perms::none to trigger failures
 // reading directories.
-TEST_CASE(test_replace_filename_propagates_error) {
+static void test_replace_filename_propagates_error() {
   using namespace fs;
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path file_two = env.create_file("dir/file_two", 99);
   const path file_out_of_dir = env.create_file("file_three", 101);
   const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
   const path sym_out_of_dir_two = env.create_symlink("dir/file", "sym_two");
   const path sym_in_dir = env.create_symlink("file_two", "dir/sym_three");
   const path sym_in_dir_two = env.create_symlink("file_two", "dir/sym_four");
 
   const perms old_perms = status(dir).permissions();
 
   {
     directory_entry ent(file);
     permissions(dir, perms::none);
     std::error_code ec = GetTestEC();
     ent.replace_filename(file_two.filename(), ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ErrorIs(ec, std::errc::permission_denied));
   }
   permissions(dir, old_perms);
   {
     directory_entry ent(sym_in_dir);
     permissions(dir, perms::none);
     std::error_code ec = GetTestEC();
     ent.replace_filename(sym_in_dir_two.filename(), ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ErrorIs(ec, std::errc::permission_denied));
   }
   permissions(dir, old_perms);
   {
     directory_entry ent(sym_out_of_dir);
     permissions(dir, perms::none);
     std::error_code ec = GetTestEC();
     ent.replace_filename(sym_out_of_dir_two.filename(), ec);
-    TEST_CHECK(!ec);
-    TEST_CHECK(ent.is_symlink());
+    assert(!ec);
+    assert(ent.is_symlink());
     ec = GetTestEC();
-    TEST_CHECK(!ent.exists(ec));
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(!ent.exists(ec));
+    assert(ErrorIs(ec, std::errc::permission_denied));
   }
 }
+#endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
+
+int main(int, char**) {
+  test_replace_filename_method();
+  test_replace_filename_ec_method();
+  test_replace_filename_calls_refresh();
+#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
+  test_replace_filename_propagates_error();
 #endif
 
-TEST_SUITE_END()
+  return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_size.pass.cpp

 // uintmax_t file_size() const;
 // uintmax_t file_size(error_code const&) const noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "filesystem_test_helper.h"
-#include "rapid-cxx-test.h"
 
 #include "test_macros.h"
 
-TEST_SUITE(directory_entry_obs_testsuite)
-
-TEST_CASE(signatures) {
+static void signatures() {
   using namespace fs;
   {
     const fs::directory_entry e = {};
     std::error_code ec;
     static_assert(std::is_same<decltype(e.file_size()), uintmax_t>::value, "");
     static_assert(std::is_same<decltype(e.file_size(ec)), uintmax_t>::value,
                   "");
     static_assert(noexcept(e.file_size()) == false, "");
     static_assert(noexcept(e.file_size(ec)) == true, "");
   }
 }
 
-TEST_CASE(basic) {
+static void basic() {
   using namespace fs;
 
   scoped_test_env env;
   const path file = env.create_file("file", 42);
   const path dir = env.create_dir("dir");
   const path sym = env.create_symlink("file", "sym");
 
   {
     directory_entry ent(file);
     uintmax_t expect = file_size(ent);
-    TEST_CHECK(expect == 42);
+    assert(expect == 42);
 
     // Remove the file to show that the results were already in the cache.
     LIBCPP_ONLY(remove(file));
 
     std::error_code ec = GetTestEC();
-    TEST_CHECK(ent.file_size(ec) == expect);
-    TEST_CHECK(!ec);
+    assert(ent.file_size(ec) == expect);
+    assert(!ec);
   }
   env.create_file("file", 99);
   {
     directory_entry ent(sym);
 
     uintmax_t expect = file_size(ent);
-    TEST_CHECK(expect == 99);
+    assert(expect == 99);
 
     LIBCPP_ONLY(remove(ent));
 
     std::error_code ec = GetTestEC();
-    TEST_CHECK(ent.file_size(ec) == 99);
-    TEST_CHECK(!ec);
+    assert(ent.file_size(ec) == 99);
+    assert(!ec);
   }
 }
 
-TEST_CASE(not_regular_file) {
+static void not_regular_file() {
   using namespace fs;
 
   scoped_test_env env;
   struct {
     const path p;
     std::errc expected_err;
   } TestCases[] = {
       {env.create_dir("dir"), std::errc::is_a_directory},
 #ifndef _WIN32
       {env.create_fifo("fifo"), std::errc::not_supported},
 #endif
       {env.create_directory_symlink("dir", "sym"), std::errc::is_a_directory}};
 
   for (auto const& TC : TestCases) {
     const path& p = TC.p;
     directory_entry ent(p);
-    TEST_CHECK(ent.path() == p);
+    assert(ent.path() == p);
     std::error_code ec = GetTestEC(0);
 
     std::error_code other_ec = GetTestEC(1);
     uintmax_t expect = file_size(p, other_ec);
 
     uintmax_t got = ent.file_size(ec);
-    TEST_CHECK(got == expect);
-    TEST_CHECK(got == uintmax_t(-1));
-    TEST_CHECK(ec == other_ec);
-    TEST_CHECK(ErrorIs(ec, TC.expected_err));
+    assert(got == expect);
+    assert(got == uintmax_t(-1));
+    assert(ec == other_ec);
+    assert(ErrorIs(ec, TC.expected_err));
 
     ExceptionChecker Checker(p, TC.expected_err, "directory_entry::file_size");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.file_size());
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.file_size());
   }
 }
 
-TEST_CASE(error_reporting) {
+static void error_reporting() {
   using namespace fs;
 
   static_test_env static_env;
   scoped_test_env env;
 
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path file_out_of_dir = env.create_file("file2", 101);
   const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
   const path sym_in_dir = env.create_symlink("file2", "dir/sym2");
 
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
   const perms old_perms = status(dir).permissions();
 #endif
 
   // test a file which doesn't exist
   {
     directory_entry ent;
 
     std::error_code ec = GetTestEC();
     ent.assign(static_env.DNE, ec);
-    TEST_REQUIRE(ent.path() == static_env.DNE);
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(ent.path() == static_env.DNE);
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ec = GetTestEC();
-    TEST_CHECK(ent.file_size(ec) == uintmax_t(-1));
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(ent.file_size(ec) == uintmax_t(-1));
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ExceptionChecker Checker(static_env.DNE,
                              std::errc::no_such_file_or_directory,
                              "directory_entry::file_size");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.file_size());
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.file_size());
   }
   // test a dead symlink
   {
     directory_entry ent;
 
     std::error_code ec = GetTestEC();
     uintmax_t expect_bad = file_size(static_env.BadSymlink, ec);
-    TEST_CHECK(expect_bad == uintmax_t(-1));
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(expect_bad == uintmax_t(-1));
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ec = GetTestEC();
     ent.assign(static_env.BadSymlink, ec);
-    TEST_REQUIRE(ent.path() == static_env.BadSymlink);
-    TEST_CHECK(!ec);
+    assert(ent.path() == static_env.BadSymlink);
+    assert(!ec);
 
     ec = GetTestEC();
-    TEST_CHECK(ent.file_size(ec) == expect_bad);
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(ent.file_size(ec) == expect_bad);
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ExceptionChecker Checker(static_env.BadSymlink,
                              std::errc::no_such_file_or_directory,
                              "directory_entry::file_size");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.file_size());
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.file_size());
   }
   // Windows doesn't support setting perms::none to trigger failures
   // reading directories.
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
   // test a file w/o appropriate permissions.
   {
     directory_entry ent;
     uintmax_t expect_good = file_size(file);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     ent.assign(file, ec);
-    TEST_REQUIRE(ent.path() == file);
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.path() == file);
+    assert(ErrorIs(ec, std::errc::permission_denied));
 
     ec = GetTestEC();
-    TEST_CHECK(ent.file_size(ec) == uintmax_t(-1));
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.file_size(ec) == uintmax_t(-1));
+    assert(ErrorIs(ec, std::errc::permission_denied));
 
     ExceptionChecker Checker(file, std::errc::permission_denied, "file_size");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.file_size());
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.file_size());
 
     permissions(dir, old_perms);
     ec = GetTestEC();
-    TEST_CHECK(ent.file_size(ec) == expect_good);
-    TEST_CHECK(!ec);
-    TEST_CHECK_NO_THROW(ent.file_size());
+    assert(ent.file_size(ec) == expect_good);
+    assert(!ec);
+    TEST_DOES_NOT_THROW(ent.file_size());
   }
   permissions(dir, old_perms);
   // test a symlink w/o appropriate permissions.
   {
     directory_entry ent;
     uintmax_t expect_good = file_size(sym_in_dir);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     ent.assign(sym_in_dir, ec);
-    TEST_REQUIRE(ent.path() == sym_in_dir);
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.path() == sym_in_dir);
+    assert(ErrorIs(ec, std::errc::permission_denied));
 
     ec = GetTestEC();
-    TEST_CHECK(ent.file_size(ec) == uintmax_t(-1));
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.file_size(ec) == uintmax_t(-1));
+    assert(ErrorIs(ec, std::errc::permission_denied));
 
     ExceptionChecker Checker(sym_in_dir, std::errc::permission_denied,
                              "file_size");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.file_size());
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.file_size());
 
     permissions(dir, old_perms);
     ec = GetTestEC();
-    TEST_CHECK(ent.file_size(ec) == expect_good);
-    TEST_CHECK(!ec);
-    TEST_CHECK_NO_THROW(ent.file_size());
+    assert(ent.file_size(ec) == expect_good);
+    assert(!ec);
+    TEST_DOES_NOT_THROW(ent.file_size());
   }
   permissions(dir, old_perms);
   // test a symlink to a file w/o appropriate permissions
   {
     directory_entry ent;
     uintmax_t expect_good = file_size(sym_out_of_dir);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     ent.assign(sym_out_of_dir, ec);
-    TEST_REQUIRE(ent.path() == sym_out_of_dir);
-    TEST_CHECK(!ec);
+    assert(ent.path() == sym_out_of_dir);
+    assert(!ec);
 
     ec = GetTestEC();
-    TEST_CHECK(ent.file_size(ec) == uintmax_t(-1));
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.file_size(ec) == uintmax_t(-1));
+    assert(ErrorIs(ec, std::errc::permission_denied));
 
     ExceptionChecker Checker(sym_out_of_dir, std::errc::permission_denied,
                              "file_size");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.file_size());
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.file_size());
 
     permissions(dir, old_perms);
     ec = GetTestEC();
-    TEST_CHECK(ent.file_size(ec) == expect_good);
-    TEST_CHECK(!ec);
-    TEST_CHECK_NO_THROW(ent.file_size());
+    assert(ent.file_size(ec) == expect_good);
+    assert(!ec);
+    TEST_DOES_NOT_THROW(ent.file_size());
   }
 #endif
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+  signatures();
+  basic();
+  not_regular_file();
+  error_reporting();
+
+  return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/file_type_obs.pass.cpp

 // file_status status() const;
 // file_status status(error_code const&) const noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "filesystem_test_helper.h"
-#include "rapid-cxx-test.h"
 
 #include "test_macros.h"
 
-TEST_SUITE(directory_entry_obs_testsuite)
-
-TEST_CASE(file_dne) {
+static void file_dne() {
   using namespace fs;
   directory_entry p("dne");
 }
 
-TEST_CASE(signatures) {
+static void signatures() {
   using namespace fs;
   const directory_entry e = {};
   std::error_code ec;
 #define TEST_FUNC(name)                                                        \
   static_assert(std::is_same<decltype(e.name()), bool>::value,                 \
                 "wrong return type");                                          \
   static_assert(noexcept(e.name()) == false, "should not be noexcept");        \
   static_assert(std::is_same<decltype(e.name(ec)), bool>::value,               \
                 "wrong return type");                                          \
   static_assert(noexcept(e.name(ec)) == true, "should be noexcept")
 
   TEST_FUNC(exists);
   TEST_FUNC(is_block_file);
   TEST_FUNC(is_character_file);
   TEST_FUNC(is_directory);
   TEST_FUNC(is_fifo);
   TEST_FUNC(is_other);
   TEST_FUNC(is_regular_file);
   TEST_FUNC(is_socket);
   TEST_FUNC(is_symlink);
 
 #undef TEST_FUNC
 }
 
-TEST_CASE(test_without_ec) {
+static void test_without_ec() {
   using namespace fs;
   using fs::directory_entry;
   using fs::file_status;
   using fs::path;
 
   scoped_test_env env;
   path f = env.create_file("foo", 42);
   path d = env.create_dir("dir");
   path hl = env.create_hardlink("foo", "hl");
   auto test_path = [=](const path &p) {
     directory_entry e(p);
     file_status st = status(p);
     file_status sym_st = symlink_status(p);
     fs::remove(p);
-    TEST_REQUIRE(e.exists());
-    TEST_REQUIRE(!exists(p));
-    TEST_CHECK(e.exists() == exists(st));
-    TEST_CHECK(e.is_block_file() == is_block_file(st));
-    TEST_CHECK(e.is_character_file() == is_character_file(st));
-    TEST_CHECK(e.is_directory() == is_directory(st));
-    TEST_CHECK(e.is_fifo() == is_fifo(st));
-    TEST_CHECK(e.is_other() == is_other(st));
-    TEST_CHECK(e.is_regular_file() == is_regular_file(st));
-    TEST_CHECK(e.is_socket() == is_socket(st));
-    TEST_CHECK(e.is_symlink() == is_symlink(sym_st));
+    assert(e.exists());
+    assert(!exists(p));
+    assert(e.exists() == exists(st));
+    assert(e.is_block_file() == is_block_file(st));
+    assert(e.is_character_file() == is_character_file(st));
+    assert(e.is_directory() == is_directory(st));
+    assert(e.is_fifo() == is_fifo(st));
+    assert(e.is_other() == is_other(st));
+    assert(e.is_regular_file() == is_regular_file(st));
+    assert(e.is_socket() == is_socket(st));
+    assert(e.is_symlink() == is_symlink(sym_st));
   };
   test_path(f);
   test_path(d);
   test_path(hl);
 #ifndef _WIN32
   path fifo = env.create_fifo("fifo");
   test_path(fifo);
 #endif
 }
 
-TEST_CASE(test_with_ec) {
+static void test_with_ec() {
   using namespace fs;
   using fs::directory_entry;
   using fs::file_status;
   using fs::path;
 
   scoped_test_env env;
   path f = env.create_file("foo", 42);
   path d = env.create_dir("dir");
   path hl = env.create_hardlink("foo", "hl");
   auto test_path = [=](const path &p) {
     directory_entry e(p);
     std::error_code status_ec = GetTestEC();
     std::error_code sym_status_ec = GetTestEC(1);
     file_status st = status(p, status_ec);
     file_status sym_st = symlink_status(p, sym_status_ec);
     fs::remove(p);
     std::error_code ec = GetTestEC(2);
     auto CheckEC = [&](std::error_code const& other_ec) {
       bool res = ec == other_ec;
       ec = GetTestEC(2);
       return res;
     };
 
-    TEST_REQUIRE(e.exists(ec));
-    TEST_CHECK(CheckEC(status_ec));
-    TEST_REQUIRE(!exists(p));
+    assert(e.exists(ec));
+    assert(CheckEC(status_ec));
+    assert(!exists(p));
 
-    TEST_CHECK(e.exists(ec) == exists(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.exists(ec) == exists(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_block_file(ec) == is_block_file(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_block_file(ec) == is_block_file(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_character_file(ec) == is_character_file(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_character_file(ec) == is_character_file(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_directory(ec) == is_directory(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_directory(ec) == is_directory(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_fifo(ec) == is_fifo(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_fifo(ec) == is_fifo(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_other(ec) == is_other(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_other(ec) == is_other(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_regular_file(ec) == is_regular_file(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_regular_file(ec) == is_regular_file(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_socket(ec) == is_socket(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_socket(ec) == is_socket(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_symlink(ec) == is_symlink(sym_st));
-    TEST_CHECK(CheckEC(sym_status_ec));
+    assert(e.is_symlink(ec) == is_symlink(sym_st));
+    assert(CheckEC(sym_status_ec));
   };
   test_path(f);
   test_path(d);
   test_path(hl);
 #ifndef _WIN32
   path fifo = env.create_fifo("fifo");
   test_path(fifo);
 #endif
 }
 
-TEST_CASE(test_with_ec_dne) {
+static void test_with_ec_dne() {
   using namespace fs;
   using fs::directory_entry;
   using fs::file_status;
   using fs::path;
   static_test_env static_env;
   for (auto p : {static_env.DNE, static_env.BadSymlink}) {
 
     directory_entry e(p);
     std::error_code status_ec = GetTestEC();
     std::error_code sym_status_ec = GetTestEC(1);
     file_status st = status(p, status_ec);
     file_status sym_st = symlink_status(p, sym_status_ec);
     std::error_code ec = GetTestEC(2);
     auto CheckEC = [&](std::error_code const& other_ec) {
       bool res = ec == other_ec;
       ec = GetTestEC(2);
       return res;
     };
 
-    TEST_CHECK(e.exists(ec) == exists(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.exists(ec) == exists(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_block_file(ec) == is_block_file(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_block_file(ec) == is_block_file(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_character_file(ec) == is_character_file(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_character_file(ec) == is_character_file(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_directory(ec) == is_directory(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_directory(ec) == is_directory(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_fifo(ec) == is_fifo(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_fifo(ec) == is_fifo(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_other(ec) == is_other(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_other(ec) == is_other(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_regular_file(ec) == is_regular_file(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_regular_file(ec) == is_regular_file(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_socket(ec) == is_socket(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_socket(ec) == is_socket(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_symlink(ec) == is_symlink(sym_st));
-    TEST_CHECK(CheckEC(sym_status_ec));
+    assert(e.is_symlink(ec) == is_symlink(sym_st));
+    assert(CheckEC(sym_status_ec));
   }
 }
 
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
 // Windows doesn't support setting perms::none to trigger failures
 // reading directories.
-TEST_CASE(test_with_ec_cannot_resolve) {
+static void test_with_ec_cannot_resolve() {
   using namespace fs;
   using fs::directory_entry;
   using fs::file_status;
   using fs::path;
 
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path file_out_of_dir = env.create_file("file2", 99);
   const path sym = env.create_symlink("file2", "dir/sym");
 
   perms old_perms = fs::status(dir).permissions();
 
   for (auto p : {file, sym}) {
     permissions(dir, old_perms);
     directory_entry e(p);
 
     permissions(dir, perms::none);
     std::error_code dummy_ec;
     e.refresh(dummy_ec);
-    TEST_REQUIRE(dummy_ec);
+    assert(dummy_ec);
 
     std::error_code status_ec = GetTestEC();
     std::error_code sym_status_ec = GetTestEC(1);
     file_status st = status(p, status_ec);
     file_status sym_st = symlink_status(p, sym_status_ec);
     std::error_code ec = GetTestEC(2);
     auto CheckEC = [&](std::error_code const& other_ec) {
       bool res = ec == other_ec;
       ec = GetTestEC(2);
       return res;
     };
 
-    TEST_CHECK(e.exists(ec) == exists(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.exists(ec) == exists(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_block_file(ec) == is_block_file(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_block_file(ec) == is_block_file(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_character_file(ec) == is_character_file(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_character_file(ec) == is_character_file(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_directory(ec) == is_directory(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_directory(ec) == is_directory(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_fifo(ec) == is_fifo(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_fifo(ec) == is_fifo(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_other(ec) == is_other(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_other(ec) == is_other(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_regular_file(ec) == is_regular_file(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_regular_file(ec) == is_regular_file(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_socket(ec) == is_socket(st));
-    TEST_CHECK(CheckEC(status_ec));
+    assert(e.is_socket(ec) == is_socket(st));
+    assert(CheckEC(status_ec));
 
-    TEST_CHECK(e.is_symlink(ec) == is_symlink(sym_st));
-    TEST_CHECK(CheckEC(sym_status_ec));
+    assert(e.is_symlink(ec) == is_symlink(sym_st));
+    assert(CheckEC(sym_status_ec));
   }
 }
+#endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
+
+int main(int, char**) {
+  file_dne();
+  signatures();
+  test_without_ec();
+  test_with_ec();
+  test_with_ec_dne();
+#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
+  test_with_ec_cannot_resolve();
 #endif
 
-TEST_SUITE_END()
+  return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/hard_link_count.pass.cpp

 // uintmax_t hard_link_count() const;
 // uintmax_t hard_link_count(error_code const&) const noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "filesystem_test_helper.h"
-#include "rapid-cxx-test.h"
 
 #include "test_macros.h"
 
-TEST_SUITE(directory_entry_obs_testsuite)
-
-TEST_CASE(signatures) {
+static void signatures() {
   using namespace fs;
   {
     const directory_entry e = {};
     std::error_code ec;
     static_assert(std::is_same<decltype(e.hard_link_count()), uintmax_t>::value, "");
     static_assert(std::is_same<decltype(e.hard_link_count(ec)), uintmax_t>::value,
                   "");
     static_assert(noexcept(e.hard_link_count()) == false, "");
     static_assert(noexcept(e.hard_link_count(ec)) == true, "");
   }
 }
 
-TEST_CASE(basic) {
+static void basic() {
   using namespace fs;
 
   scoped_test_env env;
   const path file = env.create_file("file", 42);
   const path dir = env.create_dir("dir");
   const path sym = env.create_symlink("file", "sym");
 
   {
     directory_entry ent(file);
     uintmax_t expect = hard_link_count(ent);
 
     // Remove the file to show that the results were already in the cache.
     LIBCPP_ONLY(remove(file));
 
     std::error_code ec = GetTestEC();
-    TEST_CHECK(ent.hard_link_count(ec) == expect);
-    TEST_CHECK(!ec);
+    assert(ent.hard_link_count(ec) == expect);
+    assert(!ec);
   }
   {
     directory_entry ent(dir);
     uintmax_t expect = hard_link_count(ent);
 
     LIBCPP_ONLY(remove(dir));
 
     std::error_code ec = GetTestEC();
-    TEST_CHECK(ent.hard_link_count(ec) == expect);
-    TEST_CHECK(!ec);
+    assert(ent.hard_link_count(ec) == expect);
+    assert(!ec);
   }
   env.create_file("file", 99);
   env.create_hardlink("file", "hl");
   {
     directory_entry ent(sym);
     std::error_code ec = GetTestEC();
-    TEST_CHECK(ent.hard_link_count(ec) == 2);
-    TEST_CHECK(!ec);
+    assert(ent.hard_link_count(ec) == 2);
+    assert(!ec);
   }
 }
 
-TEST_CASE(not_regular_file) {
+static void not_regular_file() {
   using namespace fs;
 
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path dir2 = env.create_dir("dir/dir2");
 
   const perms old_perms = status(dir).permissions();
 
   auto test_path = [=](const path &p) {
     std::error_code dummy_ec = GetTestEC();
     directory_entry ent(p, dummy_ec);
-    TEST_CHECK(!dummy_ec);
+    assert(!dummy_ec);
 
     uintmax_t expect = hard_link_count(p);
 
     LIBCPP_ONLY(permissions(dir, perms::none));
 
     std::error_code ec = GetTestEC();
-    TEST_CHECK(ent.hard_link_count(ec) == expect);
-    TEST_CHECK(!ec);
-    TEST_CHECK_NO_THROW(ent.hard_link_count());
+    assert(ent.hard_link_count(ec) == expect);
+    assert(!ec);
+    TEST_DOES_NOT_THROW(ent.hard_link_count());
     permissions(dir, old_perms);
   };
   test_path(dir2);
 #ifndef _WIN32
   const path fifo = env.create_fifo("dir/fifo");
   const path sym_to_fifo = env.create_symlink("dir/fifo", "dir/sym");
   test_path(fifo);
   test_path(sym_to_fifo);
 #endif
 }
 
-TEST_CASE(error_reporting) {
+static void error_reporting() {
   using namespace fs;
 
   static_test_env static_env;
   scoped_test_env env;
 
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path file_out_of_dir = env.create_file("file2", 101);
   const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
   const path sym_in_dir = env.create_symlink("file2", "dir/sym2");
 
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
   const perms old_perms = status(dir).permissions();
 #endif
 
   // test a file which doesn't exist
   {
     directory_entry ent;
 
     std::error_code ec = GetTestEC();
     ent.assign(static_env.DNE, ec);
-    TEST_CHECK(ec);
-    TEST_REQUIRE(ent.path() == static_env.DNE);
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(ec);
+    assert(ent.path() == static_env.DNE);
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ec = GetTestEC();
-    TEST_CHECK(ent.hard_link_count(ec) == uintmax_t(-1));
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(ent.hard_link_count(ec) == uintmax_t(-1));
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ExceptionChecker Checker(static_env.DNE,
                              std::errc::no_such_file_or_directory,
                              "directory_entry::hard_link_count");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.hard_link_count());
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.hard_link_count());
   }
   // test a dead symlink
   {
     directory_entry ent;
 
     std::error_code ec = GetTestEC();
     uintmax_t expect_bad = hard_link_count(static_env.BadSymlink, ec);
-    TEST_CHECK(expect_bad == uintmax_t(-1));
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(expect_bad == uintmax_t(-1));
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ec = GetTestEC();
     ent.assign(static_env.BadSymlink, ec);
-    TEST_REQUIRE(ent.path() == static_env.BadSymlink);
-    TEST_CHECK(!ec);
+    assert(ent.path() == static_env.BadSymlink);
+    assert(!ec);
 
     ec = GetTestEC();
-    TEST_CHECK(ent.hard_link_count(ec) == expect_bad);
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(ent.hard_link_count(ec) == expect_bad);
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ExceptionChecker Checker(static_env.BadSymlink,
                              std::errc::no_such_file_or_directory,
                              "directory_entry::hard_link_count");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.hard_link_count());
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.hard_link_count());
   }
   // Windows doesn't support setting perms::none to trigger failures
   // reading directories.
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
   // test a file w/o appropriate permissions.
   {
     directory_entry ent;
     uintmax_t expect_good = hard_link_count(file);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     ent.assign(file, ec);
-    TEST_REQUIRE(ent.path() == file);
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.path() == file);
+    assert(ErrorIs(ec, std::errc::permission_denied));
 
     ec = GetTestEC();
-    TEST_CHECK(ent.hard_link_count(ec) == uintmax_t(-1));
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.hard_link_count(ec) == uintmax_t(-1));
+    assert(ErrorIs(ec, std::errc::permission_denied));
 
     ExceptionChecker Checker(file, std::errc::permission_denied,
                              "hard_link_count");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.hard_link_count());
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.hard_link_count());
 
     permissions(dir, old_perms);
     ec = GetTestEC();
-    TEST_CHECK(ent.hard_link_count(ec) == expect_good);
-    TEST_CHECK(!ec);
-    TEST_CHECK_NO_THROW(ent.hard_link_count());
+    assert(ent.hard_link_count(ec) == expect_good);
+    assert(!ec);
+    TEST_DOES_NOT_THROW(ent.hard_link_count());
   }
   permissions(dir, old_perms);
   // test a symlink w/o appropriate permissions.
   {
     directory_entry ent;
     uintmax_t expect_good = hard_link_count(sym_in_dir);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     ent.assign(sym_in_dir, ec);
-    TEST_REQUIRE(ent.path() == sym_in_dir);
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.path() == sym_in_dir);
+    assert(ErrorIs(ec, std::errc::permission_denied));
 
     ec = GetTestEC();
-    TEST_CHECK(ent.hard_link_count(ec) == uintmax_t(-1));
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.hard_link_count(ec) == uintmax_t(-1));
+    assert(ErrorIs(ec, std::errc::permission_denied));
 
     ExceptionChecker Checker(sym_in_dir, std::errc::permission_denied,
                              "hard_link_count");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.hard_link_count());
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.hard_link_count());
 
     permissions(dir, old_perms);
     ec = GetTestEC();
-    TEST_CHECK(ent.hard_link_count(ec) == expect_good);
-    TEST_CHECK(!ec);
-    TEST_CHECK_NO_THROW(ent.hard_link_count());
+    assert(ent.hard_link_count(ec) == expect_good);
+    assert(!ec);
+    TEST_DOES_NOT_THROW(ent.hard_link_count());
   }
   permissions(dir, old_perms);
   // test a symlink to a file w/o appropriate permissions
   {
     directory_entry ent;
     uintmax_t expect_good = hard_link_count(sym_out_of_dir);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     ent.assign(sym_out_of_dir, ec);
-    TEST_REQUIRE(ent.path() == sym_out_of_dir);
-    TEST_CHECK(!ec);
+    assert(ent.path() == sym_out_of_dir);
+    assert(!ec);
 
     ec = GetTestEC();
-    TEST_CHECK(ent.hard_link_count(ec) == uintmax_t(-1));
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.hard_link_count(ec) == uintmax_t(-1));
+    assert(ErrorIs(ec, std::errc::permission_denied));
 
     ExceptionChecker Checker(sym_out_of_dir, std::errc::permission_denied,
                              "hard_link_count");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.hard_link_count());
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.hard_link_count());
 
     permissions(dir, old_perms);
     ec = GetTestEC();
-    TEST_CHECK(ent.hard_link_count(ec) == expect_good);
-    TEST_CHECK(!ec);
-    TEST_CHECK_NO_THROW(ent.hard_link_count());
+    assert(ent.hard_link_count(ec) == expect_good);
+    assert(!ec);
+    TEST_DOES_NOT_THROW(ent.hard_link_count());
   }
 #endif
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+  signatures();
+  basic();
+  not_regular_file();
+  error_reporting();
+  return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/last_write_time.pass.cpp

 // file_time_type last_write_time() const;
 // file_time_type last_write_time(error_code const&) const noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "filesystem_test_helper.h"
-#include "rapid-cxx-test.h"
 
 #include "test_macros.h"
 
-TEST_SUITE(directory_entry_obs_testsuite)
-
-TEST_CASE(signatures) {
+static void signatures() {
   using namespace fs;
   {
     const fs::directory_entry e = {};
     std::error_code ec;
     static_assert(std::is_same<decltype(e.last_write_time()), file_time_type>::value,
                   "");
     static_assert(std::is_same<decltype(e.last_write_time(ec)), file_time_type>::value,
                   "");
     static_assert(noexcept(e.last_write_time()) == false, "");
     static_assert(noexcept(e.last_write_time(ec)) == true, "");
   }
 }
 
-TEST_CASE(basic) {
+static void basic() {
   using namespace fs;
 
   scoped_test_env env;
   const path file = env.create_file("file", 42);
   const path dir = env.create_dir("dir");
   const path sym = env.create_symlink("file", "sym");
 
   {
     directory_entry ent(file);
     file_time_type expect = last_write_time(ent);
 
     // Remove the file to show that the results were already in the cache.
     LIBCPP_ONLY(remove(file));
 
     std::error_code ec = GetTestEC();
-    TEST_CHECK(ent.last_write_time(ec) == expect);
-    TEST_CHECK(!ec);
+    assert(ent.last_write_time(ec) == expect);
+    assert(!ec);
   }
   {
     directory_entry ent(dir);
     file_time_type expect = last_write_time(ent);
 
     LIBCPP_ONLY(remove(dir));
 
     std::error_code ec = GetTestEC();
-    TEST_CHECK(ent.last_write_time(ec) == expect);
-    TEST_CHECK(!ec);
+    assert(ent.last_write_time(ec) == expect);
+    assert(!ec);
   }
   env.create_file("file", 99);
   {
     directory_entry ent(sym);
     file_time_type expect = last_write_time(sym);
 
     std::error_code ec = GetTestEC();
-    TEST_CHECK(ent.last_write_time(ec) == expect);
-    TEST_CHECK(!ec);
+    assert(ent.last_write_time(ec) == expect);
+    assert(!ec);
   }
 }
 
-TEST_CASE(error_reporting) {
+static void error_reporting() {
   using namespace fs;
 
   static_test_env static_env;
   scoped_test_env env;
 
   const path dir = env.create_dir("dir");
   const path file = env.create_file("dir/file", 42);
   const path file_out_of_dir = env.create_file("file2", 101);
   const path sym_out_of_dir = env.create_symlink("dir/file", "sym");
   const path sym_in_dir = env.create_symlink("file2", "dir/sym2");
 
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
   const perms old_perms = status(dir).permissions();
 #endif
 
   // test a file which doesn't exist
   {
     directory_entry ent;
 
     std::error_code ec = GetTestEC();
     ent.assign(static_env.DNE, ec);
-    TEST_REQUIRE(ent.path() == static_env.DNE);
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(ent.path() == static_env.DNE);
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ec = GetTestEC();
-    TEST_CHECK(ent.last_write_time(ec) == file_time_type::min());
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(ent.last_write_time(ec) == file_time_type::min());
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ExceptionChecker Checker(static_env.DNE,
                              std::errc::no_such_file_or_directory,
                              "directory_entry::last_write_time");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.last_write_time());
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.last_write_time());
   }
   // test a dead symlink
   {
     directory_entry ent;
 
     std::error_code ec = GetTestEC();
     file_time_type expect_bad = last_write_time(static_env.BadSymlink, ec);
-    TEST_CHECK(expect_bad == file_time_type::min());
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(expect_bad == file_time_type::min());
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ec = GetTestEC();
     ent.assign(static_env.BadSymlink, ec);
-    TEST_REQUIRE(ent.path() == static_env.BadSymlink);
-    TEST_CHECK(!ec);
+    assert(ent.path() == static_env.BadSymlink);
+    assert(!ec);
 
     ec = GetTestEC();
-    TEST_CHECK(ent.last_write_time(ec) == expect_bad);
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(ent.last_write_time(ec) == expect_bad);
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 
     ExceptionChecker Checker(static_env.BadSymlink,
                              std::errc::no_such_file_or_directory,
                              "directory_entry::last_write_time");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.last_write_time());
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.last_write_time());
   }
   // Windows doesn't support setting perms::none to trigger failures
   // reading directories.
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
   // test a file w/o appropriate permissions.
   {
     directory_entry ent;
     file_time_type expect_good = last_write_time(file);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     ent.assign(file, ec);
-    TEST_REQUIRE(ent.path() == file);
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.path() == file);
+    assert(ErrorIs(ec, std::errc::permission_denied));
 
     ec = GetTestEC();
-    TEST_CHECK(ent.last_write_time(ec) == file_time_type::min());
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.last_write_time(ec) == file_time_type::min());
+    assert(ErrorIs(ec, std::errc::permission_denied));
 
     ExceptionChecker Checker(file, std::errc::permission_denied,
                              "last_write_time");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.last_write_time());
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.last_write_time());
 
     permissions(dir, old_perms);
     ec = GetTestEC();
-    TEST_CHECK(ent.last_write_time(ec) == expect_good);
-    TEST_CHECK(!ec);
-    TEST_CHECK_NO_THROW(ent.last_write_time());
+    assert(ent.last_write_time(ec) == expect_good);
+    assert(!ec);
+    TEST_DOES_NOT_THROW(ent.last_write_time());
   }
   permissions(dir, old_perms);
   // test a symlink w/o appropriate permissions.
   {
     directory_entry ent;
     file_time_type expect_good = last_write_time(sym_in_dir);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     ent.assign(sym_in_dir, ec);
-    TEST_REQUIRE(ent.path() == sym_in_dir);
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.path() == sym_in_dir);
+    assert(ErrorIs(ec, std::errc::permission_denied));
 
     ec = GetTestEC();
-    TEST_CHECK(ent.last_write_time(ec) == file_time_type::min());
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.last_write_time(ec) == file_time_type::min());
+    assert(ErrorIs(ec, std::errc::permission_denied));
 
     ExceptionChecker Checker(sym_in_dir, std::errc::permission_denied,
                              "last_write_time");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.last_write_time());
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.last_write_time());
 
     permissions(dir, old_perms);
     ec = GetTestEC();
-    TEST_CHECK(ent.last_write_time(ec) == expect_good);
-    TEST_CHECK(!ec);
-    TEST_CHECK_NO_THROW(ent.last_write_time());
+    assert(ent.last_write_time(ec) == expect_good);
+    assert(!ec);
+    TEST_DOES_NOT_THROW(ent.last_write_time());
   }
   permissions(dir, old_perms);
   // test a symlink to a file w/o appropriate permissions
   {
     directory_entry ent;
     file_time_type expect_good = last_write_time(sym_out_of_dir);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
     ent.assign(sym_out_of_dir, ec);
-    TEST_REQUIRE(ent.path() == sym_out_of_dir);
-    TEST_CHECK(!ec);
+    assert(ent.path() == sym_out_of_dir);
+    assert(!ec);
 
     ec = GetTestEC();
-    TEST_CHECK(ent.last_write_time(ec) == file_time_type::min());
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(ent.last_write_time(ec) == file_time_type::min());
+    assert(ErrorIs(ec, std::errc::permission_denied));
 
     ExceptionChecker Checker(sym_out_of_dir, std::errc::permission_denied,
                              "last_write_time");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ent.last_write_time());
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ent.last_write_time());
 
     permissions(dir, old_perms);
     ec = GetTestEC();
-    TEST_CHECK(ent.last_write_time(ec) == expect_good);
-    TEST_CHECK(!ec);
-    TEST_CHECK_NO_THROW(ent.last_write_time());
+    assert(ent.last_write_time(ec) == expect_good);
+    assert(!ec);
+    TEST_DOES_NOT_THROW(ent.last_write_time());
   }
 #endif
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+  signatures();
+  basic();
+  error_reporting();
+
+  return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/status.pass.cpp

 // file_status status() const;
 // file_status status(error_code const&) const noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "filesystem_test_helper.h"
-#include "rapid-cxx-test.h"
 
 #include "test_macros.h"
 
-TEST_SUITE(directory_entry_status_testsuite)
-
-TEST_CASE(test_basic) {
+static void test_basic() {
   using namespace fs;
   static_test_env static_env;
   {
     const fs::directory_entry e("foo");
     std::error_code ec;
     static_assert(std::is_same<decltype(e.status()), fs::file_status>::value, "");
     static_assert(std::is_same<decltype(e.status(ec)), fs::file_status>::value, "");
     static_assert(noexcept(e.status()) == false, "");
     static_assert(noexcept(e.status(ec)) == true, "");
   }
   path TestCases[] = {static_env.File, static_env.Dir, static_env.SymlinkToFile,
                       static_env.DNE};
   for (const auto& p : TestCases) {
     const directory_entry e(p);
     std::error_code pec = GetTestEC(), eec = GetTestEC(1);
     file_status ps = fs::status(p, pec);
     file_status es = e.status(eec);
-    TEST_CHECK(ps.type() == es.type());
-    TEST_CHECK(ps.permissions() == es.permissions());
-    TEST_CHECK(pec == eec);
+    assert(ps.type() == es.type());
+    assert(ps.permissions() == es.permissions());
+    assert(pec == eec);
   }
   for (const auto& p : TestCases) {
     const directory_entry e(p);
     file_status ps = fs::status(p);
     file_status es = e.status();
-    TEST_CHECK(ps.type() == es.type());
-    TEST_CHECK(ps.permissions() == es.permissions());
+    assert(ps.type() == es.type());
+    assert(ps.permissions() == es.permissions());
   }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+  test_basic();
+
+  return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_entry/directory_entry.obs/symlink_status.pass.cpp

 // file_status symlink_status() const;
 // file_status symlink_status(error_code&) const noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "filesystem_test_helper.h"
-#include "rapid-cxx-test.h"
 
 #include "test_macros.h"
 
-TEST_SUITE(directory_entry_obs_suite)
-
-TEST_CASE(test_signature) {
+static void test_signature() {
   using namespace fs;
   static_test_env static_env;
   {
     const directory_entry e("foo");
     std::error_code ec;
     static_assert(std::is_same<decltype(e.symlink_status()), file_status>::value, "");
     static_assert(std::is_same<decltype(e.symlink_status(ec)), file_status>::value, "");
     static_assert(noexcept(e.symlink_status()) == false, "");
     static_assert(noexcept(e.symlink_status(ec)) == true, "");
   }
   path TestCases[] = {static_env.File, static_env.Dir, static_env.SymlinkToFile,
                       static_env.DNE};
   for (const auto& p : TestCases) {
     const directory_entry e(p);
     std::error_code pec = GetTestEC(), eec = GetTestEC(1);
     file_status ps = fs::symlink_status(p, pec);
     file_status es = e.symlink_status(eec);
-    TEST_CHECK(ps.type() == es.type());
-    TEST_CHECK(ps.permissions() == es.permissions());
-    TEST_CHECK(pec == eec);
+    assert(ps.type() == es.type());
+    assert(ps.permissions() == es.permissions());
+    assert(pec == eec);
   }
   for (const auto& p : TestCases) {
     const directory_entry e(p);
     file_status ps = fs::symlink_status(p);
     file_status es = e.symlink_status();
-    TEST_CHECK(ps.type() == es.type());
-    TEST_CHECK(ps.permissions() == es.permissions());
+    assert(ps.type() == es.type());
+    assert(ps.permissions() == es.permissions());
   }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+  test_signature();
+  return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy.pass.cpp

 // directory_iterator(directory_iterator const&);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(directory_iterator_copy_construct_tests)
-
-TEST_CASE(test_constructor_signature)
+static void test_constructor_signature()
 {
     using D = directory_iterator;
     static_assert(std::is_copy_constructible<D>::value, "");
 }
 
-TEST_CASE(test_copy_end_iterator)
+static void test_copy_end_iterator()
 {
     const directory_iterator endIt;
     directory_iterator it(endIt);
-    TEST_CHECK(it == endIt);
+    assert(it == endIt);
 }
 
-TEST_CASE(test_copy_valid_iterator)
+static void test_copy_valid_iterator()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
     const directory_iterator endIt{};
 
     const directory_iterator it(testDir);
-    TEST_REQUIRE(it != endIt);
+    assert(it != endIt);
     const path entry = *it;
 
     const directory_iterator it2(it);
-    TEST_REQUIRE(it2 == it);
-    TEST_CHECK(*it2 == entry);
-    TEST_CHECK(*it == entry);
+    assert(it2 == it);
+    assert(*it2 == entry);
+    assert(*it == entry);
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    test_constructor_signature();
+    test_copy_end_iterator();
+    test_copy_valid_iterator();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/copy_assign.pass.cpp

 // directory_iterator& operator=(directory_iterator const&);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(directory_iterator_copy_assign_tests)
-
-TEST_CASE(test_assignment_signature)
+static void test_assignment_signature()
 {
     using D = directory_iterator;
     static_assert(std::is_copy_assignable<D>::value, "");
 }
 
-TEST_CASE(test_copy_to_end_iterator)
+static void test_copy_to_end_iterator()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
 
     const directory_iterator from(testDir);
-    TEST_REQUIRE(from != directory_iterator{});
+    assert(from != directory_iterator{});
     const path entry = *from;
 
     directory_iterator to{};
     to = from;
-    TEST_REQUIRE(to == from);
-    TEST_CHECK(*to == entry);
-    TEST_CHECK(*from == entry);
+    assert(to == from);
+    assert(*to == entry);
+    assert(*from == entry);
 }
 
 
-TEST_CASE(test_copy_from_end_iterator)
+static void test_copy_from_end_iterator()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
 
     const directory_iterator from{};
 
     directory_iterator to(testDir);
-    TEST_REQUIRE(to != directory_iterator{});
+    assert(to != directory_iterator{});
 
     to = from;
-    TEST_REQUIRE(to == from);
-    TEST_CHECK(to == directory_iterator{});
+    assert(to == from);
+    assert(to == directory_iterator{});
 }
 
-TEST_CASE(test_copy_valid_iterator)
+static void test_copy_valid_iterator()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
     const directory_iterator endIt{};
 
     directory_iterator it_obj(testDir);
     const directory_iterator& it = it_obj;
-    TEST_REQUIRE(it != endIt);
+    assert(it != endIt);
     ++it_obj;
-    TEST_REQUIRE(it != endIt);
+    assert(it != endIt);
     const path entry = *it;
 
     directory_iterator it2(testDir);
-    TEST_REQUIRE(it2 != it);
+    assert(it2 != it);
     const path entry2 = *it2;
-    TEST_CHECK(entry2 != entry);
+    assert(entry2 != entry);
 
     it2 = it;
-    TEST_REQUIRE(it2 == it);
-    TEST_CHECK(*it2 == entry);
+    assert(it2 == it);
+    assert(*it2 == entry);
 }
 
-TEST_CASE(test_returns_reference_to_self)
+static void test_returns_reference_to_self()
 {
     const directory_iterator it;
     directory_iterator it2;
     directory_iterator& ref = (it2 = it);
-    TEST_CHECK(&ref == &it2);
+    assert(&ref == &it2);
 }
 
+int main(int, char**) {
+    test_assignment_signature();
+    test_copy_to_end_iterator();
+    test_copy_from_end_iterator();
+    test_copy_valid_iterator();
+    test_returns_reference_to_self();
 
-TEST_SUITE_END()
+    return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/ctor.pass.cpp

 // directory_iterator(const path& p, directory_options options, error_code& ec);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(directory_iterator_constructor_tests)
-
-TEST_CASE(test_constructor_signatures)
+static void test_constructor_signatures()
 {
     using D = directory_iterator;
 
     // explicit directory_iterator(path const&);
     static_assert(!std::is_convertible<path, D>::value, "");
     static_assert(std::is_constructible<D, path>::value, "");
     static_assert(!std::is_nothrow_constructible<D, path>::value, "");
 
static void test_constructor_signatures()
     // directory_iterator(path const&, directory_options, error_code&)
     static_assert(std::is_constructible<D, path, directory_options,
         std::error_code&>::value, "");
     static_assert(!std::is_nothrow_constructible<D, path, directory_options,
         std::error_code&>::value, "");
 
 }
 
-TEST_CASE(test_construction_from_bad_path)
+static void test_construction_from_bad_path()
 {
     static_test_env static_env;
     std::error_code ec;
     directory_options opts = directory_options::none;
     const directory_iterator endIt;
 
     const path testPaths[] = { static_env.DNE, static_env.BadSymlink };
     for (path const& testPath : testPaths)
     {
         {
             directory_iterator it(testPath, ec);
-            TEST_CHECK(ec);
-            TEST_CHECK(it == endIt);
+            assert(ec);
+            assert(it == endIt);
         }
         {
             directory_iterator it(testPath, opts, ec);
-            TEST_CHECK(ec);
-            TEST_CHECK(it == endIt);
+            assert(ec);
+            assert(it == endIt);
         }
         {
-            TEST_CHECK_THROW(filesystem_error, directory_iterator(testPath));
-            TEST_CHECK_THROW(filesystem_error, directory_iterator(testPath, opts));
+            TEST_THROWS_TYPE(filesystem_error, directory_iterator(testPath));
+            TEST_THROWS_TYPE(filesystem_error, directory_iterator(testPath, opts));
         }
     }
 }
 
-TEST_CASE(access_denied_test_case)
+static void access_denied_test_case()
 {
     using namespace fs;
 #ifdef _WIN32
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories; test using a special inaccessible directory
     // instead.
     const path testDir = GetWindowsInaccessibleDir();
     if (testDir.empty())
-        TEST_UNSUPPORTED();
+        TEST_IS_UNSUPPORTED();
 #else
     scoped_test_env env;
     path const testDir = env.make_env_path("dir1");
     path const testFile = testDir / "testFile";
     env.create_dir(testDir);
     env.create_file(testFile, 42);
 
     // Test that we can iterator over the directory before changing the perms
     {
         directory_iterator it(testDir);
-        TEST_REQUIRE(it != directory_iterator{});
+        assert(it != directory_iterator{});
     }
     // Change the permissions so we can no longer iterate
     permissions(testDir, perms::none);
 #endif
 
     // Check that the construction fails when skip_permissions_denied is
     // not given.
     {
         std::error_code ec;
         directory_iterator it(testDir, ec);
-        TEST_REQUIRE(ec);
-        TEST_CHECK(it == directory_iterator{});
+        assert(ec);
+        assert(it == directory_iterator{});
     }
     // Check that construction does not report an error when
     // 'skip_permissions_denied' is given.
     {
         std::error_code ec;
         directory_iterator it(testDir, directory_options::skip_permission_denied, ec);
-        TEST_REQUIRE(!ec);
-        TEST_CHECK(it == directory_iterator{});
+        assert(!ec);
+        assert(it == directory_iterator{});
     }
 }
 
 
-TEST_CASE(access_denied_to_file_test_case)
+static void access_denied_to_file_test_case()
 {
     using namespace fs;
     scoped_test_env env;
     path const testFile = env.make_env_path("file1");
     env.create_file(testFile, 42);
 
     // Change the permissions so we can no longer iterate
     permissions(testFile, perms::none);
 
     // Check that the construction fails when skip_permissions_denied is
     // not given.
     {
         std::error_code ec;
         directory_iterator it(testFile, ec);
-        TEST_REQUIRE(ec);
-        TEST_CHECK(it == directory_iterator{});
+        assert(ec);
+        assert(it == directory_iterator{});
     }
     // Check that construction still fails when 'skip_permissions_denied' is given
     // because we tried to open a file and not a directory.
     {
         std::error_code ec;
         directory_iterator it(testFile, directory_options::skip_permission_denied, ec);
-        TEST_REQUIRE(ec);
-        TEST_CHECK(it == directory_iterator{});
+        assert(ec);
+        assert(it == directory_iterator{});
     }
 }
 
-TEST_CASE(test_open_on_empty_directory_equals_end)
+static void test_open_on_empty_directory_equals_end()
 {
     scoped_test_env env;
     const path testDir = env.make_env_path("dir1");
     env.create_dir(testDir);
 
     const directory_iterator endIt;
     {
         std::error_code ec;
         directory_iterator it(testDir, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(it == endIt);
+        assert(!ec);
+        assert(it == endIt);
     }
     {
         directory_iterator it(testDir);
-        TEST_CHECK(it == endIt);
+        assert(it == endIt);
     }
 }
 
-TEST_CASE(test_open_on_directory_succeeds)
+static void test_open_on_directory_succeeds()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
     std::set<path> dir_contents(static_env.DirIterationList.begin(),
                                 static_env.DirIterationList.end());
     const directory_iterator endIt{};
 
     {
         std::error_code ec;
         directory_iterator it(testDir, ec);
-        TEST_REQUIRE(!ec);
-        TEST_CHECK(it != endIt);
-        TEST_CHECK(dir_contents.count(*it));
+        assert(!ec);
+        assert(it != endIt);
+        assert(dir_contents.count(*it));
     }
     {
         directory_iterator it(testDir);
-        TEST_CHECK(it != endIt);
-        TEST_CHECK(dir_contents.count(*it));
+        assert(it != endIt);
+        assert(dir_contents.count(*it));
     }
 }
 
-TEST_CASE(test_open_on_file_fails)
+static void test_open_on_file_fails()
 {
     static_test_env static_env;
     const path testFile = static_env.File;
     const directory_iterator endIt{};
     {
         std::error_code ec;
         directory_iterator it(testFile, ec);
-        TEST_REQUIRE(ec);
-        TEST_CHECK(it == endIt);
+        assert(ec);
+        assert(it == endIt);
     }
     {
-        TEST_CHECK_THROW(filesystem_error, directory_iterator(testFile));
+        TEST_THROWS_TYPE(filesystem_error, directory_iterator(testFile));
     }
 }
 
-TEST_CASE(test_open_on_empty_string)
+static void test_open_on_empty_string()
 {
     const path testPath = "";
     const directory_iterator endIt{};
 
     std::error_code ec;
     directory_iterator it(testPath, ec);
-    TEST_CHECK(ec);
-    TEST_CHECK(it == endIt);
+    assert(ec);
+    assert(it == endIt);
 }
 
-TEST_CASE(test_open_on_dot_dir)
+static void test_open_on_dot_dir()
 {
     const path testPath = ".";
 
     std::error_code ec;
     directory_iterator it(testPath, ec);
-    TEST_CHECK(!ec);
+    assert(!ec);
 }
 
-TEST_CASE(test_open_on_symlink)
+static void test_open_on_symlink()
 {
     static_test_env static_env;
     const path symlinkToDir = static_env.SymlinkToDir;
     std::set<path> dir_contents;
     for (path const& p : static_env.DirIterationList) {
         dir_contents.insert(p.filename());
     }
     const directory_iterator endIt{};
 
     {
         std::error_code ec;
         directory_iterator it(symlinkToDir, ec);
-        TEST_REQUIRE(!ec);
-        TEST_CHECK(it != endIt);
+        assert(!ec);
+        assert(it != endIt);
         path const& entry = *it;
-        TEST_CHECK(dir_contents.count(entry.filename()));
+        assert(dir_contents.count(entry.filename()));
     }
     {
         std::error_code ec;
         directory_iterator it(symlinkToDir,
                               directory_options::follow_directory_symlink, ec);
-        TEST_REQUIRE(!ec);
-        TEST_CHECK(it != endIt);
+        assert(!ec);
+        assert(it != endIt);
         path const& entry = *it;
-        TEST_CHECK(dir_contents.count(entry.filename()));
+        assert(dir_contents.count(entry.filename()));
     }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    test_constructor_signatures();
+    test_construction_from_bad_path();
+    access_denied_test_case();
+    access_denied_to_file_test_case();
+    test_open_on_empty_directory_equals_end();
+    test_open_on_directory_succeeds();
+    test_open_on_file_fails();
+    test_open_on_empty_string();
+    test_open_on_dot_dir();
+    test_open_on_symlink();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/increment.pass.cpp

 // directory_iterator& increment(error_code& ec);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(directory_iterator_increment_tests)
-
-TEST_CASE(test_increment_signatures)
+static void test_increment_signatures()
 {
     directory_iterator d; ((void)d);
     std::error_code ec; ((void)ec);
 
     ASSERT_SAME_TYPE(decltype(++d), directory_iterator&);
     ASSERT_NOT_NOEXCEPT(++d);
 
     ASSERT_SAME_TYPE(decltype(d.increment(ec)), directory_iterator&);
     ASSERT_NOT_NOEXCEPT(d.increment(ec));
 }
 
-TEST_CASE(test_prefix_increment)
+static void test_prefix_increment()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
     const std::set<path> dir_contents(static_env.DirIterationList.begin(),
                                       static_env.DirIterationList.end());
     const directory_iterator endIt{};
 
     std::error_code ec;
     directory_iterator it(testDir, ec);
-    TEST_REQUIRE(!ec);
+    assert(!ec);
 
     std::set<path> unseen_entries = dir_contents;
     while (!unseen_entries.empty()) {
-        TEST_REQUIRE(it != endIt);
+        assert(it != endIt);
         const path entry = *it;
-        TEST_REQUIRE(unseen_entries.erase(entry) == 1);
+        assert(unseen_entries.erase(entry) == 1);
         directory_iterator& it_ref = ++it;
-        TEST_CHECK(&it_ref == &it);
+        assert(&it_ref == &it);
     }
 
-    TEST_CHECK(it == endIt);
+    assert(it == endIt);
 }
 
-TEST_CASE(test_postfix_increment)
+static void test_postfix_increment()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
     const std::set<path> dir_contents(static_env.DirIterationList.begin(),
                                       static_env.DirIterationList.end());
     const directory_iterator endIt{};
 
     std::error_code ec;
     directory_iterator it(testDir, ec);
-    TEST_REQUIRE(!ec);
+    assert(!ec);
 
     std::set<path> unseen_entries = dir_contents;
     while (!unseen_entries.empty()) {
-        TEST_REQUIRE(it != endIt);
+        assert(it != endIt);
         const path entry = *it;
-        TEST_REQUIRE(unseen_entries.erase(entry) == 1);
+        assert(unseen_entries.erase(entry) == 1);
         const path entry2 = *it++;
-        TEST_CHECK(entry2 == entry);
+        assert(entry2 == entry);
     }
 
-    TEST_CHECK(it == endIt);
+    assert(it == endIt);
 }
 
 
-TEST_CASE(test_increment_method)
+static void test_increment_method()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
     const std::set<path> dir_contents(static_env.DirIterationList.begin(),
                                       static_env.DirIterationList.end());
     const directory_iterator endIt{};
 
     std::error_code ec;
     directory_iterator it(testDir, ec);
-    TEST_REQUIRE(!ec);
+    assert(!ec);
 
     std::set<path> unseen_entries = dir_contents;
     while (!unseen_entries.empty()) {
-        TEST_REQUIRE(it != endIt);
+        assert(it != endIt);
         const path entry = *it;
-        TEST_REQUIRE(unseen_entries.erase(entry) == 1);
+        assert(unseen_entries.erase(entry) == 1);
         directory_iterator& it_ref = it.increment(ec);
-        TEST_REQUIRE(!ec);
-        TEST_CHECK(&it_ref == &it);
+        assert(!ec);
+        assert(&it_ref == &it);
     }
 
-    TEST_CHECK(it == endIt);
+    assert(it == endIt);
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    test_increment_signatures();
+    test_prefix_increment();
+    test_postfix_increment();
+    test_increment_method();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move.pass.cpp

 // directory_iterator(directory_iterator&&) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(directory_iterator_move_construct_tests)
-
-TEST_CASE(test_constructor_signature)
+static void test_constructor_signature()
 {
     using D = directory_iterator;
     static_assert(std::is_nothrow_move_constructible<D>::value, "");
 }
 
-TEST_CASE(test_move_end_iterator)
+static void test_move_end_iterator()
 {
     const directory_iterator endIt;
     directory_iterator endIt2{};
 
     directory_iterator it(std::move(endIt2));
-    TEST_CHECK(it == endIt);
-    TEST_CHECK(endIt2 == endIt);
+    assert(it == endIt);
+    assert(endIt2 == endIt);
 }
 
-TEST_CASE(test_move_valid_iterator)
+static void test_move_valid_iterator()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
     const directory_iterator endIt{};
 
     directory_iterator it(testDir);
-    TEST_REQUIRE(it != endIt);
+    assert(it != endIt);
     const path entry = *it;
 
     const directory_iterator it2(std::move(it));
-    TEST_CHECK(*it2 == entry);
+    assert(*it2 == entry);
 
-    TEST_CHECK(it == it2 || it == endIt);
+    assert(it == it2 || it == endIt);
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    test_constructor_signature();
+    test_move_end_iterator();
+    test_move_valid_iterator();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.members/move_assign.pass.cpp

 // directory_iterator& operator=(directory_iterator const&);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 // The filesystem specification explicitly allows for self-move on
 // the directory iterators. Turn off this warning so we can test it.
 TEST_CLANG_DIAGNOSTIC_IGNORED("-Wself-move")
 
 using namespace fs;
 
-TEST_SUITE(directory_iterator_move_assign_tests)
-
-TEST_CASE(test_assignment_signature)
+static void test_assignment_signature()
 {
     using D = directory_iterator;
     static_assert(std::is_nothrow_move_assignable<D>::value, "");
 }
 
-TEST_CASE(test_move_to_end_iterator)
+static void test_move_to_end_iterator()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
 
     directory_iterator from(testDir);
-    TEST_REQUIRE(from != directory_iterator{});
+    assert(from != directory_iterator{});
     const path entry = *from;
 
     directory_iterator to{};
     to = std::move(from);
-    TEST_REQUIRE(to != directory_iterator{});
-    TEST_CHECK(*to == entry);
+    assert(to != directory_iterator{});
+    assert(*to == entry);
 }
 
 
-TEST_CASE(test_move_from_end_iterator)
+static void test_move_from_end_iterator()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
 
     directory_iterator from{};
 
     directory_iterator to(testDir);
-    TEST_REQUIRE(to != from);
+    assert(to != from);
 
     to = std::move(from);
-    TEST_REQUIRE(to == directory_iterator{});
-    TEST_REQUIRE(from == directory_iterator{});
+    assert(to == directory_iterator{});
+    assert(from == directory_iterator{});
 }
 
-TEST_CASE(test_move_valid_iterator)
+static void test_move_valid_iterator()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
     const directory_iterator endIt{};
 
     directory_iterator it(testDir);
-    TEST_REQUIRE(it != endIt);
+    assert(it != endIt);
     ++it;
-    TEST_REQUIRE(it != endIt);
+    assert(it != endIt);
     const path entry = *it;
 
     directory_iterator it2(testDir);
-    TEST_REQUIRE(it2 != it);
+    assert(it2 != it);
     const path entry2 = *it2;
-    TEST_CHECK(entry2 != entry);
+    assert(entry2 != entry);
 
     it2 = std::move(it);
-    TEST_REQUIRE(it2 != directory_iterator{});
-    TEST_CHECK(*it2 == entry);
+    assert(it2 != directory_iterator{});
+    assert(*it2 == entry);
 }
 
-TEST_CASE(test_returns_reference_to_self)
+static void test_returns_reference_to_self()
 {
     directory_iterator it;
     directory_iterator it2;
     directory_iterator& ref = (it2 = it);
-    TEST_CHECK(&ref == &it2);
+    assert(&ref == &it2);
 }
 
 
-TEST_CASE(test_self_move)
+static void test_self_move()
 {
     static_test_env static_env;
     // Create two non-equal iterators that have exactly the same state.
     directory_iterator it(static_env.Dir);
     directory_iterator it2(static_env.Dir);
     ++it; ++it2;
-    TEST_CHECK(it != it2);
-    TEST_CHECK(*it2 == *it);
+    assert(it != it2);
+    assert(*it2 == *it);
 
     it = std::move(it);
-    TEST_CHECK(*it2 == *it);
+    assert(*it2 == *it);
 }
 
+int main(int, char**) {
+    test_assignment_signature();
+    test_move_to_end_iterator();
+    test_move_from_end_iterator();
+    test_move_valid_iterator();
+    test_returns_reference_to_self();
+    test_self_move();
 
-TEST_SUITE_END()
+    return 0;
+}

libcxx/test/std/input.output/filesystems/class.directory_iterator/directory_iterator.nonmembers/begin_end.pass.cpp

 // directory_iterator end(directory_iterator iter) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(directory_iterator_begin_end_tests)
-
-TEST_CASE(test_function_signatures)
+static void test_function_signatures()
 {
     directory_iterator d;
 
     ASSERT_SAME_TYPE(decltype(begin(d)), directory_iterator);
     ASSERT_SAME_TYPE(decltype(begin(std::move(d))), directory_iterator);
     ASSERT_NOEXCEPT(begin(d));
     ASSERT_NOEXCEPT(begin(std::move(d)));
 
     ASSERT_SAME_TYPE(decltype(end(d)), directory_iterator);
     ASSERT_SAME_TYPE(decltype(end(std::move(d))), directory_iterator);
     ASSERT_NOEXCEPT(end(d));
     ASSERT_NOEXCEPT(end(std::move(d)));
 }
 
-TEST_CASE(test_ranged_for_loop)
+static void test_ranged_for_loop()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
     std::set<path> dir_contents(static_env.DirIterationList.begin(),
                                 static_env.DirIterationList.end());
 
     std::error_code ec;
     directory_iterator it(testDir, ec);
-    TEST_REQUIRE(!ec);
+    assert(!ec);
 
     for (auto& elem : it) {
-        TEST_CHECK(dir_contents.erase(elem) == 1);
+        assert(dir_contents.erase(elem) == 1);
     }
-    TEST_CHECK(dir_contents.empty());
+    assert(dir_contents.empty());
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    test_function_signatures();
+    test_ranged_for_loop();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/copy.pass.cpp

 // recursive_recursive_directory_iterator(recursive_recursive_directory_iterator const&);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(recursive_directory_iterator_copy_construct_tests)
-
-TEST_CASE(test_constructor_signature)
+static void test_constructor_signature()
 {
     using D = recursive_directory_iterator;
     static_assert(std::is_copy_constructible<D>::value, "");
     //static_assert(!std::is_nothrow_copy_constructible<D>::value, "");
 }
 
-TEST_CASE(test_copy_end_iterator)
+static void test_copy_end_iterator()
 {
     const recursive_directory_iterator endIt;
     recursive_directory_iterator it(endIt);
-    TEST_CHECK(it == endIt);
+    assert(it == endIt);
 }
 
-TEST_CASE(test_copy_valid_iterator)
+static void test_copy_valid_iterator()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
     const recursive_directory_iterator endIt{};
 
     // build 'it' up with "interesting" non-default state so we can test
     // that it gets copied. We want to get 'it' into a state such that:
     //  it.options() != directory_options::none
     //  it.depth() != 0
     //  it.recursion_pending() != true
     const directory_options opts = directory_options::skip_permission_denied;
     recursive_directory_iterator it(testDir, opts);
-    TEST_REQUIRE(it != endIt);
+    assert(it != endIt);
     while (it.depth() == 0) {
         ++it;
-        TEST_REQUIRE(it != endIt);
+        assert(it != endIt);
     }
     it.disable_recursion_pending();
-    TEST_CHECK(it.options() == opts);
-    TEST_CHECK(it.depth() == 1);
-    TEST_CHECK(it.recursion_pending() == false);
+    assert(it.options() == opts);
+    assert(it.depth() == 1);
+    assert(it.recursion_pending() == false);
     const path entry = *it;
 
     // OPERATION UNDER TEST //
     const recursive_directory_iterator it2(it);
     // ------------------- //
 
-    TEST_REQUIRE(it2 == it);
-    TEST_CHECK(*it2 == entry);
-    TEST_CHECK(it2.depth() == 1);
-    TEST_CHECK(it2.recursion_pending() == false);
-    TEST_CHECK(it != endIt);
+    assert(it2 == it);
+    assert(*it2 == entry);
+    assert(it2.depth() == 1);
+    assert(it2.recursion_pending() == false);
+    assert(it != endIt);
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    test_constructor_signature();
+    test_copy_end_iterator();
+    test_copy_valid_iterator();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/copy_assign.pass.cpp

 // recursive_directory_iterator& operator=(recursive_directory_iterator const&);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(recursive_directory_iterator_copy_assign_tests)
-
 recursive_directory_iterator createInterestingIterator(const static_test_env &static_env)
     // Create an "interesting" iterator where all fields are
     // in a non-default state. The returned 'it' is in a
     // state such that:
     //   it.options() == directory_options::skip_permission_denied
     //   it.depth() == 1
     //   it.recursion_pending() == true
 {
     const path testDir = static_env.Dir;
     const recursive_directory_iterator endIt;
     recursive_directory_iterator it(testDir,
                                     directory_options::skip_permission_denied);
-    TEST_ASSERT(it != endIt);
+    assert(it != endIt);
     while (it.depth() != 1) {
         ++it;
-        TEST_ASSERT(it != endIt);
+        assert(it != endIt);
     }
-    TEST_ASSERT(it.depth() == 1);
+    assert(it.depth() == 1);
     it.disable_recursion_pending();
     return it;
 }
 
 
 recursive_directory_iterator createDifferentInterestingIterator(const static_test_env &static_env)
     // Create an "interesting" iterator where all fields are
     // in a non-default state. The returned 'it' is in a
     // state such that:
     //   it.options() == directory_options::follow_directory_symlink
     //   it.depth() == 2
     //   it.recursion_pending() == false
 {
     const path testDir = static_env.Dir;
     const recursive_directory_iterator endIt;
     recursive_directory_iterator it(testDir,
                                     directory_options::follow_directory_symlink);
-    TEST_ASSERT(it != endIt);
+    assert(it != endIt);
     while (it.depth() != 2) {
         ++it;
-        TEST_ASSERT(it != endIt);
+        assert(it != endIt);
     }
-    TEST_ASSERT(it.depth() == 2);
+    assert(it.depth() == 2);
     return it;
 }
 
-TEST_CASE(test_assignment_signature) {
+static void test_assignment_signature() {
     using D = recursive_directory_iterator;
     static_assert(std::is_copy_assignable<D>::value, "");
 }
 
-TEST_CASE(test_copy_to_end_iterator)
+static void test_copy_to_end_iterator()
 {
     static_test_env static_env;
     const recursive_directory_iterator endIt;
 
     const recursive_directory_iterator from = createInterestingIterator(static_env);
     const path entry = *from;
 
     recursive_directory_iterator to;
     to = from;
-    TEST_REQUIRE(to == from);
-    TEST_CHECK(*to == entry);
-    TEST_CHECK(to.options() == from.options());
-    TEST_CHECK(to.depth() == from.depth());
-    TEST_CHECK(to.recursion_pending() == from.recursion_pending());
+    assert(to == from);
+    assert(*to == entry);
+    assert(to.options() == from.options());
+    assert(to.depth() == from.depth());
+    assert(to.recursion_pending() == from.recursion_pending());
 }
 
 
-TEST_CASE(test_copy_from_end_iterator)
+static void test_copy_from_end_iterator()
 {
     static_test_env static_env;
     const recursive_directory_iterator from;
     recursive_directory_iterator to = createInterestingIterator(static_env);
 
     to = from;
-    TEST_REQUIRE(to == from);
-    TEST_CHECK(to == recursive_directory_iterator{});
+    assert(to == from);
+    assert(to == recursive_directory_iterator{});
 }
 
-TEST_CASE(test_copy_valid_iterator)
+static void test_copy_valid_iterator()
 {
     static_test_env static_env;
     const recursive_directory_iterator endIt;
 
     const recursive_directory_iterator it = createInterestingIterator(static_env);
     const path entry = *it;
 
     recursive_directory_iterator it2 = createDifferentInterestingIterator(static_env);
-    TEST_REQUIRE(it2                   != it);
-    TEST_CHECK(it2.options()           != it.options());
-    TEST_CHECK(it2.depth()             != it.depth());
-    TEST_CHECK(it2.recursion_pending() != it.recursion_pending());
-    TEST_CHECK(*it2                    != entry);
+    assert(it2                   != it);
+    assert(it2.options()           != it.options());
+    assert(it2.depth()             != it.depth());
+    assert(it2.recursion_pending() != it.recursion_pending());
+    assert(*it2                    != entry);
 
     it2 = it;
-    TEST_REQUIRE(it2                   == it);
-    TEST_CHECK(it2.options()           == it.options());
-    TEST_CHECK(it2.depth()             == it.depth());
-    TEST_CHECK(it2.recursion_pending() == it.recursion_pending());
-    TEST_CHECK(*it2                    == entry);
+    assert(it2                   == it);
+    assert(it2.options()           == it.options());
+    assert(it2.depth()             == it.depth());
+    assert(it2.recursion_pending() == it.recursion_pending());
+    assert(*it2                    == entry);
 }
 
-TEST_CASE(test_returns_reference_to_self)
+static void test_returns_reference_to_self()
 {
     const recursive_directory_iterator it;
     recursive_directory_iterator it2;
     recursive_directory_iterator& ref = (it2 = it);
-    TEST_CHECK(&ref == &it2);
+    assert(&ref == &it2);
 }
 
-TEST_CASE(test_self_copy)
+static void test_self_copy()
 {
     static_test_env static_env;
     // Create two non-equal iterators that have exactly the same state.
     recursive_directory_iterator it = createInterestingIterator(static_env);
     recursive_directory_iterator it2 = createInterestingIterator(static_env);
-    TEST_CHECK(it != it2);
-    TEST_CHECK(it2.options()           == it.options());
-    TEST_CHECK(it2.depth()             == it.depth());
-    TEST_CHECK(it2.recursion_pending() == it.recursion_pending());
-    TEST_CHECK(*it2 == *it);
+    assert(it != it2);
+    assert(it2.options()           == it.options());
+    assert(it2.depth()             == it.depth());
+    assert(it2.recursion_pending() == it.recursion_pending());
+    assert(*it2 == *it);
 
     // perform a self-copy and check that the state still matches the
     // other unmodified iterator.
     recursive_directory_iterator const& cit = it;
     it = cit;
-    TEST_CHECK(it2.options()           == it.options());
-    TEST_CHECK(it2.depth()             == it.depth());
-    TEST_CHECK(it2.recursion_pending() == it.recursion_pending());
-    TEST_CHECK(*it2 == *it);
+    assert(it2.options()           == it.options());
+    assert(it2.depth()             == it.depth());
+    assert(it2.recursion_pending() == it.recursion_pending());
+    assert(*it2 == *it);
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    test_assignment_signature();
+    test_copy_to_end_iterator();
+    test_copy_from_end_iterator();
+    test_copy_valid_iterator();
+    test_returns_reference_to_self();
+    test_self_copy();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/ctor.pass.cpp

 // recursive_directory_iterator(const path& p, directory_options options, error_code& ec);
 
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
+#include "assert_macros.h"
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
 using RDI = recursive_directory_iterator;
 
-TEST_SUITE(recursive_directory_iterator_constructor_tests)
-
-TEST_CASE(test_constructor_signatures)
+static void test_constructor_signatures()
 {
     using D = recursive_directory_iterator;
 
     // explicit directory_iterator(path const&);
     static_assert(!std::is_convertible<path, D>::value, "");
     static_assert(std::is_constructible<D, path>::value, "");
     static_assert(!std::is_nothrow_constructible<D, path>::value, "");
 
     // directory_iterator(path const&, error_code&)
     static_assert(std::is_constructible<D, path,
         std::error_code&>::value, "");
     static_assert(!std::is_nothrow_constructible<D, path,
         std::error_code&>::value, "");
 
     // directory_iterator(path const&, directory_options);
     static_assert(std::is_constructible<D, path, directory_options>::value, "");
     static_assert(!std::is_nothrow_constructible<D, path, directory_options>::value, "");
 
     // directory_iterator(path const&, directory_options, error_code&)
     static_assert(std::is_constructible<D, path, directory_options, std::error_code&>::value, "");
     static_assert(!std::is_nothrow_constructible<D, path, directory_options, std::error_code&>::value, "");
 }
 
-TEST_CASE(test_construction_from_bad_path)
+static void test_construction_from_bad_path()
 {
     static_test_env static_env;
     std::error_code ec;
     directory_options opts = directory_options::none;
     const RDI endIt;
 
     const path testPaths[] = { static_env.DNE, static_env.BadSymlink };
     for (path const& testPath : testPaths)
     {
         {
             RDI it(testPath, ec);
-            TEST_CHECK(ec);
-            TEST_CHECK(it == endIt);
+            assert(ec);
+            assert(it == endIt);
         }
         {
             RDI it(testPath, opts, ec);
-            TEST_CHECK(ec);
-            TEST_CHECK(it == endIt);
+            assert(ec);
+            assert(it == endIt);
         }
         {
-            TEST_CHECK_THROW(filesystem_error, RDI(testPath));
-            TEST_CHECK_THROW(filesystem_error, RDI(testPath, opts));
+            TEST_THROWS_TYPE(filesystem_error, RDI(testPath));
+            TEST_THROWS_TYPE(filesystem_error, RDI(testPath, opts));
         }
     }
 }
 
-TEST_CASE(access_denied_test_case)
+static void access_denied_test_case()
 {
     using namespace fs;
 #ifdef _WIN32
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories; test using a special inaccessible directory
     // instead.
     const path testDir = GetWindowsInaccessibleDir();
     if (testDir.empty())
-        TEST_UNSUPPORTED();
+        TEST_IS_UNSUPPORTED();
 #else
     scoped_test_env env;
     path const testDir = env.make_env_path("dir1");
     path const testFile = testDir / "testFile";
     env.create_dir(testDir);
     env.create_file(testFile, 42);
 
     // Test that we can iterator over the directory before changing the perms
     {
         RDI it(testDir);
-        TEST_REQUIRE(it != RDI{});
+        assert(it != RDI{});
     }
 
     // Change the permissions so we can no longer iterate
     permissions(testDir, perms::none);
 #endif
 
     // Check that the construction fails when skip_permissions_denied is
     // not given.
     {
         std::error_code ec;
         RDI it(testDir, ec);
-        TEST_REQUIRE(ec);
-        TEST_CHECK(it == RDI{});
+        assert(ec);
+        assert(it == RDI{});
     }
     // Check that construction does not report an error when
     // 'skip_permissions_denied' is given.
     {
         std::error_code ec;
         RDI it(testDir, directory_options::skip_permission_denied, ec);
-        TEST_REQUIRE(!ec);
-        TEST_CHECK(it == RDI{});
+        assert(!ec);
+        assert(it == RDI{});
     }
 }
 
 
-TEST_CASE(access_denied_to_file_test_case)
+static void access_denied_to_file_test_case()
 {
     using namespace fs;
 #ifdef _WIN32
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories; test using a special inaccessible directory
     // instead.
     const path testDir = GetWindowsInaccessibleDir();
     if (testDir.empty())
-        TEST_UNSUPPORTED();
+        TEST_IS_UNSUPPORTED();
     path const testFile = testDir / "inaccessible_file";
 #else
     scoped_test_env env;
     path const testFile = env.make_env_path("file1");
     env.create_file(testFile, 42);
 
     // Change the permissions so we can no longer iterate
     permissions(testFile, perms::none);
 #endif
 
     // Check that the construction fails when skip_permissions_denied is
     // not given.
     {
         std::error_code ec;
         RDI it(testFile, ec);
-        TEST_REQUIRE(ec);
-        TEST_CHECK(it == RDI{});
+        assert(ec);
+        assert(it == RDI{});
     }
     // Check that construction still fails when 'skip_permissions_denied' is given
     // because we tried to open a file and not a directory.
     {
         std::error_code ec;
         RDI it(testFile, directory_options::skip_permission_denied, ec);
-        TEST_REQUIRE(ec);
-        TEST_CHECK(it == RDI{});
+        assert(ec);
+        assert(it == RDI{});
     }
 }
 
-TEST_CASE(test_open_on_empty_directory_equals_end)
+static void test_open_on_empty_directory_equals_end()
 {
     scoped_test_env env;
     const path testDir = env.make_env_path("dir1");
     env.create_dir(testDir);
 
     const RDI endIt;
     {
         std::error_code ec;
         RDI it(testDir, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(it == endIt);
+        assert(!ec);
+        assert(it == endIt);
     }
     {
         RDI it(testDir);
-        TEST_CHECK(it == endIt);
+        assert(it == endIt);
     }
 }
 
-TEST_CASE(test_open_on_directory_succeeds)
+static void test_open_on_directory_succeeds()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
     std::set<path> dir_contents(static_env.DirIterationList.begin(),
                                 static_env.DirIterationList.end());
     const RDI endIt{};
 
     {
         std::error_code ec;
         RDI it(testDir, ec);
-        TEST_REQUIRE(!ec);
-        TEST_CHECK(it != endIt);
-        TEST_CHECK(dir_contents.count(*it));
+        assert(!ec);
+        assert(it != endIt);
+        assert(dir_contents.count(*it));
     }
     {
         RDI it(testDir);
-        TEST_CHECK(it != endIt);
-        TEST_CHECK(dir_contents.count(*it));
+        assert(it != endIt);
+        assert(dir_contents.count(*it));
     }
 }
 
-TEST_CASE(test_open_on_file_fails)
+static void test_open_on_file_fails()
 {
     static_test_env static_env;
     const path testFile = static_env.File;
     const RDI endIt{};
     {
         std::error_code ec;
         RDI it(testFile, ec);
-        TEST_REQUIRE(ec);
-        TEST_CHECK(it == endIt);
+        assert(ec);
+        assert(it == endIt);
     }
     {
-        TEST_CHECK_THROW(filesystem_error, RDI(testFile));
+        TEST_THROWS_TYPE(filesystem_error, RDI(testFile));
     }
 }
 
-TEST_CASE(test_options_post_conditions)
+static void test_options_post_conditions()
 {
     static_test_env static_env;
     const path goodDir = static_env.Dir;
     const path badDir = static_env.DNE;
 
     {
         std::error_code ec;
 
         RDI it1(goodDir, ec);
-        TEST_REQUIRE(!ec);
-        TEST_CHECK(it1.options() == directory_options::none);
+        assert(!ec);
+        assert(it1.options() == directory_options::none);
 
         RDI it2(badDir, ec);
-        TEST_REQUIRE(ec);
-        TEST_REQUIRE(it2 == RDI{});
+        assert(ec);
+        assert(it2 == RDI{});
     }
     {
         std::error_code ec;
         const directory_options opts = directory_options::skip_permission_denied;
 
         RDI it1(goodDir, opts, ec);
-        TEST_REQUIRE(!ec);
-        TEST_CHECK(it1.options() == opts);
+        assert(!ec);
+        assert(it1.options() == opts);
 
         RDI it2(badDir, opts, ec);
-        TEST_REQUIRE(ec);
-        TEST_REQUIRE(it2 == RDI{});
+        assert(ec);
+        assert(it2 == RDI{});
     }
     {
         RDI it(goodDir);
-        TEST_CHECK(it.options() == directory_options::none);
+        assert(it.options() == directory_options::none);
     }
     {
         const directory_options opts = directory_options::follow_directory_symlink;
         RDI it(goodDir, opts);
-        TEST_CHECK(it.options() == opts);
-    }
+        assert(it.options() == opts);
+    }
+
+int main(int, char**) {
+    test_constructor_signatures();
+    test_construction_from_bad_path();
+    access_denied_test_case();
+    access_denied_to_file_test_case();
+    test_open_on_empty_directory_equals_end();
+    test_open_on_directory_succeeds();
+    test_open_on_file_fails();
+    test_options_post_conditions();
+
+    return 0;
 }
-TEST_SUITE_END()

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/depth.pass.cpp

 // int depth() const
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(recursive_directory_iterator_depth_tests)
-
-TEST_CASE(test_depth)
+static void test_depth()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
     const path DirDepth1 = static_env.Dir2;
     const path DirDepth2 = static_env.Dir3;
     const recursive_directory_iterator endIt{};
 
     std::error_code ec;
     recursive_directory_iterator it(testDir, ec);
-    TEST_REQUIRE(!ec);
-    TEST_CHECK(it.depth() == 0);
+    assert(!ec);
+    assert(it.depth() == 0);
 
     bool seen_d1, seen_d2;
     seen_d1 = seen_d2 = false;
 
     while (it != endIt) {
         const path entry = *it;
         const path parent = entry.parent_path();
         if (parent == testDir) {
-            TEST_CHECK(it.depth() == 0);
+            assert(it.depth() == 0);
         } else if (parent == DirDepth1) {
-            TEST_CHECK(it.depth() == 1);
+            assert(it.depth() == 1);
             seen_d1 = true;
         } else if (parent == DirDepth2) {
-            TEST_CHECK(it.depth() == 2);
+            assert(it.depth() == 2);
             seen_d2 = true;
         } else {
-            TEST_CHECK(!"Unexpected depth while iterating over static env");
+            assert(!"Unexpected depth while iterating over static env");
         }
         ++it;
     }
-    TEST_REQUIRE(seen_d1 && seen_d2);
-    TEST_CHECK(it == endIt);
+    assert(seen_d1 && seen_d2);
+    assert(it == endIt);
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    test_depth();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/disable_recursion_pending.pass.cpp

 // void disable_recursion_pending();
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(recursive_directory_iterator_disable_recursion_pending_tests)
 
 // NOTE: The main semantics of disable_recursion_pending are tested
 // in the 'recursion_pending()' tests.
-TEST_CASE(basic_test)
+static void basic_test()
 {
     static_test_env static_env;
     recursive_directory_iterator it(static_env.Dir);
-    TEST_REQUIRE(it.recursion_pending() == true);
+    assert(it.recursion_pending() == true);
     it.disable_recursion_pending();
-    TEST_CHECK(it.recursion_pending() == false);
+    assert(it.recursion_pending() == false);
     it.disable_recursion_pending();
-    TEST_CHECK(it.recursion_pending() == false);
+    assert(it.recursion_pending() == false);
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    basic_test();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/increment.pass.cpp

 // recursive_directory_iterator& increment(error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(recursive_directory_iterator_increment_tests)
-
-TEST_CASE(test_increment_signatures)
+static void test_increment_signatures()
 {
     recursive_directory_iterator d; ((void)d);
     std::error_code ec; ((void)ec);
 
     ASSERT_SAME_TYPE(decltype(++d), recursive_directory_iterator&);
     ASSERT_NOT_NOEXCEPT(++d);
 
     ASSERT_SAME_TYPE(decltype(d.increment(ec)), recursive_directory_iterator&);
     ASSERT_NOT_NOEXCEPT(d.increment(ec));
 }
 
-TEST_CASE(test_prefix_increment)
+static void test_prefix_increment()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
     const std::set<path> dir_contents(static_env.RecDirIterationList.begin(),
                                       static_env.RecDirIterationList.end());
     const recursive_directory_iterator endIt{};
 
     std::error_code ec;
     recursive_directory_iterator it(testDir, ec);
-    TEST_REQUIRE(!ec);
+    assert(!ec);
 
     std::set<path> unseen_entries = dir_contents;
     while (!unseen_entries.empty()) {
-        TEST_REQUIRE(it != endIt);
+        assert(it != endIt);
         const path entry = *it;
-        TEST_REQUIRE(unseen_entries.erase(entry) == 1);
+        assert(unseen_entries.erase(entry) == 1);
         recursive_directory_iterator& it_ref = ++it;
-        TEST_CHECK(&it_ref == &it);
+        assert(&it_ref == &it);
     }
 
-    TEST_CHECK(it == endIt);
+    assert(it == endIt);
 }
 
-TEST_CASE(test_postfix_increment)
+static void test_postfix_increment()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
     const std::set<path> dir_contents(static_env.RecDirIterationList.begin(),
                                       static_env.RecDirIterationList.end());
     const recursive_directory_iterator endIt{};
 
     std::error_code ec;
     recursive_directory_iterator it(testDir, ec);
-    TEST_REQUIRE(!ec);
+    assert(!ec);
 
     std::set<path> unseen_entries = dir_contents;
     while (!unseen_entries.empty()) {
-        TEST_REQUIRE(it != endIt);
+        assert(it != endIt);
         const path entry = *it;
-        TEST_REQUIRE(unseen_entries.erase(entry) == 1);
+        assert(unseen_entries.erase(entry) == 1);
         const path entry2 = *it++;
-        TEST_CHECK(entry2 == entry);
+        assert(entry2 == entry);
     }
-    TEST_CHECK(it == endIt);
+    assert(it == endIt);
 }
 
 
-TEST_CASE(test_increment_method)
+static void test_increment_method()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
     const std::set<path> dir_contents(static_env.RecDirIterationList.begin(),
                                       static_env.RecDirIterationList.end());
     const recursive_directory_iterator endIt{};
 
     std::error_code ec;
     recursive_directory_iterator it(testDir, ec);
-    TEST_REQUIRE(!ec);
+    assert(!ec);
 
     std::set<path> unseen_entries = dir_contents;
     while (!unseen_entries.empty()) {
-        TEST_REQUIRE(it != endIt);
+        assert(it != endIt);
         const path entry = *it;
-        TEST_REQUIRE(unseen_entries.erase(entry) == 1);
+        assert(unseen_entries.erase(entry) == 1);
         recursive_directory_iterator& it_ref = it.increment(ec);
-        TEST_REQUIRE(!ec);
-        TEST_CHECK(&it_ref == &it);
+        assert(!ec);
+        assert(&it_ref == &it);
     }
 
-    TEST_CHECK(it == endIt);
+    assert(it == endIt);
 }
 
-TEST_CASE(test_follow_symlinks)
+static void test_follow_symlinks()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
     auto const& IterList = static_env.RecDirFollowSymlinksIterationList;
 
     const std::set<path> dir_contents(IterList.begin(), IterList.end());
     const recursive_directory_iterator endIt{};
 
     std::error_code ec;
     recursive_directory_iterator it(testDir,
                               directory_options::follow_directory_symlink, ec);
-    TEST_REQUIRE(!ec);
+    assert(!ec);
 
     std::set<path> unseen_entries = dir_contents;
     while (!unseen_entries.empty()) {
-        TEST_REQUIRE(it != endIt);
+        assert(it != endIt);
         const path entry = *it;
 
-        TEST_REQUIRE(unseen_entries.erase(entry) == 1);
+        assert(unseen_entries.erase(entry) == 1);
         recursive_directory_iterator& it_ref = it.increment(ec);
-        TEST_REQUIRE(!ec);
-        TEST_CHECK(&it_ref == &it);
+        assert(!ec);
+        assert(&it_ref == &it);
     }
-    TEST_CHECK(it == endIt);
+    assert(it == endIt);
 }
 
 // Windows doesn't support setting perms::none to trigger failures
 // reading directories.
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
-TEST_CASE(access_denied_on_recursion_test_case)
+static void access_denied_on_recursion_test_case()
 {
     using namespace fs;
     scoped_test_env env;
     const path testFiles[] = {
         env.create_dir("dir1"),
         env.create_dir("dir1/dir2"),
         env.create_file("dir1/dir2/file1"),
         env.create_file("dir1/file2")
     };
     const path startDir = testFiles[0];
     const path permDeniedDir = testFiles[1];
     const path otherFile = testFiles[3];
     auto SkipEPerm = directory_options::skip_permission_denied;
 
     // Change the permissions so we can no longer iterate
     permissions(permDeniedDir, perms::none);
 
     const recursive_directory_iterator endIt;
 
     // Test that recursion resulting in a "EACCESS" error is not ignored
     // by default.
     {
         std::error_code ec = GetTestEC();
         recursive_directory_iterator it(startDir, ec);
-        TEST_REQUIRE(ec != GetTestEC());
-        TEST_REQUIRE(!ec);
+        assert(ec != GetTestEC());
+        assert(!ec);
         while (it != endIt && it->path() != permDeniedDir)
             ++it;
-        TEST_REQUIRE(it != endIt);
-        TEST_REQUIRE(*it == permDeniedDir);
+        assert(it != endIt);
+        assert(*it == permDeniedDir);
 
         it.increment(ec);
-        TEST_CHECK(ec);
-        TEST_CHECK(it == endIt);
+        assert(ec);
+        assert(it == endIt);
     }
     // Same as above but test operator++().
     {
         std::error_code ec = GetTestEC();
         recursive_directory_iterator it(startDir, ec);
-        TEST_REQUIRE(!ec);
+        assert(!ec);
         while (it != endIt && it->path() != permDeniedDir)
             ++it;
-        TEST_REQUIRE(it != endIt);
-        TEST_REQUIRE(*it == permDeniedDir);
+        assert(it != endIt);
+        assert(*it == permDeniedDir);
 
-        TEST_REQUIRE_THROW(filesystem_error, ++it);
+        TEST_THROWS_TYPE(filesystem_error, ++it);
     }
     // Test that recursion resulting in a "EACCESS" error is ignored when the
     // correct options are given to the constructor.
     {
         std::error_code ec = GetTestEC();
         recursive_directory_iterator it(startDir, SkipEPerm, ec);
-        TEST_REQUIRE(!ec);
-        TEST_REQUIRE(it != endIt);
+        assert(!ec);
+        assert(it != endIt);
 
         bool seenOtherFile = false;
         if (*it == otherFile) {
             ++it;
             seenOtherFile = true;
-            TEST_REQUIRE (it != endIt);
+            assert (it != endIt);
         }
-        TEST_REQUIRE(*it == permDeniedDir);
+        assert(*it == permDeniedDir);
 
         ec = GetTestEC();
         it.increment(ec);
-        TEST_REQUIRE(!ec);
+        assert(!ec);
 
         if (seenOtherFile) {
-            TEST_CHECK(it == endIt);
+            assert(it == endIt);
         } else {
-            TEST_CHECK(it != endIt);
-            TEST_CHECK(*it == otherFile);
+            assert(it != endIt);
+            assert(*it == otherFile);
         }
     }
     // Test that construction resulting in a "EACCESS" error is not ignored
     // by default.
     {
         std::error_code ec;
         recursive_directory_iterator it(permDeniedDir, ec);
-        TEST_REQUIRE(ec);
-        TEST_REQUIRE(it == endIt);
+        assert(ec);
+        assert(it == endIt);
     }
     // Same as above but testing the throwing constructors
     {
-        TEST_REQUIRE_THROW(filesystem_error,
+        TEST_THROWS_TYPE(filesystem_error,
                            recursive_directory_iterator(permDeniedDir));
     }
     // Test that construction resulting in a "EACCESS" error constructs the
     // end iterator when the correct options are given.
     {
         std::error_code ec = GetTestEC();
         recursive_directory_iterator it(permDeniedDir, SkipEPerm, ec);
-        TEST_REQUIRE(!ec);
-        TEST_REQUIRE(it == endIt);
+        assert(!ec);
+        assert(it == endIt);
     }
 }
 
 // See llvm.org/PR35078
-TEST_CASE(test_PR35078)
+static void test_PR35078()
 {
   using namespace fs;
     scoped_test_env env;
     const path testFiles[] = {
         env.create_dir("dir1"),
         env.create_dir("dir1/dir2"),
         env.create_dir("dir1/dir2/dir3"),
         env.create_file("dir1/file1"),
auto SetupState = [&](bool AllowEAccess, bool& SeenFile3) {
         it.increment(ec);
       }
       return it;
     };
 
     {
       bool SeenNestedFile = false;
       recursive_directory_iterator it = SetupState(false, SeenNestedFile);
-      TEST_REQUIRE(it != endIt);
-      TEST_REQUIRE(*it == nestedDir);
+      assert(it != endIt);
+      assert(*it == nestedDir);
       ec = GetTestEC();
       it.increment(ec);
-      TEST_CHECK(ec);
-      TEST_CHECK(ErrorIs(ec, eacess));
-      TEST_CHECK(it == endIt);
+      assert(ec);
+      assert(ErrorIs(ec, eacess));
+      assert(it == endIt);
     }
     {
       bool SeenNestedFile = false;
       recursive_directory_iterator it = SetupState(true, SeenNestedFile);
-      TEST_REQUIRE(it != endIt);
-      TEST_REQUIRE(*it == nestedDir);
+      assert(it != endIt);
+      assert(*it == nestedDir);
       ec = GetTestEC();
       it.increment(ec);
-      TEST_CHECK(!ec);
+      assert(!ec);
       if (SeenNestedFile) {
-        TEST_CHECK(it == endIt);
+        assert(it == endIt);
       } else {
-        TEST_REQUIRE(it != endIt);
-        TEST_CHECK(*it == nestedFile);
+        assert(it != endIt);
+        assert(*it == nestedFile);
       }
     }
     {
       bool SeenNestedFile = false;
       recursive_directory_iterator it = SetupState(false, SeenNestedFile);
-      TEST_REQUIRE(it != endIt);
-      TEST_REQUIRE(*it == nestedDir);
+      assert(it != endIt);
+      assert(*it == nestedDir);
 
       ExceptionChecker Checker(std::errc::permission_denied,
                                "recursive_directory_iterator::operator++()",
                                format_string("attempting recursion into \"%s\"",
                                              nestedDir.string().c_str()));
-      TEST_CHECK_THROW_RESULT(filesystem_error, Checker, ++it);
+      TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, ++it);
     }
 }
 
 
 // See llvm.org/PR35078
-TEST_CASE(test_PR35078_with_symlink)
+static void test_PR35078_with_symlink()
 {
   using namespace fs;
     scoped_test_env env;
     const path testFiles[] = {
         env.create_dir("dir1"),
         env.create_file("dir1/file1"),
         env.create_dir("sym_dir"),
         env.create_dir("sym_dir/nested_sym_dir"),
struct {
         // Failing cases
         {false, true, false}
     };
     for (auto TC : TestCases) {
       bool SeenNestedFile = false;
       recursive_directory_iterator it = SetupState(TC.SkipPermDenied,
                                                    TC.FollowSymlinks,
                                                    SeenNestedFile);
-      TEST_REQUIRE(!ec);
-      TEST_REQUIRE(it != endIt);
-      TEST_REQUIRE(*it == symDir);
+      assert(!ec);
+      assert(it != endIt);
+      assert(*it == symDir);
       ec = GetTestEC();
       it.increment(ec);
       if (TC.ExpectSuccess) {
-        TEST_CHECK(!ec);
+        assert(!ec);
         if (SeenNestedFile) {
-          TEST_CHECK(it == endIt);
+          assert(it == endIt);
         } else {
-          TEST_REQUIRE(it != endIt);
-          TEST_CHECK(*it == nestedFile);
+          assert(it != endIt);
+          assert(*it == nestedFile);
         }
       } else {
-        TEST_CHECK(ec);
-        TEST_CHECK(ErrorIs(ec, eacess));
-        TEST_CHECK(it == endIt);
+        assert(ec);
+        assert(ErrorIs(ec, eacess));
+        assert(it == endIt);
       }
     }
 }
 
 
 // See llvm.org/PR35078
-TEST_CASE(test_PR35078_with_symlink_file)
+static void test_PR35078_with_symlink_file()
 {
   using namespace fs;
     scoped_test_env env;
     const path testFiles[] = {
         env.create_dir("dir1"),
         env.create_dir("dir1/dir2"),
         env.create_file("dir1/file2"),
         env.create_dir("sym_dir"),
struct {
         // Failing cases
         {false, true, false}
     };
     for (auto TC : TestCases){
       bool SeenNestedFile = false;
       recursive_directory_iterator it = SetupState(TC.SkipPermDenied,
                                                    TC.FollowSymlinks,
                                                    SeenNestedFile);
-      TEST_REQUIRE(!ec);
-      TEST_REQUIRE(it != EndIt);
-      TEST_REQUIRE(*it == nestedDir);
+      assert(!ec);
+      assert(it != EndIt);
+      assert(*it == nestedDir);
       ec = GetTestEC();
       it.increment(ec);
-      TEST_REQUIRE(it != EndIt);
-      TEST_CHECK(!ec);
-      TEST_CHECK(*it == symFile);
+      assert(it != EndIt);
+      assert(!ec);
+      assert(*it == symFile);
       ec = GetTestEC();
       it.increment(ec);
       if (TC.ExpectSuccess) {
         if (!SeenNestedFile) {
-          TEST_CHECK(!ec);
-          TEST_REQUIRE(it != EndIt);
-          TEST_CHECK(*it == nestedFile);
+          assert(!ec);
+          assert(it != EndIt);
+          assert(*it == nestedFile);
           ec = GetTestEC();
           it.increment(ec);
         }
-        TEST_CHECK(!ec);
-        TEST_CHECK(it == EndIt);
+        assert(!ec);
+        assert(it == EndIt);
       } else {
-        TEST_CHECK(ec);
-        TEST_CHECK(ErrorIs(ec, eacess));
-        TEST_CHECK(it == EndIt);
+        assert(ec);
+        assert(ErrorIs(ec, eacess));
+        assert(it == EndIt);
       }
     }
 }
-#endif
+#endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
 
+int main(int, char**) {
+    test_increment_signatures();
+    test_prefix_increment();
+    test_postfix_increment();
+    test_increment_method();
+    test_follow_symlinks();
+#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
+    access_denied_on_recursion_test_case();
+    test_PR35078();
+    test_PR35078_with_symlink();
+    test_PR35078_with_symlink_file();
+#endif
 
-TEST_SUITE_END()
+    return 0;
+}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move.pass.cpp

 // recursive_directory_iterator(recursive_directory_iterator&&) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(recursive_directory_iterator_move_construct_tests)
-
-TEST_CASE(test_constructor_signature)
+static void test_constructor_signature()
 {
     using D = recursive_directory_iterator;
     static_assert(std::is_nothrow_move_constructible<D>::value, "");
 }
 
-TEST_CASE(test_move_end_iterator)
+static void test_move_end_iterator()
 {
     const recursive_directory_iterator endIt;
     recursive_directory_iterator endIt2{};
 
     recursive_directory_iterator it(std::move(endIt2));
-    TEST_CHECK(it == endIt);
-    TEST_CHECK(endIt2 == endIt);
+    assert(it == endIt);
+    assert(endIt2 == endIt);
 }
 
-TEST_CASE(test_move_valid_iterator)
+static void test_move_valid_iterator()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
     const recursive_directory_iterator endIt{};
 
     // build 'it' up with "interesting" non-default state so we can test
     // that it gets copied. We want to get 'it' into a state such that:
     //  it.options() != directory_options::none
     //  it.depth() != 0
     //  it.recursion_pending() != true
     const directory_options opts = directory_options::skip_permission_denied;
     recursive_directory_iterator it(testDir, opts);
-    TEST_REQUIRE(it != endIt);
+    assert(it != endIt);
     while (it.depth() == 0) {
         ++it;
-        TEST_REQUIRE(it != endIt);
+        assert(it != endIt);
     }
     it.disable_recursion_pending();
-    TEST_CHECK(it.options() == opts);
-    TEST_CHECK(it.depth() == 1);
-    TEST_CHECK(it.recursion_pending() == false);
+    assert(it.options() == opts);
+    assert(it.depth() == 1);
+    assert(it.recursion_pending() == false);
     const path entry = *it;
 
     // OPERATION UNDER TEST //
     const recursive_directory_iterator it2(std::move(it));
     // ------------------- //
 
-    TEST_REQUIRE(it2 != endIt);
-    TEST_CHECK(*it2 == entry);
-    TEST_CHECK(it2.depth() == 1);
-    TEST_CHECK(it2.recursion_pending() == false);
+    assert(it2 != endIt);
+    assert(*it2 == entry);
+    assert(it2.depth() == 1);
+    assert(it2.recursion_pending() == false);
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    test_constructor_signature();
+    test_move_end_iterator();
+    test_move_valid_iterator();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/move_assign.pass.cpp

 // recursive_directory_iterator& operator=(recursive_directory_iterator const&);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 // The filesystem specification explicitly allows for self-move on
 // the directory iterators. Turn off this warning so we can test it.
 TEST_CLANG_DIAGNOSTIC_IGNORED("-Wself-move")
 
 using namespace fs;
 
-TEST_SUITE(recursive_directory_iterator_move_assign_tests)
-
 recursive_directory_iterator createInterestingIterator(const static_test_env &static_env)
     // Create an "interesting" iterator where all fields are
     // in a non-default state. The returned 'it' is in a
     // state such that:
     //   it.options() == directory_options::skip_permission_denied
     //   it.depth() == 1
     //   it.recursion_pending() == true
 {
     const path testDir = static_env.Dir;
     const recursive_directory_iterator endIt;
     recursive_directory_iterator it(testDir,
                                     directory_options::skip_permission_denied);
-    TEST_ASSERT(it != endIt);
+    assert(it != endIt);
     while (it.depth() != 1) {
         ++it;
-        TEST_ASSERT(it != endIt);
+        assert(it != endIt);
     }
-    TEST_ASSERT(it.depth() == 1);
+    assert(it.depth() == 1);
     it.disable_recursion_pending();
     return it;
 }
 
 recursive_directory_iterator createDifferentInterestingIterator(const static_test_env &static_env)
     // Create an "interesting" iterator where all fields are
     // in a non-default state. The returned 'it' is in a
     // state such that:
     //   it.options() == directory_options::follow_directory_symlink
     //   it.depth() == 2
     //   it.recursion_pending() == false
 {
     const path testDir = static_env.Dir;
     const recursive_directory_iterator endIt;
     recursive_directory_iterator it(testDir,
                                     directory_options::follow_directory_symlink);
-    TEST_ASSERT(it != endIt);
+    assert(it != endIt);
     while (it.depth() != 2) {
         ++it;
-        TEST_ASSERT(it != endIt);
+        assert(it != endIt);
     }
-    TEST_ASSERT(it.depth() == 2);
+    assert(it.depth() == 2);
     return it;
 }
 
 
-TEST_CASE(test_assignment_signature)
+static void test_assignment_signature()
 {
     using D = recursive_directory_iterator;
     static_assert(std::is_nothrow_move_assignable<D>::value, "");
 }
 
 
-TEST_CASE(test_move_to_end_iterator)
+static void test_move_to_end_iterator()
 {
     static_test_env static_env;
     const recursive_directory_iterator endIt;
 
     recursive_directory_iterator from = createInterestingIterator(static_env);
     const recursive_directory_iterator from_copy(from);
     const path entry = *from;
 
     recursive_directory_iterator to;
     to = std::move(from);
-    TEST_REQUIRE(to != endIt);
-    TEST_CHECK(*to == entry);
-    TEST_CHECK(to.options() == from_copy.options());
-    TEST_CHECK(to.depth() == from_copy.depth());
-    TEST_CHECK(to.recursion_pending() == from_copy.recursion_pending());
-    TEST_CHECK(from == endIt || from == to);
+    assert(to != endIt);
+    assert(*to == entry);
+    assert(to.options() == from_copy.options());
+    assert(to.depth() == from_copy.depth());
+    assert(to.recursion_pending() == from_copy.recursion_pending());
+    assert(from == endIt || from == to);
 }
 
 
-TEST_CASE(test_move_from_end_iterator)
+static void test_move_from_end_iterator()
 {
     static_test_env static_env;
     recursive_directory_iterator from;
     recursive_directory_iterator to = createInterestingIterator(static_env);
 
     to = std::move(from);
-    TEST_REQUIRE(to == from);
-    TEST_CHECK(to == recursive_directory_iterator{});
+    assert(to == from);
+    assert(to == recursive_directory_iterator{});
 }
 
-TEST_CASE(test_move_valid_iterator)
+static void test_move_valid_iterator()
 {
     static_test_env static_env;
     const recursive_directory_iterator endIt;
 
     recursive_directory_iterator it = createInterestingIterator(static_env);
     const recursive_directory_iterator it_copy(it);
     const path entry = *it;
 
     recursive_directory_iterator it2 = createDifferentInterestingIterator(static_env);
     const recursive_directory_iterator it2_copy(it2);
-    TEST_REQUIRE(it2 != it);
-    TEST_CHECK(it2.options() != it.options());
-    TEST_CHECK(it2.depth() != it.depth());
-    TEST_CHECK(it2.recursion_pending() != it.recursion_pending());
-    TEST_CHECK(*it2 != entry);
+    assert(it2 != it);
+    assert(it2.options() != it.options());
+    assert(it2.depth() != it.depth());
+    assert(it2.recursion_pending() != it.recursion_pending());
+    assert(*it2 != entry);
 
     it2 = std::move(it);
-    TEST_REQUIRE(it2 != it2_copy && it2 != endIt);
-    TEST_CHECK(it2.options() == it_copy.options());
-    TEST_CHECK(it2.depth() == it_copy.depth());
-    TEST_CHECK(it2.recursion_pending() == it_copy.recursion_pending());
-    TEST_CHECK(*it2 == entry);
-    TEST_CHECK(it == endIt || it == it2);
+    assert(it2 != it2_copy && it2 != endIt);
+    assert(it2.options() == it_copy.options());
+    assert(it2.depth() == it_copy.depth());
+    assert(it2.recursion_pending() == it_copy.recursion_pending());
+    assert(*it2 == entry);
+    assert(it == endIt || it == it2);
 }
 
-TEST_CASE(test_returns_reference_to_self)
+static void test_returns_reference_to_self()
 {
     recursive_directory_iterator it;
     recursive_directory_iterator it2;
     recursive_directory_iterator& ref = (it2 = std::move(it));
-    TEST_CHECK(&ref == &it2);
+    assert(&ref == &it2);
 }
 
-TEST_CASE(test_self_move)
+static void test_self_move()
 {
     static_test_env static_env;
     // Create two non-equal iterators that have exactly the same state.
     recursive_directory_iterator it = createInterestingIterator(static_env);
     recursive_directory_iterator it2 = createInterestingIterator(static_env);
-    TEST_CHECK(it != it2);
-    TEST_CHECK(it2.options()           == it.options());
-    TEST_CHECK(it2.depth()             == it.depth());
-    TEST_CHECK(it2.recursion_pending() == it.recursion_pending());
-    TEST_CHECK(*it2 == *it);
+    assert(it != it2);
+    assert(it2.options()           == it.options());
+    assert(it2.depth()             == it.depth());
+    assert(it2.recursion_pending() == it.recursion_pending());
+    assert(*it2 == *it);
 
     it = std::move(it);
-    TEST_CHECK(it2.options()           == it.options());
-    TEST_CHECK(it2.depth()             == it.depth());
-    TEST_CHECK(it2.recursion_pending() == it.recursion_pending());
-    TEST_CHECK(*it2 == *it);
+    assert(it2.options()           == it.options());
+    assert(it2.depth()             == it.depth());
+    assert(it2.recursion_pending() == it.recursion_pending());
+    assert(*it2 == *it);
 }
 
+int main(int, char**) {
+    test_assignment_signature();
+    test_move_to_end_iterator();
+    test_move_from_end_iterator();
+    test_move_valid_iterator();
+    test_returns_reference_to_self();
+    test_self_move();
 
-TEST_SUITE_END()
+    return 0;
+}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/pop.pass.cpp

 // void pop();
 // void pop(error_code& ec);
 
 #include "filesystem_include.h"
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(recursive_directory_iterator_pop_tests)
-
-TEST_CASE(signature_tests)
+static void signature_tests()
 {
     recursive_directory_iterator it{}; ((void)it);
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(it.pop());
     ASSERT_NOT_NOEXCEPT(it.pop(ec)); // may require allocation or other things
 }
 
 // NOTE: Since the order of iteration is unspecified we use a list of
 // seen files at each depth to determine the new depth after a 'pop()' operation.
-TEST_CASE(test_depth)
+static void test_depth()
 {
     static_test_env static_env;
     const recursive_directory_iterator endIt{};
 
     auto& DE0 = static_env.DirIterationList;
     std::set<path> notSeenDepth0(DE0.begin(), DE0.end());
 
     auto& DE1 = static_env.DirIterationListDepth1;
     std::set<path> notSeenDepth1(DE1.begin(), DE1.end());
 
     std::error_code ec;
     recursive_directory_iterator it(static_env.Dir, ec);
-    TEST_REQUIRE(it != endIt);
-    TEST_CHECK(it.depth() == 0);
+    assert(it != endIt);
+    assert(it.depth() == 0);
 
     while (it.depth() != 2) {
         if (it.depth() == 0)
             notSeenDepth0.erase(it->path());
         else
             notSeenDepth1.erase(it->path());
         ++it;
-        TEST_REQUIRE(it != endIt);
+        assert(it != endIt);
     }
 
     while (true) {
         auto set_ec = std::make_error_code(std::errc::address_in_use);
         it.pop(set_ec);
-        TEST_REQUIRE(!set_ec);
+        assert(!set_ec);
 
         if (it == endIt) {
             // We must have seen every entry at depth 0 and 1.
-            TEST_REQUIRE(notSeenDepth0.empty() && notSeenDepth1.empty());
+            assert(notSeenDepth0.empty() && notSeenDepth1.empty());
             break;
         }
         else if (it.depth() == 1) {
             // If we popped to depth 1 then there must be unseen entries
             // at this level.
-            TEST_REQUIRE(!notSeenDepth1.empty());
-            TEST_CHECK(notSeenDepth1.count(it->path()));
+            assert(!notSeenDepth1.empty());
+            assert(notSeenDepth1.count(it->path()));
             notSeenDepth1.clear();
         }
         else if (it.depth() == 0) {
             // If we popped to depth 0 there must be unseen entries at this
             // level. There should also be no unseen entries at depth 1.
-            TEST_REQUIRE(!notSeenDepth0.empty());
-            TEST_REQUIRE(notSeenDepth1.empty());
-            TEST_CHECK(notSeenDepth0.count(it->path()));
+            assert(!notSeenDepth0.empty());
+            assert(notSeenDepth1.empty());
+            assert(notSeenDepth0.count(it->path()));
             notSeenDepth0.clear();
         }
     }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_tests();
+    test_depth();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.members/recursion_pending.pass.cpp

 // bool recursion_pending() const;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(recursive_directory_iterator_recursion_pending_tests)
-
-TEST_CASE(initial_value_test)
+static void initial_value_test()
 {
     static_test_env static_env;
     recursive_directory_iterator it(static_env.Dir);
-    TEST_REQUIRE(it.recursion_pending() == true);
+    assert(it.recursion_pending() == true);
 }
 
-TEST_CASE(value_after_copy_construction_and_assignment_test)
+static void value_after_copy_construction_and_assignment_test()
 {
     static_test_env static_env;
     recursive_directory_iterator rec_pending_it(static_env.Dir);
     recursive_directory_iterator no_rec_pending_it(static_env.Dir);
     no_rec_pending_it.disable_recursion_pending();
 
     { // copy construction
         recursive_directory_iterator it(rec_pending_it);
-        TEST_CHECK(it.recursion_pending() == true);
+        assert(it.recursion_pending() == true);
         it.disable_recursion_pending();
-        TEST_REQUIRE(rec_pending_it.recursion_pending() == true);
+        assert(rec_pending_it.recursion_pending() == true);
 
         recursive_directory_iterator it2(no_rec_pending_it);
-        TEST_CHECK(it2.recursion_pending() == false);
+        assert(it2.recursion_pending() == false);
     }
     { // copy assignment
         recursive_directory_iterator it(static_env.Dir);
         it.disable_recursion_pending();
         it = rec_pending_it;
-        TEST_CHECK(it.recursion_pending() == true);
+        assert(it.recursion_pending() == true);
         it.disable_recursion_pending();
-        TEST_REQUIRE(rec_pending_it.recursion_pending() == true);
+        assert(rec_pending_it.recursion_pending() == true);
 
         recursive_directory_iterator it2(static_env.Dir);
         it2 = no_rec_pending_it;
-        TEST_CHECK(it2.recursion_pending() == false);
+        assert(it2.recursion_pending() == false);
     }
-    TEST_CHECK(rec_pending_it.recursion_pending() == true);
-    TEST_CHECK(no_rec_pending_it.recursion_pending() == false);
+    assert(rec_pending_it.recursion_pending() == true);
+    assert(no_rec_pending_it.recursion_pending() == false);
 }
 
 
-TEST_CASE(value_after_move_construction_and_assignment_test)
+static void value_after_move_construction_and_assignment_test()
 {
     static_test_env static_env;
     recursive_directory_iterator rec_pending_it(static_env.Dir);
     recursive_directory_iterator no_rec_pending_it(static_env.Dir);
     no_rec_pending_it.disable_recursion_pending();
 
     { // move construction
         recursive_directory_iterator it_cp(rec_pending_it);
         recursive_directory_iterator it(std::move(it_cp));
-        TEST_CHECK(it.recursion_pending() == true);
+        assert(it.recursion_pending() == true);
 
         recursive_directory_iterator it_cp2(no_rec_pending_it);
         recursive_directory_iterator it2(std::move(it_cp2));
-        TEST_CHECK(it2.recursion_pending() == false);
+        assert(it2.recursion_pending() == false);
     }
     { // copy assignment
         recursive_directory_iterator it(static_env.Dir);
         it.disable_recursion_pending();
         recursive_directory_iterator it_cp(rec_pending_it);
         it = std::move(it_cp);
-        TEST_CHECK(it.recursion_pending() == true);
+        assert(it.recursion_pending() == true);
 
         recursive_directory_iterator it2(static_env.Dir);
         recursive_directory_iterator it_cp2(no_rec_pending_it);
         it2 = std::move(it_cp2);
-        TEST_CHECK(it2.recursion_pending() == false);
+        assert(it2.recursion_pending() == false);
     }
-    TEST_CHECK(rec_pending_it.recursion_pending() == true);
-    TEST_CHECK(no_rec_pending_it.recursion_pending() == false);
+    assert(rec_pending_it.recursion_pending() == true);
+    assert(no_rec_pending_it.recursion_pending() == false);
 }
 
-TEST_CASE(increment_resets_value)
+static void increment_resets_value()
 {
     static_test_env static_env;
     const recursive_directory_iterator endIt;
     {
         recursive_directory_iterator it(static_env.Dir);
         it.disable_recursion_pending();
-        TEST_CHECK(it.recursion_pending() == false);
+        assert(it.recursion_pending() == false);
         ++it;
-        TEST_CHECK(it.recursion_pending() == true);
-        TEST_CHECK(it.depth() == 0);
+        assert(it.recursion_pending() == true);
+        assert(it.depth() == 0);
     }
     {
         recursive_directory_iterator it(static_env.Dir);
         it.disable_recursion_pending();
-        TEST_CHECK(it.recursion_pending() == false);
+        assert(it.recursion_pending() == false);
         it++;
-        TEST_CHECK(it.recursion_pending() == true);
-        TEST_CHECK(it.depth() == 0);
+        assert(it.recursion_pending() == true);
+        assert(it.depth() == 0);
     }
     {
         recursive_directory_iterator it(static_env.Dir);
         it.disable_recursion_pending();
-        TEST_CHECK(it.recursion_pending() == false);
+        assert(it.recursion_pending() == false);
         std::error_code ec;
         it.increment(ec);
-        TEST_CHECK(it.recursion_pending() == true);
-        TEST_CHECK(it.depth() == 0);
+        assert(it.recursion_pending() == true);
+        assert(it.depth() == 0);
     }
 }
 
-TEST_CASE(pop_does_not_reset_value)
+static void pop_does_not_reset_value()
 {
     static_test_env static_env;
     const recursive_directory_iterator endIt;
 
     auto& DE0 = static_env.DirIterationList;
     std::set<path> notSeenDepth0(DE0.begin(), DE0.end());
 
     recursive_directory_iterator it(static_env.Dir);
-    TEST_REQUIRE(it != endIt);
+    assert(it != endIt);
 
     while (it.depth() == 0) {
         notSeenDepth0.erase(it->path());
         ++it;
-        TEST_REQUIRE(it != endIt);
+        assert(it != endIt);
     }
-    TEST_REQUIRE(it.depth() == 1);
+    assert(it.depth() == 1);
     it.disable_recursion_pending();
     it.pop();
     // Since the order of iteration is unspecified the pop() could result
     // in the end iterator. When this is the case it is undefined behavior
     // to call recursion_pending().
     if (it == endIt) {
-        TEST_CHECK(notSeenDepth0.empty());
+        assert(notSeenDepth0.empty());
 #if defined(_LIBCPP_VERSION)
-        TEST_CHECK(it.recursion_pending() == false);
+        assert(it.recursion_pending() == false);
 #endif
     } else {
-        TEST_CHECK(! notSeenDepth0.empty());
-        TEST_CHECK(it.recursion_pending() == false);
+        assert(! notSeenDepth0.empty());
+        assert(it.recursion_pending() == false);
     }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    initial_value_test();
+    value_after_copy_construction_and_assignment_test();
+    value_after_move_construction_and_assignment_test();
+    increment_resets_value();
+    pop_does_not_reset_value();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/class.rec.dir.itr/rec.dir.itr.nonmembers/begin_end.pass.cpp

 // recursive_directory_iterator end(recursive_directory_iterator iter) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <set>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(recursive_directory_iterator_begin_end_tests)
-
-TEST_CASE(test_function_signatures)
+static void test_function_signatures()
 {
     recursive_directory_iterator d;
 
     ASSERT_SAME_TYPE(decltype(begin(d)), recursive_directory_iterator);
     ASSERT_SAME_TYPE(decltype(begin(std::move(d))), recursive_directory_iterator);
     ASSERT_NOEXCEPT(begin(d));
     ASSERT_NOEXCEPT(begin(std::move(d)));
 
     ASSERT_SAME_TYPE(decltype(end(d)), recursive_directory_iterator);
     ASSERT_SAME_TYPE(decltype(end(std::move(d))), recursive_directory_iterator);
     ASSERT_NOEXCEPT(end(d));
     ASSERT_NOEXCEPT(end(std::move(d)));
 }
 
-TEST_CASE(test_ranged_for_loop)
+static void test_ranged_for_loop()
 {
     static_test_env static_env;
     const path testDir = static_env.Dir;
     std::set<path> dir_contents(static_env.RecDirIterationList.begin(),
                                 static_env.RecDirIterationList.end());
 
     std::error_code ec;
     recursive_directory_iterator it(testDir, ec);
-    TEST_REQUIRE(!ec);
+    assert(!ec);
 
     for (auto& elem : it) {
-        TEST_CHECK(dir_contents.erase(elem) == 1);
+        assert(dir_contents.erase(elem) == 1);
     }
-    TEST_CHECK(dir_contents.empty());
+    assert(dir_contents.empty());
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    test_function_signatures();
+    test_ranged_for_loop();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.hard_lk_ct/hard_link_count.pass.cpp

 // uintmax_t hard_link_count(const path& p);
 // uintmax_t hard_link_count(const path& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(hard_link_count_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_SAME_TYPE(decltype(hard_link_count(p)), uintmax_t);
     ASSERT_SAME_TYPE(decltype(hard_link_count(p, ec)), uintmax_t);
     ASSERT_NOT_NOEXCEPT(hard_link_count(p));
     ASSERT_NOEXCEPT(hard_link_count(p, ec));
 }
 
-TEST_CASE(hard_link_count_for_file)
+static void hard_link_count_for_file()
 {
     static_test_env static_env;
-    TEST_CHECK(hard_link_count(static_env.File) == 1);
+    assert(hard_link_count(static_env.File) == 1);
     std::error_code ec;
-    TEST_CHECK(hard_link_count(static_env.File, ec) == 1);
+    assert(hard_link_count(static_env.File, ec) == 1);
 }
 
-TEST_CASE(hard_link_count_for_directory)
+static void hard_link_count_for_directory()
 {
     static_test_env static_env;
     uintmax_t DirExpect = 3; // hard link from . .. and Dir2
     uintmax_t Dir3Expect = 2; // hard link from . ..
     uintmax_t DirExpectAlt = DirExpect;
     uintmax_t Dir3ExpectAlt = Dir3Expect;
 #if defined(__APPLE__)
     // Filesystems formatted with case sensitive hfs+ behave unixish as
     // expected. Normal hfs+ filesystems report the number of directory
     // entries instead.
     DirExpectAlt = 5; // .  ..  Dir2  file1  file2
     Dir3Expect = 3; // .  ..  file5
 #endif
-    TEST_CHECK(hard_link_count(static_env.Dir) == DirExpect ||
+    assert(hard_link_count(static_env.Dir) == DirExpect ||
                hard_link_count(static_env.Dir) == DirExpectAlt ||
                hard_link_count(static_env.Dir) == 1);
-    TEST_CHECK(hard_link_count(static_env.Dir3) == Dir3Expect ||
+    assert(hard_link_count(static_env.Dir3) == Dir3Expect ||
                hard_link_count(static_env.Dir3) == Dir3ExpectAlt ||
                hard_link_count(static_env.Dir3) == 1);
 
     std::error_code ec;
-    TEST_CHECK(hard_link_count(static_env.Dir, ec) == DirExpect ||
+    assert(hard_link_count(static_env.Dir, ec) == DirExpect ||
                hard_link_count(static_env.Dir, ec) == DirExpectAlt ||
                hard_link_count(static_env.Dir) == 1);
-    TEST_CHECK(hard_link_count(static_env.Dir3, ec) == Dir3Expect ||
+    assert(hard_link_count(static_env.Dir3, ec) == Dir3Expect ||
                hard_link_count(static_env.Dir3, ec) == Dir3ExpectAlt ||
                hard_link_count(static_env.Dir3) == 1);
 }
-TEST_CASE(hard_link_count_increments_test)
+
+static void hard_link_count_increments_test()
 {
     scoped_test_env env;
     const path file = env.create_file("file", 42);
-    TEST_CHECK(hard_link_count(file) == 1);
+    assert(hard_link_count(file) == 1);
 
     env.create_hardlink(file, "file_hl");
-    TEST_CHECK(hard_link_count(file) == 2);
+    assert(hard_link_count(file) == 2);
 }
 
 
-TEST_CASE(hard_link_count_error_cases)
+static void hard_link_count_error_cases()
 {
     static_test_env static_env;
     const path testCases[] = {
         static_env.BadSymlink,
         static_env.DNE
     };
     const uintmax_t expect = static_cast<uintmax_t>(-1);
     for (auto& TC : testCases) {
         std::error_code ec;
-        TEST_CHECK(hard_link_count(TC, ec) == expect);
-        TEST_CHECK(ec);
+        assert(hard_link_count(TC, ec) == expect);
+        assert(ec);
     }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_test();
+    hard_link_count_for_file();
+    hard_link_count_for_directory();
+    hard_link_count_increments_test();
+    hard_link_count_error_cases();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.absolute/absolute.pass.cpp

 
 // path absolute(const path& p, const path& base=current_path());
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(filesystem_absolute_path_test_suite)
-
-TEST_CASE(absolute_signature_test)
+static void absolute_signature_test()
 {
     const path p; ((void)p);
     std::error_code ec;
     ASSERT_NOT_NOEXCEPT(absolute(p));
     ASSERT_NOT_NOEXCEPT(absolute(p, ec));
 }
 
 
-TEST_CASE(basic_test)
+static void basic_test()
 {
     const fs::path cwd = fs::current_path();
     const struct {
       std::string input;
       fs::path expect;
     } TestCases [] = {
         {"", cwd / ""},
         {"foo", cwd / "foo"},
         {"foo/", cwd / "foo/"},
         {"/already_absolute", cwd.root_name() / "/already_absolute"}
     };
     for (auto& TC : TestCases) {
         std::error_code ec = GetTestEC();
         const path ret = absolute(TC.input, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(ret.is_absolute());
-        TEST_CHECK(PathEqIgnoreSep(ret, TC.expect));
-        LIBCPP_ONLY(TEST_CHECK(PathEq(ret, TC.expect)));
+        assert(!ec);
+        assert(ret.is_absolute());
+        assert(PathEqIgnoreSep(ret, TC.expect));
+        LIBCPP_ONLY(assert(PathEq(ret, TC.expect)));
     }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    absolute_signature_test();
+    basic_test();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.canonical/canonical.pass.cpp

 // path canonical(const path& p);
 // path canonical(const path& p, error_code& ec);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(filesystem_canonical_path_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(canonical(p));
     ASSERT_NOT_NOEXCEPT(canonical(p, ec));
 }
 
 // There are 4 cases is the proposal for absolute path.
 // Each scope tests one of the cases.
-TEST_CASE(test_canonical)
+static void test_canonical()
 {
     static_test_env static_env;
     CWDGuard guard;
     // has_root_name() && has_root_directory()
     const path Root = static_env.Root;
     const path RootName = Root.filename();
     const path DirName = static_env.Dir.filename();
     const path SymlinkName = static_env.SymlinkToFile.filename();
const TestCase testCases[] = {
           Root },
         { static_env.SymlinkToFile,  static_env.File, Root },
         { SymlinkName, static_env.File, Root}
     };
     for (auto& TC : testCases) {
         std::error_code ec = GetTestEC();
         fs::current_path(TC.base);
         const path ret = canonical(TC.p, ec);
-        TEST_REQUIRE(!ec);
+        assert(!ec);
         const path ret2 = canonical(TC.p);
-        TEST_CHECK(PathEq(ret, TC.expect));
-        TEST_CHECK(PathEq(ret, ret2));
-        TEST_CHECK(ret.is_absolute());
+        assert(PathEq(ret, TC.expect));
+        assert(PathEq(ret, ret2));
+        assert(ret.is_absolute());
     }
 }
 
-TEST_CASE(test_dne_path)
+static void test_dne_path()
 {
     static_test_env static_env;
     std::error_code ec = GetTestEC();
     {
         const path ret = canonical(static_env.DNE, ec);
-        TEST_CHECK(ec != GetTestEC());
-        TEST_REQUIRE(ec);
-        TEST_CHECK(ret == path{});
+        assert(ec != GetTestEC());
+        assert(ec);
+        assert(ret == path{});
     }
     {
-        TEST_CHECK_THROW(filesystem_error, canonical(static_env.DNE));
+        TEST_THROWS_TYPE(filesystem_error, canonical(static_env.DNE));
     }
 }
 
-TEST_CASE(test_exception_contains_paths)
+static void test_exception_contains_paths()
 {
 #ifndef TEST_HAS_NO_EXCEPTIONS
     static_test_env static_env;
     CWDGuard guard;
     const path p = "blabla/dne";
     try {
         (void)canonical(p);
-        TEST_REQUIRE(false);
+        assert(false);
     } catch (filesystem_error const& err) {
-        TEST_CHECK(err.path1() == p);
+        assert(err.path1() == p);
         // libc++ provides the current path as the second path in the exception
-        LIBCPP_ONLY(TEST_CHECK(err.path2() == current_path()));
+        LIBCPP_ONLY(assert(err.path2() == current_path()));
     }
     fs::current_path(static_env.Dir);
     try {
         (void)canonical(p);
-        TEST_REQUIRE(false);
+        assert(false);
     } catch (filesystem_error const& err) {
-        TEST_CHECK(err.path1() == p);
-        LIBCPP_ONLY(TEST_CHECK(err.path2() == static_env.Dir));
+        assert(err.path1() == p);
+        LIBCPP_ONLY(assert(err.path2() == static_env.Dir));
     }
 #endif
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_test();
+    test_canonical();
+    test_dne_path();
+    test_exception_contains_paths();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy/copy.pass.cpp

 //           error_code& ec);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cstddef>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
 using CO = fs::copy_options;
 
-TEST_SUITE(filesystem_copy_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     const copy_options opts{}; ((void)opts);
     ASSERT_NOT_NOEXCEPT(fs::copy(p, p));
     ASSERT_NOT_NOEXCEPT(fs::copy(p, p, ec));
     ASSERT_NOT_NOEXCEPT(copy(p, p, opts));
     ASSERT_NOT_NOEXCEPT(copy(p, p, opts, ec));
 }
 
 // There are 4 cases is the proposal for absolute path.
 // Each scope tests one of the cases.
-TEST_CASE(test_error_reporting)
+static void test_error_reporting()
 {
     auto checkThrow = [](path const& f, path const& t, const std::error_code& ec)
     {
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try {
             fs::copy(f, t);
             return false;
         } catch (filesystem_error const& err) {
             return err.path1() == f
                 && err.path2() == t
                 && err.code() == ec;
         }
 #else
         ((void)f); ((void)t); ((void)ec);
         return true;
 #endif
     };
 
     static_test_env static_env;
     scoped_test_env env;
     const path file = env.create_file("file1", 42);
     const path dir = env.create_dir("dir");
 #ifndef _WIN32
     const path fifo = env.create_fifo("fifo");
-    TEST_REQUIRE(is_other(fifo));
+    assert(is_other(fifo));
 #endif
 
     const auto test_ec = GetTestEC();
 
     // !exists(f)
     {
         std::error_code ec = test_ec;
         const path f = static_env.DNE;
         const path t = env.test_root;
         fs::copy(f, t, ec);
-        TEST_REQUIRE(ec);
-        TEST_REQUIRE(ec != test_ec);
-        TEST_CHECK(checkThrow(f, t, ec));
+        assert(ec);
+        assert(ec != test_ec);
+        assert(checkThrow(f, t, ec));
     }
     { // equivalent(f, t) == true
         std::error_code ec = test_ec;
         fs::copy(file, file, ec);
-        TEST_REQUIRE(ec);
-        TEST_REQUIRE(ec != test_ec);
-        TEST_CHECK(checkThrow(file, file, ec));
+        assert(ec);
+        assert(ec != test_ec);
+        assert(checkThrow(file, file, ec));
     }
     { // is_directory(from) && is_file(to)
         std::error_code ec = test_ec;
         fs::copy(dir, file, ec);
-        TEST_REQUIRE(ec);
-        TEST_REQUIRE(ec != test_ec);
-        TEST_CHECK(checkThrow(dir, file, ec));
+        assert(ec);
+        assert(ec != test_ec);
+        assert(checkThrow(dir, file, ec));
     }
 #ifndef _WIN32
     { // is_other(from)
         std::error_code ec = test_ec;
         fs::copy(fifo, dir, ec);
-        TEST_REQUIRE(ec);
-        TEST_REQUIRE(ec != test_ec);
-        TEST_CHECK(checkThrow(fifo, dir, ec));
+        assert(ec);
+        assert(ec != test_ec);
+        assert(checkThrow(fifo, dir, ec));
     }
     { // is_other(to)
         std::error_code ec = test_ec;
         fs::copy(file, fifo, ec);
-        TEST_REQUIRE(ec);
-        TEST_REQUIRE(ec != test_ec);
-        TEST_CHECK(checkThrow(file, fifo, ec));
+        assert(ec);
+        assert(ec != test_ec);
+        assert(checkThrow(file, fifo, ec));
     }
 #endif
 }
 
-TEST_CASE(from_is_symlink)
+static void from_is_symlink()
 {
     scoped_test_env env;
     const path file = env.create_file("file", 42);
     const path symlink = env.create_symlink(file, "sym");
     const path dne = env.make_env_path("dne");
 
     { // skip symlinks
         std::error_code ec = GetTestEC();
         fs::copy(symlink, dne, copy_options::skip_symlinks, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(!exists(dne));
+        assert(!ec);
+        assert(!exists(dne));
     }
     {
         const path dest = env.make_env_path("dest");
         std::error_code ec = GetTestEC();
         fs::copy(symlink, dest, copy_options::copy_symlinks, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(exists(dest));
-        TEST_CHECK(is_symlink(dest));
+        assert(!ec);
+        assert(exists(dest));
+        assert(is_symlink(dest));
     }
     { // copy symlink but target exists
         std::error_code ec = GetTestEC();
         fs::copy(symlink, file, copy_options::copy_symlinks, ec);
-        TEST_CHECK(ec);
-        TEST_CHECK(ec != GetTestEC());
+        assert(ec);
+        assert(ec != GetTestEC());
     }
     { // create symlinks but target exists
         std::error_code ec = GetTestEC();
         fs::copy(symlink, file, copy_options::create_symlinks, ec);
-        TEST_CHECK(ec);
-        TEST_CHECK(ec != GetTestEC());
+        assert(ec);
+        assert(ec != GetTestEC());
     }
 }
 
-TEST_CASE(from_is_regular_file)
+static void from_is_regular_file()
 {
     scoped_test_env env;
     const path file = env.create_file("file", 42);
     const path dir = env.create_dir("dir");
     { // skip copy because of directory
         const path dest = env.make_env_path("dest1");
         std::error_code ec = GetTestEC();
         fs::copy(file, dest, CO::directories_only, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(!exists(dest));
+        assert(!ec);
+        assert(!exists(dest));
     }
     { // create symlink to file
         const path dest = env.make_env_path("sym");
         std::error_code ec = GetTestEC();
         fs::copy(file, dest, CO::create_symlinks, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(is_symlink(dest));
-        TEST_CHECK(equivalent(file, canonical(dest)));
+        assert(!ec);
+        assert(is_symlink(dest));
+        assert(equivalent(file, canonical(dest)));
     }
     { // create hard link to file
         const path dest = env.make_env_path("hardlink");
-        TEST_CHECK(hard_link_count(file) == 1);
+        assert(hard_link_count(file) == 1);
         std::error_code ec = GetTestEC();
         fs::copy(file, dest, CO::create_hard_links, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(exists(dest));
-        TEST_CHECK(hard_link_count(file) == 2);
+        assert(!ec);
+        assert(exists(dest));
+        assert(hard_link_count(file) == 2);
     }
     { // is_directory(t)
         const path dest_dir = env.create_dir("dest_dir");
         const path expect_dest = dest_dir / file.filename();
         std::error_code ec = GetTestEC();
         fs::copy(file, dest_dir, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(is_regular_file(expect_dest));
+        assert(!ec);
+        assert(is_regular_file(expect_dest));
     }
     { // otherwise copy_file(from, to, ...)
         const path dest = env.make_env_path("file_copy");
         std::error_code ec = GetTestEC();
         fs::copy(file, dest, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(is_regular_file(dest));
+        assert(!ec);
+        assert(is_regular_file(dest));
     }
 }
 
-TEST_CASE(from_is_directory)
+static void from_is_directory()
 {
     struct FileInfo {
         path filename;
         std::size_t size;
     };
     const FileInfo files[] = {
         {"file1", 0},
         {"file2", 42},
         {"file3", 300}
     };
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path nested_dir_name = "dir2";
     const path nested_dir = env.create_dir("dir/dir2");
 
     for (auto& FI : files) {
         env.create_file(dir / FI.filename, FI.size);
         env.create_file(nested_dir / FI.filename, FI.size);
     }
     { // test for non-existent directory
         const path dest = env.make_env_path("dest_dir1");
         std::error_code ec = GetTestEC();
         fs::copy(dir, dest, ec);
-        TEST_REQUIRE(!ec);
-        TEST_CHECK(is_directory(dest));
+        assert(!ec);
+        assert(is_directory(dest));
         for (auto& FI : files) {
             path created = dest / FI.filename;
-            TEST_CHECK(is_regular_file(created));
-            TEST_CHECK(file_size(created) == FI.size);
+            assert(is_regular_file(created));
+            assert(file_size(created) == FI.size);
         }
-        TEST_CHECK(!is_directory(dest / nested_dir_name));
+        assert(!is_directory(dest / nested_dir_name));
     }
     { // test for existing directory
         const path dest = env.create_dir("dest_dir2");
         std::error_code ec = GetTestEC();
         fs::copy(dir, dest, ec);
-        TEST_REQUIRE(!ec);
-        TEST_CHECK(is_directory(dest));
+        assert(!ec);
+        assert(is_directory(dest));
         for (auto& FI : files) {
             path created = dest / FI.filename;
-            TEST_CHECK(is_regular_file(created));
-            TEST_CHECK(file_size(created) == FI.size);
+            assert(is_regular_file(created));
+            assert(file_size(created) == FI.size);
         }
-        TEST_CHECK(!is_directory(dest / nested_dir_name));
+        assert(!is_directory(dest / nested_dir_name));
     }
     { // test recursive copy
         const path dest = env.make_env_path("dest_dir3");
         std::error_code ec = GetTestEC();
         fs::copy(dir, dest, CO::recursive, ec);
-        TEST_REQUIRE(!ec);
-        TEST_CHECK(is_directory(dest));
+        assert(!ec);
+        assert(is_directory(dest));
         const path nested_dest = dest / nested_dir_name;
-        TEST_REQUIRE(is_directory(nested_dest));
+        assert(is_directory(nested_dest));
         for (auto& FI : files) {
             path created = dest / FI.filename;
             path nested_created = nested_dest / FI.filename;
-            TEST_CHECK(is_regular_file(created));
-            TEST_CHECK(file_size(created) == FI.size);
-            TEST_CHECK(is_regular_file(nested_created));
-            TEST_CHECK(file_size(nested_created) == FI.size);
+            assert(is_regular_file(created));
+            assert(file_size(created) == FI.size);
+            assert(is_regular_file(nested_created));
+            assert(file_size(nested_created) == FI.size);
         }
     }
 }
 
-TEST_CASE(test_copy_symlinks_to_symlink_dir)
+static void test_copy_symlinks_to_symlink_dir()
 {
     scoped_test_env env;
     const path file1 = env.create_file("file1", 42);
     const path file2 = env.create_file("file2", 101);
     const path file2_sym = env.create_symlink(file2, "file2_sym");
     const path dir = env.create_dir("dir");
     const path dir_sym = env.create_directory_symlink(dir, "dir_sym");
     {
         std::error_code ec = GetTestEC();
         fs::copy(file1, dir_sym, copy_options::copy_symlinks, ec);
-        TEST_CHECK(!ec);
+        assert(!ec);
         const path dest = env.make_env_path("dir/file1");
-        TEST_CHECK(exists(dest));
-        TEST_CHECK(!is_symlink(dest));
-        TEST_CHECK(file_size(dest) == 42);
+        assert(exists(dest));
+        assert(!is_symlink(dest));
+        assert(file_size(dest) == 42);
     }
 }
 
 
-TEST_CASE(test_dir_create_symlink)
+static void test_dir_create_symlink()
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir1");
     const path dest = env.make_env_path("dne");
     {
         std::error_code ec = GetTestEC();
         fs::copy(dir, dest, copy_options::create_symlinks, ec);
-        TEST_CHECK(ErrorIs(ec, std::errc::is_a_directory));
-        TEST_CHECK(!exists(dest));
-        TEST_CHECK(!is_symlink(dest));
+        assert(ErrorIs(ec, std::errc::is_a_directory));
+        assert(!exists(dest));
+        assert(!is_symlink(dest));
     }
     {
         std::error_code ec = GetTestEC();
         fs::copy(dir, dest, copy_options::create_symlinks|copy_options::recursive, ec);
-        TEST_CHECK(ErrorIs(ec, std::errc::is_a_directory));
-        TEST_CHECK(!exists(dest));
-        TEST_CHECK(!is_symlink(dest));
+        assert(ErrorIs(ec, std::errc::is_a_directory));
+        assert(!exists(dest));
+        assert(!is_symlink(dest));
     }
 }
 
-TEST_CASE(test_otherwise_no_effects_clause)
+static void test_otherwise_no_effects_clause()
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir1");
     { // skip copy because of directory
         const path dest = env.make_env_path("dest1");
         std::error_code ec;
         fs::copy(dir, dest, CO::directories_only, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(!exists(dest));
+        assert(!ec);
+        assert(!exists(dest));
     }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_test();
+    test_error_reporting();
+    from_is_symlink();
+    from_is_regular_file();
+    from_is_directory();
+    test_copy_symlinks_to_symlink_dir();
+    test_dir_create_symlink();
+    test_otherwise_no_effects_clause();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_file/copy_file.pass.cpp

 //           error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <chrono>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
 using CO = fs::copy_options;
 
-TEST_SUITE(filesystem_copy_file_test_suite)
-
-TEST_CASE(test_signatures) {
+static void test_signatures() {
   const path p;
   ((void)p);
   const copy_options opts{};
   ((void)opts);
   std::error_code ec;
   ((void)ec);
   ASSERT_SAME_TYPE(decltype(fs::copy_file(p, p)), bool);
   ASSERT_SAME_TYPE(decltype(fs::copy_file(p, p, opts)), bool);
   ASSERT_SAME_TYPE(decltype(fs::copy_file(p, p, ec)), bool);
   ASSERT_SAME_TYPE(decltype(fs::copy_file(p, p, opts, ec)), bool);
   ASSERT_NOT_NOEXCEPT(fs::copy_file(p, p));
   ASSERT_NOT_NOEXCEPT(fs::copy_file(p, p, opts));
   ASSERT_NOT_NOEXCEPT(fs::copy_file(p, p, ec));
   ASSERT_NOT_NOEXCEPT(fs::copy_file(p, p, opts, ec));
 }
 
-TEST_CASE(test_error_reporting) {
+static void test_error_reporting() {
 
   scoped_test_env env;
   const path file = env.create_file("file1", 42);
   const path file2 = env.create_file("file2", 55);
 
   { // exists(to) && equivalent(to, from)
     std::error_code ec;
-    TEST_CHECK(fs::copy_file(file, file, copy_options::overwrite_existing,
+    assert(fs::copy_file(file, file, copy_options::overwrite_existing,
                              ec) == false);
-    TEST_CHECK(ErrorIs(ec, std::errc::file_exists));
+    assert(ErrorIs(ec, std::errc::file_exists));
     ExceptionChecker Checker(file, file, std::errc::file_exists, "copy_file");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, copy_file(file, file, copy_options::overwrite_existing));
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, copy_file(file, file, copy_options::overwrite_existing));
 
   }
   { // exists(to) && !(skip_existing | overwrite_existing | update_existing)
     std::error_code ec;
-    TEST_CHECK(fs::copy_file(file, file2, ec) == false);
-    TEST_CHECK(ErrorIs(ec, std::errc::file_exists));
+    assert(fs::copy_file(file, file2, ec) == false);
+    assert(ErrorIs(ec, std::errc::file_exists));
     ExceptionChecker Checker(file, file, std::errc::file_exists, "copy_file");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, copy_file(file, file, copy_options::overwrite_existing));
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, copy_file(file, file, copy_options::overwrite_existing));
 
   }
 }
 
 #ifndef _WIN32
-TEST_CASE(non_regular_file_test) {
+static void non_regular_file_test() {
   scoped_test_env env;
   const path fifo = env.create_fifo("fifo");
   const path dest = env.make_env_path("dest");
   const path file = env.create_file("file", 42);
 
   {
     std::error_code ec = GetTestEC();
-    TEST_REQUIRE(fs::copy_file(fifo, dest, ec) == false);
-    TEST_CHECK(ErrorIs(ec, std::errc::not_supported));
-    TEST_CHECK(!exists(dest));
+    assert(fs::copy_file(fifo, dest, ec) == false);
+    assert(ErrorIs(ec, std::errc::not_supported));
+    assert(!exists(dest));
   }
   {
     std::error_code ec = GetTestEC();
-    TEST_REQUIRE(fs::copy_file(file, fifo, copy_options::overwrite_existing,
+    assert(fs::copy_file(file, fifo, copy_options::overwrite_existing,
                                ec) == false);
-    TEST_CHECK(ErrorIs(ec, std::errc::not_supported));
-    TEST_CHECK(is_fifo(fifo));
+    assert(ErrorIs(ec, std::errc::not_supported));
+    assert(is_fifo(fifo));
   }
 
 }
-#endif
+#endif // _WIN32
 
-TEST_CASE(test_attributes_get_copied) {
+static void test_attributes_get_copied() {
   scoped_test_env env;
   const path file = env.create_file("file1", 42);
   const path dest = env.make_env_path("file2");
   (void)status(file);
   perms new_perms = perms::owner_read;
   permissions(file, new_perms);
   std::error_code ec = GetTestEC();
-  TEST_REQUIRE(fs::copy_file(file, dest, ec) == true);
-  TEST_CHECK(!ec);
+  assert(fs::copy_file(file, dest, ec) == true);
+  assert(!ec);
   auto new_st = status(dest);
-  TEST_CHECK(new_st.permissions() == NormalizeExpectedPerms(new_perms));
+  assert(new_st.permissions() == NormalizeExpectedPerms(new_perms));
 }
 
-TEST_CASE(copy_dir_test) {
+static void copy_dir_test() {
   scoped_test_env env;
   const path file = env.create_file("file1", 42);
   const path dest = env.create_dir("dir1");
   std::error_code ec = GetTestEC();
-  TEST_CHECK(fs::copy_file(file, dest, ec) == false);
-  TEST_CHECK(ec);
-  TEST_CHECK(ec != GetTestEC());
+  assert(fs::copy_file(file, dest, ec) == false);
+  assert(ec);
+  assert(ec != GetTestEC());
   ec = GetTestEC();
-  TEST_CHECK(fs::copy_file(dest, file, ec) == false);
-  TEST_CHECK(ec);
-  TEST_CHECK(ec != GetTestEC());
+  assert(fs::copy_file(dest, file, ec) == false);
+  assert(ec);
+  assert(ec != GetTestEC());
 }
 
-TEST_CASE(copy_file) {
+static void copy_file() {
   scoped_test_env env;
   const path file = env.create_file("file1", 42);
 
   { // !exists(to)
     const path dest = env.make_env_path("dest1");
     std::error_code ec = GetTestEC();
 
-    TEST_REQUIRE(fs::copy_file(file, dest, ec) == true);
-    TEST_CHECK(!ec);
-    TEST_CHECK(file_size(dest) == 42);
+    assert(fs::copy_file(file, dest, ec) == true);
+    assert(!ec);
+    assert(file_size(dest) == 42);
   }
   { // exists(to) && overwrite_existing
     const path dest = env.create_file("dest2", 55);
     permissions(dest, perms::all);
     permissions(file,
                 perms::group_write | perms::owner_write | perms::others_write,
                 perm_options::remove);
 
     std::error_code ec = GetTestEC();
-    TEST_REQUIRE(fs::copy_file(file, dest, copy_options::overwrite_existing,
+    assert(fs::copy_file(file, dest, copy_options::overwrite_existing,
                                ec) == true);
-    TEST_CHECK(!ec);
-    TEST_CHECK(file_size(dest) == 42);
-    TEST_CHECK(status(dest).permissions() == status(file).permissions());
+    assert(!ec);
+    assert(file_size(dest) == 42);
+    assert(status(dest).permissions() == status(file).permissions());
   }
   { // exists(to) && update_existing
     using Sec = std::chrono::seconds;
     const path older = env.create_file("older_file", 1);
 
     SleepFor(Sec(2));
     const path from = env.create_file("update_from", 55);
 
     SleepFor(Sec(2));
     const path newer = env.create_file("newer_file", 2);
 
     std::error_code ec = GetTestEC();
-    TEST_REQUIRE(
+    assert(
         fs::copy_file(from, older, copy_options::update_existing, ec) == true);
-    TEST_CHECK(!ec);
-    TEST_CHECK(file_size(older) == 55);
+    assert(!ec);
+    assert(file_size(older) == 55);
 
-    TEST_REQUIRE(
+    assert(
         fs::copy_file(from, newer, copy_options::update_existing, ec) == false);
-    TEST_CHECK(!ec);
-    TEST_CHECK(file_size(newer) == 2);
+    assert(!ec);
+    assert(file_size(newer) == 2);
   }
   { // skip_existing
     const path file2 = env.create_file("file2", 55);
     std::error_code ec = GetTestEC();
-    TEST_REQUIRE(fs::copy_file(file, file2, copy_options::skip_existing, ec) ==
+    assert(fs::copy_file(file, file2, copy_options::skip_existing, ec) ==
                  false);
-    TEST_CHECK(!ec);
-    TEST_CHECK(file_size(file2) == 55);
+    assert(!ec);
+    assert(file_size(file2) == 55);
   }
 }
 
+int main(int, char**) {
+  test_signatures();
+  test_error_reporting();
+#ifndef _WIN32
+  non_regular_file_test();
+#endif
+  test_attributes_get_copied();
+  copy_dir_test();
+  copy_file();
 
-TEST_SUITE_END()
+  return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_file/copy_file_large.pass.cpp

 //           error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <cassert>
 #include <cstdio>
 #include <string>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(filesystem_copy_file_test_suite)
-
 // This test is intended to test 'sendfile's 2gb limit for a single call, and
 // to ensure that libc++ correctly copies files larger than that limit.
 // However it requires allocating ~5GB of filesystem space. This might not
 // be acceptable on all systems.
-TEST_CASE(large_file) {
+static void large_file() {
   using namespace fs;
   constexpr uintmax_t sendfile_size_limit = 2147479552ull;
   constexpr uintmax_t additional_size = 1024;
   constexpr uintmax_t test_file_size = sendfile_size_limit + additional_size;
   static_assert(test_file_size > sendfile_size_limit, "");
 
   scoped_test_env env;
 
   // Check that we have more than sufficient room to create the files needed
   // to perform the test.
   if (space(env.test_root).available < 3 * test_file_size) {
-    TEST_UNSUPPORTED();
+    TEST_IS_UNSUPPORTED();
   }
 
   // Create a file right at the size limit. The file is full of '\0's.
   const path source = env.create_file("source", sendfile_size_limit);
   const std::string additional_data(additional_size, 'x');
   // Append known data to the end of the source file.
   {
     std::FILE* outf = std::fopen(source.string().c_str(), "a");
-    TEST_REQUIRE(outf != nullptr);
+    assert(outf != nullptr);
     std::fputs(additional_data.c_str(), outf);
     std::fclose(outf);
   }
-  TEST_REQUIRE(file_size(source) == test_file_size);
+  assert(file_size(source) == test_file_size);
   const path dest = env.make_env_path("dest");
 
   std::error_code ec = GetTestEC();
-  TEST_CHECK(copy_file(source, dest, ec));
-  TEST_CHECK(!ec);
+  assert(copy_file(source, dest, ec));
+  assert(!ec);
 
-  TEST_REQUIRE(is_regular_file(dest));
-  TEST_CHECK(file_size(dest) == test_file_size);
+  assert(is_regular_file(dest));
+  assert(file_size(dest) == test_file_size);
 
   // Read the data from the end of the destination file, and ensure it matches
   // the data at the end of the source file.
   std::string out_data(additional_size, 'z');
   {
     std::FILE* dest_file = std::fopen(dest.string().c_str(), "rb");
-    TEST_REQUIRE(dest_file != nullptr);
-    TEST_REQUIRE(std::fseek(dest_file, sendfile_size_limit, SEEK_SET) == 0);
-    TEST_REQUIRE(std::fread(&out_data[0], sizeof(out_data[0]), additional_size, dest_file) == additional_size);
+    assert(dest_file != nullptr);
+    assert(std::fseek(dest_file, sendfile_size_limit, SEEK_SET) == 0);
+    assert(std::fread(&out_data[0], sizeof(out_data[0]), additional_size, dest_file) == additional_size);
     std::fclose(dest_file);
   }
-  TEST_CHECK(out_data.size() == additional_data.size());
-  TEST_CHECK(out_data == additional_data);
+  assert(out_data.size() == additional_data.size());
+  assert(out_data == additional_data);
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+  large_file();
+
+  return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.copy_symlink/copy_symlink.pass.cpp

 // void copy_symlink(const path& existing_symlink, const path& new_symlink,
 //                   error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(filesystem_copy_symlink_test_suite)
-
-TEST_CASE(test_signatures)
+static void test_signatures()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(fs::copy_symlink(p, p));
     ASSERT_NOEXCEPT(fs::copy_symlink(p, p, ec));
 }
 
 
-TEST_CASE(test_error_reporting)
+static void test_error_reporting()
 {
     auto checkThrow = [](path const& f, path const& t, const std::error_code& ec)
     {
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try {
             fs::copy_symlink(f, t);
             return true;
         } catch (filesystem_error const& err) {
#endif
     const path file = env.create_file("file1", 42);
     const path file2 = env.create_file("file2", 55);
     const path sym = env.create_symlink(file, "sym");
     const path dir = env.create_dir("dir");
     const path dne = env.make_env_path("dne");
     { // from is a file, not a symlink
         std::error_code ec;
         fs::copy_symlink(file, dne, ec);
-        TEST_REQUIRE(ec);
-        TEST_CHECK(checkThrow(file, dne, ec));
+        assert(ec);
+        assert(checkThrow(file, dne, ec));
     }
     { // from is a file, not a symlink
         std::error_code ec;
         fs::copy_symlink(dir, dne, ec);
-        TEST_REQUIRE(ec);
-        TEST_CHECK(checkThrow(dir, dne, ec));
+        assert(ec);
+        assert(checkThrow(dir, dne, ec));
     }
     { // destination exists
         std::error_code ec;
         fs::copy_symlink(sym, file2, ec);
-        TEST_REQUIRE(ec);
+        assert(ec);
     }
 }
 
-TEST_CASE(copy_symlink_basic)
+static void copy_symlink_basic()
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path dir_sym = env.create_directory_symlink(dir, "dir_sym");
     const path file = env.create_file("file", 42);
     const path file_sym = env.create_symlink(file, "file_sym");
     { // test for directory symlinks
         const path dest = env.make_env_path("dest1");
         std::error_code ec;
         fs::copy_symlink(dir_sym, dest, ec);
-        TEST_REQUIRE(!ec);
-        TEST_CHECK(is_symlink(dest));
-        TEST_CHECK(equivalent(dest, dir));
+        assert(!ec);
+        assert(is_symlink(dest));
+        assert(equivalent(dest, dir));
     }
     { // test for file symlinks
         const path dest = env.make_env_path("dest2");
         std::error_code ec;
         fs::copy_symlink(file_sym, dest, ec);
-        TEST_REQUIRE(!ec);
-        TEST_CHECK(is_symlink(dest));
-        TEST_CHECK(equivalent(dest, file));
+        assert(!ec);
+        assert(is_symlink(dest));
+        assert(equivalent(dest, file));
     }
 }
 
+int main(int, char**) {
+    test_signatures();
+    test_error_reporting();
+    copy_symlink_basic();
 
-TEST_SUITE_END()
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directories/create_directories.pass.cpp

 // bool create_directories(const path& p);
 // bool create_directories(const path& p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(filesystem_create_directories_test_suite)
-
-TEST_CASE(test_signatures)
+static void test_signatures()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_SAME_TYPE(decltype(fs::create_directories(p)), bool);
     ASSERT_SAME_TYPE(decltype(fs::create_directories(p, ec)), bool);
     ASSERT_NOT_NOEXCEPT(fs::create_directories(p));
     ASSERT_NOT_NOEXCEPT(fs::create_directories(p, ec));
 }
 
-TEST_CASE(create_existing_directory)
+static void create_existing_directory()
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir1");
     std::error_code ec;
-    TEST_CHECK(fs::create_directories(dir, ec) == false);
-    TEST_CHECK(!ec);
-    TEST_CHECK(is_directory(dir));
+    assert(fs::create_directories(dir, ec) == false);
+    assert(!ec);
+    assert(is_directory(dir));
 }
 
-TEST_CASE(create_directory_one_level)
+static void create_directory_one_level()
 {
     scoped_test_env env;
     const path dir = env.make_env_path("dir1");
     std::error_code ec;
-    TEST_CHECK(fs::create_directories(dir, ec) == true);
-    TEST_CHECK(!ec);
-    TEST_CHECK(is_directory(dir));
+    assert(fs::create_directories(dir, ec) == true);
+    assert(!ec);
+    assert(is_directory(dir));
 }
 
-TEST_CASE(create_directories_multi_level)
+static void create_directories_multi_level()
 {
     scoped_test_env env;
     const path dir = env.make_env_path("dir1/dir2/dir3");
     std::error_code ec;
-    TEST_CHECK(fs::create_directories(dir, ec) == true);
-    TEST_CHECK(!ec);
-    TEST_CHECK(is_directory(dir));
+    assert(fs::create_directories(dir, ec) == true);
+    assert(!ec);
+    assert(is_directory(dir));
 }
 
-TEST_CASE(create_directory_symlinks) {
+static void create_directory_symlinks() {
   scoped_test_env env;
   const path root = env.create_dir("dir");
   const path sym_dest_dead = env.make_env_path("dead");
   const path dead_sym = env.create_directory_symlink(sym_dest_dead, "dir/sym_dir");
   const path target = env.make_env_path("dir/sym_dir/foo");
   {
     std::error_code ec = GetTestEC();
-    TEST_CHECK(create_directories(target, ec) == false);
-    TEST_CHECK(ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::file_exists));
-    TEST_CHECK(!exists(sym_dest_dead));
-    TEST_CHECK(!exists(dead_sym));
+    assert(create_directories(target, ec) == false);
+    assert(ec);
+    assert(ErrorIs(ec, std::errc::file_exists));
+    assert(!exists(sym_dest_dead));
+    assert(!exists(dead_sym));
   }
 }
 
-TEST_CASE(create_directory_through_symlinks) {
+static void create_directory_through_symlinks() {
   scoped_test_env env;
   const path root = env.create_dir("dir");
   const path sym_dir = env.create_directory_symlink(root, "sym_dir");
   const path target = env.make_env_path("sym_dir/foo");
   const path resolved_target = env.make_env_path("dir/foo");
-  TEST_REQUIRE(is_directory(sym_dir));
+  assert(is_directory(sym_dir));
   {
     std::error_code ec = GetTestEC();
-    TEST_CHECK(create_directories(target, ec) == true);
-    TEST_CHECK(!ec);
-    TEST_CHECK(is_directory(target));
-    TEST_CHECK(is_directory(resolved_target));
+    assert(create_directories(target, ec) == true);
+    assert(!ec);
+    assert(is_directory(target));
+    assert(is_directory(resolved_target));
   }
 }
 
-TEST_CASE(dest_is_file)
+static void dest_is_file()
 {
     scoped_test_env env;
     const path file = env.create_file("file", 42);
     std::error_code ec = GetTestEC();
-    TEST_CHECK(fs::create_directories(file, ec) == false);
-    TEST_CHECK(ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::file_exists));
-    TEST_CHECK(is_regular_file(file));
+    assert(fs::create_directories(file, ec) == false);
+    assert(ec);
+    assert(ErrorIs(ec, std::errc::file_exists));
+    assert(is_regular_file(file));
 }
 
-TEST_CASE(dest_part_is_file)
+static void dest_part_is_file()
 {
     scoped_test_env env;
     const path file = env.create_file("file");
     const path dir = env.make_env_path("file/dir1");
     std::error_code ec = GetTestEC();
-    TEST_CHECK(fs::create_directories(dir, ec) == false);
-    TEST_CHECK(ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::not_a_directory));
-    TEST_CHECK(is_regular_file(file));
-    TEST_CHECK(!exists(dir));
+    assert(fs::create_directories(dir, ec) == false);
+    assert(ec);
+    assert(ErrorIs(ec, std::errc::not_a_directory));
+    assert(is_regular_file(file));
+    assert(!exists(dir));
 }
 
-TEST_CASE(dest_final_part_is_file)
+static void dest_final_part_is_file()
 {
     scoped_test_env env;
     env.create_dir("dir");
     const path file = env.create_file("dir/file");
     const path dir = env.make_env_path("dir/file/dir1");
     std::error_code ec = GetTestEC();
-    TEST_CHECK(fs::create_directories(dir, ec) == false);
-    TEST_CHECK(ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::not_a_directory));
-    TEST_CHECK(is_regular_file(file));
-    TEST_CHECK(!exists(dir));
+    assert(fs::create_directories(dir, ec) == false);
+    assert(ec);
+    assert(ErrorIs(ec, std::errc::not_a_directory));
+    assert(is_regular_file(file));
+    assert(!exists(dir));
 }
 
-TEST_CASE(dest_is_empty_path)
+static void dest_is_empty_path()
 {
     std::error_code ec = GetTestEC();
-    TEST_CHECK(fs::create_directories(fs::path{}, ec) == false);
-    TEST_CHECK(ec);
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(fs::create_directories(fs::path{}, ec) == false);
+    assert(ec);
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
     ExceptionChecker Checker(path{}, std::errc::no_such_file_or_directory,
                              "create_directories");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker,
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker,
                             fs::create_directories(path{}));
 }
 
 #ifdef _WIN32
-TEST_CASE(nonexistent_root)
+static void nonexistent_root()
 {
     std::error_code ec = GetTestEC();
     // If Q:\ doesn't exist, create_directories would try to recurse upwards
     // to parent_path() until it finds a directory that does exist. As the
     // whole path is the root name, parent_path() returns itself, and it
     // would recurse indefinitely, unless the recursion is broken.
     if (!exists("Q:\\"))
-       TEST_CHECK(fs::create_directories("Q:\\", ec) == false);
-    TEST_CHECK(fs::create_directories("\\\\nonexistentserver", ec) == false);
+       assert(fs::create_directories("Q:\\", ec) == false);
+    assert(fs::create_directories("\\\\nonexistentserver", ec) == false);
 }
+#endif // _WIN32
+
+int main(int, char**) {
+    test_signatures();
+    create_existing_directory();
+    create_directory_one_level();
+    create_directories_multi_level();
+    create_directory_symlinks();
+    create_directory_through_symlinks();
+    dest_is_file();
+    dest_part_is_file();
+    dest_final_part_is_file();
+    dest_is_empty_path();
+#ifdef _WIN32
+    nonexistent_root();
 #endif
 
-TEST_SUITE_END()
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory.pass.cpp

 // bool create_directory(const path& p, const path& attr);
 // bool create_directory(const path& p, const path& attr, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 #include <sys/types.h>
 #include <sys/stat.h>
 
 using namespace fs;
 
 fs::perms read_umask() {
     auto old_mask = umask(0); // int on Windows, mode_t on POSIX.
     umask(old_mask); // reset the mask to the old value.
     return static_cast<fs::perms>(old_mask);
 }
 
-TEST_SUITE(filesystem_create_directory_test_suite)
-
-TEST_CASE(test_signatures)
+static void test_signatures()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_SAME_TYPE(decltype(fs::create_directory(p)), bool);
     ASSERT_SAME_TYPE(decltype(fs::create_directory(p, ec)), bool);
     ASSERT_SAME_TYPE(decltype(fs::create_directory(p, p)), bool);
     ASSERT_SAME_TYPE(decltype(fs::create_directory(p, p, ec)), bool);
     ASSERT_NOT_NOEXCEPT(fs::create_directory(p));
     ASSERT_NOEXCEPT(fs::create_directory(p, ec));
     ASSERT_NOT_NOEXCEPT(fs::create_directory(p, p));
     ASSERT_NOEXCEPT(fs::create_directory(p, p, ec));
 }
 
 
-TEST_CASE(create_existing_directory)
+static void create_existing_directory()
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir1");
     std::error_code ec;
-    TEST_CHECK(fs::create_directory(dir, ec) == false);
-    TEST_CHECK(!ec);
-    TEST_CHECK(is_directory(dir));
+    assert(fs::create_directory(dir, ec) == false);
+    assert(!ec);
+    assert(is_directory(dir));
     // Test throwing version
-    TEST_CHECK(fs::create_directory(dir) == false);
+    assert(fs::create_directory(dir) == false);
 }
 
-TEST_CASE(create_directory_one_level)
+static void create_directory_one_level()
 {
     scoped_test_env env;
     const path dir = env.make_env_path("dir1");
     std::error_code ec;
-    TEST_CHECK(fs::create_directory(dir, ec) == true);
-    TEST_CHECK(!ec);
-    TEST_CHECK(is_directory(dir));
+    assert(fs::create_directory(dir, ec) == true);
+    assert(!ec);
+    assert(is_directory(dir));
 
     auto st = status(dir);
     const perms expect_perms = perms::all & ~(read_umask());
-    TEST_CHECK((st.permissions() & perms::all) == expect_perms);
+    assert((st.permissions() & perms::all) == expect_perms);
 }
 
-TEST_CASE(create_directory_multi_level)
+static void create_directory_multi_level()
 {
     scoped_test_env env;
     const path dir = env.make_env_path("dir1/dir2");
     const path dir1 = env.make_env_path("dir1");
     std::error_code ec;
-    TEST_CHECK(fs::create_directory(dir, ec) == false);
-    TEST_CHECK(ec);
-    TEST_CHECK(!is_directory(dir));
-    TEST_CHECK(!is_directory(dir1));
+    assert(fs::create_directory(dir, ec) == false);
+    assert(ec);
+    assert(!is_directory(dir));
+    assert(!is_directory(dir1));
 }
 
-TEST_CASE(dest_is_file)
+static void dest_is_file()
 {
     scoped_test_env env;
     const path file = env.create_file("file", 42);
     std::error_code ec = GetTestEC();
-    TEST_CHECK(fs::create_directory(file, ec) == false);
-    TEST_CHECK(ec);
-    TEST_CHECK(is_regular_file(file));
+    assert(fs::create_directory(file, ec) == false);
+    assert(ec);
+    assert(is_regular_file(file));
 }
 
-TEST_CASE(dest_part_is_file)
+static void dest_part_is_file()
 {
     scoped_test_env env;
     const path file = env.create_file("file");
     const path dir = env.make_env_path("file/dir1");
     std::error_code ec = GetTestEC();
-    TEST_CHECK(fs::create_directory(dir, ec) == false);
-    TEST_CHECK(ec);
-    TEST_CHECK(is_regular_file(file));
-    TEST_CHECK(!exists(dir));
+    assert(fs::create_directory(dir, ec) == false);
+    assert(ec);
+    assert(is_regular_file(file));
+    assert(!exists(dir));
 }
 
-TEST_CASE(dest_is_symlink_to_dir)
+static void dest_is_symlink_to_dir()
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path sym = env.create_directory_symlink(dir, "sym_name");
     std::error_code ec = GetTestEC();
-    TEST_CHECK(create_directory(sym, ec) == false);
-    TEST_CHECK(!ec);
+    assert(create_directory(sym, ec) == false);
+    assert(!ec);
 }
 
-TEST_CASE(dest_is_symlink_to_file)
+static void dest_is_symlink_to_file()
 {
     scoped_test_env env;
     const path file = env.create_file("file");
     const path sym = env.create_symlink(file, "sym_name");
     std::error_code ec = GetTestEC();
-    TEST_CHECK(create_directory(sym, ec) == false);
-    TEST_CHECK(ec);
+    assert(create_directory(sym, ec) == false);
+    assert(ec);
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    test_signatures();
+    create_existing_directory();
+    create_directory_one_level();
+    create_directory_multi_level();
+    dest_is_file();
+    dest_part_is_file();
+    dest_is_symlink_to_dir();
+    dest_is_symlink_to_file();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory/create_directory_with_attributes.pass.cpp

 // bool create_directory(const path& p, const path& attr);
 // bool create_directory(const path& p, const path& attr, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(filesystem_create_directory_test_suite)
-
-TEST_CASE(test_signatures)
+static void test_signatures()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_SAME_TYPE(decltype(fs::create_directory(p, p)), bool);
     ASSERT_SAME_TYPE(decltype(fs::create_directory(p, p, ec)), bool);
     ASSERT_NOT_NOEXCEPT(fs::create_directory(p, p));
     ASSERT_NOEXCEPT(fs::create_directory(p, p, ec));
 }
 
-TEST_CASE(create_existing_directory)
+static void create_existing_directory()
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir1");
     const path dir2 = env.create_dir("dir2");
 
     const perms orig_p = status(dir).permissions();
     permissions(dir2, perms::none);
 
     std::error_code ec;
-    TEST_CHECK(fs::create_directory(dir, dir2, ec) == false);
-    TEST_CHECK(!ec);
+    assert(fs::create_directory(dir, dir2, ec) == false);
+    assert(!ec);
 
     // Check that the permissions were unchanged
-    TEST_CHECK(orig_p == status(dir).permissions());
+    assert(orig_p == status(dir).permissions());
 
     // Test throwing version
-    TEST_CHECK(fs::create_directory(dir, dir2) == false);
+    assert(fs::create_directory(dir, dir2) == false);
 }
 
 // Windows doesn't have the concept of perms::none on directories.
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
-TEST_CASE(create_directory_one_level)
+static void create_directory_one_level()
 {
     scoped_test_env env;
     // Remove setgid which mkdir would inherit
     permissions(env.test_root, perms::set_gid, perm_options::remove);
 
     const path dir = env.make_env_path("dir1");
     const path attr_dir = env.create_dir("dir2");
     permissions(attr_dir, perms::none);
 
     std::error_code ec;
-    TEST_CHECK(fs::create_directory(dir, attr_dir, ec) == true);
-    TEST_CHECK(!ec);
-    TEST_CHECK(is_directory(dir));
+    assert(fs::create_directory(dir, attr_dir, ec) == true);
+    assert(!ec);
+    assert(is_directory(dir));
 
     // Check that the new directory has the same permissions as attr_dir
     auto st = status(dir);
-    TEST_CHECK(st.permissions() == perms::none);
+    assert(st.permissions() == perms::none);
 }
-#endif
+#endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
 
-TEST_CASE(create_directory_multi_level)
+static void create_directory_multi_level()
 {
     scoped_test_env env;
     const path dir = env.make_env_path("dir1/dir2");
     const path dir1 = env.make_env_path("dir1");
     const path attr_dir = env.create_dir("attr_dir");
     std::error_code ec = GetTestEC();
-    TEST_CHECK(fs::create_directory(dir, attr_dir, ec) == false);
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
-    TEST_CHECK(!is_directory(dir));
-    TEST_CHECK(!is_directory(dir1));
+    assert(fs::create_directory(dir, attr_dir, ec) == false);
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(!is_directory(dir));
+    assert(!is_directory(dir1));
 }
 
-TEST_CASE(dest_is_file)
+static void dest_is_file()
 {
     scoped_test_env env;
     const path file = env.create_file("file", 42);
     const path attr_dir = env.create_dir("attr_dir");
     std::error_code ec = GetTestEC();
-    TEST_CHECK(fs::create_directory(file, attr_dir, ec) == false);
-    TEST_CHECK(ec);
-    TEST_CHECK(is_regular_file(file));
+    assert(fs::create_directory(file, attr_dir, ec) == false);
+    assert(ec);
+    assert(is_regular_file(file));
 }
 
-TEST_CASE(dest_part_is_file)
+static void dest_part_is_file()
 {
     scoped_test_env env;
     const path file = env.create_file("file", 42);
     const path dir = env.make_env_path("file/dir1");
     const path attr_dir = env.create_dir("attr_dir");
     std::error_code ec = GetTestEC();
-    TEST_CHECK(fs::create_directory(dir, attr_dir, ec) == false);
-    TEST_CHECK(ec);
-    TEST_CHECK(is_regular_file(file));
-    TEST_CHECK(!exists(dir));
+    assert(fs::create_directory(dir, attr_dir, ec) == false);
+    assert(ec);
+    assert(is_regular_file(file));
+    assert(!exists(dir));
 }
 
-TEST_CASE(attr_dir_is_invalid) {
+static void attr_dir_is_invalid() {
   scoped_test_env env;
   const path file = env.create_file("file", 42);
   const path dest = env.make_env_path("dir");
   const path dne = env.make_env_path("dne");
   {
     std::error_code ec = GetTestEC();
-    TEST_CHECK(create_directory(dest, file, ec) == false);
-    TEST_CHECK(ErrorIs(ec, std::errc::not_a_directory));
+    assert(create_directory(dest, file, ec) == false);
+    assert(ErrorIs(ec, std::errc::not_a_directory));
   }
-  TEST_REQUIRE(!exists(dest));
+  assert(!exists(dest));
   {
     std::error_code ec = GetTestEC();
-    TEST_CHECK(create_directory(dest, dne, ec) == false);
-    TEST_CHECK(ErrorIs(ec, std::errc::not_a_directory));
+    assert(create_directory(dest, dne, ec) == false);
+    assert(ErrorIs(ec, std::errc::not_a_directory));
   }
 }
 
-TEST_CASE(dest_is_symlink_to_unexisting) {
+static void dest_is_symlink_to_unexisting() {
   scoped_test_env env;
   const path attr_dir = env.create_dir("attr_dir");
   const path sym = env.create_symlink("dne_sym", "dne_sym_name");
   {
     std::error_code ec = GetTestEC();
-    TEST_CHECK(create_directory(sym, attr_dir, ec) == false);
-    TEST_CHECK(ec);
+    assert(create_directory(sym, attr_dir, ec) == false);
+    assert(ec);
   }
 }
 
-TEST_CASE(dest_is_symlink_to_dir) {
+static void dest_is_symlink_to_dir() {
   scoped_test_env env;
   const path dir = env.create_dir("dir");
   const path sym = env.create_directory_symlink(dir, "sym_name");
   const path attr_dir = env.create_dir("attr_dir");
   {
     std::error_code ec = GetTestEC();
-    TEST_CHECK(create_directory(sym, attr_dir, ec) == false);
-    TEST_CHECK(!ec);
+    assert(create_directory(sym, attr_dir, ec) == false);
+    assert(!ec);
   }
 }
 
-TEST_CASE(dest_is_symlink_to_file) {
+static void dest_is_symlink_to_file() {
   scoped_test_env env;
   const path file = env.create_file("file");
   const path sym = env.create_symlink(file, "sym_name");
   const path attr_dir = env.create_dir("attr_dir");
   {
     std::error_code ec = GetTestEC();
-    TEST_CHECK(create_directory(sym, attr_dir, ec) == false);
-    TEST_CHECK(ec);
+    assert(create_directory(sym, attr_dir, ec) == false);
+    assert(ec);
   }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+  test_signatures();
+  create_existing_directory();
+#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
+  create_directory_one_level();
+#endif
+  create_directory_multi_level();
+  dest_is_file();
+  dest_part_is_file();
+  attr_dir_is_invalid();
+  dest_is_symlink_to_unexisting();
+  dest_is_symlink_to_dir();
+  dest_is_symlink_to_file();
+
+  return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_directory_symlink/create_directory_symlink.pass.cpp

 // void create_directory_symlink(const path& existing_symlink, const path& new_symlink);
 // void create_directory_symlink(const path& existing_symlink, const path& new_symlink,
 //                   error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(filesystem_create_directory_symlink_test_suite)
-
-TEST_CASE(test_signatures)
+static void test_signatures()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(fs::create_directory_symlink(p, p));
     ASSERT_NOEXCEPT(fs::create_directory_symlink(p, p, ec));
 }
 
-TEST_CASE(test_error_reporting)
+static void test_error_reporting()
 {
     scoped_test_env env;
     const path file = env.create_file("file1", 42);
     const path file2 = env.create_file("file2", 55);
     const path sym = env.create_symlink(file, "sym");
     { // destination exists
         std::error_code ec;
         fs::create_directory_symlink(sym, file2, ec);
-        TEST_REQUIRE(ec);
+        assert(ec);
     }
 }
 
-TEST_CASE(create_directory_symlink_basic)
+static void create_directory_symlink_basic()
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path dir_sym = env.create_directory_symlink(dir, "dir_sym");
 
     const path dest = env.make_env_path("dest1");
     std::error_code ec;
     fs::create_directory_symlink(dir_sym, dest, ec);
-    TEST_REQUIRE(!ec);
-    TEST_CHECK(is_symlink(dest));
-    TEST_CHECK(equivalent(dest, dir));
+    assert(!ec);
+    assert(is_symlink(dest));
+    assert(equivalent(dest, dir));
 }
 
+int main(int, char**) {
+    test_signatures();
+    test_error_reporting();
+    create_directory_symlink_basic();
 
-TEST_SUITE_END()
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_hard_link/create_hard_link.pass.cpp

 
 // void create_hard_link(const path& existing_symlink, const path& new_symlink);
 // void create_hard_link(const path& existing_symlink, const path& new_symlink,
 //                   error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(filesystem_create_hard_link_test_suite)
-
-TEST_CASE(test_signatures)
+static void test_signatures()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(fs::create_hard_link(p, p));
     ASSERT_NOEXCEPT(fs::create_hard_link(p, p, ec));
 }
 
-TEST_CASE(test_error_reporting)
+static void test_error_reporting()
 {
     scoped_test_env env;
     const path file = env.create_file("file1", 42);
     const path file2 = env.create_file("file2", 55);
     const path sym = env.create_symlink(file, "sym");
     { // destination exists
         std::error_code ec;
         fs::create_hard_link(sym, file2, ec);
-        TEST_REQUIRE(ec);
+        assert(ec);
     }
 }
 
-TEST_CASE(create_file_hard_link)
+static void create_file_hard_link()
 {
     scoped_test_env env;
     const path file = env.create_file("file");
     const path dest = env.make_env_path("dest1");
     std::error_code ec;
-    TEST_CHECK(hard_link_count(file) == 1);
+    assert(hard_link_count(file) == 1);
     fs::create_hard_link(file, dest, ec);
-    TEST_REQUIRE(!ec);
-    TEST_CHECK(exists(dest));
-    TEST_CHECK(equivalent(dest, file));
-    TEST_CHECK(hard_link_count(file) == 2);
+    assert(!ec);
+    assert(exists(dest));
+    assert(equivalent(dest, file));
+    assert(hard_link_count(file) == 2);
 }
 
-TEST_CASE(create_directory_hard_link_fails)
+static void create_directory_hard_link_fails()
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path dest = env.make_env_path("dest2");
     std::error_code ec;
 
     fs::create_hard_link(dir, dest, ec);
-    TEST_REQUIRE(ec);
+    assert(ec);
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    test_signatures();
+    test_error_reporting();
+    create_file_hard_link();
+    create_directory_hard_link_fails();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.create_symlink/create_symlink.pass.cpp

 // void create_symlink(const path& existing_symlink, const path& new_symlink);
 // void create_symlink(const path& existing_symlink, const path& new_symlink,
 //                   error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(filesystem_create_symlink_test_suite)
-
-TEST_CASE(test_signatures)
+static void test_signatures()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(fs::create_symlink(p, p));
     ASSERT_NOEXCEPT(fs::create_symlink(p, p, ec));
 }
 
-TEST_CASE(test_error_reporting)
+static void test_error_reporting()
 {
     scoped_test_env env;
     const path file = env.create_file("file1", 42);
     const path file2 = env.create_file("file2", 55);
     const path sym = env.create_symlink(file, "sym");
     { // destination exists
         std::error_code ec;
         fs::create_symlink(sym, file2, ec);
-        TEST_REQUIRE(ec);
+        assert(ec);
     }
 }
 
-TEST_CASE(create_symlink_basic)
+static void create_symlink_basic()
 {
     scoped_test_env env;
     const path file = env.create_file("file", 42);
     const path file_sym = env.create_symlink(file, "file_sym");
     const path dir = env.create_dir("dir");
     const path dir_sym = env.create_directory_symlink(dir, "dir_sym");
     {
         const path dest = env.make_env_path("dest1");
         std::error_code ec;
         fs::create_symlink(file_sym, dest, ec);
-        TEST_REQUIRE(!ec);
-        TEST_CHECK(is_symlink(dest));
-        TEST_CHECK(equivalent(dest, file));
+        assert(!ec);
+        assert(is_symlink(dest));
+        assert(equivalent(dest, file));
     }
     {
         const path dest = env.make_env_path("dest2");
         std::error_code ec;
         fs::create_directory_symlink(dir_sym, dest, ec);
-        TEST_REQUIRE(!ec);
-        TEST_CHECK(is_symlink(dest));
-        TEST_CHECK(equivalent(dest, dir));
+        assert(!ec);
+        assert(is_symlink(dest));
+        assert(equivalent(dest, dir));
     }
 }
 
-TEST_CASE(create_symlink_dest_cleanup)
+static void create_symlink_dest_cleanup()
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path file = env.create_file("file", 42);
     const path sym = dir / "link";
     // The target path has to be normalized to backslashes before creating
     // the link on windows, otherwise the link isn't dereferencable.
     const path sym_target = "../file";
     path sym_target_normalized = sym_target;
     sym_target_normalized.make_preferred();
     std::error_code ec;
     fs::create_symlink(sym_target, sym, ec);
-    TEST_REQUIRE(!ec);
-    TEST_CHECK(equivalent(sym, file, ec));
+    assert(!ec);
+    assert(equivalent(sym, file, ec));
     const path ret = fs::read_symlink(sym, ec);
-    TEST_CHECK(!ec);
-    TEST_CHECK(ret.native() == sym_target_normalized.native());
+    assert(!ec);
+    assert(ret.native() == sym_target_normalized.native());
 }
 
+int main(int, char**) {
+    test_signatures();
+    test_error_reporting();
+    create_symlink_basic();
+    create_symlink_dest_cleanup();
 
-TEST_SUITE_END()
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.current_path/current_path.pass.cpp

 // void current_path(path const&);
 // void current_path(path const&, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(filesystem_current_path_path_test_suite)
-
-TEST_CASE(current_path_signature_test)
+static void current_path_signature_test()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(current_path());
     ASSERT_NOT_NOEXCEPT(current_path(ec));
     ASSERT_NOT_NOEXCEPT(current_path(p));
     ASSERT_NOEXCEPT(current_path(p, ec));
 }
 
-TEST_CASE(current_path_test)
+static void current_path_test()
 {
     std::error_code ec;
     const path p = current_path(ec);
-    TEST_REQUIRE(!ec);
-    TEST_CHECK(p.is_absolute());
-    TEST_CHECK(is_directory(p));
+    assert(!ec);
+    assert(p.is_absolute());
+    assert(is_directory(p));
 
     const path p2 = current_path();
-    TEST_CHECK(p2 == p);
+    assert(p2 == p);
 }
 
-TEST_CASE(current_path_after_change_test)
+static void current_path_after_change_test()
 {
     static_test_env static_env;
     CWDGuard guard;
     const path new_path = static_env.Dir;
     current_path(new_path);
-    TEST_CHECK(current_path() == new_path);
+    assert(current_path() == new_path);
 }
 
-TEST_CASE(current_path_is_file_test)
+static void current_path_is_file_test()
 {
     static_test_env static_env;
     CWDGuard guard;
     const path p = static_env.File;
     std::error_code ec;
     const path old_p = current_path();
     current_path(p, ec);
-    TEST_CHECK(ec);
-    TEST_CHECK(old_p == current_path());
+    assert(ec);
+    assert(old_p == current_path());
 }
 
-TEST_CASE(set_to_non_absolute_path)
+static void set_to_non_absolute_path()
 {
     static_test_env static_env;
     CWDGuard guard;
     const path base = static_env.Dir;
     current_path(base);
     const path p = static_env.Dir2.filename();
     std::error_code ec;
     current_path(p, ec);
-    TEST_CHECK(!ec);
+    assert(!ec);
     const path new_cwd = current_path();
-    TEST_CHECK(new_cwd == static_env.Dir2);
-    TEST_CHECK(new_cwd.is_absolute());
+    assert(new_cwd == static_env.Dir2);
+    assert(new_cwd.is_absolute());
 }
 
-TEST_CASE(set_to_empty)
+static void set_to_empty()
 {
     const path p = "";
     std::error_code ec;
     const path old_p = current_path();
     current_path(p, ec);
-    TEST_CHECK(ec);
-    TEST_CHECK(old_p == current_path());
+    assert(ec);
+    assert(old_p == current_path());
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    current_path_signature_test();
+    current_path_test();
+    current_path_after_change_test();
+    current_path_is_file_test();
+    set_to_non_absolute_path();
+    set_to_empty();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.equivalent/equivalent.pass.cpp

 // bool equivalent(path const& lhs, path const& rhs);
 // bool equivalent(path const& lhs, path const& rhs, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(equivalent_test_suite)
-
-TEST_CASE(signature_test) {
+static void signature_test() {
   const path p;
   ((void)p);
   std::error_code ec;
   ((void)ec);
   ASSERT_NOEXCEPT(equivalent(p, p, ec));
   ASSERT_NOT_NOEXCEPT(equivalent(p, p));
 }
 
-TEST_CASE(equivalent_test) {
+static void equivalent_test() {
   static_test_env static_env;
   struct TestCase {
     path lhs;
     path rhs;
     bool expect;
   };
   const TestCase testCases[] = {
       {static_env.Dir, static_env.Dir, true},
       {static_env.File, static_env.Dir, false},
       {static_env.Dir, static_env.SymlinkToDir, true},
       {static_env.Dir, static_env.SymlinkToFile, false},
       {static_env.File, static_env.File, true},
       {static_env.File, static_env.SymlinkToFile, true},
   };
   for (auto& TC : testCases) {
     std::error_code ec;
-    TEST_CHECK(equivalent(TC.lhs, TC.rhs, ec) == TC.expect);
-    TEST_CHECK(!ec);
+    assert(equivalent(TC.lhs, TC.rhs, ec) == TC.expect);
+    assert(!ec);
   }
 }
 
-TEST_CASE(equivalent_reports_error_if_input_dne) {
+static void equivalent_reports_error_if_input_dne() {
   static_test_env static_env;
   const path E = static_env.File;
   const path DNE = static_env.DNE;
   { // Test that an error is reported when either of the paths don't exist
     std::error_code ec = GetTestEC();
-    TEST_CHECK(equivalent(E, DNE, ec) == false);
-    TEST_CHECK(ec);
-    TEST_CHECK(ec != GetTestEC());
+    assert(equivalent(E, DNE, ec) == false);
+    assert(ec);
+    assert(ec != GetTestEC());
   }
   {
     std::error_code ec = GetTestEC();
-    TEST_CHECK(equivalent(DNE, E, ec) == false);
-    TEST_CHECK(ec);
-    TEST_CHECK(ec != GetTestEC());
+    assert(equivalent(DNE, E, ec) == false);
+    assert(ec);
+    assert(ec != GetTestEC());
   }
   {
-    TEST_CHECK_THROW(filesystem_error, equivalent(DNE, E));
-    TEST_CHECK_THROW(filesystem_error, equivalent(E, DNE));
+    TEST_THROWS_TYPE(filesystem_error, equivalent(DNE, E));
+    TEST_THROWS_TYPE(filesystem_error, equivalent(E, DNE));
   }
   { // Test that an exception is thrown if both paths do not exist.
-    TEST_CHECK_THROW(filesystem_error, equivalent(DNE, DNE));
+    TEST_THROWS_TYPE(filesystem_error, equivalent(DNE, DNE));
   }
   {
     std::error_code ec = GetTestEC();
-    TEST_CHECK(equivalent(DNE, DNE, ec) == false);
-    TEST_CHECK(ec);
-    TEST_CHECK(ec != GetTestEC());
+    assert(equivalent(DNE, DNE, ec) == false);
+    assert(ec);
+    assert(ec != GetTestEC());
   }
 }
 
-TEST_CASE(equivalent_hardlink_succeeds) {
+static void equivalent_hardlink_succeeds() {
   scoped_test_env env;
   path const file = env.create_file("file", 42);
   const path hl1 = env.create_hardlink(file, "hl1");
   const path hl2 = env.create_hardlink(file, "hl2");
-  TEST_CHECK(equivalent(file, hl1));
-  TEST_CHECK(equivalent(file, hl2));
-  TEST_CHECK(equivalent(hl1, hl2));
+  assert(equivalent(file, hl1));
+  assert(equivalent(file, hl2));
+  assert(equivalent(hl1, hl2));
 }
 
 #ifndef _WIN32
-TEST_CASE(equivalent_is_other_succeeds) {
+static void equivalent_is_other_succeeds() {
   scoped_test_env env;
   path const file = env.create_file("file", 42);
   const path fifo1 = env.create_fifo("fifo1");
   const path fifo2 = env.create_fifo("fifo2");
   // Required to test behavior for inputs where is_other(p) is true.
-  TEST_REQUIRE(is_other(fifo1));
-  TEST_CHECK(!equivalent(file, fifo1));
-  TEST_CHECK(!equivalent(fifo2, file));
-  TEST_CHECK(!equivalent(fifo1, fifo2));
-  TEST_CHECK(equivalent(fifo1, fifo1));
-}
+  assert(is_other(fifo1));
+  assert(!equivalent(file, fifo1));
+  assert(!equivalent(fifo2, file));
+  assert(!equivalent(fifo1, fifo2));
+  assert(equivalent(fifo1, fifo1));
+}
+#endif // _WIN32
+
+int main(int, char**) {
+  signature_test();
+  equivalent_test();
+  equivalent_reports_error_if_input_dne();
+  equivalent_hardlink_succeeds();
+#ifndef _WIN32
+  equivalent_is_other_succeeds();
 #endif
 
-TEST_SUITE_END()
+  return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.exists/exists.pass.cpp

 // bool exists(path const& p);
 // bool exists(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(exists_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     file_status s; ((void)s);
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOEXCEPT(exists(s));
     ASSERT_NOEXCEPT(exists(p, ec));
     ASSERT_NOT_NOEXCEPT(exists(p));
 }
 
-TEST_CASE(exists_status_test)
+static void exists_status_test()
 {
     struct TestCase {
         file_type type;
         bool expect;
     };
     const TestCase testCases[] = {
         {file_type::none, false},
         {file_type::not_found, false},
         {file_type::regular, true},
         {file_type::directory, true},
         {file_type::symlink, true},
         {file_type::block, true},
         {file_type::character, true},
         {file_type::fifo, true},
         {file_type::socket, true},
         {file_type::unknown, true}
     };
     for (auto& TC : testCases) {
         file_status s(TC.type);
-        TEST_CHECK(exists(s) == TC.expect);
+        assert(exists(s) == TC.expect);
     }
 }
 
-TEST_CASE(test_exist_not_found)
+static void test_exist_not_found()
 {
     static_test_env static_env;
     const path p = static_env.DNE;
-    TEST_CHECK(exists(p) == false);
+    assert(exists(p) == false);
 
-    TEST_CHECK(exists(static_env.Dir) == true);
-    TEST_CHECK(exists(static_env.Dir / "dne") == false);
+    assert(exists(static_env.Dir) == true);
+    assert(exists(static_env.Dir / "dne") == false);
     // Whether <dir>/dne/.. is considered to exist or not is not necessarily
     // something we need to define, but the platform specific behaviour
     // does affect a few other tests, so clarify the root cause here.
 #ifdef _WIN32
-    TEST_CHECK(exists(static_env.Dir / "dne" / "..") == true);
+    assert(exists(static_env.Dir / "dne" / "..") == true);
 #else
-    TEST_CHECK(exists(static_env.Dir / "dne" / "..") == false);
+    assert(exists(static_env.Dir / "dne" / "..") == false);
 #endif
 
     std::error_code ec = GetTestEC();
-    TEST_CHECK(exists(p, ec) == false);
-    TEST_CHECK(!ec);
+    assert(exists(p, ec) == false);
+    assert(!ec);
 }
 
-TEST_CASE(test_exists_fails)
+static void test_exists_fails()
 {
 #ifdef _WIN32
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories; test using a special inaccessible directory
     // instead.
     const path p = GetWindowsInaccessibleDir();
     if (p.empty())
-        TEST_UNSUPPORTED();
+        TEST_IS_UNSUPPORTED();
 #else
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path p = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 #endif
 
     std::error_code ec;
-    TEST_CHECK(exists(p, ec) == false);
-    TEST_CHECK(ec);
+    assert(exists(p, ec) == false);
+    assert(ec);
 
-    TEST_CHECK_THROW(filesystem_error, exists(p));
+    TEST_THROWS_TYPE(filesystem_error, exists(p));
 }
 
 #ifndef _WIN32
 // Checking for the existence of an invalid long path name doesn't
 // trigger errors on windows.
-TEST_CASE(test_name_too_long) {
+static void test_name_too_long() {
     std::string long_name(2500, 'a');
     const path file(long_name);
 
     std::error_code ec;
-    TEST_CHECK(exists(file, ec) == false);
-    TEST_CHECK(ec);
+    assert(exists(file, ec) == false);
+    assert(ec);
 }
+#endif // _WIN32
+
+int main(int, char**) {
+    signature_test();
+    exists_status_test();
+    test_exist_not_found();
+    test_exists_fails();
+#ifndef _WIN32
+    test_name_too_long();
 #endif
 
-TEST_SUITE_END()
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.file_size/file_size.pass.cpp

 // uintmax_t file_size(const path& p);
 // uintmax_t file_size(const path& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(file_size_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_SAME_TYPE(decltype(file_size(p)), uintmax_t);
     ASSERT_SAME_TYPE(decltype(file_size(p, ec)), uintmax_t);
     ASSERT_NOT_NOEXCEPT(file_size(p));
     ASSERT_NOEXCEPT(file_size(p, ec));
 }
 
-TEST_CASE(file_size_empty_test)
+static void file_size_empty_test()
 {
     static_test_env static_env;
     const path p = static_env.EmptyFile;
-    TEST_CHECK(file_size(p) == 0);
+    assert(file_size(p) == 0);
     std::error_code ec;
-    TEST_CHECK(file_size(p, ec) == 0);
+    assert(file_size(p, ec) == 0);
 }
 
-TEST_CASE(file_size_non_empty)
+static void file_size_non_empty()
 {
     scoped_test_env env;
     const path p = env.create_file("file", 42);
-    TEST_CHECK(file_size(p) == 42);
+    assert(file_size(p) == 42);
     std::error_code ec;
-    TEST_CHECK(file_size(p, ec) == 42);
+    assert(file_size(p, ec) == 42);
 }
 
-TEST_CASE(symlink_test_case)
+static void symlink_test_case()
 {
     static_test_env static_env;
     const path p = static_env.File;
     const path p2 = static_env.SymlinkToFile;
-    TEST_CHECK(file_size(p) == file_size(p2));
+    assert(file_size(p) == file_size(p2));
 }
 
-TEST_CASE(file_size_error_cases)
+static void file_size_error_cases()
 {
   static_test_env static_env;
   struct {
     path p;
     std::errc expected_err;
   } TestCases[] = {
       {static_env.Dir, std::errc::is_a_directory},
       {static_env.SymlinkToDir, std::errc::is_a_directory},
       {static_env.BadSymlink, std::errc::no_such_file_or_directory},
       {static_env.DNE, std::errc::no_such_file_or_directory},
       {"", std::errc::no_such_file_or_directory}};
     const uintmax_t expect = static_cast<uintmax_t>(-1);
     for (auto& TC : TestCases) {
       std::error_code ec = GetTestEC();
-      TEST_CHECK(file_size(TC.p, ec) == expect);
-      TEST_CHECK(ErrorIs(ec, TC.expected_err));
+      assert(file_size(TC.p, ec) == expect);
+      assert(ErrorIs(ec, TC.expected_err));
 
       ExceptionChecker Checker(TC.p, TC.expected_err, "file_size");
-      TEST_CHECK_THROW_RESULT(filesystem_error, Checker, file_size(TC.p));
+      TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, file_size(TC.p));
     }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_test();
+    file_size_empty_test();
+    file_size_non_empty();
+    symlink_test_case();
+    file_size_error_cases();
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_block_file/is_block_file.pass.cpp

 // bool is_block_file(path const& p);
 // bool is_block_file(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(is_block_file_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     file_status s; ((void)s);
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOEXCEPT(is_block_file(s));
     ASSERT_NOEXCEPT(is_block_file(p, ec));
     ASSERT_NOT_NOEXCEPT(is_block_file(p));
 }
 
-TEST_CASE(is_block_file_status_test)
+static void is_block_file_status_test()
 {
     struct TestCase {
         file_type type;
         bool expect;
     };
     const TestCase testCases[] = {
         {file_type::none, false},
         {file_type::not_found, false},
         {file_type::regular, false},
         {file_type::directory, false},
         {file_type::symlink, false},
         {file_type::block, true},
         {file_type::character, false},
         {file_type::fifo, false},
         {file_type::socket, false},
         {file_type::unknown, false}
     };
     for (auto& TC : testCases) {
         file_status s(TC.type);
-        TEST_CHECK(is_block_file(s) == TC.expect);
+        assert(is_block_file(s) == TC.expect);
     }
 }
 
-TEST_CASE(test_exist_not_found)
+static void test_exist_not_found()
 {
     static_test_env static_env;
     const path p = static_env.DNE;
-    TEST_CHECK(is_block_file(p) == false);
+    assert(is_block_file(p) == false);
 }
 
-TEST_CASE(test_is_block_file_fails)
+static void test_is_block_file_fails()
 {
     scoped_test_env env;
 #ifdef _WIN32
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories; test using a special inaccessible directory
     // instead.
     const path p = GetWindowsInaccessibleDir();
     if (p.empty())
-        TEST_UNSUPPORTED();
+        TEST_IS_UNSUPPORTED();
 #else
     const path dir = env.create_dir("dir");
     const path p = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 #endif
 
     std::error_code ec;
-    TEST_CHECK(is_block_file(p, ec) == false);
-    TEST_CHECK(ec);
+    assert(is_block_file(p, ec) == false);
+    assert(ec);
 
-    TEST_CHECK_THROW(filesystem_error, is_block_file(p));
+    TEST_THROWS_TYPE(filesystem_error, is_block_file(p));
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_test();
+    is_block_file_status_test();
+    test_exist_not_found();
+    test_is_block_file_fails();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_char_file/is_character_file.pass.cpp

 // bool is_character_file(path const& p);
 // bool is_character_file(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(is_character_file_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     file_status s; ((void)s);
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOEXCEPT(is_character_file(s));
     ASSERT_NOEXCEPT(is_character_file(p, ec));
     ASSERT_NOT_NOEXCEPT(is_character_file(p));
 }
 
-TEST_CASE(is_character_file_status_test)
+static void is_character_file_status_test()
 {
     struct TestCase {
         file_type type;
         bool expect;
     };
     const TestCase testCases[] = {
         {file_type::none, false},
         {file_type::not_found, false},
         {file_type::regular, false},
         {file_type::directory, false},
         {file_type::symlink, false},
         {file_type::block, false},
         {file_type::character, true},
         {file_type::fifo, false},
         {file_type::socket, false},
         {file_type::unknown, false}
     };
     for (auto& TC : testCases) {
         file_status s(TC.type);
-        TEST_CHECK(is_character_file(s) == TC.expect);
+        assert(is_character_file(s) == TC.expect);
     }
 }
 
-TEST_CASE(test_exist_not_found)
+static void test_exist_not_found()
 {
     static_test_env static_env;
     const path p = static_env.DNE;
-    TEST_CHECK(is_character_file(p) == false);
+    assert(is_character_file(p) == false);
 }
 
-TEST_CASE(test_is_character_file_fails)
+static void test_is_character_file_fails()
 {
     scoped_test_env env;
 #ifdef _WIN32
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories; test using a special inaccessible directory
     // instead.
     const path p = GetWindowsInaccessibleDir();
     if (p.empty())
-        TEST_UNSUPPORTED();
+        TEST_IS_UNSUPPORTED();
 #else
     const path dir = env.create_dir("dir");
     const path p = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 #endif
 
     std::error_code ec;
-    TEST_CHECK(is_character_file(p, ec) == false);
-    TEST_CHECK(ec);
+    assert(is_character_file(p, ec) == false);
+    assert(ec);
 
-    TEST_CHECK_THROW(filesystem_error, is_character_file(p));
+    TEST_THROWS_TYPE(filesystem_error, is_character_file(p));
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_test();
+    is_character_file_status_test();
+    test_exist_not_found();
+    test_is_character_file_fails();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_directory/is_directory.pass.cpp

 // bool is_directory(path const& p);
 // bool is_directory(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(is_directory_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     file_status s; ((void)s);
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOEXCEPT(is_directory(s));
     ASSERT_NOEXCEPT(is_directory(p, ec));
     ASSERT_NOT_NOEXCEPT(is_directory(p));
 }
 
-TEST_CASE(is_directory_status_test)
+static void is_directory_status_test()
 {
     struct TestCase {
         file_type type;
         bool expect;
     };
     const TestCase testCases[] = {
         {file_type::none, false},
         {file_type::not_found, false},
         {file_type::regular, false},
         {file_type::directory, true},
         {file_type::symlink, false},
         {file_type::block, false},
         {file_type::character, false},
         {file_type::fifo, false},
         {file_type::socket, false},
         {file_type::unknown, false}
     };
     for (auto& TC : testCases) {
         file_status s(TC.type);
-        TEST_CHECK(is_directory(s) == TC.expect);
+        assert(is_directory(s) == TC.expect);
     }
 }
 
-TEST_CASE(test_exist_not_found)
+static void test_exist_not_found()
 {
     static_test_env static_env;
     const path p = static_env.DNE;
-    TEST_CHECK(is_directory(p) == false);
+    assert(is_directory(p) == false);
 }
 
-TEST_CASE(static_env_test)
+static void static_env_test()
 {
     static_test_env static_env;
-    TEST_CHECK(is_directory(static_env.Dir));
-    TEST_CHECK(is_directory(static_env.SymlinkToDir));
-    TEST_CHECK(!is_directory(static_env.File));
+    assert(is_directory(static_env.Dir));
+    assert(is_directory(static_env.SymlinkToDir));
+    assert(!is_directory(static_env.File));
 }
 
-TEST_CASE(test_is_directory_fails)
+static void test_is_directory_fails()
 {
     scoped_test_env env;
 #ifdef _WIN32
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories; test using a special inaccessible directory
     // instead.
     const path p = GetWindowsInaccessibleDir();
     if (p.empty())
-        TEST_UNSUPPORTED();
+        TEST_IS_UNSUPPORTED();
 #else
     const path dir = env.create_dir("dir");
     const path p = env.create_dir("dir/dir2");
     permissions(dir, perms::none);
 #endif
 
     std::error_code ec;
-    TEST_CHECK(is_directory(p, ec) == false);
-    TEST_CHECK(ec);
+    assert(is_directory(p, ec) == false);
+    assert(ec);
 
-    TEST_CHECK_THROW(filesystem_error, is_directory(p));
+    TEST_THROWS_TYPE(filesystem_error, is_directory(p));
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_test();
+    is_directory_status_test();
+    test_exist_not_found();
+    static_env_test();
+    test_is_directory_fails();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_empty/is_empty.pass.cpp

 // bool is_empty(path const& p);
 // bool is_empty(path const& p, std::error_code& ec);
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(is_empty_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(is_empty(p, ec));
     ASSERT_NOT_NOEXCEPT(is_empty(p));
 }
 
-TEST_CASE(test_exist_not_found)
+static void test_exist_not_found()
 {
     static_test_env static_env;
     const path p = static_env.DNE;
     std::error_code ec;
-    TEST_CHECK(is_empty(p, ec) == false);
-    TEST_CHECK(ec);
-    TEST_CHECK_THROW(filesystem_error, is_empty(p));
+    assert(is_empty(p, ec) == false);
+    assert(ec);
+    TEST_THROWS_TYPE(filesystem_error, is_empty(p));
 }
 
-TEST_CASE(test_is_empty_directory)
+static void test_is_empty_directory()
 {
     static_test_env static_env;
-    TEST_CHECK(!is_empty(static_env.Dir));
-    TEST_CHECK(!is_empty(static_env.SymlinkToDir));
+    assert(!is_empty(static_env.Dir));
+    assert(!is_empty(static_env.SymlinkToDir));
 }
 
-TEST_CASE(test_is_empty_directory_dynamic)
+static void test_is_empty_directory_dynamic()
 {
     scoped_test_env env;
-    TEST_CHECK(is_empty(env.test_root));
+    assert(is_empty(env.test_root));
     env.create_file("foo", 42);
-    TEST_CHECK(!is_empty(env.test_root));
+    assert(!is_empty(env.test_root));
 }
 
-TEST_CASE(test_is_empty_file)
+static void test_is_empty_file()
 {
     static_test_env static_env;
-    TEST_CHECK(is_empty(static_env.EmptyFile));
-    TEST_CHECK(!is_empty(static_env.NonEmptyFile));
+    assert(is_empty(static_env.EmptyFile));
+    assert(!is_empty(static_env.NonEmptyFile));
 }
 
-TEST_CASE(test_is_empty_fails)
+static void test_is_empty_fails()
 {
     scoped_test_env env;
 #ifdef _WIN32
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories; test using a special inaccessible directory
     // instead.
     const path p = GetWindowsInaccessibleDir();
     if (p.empty())
-        TEST_UNSUPPORTED();
+        TEST_IS_UNSUPPORTED();
 #else
     const path dir = env.create_dir("dir");
     const path p = env.create_dir("dir/dir2");
     permissions(dir, perms::none);
 #endif
 
     std::error_code ec;
-    TEST_CHECK(is_empty(p, ec) == false);
-    TEST_CHECK(ec);
+    assert(is_empty(p, ec) == false);
+    assert(ec);
 
-    TEST_CHECK_THROW(filesystem_error, is_empty(p));
+    TEST_THROWS_TYPE(filesystem_error, is_empty(p));
 }
 
-TEST_CASE(test_directory_access_denied)
+static void test_directory_access_denied()
 {
     scoped_test_env env;
 #ifdef _WIN32
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories; test using a special inaccessible directory
     // instead.
     const path dir = GetWindowsInaccessibleDir();
     if (dir.empty())
-        TEST_UNSUPPORTED();
+        TEST_IS_UNSUPPORTED();
 #else
     const path dir = env.create_dir("dir");
     const path file1 = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 #endif
 
     std::error_code ec = GetTestEC();
-    TEST_CHECK(is_empty(dir, ec) == false);
-    TEST_CHECK(ec);
-    TEST_CHECK(ec != GetTestEC());
+    assert(is_empty(dir, ec) == false);
+    assert(ec);
+    assert(ec != GetTestEC());
 
-    TEST_CHECK_THROW(filesystem_error, is_empty(dir));
+    TEST_THROWS_TYPE(filesystem_error, is_empty(dir));
 }
 
 
 #ifndef _WIN32
-TEST_CASE(test_fifo_fails)
+static void test_fifo_fails()
 {
     scoped_test_env env;
     const path fifo = env.create_fifo("fifo");
 
     std::error_code ec = GetTestEC();
-    TEST_CHECK(is_empty(fifo, ec) == false);
-    TEST_CHECK(ec);
-    TEST_CHECK(ec != GetTestEC());
-
-    TEST_CHECK_THROW(filesystem_error, is_empty(fifo));
-}
+    assert(is_empty(fifo, ec) == false);
+    assert(ec);
+    assert(ec != GetTestEC());
+
+    TEST_THROWS_TYPE(filesystem_error, is_empty(fifo));
+}
+#endif // _WIN32
+
+int main(int, char**) {
+    signature_test();
+    test_exist_not_found();
+    test_is_empty_directory();
+    test_is_empty_directory_dynamic();
+    test_is_empty_file();
+    test_is_empty_fails();
+    test_directory_access_denied();
+#ifndef _WIN32
+    test_fifo_fails();
 #endif
 
-TEST_SUITE_END()
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_fifo/is_fifo.pass.cpp

 // bool is_fifo(path const& p);
 // bool is_fifo(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(is_fifo_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     file_status s; ((void)s);
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOEXCEPT(is_fifo(s));
     ASSERT_NOEXCEPT(is_fifo(p, ec));
     ASSERT_NOT_NOEXCEPT(is_fifo(p));
 }
 
-TEST_CASE(is_fifo_status_test)
+static void is_fifo_status_test()
 {
     struct TestCase {
         file_type type;
         bool expect;
     };
     const TestCase testCases[] = {
         {file_type::none, false},
         {file_type::not_found, false},
         {file_type::regular, false},
         {file_type::directory, false},
         {file_type::symlink, false},
         {file_type::block, false},
         {file_type::character, false},
         {file_type::fifo, true},
         {file_type::socket, false},
         {file_type::unknown, false}
     };
     for (auto& TC : testCases) {
         file_status s(TC.type);
-        TEST_CHECK(is_fifo(s) == TC.expect);
+        assert(is_fifo(s) == TC.expect);
     }
 }
 
-TEST_CASE(test_exist_not_found)
+static void test_exist_not_found()
 {
     static_test_env static_env;
     const path p = static_env.DNE;
-    TEST_CHECK(is_fifo(p) == false);
+    assert(is_fifo(p) == false);
 }
 
-TEST_CASE(test_is_fifo_fails)
+static void test_is_fifo_fails()
 {
     scoped_test_env env;
 #ifdef _WIN32
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories; test using a special inaccessible directory
     // instead.
     const path p = GetWindowsInaccessibleDir();
     if (p.empty())
-        TEST_UNSUPPORTED();
+        TEST_IS_UNSUPPORTED();
 #else
     const path dir = env.create_dir("dir");
     const path p = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 #endif
 
     std::error_code ec;
-    TEST_CHECK(is_fifo(p, ec) == false);
-    TEST_CHECK(ec);
+    assert(is_fifo(p, ec) == false);
+    assert(ec);
 
-    TEST_CHECK_THROW(filesystem_error, is_fifo(p));
+    TEST_THROWS_TYPE(filesystem_error, is_fifo(p));
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_test();
+    is_fifo_status_test();
+    test_exist_not_found();
+    test_is_fifo_fails();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_other/is_other.pass.cpp

 // bool is_other(path const& p);
 // bool is_other(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(is_other_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     file_status s; ((void)s);
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOEXCEPT(is_other(s));
     ASSERT_NOEXCEPT(is_other(p, ec));
     ASSERT_NOT_NOEXCEPT(is_other(p));
 }
 
-TEST_CASE(is_other_status_test)
+static void is_other_status_test()
 {
     struct TestCase {
         file_type type;
         bool expect;
     };
     const TestCase testCases[] = {
         {file_type::none, false},
         {file_type::not_found, false},
         {file_type::regular, false},
         {file_type::directory, false},
         {file_type::symlink, false},
         {file_type::block, true},
         {file_type::character, true},
         {file_type::fifo, true},
         {file_type::socket, true},
         {file_type::unknown, true}
     };
     for (auto& TC : testCases) {
         file_status s(TC.type);
-        TEST_CHECK(is_other(s) == TC.expect);
+        assert(is_other(s) == TC.expect);
     }
 }
 
-TEST_CASE(test_exist_not_found)
+static void test_exist_not_found()
 {
     static_test_env static_env;
     const path p = static_env.DNE;
-    TEST_CHECK(is_other(p) == false);
+    assert(is_other(p) == false);
 }
 
-TEST_CASE(test_is_other_fails)
+static void test_is_other_fails()
 {
     scoped_test_env env;
 #ifdef _WIN32
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories; test using a special inaccessible directory
     // instead.
     const path p = GetWindowsInaccessibleDir();
     if (p.empty())
-        TEST_UNSUPPORTED();
+        TEST_IS_UNSUPPORTED();
 #else
     const path dir = env.create_dir("dir");
     const path p = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 #endif
 
     std::error_code ec;
-    TEST_CHECK(is_other(p, ec) == false);
-    TEST_CHECK(ec);
+    assert(is_other(p, ec) == false);
+    assert(ec);
 
-    TEST_CHECK_THROW(filesystem_error, is_other(p));
+    TEST_THROWS_TYPE(filesystem_error, is_other(p));
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_test();
+    is_other_status_test();
+    test_exist_not_found();
+    test_is_other_fails();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_regular_file/is_regular_file.pass.cpp

 // bool is_regular_file(path const& p);
 // bool is_regular_file(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(is_regular_file_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     file_status s; ((void)s);
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOEXCEPT(is_regular_file(s));
     ASSERT_NOEXCEPT(is_regular_file(p, ec));
     ASSERT_NOT_NOEXCEPT(is_regular_file(p));
 }
 
-TEST_CASE(is_regular_file_status_test)
+static void is_regular_file_status_test()
 {
     struct TestCase {
         file_type type;
         bool expect;
     };
     const TestCase testCases[] = {
         {file_type::none, false},
         {file_type::not_found, false},
         {file_type::regular, true},
         {file_type::directory, false},
         {file_type::symlink, false},
         {file_type::block, false},
         {file_type::character, false},
         {file_type::fifo, false},
         {file_type::socket, false},
         {file_type::unknown, false}
     };
     for (auto& TC : testCases) {
         file_status s(TC.type);
-        TEST_CHECK(is_regular_file(s) == TC.expect);
+        assert(is_regular_file(s) == TC.expect);
     }
 }
 
-TEST_CASE(test_exist_not_found)
+static void test_exist_not_found()
 {
     static_test_env static_env;
     const path p = static_env.DNE;
-    TEST_CHECK(is_regular_file(p) == false);
+    assert(is_regular_file(p) == false);
     std::error_code ec;
-    TEST_CHECK(is_regular_file(p, ec) == false);
-    TEST_CHECK(ec);
+    assert(is_regular_file(p, ec) == false);
+    assert(ec);
 }
 
-TEST_CASE(test_is_regular_file_fails)
+static void test_is_regular_file_fails()
 {
     scoped_test_env env;
 #ifdef _WIN32
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories; test using a special inaccessible directory
     // instead.
     const path p = GetWindowsInaccessibleDir();
     if (p.empty())
-        TEST_UNSUPPORTED();
+        TEST_IS_UNSUPPORTED();
 #else
     const path dir = env.create_dir("dir");
     const path p = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 #endif
 
     std::error_code ec;
-    TEST_CHECK(is_regular_file(p, ec) == false);
-    TEST_CHECK(ec);
+    assert(is_regular_file(p, ec) == false);
+    assert(ec);
 
-    TEST_CHECK_THROW(filesystem_error, is_regular_file(p));
+    TEST_THROWS_TYPE(filesystem_error, is_regular_file(p));
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_test();
+    is_regular_file_status_test();
+    test_exist_not_found();
+    test_is_regular_file_fails();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_socket/is_socket.pass.cpp

 // bool is_socket(path const& p);
 // bool is_socket(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(is_socket_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     file_status s; ((void)s);
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOEXCEPT(is_socket(s));
     ASSERT_NOEXCEPT(is_socket(p, ec));
     ASSERT_NOT_NOEXCEPT(is_socket(p));
 }
 
-TEST_CASE(is_socket_status_test)
+static void is_socket_status_test()
 {
     struct TestCase {
         file_type type;
         bool expect;
     };
     const TestCase testCases[] = {
         {file_type::none, false},
         {file_type::not_found, false},
         {file_type::regular, false},
         {file_type::directory, false},
         {file_type::symlink, false},
         {file_type::block, false},
         {file_type::character, false},
         {file_type::fifo, false},
         {file_type::socket, true},
         {file_type::unknown, false}
     };
     for (auto& TC : testCases) {
         file_status s(TC.type);
-        TEST_CHECK(is_socket(s) == TC.expect);
+        assert(is_socket(s) == TC.expect);
     }
 }
 
-TEST_CASE(test_exist_not_found)
+static void test_exist_not_found()
 {
     static_test_env static_env;
     const path p = static_env.DNE;
-    TEST_CHECK(is_socket(p) == false);
+    assert(is_socket(p) == false);
 }
 
-TEST_CASE(test_is_socket_fails)
+static void test_is_socket_fails()
 {
     scoped_test_env env;
 #ifdef _WIN32
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories; test using a special inaccessible directory
     // instead.
     const path p = GetWindowsInaccessibleDir();
     if (p.empty())
-        TEST_UNSUPPORTED();
+        TEST_IS_UNSUPPORTED();
 #else
     const path dir = env.create_dir("dir");
     const path p = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 #endif
 
     std::error_code ec;
-    TEST_CHECK(is_socket(p, ec) == false);
-    TEST_CHECK(ec);
+    assert(is_socket(p, ec) == false);
+    assert(ec);
 
-    TEST_CHECK_THROW(filesystem_error, is_socket(p));
+    TEST_THROWS_TYPE(filesystem_error, is_socket(p));
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_test();
+    is_socket_status_test();
+    test_exist_not_found();
+    test_is_socket_fails();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.is_symlink/is_symlink.pass.cpp

 // bool is_symlink(path const& p);
 // bool is_symlink(path const& p, std::error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(is_symlink_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     file_status s; ((void)s);
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOEXCEPT(is_symlink(s));
     ASSERT_NOEXCEPT(is_symlink(p, ec));
     ASSERT_NOT_NOEXCEPT(is_symlink(p));
 }
 
-TEST_CASE(is_symlink_status_test)
+static void is_symlink_status_test()
 {
     struct TestCase {
         file_type type;
         bool expect;
     };
     const TestCase testCases[] = {
         {file_type::none, false},
         {file_type::not_found, false},
         {file_type::regular, false},
         {file_type::directory, false},
         {file_type::symlink, true},
         {file_type::block, false},
         {file_type::character, false},
         {file_type::fifo, false},
         {file_type::socket, false},
         {file_type::unknown, false}
     };
     for (auto& TC : testCases) {
         file_status s(TC.type);
-        TEST_CHECK(is_symlink(s) == TC.expect);
+        assert(is_symlink(s) == TC.expect);
     }
 }
 
-TEST_CASE(static_env_test)
+static void static_env_test()
 {
     static_test_env static_env;
     struct TestCase {
         path p;
         bool expect;
     };
     const TestCase testCases[] = {
         {static_env.File, false},
         {static_env.Dir, false},
         {static_env.SymlinkToFile, true},
         {static_env.SymlinkToDir, true},
         {static_env.BadSymlink, true}
     };
     for (auto& TC : testCases) {
-        TEST_CHECK(is_symlink(TC.p) == TC.expect);
+        assert(is_symlink(TC.p) == TC.expect);
     }
 }
 
-TEST_CASE(test_exist_not_found)
+static void test_exist_not_found()
 {
     static_test_env static_env;
     const path p = static_env.DNE;
-    TEST_CHECK(is_symlink(p) == false);
+    assert(is_symlink(p) == false);
     std::error_code ec;
-    TEST_CHECK(is_symlink(p, ec) == false);
-    TEST_CHECK(ec);
+    assert(is_symlink(p, ec) == false);
+    assert(ec);
 }
 
-TEST_CASE(test_is_symlink_fails)
+static void test_is_symlink_fails()
 {
     scoped_test_env env;
 #ifdef _WIN32
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories; test using a special inaccessible directory
     // instead.
     const path p = GetWindowsInaccessibleDir();
     if (p.empty())
-        TEST_UNSUPPORTED();
+        TEST_IS_UNSUPPORTED();
 #else
     const path dir = env.create_dir("dir");
     const path p = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 #endif
 
     std::error_code ec;
-    TEST_CHECK(is_symlink(p, ec) == false);
-    TEST_CHECK(ec);
+    assert(is_symlink(p, ec) == false);
+    assert(ec);
 
-    TEST_CHECK_THROW(filesystem_error, is_symlink(p));
+    TEST_THROWS_TYPE(filesystem_error, is_symlink(p));
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_test();
+    is_symlink_status_test();
+    static_env_test();
+    test_exist_not_found();
+    test_is_symlink_fails();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.last_write_time/last_write_time.pass.cpp

 #include <chrono>
 #include <cstdio>
 #include <cstdlib>
 #include <ctime>
 #include <ratio>
 #include <type_traits>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 #include <fcntl.h>
 #ifdef _WIN32
 #include <windows.h>
 #else
 #include <sys/time.h>
 #include <sys/stat.h>
file_time_type::duration SubSec(long long val) {
   using SubSecT = file_time_type::duration;
   if (SupportsNanosecondRoundTrip) {
     return duration_cast<SubSecT>(NanoSec(val));
   } else {
     return duration_cast<SubSecT>(MicroSec(val));
   }
 }
 
-TEST_SUITE(last_write_time_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     const file_time_type t;
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_SAME_TYPE(decltype(last_write_time(p)), file_time_type);
     ASSERT_SAME_TYPE(decltype(last_write_time(p, ec)), file_time_type);
     ASSERT_SAME_TYPE(decltype(last_write_time(p, t)), void);
     ASSERT_SAME_TYPE(decltype(last_write_time(p, t, ec)), void);
     ASSERT_NOT_NOEXCEPT(last_write_time(p));
     ASSERT_NOT_NOEXCEPT(last_write_time(p, t));
     ASSERT_NOEXCEPT(last_write_time(p, ec));
     ASSERT_NOEXCEPT(last_write_time(p, t, ec));
 }
 
-TEST_CASE(read_last_write_time_static_env_test)
+static void read_last_write_time_static_env_test()
 {
     static_test_env static_env;
     using C = file_time_type::clock;
     file_time_type min = file_time_type::min();
     // Sleep a little to make sure that static_env.File created above is
     // strictly older than C::now() even with a coarser clock granularity
     // in C::now(). (GetSystemTimeAsFileTime on windows has a fairly coarse
     // granularity.)
     SleepFor(MilliSec(30));
     {
         file_time_type ret = last_write_time(static_env.File);
-        TEST_CHECK(ret != min);
-        TEST_CHECK(ret < C::now());
-        TEST_CHECK(CompareTime(ret, LastWriteTime(static_env.File)));
+        assert(ret != min);
+        assert(ret < C::now());
+        assert(CompareTime(ret, LastWriteTime(static_env.File)));
 
         file_time_type ret2 = last_write_time(static_env.SymlinkToFile);
-        TEST_CHECK(CompareTime(ret, ret2));
-        TEST_CHECK(CompareTime(ret2, LastWriteTime(static_env.SymlinkToFile)));
+        assert(CompareTime(ret, ret2));
+        assert(CompareTime(ret2, LastWriteTime(static_env.SymlinkToFile)));
     }
     {
         file_time_type ret = last_write_time(static_env.Dir);
-        TEST_CHECK(ret != min);
-        TEST_CHECK(ret < C::now());
-        TEST_CHECK(CompareTime(ret, LastWriteTime(static_env.Dir)));
+        assert(ret != min);
+        assert(ret < C::now());
+        assert(CompareTime(ret, LastWriteTime(static_env.Dir)));
 
         file_time_type ret2 = last_write_time(static_env.SymlinkToDir);
-        TEST_CHECK(CompareTime(ret, ret2));
-        TEST_CHECK(CompareTime(ret2, LastWriteTime(static_env.SymlinkToDir)));
+        assert(CompareTime(ret, ret2));
+        assert(CompareTime(ret2, LastWriteTime(static_env.SymlinkToDir)));
     }
 }
 
-TEST_CASE(get_last_write_time_dynamic_env_test)
+static void get_last_write_time_dynamic_env_test()
 {
-    using Sec = std::chrono::seconds;
     scoped_test_env env;
 
     const path file = env.create_file("file", 42);
     const path dir = env.create_dir("dir");
 
     const auto file_times = GetTimes(file);
     const TimeSpec file_write_time = file_times.write;
     const auto dir_times = GetTimes(dir);
     const TimeSpec dir_write_time = dir_times.write;
 
     file_time_type ftime = last_write_time(file);
-    TEST_CHECK(CompareTime(ftime, file_write_time));
+    assert(CompareTime(ftime, file_write_time));
 
     file_time_type dtime = last_write_time(dir);
-    TEST_CHECK(CompareTime(dtime, dir_write_time));
+    assert(CompareTime(dtime, dir_write_time));
 
-    SleepFor(Sec(2));
+    SleepFor(std::chrono::seconds(2));
 
     // update file and add a file to the directory. Make sure the times increase.
     std::FILE* of = std::fopen(file.string().c_str(), "a");
     std::fwrite("hello", 1, sizeof("hello"), of);
     std::fclose(of);
     env.create_file("dir/file1", 1);
 
     file_time_type ftime2 = last_write_time(file);
     file_time_type dtime2 = last_write_time(dir);
 
-    TEST_CHECK(ftime2 > ftime);
-    TEST_CHECK(dtime2 > dtime);
-    TEST_CHECK(CompareTime(LastWriteTime(file), ftime2));
-    TEST_CHECK(CompareTime(LastWriteTime(dir), dtime2));
+    assert(ftime2 > ftime);
+    assert(dtime2 > dtime);
+    assert(CompareTime(LastWriteTime(file), ftime2));
+    assert(CompareTime(LastWriteTime(dir), dtime2));
 }
 
 
-TEST_CASE(set_last_write_time_dynamic_env_test)
+static void set_last_write_time_dynamic_env_test()
 {
     using Clock = file_time_type::clock;
     scoped_test_env env;
 
     const path file = env.create_file("file", 42);
     const path dir = env.create_dir("dir");
     const auto now = Clock::now();
     const file_time_type epoch_time = now - now.time_since_epoch();
#if !defined(_AIX)
         {"file, just_before_epoch_time", file, just_before_epoch_time},
         {"dir, just_before_epoch_time", dir, just_before_epoch_time}
 #endif
     };
 
     for (const auto& TC : cases) {
         const auto old_times = GetTimes(TC.p);
         file_time_type old_time;
-        TEST_REQUIRE(ConvertFromTimeSpec(old_time, old_times.write));
+        assert(ConvertFromTimeSpec(old_time, old_times.write));
 
         std::error_code ec = GetTestEC();
         last_write_time(TC.p, TC.new_time, ec);
-        TEST_CHECK(!ec);
+        assert(!ec);
 
         ec = GetTestEC();
         file_time_type  got_time = last_write_time(TC.p, ec);
-        TEST_REQUIRE(!ec);
+        assert(!ec);
 
         if (TimeIsRepresentableByFilesystem(TC.new_time)) {
-            TEST_CHECK(got_time != old_time);
-            TEST_CHECK(CompareTime(got_time, TC.new_time));
-            TEST_CHECK(CompareTime(LastAccessTime(TC.p), old_times.access));
+            assert(got_time != old_time);
+            assert(CompareTime(got_time, TC.new_time));
+            assert(CompareTime(LastAccessTime(TC.p), old_times.access));
         }
     }
 }
 
-TEST_CASE(last_write_time_symlink_test)
+static void last_write_time_symlink_test()
 {
     using Clock = file_time_type::clock;
 
     scoped_test_env env;
 
     const path file = env.create_file("file", 42);
     const path sym = env.create_symlink("file", "sym");
 
     const file_time_type new_time = Clock::now() + Hours(3);
 
     const auto old_times = GetTimes(sym);
     const auto old_sym_times = GetSymlinkTimes(sym);
 
     std::error_code ec = GetTestEC();
     last_write_time(sym, new_time, ec);
-    TEST_CHECK(!ec);
+    assert(!ec);
 
     file_time_type  got_time = last_write_time(sym);
-    TEST_CHECK(!CompareTime(got_time, old_times.write));
+    assert(!CompareTime(got_time, old_times.write));
     if (!WorkaroundStatTruncatesToSeconds) {
-      TEST_CHECK(got_time == new_time);
+      assert(got_time == new_time);
     } else {
-      TEST_CHECK(CompareTime(got_time, new_time));
+      assert(CompareTime(got_time, new_time));
     }
 
-    TEST_CHECK(CompareTime(LastWriteTime(file), new_time));
-    TEST_CHECK(CompareTime(LastAccessTime(sym), old_times.access));
+    assert(CompareTime(LastWriteTime(file), new_time));
+    assert(CompareTime(LastAccessTime(sym), old_times.access));
     Times sym_times = GetSymlinkTimes(sym);
-    TEST_CHECK(CompareTime(sym_times.write, old_sym_times.write));
+    assert(CompareTime(sym_times.write, old_sym_times.write));
 }
 
 
-TEST_CASE(test_write_min_time)
+static void test_write_min_time()
 {
     scoped_test_env env;
     const path p = env.create_file("file", 42);
     const file_time_type old_time = last_write_time(p);
     file_time_type new_time = file_time_type::min();
 
     std::error_code ec = GetTestEC();
     last_write_time(p, new_time, ec);
     file_time_type tt = last_write_time(p);
 
     if (TimeIsRepresentableByFilesystem(new_time)) {
-        TEST_CHECK(!ec);
-        TEST_CHECK(CompareTime(tt, new_time));
+        assert(!ec);
+        assert(CompareTime(tt, new_time));
 
         last_write_time(p, old_time);
         new_time = file_time_type::min() + SubSec(1);
 
         ec = GetTestEC();
         last_write_time(p, new_time, ec);
         tt = last_write_time(p);
 
         if (TimeIsRepresentableByFilesystem(new_time)) {
-            TEST_CHECK(!ec);
-            TEST_CHECK(CompareTime(tt, new_time));
+            assert(!ec);
+            assert(CompareTime(tt, new_time));
         } else {
-          TEST_CHECK(ErrorIs(ec, std::errc::value_too_large));
-          TEST_CHECK(tt == old_time);
+          assert(ErrorIs(ec, std::errc::value_too_large));
+          assert(tt == old_time);
         }
     } else {
-      TEST_CHECK(ErrorIs(ec, std::errc::value_too_large));
-      TEST_CHECK(tt == old_time);
+      assert(ErrorIs(ec, std::errc::value_too_large));
+      assert(tt == old_time);
     }
 }
 
-TEST_CASE(test_write_max_time) {
+static void test_write_max_time() {
   scoped_test_env env;
   const path p = env.create_file("file", 42);
   const file_time_type old_time = last_write_time(p);
   file_time_type new_time = file_time_type::max();
 
   std::error_code ec = GetTestEC();
   last_write_time(p, new_time, ec);
   file_time_type tt = last_write_time(p);
 
   if (TimeIsRepresentableByFilesystem(new_time)) {
-    TEST_CHECK(!ec);
-    TEST_CHECK(CompareTime(tt, new_time));
+    assert(!ec);
+    assert(CompareTime(tt, new_time));
   } else {
-    TEST_CHECK(ErrorIs(ec, std::errc::value_too_large));
-    TEST_CHECK(tt == old_time);
+    assert(ErrorIs(ec, std::errc::value_too_large));
+    assert(tt == old_time);
   }
 }
 
-TEST_CASE(test_value_on_failure)
+static void test_value_on_failure()
 {
     static_test_env static_env;
     const path p = static_env.DNE;
     std::error_code ec = GetTestEC();
-    TEST_CHECK(last_write_time(p, ec) == file_time_type::min());
-    TEST_CHECK(ErrorIs(ec, std::errc::no_such_file_or_directory));
+    assert(last_write_time(p, ec) == file_time_type::min());
+    assert(ErrorIs(ec, std::errc::no_such_file_or_directory));
 }
 
 // Windows doesn't support setting perms::none to trigger failures
 // reading directories.
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
-TEST_CASE(test_exists_fails)
+static void test_exists_fails()
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path file = env.create_file("dir/file", 42);
     permissions(dir, perms::none);
 
     std::error_code ec = GetTestEC();
-    TEST_CHECK(last_write_time(file, ec) == file_time_type::min());
-    TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
+    assert(last_write_time(file, ec) == file_time_type::min());
+    assert(ErrorIs(ec, std::errc::permission_denied));
 
     ExceptionChecker Checker(file, std::errc::permission_denied,
                              "last_write_time");
-    TEST_CHECK_THROW_RESULT(filesystem_error, Checker, last_write_time(file));
+    TEST_VALIDATE_EXCEPTION(filesystem_error, Checker, last_write_time(file));
 }
-#endif
+#endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_test();
+    read_last_write_time_static_env_test();
+    get_last_write_time_dynamic_env_test();
+    set_last_write_time_dynamic_env_test();
+    last_write_time_symlink_test();
+    test_write_min_time();
+    test_write_max_time();
+    test_value_on_failure();
+#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
+    test_exists_fails();
+#endif
+  return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.permissions/permissions.pass.cpp

 // void permissions(const path& p, perms prms, std::error_code& ec) noexcept;
 // void permissions(const path& p, perms prms, perm_options opts, std::error_code);
 
 
 
 #include "filesystem_include.h"
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
 using PR = fs::perms;
 
-TEST_SUITE(filesystem_permissions_test_suite)
-
-TEST_CASE(test_signatures)
+static void test_signatures()
 {
     const path p; ((void)p);
     const perms pr{}; ((void)pr);
     const perm_options opts{}; ((void)opts);
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(fs::permissions(p, pr));
     ASSERT_NOT_NOEXCEPT(fs::permissions(p, pr, opts));
     ASSERT_NOEXCEPT(fs::permissions(p, pr, ec));
     LIBCPP_ONLY(ASSERT_NOT_NOEXCEPT(fs::permissions(p, pr, opts, ec)));
 }
 
-TEST_CASE(test_error_reporting)
+static void test_error_reporting()
 {
     auto checkThrow = [](path const& f, fs::perms opts,
                          const std::error_code& ec)
     {
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try {
             fs::permissions(f, opts);
             return false;
#endif
     };
 
     scoped_test_env env;
     const path dne = env.make_env_path("dne");
     const path dne_sym = env.create_symlink(dne, "dne_sym");
     { // !exists
         std::error_code ec = GetTestEC();
         fs::permissions(dne, fs::perms{}, ec);
-        TEST_REQUIRE(ec);
-        TEST_CHECK(ec != GetTestEC());
-        TEST_CHECK(checkThrow(dne, fs::perms{}, ec));
+        assert(ec);
+        assert(ec != GetTestEC());
+        assert(checkThrow(dne, fs::perms{}, ec));
     }
     {
         std::error_code ec = GetTestEC();
         fs::permissions(dne_sym, fs::perms{}, ec);
-        TEST_REQUIRE(ec);
-        TEST_CHECK(ec != GetTestEC());
-        TEST_CHECK(checkThrow(dne_sym, fs::perms{}, ec));
+        assert(ec);
+        assert(ec != GetTestEC());
+        assert(checkThrow(dne_sym, fs::perms{}, ec));
     }
 }
 
-TEST_CASE(basic_permissions_test)
+static void basic_permissions_test()
 {
     scoped_test_env env;
     const path file = env.create_file("file1", 42);
     const path dir = env.create_dir("dir1");
     const path file_for_sym = env.create_file("file2", 42);
     const path sym = env.create_symlink(file_for_sym, "sym");
     const perm_options AP = perm_options::add;
     const perm_options RP = perm_options::remove;
struct TestCase {
         {sym, perms::group_all, perms::owner_all | perms::group_all, AP},
         {sym, perms::group_all, perms::owner_all, RP},
         // test non-symlink with symlink_nofollow. The last test on file/dir
         // will have set their permissions to perms::owner_all
         {file, perms::group_all, perms::owner_all | perms::group_all, AP | NF},
         {dir,  perms::group_all, perms::owner_all | perms::group_all, AP | NF}
     };
     for (auto const& TC : cases) {
-        TEST_CHECK(status(TC.p).permissions() != TC.expected);
+        assert(status(TC.p).permissions() != TC.expected);
         {
           std::error_code ec = GetTestEC();
           permissions(TC.p, TC.set_perms, TC.opts, ec);
-          TEST_CHECK(!ec);
+          assert(!ec);
           auto pp = status(TC.p).permissions();
-          TEST_CHECK(pp == NormalizeExpectedPerms(TC.expected));
+          assert(pp == NormalizeExpectedPerms(TC.expected));
         }
         if (TC.opts == perm_options::replace) {
           std::error_code ec = GetTestEC();
           permissions(TC.p, TC.set_perms, ec);
-          TEST_CHECK(!ec);
+          assert(!ec);
           auto pp = status(TC.p).permissions();
-          TEST_CHECK(pp == NormalizeExpectedPerms(TC.expected));
+          assert(pp == NormalizeExpectedPerms(TC.expected));
         }
     }
 }
 
 #ifndef _WIN32
 // This test isn't currently meaningful on Windows; the Windows file
 // permissions visible via std::filesystem doesn't show any difference
 // between owner/group/others.
-TEST_CASE(test_no_resolve_symlink_on_symlink)
+static void test_no_resolve_symlink_on_symlink()
 {
     scoped_test_env env;
     const path file = env.create_file("file", 42);
     const path sym = env.create_symlink(file, "sym");
     const auto file_perms = status(file).permissions();
 
     struct TestCase {
         perms set_perms;
#else
         // be 'operation_not_supported' and the symlink permissions should be
         // unchanged.
         const auto expected_link_perms = symlink_status(sym).permissions();
         std::error_code expected_ec = std::make_error_code(std::errc::operation_not_supported);
 #endif
         std::error_code ec = GetTestEC();
         permissions(sym, TC.set_perms, TC.opts | perm_options::nofollow, ec);
         if (expected_ec)
-            TEST_CHECK(ErrorIs(ec, static_cast<std::errc>(expected_ec.value())));
+            assert(ErrorIs(ec, static_cast<std::errc>(expected_ec.value())));
         else
-            TEST_CHECK(!ec);
-        TEST_CHECK(status(file).permissions() == file_perms);
-        TEST_CHECK(symlink_status(sym).permissions() == expected_link_perms);
+            assert(!ec);
+        assert(status(file).permissions() == file_perms);
+        assert(symlink_status(sym).permissions() == expected_link_perms);
     }
 }
-#endif
+#endif // _WIN32
 
-TEST_SUITE_END()
+int main(int, char**) {
+    test_signatures();
+    test_error_reporting();
+    basic_permissions_test();
+#ifndef _WIN32
+    test_no_resolve_symlink_on_symlink();
+#endif
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.proximate/proximate.pass.cpp

 // path proximate(const path& p, const path& base, error_code& ec);
 
 #include "filesystem_include.h"
 #include <cassert>
 #include <cstdio>
 
 #include "test_macros.h"
 #include "count_new.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 
 static int count_path_elems(const fs::path& p) {
   int count = 0;
   for (auto&& elem : p) {
     if (elem != p.root_name() && elem != "/" && elem != "")
       ++count;
   }
   return count;
 }
 
-TEST_SUITE(filesystem_proximate_path_test_suite)
 
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     using fs::path;
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(proximate(p));
     ASSERT_NOT_NOEXCEPT(proximate(p, p));
     ASSERT_NOT_NOEXCEPT(proximate(p, ec));
     ASSERT_NOT_NOEXCEPT(proximate(p, p, ec));
 }
 
-TEST_CASE(basic_test) {
+static void basic_test() {
   using fs::path;
   const path cwd = fs::current_path();
   const path parent_cwd = cwd.parent_path();
   const path curdir = cwd.filename();
-  TEST_REQUIRE(!cwd.native().empty());
+  assert(!cwd.native().empty());
   int cwd_depth = count_path_elems(cwd);
   path dot_dot_to_root;
   for (int i=0; i < cwd_depth; ++i)
     dot_dot_to_root /= "..";
   path relative_cwd = cwd.native().substr(cwd.root_path().native().size());
   // clang-format off
   struct {
     fs::path input;
#endif
   for (auto& TC : TestCases) {
     ++ID;
     std::error_code ec = GetTestEC();
     fs::path p = TC.input;
     const fs::path output = fs::proximate(p, TC.base, ec);
     fs::path expect = TC.expect;
     expect.make_preferred();
     if (ec) {
-      TEST_CHECK(!ec);
+      assert(!ec);
       std::fprintf(stderr, "TEST CASE #%d FAILED:\n"
                   "  Input: '%s'\n"
                   "  Base: '%s'\n"
                   "  Expected: '%s'\n",
         ID, TC.input.string().c_str(), TC.base.string().c_str(),
         expect.string().c_str());
     } else if (!PathEq(output, expect)) {
-      TEST_CHECK(PathEq(output, expect));
+      assert(PathEq(output, expect));
 
       const path canon_input = fs::weakly_canonical(TC.input);
       const path canon_base = fs::weakly_canonical(TC.base);
       const path lexically_p = canon_input.lexically_proximate(canon_base);
       std::fprintf(stderr, "TEST CASE #%d FAILED:\n"
                   "  Input: '%s'\n"
                   "  Base: '%s'\n"
                   "  Expected: '%s'\n"
                   "  Output: '%s'\n"
                   "  Lex Prox: '%s'\n"
                   "  Canon Input: '%s'\n"
                   "  Canon Base: '%s'\n",
         ID, TC.input.string().c_str(), TC.base.string().c_str(),
         expect.string().c_str(), output.string().c_str(),
         lexically_p.string().c_str(), canon_input.string().c_str(),
         canon_base.string().c_str());
     }
   }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+  signature_test();
+  basic_test();
+
+  return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.read_symlink/read_symlink.pass.cpp

 // <filesystem>
 
 // path read_symlink(const path& p);
 // path read_symlink(const path& p, error_code& ec);
 
 #include "filesystem_include.h"
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(filesystem_read_symlink_test_suite)
-
-TEST_CASE(test_signatures)
+static void test_signatures()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_SAME_TYPE(decltype(fs::read_symlink(p)), fs::path);
     ASSERT_SAME_TYPE(decltype(fs::read_symlink(p, ec)), fs::path);
 
     ASSERT_NOT_NOEXCEPT(fs::read_symlink(p));
     // Not noexcept because of narrow contract
     ASSERT_NOT_NOEXCEPT(fs::read_symlink(p, ec));
 }
 
-TEST_CASE(test_error_reporting)
+static void test_error_reporting()
 {
     auto checkThrow = [](path const& f, const std::error_code& ec)
     {
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try {
             (void)fs::read_symlink(f);
             return false;
         } catch (filesystem_error const& err) {
#endif
     const path cases[] = {
         env.make_env_path("dne"),
         env.create_file("file", 42),
         env.create_dir("dir")
     };
     for (path const& p : cases) {
         std::error_code ec;
         const path ret = fs::read_symlink(p, ec);
-        TEST_REQUIRE(ec);
-        TEST_CHECK(ret == path{});
-        TEST_CHECK(checkThrow(p, ec));
+        assert(ec);
+        assert(ret == path{});
+        assert(checkThrow(p, ec));
     }
 
 }
 
-TEST_CASE(basic_symlink_test)
+static void basic_symlink_test()
 {
     scoped_test_env env;
     const path dne = env.make_env_path("dne");
     const path file = env.create_file("file", 42);
     const path dir = env.create_dir("dir");
     const path link = env.create_symlink(dne, "link");
     const path nested_link = env.make_env_path("nested_link");
     create_symlink(link, nested_link);
     struct TestCase {
       path symlink;
       path expected;
     } testCases[] = {
         {env.create_symlink(dne, "dne_link"), dne},
         {env.create_symlink(file, "file_link"), file},
         {env.create_directory_symlink(dir, "dir_link"), dir},
         {nested_link, link}
     };
     for (auto& TC : testCases) {
         std::error_code ec = std::make_error_code(std::errc::address_in_use);
         const path ret = read_symlink(TC.symlink, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(ret == TC.expected);
+        assert(!ec);
+        assert(ret == TC.expected);
     }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    test_signatures();
+    test_error_reporting();
+    basic_symlink_test();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.relative/relative.pass.cpp

 #include "filesystem_include.h"
 #include <string>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "count_new.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 
-TEST_SUITE(filesystem_proximate_path_test_suite)
-
-TEST_CASE(test_signature_0) {
+static void test_signature_0() {
   fs::path p("");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == fs::path::string_type(fs::current_path()));
+  assert(output == fs::path::string_type(fs::current_path()));
 }
 
-TEST_CASE(test_signature_1) {
+static void test_signature_1() {
   fs::path p(".");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == fs::path::string_type(fs::current_path()));
+  assert(output == fs::path::string_type(fs::current_path()));
 }
 
-TEST_CASE(test_signature_2) {
+static void test_signature_2() {
   static_test_env static_env;
   fs::path p(static_env.File);
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == fs::path::string_type(static_env.File));
+  assert(output == fs::path::string_type(static_env.File));
 }
 
-TEST_CASE(test_signature_3) {
+static void test_signature_3() {
   static_test_env static_env;
   fs::path p(static_env.Dir);
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == fs::path::string_type(static_env.Dir));
+  assert(output == fs::path::string_type(static_env.Dir));
 }
 
-TEST_CASE(test_signature_4) {
+static void test_signature_4() {
   static_test_env static_env;
   fs::path p(static_env.SymlinkToDir);
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == fs::path::string_type(static_env.Dir));
+  assert(output == fs::path::string_type(static_env.Dir));
 }
 
-TEST_CASE(test_signature_5) {
+static void test_signature_5() {
   static_test_env static_env;
   fs::path p(static_env.SymlinkToDir / "dir2/.");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == fs::path::string_type(static_env.Dir / "dir2"));
+  assert(output == fs::path::string_type(static_env.Dir / "dir2"));
 }
 
-TEST_CASE(test_signature_6) {
+static void test_signature_6() {
   static_test_env static_env;
   // FIXME? If the trailing separator occurs in a part of the path that exists,
   // it is omitted. Otherwise it is added to the end of the result.
   fs::path p(static_env.SymlinkToDir / "dir2/./");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == fs::path::string_type(static_env.Dir / "dir2"));
+  assert(output == fs::path::string_type(static_env.Dir / "dir2"));
 }
 
-TEST_CASE(test_signature_7) {
+static void test_signature_7() {
   static_test_env static_env;
   fs::path p(static_env.SymlinkToDir / "dir2/DNE/./");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == fs::path::string_type(static_env.Dir / "dir2/DNE/"));
+  assert(output == fs::path::string_type(static_env.Dir / "dir2/DNE/"));
 }
 
-TEST_CASE(test_signature_8) {
+static void test_signature_8() {
   static_test_env static_env;
   fs::path p(static_env.SymlinkToDir / "dir2");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == fs::path::string_type(static_env.Dir2));
+  assert(output == fs::path::string_type(static_env.Dir2));
 }
 
-TEST_CASE(test_signature_9) {
+static void test_signature_9() {
   static_test_env static_env;
   fs::path p(static_env.SymlinkToDir / "dir2/../dir2/DNE/..");
   const fs::path output = fs::weakly_canonical(p);
   // weakly_canonical has a quirk - if the path is considered to exist,
   // it's returned without a trailing slash, otherwise it's returned with
   // one (see a note in fs.op.weakly_canonical/weakly_canonical.pass.cpp).
   // On Windows, a path like existent/nonexistentsubdir/.. is considered
   // to exist, on posix it's considered to not exist. Therefore, the
   // result here differs in the trailing slash.
 #ifdef _WIN32
-  TEST_CHECK(output == fs::path::string_type(static_env.Dir2));
+  assert(output == fs::path::string_type(static_env.Dir2));
 #else
-  TEST_CHECK(output == fs::path::string_type(static_env.Dir2 / ""));
+  assert(output == fs::path::string_type(static_env.Dir2 / ""));
 #endif
 }
 
-TEST_CASE(test_signature_10) {
+static void test_signature_10() {
   static_test_env static_env;
   fs::path p(static_env.SymlinkToDir / "dir2/dir3/../DNE/DNE2");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == fs::path::string_type(static_env.Dir2 / "DNE/DNE2"));
+  assert(output == fs::path::string_type(static_env.Dir2 / "DNE/DNE2"));
 }
 
-TEST_CASE(test_signature_11) {
+static void test_signature_11() {
   static_test_env static_env;
   fs::path p(static_env.Dir / "../dir1");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == fs::path::string_type(static_env.Dir));
+  assert(output == fs::path::string_type(static_env.Dir));
 }
 
-TEST_CASE(test_signature_12) {
+static void test_signature_12() {
   static_test_env static_env;
   fs::path p(static_env.Dir / "./.");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == fs::path::string_type(static_env.Dir));
+  assert(output == fs::path::string_type(static_env.Dir));
 }
 
-TEST_CASE(test_signature_13) {
+static void test_signature_13() {
   static_test_env static_env;
   fs::path p(static_env.Dir / "DNE/../foo");
   const fs::path output = fs::weakly_canonical(p);
-  TEST_CHECK(output == fs::path::string_type(static_env.Dir / "foo"));
+  assert(output == fs::path::string_type(static_env.Dir / "foo"));
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+  test_signature_0();
+  test_signature_1();
+  test_signature_2();
+  test_signature_3();
+  test_signature_4();
+  test_signature_5();
+  test_signature_6();
+  test_signature_7();
+  test_signature_8();
+  test_signature_9();
+  test_signature_10();
+  test_signature_11();
+  test_signature_12();
+  test_signature_13();
+
+  return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove/remove.pass.cpp

 // <filesystem>
 
 // bool remove(const path& p);
 // bool remove(const path& p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(filesystem_remove_test_suite)
-
-TEST_CASE(test_signatures)
+static void test_signatures()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_SAME_TYPE(decltype(fs::remove(p)), bool);
     ASSERT_SAME_TYPE(decltype(fs::remove(p, ec)), bool);
 
     ASSERT_NOT_NOEXCEPT(fs::remove(p));
     ASSERT_NOEXCEPT(fs::remove(p, ec));
 }
 
-TEST_CASE(test_error_reporting)
+static void test_error_reporting()
 {
     auto checkThrow = [](path const& f, const std::error_code& ec)
     {
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try {
             fs::remove(f);
             return false;
         } catch (filesystem_error const& err) {
#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
         // GetWindowsInaccessibleDir() doesn't cause fs::remove() to report
         // errors, it just returns false cleanly.
         file_in_bad_dir,
 #endif
     };
     for (auto& p : testCases) {
         std::error_code ec;
 
-        TEST_CHECK(!fs::remove(p, ec));
-        TEST_CHECK(ec);
-        TEST_CHECK(checkThrow(p, ec));
+        assert(!fs::remove(p, ec));
+        assert(ec);
+        assert(checkThrow(p, ec));
     }
 
     // PR#35780
     const path testCasesNonexistant[] = {
         "",
         env.make_env_path("dne")
     };
 
     for (auto& p : testCasesNonexistant) {
         std::error_code ec;
 
-        TEST_CHECK(!fs::remove(p, ec));
-        TEST_CHECK(!ec);
+        assert(!fs::remove(p, ec));
+        assert(!ec);
     }
 }
 
-TEST_CASE(basic_remove_test)
+static void basic_remove_test()
 {
     scoped_test_env env;
     const path dne = env.make_env_path("dne");
     const path link = env.create_symlink(dne, "link");
     const path nested_link = env.make_env_path("nested_link");
     create_symlink(link, nested_link);
     const path testCases[] = {
         env.create_file("file", 42),
         env.create_dir("empty_dir"),
         nested_link,
         link
     };
     for (auto& p : testCases) {
         std::error_code ec = std::make_error_code(std::errc::address_in_use);
-        TEST_CHECK(remove(p, ec));
-        TEST_CHECK(!ec);
-        TEST_CHECK(!exists(symlink_status(p)));
+        assert(remove(p, ec));
+        assert(!ec);
+        assert(!exists(symlink_status(p)));
     }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    test_signatures();
+    test_error_reporting();
+    basic_remove_test();
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.remove_all/remove_all.pass.cpp

 // <filesystem>
 
 // uintmax_t remove_all(const path& p);
 // uintmax_t remove_all(const path& p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(filesystem_remove_all_test_suite)
-
-TEST_CASE(test_signatures)
+static void test_signatures()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_SAME_TYPE(decltype(fs::remove_all(p)), std::uintmax_t);
     ASSERT_SAME_TYPE(decltype(fs::remove_all(p, ec)), std::uintmax_t);
 
     ASSERT_NOT_NOEXCEPT(fs::remove_all(p));
     ASSERT_NOT_NOEXCEPT(fs::remove_all(p, ec));
 }
 
-TEST_CASE(test_error_reporting)
+static void test_error_reporting()
 {
     scoped_test_env env;
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories.
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
     auto checkThrow = [](path const& f, const std::error_code& ec)
     {
 #ifndef TEST_HAS_NO_EXCEPTIONS
#endif
 
     const path testCases[] = {
         file_in_bad_dir
     };
     const auto BadRet = static_cast<std::uintmax_t>(-1);
     for (auto& p : testCases) {
         std::error_code ec;
 
-        TEST_CHECK(fs::remove_all(p, ec) == BadRet);
-        TEST_CHECK(ec);
-        TEST_CHECK(checkThrow(p, ec));
+        assert(fs::remove_all(p, ec) == BadRet);
+        assert(ec);
+        assert(checkThrow(p, ec));
     }
 #endif
 
     // PR#35780
     const path testCasesNonexistant[] = {
         "",
         env.make_env_path("dne")
     };
     for (auto &p : testCasesNonexistant) {
         std::error_code ec;
 
-        TEST_CHECK(fs::remove_all(p, ec) == 0);
-        TEST_CHECK(!ec);
+        assert(fs::remove_all(p, ec) == 0);
+        assert(!ec);
     }
 }
 
-TEST_CASE(basic_remove_all_test)
+static void basic_remove_all_test()
 {
     scoped_test_env env;
     const path dne = env.make_env_path("dne");
     const path link = env.create_symlink(dne, "link");
     const path nested_link = env.make_env_path("nested_link");
     create_symlink(link, nested_link);
     const path testCases[] = {
         env.create_file("file", 42),
         env.create_dir("empty_dir"),
         nested_link,
         link
     };
     for (auto& p : testCases) {
         std::error_code ec = std::make_error_code(std::errc::address_in_use);
-        TEST_CHECK(remove(p, ec));
-        TEST_CHECK(!ec);
-        TEST_CHECK(!exists(symlink_status(p)));
+        assert(remove(p, ec));
+        assert(!ec);
+        assert(!exists(symlink_status(p)));
     }
 }
 
-TEST_CASE(symlink_to_dir)
+static void symlink_to_dir()
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path file = env.create_file(dir / "file", 42);
     const path link = env.create_directory_symlink(dir, "sym");
 
     {
         std::error_code ec = std::make_error_code(std::errc::address_in_use);
-        TEST_CHECK(remove_all(link, ec) == 1);
-        TEST_CHECK(!ec);
-        TEST_CHECK(!exists(symlink_status(link)));
-        TEST_CHECK(exists(dir));
-        TEST_CHECK(exists(file));
+        assert(remove_all(link, ec) == 1);
+        assert(!ec);
+        assert(!exists(symlink_status(link)));
+        assert(exists(dir));
+        assert(exists(file));
     }
 }
 
 
-TEST_CASE(nested_dir)
+static void nested_dir()
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path dir1 = env.create_dir(dir / "dir1");
     const path out_of_dir_file = env.create_file("file1", 42);
     const path all_files[] = {
         dir, dir1,
         env.create_file(dir / "file1", 42),
         env.create_symlink(out_of_dir_file, dir / "sym1"),
         env.create_file(dir1 / "file2", 42),
         env.create_directory_symlink(dir, dir1 / "sym2")
     };
     const std::size_t expected_count = sizeof(all_files) / sizeof(all_files[0]);
 
     std::error_code ec = std::make_error_code(std::errc::address_in_use);
-    TEST_CHECK(remove_all(dir, ec) == expected_count);
-    TEST_CHECK(!ec);
+    assert(remove_all(dir, ec) == expected_count);
+    assert(!ec);
     for (auto const& p : all_files) {
-        TEST_CHECK(!exists(symlink_status(p)));
+        assert(!exists(symlink_status(p)));
     }
-    TEST_CHECK(exists(out_of_dir_file));
+    assert(exists(out_of_dir_file));
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    test_signatures();
+    test_error_reporting();
+    basic_remove_all_test();
+    symlink_to_dir();
+    nested_dir();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.rename/rename.pass.cpp

 // <filesystem>
 
 // void rename(const path& old_p, const path& new_p);
 // void rename(const path& old_p,  const path& new_p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(filesystem_rename_test_suite)
-
-TEST_CASE(test_signatures)
+static void test_signatures()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_SAME_TYPE(decltype(fs::rename(p, p)), void);
     ASSERT_SAME_TYPE(decltype(fs::rename(p, p, ec)), void);
 
     ASSERT_NOT_NOEXCEPT(fs::rename(p, p));
     ASSERT_NOEXCEPT(fs::rename(p, p, ec));
 }
 
-TEST_CASE(test_error_reporting)
+static void test_error_reporting()
 {
     auto checkThrow = [](path const& f, path const& t, const std::error_code& ec)
     {
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try {
             fs::rename(f, t);
             return false;
         } catch (filesystem_error const& err) {
#ifndef _WIN32
         {dir, file},
 #endif
     };
     for (auto& TC : cases) {
         auto from_before = status(TC.from);
         auto to_before = status(TC.to);
         std::error_code ec;
         rename(TC.from, TC.to, ec);
-        TEST_REQUIRE(ec);
-        TEST_CHECK(from_before.type() == status(TC.from).type());
-        TEST_CHECK(to_before.type() == status(TC.to).type());
-        TEST_CHECK(checkThrow(TC.from, TC.to, ec));
+        assert(ec);
+        assert(from_before.type() == status(TC.from).type());
+        assert(to_before.type() == status(TC.to).type());
+        assert(checkThrow(TC.from, TC.to, ec));
     }
 }
 
-TEST_CASE(basic_rename_test)
+static void basic_rename_test()
 {
     scoped_test_env env;
 
     const std::error_code set_ec = std::make_error_code(std::errc::address_in_use);
     const path file = env.create_file("file1", 42);
     { // same file
         std::error_code ec = set_ec;
         rename(file, file, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(is_regular_file(file));
-        TEST_CHECK(file_size(file) == 42);
+        assert(!ec);
+        assert(is_regular_file(file));
+        assert(file_size(file) == 42);
     }
     const path sym = env.create_symlink(file, "sym");
     { // file -> symlink
         std::error_code ec = set_ec;
         rename(file, sym, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(!exists(file));
-        TEST_CHECK(is_regular_file(symlink_status(sym)));
-        TEST_CHECK(file_size(sym) == 42);
+        assert(!ec);
+        assert(!exists(file));
+        assert(is_regular_file(symlink_status(sym)));
+        assert(file_size(sym) == 42);
     }
     const path file2 = env.create_file("file2", 42);
     const path file3 = env.create_file("file3", 100);
     { // file -> file
         std::error_code ec = set_ec;
         rename(file2, file3, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(!exists(file2));
-        TEST_CHECK(is_regular_file(file3));
-        TEST_CHECK(file_size(file3) == 42);
+        assert(!ec);
+        assert(!exists(file2));
+        assert(is_regular_file(file3));
+        assert(file_size(file3) == 42);
     }
     const path dne = env.make_env_path("dne");
     const path bad_sym = env.create_symlink(dne, "bad_sym");
     const path bad_sym_dest = env.make_env_path("bad_sym2");
     { // bad-symlink
         std::error_code ec = set_ec;
         rename(bad_sym, bad_sym_dest, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(!exists(symlink_status(bad_sym)));
-        TEST_CHECK(is_symlink(bad_sym_dest));
-        TEST_CHECK(read_symlink(bad_sym_dest) == dne);
+        assert(!ec);
+        assert(!exists(symlink_status(bad_sym)));
+        assert(is_symlink(bad_sym_dest));
+        assert(read_symlink(bad_sym_dest) == dne);
     }
 }
 
-TEST_CASE(basic_rename_dir_test)
+static void basic_rename_dir_test()
 {
     static_test_env env;
     const std::error_code set_ec = std::make_error_code(std::errc::address_in_use);
     const path new_dir = env.makePath("new_dir");
     { // dir -> dir (with contents)
         std::error_code ec = set_ec;
         rename(env.Dir, new_dir, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(!exists(env.Dir));
-        TEST_CHECK(is_directory(new_dir));
-        TEST_CHECK(exists(new_dir / "file1"));
+        assert(!ec);
+        assert(!exists(env.Dir));
+        assert(is_directory(new_dir));
+        assert(exists(new_dir / "file1"));
     }
 #ifdef _WIN32
     // On Windows, renaming a directory over a file isn't an error (this
     // case is skipped in test_error_reporting above).
     { // dir -> file
         std::error_code ec = set_ec;
         rename(new_dir, env.NonEmptyFile, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(!exists(new_dir));
-        TEST_CHECK(is_directory(env.NonEmptyFile));
-        TEST_CHECK(exists(env.NonEmptyFile / "file1"));
+        assert(!ec);
+        assert(!exists(new_dir));
+        assert(is_directory(env.NonEmptyFile));
+        assert(exists(env.NonEmptyFile / "file1"));
     }
 #endif
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    test_signatures();
+    test_error_reporting();
+    basic_rename_test();
+    basic_rename_dir_test();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.resize_file/resize_file.pass.cpp

 // <filesystem>
 
 // void resize_file(const path& p, uintmax_t new_size);
 // void resize_file(const path& p, uintmax_t new_size, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(filesystem_resize_file_test_suite)
-
-TEST_CASE(test_signatures)
+static void test_signatures()
 {
     const path p; ((void)p);
     std::uintmax_t i; ((void)i);
     std::error_code ec; ((void)ec);
 
     ASSERT_SAME_TYPE(decltype(fs::resize_file(p, i)), void);
     ASSERT_SAME_TYPE(decltype(fs::resize_file(p, i, ec)), void);
 
     ASSERT_NOT_NOEXCEPT(fs::resize_file(p, i));
     ASSERT_NOEXCEPT(fs::resize_file(p, i, ec));
 }
 
-TEST_CASE(test_error_reporting)
+static void test_error_reporting()
 {
     auto checkThrow = [](path const& f, std::uintmax_t s, const std::error_code& ec)
     {
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try {
             fs::resize_file(f, s);
             return false;
         } catch (filesystem_error const& err) {
#endif
     const path bad_sym = env.create_symlink(dne, "sym");
     const path dir = env.create_dir("dir1");
     const path cases[] = {
         dne, bad_sym, dir
     };
     for (auto& p : cases) {
         std::error_code ec;
         resize_file(p, 42, ec);
-        TEST_REQUIRE(ec);
-        TEST_CHECK(checkThrow(p, 42, ec));
+        assert(ec);
+        assert(checkThrow(p, 42, ec));
     }
 }
 
-TEST_CASE(basic_resize_file_test)
+static void basic_resize_file_test()
 {
     scoped_test_env env;
     const path file1 = env.create_file("file1", 42);
     const auto set_ec = std::make_error_code(std::errc::address_in_use);
     { // grow file
         const std::uintmax_t new_s = 100;
         std::error_code ec = set_ec;
         resize_file(file1, new_s, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(file_size(file1) == new_s);
+        assert(!ec);
+        assert(file_size(file1) == new_s);
     }
     { // shrink file
         const std::uintmax_t new_s = 1;
         std::error_code ec = set_ec;
         resize_file(file1, new_s, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(file_size(file1) == new_s);
+        assert(!ec);
+        assert(file_size(file1) == new_s);
     }
     { // shrink file to zero
         const std::uintmax_t new_s = 0;
         std::error_code ec = set_ec;
         resize_file(file1, new_s, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(file_size(file1) == new_s);
+        assert(!ec);
+        assert(file_size(file1) == new_s);
     }
     const path sym = env.create_symlink(file1, "sym");
     { // grow file via symlink
         const std::uintmax_t new_s = 1024;
         std::error_code ec = set_ec;
         resize_file(sym, new_s, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(file_size(file1) == new_s);
+        assert(!ec);
+        assert(file_size(file1) == new_s);
     }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    test_signatures();
+    test_error_reporting();
+    basic_resize_file_test();
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.space/space.pass.cpp

 // <filesystem>
 
 // space_info space(const path& p);
 // space_info space(const path& p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
 bool EqualDelta(std::uintmax_t x, std::uintmax_t y, std::uintmax_t delta) {
     if (x >= y) {
         return (x - y) <= delta;
     } else {
         return (y - x) <= delta;
     }
 }
 
-TEST_SUITE(filesystem_space_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_SAME_TYPE(decltype(space(p)), space_info);
     ASSERT_SAME_TYPE(decltype(space(p, ec)), space_info);
     ASSERT_NOT_NOEXCEPT(space(p));
     ASSERT_NOEXCEPT(space(p, ec));
 }
 
-TEST_CASE(test_error_reporting)
+static void test_error_reporting()
 {
     static_test_env static_env;
     auto checkThrow = [](path const& f, const std::error_code& ec)
     {
 #ifndef TEST_HAS_NO_EXCEPTIONS
         try {
             (void)space(f);
             return false;
const path cases[] = {
         "",
         static_env.DNE,
         static_env.BadSymlink
     };
     for (auto& p : cases) {
         const auto expect = static_cast<std::uintmax_t>(-1);
         std::error_code ec;
         space_info info = space(p, ec);
-        TEST_CHECK(ec);
-        TEST_CHECK(info.capacity == expect);
-        TEST_CHECK(info.free == expect);
-        TEST_CHECK(info.available == expect);
-        TEST_CHECK(checkThrow(p, ec));
+        assert(ec);
+        assert(info.capacity == expect);
+        assert(info.free == expect);
+        assert(info.available == expect);
+        assert(checkThrow(p, ec));
     }
 }
 
-TEST_CASE(basic_space_test)
+static void basic_space_test()
 {
     static_test_env static_env;
 
     // All the test cases should reside on the same filesystem and therefore
     // should have the same expected result. Compute this expected result
     // one and check that it looks semi-sane.
     const std::uintmax_t bad_value = static_cast<std::uintmax_t>(-1);
     std::uintmax_t expect_capacity;
     std::uintmax_t expect_free;
     std::uintmax_t expect_avail;
-    TEST_REQUIRE(utils::space(static_env.Dir.string(), expect_capacity,
+    assert(utils::space(static_env.Dir.string(), expect_capacity,
                               expect_free, expect_avail));
 
     // Other processes running on the operating system may have changed
     // the amount of space available. Check that these are within tolerances.
     // Currently 5% of capacity
     const std::uintmax_t delta = expect_capacity / 20;
     const path cases[] = {
         static_env.File,
         static_env.Dir,
         static_env.Dir2,
         static_env.SymlinkToFile,
         static_env.SymlinkToDir
     };
     for (auto& p : cases) {
         std::error_code ec = GetTestEC();
         space_info info = space(p, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(info.capacity != bad_value);
-        TEST_CHECK(expect_capacity == info.capacity);
-        TEST_CHECK(info.free != bad_value);
-        TEST_CHECK(EqualDelta(expect_free, info.free, delta));
-        TEST_CHECK(info.available != bad_value);
-        TEST_CHECK(EqualDelta(expect_avail, info.available, delta));
+        assert(!ec);
+        assert(info.capacity != bad_value);
+        assert(expect_capacity == info.capacity);
+        assert(info.free != bad_value);
+        assert(EqualDelta(expect_free, info.free, delta));
+        assert(info.available != bad_value);
+        assert(EqualDelta(expect_avail, info.available, delta));
     }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_test();
+    test_error_reporting();
+    basic_space_test();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.status/status.pass.cpp

 // <filesystem>
 
 // file_status status(const path& p);
 // file_status status(const path& p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(filesystem_status_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(status(p));
     ASSERT_NOEXCEPT(status(p, ec));
 }
 
-TEST_CASE(test_status_not_found)
+static void test_status_not_found()
 {
     static_test_env static_env;
     const std::errc expect_errc = std::errc::no_such_file_or_directory;
     const path cases[] {
         static_env.DNE,
         static_env.BadSymlink
     };
     for (auto& p : cases) {
         std::error_code ec = std::make_error_code(std::errc::address_in_use);
         // test non-throwing overload.
         file_status st = status(p, ec);
-        TEST_CHECK(ErrorIs(ec, expect_errc));
-        TEST_CHECK(st.type() == file_type::not_found);
-        TEST_CHECK(st.permissions() == perms::unknown);
+        assert(ErrorIs(ec, expect_errc));
+        assert(st.type() == file_type::not_found);
+        assert(st.permissions() == perms::unknown);
         // test throwing overload. It should not throw even though it reports
         // that the file was not found.
-        TEST_CHECK_NO_THROW(st = status(p));
-        TEST_CHECK(st.type() == file_type::not_found);
-        TEST_CHECK(st.permissions() == perms::unknown);
+        TEST_DOES_NOT_THROW(st = status(p));
+        assert(st.type() == file_type::not_found);
+        assert(st.permissions() == perms::unknown);
     }
 }
 
 // Windows doesn't support setting perms::none to trigger failures
 // reading directories. Imaginary files under GetWindowsInaccessibleDir()
 // produce no_such_file_or_directory, not the error codes this test checks
 // for. Finally, status() for a too long file name doesn't return errors
 // on windows.
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
-TEST_CASE(test_status_cannot_resolve)
+static void test_status_cannot_resolve()
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path file = env.create_file("dir/file", 42);
     const path sym = env.create_symlink("dir/file", "sym");
     permissions(dir, perms::none);
 
     const std::errc set_errc = std::errc::address_in_use;
     const std::errc perm_errc = std::errc::permission_denied;
     const std::errc name_too_long_errc = std::errc::filename_too_long;
 
     struct TestCase {
       path p;
       std::errc expect_errc;
     } const TestCases[] = {
       {file, perm_errc},
       {sym, perm_errc},
       {path(std::string(2500, 'a')), name_too_long_errc}
     };
     for (auto& TC : TestCases)
     {
         { // test non-throwing case
             std::error_code ec = std::make_error_code(set_errc);
             file_status st = status(TC.p, ec);
-            TEST_CHECK(ErrorIs(ec, TC.expect_errc));
-            TEST_CHECK(st.type() == file_type::none);
-            TEST_CHECK(st.permissions() == perms::unknown);
+            assert(ErrorIs(ec, TC.expect_errc));
+            assert(st.type() == file_type::none);
+            assert(st.permissions() == perms::unknown);
         }
 #ifndef TEST_HAS_NO_EXCEPTIONS
         { // test throwing case
             try {
                 status(TC.p);
             } catch (filesystem_error const& err) {
-                TEST_CHECK(err.path1() == TC.p);
-                TEST_CHECK(err.path2() == "");
-                TEST_CHECK(ErrorIs(err.code(), TC.expect_errc));
+                assert(err.path1() == TC.p);
+                assert(err.path2() == "");
+                assert(ErrorIs(err.code(), TC.expect_errc));
             }
         }
 #endif
     }
 }
-#endif
+#endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
 
-TEST_CASE(status_file_types_test)
+static void status_file_types_test()
 {
     static_test_env static_env;
     scoped_test_env env;
     struct TestCase {
       path p;
       file_type expect_type;
     } cases[] = {
         {static_env.File, file_type::regular},

 #ifndef _WIN32
         {env.create_fifo("fifo"), file_type::fifo}
 #endif
     };
     for (const auto& TC : cases) {
         // test non-throwing case
         std::error_code ec = std::make_error_code(std::errc::address_in_use);
         file_status st = status(TC.p, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(st.type() == TC.expect_type);
-        TEST_CHECK(st.permissions() != perms::unknown);
+        assert(!ec);
+        assert(st.type() == TC.expect_type);
+        assert(st.permissions() != perms::unknown);
         // test throwing case
-        TEST_REQUIRE_NO_THROW(st = status(TC.p));
-        TEST_CHECK(st.type() == TC.expect_type);
-        TEST_CHECK(st.permissions() != perms::unknown);
+        TEST_DOES_NOT_THROW(st = status(TC.p));
+        assert(st.type() == TC.expect_type);
+        assert(st.permissions() != perms::unknown);
     }
 }
 
-TEST_CASE(test_block_file)
+static void test_block_file()
 {
     const path possible_paths[] = {
         "/dev/drive0", // Apple
         "/dev/sda",
         "/dev/loop0"
     };
     path p;
     for (const path& possible_p : possible_paths) {
         std::error_code ec;
         if (exists(possible_p, ec)) {
             p = possible_p;
             break;
         }
     }
     if (p == path{}) {
-        TEST_UNSUPPORTED();
+        TEST_IS_UNSUPPORTED();
     }
     // test non-throwing case
     std::error_code ec = std::make_error_code(std::errc::address_in_use);
     file_status st = status(p, ec);
-    TEST_CHECK(!ec);
-    TEST_CHECK(st.type() == file_type::block);
-    TEST_CHECK(st.permissions() != perms::unknown);
+    assert(!ec);
+    assert(st.type() == file_type::block);
+    assert(st.permissions() != perms::unknown);
     // test throwing case
-    TEST_REQUIRE_NO_THROW(st = status(p));
-    TEST_CHECK(st.type() == file_type::block);
-    TEST_CHECK(st.permissions() != perms::unknown);
+    TEST_DOES_NOT_THROW(st = status(p));
+    assert(st.type() == file_type::block);
+    assert(st.permissions() != perms::unknown);
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_test();
+    test_status_not_found();
+#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
+    test_status_cannot_resolve();
+#endif
+    status_file_types_test();
+    test_block_file();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.status_known/status_known.pass.cpp

 
 // bool status_known(file_status s) noexcept;
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(status_known_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     file_status s; ((void)s);
     ASSERT_SAME_TYPE(decltype(status_known(s)), bool);
     ASSERT_NOEXCEPT(status_known(s));
 }
 
-TEST_CASE(status_known_test)
+static void status_known_test()
 {
     struct TestCase {
         file_type type;
         bool expect;
     };
     const TestCase testCases[] = {
         {file_type::none, false},
         {file_type::not_found, true},
         {file_type::regular, true},
         {file_type::directory, true},
         {file_type::symlink, true},
         {file_type::block, true},
         {file_type::character, true},
         {file_type::fifo, true},
         {file_type::socket, true},
         {file_type::unknown, true}
     };
     for (auto& TC : testCases) {
         file_status s(TC.type);
-        TEST_CHECK(status_known(s) == TC.expect);
+        assert(status_known(s) == TC.expect);
     }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_test();
+    status_known_test();
+
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.symlink_status/symlink_status.pass.cpp

 // <filesystem>
 
 // file_status symlink_status(const path& p);
 // file_status symlink_status(const path& p, error_code& ec) noexcept;
 
 #include "filesystem_include.h"
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
-TEST_SUITE(filesystem_symlink_status_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     const path p; ((void)p);
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(symlink_status(p));
     ASSERT_NOEXCEPT(symlink_status(p, ec));
 }
 
-TEST_CASE(test_symlink_status_not_found)
+static void test_symlink_status_not_found()
 {
     static_test_env static_env;
     const std::errc expect_errc = std::errc::no_such_file_or_directory;
     const path cases[] {
         static_env.DNE
     };
     for (auto& p : cases) {
         std::error_code ec = std::make_error_code(std::errc::address_in_use);
         // test non-throwing overload.
         file_status st = symlink_status(p, ec);
-        TEST_CHECK(ErrorIs(ec, expect_errc));
-        TEST_CHECK(st.type() == file_type::not_found);
-        TEST_CHECK(st.permissions() == perms::unknown);
+        assert(ErrorIs(ec, expect_errc));
+        assert(st.type() == file_type::not_found);
+        assert(st.permissions() == perms::unknown);
         // test throwing overload. It should not throw even though it reports
         // that the file was not found.
-        TEST_CHECK_NO_THROW(st = status(p));
-        TEST_CHECK(st.type() == file_type::not_found);
-        TEST_CHECK(st.permissions() == perms::unknown);
+        TEST_DOES_NOT_THROW(st = status(p));
+        assert(st.type() == file_type::not_found);
+        assert(st.permissions() == perms::unknown);
     }
 }
 
 // Windows doesn't support setting perms::none to trigger failures
 // reading directories. Imaginary files under GetWindowsInaccessibleDir()
 // produce no_such_file_or_directory, not the error codes this test checks
 // for. Finally, status() for a too long file name doesn't return errors
 // on windows.
 #ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
-TEST_CASE(test_symlink_status_cannot_resolve)
+static void test_symlink_status_cannot_resolve()
 {
     scoped_test_env env;
     const path dir = env.create_dir("dir");
     const path file_in_dir = env.create_file("dir/file", 42);
     const path sym_in_dir = env.create_symlink("dir/file", "dir/bad_sym");
     const path sym_points_in_dir = env.create_symlink("dir/file", "sym");
     permissions(dir, perms::none);
 
     const std::errc set_errc = std::errc::address_in_use;
     const std::errc expect_errc = std::errc::permission_denied;
 
     const path fail_cases[] = {
         file_in_dir, sym_in_dir
     };
     for (auto& p : fail_cases)
     {
         { // test non-throwing case
             std::error_code ec = std::make_error_code(set_errc);
             file_status st = symlink_status(p, ec);
-            TEST_CHECK(ErrorIs(ec, expect_errc));
-            TEST_CHECK(st.type() == file_type::none);
-            TEST_CHECK(st.permissions() == perms::unknown);
+            assert(ErrorIs(ec, expect_errc));
+            assert(st.type() == file_type::none);
+            assert(st.permissions() == perms::unknown);
         }
 #ifndef TEST_HAS_NO_EXCEPTIONS
         { // test throwing case
             try {
                 (void)symlink_status(p);
             } catch (filesystem_error const& err) {
-                TEST_CHECK(err.path1() == p);
-                TEST_CHECK(err.path2() == "");
-                TEST_CHECK(ErrorIs(err.code(), expect_errc));
+                assert(err.path1() == p);
+                assert(err.path2() == "");
+                assert(ErrorIs(err.code(), expect_errc));
             }
         }
 #endif
     }
     // Test that a symlink that points into a directory without read perms
     // can be stat-ed using symlink_status
     {
         std::error_code ec = std::make_error_code(set_errc);
         file_status st = symlink_status(sym_points_in_dir, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(st.type() == file_type::symlink);
-        TEST_CHECK(st.permissions() != perms::unknown);
+        assert(!ec);
+        assert(st.type() == file_type::symlink);
+        assert(st.permissions() != perms::unknown);
         // test non-throwing version
-        TEST_REQUIRE_NO_THROW(st = symlink_status(sym_points_in_dir));
-        TEST_CHECK(st.type() == file_type::symlink);
-        TEST_CHECK(st.permissions() != perms::unknown);
+        TEST_DOES_NOT_THROW(st = symlink_status(sym_points_in_dir));
+        assert(st.type() == file_type::symlink);
+        assert(st.permissions() != perms::unknown);
     }
 }
-#endif
+#endif // TEST_WIN_NO_FILESYSTEM_PERMS_NONE
 
 
-TEST_CASE(symlink_status_file_types_test)
+static void symlink_status_file_types_test()
 {
     static_test_env static_env;
     scoped_test_env env;
     struct TestCase {
       path p;
       file_type expect_type;
     } cases[] = {
         {static_env.BadSymlink, file_type::symlink},

 #ifndef _WIN32
         {env.create_fifo("fifo"), file_type::fifo}
 #endif
     };
     for (const auto& TC : cases) {
         // test non-throwing case
         std::error_code ec = std::make_error_code(std::errc::address_in_use);
         file_status st = symlink_status(TC.p, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(st.type() == TC.expect_type);
-        TEST_CHECK(st.permissions() != perms::unknown);
+        assert(!ec);
+        assert(st.type() == TC.expect_type);
+        assert(st.permissions() != perms::unknown);
         // test throwing case
-        TEST_REQUIRE_NO_THROW(st = symlink_status(TC.p));
-        TEST_CHECK(st.type() == TC.expect_type);
-        TEST_CHECK(st.permissions() != perms::unknown);
+        TEST_DOES_NOT_THROW(st = symlink_status(TC.p));
+        assert(st.type() == TC.expect_type);
+        assert(st.permissions() != perms::unknown);
     }
 }
 
-TEST_CASE(test_block_file)
+static void test_block_file()
 {
     const path possible_paths[] = {
         "/dev/drive0", // Apple
         "/dev/sda",    // Linux
         "/dev/loop0"   // Linux
         // No FreeBSD files known
     };
     path p;
     for (const path& possible_p : possible_paths) {
         std::error_code ec;
         if (exists(possible_p, ec)) {
             p = possible_p;
             break;
         }
     }
     if (p == path{}) {
-        TEST_UNSUPPORTED();
+        TEST_IS_UNSUPPORTED();
     }
     scoped_test_env env;
     { // test block file
         // test non-throwing case
         std::error_code ec = std::make_error_code(std::errc::address_in_use);
         file_status st = symlink_status(p, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(st.type() == file_type::block);
-        TEST_CHECK(st.permissions() != perms::unknown);
+        assert(!ec);
+        assert(st.type() == file_type::block);
+        assert(st.permissions() != perms::unknown);
         // test throwing case
-        TEST_REQUIRE_NO_THROW(st = symlink_status(p));
-        TEST_CHECK(st.type() == file_type::block);
-        TEST_CHECK(st.permissions() != perms::unknown);
+        TEST_DOES_NOT_THROW(st = symlink_status(p));
+        assert(st.type() == file_type::block);
+        assert(st.permissions() != perms::unknown);
     }
     const path sym = env.make_env_path("sym");
     create_symlink(p, sym);
     { // test symlink to block file
         // test non-throwing case
         std::error_code ec = std::make_error_code(std::errc::address_in_use);
         file_status st = symlink_status(sym, ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(st.type() == file_type::symlink);
-        TEST_CHECK(st.permissions() != perms::unknown);
+        assert(!ec);
+        assert(st.type() == file_type::symlink);
+        assert(st.permissions() != perms::unknown);
         // test throwing case
-        TEST_REQUIRE_NO_THROW(st = symlink_status(sym));
-        TEST_CHECK(st.type() == file_type::symlink);
-        TEST_CHECK(st.permissions() != perms::unknown);
+        TEST_DOES_NOT_THROW(st = symlink_status(sym));
+        assert(st.type() == file_type::symlink);
+        assert(st.permissions() != perms::unknown);
     }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_test();
+    test_symlink_status_not_found();
+#ifndef TEST_WIN_NO_FILESYSTEM_PERMS_NONE
+    test_symlink_status_cannot_resolve();
+#endif
+    symlink_status_file_types_test();
+    test_block_file();
+    return 0;
+}

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.temp_dir_path/temp_directory_path.pass.cpp

 
 #include "filesystem_include.h"
 #include <memory>
 #include <cstdlib>
 #include <cstring>
 #include <cassert>
 
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "filesystem_test_helper.h"
 
 using namespace fs;
 
 void PutEnv(std::string var, fs::path value) {
     assert(utils::setenv(var.c_str(), value.string().c_str(), /* overwrite */ 1) == 0);
 }
 
 void UnsetEnv(std::string var) {
     assert(utils::unsetenv(var.c_str()) == 0);
 }
 
-TEST_SUITE(filesystem_temp_directory_path_test_suite)
-
-TEST_CASE(signature_test)
+static void signature_test()
 {
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(temp_directory_path());
     ASSERT_NOT_NOEXCEPT(temp_directory_path(ec));
 }
 
-TEST_CASE(basic_tests)
+static void basic_tests()
 {
     scoped_test_env env;
     const path dne = env.make_env_path("dne");
     const path file = env.create_file("file", 42);
 #ifdef _WIN32
     // Windows doesn't support setting perms::none to trigger failures
     // reading directories; test using a special inaccessible directory
     // instead.

 #endif
     };
     for (auto& TC : cases) {
         PutEnv(TC.name, TC.p);
     }
     for (auto& TC : cases) {
         std::error_code ec = GetTestEC();
         path ret = temp_directory_path(ec);
-        TEST_CHECK(!ec);
-        TEST_CHECK(ret == TC.p);
-        TEST_CHECK(is_directory(ret));
+        assert(!ec);
+        assert(ret == TC.p);
+        assert(is_directory(ret));
 
         // Set the env variable to a path that does not exist and check
         // that it fails.
         PutEnv(TC.name, dne);
         ec = GetTestEC();
         ret = temp_directory_path(ec);
-        LIBCPP_ONLY(TEST_CHECK(ErrorIs(ec, expect_errc)));
-        TEST_CHECK(ec != GetTestEC());
-        TEST_CHECK(ec);
-        TEST_CHECK(ret == "");
+        LIBCPP_ONLY(assert(ErrorIs(ec, expect_errc)));
+        assert(ec != GetTestEC());
+        assert(ec);
+        assert(ret == "");
 
         // Set the env variable to point to a file and check that it fails.
         PutEnv(TC.name, file);
         ec = GetTestEC();
         ret = temp_directory_path(ec);
-        LIBCPP_ONLY(TEST_CHECK(ErrorIs(ec, expect_errc)));
-        TEST_CHECK(ec != GetTestEC());
-        TEST_CHECK(ec);
-        TEST_CHECK(ret == "");
+        LIBCPP_ONLY(assert(ErrorIs(ec, expect_errc)));
+        assert(ec != GetTestEC());
+        assert(ec);
+        assert(ret == "");
 
         if (!inaccessible_dir.empty()) {
             // Set the env variable to point to a dir we can't access
             PutEnv(TC.name, inaccessible_dir);
             ec = GetTestEC();
             ret = temp_directory_path(ec);
-            TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
-            TEST_CHECK(ret == "");
+            assert(ErrorIs(ec, std::errc::permission_denied));
+            assert(ret == "");
         }
 
         // Set the env variable to point to a non-existent dir
         PutEnv(TC.name, TC.p / "does_not_exist");
         ec = GetTestEC();
         ret = temp_directory_path(ec);
-        TEST_CHECK(ec != GetTestEC());
-        TEST_CHECK(ec);
-        TEST_CHECK(ret == "");
+        assert(ec != GetTestEC());
+        assert(ec);
+        assert(ret == "");
 
         // Finally erase this env variable
         UnsetEnv(TC.name);
     }
     // No env variables are defined
     path fallback;
     {
         std::error_code ec = GetTestEC();
         path ret = temp_directory_path(ec);
-        TEST_CHECK(!ec);
+        assert(!ec);
 #ifndef _WIN32
         // On Windows, the function falls back to the Windows folder.
-        TEST_CHECK(ret == "/tmp");
+        assert(ret == "/tmp");
 #endif
-        TEST_CHECK(is_directory(ret));
+        assert(is_directory(ret));
         fallback = ret;
     }
     for (auto& TC : ignored_cases) {
         // Check that certain variables are ignored
         PutEnv(TC.name, TC.p);
         std::error_code ec = GetTestEC();
         path ret = temp_directory_path(ec);
-        TEST_CHECK(!ec);
+        assert(!ec);
 
         // Check that we return the same as above when no vars were defined.
-        TEST_CHECK(ret == fallback);
+        assert(ret == fallback);
 
         // Finally erase this env variable
         UnsetEnv(TC.name);
     }
 }
 
-TEST_SUITE_END()
+int main(int, char**) {
+    signature_test();
+    basic_tests();
+    return 0;
+}

libcxx/test/std/utilities/format/format.functions/format_tests.h

void format_tests(TestFunction check, ExceptionTest check_exception) {
   // ** Test invalid format strings ***
   check_exception("The format string terminates at a '{'", SV("{"));
   check_exception("The replacement field misses a terminating '}'", SV("{:"), 42);
 
   check_exception("The format string contains an invalid escape sequence", SV("}"));
   check_exception("The format string contains an invalid escape sequence", SV("{:}-}"), 42);
 
   check_exception("The format string contains an invalid escape sequence", SV("} "));
-
+#if 0
   check_exception("The arg-id of the format-spec starts with an invalid character", SV("{-"), 42);
   check_exception("Argument index out of bounds", SV("hello {}"));
   check_exception("Argument index out of bounds", SV("hello {0}"));
   check_exception("Argument index out of bounds", SV("hello {1}"), 42);
 
   // *** Test char format argument ***
   // The `char` to `wchar_t` formatting is tested separately.
   check(SV("hello 09azAZ!"),
if constexpr (modus == execution_modus::full)
     format_test_pointer<CharT>(check, check_exception);
 
   // *** Test handle formatter argument ***
   format_test_handle<CharT>(check, check_exception);
 
   // *** Test the interal buffer optimizations ***
   if constexpr (modus == execution_modus::full)
     format_test_buffer_optimizations<CharT>(check);
+#endif
 }
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
 template <class TestFunction>
 void format_tests_char_to_wchar_t(TestFunction check) {
   using CharT = wchar_t;
   check(SV("hello 09azA"), SV("hello {}{}{}{}{}"), '0', '9', 'a', 'z', 'A');
 }
 #endif
 
 #endif // TEST_STD_UTILITIES_FORMAT_FORMAT_FUNCTIONS_FORMAT_TESTS_H

libcxx/test/std/utilities/format/format.functions/vformat.pass.cpp

 #include <format>
 #include <cassert>
 #include <vector>
 
 #include "test_macros.h"
 #include "format_tests.h"
 #include "string_literal.h"
 #include "assert_macros.h"
+#include "concat_macros.h"
 
 auto test = []<class CharT, class... Args>(
                 std::basic_string_view<CharT> expected, std::basic_string_view<CharT> fmt, Args&&... args) constexpr {
   std::basic_string<CharT> out = std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...));
-  TEST_REQUIRE(
-      out == expected,
-      test_concat_message("\nFormat string   ", fmt, "\nExpected output ", expected, "\nActual output   ", out, '\n'));
+  TEST_REQUIRE(out == expected,
+               TEST_WRITE_CONCATENATED(
+                   "\nFormat string   ", fmt, "\nExpected output ", expected, "\nActual output   ", out, '\n'));
 };
 
 auto test_exception =
     []<class CharT, class... Args>(
         [[maybe_unused]] std::string_view what,
         [[maybe_unused]] std::basic_string_view<CharT> fmt,
         [[maybe_unused]] Args&&... args) {
-#ifndef TEST_HAS_NO_EXCEPTIONS
-      try {
-        TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...));
-        TEST_FAIL(test_concat_message("\nFormat string   ", fmt, "\nDidn't throw an exception.\n"));
-      } catch ([[maybe_unused]] const std::format_error& e) {
+      TEST_VALIDATE_EXCEPTION(
+          std::format_error,
+          [&]([[maybe_unused]] const std::format_error& e) {
             TEST_LIBCPP_REQUIRE(
                 e.what() == what,
-            test_concat_message(
+                TEST_WRITE_CONCATENATED(
                     "\nFormat string   ", fmt, "\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
-
-        return;
-      }
-      assert(false);
-#endif
+          },
+          std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...)));
     };
 
 int main(int, char**) {
   format_tests<char, execution_modus::full>(test, test_exception);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   format_tests_char_to_wchar_t(test);
   format_tests<wchar_t, execution_modus::full>(test, test_exception);
 #endif
 
   return 0;
 }

libcxx/test/support/assert_macros.h

 //   the expected output, and the format string used. These macros allow
 //   logging additional arguments.
 
 #include "test_macros.h"
 
 #include <cstdio>
 #include <cstdlib>
 
-#ifndef TEST_HAS_NO_LOCALIZATION
-#  include <sstream>
-#endif
-
-#if TEST_STD_VER > 17
-
-#  ifndef TEST_HAS_NO_LOCALIZATION
-template <class T>
-concept test_char_streamable = requires(T&& value) { std::stringstream{} << std::forward<T>(value); };
-#  endif
+void test_log(const char* condition, const char* file, int line, const char* message) {
+  const char* msg = condition ? "Assertion failure: " : "Unconditional failure:";
+  std::fprintf(stderr, "%s%s %s %d\n%s", msg, condition, file, line, message);
+}
 
-// If possible concatenates message for the assertion function, else returns a
-// default message. Not being able to stream is not considered and error. For
-// example, streaming to std::wcerr doesn't work properly in the CI. Therefore
-// the formatting tests should only stream to std::string_string.
-template <class... Args>
-std::string test_concat_message([[maybe_unused]] Args&&... args) {
-#  ifndef TEST_HAS_NO_LOCALIZATION
-  if constexpr ((test_char_streamable<Args> && ...)) {
-    std::stringstream sstr;
-    ((sstr << std::forward<Args>(args)), ...);
-    return sstr.str();
-  } else
-#  endif
-    return "Message discarded since it can't be streamed to std::cerr.\n";
+void test_log(const char* condition, const char* file, int line, std::string&& message) {
+  test_log(condition, file, line, message.c_str());
 }
 
-#endif // TEST_STD_VER > 17
+template <class F>
+void test_log(const char* condition, const char* file, int line, const F& functor) {
+  std::fprintf(stderr, "Assertion failure: %s %s %d\n", condition, file, line);
+  functor();
+}
 
 // Logs the error and calls exit.
 //
 // It shows a generic assert like message including a custom message. This
 // message should end with a newline.
-[[noreturn]] void test_log_error(const char* condition, const char* file, int line, std::string&& message) {
-  const char* msg = condition ? "Assertion failure: " : "Unconditional failure:";
-  std::fprintf(stderr, "%s%s %s %d\n%s", msg, condition, file, line, message.c_str());
-  exit(EXIT_FAILURE);
+template <class Arg>
+[[noreturn]] void test_fail(const char* file, int line, Arg&& arg) {
+  test_log("", file, line, std::forward<Arg>(arg));
+  std::abort();
 }
 
-inline void test_fail(const char* file, int line, std::string&& message) {
-  test_log_error("", file, line, std::move(message));
-}
-
-inline void test_require(bool condition, const char* condition_str, const char* file, int line, std::string&& message) {
+template <class Arg>
+void test_require(bool condition, const char* condition_str, const char* file, int line, Arg&& arg) {
   if (condition)
     return;
 
-  test_log_error(condition_str, file, line, std::move(message));
-}
-
-inline void test_libcpp_require(
-    [[maybe_unused]] bool condition,
-    [[maybe_unused]] const char* condition_str,
-    [[maybe_unused]] const char* file,
-    [[maybe_unused]] int line,
-    [[maybe_unused]] std::string&& message) {
-#if defined(_LIBCPP_VERSION)
-  test_require(condition, condition_str, file, line, std::move(message));
-#endif
+  test_log(condition_str, file, line, std::forward<Arg>(arg));
+  std::abort();
 }
 
 // assert(false) replacement
-#define TEST_FAIL(MSG) ::test_fail(__FILE__, __LINE__, MSG)
+// The ARG is either a
+// - c-ctring or std::string, in which case the string is printed to stderr,
+// - an invocable object, which will be invoked.
+#define TEST_FAIL(ARG) ::test_fail(__FILE__, __LINE__, ARG)
 
 // assert replacement.
-#define TEST_REQUIRE(CONDITION, MSG) ::test_require(CONDITION, #CONDITION, __FILE__, __LINE__, MSG)
+// ARG is the same as for TEST_FAIL
+#define TEST_REQUIRE(CONDITION, ARG) ::test_require(CONDITION, #CONDITION, __FILE__, __LINE__, ARG)
 
 // LIBCPP_ASSERT replacement
 //
 // This requirement is only tested when the test suite is used for libc++.
 // This allows checking libc++ specific requirements, for example the error
 // messages of exceptions.
-#define TEST_LIBCPP_REQUIRE(CONDITION, MSG) ::test_libcpp_require(CONDITION, #CONDITION, __FILE__, __LINE__, MSG)
+// ARG is the same as for TEST_FAIL
+#if defined(_LIBCPP_VERSION)
+#  define TEST_LIBCPP_REQUIRE(CONDITION, ARG) ::test_require(CONDITION, #CONDITION, __FILE__, __LINE__, ARG)
+#else
+#  define TEST_LIBCPP_REQUIRE(...) /* DO NOTHING */
+#endif
+
+// Helper macro to test an expression does not throw any exception.
+#ifndef TEST_HAS_NO_EXCEPTIONS
+#  define TEST_DOES_NOT_THROW(EXPR)                                                                                    \
+    do {                                                                                                               \
+      try {                                                                                                            \
+        static_cast<void>(EXPR);                                                                                       \
+      } catch (...) {                                                                                                  \
+        ::test_log(#EXPR, __FILE__, __LINE__, "no exception was expected\n");                                          \
+        ::std::abort();                                                                                                \
+      }                                                                                                                \
+    } while (false) /* */
+
+// Helper macro to test an expression throws an exception of the expected type.
+#  define TEST_THROWS_TYPE(TYPE, EXPR)                                                                                 \
+    do {                                                                                                               \
+      try {                                                                                                            \
+        static_cast<void>(EXPR);                                                                                       \
+        ::test_log(nullptr,                                                                                            \
+                   __FILE__,                                                                                           \
+                   __LINE__,                                                                                           \
+                   "no exception is thrown while an exception of type " #TYPE " was expected\n");                      \
+        ::std::abort();                                                                                                \
+      } catch (const TYPE&) {                                                                                          \
+        /* DO NOTHING */                                                                                               \
+      } catch (...) {                                                                                                  \
+        ::test_log(nullptr,                                                                                            \
+                   __FILE__,                                                                                           \
+                   __LINE__,                                                                                           \
+                   "the type of the exception caught differs from the expected type " #TYPE "\n");                     \
+        ::std::abort();                                                                                                \
+      }                                                                                                                \
+    } while (false) /* */
+
+// Helper macro to test an expression throws an exception of the expected type and satisfies a predicate.
+//
+// In order to log additional information the predicate can use log macros.
+// The exception caught is used as argument to the predicate.
+#  define TEST_VALIDATE_EXCEPTION(TYPE, PRED, EXPR)                                                                    \
+    do {                                                                                                               \
+      try {                                                                                                            \
+        static_cast<void>(EXPR);                                                                                       \
+        ::test_log(nullptr,                                                                                            \
+                   __FILE__,                                                                                           \
+                   __LINE__,                                                                                           \
+                   "no exception is thrown while an exception of type " #TYPE " was expected\n");                      \
+        ::std::abort();                                                                                                \
+      } catch (const TYPE& EXCEPTION) {                                                                                \
+        PRED(EXCEPTION);                                                                                               \
+      } catch (...) {                                                                                                  \
+        ::test_log(nullptr,                                                                                            \
+                   __FILE__,                                                                                           \
+                   __LINE__,                                                                                           \
+                   "the type of the exception caught differs from the expected type " #TYPE "\n");                     \
+        ::std::abort();                                                                                                \
+      }                                                                                                                \
+    } while (false)                    /* */
+
+#else                                  // TEST_HAS_NO_EXCEPTIONS
+#  define TEST_DOES_NOT_THROW(EXPR) static_cast<void>(EXPR);
+#  define TEST_THROWS_TYPE(...)        /* DO NOTHING */
+#  define TEST_VALIDATE_EXCEPTION(...) /* DO NOTHING */
+#endif                                 // TEST_HAS_NO_EXCEPTIONS
+
+#define TEST_IS_UNSUPPORTED(...) return
 
 #endif // TEST_SUPPORT_ASSERT_MACROS_H

libcxx/test/support/concat_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_CONCAT_MACROS_H
+#define TEST_SUPPORT_CONCAT_MACROS_H
+
+#include <cstdio>
+#include <string>
+
+#include "test_macros.h"
+
+#ifndef TEST_HAS_NO_LOCALIZATION
+#  include <sstream>
+#endif
+
+#if TEST_STD_VER > 17
+
+#  ifndef TEST_HAS_NO_LOCALIZATION
+template <class T>
+concept test_char_streamable = requires(T&& value) { std::stringstream{} << std::forward<T>(value); };
+#  endif
+
+// If possible concatenates message for the assertion function, else returns a
+// default message. Not being able to stream is not considered and error. For
+// example, streaming to std::wcerr doesn't work properly in the CI. Therefore
+// the formatting tests should only stream to std::string.
+//
+// The macro TEST_WRITE_CONCATENATED can be used to evaluate the arguments
+// lazily. This useful when using this function in combination with
+// assert_macros.h.
+template <class... Args>
+std::string test_concat_message([[maybe_unused]] Args&&... args) {
+#  ifndef TEST_HAS_NO_LOCALIZATION
+  if constexpr ((test_char_streamable<Args> && ...)) {
+    std::stringstream sstr;
+    ((sstr << std::forward<Args>(args)), ...);
+    return sstr.str();
+  } else
+#  endif
+    return "Message discarded since it can't be streamed to std::cerr.\n";
+}
+
+// Writes its arguments to stderr, using the test_concat_message helper.
+#  define TEST_WRITE_CONCATENATED(...) [&] { ::std::fprintf(stderr, "%s", ::test_concat_message(__VA_ARGS__).c_str()); }
+
+#endif // TEST_STD_VER > 17
+
+#endif //  TEST_SUPPORT_CONCAT_MACROS_H

libcxx/test/support/filesystem_test_helper.h

 #include <cassert>
 #include <chrono>
 #include <cstdint>
 #include <cstdio> // for printf
 #include <string>
 #include <system_error>
 #include <vector>
 
+#include "assert_macros.h"
 #include "make_string.h"
 #include "test_macros.h"
-#include "rapid-cxx-test.h"
 #include "format_string.h"
 
 // For creating socket files
 #if !defined(__FreeBSD__) && !defined(__APPLE__) && !defined(_WIN32)
 # include <sys/socket.h>
 # include <sys/un.h>
 #endif
 
explicit ExceptionChecker(fs::path p, std::errc first_err,
         func_name(fun_name), opt_message(opt_msg) {}
 
   explicit ExceptionChecker(fs::path p1, fs::path p2, std::errc first_err,
                             const char* fun_name, std::string opt_msg = {})
       : expected_err(first_err), expected_path1(p1), expected_path2(p2),
         num_paths(2), func_name(fun_name), opt_message(opt_msg) {}
 
   void operator()(fs::filesystem_error const& Err) {
-    TEST_CHECK(ErrorIsImp(Err.code(), {expected_err}));
-    TEST_CHECK(Err.path1() == expected_path1);
-    TEST_CHECK(Err.path2() == expected_path2);
+    assert(ErrorIsImp(Err.code(), {expected_err}));
+    assert(Err.path1() == expected_path1);
+    assert(Err.path2() == expected_path2);
     LIBCPP_ONLY(check_libcxx_string(Err));
   }
 
   void check_libcxx_string(fs::filesystem_error const& Err) {
     std::string message = std::make_error_code(expected_err).message();
 
     std::string additional_msg = "";
     if (!opt_message.empty()) {
std::string format = [&]() -> std::string {
                              additional_msg, message,
                              transform_path(expected_path1).c_str());
       case 2:
         return format_string("filesystem error: in %s: %s%s [%s] [%s]",
                              func_name, additional_msg, message,
                              transform_path(expected_path1).c_str(),
                              transform_path(expected_path2).c_str());
       default:
-        TEST_CHECK(false && "unexpected case");
+        TEST_FAIL("unexpected case");
         return "";
       }
     }();
-    TEST_CHECK(format == Err.what());
+    assert(format == Err.what());
     if (format != Err.what()) {
       fprintf(stderr,
               "filesystem_error::what() does not match expected output:\n");
       fprintf(stderr, "  expected: \"%s\"\n", format.c_str());
       fprintf(stderr, "  actual:   \"%s\"\n\n", Err.what());
     }
   }
 

libcxx/test/support/rapid-cxx-test.h

-#ifndef RAPID_CXX_TEST_H
-#define RAPID_CXX_TEST_H
-
-# include <cstddef>
-# include <cstdlib>
-# include <cstdio>
-# include <cstring>
-# include <cassert>
-
-#include "test_macros.h"
-
-#if !defined(RAPID_CXX_TEST_NO_SYSTEM_HEADER) || !defined(__GNUC__)
-#pragma GCC system_header
-#endif
-
-# define RAPID_CXX_TEST_PP_CAT(x, y) RAPID_CXX_TEST_PP_CAT_2(x, y)
-# define RAPID_CXX_TEST_PP_CAT_2(x, y) x##y
-
-# define RAPID_CXX_TEST_PP_STR(...) RAPID_CXX_TEST_PP_STR_2(__VA_ARGS__)
-# define RAPID_CXX_TEST_PP_STR_2(...) #__VA_ARGS__
-
-# if defined(__GNUC__)
-#   define TEST_FUNC_NAME() __PRETTY_FUNCTION__
-#   define RAPID_CXX_TEST_UNUSED __attribute__((unused))
-# else
-#   define TEST_FUNC_NAME() __func__
-#   define RAPID_CXX_TEST_UNUSED
-# endif
-
-////////////////////////////////////////////////////////////////////////////////
-//                          TEST_SUITE
-////////////////////////////////////////////////////////////////////////////////
-# define TEST_SUITE(Name)                                           \
-namespace Name                                                      \
-{                                                                   \
-    inline ::rapid_cxx_test::test_suite & get_test_suite()          \
-    {                                                               \
-        static ::rapid_cxx_test::test_suite m_suite(#Name);         \
-        return m_suite;                                             \
-    }                                                               \
-                                                                    \
-    inline int unit_test_main(int, char**)                          \
-    {                                                               \
-        ::rapid_cxx_test::test_runner runner(get_test_suite());     \
-        return runner.run();                                        \
-    }                                                               \
-}                                                                   \
-int main(int argc, char **argv)                                     \
-{                                                                   \
-    return Name::unit_test_main(argc, argv);                        \
-}                                                                   \
-namespace Name                                                      \
-{ /* namespace closed in TEST_SUITE_END */
-#
-
-////////////////////////////////////////////////////////////////////////////////
-//                         TEST_SUITE_END
-////////////////////////////////////////////////////////////////////////////////
-# define TEST_SUITE_END()                                       \
-} /* namespace opened in TEST_SUITE(...) */
-#
-
-////////////////////////////////////////////////////////////////////////////////
-//                          TEST_CASE
-////////////////////////////////////////////////////////////////////////////////
-
-# if !defined(__clang__)
-#
-# define TEST_CASE(Name)                                                                                \
-    void Name();                                                                                        \
-    static void RAPID_CXX_TEST_PP_CAT(Name, _invoker)()                                                 \
-    {                                                                                                   \
-        Name();                                                                                         \
-    }                                                                                                   \
-    static ::rapid_cxx_test::registrar                                                                  \
-    RAPID_CXX_TEST_PP_CAT(rapid_cxx_test_registrar_, Name)(                                         \
-        get_test_suite()                                                                                \
-      , ::rapid_cxx_test::test_case(__FILE__, #Name, __LINE__, & RAPID_CXX_TEST_PP_CAT(Name, _invoker)) \
-      );                                                                                                \
-    void Name()
-#
-# else /* __clang__ */
-#
-# define TEST_CASE(Name)                                                                                \
-    void Name();                                                                                        \
-    static void RAPID_CXX_TEST_PP_CAT(Name, _invoker)()                                                 \
-    {                                                                                                   \
-        Name();                                                                                         \
-    }                                                                                                   \
-    _Pragma("clang diagnostic push")                                                                    \
-    _Pragma("clang diagnostic ignored \"-Wglobal-constructors\"")                                       \
-    static ::rapid_cxx_test::registrar                                                                  \
-    RAPID_CXX_TEST_PP_CAT(rapid_cxx_test_registrar_, Name)(                                         \
-        get_test_suite()                                                                                \
-      , ::rapid_cxx_test::test_case(__FILE__, #Name, __LINE__, & RAPID_CXX_TEST_PP_CAT(Name, _invoker)) \
-      );                                                                                                \
-    _Pragma("clang diagnostic pop")                                                                     \
-    void Name()
-#
-# endif /* !defined(__clang__) */
-
-
-# define TEST_SET_CHECKPOINT() ::rapid_cxx_test::set_checkpoint(__FILE__, TEST_FUNC_NAME(), __LINE__)
-
-#define RAPID_CXX_TEST_OUTCOME()
-
-////////////////////////////////////////////////////////////////////////////////
-//                              TEST_UNSUPPORTED
-////////////////////////////////////////////////////////////////////////////////
-# define TEST_UNSUPPORTED()                                                                 \
-    do {                                                                                    \
-        TEST_SET_CHECKPOINT();                                                              \
-        ::rapid_cxx_test::test_outcome m_f(                                                 \
-          ::rapid_cxx_test::failure_type::unsupported, __FILE__, TEST_FUNC_NAME(), __LINE__ \
-          , "", ""                                                                          \
-        );                                                                                  \
-        ::rapid_cxx_test::get_reporter().report(m_f);                                       \
-        return;                                                                             \
-    } while (false)
-#
-
-
-////////////////////////////////////////////////////////////////////////////////
-//                            BASIC ASSERTIONS
-////////////////////////////////////////////////////////////////////////////////
-# define TEST_WARN(...)                                                                \
-    do {                                                                               \
-        TEST_SET_CHECKPOINT();                                                         \
-        ::rapid_cxx_test::test_outcome m_f(                                            \
-            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
-            , "TEST_WARN(" #__VA_ARGS__ ")", ""                                        \
-            );                                                                         \
-        if (not (__VA_ARGS__)) {                                                       \
-            m_f.type = ::rapid_cxx_test::failure_type::warn;                           \
-        }                                                                              \
-        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
-    } while (false)
-#
-
-# define TEST_CHECK(...)                                                               \
-    do {                                                                               \
-        TEST_SET_CHECKPOINT();                                                         \
-        ::rapid_cxx_test::test_outcome m_f(                                            \
-            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
-            , "TEST_CHECK(" #__VA_ARGS__ ")", ""                                       \
-            );                                                                         \
-        if (not (__VA_ARGS__)) {                                                       \
-            m_f.type = ::rapid_cxx_test::failure_type::check;                          \
-        }                                                                              \
-        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
-    } while (false)
-#
-
-# define TEST_REQUIRE(...)                                                             \
-    do {                                                                               \
-        TEST_SET_CHECKPOINT();                                                         \
-        ::rapid_cxx_test::test_outcome m_f(                                            \
-            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
-            , "TEST_REQUIRE(" #__VA_ARGS__ ")", ""                                     \
-            );                                                                         \
-        if (not (__VA_ARGS__)) {                                                       \
-            m_f.type = ::rapid_cxx_test::failure_type::require;                        \
-        }                                                                              \
-        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
-        if (m_f.type != ::rapid_cxx_test::failure_type::none) {                        \
-            return;                                                                    \
-        }                                                                              \
-    } while (false)
-#
-
-# define TEST_ASSERT(...)                                                              \
-    do {                                                                               \
-        TEST_SET_CHECKPOINT();                                                         \
-        ::rapid_cxx_test::test_outcome m_f(                                            \
-            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
-            , "TEST_ASSERT(" #__VA_ARGS__ ")", ""                                      \
-            );                                                                         \
-        if (not (__VA_ARGS__)) {                                                       \
-            m_f.type = ::rapid_cxx_test::failure_type::assert;                         \
-        }                                                                              \
-        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
-        if (m_f.type != ::rapid_cxx_test::failure_type::none) {                        \
-            std::abort();                                                              \
-        }                                                                              \
-    } while (false)
-#
-
-////////////////////////////////////////////////////////////////////////////////
-//                    TEST_CHECK_NO_THROW / TEST_CHECK_THROW
-////////////////////////////////////////////////////////////////////////////////
-#ifndef TEST_HAS_NO_EXCEPTIONS
-
-# define TEST_CHECK_NO_THROW(...)                                                      \
-    do {                                                                               \
-        TEST_SET_CHECKPOINT();                                                         \
-        ::rapid_cxx_test::test_outcome m_f(                                            \
-            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
-            , "TEST_CHECK_NO_THROW(" #__VA_ARGS__ ")", ""                              \
-            );                                                                         \
-        try {                                                                          \
-            (static_cast<void>(__VA_ARGS__));                                          \
-        } catch (...) {                                                                \
-            m_f.type = ::rapid_cxx_test::failure_type::check;                          \
-        }                                                                              \
-        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
-    } while (false)
-#
-
-# define TEST_CHECK_THROW(Except, ...)                                                 \
-    do {                                                                               \
-        TEST_SET_CHECKPOINT();                                                         \
-        ::rapid_cxx_test::test_outcome m_f(                                            \
-            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
-            , "TEST_CHECK_THROW(" #Except "," #__VA_ARGS__ ")", ""                     \
-            );                                                                         \
-        try {                                                                          \
-            (static_cast<void>(__VA_ARGS__));                                          \
-            m_f.type = ::rapid_cxx_test::failure_type::check;                          \
-        } catch (Except const &) {}                                                    \
-        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
-    } while (false)
-#
-
-#define TEST_CHECK_THROW_RESULT(Except, Checker, ...)                          \
-  do {                                                                         \
-    TEST_SET_CHECKPOINT();                                                     \
-    ::rapid_cxx_test::test_outcome m_f(::rapid_cxx_test::failure_type::none,   \
-                                       __FILE__, TEST_FUNC_NAME(), __LINE__,   \
-                                       "TEST_CHECK_THROW_RESULT(" #Except      \
-                                       "," #Checker "," #__VA_ARGS__ ")",      \
-                                       "");                                    \
-    try {                                                                      \
-      (static_cast<void>(__VA_ARGS__));                                        \
-      m_f.type = ::rapid_cxx_test::failure_type::check;                        \
-    } catch (Except const& Caught) {                                           \
-      Checker(Caught);                                                         \
-    }                                                                          \
-    ::rapid_cxx_test::get_reporter().report(m_f);                              \
-  } while (false)
-#
-
-#else // TEST_HAS_NO_EXCEPTIONS
-
-# define TEST_CHECK_NO_THROW(...)                                                      \
-    do {                                                                               \
-        TEST_SET_CHECKPOINT();                                                         \
-        ::rapid_cxx_test::test_outcome m_f(                                            \
-            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
-            , "TEST_CHECK_NO_THROW(" #__VA_ARGS__ ")", ""                              \
-            );                                                                         \
-        (static_cast<void>(__VA_ARGS__));                                              \
-        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
-    } while (false)
-#
-
-#define TEST_CHECK_THROW(Except, ...) ((void)0)
-#define TEST_CHECK_THROW_RESULT(Except, Checker, ...) ((void)0)
-
-#endif // TEST_HAS_NO_EXCEPTIONS
-
-
-////////////////////////////////////////////////////////////////////////////////
-//                    TEST_REQUIRE_NO_THROW / TEST_REQUIRE_THROWs
-////////////////////////////////////////////////////////////////////////////////
-#ifndef TEST_HAS_NO_EXCEPTIONS
-
-# define TEST_REQUIRE_NO_THROW(...)                                                    \
-    do {                                                                               \
-        TEST_SET_CHECKPOINT();                                                         \
-        ::rapid_cxx_test::test_outcome m_f(                                            \
-            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
-            , "TEST_REQUIRE_NO_THROW(" #__VA_ARGS__ ")", ""                            \
-            );                                                                         \
-        try {                                                                          \
-            (static_cast<void>(__VA_ARGS__));                                          \
-        } catch (...) {                                                                \
-            m_f.type = ::rapid_cxx_test::failure_type::require;                        \
-        }                                                                              \
-        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
-        if (m_f.type != ::rapid_cxx_test::failure_type::none) {                        \
-            return;                                                                    \
-        }                                                                              \
-    } while (false)
-#
-
-# define TEST_REQUIRE_THROW(Except, ...)                                               \
-    do {                                                                               \
-        TEST_SET_CHECKPOINT();                                                         \
-        ::rapid_cxx_test::test_outcome m_f(                                            \
-            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
-            , "TEST_REQUIRE_THROW(" #Except "," #__VA_ARGS__ ")", ""                   \
-            );                                                                         \
-        try {                                                                          \
-            (static_cast<void>(__VA_ARGS__));                                          \
-            m_f.type = ::rapid_cxx_test::failure_type::require;                        \
-        } catch (Except const &) {}                                                    \
-        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
-        if (m_f.type != ::rapid_cxx_test::failure_type::none) {                        \
-            return;                                                                    \
-        }                                                                              \
-    } while (false)
-#
-
-#else // TEST_HAS_NO_EXCEPTIONS
-
-# define TEST_REQUIRE_NO_THROW(...)                                                    \
-    do {                                                                               \
-        TEST_SET_CHECKPOINT();                                                         \
-        ::rapid_cxx_test::test_outcome m_f(                                            \
-            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
-            , "TEST_REQUIRE_NO_THROW(" #__VA_ARGS__ ")", ""                            \
-            );                                                                         \
-        (static_cast<void>(__VA_ARGS__));                                              \
-        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
-    } while (false)
-#
-
-#define TEST_REQUIRE_THROW(Except, ...) ((void)0)
-
-#endif // TEST_HAS_NO_EXCEPTIONS
-
-////////////////////////////////////////////////////////////////////////////////
-//                    TEST_ASSERT_NO_THROW / TEST_ASSERT_THROW
-////////////////////////////////////////////////////////////////////////////////
-#ifndef TEST_HAS_NO_EXCEPTIONS
-
-# define TEST_ASSERT_NO_THROW(...)                                                     \
-    do {                                                                               \
-        TEST_SET_CHECKPOINT();                                                         \
-        ::rapid_cxx_test::test_outcome m_f(                                            \
-            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
-            , "TEST_ASSERT_NO_THROW(" #__VA_ARGS__ ")", ""                             \
-            );                                                                         \
-        try {                                                                          \
-            (static_cast<void>(__VA_ARGS__));                                          \
-        } catch (...) {                                                                \
-            m_f.type = ::rapid_cxx_test::failure_type::assert;                         \
-        }                                                                              \
-        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
-        if (m_f.type != ::rapid_cxx_test::failure_type::none) {                        \
-            std::abort();                                                              \
-        }                                                                              \
-    } while (false)
-#
-
-# define TEST_ASSERT_THROW(Except, ...)                                                \
-    do {                                                                               \
-        TEST_SET_CHECKPOINT();                                                         \
-        ::rapid_cxx_test::test_outcome m_f(                                            \
-            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
-            , "TEST_ASSERT_THROW(" #Except "," #__VA_ARGS__ ")", ""                    \
-            );                                                                         \
-        try {                                                                          \
-            (static_cast<void>(__VA_ARGS__));                                          \
-            m_f.type = ::rapid_cxx_test::failure_type::assert;                         \
-        } catch (Except const &) {}                                                    \
-        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
-        if (m_f.type != ::rapid_cxx_test::failure_type::none) {                        \
-            std::abort();                                                              \
-        }                                                                              \
-    } while (false)
-#
-
-#else // TEST_HAS_NO_EXCEPTIONS
-
-# define TEST_ASSERT_NO_THROW(...)                                                     \
-    do {                                                                               \
-        TEST_SET_CHECKPOINT();                                                         \
-        ::rapid_cxx_test::test_outcome m_f(                                            \
-            ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__ \
-            , "TEST_ASSERT_NO_THROW(" #__VA_ARGS__ ")", ""                             \
-            );                                                                         \
-        (static_cast<void>(__VA_ARGS__));                                              \
-        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
-    } while (false)
-#
-
-#define TEST_ASSERT_THROW(Except, ...) ((void)0)
-
-#endif // TEST_HAS_NO_EXCEPTIONS
-
-////////////////////////////////////////////////////////////////////////////////
-//
-////////////////////////////////////////////////////////////////////////////////
-
-# define TEST_WARN_EQUAL_COLLECTIONS(...)                                              \
-    do {                                                                               \
-        TEST_SET_CHECKPOINT();                                                         \
-        ::rapid_cxx_test::test_outcome m_f(                                            \
-          ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__   \
-          , "TEST_WARN_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", ""                        \
-        );                                                                             \
-        if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
-            m_f.type = ::rapid_cxx_test::failure_type::warn;                           \
-        }                                                                              \
-        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
-    } while (false)
-#
-
-# define TEST_CHECK_EQUAL_COLLECTIONS(...)                                             \
-    do {                                                                               \
-        TEST_SET_CHECKPOINT();                                                         \
-        ::rapid_cxx_test::test_outcome m_f(                                            \
-          ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__   \
-          , "TEST_CHECK_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", ""                       \
-        );                                                                             \
-        if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
-            m_f.type = ::rapid_cxx_test::failure_type::check;                          \
-        }                                                                              \
-        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
-    } while (false)
-#
-
-# define TEST_REQUIRE_EQUAL_COLLECTIONS(...)                                           \
-    do {                                                                               \
-        TEST_SET_CHECKPOINT();                                                         \
-        ::rapid_cxx_test::test_outcome m_f(                                            \
-          ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__   \
-          , "TEST_REQUIRE_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", ""                     \
-        );                                                                             \
-        if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
-            m_f.type = ::rapid_cxx_test::failure_type::require;                        \
-        }                                                                              \
-        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
-        if (m_f.type != ::rapid_cxx_test::failure_type::none) {                        \
-            return;                                                                    \
-        }                                                                              \
-    } while (false)
-#
-
-# define TEST_ASSERT_EQUAL_COLLECTIONS(...)                                            \
-    do {                                                                               \
-        TEST_SET_CHECKPOINT();                                                         \
-        ::rapid_cxx_test::test_outcome m_f(                                            \
-          ::rapid_cxx_test::failure_type::none, __FILE__, TEST_FUNC_NAME(), __LINE__   \
-          , "TEST_ASSERT_EQUAL_COLLECTIONS(" #__VA_ARGS__ ")", ""                      \
-        );                                                                             \
-        if (not ::rapid_cxx_test::detail::check_equal_collections_impl(__VA_ARGS__)) { \
-            m_f.type = ::rapid_cxx_test::failure_type::assert;                         \
-        }                                                                              \
-        ::rapid_cxx_test::get_reporter().report(m_f);                                  \
-        if (m_f.type != ::rapid_cxx_test::failure_type::none) {                        \
-          ::std::abort();                                                              \
-        }                                                                              \
-    } while (false)
-#
-
-namespace rapid_cxx_test
-{
-    typedef void (*invoker_t)();
-
-    ////////////////////////////////////////////////////////////////////////////
-    struct test_case
-    {
-        test_case()
-            : file(""), func(""), line(0), invoke(NULL)
-        {}
-
-        test_case(const char* file1, const char* func1, std::size_t line1,
-                  invoker_t invoke1)
-            : file(file1), func(func1), line(line1), invoke(invoke1)
-        {}
-
-        const char *file;
-        const char *func;
-        std::size_t line;
-        invoker_t invoke;
-    };
-
-    ////////////////////////////////////////////////////////////////////////////
-    struct failure_type
-    {
-        enum enum_type {
-            none,
-            unsupported,
-            warn,
-            check,
-            require,
-            assert,
-            uncaught_exception
-        };
-    };
-
-    typedef failure_type::enum_type failure_type_t;
-
-    ////////////////////////////////////////////////////////////////////////////
-    struct test_outcome
-    {
-        test_outcome()
-            : type(failure_type::none),
-              file(""), func(""), line(0),
-              expression(""), message("")
-        {}
-
-        test_outcome(failure_type_t type1, const char* file1, const char* func1,
-                     std::size_t line1, const char* expression1,
-                     const char* message1)
-            : type(type1), file(file1), func(func1), line(line1),
-              expression(expression1), message(message1)
-        {
-            trim_func_string();
-        }
-
-        failure_type_t type;
-        const char *file;
-        const char *func;
-        std::size_t line;
-        const char *expression;
-        const char *message;
-
-    private:
-        void trim_file_string() {
-            const char* f_start  = file;
-            const char* prev_start = f_start;
-            const char* last_start = f_start;
-            char last;
-            while ((last = *f_start) != '\0') {
-                ++f_start;
-                if (last == '/' && *f_start) {
-                    prev_start = last_start;
-                    last_start = f_start;
-                }
-            }
-            file = prev_start;
-        }
-      void trim_func_string() {
-          const char* void_loc = ::strstr(func, "void ");
-          if (void_loc == func) {
-              func += strlen("void ");
-          }
-          const char* namespace_loc = ::strstr(func, "::");
-          if (namespace_loc) {
-              func = namespace_loc + 2;
-          }
-      }
-    };
-
-    ////////////////////////////////////////////////////////////////////////////
-    struct checkpoint
-    {
-        const char *file;
-        const char *func;
-        std::size_t line;
-    };
-
-    namespace detail
-    {
-        inline checkpoint & global_checkpoint()
-        {
-            static checkpoint cp = {"", "", 0};
-            return cp;
-        }
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-    inline void set_checkpoint(const char* file, const char* func, std::size_t line)
-    {
-        checkpoint& cp = detail::global_checkpoint();
-        cp.file = file;
-        cp.func = func;
-        cp.line = line;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-    inline checkpoint const & get_checkpoint()
-    {
-        return detail::global_checkpoint();
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-    class test_suite
-    {
-    public:
-        typedef test_case const* iterator;
-        typedef iterator const_iterator;
-
-    public:
-        test_suite(const char *xname)
-          : m_name(xname), m_tests(), m_size(0)
-        {
-            assert(xname);
-        }
-
-    public:
-        const char *name() const { return m_name; }
-
-        std::size_t size() const { return m_size; }
-
-        test_case const & operator[](std::size_t i) const
-        {
-            assert(i < m_size);
-            return m_tests[i];
-        }
-
-        const_iterator begin() const
-        { return m_tests; }
-
-        const_iterator end() const
-        {
-            return m_tests + m_size;
-        }
-
-    public:
-        std::size_t register_test(test_case tc)
-        {
-            static std::size_t test_case_max = sizeof(m_tests) / sizeof(test_case);
-            assert(m_size < test_case_max);
-            m_tests[m_size] = tc;
-            return m_size++;
-        }
-
-    private:
-        test_suite(test_suite const &);
-        test_suite & operator=(test_suite const &);
-
-    private:
-        const char* m_name;
-        // Since fast compile times in a priority, we use simple containers
-        // with hard limits.
-        test_case m_tests[256];
-        std::size_t m_size;
-    };
-
-    ////////////////////////////////////////////////////////////////////////////
-    class registrar
-    {
-    public:
-        registrar(test_suite & st, test_case tc)
-        {
-            st.register_test(tc);
-        }
-    };
-
-    ////////////////////////////////////////////////////////////////////////////
-    class test_reporter
-    {
-    public:
-        test_reporter()
-            : m_testcases(0), m_testcase_failures(0), m_unsupported(0),
-              m_assertions(0), m_warning_failures(0), m_check_failures(0),
-              m_require_failures(0), m_uncaught_exceptions(0), m_failure()
-        {
-        }
-
-        void test_case_begin()
-        {
-            ++m_testcases;
-            clear_failure();
-        }
-
-        void test_case_end()
-        {
-            if (m_failure.type != failure_type::none
-                && m_failure.type !=  failure_type::unsupported) {
-                ++m_testcase_failures;
-            }
-        }
-
-# if defined(__GNUC__)
-#   pragma GCC diagnostic push
-#   pragma GCC diagnostic ignored "-Wswitch-default"
-# endif
-        // Each assertion and failure is reported through this function.
-        void report(test_outcome o)
-        {
-            ++m_assertions;
-            switch (o.type)
-            {
-            case failure_type::none:
-                break;
-            case failure_type::unsupported:
-                ++m_unsupported;
-                m_failure = o;
-                break;
-            case failure_type::warn:
-                ++m_warning_failures;
-                report_error(o);
-                break;
-            case failure_type::check:
-                ++m_check_failures;
-                report_error(o);
-                m_failure = o;
-                break;
-            case failure_type::require:
-                ++m_require_failures;
-                report_error(o);
-                m_failure = o;
-                break;
-            case failure_type::assert:
-                report_error(o);
-                break;
-            case failure_type::uncaught_exception:
-                ++m_uncaught_exceptions;
-                std::fprintf(stderr
-                    , "Test case FAILED with uncaught exception:\n"
-                      "    last checkpoint near %s::%lu %s\n\n"
-                    , o.file, o.line, o.func
-                    );
-                m_failure = o;
-                break;
-            }
-        }
-# if defined(__GNUC__)
-#   pragma GCC diagnostic pop
-# endif
-
-        test_outcome current_failure() const
-        {
-            return m_failure;
-        }
-
-        void clear_failure()
-        {
-            m_failure.type = failure_type::none;
-            m_failure.file = "";
-            m_failure.func = "";
-            m_failure.line = 0;
-            m_failure.expression = "";
-            m_failure.message = "";
-        }
-
-        std::size_t test_case_count() const
-        { return m_testcases; }
-
-        std::size_t test_case_failure_count() const
-        { return m_testcase_failures; }
-
-        std::size_t unsupported_count() const
-        { return m_unsupported; }
-
-        std::size_t assertion_count() const
-        { return m_assertions; }
-
-        std::size_t warning_failure_count() const
-        { return m_warning_failures; }
-
-        std::size_t check_failure_count() const
-        { return m_check_failures; }
-
-        std::size_t require_failure_count() const
-        { return m_require_failures; }
-
-        std::size_t failure_count() const
-        { return m_check_failures + m_require_failures + m_uncaught_exceptions; }
-
-        // Print a summary of what was run and the outcome.
-        void print_summary(const char* suitename) const
-        {
-            FILE* out = failure_count() ? stderr : stdout;
-            std::size_t testcases_run = m_testcases - m_unsupported;
-            std::fprintf(out, "Summary for testsuite %s:\n", suitename);
-            std::fprintf(out, "    %lu of %lu test cases passed.\n", testcases_run - m_testcase_failures, testcases_run);
-            std::fprintf(out, "    %lu of %lu assertions passed.\n", m_assertions - (m_warning_failures + m_check_failures + m_require_failures), m_assertions);
-            std::fprintf(out, "    %lu unsupported test case%s.\n", m_unsupported, (m_unsupported != 1 ? "s" : ""));
-        }
-
-    private:
-        test_reporter(test_reporter const &);
-        test_reporter const & operator=(test_reporter const &);
-
-        void report_error(test_outcome o) const
-        {
-            std::fprintf(stderr, "In %s:%lu Assertion %s failed.\n    in file: %s\n    %s\n"
-                , o.func, o.line, o.expression, o.file,  o.message ? o.message : ""
-              );
-        }
-
-    private:
-        // counts of testcases, failed testcases, and unsupported testcases.
-        std::size_t m_testcases;
-        std::size_t m_testcase_failures;
-        std::size_t m_unsupported;
-
-        // counts of assertions and assertion failures.
-        std::size_t m_assertions;
-        std::size_t m_warning_failures;
-        std::size_t m_check_failures;
-        std::size_t m_require_failures;
-        std::size_t m_uncaught_exceptions;
-
-        // The last failure. This is cleared between testcases.
-        test_outcome m_failure;
-    };
-
-    ////////////////////////////////////////////////////////////////////////////
-    inline test_reporter & get_reporter()
-    {
-        static test_reporter o;
-        return o;
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-    class test_runner
-    {
-    public:
-        test_runner(test_suite & ts)
-          : m_ts(ts)
-        {}
-
-    public:
-        int run()
-        {
-            // for each testcase
-            for (test_suite::const_iterator b = m_ts.begin(), e = m_ts.end();
-                 b != e; ++b)
-            {
-                test_case const& tc = *b;
-                set_checkpoint(tc.file, tc.func, tc.line);
-                get_reporter().test_case_begin();
-#ifndef TEST_HAS_NO_EXCEPTIONS
-                try {
-#endif
-                    tc.invoke();
-#ifndef TEST_HAS_NO_EXCEPTIONS
-                } catch (...) {
-                    test_outcome o;
-                    o.type = failure_type::uncaught_exception;
-                    o.file = get_checkpoint().file;
-                    o.func = get_checkpoint().func;
-                    o.line = get_checkpoint().line;
-                    o.expression = "";
-                    o.message = "";
-                    get_reporter().report(o);
-                }
-#endif
-                get_reporter().test_case_end();
-            }
-            auto exit_code = get_reporter().failure_count() ? EXIT_FAILURE : EXIT_SUCCESS;
-            if (exit_code == EXIT_FAILURE || get_reporter().unsupported_count())
-              get_reporter().print_summary(m_ts.name());
-            return exit_code;
-        }
-
-    private:
-        test_runner(test_runner const &);
-        test_runner operator=(test_runner const &);
-
-        test_suite & m_ts;
-    };
-
-    namespace detail
-    {
-        template <class Iter1, class Iter2>
-        bool check_equal_collections_impl(
-            Iter1 start1, Iter1 const end1
-          , Iter2 start2, Iter2 const end2
-          )
-        {
-            while (start1 != end1 && start2 != end2) {
-                if (*start1 != *start2) {
-                    return false;
-                }
-                ++start1; ++start2;
-            }
-            return (start1 == end1 && start2 == end2);
-        }
-    }                                                       // namespace detail
-
-}                                                    // namespace rapid_cxx_test
-
-
-# if defined(__GNUC__)
-#   pragma GCC diagnostic pop
-# endif
-
-#endif /* RAPID_CXX_TEST_H */