Improve P0218R1_filesystem test reliability and temp filename generation

tests/std/include/temp_file_name.hpp

@@ -7,11 +7,11 @@
 #include <string>
 
 [[nodiscard]] inline std::string temp_file_name() {
-    std::string ret{"temp_file_"};
+    std::string ret{"msvc_stl_"};
     std::uniform_int_distribution<int> dist{0, 15};
     std::random_device rd;
 
-    for (int i = 0; i < 64; ++i) { // 64 hexits = 256 bits of entropy
+    for (int i = 0; i < 32; ++i) { // 32 hexits = 128 bits of entropy
         ret.push_back("0123456789ABCDEF"[dist(rd)]);
     }
 

tests/std/include/test_filesystem_support.hpp

@@ -6,32 +6,31 @@
 #define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING
 
 #include <algorithm>
-#include <cstring>
 #include <experimental/filesystem>
 #include <filesystem>
 #include <iterator>
 #include <random>
 #include <string>
 
-inline std::string get_test_directory_subname(const char* const testName, const size_t testNameLength) {
+template <class T>
+std::string get_test_directory_subname(const T& testName) {
     using namespace std;
     random_device rd;
     uniform_int_distribution<> dist(0, 15);
-    string subName(testName, testNameLength);
+    string subName(testName);
     subName.push_back('_');
-    generate_n(back_inserter(subName), 16, [&] { return "0123456789ABCDEF"[dist(rd)]; });
+    generate_n(back_inserter(subName), 32, [&] { return "0123456789ABCDEF"[dist(rd)]; });
     return subName;
 }
 
-inline std::experimental::filesystem::path get_test_directory(const char* const testName) {
-    return std::experimental::filesystem::temp_directory_path()
-         / get_test_directory_subname(testName, strlen(testName));
+inline std::experimental::filesystem::path get_experimental_test_directory(const char* const testName) {
+    return std::experimental::filesystem::temp_directory_path() / get_test_directory_subname(testName);
 }
 
 #if _HAS_CXX17
 #include <string_view>
 
-inline std::filesystem::path get_new_test_directory(std::string_view testName) {
-    return std::filesystem::temp_directory_path() / get_test_directory_subname(testName.data(), testName.size());
+inline std::filesystem::path get_test_directory(std::string_view testName) {
+    return std::filesystem::temp_directory_path() / get_test_directory_subname(testName);
 }
 #endif // _HAS_CXX17

tests/std/tests/Dev11_1066931_filesystem_rename_noop/test.cpp

@@ -345,7 +345,7 @@ int main() {
     error_code ec;
     const auto previousCd = fs::current_path(ec);
     assert_success(ec);
-    const auto testDir = get_test_directory("filesystem_rename_noop");
+    const auto testDir = get_experimental_test_directory("filesystem_rename_noop");
     printf("changing directory to \"%ls\"\n", testDir.native().c_str());
     fs::create_directory(testDir, ec);
     assert_success(ec);

tests/std/tests/P0218R1_filesystem/test.cpp

@@ -53,10 +53,10 @@ template <typename Elem, typename Traits>
     return str.size() >= prefix.size() && Traits::compare(str.data(), prefix.data(), prefix.size()) == 0;
 }
 
-struct test_temp_directory {
-    error_code ec;
+struct [[nodiscard]] test_temp_directory {
     path directoryPath;
-    explicit test_temp_directory(const string_view testName) : directoryPath(get_new_test_directory(testName)) {
+    explicit test_temp_directory(const string_view testName) : directoryPath(get_test_directory(testName)) {
+        error_code ec;
         remove_all(directoryPath, ec);
         if (ec) {
             wcerr << L"Warning, couldn't clean up " << directoryPath << L" before test.\n";
@@ -68,7 +68,11 @@ struct test_temp_directory {
         }
     }
 
+    test_temp_directory(const test_temp_directory&)            = delete;
+    test_temp_directory& operator=(const test_temp_directory&) = delete;
+
     ~test_temp_directory() noexcept {
+        error_code ec;
         remove_all(directoryPath, ec);
         if (ec) {
             wcerr << L"Warning, couldn't clean up " << directoryPath << L" after test.\n";
@@ -1420,8 +1424,8 @@ void test_recursive_directory_iterator() {
     test_directory_iterator_common_parts<recursive_directory_iterator>("recursive_directory_iterator"sv);
 
     {
-        const test_temp_directory recursiveTests("recursive_directory_iterator specific"sv);
-        create_file_containing(recursiveTests.directoryPath / L"a.txt"sv, L"hello");
+        const test_temp_directory tempDir("recursive_directory_iterator-specific"sv);
+        create_file_containing(tempDir.directoryPath / L"a.txt"sv, L"hello");
 
         // _NODISCARD directory_options  options() const;
         // _NODISCARD int                depth() const;
@@ -1430,19 +1434,19 @@ void test_recursive_directory_iterator() {
         // void disable_recursion_pending();
         {
             error_code ec;
-            recursive_directory_iterator good_dir(recursiveTests.directoryPath, directory_options::none, ec);
+            recursive_directory_iterator good_dir(tempDir.directoryPath, directory_options::none, ec);
             if (!EXPECT(good(ec))) {
                 return;
             }
 
             EXPECT(good_dir.options() == directory_options::none);
 
             recursive_directory_iterator good_dir2(
-                recursiveTests.directoryPath, directory_options::skip_permission_denied, ec);
+                tempDir.directoryPath, directory_options::skip_permission_denied, ec);
             EXPECT(good_dir2.options() == directory_options::skip_permission_denied);
 
             recursive_directory_iterator good_dir3(
-                recursiveTests.directoryPath, directory_options::follow_directory_symlink, ec);
+                tempDir.directoryPath, directory_options::follow_directory_symlink, ec);
             EXPECT(good_dir3.options() == directory_options::follow_directory_symlink);
 
             EXPECT(good_dir.depth() == 0);
@@ -1461,7 +1465,7 @@ void test_recursive_directory_iterator() {
 
         // void pop();
         {
-            recursive_directory_iterator good_dir(recursiveTests.directoryPath, directory_options::none);
+            recursive_directory_iterator good_dir(tempDir.directoryPath, directory_options::none);
             good_dir.pop();
             EXPECT(good_dir == recursive_directory_iterator{});
         }
@@ -1481,10 +1485,10 @@ void test_recursive_directory_iterator() {
 
     // Also test VSO-649431 <filesystem> follow_directory_symlinks with a broken symlink causes iteration to break
     {
-        const test_temp_directory followSymlinkTests("recursive_directory_iterator_VSO-649431"sv);
-        const path aaa = followSymlinkTests.directoryPath / L"aaa"sv;
-        const path bbb = followSymlinkTests.directoryPath / L"bbb"sv;
-        const path ccc = followSymlinkTests.directoryPath / L"ccc"sv;
+        const test_temp_directory tempDir("recursive_directory_iterator-VSO-649431"sv);
+        const path aaa = tempDir.directoryPath / L"aaa"sv;
+        const path bbb = tempDir.directoryPath / L"bbb"sv;
+        const path ccc = tempDir.directoryPath / L"ccc"sv;
         error_code ec;
         create_directory_symlink(nonexistentPaths[0], bbb, ec);
         if (ec) {
@@ -1496,7 +1500,7 @@ void test_recursive_directory_iterator() {
                 directory_options::follow_directory_symlink, directory_options::skip_permission_denied,
                 directory_options::follow_directory_symlink | directory_options::skip_permission_denied};
             for (const auto& option : options) {
-                recursive_directory_iterator first(followSymlinkTests.directoryPath, option);
+                recursive_directory_iterator first(tempDir.directoryPath, option);
                 assert(first != recursive_directory_iterator{});
                 EXPECT(first->is_directory());
                 EXPECT(!first->is_symlink());
@@ -2883,7 +2887,7 @@ void test_invalid_conversions() {
 }
 
 void test_status() {
-    const test_temp_directory tempDir("test_status"sv);
+    const test_temp_directory tempDir("status"sv);
     const path& testDir = tempDir.directoryPath;
     const path testFile(testDir / L"test_file"sv);
     const path testLink(testDir / L"test_link"sv);
@@ -3328,9 +3332,9 @@ void test_rename() {
     const path fileA(tempDir.directoryPath / L"filea.txt"sv);
     const path fileB(tempDir.directoryPath / L"fileb.txt"sv);
 
-    create_directories(dir.native(), ec);
+    create_directories(dir, ec);
     EXPECT(good(ec));
-    create_directory(otherDir.native(), ec);
+    create_directory(otherDir, ec);
     EXPECT(good(ec));
     create_file_containing(fileA, L"hello");
     create_file_containing(fileB, L"world");
@@ -3342,15 +3346,26 @@ void test_rename() {
     EXPECT(good(ec));
     EXPECT(read_file_contents(fileA) == L"hello");
 
+#ifndef _MSVC_INTERNAL_TESTING // TRANSITION, skip this for all MSVC-internal test runs.
+    // As of 2024-05-09, these rename() tests sporadically fail in MSVC-internal private test runs with
+    // "Access is denied" error codes. We've never observed such failures in MSVC-internal PR/CI checks,
+    // MSVC-internal local test runs, GitHub PR/CI checks, or GitHub local test runs. There's no significant
+    // compiler interaction here, so we can live with GitHub-only test coverage. Although we don't know the
+    // root cause, we suspect that this is related to the physical machines that are used for MSVC-internal
+    // private test runs, so we should check whether they've been replaced in a year or two.
+
     // If new_p resolves to an existing non-directory file, new_p is removed
     rename(fileA, fileB, ec);
     EXPECT(good(ec));
-    EXPECT(!exists(fileA.native()));
+    EXPECT(!exists(fileA));
     EXPECT(read_file_contents(fileB) == L"hello");
 
     // Standard rename where target doesn't exist
-    rename(fileB, fileA);
+    rename(fileB, fileA, ec);
+    EXPECT(good(ec));
+    EXPECT(!exists(fileB));
     EXPECT(read_file_contents(fileA) == L"hello");
+#endif // ^^^ no workaround ^^^
 
     // Bad cases
     EXPECT(throws_filesystem_error([&] { rename(dir, otherDir); }, "rename", dir, otherDir));
@@ -3364,7 +3379,7 @@ void test_space() {
     const path file(dir / L"test_space_file.txt"sv);
 
     error_code ec;
-    create_directory(dir.native(), ec);
+    create_directory(dir, ec);
     EXPECT(good(ec));
     create_file_containing(file, L"hello");
 
@@ -3643,7 +3658,7 @@ void test_create_directory() {
 }
 
 void test_create_dirs_and_remove_all() {
-    const test_temp_directory tempDir("create_dirs_and_remove_all"sv);
+    const test_temp_directory tempDir("create_directories-and-remove_all"sv);
     const path& r = tempDir.directoryPath;
 
     // test long path support

tests/std/tests/VSO_0000000_path_stream_parameter/test.cpp

@@ -18,7 +18,7 @@ int main() {
     error_code ec;
 
     {
-        const auto testDir = get_test_directory("path_stream_parameter");
+        const auto testDir = get_experimental_test_directory("path_stream_parameter");
         fs::create_directories(testDir, ec);
         assert(!ec);
 
@@ -81,7 +81,7 @@ int main() {
 
 #if _HAS_CXX17
     {
-        const auto testDir = get_new_test_directory("path_stream_parameter");
+        const auto testDir = get_test_directory("path_stream_parameter");
         fs::create_directories(testDir.native(), ec);
         assert(!ec);
 

tests/tr1/tests/cstdio/test.cpp

@@ -5,13 +5,14 @@
 #define TEST_NAMEX "<cstdio>"
 
 #include "tdefs.h"
-#include "temp_file_name.h"
 #include <assert.h>
 #include <cstdio>
 #include <errno.h>
 #include <stdarg.h>
 #include <string.h>
 
+#include <temp_file_name.hpp>
+
 #undef clearerr // tested in stdio2.c
 #undef feof
 #undef ferror

tests/tr1/tests/cwchar1/test.cpp

@@ -5,13 +5,14 @@
 #define TEST_NAMEX "<cwchar>, part 1"
 
 #include "tdefs.h"
-#include "temp_file_name.h"
 #include <assert.h>
 #include <cwchar>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include <temp_file_name.hpp>
+
 #pragma warning(disable : 4793) // function compiled as native
 
 

tests/tr1/tests/fstream1/test.cpp

@@ -5,11 +5,12 @@
 #define TEST_NAME "<fstream>, part 1"
 
 #include "tdefs.h"
-#include "temp_file_name.h"
 #include <assert.h>
 #include <fstream>
 #include <string>
 
+#include <temp_file_name.hpp>
+
 void test_main() { // test basic workings of char fstream definitions
     STD string tn_str = temp_file_name();
     const char* tn    = tn_str.c_str();

tests/tr1/tests/fstream2/test.cpp

@@ -5,11 +5,12 @@
 #define TEST_NAME "<fstream>, part 2"
 
 #include "tdefs.h"
-#include "temp_file_name.h"
 #include <assert.h>
 #include <fstream>
 #include <wchar.h>
 
+#include <temp_file_name.hpp>
+
 void test_main() { // test basic workings of wide fstream definitions
     const auto temp_name = temp_file_name();
     const char* tn       = temp_name.c_str();