You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
773 lines
21 KiB
773 lines
21 KiB
#include <algorithm>
|
|
#include <csignal>
|
|
#include <cstdio>
|
|
#include <functional>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include <cm/memory>
|
|
|
|
#include <cm3p/uv.h>
|
|
|
|
#include "cmGetPipes.h"
|
|
#include "cmStringAlgorithms.h"
|
|
#include "cmUVHandlePtr.h"
|
|
#include "cmUVProcessChain.h"
|
|
#include "cmUVStream.h"
|
|
#include "cmUVStreambuf.h"
|
|
|
|
struct ExpectedStatus
|
|
{
|
|
bool MatchExitStatus;
|
|
bool MatchTermSignal;
|
|
cmUVProcessChain::Status Status;
|
|
cmUVProcessChain::ExceptionCode ExceptionCode;
|
|
std::string ExceptionString;
|
|
};
|
|
|
|
static const char* ExceptionCodeToString(cmUVProcessChain::ExceptionCode code)
|
|
{
|
|
switch (code) {
|
|
case cmUVProcessChain::ExceptionCode::None:
|
|
return "None";
|
|
case cmUVProcessChain::ExceptionCode::Fault:
|
|
return "Fault";
|
|
case cmUVProcessChain::ExceptionCode::Illegal:
|
|
return "Illegal";
|
|
case cmUVProcessChain::ExceptionCode::Interrupt:
|
|
return "Interrupt";
|
|
case cmUVProcessChain::ExceptionCode::Numerical:
|
|
return "Numerical";
|
|
case cmUVProcessChain::ExceptionCode::Spawn:
|
|
return "Spawn";
|
|
case cmUVProcessChain::ExceptionCode::Other:
|
|
return "Other";
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
|
|
bool operator==(const cmUVProcessChain::Status* actual,
|
|
const ExpectedStatus& expected)
|
|
{
|
|
if (expected.Status.SpawnResult != actual->SpawnResult) {
|
|
return false;
|
|
}
|
|
if (expected.Status.Finished != actual->Finished) {
|
|
return false;
|
|
}
|
|
if (expected.MatchExitStatus &&
|
|
expected.Status.ExitStatus != actual->ExitStatus) {
|
|
return false;
|
|
}
|
|
if (expected.MatchTermSignal &&
|
|
expected.Status.TermSignal != actual->TermSignal) {
|
|
return false;
|
|
}
|
|
if (expected.Status.Finished &&
|
|
std::make_pair(expected.ExceptionCode, expected.ExceptionString) !=
|
|
actual->GetException()) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool resultsMatch(
|
|
const std::vector<const cmUVProcessChain::Status*>& actual,
|
|
const std::vector<ExpectedStatus>& expected)
|
|
{
|
|
return actual.size() == expected.size() &&
|
|
std::equal(actual.begin(), actual.end(), expected.begin());
|
|
}
|
|
|
|
static std::string getInput(std::istream& input)
|
|
{
|
|
char buffer[1024];
|
|
std::ostringstream str;
|
|
do {
|
|
input.read(buffer, 1024);
|
|
str.write(buffer, input.gcount());
|
|
} while (input.gcount() > 0);
|
|
return str.str();
|
|
}
|
|
|
|
template <typename T>
|
|
std::function<std::ostream&(std::ostream&)> printExpected(bool match,
|
|
const T& value)
|
|
{
|
|
return [match, value](std::ostream& stream) -> std::ostream& {
|
|
if (match) {
|
|
stream << value;
|
|
} else {
|
|
stream << "*";
|
|
}
|
|
return stream;
|
|
};
|
|
}
|
|
|
|
std::ostream& operator<<(
|
|
std::ostream& stream,
|
|
const std::function<std::ostream&(std::ostream&)>& func)
|
|
{
|
|
return func(stream);
|
|
}
|
|
|
|
static void printResults(
|
|
const std::vector<const cmUVProcessChain::Status*>& actual,
|
|
const std::vector<ExpectedStatus>& expected)
|
|
{
|
|
std::cout << "Expected: " << std::endl;
|
|
for (auto const& e : expected) {
|
|
std::cout << " SpawnResult: " << e.Status.SpawnResult
|
|
<< ", Finished: " << e.Status.Finished << ", ExitStatus: "
|
|
<< printExpected(e.MatchExitStatus, e.Status.ExitStatus)
|
|
<< ", TermSignal: "
|
|
<< printExpected(e.MatchTermSignal, e.Status.TermSignal)
|
|
<< ", ExceptionCode: "
|
|
<< printExpected(e.Status.Finished,
|
|
ExceptionCodeToString(e.ExceptionCode))
|
|
<< ", ExceptionString: \""
|
|
<< printExpected(e.Status.Finished, e.ExceptionString) << '"'
|
|
<< std::endl;
|
|
}
|
|
std::cout << "Actual:" << std::endl;
|
|
for (auto const& a : actual) {
|
|
auto exception = a->GetException();
|
|
std::cout << " SpawnResult: " << a->SpawnResult
|
|
<< ", Finished: " << a->Finished
|
|
<< ", ExitStatus: " << a->ExitStatus
|
|
<< ", TermSignal: " << a->TermSignal
|
|
<< ", ExceptionCode: " << ExceptionCodeToString(exception.first)
|
|
<< ", ExceptionString: \"" << exception.second << '"'
|
|
<< std::endl;
|
|
}
|
|
}
|
|
|
|
static bool checkExecution(cmUVProcessChainBuilder& builder,
|
|
std::unique_ptr<cmUVProcessChain>& chain)
|
|
{
|
|
static const std::vector<ExpectedStatus> status1 = {
|
|
{ false,
|
|
false,
|
|
{ 0, false, 0, 0 },
|
|
cmUVProcessChain::ExceptionCode::None,
|
|
"" },
|
|
{ false,
|
|
false,
|
|
{ 0, false, 0, 0 },
|
|
cmUVProcessChain::ExceptionCode::None,
|
|
"" },
|
|
{ false,
|
|
false,
|
|
{ 0, false, 0, 0 },
|
|
cmUVProcessChain::ExceptionCode::None,
|
|
"" },
|
|
};
|
|
|
|
static const std::vector<ExpectedStatus> status2 = {
|
|
{ true,
|
|
true,
|
|
{ 0, true, 0, 0 },
|
|
cmUVProcessChain::ExceptionCode::None,
|
|
"" },
|
|
{ false,
|
|
false,
|
|
{ 0, false, 0, 0 },
|
|
cmUVProcessChain::ExceptionCode::None,
|
|
"" },
|
|
{ false,
|
|
false,
|
|
{ 0, false, 0, 0 },
|
|
cmUVProcessChain::ExceptionCode::None,
|
|
"" },
|
|
};
|
|
|
|
static const std::vector<ExpectedStatus> status3 = {
|
|
{ true,
|
|
true,
|
|
{ 0, true, 0, 0 },
|
|
cmUVProcessChain::ExceptionCode::None,
|
|
"" },
|
|
{ true,
|
|
true,
|
|
{ 0, true, 1, 0 },
|
|
cmUVProcessChain::ExceptionCode::None,
|
|
"" },
|
|
#ifdef _WIN32
|
|
{ true,
|
|
true,
|
|
{ 0, true, STATUS_ACCESS_VIOLATION, 0 },
|
|
cmUVProcessChain::ExceptionCode::Fault,
|
|
"Access violation" },
|
|
#else
|
|
{ false,
|
|
true,
|
|
{ 0, true, 0, SIGABRT },
|
|
cmUVProcessChain::ExceptionCode::Other,
|
|
"Subprocess aborted" },
|
|
#endif
|
|
};
|
|
|
|
std::vector<const cmUVProcessChain::Status*> status;
|
|
|
|
chain = cm::make_unique<cmUVProcessChain>(builder.Start());
|
|
if (!chain->Valid()) {
|
|
std::cout << "Valid() returned false, should be true" << std::endl;
|
|
return false;
|
|
}
|
|
status = chain->GetStatus();
|
|
if (!resultsMatch(status, status1)) {
|
|
std::cout << "GetStatus() did not produce expected output" << std::endl;
|
|
printResults(status, status1);
|
|
return false;
|
|
}
|
|
if (chain->Finished()) {
|
|
std::cout << "Finished() returned true, should be false" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if (chain->Wait(9000)) {
|
|
std::cout << "Wait() returned true, should be false" << std::endl;
|
|
return false;
|
|
}
|
|
status = chain->GetStatus();
|
|
if (!resultsMatch(status, status2)) {
|
|
std::cout << "GetStatus() did not produce expected output" << std::endl;
|
|
printResults(status, status2);
|
|
return false;
|
|
}
|
|
if (chain->Finished()) {
|
|
std::cout << "Finished() returned true, should be false" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if (!chain->Wait()) {
|
|
std::cout << "Wait() returned false, should be true" << std::endl;
|
|
return false;
|
|
}
|
|
status = chain->GetStatus();
|
|
if (!resultsMatch(status, status3)) {
|
|
std::cout << "GetStatus() did not produce expected output" << std::endl;
|
|
printResults(status, status3);
|
|
return false;
|
|
}
|
|
if (!chain->Finished()) {
|
|
std::cout << "Finished() returned false, should be true" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool checkOutput(std::istream& outputStream, std::istream& errorStream)
|
|
{
|
|
std::string output = getInput(outputStream);
|
|
if (output != "HELO WRD!") {
|
|
std::cout << "Output was \"" << output << "\", expected \"HELO WRD!\""
|
|
<< std::endl;
|
|
return false;
|
|
}
|
|
|
|
std::string error = getInput(errorStream);
|
|
auto qemu_error_pos = error.find("qemu:");
|
|
if (qemu_error_pos != std::string::npos) {
|
|
error.resize(qemu_error_pos);
|
|
}
|
|
if (error.length() != 3 || error.find('1') == std::string::npos ||
|
|
error.find('2') == std::string::npos ||
|
|
error.find('3') == std::string::npos) {
|
|
std::cout << "Error was \"" << error << "\", expected \"123\""
|
|
<< std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool testUVProcessChainBuiltin(const char* helperCommand)
|
|
{
|
|
cmUVProcessChainBuilder builder;
|
|
std::unique_ptr<cmUVProcessChain> chain;
|
|
builder.AddCommand({ helperCommand, "echo" })
|
|
.AddCommand({ helperCommand, "capitalize" })
|
|
.AddCommand({ helperCommand, "dedup" })
|
|
.SetBuiltinStream(cmUVProcessChainBuilder::Stream_OUTPUT)
|
|
.SetBuiltinStream(cmUVProcessChainBuilder::Stream_ERROR)
|
|
.SetBuiltinLoop();
|
|
if (builder.GetLoop()) {
|
|
std::cout << "GetLoop() should return null" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if (!checkExecution(builder, chain)) {
|
|
return false;
|
|
}
|
|
|
|
if (chain->OutputStream() < 0) {
|
|
std::cout << "OutputStream() was invalid, expecting valid" << std::endl;
|
|
return false;
|
|
}
|
|
if (chain->ErrorStream() < 0) {
|
|
std::cout << "ErrorStream() was invalid, expecting valid" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
cmUVPipeIStream output(chain->GetLoop(), chain->OutputStream());
|
|
cmUVPipeIStream error(chain->GetLoop(), chain->ErrorStream());
|
|
|
|
if (!checkOutput(output, error)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool testUVProcessChainBuiltinMerged(const char* helperCommand)
|
|
{
|
|
cmUVProcessChainBuilder builder;
|
|
std::unique_ptr<cmUVProcessChain> chain;
|
|
builder.AddCommand({ helperCommand, "echo" })
|
|
.AddCommand({ helperCommand, "capitalize" })
|
|
.AddCommand({ helperCommand, "dedup" })
|
|
.SetMergedBuiltinStreams();
|
|
|
|
if (!checkExecution(builder, chain)) {
|
|
return false;
|
|
}
|
|
|
|
if (chain->OutputStream() < 0) {
|
|
std::cout << "OutputStream() was invalid, expecting valid" << std::endl;
|
|
return false;
|
|
}
|
|
if (chain->ErrorStream() < 0) {
|
|
std::cout << "ErrorStream() was invalid, expecting valid" << std::endl;
|
|
return false;
|
|
}
|
|
if (chain->OutputStream() != chain->ErrorStream()) {
|
|
std::cout << "OutputStream() and ErrorStream() expected to be the same"
|
|
<< std::endl;
|
|
return false;
|
|
}
|
|
|
|
cmUVPipeIStream mergedStream(chain->GetLoop(), chain->OutputStream());
|
|
|
|
std::string merged = getInput(mergedStream);
|
|
auto qemuErrorPos = merged.find("qemu:");
|
|
if (qemuErrorPos != std::string::npos) {
|
|
merged.resize(qemuErrorPos);
|
|
}
|
|
if (merged.length() != cmStrLen("HELO WRD!123") ||
|
|
merged.find('1') == std::string::npos ||
|
|
merged.find('2') == std::string::npos ||
|
|
merged.find('3') == std::string::npos) {
|
|
std::cout << "Expected output to contain '1', '2', and '3', was \""
|
|
<< merged << "\"" << std::endl;
|
|
return false;
|
|
}
|
|
std::string output;
|
|
for (auto const& c : merged) {
|
|
if (c != '1' && c != '2' && c != '3') {
|
|
output += c;
|
|
}
|
|
}
|
|
if (output != "HELO WRD!") {
|
|
std::cout << "Output was \"" << output << "\", expected \"HELO WRD!\""
|
|
<< std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool testUVProcessChainExternal(const char* helperCommand)
|
|
{
|
|
cmUVProcessChainBuilder builder;
|
|
std::unique_ptr<cmUVProcessChain> chain;
|
|
int outputPipe[2], errorPipe[2];
|
|
cm::uv_pipe_ptr outputInPipe, outputOutPipe, errorInPipe, errorOutPipe;
|
|
|
|
if (cmGetPipes(outputPipe) < 0) {
|
|
std::cout << "Error creating pipes" << std::endl;
|
|
return false;
|
|
}
|
|
if (cmGetPipes(errorPipe) < 0) {
|
|
std::cout << "Error creating pipes" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
builder.AddCommand({ helperCommand, "echo" })
|
|
.AddCommand({ helperCommand, "capitalize" })
|
|
.AddCommand({ helperCommand, "dedup" })
|
|
.SetExternalStream(cmUVProcessChainBuilder::Stream_OUTPUT, outputPipe[1])
|
|
.SetExternalStream(cmUVProcessChainBuilder::Stream_ERROR, errorPipe[1]);
|
|
if (builder.GetLoop()) {
|
|
std::cout << "GetLoop() should return null" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if (!checkExecution(builder, chain)) {
|
|
return false;
|
|
}
|
|
|
|
if (chain->OutputStream() >= 0) {
|
|
std::cout << "OutputStream() was valid, expecting invalid" << std::endl;
|
|
return false;
|
|
}
|
|
if (chain->ErrorStream() >= 0) {
|
|
std::cout << "ErrorStream() was valid, expecting invalid" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
outputOutPipe.init(chain->GetLoop(), 0);
|
|
uv_pipe_open(outputOutPipe, outputPipe[1]);
|
|
outputOutPipe.reset();
|
|
|
|
errorOutPipe.init(chain->GetLoop(), 0);
|
|
uv_pipe_open(errorOutPipe, errorPipe[1]);
|
|
errorOutPipe.reset();
|
|
|
|
outputInPipe.init(chain->GetLoop(), 0);
|
|
uv_pipe_open(outputInPipe, outputPipe[0]);
|
|
cmUVStreambuf outputBuf;
|
|
outputBuf.open(outputInPipe);
|
|
std::istream outputStream(&outputBuf);
|
|
|
|
errorInPipe.init(chain->GetLoop(), 0);
|
|
uv_pipe_open(errorInPipe, errorPipe[0]);
|
|
cmUVStreambuf errorBuf;
|
|
errorBuf.open(errorInPipe);
|
|
std::istream errorStream(&errorBuf);
|
|
|
|
if (!checkOutput(outputStream, errorStream)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool testUVProcessChainNone(const char* helperCommand)
|
|
{
|
|
cmUVProcessChainBuilder builder;
|
|
std::unique_ptr<cmUVProcessChain> chain;
|
|
builder.AddCommand({ helperCommand, "echo" })
|
|
.AddCommand({ helperCommand, "capitalize" })
|
|
.AddCommand({ helperCommand, "dedup" });
|
|
|
|
if (!checkExecution(builder, chain)) {
|
|
return false;
|
|
}
|
|
|
|
if (chain->OutputStream() >= 0) {
|
|
std::cout << "OutputStream() was valid, expecting invalid" << std::endl;
|
|
return false;
|
|
}
|
|
if (chain->ErrorStream() >= 0) {
|
|
std::cout << "ErrorStream() was valid, expecting invalid" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool testUVProcessChainCwdUnchanged(const char* helperCommand)
|
|
{
|
|
cmUVProcessChainBuilder builder;
|
|
builder.AddCommand({ helperCommand, "pwd" })
|
|
.SetBuiltinStream(cmUVProcessChainBuilder::Stream_OUTPUT)
|
|
.SetBuiltinStream(cmUVProcessChainBuilder::Stream_ERROR);
|
|
|
|
auto chain = builder.Start();
|
|
chain.Wait();
|
|
if (chain.GetStatus().front()->ExitStatus != 0) {
|
|
std::cout << "Exit status was " << chain.GetStatus().front()->ExitStatus
|
|
<< ", expecting 0" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
cmUVPipeIStream output(chain.GetLoop(), chain.OutputStream());
|
|
auto cwd = getInput(output);
|
|
if (!cmHasLiteralSuffix(cwd, "/Tests/CMakeLib")) {
|
|
std::cout << "Working directory was \"" << cwd
|
|
<< "\", expected to end in \"/Tests/CMakeLib\"" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool testUVProcessChainCwdChanged(const char* helperCommand)
|
|
{
|
|
cmUVProcessChainBuilder builder;
|
|
builder.AddCommand({ helperCommand, "pwd" })
|
|
.SetBuiltinStream(cmUVProcessChainBuilder::Stream_OUTPUT)
|
|
.SetBuiltinStream(cmUVProcessChainBuilder::Stream_ERROR)
|
|
.SetWorkingDirectory("..");
|
|
|
|
auto chain = builder.Start();
|
|
chain.Wait();
|
|
if (chain.GetStatus().front()->ExitStatus != 0) {
|
|
std::cout << "Exit status was " << chain.GetStatus().front()->ExitStatus
|
|
<< ", expecting 0" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
cmUVPipeIStream output(chain.GetLoop(), chain.OutputStream());
|
|
auto cwd = getInput(output);
|
|
if (!cmHasLiteralSuffix(cwd, "/Tests")) {
|
|
std::cout << "Working directory was \"" << cwd
|
|
<< "\", expected to end in \"/Tests\"" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool testUVProcessChainSpawnFail(const char* helperCommand)
|
|
{
|
|
static const std::vector<ExpectedStatus> status1 = {
|
|
{ false,
|
|
false,
|
|
{ 0, false, 0, 0 },
|
|
cmUVProcessChain::ExceptionCode::None,
|
|
"" },
|
|
{ false,
|
|
false,
|
|
{ UV_ENOENT, true, 0, 0 },
|
|
cmUVProcessChain::ExceptionCode::Spawn,
|
|
uv_strerror(UV_ENOENT) },
|
|
#ifdef _WIN32
|
|
{ true,
|
|
true,
|
|
{ 0, true, STATUS_ACCESS_VIOLATION, 0 },
|
|
cmUVProcessChain::ExceptionCode::Fault,
|
|
"Access violation" },
|
|
#else
|
|
{ false,
|
|
true,
|
|
{ 0, true, 0, SIGABRT },
|
|
cmUVProcessChain::ExceptionCode::Other,
|
|
"Subprocess aborted" },
|
|
#endif
|
|
};
|
|
|
|
static const std::vector<ExpectedStatus> status2 = {
|
|
#ifdef _WIN32
|
|
{ true,
|
|
true,
|
|
{ 0, true, 0, 0 },
|
|
cmUVProcessChain::ExceptionCode::None,
|
|
"" },
|
|
#else
|
|
{ false,
|
|
true,
|
|
{ 0, true, 0, SIGPIPE },
|
|
cmUVProcessChain::ExceptionCode::Other,
|
|
"SIGPIPE" },
|
|
#endif
|
|
{ false,
|
|
false,
|
|
{ UV_ENOENT, true, 0, 0 },
|
|
cmUVProcessChain::ExceptionCode::Spawn,
|
|
uv_strerror(UV_ENOENT) },
|
|
#ifdef _WIN32
|
|
{ true,
|
|
true,
|
|
{ 0, true, STATUS_ACCESS_VIOLATION, 0 },
|
|
cmUVProcessChain::ExceptionCode::Fault,
|
|
"Access violation" },
|
|
#else
|
|
{ false,
|
|
true,
|
|
{ 0, true, 0, SIGABRT },
|
|
cmUVProcessChain::ExceptionCode::Other,
|
|
"Subprocess aborted" },
|
|
#endif
|
|
};
|
|
|
|
std::vector<const cmUVProcessChain::Status*> status;
|
|
|
|
cmUVProcessChainBuilder builder;
|
|
builder.AddCommand({ helperCommand, "echo" })
|
|
.AddCommand({ "this_command_is_for_cmake_and_should_never_exist" })
|
|
.AddCommand({ helperCommand, "dedup" })
|
|
.SetBuiltinStream(cmUVProcessChainBuilder::Stream_OUTPUT)
|
|
.SetBuiltinStream(cmUVProcessChainBuilder::Stream_ERROR);
|
|
|
|
auto chain = builder.Start();
|
|
if (!chain.Valid()) {
|
|
std::cout << "Valid() returned false, should be true" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
// Some platforms, like Solaris 10, take a long time to report a trapped
|
|
// subprocess to the parent process (about 1.7 seconds in the case of
|
|
// Solaris 10.) Wait 3 seconds to give it enough time.
|
|
if (chain.Wait(3000)) {
|
|
std::cout << "Wait() did not time out" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
status = chain.GetStatus();
|
|
if (!resultsMatch(status, status1)) {
|
|
std::cout << "GetStatus() did not produce expected output" << std::endl;
|
|
printResults(status, status1);
|
|
return false;
|
|
}
|
|
|
|
if (!chain.Wait()) {
|
|
std::cout << "Wait() timed out" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
status = chain.GetStatus();
|
|
if (!resultsMatch(status, status2)) {
|
|
std::cout << "GetStatus() did not produce expected output" << std::endl;
|
|
printResults(status, status2);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool testUVProcessChainInputFile(const char* helperCommand)
|
|
{
|
|
std::unique_ptr<FILE, int (*)(FILE*)> f(
|
|
fopen("testUVProcessChainInput.txt", "rb"), fclose);
|
|
|
|
cmUVProcessChainBuilder builder;
|
|
builder.AddCommand({ helperCommand, "dedup" })
|
|
.SetExternalStream(cmUVProcessChainBuilder::Stream_INPUT, f.get())
|
|
.SetBuiltinStream(cmUVProcessChainBuilder::Stream_OUTPUT);
|
|
|
|
auto chain = builder.Start();
|
|
|
|
if (!chain.Wait()) {
|
|
std::cout << "Wait() timed out" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
cmUVPipeIStream stream(chain.GetLoop(), chain.OutputStream());
|
|
std::string output = getInput(stream);
|
|
if (output != "HELO WRD!") {
|
|
std::cout << "Output was \"" << output << "\", expected \"HELO WRD!\""
|
|
<< std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool testUVProcessChainWait0(const char* helperCommand)
|
|
{
|
|
cmUVProcessChainBuilder builder;
|
|
builder.AddCommand({ helperCommand, "echo" });
|
|
|
|
auto chain = builder.Start();
|
|
if (!chain.Wait(0)) {
|
|
std::cout << "Wait(0) returned false, should be true" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool testUVProcessChainExternalLoop(const char* helperCommand)
|
|
{
|
|
cm::uv_loop_ptr loop;
|
|
loop.init();
|
|
|
|
cmUVProcessChainBuilder builder;
|
|
builder.AddCommand({ helperCommand, "echo" })
|
|
.SetBuiltinStream(cmUVProcessChainBuilder::Stream_OUTPUT)
|
|
.SetExternalLoop(*loop);
|
|
if (builder.GetLoop() != loop) {
|
|
std::cout << "GetLoop() should return external loop" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
auto chain = builder.Start();
|
|
|
|
if (&chain.GetLoop() != loop) {
|
|
std::cout << "GetLoop() should return external loop" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
if (!chain.Wait()) {
|
|
std::cout << "Wait() timed out" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
cmUVPipeIStream stream(chain.GetLoop(), chain.OutputStream());
|
|
std::string output = getInput(stream);
|
|
if (output != "HELLO world!") {
|
|
std::cout << "Output was \"" << output << "\", expected \"HELLO world!\""
|
|
<< std::endl;
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
int testUVProcessChain(int argc, char** const argv)
|
|
{
|
|
if (argc < 2) {
|
|
std::cout << "Invalid arguments.\n";
|
|
return -1;
|
|
}
|
|
|
|
if (!testUVProcessChainBuiltin(argv[1])) {
|
|
std::cout << "While executing testUVProcessChainBuiltin().\n";
|
|
return -1;
|
|
}
|
|
|
|
if (!testUVProcessChainBuiltinMerged(argv[1])) {
|
|
std::cout << "While executing testUVProcessChainBuiltinMerged().\n";
|
|
return -1;
|
|
}
|
|
|
|
if (!testUVProcessChainExternal(argv[1])) {
|
|
std::cout << "While executing testUVProcessChainExternal().\n";
|
|
return -1;
|
|
}
|
|
|
|
if (!testUVProcessChainNone(argv[1])) {
|
|
std::cout << "While executing testUVProcessChainNone().\n";
|
|
return -1;
|
|
}
|
|
|
|
if (!testUVProcessChainCwdUnchanged(argv[1])) {
|
|
std::cout << "While executing testUVProcessChainCwdUnchanged().\n";
|
|
return -1;
|
|
}
|
|
|
|
if (!testUVProcessChainCwdChanged(argv[1])) {
|
|
std::cout << "While executing testUVProcessChainCwdChanged().\n";
|
|
return -1;
|
|
}
|
|
|
|
if (!testUVProcessChainSpawnFail(argv[1])) {
|
|
std::cout << "While executing testUVProcessChainSpawnFail().\n";
|
|
return -1;
|
|
}
|
|
|
|
if (!testUVProcessChainInputFile(argv[1])) {
|
|
std::cout << "While executing testUVProcessChainInputFile().\n";
|
|
return -1;
|
|
}
|
|
|
|
if (!testUVProcessChainWait0(argv[1])) {
|
|
std::cout << "While executing testUVProcessChainWait0().\n";
|
|
return -1;
|
|
}
|
|
|
|
if (!testUVProcessChainExternalLoop(argv[1])) {
|
|
std::cout << "While executing testUVProcessChainExternalLoop().\n";
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|