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

ENH: Add support for CTestCustom.ctest, which modifies some behavior of ctest

This commit is contained in:
Andy Cedilnik 2004-01-26 13:57:26 -05:00
parent 222e9a2876
commit 2db971afb4
2 changed files with 368 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

411
Source/cmCTest.cxx
View File

@ -21,6 +21,7 @@
#include "cmGlobalGenerator.h"
#include <cmsys/Directory.hxx>
#include "cmListFileCache.h"
#include "cmGlob.h"
#include "cmCTestSubmit.h"
#include "curl/curl.h"
@ -324,10 +325,14 @@ cmCTest::cmCTest()
}
}
void cmCTest::Initialize()
int cmCTest::Initialize()
{
m_ToplevelPath = cmSystemTools::GetCurrentWorkingDirectory();
cmSystemTools::ConvertToUnixSlashes(m_ToplevelPath);
if ( !this->ReadCustomConfigurationFileTree(m_ToplevelPath.c_str()) )
{
return 0;
}
this->UpdateCTestConfiguration();
if ( m_DartMode )
{
@ -338,7 +343,7 @@ void cmCTest::Initialize()
{
std::cerr << "File " << testingDir << " is in the place of the testing directory"
<< std::endl;
return;
return 0;
}
}
else
@ -347,7 +352,7 @@ void cmCTest::Initialize()
{
std::cerr << "Cannot create directory " << testingDir
<< std::endl;
return;
return 0;
}
}
std::string tagfile = testingDir + "/TAG";
@ -408,6 +413,7 @@ void cmCTest::Initialize()
}
m_CurrentTag = tag;
}
return 1;
}
void cmCTest::UpdateCTestConfiguration()
@ -1042,7 +1048,7 @@ int cmCTest::BuildDirectory()
ofs.close();
}
int cc;
tm_VectorOfStrings::size_type cc;
if ( m_DartConfiguration["SourceDirectory"].size() > 20 ||
m_DartConfiguration["BuildDirectory"].size() > 20 )
{
@ -1090,7 +1096,24 @@ int cmCTest::BuildDirectory()
// Errors
for ( cc = 0; cmCTestErrorMatches[cc]; cc ++ )
{
cmsys::RegularExpression re(cmCTestErrorMatches[cc]);
m_CustomErrorMatches.push_back(cmCTestErrorMatches[cc]);
}
for ( cc = 0; cmCTestErrorExceptions[cc]; cc ++ )
{
m_CustomErrorExceptions.push_back(cmCTestErrorExceptions[cc]);
}
for ( cc = 0; cmCTestWarningMatches[cc]; cc ++ )
{
m_CustomWarningMatches.push_back(cmCTestWarningMatches[cc]);
}
for ( cc = 0; cmCTestWarningExceptions[cc]; cc ++ )
{
m_CustomWarningExceptions.push_back(cmCTestWarningExceptions[cc]);
}
for ( cc = 0; cc < m_CustomErrorMatches.size(); cc ++ )
{
cmsys::RegularExpression re(m_CustomErrorMatches[cc].c_str());
cmCTest::tm_VectorOfStrings::size_type kk;
for ( kk = 0; kk < lines.size(); kk ++ )
{
@ -1101,9 +1124,9 @@ int cmCTest::BuildDirectory()
}
}
// Warnings
for ( cc = 0; cmCTestWarningMatches[cc]; cc ++ )
for ( cc = 0; cc < m_CustomWarningMatches.size(); cc ++ )
{
cmsys::RegularExpression re(cmCTestWarningMatches[cc]);
cmsys::RegularExpression re(m_CustomWarningMatches[cc].c_str());
cmCTest::tm_VectorOfStrings::size_type kk;
for ( kk = 0; kk < lines.size(); kk ++ )
{
@ -1114,9 +1137,9 @@ int cmCTest::BuildDirectory()
}
}
// Errors exceptions
for ( cc = 0; cmCTestErrorExceptions[cc]; cc ++ )
for ( cc = 0; cc < m_CustomErrorExceptions.size(); cc ++ )
{
cmsys::RegularExpression re(cmCTestErrorExceptions[cc]);
cmsys::RegularExpression re(m_CustomErrorExceptions[cc].c_str());
std::vector<int>::size_type kk;
for ( kk =0; kk < markedLines.size(); kk ++ )
{
@ -1130,9 +1153,9 @@ int cmCTest::BuildDirectory()
}
}
// Warning exceptions
for ( cc = 0; cmCTestWarningExceptions[cc]; cc ++ )
for ( cc = 0; cc < m_CustomWarningExceptions.size(); cc ++ )
{
cmsys::RegularExpression re(cmCTestWarningExceptions[cc]);
cmsys::RegularExpression re(m_CustomWarningExceptions[cc].c_str());
std::vector<int>::size_type kk;
for ( kk =0; kk < markedLines.size(); kk ++ )
{
@ -1818,13 +1841,59 @@ void cmCTest::ProcessDirectory(cmCTest::tm_VectorOfStrings &passed,
{
continue;
}
if ( memcheck )
{
tm_VectorOfStrings::iterator it;
bool found = false;
for ( it = m_CustomMemCheckIgnore.begin();
it != m_CustomMemCheckIgnore.end(); ++ it )
{
if ( *it == args[0].Value )
{
found = true;
break;
}
}
if ( found )
{
if ( m_Verbose )
{
std::cout << "Ignore memcheck: " << *it << std::endl;
}
continue;
}
}
else
{
tm_VectorOfStrings::iterator it;
bool found = false;
for ( it = m_CustomTestsIgnore.begin();
it != m_CustomTestsIgnore.end(); ++ it )
{
if ( *it == args[0].Value )
{
found = true;
break;
}
}
if ( found )
{
if ( m_Verbose )
{
std::cout << "Ignore test: " << *it << std::endl;
}
continue;
}
}
if (this->m_UseIncludeRegExp && !ireg.find(args[0].Value.c_str()))
{
continue;
}
if (this->m_UseExcludeRegExp &&
!this->m_UseExcludeRegExpFirst &&
ereg.find(args[0].Value.c_str()))
!this->m_UseExcludeRegExpFirst &&
ereg.find(args[0].Value.c_str()))
{
continue;
}
@ -1941,25 +2010,25 @@ void cmCTest::ProcessDirectory(cmCTest::tm_VectorOfStrings &passed,
fprintf(stderr,"***Exception: ");
switch ( retVal )
{
case cmsysProcess_Exception_Fault:
fprintf(stderr,"SegFault");
cres.m_Status = cmCTest::SEGFAULT;
break;
case cmsysProcess_Exception_Illegal:
fprintf(stderr,"Illegal");
cres.m_Status = cmCTest::ILLEGAL;
break;
case cmsysProcess_Exception_Interrupt:
fprintf(stderr,"Interrupt");
cres.m_Status = cmCTest::INTERRUPT;
break;
case cmsysProcess_Exception_Numerical:
fprintf(stderr,"Numerical");
cres.m_Status = cmCTest::NUMERICAL;
break;
default:
fprintf(stderr,"Other");
cres.m_Status = cmCTest::OTHER_FAULT;
case cmsysProcess_Exception_Fault:
fprintf(stderr,"SegFault");
cres.m_Status = cmCTest::SEGFAULT;
break;
case cmsysProcess_Exception_Illegal:
fprintf(stderr,"Illegal");
cres.m_Status = cmCTest::ILLEGAL;
break;
case cmsysProcess_Exception_Interrupt:
fprintf(stderr,"Interrupt");
cres.m_Status = cmCTest::INTERRUPT;
break;
case cmsysProcess_Exception_Numerical:
fprintf(stderr,"Numerical");
cres.m_Status = cmCTest::NUMERICAL;
break;
default:
fprintf(stderr,"Other");
cres.m_Status = cmCTest::OTHER_FAULT;
}
fprintf(stderr,"\n");
}
@ -2101,6 +2170,23 @@ int cmCTest::TestDirectory(bool memcheck)
}
}
if ( memcheck )
{
if ( !this->ExecuteCommands(m_CustomPreMemCheck) )
{
std::cerr << "Problem executing pre-memcheck command(s)." << std::endl;
return 1;
}
}
else
{
if ( !this->ExecuteCommands(m_CustomPreTest) )
{
std::cerr << "Problem executing pre-test command(s)." << std::endl;
return 1;
}
}
cmCTest::tm_VectorOfStrings passed;
cmCTest::tm_VectorOfStrings failed;
int total;
@ -2125,7 +2211,7 @@ int cmCTest::TestDirectory(bool memcheck)
{
std::cerr << "\nThe following tests passed:\n";
for(cmCTest::tm_VectorOfStrings::iterator j = passed.begin();
j != passed.end(); ++j)
j != passed.end(); ++j)
{
std::cerr << "\t" << *j << "\n";
}
@ -2137,13 +2223,13 @@ int cmCTest::TestDirectory(bool memcheck)
percent = 99;
}
fprintf(stderr,"\n%.0f%% tests passed, %i tests failed out of %i\n",
percent, int(failed.size()), total);
percent, int(failed.size()), total);
if (failed.size())
{
std::cerr << "\nThe following tests FAILED:\n";
for(cmCTest::tm_VectorOfStrings::iterator j = failed.begin();
j != failed.end(); ++j)
j != failed.end(); ++j)
{
std::cerr << "\t" << *j << "\n";
}
@ -2170,6 +2256,23 @@ int cmCTest::TestDirectory(bool memcheck)
}
}
if ( memcheck )
{
if ( !this->ExecuteCommands(m_CustomPostMemCheck) )
{
std::cerr << "Problem executing post-memcheck command(s)." << std::endl;
return 1;
}
}
else
{
if ( !this->ExecuteCommands(m_CustomPostTest) )
{
std::cerr << "Problem executing post-test command(s)." << std::endl;
return 1;
}
}
return int(failed.size());
}
@ -2233,7 +2336,7 @@ int cmCTest::SubmitResults()
cmCTestSubmit submit;
submit.SetVerbose(m_Verbose);
if ( m_DartConfiguration["DropMethod"] == "" ||
m_DartConfiguration["DropMethod"] == "ftp" )
m_DartConfiguration["DropMethod"] == "ftp" )
{
std::cout << " Using FTP submit method" << std::endl;
std::string url = "ftp://";
@ -2323,14 +2426,14 @@ void cmCTest::GenerateDartMemCheckOutput(std::ostream& os)
os << "<MemCheck>" << std::endl;
}
os << "\t<StartDateTime>" << m_StartTest << "</StartDateTime>\n"
<< "\t<TestList>\n";
<< "\t<TestList>\n";
tm_TestResultsVector::size_type cc;
for ( cc = 0; cc < m_TestResults.size(); cc ++ )
{
cmCTestTestResult *result = &m_TestResults[cc];
os << "\t\t<Test>" << this->MakeXMLSafe(result->m_Path)
<< "/" << this->MakeXMLSafe(result->m_Name)
<< "</Test>" << std::endl;
<< "/" << this->MakeXMLSafe(result->m_Name)
<< "</Test>" << std::endl;
}
os << "\t</TestList>\n";
for ( cc = 0; cc < m_TestResults.size(); cc ++ )
@ -2405,15 +2508,15 @@ void cmCTest::GenerateDartTestOutput(std::ostream& os)
this->StartXML(os);
os << "<Testing>\n"
<< "\t<StartDateTime>" << m_StartTest << "</StartDateTime>\n"
<< "\t<TestList>\n";
<< "\t<StartDateTime>" << m_StartTest << "</StartDateTime>\n"
<< "\t<TestList>\n";
tm_TestResultsVector::size_type cc;
for ( cc = 0; cc < m_TestResults.size(); cc ++ )
{
cmCTestTestResult *result = &m_TestResults[cc];
os << "\t\t<Test>" << this->MakeXMLSafe(result->m_Path)
<< "/" << this->MakeXMLSafe(result->m_Name)
<< "</Test>" << std::endl;
<< "/" << this->MakeXMLSafe(result->m_Name)
<< "</Test>" << std::endl;
}
os << "\t</TestList>\n";
for ( cc = 0; cc < m_TestResults.size(); cc ++ )
@ -2469,7 +2572,7 @@ void cmCTest::GenerateDartTestOutput(std::ostream& os)
}
os << "\t<EndDateTime>" << m_EndTest << "</EndDateTime>\n"
<< "</Testing>" << std::endl;
<< "</Testing>" << std::endl;
this->EndXML(os);
}
@ -2556,10 +2659,10 @@ std::string cmCTest::GetTestModelString()
{
switch ( m_TestModel )
{
case cmCTest::NIGHTLY:
return "Nightly";
case cmCTest::CONTINUOUS:
return "Continuous";
case cmCTest::NIGHTLY:
return "Nightly";
case cmCTest::CONTINUOUS:
return "Continuous";
}
return "Experimental";
}
@ -2661,7 +2764,7 @@ std::string cmCTest::GenerateRegressionImages(const std::string& xml)
#ifdef _WIN32
| std::ios::binary
#endif
);
);
unsigned char *file_buffer = new unsigned char [ len + 1 ];
ifs.read(reinterpret_cast<char*>(file_buffer), len);
unsigned char *encoded_buffer = new unsigned char [ static_cast<int>(len * 1.5 + 1) ];
@ -2715,7 +2818,7 @@ std::string cmCTest::GenerateRegressionImages(const std::string& xml)
}
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, bool verbose, int timeout, std::ofstream& ofs)
{
std::vector<cmStdString> args = cmSystemTools::ParseArguments(command);
@ -2726,7 +2829,7 @@ int cmCTest::RunMakeCommand(const char* command, std::string* output,
std::vector<const char*> argv;
for(std::vector<cmStdString>::const_iterator a = args.begin();
a != args.end(); ++a)
a != args.end(); ++a)
{
argv.push_back(a->c_str());
}
@ -2854,7 +2957,7 @@ int cmCTest::RunTest(std::vector<const char*> argv, std::string* output, int *re
cmsysProcess* cp = cmsysProcess_New();
cmsysProcess_SetCommand(cp, &*argv.begin());
// std::cout << "Command is: " << argv[0] << std::endl;
// std::cout << "Command is: " << argv[0] << std::endl;
if(cmSystemTools::GetRunCommandHideConsole())
{
cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
@ -2932,27 +3035,27 @@ const char* cmCTest::GetTestStatus(int status)
}
void cmCTest::RestoreBackupDirectories(bool backup,
const char *srcDir,
const char *binDir,
const char *backupSrcDir,
const char *backupBinDir)
const char *srcDir,
const char *binDir,
const char *backupSrcDir,
const char *backupBinDir)
{
// if we backed up the dirs and the build failed, then restore
// the backed up dirs
if (backup)
{
// if for some reason those directories exist then first delete them
if (cmSystemTools::FileExists(srcDir))
{
cmSystemTools::RemoveADirectory(srcDir);
}
if (cmSystemTools::FileExists(binDir))
{
cmSystemTools::RemoveADirectory(binDir);
}
// rename the src and binary directories
rename(backupSrcDir, srcDir);
rename(backupBinDir, binDir);
// if for some reason those directories exist then first delete them
if (cmSystemTools::FileExists(srcDir))
{
cmSystemTools::RemoveADirectory(srcDir);
}
if (cmSystemTools::FileExists(binDir))
{
cmSystemTools::RemoveADirectory(binDir);
}
// rename the src and binary directories
rename(backupSrcDir, srcDir);
rename(backupBinDir, binDir);
}
}
@ -2978,11 +3081,11 @@ int cmCTest::RunConfigurationScript()
// set a variable with the path to the current script
lg->GetMakefile()->AddDefinition("CTEST_SCRIPT_DIRECTORY",
cmSystemTools::GetFilenamePath(
m_ConfigurationScript).c_str());
cmSystemTools::GetFilenamePath(
m_ConfigurationScript).c_str());
lg->GetMakefile()->AddDefinition("CTEST_SCRIPT_NAME",
cmSystemTools::GetFilenameName(
m_ConfigurationScript).c_str());
cmSystemTools::GetFilenameName(
m_ConfigurationScript).c_str());
if (!lg->GetMakefile()->ReadListFile(0, m_ConfigurationScript.c_str()))
{
return 2;
@ -3062,22 +3165,22 @@ int cmCTest::RunConfigurationScript()
{
cmSystemTools::Error("Unable to create the src directory");
this->RestoreBackupDirectories(backup, srcDir, binDir,
backupSrcDir.c_str(),
backupBinDir.c_str());
backupSrcDir.c_str(),
backupBinDir.c_str());
return 5;
}
// then do the checkout
output = "";
res = cmSystemTools::RunSingleCommand(cvsCheckOut, &output,
&retVal, ctestRoot,
m_Verbose, 0 /*m_TimeOut*/);
&retVal, ctestRoot,
m_Verbose, 0 /*m_TimeOut*/);
if (!res || retVal != 0)
{
cmSystemTools::Error("Unable to perform cvs checkout ");
this->RestoreBackupDirectories(backup, srcDir, binDir,
backupSrcDir.c_str(),
backupBinDir.c_str());
backupSrcDir.c_str(),
backupBinDir.c_str());
return 6;
}
}
@ -3101,8 +3204,8 @@ int cmCTest::RunConfigurationScript()
{
cmSystemTools::Error("Unable to create the binary directory");
this->RestoreBackupDirectories(backup, srcDir, binDir,
backupSrcDir.c_str(),
backupBinDir.c_str());
backupSrcDir.c_str(),
backupBinDir.c_str());
return 7;
}
}
@ -3130,14 +3233,14 @@ int cmCTest::RunConfigurationScript()
output = "";
retVal = 0;
res = cmSystemTools::RunSingleCommand(fullCommand.c_str(), &output,
&retVal, cvsArgs[0].c_str(),
m_Verbose, 0 /*m_TimeOut*/);
&retVal, cvsArgs[0].c_str(),
m_Verbose, 0 /*m_TimeOut*/);
if (!res || retVal != 0)
{
cmSystemTools::Error("Unable to perform extra cvs updates");
this->RestoreBackupDirectories(backup, srcDir, binDir,
backupSrcDir.c_str(),
backupBinDir.c_str());
backupSrcDir.c_str(),
backupBinDir.c_str());
return 8;
}
}
@ -3155,8 +3258,8 @@ int cmCTest::RunConfigurationScript()
if(!fout)
{
this->RestoreBackupDirectories(backup, srcDir, binDir,
backupSrcDir.c_str(),
backupBinDir.c_str());
backupSrcDir.c_str(),
backupBinDir.c_str());
return 9;
}
@ -3181,8 +3284,8 @@ int cmCTest::RunConfigurationScript()
command += "\"";
retVal = 0;
res = cmSystemTools::RunSingleCommand(command.c_str(), &output,
&retVal, binDir,
m_Verbose, 0 /*m_TimeOut*/);
&retVal, binDir,
m_Verbose, 0 /*m_TimeOut*/);
if (!res || retVal != 0)
{
// even if this fails continue to the next step
@ -3195,16 +3298,16 @@ int cmCTest::RunConfigurationScript()
output = "";
retVal = 0;
res = cmSystemTools::RunSingleCommand(command.c_str(), &output,
&retVal, binDir,
m_Verbose, 0 /*m_TimeOut*/);
&retVal, binDir,
m_Verbose, 0 /*m_TimeOut*/);
// did something critical fail in ctest
if (!res || cmakeFailed ||
retVal & CTEST_BUILD_ERRORS)
retVal & CTEST_BUILD_ERRORS)
{
this->RestoreBackupDirectories(backup, srcDir, binDir,
backupSrcDir.c_str(),
backupBinDir.c_str());
backupSrcDir.c_str(),
backupBinDir.c_str());
if (cmakeFailed)
{
cmSystemTools::Error("Unable to run cmake");
@ -3340,7 +3443,7 @@ bool cmCTest::ProcessMemCheckValgrindOutput(const std::string& str, std::string&
if ( valgrindLine.find(lines[cc]) )
{
int failure = cmCTest::NO_MEMORY_FAULT;
if ( vgFIM.find(lines[cc]) ) { failure = cmCTest::FIM; }
if ( vgFIM.find(lines[cc]) ) { failure = cmCTest::FIM; }
else if ( vgFMM.find(lines[cc]) ) { failure = cmCTest::FMM; }
else if ( vgMLK.find(lines[cc]) ) { failure = cmCTest::MLK; }
else if ( vgPAR.find(lines[cc]) ) { failure = cmCTest::PAR; }
@ -3685,7 +3788,7 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
}
if( ( arg.find("-T",0) == 0 ) &&
(i < args.size() -1) )
(i < args.size() -1) )
{
this->m_DartMode = true;
i++;
@ -3693,7 +3796,7 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
}
if( ( arg.find("-M",0) == 0 || arg.find("--test-model",0) == 0 ) &&
(i < args.size() -1) )
(i < args.size() -1) )
{
i++;
std::string const& str = args[i];
@ -3702,7 +3805,7 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
this->SetTestModel(cmCTest::NIGHTLY);
}
else if ( str == "CONTINUOUS" || str == "continuous" ||
str == "Continuous" )
str == "Continuous" )
{
this->SetTestModel(cmCTest::CONTINUOUS);
std::cout << "Continuous" << std::endl;
@ -3806,7 +3909,7 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
{
m_BuildOptions.push_back(args[i]);
if(i+1 < args.size()
&& (args[i+1] == "--build-target" || args[i+1] == "--test-command"))
&& (args[i+1] == "--build-target" || args[i+1] == "--test-command"))
{
done = true;
}
@ -3846,8 +3949,14 @@ int cmCTest::Run(std::vector<std::string>const& args, std::string* output)
}
else
{
this->Initialize();
res = this->ProcessTests();
if ( !this->Initialize() )
{
res = 12;
}
else
{
res = this->ProcessTests();
}
this->Finalize();
}
return res;
@ -3883,9 +3992,9 @@ void cmCTest::FindRunningCMake(const char* arg0)
std::string dir;
std::string file;
if(cmSystemTools::SplitProgramPath(m_CTestSelf.c_str(),
dir,
file,
true))
dir,
file,
true))
{
m_CMakeSelf = dir += "/cmake";
m_CMakeSelf += cmSystemTools::GetExecutableExtension();
@ -4071,7 +4180,7 @@ int cmCTest::RunCMakeAndTest(std::string* outstring)
retVal = 0;
std::string output;
if (!cmSystemTools::RunSingleCommand(cleanCommand.c_str(), &output, &retVal) ||
retVal)
retVal)
{
out << "Error: " << cleanCommand.c_str() << " execution failed\n";
out << output.c_str() << "\n";
@ -4153,7 +4262,7 @@ int cmCTest::RunCMakeAndTest(std::string* outstring)
return retVal;
}
// now run the compiled test if we can find it
// now run the compiled test if we can find it
// See if the executable exists as written.
std::vector<std::string> failed;
std::string fullPath;
@ -4168,7 +4277,7 @@ int cmCTest::RunCMakeAndTest(std::string* outstring)
std::string tryPath = m_TestCommand;
tryPath += cmSystemTools::GetExecutableExtension();
if(cmSystemTools::FileExists(tryPath.c_str())
&& !cmSystemTools::FileIsDirectory(tryPath.c_str()))
&& !cmSystemTools::FileIsDirectory(tryPath.c_str()))
{
fullPath = cmSystemTools::CollapseFullPath(tryPath.c_str());
}
@ -4179,7 +4288,7 @@ int cmCTest::RunCMakeAndTest(std::string* outstring)
tryPath = m_ConfigType + "/";
tryPath += cmSystemTools::GetFilenameName(m_TestCommand);
if(cmSystemTools::FileExists(tryPath.c_str())
&& !cmSystemTools::FileIsDirectory(tryPath.c_str()))
&& !cmSystemTools::FileIsDirectory(tryPath.c_str()))
{
fullPath = cmSystemTools::CollapseFullPath(tryPath.c_str());
}
@ -4188,7 +4297,7 @@ int cmCTest::RunCMakeAndTest(std::string* outstring)
failed.push_back(tryPath);
tryPath += cmSystemTools::GetExecutableExtension();
if(cmSystemTools::FileExists(tryPath.c_str())
&& !cmSystemTools::FileIsDirectory(tryPath.c_str()))
&& !cmSystemTools::FileIsDirectory(tryPath.c_str()))
{
fullPath = cmSystemTools::CollapseFullPath(tryPath.c_str());
}
@ -4200,7 +4309,7 @@ int cmCTest::RunCMakeAndTest(std::string* outstring)
tryPath += m_TestCommand;
tryPath += cmSystemTools::GetExecutableExtension();
if(cmSystemTools::FileExists(tryPath.c_str())
&& !cmSystemTools::FileIsDirectory(tryPath.c_str()))
&& !cmSystemTools::FileIsDirectory(tryPath.c_str()))
{
fullPath = cmSystemTools::CollapseFullPath(tryPath.c_str());
}
@ -4213,7 +4322,7 @@ int cmCTest::RunCMakeAndTest(std::string* outstring)
tryPath += m_TestCommand;
tryPath += cmSystemTools::GetExecutableExtension();
if(cmSystemTools::FileExists(tryPath.c_str())
&& !cmSystemTools::FileIsDirectory(tryPath.c_str()))
&& !cmSystemTools::FileIsDirectory(tryPath.c_str()))
{
fullPath = cmSystemTools::CollapseFullPath(tryPath.c_str());
}
@ -4296,3 +4405,85 @@ void cmCTest::SetNotesFiles(const char* notes)
}
m_NotesFiles = notes;
}
int cmCTest::ReadCustomConfigurationFileTree(const char* dir)
{
tm_VectorOfStrings dirs;
tm_VectorOfStrings ndirs;
dirs.push_back(dir);
cmake cm;
cmGlobalGenerator gg;
gg.SetCMakeInstance(&cm);
cmLocalGenerator *lg = gg.CreateLocalGenerator();
lg->SetGlobalGenerator(&gg);
cmMakefile *mf = lg->GetMakefile();
while ( dirs.size() > 0 )
{
tm_VectorOfStrings::iterator cdir = dirs.end()-1;
std::string rexpr = *cdir + "/*";
std::string fname = *cdir + "/CTestCustom.ctest";
if ( cmSystemTools::FileExists(fname.c_str()) &&
(!lg->GetMakefile()->ReadListFile(0, fname.c_str()) ||
cmSystemTools::GetErrorOccuredFlag() ) )
{
std::cerr << "Problem reading custom configuration" << std::endl;
return 0;
}
dirs.erase(dirs.end()-1, dirs.end());
cmSystemTools::SimpleGlob(rexpr, ndirs, -1);
dirs.insert(dirs.end(), ndirs.begin(), ndirs.end());
}
this->PopulateCustomVector(mf, "CTEST_CUSTOM_ERROR_MATCH", m_CustomErrorMatches);
this->PopulateCustomVector(mf, "CTEST_CUSTOM_ERROR_EXCEPTION", m_CustomErrorExceptions);
this->PopulateCustomVector(mf, "CTEST_CUSTOM_WARNING_MATCH", m_CustomWarningMatches);
this->PopulateCustomVector(mf, "CTEST_CUSTOM_WARNING_EXCEPTION", m_CustomWarningExceptions);
this->PopulateCustomVector(mf, "CTEST_CUSTOM_TESTS_IGNORE", m_CustomTestsIgnore);
this->PopulateCustomVector(mf, "CTEST_CUSTOM_MEMCHECK_IGNORE", m_CustomMemCheckIgnore);
this->PopulateCustomVector(mf, "CTEST_CUSTOM_PRE_TEST", m_CustomPreTest);
this->PopulateCustomVector(mf, "CTEST_CUSTOM_POST_TEST", m_CustomPostTest);
this->PopulateCustomVector(mf, "CTEST_CUSTOM_PRE_MEMCHECK", m_CustomPreMemCheck);
this->PopulateCustomVector(mf, "CTEST_CUSTOM_POST_MEMCHECK", m_CustomPostMemCheck);
return 1;
}
void cmCTest::PopulateCustomVector(cmMakefile* mf, const char* def, tm_VectorOfStrings& vec)
{
if ( !def)
{
return;
}
const char* dval = mf->GetDefinition(def);
if ( !dval )
{
return;
}
std::vector<std::string> slist;
cmSystemTools::ExpandListArgument(dval, slist);
vec.insert(vec.end(), slist.begin(), slist.end());
}
int cmCTest::ExecuteCommands(tm_VectorOfStrings& vec)
{
tm_VectorOfStrings::iterator it;
for ( it = vec.begin(); it != vec.end(); ++it )
{
int retVal = 0;
if ( m_Verbose )
{
std::cout << "Run command: " << *it << std::endl;
}
if ( !cmSystemTools::RunSingleCommand(it->c_str(), 0, &retVal, 0, true /*m_Verbose*/) ||
retVal != 0 )
{
std::cerr << "Problem running command: " << *it << std::endl;
return 0;
}
}
return 1;
}

22
Source/cmCTest.h
View File

@ -21,6 +21,8 @@
#include "cmStandardIncludes.h"
class cmMakefile;
class cmCTest
{
public:
@ -37,7 +39,7 @@ public:
/**
* Initialize and finalize testing
*/
void Initialize();
int Initialize();
void Finalize();
/**
@ -315,6 +317,24 @@ private:
bool m_BuildNoCMake;
std::string m_NotesFiles;
int ReadCustomConfigurationFileTree(const char* dir);
void PopulateCustomVector(cmMakefile* mf, const char* definition, tm_VectorOfStrings& vec);
tm_VectorOfStrings m_CustomErrorMatches;
tm_VectorOfStrings m_CustomErrorExceptions;
tm_VectorOfStrings m_CustomWarningMatches;
tm_VectorOfStrings m_CustomWarningExceptions;
tm_VectorOfStrings m_CustomTestsIgnore;
tm_VectorOfStrings m_CustomMemCheckIgnore;
tm_VectorOfStrings m_CustomPreTest;
tm_VectorOfStrings m_CustomPostTest;
tm_VectorOfStrings m_CustomPreMemCheck;
tm_VectorOfStrings m_CustomPostMemCheck;
int ExecuteCommands(tm_VectorOfStrings& vec);
//! Reread the configuration file
void UpdateCTestConfiguration();