tests/framework/util/folder_manager.cpp - third_party/Vulkan-Loader - Git at Google

 /*
  * Copyright (c) 2025 The Khronos Group Inc.
  * Copyright (c) 2025 Valve Corporation
  * Copyright (c) 2025 LunarG, Inc.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and/or associated documentation files (the "Materials"), to
  * deal in the Materials without restriction, including without limitation the
  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
  * sell copies of the Materials, and to permit persons to whom the Materials are
  * furnished to do so, subject to the following conditions:
  *
  * The above copyright notice(s) and this permission notice shall be included in
  * all copies or substantial portions of the Materials.
  *
  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  *
  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE
  * USE OR OTHER DEALINGS IN THE MATERIALS.
  *
  */

 #include "folder_manager.h"

 #include <algorithm>
 #include <fstream>

 #include "gtest/gtest.h"

 #include "util/json_writer.h"
 #include "util/env_var_wrapper.h"

 namespace fs {
 Folder::Folder(std::filesystem::path root_path, std::string name) noexcept : folder((root_path / name).lexically_normal()) {
     clear();
     // Don't actually create the folder yet, as we will do it on demand
 }
 Folder::~Folder() noexcept { clear(); }
 Folder::Folder(Folder&& other) noexcept : actually_created(other.actually_created), folder(other.folder) { other.folder.clear(); }
 Folder& Folder::operator=(Folder&& other) noexcept {
     folder = other.folder;
     actually_created = other.actually_created;
     other.folder.clear();
     return *this;
 }

 void Folder::check_if_first_use() {
     if (!actually_created) {
         if (!::testing::internal::InDeathTestChild()) {
             std::error_code err;
             if (!std::filesystem::create_directories(folder, err)) {
                 std::cerr << "Failed to create folder " << folder << " because " << err.message() << "\n";
             }
         }
         actually_created = true;
     }
 }

 std::filesystem::path Folder::write_manifest(std::filesystem::path const& name, std::string const& contents) {
     check_if_first_use();
     std::filesystem::path out_path = (folder / name).lexically_normal();
     if (!::testing::internal::InDeathTestChild()) {
         auto file = std::ofstream(out_path, std::ios_base::trunc | std::ios_base::out);
         if (!file) {
             std::cerr << "Failed to create manifest " << name << " at " << out_path << "\n";
             return out_path;
         }
         file << contents << std::endl;
     }
     insert_file_to_tracking(name);
     return out_path;
 }

 // close file handle, delete file, remove `name` from managed file list.
 void Folder::remove(std::filesystem::path const& name) {
     check_if_first_use();
     std::filesystem::path out_path = folder / name;
     if (!::testing::internal::InDeathTestChild()) {
         std::error_code err;
         if (!std::filesystem::remove(out_path, err)) {
             std::cerr << "Failed to remove file " << name << " at " << out_path << " because " << err.message() << "\n";
         }
     }

     auto found = std::find(added_files.begin(), added_files.end(), name);
     if (found != added_files.end()) {
         added_files.erase(found);
     } else {
         std::cout << "File " << name << " not in tracked files of folder " << folder << ".\n";
     }
 }

 // copy file into this folder
 std::filesystem::path Folder::copy_file(std::filesystem::path const& file, std::filesystem::path const& new_name) {
     check_if_first_use();
     insert_file_to_tracking(new_name);

     auto new_filepath = folder / new_name;
     if (!::testing::internal::InDeathTestChild()) {
         std::error_code err;
         if (!std::filesystem::copy_file(file, new_filepath, err)) {
             std::cerr << "Failed to copy file " << file << " to " << new_filepath << " because " << err.message() << "\n";
         }
     }
     return new_filepath;
 }

 std::vector<std::filesystem::path> Folder::get_files() const { return added_files; }

 std::filesystem::path Folder::add_symlink(std::filesystem::path const& target, std::filesystem::path const& link_name) {
     check_if_first_use();

     if (!::testing::internal::InDeathTestChild()) {
         std::error_code err;
         std::filesystem::create_symlink(target, folder / link_name, err);
         if (err.value() != 0) {
             std::cerr << "Failed to create symlink with target" << target << " with name " << folder / link_name << " because "
                       << err.message() << "\n";
         }
     }
     insert_file_to_tracking(link_name);
     return folder / link_name;
 }
 void Folder::insert_file_to_tracking(std::filesystem::path const& name) {
     auto found = std::find(added_files.begin(), added_files.end(), name);
     if (found != added_files.end()) {
         std::cout << "Overwriting manifest " << name << ". Was this intended?\n";
     } else {
         added_files.emplace_back(name);
     }
 }

 void Folder::clear() const noexcept {
     if (!::testing::internal::InDeathTestChild()) {
         std::error_code err;
         std::filesystem::remove_all(folder, err);
         if (err.value() != 0) {
             std::cerr << "Failed to remove folder " << folder << " because " << err.message() << "\n";
         }
     }
 }

 std::filesystem::path category_path_name(ManifestCategory category) {
     if (category == ManifestCategory::settings) return "settings.d";
     if (category == ManifestCategory::implicit_layer) return "implicit_layer.d";
     if (category == ManifestCategory::explicit_layer)
         return "explicit_layer.d";
     else
         return "icd.d";
 }

 FileSystemManager::FileSystemManager()
     : root_folder(std::filesystem::path(TEST_EXECUTION_DIRECTORY),
                   std::string(::testing::UnitTest::GetInstance()->GetInstance()->current_test_suite()->name()) + "_" +
                       ::testing::UnitTest::GetInstance()->current_test_info()->name()) {
     // Clean out test folder in case a previous run's files are still around
     root_folder.clear();

     auto const& root = root_folder.location();
     folders.try_emplace(ManifestLocation::null, root, std::string("null_dir"));
     folders.try_emplace(ManifestLocation::driver, root, std::string("icd_manifests"));
     folders.try_emplace(ManifestLocation::driver_env_var, root, std::string("icd_env_vars_manifests"));
     folders.try_emplace(ManifestLocation::explicit_layer, root, std::string("explicit_layer_manifests"));
     folders.try_emplace(ManifestLocation::explicit_layer_env_var, root, std::string("explicit_env_var_layer_folder"));
     folders.try_emplace(ManifestLocation::explicit_layer_add_env_var, root, std::string("explicit_add_env_var_layer_folder"));
     folders.try_emplace(ManifestLocation::implicit_layer, root, std::string("implicit_layer_manifests"));
     folders.try_emplace(ManifestLocation::implicit_layer_env_var, root, std::string("implicit_env_var_layer_manifests"));
     folders.try_emplace(ManifestLocation::implicit_layer_add_env_var, root, std::string("implicit_add_env_var_layer_manifests"));
     folders.try_emplace(ManifestLocation::override_layer, root, std::string("override_layer_manifests"));
 #if defined(_WIN32)
     folders.try_emplace(ManifestLocation::windows_app_package, root, std::string("app_package_manifests"));
 #endif
 #if defined(__APPLE__)
     folders.try_emplace(ManifestLocation::macos_bundle, root, std::string("macos_bundle"));
 #endif
     folders.try_emplace(ManifestLocation::settings_location, root, std::string("settings_location"));
     folders.try_emplace(ManifestLocation::unsecured_driver, root, std::string("unsecured_driver"));
     folders.try_emplace(ManifestLocation::unsecured_explicit_layer, root, std::string("unsecured_explicit_layer"));
     folders.try_emplace(ManifestLocation::unsecured_implicit_layer, root, std::string("unsecured_implicit_layer"));
     folders.try_emplace(ManifestLocation::unsecured_settings, root, std::string("unsecured_settings"));
 }

 fs::Folder& FileSystemManager::get_folder(ManifestLocation location) noexcept { return folders.at(location); }
 fs::Folder const& FileSystemManager::get_folder(ManifestLocation location) const noexcept { return folders.at(location); }

 Folder* FileSystemManager::get_folder_for_given_path(std::string_view given_path) noexcept {
     for (auto const& [manifest_location, folder] : folders) {
         if (folder.location() == given_path) {
             return &folders.at(manifest_location);
         }
     }
     for (auto const& [redirected_path, redirected_location] : redirected_paths) {
         if (redirected_path == given_path) {
             return &folders.at(redirected_location);
         }
         const auto mismatch_pair =
             std::mismatch(given_path.begin(), given_path.end(), redirected_path.begin(), redirected_path.end());
         if (mismatch_pair.second == redirected_path.end()) return &folders.at(redirected_location);
     }
     return nullptr;
 }

 bool FileSystemManager::is_folder_path(std::filesystem::path const& path) const noexcept {
     for (auto const& [location, folder] : folders) {
         if (path == folder.location()) {
             return true;
         }
     }
     return false;
 }

 void FileSystemManager::add_path_redirect(std::filesystem::path const& redirected_path, ManifestLocation location) {
     redirected_paths[redirected_path.string()] = location;
 }

 std::filesystem::path FileSystemManager::get_real_path_of_redirected_path(std::filesystem::path const& path) const {
     if (redirected_paths.count(path.string()) > 0) {
         return folders.at(redirected_paths.at(path.lexically_normal().string())).location();
     }
     for (auto const& [redirected_path_str, redirected_location] : redirected_paths) {
         std::filesystem::path redirected_path = redirected_path_str;
         const auto mismatch_pair = std::mismatch(path.begin(), path.end(), redirected_path.begin(), redirected_path.end());
         if (mismatch_pair.second == redirected_path.end()) return folders.at(redirected_location).location();
     }
     return std::filesystem::path{};
 }

 std::filesystem::path FileSystemManager::get_path_redirect_by_manifest_location(ManifestLocation location) const {
     for (auto const& [path, redirected_location] : redirected_paths) {
         if (redirected_location == location) {
             return path;
         }
     }
     return folders.at(ManifestLocation::null).location();
 }

 }  // namespace fs
	/*
	* Copyright (c) 2025 The Khronos Group Inc.
	* Copyright (c) 2025 Valve Corporation
	* Copyright (c) 2025 LunarG, Inc.
	*
	* Permission is hereby granted, free of charge, to any person obtaining a copy
	* of this software and/or associated documentation files (the "Materials"), to
	* deal in the Materials without restriction, including without limitation the
	* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
	* sell copies of the Materials, and to permit persons to whom the Materials are
	* furnished to do so, subject to the following conditions:
	*
	* The above copyright notice(s) and this permission notice shall be included in
	* all copies or substantial portions of the Materials.
	*
	* THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	*
	* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
	* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
	* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE
	* USE OR OTHER DEALINGS IN THE MATERIALS.
	*
	*/

	#include "folder_manager.h"

	#include <algorithm>
	#include <fstream>

	#include "gtest/gtest.h"

	#include "util/json_writer.h"
	#include "util/env_var_wrapper.h"

	namespace fs {
	Folder::Folder(std::filesystem::path root_path, std::string name) noexcept : folder((root_path / name).lexically_normal()) {
	clear();
	// Don't actually create the folder yet, as we will do it on demand
	}
	Folder::~Folder() noexcept { clear(); }
	Folder::Folder(Folder&& other) noexcept : actually_created(other.actually_created), folder(other.folder) { other.folder.clear(); }
	Folder& Folder::operator=(Folder&& other) noexcept {
	folder = other.folder;
	actually_created = other.actually_created;
	other.folder.clear();
	return *this;
	}

	void Folder::check_if_first_use() {
	if (!actually_created) {
	if (!::testing::internal::InDeathTestChild()) {
	std::error_code err;
	if (!std::filesystem::create_directories(folder, err)) {
	std::cerr << "Failed to create folder " << folder << " because " << err.message() << "\n";
	}
	}
	actually_created = true;
	}
	}

	std::filesystem::path Folder::write_manifest(std::filesystem::path const& name, std::string const& contents) {
	check_if_first_use();
	std::filesystem::path out_path = (folder / name).lexically_normal();
	if (!::testing::internal::InDeathTestChild()) {
	auto file = std::ofstream(out_path, std::ios_base::trunc \| std::ios_base::out);
	if (!file) {
	std::cerr << "Failed to create manifest " << name << " at " << out_path << "\n";
	return out_path;
	}
	file << contents << std::endl;
	}
	insert_file_to_tracking(name);
	return out_path;
	}

	// close file handle, delete file, remove `name` from managed file list.
	void Folder::remove(std::filesystem::path const& name) {
	check_if_first_use();
	std::filesystem::path out_path = folder / name;
	if (!::testing::internal::InDeathTestChild()) {
	std::error_code err;
	if (!std::filesystem::remove(out_path, err)) {
	std::cerr << "Failed to remove file " << name << " at " << out_path << " because " << err.message() << "\n";
	}
	}

	auto found = std::find(added_files.begin(), added_files.end(), name);
	if (found != added_files.end()) {
	added_files.erase(found);
	} else {
	std::cout << "File " << name << " not in tracked files of folder " << folder << ".\n";
	}
	}

	// copy file into this folder
	std::filesystem::path Folder::copy_file(std::filesystem::path const& file, std::filesystem::path const& new_name) {
	check_if_first_use();
	insert_file_to_tracking(new_name);

	auto new_filepath = folder / new_name;
	if (!::testing::internal::InDeathTestChild()) {
	std::error_code err;
	if (!std::filesystem::copy_file(file, new_filepath, err)) {
	std::cerr << "Failed to copy file " << file << " to " << new_filepath << " because " << err.message() << "\n";
	}
	}
	return new_filepath;
	}

	std::vector<std::filesystem::path> Folder::get_files() const { return added_files; }

	std::filesystem::path Folder::add_symlink(std::filesystem::path const& target, std::filesystem::path const& link_name) {
	check_if_first_use();

	if (!::testing::internal::InDeathTestChild()) {
	std::error_code err;
	std::filesystem::create_symlink(target, folder / link_name, err);
	if (err.value() != 0) {
	std::cerr << "Failed to create symlink with target" << target << " with name " << folder / link_name << " because "
	<< err.message() << "\n";
	}
	}
	insert_file_to_tracking(link_name);
	return folder / link_name;
	}
	void Folder::insert_file_to_tracking(std::filesystem::path const& name) {
	auto found = std::find(added_files.begin(), added_files.end(), name);
	if (found != added_files.end()) {
	std::cout << "Overwriting manifest " << name << ". Was this intended?\n";
	} else {
	added_files.emplace_back(name);
	}
	}

	void Folder::clear() const noexcept {
	if (!::testing::internal::InDeathTestChild()) {
	std::error_code err;
	std::filesystem::remove_all(folder, err);
	if (err.value() != 0) {
	std::cerr << "Failed to remove folder " << folder << " because " << err.message() << "\n";
	}
	}
	}

	std::filesystem::path category_path_name(ManifestCategory category) {
	if (category == ManifestCategory::settings) return "settings.d";
	if (category == ManifestCategory::implicit_layer) return "implicit_layer.d";
	if (category == ManifestCategory::explicit_layer)
	return "explicit_layer.d";
	else
	return "icd.d";
	}

	FileSystemManager::FileSystemManager()
	: root_folder(std::filesystem::path(TEST_EXECUTION_DIRECTORY),
	std::string(::testing::UnitTest::GetInstance()->GetInstance()->current_test_suite()->name()) + "_" +
	::testing::UnitTest::GetInstance()->current_test_info()->name()) {
	// Clean out test folder in case a previous run's files are still around
	root_folder.clear();

	auto const& root = root_folder.location();
	folders.try_emplace(ManifestLocation::null, root, std::string("null_dir"));
	folders.try_emplace(ManifestLocation::driver, root, std::string("icd_manifests"));
	folders.try_emplace(ManifestLocation::driver_env_var, root, std::string("icd_env_vars_manifests"));
	folders.try_emplace(ManifestLocation::explicit_layer, root, std::string("explicit_layer_manifests"));
	folders.try_emplace(ManifestLocation::explicit_layer_env_var, root, std::string("explicit_env_var_layer_folder"));
	folders.try_emplace(ManifestLocation::explicit_layer_add_env_var, root, std::string("explicit_add_env_var_layer_folder"));
	folders.try_emplace(ManifestLocation::implicit_layer, root, std::string("implicit_layer_manifests"));
	folders.try_emplace(ManifestLocation::implicit_layer_env_var, root, std::string("implicit_env_var_layer_manifests"));
	folders.try_emplace(ManifestLocation::implicit_layer_add_env_var, root, std::string("implicit_add_env_var_layer_manifests"));
	folders.try_emplace(ManifestLocation::override_layer, root, std::string("override_layer_manifests"));
	#if defined(_WIN32)
	folders.try_emplace(ManifestLocation::windows_app_package, root, std::string("app_package_manifests"));
	#endif
	#if defined(__APPLE__)
	folders.try_emplace(ManifestLocation::macos_bundle, root, std::string("macos_bundle"));
	#endif
	folders.try_emplace(ManifestLocation::settings_location, root, std::string("settings_location"));
	folders.try_emplace(ManifestLocation::unsecured_driver, root, std::string("unsecured_driver"));
	folders.try_emplace(ManifestLocation::unsecured_explicit_layer, root, std::string("unsecured_explicit_layer"));
	folders.try_emplace(ManifestLocation::unsecured_implicit_layer, root, std::string("unsecured_implicit_layer"));
	folders.try_emplace(ManifestLocation::unsecured_settings, root, std::string("unsecured_settings"));
	}

	fs::Folder& FileSystemManager::get_folder(ManifestLocation location) noexcept { return folders.at(location); }
	fs::Folder const& FileSystemManager::get_folder(ManifestLocation location) const noexcept { return folders.at(location); }

	Folder* FileSystemManager::get_folder_for_given_path(std::string_view given_path) noexcept {
	for (auto const& [manifest_location, folder] : folders) {
	if (folder.location() == given_path) {
	return &folders.at(manifest_location);
	}
	}
	for (auto const& [redirected_path, redirected_location] : redirected_paths) {
	if (redirected_path == given_path) {
	return &folders.at(redirected_location);
	}
	const auto mismatch_pair =
	std::mismatch(given_path.begin(), given_path.end(), redirected_path.begin(), redirected_path.end());
	if (mismatch_pair.second == redirected_path.end()) return &folders.at(redirected_location);
	}
	return nullptr;
	}

	bool FileSystemManager::is_folder_path(std::filesystem::path const& path) const noexcept {
	for (auto const& [location, folder] : folders) {
	if (path == folder.location()) {
	return true;
	}
	}
	return false;
	}

	void FileSystemManager::add_path_redirect(std::filesystem::path const& redirected_path, ManifestLocation location) {
	redirected_paths[redirected_path.string()] = location;
	}

	std::filesystem::path FileSystemManager::get_real_path_of_redirected_path(std::filesystem::path const& path) const {
	if (redirected_paths.count(path.string()) > 0) {
	return folders.at(redirected_paths.at(path.lexically_normal().string())).location();
	}
	for (auto const& [redirected_path_str, redirected_location] : redirected_paths) {
	std::filesystem::path redirected_path = redirected_path_str;
	const auto mismatch_pair = std::mismatch(path.begin(), path.end(), redirected_path.begin(), redirected_path.end());
	if (mismatch_pair.second == redirected_path.end()) return folders.at(redirected_location).location();
	}
	return std::filesystem::path{};
	}

	std::filesystem::path FileSystemManager::get_path_redirect_by_manifest_location(ManifestLocation location) const {
	for (auto const& [path, redirected_location] : redirected_paths) {
	if (redirected_location == location) {
	return path;
	}
	}
	return folders.at(ManifestLocation::null).location();
	}

	} // namespace fs