CMake/Source/cmCTest.h

514 lines
14 KiB
C
Raw Normal View History

2001-08-23 19:12:19 +04:00
/*=========================================================================
Program: CMake - Cross-Platform Makefile Generator
2001-08-23 19:12:19 +04:00
Module: $RCSfile$
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
2001-08-23 19:12:19 +04:00
2006-03-09 19:57:43 +03:00
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
2002-01-21 23:30:43 +03:00
PURPOSE. See the above copyright notices for more information.
2001-08-23 19:12:19 +04:00
=========================================================================*/
2003-02-11 05:52:01 +03:00
#ifndef cmCTest_h
#define cmCTest_h
2001-08-23 19:12:19 +04:00
#include "cmStandardIncludes.h"
#include "cmListFileCache.h"
2004-09-07 20:54:15 +04:00
#include <time.h>
2002-05-22 17:47:41 +04:00
class cmake;
class cmMakefile;
2005-01-27 23:54:47 +03:00
class cmCTestGenericHandler;
class cmGeneratedFileStream;
class cmCTestCommand;
class cmCTestScriptHandler;
#define cmCTestLog(ctSelf, logType, msg) \
do { \
cmOStringStream cmCTestLog_msg; \
cmCTestLog_msg << msg; \
2006-03-09 19:57:43 +03:00
(ctSelf)->Log(cmCTest::logType, __FILE__, __LINE__,\
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
2002-12-17 05:19:21 +03:00
class cmCTest
2001-08-23 19:12:19 +04:00
{
public:
/** Enumerate parts of the testing and submission process. */
enum Part
{
PartStart,
PartUpdate,
PartConfigure,
PartBuild,
PartTest,
PartCoverage,
PartMemCheck,
PartSubmit,
PartNotes,
PartExtraFiles,
PartCount // Update names in constructor when adding a part
};
/** Representation of one part. */
struct PartInfo
{
PartInfo(): Enabled(false) {}
void SetName(const char* name) { this->Name = name; }
const char* GetName() const { return this->Name.c_str(); }
void Enable() { this->Enabled = true; }
operator bool() const { return this->Enabled; }
std::vector<std::string> SubmitFiles;
private:
bool Enabled;
std::string Name;
};
/** Get a testing part id from its string name. Returns PartCount
if the string does not name a valid part. */
Part GetPartFromName(const char* name);
2006-03-10 23:03:09 +03:00
typedef std::vector<cmStdString> VectorOfStrings;
typedef std::set<cmStdString> SetOfStrings;
///! Process Command line arguments
int Run(std::vector<std::string> &, std::string* output = 0);
2006-03-09 19:57:43 +03:00
/**
* Initialize and finalize testing
*/
2006-03-09 19:57:43 +03:00
int Initialize(const char* binary_dir, bool new_tag = false,
bool verbose_tag = true);
bool InitializeFromCommand(cmCTestCommand* command, bool first = false);
void Finalize();
/**
* Process the tests. This is the main routine. The execution of the
* tests should look like this:
*
* ctest foo;
* foo.Initialize();
* // Set some things on foo
* foo.ProcessTests();
* foo.Finalize();
*/
int ProcessTests();
/*
* A utility function that returns the nightly time
*/
2006-03-09 19:57:43 +03:00
struct tm* GetNightlyTime(std::string str,
bool tomorrowtag);
2006-03-09 19:57:43 +03:00
/*
* Is the tomorrow tag set?
*/
2006-03-15 19:02:08 +03:00
bool GetTomorrowTag() { return this->TomorrowTag; };
2006-03-09 19:57:43 +03:00
/**
* Try to run tests of the project
*/
int TestDirectory(bool memcheck);
2004-09-09 16:41:05 +04:00
///! what is the configuraiton type, e.g. Debug, Release etc.
std::string const& GetConfigType();
2006-03-15 19:02:08 +03:00
double GetTimeOut() { return this->TimeOut; }
void SetTimeOut(double t) { this->TimeOut = t; }
2008-07-03 17:31:33 +04:00
// how many test to run at the same time
int GetParallelLevel() { return this->ParallelLevel; }
void SetParallelLevel(int t) { this->ParallelLevel = t; }
bool GetParallelSubprocess() { return this->ParallelSubprocess; }
void SetParallelSubprocess() { this->ParallelSubprocess = true; }
void SetParallelSubprocessId(int id) { this->ParallelSubprocessId = id;}
int GetParallelSubprocessId() { return this->ParallelSubprocessId;}
const char* GetParallelCacheFile()
{ return this->ParallelCacheFile.c_str();}
void SetParallelCacheFile(const char* c) { this->ParallelCacheFile = c; }
2006-03-09 19:57:43 +03:00
2003-01-07 07:13:15 +03:00
/**
* Check if CTest file exists
*/
bool CTestFileExists(const std::string& filename);
bool AddIfExists(Part part, const char* file);
2003-01-07 07:13:15 +03:00
/**
* Set the cmake test
*/
bool SetTest(const char*, bool report = true);
2003-02-11 05:52:01 +03:00
/**
* Set the cmake test mode (experimental, nightly, continuous).
*/
void SetTestModel(int mode);
2006-03-15 19:02:08 +03:00
int GetTestModel() { return this->TestModel; };
2006-03-09 19:57:43 +03:00
2003-02-11 05:52:01 +03:00
std::string GetTestModelString();
static int GetTestModelFromString(const char* str);
2004-09-09 16:41:05 +04:00
static std::string CleanString(const std::string& str);
2005-05-03 17:40:16 +04:00
std::string GetCTestConfiguration(const char *name);
void SetCTestConfiguration(const char *name, const char* value);
void EmptyCTestConfiguration();
2006-03-09 19:57:43 +03:00
2001-08-23 19:12:19 +04:00
/**
2004-09-06 20:46:35 +04:00
* constructor and destructor
2001-08-23 19:12:19 +04:00
*/
2002-12-17 05:19:21 +03:00
cmCTest();
2004-09-06 20:46:35 +04:00
~cmCTest();
2006-03-09 19:57:43 +03:00
//! Set the notes files to be created.
void SetNotesFiles(const char* notes);
void PopulateCustomVector(cmMakefile* mf, const char* definition,
VectorOfStrings& vec);
void PopulateCustomInteger(cmMakefile* mf, const char* def,
2006-03-09 19:57:43 +03:00
int& val);
2004-01-23 17:44:47 +03:00
///! Get the current time as string
std::string CurrentTime();
2006-03-09 19:57:43 +03:00
/**
* Return the time remaianing that the script is allowed to run in
* seconds if the user has set the variable CTEST_TIME_LIMIT. If that has
* not been set it returns 1e7 seconds
*/
double GetRemainingTimeAllowed();
///! Open file in the output directory and set the stream
2006-03-09 19:57:43 +03:00
bool OpenOutputFile(const std::string& path,
const std::string& name,
cmGeneratedFileStream& stream,
bool compress = false);
///! Convert string to something that is XML safe
static std::string MakeXMLSafe(const std::string&);
///! Should we only show what we would do?
bool GetShowOnly();
///! The max output width
int GetMaxTestNameWidth() const;
2009-01-09 20:32:52 +03:00
void SetMaxTestNameWidth(int w) { this->MaxTestNameWidth = w;}
/**
2006-03-09 19:57:43 +03:00
* Run a single executable command and put the stdout and stderr
* in output.
*
* If verbose is false, no user-viewable output from the program
* being run will be generated.
*
* If timeout is specified, the command will be terminated after
* timeout expires. Timeout is specified in seconds.
*
* Argument retVal should be a pointer to the location where the
2006-03-09 19:57:43 +03:00
* exit code will be stored. If the retVal is not specified and
* the program exits with a code other than 0, then the this
* function will return false.
*
* If the command has spaces in the path the caller MUST call
* cmSystemTools::ConvertToRunCommandPath on the command before passing
* it into this function or it will not work. The command must be correctly
2006-03-09 19:57:43 +03:00
* escaped for this to with spaces.
*/
bool RunCommand(const char* command,
std::string* stdOut, std::string* stdErr,
int* retVal = 0, const char* dir = 0, double timeout = 0.0);
2006-03-09 19:57:43 +03:00
//! Start CTest XML output file
void StartXML(std::ostream& ostr, bool append);
//! End CTest XML output file
void EndXML(std::ostream& ostr);
//! Run command specialized for make and configure. Returns process status
// and retVal is return value or exception.
int RunMakeCommand(const char* command, std::string* output,
2006-03-09 19:57:43 +03:00
int* retVal, const char* dir, int timeout,
std::ofstream& ofs);
/*
* return the current tag
*/
std::string GetCurrentTag();
2004-09-07 18:37:39 +04:00
//! Get the path to the build tree
std::string GetBinaryDir();
2006-03-09 19:57:43 +03:00
//! Get the short path to the file. This means if the file is in binary or
//source directory, it will become /.../relative/path/to/file
std::string GetShortPathToFile(const char* fname);
//! Get the path to CTest
2006-03-15 19:02:08 +03:00
const char* GetCTestExecutable() { return this->CTestSelf.c_str(); }
const char* GetCMakeExecutable() { return this->CMakeSelf.c_str(); }
enum {
EXPERIMENTAL,
NIGHTLY,
CONTINUOUS
};
// provide some more detailed info on the return code for ctest
enum {
UPDATE_ERRORS = 0x01,
CONFIGURE_ERRORS = 0x02,
BUILD_ERRORS = 0x04,
TEST_ERRORS = 0x08,
MEMORY_ERRORS = 0x10,
COVERAGE_ERRORS = 0x20,
SUBMIT_ERRORS = 0x40
};
///! Are we producing XML
bool GetProduceXML();
void SetProduceXML(bool v);
2004-09-09 16:41:05 +04:00
//! Run command specialized for tests. Returns process status and retVal is
// return value or exception. If environment is non-null, it is used to set
// environment variables prior to running the test. After running the test,
// environment variables are restored to their previous values.
2006-03-09 19:57:43 +03:00
int RunTest(std::vector<const char*> args, std::string* output, int *retVal,
std::ostream* logfile, double testTimeOut,
std::vector<std::string>* environment);
2004-09-09 16:41:05 +04:00
/**
2006-03-09 19:57:43 +03:00
* Execute handler and return its result. If the handler fails, it returns
* negative value.
*/
int ExecuteHandler(const char* handler);
2006-03-09 19:57:43 +03:00
/*
* Get the handler object
*/
cmCTestGenericHandler* GetHandler(const char* handler);
cmCTestGenericHandler* GetInitializedHandler(const char* handler);
/*
* Set the CTest variable from CMake variable
*/
2006-03-09 19:57:43 +03:00
bool SetCTestConfigurationFromCMakeVariable(cmMakefile* mf,
const char* dconfig, const char* cmake_var);
//! Make string safe to be send as an URL
static std::string MakeURLSafe(const std::string&);
2006-03-09 19:57:43 +03:00
//! Should ctect configuration be updated. When using new style ctest
// script, this should be true.
void SetSuppressUpdatingCTestConfiguration(bool val)
{
2006-03-15 19:02:08 +03:00
this->SuppressUpdatingCTestConfiguration = val;
}
//! Add overwrite to ctest configuration.
// The format is key=value
void AddCTestConfigurationOverwrite(const char* encstr);
//! Create XML file that contains all the notes specified
int GenerateNotesFile(const std::vector<cmStdString> &files);
//! Submit extra files to the server
bool SubmitExtraFiles(const char* files);
bool SubmitExtraFiles(const std::vector<cmStdString> &files);
//! Set the output log file name
void SetOutputLogFileName(const char* name);
//! Set the visual studio or Xcode config type
void SetConfigType(const char* ct);
//! Various log types
enum {
DEBUG = 0,
OUTPUT,
HANDLER_OUTPUT,
HANDLER_VERBOSE_OUTPUT,
WARNING,
ERROR_MESSAGE,
OTHER
};
//! Add log to the output
void Log(int logType, const char* file, int line, const char* msg);
//! Get the version of dart server
2006-03-15 19:02:08 +03:00
int GetDartVersion() { return this->DartVersion; }
//! Add file to be submitted
void AddSubmitFile(Part part, const char* name);
std::vector<std::string> const& GetSubmitFiles(Part part)
{ return this->Parts[part].SubmitFiles; }
2006-03-29 00:20:03 +04:00
//! Read the custom configuration files and apply them to the current ctest
int ReadCustomConfigurationFileTree(const char* dir, cmMakefile* mf);
2006-03-29 00:20:03 +04:00
std::vector<cmStdString> &GetInitialCommandLineArguments()
{ return this->InitialCommandLineArguments; };
//! Set the track to submit to
void SetSpecificTrack(const char* track);
const char* GetSpecificTrack();
2008-07-03 17:31:33 +04:00
bool GetVerbose() { return this->Verbose;}
bool GetExtraVerbose() { return this->ExtraVerbose;}
/** Direct process output to given streams. */
void SetStreams(std::ostream* out, std::ostream* err)
{ this->StreamOut = out; this->StreamErr = err; }
void AddSiteProperties(std::ostream& );
private:
2006-03-15 19:02:08 +03:00
std::string ConfigType;
bool Verbose;
bool ExtraVerbose;
bool ProduceXML;
2006-03-15 19:02:08 +03:00
bool ForceNewCTestProcess;
2006-03-15 19:02:08 +03:00
bool RunConfigurationScript;
int GenerateNotesFile(const char* files);
// these are helper classes
2005-01-27 23:54:47 +03:00
typedef std::map<cmStdString,cmCTestGenericHandler*> t_TestingHandlers;
2006-03-15 19:02:08 +03:00
t_TestingHandlers TestingHandlers;
2006-03-09 19:57:43 +03:00
2006-03-15 19:02:08 +03:00
bool ShowOnly;
2004-06-02 21:39:25 +04:00
//! Map of configuration properties
2006-03-10 23:03:09 +03:00
typedef std::map<cmStdString, cmStdString> CTestConfigurationMap;
2006-03-15 19:02:08 +03:00
std::string CTestConfigFile;
CTestConfigurationMap CTestConfiguration;
CTestConfigurationMap CTestConfigurationOverwrites;
PartInfo Parts[PartCount];
typedef std::map<cmStdString, Part> PartMapType;
PartMapType PartMap;
2006-03-09 19:57:43 +03:00
2006-03-15 19:02:08 +03:00
std::string CurrentTag;
bool TomorrowTag;
2002-10-09 06:00:11 +04:00
2006-03-15 19:02:08 +03:00
int TestModel;
std::string SpecificTrack;
2003-02-11 05:52:01 +03:00
2006-03-15 19:02:08 +03:00
double TimeOut;
2003-08-04 06:36:17 +04:00
int MaxTestNameWidth;
2008-07-03 17:31:33 +04:00
std::string ParallelCacheFile;
int ParallelLevel;
int ParallelSubprocessId;
bool ParallelSubprocess;
2006-03-15 19:02:08 +03:00
int CompatibilityMode;
// information for the --build-and-test options
2006-03-15 19:02:08 +03:00
std::string CMakeSelf;
std::string CTestSelf;
std::string BinaryDir;
2006-03-15 19:02:08 +03:00
std::string NotesFiles;
2006-03-09 19:57:43 +03:00
2006-03-15 19:02:08 +03:00
bool InteractiveDebugMode;
2004-08-26 17:45:20 +04:00
2006-03-15 19:02:08 +03:00
bool ShortDateFormat;
2006-03-15 19:02:08 +03:00
bool CompressXMLFiles;
2006-03-09 19:57:43 +03:00
void InitStreams();
std::ostream* StreamOut;
std::ostream* StreamErr;
void BlockTestErrorDiagnostics();
2006-03-09 19:57:43 +03:00
//! parse the option after -D and convert it into the appropriate steps
bool AddTestsForDashboardType(std::string &targ);
//! parse and process most common command line arguments
void HandleCommandLineArguments(size_t &i,
std::vector<std::string> &args);
//! hande the -S -SP and -SR arguments
void HandleScriptArguments(size_t &i,
std::vector<std::string> &args,
bool &SRArgumentSpecified);
//! Reread the configuration file
bool UpdateCTestConfiguration();
//! Create not from files.
2006-03-09 19:57:43 +03:00
int GenerateCTestNotesOutput(std::ostream& os,
2006-03-10 23:03:09 +03:00
const VectorOfStrings& files);
///! Find the running cmake
void FindRunningCMake();
//! Check if the argument is the one specified
2006-03-09 19:57:43 +03:00
bool CheckArgument(const std::string& arg, const char* varg1,
const char* varg2 = 0);
//! Output errors from a test
void OutputTestErrors(std::vector<char> const &process_output);
2006-03-15 19:02:08 +03:00
bool SuppressUpdatingCTestConfiguration;
2006-03-15 19:02:08 +03:00
bool Debug;
bool ShowLineNumbers;
bool Quiet;
2006-03-15 19:02:08 +03:00
int DartVersion;
2006-03-15 19:02:08 +03:00
std::set<cmStdString> SubmitFiles;
std::vector<cmStdString> InitialCommandLineArguments;
2006-03-15 19:02:08 +03:00
int SubmitIndex;
2006-03-09 19:57:43 +03:00
2006-03-15 19:02:08 +03:00
cmGeneratedFileStream* OutputLogFile;
int OutputLogFileLastTag;
bool OutputTestOutputOnTestFailure;
2001-08-23 19:12:19 +04:00
};
class cmCTestLogWrite
{
public:
2006-03-09 19:57:43 +03:00
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)
{
2006-03-01 00:17:27 +03:00
if (!c.Length)
{
return os;
}
os.write(c.Data, c.Length);
os.flush();
return os;
}
2003-02-11 05:52:01 +03:00
#endif