CMake/Source/cmCTest.h

267 lines
6.9 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
2002-01-21 23:30:43 +03:00
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
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 cmMakefile;
2004-09-07 18:37:39 +04:00
class cmCTestBuildHandler;
2004-09-09 16:41:05 +04:00
class cmCTestConfigureHandler;
class cmCTestCoverageHandler;
2004-09-06 20:46:35 +04:00
class cmCTestScriptHandler;
2004-09-09 16:41:05 +04:00
class cmCTestTestHandler;
class cmCTestUpdateHandler;
2002-12-17 05:19:21 +03:00
class cmCTest
2001-08-23 19:12:19 +04:00
{
public:
typedef std::vector<cmStdString> tm_VectorOfStrings;
///! Process Command line arguments
int Run(std::vector<std::string>const&, std::string* output = 0);
/**
* Initialize and finalize testing
*/
int Initialize();
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
*/
2004-09-07 20:52:09 +04:00
static struct tm* GetNightlyTime(std::string str,
bool verbose,
bool tomorrowtag);
/*
* Is the tomorrow tag set?
*/
bool GetTomorrowTag() { return m_TomorrowTag; };
/**
* Try to run tests of the project
*/
int TestDirectory(bool memcheck);
2003-01-07 07:13:15 +03:00
/**
* Do submit testing results
*/
int SubmitResults();
std::string GetSubmitResultsPrefix();
2004-09-09 16:41:05 +04:00
///! what is the configuraiton type, e.g. Debug, Release etc.
std::string GetConfigType();
2003-01-07 07:13:15 +03:00
/**
* Check if CTest file exists
*/
bool CTestFileExists(const std::string& filename);
/**
* 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);
int GetTestModel() { return m_TestModel; };
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);
std::string GetDartConfiguration(const char *name);
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();
//! Set the notes files to be created.
void SetNotesFiles(const char* notes);
std::string m_ConfigType;
bool m_Verbose;
bool m_DartMode;
bool m_ForceNewCTestProcess;
2003-12-02 03:25:51 +03:00
bool m_RunConfigurationScript;
2003-02-11 05:52:01 +03:00
enum {
EXPERIMENTAL,
NIGHTLY,
CONTINUOUS
};
2004-09-06 20:46:35 +04:00
// 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
};
2004-09-06 20:46:35 +04:00
int GenerateNotesFile(const char* files);
2004-01-23 17:44:47 +03:00
bool OpenOutputFile(const std::string& path,
const std::string& name, std::ofstream& stream);
static std::string MakeXMLSafe(const std::string&);
static std::string MakeURLSafe(const std::string&);
/*
* return the current tag
*/
std::string GetCurrentTag();
///! Get the current time as string
std::string CurrentTime();
///! Should we only show what we would do?
bool GetShowOnly();
2004-09-09 16:41:05 +04:00
///! Are we producing XML
bool GetProduceXML();
//! Start CTest XML output file
void StartXML(std::ostream& ostr);
//! 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,
int* retVal, const char* dir, bool verbose, int timeout,
std::ofstream& ofs);
2004-09-07 18:37:39 +04:00
static void PopulateCustomVector(cmMakefile* mf, const char* definition,
tm_VectorOfStrings& vec);
2004-09-09 16:41:05 +04:00
std::string GetToplevelPath();
//! Run command specialized for tests. Returns process status and retVal is
// return value or exception.
int RunTest(std::vector<const char*> args, std::string* output, int *retVal,
std::ostream* logfile);
2001-08-23 19:12:19 +04:00
private:
// these are helper classes
2004-09-09 16:41:05 +04:00
cmCTestBuildHandler *BuildHandler;
cmCTestCoverageHandler *CoverageHandler;
cmCTestScriptHandler *ScriptHandler;
2004-09-09 16:41:05 +04:00
cmCTestTestHandler *TestHandler;
cmCTestUpdateHandler *UpdateHandler;
cmCTestConfigureHandler *ConfigureHandler;
2004-09-06 20:46:35 +04:00
bool m_ShowOnly;
enum {
2003-02-11 07:19:01 +03:00
FIRST_TEST = 0,
UPDATE_TEST = 1,
2003-03-20 00:35:02 +03:00
START_TEST = 2,
CONFIGURE_TEST = 3,
BUILD_TEST = 4,
TEST_TEST = 5,
COVERAGE_TEST = 6,
MEMCHECK_TEST = 7,
2003-03-20 00:35:02 +03:00
SUBMIT_TEST = 8,
NOTES_TEST = 9,
ALL_TEST = 10,
LAST_TEST = 11
};
2004-06-02 21:39:25 +04:00
//! Map of configuration properties
typedef std::map<std::string, std::string> tm_DartConfigurationMap;
std::string m_ToplevelPath;
tm_DartConfigurationMap m_DartConfiguration;
int m_Tests[LAST_TEST];
std::string m_CurrentTag;
2004-03-14 20:28:37 +03:00
bool m_TomorrowTag;
2002-10-09 06:00:11 +04:00
2003-02-11 17:19:36 +03:00
int m_TestModel;
2003-02-11 05:52:01 +03:00
double m_TimeOut;
2003-08-04 06:36:17 +04:00
int m_CompatibilityMode;
// information for the --build-and-test options
std::string m_ExecutableDirectory;
std::string m_CMakeSelf;
std::string m_CTestSelf;
std::string m_SourceDir;
std::string m_BinaryDir;
std::string m_BuildRunDir;
std::string m_BuildGenerator;
std::string m_BuildMakeProgram;
std::string m_BuildProject;
std::string m_BuildTarget;
std::vector<std::string> m_BuildOptions;
std::string m_TestCommand;
std::vector<std::string> m_TestCommandArgs;
bool m_BuildTwoConfig;
bool m_BuildNoClean;
2004-01-13 19:22:47 +03:00
bool m_BuildNoCMake;
std::string m_NotesFiles;
int ReadCustomConfigurationFileTree(const char* dir);
bool m_InteractiveDebugMode;
2004-08-26 17:45:20 +04:00
bool m_ShortDateFormat;
void BlockTestErrorDiagnostics();
//! Reread the configuration file
void UpdateCTestConfiguration();
//! Create not from files.
int GenerateDartNotesOutput(std::ostream& os, const tm_VectorOfStrings& files);
///! Run CMake and build a test and then run it as a single test.
int RunCMakeAndTest(std::string* output);
///! Find the running cmake
void FindRunningCMake(const char* arg0);
2001-08-23 19:12:19 +04:00
};
2003-02-11 05:52:01 +03:00
#endif