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

ctest_test: Add QUIET option

Browse Source
This commit is contained in:
Zack Galbreath 2015-02-17 14:23:56 -05:00 committed by Brad King
parent 49ba4545c2
commit 876a680d48
11 changed files with 105 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Help/command/ctest_test.rst
View File

@ -31,3 +31,9 @@ tests should all stop running.
The APPEND option marks results for append to those previously The APPEND option marks results for append to those previously
submitted to a dashboard server since the last ctest_start. Append submitted to a dashboard server since the last ctest_start. Append
semantics are defined by the dashboard server in use. semantics are defined by the dashboard server in use.
The QUIET option suppresses any CTest-specific non-error messages
that would have otherwise been printed to the console. Output from
the underlying test command is not affected. Summary info detailing
the percentage of passing tests is also unaffected by the QUIET
option.

47
Source/CTest/cmCTestMultiProcessHandler.cxx
View File

@ -113,7 +113,8 @@ void cmCTestMultiProcessHandler::RunTests()
//--------------------------------------------------------- //---------------------------------------------------------
void cmCTestMultiProcessHandler::StartTestProcess(int test) void cmCTestMultiProcessHandler::StartTestProcess(int test)
{ {
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "test " << test << "\n"); cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
"test " << test << "\n", this->Quiet);
this->TestRunningMap[test] = true; // mark the test as running this->TestRunningMap[test] = true; // mark the test as running
// now remove the test itself // now remove the test itself
this->EraseTest(test); this->EraseTest(test);
@ -639,39 +640,44 @@ void cmCTestMultiProcessHandler::PrintTestList()
if(!p.Labels.empty()) //print the labels if(!p.Labels.empty()) //print the labels
{ {
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Labels:"); cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Labels:",
this->Quiet);
} }
for(std::vector<std::string>::iterator label = p.Labels.begin(); for(std::vector<std::string>::iterator label = p.Labels.begin();
label != p.Labels.end(); ++label) label != p.Labels.end(); ++label)
{ {
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, " " << *label); cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, " " << *label,
this->Quiet);
} }
if(!p.Labels.empty()) //print the labels if(!p.Labels.empty()) //print the labels
{ {
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl); cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl,
this->Quiet);
} }
if (this->TestHandler->MemCheck) if (this->TestHandler->MemCheck)
{ {
cmCTestLog(this->CTest, HANDLER_OUTPUT, " Memory Check"); cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, " Memory Check",
this->Quiet);
} }
else else
{ {
cmCTestLog(this->CTest, HANDLER_OUTPUT, " Test"); cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, " Test", this->Quiet);
} }
std::ostringstream indexStr; std::ostringstream indexStr;
indexStr << " #" << p.Index << ":"; indexStr << " #" << p.Index << ":";
cmCTestLog(this->CTest, HANDLER_OUTPUT, cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
std::setw(3 + getNumWidth(this->TestHandler->GetMaxIndex())) std::setw(3 + getNumWidth(this->TestHandler->GetMaxIndex()))
<< indexStr.str()); << indexStr.str(), this->Quiet);
cmCTestLog(this->CTest, HANDLER_OUTPUT, " "); cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, " ", this->Quiet);
cmCTestLog(this->CTest, HANDLER_OUTPUT, p.Name.c_str() << std::endl); cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
p.Name.c_str() << std::endl, this->Quiet);
//pop working dir //pop working dir
cmSystemTools::ChangeDirectory(current_dir); cmSystemTools::ChangeDirectory(current_dir);
} }
cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl << "Total Tests: " cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, std::endl << "Total Tests: "
<< this->Total << std::endl); << this->Total << std::endl, this->Quiet);
} }
void cmCTestMultiProcessHandler::PrintLabels() void cmCTestMultiProcessHandler::PrintLabels()
@ -686,16 +692,19 @@ void cmCTestMultiProcessHandler::PrintLabels()
if(!allLabels.empty()) if(!allLabels.empty())
{ {
cmCTestLog(this->CTest, HANDLER_OUTPUT, "All Labels:" << std::endl); cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
"All Labels:" << std::endl, this->Quiet);
} }
else else
{ {
cmCTestLog(this->CTest, HANDLER_OUTPUT, "No Labels Exist" << std::endl); cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
"No Labels Exist" << std::endl, this->Quiet);
} }
for(std::set<std::string>::iterator label = allLabels.begin(); for(std::set<std::string>::iterator label = allLabels.begin();
label != allLabels.end(); ++label) label != allLabels.end(); ++label)
{ {
cmCTestLog(this->CTest, HANDLER_OUTPUT, " " << *label << std::endl); cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
" " << *label << std::endl, this->Quiet);
} }
} }
@ -758,8 +767,8 @@ int cmCTestMultiProcessHandler::FindMaxIndex()
//Returns true if no cycles exist in the dependency graph //Returns true if no cycles exist in the dependency graph
bool cmCTestMultiProcessHandler::CheckCycles() bool cmCTestMultiProcessHandler::CheckCycles()
{ {
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
"Checking test dependency graph..." << std::endl); "Checking test dependency graph..." << std::endl, this->Quiet);
for(TestMap::iterator it = this->Tests.begin(); for(TestMap::iterator it = this->Tests.begin();
it != this->Tests.end(); ++it) it != this->Tests.end(); ++it)
{ {
@ -794,7 +803,7 @@ bool cmCTestMultiProcessHandler::CheckCycles()
} }
} }
} }
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
"Checking test dependency graph end" << std::endl); "Checking test dependency graph end" << std::endl, this->Quiet);
return true; return true;
} }

3
Source/CTest/cmCTestMultiProcessHandler.h
View File

@ -57,6 +57,8 @@ public:
cmCTestTestHandler * GetTestHandler() cmCTestTestHandler * GetTestHandler()
{ return this->TestHandler; } { return this->TestHandler; }
void SetQuiet(bool b) { this->Quiet = b; }
protected: protected:
// Start the next test or tests as many as are allowed by // Start the next test or tests as many as are allowed by
// ParallelLevel // ParallelLevel
@ -118,6 +120,7 @@ protected:
cmCTestTestHandler * TestHandler; cmCTestTestHandler * TestHandler;
cmCTest* CTest; cmCTest* CTest;
bool HasCycles; bool HasCycles;
bool Quiet;
}; };
#endif #endif

1
Source/CTest/cmCTestTestCommand.cxx
View File

@ -103,6 +103,7 @@ cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
{ {
this->CTest->SetStopTime(this->Values[ctt_STOP_TIME]); this->CTest->SetStopTime(this->Values[ctt_STOP_TIME]);
} }
handler->SetQuiet(this->Quiet);
return handler; return handler;
} }

64
Source/CTest/cmCTestTestHandler.cxx
View File

@ -527,10 +527,10 @@ int cmCTestTestHandler::ProcessHandler()
this->TestResults.clear(); this->TestResults.clear();
cmCTestLog(this->CTest, HANDLER_OUTPUT, cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
(this->MemCheck ? "Memory check" : "Test") (this->MemCheck ? "Memory check" : "Test")
<< " project " << cmSystemTools::GetCurrentWorkingDirectory() << " project " << cmSystemTools::GetCurrentWorkingDirectory()
<< std::endl); << std::endl, this->Quiet);
if ( ! this->PreProcessHandler() ) if ( ! this->PreProcessHandler() )
{ {
return -1; return -1;
@ -567,13 +567,13 @@ int cmCTestTestHandler::ProcessHandler()
if (this->HandlerVerbose && !passed.empty() && if (this->HandlerVerbose && !passed.empty() &&
(this->UseIncludeRegExpFlag || this->UseExcludeRegExpFlag)) (this->UseIncludeRegExpFlag || this->UseExcludeRegExpFlag))
{ {
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl
<< "The following tests passed:" << std::endl); << "The following tests passed:" << std::endl, this->Quiet);
for(std::vector<std::string>::iterator j = passed.begin(); for(std::vector<std::string>::iterator j = passed.begin();
j != passed.end(); ++j) j != passed.end(); ++j)
{ {
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "\t" << *j cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "\t" << *j
<< std::endl); << std::endl, this->Quiet);
} }
} }
@ -593,8 +593,8 @@ int cmCTestTestHandler::ProcessHandler()
} }
char realBuf[1024]; char realBuf[1024];
sprintf(realBuf, "%6.2f sec", (double)(clock_finish - clock_start)); sprintf(realBuf, "%6.2f sec", (double)(clock_finish - clock_start));
cmCTestLog(this->CTest, HANDLER_OUTPUT, "\nTotal Test time (real) = " cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
<< realBuf << "\n" ); "\nTotal Test time (real) = " << realBuf << "\n", this->Quiet );
if (!failed.empty()) if (!failed.empty())
{ {
@ -614,11 +614,11 @@ int cmCTestTestHandler::ProcessHandler()
if ( ftit->Status != cmCTestTestHandler::COMPLETED ) if ( ftit->Status != cmCTestTestHandler::COMPLETED )
{ {
ofs << ftit->TestCount << ":" << ftit->Name << std::endl; ofs << ftit->TestCount << ":" << ftit->Name << std::endl;
cmCTestLog(this->CTest, HANDLER_OUTPUT, "\t" << std::setw(3) cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "\t" << std::setw(3)
<< ftit->TestCount << " - " << ftit->TestCount << " - "
<< ftit->Name << " (" << ftit->Name << " ("
<< this->GetTestStatus(ftit->Status) << ")" << this->GetTestStatus(ftit->Status) << ")"
<< std::endl); << std::endl, this->Quiet);
} }
} }
} }
@ -700,7 +700,8 @@ void cmCTestTestHandler::PrintLabelSummary()
// now print times // now print times
if(!labels.empty()) if(!labels.empty())
{ {
cmCTestLog(this->CTest, HANDLER_OUTPUT, "\nLabel Time Summary:"); cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "\nLabel Time Summary:",
this->Quiet);
} }
for(std::set<std::string>::const_iterator i = labels.begin(); for(std::set<std::string>::const_iterator i = labels.begin();
i != labels.end(); ++i) i != labels.end(); ++i)
@ -709,8 +710,8 @@ void cmCTestTestHandler::PrintLabelSummary()
label.resize(maxlen +3, ' '); label.resize(maxlen +3, ' ');
char buf[1024]; char buf[1024];
sprintf(buf, "%6.2f sec", labelTimes[*i]); sprintf(buf, "%6.2f sec", labelTimes[*i]);
cmCTestLog(this->CTest, HANDLER_OUTPUT, "\n" cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "\n"
<< label << " = " << buf ); << label << " = " << buf, this->Quiet );
if ( this->LogFile ) if ( this->LogFile )
{ {
*this->LogFile << "\n" << *i << " = " *this->LogFile << "\n" << *i << " = "
@ -723,7 +724,7 @@ void cmCTestTestHandler::PrintLabelSummary()
{ {
*this->LogFile << "\n"; *this->LogFile << "\n";
} }
cmCTestLog(this->CTest, HANDLER_OUTPUT, "\n"); cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "\n", this->Quiet);
} }
} }
@ -1063,6 +1064,7 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<std::string> &passed,
parallel->SetCTest(this->CTest); parallel->SetCTest(this->CTest);
parallel->SetParallelLevel(this->CTest->GetParallelLevel()); parallel->SetParallelLevel(this->CTest->GetParallelLevel());
parallel->SetTestHandler(this); parallel->SetTestHandler(this);
parallel->SetQuiet(this->Quiet);
*this->LogFile << "Start testing: " *this->LogFile << "Start testing: "
<< this->CTest->CurrentTime() << std::endl << this->CTest->CurrentTime() << std::endl
@ -1334,8 +1336,8 @@ int cmCTestTestHandler::ExecuteCommands(std::vector<std::string>& vec)
for ( it = vec.begin(); it != vec.end(); ++it ) for ( it = vec.begin(); it != vec.end(); ++it )
{ {
int retVal = 0; int retVal = 0;
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run command: " << *it cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run command: " <<
<< std::endl); *it << std::endl, this->Quiet);
if ( !cmSystemTools::RunSingleCommand(it->c_str(), 0, &retVal, 0, if ( !cmSystemTools::RunSingleCommand(it->c_str(), 0, &retVal, 0,
cmSystemTools::OUTPUT_MERGE cmSystemTools::OUTPUT_MERGE
/*this->Verbose*/) || retVal != 0 ) /*this->Verbose*/) || retVal != 0 )
@ -1541,8 +1543,7 @@ std::string cmCTestTestHandler
for(std::vector<std::string>::iterator i = failed.begin(); for(std::vector<std::string>::iterator i = failed.begin();
i != failed.end(); ++i) i != failed.end(); ++i)
{ {
cmCTestLog(ctest, HANDLER_OUTPUT, cmCTestLog(ctest, HANDLER_OUTPUT, i->c_str() << "\n");
i->c_str() << "\n");
} }
} }
@ -1571,8 +1572,8 @@ void cmCTestTestHandler::GetListOfTests()
{ {
this->ExcludeTestsRegularExpression.compile(this->ExcludeRegExp.c_str()); this->ExcludeTestsRegularExpression.compile(this->ExcludeRegExp.c_str());
} }
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
"Constructing a list of tests" << std::endl); "Constructing a list of tests" << std::endl, this->Quiet);
cmake cm; cmake cm;
cmGlobalGenerator gg; cmGlobalGenerator gg;
gg.SetCMakeInstance(&cm); gg.SetCMakeInstance(&cm);
@ -1628,8 +1629,8 @@ void cmCTestTestHandler::GetListOfTests()
{ {
return; return;
} }
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
"Done constructing a list of tests" << std::endl); "Done constructing a list of tests" << std::endl, this->Quiet);
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -2016,8 +2017,8 @@ std::string cmCTestTestHandler::GenerateRegressionImages(
<< "><Value>File " << filename << "><Value>File " << filename
<< " not found</Value></NamedMeasurement>" << " not found</Value></NamedMeasurement>"
<< std::endl; << std::endl;
cmCTestLog(this->CTest, HANDLER_OUTPUT, "File \"" << filename cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "File \"" << filename
<< "\" not found." << std::endl); << "\" not found." << std::endl, this->Quiet);
} }
cxml.erase(measurementfile.start(), cxml.erase(measurementfile.start(),
measurementfile.end() - measurementfile.start()); measurementfile.end() - measurementfile.start());
@ -2265,7 +2266,8 @@ bool cmCTestTestHandler::SetTestsProperties(
bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args) bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args)
{ {
const std::string& testname = args[0]; const std::string& testname = args[0];
cmCTestLog(this->CTest, DEBUG, "Add test: " << args[0] << std::endl); cmCTestOptionalLog(this->CTest, DEBUG, "Add test: " << args[0] << std::endl,
this->Quiet);
if (this->UseExcludeRegExpFlag && if (this->UseExcludeRegExpFlag &&
this->UseExcludeRegExpFirst && this->UseExcludeRegExpFirst &&
@ -2288,8 +2290,8 @@ bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args)
} }
if ( found ) if ( found )
{ {
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Ignore memcheck: " cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
<< *it << std::endl); "Ignore memcheck: " << *it << std::endl, this->Quiet);
return true; return true;
} }
} }
@ -2308,8 +2310,8 @@ bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args)
} }
if ( found ) if ( found )
{ {
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Ignore test: " cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Ignore test: "
<< *it << std::endl); << *it << std::endl, this->Quiet);
return true; return true;
} }
} }
@ -2318,8 +2320,8 @@ bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args)
test.Name = testname; test.Name = testname;
test.Args = args; test.Args = args;
test.Directory = cmSystemTools::GetCurrentWorkingDirectory(); test.Directory = cmSystemTools::GetCurrentWorkingDirectory();
cmCTestLog(this->CTest, DEBUG, "Set test directory: " cmCTestOptionalLog(this->CTest, DEBUG, "Set test directory: "
<< test.Directory << std::endl); << test.Directory << std::endl, this->Quiet);
test.IsInBasedOnREOptions = true; test.IsInBasedOnREOptions = true;
test.WillFail = false; test.WillFail = false;

1
Tests/RunCMake/CMakeLists.txt
View File

@ -133,6 +133,7 @@ add_RunCMake_test(ctest_build)
add_RunCMake_test(ctest_configure) add_RunCMake_test(ctest_configure)
add_RunCMake_test(ctest_start) add_RunCMake_test(ctest_start)
add_RunCMake_test(ctest_submit) add_RunCMake_test(ctest_submit)
add_RunCMake_test(ctest_test)
add_RunCMake_test(file) add_RunCMake_test(file)
add_RunCMake_test(find_library) add_RunCMake_test(find_library)
add_RunCMake_test(find_package) add_RunCMake_test(find_package)

4
Tests/RunCMake/ctest_test/CMakeLists.txt.in Normal file
View File

@ -0,0 +1,4 @@
cmake_minimum_required(VERSION 3.1)
project(CTestTest@CASE_NAME@ NONE)
include(CTest)
add_test(NAME RunCMakeVersion COMMAND "${CMAKE_COMMAND}" --version)

1
Tests/RunCMake/ctest_test/CTestConfig.cmake.in Normal file
View File

@ -0,0 +1 @@
set(CTEST_PROJECT_NAME "CTestTest@CASE_NAME@")

10
Tests/RunCMake/ctest_test/RunCMakeTest.cmake Normal file
View File

@ -0,0 +1,10 @@
include(RunCTest)
set(CASE_CTEST_TEST_ARGS "")
function(run_ctest_test CASE_NAME)
set(CASE_CTEST_TEST_ARGS "${ARGN}")
run_ctest(${CASE_NAME})
endfunction()
run_ctest_test(TestQuiet QUIET)

2
Tests/RunCMake/ctest_test/TestQuiet-stdout.txt Normal file
View File

@ -0,0 +1,2 @@
0 Compiler warnings
Start 1: RunCMakeVersion

16
Tests/RunCMake/ctest_test/test.cmake.in Normal file
View File

@ -0,0 +1,16 @@
cmake_minimum_required(VERSION 3.1)
set(CTEST_SITE "test-site")
set(CTEST_BUILD_NAME "test-build-name")
set(CTEST_SOURCE_DIRECTORY "@RunCMake_BINARY_DIR@/@CASE_NAME@")
set(CTEST_BINARY_DIRECTORY "@RunCMake_BINARY_DIR@/@CASE_NAME@-build")
set(CTEST_CMAKE_GENERATOR "@RunCMake_GENERATOR@")
set(CTEST_CMAKE_GENERATOR_PLATFORM "@RunCMake_GENERATOR_PLATFORM@")
set(CTEST_CMAKE_GENERATOR_TOOLSET "@RunCMake_GENERATOR_TOOLSET@")
set(CTEST_BUILD_CONFIGURATION "$ENV{CMAKE_CONFIG_TYPE}")
set(ctest_test_args "@CASE_CTEST_TEST_ARGS@")
ctest_start(Experimental)
ctest_configure()
ctest_build()
ctest_test(${ctest_test_args})