kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge topic 'reorganize-cmCTest' 

61fcd08a Help: Fix documentation of ctest --build-and-test
7c67d401 Help: Consistently use quotes and fix punctuation in ctest(1) manual
0076fb10 cmCTest: Update doxygen to be consistent
30c5f94c cmCTest: Rename "ProcessTests()" to "ProcessSteps()" and improve doxygen
7c87ab75 cmCTest: Facilitate code reading adding consistent comments in Run()
6d8b9aa6 cmCTest: Improve readability adding "HandleTest(Action|Model)Argument()"
280d0a69 cmCTest: Improve readability adding "RunCMakeAndTest()" and "ExecuteTests()"
898cb987 cmCTest: Fix typo
This commit is contained in:
Brad King 2016-07-06 09:35:38 -04:00 committed by CMake Topic Stage
parent 8df2e68614 61fcd08a49
commit 50adbfcacb
3 changed files with 300 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
Help/manual/ctest.1.rst
View File

@ -56,7 +56,7 @@ Options
Enable failover.
This option allows ctest to resume a test set execution that was
previously interrupted. If no interruption occurred, the -F option
previously interrupted. If no interruption occurred, the ``-F`` option
will have no effect.
``-j <jobs>, --parallel <jobs>``
@ -77,12 +77,12 @@ Options
Make ctest quiet.
This option will suppress all the output. The output log file will
still be generated if the --output-log is specified. Options such
as --verbose, --extra-verbose, and --debug are ignored if --quiet is
specified.
still be generated if the ``--output-log`` is specified. Options such
as ``--verbose``, ``--extra-verbose``, and ``--debug`` are ignored
if ``--quiet`` is specified.
``-O <file>, --output-log <file>``
Output to log file
Output to log file.
This option tells ctest to write all its output to a log file.
@ -90,7 +90,7 @@ Options
Disable actual execution of tests.
This option tells ctest to list the tests that would be run but not
actually run them. Useful in conjunction with the -R and -E
actually run them. Useful in conjunction with the ``-R`` and ``-E``
options.
``-L <regex>, --label-regex <regex>``
@ -118,7 +118,7 @@ Options
given regular expression.
``-D <dashboard>, --dashboard <dashboard>``
Execute dashboard test
Execute dashboard test.
This option tells ctest to act as a CDash client and perform a
dashboard test. All tests are <Mode><Test>, where Mode can be
@ -126,26 +126,27 @@ Options
Update, Configure, Build, Test, Coverage, and Submit.
``-D <var>:<type>=<value>``
Define a variable for script mode
Define a variable for script mode.
Pass in variable values on the command line. Use in conjunction
with -S to pass variable values to a dashboard script. Parsing -D
with ``-S`` to pass variable values to a dashboard script. Parsing ``-D``
arguments as variable values is only attempted if the value
following -D does not match any of the known dashboard types.
following ``-D`` does not match any of the known dashboard types.
``-M <model>, --test-model <model>``
Sets the model for a dashboard
Sets the model for a dashboard.
This option tells ctest to act as a CDash client where the TestModel
can be Experimental, Nightly, and Continuous. Combining -M and -T
is similar to -D
This option tells ctest to act as a CDash client where the ``<model>``
can be ``Experimental``, ``Nightly``, and ``Continuous``.
Combining ``-M`` and ``-T`` is similar to ``-D``.
``-T <action>, --test-action <action>``
Sets the dashboard action to perform
Sets the dashboard action to perform.
This option tells ctest to act as a CDash client and perform some
action such as start, build, test etc. Combining -M and -T is
similar to -D
action such as ``start``, ``build``, ``test`` etc. See
`Dashboard Client Steps`_ for the full list of actions.
Combining ``-M`` and ``-T`` is similar to ``-D``.
``--track <track>``
Specify the track to submit dashboard to
@ -156,24 +157,24 @@ Options
arbitrary.
``-S <script>, --script <script>``
Execute a dashboard for a configuration
Execute a dashboard for a configuration.
This option tells ctest to load in a configuration script which sets
a number of parameters such as the binary and source directories.
Then ctest will do what is required to create and run a dashboard.
This option basically sets up a dashboard and then runs ctest -D
This option basically sets up a dashboard and then runs ``ctest -D``
with the appropriate options.
``-SP <script>, --script-new-process <script>``
Execute a dashboard for a configuration
Execute a dashboard for a configuration.
This option does the same operations as -S but it will do them in a
This option does the same operations as ``-S`` but it will do them in a
separate process. This is primarily useful in cases where the
script may modify the environment and you do not want the modified
environment to impact other -S scripts.
environment to impact other ``-S`` scripts.
``-A <file>, --add-notes <file>``
Add a notes file with submission
Add a notes file with submission.
This option tells ctest to include a notes file when submitting
dashboard.
@ -188,19 +189,19 @@ Options
contains the same syntax as the command line.
``-U, --union``
Take the Union of -I and -R
Take the Union of ``-I`` and ``-R``.
When both -R and -I are specified by default the intersection of
tests are run. By specifying -U the union of tests is run instead.
When both ``-R`` and ``-I`` are specified by default the intersection of
tests are run. By specifying ``-U`` the union of tests is run instead.
``--rerun-failed``
Run only the tests that failed previously
Run only the tests that failed previously.
This option tells ctest to perform only the tests that failed during
its previous run. When this option is specified, ctest ignores all
other options intended to modify the list of tests to run (-L, -R,
-E, -LE, -I, etc). In the event that CTest runs and no tests fail,
subsequent calls to ctest with the --rerun-failed option will run
other options intended to modify the list of tests to run (``-L``, ``-R``,
``-E``, ``-LE``, ``-I``, etc). In the event that CTest runs and no tests
fail, subsequent calls to ctest with the ``--rerun-failed`` option will run
the set of tests that most recently failed (if any).
``--repeat-until-fail <n>``
@ -209,7 +210,7 @@ Options
This is useful in finding sporadic failures in test cases.
``--max-width <width>``
Set the max width for a test name to output
Set the max width for a test name to output.
Set the maximum width for each test name to show in the output.
This allows the user to widen the output to avoid clipping the test
@ -232,26 +233,25 @@ Options
label associated with the tests run. If there are no labels on the
tests, nothing extra is printed.
``--build-and-test``
``--build-and-test <path-to-source> <path-to-build>``
Configure, build and run a test.
This option tells ctest to configure (i.e. run cmake on), build,
and or execute a test. The configure and test steps are optional.
The arguments to this command line are the source and binary
directories. By default this will run CMake on the Source/Bin
directories specified unless --build-nocmake is specified.
The --build-generator option *must* be provided to use
--build-and-test. If --test-command is specified then that will be
directories.
The ``--build-generator`` option *must* be provided to use
``--build-and-test``. If ``--test-command`` is specified then that will be
run after the build is complete. Other options that affect this
mode are --build-target --build-nocmake, --build-run-dir,
--build-two-config, --build-exe-dir,
--build-project,--build-noclean, --build-options
mode are ``--build-target``, ``--build-nocmake``, ``--build-run-dir``,
``--build-two-config``, ``--build-exe-dir``,
``--build-project``, ``--build-noclean`` and ``--build-options``.
``--build-target``
Specify a specific target to build.
This option goes with the --build-and-test option, if left out the
all target is built.
This option goes with the ``--build-and-test`` option, if left out the
``all`` target is built.
``--build-nocmake``
Run the build without running cmake first.
@ -264,13 +264,13 @@ Options
Directory where programs will be after it has been compiled.
``--build-two-config``
Run CMake twice
Run CMake twice.
``--build-exe-dir``
Specify the directory for the executable.
``--build-generator``
Specify the generator to use.
Specify the generator to use. See the :manual:`cmake-generators(7)` manual.
``--build-generator-platform``
Specify the generator-specific platform.
@ -288,25 +288,23 @@ Options
Skip the make clean step.
``--build-config-sample``
A sample executable to use to determine the configuration
A sample executable to use to determine the configuration that
should be used. e.g. Debug/Release/etc
should be used. e.g. Debug/Release/etc.
``--build-options``
Add extra options to the build step.
This option must be the last option with the exception of
--test-command
``--test-command``
``--test-command``
The test to run with the --build-and-test option.
The test to run with the ``--build-and-test`` option.
``--test-output-size-passed <size>``
Limit the output for passed tests to <size> bytes.
Limit the output for passed tests to ``<size>`` bytes.
``--test-output-size-failed <size>``
Limit the output for failed tests to <size> bytes.
Limit the output for failed tests to ``<size>`` bytes.
``--test-timeout``
The time limit in seconds, internal use only.
@ -335,14 +333,14 @@ Options
This option will submit extra files to the dashboard.
``--force-new-ctest-process``
Run child CTest instances as new processes
Run child CTest instances as new processes.
By default CTest will run child CTest instances within the same
process. If this behavior is not desired, this argument will
enforce new processes for child CTest processes.
``--schedule-random``
Use a random order for scheduling tests
Use a random order for scheduling tests.
This option will run the tests in a random order. It is commonly
used to detect implicit dependencies in a test suite.
@ -361,7 +359,7 @@ Options
Set a time at which all tests should stop running.
Set a real time of day at which all tests should timeout. Example:
7:00:00 -0400. Any time format understood by the curl date parser
``7:00:00 -0400``. Any time format understood by the curl date parser
is accepted. Local time is assumed if no timezone is specified.
``--http1.0``

163
Source/cmCTest.cxx
View File

@ -886,7 +886,7 @@ int cmCTest::ExecuteHandler(const char* shandler)
return handler->ProcessHandler();
}
int cmCTest::ProcessTests()
int cmCTest::ProcessSteps()
{
int res = 0;
bool notest = true;
@ -2018,7 +2018,7 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
// handle the script arguments -S -SR -SP
this->HandleScriptArguments(i, args, SRArgumentSpecified);
// handle a request for a dashboard
// --dashboard: handle a request for a dashboard
std::string arg = args[i];
if (this->CheckArgument(arg, "-D", "--dashboard") && i < args.size() - 1) {
this->ProduceXML = true;
@ -2044,54 +2044,18 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
this->AddVariableDefinition(input);
}
if (this->CheckArgument(arg, "-T", "--test-action") &&
(i < args.size() - 1)) {
this->ProduceXML = true;
i++;
if (!this->SetTest(args[i].c_str(), false)) {
// --test-action: calls SetTest(<stage>, /*report=*/ false) to enable
// the corresponding stage
if (!this->HandleTestActionArgument(ctestExec, i, args)) {
executeTests = false;
cmCTestLog(this, ERROR_MESSAGE,
"CTest -T called with incorrect option: " << args[i]
<< std::endl);
cmCTestLog(this, ERROR_MESSAGE, "Available options are:"
<< std::endl
<< " " << ctestExec << " -T all" << std::endl
<< " " << ctestExec << " -T start" << std::endl
<< " " << ctestExec << " -T update" << std::endl
<< " " << ctestExec << " -T configure" << std::endl
<< " " << ctestExec << " -T build" << std::endl
<< " " << ctestExec << " -T test" << std::endl
<< " " << ctestExec << " -T coverage" << std::endl
<< " " << ctestExec << " -T memcheck" << std::endl
<< " " << ctestExec << " -T notes" << std::endl
<< " " << ctestExec << " -T submit" << std::endl);
}
}
// what type of test model
if (this->CheckArgument(arg, "-M", "--test-model") &&
(i < args.size() - 1)) {
i++;
std::string const& str = args[i];
if (cmSystemTools::LowerCase(str) == "nightly") {
this->SetTestModel(cmCTest::NIGHTLY);
} else if (cmSystemTools::LowerCase(str) == "continuous") {
this->SetTestModel(cmCTest::CONTINUOUS);
} else if (cmSystemTools::LowerCase(str) == "experimental") {
this->SetTestModel(cmCTest::EXPERIMENTAL);
} else {
// --test-model: what type of test model
if (!this->HandleTestModelArgument(ctestExec, i, args)) {
executeTests = false;
cmCTestLog(this, ERROR_MESSAGE,
"CTest -M called with incorrect option: " << str
<< std::endl);
cmCTestLog(this, ERROR_MESSAGE, "Available options are:"
<< std::endl
<< " " << ctestExec << " -M Continuous" << std::endl
<< " " << ctestExec << " -M Experimental" << std::endl
<< " " << ctestExec << " -M Nightly" << std::endl);
}
}
// --extra-submit
if (this->CheckArgument(arg, "--extra-submit") && i < args.size() - 1) {
this->ProduceXML = true;
this->SetTest("Submit");
@ -2106,6 +2070,7 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
cmakeAndTest = true;
}
// --schedule-random
if (this->CheckArgument(arg, "--schedule-random")) {
this->ScheduleType = "Random";
}
@ -2124,6 +2089,7 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
}
} // the close of the for argument loop
// handle CTEST_PARALLEL_LEVEL environment variable
if (!this->ParallelLevelSetInCli) {
if (const char* parallel = cmSystemTools::GetEnv("CTEST_PARALLEL_LEVEL")) {
int plevel = atoi(parallel);
@ -2131,25 +2097,80 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
}
}
// now what sould cmake do? if --build-and-test was specified then
// now what should cmake do? if --build-and-test was specified then
// we run the build and test handler and return
if (cmakeAndTest) {
this->Verbose = true;
cmCTestBuildAndTestHandler* handler =
static_cast<cmCTestBuildAndTestHandler*>(this->GetHandler("buildtest"));
int retv = handler->ProcessHandler();
*output = handler->GetOutput();
#ifdef CMAKE_BUILD_WITH_CMAKE
cmDynamicLoader::FlushCache();
#endif
if (retv != 0) {
cmCTestLog(this, DEBUG,
"build and test failing returning: " << retv << std::endl);
}
return retv;
return this->RunCMakeAndTest(output);
}
if (executeTests) {
return this->ExecuteTests();
}
return 1;
}
bool cmCTest::HandleTestActionArgument(const char* ctestExec, size_t& i,
const std::vector<std::string>& args)
{
bool success = true;
std::string arg = args[i];
if (this->CheckArgument(arg, "-T", "--test-action") &&
(i < args.size() - 1)) {
this->ProduceXML = true;
i++;
if (!this->SetTest(args[i].c_str(), false)) {
success = false;
cmCTestLog(this, ERROR_MESSAGE, "CTest -T called with incorrect option: "
<< args[i] << std::endl);
cmCTestLog(this, ERROR_MESSAGE, "Available options are:"
<< std::endl
<< " " << ctestExec << " -T all" << std::endl
<< " " << ctestExec << " -T start" << std::endl
<< " " << ctestExec << " -T update" << std::endl
<< " " << ctestExec << " -T configure" << std::endl
<< " " << ctestExec << " -T build" << std::endl
<< " " << ctestExec << " -T test" << std::endl
<< " " << ctestExec << " -T coverage" << std::endl
<< " " << ctestExec << " -T memcheck" << std::endl
<< " " << ctestExec << " -T notes" << std::endl
<< " " << ctestExec << " -T submit" << std::endl);
}
}
return success;
}
bool cmCTest::HandleTestModelArgument(const char* ctestExec, size_t& i,
const std::vector<std::string>& args)
{
bool success = true;
std::string arg = args[i];
if (this->CheckArgument(arg, "-M", "--test-model") &&
(i < args.size() - 1)) {
i++;
std::string const& str = args[i];
if (cmSystemTools::LowerCase(str) == "nightly") {
this->SetTestModel(cmCTest::NIGHTLY);
} else if (cmSystemTools::LowerCase(str) == "continuous") {
this->SetTestModel(cmCTest::CONTINUOUS);
} else if (cmSystemTools::LowerCase(str) == "experimental") {
this->SetTestModel(cmCTest::EXPERIMENTAL);
} else {
success = false;
cmCTestLog(this, ERROR_MESSAGE, "CTest -M called with incorrect option: "
<< str << std::endl);
cmCTestLog(this, ERROR_MESSAGE, "Available options are:"
<< std::endl
<< " " << ctestExec << " -M Continuous" << std::endl
<< " " << ctestExec << " -M Experimental" << std::endl
<< " " << ctestExec << " -M Nightly" << std::endl);
}
}
return success;
}
int cmCTest::ExecuteTests()
{
int res;
// call process directory
if (this->RunConfigurationScript) {
@ -2157,8 +2178,8 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
cmCTestLog(this, OUTPUT, "* Extra verbosity turned on" << std::endl);
}
cmCTest::t_TestingHandlers::iterator it;
for (it = this->TestingHandlers.begin();
it != this->TestingHandlers.end(); ++it) {
for (it = this->TestingHandlers.begin(); it != this->TestingHandlers.end();
++it) {
it->second->SetVerbose(this->ExtraVerbose);
it->second->SetSubmitIndex(this->SubmitIndex);
}
@ -2175,8 +2196,8 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
this->ExtraVerbose = this->Verbose;
this->Verbose = true;
cmCTest::t_TestingHandlers::iterator it;
for (it = this->TestingHandlers.begin();
it != this->TestingHandlers.end(); ++it) {
for (it = this->TestingHandlers.begin(); it != this->TestingHandlers.end();
++it) {
it->second->SetVerbose(this->Verbose);
it->second->SetSubmitIndex(this->SubmitIndex);
}
@ -2186,7 +2207,7 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
cmCTestLog(this, ERROR_MESSAGE, "Problem initializing the dashboard."
<< std::endl);
} else {
res = this->ProcessTests();
res = this->ProcessSteps();
}
this->Finalize();
}
@ -2197,7 +2218,21 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output)
return res;
}
return 1;
int cmCTest::RunCMakeAndTest(std::string* output)
{
this->Verbose = true;
cmCTestBuildAndTestHandler* handler =
static_cast<cmCTestBuildAndTestHandler*>(this->GetHandler("buildtest"));
int retv = handler->ProcessHandler();
*output = handler->GetOutput();
#ifdef CMAKE_BUILD_WITH_CMAKE
cmDynamicLoader::FlushCache();
#endif
if (retv != 0) {
cmCTestLog(this, DEBUG, "build and test failing returning: " << retv
<< std::endl);
}
return retv;
}
void cmCTest::SetNotesFiles(const char* notes)

173
Source/cmCTest.h
View File

@ -53,6 +53,13 @@ class cmXMLWriter;
#endif
#define cout no_cout_use_cmCTestLog
/** \class cmCTest
* \brief Represents a ctest invocation.
*
* This class represents a ctest invocation. It is the top level class when
* running ctest.
*
*/
class cmCTest
{
friend class cmCTestRunTest;
@ -119,7 +126,7 @@ public:
typedef std::vector<cmsys::String> VectorOfStrings;
typedef std::set<std::string> SetOfStrings;
///! Process Command line arguments
/** Process Command line arguments */
int Run(std::vector<std::string>&, std::string* output = CM_NULLPTR);
/**
@ -129,23 +136,30 @@ public:
void Finalize();
/**
* Process the tests. This is the main routine. The execution of the
* tests should look like this:
* Process the dashboard client steps.
*
* Steps are enabled using SetTest()
*
* The execution of the steps (or #Part) should look like this:
*
* /code
* ctest foo;
* foo.Initialize();
* // Set some things on foo
* foo.ProcessTests();
* foo.ProcessSteps();
* foo.Finalize();
* /endcode
*
* \sa Initialize(), Finalize(), Part, PartInfo, SetTest()
*/
int ProcessTests();
int ProcessSteps();
/*
/**
* A utility function that returns the nightly time
*/
struct tm* GetNightlyTime(std::string const& str, bool tomorrowtag);
/*
/**
* Is the tomorrow tag set?
*/
bool GetTomorrowTag() { return this->TomorrowTag; }
@ -155,14 +169,14 @@ public:
*/
int TestDirectory(bool memcheck);
///! what is the configuraiton type, e.g. Debug, Release etc.
/** what is the configuraiton type, e.g. Debug, Release etc. */
std::string const& GetConfigType();
double GetTimeOut() { return this->TimeOut; }
void SetTimeOut(double t) { this->TimeOut = t; }
double GetGlobalTimeout() { return this->GlobalTimeout; }
// how many test to run at the same time
/** how many test to run at the same time */
int GetParallelLevel() { return this->ParallelLevel; }
void SetParallelLevel(int);
@ -200,19 +214,19 @@ public:
cmCTest();
~cmCTest();
//! Set the notes files to be created.
/** Set the notes files to be created. */
void SetNotesFiles(const char* notes);
void PopulateCustomVector(cmMakefile* mf, const std::string& definition,
std::vector<std::string>& vec);
void PopulateCustomInteger(cmMakefile* mf, const std::string& def, int& val);
///! Get the current time as string
/** Get the current time as string */
std::string CurrentTime();
//! tar/gzip and then base 64 encode a file
/** tar/gzip and then base 64 encode a file */
std::string Base64GzipEncodeFile(std::string const& file);
//! base64 encode a file
/** base64 encode a file */
std::string Base64EncodeFile(std::string const& file);
/**
@ -222,11 +236,13 @@ public:
*/
double GetRemainingTimeAllowed();
///! Open file in the output directory and set the stream
/**
* Open file in the output directory and set the stream
*/
bool OpenOutputFile(const std::string& path, const std::string& name,
cmGeneratedFileStream& stream, bool compress = false);
///! Should we only show what we would do?
/** Should we only show what we would do? */
bool GetShowOnly();
bool ShouldUseHTTP10() { return this->UseHTTP10; }
@ -242,11 +258,11 @@ public:
std::string GetStopTime() { return this->StopTime; }
void SetStopTime(std::string const& time);
// Used for parallel ctest job scheduling
/** Used for parallel ctest job scheduling */
std::string GetScheduleType() { return this->ScheduleType; }
void SetScheduleType(std::string type) { this->ScheduleType = type; }
///! The max output width
/** The max output width */
int GetMaxTestNameWidth() const;
void SetMaxTestNameWidth(int w) { this->MaxTestNameWidth = w; }
@ -274,31 +290,37 @@ public:
std::string* stdErr, int* retVal = CM_NULLPTR,
const char* dir = CM_NULLPTR, double timeout = 0.0);
//! Clean/make safe for xml the given value such that it may be used as
// one of the key fields by CDash when computing the buildid.
/**
* Clean/make safe for xml the given value such that it may be used as
* one of the key fields by CDash when computing the buildid.
*/
static std::string SafeBuildIdField(const std::string& value);
//! Start CTest XML output file
/** Start CTest XML output file */
void StartXML(cmXMLWriter& xml, bool append);
//! End CTest XML output file
/** End CTest XML output file */
void EndXML(cmXMLWriter& xml);
//! Run command specialized for make and configure. Returns process status
// and retVal is return value or exception.
/**
* Run command specialized for make and configure. Returns process status
* and retVal is return value or exception.
*/
int RunMakeCommand(const char* command, std::string& output, int* retVal,
const char* dir, int timeout, std::ostream& ofs);
/*
* return the current tag
*/
/** Return the current tag */
std::string GetCurrentTag();
//! Get the path to the build tree
/** Get the path to the build tree */
std::string GetBinaryDir();
//! Get the short path to the file. This means if the file is in binary or
// source directory, it will become /.../relative/path/to/file
/**
* Get the short path to the file.
*
* This means if the file is in binary or
* source directory, it will become /.../relative/path/to/file
*/
std::string GetShortPathToFile(const char* fname);
enum
@ -308,7 +330,7 @@ public:
CONTINUOUS
};
// provide some more detailed info on the return code for ctest
/** provide some more detailed info on the return code for ctest */
enum
{
UPDATE_ERRORS = 0x01,
@ -320,14 +342,16 @@ public:
SUBMIT_ERRORS = 0x40
};
///! Are we producing XML
/** Are we producing XML */
bool GetProduceXML();
void SetProduceXML(bool v);
//! Run command specialized for tests. Returns process status and retVal is
// return value or exception. If environment is non-null, it is used to set
// environment variables prior to running the test. After running the test,
// environment variables are restored to their previous values.
/**
* Run command specialized for tests. Returns process status and retVal is
* return value or exception. If environment is non-null, it is used to set
* environment variables prior to running the test. After running the test,
* environment variables are restored to their previous values.
*/
int RunTest(std::vector<const char*> args, std::string* output, int* retVal,
std::ostream* logfile, double testTimeOut,
std::vector<std::string>* environment);
@ -338,13 +362,13 @@ public:
*/
int ExecuteHandler(const char* handler);
/*
/**
* Get the handler object
*/
cmCTestGenericHandler* GetHandler(const char* handler);
cmCTestGenericHandler* GetInitializedHandler(const char* handler);
/*
/**
* Set the CTest variable from CMake variable
*/
bool SetCTestConfigurationFromCMakeVariable(cmMakefile* mf,
@ -352,37 +376,42 @@ public:
const std::string& cmake_var,
bool suppress = false);
//! Make string safe to be send as an URL
/** Make string safe to be send as an URL */
static std::string MakeURLSafe(const std::string&);
/** Decode a URL to the original string. */
static std::string DecodeURL(const std::string&);
//! Should ctect configuration be updated. When using new style ctest
// script, this should be true.
/**
* Should ctect configuration be updated. When using new style ctest
* script, this should be true.
*/
void SetSuppressUpdatingCTestConfiguration(bool val)
{
this->SuppressUpdatingCTestConfiguration = val;
}
//! Add overwrite to ctest configuration.
// The format is key=value
/**
* Add overwrite to ctest configuration.
*
* The format is key=value
*/
void AddCTestConfigurationOverwrite(const std::string& encstr);
//! Create XML file that contains all the notes specified
/** Create XML file that contains all the notes specified */
int GenerateNotesFile(const VectorOfStrings& files);
//! Submit extra files to the server
/** Submit extra files to the server */
bool SubmitExtraFiles(const char* files);
bool SubmitExtraFiles(const VectorOfStrings& files);
//! Set the output log file name
/** Set the output log file name */
void SetOutputLogFileName(const char* name);
//! Set the visual studio or Xcode config type
/** Set the visual studio or Xcode config type */
void SetConfigType(const char* ct);
//! Various log types
/** Various log types */
enum
{
DEBUG = 0,
@ -395,15 +424,15 @@ public:
OTHER
};
//! Add log to the output
/** Add log to the output */
void Log(int logType, const char* file, int line, const char* msg,
bool suppress = false);
//! Get the version of dart server
/** Get the version of dart server */
int GetDartVersion() { return this->DartVersion; }
int GetDropSiteCDash() { return this->DropSiteCDash; }
//! Add file to be submitted
/** Add file to be submitted */
void AddSubmitFile(Part part, const char* name);
std::vector<std::string> const& GetSubmitFiles(Part part)
{
@ -411,7 +440,9 @@ public:
}
void ClearSubmitFiles(Part part) { this->Parts[part].SubmitFiles.clear(); }
//! Read the custom configuration files and apply them to the current ctest
/**
* Read the custom configuration files and apply them to the current ctest
*/
int ReadCustomConfigurationFileTree(const char* dir, cmMakefile* mf);
std::vector<std::string>& GetInitialCommandLineArguments()
@ -419,7 +450,7 @@ public:
return this->InitialCommandLineArguments;
}
//! Set the track to submit to
/** Set the track to submit to */
void SetSpecificTrack(const char* track);
const char* GetSpecificTrack();
@ -447,10 +478,13 @@ public:
{
return this->Definitions;
}
// return the number of times a test should be run
/** Return the number of times a test should be run */
int GetTestRepeat() { return this->RepeatTests; }
// return true if test should run until fail
/** Return true if test should run until fail */
bool GetRepeatUntilFail() { return this->RepeatUntilFail; }
private:
int RepeatTests;
bool RepeatUntilFail;
@ -485,7 +519,7 @@ private:
bool ShowOnly;
//! Map of configuration properties
/** Map of configuration properties */
typedef std::map<std::string, std::string> CTestConfigurationMap;
std::string CTestConfigFile;
@ -549,36 +583,47 @@ private:
*/
int Initialize(const char* binary_dir, cmCTestStartCommand* command);
//! parse the option after -D and convert it into the appropriate steps
/** parse the option after -D and convert it into the appropriate steps */
bool AddTestsForDashboardType(std::string& targ);
//! read as "emit an error message for an unknown -D value"
/** read as "emit an error message for an unknown -D value" */
void ErrorMessageUnknownDashDValue(std::string& val);
//! add a variable definition from a command line -D value
/** add a variable definition from a command line -D value */
bool AddVariableDefinition(const std::string& arg);
//! parse and process most common command line arguments
/** parse and process most common command line arguments */
bool HandleCommandLineArguments(size_t& i, std::vector<std::string>& args,
std::string& errormsg);
//! hande the -S -SP and -SR arguments
/** hande the -S -SP and -SR arguments */
void HandleScriptArguments(size_t& i, std::vector<std::string>& args,
bool& SRArgumentSpecified);
//! Reread the configuration file
/** Reread the configuration file */
bool UpdateCTestConfiguration();
//! Create note from files.
/** Create note from files. */
int GenerateCTestNotesOutput(cmXMLWriter& xml, const VectorOfStrings& files);
//! Check if the argument is the one specified
/** Check if the argument is the one specified */
bool CheckArgument(const std::string& arg, const char* varg1,
const char* varg2 = CM_NULLPTR);
//! Output errors from a test
/** Output errors from a test */
void OutputTestErrors(std::vector<char> const& process_output);
/** Handle the --test-action command line argument */
bool HandleTestActionArgument(const char* ctestExec, size_t& i,
const std::vector<std::string>& args);
/** Handle the --test-model command line argument */
bool HandleTestModelArgument(const char* ctestExec, size_t& i,
const std::vector<std::string>& args);
int RunCMakeAndTest(std::string* output);
int ExecuteTests();
bool SuppressUpdatingCTestConfiguration;
bool Debug;