[libc++] Remove uses of verbose_assert.h in Filesystem tests

ldionne · ldionne · commit e557b6a66d54 · 2020-10-20T16:57:00.000-04:00
For a modest loss of debugability in the tests, this allows more tests
to run on platforms that do not have support for &lt;iostream&gt;.
diff --git a/libcxx/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp b/libcxx/test/std/input.output/filesystems/class.path/path.member/path.append.pass.cpp
@@ -30,7 +30,6 @@
 #include "test_iterators.h"
 #include "count_new.h"
 #include "filesystem_test_helper.h"
-#include "verbose_assert.h"
 
 
 struct AppendOperatorTestcase {
@@ -108,7 +107,7 @@ void doAppendSourceAllocTest(AppendOperatorTestcase const& TC)
       DisableAllocationGuard g;
       LHS /= RHS;
     }
-    ASSERT_PRED(PathEq, LHS , E);
+    assert(PathEq(LHS, E));
   }
   // basic_string_view
   {
@@ -184,8 +183,7 @@ void doAppendSourceTest(AppendOperatorTestcase const& TC)
     path Result(L);
     Str RHS(R);
     path& Ref = (Result /= RHS);
-    ASSERT_EQ(Result, E)
-        << DISPLAY(L) << DISPLAY(R);
+    assert(Result == E);
     assert(&Ref == &Result);
   }
   {
@@ -229,8 +227,7 @@ void doAppendSourceTest(AppendOperatorTestcase const& TC)
     path LHS(L);
     Ptr RHS(R);
     path& Ref = LHS.append(RHS, StrEnd(RHS));
-    ASSERT_PRED(PathEq, LHS, E)
-        << DISPLAY(L) << DISPLAY(R);
+    assert(PathEq(LHS, E));
     assert(&Ref == &LHS);
   }
   // iterators
@@ -321,8 +318,7 @@ int main(int, char**)
       path LHS(LHS_In);
       path RHS(RHS_In);
       path& Res = (LHS /= RHS);
-      ASSERT_PRED(PathEq, Res, (const char*)TC.expect)
-          << DISPLAY(LHS_In) << DISPLAY(RHS_In);
+      assert(PathEq(Res, (const char*)TC.expect));
       assert(&Res == &LHS);
     }
     doAppendSourceTest<char>    (TC);
diff --git a/libcxx/test/std/input.output/filesystems/class.path/path.member/path.compare.pass.cpp b/libcxx/test/std/input.output/filesystems/class.path/path.member/path.compare.pass.cpp
@@ -35,7 +35,6 @@
 #include "test_iterators.h"
 #include "count_new.h"
 #include "filesystem_test_helper.h"
-#include "verbose_assert.h"
 
 struct PathCompareTest {
   const char* LHS;
@@ -99,11 +98,10 @@ void test_compare_basic()
       int ret4 = normalize_ret(p1.compare(RV));
 
       g.release();
-      ASSERT_EQ(ret1, ret2);
-      ASSERT_EQ(ret1, ret3);
-      ASSERT_EQ(ret1, ret4);
-      ASSERT_EQ(ret1, E)
-          << DISPLAY(TC.LHS) << DISPLAY(TC.RHS);
+      assert(ret1 == ret2);
+      assert(ret1 == ret3);
+      assert(ret1 == ret4);
+      assert(ret1 == E);
 
       // check signatures
       ASSERT_NOEXCEPT(p1.compare(p2));
diff --git a/libcxx/test/std/input.output/filesystems/class.path/path.member/path.decompose/path.decompose.pass.cpp b/libcxx/test/std/input.output/filesystems/class.path/path.member/path.decompose/path.decompose.pass.cpp
@@ -44,15 +44,17 @@
 
 
 #include "filesystem_include.h"
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <iterator>
 #include <type_traits>
 #include <vector>
-#include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 #include "count_new.h"
 #include "filesystem_test_helper.h"
-#include "verbose_assert.h"
 
 struct ComparePathExact {
   bool operator()(fs::path const& LHS, std::string const& RHS) const {
@@ -120,46 +122,41 @@ void decompPathTest()
   using namespace fs;
   for (auto const & TC : PathTestCases) {
     fs::path p(TC.raw);
-    ASSERT(p == TC.raw);
+    assert(p == TC.raw);
 
-    ASSERT_EQ(p.root_path(), TC.root_path);
-    ASSERT_NEQ(p.has_root_path(), TC.root_path.empty());
+    assert(p.root_path() == TC.root_path);
+    assert(p.has_root_path() != TC.root_path.empty());
 
-    ASSERT(p.root_name().native().empty())
-        << DISPLAY(p.root_name());
-    ASSERT_EQ(p.root_name(),TC.root_name);
-    ASSERT_NEQ(p.has_root_name(), TC.root_name.empty());
+    assert(p.root_name().native().empty());
+    assert(p.root_name() == TC.root_name);
+    assert(p.has_root_name() != TC.root_name.empty());
 
-    ASSERT_EQ(p.root_directory(), TC.root_directory);
-    ASSERT_NEQ(p.has_root_directory(), TC.root_directory.empty());
+    assert(p.root_directory() == TC.root_directory);
+    assert(p.has_root_directory() != TC.root_directory.empty());
 
-    ASSERT_EQ(p.relative_path(), TC.relative_path);
-    ASSERT_NEQ(p.has_relative_path(), TC.relative_path.empty());
+    assert(p.relative_path() == TC.relative_path);
+    assert(p.has_relative_path() != TC.relative_path.empty());
 
-    ASSERT_EQ(p.parent_path(), TC.parent_path);
-    ASSERT_NEQ(p.has_parent_path(), TC.parent_path.empty());
+    assert(p.parent_path() == TC.parent_path);
+    assert(p.has_parent_path() != TC.parent_path.empty());
 
-    ASSERT_EQ(p.filename(), TC.filename);
-    ASSERT_NEQ(p.has_filename(), TC.filename.empty());
+    assert(p.filename() == TC.filename);
+    assert(p.has_filename() != TC.filename.empty());
 
-    ASSERT_EQ(p.is_absolute(), p.has_root_directory());
-    ASSERT_NEQ(p.is_relative(), p.is_absolute());
+    assert(p.is_absolute() == p.has_root_directory());
+    assert(p.is_relative() != p.is_absolute());
     if (p.empty())
-      ASSERT(p.is_relative());
+      assert(p.is_relative());
 
-    ASSERT_COLLECTION_EQ_COMP(
-        p.begin(), p.end(),
-        TC.elements.begin(), TC.elements.end(),
-        ComparePathExact()
-    );
-    // check backwards
+    assert(static_cast<std::size_t>(std::distance(p.begin(), p.end())) == TC.elements.size());
+    assert(std::equal(p.begin(), p.end(), TC.elements.begin(), ComparePathExact()));
 
+    // check backwards
     std::vector<fs::path> Parts;
     for (auto it = p.end(); it != p.begin(); )
       Parts.push_back(*--it);
-    ASSERT_COLLECTION_EQ_COMP(Parts.begin(), Parts.end(),
-                                 TC.elements.rbegin(), TC.elements.rend(),
-                              ComparePathExact());
+    assert(static_cast<std::size_t>(std::distance(Parts.begin(), Parts.end())) == TC.elements.size());
+    assert(std::equal(Parts.begin(), Parts.end(), TC.elements.rbegin(), ComparePathExact()));
   }
 }
 
@@ -191,17 +188,17 @@ void decompFilenameTest()
   using namespace fs;
   for (auto const & TC : FilenameTestCases) {
     fs::path p(TC.raw);
-    ASSERT_EQ(p, TC.raw);
+    assert(p == TC.raw);
     ASSERT_NOEXCEPT(p.empty());
 
-    ASSERT_EQ(p.filename(), TC.filename);
-    ASSERT_NEQ(p.has_filename(), TC.filename.empty());
+    assert(p.filename() == TC.filename);
+    assert(p.has_filename() != TC.filename.empty());
 
-    ASSERT_EQ(p.stem(), TC.stem);
-    ASSERT_NEQ(p.has_stem(), TC.stem.empty());
+    assert(p.stem() == TC.stem);
+    assert(p.has_stem() != TC.stem.empty());
 
-    ASSERT_EQ(p.extension(), TC.extension);
-    ASSERT_NEQ(p.has_extension(), TC.extension.empty());
+    assert(p.extension() == TC.extension);
+    assert(p.has_extension() != TC.extension.empty());
   }
 }
 
diff --git a/libcxx/test/std/input.output/filesystems/class.path/path.member/path.modifiers/remove_filename.pass.cpp b/libcxx/test/std/input.output/filesystems/class.path/path.member/path.modifiers/remove_filename.pass.cpp
@@ -22,7 +22,6 @@
 #include "test_iterators.h"
 #include "count_new.h"
 #include "filesystem_test_helper.h"
-#include "verbose_assert.h"
 
 struct RemoveFilenameTestcase {
   const char* value;
@@ -65,7 +64,7 @@ int main(int, char**)
     path p(p_orig);
     assert(p == TC.value);
     path& Ref = (p.remove_filename());
-    ASSERT_EQ(p, TC.expect) << DISPLAY(p_orig);
+    assert(p == TC.expect);
     assert(&Ref == &p);
     assert(!p.has_filename());
   }
diff --git a/libcxx/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_filename.pass.cpp b/libcxx/test/std/input.output/filesystems/class.path/path.member/path.modifiers/replace_filename.pass.cpp
@@ -22,7 +22,6 @@
 #include "test_iterators.h"
 #include "count_new.h"
 #include "filesystem_test_helper.h"
-#include "verbose_assert.h"
 
 struct ReplaceFilenameTestcase {
   const char* value;
@@ -51,19 +50,17 @@ int main(int, char**)
   using namespace fs;
   for (auto const & TC : TestCases) {
     path p(TC.value);
-    ASSERT_EQ(p, TC.value);
-    path& Ref = (p.replace_filename(TC.filename));
-    ASSERT_EQ(p, TC.expect)
-        << DISPLAY(TC.value)
-        << DISPLAY(TC.filename);
+    assert(p == TC.value);
+    path& Ref = p.replace_filename(TC.filename);
+    assert(p == TC.expect);
     assert(&Ref == &p);
     // Tests Effects "as-if": remove_filename() append(filename)
     {
       path p2(TC.value);
       path replace(TC.filename);
       p2.remove_filename();
       p2 /= replace;
-      ASSERT_EQ(p, p2);
+      assert(p == p2);
     }
   }
 
diff --git a/libcxx/test/support/verbose_assert.h b/libcxx/test/support/verbose_assert.h
