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

ENH: added per test timeout support

This commit is contained in:
Ken Martin 2007-01-25 11:16:16 -05:00
parent f71ad851d8
commit 2f84bd1758
8 changed files with 345 additions and 289 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
Source/CTest/cmCTestBuildAndTestHandler.cxx
View File

@ -29,6 +29,7 @@ cmCTestBuildAndTestHandler::cmCTestBuildAndTestHandler()
this->BuildTwoConfig = false;
this->BuildNoClean = false;
this->BuildNoCMake = false;
this->Timeout = 0;
}
//----------------------------------------------------------------------
@ -146,7 +147,6 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
cmSystemTools::SetErrorCallback(CMakeMessageCallback, &cmakeOutString);
cmSystemTools::SetStdoutCallback(CMakeStdoutCallback, &cmakeOutString);
cmOStringStream out;
// What is this? double timeout = this->CTest->GetTimeOut();
// if the generator and make program are not specified then it is an error
if (!this->BuildGenerator.size() || !this->BuildMakeProgram.size())
@ -217,7 +217,7 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
*outstring = out.str();
}
// if not test was specified then we are done
// if no test was specified then we are done
if (!this->TestCommand.size())
{
return 0;
@ -361,8 +361,8 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
out << this->TestCommandArgs[k] << " ";
}
out << "\n";
// What is this? this->TimeOut = timeout;
int runTestRes = this->CTest->RunTest(testCommand, &outs, &retval, 0);
int runTestRes = this->CTest->RunTest(testCommand, &outs, &retval, 0,
this->Timeout);
if(runTestRes != cmsysProcess_State_Exited || retval != 0)
{
out << "Failed to run test command: " << testCommand[0] << "\n";
@ -432,6 +432,11 @@ int cmCTestBuildAndTestHandler::ProcessCommandLineArguments(
idx++;
this->ExecutableDirectory = allArgs[idx];
}
if(currentArg.find("--test-timeout",0) == 0 && idx < allArgs.size() - 1)
{
idx++;
this->Timeout = atof(allArgs[idx].c_str());
}
if(currentArg.find("--build-generator",0) == 0 && idx < allArgs.size() - 1)
{
idx++;

1
Source/CTest/cmCTestBuildAndTestHandler.h
View File

@ -75,6 +75,7 @@ protected:
std::vector<std::string> TestCommandArgs;
std::vector<std::string> BuildTargets;
bool BuildNoCMake;
double Timeout;
};
#endif

575
Source/CTest/cmCTestTestHandler.cxx
View File

@ -558,6 +558,292 @@ int cmCTestTestHandler::ProcessHandler()
return 0;
}
//----------------------------------------------------------------------
void cmCTestTestHandler::ProcessOneTest(cmCTestTestProperties *it,
std::vector<cmStdString> &passed,
std::vector<cmStdString> &failed,
int cnt, int tmsize)
{
const std::string& testname = it->Name;
std::vector<std::string>& args = it->Args;
cmCTestTestResult cres;
cres.Properties = &*it;
cres.ExecutionTime = 0;
cres.ReturnValue = -1;
cres.Status = cmCTestTestHandler::NOT_RUN;
cres.TestCount = cnt;
cres.Name = testname;
cres.Path = it->Directory.c_str();
cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(3) << cnt << "/");
cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(3) << tmsize << " ");
if ( this->MemCheck )
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Memory Check");
}
else
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Testing");
}
cmCTestLog(this->CTest, HANDLER_OUTPUT, " ");
std::string outname = testname;
outname.resize(30, ' ');
*this->LogFile << cnt << "/" << tmsize << " Testing: " << testname
<< std::endl;
if ( this->CTest->GetShowOnly() )
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, outname.c_str() << std::endl);
}
else
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, outname.c_str());
}
cmCTestLog(this->CTest, DEBUG, "Testing " << args[0].c_str() << " ... ");
// find the test executable
std::string actualCommand = this->FindTheExecutable(args[1].c_str());
std::string testCommand
= cmSystemTools::ConvertToOutputPath(actualCommand.c_str());
// continue if we did not find the executable
if (testCommand == "")
{
*this->LogFile << "Unable to find executable: " << args[1].c_str()
<< std::endl;
cmCTestLog(this->CTest, ERROR_MESSAGE, "Unable to find executable: "
<< args[1].c_str() << std::endl);
cres.Output = "Unable to find executable: " + args[1];
if ( !this->CTest->GetShowOnly() )
{
cres.FullCommandLine = actualCommand;
this->TestResults.push_back( cres );
failed.push_back(testname);
return;
}
}
// add the arguments
std::vector<std::string>::const_iterator j = args.begin();
++j;
++j;
std::vector<const char*> arguments;
this->GenerateTestCommand(arguments);
arguments.push_back(actualCommand.c_str());
for(;j != args.end(); ++j)
{
testCommand += " ";
testCommand += cmSystemTools::EscapeSpaces(j->c_str());
arguments.push_back(j->c_str());
}
arguments.push_back(0);
/**
* Run an executable command and put the stdout in output.
*/
std::string output;
int retVal = 0;
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl
<< (this->MemCheck?"MemCheck":"Test")
<< " command: " << testCommand
<< std::endl);
*this->LogFile << cnt << "/" << tmsize
<< " Test: " << testname.c_str() << std::endl;
*this->LogFile << "Command: ";
std::vector<cmStdString>::size_type ll;
for ( ll = 0; ll < arguments.size()-1; ll ++ )
{
*this->LogFile << "\"" << arguments[ll] << "\" ";
}
*this->LogFile
<< std::endl
<< "Directory: " << it->Directory << std::endl
<< "\"" << testname.c_str() << "\" start time: "
<< this->CTest->CurrentTime() << std::endl
<< "Output:" << std::endl
<< "----------------------------------------------------------"
<< std::endl;
int res = 0;
double clock_start, clock_finish;
clock_start = cmSystemTools::GetTime();
if ( !this->CTest->GetShowOnly() )
{
res = this->CTest->RunTest(arguments, &output, &retVal, this->LogFile,
it->Timeout);
}
clock_finish = cmSystemTools::GetTime();
if ( this->LogFile )
{
double ttime = clock_finish - clock_start;
int hours = static_cast<int>(ttime / (60 * 60));
int minutes = static_cast<int>(ttime / 60) % 60;
int seconds = static_cast<int>(ttime) % 60;
char buffer[100];
sprintf(buffer, "%02d:%02d:%02d", hours, minutes, seconds);
*this->LogFile
<< "----------------------------------------------------------"
<< std::endl
<< "\"" << testname.c_str() << "\" end time: "
<< this->CTest->CurrentTime() << std::endl
<< "\"" << testname.c_str() << "\" time elapsed: "
<< buffer << std::endl
<< "----------------------------------------------------------"
<< std::endl << std::endl;
}
cres.ExecutionTime = (double)(clock_finish - clock_start);
cres.FullCommandLine = testCommand;
if ( !this->CTest->GetShowOnly() )
{
bool testFailed = false;
std::vector<cmsys::RegularExpression>::iterator passIt;
bool forceFail = false;
if ( it->RequiredRegularExpressions.size() > 0 )
{
bool found = false;
for ( passIt = it->RequiredRegularExpressions.begin();
passIt != it->RequiredRegularExpressions.end();
++ passIt )
{
if ( passIt->find(output.c_str()) )
{
found = true;
}
}
if ( !found )
{
forceFail = true;
}
}
if ( it->ErrorRegularExpressions.size() > 0 )
{
for ( passIt = it->ErrorRegularExpressions.begin();
passIt != it->ErrorRegularExpressions.end();
++ passIt )
{
if ( passIt->find(output.c_str()) )
{
forceFail = true;
}
}
}
if (res == cmsysProcess_State_Exited &&
(retVal == 0 || it->RequiredRegularExpressions.size()) &&
!forceFail)
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, " Passed");
if ( it->WillFail )
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, " - But it should fail!");
cres.Status = cmCTestTestHandler::FAILED;
testFailed = true;
}
else
{
cres.Status = cmCTestTestHandler::COMPLETED;
}
cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
}
else
{
testFailed = true;
cres.Status = cmCTestTestHandler::FAILED;
if ( res == cmsysProcess_State_Expired )
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Timeout" << std::endl);
cres.Status = cmCTestTestHandler::TIMEOUT;
}
else if ( res == cmsysProcess_State_Exception )
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Exception: ");
switch ( retVal )
{
case cmsysProcess_Exception_Fault:
cmCTestLog(this->CTest, HANDLER_OUTPUT, "SegFault");
cres.Status = cmCTestTestHandler::SEGFAULT;
break;
case cmsysProcess_Exception_Illegal:
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Illegal");
cres.Status = cmCTestTestHandler::ILLEGAL;
break;
case cmsysProcess_Exception_Interrupt:
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Interrupt");
cres.Status = cmCTestTestHandler::INTERRUPT;
break;
case cmsysProcess_Exception_Numerical:
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Numerical");
cres.Status = cmCTestTestHandler::NUMERICAL;
break;
default:
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Other");
cres.Status = cmCTestTestHandler::OTHER_FAULT;
}
cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
}
else if ( res == cmsysProcess_State_Error )
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Bad command " << res
<< std::endl);
cres.Status = cmCTestTestHandler::BAD_COMMAND;
}
else
{
// Force fail will also be here?
cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Failed");
if ( it->WillFail )
{
cres.Status = cmCTestTestHandler::COMPLETED;
cmCTestLog(this->CTest, HANDLER_OUTPUT, " - supposed to fail");
testFailed = false;
}
cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
}
}
if ( testFailed )
{
failed.push_back(testname);
}
else
{
passed.push_back(testname);
}
if (!output.empty() && output.find("<DartMeasurement") != output.npos)
{
if (this->DartStuff.find(output.c_str()))
{
std::string dartString = this->DartStuff.match(1);
cmSystemTools::ReplaceString(output, dartString.c_str(),"");
cres.RegressionImages
= this->GenerateRegressionImages(dartString);
}
}
}
if ( cres.Status == cmCTestTestHandler::COMPLETED )
{
this->CleanTestOutput(output, static_cast<size_t>
(this->CustomMaximumPassedTestOutputSize));
}
else
{
this->CleanTestOutput(output, static_cast<size_t>
(this->CustomMaximumFailedTestOutputSize));
}
cres.Output = output;
cres.ReturnValue = retVal;
cres.CompletionStatus = "Completed";
this->TestResults.push_back( cres );
}
//----------------------------------------------------------------------
void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
std::vector<cmStdString> &failed)
@ -613,26 +899,15 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
continue;
}
const std::string& testname = it->Name;
std::vector<std::string>& args = it->Args;
cmCTestTestResult cres;
cres.Properties = &*it;
cres.ExecutionTime = 0;
cres.ReturnValue = -1;
cres.Status = cmCTestTestHandler::NOT_RUN;
cres.TestCount = cnt;
if (!(last_directory == it->Directory))
{
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
"Changing directory into " << it->Directory.c_str() << "\n");
"Changing directory into " << it->Directory.c_str() << "\n");
*this->LogFile << "Changing directory into: " << it->Directory.c_str()
<< std::endl;
<< std::endl;
last_directory = it->Directory;
cmSystemTools::ChangeDirectory(it->Directory.c_str());
}
cres.Name = testname;
cres.Path = it->Directory.c_str();
if (this->UseUnion)
{
@ -649,278 +924,15 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
// is this test in the list of tests to run? If not then skip it
if ((this->TestsToRun.size() &&
std::find(this->TestsToRun.begin(),
this->TestsToRun.end(), inREcnt)
this->TestsToRun.end(), inREcnt)
== this->TestsToRun.end()) || !it->IsInBasedOnREOptions)
{
continue;
}
}
cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(3) << cnt << "/");
cmCTestLog(this->CTest, HANDLER_OUTPUT, std::setw(3) << tmsize << " ");
if ( this->MemCheck )
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Memory Check");
}
else
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Testing");
}
cmCTestLog(this->CTest, HANDLER_OUTPUT, " ");
std::string outname = testname;
outname.resize(30, ' ');
*this->LogFile << cnt << "/" << tmsize << " Testing: " << testname
<< std::endl;
if ( this->CTest->GetShowOnly() )
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, outname.c_str() << std::endl);
}
else
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, outname.c_str());
}
cmCTestLog(this->CTest, DEBUG, "Testing " << args[0].c_str() << " ... ");
// find the test executable
std::string actualCommand = this->FindTheExecutable(args[1].c_str());
std::string testCommand
= cmSystemTools::ConvertToOutputPath(actualCommand.c_str());
// continue if we did not find the executable
if (testCommand == "")
{
*this->LogFile << "Unable to find executable: " << args[1].c_str()
<< std::endl;
cmCTestLog(this->CTest, ERROR_MESSAGE, "Unable to find executable: "
<< args[1].c_str() << std::endl);
cres.Output = "Unable to find executable: " + args[1];
if ( !this->CTest->GetShowOnly() )
{
cres.FullCommandLine = actualCommand;
this->TestResults.push_back( cres );
failed.push_back(testname);
continue;
}
}
// add the arguments
std::vector<std::string>::const_iterator j = args.begin();
++j;
++j;
std::vector<const char*> arguments;
this->GenerateTestCommand(arguments);
arguments.push_back(actualCommand.c_str());
for(;j != args.end(); ++j)
{
testCommand += " ";
testCommand += cmSystemTools::EscapeSpaces(j->c_str());
arguments.push_back(j->c_str());
}
arguments.push_back(0);
/**
* Run an executable command and put the stdout in output.
*/
std::string output;
int retVal = 0;
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl
<< (this->MemCheck?"MemCheck":"Test") << " command: " << testCommand
<< std::endl);
*this->LogFile << cnt << "/" << tmsize
<< " Test: " << testname.c_str() << std::endl;
*this->LogFile << "Command: ";
std::vector<cmStdString>::size_type ll;
for ( ll = 0; ll < arguments.size()-1; ll ++ )
{
*this->LogFile << "\"" << arguments[ll] << "\" ";
}
*this->LogFile
<< std::endl
<< "Directory: " << it->Directory << std::endl
<< "\"" << testname.c_str() << "\" start time: "
<< this->CTest->CurrentTime() << std::endl
<< "Output:" << std::endl
<< "----------------------------------------------------------"
<< std::endl;
int res = 0;
double clock_start, clock_finish;
clock_start = cmSystemTools::GetTime();
if ( !this->CTest->GetShowOnly() )
{
res = this->CTest->RunTest(arguments, &output, &retVal, this->LogFile);
}
clock_finish = cmSystemTools::GetTime();
if ( this->LogFile )
{
double ttime = clock_finish - clock_start;
int hours = static_cast<int>(ttime / (60 * 60));
int minutes = static_cast<int>(ttime / 60) % 60;
int seconds = static_cast<int>(ttime) % 60;
char buffer[100];
sprintf(buffer, "%02d:%02d:%02d", hours, minutes, seconds);
*this->LogFile
<< "----------------------------------------------------------"
<< std::endl
<< "\"" << testname.c_str() << "\" end time: "
<< this->CTest->CurrentTime() << std::endl
<< "\"" << testname.c_str() << "\" time elapsed: "
<< buffer << std::endl
<< "----------------------------------------------------------"
<< std::endl << std::endl;
}
cres.ExecutionTime = (double)(clock_finish - clock_start);
cres.FullCommandLine = testCommand;
if ( !this->CTest->GetShowOnly() )
{
bool testFailed = false;
std::vector<cmsys::RegularExpression>::iterator passIt;
bool forceFail = false;
if ( it->RequiredRegularExpressions.size() > 0 )
{
bool found = false;
for ( passIt = it->RequiredRegularExpressions.begin();
passIt != it->RequiredRegularExpressions.end();
++ passIt )
{
if ( passIt->find(output.c_str()) )
{
found = true;
}
}
if ( !found )
{
forceFail = true;
}
}
if ( it->ErrorRegularExpressions.size() > 0 )
{
for ( passIt = it->ErrorRegularExpressions.begin();
passIt != it->ErrorRegularExpressions.end();
++ passIt )
{
if ( passIt->find(output.c_str()) )
{
forceFail = true;
}
}
}
if (res == cmsysProcess_State_Exited &&
(retVal == 0 || it->RequiredRegularExpressions.size()) &&
!forceFail)
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, " Passed");
if ( it->WillFail )
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, " - But it should fail!");
cres.Status = cmCTestTestHandler::FAILED;
testFailed = true;
}
else
{
cres.Status = cmCTestTestHandler::COMPLETED;
}
cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
}
else
{
testFailed = true;
cres.Status = cmCTestTestHandler::FAILED;
if ( res == cmsysProcess_State_Expired )
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Timeout" << std::endl);
cres.Status = cmCTestTestHandler::TIMEOUT;
}
else if ( res == cmsysProcess_State_Exception )
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Exception: ");
switch ( retVal )
{
case cmsysProcess_Exception_Fault:
cmCTestLog(this->CTest, HANDLER_OUTPUT, "SegFault");
cres.Status = cmCTestTestHandler::SEGFAULT;
break;
case cmsysProcess_Exception_Illegal:
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Illegal");
cres.Status = cmCTestTestHandler::ILLEGAL;
break;
case cmsysProcess_Exception_Interrupt:
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Interrupt");
cres.Status = cmCTestTestHandler::INTERRUPT;
break;
case cmsysProcess_Exception_Numerical:
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Numerical");
cres.Status = cmCTestTestHandler::NUMERICAL;
break;
default:
cmCTestLog(this->CTest, HANDLER_OUTPUT, "Other");
cres.Status = cmCTestTestHandler::OTHER_FAULT;
}
cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
}
else if ( res == cmsysProcess_State_Error )
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Bad command " << res
<< std::endl);
cres.Status = cmCTestTestHandler::BAD_COMMAND;
}
else
{
// Force fail will also be here?
cmCTestLog(this->CTest, HANDLER_OUTPUT, "***Failed");
if ( it->WillFail )
{
cres.Status = cmCTestTestHandler::COMPLETED;
cmCTestLog(this->CTest, HANDLER_OUTPUT, " - supposed to fail");
testFailed = false;
}
cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
}
}
if ( testFailed )
{
failed.push_back(testname);
}
else
{
passed.push_back(testname);
}
if (!output.empty() && output.find("<DartMeasurement") != output.npos)
{
if (this->DartStuff.find(output.c_str()))
{
std::string dartString = this->DartStuff.match(1);
cmSystemTools::ReplaceString(output, dartString.c_str(),"");
cres.RegressionImages
= this->GenerateRegressionImages(dartString);
}
}
}
if ( cres.Status == cmCTestTestHandler::COMPLETED )
{
this->CleanTestOutput(output, static_cast<size_t>(
this->CustomMaximumPassedTestOutputSize));
}
else
{
this->CleanTestOutput(output, static_cast<size_t>(
this->CustomMaximumFailedTestOutputSize));
}
cres.Output = output;
cres.ReturnValue = retVal;
cres.CompletionStatus = "Completed";
this->TestResults.push_back( cres );
// process this one test
this->ProcessOneTest(&(*it), passed, failed, cnt, tmsize);
}
this->EndTest = this->CTest->CurrentTime();
@ -1647,6 +1659,10 @@ bool cmCTestTestHandler::SetTestsProperties(
{
rtit->WillFail = cmSystemTools::IsOn(val.c_str());
}
if ( key == "TIMEOUT" )
{
rtit->Timeout = atof(val.c_str());
}
if ( key == "FAIL_REGULAR_EXPRESSION" )
{
std::vector<std::string> lval;
@ -1751,6 +1767,7 @@ bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args)
test.IsInBasedOnREOptions = true;
test.WillFail = false;
test.Timeout = 0;
if (this->UseIncludeRegExpFlag &&
!this->IncludeTestsRegularExpression.find(testname.c_str()))
{

10
Source/CTest/cmCTestTestHandler.h
View File

@ -85,6 +85,7 @@ public:
std::map<cmStdString, cmStdString> Measurements;
bool IsInBasedOnREOptions;
bool WillFail;
double Timeout;
};
struct cmCTestTestResult
@ -145,11 +146,18 @@ private:
virtual void GenerateDartOutput(std::ostream& os);
/**
* Run the test for a directory and any subdirectories
* Run the tests for a directory and any subdirectories
*/
void ProcessDirectory(std::vector<cmStdString> &passed,
std::vector<cmStdString> &failed);
/**
* Run one test
*/
void ProcessOneTest(cmCTestTestProperties *props,
std::vector<cmStdString> &passed,
std::vector<cmStdString> &failed,
int count, int tmsize);
typedef std::vector<cmCTestTestProperties> ListOfTests;
/**

16
Source/cmCTest.cxx
View File

@ -1074,7 +1074,7 @@ int cmCTest::RunMakeCommand(const char* command, std::string* output,
//----------------------------------------------------------------------
int cmCTest::RunTest(std::vector<const char*> argv,
std::string* output, int *retVal,
std::ostream* log)
std::ostream* log, double testTimeOut)
{
if(cmSystemTools::SameFile(argv[0], this->CTestSelf.c_str()) &&
!this->ForceNewCTestProcess)
@ -1087,6 +1087,14 @@ int cmCTest::RunTest(std::vector<const char*> argv,
{
if(argv[i])
{
// if this test has a test command make sure we pass the timeout in
if (strcmp(argv[i],"--test-command") == 0 && testTimeOut)
{
args.push_back("--test-timeout");
cmOStringStream msg;
msg << testTimeOut;
args.push_back(msg.str());
}
args.push_back(argv[i]);
}
}
@ -1128,6 +1136,12 @@ int cmCTest::RunTest(std::vector<const char*> argv,
{
timeout = this->TimeOut;
}
cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "-- timeout set to "
<< testTimeOut << std::endl);
if (testTimeOut && testTimeOut < timeout)
{
timeout = testTimeOut;
}
// always have at least 1 second if we got to here
if (timeout <= 0)
{

2
Source/cmCTest.h
View File

@ -232,7 +232,7 @@ public:
//! Run command specialized for tests. Returns process status and retVal is
// return value or exception.
int RunTest(std::vector<const char*> args, std::string* output, int *retVal,
std::ostream* logfile);
std::ostream* logfile, double testTimeOut);
/**
* Execute handler and return its result. If the handler fails, it returns

9
Source/cmTest.cxx
View File

@ -117,6 +117,15 @@ void cmTest::DefineProperties(cmake *cm)
"against the specified regular expressions and at least one of the"
" regular expressions has to match, otherwise the test will fail.");
cm->DefineProperty
("TIMEOUT", cmProperty::TEST,
"How many seconds to allow for this test.",
"This property if set will limit a test to nto take more than "
"the specified number of seconds to run. If it exceeds that the "
"test process will be killed and ctest will move to the next test. "
"This setting takes precedence over DART_TESTING_TIMEOUT and "
"CTEST_TESTING_TIMOUT.");
cm->DefineProperty
("WILL_FAIL", cmProperty::TEST,
"If set to true, this will invert the pass/fail flag of the test.",

4
Source/ctest.cxx
View File

@ -148,7 +148,7 @@ static const cmDocumentationEntry cmDocumentationOptions[] =
"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"},
"--build-noclean, --build-options, --test-timeout"},
{"--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." },
@ -168,6 +168,8 @@ static const cmDocumentationEntry cmDocumentationOptions[] =
{"--test-command", "The test to run with the --build-and-test option.", ""
},
{"--test-timeout", "The time limit in seconds for --test-command.", ""
},
{"--tomorrow-tag", "Nightly or experimental starts with next day tag.",
"This is useful if the build will not finish in one day." },
{"--ctest-config", "The configuration file used to initialize CTest state "