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"));
}
int
main(int argc, char **argv)
{
DefaultFilesystem filesystem = DefaultFilesystem();
process::DefaultContext processContext = process::DefaultContext();
return acdriver::Driver::Run(&processContext, &filesystem);
}
int
main(int argc, char **argv, char **envp)
{
DefaultFilesystem filesystem = DefaultFilesystem();
process::DefaultContext processContext = process::DefaultContext();
builtin::infoPlistUtility::Driver driver;
return driver.run(&processContext, &filesystem);
}
int
main(int argc, char **argv)
{
DefaultFilesystem filesystem = DefaultFilesystem();
std::vector<std::string> args = std::vector<std::string>(argv + 1, argv + argc);
/*
* Parse out the options, or print help & exit.
*/
Options options;
std::pair<bool, std::string> result = libutil::Options::Parse<Options>(&options, args);
if (!result.first) {
return Help(result.second);
}
/*
* Handle the various actions.
*/
if (options.help()) {
return Help();
} else if (options.version()) {
return Version();
} else if (options.printPath()) {
ext::optional<std::string> developer = xcsdk::Environment::DeveloperRoot(&filesystem);
if (!developer) {
fprintf(stderr, "error: no developer directory found\n");
return 1;
}
fprintf(stdout, "%s\n", developer->c_str());
return 0;
} else if (options.resetPath()) {
if (!xcsdk::Environment::WriteDeveloperRoot(&filesystem, ext::nullopt)) {
fprintf(stderr, "error: failed to reset developer root. are you root?\n");
return 1;
}
return 0;
} else if (options.switchPath()) {
if (!xcsdk::Environment::WriteDeveloperRoot(&filesystem, *options.switchPath())) {
fprintf(stderr, "error: failed to set developer root. are you root?\n");
return 1;
}
return 0;
} else if (options.install()) {
fprintf(stderr, "error: install not implemented\n");
return 1;
} else {
return Help(std::string("no actions provided"));
}
}
int
main(int argc, char **argv)
{
DefaultFilesystem filesystem = DefaultFilesystem();
if (argc < 2) {
fprintf(stderr, "usage: %s path\n", argv[0]);
return -1;
}
std::string path = argv[1];
Manager::shared_ptr manager = Manager::Create();
manager->registerDomains(&filesystem, { { "xcspec", path } });
return 0;
}
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);
}
int
main(int argc, char **argv)
{
DefaultFilesystem filesystem = DefaultFilesystem();
process::DefaultContext processContext = process::DefaultContext();
/*
* Parse out the options, or print help & exit.
*/
Options options;
std::pair<bool, std::string> result = libutil::Options::Parse<Options>(&options, processContext.commandLineArguments());
if (!result.first) {
return Help(result.second);
}
/*
* Handle the basic options.
*/
if (options.help()) {
return Help();
} else if (options.version()) {
return Version();
}
/*
* Diagnose missing options.
*/
if (options.inputs().empty() || !options.output() || !options.name()) {
return Help("missing option(s)");
}
std::vector<std::string> inputs;
for (std::pair<dependency::DependencyInfoFormat, std::string> const &input : options.inputs()) {
/*
* Load the dependency info.
*/
std::vector<dependency::DependencyInfo> info;
if (!LoadDependencyInfo(&filesystem, input.second, input.first, &info)) {
return -1;
}
for (dependency::DependencyInfo const &dependencyInfo : info) {
inputs.insert(inputs.end(), dependencyInfo.inputs().begin(), dependencyInfo.inputs().end());
}
}
/*
* Serialize the output.
*/
std::string contents = SerializeMakefileDependencyInfo(processContext.currentDirectory(), *options.name(), inputs);
/*
* Write out the output.
*/
std::vector<uint8_t> makefileContents = std::vector<uint8_t>(contents.begin(), contents.end());
if (!filesystem.write(makefileContents, *options.output())) {
return false;
}
return 0;
}