Fluorine Manager: full Linux port of Mod Organizer 2

Complete native Linux port with FUSE-based virtual filesystem,
Proton/umu-run integration, and Flatpak packaging.

Key features:
- FUSE VFS replacing Windows USVFS (in-process + standalone helper for Flatpak)
- Proton/GE-Proton/umu-run launcher with env var forwarding
- Flatpak support (sandbox-aware VFS, NXM handler, umu-run)
- Wine prefix management UI
- Case-insensitive path resolution for Linux filesystems
- QSettings-safe INI handling (avoids Bethesda INI corruption)
- Portable instance support with auto-generated launcher scripts

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

1 files changed, 122 insertions, 0 deletions

diff --git a/libs/usvfs/test/gtest_utils/gtest_utils.cpp b/libs/usvfs/test/gtest_utils/gtest_utils.cpp
new file mode 100644
index 0000000..f292dfd
--- /dev/null
+++ b/libs/usvfs/test/gtest_utils/gtest_utils.cpp
@@ -0,0 +1,122 @@
+#include "gtest_utils.h"
+
+// this file is shared by both usvfs_global_test and usvfs_global_test_runner
+//
+
+#include <filesystem>
+#include <format>
+#include <fstream>
+
+#include <boost/algorithm/string.hpp>
+
+#include <gtest/gtest.h>
+
+std::string trimmed(std::string content)
+{
+  boost::algorithm::trim(content);
+  return content;
+}
+
+// small utility to read files
+std::optional<std::string> read_content(const std::filesystem::path& path,
+                                        bool trim = true)
+{
+  std::ifstream ifs(path, std::ios::binary | std::ios::ate);
+
+  if (!ifs) {
+    return {};
+  }
+
+  const auto count = ifs.tellg();
+
+  std::string buffer(static_cast<std::size_t>(count), '\0');
+
+  ifs.seekg(0, std::ios::beg);
+  ifs.read(buffer.data(), count);
+
+  if (trim) {
+    boost::algorithm::trim(buffer);
+  }
+
+  return buffer;
+}
+
+::testing::AssertionResult AssertDirectoryEquals(const std::filesystem::path& expected,
+                                                 const std::filesystem::path& actual,
+                                                 bool content)
+{
+  std::vector<std::string> failure_messages;
+  std::vector<std::filesystem::path> in_both;
+
+  // iterate left, check on right
+  for (const auto& it : std::filesystem::recursive_directory_iterator{expected}) {
+    const auto relpath = relative(it.path(), expected);
+    if (!exists(actual / relpath)) {
+      failure_messages.push_back(
+          std::format("{} expected but not found", relpath.string()));
+    } else {
+      in_both.push_back(relpath);
+    }
+  }
+
+  // iterate right, check on left
+  for (const auto& it : std::filesystem::recursive_directory_iterator{actual}) {
+    const auto relpath = relative(it.path(), actual);
+    if (!exists(expected / relpath)) {
+      failure_messages.push_back(
+          std::format("{} found but not expected", relpath.string()));
+    }
+  }
+
+  // check contents
+  if (content) {
+    for (const auto& relpath : in_both) {
+      const auto expected_path = expected / relpath, actual_path = actual / relpath;
+
+      if (is_directory(expected_path) != is_directory(actual_path)) {
+        failure_messages.push_back(
+            std::format("{} type mismatch, expected {} but found {}", relpath.string(),
+                        is_directory(expected_path) ? "directory" : "file",
+                        is_directory(expected_path) ? "file" : "directory"));
+        continue;
+      }
+
+      if (is_directory(expected_path)) {
+        continue;
+      }
+
+      if (read_content(expected_path) != read_content(actual_path)) {
+        failure_messages.push_back(
+            std::format("{} content mismatch", relpath.string()));
+      }
+    }
+  }
+
+  if (failure_messages.empty()) {
+    return ::testing::AssertionSuccess();
+  }
+
+  return ::testing::AssertionFailure()
+         << "\n"
+         << boost::algorithm::join(failure_messages, "\n") << "\n";
+}
+
+::testing::AssertionResult AssertContentEquals(std::string_view expected,
+                                               const std::filesystem::path& path,
+                                               bool trim)
+{
+  const auto content = read_content(path, trim);
+
+  if (!content) {
+    return ::testing::AssertionFailure()
+           << "failed to open path '" << path.string() << "'";
+  }
+
+  if (*content != expected) {
+    return ::testing::AssertionFailure()
+           << "mismatch content for '" << path.string() << "', expected '" << expected
+           << "', found '" << *content << "'";
+  }
+
+  return ::testing::AssertionSuccess();
+}