CMake/Source/CTest/cmCTestTestHandler.cxx

2292 lines
66 KiB
C++
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
2004-09-09 16:41:05 +04:00
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
2004-09-09 16:41:05 +04:00
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
2004-09-09 16:41:05 +04:00
#include "cmCTestTestHandler.h"
2008-07-03 17:31:33 +04:00
#include "cmCTestMultiProcessHandler.h"
#include "cmCTestBatchTestHandler.h"
2004-09-09 16:41:05 +04:00
#include "cmCTest.h"
#include "cmCTestRunTest.h"
2004-09-09 16:41:05 +04:00
#include "cmake.h"
#include "cmGeneratedFileStream.h"
2004-09-09 16:41:05 +04:00
#include <cmsys/Process.h>
#include <cmsys/RegularExpression.hxx>
#include <cmsys/Base64.h>
#include "cmMakefile.h"
#include "cmGlobalGenerator.h"
#include "cmLocalGenerator.h"
#include "cmCommand.h"
#include "cmSystemTools.h"
#include "cmXMLSafe.h"
2004-09-09 16:41:05 +04:00
2006-03-09 19:17:10 +03:00
#include <stdlib.h>
2004-09-09 18:52:51 +04:00
#include <math.h>
#include <float.h>
#include <memory> // auto_ptr
2008-01-19 23:09:36 +03:00
//----------------------------------------------------------------------
class cmCTestSubdirCommand : public cmCommand
{
public:
/**
* This is a virtual constructor for the command.
*/
virtual cmCommand* Clone()
{
cmCTestSubdirCommand* c = new cmCTestSubdirCommand;
c->TestHandler = this->TestHandler;
return c;
}
/**
* This is called when the command is first encountered in
* the CMakeLists.txt file.
*/
virtual bool InitialPass(std::vector<std::string> const& args,
cmExecutionStatus &);
2008-01-19 23:09:36 +03:00
/**
* The name of the command as specified in CMakeList.txt.
*/
virtual const char* GetName() { return "subdirs";}
// Unused methods
virtual const char* GetTerseDocumentation() { return ""; }
virtual const char* GetFullDocumentation() { return ""; }
cmTypeMacro(cmCTestSubdirCommand, cmCommand);
cmCTestTestHandler* TestHandler;
};
//----------------------------------------------------------------------
bool cmCTestSubdirCommand
::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
2008-01-19 23:09:36 +03:00
{
if(args.size() < 1 )
{
this->SetError("called with incorrect number of arguments");
return false;
}
std::vector<std::string>::const_iterator it;
std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
for ( it = args.begin(); it != args.end(); ++ it )
{
cmSystemTools::ChangeDirectory(cwd.c_str());
std::string fname;
2008-01-19 23:09:36 +03:00
if(cmSystemTools::FileIsFullPath(it->c_str()))
{
fname = *it;
}
else
{
fname = cwd;
fname += "/";
fname += *it;
}
if ( !cmSystemTools::FileIsDirectory(fname.c_str()) )
2008-01-19 23:09:36 +03:00
{
// No subdirectory? So what...
continue;
}
cmSystemTools::ChangeDirectory(fname.c_str());
const char* testFilename;
if( cmSystemTools::FileExists("CTestTestfile.cmake") )
{
// does the CTestTestfile.cmake exist ?
testFilename = "CTestTestfile.cmake";
}
else if( cmSystemTools::FileExists("DartTestfile.txt") )
{
// does the DartTestfile.txt exist ?
testFilename = "DartTestfile.txt";
}
2008-01-19 23:09:36 +03:00
else
{
// No CTestTestfile? Who cares...
cmSystemTools::ChangeDirectory(cwd.c_str());
continue;
}
fname += "/";
fname += testFilename;
bool readit =
this->Makefile->ReadListFile(this->Makefile->GetCurrentListFile(),
fname.c_str());
cmSystemTools::ChangeDirectory(cwd.c_str());
if(!readit)
{
std::string m = "Could not find include file: ";
m += fname;
this->SetError(m.c_str());
return false;
}
}
return true;
}
//----------------------------------------------------------------------
class cmCTestAddSubdirectoryCommand : public cmCommand
{
public:
/**
* This is a virtual constructor for the command.
*/
2006-03-09 19:17:10 +03:00
virtual cmCommand* Clone()
{
cmCTestAddSubdirectoryCommand* c = new cmCTestAddSubdirectoryCommand;
2006-03-10 23:03:09 +03:00
c->TestHandler = this->TestHandler;
return c;
}
/**
* This is called when the command is first encountered in
* the CMakeLists.txt file.
*/
virtual bool InitialPass(std::vector<std::string> const& args,
cmExecutionStatus &);
/**
* The name of the command as specified in CMakeList.txt.
*/
virtual const char* GetName() { return "add_subdirectory";}
// Unused methods
virtual const char* GetTerseDocumentation() { return ""; }
virtual const char* GetFullDocumentation() { return ""; }
cmTypeMacro(cmCTestAddSubdirectoryCommand, cmCommand);
2006-03-10 23:03:09 +03:00
cmCTestTestHandler* TestHandler;
};
//----------------------------------------------------------------------
bool cmCTestAddSubdirectoryCommand
::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
{
if(args.size() < 1 )
{
this->SetError("called with incorrect number of arguments");
return false;
}
2006-03-09 19:17:10 +03:00
std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
cmSystemTools::ChangeDirectory(cwd.c_str());
std::string fname = cwd;
fname += "/";
fname += args[1];
2006-03-09 19:17:10 +03:00
if ( !cmSystemTools::FileExists(fname.c_str()) )
{
// No subdirectory? So what...
return true;
}
cmSystemTools::ChangeDirectory(fname.c_str());
const char* testFilename;
if( cmSystemTools::FileExists("CTestTestfile.cmake") )
{
// does the CTestTestfile.cmake exist ?
testFilename = "CTestTestfile.cmake";
}
else if( cmSystemTools::FileExists("DartTestfile.txt") )
{
// does the DartTestfile.txt exist ?
testFilename = "DartTestfile.txt";
}
else
{
// No CTestTestfile? Who cares...
cmSystemTools::ChangeDirectory(cwd.c_str());
return true;
}
fname += "/";
fname += testFilename;
bool readit =
this->Makefile->ReadListFile(this->Makefile->GetCurrentListFile(),
fname.c_str());
cmSystemTools::ChangeDirectory(cwd.c_str());
if(!readit)
{
std::string m = "Could not find include file: ";
m += fname;
this->SetError(m.c_str());
return false;
}
return true;
}
//----------------------------------------------------------------------
class cmCTestAddTestCommand : public cmCommand
{
public:
/**
* This is a virtual constructor for the command.
*/
2006-03-09 19:17:10 +03:00
virtual cmCommand* Clone()
{
cmCTestAddTestCommand* c = new cmCTestAddTestCommand;
2006-03-10 23:03:09 +03:00
c->TestHandler = this->TestHandler;
return c;
}
/**
* This is called when the command is first encountered in
* the CMakeLists.txt file.
*/
virtual bool InitialPass(std::vector<std::string> const&,
cmExecutionStatus &);
/**
* The name of the command as specified in CMakeList.txt.
*/
virtual const char* GetName() { return "ADD_TEST";}
// Unused methods
virtual const char* GetTerseDocumentation() { return ""; }
virtual const char* GetFullDocumentation() { return ""; }
cmTypeMacro(cmCTestAddTestCommand, cmCommand);
2006-03-10 23:03:09 +03:00
cmCTestTestHandler* TestHandler;
};
//----------------------------------------------------------------------
bool cmCTestAddTestCommand
::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
{
if ( args.size() < 2 )
{
this->SetError("called with incorrect number of arguments");
return false;
}
return this->TestHandler->AddTest(args);
}
//----------------------------------------------------------------------
class cmCTestSetTestsPropertiesCommand : public cmCommand
{
public:
/**
* This is a virtual constructor for the command.
*/
2006-03-09 19:17:10 +03:00
virtual cmCommand* Clone()
{
2006-03-09 19:17:10 +03:00
cmCTestSetTestsPropertiesCommand* c
= new cmCTestSetTestsPropertiesCommand;
2006-03-10 23:03:09 +03:00
c->TestHandler = this->TestHandler;
return c;
}
/**
* This is called when the command is first encountered in
* the CMakeLists.txt file.
*/
virtual bool InitialPass(std::vector<std::string> const&,
cmExecutionStatus &);
/**
* The name of the command as specified in CMakeList.txt.
*/
virtual const char* GetName() { return "SET_TESTS_PROPERTIES";}
// Unused methods
virtual const char* GetTerseDocumentation() { return ""; }
virtual const char* GetFullDocumentation() { return ""; }
cmTypeMacro(cmCTestSetTestsPropertiesCommand, cmCommand);
2006-03-10 23:03:09 +03:00
cmCTestTestHandler* TestHandler;
};
//----------------------------------------------------------------------
bool cmCTestSetTestsPropertiesCommand
::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
{
2006-03-10 23:03:09 +03:00
return this->TestHandler->SetTestsProperties(args);
}
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
2004-09-09 16:41:05 +04:00
// get the next number in a string with numbers separated by ,
// pos is the start of the search and pos2 is the end of the search
2006-03-09 19:17:10 +03:00
// pos becomes pos2 after a call to GetNextNumber.
2004-09-09 16:41:05 +04:00
// -1 is returned at the end of the list.
2006-03-09 19:17:10 +03:00
inline int GetNextNumber(std::string const& in,
2004-09-09 16:41:05 +04:00
int& val,
std::string::size_type& pos,
std::string::size_type& pos2)
{
pos2 = in.find(',', pos);
if(pos2 != in.npos)
{
if(pos2-pos == 0)
{
val = -1;
}
else
{
val = atoi(in.substr(pos, pos2-pos).c_str());
}
pos = pos2+1;
return 1;
}
else
{
if(in.size()-pos == 0)
{
val = -1;
}
else
{
val = atoi(in.substr(pos, in.size()-pos).c_str());
}
return 0;
}
}
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
2004-09-09 16:41:05 +04:00
// get the next number in a string with numbers separated by ,
// pos is the start of the search and pos2 is the end of the search
2006-03-09 19:17:10 +03:00
// pos becomes pos2 after a call to GetNextNumber.
2004-09-09 16:41:05 +04:00
// -1 is returned at the end of the list.
2006-03-09 19:17:10 +03:00
inline int GetNextRealNumber(std::string const& in,
2004-09-09 16:41:05 +04:00
double& val,
std::string::size_type& pos,
std::string::size_type& pos2)
{
pos2 = in.find(',', pos);
if(pos2 != in.npos)
{
if(pos2-pos == 0)
{
val = -1;
}
else
{
val = atof(in.substr(pos, pos2-pos).c_str());
}
pos = pos2+1;
return 1;
}
else
{
if(in.size()-pos == 0)
{
val = -1;
}
else
{
val = atof(in.substr(pos, in.size()-pos).c_str());
}
return 0;
}
}
2006-03-09 19:17:10 +03:00
2004-09-09 16:41:05 +04:00
//----------------------------------------------------------------------
cmCTestTestHandler::cmCTestTestHandler()
{
2006-03-10 23:03:09 +03:00
this->UseUnion = false;
2006-03-09 19:17:10 +03:00
this->UseIncludeLabelRegExpFlag = false;
this->UseExcludeLabelRegExpFlag = false;
2006-03-10 23:03:09 +03:00
this->UseIncludeRegExpFlag = false;
this->UseExcludeRegExpFlag = false;
this->UseExcludeRegExpFirst = false;
2006-03-10 23:03:09 +03:00
this->CustomMaximumPassedTestOutputSize = 1 * 1024;
this->CustomMaximumFailedTestOutputSize = 300 * 1024;
2006-03-09 19:17:10 +03:00
2006-03-10 23:03:09 +03:00
this->MemCheck = false;
2006-03-10 23:03:09 +03:00
this->LogFile = 0;
2005-08-18 21:50:16 +04:00
2009-01-15 18:32:56 +03:00
// regex to detect <DartMeasurement>...</DartMeasurement>
this->DartStuff.compile(
"(<DartMeasurement.*/DartMeasurement[a-zA-Z]*>)");
// regex to detect each individual <DartMeasurement>...</DartMeasurement>
this->DartStuff1.compile(
"(<DartMeasurement[^<]*</DartMeasurement[a-zA-Z]*>)");
2004-09-09 16:41:05 +04:00
}
//----------------------------------------------------------------------
void cmCTestTestHandler::Initialize()
{
this->Superclass::Initialize();
2006-03-10 23:03:09 +03:00
this->ElapsedTestingTime = -1;
2006-03-10 23:03:09 +03:00
this->TestResults.clear();
2006-03-10 23:03:09 +03:00
this->CustomTestsIgnore.clear();
this->StartTest = "";
this->EndTest = "";
2006-03-10 23:03:09 +03:00
this->CustomPreTest.clear();
this->CustomPostTest.clear();
this->CustomMaximumPassedTestOutputSize = 1 * 1024;
this->CustomMaximumFailedTestOutputSize = 300 * 1024;
2006-03-10 23:03:09 +03:00
this->TestsToRun.clear();
2006-03-10 23:03:09 +03:00
this->UseIncludeRegExpFlag = false;
this->UseExcludeRegExpFlag = false;
this->UseExcludeRegExpFirst = false;
this->IncludeLabelRegularExpression = "";
this->ExcludeLabelRegularExpression = "";
2006-03-10 23:03:09 +03:00
this->IncludeRegExp = "";
this->ExcludeRegExp = "";
TestsToRunString = "";
2006-03-10 23:03:09 +03:00
this->UseUnion = false;
this->TestList.clear();
}
2004-09-09 16:41:05 +04:00
//----------------------------------------------------------------------
void cmCTestTestHandler::PopulateCustomVectors(cmMakefile *mf)
{
this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_PRE_TEST",
2006-03-10 23:03:09 +03:00
this->CustomPreTest);
this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_POST_TEST",
2006-03-10 23:03:09 +03:00
this->CustomPostTest);
this->CTest->PopulateCustomVector(mf,
2006-03-09 19:17:10 +03:00
"CTEST_CUSTOM_TESTS_IGNORE",
2006-03-10 23:03:09 +03:00
this->CustomTestsIgnore);
this->CTest->PopulateCustomInteger(mf,
2006-03-09 19:17:10 +03:00
"CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE",
2006-03-10 23:03:09 +03:00
this->CustomMaximumPassedTestOutputSize);
this->CTest->PopulateCustomInteger(mf,
2006-03-09 19:17:10 +03:00
"CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE",
2006-03-10 23:03:09 +03:00
this->CustomMaximumFailedTestOutputSize);
2004-09-09 16:41:05 +04:00
}
//----------------------------------------------------------------------
2005-01-27 23:54:47 +03:00
int cmCTestTestHandler::PreProcessHandler()
2004-09-09 16:41:05 +04:00
{
2006-03-10 23:03:09 +03:00
if ( !this->ExecuteCommands(this->CustomPreTest) )
2004-09-09 16:41:05 +04:00
{
2006-03-10 23:03:09 +03:00
cmCTestLog(this->CTest, ERROR_MESSAGE,
2006-03-09 19:17:10 +03:00
"Problem executing pre-test command(s)." << std::endl);
2005-01-27 23:54:47 +03:00
return 0;
2004-09-09 16:41:05 +04:00
}
2005-01-27 23:54:47 +03:00
return 1;
}
2004-09-09 16:41:05 +04:00
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
int cmCTestTestHandler::PostProcessHandler()
{
2006-03-10 23:03:09 +03:00
if ( !this->ExecuteCommands(this->CustomPostTest) )
2004-09-09 16:41:05 +04:00
{
2006-03-10 23:03:09 +03:00
cmCTestLog(this->CTest, ERROR_MESSAGE,
2006-03-09 19:17:10 +03:00
"Problem executing post-test command(s)." << std::endl);
2005-01-27 23:54:47 +03:00
return 0;
2004-09-09 16:41:05 +04:00
}
2005-01-27 23:54:47 +03:00
return 1;
}
//----------------------------------------------------------------------
//clearly it would be nice if this were broken up into a few smaller
//functions and commented...
int cmCTestTestHandler::ProcessHandler()
{
2005-02-18 00:11:10 +03:00
// Update internal data structure from generic one
this->SetTestsToRunInformation(this->GetOption("TestsToRunInformation"));
this->SetUseUnion(cmSystemTools::IsOn(this->GetOption("UseUnion")));
if(cmSystemTools::IsOn(this->GetOption("ScheduleRandom")))
{
this->CTest->SetScheduleType("Random");
}
if(this->GetOption("ParallelLevel"))
{
this->CTest->SetParallelLevel(atoi(this->GetOption("ParallelLevel")));
}
2005-02-18 00:11:10 +03:00
const char* val;
val = this->GetOption("LabelRegularExpression");
if ( val )
{
this->UseIncludeLabelRegExpFlag = true;
this->IncludeLabelRegExp = val;
}
val = this->GetOption("ExcludeLabelRegularExpression");
if ( val )
{
this->UseExcludeLabelRegExpFlag = true;
this->ExcludeLabelRegularExpression = val;
}
2005-02-18 00:11:10 +03:00
val = this->GetOption("IncludeRegularExpression");
if ( val )
{
this->UseIncludeRegExp();
this->SetIncludeRegExp(val);
}
val = this->GetOption("ExcludeRegularExpression");
if ( val )
{
this->UseExcludeRegExp();
this->SetExcludeRegExp(val);
}
2006-03-10 23:03:09 +03:00
this->TestResults.clear();
cmCTestLog(this->CTest, HANDLER_OUTPUT,
(this->MemCheck ? "Memory check" : "Test")
<< " project " << cmSystemTools::GetCurrentWorkingDirectory()
<< std::endl);
2005-01-27 23:54:47 +03:00
if ( ! this->PreProcessHandler() )
2004-09-09 16:41:05 +04:00
{
2005-01-27 23:54:47 +03:00
return -1;
2004-09-09 16:41:05 +04:00
}
2005-08-18 21:50:16 +04:00
cmGeneratedFileStream mLogFile;
this->StartLogFile((this->MemCheck ? "DynamicAnalysis" : "Test"), mLogFile);
2006-03-10 23:03:09 +03:00
this->LogFile = &mLogFile;
2005-08-18 21:50:16 +04:00
2004-09-09 16:41:05 +04:00
std::vector<cmStdString> passed;
std::vector<cmStdString> failed;
int total;
//start the real time clock
double clock_start, clock_finish;
clock_start = cmSystemTools::GetTime();
2005-01-27 23:54:47 +03:00
this->ProcessDirectory(passed, failed);
2004-09-09 16:41:05 +04:00
clock_finish = cmSystemTools::GetTime();
2004-09-09 16:41:05 +04:00
total = int(passed.size()) + int(failed.size());
if (total == 0)
{
2006-03-10 23:03:09 +03:00
if ( !this->CTest->GetShowOnly() )
2004-09-09 16:41:05 +04:00
{
2006-03-10 23:03:09 +03:00
cmCTestLog(this->CTest, ERROR_MESSAGE, "No tests were found!!!"
2006-03-09 19:17:10 +03:00
<< std::endl);
2004-09-09 16:41:05 +04:00
}
}
else
{
2006-03-10 23:03:09 +03:00
if (this->HandlerVerbose && passed.size() &&
(this->UseIncludeRegExpFlag || this->UseExcludeRegExpFlag))
2004-09-09 16:41:05 +04:00
{
2006-03-10 23:03:09 +03:00
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl
2006-03-09 19:17:10 +03:00
<< "The following tests passed:" << std::endl);
2004-09-09 16:41:05 +04:00
for(std::vector<cmStdString>::iterator j = passed.begin();
j != passed.end(); ++j)
2006-03-09 19:17:10 +03:00
{
2006-03-10 23:03:09 +03:00
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "\t" << *j
<< std::endl);
2004-09-09 16:41:05 +04:00
}
}
2009-10-02 23:30:01 +04:00
float percent = float(passed.size()) * 100.0f / float(total);
2004-09-09 16:41:05 +04:00
if ( failed.size() > 0 && percent > 99)
{
percent = 99;
}
2009-10-02 23:30:01 +04:00
cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl
<< static_cast<int>(percent + .5) << "% tests passed, "
2009-10-02 23:30:01 +04:00
<< failed.size() << " tests failed out of "
<< total << std::endl);
if(this->CTest->GetLabelSummary())
2008-07-03 17:31:33 +04:00
{
this->PrintLabelSummary();
2008-07-03 17:31:33 +04:00
}
char realBuf[1024];
sprintf(realBuf, "%6.2f sec", (double)(clock_finish - clock_start));
cmCTestLog(this->CTest, HANDLER_OUTPUT, "\nTotal Test time (real) = "
<< realBuf << "\n" );
2006-03-09 19:17:10 +03:00
if (failed.size())
2004-09-09 16:41:05 +04:00
{
cmGeneratedFileStream ofs;
cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl
<< "The following tests FAILED:" << std::endl);
this->StartLogFile("TestsFailed", ofs);
std::vector<cmCTestTestHandler::cmCTestTestResult>::iterator ftit;
for(ftit = this->TestResults.begin();
ftit != this->TestResults.end(); ++ftit)
2004-09-09 16:41:05 +04:00
{
if ( ftit->Status != cmCTestTestHandler::COMPLETED )
2004-09-09 16:41:05 +04:00
{
ofs << ftit->TestCount << ":" << ftit->Name << std::endl;
cmCTestLog(this->CTest, HANDLER_OUTPUT, "\t" << std::setw(3)
<< ftit->TestCount << " - "
<< ftit->Name.c_str() << " ("
<< this->GetTestStatus(ftit->Status) << ")"
<< std::endl);
2004-09-09 16:41:05 +04:00
}
}
}
}
2006-03-10 23:03:09 +03:00
if ( this->CTest->GetProduceXML() )
2004-09-09 16:41:05 +04:00
{
cmGeneratedFileStream xmlfile;
2006-03-10 23:03:09 +03:00
if( !this->StartResultingXML(
(this->MemCheck ? cmCTest::PartMemCheck : cmCTest::PartTest),
2006-03-10 23:03:09 +03:00
(this->MemCheck ? "DynamicAnalysis" : "Test"), xmlfile) )
2004-09-09 16:41:05 +04:00
{
2006-03-10 23:03:09 +03:00
cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create "
<< (this->MemCheck ? "memory check" : "testing")
<< " XML file" << std::endl);
2006-03-10 23:03:09 +03:00
this->LogFile = 0;
2004-09-09 16:41:05 +04:00
return 1;
}
2005-01-27 23:54:47 +03:00
this->GenerateDartOutput(xmlfile);
2004-09-09 16:41:05 +04:00
}
2005-01-27 23:54:47 +03:00
if ( ! this->PostProcessHandler() )
2004-09-09 16:41:05 +04:00
{
2006-03-10 23:03:09 +03:00
this->LogFile = 0;
2005-01-27 23:54:47 +03:00
return -1;
2004-09-09 16:41:05 +04:00
}
2005-01-27 23:54:47 +03:00
if ( !failed.empty() )
2004-09-09 16:41:05 +04:00
{
2006-03-10 23:03:09 +03:00
this->LogFile = 0;
2005-01-27 23:54:47 +03:00
return -1;
2004-09-09 16:41:05 +04:00
}
2006-03-10 23:03:09 +03:00
this->LogFile = 0;
2005-01-27 23:54:47 +03:00
return 0;
2004-09-09 16:41:05 +04:00
}
//----------------------------------------------------------------------
void cmCTestTestHandler::PrintLabelSummary()
{
cmCTestTestHandler::ListOfTests::iterator it = this->TestList.begin();
cmCTestTestHandler::TestResultsVector::iterator ri =
this->TestResults.begin();
std::map<cmStdString, double> labelTimes;
std::set<cmStdString> labels;
// initialize maps
std::string::size_type maxlen = 0;
for(; it != this->TestList.end(); ++it)
{
cmCTestTestProperties& p = *it;
if(p.Labels.size() != 0)
{
for(std::vector<std::string>::iterator l = p.Labels.begin();
l != p.Labels.end(); ++l)
{
if((*l).size() > maxlen)
{
maxlen = (*l).size();
}
labels.insert(*l);
labelTimes[*l] = 0;
}
}
}
ri = this->TestResults.begin();
// fill maps
for(; ri != this->TestResults.end(); ++ri)
{
cmCTestTestResult &result = *ri;
cmCTestTestProperties& p = *result.Properties;
if(p.Labels.size() != 0)
{
for(std::vector<std::string>::iterator l = p.Labels.begin();
l != p.Labels.end(); ++l)
{
labelTimes[*l] += result.ExecutionTime;
}
}
}
// now print times
if(labels.size())
{
cmCTestLog(this->CTest, HANDLER_OUTPUT, "\nLabel Time Summary:");
}
for(std::set<cmStdString>::const_iterator i = labels.begin();
i != labels.end(); ++i)
{
std::string label = *i;
label.resize(maxlen +3, ' ');
char buf[1024];
sprintf(buf, "%6.2f sec", labelTimes[*i]);
cmCTestLog(this->CTest, HANDLER_OUTPUT, "\n"
<< label << " = " << buf );
if ( this->LogFile )
{
*this->LogFile << "\n" << *i << " = "
<< buf << "\n";
}
}
if(labels.size())
{
if(this->LogFile)
{
*this->LogFile << "\n";
}
cmCTestLog(this->CTest, HANDLER_OUTPUT, "\n");
}
}
//----------------------------------------------------------------------
void cmCTestTestHandler::CheckLabelFilterInclude(cmCTestTestProperties& it)
{
// if not using Labels to filter then return
if (!this->UseIncludeLabelRegExpFlag )
{
return;
}
// if there are no labels and we are filtering by labels
// then exclude the test as it does not have the label
if(it.Labels.size() == 0 )
{
it.IsInBasedOnREOptions = false;
return;
}
// check to see if the label regular expression matches
bool found = false; // assume it does not match
// loop over all labels and look for match
for(std::vector<std::string>::iterator l = it.Labels.begin();
l != it.Labels.end(); ++l)
{
if(this->IncludeLabelRegularExpression.find(*l))
{
found = true;
}
}
// if no match was found, exclude the test
if(!found)
{
it.IsInBasedOnREOptions = false;
}
}
//----------------------------------------------------------------------
void cmCTestTestHandler::CheckLabelFilterExclude(cmCTestTestProperties& it)
{
// if not using Labels to filter then return
if (!this->UseExcludeLabelRegExpFlag )
{
return;
}
// if there are no labels and we are excluding by labels
// then do nothing as a no label can not be a match
if(it.Labels.size() == 0 )
{
return;
}
// check to see if the label regular expression matches
bool found = false; // assume it does not match
// loop over all labels and look for match
for(std::vector<std::string>::iterator l = it.Labels.begin();
l != it.Labels.end(); ++l)
{
if(this->ExcludeLabelRegularExpression.find(*l))
{
found = true;
}
}
// if match was found, exclude the test
if(found)
{
it.IsInBasedOnREOptions = false;
}
}
//----------------------------------------------------------------------
void cmCTestTestHandler::CheckLabelFilter(cmCTestTestProperties& it)
{
this->CheckLabelFilterInclude(it);
this->CheckLabelFilterExclude(it);
}
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
2008-07-03 17:31:33 +04:00
void cmCTestTestHandler::ComputeTestList()
2004-09-09 16:41:05 +04:00
{
2008-07-03 17:31:33 +04:00
this->TestList.clear(); // clear list of test
this->GetListOfTests();
2006-03-10 23:03:09 +03:00
cmCTestTestHandler::ListOfTests::size_type tmsize = this->TestList.size();
// how many tests are in based on RegExp?
int inREcnt = 0;
2006-03-10 23:03:09 +03:00
cmCTestTestHandler::ListOfTests::iterator it;
for ( it = this->TestList.begin(); it != this->TestList.end(); it ++ )
{
this->CheckLabelFilter(*it);
2006-03-10 23:03:09 +03:00
if (it->IsInBasedOnREOptions)
{
inREcnt ++;
}
}
// expand the test list based on the union flag
2006-03-10 23:03:09 +03:00
if (this->UseUnion)
{
this->ExpandTestsToRunInformation((int)tmsize);
}
else
{
this->ExpandTestsToRunInformation(inREcnt);
}
2008-07-03 17:31:33 +04:00
// Now create a final list of tests to run
2004-09-09 16:41:05 +04:00
int cnt = 0;
inREcnt = 0;
2008-07-03 17:31:33 +04:00
std::string last_directory = "";
ListOfTests finalList;
2006-03-10 23:03:09 +03:00
for ( it = this->TestList.begin(); it != this->TestList.end(); it ++ )
2004-09-09 16:41:05 +04:00
{
cnt ++;
2006-03-10 23:03:09 +03:00
if (it->IsInBasedOnREOptions)
{
inREcnt++;
}
2006-03-10 23:03:09 +03:00
if (this->UseUnion)
2004-09-09 16:41:05 +04:00
{
// if it is not in the list and not in the regexp then skip
2006-03-10 23:03:09 +03:00
if ((this->TestsToRun.size() &&
std::find(this->TestsToRun.begin(), this->TestsToRun.end(), cnt)
== this->TestsToRun.end()) && !it->IsInBasedOnREOptions)
{
continue;
}
2004-09-09 16:41:05 +04:00
}
else
{
// is this test in the list of tests to run? If not then skip it
2006-03-10 23:03:09 +03:00
if ((this->TestsToRun.size() &&
std::find(this->TestsToRun.begin(),
2007-01-25 19:16:16 +03:00
this->TestsToRun.end(), inREcnt)
2006-03-10 23:03:09 +03:00
== this->TestsToRun.end()) || !it->IsInBasedOnREOptions)
{
continue;
}
}
2008-07-03 17:31:33 +04:00
it->Index = cnt; // save the index into the test list for this test
finalList.push_back(*it);
}
// Save the total number of tests before exclusions
this->TotalNumberOfTests = this->TestList.size();
// Set the TestList to the final list of all test
this->TestList = finalList;
std::string::size_type max = this->CTest->GetMaxTestNameWidth();
2009-07-18 00:15:11 +04:00
for (it = this->TestList.begin();
it != this->TestList.end(); it ++ )
{
cmCTestTestProperties& p = *it;
if(max < p.Name.size())
{
max = p.Name.size();
}
}
if(static_cast<std::string::size_type>(this->CTest->GetMaxTestNameWidth())
!= max)
{
2009-07-19 21:40:38 +04:00
this->CTest->SetMaxTestNameWidth(static_cast<int>(max));
}
2008-07-03 17:31:33 +04:00
}
bool cmCTestTestHandler::GetValue(const char* tag,
int& value,
std::ifstream& fin)
{
std::string line;
2008-07-04 18:10:30 +04:00
bool ret = true;
2008-07-03 17:31:33 +04:00
cmSystemTools::GetLineFromStream(fin, line);
if(line == tag)
{
fin >> value;
2008-07-04 18:10:30 +04:00
ret = cmSystemTools::GetLineFromStream(fin, line); // read blank line
2008-07-03 17:31:33 +04:00
}
else
{
cmCTestLog(this->CTest, ERROR_MESSAGE,
"parse error: missing tag: "
<< tag << " found [" << line << "]" << std::endl);
2008-07-04 18:10:30 +04:00
ret = false;
2008-07-03 17:31:33 +04:00
}
2008-07-04 18:10:30 +04:00
return ret;
2008-07-03 17:31:33 +04:00
}
bool cmCTestTestHandler::GetValue(const char* tag,
double& value,
std::ifstream& fin)
{
std::string line;
cmSystemTools::GetLineFromStream(fin, line);
2008-07-04 18:10:30 +04:00
bool ret = true;
2008-07-03 17:31:33 +04:00
if(line == tag)
{
fin >> value;
2008-07-04 18:10:30 +04:00
ret = cmSystemTools::GetLineFromStream(fin, line); // read blank line
2008-07-03 17:31:33 +04:00
}
else
{
cmCTestLog(this->CTest, ERROR_MESSAGE,
"parse error: missing tag: "
<< tag << " found [" << line << "]" << std::endl);
2008-07-04 18:10:30 +04:00
ret = false;
2008-07-03 17:31:33 +04:00
}
2008-07-04 18:10:30 +04:00
return ret;
2008-07-03 17:31:33 +04:00
}
bool cmCTestTestHandler::GetValue(const char* tag,
bool& value,
std::ifstream& fin)
{
std::string line;
cmSystemTools::GetLineFromStream(fin, line);
2008-07-04 18:10:30 +04:00
bool ret = true;
2008-07-03 17:31:33 +04:00
if(line == tag)
{
#ifdef __HAIKU__
int tmp = 0;
fin >> tmp;
value = false;
if(tmp)
{
value = true;
}
#else
2008-07-03 17:31:33 +04:00
fin >> value;
#endif
2008-07-04 18:10:30 +04:00
ret = cmSystemTools::GetLineFromStream(fin, line); // read blank line
2008-07-03 17:31:33 +04:00
}
else
{
cmCTestLog(this->CTest, ERROR_MESSAGE,
"parse error: missing tag: "
<< tag << " found [" << line << "]" << std::endl);
2008-07-04 18:10:30 +04:00
ret = false;
2008-07-03 17:31:33 +04:00
}
2008-07-04 18:10:30 +04:00
return ret;
2008-07-03 17:31:33 +04:00
}
bool cmCTestTestHandler::GetValue(const char* tag,
size_t& value,
std::ifstream& fin)
{
std::string line;
cmSystemTools::GetLineFromStream(fin, line);
2008-07-04 18:10:30 +04:00
bool ret = true;
2008-07-03 17:31:33 +04:00
if(line == tag)
{
fin >> value;
2008-07-04 18:10:30 +04:00
ret = cmSystemTools::GetLineFromStream(fin, line); // read blank line
2008-07-03 17:31:33 +04:00
}
else
{
cmCTestLog(this->CTest, ERROR_MESSAGE,
"parse error: missing tag: "
<< tag << " found [" << line.c_str() << "]" << std::endl);
2008-07-04 18:10:30 +04:00
ret = false;
2008-07-03 17:31:33 +04:00
}
2008-07-04 18:10:30 +04:00
return ret;
2008-07-03 17:31:33 +04:00
}
bool cmCTestTestHandler::GetValue(const char* tag,
std::string& value,
std::ifstream& fin)
{
std::string line;
cmSystemTools::GetLineFromStream(fin, line);
2008-07-04 18:10:30 +04:00
bool ret = true;
2008-07-03 17:31:33 +04:00
if(line == tag)
{
2008-07-04 18:10:30 +04:00
ret = cmSystemTools::GetLineFromStream(fin, value);
2008-07-03 17:31:33 +04:00
}
else
{
cmCTestLog(this->CTest, ERROR_MESSAGE,
"parse error: missing tag: "
<< tag << " found [" << line << "]" << std::endl);
2008-07-04 18:10:30 +04:00
ret = false;
2008-07-03 17:31:33 +04:00
}
2008-07-04 18:10:30 +04:00
return ret;
2008-07-03 17:31:33 +04:00
}
//---------------------------------------------------------------------
void cmCTestTestHandler::ProcessDirectory(std::vector<cmStdString> &passed,
2008-07-03 17:31:33 +04:00
std::vector<cmStdString> &failed)
{
this->ComputeTestList();
2009-08-31 18:28:39 +04:00
this->StartTest = this->CTest->CurrentTime();
this->StartTestTime = static_cast<unsigned int>(cmSystemTools::GetTime());
double elapsed_time_start = cmSystemTools::GetTime();
cmCTestMultiProcessHandler* parallel = this->CTest->GetBatchJobs() ?
new cmCTestBatchTestHandler : new cmCTestMultiProcessHandler;
parallel->SetCTest(this->CTest);
parallel->SetParallelLevel(this->CTest->GetParallelLevel());
parallel->SetTestHandler(this);
*this->LogFile << "Start testing: "
<< this->CTest->CurrentTime() << std::endl
<< "----------------------------------------------------------"
<< std::endl;
cmCTestMultiProcessHandler::TestMap tests;
cmCTestMultiProcessHandler::PropertiesMap properties;
bool randomSchedule = this->CTest->GetScheduleType() == "Random";
if(randomSchedule)
{
srand((unsigned)time(0));
}
2008-07-03 17:31:33 +04:00
for (ListOfTests::iterator it = this->TestList.begin();
it != this->TestList.end(); ++it)
2008-07-03 17:31:33 +04:00
{
cmCTestTestProperties& p = *it;
cmCTestMultiProcessHandler::TestSet depends;
if(randomSchedule)
{
p.Cost = rand();
}
if(p.Timeout == 0 && this->CTest->GetGlobalTimeout() != 0)
{
p.Timeout = this->CTest->GetGlobalTimeout();
}
2008-07-03 17:31:33 +04:00
if(p.Depends.size())
{
for(std::vector<std::string>::iterator i = p.Depends.begin();
i != p.Depends.end(); ++i)
2008-07-03 17:31:33 +04:00
{
for(ListOfTests::iterator it2 = this->TestList.begin();
it2 != this->TestList.end(); ++it2)
2008-07-03 17:31:33 +04:00
{
if(it2->Name == *i)
{
depends.insert(it2->Index);
break; // break out of test loop as name can only match 1
}
}
}
}
tests[it->Index] = depends;
properties[it->Index] = &*it;
2008-07-03 17:31:33 +04:00
}
parallel->SetTests(tests, properties);
parallel->SetPassFailVectors(&passed, &failed);
2008-07-03 17:31:33 +04:00
this->TestResults.clear();
parallel->SetTestResults(&this->TestResults);
if(this->CTest->GetShowOnly())
{
parallel->PrintTestList();
}
else
{
parallel->RunTests();
}
delete parallel;
2009-08-31 18:28:39 +04:00
this->EndTest = this->CTest->CurrentTime();
this->EndTestTime = static_cast<unsigned int>(cmSystemTools::GetTime());
this->ElapsedTestingTime = cmSystemTools::GetTime() - elapsed_time_start;
*this->LogFile << "End testing: "
<< this->CTest->CurrentTime() << std::endl;
2004-09-09 16:41:05 +04:00
}
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
void cmCTestTestHandler::GenerateTestCommand(std::vector<std::string>&)
2004-09-09 16:41:05 +04:00
{
}
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
void cmCTestTestHandler::GenerateDartOutput(std::ostream& os)
2004-09-09 16:41:05 +04:00
{
2006-03-10 23:03:09 +03:00
if ( !this->CTest->GetProduceXML() )
2004-09-09 16:41:05 +04:00
{
return;
}
this->CTest->StartXML(os, this->AppendXML);
2004-09-09 16:41:05 +04:00
os << "<Testing>\n"
2006-03-10 23:03:09 +03:00
<< "\t<StartDateTime>" << this->StartTest << "</StartDateTime>\n"
<< "\t<StartTestTime>" << this->StartTestTime << "</StartTestTime>\n"
2004-09-09 16:41:05 +04:00
<< "\t<TestList>\n";
2006-03-10 23:03:09 +03:00
cmCTestTestHandler::TestResultsVector::size_type cc;
for ( cc = 0; cc < this->TestResults.size(); cc ++ )
2004-09-09 16:41:05 +04:00
{
2006-03-10 23:03:09 +03:00
cmCTestTestResult *result = &this->TestResults[cc];
std::string testPath = result->Path + "/" + result->Name;
os << "\t\t<Test>" << cmXMLSafe(
2006-03-10 23:03:09 +03:00
this->CTest->GetShortPathToFile(testPath.c_str()))
2004-09-09 16:41:05 +04:00
<< "</Test>" << std::endl;
}
os << "\t</TestList>\n";
2006-03-10 23:03:09 +03:00
for ( cc = 0; cc < this->TestResults.size(); cc ++ )
2004-09-09 16:41:05 +04:00
{
2006-03-10 23:03:09 +03:00
cmCTestTestResult *result = &this->TestResults[cc];
this->WriteTestResultHeader(os, result);
os << "\t\t<Results>" << std::endl;
2006-03-10 23:03:09 +03:00
if ( result->Status != cmCTestTestHandler::NOT_RUN )
2004-09-09 16:41:05 +04:00
{
2006-03-10 23:03:09 +03:00
if ( result->Status != cmCTestTestHandler::COMPLETED ||
result->ReturnValue )
2004-09-09 16:41:05 +04:00
{
2006-03-09 19:17:10 +03:00
os << "\t\t\t<NamedMeasurement type=\"text/string\" "
"name=\"Exit Code\"><Value>"
<< cmXMLSafe(this->GetTestStatus(result->Status))
<< "</Value>"
2006-03-09 19:17:10 +03:00
"</NamedMeasurement>\n"
<< "\t\t\t<NamedMeasurement type=\"text/string\" "
"name=\"Exit Value\"><Value>"
<< result->ReturnValue
<< "</Value></NamedMeasurement>"
2006-03-09 19:17:10 +03:00
<< std::endl;
2004-09-09 16:41:05 +04:00
}
2006-03-10 23:03:09 +03:00
os << result->RegressionImages;
2004-09-09 16:41:05 +04:00
os << "\t\t\t<NamedMeasurement type=\"numeric/double\" "
<< "name=\"Execution Time\"><Value>"
<< result->ExecutionTime
<< "</Value></NamedMeasurement>\n";
if(result->Reason.size())
{
const char* reasonType = "Pass Reason";
if(result->Status != cmCTestTestHandler::COMPLETED &&
result->Status != cmCTestTestHandler::NOT_RUN)
{
reasonType = "Fail Reason";
}
os << "\t\t\t<NamedMeasurement type=\"text/string\" "
<< "name=\"" << reasonType << "\"><Value>"
<< cmXMLSafe(result->Reason)
<< "</Value></NamedMeasurement>\n";
}
2006-03-09 19:17:10 +03:00
os
2004-09-09 16:41:05 +04:00
<< "\t\t\t<NamedMeasurement type=\"text/string\" "
<< "name=\"Completion Status\"><Value>"
<< cmXMLSafe(result->CompletionStatus)
<< "</Value></NamedMeasurement>\n";
2004-09-09 16:41:05 +04:00
}
os
<< "\t\t\t<NamedMeasurement type=\"text/string\" "
<< "name=\"Command Line\"><Value>"
<< cmXMLSafe(result->FullCommandLine)
<< "</Value></NamedMeasurement>\n";
std::map<cmStdString,cmStdString>::iterator measureIt;
for ( measureIt = result->Properties->Measurements.begin();
measureIt != result->Properties->Measurements.end();
++ measureIt )
{
os
<< "\t\t\t<NamedMeasurement type=\"text/string\" "
<< "name=\"" << measureIt->first.c_str() << "\"><Value>"
<< cmXMLSafe(measureIt->second)
<< "</Value></NamedMeasurement>\n";
}
2006-03-09 19:17:10 +03:00
os
2004-09-09 16:41:05 +04:00
<< "\t\t\t<Measurement>\n"
<< "\t\t\t\t<Value"
<< (result->CompressOutput ?
" encoding=\"base64\" compression=\"gzip\">"
: ">");
os << cmXMLSafe(result->Output);
2004-09-09 16:41:05 +04:00
os
<< "</Value>\n"
<< "\t\t\t</Measurement>\n"
<< "\t\t</Results>\n";
this->AttachFiles(os, result);
this->WriteTestResultFooter(os, result);
2004-09-09 16:41:05 +04:00
}
2006-03-10 23:03:09 +03:00
os << "\t<EndDateTime>" << this->EndTest << "</EndDateTime>\n"
<< "\t<EndTestTime>" << this->EndTestTime << "</EndTestTime>\n"
2006-03-09 19:17:10 +03:00
<< "<ElapsedMinutes>"
2006-03-10 23:03:09 +03:00
<< static_cast<int>(this->ElapsedTestingTime/6)/10.0
2004-09-09 16:41:05 +04:00
<< "</ElapsedMinutes>"
<< "</Testing>" << std::endl;
2006-03-10 23:03:09 +03:00
this->CTest->EndXML(os);
2004-09-09 16:41:05 +04:00
}
//----------------------------------------------------------------------------
void cmCTestTestHandler::WriteTestResultHeader(std::ostream& os,
cmCTestTestResult* result)
{
os << "\t<Test Status=\"";
if ( result->Status == cmCTestTestHandler::COMPLETED )
{
os << "passed";
}
else if ( result->Status == cmCTestTestHandler::NOT_RUN )
{
os << "notrun";
}
else
{
os << "failed";
}
std::string testPath = result->Path + "/" + result->Name;
os << "\">\n"
<< "\t\t<Name>" << cmXMLSafe(result->Name) << "</Name>\n"
<< "\t\t<Path>" << cmXMLSafe(
this->CTest->GetShortPathToFile(result->Path.c_str())) << "</Path>\n"
<< "\t\t<FullName>" << cmXMLSafe(
this->CTest->GetShortPathToFile(testPath.c_str())) << "</FullName>\n"
<< "\t\t<FullCommandLine>"
<< cmXMLSafe(result->FullCommandLine)
<< "</FullCommandLine>\n";
}
//----------------------------------------------------------------------------
void cmCTestTestHandler::WriteTestResultFooter(std::ostream& os,
cmCTestTestResult* result)
{
if(!result->Properties->Labels.empty())
{
os << "\t\t<Labels>\n";
std::vector<std::string> const& labels = result->Properties->Labels;
for(std::vector<std::string>::const_iterator li = labels.begin();
li != labels.end(); ++li)
{
os << "\t\t\t<Label>" << cmXMLSafe(*li) << "</Label>\n";
}
os << "\t\t</Labels>\n";
}
os
<< "\t</Test>" << std::endl;
}
//----------------------------------------------------------------------
void cmCTestTestHandler::AttachFiles(std::ostream& os,
cmCTestTestResult* result)
{
if(result->Status != cmCTestTestHandler::COMPLETED
&& result->Properties->AttachOnFail.size())
{
result->Properties->AttachedFiles.insert(
result->Properties->AttachedFiles.end(),
result->Properties->AttachOnFail.begin(),
result->Properties->AttachOnFail.end());
}
for(std::vector<std::string>::const_iterator file =
result->Properties->AttachedFiles.begin();
file != result->Properties->AttachedFiles.end(); ++file)
{
std::string base64 = this->EncodeFile(*file);
std::string fname = cmSystemTools::GetFilenameName(*file);
os << "\t\t<NamedMeasurement name=\"Attached File\" encoding=\"base64\" "
"compression=\"tar/gzip\" filename=\"" << fname << "\" type=\"file\">"
"\n\t\t\t<Value>\n\t\t\t"
<< base64
<< "\n\t\t\t</Value>\n\t\t</NamedMeasurement>\n";
}
}
//----------------------------------------------------------------------
std::string cmCTestTestHandler::EncodeFile(std::string file)
{
std::string tarFile = file + "_temp.tar.gz";
std::vector<cmStdString> files;
files.push_back(file);
if(!cmSystemTools::CreateTar(tarFile.c_str(), files, true, false, false))
{
cmCTestLog(this->CTest, ERROR_MESSAGE, "Error creating tar while "
"attaching file: " << file << std::endl);
return "";
}
long len = cmSystemTools::FileLength(tarFile.c_str());
std::ifstream ifs(tarFile.c_str(), std::ios::in
#ifdef _WIN32
| std::ios::binary
#endif
);
unsigned char *file_buffer = new unsigned char [ len + 1 ];
ifs.read(reinterpret_cast<char*>(file_buffer), len);
ifs.close();
cmSystemTools::RemoveFile(tarFile.c_str());
unsigned char *encoded_buffer
= new unsigned char [ static_cast<int>(len * 1.5 + 5) ];
unsigned long rlen
= cmsysBase64_Encode(file_buffer, len, encoded_buffer, 1);
std::string base64 = "";
for(unsigned long i = 0; i < rlen; i++)
{
base64 += encoded_buffer[i];
}
delete [] file_buffer;
delete [] encoded_buffer;
return base64;
}
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
2004-09-09 16:41:05 +04:00
int cmCTestTestHandler::ExecuteCommands(std::vector<cmStdString>& vec)
{
std::vector<cmStdString>::iterator it;
for ( it = vec.begin(); it != vec.end(); ++it )
{
int retVal = 0;
2006-03-10 23:03:09 +03:00
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run command: " << *it
2006-03-09 19:17:10 +03:00
<< std::endl);
if ( !cmSystemTools::RunSingleCommand(it->c_str(), 0, &retVal, 0, true
2006-03-10 23:03:09 +03:00
/*this->Verbose*/) || retVal != 0 )
2004-09-09 16:41:05 +04:00
{
2006-03-10 23:03:09 +03:00
cmCTestLog(this->CTest, ERROR_MESSAGE, "Problem running command: "
<< *it << std::endl);
2004-09-09 16:41:05 +04:00
return 0;
}
}
return 1;
}
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
// Find the appropriate executable to run for a test
2004-09-09 16:41:05 +04:00
std::string cmCTestTestHandler::FindTheExecutable(const char *exe)
{
std::string resConfig;
std::vector<std::string> extraPaths;
std::vector<std::string> failedPaths;
return cmCTestTestHandler::FindExecutable(this->CTest,
exe, resConfig,
extraPaths,
failedPaths);
}
2004-09-09 16:41:05 +04:00
// add additional configurations to the search path
void cmCTestTestHandler
::AddConfigurations(cmCTest *ctest,
std::vector<std::string> &attempted,
std::vector<std::string> &attemptedConfigs,
std::string filepath,
std::string &filename)
{
std::string tempPath;
if (filepath.size() &&
filepath[filepath.size()-1] != '/')
2004-09-09 16:41:05 +04:00
{
filepath += "/";
2004-09-09 16:41:05 +04:00
}
tempPath = filepath + filename;
attempted.push_back(tempPath);
attemptedConfigs.push_back("");
if(ctest->GetConfigType().size())
2004-09-09 16:41:05 +04:00
{
tempPath = filepath;
tempPath += ctest->GetConfigType();
tempPath += "/";
tempPath += filename;
attempted.push_back(tempPath);
attemptedConfigs.push_back(ctest->GetConfigType());
// If the file is an OSX bundle then the configtyp
// will be at the start of the path
tempPath = ctest->GetConfigType();
tempPath += "/";
tempPath += filepath;
tempPath += filename;
attempted.push_back(tempPath);
attemptedConfigs.push_back(ctest->GetConfigType());
2004-09-09 16:41:05 +04:00
}
else
2004-09-09 16:41:05 +04:00
{
// no config specified to try some options
tempPath = filepath;
tempPath += "Release/";
tempPath += filename;
attempted.push_back(tempPath);
attemptedConfigs.push_back("Release");
tempPath = filepath;
tempPath += "Debug/";
tempPath += filename;
attempted.push_back(tempPath);
attemptedConfigs.push_back("Debug");
tempPath = filepath;
tempPath += "MinSizeRel/";
tempPath += filename;
attempted.push_back(tempPath);
attemptedConfigs.push_back("MinSizeRel");
tempPath = filepath;
tempPath += "RelWithDebInfo/";
tempPath += filename;
attempted.push_back(tempPath);
attemptedConfigs.push_back("RelWithDebInfo");
tempPath = filepath;
tempPath += "Deployment/";
tempPath += filename;
attempted.push_back(tempPath);
attemptedConfigs.push_back("Deployment");
tempPath = filepath;
tempPath += "Development/";
tempPath += filename;
attempted.push_back(tempPath);
attemptedConfigs.push_back("Deployment");
}
}
//----------------------------------------------------------------------
// Find the appropriate executable to run for a test
std::string cmCTestTestHandler
::FindExecutable(cmCTest *ctest,
const char *testCommand,
std::string &resultingConfig,
std::vector<std::string> &extraPaths,
std::vector<std::string> &failed)
{
// now run the compiled test if we can find it
std::vector<std::string> attempted;
std::vector<std::string> attemptedConfigs;
std::string tempPath;
std::string filepath =
cmSystemTools::GetFilenamePath(testCommand);
std::string filename =
cmSystemTools::GetFilenameName(testCommand);
cmCTestTestHandler::AddConfigurations(ctest, attempted,
attemptedConfigs,
filepath,filename);
// even if a fullpath was specified also try it relative to the current
// directory
if (filepath.size() && filepath[0] == '/')
{
std::string localfilepath = filepath.substr(1,filepath.size()-1);
cmCTestTestHandler::AddConfigurations(ctest, attempted,
attemptedConfigs,
localfilepath,filename);
}
// if extraPaths are provided and we were not passed a full path, try them,
// try any extra paths
if (filepath.size() == 0)
{
for (unsigned int i = 0; i < extraPaths.size(); ++i)
2004-09-09 16:41:05 +04:00
{
std::string filepathExtra =
cmSystemTools::GetFilenamePath(extraPaths[i]);
std::string filenameExtra =
cmSystemTools::GetFilenameName(extraPaths[i]);
cmCTestTestHandler::AddConfigurations(ctest,attempted,
attemptedConfigs,
filepathExtra,
filenameExtra);
2004-09-09 16:41:05 +04:00
}
}
// store the final location in fullPath
std::string fullPath;
2004-09-09 16:41:05 +04:00
// now look in the paths we specified above
for(unsigned int ai=0;
ai < attempted.size() && fullPath.size() == 0; ++ai)
{
// first check without exe extension
if(cmSystemTools::FileExists(attempted[ai].c_str())
&& !cmSystemTools::FileIsDirectory(attempted[ai].c_str()))
2004-09-09 16:41:05 +04:00
{
fullPath = cmSystemTools::CollapseFullPath(attempted[ai].c_str());
resultingConfig = attemptedConfigs[ai];
2004-09-09 16:41:05 +04:00
}
// then try with the exe extension
else
2004-09-09 16:41:05 +04:00
{
failed.push_back(attempted[ai].c_str());
tempPath = attempted[ai];
tempPath += cmSystemTools::GetExecutableExtension();
if(cmSystemTools::FileExists(tempPath.c_str())
&& !cmSystemTools::FileIsDirectory(tempPath.c_str()))
{
fullPath = cmSystemTools::CollapseFullPath(tempPath.c_str());
resultingConfig = attemptedConfigs[ai];
}
else
{
failed.push_back(tempPath.c_str());
}
2004-09-09 16:41:05 +04:00
}
}
// if everything else failed, check the users path, but only if a full path
// wasn't specified
if (fullPath.size() == 0 && filepath.size() == 0)
2004-09-09 16:41:05 +04:00
{
std::string path = cmSystemTools::FindProgram(filename.c_str());
2004-09-09 16:41:05 +04:00
if (path != "")
{
resultingConfig = "";
2004-09-09 16:41:05 +04:00
return path;
}
}
if(fullPath.size() == 0)
{
cmCTestLog(ctest, HANDLER_OUTPUT,
"Could not find executable " << testCommand << "\n"
<< "Looked in the following places:\n");
for(std::vector<std::string>::iterator i = failed.begin();
i != failed.end(); ++i)
{
cmCTestLog(ctest, HANDLER_OUTPUT,
i->c_str() << "\n");
}
}
2004-09-09 16:41:05 +04:00
return fullPath;
}
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
void cmCTestTestHandler::GetListOfTests()
2004-09-09 16:41:05 +04:00
{
if ( !this->IncludeLabelRegExp.empty() )
{
this->IncludeLabelRegularExpression.
compile(this->IncludeLabelRegExp.c_str());
}
if ( !this->IncludeLabelRegExp.empty() )
{
this->ExcludeLabelRegularExpression.
compile(this->ExcludeLabelRegExp.c_str());
}
2006-03-10 23:03:09 +03:00
if ( !this->IncludeRegExp.empty() )
{
2006-03-10 23:03:09 +03:00
this->IncludeTestsRegularExpression.compile(this->IncludeRegExp.c_str());
}
2006-03-10 23:03:09 +03:00
if ( !this->ExcludeRegExp.empty() )
{
2006-03-10 23:03:09 +03:00
this->ExcludeTestsRegularExpression.compile(this->ExcludeRegExp.c_str());
}
2006-03-10 23:03:09 +03:00
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
"Constructing a list of tests" << std::endl);
cmake cm;
cmGlobalGenerator gg;
gg.SetCMakeInstance(&cm);
std::auto_ptr<cmLocalGenerator> lg(gg.CreateLocalGenerator());
cmMakefile *mf = lg->GetMakefile();
2006-03-09 19:17:10 +03:00
mf->AddDefinition("CTEST_CONFIGURATION_TYPE",
2006-03-10 23:03:09 +03:00
this->CTest->GetConfigType().c_str());
// Add handler for ADD_TEST
cmCTestAddTestCommand* newCom1 = new cmCTestAddTestCommand;
2006-03-10 23:03:09 +03:00
newCom1->TestHandler = this;
cm.AddCommand(newCom1);
2008-01-19 23:09:36 +03:00
// Add handler for SUBDIRS
cmCTestSubdirCommand* newCom2 =
new cmCTestSubdirCommand;
2006-03-10 23:03:09 +03:00
newCom2->TestHandler = this;
cm.AddCommand(newCom2);
2008-01-19 23:09:36 +03:00
// Add handler for ADD_SUBDIRECTORY
cmCTestAddSubdirectoryCommand* newCom3 =
new cmCTestAddSubdirectoryCommand;
2006-03-10 23:03:09 +03:00
newCom3->TestHandler = this;
cm.AddCommand(newCom3);
2008-01-19 23:09:36 +03:00
// Add handler for SET_SOURCE_FILES_PROPERTIES
cmCTestSetTestsPropertiesCommand* newCom4
= new cmCTestSetTestsPropertiesCommand;
newCom4->TestHandler = this;
cm.AddCommand(newCom4);
2005-06-20 16:59:33 +04:00
const char* testFilename;
if( cmSystemTools::FileExists("CTestTestfile.cmake") )
{
// does the CTestTestfile.cmake exist ?
testFilename = "CTestTestfile.cmake";
}
2008-02-01 00:33:07 +03:00
else if( cmSystemTools::FileExists("DartTestfile.txt") )
{
// does the DartTestfile.txt exist ?
testFilename = "DartTestfile.txt";
}
else
2004-09-09 16:41:05 +04:00
{
return;
}
if ( !mf->ReadListFile(0, testFilename) )
2004-09-09 16:41:05 +04:00
{
return;
}
if ( cmSystemTools::GetErrorOccuredFlag() )
2004-09-09 16:41:05 +04:00
{
return;
2004-09-09 16:41:05 +04:00
}
2006-03-10 23:03:09 +03:00
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
2006-03-09 19:17:10 +03:00
"Done constructing a list of tests" << std::endl);
2004-09-09 16:41:05 +04:00
}
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
2004-09-09 16:41:05 +04:00
void cmCTestTestHandler::UseIncludeRegExp()
{
2006-03-10 23:03:09 +03:00
this->UseIncludeRegExpFlag = true;
2004-09-09 16:41:05 +04:00
}
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
2004-09-09 16:41:05 +04:00
void cmCTestTestHandler::UseExcludeRegExp()
{
2006-03-10 23:03:09 +03:00
this->UseExcludeRegExpFlag = true;
this->UseExcludeRegExpFirst = this->UseIncludeRegExpFlag ? false : true;
2004-09-09 16:41:05 +04:00
}
2006-03-09 19:17:10 +03:00
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
2004-09-09 16:41:05 +04:00
const char* cmCTestTestHandler::GetTestStatus(int status)
{
static const char statuses[][100] = {
"Not Run",
"Timeout",
"SEGFAULT",
"ILLEGAL",
"INTERRUPT",
"NUMERICAL",
"OTHER_FAULT",
"Failed",
"BAD_COMMAND",
"Completed"
};
2006-03-09 19:17:10 +03:00
if ( status < cmCTestTestHandler::NOT_RUN ||
2004-09-09 16:41:05 +04:00
status > cmCTestTestHandler::COMPLETED )
{
return "No Status";
}
return statuses[status];
}
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
2008-07-07 03:58:38 +04:00
void cmCTestTestHandler::ExpandTestsToRunInformation(size_t numTests)
2004-09-09 16:41:05 +04:00
{
if (this->TestsToRunString.empty())
{
return;
}
2006-03-09 19:17:10 +03:00
2004-09-09 16:41:05 +04:00
int start;
int end = -1;
double stride = -1;
std::string::size_type pos = 0;
std::string::size_type pos2;
// read start
if(GetNextNumber(this->TestsToRunString, start, pos, pos2))
{
// read end
if(GetNextNumber(this->TestsToRunString, end, pos, pos2))
{
// read stride
if(GetNextRealNumber(this->TestsToRunString, stride, pos, pos2))
{
int val =0;
// now read specific numbers
while(GetNextNumber(this->TestsToRunString, val, pos, pos2))
{
2006-03-10 23:03:09 +03:00
this->TestsToRun.push_back(val);
2004-09-09 16:41:05 +04:00
}
2006-03-10 23:03:09 +03:00
this->TestsToRun.push_back(val);
2004-09-09 16:41:05 +04:00
}
}
}
// if start is not specified then we assume we start at 1
if(start == -1)
{
start = 1;
}
// if end isnot specified then we assume we end with the last test
if(end == -1)
{
2008-07-07 06:06:08 +04:00
end = static_cast<int>(numTests);
2004-09-09 16:41:05 +04:00
}
2006-03-09 19:17:10 +03:00
2004-09-09 16:41:05 +04:00
// if the stride wasn't specified then it defaults to 1
if(stride == -1)
{
stride = 1;
}
// if we have a range then add it
if(end != -1 && start != -1 && stride > 0)
{
int i = 0;
while (i*stride + start <= end)
{
2006-03-10 23:03:09 +03:00
this->TestsToRun.push_back(static_cast<int>(i*stride+start));
2004-09-09 16:41:05 +04:00
++i;
}
}
// sort the array
2006-03-10 23:03:09 +03:00
std::sort(this->TestsToRun.begin(), this->TestsToRun.end(),
std::less<int>());
2004-09-09 16:41:05 +04:00
// remove duplicates
2006-03-09 19:17:10 +03:00
std::vector<int>::iterator new_end =
2006-03-10 23:03:09 +03:00
std::unique(this->TestsToRun.begin(), this->TestsToRun.end());
this->TestsToRun.erase(new_end, this->TestsToRun.end());
2004-09-09 16:41:05 +04:00
}
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
// Just for convenience
2004-09-09 16:41:05 +04:00
#define SPACE_REGEX "[ \t\r\n]"
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
2004-09-09 16:41:05 +04:00
std::string cmCTestTestHandler::GenerateRegressionImages(
const std::string& xml)
{
cmsys::RegularExpression twoattributes(
2006-03-09 19:17:10 +03:00
"<DartMeasurement"
SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
2004-09-09 16:41:05 +04:00
SPACE_REGEX "*>([^<]*)</DartMeasurement>");
cmsys::RegularExpression threeattributes(
2006-03-09 19:17:10 +03:00
"<DartMeasurement"
SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
2004-09-09 16:41:05 +04:00
SPACE_REGEX "*>([^<]*)</DartMeasurement>");
cmsys::RegularExpression fourattributes(
2006-03-09 19:17:10 +03:00
"<DartMeasurement"
SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
2004-09-09 16:41:05 +04:00
SPACE_REGEX "*>([^<]*)</DartMeasurement>");
2008-06-17 22:03:49 +04:00
cmsys::RegularExpression cdatastart(
"<DartMeasurement"
SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
2008-06-17 22:03:49 +04:00
SPACE_REGEX "*>"
SPACE_REGEX "*<!\\[CDATA\\[");
cmsys::RegularExpression cdataend(
"]]>"
SPACE_REGEX "*</DartMeasurement>");
2004-09-09 16:41:05 +04:00
cmsys::RegularExpression measurementfile(
2006-03-09 19:17:10 +03:00
"<DartMeasurementFile"
SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
SPACE_REGEX "*(name|type|encoding|compression)=\"([^\"]*)\""
2004-09-09 16:41:05 +04:00
SPACE_REGEX "*>([^<]*)</DartMeasurementFile>");
cmOStringStream ostr;
bool done = false;
std::string cxml = xml;
while ( ! done )
{
if ( twoattributes.find(cxml) )
{
ostr
2006-03-09 19:17:10 +03:00
<< "\t\t\t<NamedMeasurement"
<< " " << twoattributes.match(1) << "=\""
<< twoattributes.match(2) << "\""
<< " " << twoattributes.match(3) << "=\""
<< twoattributes.match(4) << "\""
<< "><Value>" << twoattributes.match(5)
<< "</Value></NamedMeasurement>"
2004-09-09 16:41:05 +04:00
<< std::endl;
2006-03-09 19:17:10 +03:00
cxml.erase(twoattributes.start(),
twoattributes.end() - twoattributes.start());
2004-09-09 16:41:05 +04:00
}
else if ( threeattributes.find(cxml) )
{
ostr
2006-03-09 19:17:10 +03:00
<< "\t\t\t<NamedMeasurement"
<< " " << threeattributes.match(1) << "=\""
<< threeattributes.match(2) << "\""
<< " " << threeattributes.match(3) << "=\""
<< threeattributes.match(4) << "\""
<< " " << threeattributes.match(5) << "=\""
<< threeattributes.match(6) << "\""
<< "><Value>" << threeattributes.match(7)
<< "</Value></NamedMeasurement>"
2004-09-09 16:41:05 +04:00
<< std::endl;
2006-03-09 19:17:10 +03:00
cxml.erase(threeattributes.start(),
threeattributes.end() - threeattributes.start());
2004-09-09 16:41:05 +04:00
}
else if ( fourattributes.find(cxml) )
{
ostr
2006-03-09 19:17:10 +03:00
<< "\t\t\t<NamedMeasurement"
<< " " << fourattributes.match(1) << "=\""
<< fourattributes.match(2) << "\""
<< " " << fourattributes.match(3) << "=\""
<< fourattributes.match(4) << "\""
<< " " << fourattributes.match(5) << "=\""
<< fourattributes.match(6) << "\""
<< " " << fourattributes.match(7) << "=\""
<< fourattributes.match(8) << "\""
<< "><Value>" << fourattributes.match(9)
<< "</Value></NamedMeasurement>"
2004-09-09 16:41:05 +04:00
<< std::endl;
2006-03-09 19:17:10 +03:00
cxml.erase(fourattributes.start(),
fourattributes.end() - fourattributes.start());
2004-09-09 16:41:05 +04:00
}
2008-06-17 22:03:49 +04:00
else if ( cdatastart.find(cxml) && cdataend.find(cxml) )
{
ostr
<< "\t\t\t<NamedMeasurement"
2008-06-17 22:03:49 +04:00
<< " " << cdatastart.match(1) << "=\""
<< cdatastart.match(2) << "\""
<< " " << cdatastart.match(3) << "=\""
<< cdatastart.match(4) << "\""
<< "><Value><![CDATA["
<< cxml.substr(cdatastart.end(), cdataend.start() - cdatastart.end())
<< "]]></Value></NamedMeasurement>"
<< std::endl;
2008-06-17 22:03:49 +04:00
cxml.erase(cdatastart.start(),
cdataend.end() - cdatastart.start());
}
2004-09-09 16:41:05 +04:00
else if ( measurementfile.find(cxml) )
{
2006-03-09 19:17:10 +03:00
const std::string& filename =
2004-09-09 16:41:05 +04:00
cmCTest::CleanString(measurementfile.match(5));
if ( cmSystemTools::FileExists(filename.c_str()) )
{
long len = cmSystemTools::FileLength(filename.c_str());
if ( len == 0 )
{
std::string k1 = measurementfile.match(1);
std::string v1 = measurementfile.match(2);
std::string k2 = measurementfile.match(3);
std::string v2 = measurementfile.match(4);
if ( cmSystemTools::LowerCase(k1) == "type" )
{
v1 = "text/string";
}
if ( cmSystemTools::LowerCase(k2) == "type" )
{
v2 = "text/string";
2006-03-09 19:17:10 +03:00
}
2004-09-09 16:41:05 +04:00
ostr
2006-03-09 19:17:10 +03:00
<< "\t\t\t<NamedMeasurement"
2004-09-09 16:41:05 +04:00
<< " " << k1 << "=\"" << v1 << "\""
<< " " << k2 << "=\"" << v2 << "\""
<< " encoding=\"none\""
2006-03-09 19:17:10 +03:00
<< "><Value>Image " << filename.c_str()
2004-09-09 16:41:05 +04:00
<< " is empty</Value></NamedMeasurement>";
}
else
{
2006-03-09 19:17:10 +03:00
std::ifstream ifs(filename.c_str(), std::ios::in
2004-09-09 16:41:05 +04:00
#ifdef _WIN32
| std::ios::binary
#endif
);
unsigned char *file_buffer = new unsigned char [ len + 1 ];
ifs.read(reinterpret_cast<char*>(file_buffer), len);
2006-03-09 19:17:10 +03:00
unsigned char *encoded_buffer
= new unsigned char [ static_cast<int>(len * 1.5 + 5) ];
unsigned long rlen
= cmsysBase64_Encode(file_buffer, len, encoded_buffer, 1);
2004-09-09 16:41:05 +04:00
unsigned long cc;
2006-03-09 19:17:10 +03:00
2004-09-09 16:41:05 +04:00
ostr
2006-03-09 19:17:10 +03:00
<< "\t\t\t<NamedMeasurement"
<< " " << measurementfile.match(1) << "=\""
<< measurementfile.match(2) << "\""
<< " " << measurementfile.match(3) << "=\""
<< measurementfile.match(4) << "\""
2004-09-09 16:41:05 +04:00
<< " encoding=\"base64\""
<< ">" << std::endl << "\t\t\t\t<Value>";
for ( cc = 0; cc < rlen; cc ++ )
{
ostr << encoded_buffer[cc];
if ( cc % 60 == 0 && cc )
{
ostr << std::endl;
}
}
ostr
2006-03-09 19:17:10 +03:00
<< "</Value>" << std::endl << "\t\t\t</NamedMeasurement>"
2004-09-09 16:41:05 +04:00
<< std::endl;
delete [] file_buffer;
delete [] encoded_buffer;
}
}
else
{
int idx = 4;
if ( measurementfile.match(1) == "name" )
{
idx = 2;
}
ostr
2006-03-09 19:17:10 +03:00
<< "\t\t\t<NamedMeasurement"
2004-09-09 16:41:05 +04:00
<< " name=\"" << measurementfile.match(idx) << "\""
<< " text=\"text/string\""
2006-03-09 19:17:10 +03:00
<< "><Value>File " << filename.c_str()
<< " not found</Value></NamedMeasurement>"
2004-09-09 16:41:05 +04:00
<< std::endl;
2006-03-10 23:03:09 +03:00
cmCTestLog(this->CTest, HANDLER_OUTPUT, "File \"" << filename.c_str()
2006-03-09 19:17:10 +03:00
<< "\" not found." << std::endl);
2004-09-09 16:41:05 +04:00
}
2006-03-09 19:17:10 +03:00
cxml.erase(measurementfile.start(),
measurementfile.end() - measurementfile.start());
2004-09-09 16:41:05 +04:00
}
else
{
done = true;
}
}
return ostr.str();
}
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
2004-09-09 16:41:05 +04:00
void cmCTestTestHandler::SetIncludeRegExp(const char *arg)
{
2006-03-10 23:03:09 +03:00
this->IncludeRegExp = arg;
2004-09-09 16:41:05 +04:00
}
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
2004-09-09 16:41:05 +04:00
void cmCTestTestHandler::SetExcludeRegExp(const char *arg)
{
2006-03-10 23:03:09 +03:00
this->ExcludeRegExp = arg;
2004-09-09 16:41:05 +04:00
}
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
2004-09-09 16:41:05 +04:00
void cmCTestTestHandler::SetTestsToRunInformation(const char* in)
{
if ( !in )
{
return;
}
2004-09-09 16:41:05 +04:00
this->TestsToRunString = in;
2006-03-09 19:17:10 +03:00
// if the argument is a file, then read it and use the contents as the
// string
2004-09-09 16:41:05 +04:00
if(cmSystemTools::FileExists(in))
{
std::ifstream fin(in);
unsigned long filelen = cmSystemTools::FileLength(in);
char* buff = new char[filelen+1];
fin.getline(buff, filelen);
buff[fin.gcount()] = 0;
this->TestsToRunString = buff;
}
}
2005-01-27 23:54:47 +03:00
//----------------------------------------------------------------------
2006-03-09 19:17:10 +03:00
bool cmCTestTestHandler::CleanTestOutput(std::string& output,
size_t remove_threshold)
{
if ( remove_threshold == 0 )
{
return true;
}
if ( output.find("CTEST_FULL_OUTPUT") != output.npos )
{
return true;
}
cmOStringStream ostr;
std::string::size_type cc;
std::string::size_type skipsize = 0;
int inTag = 0;
int skipped = 0;
for ( cc = 0; cc < output.size(); cc ++ )
{
int ch = output[cc];
if ( ch < 0 || ch > 255 )
{
break;
}
if ( ch == '<' )
{
inTag = 1;
}
if ( !inTag )
{
int notskip = 0;
// Skip
if ( skipsize < remove_threshold )
{
ostr << static_cast<char>(ch);
notskip = 1;
}
skipsize ++;
if ( notskip && skipsize >= remove_threshold )
{
skipped = 1;
}
}
else
{
ostr << static_cast<char>(ch);
}
if ( ch == '>' )
{
inTag = 0;
}
}
if ( skipped )
{
2006-03-09 19:17:10 +03:00
ostr << "..." << std::endl << "The rest of the test output was removed "
"since it exceeds the threshold of "
<< remove_threshold << " characters." << std::endl;
}
output = ostr.str();
return true;
}
//----------------------------------------------------------------------
2006-03-09 19:17:10 +03:00
bool cmCTestTestHandler::SetTestsProperties(
const std::vector<std::string>& args)
{
std::vector<std::string>::const_iterator it;
std::vector<cmStdString> tests;
bool found = false;
for ( it = args.begin(); it != args.end(); ++ it )
{
if ( *it == "PROPERTIES" )
{
found = true;
break;
}
tests.push_back(*it);
}
if ( !found )
{
return false;
}
++ it; // skip PROPERTIES
for ( ; it != args.end(); ++ it )
{
std::string key = *it;
++ it;
if ( it == args.end() )
{
break;
}
std::string val = *it;
std::vector<cmStdString>::const_iterator tit;
for ( tit = tests.begin(); tit != tests.end(); ++ tit )
{
2006-03-10 23:03:09 +03:00
cmCTestTestHandler::ListOfTests::iterator rtit;
for ( rtit = this->TestList.begin();
rtit != this->TestList.end();
++ rtit )
{
2006-03-10 23:03:09 +03:00
if ( *tit == rtit->Name )
{
if ( key == "WILL_FAIL" )
{
2006-03-10 23:03:09 +03:00
rtit->WillFail = cmSystemTools::IsOn(val.c_str());
}
if ( key == "ATTACHED_FILES" )
{
std::vector<std::string> lval;
cmSystemTools::ExpandListArgument(val.c_str(), lval);
for(std::vector<std::string>::iterator f = lval.begin();
f != lval.end(); ++f)
{
rtit->AttachedFiles.push_back(*f);
}
}
if ( key == "ATTACHED_FILES_ON_FAIL" )
{
std::vector<std::string> lval;
cmSystemTools::ExpandListArgument(val.c_str(), lval);
for(std::vector<std::string>::iterator f = lval.begin();
f != lval.end(); ++f)
{
rtit->AttachOnFail.push_back(*f);
}
}
2007-01-25 19:16:16 +03:00
if ( key == "TIMEOUT" )
{
rtit->Timeout = atof(val.c_str());
}
if ( key == "COST" )
2009-09-03 19:14:13 +04:00
{
2009-10-02 23:30:01 +04:00
rtit->Cost = static_cast<float>(atof(val.c_str()));
2009-09-03 19:14:13 +04:00
}
if ( key == "REQUIRED_FILES" )
{
std::vector<std::string> lval;
cmSystemTools::ExpandListArgument(val.c_str(), lval);
for(std::vector<std::string>::iterator f = lval.begin();
f != lval.end(); ++f)
{
rtit->RequiredFiles.push_back(*f);
}
}
if ( key == "RUN_SERIAL" )
{
rtit->RunSerial = cmSystemTools::IsOn(val.c_str());
}
if ( key == "FAIL_REGULAR_EXPRESSION" )
{
std::vector<std::string> lval;
cmSystemTools::ExpandListArgument(val.c_str(), lval);
std::vector<std::string>::iterator crit;
for ( crit = lval.begin(); crit != lval.end(); ++ crit )
{
2006-03-10 23:03:09 +03:00
rtit->ErrorRegularExpressions.push_back(
std::pair<cmsys::RegularExpression, std::string>(
cmsys::RegularExpression(crit->c_str()),
std::string(crit->c_str())));
}
}
if ( key == "PROCESSORS" )
{
rtit->Processors = atoi(val.c_str());
if(rtit->Processors < 1)
{
rtit->Processors = 1;
}
}
2008-07-03 17:31:33 +04:00
if ( key == "DEPENDS" )
{
2008-07-03 17:31:33 +04:00
std::vector<std::string> lval;
cmSystemTools::ExpandListArgument(val.c_str(), lval);
std::vector<std::string>::iterator crit;
for ( crit = lval.begin(); crit != lval.end(); ++ crit )
{
rtit->Depends.push_back(*crit);
}
}
if ( key == "ENVIRONMENT" )
{
std::vector<std::string> lval;
cmSystemTools::ExpandListArgument(val.c_str(), lval);
std::vector<std::string>::iterator crit;
for ( crit = lval.begin(); crit != lval.end(); ++ crit )
{
rtit->Environment.push_back(*crit);
}
}
if ( key == "LABELS" )
{
std::vector<std::string> lval;
cmSystemTools::ExpandListArgument(val.c_str(), lval);
std::vector<std::string>::iterator crit;
for ( crit = lval.begin(); crit != lval.end(); ++ crit )
{
rtit->Labels.push_back(*crit);
}
}
if ( key == "MEASUREMENT" )
{
size_t pos = val.find_first_of("=");
if ( pos != val.npos )
{
std::string mKey = val.substr(0, pos);
const char* mVal = val.c_str() + pos + 1;
rtit->Measurements[mKey] = mVal;
}
else
{
rtit->Measurements[val] = "1";
}
}
if ( key == "PASS_REGULAR_EXPRESSION" )
{
std::vector<std::string> lval;
cmSystemTools::ExpandListArgument(val.c_str(), lval);
std::vector<std::string>::iterator crit;
for ( crit = lval.begin(); crit != lval.end(); ++ crit )
{
2006-03-10 23:03:09 +03:00
rtit->RequiredRegularExpressions.push_back(
std::pair<cmsys::RegularExpression, std::string>(
cmsys::RegularExpression(crit->c_str()),
std::string(crit->c_str())));
}
}
}
}
}
}
return true;
}
//----------------------------------------------------------------------
bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args)
{
const std::string& testname = args[0];
2006-07-13 00:30:14 +04:00
cmCTestLog(this->CTest, DEBUG, "Add test: " << args[0] << std::endl);
2006-03-10 23:03:09 +03:00
if (this->UseExcludeRegExpFlag &&
this->UseExcludeRegExpFirst &&
this->ExcludeTestsRegularExpression.find(testname.c_str()))
{
return true;
}
2006-03-10 23:03:09 +03:00
if ( this->MemCheck )
{
std::vector<cmStdString>::iterator it;
bool found = false;
2006-03-10 23:03:09 +03:00
for ( it = this->CustomTestsIgnore.begin();
it != this->CustomTestsIgnore.end(); ++ it )
{
if ( *it == testname )
{
found = true;
break;
}
}
if ( found )
{
2006-03-10 23:03:09 +03:00
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Ignore memcheck: "
2006-03-09 19:17:10 +03:00
<< *it << std::endl);
return true;
}
}
else
{
std::vector<cmStdString>::iterator it;
bool found = false;
2006-03-10 23:03:09 +03:00
for ( it = this->CustomTestsIgnore.begin();
it != this->CustomTestsIgnore.end(); ++ it )
{
if ( *it == testname )
{
found = true;
break;
}
}
if ( found )
{
2006-03-10 23:03:09 +03:00
cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Ignore test: "
2006-03-09 19:17:10 +03:00
<< *it << std::endl);
return true;
}
}
cmCTestTestProperties test;
2006-03-10 23:03:09 +03:00
test.Name = testname;
test.Args = args;
test.Directory = cmSystemTools::GetCurrentWorkingDirectory();
2006-07-13 17:13:29 +04:00
cmCTestLog(this->CTest, DEBUG, "Set test directory: "
<< test.Directory << std::endl);
2006-03-10 23:03:09 +03:00
test.IsInBasedOnREOptions = true;
test.WillFail = false;
test.RunSerial = false;
2007-01-25 19:16:16 +03:00
test.Timeout = 0;
test.Cost = 0;
test.Processors = 1;
2006-03-10 23:03:09 +03:00
if (this->UseIncludeRegExpFlag &&
!this->IncludeTestsRegularExpression.find(testname.c_str()))
{
2006-03-10 23:03:09 +03:00
test.IsInBasedOnREOptions = false;
}
2006-03-10 23:03:09 +03:00
else if (this->UseExcludeRegExpFlag &&
!this->UseExcludeRegExpFirst &&
this->ExcludeTestsRegularExpression.find(testname.c_str()))
{
2006-03-10 23:03:09 +03:00
test.IsInBasedOnREOptions = false;
}
2006-03-10 23:03:09 +03:00
this->TestList.push_back(test);
return true;
}