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

ENH: Add support for writing output file. While doing that, redesign the way ctest does output. There may still be problems with commands failing, but that should be fixed by applying the similar concept to whole CMake

This commit is contained in:
Andy Cedilnik 2005-05-31 17:32:40 -04:00
parent f963c406ab
commit f6e5a878fc
15 changed files with 582 additions and 492 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
Source/CTest/cmCTestBuildHandler.cxx
View File

@ -171,8 +171,8 @@ cmCTestBuildHandler::cmCTestBuildHandler()
} }
else else
{ {
std::cout << "Problem Compiling regular expression: " cmCTestLog(m_CTest, ERROR, "Problem Compiling regular expression: "
<< cmCTestWarningErrorFileLine[cc].m_RegularExpressionString << std::endl; << cmCTestWarningErrorFileLine[cc].m_RegularExpressionString << std::endl);
} }
} }
} }
@ -196,17 +196,17 @@ void cmCTestBuildHandler::PopulateCustomVectors(cmMakefile *mf)
//functions and commented... //functions and commented...
int cmCTestBuildHandler::ProcessHandler() int cmCTestBuildHandler::ProcessHandler()
{ {
std::cout << "Build project" << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, "Build project" << std::endl);
const std::string &makeCommand = m_CTest->GetCTestConfiguration("MakeCommand"); const std::string &makeCommand = m_CTest->GetCTestConfiguration("MakeCommand");
if ( makeCommand.size() == 0 ) if ( makeCommand.size() == 0 )
{ {
std::cerr << "Cannot find MakeCommand key in the DartConfiguration.tcl" << std::endl; cmCTestLog(m_CTest, ERROR, "Cannot find MakeCommand key in the DartConfiguration.tcl" << std::endl);
return -1; return -1;
} }
const std::string &buildDirectory = m_CTest->GetCTestConfiguration("BuildDirectory"); const std::string &buildDirectory = m_CTest->GetCTestConfiguration("BuildDirectory");
if ( buildDirectory.size() == 0 ) if ( buildDirectory.size() == 0 )
{ {
std::cerr << "Cannot find BuildDirectory key in the DartConfiguration.tcl" << std::endl; cmCTestLog(m_CTest, ERROR, "Cannot find BuildDirectory key in the DartConfiguration.tcl" << std::endl);
return -1; return -1;
} }
@ -214,7 +214,7 @@ int cmCTestBuildHandler::ProcessHandler()
double elapsed_time_start = cmSystemTools::GetTime(); double elapsed_time_start = cmSystemTools::GetTime();
if ( !m_CTest->OpenOutputFile("Temporary", "LastBuild.log", ofs) ) if ( !m_CTest->OpenOutputFile("Temporary", "LastBuild.log", ofs) )
{ {
std::cerr << "Cannot create LastBuild.log file" << std::endl; cmCTestLog(m_CTest, ERROR, "Cannot create LastBuild.log file" << std::endl);
} }
m_StartBuild = m_CTest->CurrentTime(); m_StartBuild = m_CTest->CurrentTime();
@ -224,18 +224,17 @@ int cmCTestBuildHandler::ProcessHandler()
if ( !m_CTest->GetShowOnly() ) if ( !m_CTest->GetShowOnly() )
{ {
res = m_CTest->RunMakeCommand(makeCommand.c_str(), &output, res = m_CTest->RunMakeCommand(makeCommand.c_str(), &output,
&retVal, buildDirectory.c_str(), &retVal, buildDirectory.c_str(), 0, ofs);
m_Verbose, 0, ofs);
} }
else else
{ {
std::cout << "Build with command: " << makeCommand << std::endl; cmCTestLog(m_CTest, DEBUG, "Build with command: " << makeCommand << std::endl);
} }
m_EndBuild = m_CTest->CurrentTime(); m_EndBuild = m_CTest->CurrentTime();
double elapsed_build_time = cmSystemTools::GetTime() - elapsed_time_start; double elapsed_build_time = cmSystemTools::GetTime() - elapsed_time_start;
if (res != cmsysProcess_State_Exited || retVal ) if (res != cmsysProcess_State_Exited || retVal )
{ {
std::cerr << "Error(s) when building project" << std::endl; cmCTestLog(m_CTest, ERROR, "Error(s) when building project" << std::endl);
} }
std::vector<cmStdString>::size_type cc; std::vector<cmStdString>::size_type cc;
@ -382,13 +381,13 @@ int cmCTestBuildHandler::ProcessHandler()
bool found = false; bool found = false;
if ( markedLines[kk] == 1 ) if ( markedLines[kk] == 1 )
{ {
//std::cout << "Error: " << lines[kk] << std::endl; cmCTestLog(m_CTest, DEBUG, "Error: " << lines[kk] << std::endl);
errorwarning.m_Error = true; errorwarning.m_Error = true;
found = true; found = true;
} }
else if ( markedLines[kk] > 1 ) else if ( markedLines[kk] > 1 )
{ {
//std::cout << "Warning: " << lines[kk] << std::endl; cmCTestLog(m_CTest, DEBUG, "Warning: " << lines[kk] << std::endl);
errorwarning.m_Error = false; errorwarning.m_Error = false;
found = true; found = true;
} }
@ -433,13 +432,12 @@ int cmCTestBuildHandler::ProcessHandler()
} }
} }
std::cout << " " << errors << " Compiler errors" << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " " << errors << " Compiler errors" << std::endl);
std::cout << " " << warnings << " Compiler warnings" << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " " << warnings << " Compiler warnings" << std::endl);
cmGeneratedFileStream xofs; cmGeneratedFileStream xofs;
if( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), "Build.xml", xofs, true) ) if( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), "Build.xml", xofs, true) )
{ {
std::cerr << "Cannot create build XML file" << std::endl; cmCTestLog(m_CTest, ERROR, "Cannot create build XML file" << std::endl);
return -1; return -1;
} }
this->GenerateDartBuildOutput(xofs, errorsWarnings, elapsed_build_time); this->GenerateDartBuildOutput(xofs, errorsWarnings, elapsed_build_time);

19
Source/CTest/cmCTestConfigureHandler.cxx
View File

@ -26,7 +26,6 @@
//---------------------------------------------------------------------- //----------------------------------------------------------------------
cmCTestConfigureHandler::cmCTestConfigureHandler() cmCTestConfigureHandler::cmCTestConfigureHandler()
{ {
m_Verbose = false;
m_CTest = 0; m_CTest = 0;
} }
@ -36,19 +35,19 @@ cmCTestConfigureHandler::cmCTestConfigureHandler()
//functions and commented... //functions and commented...
int cmCTestConfigureHandler::ProcessHandler() int cmCTestConfigureHandler::ProcessHandler()
{ {
std::cout << "Configure project" << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, "Configure project" << std::endl);
std::string cCommand = m_CTest->GetCTestConfiguration("ConfigureCommand"); std::string cCommand = m_CTest->GetCTestConfiguration("ConfigureCommand");
if ( cCommand.size() == 0 ) if ( cCommand.size() == 0 )
{ {
std::cerr << "Cannot find ConfigureCommand key in the DartConfiguration.tcl" cmCTestLog(m_CTest, ERROR, "Cannot find ConfigureCommand key in the DartConfiguration.tcl"
<< std::endl; << std::endl);
return -1; return -1;
} }
std::string buildDirectory = m_CTest->GetCTestConfiguration("BuildDirectory"); std::string buildDirectory = m_CTest->GetCTestConfiguration("BuildDirectory");
if ( buildDirectory.size() == 0 ) if ( buildDirectory.size() == 0 )
{ {
std::cerr << "Cannot find BuildDirectory key in the DartConfiguration.tcl" << std::endl; cmCTestLog(m_CTest, ERROR, "Cannot find BuildDirectory key in the DartConfiguration.tcl" << std::endl);
return -1; return -1;
} }
@ -61,7 +60,7 @@ int cmCTestConfigureHandler::ProcessHandler()
cmGeneratedFileStream os; cmGeneratedFileStream os;
if ( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), "Configure.xml", os, true) ) if ( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), "Configure.xml", os, true) )
{ {
std::cerr << "Cannot open configure file" << std::endl; cmCTestLog(m_CTest, ERROR, "Cannot open configure file" << std::endl);
return 1; return 1;
} }
std::string start_time = m_CTest->CurrentTime(); std::string start_time = m_CTest->CurrentTime();
@ -70,7 +69,7 @@ int cmCTestConfigureHandler::ProcessHandler()
m_CTest->OpenOutputFile("Temporary", "LastConfigure.log", ofs); m_CTest->OpenOutputFile("Temporary", "LastConfigure.log", ofs);
res = m_CTest->RunMakeCommand(cCommand.c_str(), &output, res = m_CTest->RunMakeCommand(cCommand.c_str(), &output,
&retVal, buildDirectory.c_str(), &retVal, buildDirectory.c_str(),
m_Verbose, 0, ofs); 0, ofs);
if ( ofs ) if ( ofs )
{ {
@ -87,7 +86,7 @@ int cmCTestConfigureHandler::ProcessHandler()
os << retVal; os << retVal;
} }
os << "<ConfigureCommand>" << cCommand.c_str() << "</ConfigureCommand>" << std::endl; os << "<ConfigureCommand>" << cCommand.c_str() << "</ConfigureCommand>" << std::endl;
//std::cout << "End" << std::endl; cmCTestLog(m_CTest, DEBUG, "End" << std::endl);
os << "<Log>" << cmCTest::MakeXMLSafe(output) << "</Log>" << std::endl; os << "<Log>" << cmCTest::MakeXMLSafe(output) << "</Log>" << std::endl;
std::string end_time = m_CTest->CurrentTime(); std::string end_time = m_CTest->CurrentTime();
os << "\t<ConfigureStatus>" << retVal << "</ConfigureStatus>\n" os << "\t<ConfigureStatus>" << retVal << "</ConfigureStatus>\n"
@ -102,11 +101,11 @@ int cmCTestConfigureHandler::ProcessHandler()
} }
else else
{ {
std::cout << "Configure with command: " << cCommand << std::endl; cmCTestLog(m_CTest, DEBUG, "Configure with command: " << cCommand << std::endl);
} }
if (! res || retVal ) if (! res || retVal )
{ {
std::cerr << "Error(s) when updating the project" << std::endl; cmCTestLog(m_CTest, ERROR, "Error(s) when updating the project" << std::endl);
return -1; return -1;
} }
return 0; return 0;

95
Source/CTest/cmCTestCoverageHandler.cxx
View File

@ -34,7 +34,6 @@
//---------------------------------------------------------------------- //----------------------------------------------------------------------
cmCTestCoverageHandler::cmCTestCoverageHandler() cmCTestCoverageHandler::cmCTestCoverageHandler()
{ {
m_Verbose = false;
m_CTest = 0; m_CTest = 0;
} }
@ -43,11 +42,11 @@ bool cmCTestCoverageHandler::StartLogFile(cmGeneratedFileStream& covLogFile, int
{ {
char covLogFilename[1024]; char covLogFilename[1024];
sprintf(covLogFilename, "CoverageLog-%d.xml", logFileCount); sprintf(covLogFilename, "CoverageLog-%d.xml", logFileCount);
std::cout << "Open file: " << covLogFilename << std::endl; cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Open file: " << covLogFilename << std::endl);
if (!m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), if (!m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(),
covLogFilename, covLogFile, true)) covLogFilename, covLogFile, true))
{ {
std::cerr << "Cannot open log file: " << covLogFilename << std::endl; cmCTestLog(m_CTest, ERROR, "Cannot open log file: " << covLogFilename << std::endl);
return false; return false;
} }
std::string local_start_time = m_CTest->CurrentTime(); std::string local_start_time = m_CTest->CurrentTime();
@ -66,13 +65,13 @@ void cmCTestCoverageHandler::EndLogFile(cmGeneratedFileStream& ostr, int logFile
m_CTest->EndXML(ostr); m_CTest->EndXML(ostr);
char covLogFilename[1024]; char covLogFilename[1024];
sprintf(covLogFilename, "CoverageLog-%d.xml", logFileCount); sprintf(covLogFilename, "CoverageLog-%d.xml", logFileCount);
std::cout << "Close file: " << covLogFilename << std::endl; cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Close file: " << covLogFilename << std::endl);
ostr.close(); ostr.close();
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool cmCTestCoverageHandler::ShouldIDoCoverage(const char* file, const char* srcDir, bool cmCTestCoverageHandler::ShouldIDoCoverage(const char* file, const char* srcDir,
const char* binDir, bool verbose) const char* binDir)
{ {
std::string fSrcDir = cmSystemTools::CollapseFullPath(srcDir); std::string fSrcDir = cmSystemTools::CollapseFullPath(srcDir);
std::string fBinDir = cmSystemTools::CollapseFullPath(binDir); std::string fBinDir = cmSystemTools::CollapseFullPath(binDir);
@ -108,10 +107,7 @@ bool cmCTestCoverageHandler::ShouldIDoCoverage(const char* file, const char* src
fFile.c_str(), checkDir.c_str()); fFile.c_str(), checkDir.c_str());
if ( ndc.size() ) if ( ndc.size() )
{ {
if ( verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Found: " << ndc.c_str() << " so skip coverage of " << file << std::endl);
{
std::cout << "Found: " << ndc.c_str() << " so skip coverage of " << file << std::endl;
}
return false; return false;
} }
@ -141,10 +137,7 @@ bool cmCTestCoverageHandler::ShouldIDoCoverage(const char* file, const char* src
fFile.c_str(), checkDir.c_str()); fFile.c_str(), checkDir.c_str());
if ( ndc.size() ) if ( ndc.size() )
{ {
if ( verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Found: " << ndc.c_str() << " so skip coverage of: " << file << std::endl);
{
std::cout << "Found: " << ndc.c_str() << " so skip coverage of: " << file << std::endl;
}
return false; return false;
} }
// Ok, nothing in source tree, nothing in binary tree // Ok, nothing in source tree, nothing in binary tree
@ -171,7 +164,7 @@ int cmCTestCoverageHandler::ProcessHandler()
std::string gcovOutputRex = "[0-9]+\\.[0-9]+% of [0-9]+ (source |)lines executed in file (.*)$"; std::string gcovOutputRex = "[0-9]+\\.[0-9]+% of [0-9]+ (source |)lines executed in file (.*)$";
std::string gcovOutputRex2 = "^Creating (.*\\.gcov)\\."; std::string gcovOutputRex2 = "^Creating (.*\\.gcov)\\.";
std::cout << "Performing coverage" << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, "Performing coverage" << std::endl);
double elapsed_time_start = cmSystemTools::GetTime(); double elapsed_time_start = cmSystemTools::GetTime();
std::string coverage_start_time = m_CTest->CurrentTime(); std::string coverage_start_time = m_CTest->CurrentTime();
@ -190,7 +183,7 @@ int cmCTestCoverageHandler::ProcessHandler()
if ( files.size() == 0 ) if ( files.size() == 0 )
{ {
std::cerr << " Cannot find any coverage files." << std::endl; cmCTestLog(m_CTest, ERROR, " Cannot find any coverage files." << std::endl);
// No coverage files is a valid thing, so the exit code is 0 // No coverage files is a valid thing, so the exit code is 0
return 0; return 0;
} }
@ -209,10 +202,7 @@ int cmCTestCoverageHandler::ProcessHandler()
{ {
std::string fileDir = cmSystemTools::GetFilenamePath(it->c_str()); std::string fileDir = cmSystemTools::GetFilenamePath(it->c_str());
std::string command = "\"" + gcovCommand + "\" -l -o \"" + fileDir + "\" \"" + *it + "\""; std::string command = "\"" + gcovCommand + "\" -l -o \"" + fileDir + "\" \"" + *it + "\"";
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, command.c_str() << std::endl);
{
std::cout << command.c_str() << std::endl;
}
std::string output = ""; std::string output = "";
int retVal = 0; int retVal = 0;
int res = cmSystemTools::RunSingleCommand(command.c_str(), &output, int res = cmSystemTools::RunSingleCommand(command.c_str(), &output,
@ -220,13 +210,13 @@ int cmCTestCoverageHandler::ProcessHandler()
false, 0 /*m_TimeOut*/); false, 0 /*m_TimeOut*/);
if ( ! res ) if ( ! res )
{ {
std::cerr << "Problem running coverage on file: " << it->c_str() << std::endl; cmCTestLog(m_CTest, ERROR, "Problem running coverage on file: " << it->c_str() << std::endl);
error ++; error ++;
continue; continue;
} }
if ( retVal != 0 ) if ( retVal != 0 )
{ {
std::cerr << "Coverage command returned: " << retVal << " while processing: " << it->c_str() << std::endl; cmCTestLog(m_CTest, ERROR, "Coverage command returned: " << retVal << " while processing: " << it->c_str() << std::endl);
} }
std::vector<cmStdString> lines; std::vector<cmStdString> lines;
std::vector<cmStdString>::iterator line; std::vector<cmStdString>::iterator line;
@ -242,10 +232,7 @@ int cmCTestCoverageHandler::ProcessHandler()
file.substr(0, sourceDir.size()) == sourceDir && file.substr(0, sourceDir.size()) == sourceDir &&
file[sourceDir.size()] == '/' ) file[sourceDir.size()] == '/' )
{ {
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, " produced s: " << file << std::endl);
{
std::cout << " produced s: " << file << std::endl;
}
cfile = file; cfile = file;
} }
// Binary dir? // Binary dir?
@ -253,18 +240,15 @@ int cmCTestCoverageHandler::ProcessHandler()
file.substr(0, binaryDir.size()) == binaryDir && file.substr(0, binaryDir.size()) == binaryDir &&
file[binaryDir.size()] == '/' ) file[binaryDir.size()] == '/' )
{ {
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, " produce b: " << file << std::endl);
{
std::cout << " produce b: " << file << std::endl;
}
cfile = file; cfile = file;
} }
if ( cfile.empty() ) if ( cfile.empty() )
{ {
std::cerr << "Something went wrong" << std::endl; cmCTestLog(m_CTest, ERROR, "Something went wrong" << std::endl);
std::cerr << "File: [" << file << "]" << std::endl; cmCTestLog(m_CTest, ERROR, "File: [" << file << "]" << std::endl);
std::cerr << "s: [" << file.substr(0, sourceDir.size()) << "]" << std::endl; cmCTestLog(m_CTest, ERROR, "s: [" << file.substr(0, sourceDir.size()) << "]" << std::endl);
std::cerr << "b: [" << file.substr(0, binaryDir.size()) << "]" << std::endl; cmCTestLog(m_CTest, ERROR, "b: [" << file.substr(0, binaryDir.size()) << "]" << std::endl);
} }
} }
else if ( re2.find(line->c_str() ) ) else if ( re2.find(line->c_str() ) )
@ -273,14 +257,11 @@ int cmCTestCoverageHandler::ProcessHandler()
if ( cfile.size() ) if ( cfile.size() )
{ {
singleFileCoverageVector* vec = &totalCoverage[cfile]; singleFileCoverageVector* vec = &totalCoverage[cfile];
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, " in file: " << fname << std::endl);
{
std::cout << " in file: " << fname << std::endl;
}
std::ifstream ifile(fname.c_str()); std::ifstream ifile(fname.c_str());
if ( ! ifile ) if ( ! ifile )
{ {
std::cerr << "Cannot open file: " << fname << std::endl; cmCTestLog(m_CTest, ERROR, "Cannot open file: " << fname << std::endl);
} }
else else
{ {
@ -317,7 +298,7 @@ int cmCTestCoverageHandler::ProcessHandler()
} }
else else
{ {
std::cerr << "Unknown line: " << line->c_str() << std::endl; cmCTestLog(m_CTest, ERROR, "Unknown line: " << line->c_str() << std::endl);
error ++; error ++;
} }
} }
@ -329,7 +310,8 @@ int cmCTestCoverageHandler::ProcessHandler()
if (!m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), if (!m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(),
"Coverage.xml", covSumFile, true)) "Coverage.xml", covSumFile, true))
{ {
std::cerr << "Cannot open coverage summary file: Coverage.xml" << std::endl; cmCTestLog(m_CTest, ERROR, "Cannot open coverage summary file: Coverage.xml" << std::endl);
return -1; return -1;
} }
@ -366,30 +348,24 @@ int cmCTestCoverageHandler::ProcessHandler()
const std::string fullFileName = fileIterator->first; const std::string fullFileName = fileIterator->first;
const std::string fileName = cmSystemTools::GetFilenameName(fullFileName.c_str()); const std::string fileName = cmSystemTools::GetFilenameName(fullFileName.c_str());
std::string fullFilePath = cmSystemTools::GetFilenamePath(fullFileName.c_str()); std::string fullFilePath = cmSystemTools::GetFilenamePath(fullFileName.c_str());
if ( m_Verbose ) cmCTestLog(m_CTest, ERROR, "Process file: " << fullFileName << std::endl);
{
std::cerr << "Process file: " << fullFileName << std::endl;
}
cmSystemTools::ConvertToUnixSlashes(fullFilePath); cmSystemTools::ConvertToUnixSlashes(fullFilePath);
if ( !cmSystemTools::FileExists(fullFileName.c_str()) ) if ( !cmSystemTools::FileExists(fullFileName.c_str()) )
{ {
std::cerr << "Cannot find file: " << fullFileName.c_str() << std::endl; cmCTestLog(m_CTest, ERROR, "Cannot find file: " << fullFileName.c_str() << std::endl);
continue; continue;
} }
bool shouldIDoCoverage bool shouldIDoCoverage
= this->ShouldIDoCoverage(fullFileName.c_str(), = this->ShouldIDoCoverage(fullFileName.c_str(),
sourceDir.c_str(), binaryDir.c_str(), m_Verbose); sourceDir.c_str(), binaryDir.c_str());
if ( !shouldIDoCoverage ) if ( !shouldIDoCoverage )
{ {
if ( m_Verbose ) cmCTestLog(m_CTest, ERROR, ".NoDartCoverage found, so skip coverage check for: "
{
std::cerr << ".NoDartCoverage found, so skip coverage check for: "
<< fullFileName.c_str() << fullFileName.c_str()
<< std::endl; << std::endl);
}
continue; continue;
} }
@ -403,7 +379,7 @@ int cmCTestCoverageHandler::ProcessHandler()
std::ifstream ifs(fullFileName.c_str()); std::ifstream ifs(fullFileName.c_str());
if ( !ifs) if ( !ifs)
{ {
std::cerr << "Cannot open source file: " << fullFileName.c_str() << std::endl; cmCTestLog(m_CTest, ERROR, "Cannot open source file: " << fullFileName.c_str() << std::endl);
error ++; error ++;
continue; continue;
} }
@ -417,7 +393,7 @@ int cmCTestCoverageHandler::ProcessHandler()
{ {
if ( !cmSystemTools::GetLineFromStream(ifs, line) ) if ( !cmSystemTools::GetLineFromStream(ifs, line) )
{ {
std::cerr << "Problem reading source file: " << fullFileName.c_str() << " line:" << cc << std::endl; cmCTestLog(m_CTest, ERROR, "Problem reading source file: " << fullFileName.c_str() << " line:" << cc << std::endl);
error ++; error ++;
break; break;
} }
@ -434,7 +410,7 @@ int cmCTestCoverageHandler::ProcessHandler()
} }
if ( cmSystemTools::GetLineFromStream(ifs, line) ) if ( cmSystemTools::GetLineFromStream(ifs, line) )
{ {
std::cerr << "Looks like there are more lines in the file: " << line << std::endl; cmCTestLog(m_CTest, ERROR, "Looks like there are more lines in the file: " << line << std::endl);
} }
float cper = 0; float cper = 0;
float cmet = 0; float cmet = 0;
@ -492,14 +468,13 @@ int cmCTestCoverageHandler::ProcessHandler()
<< "</Coverage>" << std::endl; << "</Coverage>" << std::endl;
m_CTest->EndXML(covSumFile); m_CTest->EndXML(covSumFile);
std::cout << "\tCovered LOC: " << total_tested << std::endl cmCTestLog(m_CTest, HANDLER_OUTPUT, "\tCovered LOC: " << total_tested << std::endl
<< "\tNot covered LOC: " << total_untested << std::endl << "\tNot covered LOC: " << total_untested << std::endl
<< "\tTotal LOC: " << total_lines << std::endl << "\tTotal LOC: " << total_lines << std::endl
<< "\tPercentage Coverage: "; << "\tPercentage Coverage: "
<< std::setiosflags(std::ios::fixed)
std::cout.setf(std::ios::fixed, std::ios::floatfield); << std::setprecision(2)
std::cout.precision(2); << (percent_coverage) << "%" << std::endl);
std::cout << (percent_coverage) << "%" << std::endl;
cmSystemTools::ChangeDirectory(currentDirectory.c_str()); cmSystemTools::ChangeDirectory(currentDirectory.c_str());

2
Source/CTest/cmCTestCoverageHandler.h
View File

@ -41,7 +41,7 @@ public:
private: private:
bool ShouldIDoCoverage(const char* file, const char* srcDir, bool ShouldIDoCoverage(const char* file, const char* srcDir,
const char* binDir, bool verbose); const char* binDir);
bool StartLogFile(cmGeneratedFileStream& ostr, int logFileCount); bool StartLogFile(cmGeneratedFileStream& ostr, int logFileCount);
void EndLogFile(cmGeneratedFileStream& ostr, int logFileCount); void EndLogFile(cmGeneratedFileStream& ostr, int logFileCount);

2
Source/CTest/cmCTestGenericHandler.cxx
View File

@ -19,7 +19,7 @@
cmCTestGenericHandler::cmCTestGenericHandler() cmCTestGenericHandler::cmCTestGenericHandler()
{ {
m_Verbose = false; m_HandlerVerbose = false;
m_CTest = 0; m_CTest = 0;
} }

5
Source/CTest/cmCTestGenericHandler.h
View File

@ -34,7 +34,7 @@ public:
/** /**
* If verbose then more informaiton is printed out * If verbose then more informaiton is printed out
*/ */
void SetVerbose(bool val) { m_Verbose = val; } void SetVerbose(bool val) { m_HandlerVerbose = val; }
/** /**
* Populate internals from CTest custom scripts * Populate internals from CTest custom scripts
@ -51,6 +51,7 @@ public:
* Set the CTest instance * Set the CTest instance
*/ */
void SetCTestInstance(cmCTest* ctest) { m_CTest = ctest; } void SetCTestInstance(cmCTest* ctest) { m_CTest = ctest; }
cmCTest* GetCTestInstance() { return m_CTest; }
/** /**
* Construct handler * Construct handler
@ -64,7 +65,7 @@ public:
const char* GetOption(const char* op); const char* GetOption(const char* op);
protected: protected:
bool m_Verbose; bool m_HandlerVerbose;
cmCTest *m_CTest; cmCTest *m_CTest;
t_StringToString m_Options; t_StringToString m_Options;
}; };

50
Source/CTest/cmCTestMemCheckHandler.cxx
View File

@ -100,7 +100,7 @@ int cmCTestMemCheckHandler::PreProcessHandler()
if ( !this->ExecuteCommands(m_CustomPreMemCheck) ) if ( !this->ExecuteCommands(m_CustomPreMemCheck) )
{ {
std::cerr << "Problem executing pre-memcheck command(s)." << std::endl; cmCTestLog(m_CTest, ERROR, "Problem executing pre-memcheck command(s)." << std::endl);
return 0; return 0;
} }
return 1; return 1;
@ -111,7 +111,7 @@ int cmCTestMemCheckHandler::PostProcessHandler()
{ {
if ( !this->ExecuteCommands(m_CustomPostMemCheck) ) if ( !this->ExecuteCommands(m_CustomPostMemCheck) )
{ {
std::cerr << "Problem executing post-memcheck command(s)." << std::endl; cmCTestLog(m_CTest, ERROR, "Problem executing post-memcheck command(s)." << std::endl);
return 0; return 0;
} }
return 1; return 1;
@ -130,10 +130,7 @@ void cmCTestMemCheckHandler::GenerateTestCommand(std::vector<const char*>& args)
memcheckcommand += " "; memcheckcommand += " ";
memcheckcommand += cmSystemTools::EscapeSpaces(m_MemoryTesterOptionsParsed[pp].c_str()); memcheckcommand += cmSystemTools::EscapeSpaces(m_MemoryTesterOptionsParsed[pp].c_str());
} }
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Memory check command: " << memcheckcommand << std::endl);
{
std::cout << "Memory check command: " << memcheckcommand << std::endl;
}
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -188,7 +185,7 @@ void cmCTestMemCheckHandler::GenerateDartOutput(std::ostream& os)
<< "</Test>" << std::endl; << "</Test>" << std::endl;
} }
os << "\t</TestList>\n"; os << "\t</TestList>\n";
std::cout << "-- Processing memory checking output: "; cmCTestLog(m_CTest, HANDLER_OUTPUT, "-- Processing memory checking output: ");
unsigned int total = m_TestResults.size(); unsigned int total = m_TestResults.size();
unsigned int step = total / 10; unsigned int step = total / 10;
unsigned int current = 0; unsigned int current = 0;
@ -244,21 +241,24 @@ void cmCTestMemCheckHandler::GenerateDartOutput(std::ostream& os)
<< "\t</Test>" << std::endl; << "\t</Test>" << std::endl;
if ( current < cc ) if ( current < cc )
{ {
std::cout << "#"; cmCTestLog(m_CTest, HANDLER_OUTPUT, "#" << std::flush);
std::cout.flush();
current += step; current += step;
} }
} }
std::cout << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, std::endl);
std::cerr << "Memory checking results:" << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, "Memory checking results:" << std::endl);
os << "\t<DefectList>" << std::endl; os << "\t<DefectList>" << std::endl;
for ( cc = 0; cmCTestMemCheckResultStrings[cc]; cc ++ ) for ( cc = 0; cmCTestMemCheckResultStrings[cc]; cc ++ )
{ {
if ( m_MemoryTesterGlobalResults[cc] ) if ( m_MemoryTesterGlobalResults[cc] )
{ {
#ifdef cerr
# undef cerr
#endif
std::cerr.width(35); std::cerr.width(35);
std::cerr << cmCTestMemCheckResultLongStrings[cc] << " - " #define cerr no_cerr
<< m_MemoryTesterGlobalResults[cc] << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, cmCTestMemCheckResultLongStrings[cc] << " - "
<< m_MemoryTesterGlobalResults[cc] << std::endl);
os << "\t\t<Defect Type=\"" << cmCTestMemCheckResultLongStrings[cc] << "\"/>" << std::endl; os << "\t\t<Defect Type=\"" << cmCTestMemCheckResultLongStrings[cc] << "\"/>" << std::endl;
} }
} }
@ -296,8 +296,8 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking()
} }
else else
{ {
std::cerr << "Memory checker (MemoryCheckCommand) not set, or cannot find the specified program." cmCTestLog(m_CTest, ERROR, "Memory checker (MemoryCheckCommand) not set, or cannot find the specified program."
<< std::endl; << std::endl);
return false; return false;
} }
@ -330,8 +330,8 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking()
{ {
if ( !cmSystemTools::FileExists(m_CTest->GetCTestConfiguration("MemoryCheckSuppressionFile").c_str()) ) if ( !cmSystemTools::FileExists(m_CTest->GetCTestConfiguration("MemoryCheckSuppressionFile").c_str()) )
{ {
std::cerr << "Cannot find memory checker suppression file: " cmCTestLog(m_CTest, ERROR, "Cannot find memory checker suppression file: "
<< m_CTest->GetCTestConfiguration("MemoryCheckSuppressionFile").c_str() << std::endl; << m_CTest->GetCTestConfiguration("MemoryCheckSuppressionFile").c_str() << std::endl);
return false; return false;
} }
m_MemoryTesterOptions += " --suppressions=" + cmSystemTools::EscapeSpaces(m_CTest->GetCTestConfiguration("MemoryCheckSuppressionFile").c_str()) + ""; m_MemoryTesterOptions += " --suppressions=" + cmSystemTools::EscapeSpaces(m_CTest->GetCTestConfiguration("MemoryCheckSuppressionFile").c_str()) + "";
@ -349,12 +349,12 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking()
else if ( m_MemoryTester.find("boundschecker") != std::string::npos ) else if ( m_MemoryTester.find("boundschecker") != std::string::npos )
{ {
m_MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER; m_MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER;
std::cerr << "Bounds checker not yet implemented" << std::endl; cmCTestLog(m_CTest, ERROR, "Bounds checker not yet implemented" << std::endl);
return false; return false;
} }
else else
{ {
std::cerr << "Do not understand memory checker: " << m_MemoryTester.c_str() << std::endl; cmCTestLog(m_CTest, ERROR, "Do not understand memory checker: " << m_MemoryTester.c_str() << std::endl);
return false; return false;
} }
@ -409,7 +409,7 @@ bool cmCTestMemCheckHandler::ProcessMemCheckPurifyOutput(
if ( !cmSystemTools::FileExists(m_MemoryTesterOutputFile.c_str()) ) if ( !cmSystemTools::FileExists(m_MemoryTesterOutputFile.c_str()) )
{ {
log = "Cannot find Purify output file: " + m_MemoryTesterOutputFile; log = "Cannot find Purify output file: " + m_MemoryTesterOutputFile;
std::cerr << log.c_str() << std::endl; cmCTestLog(m_CTest, ERROR, log.c_str() << std::endl);
return false; return false;
} }
@ -417,7 +417,7 @@ bool cmCTestMemCheckHandler::ProcessMemCheckPurifyOutput(
if ( !ifs ) if ( !ifs )
{ {
log = "Cannot read Purify output file: " + m_MemoryTesterOutputFile; log = "Cannot read Purify output file: " + m_MemoryTesterOutputFile;
std::cerr << log.c_str() << std::endl; cmCTestLog(m_CTest, ERROR, log.c_str() << std::endl);
return false; return false;
} }
@ -445,7 +445,7 @@ bool cmCTestMemCheckHandler::ProcessMemCheckPurifyOutput(
} }
if ( cc == cmCTestMemCheckHandler::NO_MEMORY_FAULT ) if ( cc == cmCTestMemCheckHandler::NO_MEMORY_FAULT )
{ {
std::cerr<< "Unknown Purify memory fault: " << pfW.match(1) << std::endl; cmCTestLog(m_CTest, ERROR, "Unknown Purify memory fault: " << pfW.match(1) << std::endl);
ostr << "*** Unknown Purify memory fault: " << pfW.match(1) << std::endl; ostr << "*** Unknown Purify memory fault: " << pfW.match(1) << std::endl;
} }
} }
@ -508,8 +508,8 @@ bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput(
cmsys::RegularExpression vgIPW("== .*Invalid write of size [0-9]"); cmsys::RegularExpression vgIPW("== .*Invalid write of size [0-9]");
cmsys::RegularExpression vgABR("== .*pthread_mutex_unlock: mutex is locked by a different thread"); cmsys::RegularExpression vgABR("== .*pthread_mutex_unlock: mutex is locked by a different thread");
//double sttime = cmSystemTools::GetTime(); double sttime = cmSystemTools::GetTime();
//std::cout << "Start test: " << lines.size() << std::endl; cmCTestLog(m_CTest, DEBUG, "Start test: " << lines.size() << std::endl);
for ( cc = 0; cc < lines.size(); cc ++ ) for ( cc = 0; cc < lines.size(); cc ++ )
{ {
if ( valgrindLine.find(lines[cc]) ) if ( valgrindLine.find(lines[cc]) )
@ -538,7 +538,7 @@ bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput(
ostr << cmCTest::MakeXMLSafe(lines[cc]) << std::endl; ostr << cmCTest::MakeXMLSafe(lines[cc]) << std::endl;
} }
} }
//std::cout << "End test (elapsed: " << (cmSystemTools::GetTime() - sttime) << std::endl; cmCTestLog(m_CTest, DEBUG, "End test (elapsed: " << (cmSystemTools::GetTime() - sttime) << std::endl);
log = ostr.str(); log = ostr.str();
if ( defects ) if ( defects )
{ {

49
Source/CTest/cmCTestScriptHandler.cxx
View File

@ -80,7 +80,6 @@ IsFunctionBlocked(const cmListFileFunction& , cmMakefile &)
//---------------------------------------------------------------------- //----------------------------------------------------------------------
cmCTestScriptHandler::cmCTestScriptHandler() cmCTestScriptHandler::cmCTestScriptHandler()
{ {
m_Verbose = false;
m_Backup = false; m_Backup = false;
m_EmptyBinDir = false; m_EmptyBinDir = false;
m_EmptyBinDirOnce = false; m_EmptyBinDirOnce = false;
@ -463,13 +462,10 @@ int cmCTestScriptHandler::CheckOutSourceDir()
{ {
// we must now checkout the src dir // we must now checkout the src dir
output = ""; output = "";
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Run cvs: " << m_CVSCheckOut << std::endl);
{
std::cerr << "Run cvs: " << m_CVSCheckOut << std::endl;
}
res = cmSystemTools::RunSingleCommand(m_CVSCheckOut.c_str(), &output, res = cmSystemTools::RunSingleCommand(m_CVSCheckOut.c_str(), &output,
&retVal, m_CTestRoot.c_str(), &retVal, m_CTestRoot.c_str(),
m_Verbose, 0 /*m_TimeOut*/); m_HandlerVerbose, 0 /*m_TimeOut*/);
if (!res || retVal != 0) if (!res || retVal != 0)
{ {
cmSystemTools::Error("Unable to perform cvs checkout:\n", cmSystemTools::Error("Unable to perform cvs checkout:\n",
@ -543,13 +539,10 @@ int cmCTestScriptHandler::PerformExtraUpdates()
fullCommand += cvsArgs[1]; fullCommand += cvsArgs[1];
output = ""; output = "";
retVal = 0; retVal = 0;
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Run CVS: " << fullCommand.c_str() << std::endl);
{
std::cerr << "Run CVS: " << fullCommand.c_str() << std::endl;
}
res = cmSystemTools::RunSingleCommand(fullCommand.c_str(), &output, res = cmSystemTools::RunSingleCommand(fullCommand.c_str(), &output,
&retVal, cvsArgs[0].c_str(), &retVal, cvsArgs[0].c_str(),
m_Verbose, 0 /*m_TimeOut*/); m_HandlerVerbose, 0 /*m_TimeOut*/);
if (!res || retVal != 0) if (!res || retVal != 0)
{ {
cmSystemTools::Error("Unable to perform extra cvs updates:\n", cmSystemTools::Error("Unable to perform extra cvs updates:\n",
@ -592,7 +585,7 @@ int cmCTestScriptHandler::RunConfigurationDashboard()
{ {
if ( !cmCTestScriptHandler::EmptyBinaryDirectory(m_BinaryDir.c_str()) ) if ( !cmCTestScriptHandler::EmptyBinaryDirectory(m_BinaryDir.c_str()) )
{ {
std::cerr << "Problem removing the binary directory" << std::endl; cmCTestLog(m_CTest, ERROR, "Problem removing the binary directory" << std::endl);
} }
} }
@ -669,13 +662,10 @@ int cmCTestScriptHandler::RunConfigurationDashboard()
output = ""; output = "";
command += "\""; command += "\"";
retVal = 0; retVal = 0;
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Run cmake command: " << command.c_str() << std::endl);
{
std::cerr << "Run cmake command: " << command.c_str() << std::endl;
}
res = cmSystemTools::RunSingleCommand(command.c_str(), &output, res = cmSystemTools::RunSingleCommand(command.c_str(), &output,
&retVal, m_BinaryDir.c_str(), &retVal, m_BinaryDir.c_str(),
m_Verbose, 0 /*m_TimeOut*/); m_HandlerVerbose, 0 /*m_TimeOut*/);
if ( !m_CMOutFile.empty() ) if ( !m_CMOutFile.empty() )
{ {
@ -685,11 +675,8 @@ int cmCTestScriptHandler::RunConfigurationDashboard()
cmakeOutputFile = m_BinaryDir + "/" + cmakeOutputFile; cmakeOutputFile = m_BinaryDir + "/" + cmakeOutputFile;
} }
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Write CMake output to file: " << cmakeOutputFile.c_str()
{ << std::endl);
std::cerr << "Write CMake output to file: " << cmakeOutputFile.c_str()
<< std::endl;
}
cmGeneratedFileStream fout(cmakeOutputFile.c_str()); cmGeneratedFileStream fout(cmakeOutputFile.c_str());
if ( fout ) if ( fout )
{ {
@ -697,8 +684,8 @@ int cmCTestScriptHandler::RunConfigurationDashboard()
} }
else else
{ {
cmSystemTools::Error("Cannot open CMake output file: ", cmCTestLog(m_CTest, ERROR, "Cannot open CMake output file: "
cmakeOutputFile.c_str(), " for writing"); << cmakeOutputFile.c_str() << " for writing" << std::endl);
} }
} }
if (!res || retVal != 0) if (!res || retVal != 0)
@ -718,13 +705,10 @@ int cmCTestScriptHandler::RunConfigurationDashboard()
command = ctestCommands[i]; command = ctestCommands[i];
output = ""; output = "";
retVal = 0; retVal = 0;
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Run ctest command: " << command.c_str() << std::endl);
{
std::cerr << "Run ctest command: " << command.c_str() << std::endl;
}
res = cmSystemTools::RunSingleCommand(command.c_str(), &output, res = cmSystemTools::RunSingleCommand(command.c_str(), &output,
&retVal, m_BinaryDir.c_str(), &retVal, m_BinaryDir.c_str(),
m_Verbose, 0 /*m_TimeOut*/); m_HandlerVerbose, 0 /*m_TimeOut*/);
// did something critical fail in ctest // did something critical fail in ctest
if (!res || cmakeFailed || if (!res || cmakeFailed ||
@ -733,11 +717,12 @@ int cmCTestScriptHandler::RunConfigurationDashboard()
this->RestoreBackupDirectories(); this->RestoreBackupDirectories();
if (cmakeFailed) if (cmakeFailed)
{ {
cmSystemTools::Error("Unable to run cmake:\n", cmCTestLog(m_CTest, ERROR, "Unable to run cmake:" << std::endl
cmakeFailedOuput.c_str()); << cmakeFailedOuput.c_str() << std::endl);
return 10; return 10;
} }
cmSystemTools::Error("Unable to run ctest:\n", output.c_str()); cmCTestLog(m_CTest, ERROR, "Unable to run ctest:" << std::endl
<< output.c_str() << std::endl);
if (!res) if (!res)
{ {
return 11; return 11;

6
Source/CTest/cmCTestStartCommand.cxx
View File

@ -64,15 +64,15 @@ bool cmCTestStartCommand::InitialPass(
this->SetError("binary directory not specified. Specify binary directory as an argument or set CTEST_BINARY_DIRECTORY"); this->SetError("binary directory not specified. Specify binary directory as an argument or set CTEST_BINARY_DIRECTORY");
return false; return false;
} }
std::cout << "Run dashboard with model " << smodel cmCTestLog(m_CTest, OUTPUT, "Run dashboard with model " << smodel
<< " for src dir: " << src_dir << " and binary dir: " << bld_dir << std::endl; << " for src dir: " << src_dir << " and binary dir: " << bld_dir << std::endl);
std::string fname = src_dir; std::string fname = src_dir;
fname += "/CTestConfig.cmake"; fname += "/CTestConfig.cmake";
cmSystemTools::ConvertToUnixSlashes(fname); cmSystemTools::ConvertToUnixSlashes(fname);
if ( cmSystemTools::FileExists(fname.c_str()) ) if ( cmSystemTools::FileExists(fname.c_str()) )
{ {
std::cout << " Reading ctest configuration file: " << fname.c_str() << std::endl; cmCTestLog(m_CTest, OUTPUT, " Reading ctest configuration file: " << fname.c_str() << std::endl);
bool readit = m_Makefile->ReadListFile(m_Makefile->GetCurrentListFile(), bool readit = m_Makefile->ReadListFile(m_Makefile->GetCurrentListFile(),
fname.c_str() ); fname.c_str() );
if(!readit) if(!readit)

190
Source/CTest/cmCTestSubmitHandler.cxx
View File

@ -33,10 +33,23 @@ PURPOSE. See the above copyright notices for more information.
#include <sys/stat.h> #include <sys/stat.h>
typedef std::vector<char> cmCTestSubmitHandlerVectorOfChar;
static size_t
cmCTestSubmitHandlerWriteMemoryCallback(void *ptr, size_t size, size_t nmemb, void *data)
{
register int realsize = size * nmemb;
cmCTestSubmitHandlerVectorOfChar *vec = static_cast<cmCTestSubmitHandlerVectorOfChar*>(data);
const char* chPtr = static_cast<char*>(ptr);
vec->insert(vec->end(), chPtr, chPtr + realsize);
return realsize;
}
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
cmCTestSubmitHandler::cmCTestSubmitHandler() : m_HTTPProxy(), m_FTPProxy() cmCTestSubmitHandler::cmCTestSubmitHandler() : m_HTTPProxy(), m_FTPProxy()
{ {
m_Verbose = false;
m_HTTPProxy = ""; m_HTTPProxy = "";
m_HTTPProxyType = 0; m_HTTPProxyType = 0;
m_HTTPProxyAuth = ""; m_HTTPProxyAuth = "";
@ -107,11 +120,11 @@ cmCTestSubmitHandler::cmCTestSubmitHandler() : m_HTTPProxy(), m_FTPProxy()
} }
if ( m_HTTPProxy.size() > 0 ) if ( m_HTTPProxy.size() > 0 )
{ {
std::cout << " Use HTTP Proxy: " << m_HTTPProxy << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Use HTTP Proxy: " << m_HTTPProxy << std::endl);
} }
if ( m_FTPProxy.size() > 0 ) if ( m_FTPProxy.size() > 0 )
{ {
std::cout << " Use FTP Proxy: " << m_FTPProxy << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Use FTP Proxy: " << m_FTPProxy << std::endl);
} }
} }
@ -168,13 +181,11 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const cmStdString& localprefix,
ftpfile = ::fopen(local_file.c_str(), "rb"); ftpfile = ::fopen(local_file.c_str(), "rb");
*m_LogFile << "\tUpload file: " << local_file.c_str() << " to " *m_LogFile << "\tUpload file: " << local_file.c_str() << " to "
<< upload_as.c_str() << std::endl; << upload_as.c_str() << std::endl;
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, " Upload file: " << local_file.c_str() << " to "
{ << upload_as.c_str() << std::endl);
std::cout << " Upload file: " << local_file.c_str() << " to "
<< upload_as.c_str() << std::endl;
}
if ( m_Verbose ) ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 0);
if ( m_HandlerVerbose )
{ {
::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1); ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
} }
@ -187,24 +198,39 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const cmStdString& localprefix,
// and give the size of the upload (optional) // and give the size of the upload (optional)
::curl_easy_setopt(curl, CURLOPT_INFILESIZE, static_cast<long>(st.st_size)); ::curl_easy_setopt(curl, CURLOPT_INFILESIZE, static_cast<long>(st.st_size));
// and give curl the buffer for errors
::curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &error_buffer); ::curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &error_buffer);
// specify handler for output
::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, cmCTestSubmitHandlerWriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
cmCTestSubmitHandlerVectorOfChar chunk;
::curl_easy_setopt(curl, CURLOPT_FILE, (void *)&chunk);
// Now run off and do what you've been told! // Now run off and do what you've been told!
res = ::curl_easy_perform(curl); res = ::curl_easy_perform(curl);
cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "CURL output: ["
<< cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]" << std::endl);
fclose(ftpfile); fclose(ftpfile);
if ( res ) if ( res )
{ {
std::cerr << " Error when uploading file: " << local_file.c_str() << std::endl; cmCTestLog(m_CTest, ERROR, " Error when uploading file: " << local_file.c_str() << std::endl);
std::cerr << " Error message was: " << error_buffer << std::endl; cmCTestLog(m_CTest, ERROR, " Error message was: " << error_buffer << std::endl);
*m_LogFile << " Error when uploading file: " << local_file.c_str() << std::endl *m_LogFile << " Error when uploading file: " << local_file.c_str() << std::endl
<< " Error message was: " << error_buffer << std::endl; << " Error message was: " << error_buffer << std::endl
<< " Curl output was: " << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << std::endl;
cmCTestLog(m_CTest, ERROR, "CURL output: ["
<< cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]" << std::endl);
::curl_easy_cleanup(curl); ::curl_easy_cleanup(curl);
::curl_global_cleanup(); ::curl_global_cleanup();
return false; return false;
} }
// always cleanup // always cleanup
::curl_easy_cleanup(curl); ::curl_easy_cleanup(curl);
std::cout << " Uploaded: " + local_file << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Uploaded: " + local_file << std::endl);
} }
} }
::curl_global_cleanup(); ::curl_global_cleanup();
@ -261,7 +287,8 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
/* HTTP PUT please */ /* HTTP PUT please */
curl_easy_setopt(curl, CURLOPT_PUT, 1); curl_easy_setopt(curl, CURLOPT_PUT, 1);
if ( m_Verbose ) ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 0);
if ( m_HandlerVerbose )
{ {
::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1); ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
} }
@ -306,11 +333,8 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
} }
ftpfile = ::fopen(local_file.c_str(), "rb"); ftpfile = ::fopen(local_file.c_str(), "rb");
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, " Upload file: " << local_file.c_str() << " to "
{ << upload_as.c_str() << " Size: " << st.st_size << std::endl);
std::cout << " Upload file: " << local_file.c_str() << " to "
<< upload_as.c_str() << " Size: " << st.st_size << std::endl;
}
// specify target // specify target
@ -325,22 +349,36 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
// and give curl the buffer for errors // and give curl the buffer for errors
::curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &error_buffer); ::curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &error_buffer);
// specify handler for output
::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, cmCTestSubmitHandlerWriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
cmCTestSubmitHandlerVectorOfChar chunk;
::curl_easy_setopt(curl, CURLOPT_FILE, (void *)&chunk);
// Now run off and do what you've been told! // Now run off and do what you've been told!
res = ::curl_easy_perform(curl); res = ::curl_easy_perform(curl);
cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "CURL output: ["
<< cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]" << std::endl);
fclose(ftpfile); fclose(ftpfile);
if ( res ) if ( res )
{ {
std::cerr << " Error when uploading file: " << local_file.c_str() << std::endl; cmCTestLog(m_CTest, ERROR, " Error when uploading file: " << local_file.c_str() << std::endl);
cmCTestLog(m_CTest, ERROR, " Error message was: " << error_buffer << std::endl);
*m_LogFile << " Error when uploading file: " << local_file.c_str() << std::endl *m_LogFile << " Error when uploading file: " << local_file.c_str() << std::endl
<< " Error message was: " << error_buffer << std::endl; << " Error message was: " << error_buffer << std::endl
<< " Curl output was: " << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << std::endl;
cmCTestLog(m_CTest, ERROR, "CURL output: ["
<< cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]" << std::endl);
::curl_easy_cleanup(curl); ::curl_easy_cleanup(curl);
::curl_global_cleanup(); ::curl_global_cleanup();
return false; return false;
} }
// always cleanup // always cleanup
::curl_easy_cleanup(curl); ::curl_easy_cleanup(curl);
std::cout << " Uploaded: " + local_file << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Uploaded: " + local_file << std::endl);
} }
} }
::curl_global_cleanup(); ::curl_global_cleanup();
@ -388,7 +426,7 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(const std::vector<cmStdString>& file
} }
::curl_easy_setopt(curl, CURLOPT_VERBOSE, 0); ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 0);
if ( m_Verbose ) if ( m_HandlerVerbose )
{ {
::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1); ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
} }
@ -396,6 +434,13 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(const std::vector<cmStdString>& file
// and give curl the buffer for errors // and give curl the buffer for errors
::curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &error_buffer); ::curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &error_buffer);
// specify handler for output
::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, cmCTestSubmitHandlerWriteMemoryCallback);
/* we pass our 'chunk' struct to the callback function */
cmCTestSubmitHandlerVectorOfChar chunk;
::curl_easy_setopt(curl, CURLOPT_FILE, (void *)&chunk);
cmStdString file = remoteprefix + files[cc]; cmStdString file = remoteprefix + files[cc];
cmStdString ofile = ""; cmStdString ofile = "";
for ( kk = 0; kk < file.size(); kk ++ ) for ( kk = 0; kk < file.size(); kk ++ )
@ -424,26 +469,32 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(const std::vector<cmStdString>& file
= url + ((url.find("?",0) == cmStdString::npos) ? "?" : "&") = url + ((url.find("?",0) == cmStdString::npos) ? "?" : "&")
+ "xmlfile=" + ofile; + "xmlfile=" + ofile;
*m_LogFile << "Trigger url: " << turl.c_str() << std::endl; *m_LogFile << "Trigger url: " << turl.c_str() << std::endl;
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, " Trigger url: " << turl.c_str() << std::endl);
{
std::cout << " Trigger url: " << turl.c_str() << std::endl;
}
curl_easy_setopt(curl, CURLOPT_URL, turl.c_str()); curl_easy_setopt(curl, CURLOPT_URL, turl.c_str());
if ( curl_easy_perform(curl) ) if ( curl_easy_perform(curl) )
{ {
std::cerr << " Error when triggering: " << turl.c_str() << std::endl; cmCTestLog(m_CTest, ERROR, " Error when triggering: " << turl.c_str() << std::endl);
*m_LogFile << "\tTrigerring failed with error: " << error_buffer << std::endl; cmCTestLog(m_CTest, ERROR, " Error message was: " << error_buffer << std::endl);
*m_LogFile << "\tTrigerring failed with error: " << error_buffer << std::endl
<< " Error message was: " << error_buffer << std::endl
<< " Curl output was: " << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << std::endl;
cmCTestLog(m_CTest, ERROR, "CURL output: ["
<< cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]" << std::endl);
::curl_easy_cleanup(curl); ::curl_easy_cleanup(curl);
::curl_global_cleanup(); ::curl_global_cleanup();
return false; return false;
} }
cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "CURL output: ["
<< cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]" << std::endl);
// always cleanup // always cleanup
::curl_easy_cleanup(curl); ::curl_easy_cleanup(curl);
std::cout << std::endl; cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, std::endl);
} }
} }
::curl_global_cleanup(); ::curl_global_cleanup();
std::cout << " Dart server triggered..." << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Dart server triggered..." << std::endl);
return true; return true;
} }
@ -486,11 +537,8 @@ bool cmCTestSubmitHandler::SubmitUsingSCP(
argv[1] = lfname.c_str(); argv[1] = lfname.c_str();
std::string rfname = url + "/" + remoteprefix + *it; std::string rfname = url + "/" + remoteprefix + *it;
argv[2] = rfname.c_str(); argv[2] = rfname.c_str();
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Execute \"" << argv[0] << "\" \"" << argv[1] << "\" \""
{ << argv[2] << "\"" << std::endl);
std::cout << "Execute \"" << argv[0] << "\" \"" << argv[1] << "\" \""
<< argv[2] << "\"" << std::endl;
}
*m_LogFile << "Execute \"" << argv[0] << "\" \"" << argv[1] << "\" \"" *m_LogFile << "Execute \"" << argv[0] << "\" \"" << argv[1] << "\" \""
<< argv[2] << "\"" << std::endl; << argv[2] << "\"" << std::endl;
cmsysProcess_SetCommand(cp, &*argv.begin()); cmsysProcess_SetCommand(cp, &*argv.begin());
@ -499,7 +547,7 @@ bool cmCTestSubmitHandler::SubmitUsingSCP(
int length; int length;
while(cmsysProcess_WaitForData(cp, &data, &length, 0)) while(cmsysProcess_WaitForData(cp, &data, &length, 0))
{ {
std::cout.write(data, length); cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, cmCTestLogWrite(data, length));
} }
cmsysProcess_WaitForExit(cp, 0); cmsysProcess_WaitForExit(cp, 0);
int result = cmsysProcess_GetState(cp); int result = cmsysProcess_GetState(cp);
@ -509,10 +557,7 @@ bool cmCTestSubmitHandler::SubmitUsingSCP(
retVal = cmsysProcess_GetExitValue(cp); retVal = cmsysProcess_GetExitValue(cp);
if ( retVal != 0 ) if ( retVal != 0 )
{ {
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "\tSCP returned: " << retVal << std::endl);
{
std::cout << "\tSCP returned: " << retVal << std::endl;
}
*m_LogFile << "\tSCP returned: " << retVal << std::endl; *m_LogFile << "\tSCP returned: " << retVal << std::endl;
problems ++; problems ++;
} }
@ -520,29 +565,20 @@ bool cmCTestSubmitHandler::SubmitUsingSCP(
else if(result == cmsysProcess_State_Exception) else if(result == cmsysProcess_State_Exception)
{ {
retVal = cmsysProcess_GetExitException(cp); retVal = cmsysProcess_GetExitException(cp);
if ( m_Verbose ) cmCTestLog(m_CTest, ERROR, "\tThere was an exception: " << retVal << std::endl);
{
std::cerr << "\tThere was an exception: " << retVal << std::endl;
}
*m_LogFile << "\tThere was an exception: " << retVal << std::endl; *m_LogFile << "\tThere was an exception: " << retVal << std::endl;
problems ++; problems ++;
} }
else if(result == cmsysProcess_State_Expired) else if(result == cmsysProcess_State_Expired)
{ {
if ( m_Verbose ) cmCTestLog(m_CTest, ERROR, "\tThere was a timeout" << std::endl);
{
std::cerr << "\tThere was a timeout" << std::endl;
}
*m_LogFile << "\tThere was a timeout" << std::endl; *m_LogFile << "\tThere was a timeout" << std::endl;
problems ++; problems ++;
} }
else if(result == cmsysProcess_State_Error) else if(result == cmsysProcess_State_Error)
{ {
if ( m_Verbose ) cmCTestLog(m_CTest, ERROR, "\tError executing SCP: "
{ << cmsysProcess_GetErrorString(cp) << std::endl);
std::cerr << "\tError executing SCP: "
<< cmsysProcess_GetErrorString(cp) << std::endl;
}
*m_LogFile << "\tError executing SCP: " *m_LogFile << "\tError executing SCP: "
<< cmsysProcess_GetErrorString(cp) << std::endl; << cmsysProcess_GetErrorString(cp) << std::endl;
problems ++; problems ++;
@ -574,14 +610,14 @@ bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const cmStdString& localprefix,
xmlrpc_env_init(&env); xmlrpc_env_init(&env);
/* Call the famous server at UserLand. */ /* Call the famous server at UserLand. */
std::cout << " Submitting to: " << realURL.c_str() << " (" << remoteprefix.c_str() << ")" << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Submitting to: " << realURL.c_str() << " (" << remoteprefix.c_str() << ")" << std::endl);
std::vector<cmStdString>::const_iterator it; std::vector<cmStdString>::const_iterator it;
for ( it = files.begin(); it != files.end(); ++it ) for ( it = files.begin(); it != files.end(); ++it )
{ {
xmlrpc_value *result; xmlrpc_value *result;
std::string local_file = localprefix + "/" + *it; std::string local_file = localprefix + "/" + *it;
std::cout << " Submit file: " << local_file.c_str() << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Submit file: " << local_file.c_str() << std::endl);
struct stat st; struct stat st;
if ( ::stat(local_file.c_str(), &st) ) if ( ::stat(local_file.c_str(), &st) )
{ {
@ -613,7 +649,7 @@ bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const cmStdString& localprefix,
if ( env.fault_occurred ) if ( env.fault_occurred )
{ {
std::cerr << " Submission problem: " << env.fault_string << " (" << env.fault_code << ")" << std::endl; cmCTestLog(m_CTest, ERROR, " Submission problem: " << env.fault_string << " (" << env.fault_code << ")" << std::endl);
xmlrpc_env_clean(&env); xmlrpc_env_clean(&env);
xmlrpc_client_cleanup(); xmlrpc_client_cleanup();
return false; return false;
@ -637,7 +673,7 @@ int cmCTestSubmitHandler::ProcessHandler()
const std::string &buildDirectory = m_CTest->GetCTestConfiguration("BuildDirectory"); const std::string &buildDirectory = m_CTest->GetCTestConfiguration("BuildDirectory");
if ( buildDirectory.size() == 0 ) if ( buildDirectory.size() == 0 )
{ {
std::cerr << "Cannot find BuildDirectory key in the DartConfiguration.tcl" << std::endl; cmCTestLog(m_CTest, ERROR, "Cannot find BuildDirectory key in the DartConfiguration.tcl" << std::endl);
return -1; return -1;
} }
@ -658,20 +694,20 @@ int cmCTestSubmitHandler::ProcessHandler()
std::string gpath = buildDirectory + "/Testing/" + m_CTest->GetCurrentTag(); std::string gpath = buildDirectory + "/Testing/" + m_CTest->GetCurrentTag();
std::string::size_type glen = gpath.size() + 1; std::string::size_type glen = gpath.size() + 1;
gpath = gpath + "/CoverageLog*"; gpath = gpath + "/CoverageLog*";
//std::cout << "Globbing for: " << gpath.c_str() << std::endl; cmCTestLog(m_CTest, DEBUG, "Globbing for: " << gpath.c_str() << std::endl);
if ( cmSystemTools::SimpleGlob(gpath, gfiles, 1) ) if ( cmSystemTools::SimpleGlob(gpath, gfiles, 1) )
{ {
size_t cc; size_t cc;
for ( cc = 0; cc < gfiles.size(); cc ++ ) for ( cc = 0; cc < gfiles.size(); cc ++ )
{ {
gfiles[cc] = gfiles[cc].substr(glen); gfiles[cc] = gfiles[cc].substr(glen);
//std::cout << "Glob file: " << gfiles[cc].c_str() << std::endl; cmCTestLog(m_CTest, DEBUG, "Glob file: " << gfiles[cc].c_str() << std::endl);
files.push_back(gfiles[cc]); files.push_back(gfiles[cc]);
} }
} }
else else
{ {
std::cerr << "Problem globbing" << std::endl; cmCTestLog(m_CTest, ERROR, "Problem globbing" << std::endl);
} }
} }
m_CTest->AddIfExists(files, "DynamicAnalysis.xml"); m_CTest->AddIfExists(files, "DynamicAnalysis.xml");
@ -689,14 +725,14 @@ int cmCTestSubmitHandler::ProcessHandler()
cnt ++; cnt ++;
} }
} }
std::cout << "Submit files (using " << m_CTest->GetCTestConfiguration("DropMethod") << ")" cmCTestLog(m_CTest, HANDLER_OUTPUT, "Submit files (using " << m_CTest->GetCTestConfiguration("DropMethod") << ")"
<< std::endl; << std::endl);
this->SetLogFile(&ofs); this->SetLogFile(&ofs);
if ( m_CTest->GetCTestConfiguration("DropMethod") == "" || if ( m_CTest->GetCTestConfiguration("DropMethod") == "" ||
m_CTest->GetCTestConfiguration("DropMethod") == "ftp" ) m_CTest->GetCTestConfiguration("DropMethod") == "ftp" )
{ {
ofs << "Using drop method: FTP" << std::endl; ofs << "Using drop method: FTP" << std::endl;
std::cout << " Using FTP submit method" << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Using FTP submit method" << std::endl);
std::string url = "ftp://"; std::string url = "ftp://";
url += cmCTest::MakeURLSafe(m_CTest->GetCTestConfiguration("DropSiteUser")) + ":" + url += cmCTest::MakeURLSafe(m_CTest->GetCTestConfiguration("DropSiteUser")) + ":" +
cmCTest::MakeURLSafe(m_CTest->GetCTestConfiguration("DropSitePassword")) + "@" + cmCTest::MakeURLSafe(m_CTest->GetCTestConfiguration("DropSitePassword")) + "@" +
@ -705,24 +741,24 @@ int cmCTestSubmitHandler::ProcessHandler()
if ( !this->SubmitUsingFTP(buildDirectory+"/Testing/"+m_CTest->GetCurrentTag(), if ( !this->SubmitUsingFTP(buildDirectory+"/Testing/"+m_CTest->GetCurrentTag(),
files, prefix, url) ) files, prefix, url) )
{ {
std::cerr << " Problems when submitting via FTP" << std::endl; cmCTestLog(m_CTest, ERROR, " Problems when submitting via FTP" << std::endl);
ofs << " Problems when submitting via FTP" << std::endl; ofs << " Problems when submitting via FTP" << std::endl;
return -1; return -1;
} }
if ( !this->TriggerUsingHTTP(files, prefix, m_CTest->GetCTestConfiguration("TriggerSite")) ) if ( !this->TriggerUsingHTTP(files, prefix, m_CTest->GetCTestConfiguration("TriggerSite")) )
{ {
std::cerr << " Problems when triggering via HTTP" << std::endl; cmCTestLog(m_CTest, ERROR, " Problems when triggering via HTTP" << std::endl);
ofs << " Problems when triggering via HTTP" << std::endl; ofs << " Problems when triggering via HTTP" << std::endl;
return -1; return -1;
} }
std::cout << " Submission successful" << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Submission successful" << std::endl);
ofs << " Submission successful" << std::endl; ofs << " Submission successful" << std::endl;
return 0; return 0;
} }
else if ( m_CTest->GetCTestConfiguration("DropMethod") == "http" ) else if ( m_CTest->GetCTestConfiguration("DropMethod") == "http" )
{ {
ofs << "Using drop method: HTTP" << std::endl; ofs << "Using drop method: HTTP" << std::endl;
std::cout << " Using HTTP submit method" << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Using HTTP submit method" << std::endl);
std::string url = "http://"; std::string url = "http://";
if ( m_CTest->GetCTestConfiguration("DropSiteUser").size() > 0 ) if ( m_CTest->GetCTestConfiguration("DropSiteUser").size() > 0 )
{ {
@ -736,33 +772,33 @@ int cmCTestSubmitHandler::ProcessHandler()
url += m_CTest->GetCTestConfiguration("DropSite") + m_CTest->GetCTestConfiguration("DropLocation"); url += m_CTest->GetCTestConfiguration("DropSite") + m_CTest->GetCTestConfiguration("DropLocation");
if ( !this->SubmitUsingHTTP(buildDirectory +"/Testing/"+m_CTest->GetCurrentTag(), files, prefix, url) ) if ( !this->SubmitUsingHTTP(buildDirectory +"/Testing/"+m_CTest->GetCurrentTag(), files, prefix, url) )
{ {
std::cerr << " Problems when submitting via HTTP" << std::endl; cmCTestLog(m_CTest, ERROR, " Problems when submitting via HTTP" << std::endl);
ofs << " Problems when submitting via HTTP" << std::endl; ofs << " Problems when submitting via HTTP" << std::endl;
return -1; return -1;
} }
if ( !this->TriggerUsingHTTP(files, prefix, m_CTest->GetCTestConfiguration("TriggerSite")) ) if ( !this->TriggerUsingHTTP(files, prefix, m_CTest->GetCTestConfiguration("TriggerSite")) )
{ {
std::cerr << " Problems when triggering via HTTP" << std::endl; cmCTestLog(m_CTest, ERROR, " Problems when triggering via HTTP" << std::endl);
ofs << " Problems when triggering via HTTP" << std::endl; ofs << " Problems when triggering via HTTP" << std::endl;
return -1; return -1;
} }
std::cout << " Submission successful" << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Submission successful" << std::endl);
ofs << " Submission successful" << std::endl; ofs << " Submission successful" << std::endl;
return 0; return 0;
} }
else if ( m_CTest->GetCTestConfiguration("DropMethod") == "xmlrpc" ) else if ( m_CTest->GetCTestConfiguration("DropMethod") == "xmlrpc" )
{ {
ofs << "Using drop method: XML-RPC" << std::endl; ofs << "Using drop method: XML-RPC" << std::endl;
std::cout << " Using XML-RPC submit method" << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Using XML-RPC submit method" << std::endl);
std::string url = m_CTest->GetCTestConfiguration("DropSite"); std::string url = m_CTest->GetCTestConfiguration("DropSite");
prefix = m_CTest->GetCTestConfiguration("DropLocation"); prefix = m_CTest->GetCTestConfiguration("DropLocation");
if ( !this->SubmitUsingXMLRPC(buildDirectory+"/Testing/"+m_CTest->GetCurrentTag(), files, prefix, url) ) if ( !this->SubmitUsingXMLRPC(buildDirectory+"/Testing/"+m_CTest->GetCurrentTag(), files, prefix, url) )
{ {
std::cerr << " Problems when submitting via XML-RPC" << std::endl; cmCTestLog(m_CTest, ERROR, " Problems when submitting via XML-RPC" << std::endl);
ofs << " Problems when submitting via XML-RPC" << std::endl; ofs << " Problems when submitting via XML-RPC" << std::endl;
return -1; return -1;
} }
std::cout << " Submission successful" << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Submission successful" << std::endl);
ofs << " Submission successful" << std::endl; ofs << " Submission successful" << std::endl;
return 0; return 0;
} }
@ -778,14 +814,14 @@ int cmCTestSubmitHandler::ProcessHandler()
if ( !this->SubmitUsingSCP(m_CTest->GetCTestConfiguration("ScpCommand"), if ( !this->SubmitUsingSCP(m_CTest->GetCTestConfiguration("ScpCommand"),
buildDirectory+"/Testing/"+m_CTest->GetCurrentTag(), files, prefix, url) ) buildDirectory+"/Testing/"+m_CTest->GetCurrentTag(), files, prefix, url) )
{ {
std::cerr << " Problems when submitting via SCP" << std::endl; cmCTestLog(m_CTest, ERROR, " Problems when submitting via SCP" << std::endl);
ofs << " Problems when submitting via SCP" << std::endl; ofs << " Problems when submitting via SCP" << std::endl;
return -1; return -1;
} }
std::cout << " Submission successful" << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Submission successful" << std::endl);
ofs << " Submission successful" << std::endl; ofs << " Submission successful" << std::endl;
} }
std::cout << " Unknown submission method: \"" << m_CTest->GetCTestConfiguration("DropMethod") << "\"" << std::endl; cmCTestLog(m_CTest, ERROR, " Unknown submission method: \"" << m_CTest->GetCTestConfiguration("DropMethod") << "\"" << std::endl);
return -1; return -1;
} }

101
Source/CTest/cmCTestTestHandler.cxx
View File

@ -177,7 +177,7 @@ int cmCTestTestHandler::PreProcessHandler()
{ {
if ( !this->ExecuteCommands(m_CustomPreTest) ) if ( !this->ExecuteCommands(m_CustomPreTest) )
{ {
std::cerr << "Problem executing pre-test command(s)." << std::endl; cmCTestLog(m_CTest, ERROR, "Problem executing pre-test command(s)." << std::endl);
return 0; return 0;
} }
return 1; return 1;
@ -188,7 +188,7 @@ int cmCTestTestHandler::PostProcessHandler()
{ {
if ( !this->ExecuteCommands(m_CustomPostTest) ) if ( !this->ExecuteCommands(m_CustomPostTest) )
{ {
std::cerr << "Problem executing post-test command(s)." << std::endl; cmCTestLog(m_CTest, ERROR, "Problem executing post-test command(s)." << std::endl);
return 0; return 0;
} }
return 1; return 1;
@ -218,7 +218,7 @@ int cmCTestTestHandler::ProcessHandler()
m_TestResults.clear(); m_TestResults.clear();
std::cout << (m_MemCheck ? "Memory check" : "Test") << " project" << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, (m_MemCheck ? "Memory check" : "Test") << " project" << std::endl);
if ( ! this->PreProcessHandler() ) if ( ! this->PreProcessHandler() )
{ {
return -1; return -1;
@ -236,19 +236,19 @@ int cmCTestTestHandler::ProcessHandler()
{ {
if ( !m_CTest->GetShowOnly() ) if ( !m_CTest->GetShowOnly() )
{ {
std::cerr << "No tests were found!!!\n"; cmCTestLog(m_CTest, ERROR, "No tests were found!!!" << std::endl);
} }
} }
else else
{ {
if (m_Verbose && passed.size() && if (m_HandlerVerbose && passed.size() &&
(m_UseIncludeRegExp || m_UseExcludeRegExp)) (m_UseIncludeRegExp || m_UseExcludeRegExp))
{ {
std::cerr << "\nThe following tests passed:\n"; cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, std::endl << "The following tests passed:" << std::endl);
for(std::vector<cmStdString>::iterator j = passed.begin(); for(std::vector<cmStdString>::iterator j = passed.begin();
j != passed.end(); ++j) j != passed.end(); ++j)
{ {
std::cerr << "\t" << *j << "\n"; cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "\t" << *j << std::endl);
} }
} }
@ -257,14 +257,16 @@ int cmCTestTestHandler::ProcessHandler()
{ {
percent = 99; percent = 99;
} }
fprintf(stderr,"\n%.0f%% tests passed, %i tests failed out of %i\n", cmCTestLog(m_CTest, HANDLER_OUTPUT, std::endl << std::setprecision(0) << percent << "% tests passed, "
percent, int(failed.size()), total); << failed.size() << " tests failed out of " << total << std::endl);
//fprintf(stderr,"\n%.0f%% tests passed, %i tests failed out of %i\n",
// percent, int(failed.size()), total);
if (failed.size()) if (failed.size())
{ {
cmGeneratedFileStream ofs; cmGeneratedFileStream ofs;
std::cerr << "\nThe following tests FAILED:\n"; cmCTestLog(m_CTest, ERROR, std::endl << "The following tests FAILED:" << std::endl);
m_CTest->OpenOutputFile("Temporary", "LastTestsFailed.log", ofs); m_CTest->OpenOutputFile("Temporary", "LastTestsFailed.log", ofs);
std::vector<cmCTestTestHandler::cmCTestTestResult>::iterator ftit; std::vector<cmCTestTestHandler::cmCTestTestResult>::iterator ftit;
@ -274,8 +276,9 @@ int cmCTestTestHandler::ProcessHandler()
if ( ftit->m_Status != cmCTestTestHandler::COMPLETED ) if ( ftit->m_Status != cmCTestTestHandler::COMPLETED )
{ {
ofs << ftit->m_TestCount << ":" << ftit->m_Name << std::endl; ofs << ftit->m_TestCount << ":" << ftit->m_Name << std::endl;
fprintf(stderr, "\t%3d - %s (%s)\n", ftit->m_TestCount, ftit->m_Name.c_str(), cmCTestLog(m_CTest, HANDLER_OUTPUT, "\t" << std::setw(3) << ftit->m_TestCount << " - " << ftit->m_Name.c_str() << " (" << this->GetTestStatus(ftit->m_Status) << ")" << std::endl);
this->GetTestStatus(ftit->m_Status)); //fprintf(stderr, "\t%3d - %s (%s)\n", ftit->m_TestCount, ftit->m_Name.c_str(),
// this->GetTestStatus(ftit->m_Status));
} }
} }
@ -288,8 +291,8 @@ int cmCTestTestHandler::ProcessHandler()
if( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), if( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(),
(m_MemCheck ? "DynamicAnalysis.xml" : "Test.xml"), xmlfile, true) ) (m_MemCheck ? "DynamicAnalysis.xml" : "Test.xml"), xmlfile, true) )
{ {
std::cerr << "Cannot create " << (m_MemCheck ? "memory check" : "testing") cmCTestLog(m_CTest, ERROR, "Cannot create " << (m_MemCheck ? "memory check" : "testing")
<< " XML file" << std::endl; << " XML file" << std::endl);
return 1; return 1;
} }
this->GenerateDartOutput(xmlfile); this->GenerateDartOutput(xmlfile);
@ -374,11 +377,8 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
if (!(last_directory == it->m_Directory)) if (!(last_directory == it->m_Directory))
{ {
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Changing directory into "
{ << it->m_Directory.c_str() << "\n");
std::cerr << "Changing directory into "
<< it->m_Directory.c_str() << "\n";
}
last_directory = it->m_Directory; last_directory = it->m_Directory;
cmSystemTools::ChangeDirectory(it->m_Directory.c_str()); cmSystemTools::ChangeDirectory(it->m_Directory.c_str());
} }
@ -406,24 +406,21 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
} }
} }
std::cerr.width(3); cmCTestLog(m_CTest, HANDLER_OUTPUT, std::setw(3) << cnt << "/");
std::cerr << cnt << "/"; cmCTestLog(m_CTest, HANDLER_OUTPUT, std::setw(3) << tmsize << " Testing ");
std::cerr.width(3);
std::cerr << tmsize << " Testing ";
std::string outname = testname; std::string outname = testname;
outname.resize(30, ' '); outname.resize(30, ' ');
if ( m_CTest->GetShowOnly() ) if ( m_CTest->GetShowOnly() )
{ {
std::cerr << outname.c_str() << "\n"; cmCTestLog(m_CTest, HANDLER_OUTPUT, outname.c_str() << std::endl);
} }
else else
{ {
std::cerr << outname.c_str(); cmCTestLog(m_CTest, HANDLER_OUTPUT, outname.c_str());
std::cerr.flush();
} }
//std::cerr << "Testing " << args[0] << " ... "; cmCTestLog(m_CTest, DEBUG, "Testing " << args[0].Value.c_str() << " ... ");
// find the test executable // find the test executable
std::string actualCommand = this->FindTheExecutable(args[1].Value.c_str()); std::string actualCommand = this->FindTheExecutable(args[1].Value.c_str());
std::string testCommand = cmSystemTools::ConvertToOutputPath(actualCommand.c_str()); std::string testCommand = cmSystemTools::ConvertToOutputPath(actualCommand.c_str());
@ -431,8 +428,8 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
// continue if we did not find the executable // continue if we did not find the executable
if (testCommand == "") if (testCommand == "")
{ {
std::cerr << "Unable to find executable: " << cmCTestLog(m_CTest, ERROR, "Unable to find executable: "
args[1].Value.c_str() << "\n"; << args[1].Value.c_str() << std::endl);
if ( !m_CTest->GetShowOnly() ) if ( !m_CTest->GetShowOnly() )
{ {
cres.m_FullCommandLine = actualCommand; cres.m_FullCommandLine = actualCommand;
@ -464,10 +461,7 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
int retVal = 0; int retVal = 0;
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, std::endl << (m_MemCheck?"MemCheck":"Test") << " command: " << testCommand << std::endl);
{
std::cout << std::endl << (m_MemCheck?"MemCheck":"Test") << " command: " << testCommand << std::endl;
}
if ( olog ) if ( olog )
{ {
*olog << cnt << "/" << tmsize *olog << cnt << "/" << tmsize
@ -524,7 +518,7 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
{ {
if (res == cmsysProcess_State_Exited && retVal == 0) if (res == cmsysProcess_State_Exited && retVal == 0)
{ {
std::cerr << " Passed\n"; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Passed" << std::endl);
passed.push_back(testname); passed.push_back(testname);
cres.m_Status = cmCTestTestHandler::COMPLETED; cres.m_Status = cmCTestTestHandler::COMPLETED;
} }
@ -533,44 +527,44 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
cres.m_Status = cmCTestTestHandler::FAILED; cres.m_Status = cmCTestTestHandler::FAILED;
if ( res == cmsysProcess_State_Expired ) if ( res == cmsysProcess_State_Expired )
{ {
std::cerr << "***Timeout\n"; cmCTestLog(m_CTest, HANDLER_OUTPUT, "***Timeout" << std::endl);
cres.m_Status = cmCTestTestHandler::TIMEOUT; cres.m_Status = cmCTestTestHandler::TIMEOUT;
} }
else if ( res == cmsysProcess_State_Exception ) else if ( res == cmsysProcess_State_Exception )
{ {
std::cerr << "***Exception: "; cmCTestLog(m_CTest, HANDLER_OUTPUT, "***Exception: ");
switch ( retVal ) switch ( retVal )
{ {
case cmsysProcess_Exception_Fault: case cmsysProcess_Exception_Fault:
std::cerr << "SegFault"; cmCTestLog(m_CTest, HANDLER_OUTPUT, "SegFault");
cres.m_Status = cmCTestTestHandler::SEGFAULT; cres.m_Status = cmCTestTestHandler::SEGFAULT;
break; break;
case cmsysProcess_Exception_Illegal: case cmsysProcess_Exception_Illegal:
std::cerr << "Illegal"; cmCTestLog(m_CTest, HANDLER_OUTPUT, "Illegal");
cres.m_Status = cmCTestTestHandler::ILLEGAL; cres.m_Status = cmCTestTestHandler::ILLEGAL;
break; break;
case cmsysProcess_Exception_Interrupt: case cmsysProcess_Exception_Interrupt:
std::cerr << "Interrupt"; cmCTestLog(m_CTest, HANDLER_OUTPUT, "Interrupt");
cres.m_Status = cmCTestTestHandler::INTERRUPT; cres.m_Status = cmCTestTestHandler::INTERRUPT;
break; break;
case cmsysProcess_Exception_Numerical: case cmsysProcess_Exception_Numerical:
std::cerr << "Numerical"; cmCTestLog(m_CTest, HANDLER_OUTPUT, "Numerical");
cres.m_Status = cmCTestTestHandler::NUMERICAL; cres.m_Status = cmCTestTestHandler::NUMERICAL;
break; break;
default: default:
std::cerr << "Other"; cmCTestLog(m_CTest, HANDLER_OUTPUT, "Other");
cres.m_Status = cmCTestTestHandler::OTHER_FAULT; cres.m_Status = cmCTestTestHandler::OTHER_FAULT;
} }
std::cerr << "\n"; cmCTestLog(m_CTest, HANDLER_OUTPUT, std::endl);
} }
else if ( res == cmsysProcess_State_Error ) else if ( res == cmsysProcess_State_Error )
{ {
std::cerr << "***Bad command " << res << "\n"; cmCTestLog(m_CTest, HANDLER_OUTPUT, "***Bad command " << res << std::endl);
cres.m_Status = cmCTestTestHandler::BAD_COMMAND; cres.m_Status = cmCTestTestHandler::BAD_COMMAND;
} }
else else
{ {
std::cerr << "***Failed\n"; cmCTestLog(m_CTest, HANDLER_OUTPUT, "***Failed" << std::endl);
} }
failed.push_back(testname); failed.push_back(testname);
} }
@ -707,14 +701,11 @@ int cmCTestTestHandler::ExecuteCommands(std::vector<cmStdString>& vec)
for ( it = vec.begin(); it != vec.end(); ++it ) for ( it = vec.begin(); it != vec.end(); ++it )
{ {
int retVal = 0; int retVal = 0;
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Run command: " << *it << std::endl);
{
std::cout << "Run command: " << *it << std::endl;
}
if ( !cmSystemTools::RunSingleCommand(it->c_str(), 0, &retVal, 0, true /*m_Verbose*/) || if ( !cmSystemTools::RunSingleCommand(it->c_str(), 0, &retVal, 0, true /*m_Verbose*/) ||
retVal != 0 ) retVal != 0 )
{ {
std::cerr << "Problem running command: " << *it << std::endl; cmCTestLog(m_CTest, ERROR, "Problem running command: " << *it << std::endl);
return 0; return 0;
} }
} }
@ -874,10 +865,7 @@ void cmCTestTestHandler::GetListOfTests(tm_ListOfTests* testlist)
} }
if ( found ) if ( found )
{ {
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Ignore memcheck: " << *it << std::endl);
{
std::cout << "Ignore memcheck: " << *it << std::endl;
}
continue; continue;
} }
} }
@ -896,10 +884,7 @@ void cmCTestTestHandler::GetListOfTests(tm_ListOfTests* testlist)
} }
if ( found ) if ( found )
{ {
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Ignore test: " << *it << std::endl);
{
std::cout << "Ignore test: " << *it << std::endl;
}
continue; continue;
} }
} }
@ -1181,7 +1166,7 @@ std::string cmCTestTestHandler::GenerateRegressionImages(
<< " text=\"text/string\"" << " text=\"text/string\""
<< "><Value>File " << filename.c_str() << " not found</Value></NamedMeasurement>" << "><Value>File " << filename.c_str() << " not found</Value></NamedMeasurement>"
<< std::endl; << std::endl;
std::cout << "File \"" << filename.c_str() << "\" not found." << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, "File \"" << filename.c_str() << "\" not found." << std::endl);
} }
cxml.erase(measurementfile.start(), measurementfile.end() - measurementfile.start()); cxml.erase(measurementfile.start(), measurementfile.end() - measurementfile.start());
} }

113
Source/CTest/cmCTestUpdateHandler.cxx
View File

@ -51,7 +51,7 @@ public:
std::string m_Message; std::string m_Message;
}; };
cmCTestUpdateHandlerSVNXMLParser(cmCTestUpdateHandler* up) cmCTestUpdateHandlerSVNXMLParser(cmCTestUpdateHandler* up)
: cmXMLParser(), m_UpdateHandler(up), m_MinRevision(-1), m_MaxRevision(-1), m_Verbose(false) : cmXMLParser(), m_UpdateHandler(up), m_MinRevision(-1), m_MaxRevision(-1)
{ {
} }
@ -73,8 +73,6 @@ public:
int GetMinRevision() { return m_MinRevision; } int GetMinRevision() { return m_MinRevision; }
int GetMaxRevision() { return m_MaxRevision; } int GetMaxRevision() { return m_MaxRevision; }
void SetVerbose(bool v) { m_Verbose = v; }
protected: protected:
void StartElement(const char* name, const char** atts) void StartElement(const char* name, const char** atts)
{ {
@ -101,13 +99,10 @@ protected:
{ {
if ( strcmp(name, "logentry") == 0 ) if ( strcmp(name, "logentry") == 0 )
{ {
if ( m_Verbose ) cmCTestLog(m_UpdateHandler->GetCTestInstance(), HANDLER_VERBOSE_OUTPUT, "\tRevision: " << m_CommitLog.m_Revision<< std::endl
{ << "\tAuthor: " << m_CommitLog.m_Author.c_str() << std::endl
std::cout << "\tRevision: " << m_CommitLog.m_Revision<< std::endl; << "\tDate: " << m_CommitLog.m_Date.c_str() << std::endl
std::cout << "\tAuthor: " << m_CommitLog.m_Author.c_str() << std::endl; << "\tMessage: " << m_CommitLog.m_Message.c_str() << std::endl);
std::cout << "\tDate: " << m_CommitLog.m_Date.c_str() << std::endl;
std::cout << "\tMessage: " << m_CommitLog.m_Message.c_str() << std::endl;
}
m_Commits.push_back(m_CommitLog); m_Commits.push_back(m_CommitLog);
} }
else if ( strcmp(name, "author") == 0 ) else if ( strcmp(name, "author") == 0 )
@ -154,7 +149,6 @@ private:
t_VectorOfCommits m_Commits; t_VectorOfCommits m_Commits;
int m_MinRevision; int m_MinRevision;
int m_MaxRevision; int m_MaxRevision;
bool m_Verbose;
}; };
//********************************************************************** //**********************************************************************
//---------------------------------------------------------------------- //----------------------------------------------------------------------
@ -162,7 +156,6 @@ private:
//---------------------------------------------------------------------- //----------------------------------------------------------------------
cmCTestUpdateHandler::cmCTestUpdateHandler() cmCTestUpdateHandler::cmCTestUpdateHandler()
{ {
m_Verbose = false;
m_CTest = 0; m_CTest = 0;
} }
@ -211,11 +204,11 @@ int cmCTestUpdateHandler::ProcessHandler()
const char* sourceDirectory = this->GetOption("SourceDirectory"); const char* sourceDirectory = this->GetOption("SourceDirectory");
if ( !sourceDirectory ) if ( !sourceDirectory )
{ {
std::cerr << "Cannot find SourceDirectory key in the DartConfiguration.tcl" << std::endl; cmCTestLog(m_CTest, ERROR, "Cannot find SourceDirectory key in the DartConfiguration.tcl" << std::endl);
return -1; return -1;
} }
std::cout << "Updating the repository: " << sourceDirectory << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, "Updating the repository: " << sourceDirectory << std::endl);
// Get update command // Get update command
std::string updateCommand = m_CTest->GetCTestConfiguration("UpdateCommand"); std::string updateCommand = m_CTest->GetCTestConfiguration("UpdateCommand");
@ -227,7 +220,7 @@ int cmCTestUpdateHandler::ProcessHandler()
updateCommand = m_CTest->GetCTestConfiguration("SVNCommand"); updateCommand = m_CTest->GetCTestConfiguration("SVNCommand");
if ( updateCommand.empty() ) if ( updateCommand.empty() )
{ {
std::cerr << "Cannot find CVSCommand, SVNCommand, or UpdateCommand key in the DartConfiguration.tcl" << std::endl; cmCTestLog(m_CTest, ERROR, "Cannot find CVSCommand, SVNCommand, or UpdateCommand key in the DartConfiguration.tcl" << std::endl);
return -1; return -1;
} }
else else
@ -264,8 +257,8 @@ int cmCTestUpdateHandler::ProcessHandler()
std::string extra_update_opts; std::string extra_update_opts;
if ( m_CTest->GetTestModel() == cmCTest::NIGHTLY ) if ( m_CTest->GetTestModel() == cmCTest::NIGHTLY )
{ {
struct tm* t = cmCTest::GetNightlyTime(m_CTest->GetCTestConfiguration("NightlyStartTime"), struct tm* t = m_CTest->GetNightlyTime(m_CTest->GetCTestConfiguration("NightlyStartTime"),
m_Verbose, m_CTest->GetTomorrowTag()); m_CTest->GetTomorrowTag());
char current_time[1024]; char current_time[1024];
sprintf(current_time, "%04d-%02d-%02d %02d:%02d:%02d", sprintf(current_time, "%04d-%02d-%02d %02d:%02d:%02d",
t->tm_year + 1900, t->tm_year + 1900,
@ -324,15 +317,12 @@ int cmCTestUpdateHandler::ProcessHandler()
// //
if ( !command.empty() ) if ( !command.empty() )
{ {
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "* Get repository information: " << command.c_str() << std::endl);
{
std::cout << "* Get repository information: " << command.c_str() << std::endl;
}
if ( !m_CTest->GetShowOnly() ) if ( !m_CTest->GetShowOnly() )
{ {
res = cmSystemTools::RunSingleCommand(command.c_str(), &goutput, res = cmSystemTools::RunSingleCommand(command.c_str(), &goutput,
&retVal, sourceDirectory, &retVal, sourceDirectory,
m_Verbose, 0 /*m_TimeOut*/); m_HandlerVerbose, 0 /*m_TimeOut*/);
if ( ofs ) if ( ofs )
{ {
ofs << "--- Update information ---" << std::endl; ofs << "--- Update information ---" << std::endl;
@ -350,7 +340,7 @@ int cmCTestUpdateHandler::ProcessHandler()
{ {
std::string currentRevisionString = current_revision_regex.match(1); std::string currentRevisionString = current_revision_regex.match(1);
svn_current_revision = atoi(currentRevisionString.c_str()); svn_current_revision = atoi(currentRevisionString.c_str());
std::cout << " Old revision of repository is: " << svn_current_revision << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Old revision of repository is: " << svn_current_revision << std::endl);
} }
} }
break; break;
@ -358,7 +348,7 @@ int cmCTestUpdateHandler::ProcessHandler()
} }
else else
{ {
std::cout << "Update with command: " << command << std::endl; cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Update with command: " << command << std::endl);
} }
} }
@ -369,15 +359,12 @@ int cmCTestUpdateHandler::ProcessHandler()
cmGeneratedFileStream os; cmGeneratedFileStream os;
if ( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), "Update.xml", os, true) ) if ( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), "Update.xml", os, true) )
{ {
std::cerr << "Cannot open log file" << std::endl; cmCTestLog(m_CTest, ERROR, "Cannot open log file" << std::endl);
} }
std::string start_time = m_CTest->CurrentTime(); std::string start_time = m_CTest->CurrentTime();
double elapsed_time_start = cmSystemTools::GetTime(); double elapsed_time_start = cmSystemTools::GetTime();
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "* Update repository: " << command.c_str() << std::endl);
{
std::cout << "* Update repository: " << command.c_str() << std::endl;
}
if ( !m_CTest->GetShowOnly() ) if ( !m_CTest->GetShowOnly() )
{ {
command = ""; command = "";
@ -388,7 +375,7 @@ int cmCTestUpdateHandler::ProcessHandler()
" " + extra_update_opts; " " + extra_update_opts;
res = cmSystemTools::RunSingleCommand(command.c_str(), &goutput, res = cmSystemTools::RunSingleCommand(command.c_str(), &goutput,
&retVal, sourceDirectory, &retVal, sourceDirectory,
m_Verbose, 0 /*m_TimeOut*/); m_HandlerVerbose, 0 /*m_TimeOut*/);
break; break;
case cmCTestUpdateHandler::e_SVN: case cmCTestUpdateHandler::e_SVN:
{ {
@ -397,11 +384,11 @@ int cmCTestUpdateHandler::ProcessHandler()
" " + extra_update_opts; " " + extra_update_opts;
bool res1 = cmSystemTools::RunSingleCommand(command.c_str(), &partialOutput, bool res1 = cmSystemTools::RunSingleCommand(command.c_str(), &partialOutput,
&retVal, sourceDirectory, &retVal, sourceDirectory,
m_Verbose, 0 /*m_TimeOut*/); m_HandlerVerbose, 0 /*m_TimeOut*/);
command = updateCommand + " status"; command = updateCommand + " status";
res = cmSystemTools::RunSingleCommand(command.c_str(), &partialOutput, res = cmSystemTools::RunSingleCommand(command.c_str(), &partialOutput,
&retVal, sourceDirectory, &retVal, sourceDirectory,
m_Verbose, 0 /*m_TimeOut*/); m_HandlerVerbose, 0 /*m_TimeOut*/);
goutput += partialOutput; goutput += partialOutput;
res = res && res1; res = res && res1;
} }
@ -465,26 +452,21 @@ int cmCTestUpdateHandler::ProcessHandler()
} }
if ( updateType == cmCTestUpdateHandler::e_SVN ) if ( updateType == cmCTestUpdateHandler::e_SVN )
{ {
std::cout << " Current revision of repository is: " << svn_latest_revision << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Current revision of repository is: " << svn_latest_revision << std::endl);
} }
std::cout << " Gathering version information (each . represents one updated file):" << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Gathering version information (each . represents one updated file):" << std::endl);
int file_count = 0; int file_count = 0;
for ( cc= 0 ; cc < lines.size(); cc ++ ) for ( cc= 0 ; cc < lines.size(); cc ++ )
{ {
const char* line = lines[cc].c_str(); const char* line = lines[cc].c_str();
if ( file_update_line.find(line) ) if ( file_update_line.find(line) )
{
if ( !m_Verbose )
{ {
if ( file_count == 0 ) if ( file_count == 0 )
{ {
std::cout << " "; cmCTestLog(m_CTest, HANDLER_OUTPUT, " " << std::flush);
std::cout.flush();
} }
std::cout << "."; cmCTestLog(m_CTest, HANDLER_OUTPUT, "." << std::flush);
}
std::cout.flush();
std::string upChar = file_update_line.match(1); std::string upChar = file_update_line.match(1);
std::string upFile = file_update_line.match(2); std::string upFile = file_update_line.match(2);
char mod = upChar[0]; char mod = upChar[0];
@ -495,7 +477,7 @@ int cmCTestUpdateHandler::ProcessHandler()
modifiedOrConflict = true; modifiedOrConflict = true;
} }
const char* file = upFile.c_str(); const char* file = upFile.c_str();
//std::cout << "Line" << cc << ": " << mod << " - " << file << std::endl; cmCTestLog(m_CTest, DEBUG, "Line" << cc << ": " << mod << " - " << file << std::endl);
std::string output; std::string output;
if ( modifiedOrConflict ) if ( modifiedOrConflict )
@ -521,14 +503,11 @@ int cmCTestUpdateHandler::ProcessHandler()
} }
break; break;
} }
//std::cout << "Do log: " << logcommand << std::endl; cmCTestLog(m_CTest, DEBUG, "Do log: " << logcommand << std::endl);
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "* Get file update information: " << logcommand.c_str() << std::endl);
{
std::cout << "* Get file update information: " << logcommand.c_str() << std::endl;
}
res = cmSystemTools::RunSingleCommand(logcommand.c_str(), &output, res = cmSystemTools::RunSingleCommand(logcommand.c_str(), &output,
&retVal, sourceDirectory, &retVal, sourceDirectory,
m_Verbose, 0 /*m_TimeOut*/); m_HandlerVerbose, 0 /*m_TimeOut*/);
if ( ofs ) if ( ofs )
{ {
ofs << output << std::endl; ofs << output << std::endl;
@ -536,7 +515,7 @@ int cmCTestUpdateHandler::ProcessHandler()
} }
if ( res && retVal == 0) if ( res && retVal == 0)
{ {
//std::cout << output << std::endl; cmCTestLog(m_CTest, DEBUG, output << std::endl);
std::string::size_type sline = 0; std::string::size_type sline = 0;
std::string srevision1 = "Unknown"; std::string srevision1 = "Unknown";
std::string sdate1 = "Unknown"; std::string sdate1 = "Unknown";
@ -618,11 +597,11 @@ int cmCTestUpdateHandler::ProcessHandler()
srevision1 = str.str(); srevision1 = str.str();
if (!svn_status_line_regex.find(output)) if (!svn_status_line_regex.find(output))
{ {
std::cerr << "Bad output from SVN status command: " << output << std::endl; cmCTestLog(m_CTest, ERROR, "Bad output from SVN status command: " << output << std::endl);
} }
else if ( svn_status_line_regex.match(4) != file ) else if ( svn_status_line_regex.match(4) != file )
{ {
std::cerr << "Bad output from SVN status command. The file name returned: \"" << svn_status_line_regex.match(4) << "\" was different than the file specified: \"" << file << "\"" << std::endl; cmCTestLog(m_CTest, ERROR, "Bad output from SVN status command. The file name returned: \"" << svn_status_line_regex.match(4) << "\" was different than the file specified: \"" << file << "\"" << std::endl);
} }
else else
{ {
@ -638,7 +617,6 @@ int cmCTestUpdateHandler::ProcessHandler()
else else
{ {
cmCTestUpdateHandlerSVNXMLParser parser(this); cmCTestUpdateHandlerSVNXMLParser parser(this);
parser.SetVerbose(m_Verbose);
if ( parser.Parse(output.c_str()) ) if ( parser.Parse(output.c_str()) )
{ {
int minrev = parser.GetMinRevision(); int minrev = parser.GetMinRevision();
@ -719,12 +697,9 @@ int cmCTestUpdateHandler::ProcessHandler()
{ {
srevision2 = srevision1; srevision2 = srevision1;
} }
if ( m_Verbose ) cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "File: " << path.c_str() << " / " << fname.c_str() << " was updated by "
{
std::cout << "File: " << path.c_str() << " / " << fname.c_str() << " was updated by "
<< sauthor1.c_str() << " to revision: " << srevision1.c_str() << sauthor1.c_str() << " to revision: " << srevision1.c_str()
<< " from revision: " << srevision2.c_str() << std::endl; << " from revision: " << srevision2.c_str() << std::endl);
}
os << "\t\t<File Directory=\"" << cmCTest::MakeXMLSafe(path) << "\">" << cmCTest::MakeXMLSafe(fname) os << "\t\t<File Directory=\"" << cmCTest::MakeXMLSafe(path) << "\">" << cmCTest::MakeXMLSafe(fname)
<< "</File>\n" << "</File>\n"
<< "\t\t<Directory>" << cmCTest::MakeXMLSafe(path) << "</Directory>\n" << "\t\t<Directory>" << cmCTest::MakeXMLSafe(path) << "</Directory>\n"
@ -785,25 +760,25 @@ int cmCTestUpdateHandler::ProcessHandler()
} }
if ( file_count ) if ( file_count )
{ {
std::cout << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, std::endl);
} }
if ( num_updated ) if ( num_updated )
{ {
std::cout << " Found " << num_updated << " updated files" << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Found " << num_updated << " updated files" << std::endl);
} }
if ( num_modified ) if ( num_modified )
{ {
std::cout << " Found " << num_modified << " locally modified files" cmCTestLog(m_CTest, HANDLER_OUTPUT, " Found " << num_modified << " locally modified files"
<< std::endl; << std::endl);
} }
if ( num_conflicting ) if ( num_conflicting )
{ {
std::cout << " Found " << num_conflicting << " conflicting files" cmCTestLog(m_CTest, HANDLER_OUTPUT, " Found " << num_conflicting << " conflicting files"
<< std::endl; << std::endl);
} }
if ( num_modified == 0 && num_conflicting == 0 && num_updated == 0 ) if ( num_modified == 0 && num_conflicting == 0 && num_updated == 0 )
{ {
std::cout << " Project is up-to-date" << std::endl; cmCTestLog(m_CTest, HANDLER_OUTPUT, " Project is up-to-date" << std::endl);
} }
if ( !first_file ) if ( !first_file )
{ {
@ -826,7 +801,7 @@ int cmCTestUpdateHandler::ProcessHandler()
os << "\t</Author>" << std::endl; os << "\t</Author>" << std::endl;
} }
//std::cout << "End" << std::endl; cmCTestLog(m_CTest, DEBUG, "End" << std::endl);
std::string end_time = m_CTest->CurrentTime(); std::string end_time = m_CTest->CurrentTime();
os << "\t<EndDateTime>" << end_time << "</EndDateTime>\n" os << "\t<EndDateTime>" << end_time << "</EndDateTime>\n"
<< "<ElapsedMinutes>" << << "<ElapsedMinutes>" <<
@ -836,13 +811,13 @@ int cmCTestUpdateHandler::ProcessHandler()
if ( num_modified > 0 || num_conflicting > 0 ) if ( num_modified > 0 || num_conflicting > 0 )
{ {
os << "Update error: There are modified or conflicting files in the repository"; os << "Update error: There are modified or conflicting files in the repository";
std::cerr << " There are modified or conflicting files in the repository" << std::endl; cmCTestLog(m_CTest, ERROR, " There are modified or conflicting files in the repository" << std::endl);
} }
if ( updateProducedError ) if ( updateProducedError )
{ {
os << "Update error: "; os << "Update error: ";
os << m_CTest->MakeXMLSafe(goutput); os << m_CTest->MakeXMLSafe(goutput);
std::cerr << " Update with command: " << command << " failed" << std::endl; cmCTestLog(m_CTest, ERROR, " Update with command: " << command << " failed" << std::endl);
} }
os << "</UpdateReturnStatus>" << std::endl; os << "</UpdateReturnStatus>" << std::endl;
os << "</Update>" << std::endl; os << "</Update>" << std::endl;
@ -854,8 +829,8 @@ int cmCTestUpdateHandler::ProcessHandler()
if (! res || retVal ) if (! res || retVal )
{ {
std::cerr << "Error(s) when updating the project" << std::endl; cmCTestLog(m_CTest, ERROR, "Error(s) when updating the project" << std::endl);
std::cerr << "Output: " << goutput << std::endl; cmCTestLog(m_CTest, ERROR, "Output: " << goutput << std::endl);
return -1; return -1;
} }
return count; return count;

310
Source/cmCTest.cxx
View File

@ -50,16 +50,12 @@
#define DEBUGERR std::cerr << __LINE__ << " "; std::cerr #define DEBUGERR std::cerr << __LINE__ << " "; std::cerr
struct tm* cmCTest::GetNightlyTime(std::string str, struct tm* cmCTest::GetNightlyTime(std::string str,
bool verbose,
bool tomorrowtag) bool tomorrowtag)
{ {
struct tm* lctime; struct tm* lctime;
time_t tctime = time(0); time_t tctime = time(0);
if ( verbose ) cmCTestLog(this, OUTPUT, "Determine Nightly Start Time" << std::endl
{ << " Specified time: " << str.c_str() << std::endl);
std::cout << "Determine Nightly Start Time" << std::endl;
std::cout << " Specified time: " << str.c_str() << std::endl;
}
//Convert the nightly start time to seconds. Since we are //Convert the nightly start time to seconds. Since we are
//providing only a time and a timezone, the current date of //providing only a time and a timezone, the current date of
//the local machine is assumed. Consequently, nightlySeconds //the local machine is assumed. Consequently, nightlySeconds
@ -67,18 +63,12 @@ struct tm* cmCTest::GetNightlyTime(std::string str,
//will be opened on the date of the current client machine. //will be opened on the date of the current client machine.
//As such, this time may be in the past or in the future. //As such, this time may be in the past or in the future.
time_t ntime = curl_getdate(str.c_str(), &tctime); time_t ntime = curl_getdate(str.c_str(), &tctime);
if ( verbose ) cmCTestLog(this, DEBUG, " Get curl time: " << ntime << std::endl);
{
std::cout << " Get curl time: " << ntime << std::endl;
}
tctime = time(0); tctime = time(0);
if ( verbose ) cmCTestLog(this, DEBUG, " Get the current time: " << tctime << std::endl);
{
std::cout << " Get the current time: " << tctime << std::endl;
}
const int dayLength = 24 * 60 * 60; const int dayLength = 24 * 60 * 60;
//std::cout << "Seconds: " << tctime << std::endl; cmCTestLog(this, DEBUG, "Seconds: " << tctime << std::endl);
while ( ntime > tctime ) while ( ntime > tctime )
{ {
// If nightlySeconds is in the past, this is the current // If nightlySeconds is in the past, this is the current
@ -87,29 +77,20 @@ struct tm* cmCTest::GetNightlyTime(std::string str,
// dashboard to be opened, so subtract 24 hours to get the // dashboard to be opened, so subtract 24 hours to get the
// time of the current open dashboard // time of the current open dashboard
ntime -= dayLength; ntime -= dayLength;
//std::cout << "Pick yesterday" << std::endl; cmCTestLog(this, DEBUG, "Pick yesterday" << std::endl);
if ( verbose ) cmCTestLog(this, DEBUG, " Future time, subtract day: " << ntime << std::endl);
{
std::cout << " Future time, subtract day: " << ntime << std::endl;
}
} }
while ( tctime > (ntime + dayLength) ) while ( tctime > (ntime + dayLength) )
{ {
ntime += dayLength; ntime += dayLength;
if ( verbose ) cmCTestLog(this, DEBUG, " Past time, add day: " << ntime << std::endl);
{
std::cout << " Past time, add day: " << ntime << std::endl;
}
}
//std::cout << "nightlySeconds: " << ntime << std::endl;
if ( verbose )
{
std::cout << " Current time: " << tctime
<< " Nightly time: " << ntime << std::endl;
} }
cmCTestLog(this, DEBUG, "nightlySeconds: " << ntime << std::endl);
cmCTestLog(this, DEBUG, " Current time: " << tctime
<< " Nightly time: " << ntime << std::endl);
if ( tomorrowtag ) if ( tomorrowtag )
{ {
std::cout << "Use future tag, Add a day" << std::endl; cmCTestLog(this, OUTPUT, " Use future tag, Add a day" << std::endl);
ntime += dayLength; ntime += dayLength;
} }
lctime = gmtime(&ntime); lctime = gmtime(&ntime);
@ -145,7 +126,7 @@ std::string cmCTest::CurrentTime()
{ {
strftime(current_time, 1000, "%a %b %d %H:%M:%S %Z %Y", t); strftime(current_time, 1000, "%a %b %d %H:%M:%S %Z %Y", t);
} }
//std::cout << "Current_Time: " << current_time << std::endl; cmCTestLog(this, DEBUG, " Current_Time: " << current_time << std::endl);
return cmCTest::MakeXMLSafe(cmCTest::CleanString(current_time)); return cmCTest::MakeXMLSafe(cmCTest::CleanString(current_time));
} }
@ -227,6 +208,8 @@ cmCTest::cmCTest()
m_BuildNoClean = false; m_BuildNoClean = false;
m_BuildTwoConfig = false; m_BuildTwoConfig = false;
m_Verbose = false; m_Verbose = false;
m_Debug = false;
m_Quiet = false;
m_ExtraVerbose = false; m_ExtraVerbose = false;
m_ProduceXML = false; m_ProduceXML = false;
m_ShowOnly = false; m_ShowOnly = false;
@ -258,6 +241,8 @@ cmCTest::cmCTest()
{ {
it->second->SetCTestInstance(this); it->second->SetCTestInstance(this);
} }
m_OutputLogFile = 0;
m_OutputLogFileLastTag = -1;
} }
cmCTest::~cmCTest() cmCTest::~cmCTest()
@ -268,6 +253,7 @@ cmCTest::~cmCTest()
delete it->second; delete it->second;
it->second = 0; it->second = 0;
} }
this->SetOutputLogFileName(0);
} }
int cmCTest::Initialize(const char* binary_dir, bool new_tag) int cmCTest::Initialize(const char* binary_dir, bool new_tag)
@ -291,8 +277,8 @@ int cmCTest::Initialize(const char* binary_dir, bool new_tag)
{ {
if ( !cmSystemTools::FileIsDirectory(testingDir.c_str()) ) if ( !cmSystemTools::FileIsDirectory(testingDir.c_str()) )
{ {
std::cerr << "File " << testingDir << " is in the place of the testing directory" cmCTestLog(this, ERROR, "File " << testingDir << " is in the place of the testing directory"
<< std::endl; << std::endl);
return 0; return 0;
} }
} }
@ -300,8 +286,8 @@ int cmCTest::Initialize(const char* binary_dir, bool new_tag)
{ {
if ( !cmSystemTools::MakeDirectory(testingDir.c_str()) ) if ( !cmSystemTools::MakeDirectory(testingDir.c_str()) )
{ {
std::cerr << "Cannot create directory " << testingDir cmCTestLog(this, ERROR, "Cannot create directory " << testingDir
<< std::endl; << std::endl);
return 0; return 0;
} }
} }
@ -341,13 +327,11 @@ int cmCTest::Initialize(const char* binary_dir, bool new_tag)
} }
if ( tag.size() == 0 || new_tag || m_Tests[cmCTest::START_TEST] || m_Tests[ALL_TEST]) if ( tag.size() == 0 || new_tag || m_Tests[cmCTest::START_TEST] || m_Tests[ALL_TEST])
{ {
//std::cout << "TestModel: " << this->GetTestModelString() << std::endl; cmCTestLog(this, DEBUG, "TestModel: " << this->GetTestModelString() << std::endl);
//std::cout << "TestModel: " << m_TestModel << std::endl; cmCTestLog(this, DEBUG, "TestModel: " << m_TestModel << std::endl);
if ( m_TestModel == cmCTest::NIGHTLY ) if ( m_TestModel == cmCTest::NIGHTLY )
{ {
lctime = cmCTest::GetNightlyTime(m_CTestConfiguration["NightlyStartTime"], lctime = this->GetNightlyTime(m_CTestConfiguration["NightlyStartTime"], m_TomorrowTag);
m_ExtraVerbose,
m_TomorrowTag);
} }
char datestring[100]; char datestring[100];
sprintf(datestring, "%04d%02d%02d-%02d%02d", sprintf(datestring, "%04d%02d%02d-%02d%02d",
@ -364,8 +348,8 @@ int cmCTest::Initialize(const char* binary_dir, bool new_tag)
ofs << this->GetTestModelString() << std::endl; ofs << this->GetTestModelString() << std::endl;
} }
ofs.close(); ofs.close();
std::cout << "Create new tag: " << tag << " - " cmCTestLog(this, OUTPUT, "Create new tag: " << tag << " - "
<< this->GetTestModelString() << std::endl; << this->GetTestModelString() << std::endl);
} }
m_CurrentTag = tag; m_CurrentTag = tag;
} }
@ -389,7 +373,7 @@ bool cmCTest::UpdateCTestConfiguration()
} }
if ( !cmSystemTools::FileExists(fileName.c_str()) ) if ( !cmSystemTools::FileExists(fileName.c_str()) )
{ {
std::cerr << "Cannot find file: " << fileName.c_str() << std::endl; cmCTestLog(this, ERROR, "Cannot find file: " << fileName.c_str() << std::endl);
return false; return false;
} }
// parse the dart test file // parse the dart test file
@ -501,7 +485,7 @@ bool cmCTest::SetTest(const char* ttype, bool report)
{ {
if ( report ) if ( report )
{ {
std::cerr << "Don't know about test \"" << ttype << "\" yet..." << std::endl; cmCTestLog(this, ERROR, "Don't know about test \"" << ttype << "\" yet..." << std::endl);
} }
return false; return false;
} }
@ -527,9 +511,9 @@ bool cmCTest::OpenOutputFile(const std::string& path,
{ {
if ( !cmSystemTools::FileIsDirectory(testingDir.c_str()) ) if ( !cmSystemTools::FileIsDirectory(testingDir.c_str()) )
{ {
std::cerr << "File " << testingDir cmCTestLog(this, ERROR, "File " << testingDir
<< " is in the place of the testing directory" << " is in the place of the testing directory"
<< std::endl; << std::endl);
return false; return false;
} }
} }
@ -537,8 +521,8 @@ bool cmCTest::OpenOutputFile(const std::string& path,
{ {
if ( !cmSystemTools::MakeDirectory(testingDir.c_str()) ) if ( !cmSystemTools::MakeDirectory(testingDir.c_str()) )
{ {
std::cerr << "Cannot create directory " << testingDir cmCTestLog(this, ERROR, "Cannot create directory " << testingDir
<< std::endl; << std::endl);
return false; return false;
} }
} }
@ -546,7 +530,7 @@ bool cmCTest::OpenOutputFile(const std::string& path,
stream.Open(filename.c_str()); stream.Open(filename.c_str());
if( !stream ) if( !stream )
{ {
std::cerr << "Problem opening file: " << filename << std::endl; cmCTestLog(this, ERROR, "Problem opening file: " << filename << std::endl);
return false; return false;
} }
if ( compress ) if ( compress )
@ -751,7 +735,7 @@ int cmCTest::GetTestModelFromString(const char* str)
} }
int cmCTest::RunMakeCommand(const char* command, std::string* output, int cmCTest::RunMakeCommand(const char* command, std::string* output,
int* retVal, const char* dir, bool verbose, int timeout, std::ofstream& ofs) int* retVal, const char* dir, int timeout, std::ofstream& ofs)
{ {
std::vector<cmStdString> args = cmSystemTools::ParseArguments(command); std::vector<cmStdString> args = cmSystemTools::ParseArguments(command);
@ -786,11 +770,8 @@ int cmCTest::RunMakeCommand(const char* command, std::string* output,
char* data; char* data;
int length; int length;
if ( !verbose ) cmCTestLog(this, HANDLER_OUTPUT, " Each . represents " << tick_len << " bytes of output" << std::endl
{ << " " << std::flush);
std::cout << " Each . represents " << tick_len << " bytes of output" << std::endl;
std::cout << " " << std::flush;
}
while(cmsysProcess_WaitForData(cp, &data, &length, 0)) while(cmsysProcess_WaitForData(cp, &data, &length, 0))
{ {
if ( output ) if ( output )
@ -804,34 +785,26 @@ int cmCTest::RunMakeCommand(const char* command, std::string* output,
} }
output->append(data, length); output->append(data, length);
if ( !verbose )
{
while ( output->size() > (tick * tick_len) ) while ( output->size() > (tick * tick_len) )
{ {
tick ++; tick ++;
std::cout << "." << std::flush; cmCTestLog(this, HANDLER_OUTPUT, "." << std::flush);
if ( tick % tick_line_len == 0 && tick > 0 ) if ( tick % tick_line_len == 0 && tick > 0 )
{ {
std::cout << " Size: "; cmCTestLog(this, HANDLER_OUTPUT, " Size: "
std::cout << int((output->size() / 1024.0) + 1) << "K" << std::endl; << int((output->size() / 1024.0) + 1) << "K" << std::endl
std::cout << " " << std::flush; << " " << std::flush);
} }
} }
} }
} cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, cmCTestLogWrite(data, length));
if(verbose)
{
std::cout.write(data, length);
std::cout.flush();
}
if ( ofs ) if ( ofs )
{ {
ofs.write(data, length); ofs << cmCTestLogWrite(data, length);
ofs.flush();
} }
} }
std::cout << " Size of output: "; cmCTestLog(this, OUTPUT, " Size of output: "
std::cout << int(output->size() / 1024.0) << "K" << std::endl; << int(output->size() / 1024.0) << "K" << std::endl);
cmsysProcess_WaitForExit(cp, 0); cmsysProcess_WaitForExit(cp, 0);
@ -844,11 +817,11 @@ int cmCTest::RunMakeCommand(const char* command, std::string* output,
else if(result == cmsysProcess_State_Exception) else if(result == cmsysProcess_State_Exception)
{ {
*retVal = cmsysProcess_GetExitException(cp); *retVal = cmsysProcess_GetExitException(cp);
std::cout << "There was an exception: " << *retVal << std::endl; cmCTestLog(this, WARNING, "There was an exception: " << *retVal << std::endl);
} }
else if(result == cmsysProcess_State_Expired) else if(result == cmsysProcess_State_Expired)
{ {
std::cout << "There was a timeout" << std::endl; cmCTestLog(this, WARNING, "There was a timeout" << std::endl);
} }
else if(result == cmsysProcess_State_Error) else if(result == cmsysProcess_State_Error)
{ {
@ -892,11 +865,8 @@ int cmCTest::RunTest(std::vector<const char*> argv,
} }
cmSystemTools::ChangeDirectory(oldpath.c_str()); cmSystemTools::ChangeDirectory(oldpath.c_str());
if(m_ExtraVerbose) cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "Internal cmCTest object used to run test." << std::endl
{ << *output << std::endl);
std::cout << "Internal cmCTest object used to run test.\n";
std::cout << *output << "\n";
}
return cmsysProcess_State_Exited; return cmsysProcess_State_Exited;
} }
std::vector<char> tempOutput; std::vector<char> tempOutput;
@ -907,7 +877,7 @@ int cmCTest::RunTest(std::vector<const char*> argv,
cmsysProcess* cp = cmsysProcess_New(); cmsysProcess* cp = cmsysProcess_New();
cmsysProcess_SetCommand(cp, &*argv.begin()); cmsysProcess_SetCommand(cp, &*argv.begin());
// std::cout << "Command is: " << argv[0] << std::endl; cmCTestLog(this, DEBUG, "Command is: " << argv[0] << std::endl);
if(cmSystemTools::GetRunCommandHideConsole()) if(cmSystemTools::GetRunCommandHideConsole())
{ {
cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1); cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
@ -923,15 +893,10 @@ int cmCTest::RunTest(std::vector<const char*> argv,
{ {
tempOutput.insert(tempOutput.end(), data, data+length); tempOutput.insert(tempOutput.end(), data, data+length);
} }
if ( m_ExtraVerbose ) cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, cmCTestLogWrite(data, length));
{
std::cout.write(data, length);
std::cout.flush();
}
if ( log ) if ( log )
{ {
log->write(data, length); log->write(data, length);
log->flush();
} }
} }
@ -940,10 +905,7 @@ int cmCTest::RunTest(std::vector<const char*> argv,
{ {
output->append(&*tempOutput.begin(), tempOutput.size()); output->append(&*tempOutput.begin(), tempOutput.size());
} }
if ( m_ExtraVerbose ) cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "-- Process completed" << std::endl);
{
std::cout << "-- Process completed" << std::endl;
}
int result = cmsysProcess_GetState(cp); int result = cmsysProcess_GetState(cp);
@ -957,22 +919,14 @@ int cmCTest::RunTest(std::vector<const char*> argv,
std::string outerr = "\n*** Exception executing: "; std::string outerr = "\n*** Exception executing: ";
outerr += cmsysProcess_GetExceptionString(cp); outerr += cmsysProcess_GetExceptionString(cp);
*output += outerr; *output += outerr;
if ( m_ExtraVerbose ) cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, outerr.c_str() << std::endl << std::flush);
{
std::cout << outerr.c_str() << "\n";
std::cout.flush();
}
} }
else if(result == cmsysProcess_State_Error) else if(result == cmsysProcess_State_Error)
{ {
std::string outerr = "\n*** ERROR executing: "; std::string outerr = "\n*** ERROR executing: ";
outerr += cmsysProcess_GetErrorString(cp); outerr += cmsysProcess_GetErrorString(cp);
*output += outerr; *output += outerr;
if ( m_ExtraVerbose ) cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, outerr.c_str() << std::endl << std::flush);
{
std::cout << outerr.c_str() << "\n";
std::cout.flush();
}
} }
cmsysProcess_Delete(cp); cmsysProcess_Delete(cp);
@ -1009,7 +963,7 @@ int cmCTest::GenerateCTestNotesOutput(std::ostream& os, const cmCTest::tm_Vector
for ( it = files.begin(); it != files.end(); it ++ ) for ( it = files.begin(); it != files.end(); it ++ )
{ {
std::cout << "\tAdd file: " << it->c_str() << std::endl; cmCTestLog(this, OUTPUT, "\tAdd file: " << it->c_str() << std::endl);
std::string note_time = this->CurrentTime(); std::string note_time = this->CurrentTime();
os << "<Note Name=\"" << this->MakeXMLSafe(it->c_str()) << "\">\n" os << "<Note Name=\"" << this->MakeXMLSafe(it->c_str()) << "\">\n"
<< "<DateTime>" << note_time << "</DateTime>\n" << "<DateTime>" << note_time << "</DateTime>\n"
@ -1027,7 +981,7 @@ int cmCTest::GenerateCTestNotesOutput(std::ostream& os, const cmCTest::tm_Vector
else else
{ {
os << "Problem reading file: " << it->c_str() << std::endl; os << "Problem reading file: " << it->c_str() << std::endl;
std::cerr << "Problem reading file: " << it->c_str() << " while creating notes" << std::endl; cmCTestLog(this, ERROR, "Problem reading file: " << it->c_str() << " while creating notes" << std::endl);
} }
os << "</Text>\n" os << "</Text>\n"
<< "</Note>" << std::endl; << "</Note>" << std::endl;
@ -1042,7 +996,7 @@ int cmCTest::GenerateNotesFile(const std::vector<cmStdString> &files)
cmGeneratedFileStream ofs; cmGeneratedFileStream ofs;
if ( !this->OpenOutputFile(m_CurrentTag, "Notes.xml", ofs) ) if ( !this->OpenOutputFile(m_CurrentTag, "Notes.xml", ofs) )
{ {
std::cerr << "Cannot open notes file" << std::endl; cmCTestLog(this, ERROR, "Cannot open notes file" << std::endl);
return 1; return 1;
} }
@ -1059,7 +1013,7 @@ int cmCTest::GenerateNotesFile(const char* cfiles)
std::vector<cmStdString> files; std::vector<cmStdString> files;
std::cout << "Create notes file" << std::endl; cmCTestLog(this, OUTPUT, "Create notes file" << std::endl);
files = cmSystemTools::SplitString(cfiles, ';'); files = cmSystemTools::SplitString(cfiles, ';');
if ( files.size() == 0 ) if ( files.size() == 0 )
@ -1092,6 +1046,10 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
cmSystemTools::ReplaceString(this->m_ConfigType, ".\\", ""); cmSystemTools::ReplaceString(this->m_ConfigType, ".\\", "");
} }
if( arg.find("-Q",0) == 0 || arg.find("--quiet",0) == 0 )
{
this->m_Quiet = true;
}
if( arg.find("-V",0) == 0 || arg.find("--verbose",0) == 0 ) if( arg.find("-V",0) == 0 || arg.find("--verbose",0) == 0 )
{ {
this->m_Verbose = true; this->m_Verbose = true;
@ -1115,6 +1073,12 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
ch->AddConfigurationScript(args[i].c_str()); ch->AddConfigurationScript(args[i].c_str());
} }
if( ( arg.find("-O",0) == 0 || arg.find("--output-log") == 0 ) && i < args.size() - 1 )
{
i++;
this->SetOutputLogFileName(args[i].c_str());
}
if( arg.find("--tomorrow-tag",0) == 0 ) if( arg.find("--tomorrow-tag",0) == 0 )
{ {
m_TomorrowTag = true; m_TomorrowTag = true;
@ -1312,8 +1276,8 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
else else
{ {
performSomeTest = false; performSomeTest = false;
std::cerr << "CTest -D called with incorrect option: " << targ << std::endl; cmCTestLog(this, ERROR, "CTest -D called with incorrect option: " << targ << std::endl);
std::cerr << "Available options are:" << std::endl cmCTestLog(this, ERROR, "Available options are:" << std::endl
<< " " << ctestExec << " -D Continuous" << std::endl << " " << ctestExec << " -D Continuous" << std::endl
<< " " << ctestExec << " -D Continuous(Start|Update|Configure|Build)" << std::endl << " " << ctestExec << " -D Continuous(Start|Update|Configure|Build)" << std::endl
<< " " << ctestExec << " -D Continuous(Test|Coverage|MemCheck|Submit)" << std::endl << " " << ctestExec << " -D Continuous(Test|Coverage|MemCheck|Submit)" << std::endl
@ -1323,8 +1287,7 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
<< " " << ctestExec << " -D Nightly" << std::endl << " " << ctestExec << " -D Nightly" << std::endl
<< " " << ctestExec << " -D Nightly(Start|Update|Configure|Build)" << std::endl << " " << ctestExec << " -D Nightly(Start|Update|Configure|Build)" << std::endl
<< " " << ctestExec << " -D Nightly(Test|Coverage|MemCheck|Submit)" << std::endl << " " << ctestExec << " -D Nightly(Test|Coverage|MemCheck|Submit)" << std::endl
<< " " << ctestExec << " -D NightlyMemoryCheck" << std::endl; << " " << ctestExec << " -D NightlyMemoryCheck" << std::endl);
;
} }
} }
@ -1336,8 +1299,8 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
if ( !this->SetTest(args[i].c_str(), false) ) if ( !this->SetTest(args[i].c_str(), false) )
{ {
performSomeTest = false; performSomeTest = false;
std::cerr << "CTest -T called with incorrect option: " << args[i].c_str() << std::endl; cmCTestLog(this, ERROR, "CTest -T called with incorrect option: " << args[i].c_str() << std::endl);
std::cerr << "Available options are:" << std::endl cmCTestLog(this, ERROR, "Available options are:" << std::endl
<< " " << ctestExec << " -T all" << std::endl << " " << ctestExec << " -T all" << std::endl
<< " " << ctestExec << " -T start" << std::endl << " " << ctestExec << " -T start" << std::endl
<< " " << ctestExec << " -T update" << std::endl << " " << ctestExec << " -T update" << std::endl
@ -1347,7 +1310,7 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
<< " " << ctestExec << " -T coverage" << std::endl << " " << ctestExec << " -T coverage" << std::endl
<< " " << ctestExec << " -T memcheck" << std::endl << " " << ctestExec << " -T memcheck" << std::endl
<< " " << ctestExec << " -T notes" << std::endl << " " << ctestExec << " -T notes" << std::endl
<< " " << ctestExec << " -T submit" << std::endl; << " " << ctestExec << " -T submit" << std::endl);
} }
} }
@ -1371,11 +1334,11 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
else else
{ {
performSomeTest = false; performSomeTest = false;
std::cerr << "CTest -M called with incorrect option: " << str.c_str() << std::endl; cmCTestLog(this, ERROR, "CTest -M called with incorrect option: " << str.c_str() << std::endl);
std::cerr << "Available options are:" << std::endl cmCTestLog(this, ERROR, "Available options are:" << std::endl
<< " " << ctestExec << " -M Continuous" << std::endl << " " << ctestExec << " -M Continuous" << std::endl
<< " " << ctestExec << " -M Experimental" << std::endl << " " << ctestExec << " -M Experimental" << std::endl
<< " " << ctestExec << " -M Nightly" << std::endl; << " " << ctestExec << " -M Nightly" << std::endl);
} }
} }
@ -1425,7 +1388,7 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
} }
else else
{ {
std::cerr << "--build-and-test must have source and binary dir\n"; cmCTestLog(this, ERROR, "--build-and-test must have source and binary dir" << std::endl);
} }
} }
if(arg.find("--build-target",0) == 0 && i < args.size() - 1) if(arg.find("--build-target",0) == 0 && i < args.size() - 1)
@ -1530,6 +1493,7 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
else else
{ {
m_ExtraVerbose = m_Verbose; m_ExtraVerbose = m_Verbose;
m_Verbose = true;
cmCTest::t_TestingHandlers::iterator it; cmCTest::t_TestingHandlers::iterator it;
for ( it = m_TestingHandlers.begin(); it != m_TestingHandlers.end(); ++ it ) for ( it = m_TestingHandlers.begin(); it != m_TestingHandlers.end(); ++ it )
{ {
@ -1666,7 +1630,7 @@ int cmCTest::RunCMake(std::string* outstring, cmOStringStream &out,
} }
else else
{ {
std::cerr << out.str() << "\n"; cmCTestLog(this, ERROR, out.str() << std::endl);
} }
return 1; return 1;
} }
@ -1685,7 +1649,7 @@ int cmCTest::RunCMake(std::string* outstring, cmOStringStream &out,
} }
else else
{ {
std::cerr << out.str() << "\n"; cmCTestLog(this, ERROR, out.str() << std::endl);
} }
return 1; return 1;
} }
@ -1874,7 +1838,7 @@ int cmCTest::RunCMakeAndTest(std::string* outstring)
} }
else else
{ {
std::cerr << out.str(); cmCTestLog(this, ERROR, out.str());
} }
// return to the original directory // return to the original directory
cmSystemTools::ChangeDirectory(cwd.c_str()); cmSystemTools::ChangeDirectory(cwd.c_str());
@ -1917,7 +1881,7 @@ int cmCTest::RunCMakeAndTest(std::string* outstring)
} }
else else
{ {
std::cout << out.str() << "\n"; cmCTestLog(this, OUTPUT, out.str() << std::endl);
} }
return retval; return retval;
} }
@ -1952,7 +1916,7 @@ int cmCTest::ReadCustomConfigurationFileTree(const char* dir)
(!lg->GetMakefile()->ReadListFile(0, fname.c_str()) || (!lg->GetMakefile()->ReadListFile(0, fname.c_str()) ||
cmSystemTools::GetErrorOccuredFlag() ) ) cmSystemTools::GetErrorOccuredFlag() ) )
{ {
std::cerr << "Problem reading custom configuration" << std::endl; cmCTestLog(this, ERROR, "Problem reading custom configuration" << std::endl);
} }
dirs.erase(dirs.end()-1, dirs.end()); dirs.erase(dirs.end()-1, dirs.end());
cmSystemTools::SimpleGlob(rexpr, ndirs, -1); cmSystemTools::SimpleGlob(rexpr, ndirs, -1);
@ -2117,3 +2081,109 @@ bool cmCTest::SetCTestConfigurationFromCMakeVariable(cmMakefile* mf, const char*
this->SetCTestConfiguration(dconfig, ctvar); this->SetCTestConfiguration(dconfig, ctvar);
return true; return true;
} }
void cmCTest::SetOutputLogFileName(const char* name)
{
if ( m_OutputLogFile)
{
delete m_OutputLogFile;
m_OutputLogFile= 0;
}
if ( name )
{
m_OutputLogFile = new cmGeneratedFileStream(name);
}
}
static const char* cmCTestStringLogType[] =
{
"DEBUG",
"OUTPUT",
"HANDLER_OUTPUT",
"HANDLER_VERBOSE_OUTPUT",
"WARNING",
"ERROR",
0
};
#ifdef cerr
# undef cerr
#endif
#ifdef cout
# undef cout
#endif
void cmCTest::Log(int logType, const char* msg)
{
if ( !msg || !*msg )
{
return;
}
if ( m_OutputLogFile )
{
bool display = true;
if ( logType == cmCTest::DEBUG && !m_Debug ) { display = false; }
if ( logType == cmCTest::HANDLER_VERBOSE_OUTPUT && !m_Debug && !m_ExtraVerbose ) { display = false; }
if ( display )
{
if ( logType != m_OutputLogFileLastTag )
{
*m_OutputLogFile << "[";
if ( logType >= OTHER || logType < 0 )
{
*m_OutputLogFile << "OTHER";
}
else
{
*m_OutputLogFile << cmCTestStringLogType[logType];
}
*m_OutputLogFile << "] " << std::endl << std::flush;
}
*m_OutputLogFile << msg << std::flush;
if ( logType != m_OutputLogFileLastTag )
{
*m_OutputLogFile << std::endl << std::flush;
m_OutputLogFileLastTag = logType;
}
}
}
if ( !m_Quiet )
{
switch ( logType )
{
case DEBUG:
if ( m_Debug )
{
std::cout << msg;
std::cout.flush();
}
break;
case OUTPUT: case HANDLER_OUTPUT:
if ( m_Debug || m_Verbose )
{
std::cout << msg;
std::cout.flush();
}
break;
case HANDLER_VERBOSE_OUTPUT:
if ( m_Debug || m_ExtraVerbose )
{
std::cout << msg;
std::cout.flush();
}
break;
case WARNING:
std::cerr << msg;
std::cerr.flush();
break;
case ERROR:
std::cerr << msg;
std::cerr.flush();
break;
default:
std::cout << msg;
std::cout.flush();
}
}
}

64
Source/cmCTest.h
View File

@ -18,7 +18,6 @@
#ifndef cmCTest_h #ifndef cmCTest_h
#define cmCTest_h #define cmCTest_h
#include "cmStandardIncludes.h" #include "cmStandardIncludes.h"
#include "cmListFileCache.h" #include "cmListFileCache.h"
#include <time.h> #include <time.h>
@ -28,6 +27,23 @@ class cmMakefile;
class cmCTestGenericHandler; class cmCTestGenericHandler;
class cmGeneratedFileStream; class cmGeneratedFileStream;
#define cmCTestLog(ctSelf, logType, msg) \
do { \
cmOStringStream cmCTestLog_msg; \
cmCTestLog_msg << msg; \
(ctSelf)->Log(cmCTest::logType, cmCTestLog_msg.str().c_str());\
} while ( 0 )
#ifdef cerr
# undef cerr
#endif
#define cerr no_cerr_use_cmCTestLog
#ifdef cout
# undef cout
#endif
#define cout no_cout_use_cmCTestLog
class cmCTest class cmCTest
{ {
public: public:
@ -57,8 +73,7 @@ public:
/* /*
* A utility function that returns the nightly time * A utility function that returns the nightly time
*/ */
static struct tm* GetNightlyTime(std::string str, struct tm* GetNightlyTime(std::string str,
bool verbose,
bool tomorrowtag); bool tomorrowtag);
/* /*
@ -134,7 +149,7 @@ public:
//! Run command specialized for make and configure. Returns process status //! Run command specialized for make and configure. Returns process status
// and retVal is return value or exception. // and retVal is return value or exception.
int RunMakeCommand(const char* command, std::string* output, int RunMakeCommand(const char* command, std::string* output,
int* retVal, const char* dir, bool verbose, int timeout, int* retVal, const char* dir, int timeout,
std::ofstream& ofs); std::ofstream& ofs);
/* /*
@ -206,6 +221,24 @@ public:
//! Create XML file that contains all the notes specified //! Create XML file that contains all the notes specified
int GenerateNotesFile(const std::vector<cmStdString> &files); int GenerateNotesFile(const std::vector<cmStdString> &files);
//! Set the output log file name
void SetOutputLogFileName(const char* name);
//! Various log types
enum {
DEBUG = 0,
OUTPUT,
HANDLER_OUTPUT,
HANDLER_VERBOSE_OUTPUT,
WARNING,
ERROR,
OTHER
};
//! Add log to the output
void Log(int logType, const char* msg);
private: private:
std::string m_ConfigType; std::string m_ConfigType;
bool m_Verbose; bool m_Verbose;
@ -302,6 +335,29 @@ private:
void FindRunningCMake(const char* arg0); void FindRunningCMake(const char* arg0);
bool m_SuppressUpdatingCTestConfiguration; bool m_SuppressUpdatingCTestConfiguration;
bool m_Debug;
bool m_Quiet;
cmGeneratedFileStream* m_OutputLogFile;
int m_OutputLogFileLastTag;
}; };
class cmCTestLogWrite
{
public:
cmCTestLogWrite(const char* data, size_t length) : Data(data), Length(length) {}
const char* Data;
size_t Length;
};
inline std::ostream& operator<< (std::ostream& os, const cmCTestLogWrite& c)
{
os.write(c.Data, c.Length);
os.flush();
return os;
}
#endif #endif

22
Source/ctest.cxx
View File

@ -59,6 +59,12 @@ static const cmDocumentationEntry cmDocumentationOptions[] =
{"-V,--verbose", "Enable verbose output from tests.", {"-V,--verbose", "Enable verbose output from tests.",
"Test output is normally suppressed and only summary information is " "Test output is normally suppressed and only summary information is "
"displayed. This option will show all test output."}, "displayed. This option will show all test output."},
{"-Q,--quiet", "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."},
{"-O <file>, --output-log <file>", "Output to log file",
"This option tells ctest to write all its output to a log file."},
{"-N,--show-only", "Disable actual execution of tests.", {"-N,--show-only", "Disable actual execution of tests.",
"This option tells ctest to list the tests that would be run but not " "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 options."}, "actually run them. Useful in conjunction with the -R and -E options."},
@ -158,10 +164,11 @@ int main (int argc, char *argv[])
{ {
cmSystemTools::EnableMSVCDebugHook(); cmSystemTools::EnableMSVCDebugHook();
int nocwd = 0; int nocwd = 0;
cmCTest inst;
if ( cmSystemTools::GetCurrentWorkingDirectory().size() == 0 ) if ( cmSystemTools::GetCurrentWorkingDirectory().size() == 0 )
{ {
std::cerr << "Current working directory cannot be established." << std::endl; cmCTestLog(&inst, ERROR, "Current working directory cannot be established." << std::endl);
nocwd = 1; nocwd = 1;
} }
@ -175,9 +182,9 @@ int main (int argc, char *argv[])
{ {
if(argc == 1) if(argc == 1)
{ {
std::cout << "*********************************" << std::endl; cmCTestLog(&inst, ERROR, "*********************************" << std::endl
std::cout << "No test configuration file found!" << std::endl; << "No test configuration file found!" << std::endl
std::cout << "*********************************" << std::endl; << "*********************************" << std::endl);
} }
cmDocumentation doc; cmDocumentation doc;
if(doc.CheckOptions(argc, argv) || nocwd) if(doc.CheckOptions(argc, argv) || nocwd)
@ -189,7 +196,11 @@ int main (int argc, char *argv[])
doc.SetDescriptionSection(cmDocumentationDescription); doc.SetDescriptionSection(cmDocumentationDescription);
doc.SetOptionsSection(cmDocumentationOptions); doc.SetOptionsSection(cmDocumentationOptions);
doc.SetSeeAlsoList(cmDocumentationSeeAlso); doc.SetSeeAlsoList(cmDocumentationSeeAlso);
#ifdef cout
# undef cout
#endif
return doc.PrintRequestedDocumentation(std::cout)? 0:1; return doc.PrintRequestedDocumentation(std::cout)? 0:1;
#define cout no_cout_use_cmCTestLog
} }
} }
@ -198,7 +209,6 @@ int main (int argc, char *argv[])
std::string comspec = "cmw9xcom.exe"; std::string comspec = "cmw9xcom.exe";
cmSystemTools::SetWindows9xComspecSubstitute(comspec.c_str()); cmSystemTools::SetWindows9xComspecSubstitute(comspec.c_str());
#endif #endif
cmCTest inst;
// copy the args to a vector // copy the args to a vector
std::vector<std::string> args; std::vector<std::string> args;
for(int i =0; i < argc; ++i) for(int i =0; i < argc; ++i)
@ -208,7 +218,7 @@ int main (int argc, char *argv[])
// run ctest // run ctest
std::string output; std::string output;
int res = inst.Run(args,&output); int res = inst.Run(args,&output);
std::cout << output; cmCTestLog(&inst, OUTPUT, output);
cmListFileCache::ClearCache(); cmListFileCache::ClearCache();
return res; return res;