1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
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();
}
|
