TEST(copyStrings, CopyMultiple)
{
std::vector<uint8_t> contents;
MemoryFilesystem filesystem = MemoryFilesystem({
MemoryFilesystem::Entry::File("in1.strings", Contents("string1 = value1;")),
MemoryFilesystem::Entry::File("in2.strings", Contents("string2 = value2;")),
MemoryFilesystem::Entry::Directory("output", { }),
});
Driver driver;
EXPECT_EQ(0, driver.run({
"in1.strings",
"in2.strings",
"--outdir", "output",
"--outputencoding", "utf-8",
}, { }, &filesystem, "/"));
contents.clear();
EXPECT_TRUE(filesystem.read(&contents, "output/in1.strings"));
EXPECT_EQ(contents, Contents("string1 = value1;\n"));
contents.clear();
EXPECT_TRUE(filesystem.read(&contents, "output/in2.strings"));
EXPECT_EQ(contents, Contents("string2 = value2;\n"));
}
TEST(copyStrings, InputOutputEncoding)
{
std::unordered_map<std::string, plist::Format::Encoding> encodings = {
{ "utf-8", plist::Format::Encoding::UTF8 },
{ "utf-16", plist::Format::Encoding::UTF16LE },
{ "utf-32", plist::Format::Encoding::UTF32LE },
};
for (auto const &entry1 : encodings) {
for (auto const &entry2 : encodings) {
/* Convert input to each encoding. */
MemoryFilesystem filesystem = MemoryFilesystem({
MemoryFilesystem::Entry::File("in.strings", plist::Format::Encodings::Convert(
Contents("string = value;\n"),
plist::Format::Encoding::UTF8,
entry1.second
)),
MemoryFilesystem::Entry::Directory("output", { }),
});
Driver driver;
EXPECT_EQ(0, driver.run({
"in.strings",
"--outdir", "output",
"--inputencoding", entry1.first,
"--outputencoding", entry2.first,
}, { }, &filesystem, "/"));
std::vector<uint8_t> contents;
EXPECT_TRUE(filesystem.read(&contents, "output/in.strings"));
/* Expect output in each encoding. */
EXPECT_EQ(contents, plist::Format::Encodings::Convert(
Contents("string = value;\n"),
plist::Format::Encoding::UTF8,
entry2.second
));
}
}
}
TEST(DirectoryDependencyInfo, Deserialize)
{
MemoryFilesystem filesystem = MemoryFilesystem({
MemoryFilesystem::Entry::Directory("root", {
MemoryFilesystem::Entry::File("file1", { }),
MemoryFilesystem::Entry::File("file2", { }),
MemoryFilesystem::Entry::Directory("dir", {
MemoryFilesystem::Entry::File("file3", { }),
}),
}),
});
auto info = DirectoryDependencyInfo::Deserialize(&filesystem, "/root");
ASSERT_TRUE(info);
EXPECT_EQ(info->dependencyInfo().inputs(), std::vector<std::string>({
"/root/file1",
"/root/file2",
"/root/dir",
"/root/dir/file3",
}));
EXPECT_TRUE(info->dependencyInfo().outputs().empty());
}
TEST(SimpleExecutor, PropagateToolResult)
{
/* Create in-memory execution environment. */
auto filesystem = MemoryFilesystem({
MemoryFilesystem::Entry::File("fail-tool", std::vector<uint8_t>()),
MemoryFilesystem::Entry::File("success-tool", std::vector<uint8_t>()),
});
auto launcher = process::MemoryLauncher({
{ "/fail-tool", [](Filesystem *filesystem, process::Context const *context) -> ext::optional<int> {
return 1;
} },
{ "/success-tool", [](Filesystem *filesystem, process::Context const *context) -> ext::optional<int> {
return 0;
} },
});
auto registry = builtin::Registry::Create({
std::static_pointer_cast<builtin::Driver>(std::make_shared<Driver>("builtin-fail", [](process::Context const *context, Filesystem *filesystem) -> int {
return 1;
})),
std::static_pointer_cast<builtin::Driver>(std::make_shared<Driver>("builtin-success", [](process::Context const *context, Filesystem *filesystem) -> int {
return 0;
})),
});
auto context = process::MemoryContext(
"",
"/",
std::vector<std::string>(),
std::unordered_map<std::string, std::string>(),
0,
0,
"user",
"group");
/* Create invocations to execute. */
auto builtinSuccess = pbxbuild::Tool::Invocation();
builtinSuccess.executable() = pbxbuild::Tool::Invocation::Executable::Builtin("builtin-success");
auto builtinFail = pbxbuild::Tool::Invocation();
builtinFail.executable() = pbxbuild::Tool::Invocation::Executable::Builtin("builtin-fail");
auto externalSuccess = pbxbuild::Tool::Invocation();
externalSuccess.executable() = pbxbuild::Tool::Invocation::Executable::External("success-tool");
auto externalFail = pbxbuild::Tool::Invocation();
externalFail.executable() = pbxbuild::Tool::Invocation::Executable::External("fail-tool");
/* Create test executor. */
auto formatter = xcformatter::NullFormatter::Create();
std::vector<std::string> const executablePaths = { "/" };
SimpleExecutor executor = SimpleExecutor(formatter, false, registry);
/* Succeed if all tools succeed. */
auto success = executor.performInvocations(
&context,
&launcher,
&filesystem,
executablePaths,
{
builtinSuccess,
externalSuccess,
},
false);
ASSERT_TRUE(success.first);
EXPECT_EQ(success.second.size(), 0);
/* Fail if a tool fails. */
auto fail1 = executor.performInvocations(
&context,
&launcher,
&filesystem,
executablePaths,
{
externalFail,
builtinSuccess,
externalSuccess,
},
false);
ASSERT_FALSE(fail1.first);
EXPECT_EQ(fail1.second.size(), 1);
/* Fail if a tool fails, even if not first. */
auto fail2 = executor.performInvocations(
&context,
&launcher,
&filesystem,
executablePaths,
{
builtinSuccess,
builtinFail,
externalSuccess,
externalFail,
},
false);
ASSERT_FALSE(fail2.first);
EXPECT_EQ(fail2.second.size(), 1);
}