Add filesystem semantic edge coverage

Author: ntoskrnl7

docs/feature-coverage.md

@@ -372,6 +372,10 @@ are tracked in the [cppreference attribution note](./cppreference-attribution.md
   [(cppreference example)](../test/cmake/driver/src/cpp/stl/filesystem.cpp)
 - [x] [std::filesystem::canonical / weakly_canonical](https://en.cppreference.com/w/cpp/filesystem/canonical)
   [(cppreference example)](../test/cmake/driver/src/cpp/stl/filesystem.cpp)
+- [x] `std::filesystem` semantic edge checks
+  - Error-code overloads, metadata refresh after file changes, and recursive
+    traversal pruning are covered by driver semantic tests.
+  [(driver semantic test)](../test/cmake/driver/src/cpp/stl/filesystem.cpp)
 - [x] [std::string](https://en.cppreference.com/w/cpp/string/basic_string)
   [(cppreference example)](../test/cmake/driver/src/cpp/stl/string.cpp)
 - [x] String member operations:
@@ -560,10 +564,6 @@ semantics beyond the simple standalone examples.
   - Timed shared-lock behavior.
   - Additional `std::future` / `std::shared_future` error-path and timeout
     behavior.
-- [ ] Filesystem edge coverage
-  - More error-code overloads, metadata transitions, recursive traversal
-    options, and negative-path behavior for already-covered filesystem
-    operations.
 
 ### Needs Investigation
 

docs/ko-kr-feature-coverage.md

@@ -371,6 +371,10 @@ cppreference Example 코드를 이식한 항목은
   [(cppreference example)](../test/cmake/driver/src/cpp/stl/filesystem.cpp)
 - [x] [std::filesystem::canonical / weakly_canonical](https://en.cppreference.com/w/cpp/filesystem/canonical)
   [(cppreference example)](../test/cmake/driver/src/cpp/stl/filesystem.cpp)
+- [x] `std::filesystem` semantic edge check
+  - Error-code overload, file 변경 후 metadata refresh, recursive traversal
+    pruning은 driver semantic test로 검증합니다.
+  [(driver semantic test)](../test/cmake/driver/src/cpp/stl/filesystem.cpp)
 - [x] [std::string](https://en.cppreference.com/w/cpp/string/basic_string)
   [(cppreference example)](../test/cmake/driver/src/cpp/stl/string.cpp)
 - [x] String member operation:
@@ -558,10 +562,6 @@ standalone 예제보다 더 넓은 driver-runtime error path나 timing-sensitive
 - [ ] Threading 및 synchronization
   - timed shared-lock 동작
   - `std::future` / `std::shared_future` error-path 및 timeout 동작
-- [ ] Filesystem edge coverage
-  - 이미 coverage된 filesystem operation의 error-code overload,
-    metadata transition, recursive traversal option, negative-path 동작
-    보강
 
 ### 추가 조사가 필요한 후보
 

test/cmake/driver/src/all.cpp

@@ -352,6 +352,9 @@ void run();
 namespace filesystem_canonical_test {
 void run();
 }
+namespace filesystem_semantic_edge_test {
+void run();
+}
 namespace forward_list_insert_after_test {
 void run();
 }
@@ -688,6 +691,12 @@ template <typename Fn> void run_cppreference_test(const char *name, Fn fn) {
   fn();
   std::cout << "[crtsys] PASS " << name << '\n';
 }
+
+template <typename Fn> void run_driver_semantic_test(const char *name, Fn fn) {
+  std::cout << "\n[crtsys] RUN " << name << " (driver semantic)\n";
+  fn();
+  std::cout << "[crtsys] PASS " << name << '\n';
+}
 } // namespace
 
 #define CRTSYS_RUN_CPPREFERENCE_TEST(test_namespace)                           \
@@ -697,6 +706,9 @@ template <typename Fn> void run_cppreference_test(const char *name, Fn fn) {
   run_cppreference_test(#test_namespace,                                      \
                         [] { ntl::expand_stack(test_namespace::run); })
 
+#define CRTSYS_RUN_DRIVER_SEMANTIC_TEST(test_namespace)                        \
+  run_driver_semantic_test(#test_namespace, [] { test_namespace::run(); })
+
 //
 // C++ Standard tests.
 //
@@ -834,6 +846,7 @@ void cpp_std_tests() {
   CRTSYS_RUN_CPPREFERENCE_TEST(filesystem_relative_test);
   CRTSYS_RUN_CPPREFERENCE_TEST(filesystem_last_write_time_test);
   CRTSYS_RUN_CPPREFERENCE_TEST(filesystem_canonical_test);
+  CRTSYS_RUN_DRIVER_SEMANTIC_TEST(filesystem_semantic_edge_test);
   CRTSYS_RUN_CPPREFERENCE_TEST(sort_test);
   CRTSYS_RUN_CPPREFERENCE_TEST(find_test);
   CRTSYS_RUN_CPPREFERENCE_TEST(transform_test);

test/cmake/driver/src/cpp/stl/filesystem.cpp

@@ -638,3 +638,108 @@ void run() {
   std::cout << "Deleted " << count << " files or directories.\n";
 }
 } // namespace filesystem_canonical_test
+
+namespace filesystem_semantic_edge_test {
+void run() {
+  const fs::path sandbox{"sandbox"};
+  remove_sandbox(sandbox);
+
+  const bool created_sandbox = fs::create_directory(sandbox);
+  (void)created_sandbox;
+  assert(created_sandbox);
+
+  std::error_code ec;
+  const fs::path missing = sandbox / "missing.txt";
+  const fs::path target = sandbox / "target.txt";
+
+  const bool copied_missing = fs::copy_file(missing, target, ec);
+  (void)copied_missing;
+  assert(!copied_missing);
+  assert(ec);
+
+  bool caught_copy_error{};
+  try {
+    fs::copy_file(missing, target);
+  } catch (const fs::filesystem_error &ex) {
+    caught_copy_error = true;
+    assert(ex.code());
+    std::cout << "copy_file missing source reported: " << ex.what() << '\n';
+  }
+  assert(caught_copy_error);
+  // Release builds compile out assert(), so mark assert-only locals as used.
+  (void)caught_copy_error;
+
+  ec.clear();
+  fs::rename(missing, target, ec);
+  assert(ec);
+
+  ec.clear();
+  const bool removed_missing = fs::remove(missing, ec);
+  (void)removed_missing;
+  assert(!ec);
+  assert(!removed_missing);
+
+  const fs::path metadata_file = sandbox / "metadata.txt";
+  std::ofstream(metadata_file) << "ab";
+  fs::directory_entry entry{metadata_file};
+  assert(entry.exists());
+  assert(entry.is_regular_file());
+  assert(entry.file_size() == 2);
+
+  fs::resize_file(metadata_file, 5, ec);
+  assert(!ec);
+  entry.refresh(ec);
+  assert(!ec);
+  assert(entry.file_size() == 5);
+
+  fs::remove(metadata_file, ec);
+  assert(!ec);
+  entry.refresh(ec);
+  assert(!entry.exists());
+
+  fs::create_directories(sandbox / "a" / "b");
+  fs::create_directory(sandbox / "c");
+  std::ofstream(sandbox / "root.txt").put('r');
+  std::ofstream(sandbox / "a" / "one.txt").put('1');
+  std::ofstream(sandbox / "a" / "b" / "two.txt").put('2');
+  std::ofstream(sandbox / "c" / "three.txt").put('3');
+
+  std::uintmax_t full_recursive_entries{};
+  for (auto it = fs::recursive_directory_iterator{sandbox};
+       it != fs::recursive_directory_iterator{}; ++it) {
+    ++full_recursive_entries;
+  }
+  assert(full_recursive_entries == 7);
+  // Release builds compile out assert(), so mark assert-only locals as used.
+  (void)full_recursive_entries;
+
+  bool saw_pruned_dir{};
+  bool saw_pruned_child{};
+  bool saw_sibling_child{};
+  std::uintmax_t pruned_recursive_entries{};
+  for (auto it = fs::recursive_directory_iterator{sandbox};
+       it != fs::recursive_directory_iterator{}; ++it) {
+    if (it->path().filename() == "a") {
+      saw_pruned_dir = true;
+      it.disable_recursion_pending();
+    }
+    saw_pruned_child = saw_pruned_child || it->path().filename() == "two.txt";
+    saw_sibling_child =
+        saw_sibling_child || it->path().filename() == "three.txt";
+    ++pruned_recursive_entries;
+  }
+
+  assert(saw_pruned_dir);
+  assert(!saw_pruned_child);
+  assert(saw_sibling_child);
+  assert(pruned_recursive_entries == 4);
+  // Release builds compile out assert(), so mark assert-only locals as used.
+  (void)saw_pruned_dir;
+  (void)saw_pruned_child;
+  (void)saw_sibling_child;
+  (void)pruned_recursive_entries;
+
+  remove_sandbox(sandbox);
+  std::cout << "filesystem semantic edge assertions passed\n";
+}
+} // namespace filesystem_semantic_edge_test