{

char const* RegularExpressionString;

int FileIndex;

int LineIndex;

: Superclass(ctest)

, LastErrorOrWarning(this->ErrorsAndWarnings.end())

{

{

this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_ERROR_MATCH",

this->CustomErrorMatches);

this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_ERROR_EXCEPTION",

this->CustomErrorExceptions);

this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_WARNING_MATCH",

this->CustomWarningMatches);

this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_WARNING_EXCEPTION",

this->CustomWarningExceptions);

this->CTest->PopulateCustomInteger(

mf, "CTEST_CUSTOM_MAXIMUM_NUMBER_OF_ERRORS", this->MaxErrors);

this->CTest->PopulateCustomInteger(

mf, "CTEST_CUSTOM_MAXIMUM_NUMBER_OF_WARNINGS", this->MaxWarnings);

int n = -1;

this->CTest->PopulateCustomInteger(mf, "CTEST_CUSTOM_ERROR_PRE_CONTEXT", n);

if (n != -1) {

this->MaxPreContext = static_cast<size_t>(n);

}

n = -1;

this->CTest->PopulateCustomInteger(mf, "CTEST_CUSTOM_ERROR_POST_CONTEXT", n);

if (n != -1) {

this->MaxPostContext = static_cast<size_t>(n);

}

// Record the user-specified custom warning rules.

if (cmValue customWarningMatchers =

mf->GetDefinition("CTEST_CUSTOM_WARNING_MATCH")) {

cmExpandList(*customWarningMatchers, this->ReallyCustomWarningMatches);

}

if (cmValue customWarningExceptions =

mf->GetDefinition("CTEST_CUSTOM_WARNING_EXCEPTION")) {

cmExpandList(*customWarningExceptions,

this->ReallyCustomWarningExceptions);

}

{

std::string makeCommand = this->CTest->GetCTestConfiguration("MakeCommand");

cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,

"MakeCommand:" << makeCommand << "\n", this->Quiet);

std::string configType = this->CTest->GetConfigType();

if (configType.empty()) {

configType =

this->CTest->GetCTestConfiguration("DefaultCTestConfigurationType");

}

if (configType.empty()) {

configType = "Release";

}

cmSystemTools::ReplaceString(makeCommand, "${CTEST_CONFIGURATION_TYPE}",

configType.c_str());

return makeCommand;

{

cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "Build project" << std::endl,

this->Quiet);

// do we have time for this

if (this->CTest->GetRemainingTimeAllowed() < std::chrono::minutes(2)) {

return 0;

}

int entry;

for (entry = 0; cmCTestWarningErrorFileLine[entry].RegularExpressionString;

++entry) {

cmCTestBuildHandler::cmCTestCompileErrorWarningRex r;

if (r.RegularExpression.compile(

cmCTestWarningErrorFileLine[entry].RegularExpressionString)) {

r.FileIndex = cmCTestWarningErrorFileLine[entry].FileIndex;

r.LineIndex = cmCTestWarningErrorFileLine[entry].LineIndex;

this->ErrorWarningFileLineRegex.push_back(std::move(r));

} else {

cmCTestLog(

this->CTest, ERROR_MESSAGE,

"Problem Compiling regular expression: "

<< cmCTestWarningErrorFileLine[entry].RegularExpressionString

<< std::endl);

}

}

// Determine build command and build directory

std::string makeCommand = this->GetMakeCommand();

if (makeCommand.empty()) {

cmCTestLog(this->CTest, ERROR_MESSAGE,

"Cannot find MakeCommand key in the DartConfiguration.tcl"

<< std::endl);

return -1;

}

std::string const& buildDirectory =

this->CTest->GetCTestConfiguration("BuildDirectory");

if (buildDirectory.empty()) {

cmCTestLog(this->CTest, ERROR_MESSAGE,

"Cannot find BuildDirectory key in the DartConfiguration.tcl"

<< std::endl);

return -1;

}

std::string const& useLaunchers =

this->CTest->GetCTestConfiguration("UseLaunchers");

this->UseCTestLaunch = cmIsOn(useLaunchers);

// Create a last build log

cmGeneratedFileStream ofs;

auto elapsed_time_start = std::chrono::steady_clock::now();

if (!this->StartLogFile("Build", ofs)) {

cmCTestLog(this->CTest, ERROR_MESSAGE,

"Cannot create build log file" << std::endl);

}

this->LogFileName = ofs.GetTempName();

// Create lists of regular expression strings for errors, error exceptions,

// warnings and warning exceptions.

std::vector<std::string>::size_type cc;

for (cc = 0; cmCTestErrorMatches[cc]; cc++) {

this->CustomErrorMatches.emplace_back(cmCTestErrorMatches[cc]);

}

for (cc = 0; cmCTestErrorExceptions[cc]; cc++) {

this->CustomErrorExceptions.emplace_back(cmCTestErrorExceptions[cc]);

}

for (cc = 0; cmCTestWarningMatches[cc]; cc++) {

this->CustomWarningMatches.emplace_back(cmCTestWarningMatches[cc]);

}

for (cc = 0; cmCTestWarningExceptions[cc]; cc++) {

this->CustomWarningExceptions.emplace_back(cmCTestWarningExceptions[cc]);

}

// Pre-compile regular expressions objects for all regular expressions

#define cmCTestBuildHandlerPopulateRegexVector(strings, regexes) \

do { \

regexes.clear(); \

cmCTestOptionalLog(this->CTest, DEBUG, \

this << "Add " #regexes << std::endl, this->Quiet); \

for (std::string const& s : (strings)) { \

cmCTestOptionalLog(this->CTest, DEBUG, \

"Add " #strings ": " << s << std::endl, \

this->Quiet); \

(regexes).emplace_back(s); \

} \

} while (false)

cmCTestBuildHandlerPopulateRegexVector(this->CustomErrorMatches,

this->ErrorMatchRegex);

cmCTestBuildHandlerPopulateRegexVector(this->CustomErrorExceptions,

this->ErrorExceptionRegex);

cmCTestBuildHandlerPopulateRegexVector(this->CustomWarningMatches,

this->WarningMatchRegex);

cmCTestBuildHandlerPopulateRegexVector(this->CustomWarningExceptions,

this->WarningExceptionRegex);

// Determine source and binary tree substitutions to simplify the output.

this->SimplifySourceDir.clear();

this->SimplifyBuildDir.clear();

if (this->CTest->GetCTestConfiguration("SourceDirectory").size() > 20) {

std::string srcdir =

this->CTest->GetCTestConfiguration("SourceDirectory") + "/";

cc = srcdir.rfind('/', srcdir.size() - 2);

if (cc != std::string::npos) {

srcdir.resize(cc + 1);

this->SimplifySourceDir = std::move(srcdir);

}

}

if (this->CTest->GetCTestConfiguration("BuildDirectory").size() > 20) {

std::string bindir =

this->CTest->GetCTestConfiguration("BuildDirectory") + "/";

cc = bindir.rfind('/', bindir.size() - 2);

if (cc != std::string::npos) {

bindir.resize(cc + 1);

this->SimplifyBuildDir = std::move(bindir);

}

}

// Ok, let's do the build

// Remember start build time

this->StartBuild = this->CTest->CurrentTime();

this->StartBuildTime = std::chrono::system_clock::now();

cmStringReplaceHelper colorRemover("\x1b\\[[0-9;]*m", "", nullptr);

this->ColorRemover = &colorRemover;

int retVal = 0;

bool res = true;

if (!this->CTest->GetShowOnly()) {

res = this->RunMakeCommand(makeCommand, &retVal, buildDirectory.c_str(), 0,

ofs);

} else {

cmCTestOptionalLog(this->CTest, DEBUG,

"Build with command: " << makeCommand << std::endl,

this->Quiet);

}

// Remember end build time and calculate elapsed time

this->EndBuild = this->CTest->CurrentTime();

this->EndBuildTime = std::chrono::system_clock::now();

auto elapsed_build_time =

std::chrono::steady_clock::now() - elapsed_time_start;

// Cleanups strings in the errors and warnings list.

if (!this->SimplifySourceDir.empty()) {

for (cmCTestBuildErrorWarning& evit : this->ErrorsAndWarnings) {

cmSystemTools::ReplaceString(evit.Text, this->SimplifySourceDir.c_str(),

"/.../");

cmSystemTools::ReplaceString(evit.PreContext,

this->SimplifySourceDir.c_str(), "/.../");

cmSystemTools::ReplaceString(evit.PostContext,

this->SimplifySourceDir.c_str(), "/.../");

}

}

if (!this->SimplifyBuildDir.empty()) {

for (cmCTestBuildErrorWarning& evit : this->ErrorsAndWarnings) {

cmSystemTools::ReplaceString(evit.Text, this->SimplifyBuildDir.c_str(),

"/.../");

cmSystemTools::ReplaceString(evit.PreContext,

this->SimplifyBuildDir.c_str(), "/.../");

cmSystemTools::ReplaceString(evit.PostContext,

this->SimplifyBuildDir.c_str(), "/.../");

}

}

// Generate XML output

cmGeneratedFileStream xofs;

if (!this->StartResultingXML(cmCTest::PartBuild, "Build", xofs)) {

cmCTestLog(this->CTest, ERROR_MESSAGE,

"Cannot create build XML file" << std::endl);

return -1;

}

cmXMLWriter xml(xofs);

this->GenerateXMLHeader(xml);

if (this->UseCTestLaunch) {

this->GenerateXMLLaunched(xml);

} else {

this->GenerateXMLLogScraped(xml);

}

this->CTest->GetInstrumentation().CollectTimingData(

cmInstrumentationQuery::Hook::PrepareForCDash);

this->GenerateInstrumentationXML(xml);

this->GenerateXMLFooter(xml, elapsed_build_time);

if (!res || retVal || this->TotalErrors > 0) {

cmCTestLog(this->CTest, ERROR_MESSAGE,

"Error(s) when building project" << std::endl);

}

// Display message about number of errors and warnings

cmCTestLog(this->CTest, HANDLER_OUTPUT,

" " << this->TotalErrors

<< (this->TotalErrors >= this->MaxErrors ? " or more" : "")

<< " Compiler errors" << std::endl);

cmCTestLog(

this->CTest, HANDLER_OUTPUT,

" " << this->TotalWarnings

<< (this->TotalWarnings >= this->MaxWarnings ? " or more" : "")

<< " Compiler warnings" << std::endl);

return retVal;

{

this->CTest->StartXML(xml, this->CMake, this->AppendXML);

this->CTest->GenerateSubprojectsOutput(xml);

xml.StartElement("Build");

xml.Element("StartDateTime", this->StartBuild);

xml.Element("StartBuildTime", this->StartBuildTime);

xml.Element("SourceDirectory",

this->CTest->GetCTestConfiguration("SourceDirectory"));

xml.Element("BinaryDirectory", this->CTest->GetBinaryDir());

xml.Element("BuildCommand", this->GetMakeCommand());

{

if (this->CTestLaunchDir.empty()) {

return;

}

// Sort XML fragments in chronological order.

cmFileTimeCache ftc;

FragmentCompare fragmentCompare(&ftc);

using Fragments = std::set<std::string, FragmentCompare>;

Fragments fragments(fragmentCompare);

// only report the first 50 warnings and first 50 errors

int numErrorsAllowed = this->MaxErrors;

int numWarningsAllowed = this->MaxWarnings;

// Identify fragments on disk.

cmsys::Directory launchDir;

launchDir.Load(this->CTestLaunchDir);

unsigned long n = launchDir.GetNumberOfFiles();

for (unsigned long i = 0; i < n; ++i) {

std::string const& fname = launchDir.GetFileName(i);

if (this->IsLaunchedErrorFile(fname) && numErrorsAllowed) {

numErrorsAllowed--;

fragments.insert(cmStrCat(this->CTestLaunchDir, '/', fname));

++this->TotalErrors;

} else if (this->IsLaunchedWarningFile(fname) && numWarningsAllowed) {

numWarningsAllowed--;

fragments.insert(cmStrCat(this->CTestLaunchDir, '/', fname));

++this->TotalWarnings;

}

}

// Copy the fragments into the final XML file.

for (std::string const& f : fragments) {

xml.FragmentFile(f.c_str());

}

{

std::vector<cmCTestBuildErrorWarning>& ew = this->ErrorsAndWarnings;

std::vector<cmCTestBuildErrorWarning>::iterator it;

// only report the first 50 warnings and first 50 errors

int numErrorsAllowed = this->MaxErrors;

int numWarningsAllowed = this->MaxWarnings;

std::string srcdir = this->CTest->GetCTestConfiguration("SourceDirectory");

for (it = ew.begin();

it != ew.end() && (numErrorsAllowed || numWarningsAllowed); it++) {

cmCTestBuildErrorWarning* cm = &(*it);

if ((cm->Error && numErrorsAllowed) ||

(!cm->Error && numWarningsAllowed)) {

if (cm->Error) {

numErrorsAllowed--;

} else {

numWarningsAllowed--;

}

xml.StartElement(cm->Error ? "Error" : "Warning");

xml.Element("BuildLogLine", cm->LogLine);

xml.Element("Text", cm->Text);

for (cmCTestCompileErrorWarningRex& rit :

this->ErrorWarningFileLineRegex) {

cmsys::RegularExpression* re = &rit.RegularExpression;

if (re->find(cm->Text)) {

cm->SourceFile = re->match(rit.FileIndex);

// At this point we need to make this->SourceFile relative to

// the source root of the project, so cvs links will work

cmSystemTools::ConvertToUnixSlashes(cm->SourceFile);

if (cm->SourceFile.find("/.../") != std::string::npos) {

cmSystemTools::ReplaceString(cm->SourceFile, "/.../", "");

std::string::size_type p = cm->SourceFile.find('/');

if (p != std::string::npos) {

cm->SourceFile =

cm->SourceFile.substr(p + 1, cm->SourceFile.size() - p);

}

} else {

// make sure it is a full path with the correct case

cm->SourceFile =

cmSystemTools::ToNormalizedPathOnDisk(cm->SourceFile);

cmSystemTools::ReplaceString(cm->SourceFile, srcdir, "");

}

cm->LineNumber = atoi(re->match(rit.LineIndex).c_str());

break;

}

}

if (!cm->SourceFile.empty() && cm->LineNumber >= 0) {

if (!cm->SourceFile.empty()) {

xml.Element("SourceFile", cm->SourceFile);

}

if (!cm->SourceFileTail.empty()) {

xml.Element("SourceFileTail", cm->SourceFileTail);

}

if (cm->LineNumber >= 0) {

xml.Element("SourceLineNumber", cm->LineNumber);

}

}

xml.Element("PreContext", cm->PreContext);

xml.StartElement("PostContext");

xml.Content(cm->PostContext);

// is this the last warning or error, if so notify

if ((cm->Error && !numErrorsAllowed) ||

(!cm->Error && !numWarningsAllowed)) {

xml.Content("\nThe maximum number of reported warnings or errors "

"has been reached!!!\n");

}

xml.EndElement(); // PostContext

xml.Element("RepeatCount", "0");

xml.EndElement(); // "Error" / "Warning"

}

}

{

// Record instrumentation data on a per-target basis.

cmsys::Directory targets_dir;

std::string targets_snippet_dir = cmStrCat(

this->CTest->GetInstrumentation().GetCDashDir(), "/build/targets");

if (targets_dir.Load(targets_snippet_dir) &&

targets_dir.GetNumberOfFiles() > 0) {

xml.StartElement("Targets");

for (unsigned int i = 0; i < targets_dir.GetNumberOfFiles(); i++) {

if (!targets_dir.FileIsDirectory(i)) {

continue;

}

std::string const& target_name = targets_dir.GetFileName(i);

if (target_name == "." || target_name == "..") {

continue;

}

xml.StartElement("Target");

xml.Attribute("name", target_name);

// Load latest CMake content file

Json::Value target_data;

std::string cmake_content_file =

cmStrCat(CTest->GetInstrumentation().GetDataDir(), "/content/",

this->CTest->GetInstrumentation().GetFileByTimestamp(

cmInstrumentation::LatestOrOldest::Latest, "content"));

if (!cmake_content_file.empty() &&

cmSystemTools::FileExists(cmake_content_file)) {

Json::Value cmake_content;

cmJSONState parseState =

cmJSONState(cmake_content_file, &cmake_content);

if (!parseState.errors.empty()) {

cmSystemTools::Error(parseState.GetErrorMessage(true));

break;

}

if (cmake_content.isMember("targets")) {

target_data = cmake_content["targets"];

}

}

bool target_has_data =

target_data.isObject() && target_data.isMember(target_name);

// Extract targetType

std::string target_type = "UNKNOWN";

if (target_has_data) {

target_type = target_data[target_name]["type"].asString();

}

xml.Attribute("type", target_type);

// Extract targetLabels

if (target_has_data && !target_data[target_name]["labels"].empty()) {

xml.StartElement("Labels");

for (auto const& json_label_item :

target_data[target_name]["labels"]) {

xml.Element("Label", json_label_item.asString());

}

xml.EndElement(); // Labels

}

// Write instrumendation data for this target.

std::string target_subdir = cmStrCat("build/targets/", target_name);

this->CTest->ConvertInstrumentationSnippetsToXML(xml, target_subdir);

std::string target_dir_fullpath = cmStrCat(

this->CTest->GetInstrumentation().GetCDashDir(), '/', target_subdir);

if (cmSystemTools::FileIsDirectory(target_dir_fullpath)) {

cmSystemTools::RemoveADirectory(target_dir_fullpath);

}

xml.EndElement(); // Target

}

xml.EndElement(); // Targets

}

// Also record instrumentation data for custom commands (no target).

this->CTest->ConvertInstrumentationSnippetsToXML(xml, "build/commands");

cmDuration elapsed_build_time)

{

xml.StartElement("Log");

xml.Attribute("Encoding", "base64");

xml.Attribute("Compression", "bin/gzip");

xml.EndElement(); // Log

xml.Element("EndDateTime", this->EndBuild);

xml.Element("EndBuildTime", this->EndBuildTime);

xml.Element(

"ElapsedMinutes",

std::chrono::duration_cast<std::chrono::minutes>(elapsed_build_time)

.count());

xml.EndElement(); // Build

this->CTest->EndXML(xml);

{

// error-{hash}.xml

return (cmHasLiteralPrefix(fname, "error-") &&

cmHasLiteralSuffix(fname, ".xml"));

{

// warning-{hash}.xml

return (cmHasLiteralPrefix(fname, "warning-") &&

cmHasLiteralSuffix(fname, ".xml"));

int* retVal, char const* dir,

int timeout, std::ostream& ofs,

Encoding encoding)

{

// First generate the command and arguments

std::vector<std::string> args = cmSystemTools::ParseArguments(command);

if (args.empty()) {

return false;

}

cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,

"Run command:", this->Quiet);

for (auto const& arg : args) {

cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,

" \"" << arg << "\"", this->Quiet);

}

cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl,

this->Quiet);

// Optionally use make rule launchers to record errors and warnings.

LaunchHelper launchHelper(this);

static_cast<void>(launchHelper);

// Now create process object

cmUVProcessChainBuilder builder;

builder.AddCommand(args)

.SetBuiltinStream(cmUVProcessChainBuilder::Stream_OUTPUT)

.SetBuiltinStream(cmUVProcessChainBuilder::Stream_ERROR);

if (dir) {

builder.SetWorkingDirectory(dir);

}

auto chain = builder.Start();

// Initialize tick's

std::string::size_type tick = 0;

static constexpr std::string::size_type tick_len = 1024;

cmProcessOutput processOutput(encoding);

cmCTestOptionalLog(

this->CTest, HANDLER_PROGRESS_OUTPUT,

" Each symbol represents "

<< tick_len << " bytes of output." << std::endl

<< (this->UseCTestLaunch

? ""

: " '!' represents an error and '*' a warning.\n")

<< " " << std::flush,

this->Quiet);

// Initialize building structures

this->BuildProcessingQueue.clear();

this->OutputLineCounter = 0;

this->ErrorsAndWarnings.clear();

this->TotalErrors = 0;

this->TotalWarnings = 0;

this->BuildOutputLogSize = 0;

this->LastTickChar = '.';

this->WarningQuotaReached = false;

this->ErrorQuotaReached = false;

cm::uv_timer_ptr timer;

bool timedOut = false;

timer.init(chain.GetLoop(), &timedOut);

if (timeout > 0) {

timer.start(

[](uv_timer_t* t) {

auto* timedOutPtr = static_cast<bool*>(t->data);

*timedOutPtr = true;

},

timeout * 1000, 0, cm::uv_update_time::yes);

}

// For every chunk of data

bool outFinished = false;

bool errFinished = false;

auto startRead = [this, &processOutput, &tick,

&ofs](uv_stream_t* stream,

t_BuildProcessingQueueType& queue, bool& finished,

int id) -> std::unique_ptr<cmUVStreamReadHandle> {

return cmUVStreamRead(

stream,

[this, &processOutput, &queue, id, &tick, &ofs](std::vector<char> data) {

// Replace '\0' with '\n', since '\0' does not really make sense. This

// is for Visual Studio output

for (auto& c : data) {

if (c == 0) {

c = '\n';

}

}

// Process the chunk of data

std::string strdata;

processOutput.DecodeText(data.data(), data.size(), strdata, id);

this->ProcessBuffer(strdata.c_str(), strdata.size(), tick, tick_len,

ofs, &queue);

},

[this, &processOutput, &queue, id, &tick, &ofs, &finished]() {

std::string strdata;

processOutput.DecodeText(std::string(), strdata, id);

if (!strdata.empty()) {

this->ProcessBuffer(strdata.c_str(), strdata.size(), tick, tick_len,

ofs, &queue);

}

finished = true;

});

};

auto outputHandle = startRead(chain.OutputStream(),

this->BuildProcessingQueue, outFinished, 1);

auto errorHandle = startRead(

chain.ErrorStream(), this->BuildProcessingErrorQueue, errFinished, 2);

while (!timedOut && !(outFinished && errFinished && chain.Finished())) {

uv_run(&chain.GetLoop(), UV_RUN_ONCE);

}

this->ProcessBuffer(nullptr, 0, tick, tick_len, ofs,

&this->BuildProcessingQueue);

this->ProcessBuffer(nullptr, 0, tick, tick_len, ofs,

&this->BuildProcessingErrorQueue);

cmCTestOptionalLog(this->CTest, HANDLER_PROGRESS_OUTPUT,

" Size of output: "

<< ((this->BuildOutputLogSize + 512) / 1024) << "K"

<< std::endl,

this->Quiet);

if (chain.Finished()) {

auto const& status = chain.GetStatus(0);

auto exception = status.GetException();

switch (exception.first) {

case cmUVProcessChain::ExceptionCode::None:

if (retVal) {

*retVal = static_cast<int>(status.ExitStatus);

cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,

"Command exited with the value: " << *retVal

<< std::endl,

this->Quiet);

// if a non zero return value

if (*retVal) {

// If there was an error running command, report that on the

// dashboard.

if (this->UseCTestLaunch) {

// For launchers, do not record this top-level error if other

// more granular build errors have already been captured.

bool launcherXMLFound = false;

cmsys::Directory launchDir;

launchDir.Load(this->CTestLaunchDir);

unsigned long n = launchDir.GetNumberOfFiles();

for (unsigned long i = 0; i < n; ++i) {

std::string const& fname = launchDir.GetFileName(i);

if (cmHasLiteralSuffix(fname, ".xml")) {

launcherXMLFound = true;

break;

}

}

if (!launcherXMLFound) {

cmCTestLaunchReporter reporter;

reporter.RealArgs = args;

reporter.ComputeFileNames();

reporter.ExitCode = *retVal;

reporter.Status = status;

// Use temporary BuildLog file to populate this error for

// CDash.

ofs.flush();

reporter.LogOut = this->LogFileName;

reporter.WriteXML();

}

} else {

cmCTestBuildErrorWarning errorwarning;

errorwarning.LineNumber = 0;

errorwarning.LogLine = 1;

errorwarning.Text = cmStrCat(

"*** WARNING non-zero return value in ctest from: ", args[0]);

errorwarning.PreContext.clear();

errorwarning.PostContext.clear();

errorwarning.Error = false;

this->ErrorsAndWarnings.push_back(std::move(errorwarning));

this->TotalWarnings++;

}

}

}

break;

case cmUVProcessChain::ExceptionCode::Spawn: {

// If there was an error running command, report that on the dashboard.

cmCTestBuildErrorWarning errorwarning;

errorwarning.LineNumber = 0;

errorwarning.LogLine = 1;

errorwarning.Text =

cmStrCat("*** ERROR executing: ", exception.second);

errorwarning.PreContext.clear();

errorwarning.PostContext.clear();

errorwarning.Error = true;

this->ErrorsAndWarnings.push_back(std::move(errorwarning));

this->TotalErrors++;

cmCTestLog(this->CTest, ERROR_MESSAGE,