[libcxx] [test] Fix lexically_normal and lexically_relative_and_proximate for windows

[mstorsjo]

Summary

Convert the expected result path to preferred separators, add exceptions
to the test results where needed (due to some cases being interpreted
as a root name).

[curdeius]

libcxx/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp

42

Unless I am mistaken, the test case for //base is identical for Win32 and other platforms.

[mstorsjo]

libcxx/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp

42

Thanks, looks like you're right. Updating...

[mstorsjo]

Un-ifdef a testcase that was identical in both cases

[• Quuxplusone]

LGTM!

libcxx/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp

89

Potential drive-by clarity improvement: Here we construct proximate_expected from the old value of output, rather than from expect. This works, because by the time we reach this line, it is guaranteed that PathEq(output, expect). Still, IMHO, this code would be less confusing if you replaced the identifier output on this line with the identifier expect. Plus, fix the argument order to PathEq so that it's parallel to the order on line 81.

const fs::path proximate_expect = expect.empty() ? p : expect;
if (!PathEq(proximate_output, proximate_expect))
  ~~~

Not a blocker, but I think it'd be nice.

[mstorsjo]

libcxx/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp

89

Sure, I can do a separate change to improve the consistency that way.

[curdeius]

LGTM.

libcxx/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_normal.pass.cpp

std::string expect;
       {"/../..", "/"},
       {"/../../", "/"},
       {"..", ".."},
       {"../", ".."},
       {"/a/b/c/../", "/a/b/"},
       {"/a/b/./", "/a/b/"},
       {"/a/b/c/../d", "/a/b/d"},
       {"/a/b/c/../d/", "/a/b/d/"},
+#ifdef _WIN32
+      {"//a/", "//a/"},
+      {"//a/b/", "//a/b/"},
+      {"//a/b/.", "//a/b/"},
+      {"//a/..", "//a/"},
+#else
       {"//a/", "/a/"},
       {"//a/b/", "/a/b/"},
       {"//a/b/.", "/a/b/"},
       {"//a/..", "/"},
+#endif
       ///===---------------------------------------------------------------===//
       /// Tests specifically for the clauses under [fs.path.generic]p6
       ///===---------------------------------------------------------------===//
       // p1: If the path is empty, stop.
       {"", ""},
       // p2: Replace each slash character in the root-name with a preferred
       // separator.
       {"NO_ROOT_NAME_ON_LINUX", "NO_ROOT_NAME_ON_LINUX"},
#endif
   };
   // clang-format on
   int ID = 0;
   bool Failed = false;
   for (auto& TC : TestCases) {
     ++ID;
     fs::path p(TC.input);
     const fs::path output = p.lexically_normal();
-    if (!PathEq(output, TC.expect)) {
+    fs::path expect(TC.expect);
+    expect.make_preferred();
+    if (!PathEq(output, expect)) {
       Failed = true;
       std::fprintf(stderr, "TEST CASE #%d FAILED:\n"
                   "  Input: '%s'\n"
                   "  Expected: '%s'\n"
                   "  Output: '%s'\n",
-        ID, TC.input.c_str(), TC.expect.c_str(), output.string().c_str());
+        ID, TC.input.c_str(), expect.string().c_str(), output.string().c_str());
     }
   }
   return Failed;
 }

libcxx/test/std/input.output/filesystems/class.path/path.member/path.gen/lexically_relative_and_proximate.pass.cpp

struct {
     std::string base;
     std::string expect;
   } TestCases[] = {
       {"", "", "."},
       {"/", "a", ""},
       {"a", "/", ""},
       {"//net", "a", ""},
       {"a", "//net", ""},
+#ifdef _WIN32
+      {"//net/", "//net", ""},
+      {"//net", "//net/", ""},
+      {"//base", "a", ""},
+#else
       {"//net/", "//net", "."},
       {"//net", "//net/", "."},
       {"//base", "a", ""},
+#endif
       {"a", "a", "."},
       {"a/b", "a/b", "."},
       {"a/b/c/", "a/b/c/", "."},
       {"//net", "//net", "."},
       {"//net/", "//net/", "."},
       {"//net/a/b", "//net/a/b", "."},
       {"/a/d", "/a/b/c", "../../d"},
       {"/a/b/c", "/a/d", "../b/c"},
       {"a/b/c", "a", "b/c"},
       {"a/b/c", "a/b/c/x/y", "../.."},
       {"a/b/c", "a/b/c", "."},
       {"a/b", "c/d", "../../a/b"}
   };
   // clang-format on
   int ID = 0;
   bool Failed = false;
   for (auto& TC : TestCases) {
     ++ID;
     const fs::path p(TC.input);
     const fs::path output = p.lexically_relative(TC.base);
+    fs::path expect(TC.expect);
+    expect.make_preferred();
     auto ReportErr = [&](const char* Testing, fs::path const& Output,
                                               fs::path const& Expected) {
       Failed = true;
       std::fprintf(stderr, "TEST CASE #%d FAILED:\n"
                   "  Testing: %s\n"
                   "  Input: '%s'\n"
                   "  Base: '%s'\n"
                   "  Expected: '%s'\n"
                   "  Output: '%s'\n",
         ID, Testing, TC.input.c_str(), TC.base.c_str(),
         Expected.string().c_str(), Output.string().c_str());
     };
-    if (!PathEq(output, TC.expect))
-      ReportErr("path::lexically_relative", output, TC.expect);
+    if (!PathEq(output, expect))
+      ReportErr("path::lexically_relative", output, expect);
     const fs::path proximate_output = p.lexically_proximate(TC.base);
     // [path.gen] lexically_proximate
     // Returns: If the value of lexically_relative(base) is not an empty path,
     // return it. Otherwise return *this.
     const fs::path proximate_expected = output.native().empty() ? p
         : output;
     if (!PathEq(proximate_expected, proximate_output))
       ReportErr("path::lexically_proximate", proximate_output, proximate_expected);
   }
   return Failed;
 }