mirror/CMake
1
0
Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2026-01-04 12:49:36 -06:00
Code Issues Packages Projects Releases Wiki Activity

ctest: Split --build-and-test implementation from handler infrastructure

Browse Source 
It does not follow the pattern of the dashboard-mode step handlers.
This commit is contained in:
Brad King
2024-10-14 11:28:34 -04:00
parent 270ab612b9
commit 3d2882290b
5 changed files with 70 additions and 83 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Source/CMakeLists.txt
View File

@@ -1071,7 +1071,7 @@ add_library(
cmCTest.cxx
CTest/cmProcess.cxx
CTest/cmCTestBinPacker.cxx
CTest/cmCTestBuildAndTestHandler.cxx
CTest/cmCTestBuildAndTest.cxx
CTest/cmCTestBuildCommand.cxx
CTest/cmCTestBuildHandler.cxx
CTest/cmCTestConfigureCommand.cxx

21
Source/CTest/cmCTestBuildAndTestHandler.cxx → Source/CTest/cmCTestBuildAndTest.cxx
View File

@@ -1,6 +1,6 @@
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmCTestBuildAndTestHandler.h"
#include "cmCTestBuildAndTest.h"
#include <chrono>
#include <cstring>
@@ -19,19 +19,17 @@
struct cmMessageMetadata;
cmCTestBuildAndTestHandler::cmCTestBuildAndTestHandler() = default;
void cmCTestBuildAndTestHandler::Initialize()
cmCTestBuildAndTest::cmCTestBuildAndTest(cmCTest* ctest)
: CTest(ctest)
{
this->BuildTargets.clear();
this->Superclass::Initialize();
}
const char* cmCTestBuildAndTestHandler::GetOutput()
const char* cmCTestBuildAndTest::GetOutput()
{
return this->Output.c_str();
}
int cmCTestBuildAndTestHandler::ProcessHandler()
int cmCTestBuildAndTest::Run()
{
this->Output.clear();
cmSystemTools::ResetErrorOccurredFlag();
@@ -40,9 +38,8 @@ int cmCTestBuildAndTestHandler::ProcessHandler()
return retv;
}
int cmCTestBuildAndTestHandler::RunCMake(std::ostringstream& out,
std::string& cmakeOutString,
cmake* cm)
int cmCTestBuildAndTest::RunCMake(std::ostringstream& out,
std::string& cmakeOutString, cmake* cm)
{
std::vector<std::string> args;
args.push_back(cmSystemTools::GetCMakeCommand());
@@ -134,7 +131,7 @@ public:
const cmCTestBuildAndTestCaptureRAII&) = delete;
};
int cmCTestBuildAndTestHandler::RunCMakeAndTest()
int cmCTestBuildAndTest::RunCMakeAndTest()
{
// if the generator and make program are not specified then it is an error
if (this->BuildGenerator.empty()) {

16
Source/CTest/cmCTestBuildAndTestHandler.h → Source/CTest/cmCTestBuildAndTest.h
View File

@@ -8,35 +8,33 @@
#include <string>
#include <vector>
#include "cmCTestGenericHandler.h"
#include "cmDuration.h"
class cmake;
class cmCTest;
/** \class cmCTestBuildAndTestHandler
/** \class cmCTestBuildAndTest
* \brief A class that handles ctest -S invocations
*
*/
class cmCTestBuildAndTestHandler : public cmCTestGenericHandler
class cmCTestBuildAndTest
{
public:
using Superclass = cmCTestGenericHandler;
/*
* The main entry point for this class
*/
int ProcessHandler() override;
int Run();
/*
* Get the output variable
*/
const char* GetOutput();
cmCTestBuildAndTestHandler();
cmCTestBuildAndTest(cmCTest* ctest);
void Initialize() override;
private:
cmCTest* CTest;
protected:
//! Run CMake and build a test and then run it as a single test.
int RunCMakeAndTest();
int RunCMake(std::ostringstream& out, std::string& cmakeOutString,

112
Source/cmCTest.cxx
View File

@@ -41,7 +41,7 @@
#endif
#include "cmCMakePresetsGraph.h"
#include "cmCTestBuildAndTestHandler.h"
#include "cmCTestBuildAndTest.h"
#include "cmCTestBuildHandler.h"
#include "cmCTestConfigureHandler.h"
#include "cmCTestCoverageHandler.h"
@@ -83,6 +83,11 @@
struct cmCTest::Private
{
Private(cmCTest* ctest)
: BuildAndTest(ctest)
{
}
/** Representation of one part. */
struct PartInfo
{
@@ -123,7 +128,7 @@ struct cmCTest::Private
// these are helper classes
cmCTestBuildHandler BuildHandler;
cmCTestBuildAndTestHandler BuildAndTestHandler;
cmCTestBuildAndTest BuildAndTest;
cmCTestCoverageHandler CoverageHandler;
cmCTestScriptHandler ScriptHandler;
cmCTestTestHandler TestHandler;
@@ -135,17 +140,16 @@ struct cmCTest::Private
std::vector<cmCTestGenericHandler*> GetTestingHandlers()
{
return { &this->BuildHandler, &this->BuildAndTestHandler,
&this->CoverageHandler, &this->ScriptHandler,
&this->TestHandler, &this->UpdateHandler,
&this->ConfigureHandler, &this->MemCheckHandler,
&this->SubmitHandler, &this->UploadHandler };
return { &this->BuildHandler, &this->CoverageHandler,
&this->ScriptHandler, &this->TestHandler,
&this->UpdateHandler, &this->ConfigureHandler,
&this->MemCheckHandler, &this->SubmitHandler,
&this->UploadHandler };
}
std::map<std::string, cmCTestGenericHandler*> GetNamedTestingHandlers()
{
return { { "build", &this->BuildHandler },
{ "buildtest", &this->BuildAndTestHandler },
{ "coverage", &this->CoverageHandler },
{ "script", &this->ScriptHandler },
{ "test", &this->TestHandler },
@@ -342,7 +346,7 @@ std::string cmCTest::DecodeURL(const std::string& in)
}
cmCTest::cmCTest()
: Impl(new Private)
: Impl(cm::make_unique<Private>(this))
{
std::string envValue;
if (cmSystemTools::GetEnv("CTEST_OUTPUT_ON_FAILURE", envValue)) {
@@ -896,11 +900,6 @@ cmCTestBuildHandler* cmCTest::GetBuildHandler()
return &this->Impl->BuildHandler;
}
cmCTestBuildAndTestHandler* cmCTest::GetBuildAndTestHandler()
{
return &this->Impl->BuildAndTestHandler;
}
cmCTestCoverageHandler* cmCTest::GetCoverageHandler()
{
return &this->Impl->CoverageHandler;
@@ -2564,91 +2563,87 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
this->SetTest("Submit");
return this->SubmitExtraFiles(extra);
} },
CommandArgument{ "--build-and-test",
"--build-and-test must have source and binary dir",
CommandArgument::Values::Two,
[this, &cmakeAndTest](std::string const& dirs) -> bool {
cmakeAndTest = true;
cmList dirList{ dirs };
if (dirList.size() != 2) {
return false;
}
this->Impl->BuildAndTestHandler.SourceDir =
cmSystemTools::CollapseFullPath(dirList[0]);
this->Impl->BuildAndTestHandler.BinaryDir =
cmSystemTools::CollapseFullPath(dirList[1]);
cmSystemTools::MakeDirectory(
this->Impl->BuildAndTestHandler.BinaryDir);
return true;
} },
CommandArgument{
"--build-target", CommandArgument::Values::One,
[this](std::string const& t) -> bool {
this->Impl->BuildAndTestHandler.BuildTargets.emplace_back(t);
"--build-and-test", "--build-and-test must have source and binary dir",
CommandArgument::Values::Two,
[this, &cmakeAndTest](std::string const& dirs) -> bool {
cmakeAndTest = true;
cmList dirList{ dirs };
if (dirList.size() != 2) {
return false;
}
this->Impl->BuildAndTest.SourceDir =
cmSystemTools::CollapseFullPath(dirList[0]);
this->Impl->BuildAndTest.BinaryDir =
cmSystemTools::CollapseFullPath(dirList[1]);
cmSystemTools::MakeDirectory(this->Impl->BuildAndTest.BinaryDir);
return true;
} },
CommandArgument{ "--build-target", CommandArgument::Values::One,
[this](std::string const& t) -> bool {
this->Impl->BuildAndTest.BuildTargets.emplace_back(t);
return true;
} },
CommandArgument{ "--build-noclean", CommandArgument::Values::Zero,
[this](std::string const&) -> bool {
this->Impl->BuildAndTestHandler.BuildNoClean = true;
this->Impl->BuildAndTest.BuildNoClean = true;
return true;
} },
CommandArgument{ "--build-nocmake", CommandArgument::Values::Zero,
[this](std::string const&) -> bool {
this->Impl->BuildAndTestHandler.BuildNoCMake = true;
this->Impl->BuildAndTest.BuildNoCMake = true;
return true;
} },
CommandArgument{ "--build-two-config", CommandArgument::Values::Zero,
[this](std::string const&) -> bool {
this->Impl->BuildAndTestHandler.BuildTwoConfig = true;
this->Impl->BuildAndTest.BuildTwoConfig = true;
return true;
} },
CommandArgument{ "--build-run-dir", CommandArgument::Values::One,
[this](std::string const& dir) -> bool {
this->Impl->BuildAndTestHandler.BuildRunDir = dir;
this->Impl->BuildAndTest.BuildRunDir = dir;
return true;
} },
CommandArgument{ "--build-exe-dir", CommandArgument::Values::One,
[this](std::string const& dir) -> bool {
this->Impl->BuildAndTestHandler.ExecutableDirectory =
dir;
this->Impl->BuildAndTest.ExecutableDirectory = dir;
return true;
} },
CommandArgument{ "--test-timeout", CommandArgument::Values::One,
[this](std::string const& t) -> bool {
this->Impl->BuildAndTestHandler.Timeout =
this->Impl->BuildAndTest.Timeout =
cmDuration(atof(t.c_str()));
return true;
} },
CommandArgument{ "--build-generator", CommandArgument::Values::One,
[this](std::string const& g) -> bool {
this->Impl->BuildAndTestHandler.BuildGenerator = g;
this->Impl->BuildAndTest.BuildGenerator = g;
return true;
} },
CommandArgument{ "--build-generator-platform",
CommandArgument::Values::One,
[this](std::string const& p) -> bool {
this->Impl->BuildAndTest.BuildGeneratorPlatform = p;
return true;
} },
CommandArgument{
"--build-generator-platform", CommandArgument::Values::One,
[this](std::string const& p) -> bool {
this->Impl->BuildAndTestHandler.BuildGeneratorPlatform = p;
return true;
} },
CommandArgument{ "--build-generator-toolset", CommandArgument::Values::One,
[this](std::string const& t) -> bool {
this->Impl->BuildAndTestHandler.BuildGeneratorToolset =
t;
this->Impl->BuildAndTest.BuildGeneratorToolset = t;
return true;
} },
CommandArgument{ "--build-project", CommandArgument::Values::One,
[this](std::string const& p) -> bool {
this->Impl->BuildAndTestHandler.BuildProject = p;
this->Impl->BuildAndTest.BuildProject = p;
return true;
} },
CommandArgument{ "--build-makeprogram", CommandArgument::Values::One,
[this](std::string const& p) -> bool {
this->Impl->BuildAndTestHandler.BuildMakeProgram = p;
this->Impl->BuildAndTest.BuildMakeProgram = p;
return true;
} },
CommandArgument{ "--build-config-sample", CommandArgument::Values::One,
[this](std::string const& s) -> bool {
this->Impl->BuildAndTestHandler.ConfigSample = s;
this->Impl->BuildAndTest.ConfigSample = s;
return true;
} },
CommandArgument{ "-SP", CommandArgument::Values::One, dashSP },
@@ -3028,16 +3023,16 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
while (i + 1 < args.size() && args[i + 1] != "--build-target"_s &&
args[i + 1] != "--test-command"_s) {
++i;
this->Impl->BuildAndTestHandler.BuildOptions.emplace_back(args[i]);
this->Impl->BuildAndTest.BuildOptions.emplace_back(args[i]);
}
}
if (!matched && arg == "--test-command"_s && i + 1 < args.size()) {
matched = true;
++i;
this->Impl->BuildAndTestHandler.TestCommand = args[i];
this->Impl->BuildAndTest.TestCommand = args[i];
while (i + 1 < args.size()) {
++i;
this->Impl->BuildAndTestHandler.TestCommandArgs.emplace_back(args[i]);
this->Impl->BuildAndTest.TestCommandArgs.emplace_back(args[i]);
}
}
if (!matched && cmHasLiteralPrefix(arg, "-") &&
@@ -3174,9 +3169,8 @@ int cmCTest::ExecuteTests()
int cmCTest::RunCMakeAndTest(std::string* output)
{
this->Impl->Verbose = true;
cmCTestBuildAndTestHandler* handler = this->GetBuildAndTestHandler();
int retv = handler->ProcessHandler();
*output = handler->GetOutput();
int retv = this->Impl->BuildAndTest.Run();
*output = this->Impl->BuildAndTest.GetOutput();
#ifndef CMAKE_BOOTSTRAP
cmDynamicLoader::FlushCache();
#endif

2
Source/cmCTest.h
View File

@@ -19,7 +19,6 @@
#include "cmProcessOutput.h"
class cmCTestBuildHandler;
class cmCTestBuildAndTestHandler;
class cmCTestCoverageHandler;
class cmCTestScriptHandler;
class cmCTestTestHandler;
@@ -313,7 +312,6 @@ public:
* Get the handler object
*/
cmCTestBuildHandler* GetBuildHandler();
cmCTestBuildAndTestHandler* GetBuildAndTestHandler();
cmCTestCoverageHandler* GetCoverageHandler();
cmCTestScriptHandler* GetScriptHandler();
cmCTestTestHandler* GetTestHandler();