[libcxx] [test] Use error_code::default_error_condition to check errors against the expected codes

[mstorsjo]

Summary

error_code returned from functions might not be of the generic category, but of the system category, which can have different error code values. Use default_error_condition() to remap errors to the generic category where possible, to allow comparing them to the expected values.

Use the ErrorIs() helper instead of a direct comparison against an excpected value.

[ldionne]

LGTM with my comments applied.

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

176

Can you please use static_cast instead of a C-style cast?

libcxx/test/support/filesystem_test_helper.h

565

Same, static_cast.

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

using namespace fs;
     const path nestedDir = testFiles[2];
     const path nestedFile = testFiles[3];
 
     // Change the permissions so we can no longer iterate
     permissions(permDeniedDir,
                 perms::group_exec|perms::owner_exec|perms::others_exec,
                 perm_options::remove);
 
-    const std::error_code eacess_ec =
-        std::make_error_code(std::errc::permission_denied);
+    const std::errc eacess = std::errc::permission_denied;
     std::error_code ec = GetTestEC();
 
     const recursive_directory_iterator endIt;
 
     auto SetupState = [&](bool AllowEAccess, bool& SeenFile3) {
       SeenFile3 = false;
       auto Opts = AllowEAccess ? directory_options::skip_permission_denied
           : directory_options::none;
using namespace fs;
     {
       bool SeenNestedFile = false;
       recursive_directory_iterator it = SetupState(false, SeenNestedFile);
       TEST_REQUIRE(it != endIt);
       TEST_REQUIRE(*it == nestedDir);
       ec = GetTestEC();
       it.increment(ec);
       TEST_CHECK(ec);
-      TEST_CHECK(ec == eacess_ec);
+      TEST_CHECK(ErrorIs(ec, eacess));
       TEST_CHECK(it == endIt);
     }
     {
       bool SeenNestedFile = false;
       recursive_directory_iterator it = SetupState(true, SeenNestedFile);
       TEST_REQUIRE(it != endIt);
       TEST_REQUIRE(*it == nestedDir);
       ec = GetTestEC();
// const unsigned TestFilesSize = sizeof(testFiles) / sizeof(testFiles[0]);
     const path permDeniedDir = testFiles[2];
     const path symDir = testFiles[4];
 
     // Change the permissions so we can no longer iterate
     permissions(permDeniedDir,
                 perms::group_exec|perms::owner_exec|perms::others_exec,
                 perm_options::remove);
 
-    const std::error_code eacess_ec =
-        std::make_error_code(std::errc::permission_denied);
+    const std::errc eacess = std::errc::permission_denied;
     std::error_code ec = GetTestEC();
 
     const recursive_directory_iterator endIt;
 
     auto SetupState = [&](bool AllowEAccess, bool FollowSym, bool& SeenFile3) {
       SeenFile3 = false;
       auto Opts = AllowEAccess ? directory_options::skip_permission_denied
           : directory_options::none;
for (auto TC : TestCases) {
         if (SeenNestedFile) {
           TEST_CHECK(it == endIt);
         } else {
           TEST_REQUIRE(it != endIt);
           TEST_CHECK(*it == nestedFile);
         }
       } else {
         TEST_CHECK(ec);
-        TEST_CHECK(ec == eacess_ec);
+        TEST_CHECK(ErrorIs(ec, eacess));
         TEST_CHECK(it == endIt);
       }
     }
 }
 
 
 // See llvm.org/PR35078
 TEST_CASE(test_PR35078_with_symlink_file)
using namespace fs;
     const path permDeniedDir = testFiles[3];
     const path symFile = testFiles[TestFilesSize - 1];
 
     // Change the permissions so we can no longer iterate
     permissions(permDeniedDir,
                 perms::group_exec|perms::owner_exec|perms::others_exec,
                 perm_options::remove);
 
-    const std::error_code eacess_ec =
-        std::make_error_code(std::errc::permission_denied);
+    const std::errc eacess = std::errc::permission_denied;
     std::error_code ec = GetTestEC();
 
     const recursive_directory_iterator EndIt;
 
     auto SetupState = [&](bool AllowEAccess, bool FollowSym, bool& SeenNestedFile) {
       SeenNestedFile = false;
       auto Opts = AllowEAccess ? directory_options::skip_permission_denied
           : directory_options::none;
for (auto TC : TestCases){
           TEST_CHECK(*it == nestedFile);
           ec = GetTestEC();
           it.increment(ec);
         }
         TEST_CHECK(!ec);
         TEST_CHECK(it == EndIt);
       } else {
         TEST_CHECK(ec);
-        TEST_CHECK(ec == eacess_ec);
+        TEST_CHECK(ErrorIs(ec, eacess));
         TEST_CHECK(it == EndIt);
       }
     }
 }
 
 
 TEST_SUITE_END()

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

 TEST_CASE(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(ec == std::make_error_code(std::errc::is_a_directory));
+        TEST_CHECK(ErrorIs(ec, std::errc::is_a_directory));
         TEST_CHECK(!exists(dest));
         TEST_CHECK(!is_symlink(dest));
     }
     {
         std::error_code ec = GetTestEC();
         fs::copy(dir, dest, copy_options::create_symlinks|copy_options::recursive, ec);
-        TEST_CHECK(ec == std::make_error_code(std::errc::is_a_directory));
+        TEST_CHECK(ErrorIs(ec, std::errc::is_a_directory));
         TEST_CHECK(!exists(dest));
         TEST_CHECK(!is_symlink(dest));
     }
 }
 
 TEST_CASE(test_otherwise_no_effects_clause)
 {
     scoped_test_env env;

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

#else
         // On linux symlink permissions are not supported. The error code should
         // 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);
-        TEST_CHECK(ec == expected_ec);
+        if (expected_ec)
+            TEST_CHECK(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);
     }
 }
 
 TEST_SUITE_END()

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

TEST_CASE(signature_test)
     std::error_code ec; ((void)ec);
     ASSERT_NOT_NOEXCEPT(status(p));
     ASSERT_NOEXCEPT(status(p, ec));
 }
 
 TEST_CASE(test_status_not_found)
 {
     static_test_env static_env;
-    const std::error_code expect_ec =
-        std::make_error_code(std::errc::no_such_file_or_directory);
+    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(ec == expect_ec);
+        TEST_CHECK(ErrorIs(ec, expect_errc));
         TEST_CHECK(st.type() == file_type::not_found);
         TEST_CHECK(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_CASE(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::error_code set_ec =
-        std::make_error_code(std::errc::address_in_use);
-    const std::error_code perm_ec =
-        std::make_error_code(std::errc::permission_denied);
-    const std::error_code name_too_long_ec =
-        std::make_error_code(std::errc::filename_too_long);
+    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::error_code expect_ec;
+      std::errc expect_errc;
     } const TestCases[] = {
-      {file, perm_ec},
-      {sym, perm_ec},
-      {path(std::string(2500, 'a')), name_too_long_ec}
+      {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 = set_ec;
+            std::error_code ec = std::make_error_code(set_errc);
             file_status st = status(TC.p, ec);
-            TEST_CHECK(ec == TC.expect_ec);
+            TEST_CHECK(ErrorIs(ec, TC.expect_errc));
             TEST_CHECK(st.type() == file_type::none);
             TEST_CHECK(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(err.code() == TC.expect_ec);
+                TEST_CHECK(ErrorIs(err.code(), TC.expect_errc));
             }
         }
 #endif
     }
 }
 
 TEST_CASE(status_file_types_test)
 {

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

TEST_CASE(signature_test)
     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_test_env static_env;
-    const std::error_code expect_ec =
-        std::make_error_code(std::errc::no_such_file_or_directory);
+    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(ec == expect_ec);
+        TEST_CHECK(ErrorIs(ec, expect_errc));
         TEST_CHECK(st.type() == file_type::not_found);
         TEST_CHECK(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_CASE(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::error_code set_ec =
-        std::make_error_code(std::errc::address_in_use);
-    const std::error_code expect_ec =
-        std::make_error_code(std::errc::permission_denied);
+    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 = set_ec;
+            std::error_code ec = std::make_error_code(set_errc);
             file_status st = symlink_status(p, ec);
-            TEST_CHECK(ec == expect_ec);
+            TEST_CHECK(ErrorIs(ec, expect_errc));
             TEST_CHECK(st.type() == file_type::none);
             TEST_CHECK(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(err.code() == expect_ec);
+                TEST_CHECK(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 = set_ec;
+        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);
         // 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);

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

 TEST_CASE(basic_tests)
 {
     scoped_test_env env;
     const path dne = env.make_env_path("dne");
     const path file = env.create_file("file", 42);
     const path dir_perms = env.create_dir("bad_perms_dir");
     const path nested_dir = env.create_dir("bad_perms_dir/nested");
     permissions(dir_perms, perms::none);
-    const std::error_code expect_ec = std::make_error_code(std::errc::not_a_directory);
+    LIBCPP_ONLY(const std::errc expect_errc = std::errc::not_a_directory);
     struct TestCase {
       std::string name;
       path p;
     } cases[] = {
         {"TMPDIR", env.create_dir("dir1")},
         {"TMP", env.create_dir("dir2")},
         {"TEMP", env.create_dir("dir3")},
         {"TEMPDIR", env.create_dir("dir4")}
     };
     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));
 
         // 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(ec == expect_ec));
+        LIBCPP_ONLY(TEST_CHECK(ErrorIs(ec, expect_errc)));
         TEST_CHECK(ec != GetTestEC());
         TEST_CHECK(ec);
         TEST_CHECK(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(ec == expect_ec));
+        LIBCPP_ONLY(TEST_CHECK(ErrorIs(ec, expect_errc)));
         TEST_CHECK(ec != GetTestEC());
         TEST_CHECK(ec);
         TEST_CHECK(ret == "");
 
         // Set the env variable to point to a dir we can't access
         PutEnv(TC.name, nested_dir);
         ec = GetTestEC();
         ret = temp_directory_path(ec);
-        TEST_CHECK(ec == std::make_error_code(std::errc::permission_denied));
+        TEST_CHECK(ErrorIs(ec, std::errc::permission_denied));
         TEST_CHECK(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);

libcxx/test/support/filesystem_test_helper.h

default:
       std::abort();
     }
   };
   return std::make_error_code(GetErrc());
 }
 
 inline bool ErrorIsImp(const std::error_code& ec,
                        std::vector<std::errc> const& errors) {
+  std::error_condition cond = ec.default_error_condition();
   for (auto errc : errors) {
-    if (ec == std::make_error_code(errc))
+    if (cond.value() == static_cast<int>(errc))
       return true;
   }
   return false;
 }
 
 template <class... ErrcT>
 inline bool ErrorIs(const std::error_code& ec, std::errc First, ErrcT... Rest) {
   std::vector<std::errc> errors = {First, Rest...};