/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file LICENSE.rst or https://cmake.org/licensing for details. */
#include "cmCTestBuildAndTest.h"
#include <chrono>
#include <cstdint>
#include <iostream>
#include <ratio>
#include <utility>
#include "cmBuildArgs.h"
#include "cmBuildOptions.h"
#include "cmCTest.h"
#include "cmCTestTestHandler.h"
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmProcessOutput.h"
#include "cmState.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
#include "cmUVProcessChain.h"
#include "cmUVStream.h"
#include "cmWorkingDirectory.h"
#include "cmake.h"
struct cmMessageMetadata;
cmCTestBuildAndTest::cmCTestBuildAndTest(cmCTest* ctest)
: CTest(ctest)
{
}
bool cmCTestBuildAndTest::RunCMake(cmake* cm)
{
std::vector<std::string> args;
args.push_back(cmSystemTools::GetCMakeCommand());
args.push_back(this->SourceDir);
if (!this->BuildGenerator.empty()) {
args.push_back("-G" + this->BuildGenerator);
}
if (!this->BuildGeneratorPlatform.empty()) {
args.push_back("-A" + this->BuildGeneratorPlatform);
}
if (!this->BuildGeneratorToolset.empty()) {
args.push_back("-T" + this->BuildGeneratorToolset);
}
char const* config = nullptr;
if (!this->CTest->GetConfigType().empty()) {
config = this->CTest->GetConfigType().c_str();
}
if (config) {
args.push_back("-DCMAKE_BUILD_TYPE:STRING=" + std::string(config));
}
if (!this->BuildMakeProgram.empty() &&
(this->BuildGenerator.find("Make") != std::string::npos ||
this->BuildGenerator.find("Ninja") != std::string::npos ||
this->BuildGenerator.find("FASTBuild") != std::string::npos)) {
args.push_back("-DCMAKE_MAKE_PROGRAM:FILEPATH=" + this->BuildMakeProgram);
}
for (std::string const& opt : this->BuildOptions) {
args.push_back(opt);
}
std::cout << "======== CMake output ======\n";
if (cm->Run(args) != 0) {
std::cout << "======== End CMake output ======\n"
"Error: cmake execution failed\n";
return false;
}
// do another config?
if (this->BuildTwoConfig) {
if (cm->Run(args) != 0) {
std::cout << "======== End CMake output ======\n"
"Error: cmake execution failed\n";
return false;
}
}
std::cout << "======== End CMake output ======\n";
return true;
}
bool cmCTestBuildAndTest::RunTest(std::vector<std::string> const& argv,
int* retVal, cmDuration timeout)
{
cmUVProcessChainBuilder builder;
builder.AddCommand(argv).SetMergedBuiltinStreams();
auto chain = builder.Start();
cmProcessOutput processOutput(cmProcessOutput::Auto);
auto outputHandle = cmUVStreamRead(
chain.OutputStream(),
[&processOutput](std::vector<char> data) {
std::string decoded;
processOutput.DecodeText(data.data(), data.size(), decoded);
std::cout << decoded << std::flush;
},
[]() {});
bool complete = chain.Wait(static_cast<uint64_t>(timeout.count() * 1000.0));
bool result = false;
if (complete) {
auto const& status = chain.GetStatus(0);
auto exception = status.GetException();
switch (exception.first) {
case cmUVProcessChain::ExceptionCode::None:
*retVal = static_cast<int>(status.ExitStatus);
result = true;
break;
case cmUVProcessChain::ExceptionCode::Spawn: {
std::cout << "\n*** ERROR executing: " << exception.second;
} break;
default: {
*retVal = status.TermSignal;
std::cout << "\n*** Exception executing: " << exception.second;
} break;
}
} else {
chain.Terminate();
}
return result;
}
class cmCTestBuildAndTestCaptureRAII
{
cmake& CM;
public:
cmCTestBuildAndTestCaptureRAII(cmake& cm)
: CM(cm)
{
cmSystemTools::SetMessageCallback(
[](std::string const& msg, cmMessageMetadata const& /* unused */) {
std::cout << msg << std::endl;
});
cmSystemTools::SetStdoutCallback(
[](std::string const& m) { std::cout << m << std::flush; });
cmSystemTools::SetStderrCallback(
[](std::string const& m) { std::cout << m << std::flush; });
this->CM.SetProgressCallback([](std::string const& msg, float prog) {
if (prog < 0) {
std::cout << msg << std::endl;
}
});
}
~cmCTestBuildAndTestCaptureRAII()
{
this->CM.SetProgressCallback(nullptr);
cmSystemTools::SetStderrCallback(nullptr);
cmSystemTools::SetStdoutCallback(nullptr);
cmSystemTools::SetMessageCallback(nullptr);
}
cmCTestBuildAndTestCaptureRAII(cmCTestBuildAndTestCaptureRAII const&) =
delete;
cmCTestBuildAndTestCaptureRAII& operator=(
cmCTestBuildAndTestCaptureRAII const&) = delete;
};
int cmCTestBuildAndTest::Run()
{
// if the generator and make program are not specified then it is an error
if (this->BuildGenerator.empty()) {
std::cout << "--build-and-test requires that the generator "
"be provided using the --build-generator "
"command line option.\n";
return 1;
}
cmake cm(cmState::Role::Project);
cmCTestBuildAndTestCaptureRAII captureRAII(cm);
static_cast<void>(captureRAII);
if (this->CTest->GetConfigType().empty() && !this->ConfigSample.empty()) {
// use the config sample to set the ConfigType
std::string fullPath;
std::string resultingConfig;
std::vector<std::string> extraPaths;
std::vector<std::string> failed;
fullPath = cmCTestTestHandler::FindExecutable(
this->CTest, this->ConfigSample, resultingConfig, extraPaths, failed);
if (!fullPath.empty() && !resultingConfig.empty()) {
this->CTest->SetConfigType(resultingConfig);
}
std::cout << "Using config sample with results: " << fullPath << " and "
<< resultingConfig << std::endl;
}
// we need to honor the timeout specified, the timeout include cmake, build
// and test time
auto clock_start = std::chrono::steady_clock::now();
// make sure the binary dir is there
std::cout << "Internal cmake changing into directory: " << this->BinaryDir
<< std::endl;
if (!cmSystemTools::FileIsDirectory(this->BinaryDir)) {
cmSystemTools::MakeDirectory(this->BinaryDir);
}
cmWorkingDirectory workdir(this->BinaryDir);
if (workdir.Failed()) {
std::cout << workdir.GetError() << '\n';
return 1;
}
if (this->BuildNoCMake) {
// Make the generator available for the Build call below.
cm.SetGlobalGenerator(cm.CreateGlobalGenerator(this->BuildGenerator));
if (!this->BuildGeneratorPlatform.empty()) {
cmMakefile mf(cm.GetGlobalGenerator(), cm.GetCurrentSnapshot());
if (!cm.GetGlobalGenerator()->SetGeneratorPlatform(
this->BuildGeneratorPlatform, &mf)) {
return 1;
}
}
// Load the cache to make CMAKE_MAKE_PROGRAM available.
cm.LoadCache(this->BinaryDir);
} else {
// do the cmake step, no timeout here since it is not a sub process
if (!this->RunCMake(&cm)) {
return 1;
}
}
// do the build
if (this->BuildTargets.empty()) {
this->BuildTargets.emplace_back();
}
for (std::string const& tar : this->BuildTargets) {
cmDuration remainingTime = std::chrono::seconds(0);
if (this->Timeout > cmDuration::zero()) {
remainingTime =
this->Timeout - (std::chrono::steady_clock::now() - clock_start);
if (remainingTime <= std::chrono::seconds(0)) {
std::cout << "--build-and-test timeout exceeded. ";
return 1;
}
}
char const* config = nullptr;
if (!this->CTest->GetConfigType().empty()) {
config = this->CTest->GetConfigType().c_str();
}
if (!config) {
config = "Debug";
}
cmBuildArgs buildArgs;
buildArgs.jobs = cmake::NO_BUILD_PARALLEL_LEVEL;
buildArgs.binaryDir = this->BinaryDir;
buildArgs.projectName = this->BuildProject;
buildArgs.verbose = false;
cmBuildOptions buildOptions(!this->BuildNoClean, false,
PackageResolveMode::Disable);
int retVal = cm.GetGlobalGenerator()->Build(
buildArgs, { tar }, std::cout, this->BuildMakeProgram, config,
buildOptions, remainingTime, cmSystemTools::OUTPUT_PASSTHROUGH);
// if the build failed then return
if (retVal) {
return 1;
}
}
// if no test was specified then we are done
if (this->TestCommand.empty()) {
return 0;
}
// now run the compiled test if we can find it
// store the final location in fullPath
std::string fullPath;
std::string resultingConfig;
std::vector<std::string> extraPaths;
// if this->ExecutableDirectory is set try that as well
if (!this->ExecutableDirectory.empty()) {
std::string tempPath =
cmStrCat(this->ExecutableDirectory, '/', this->TestCommand);
extraPaths.push_back(tempPath);
}
std::vector<std::string> failed;
fullPath = cmCTestTestHandler::FindExecutable(
this->CTest, this->TestCommand, resultingConfig, extraPaths, failed);
if (!cmSystemTools::FileExists(fullPath)) {
std::cout
<< "Could not find path to executable, perhaps it was not built: "
<< this->TestCommand << "\n"
<< "tried to find it in these places:\n"
<< fullPath << '\n';
for (std::string const& fail : failed) {
std::cout << fail << '\n';
}
return 1;
}
std::vector<std::string> testCommand;
testCommand.push_back(fullPath);
for (std::string const& testCommandArg : this->TestCommandArgs) {
testCommand.push_back(testCommandArg);
}
int retval = 0;
// run the test from the this->BuildRunDir if set
if (!this->BuildRunDir.empty()) {
std::cout << "Run test in directory: " << this->BuildRunDir << '\n';
if (!workdir.SetDirectory(this->BuildRunDir)) {
std::cout << workdir.GetError() << '\n';
return 1;
}
}
std::cout << "Running test command: \"" << fullPath << '"';
for (std::string const& testCommandArg : this->TestCommandArgs) {
std::cout << " \"" << testCommandArg << '"';
}
std::cout << '\n';
// how much time is remaining
cmDuration remainingTime = std::chrono::seconds(0);
if (this->Timeout > cmDuration::zero()) {
remainingTime =
this->Timeout - (std::chrono::steady_clock::now() - clock_start);
if (remainingTime <= std::chrono::seconds(0)) {
std::cout << "--build-and-test timeout exceeded. ";
return 1;
}
}
bool runTestRes = this->RunTest(testCommand, &retval, remainingTime);
if (!runTestRes || retval != 0) {
std::cout << "\nTest command failed: " << testCommand[0] << '\n';
retval = 1;
}
return retval;
}
