[libcxx] [test] Do error printfs to stderr in filesystem tests

[mstorsjo]

Summary

This makes them more readable in llvm-lit's output on failures.

This only applies the change on the filesystem test subdir.

[ldionne]

The reason why I originally used printf instead of fprintf(stderr) is that some platforms provide printf (via printing to some sort of uart port), but not a proper stderr. But I agree this change makes sense, and we can't make filesystem work on those platforms anyway.

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

int main(int, char**) {
   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)) {
       Failed = true;
-      std::printf("TEST CASE #%d FAILED:\n"
+      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.native().c_str());
     }
   }
   return Failed;
 }

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

int main(int, char**) {
   bool Failed = false;
   for (auto& TC : TestCases) {
     ++ID;
     const fs::path p(TC.input);
     const fs::path output = p.lexically_relative(TC.base);
     auto ReportErr = [&](const char* Testing, fs::path const& Output,
                                               fs::path const& Expected) {
       Failed = true;
-      std::printf("TEST CASE #%d FAILED:\n"
+      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.c_str(), Output.native().c_str());
     };

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

TEST_CASE(basic_test) {
   int ID = 0;
   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);
     if (ec) {
       TEST_CHECK(!ec);
-      std::printf("TEST CASE #%d FAILED:\n"
+      std::fprintf(stderr, "TEST CASE #%d FAILED:\n"
                   "  Input: '%s'\n"
                   "  Base: '%s'\n"
                   "  Expected: '%s'\n",
         ID, TC.input.c_str(), TC.base.c_str(), TC.expect.c_str());
     } else if (!PathEq(output, TC.expect)) {
       TEST_CHECK(PathEq(output, TC.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::printf("TEST CASE #%d FAILED:\n"
+      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.c_str(), TC.base.c_str(), TC.expect.c_str(),
         output.native().c_str(), lexically_p.native().c_str(),
         canon_input.c_str(), canon_base.c_str());
     }
   }
 }
 
 TEST_SUITE_END()

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

int main(int, char**) {
   int ID = 0;
   bool Failed = false;
   for (auto& TC : TestCases) {
     ++ID;
     fs::path p(TC.input);
     const fs::path output = fs::weakly_canonical(p);
     if (!PathEq(output, TC.expect)) {
       Failed = true;
-      std::printf("TEST CASE #%d FAILED:\n"
+      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.native().c_str());
     }
   }
   return Failed;
 }