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

Merge topic 'include-what-you-use' 

38491644 CTest: fix include-what-you-use violations
This commit is contained in:
Brad King 2016-08-25 09:50:45 -04:00 committed by CMake Topic Stage
parent a79abb82fe 3849164454
commit 98caa14cc8
93 changed files with 647 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Source/CTest/cmCTestBZR.cxx
View File

@ -12,12 +12,18 @@
#include "cmCTestBZR.h" #include "cmCTestBZR.h"
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestVC.h"
#include "cmProcessTools.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include "cmXMLParser.h" #include "cmXMLParser.h"
#include <cmsys/RegularExpression.hxx>
#include <cm_expat.h> #include <cm_expat.h>
#include <cmsys/RegularExpression.hxx>
#include <list>
#include <map>
#include <ostream>
#include <stdlib.h>
#include <vector>
extern "C" int cmBZRXMLParserUnknownEncodingHandler(void* /*unused*/, extern "C" int cmBZRXMLParserUnknownEncodingHandler(void* /*unused*/,
const XML_Char* name, const XML_Char* name,

14
Source/CTest/cmCTestBZR.h
View File

@ -12,8 +12,15 @@
#ifndef cmCTestBZR_h #ifndef cmCTestBZR_h
#define cmCTestBZR_h #define cmCTestBZR_h
#include <cmConfigure.h>
#include "cmCTestGlobalVC.h" #include "cmCTestGlobalVC.h"
#include <iosfwd>
#include <string>
class cmCTest;
/** \class cmCTestBZR /** \class cmCTestBZR
* \brief Interaction with bzr command-line tool * \brief Interaction with bzr command-line tool
* *
@ -41,13 +48,14 @@ private:
// Parsing helper classes. // Parsing helper classes.
class InfoParser; class InfoParser;
class RevnoParser;
class LogParser; class LogParser;
class UpdateParser; class RevnoParser;
class StatusParser; class StatusParser;
class UpdateParser;
friend class InfoParser; friend class InfoParser;
friend class RevnoParser;
friend class LogParser; friend class LogParser;
friend class RevnoParser;
friend class UpdateParser; friend class UpdateParser;
friend class StatusParser; friend class StatusParser;
}; };

8
Source/CTest/cmCTestBatchTestHandler.cxx
View File

@ -13,10 +13,14 @@
#include "cmCTestBatchTestHandler.h" #include "cmCTestBatchTestHandler.h"
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestMultiProcessHandler.h"
#include "cmCTestTestHandler.h"
#include "cmProcess.h" #include "cmProcess.h"
#include "cmStandardIncludes.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include <stdlib.h>
#include <map>
#include <utility>
#include <vector>
cmCTestBatchTestHandler::~cmCTestBatchTestHandler() cmCTestBatchTestHandler::~cmCTestBatchTestHandler()
{ {

5
Source/CTest/cmCTestBatchTestHandler.h
View File

@ -13,12 +13,11 @@
#ifndef cmCTestBatchTestHandler_h #ifndef cmCTestBatchTestHandler_h
#define cmCTestBatchTestHandler_h #define cmCTestBatchTestHandler_h
#include <cmStandardIncludes.h> #include <cmConfigure.h>
#include <cmCTestMultiProcessHandler.h> #include <cmCTestMultiProcessHandler.h>
#include <cmCTestRunTest.h>
#include <cmCTestTestHandler.h>
#include <cmsys/FStream.hxx> #include <cmsys/FStream.hxx>
#include <string>
/** \class cmCTestBatchTestHandler /** \class cmCTestBatchTestHandler
* \brief run parallel ctest * \brief run parallel ctest

2
Source/CTest/cmCTestBuildAndTestHandler.cxx
View File

@ -17,7 +17,9 @@
#include "cmGlobalGenerator.h" #include "cmGlobalGenerator.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include "cmake.h" #include "cmake.h"
#include <cmsys/Process.h> #include <cmsys/Process.h>
#include <stdlib.h>
cmCTestBuildAndTestHandler::cmCTestBuildAndTestHandler() cmCTestBuildAndTestHandler::cmCTestBuildAndTestHandler()
{ {

9
Source/CTest/cmCTestBuildAndTestHandler.h
View File

@ -13,8 +13,15 @@
#ifndef cmCTestBuildAndTestHandler_h #ifndef cmCTestBuildAndTestHandler_h
#define cmCTestBuildAndTestHandler_h #define cmCTestBuildAndTestHandler_h
#include <cmConfigure.h>
#include "cmCTestGenericHandler.h" #include "cmCTestGenericHandler.h"
#include "cmListFileCache.h" #include "cmTypeMacro.h"
#include <sstream>
#include <stddef.h>
#include <string>
#include <vector>
class cmake; class cmake;

7
Source/CTest/cmCTestBuildCommand.cxx
View File

@ -15,8 +15,15 @@
#include "cmCTestBuildHandler.h" #include "cmCTestBuildHandler.h"
#include "cmCTestGenericHandler.h" #include "cmCTestGenericHandler.h"
#include "cmGlobalGenerator.h" #include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmSystemTools.h"
#include "cmake.h" #include "cmake.h"
#include <sstream>
#include <string.h>
class cmExecutionStatus;
cmCTestBuildCommand::cmCTestBuildCommand() cmCTestBuildCommand::cmCTestBuildCommand()
{ {
this->GlobalGenerator = CM_NULLPTR; this->GlobalGenerator = CM_NULLPTR;

13
Source/CTest/cmCTestBuildCommand.h
View File

@ -12,10 +12,19 @@
#ifndef cmCTestBuildCommand_h #ifndef cmCTestBuildCommand_h
#define cmCTestBuildCommand_h #define cmCTestBuildCommand_h
#include "cmCTestHandlerCommand.h" #include <cmConfigure.h>
#include "cmCTestHandlerCommand.h"
#include "cmTypeMacro.h"
#include <string>
#include <vector>
class cmGlobalGenerator;
class cmCTestBuildHandler; class cmCTestBuildHandler;
class cmCTestGenericHandler;
class cmCommand;
class cmExecutionStatus;
class cmGlobalGenerator;
/** \class cmCTestBuild /** \class cmCTestBuild
* \brief Run a ctest script * \brief Run a ctest script

15
Source/CTest/cmCTestBuildHandler.cxx
View File

@ -16,25 +16,16 @@
#include "cmCTest.h" #include "cmCTest.h"
#include "cmFileTimeComparison.h" #include "cmFileTimeComparison.h"
#include "cmGeneratedFileStream.h" #include "cmGeneratedFileStream.h"
#include "cmGlobalGenerator.h"
#include "cmMakefile.h" #include "cmMakefile.h"
#include "cmSystemTools.h"
#include "cmXMLWriter.h" #include "cmXMLWriter.h"
#include "cmake.h"
//#include <cmsys/RegularExpression.hxx>
#include <cmsys/Directory.hxx> #include <cmsys/Directory.hxx>
#include <cmsys/FStream.hxx> #include <cmsys/FStream.hxx>
#include <cmsys/Process.h> #include <cmsys/Process.h>
#include <set>
// used for sleep
#ifdef _WIN32
#include "windows.h"
#endif
#include <float.h>
#include <math.h>
#include <stdlib.h> #include <stdlib.h>
#include <time.h> #include <string.h>
static const char* cmCTestErrorMatches[] = { static const char* cmCTestErrorMatches[] = {
"^[Bb]us [Ee]rror", "^[Bb]us [Ee]rror",

11
Source/CTest/cmCTestBuildHandler.h
View File

@ -13,13 +13,17 @@
#ifndef cmCTestBuildHandler_h #ifndef cmCTestBuildHandler_h
#define cmCTestBuildHandler_h #define cmCTestBuildHandler_h
#include "cmCTestGenericHandler.h" #include <cmConfigure.h>
#include "cmListFileCache.h" #include "cmCTestGenericHandler.h"
#include "cmTypeMacro.h"
#include <cmsys/RegularExpression.hxx> #include <cmsys/RegularExpression.hxx>
#include <deque> #include <deque>
#include <iosfwd>
#include <stddef.h>
#include <string>
#include <vector>
class cmMakefile; class cmMakefile;
class cmXMLWriter; class cmXMLWriter;
@ -148,6 +152,7 @@ private:
bool UseCTestLaunch; bool UseCTestLaunch;
std::string CTestLaunchDir; std::string CTestLaunchDir;
class LaunchHelper; class LaunchHelper;
friend class LaunchHelper; friend class LaunchHelper;
class FragmentCompare; class FragmentCompare;
}; };

2
Source/CTest/cmCTestCVS.cxx
View File

@ -12,11 +12,13 @@
#include "cmCTestCVS.h" #include "cmCTestCVS.h"
#include "cmCTest.h" #include "cmCTest.h"
#include "cmProcessTools.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include "cmXMLWriter.h" #include "cmXMLWriter.h"
#include <cmsys/FStream.hxx> #include <cmsys/FStream.hxx>
#include <cmsys/RegularExpression.hxx> #include <cmsys/RegularExpression.hxx>
#include <utility>
cmCTestCVS::cmCTestCVS(cmCTest* ct, std::ostream& log) cmCTestCVS::cmCTestCVS(cmCTest* ct, std::ostream& log)
: cmCTestVC(ct, log) : cmCTestVC(ct, log)

12
Source/CTest/cmCTestCVS.h
View File

@ -12,11 +12,18 @@
#ifndef cmCTestCVS_h #ifndef cmCTestCVS_h
#define cmCTestCVS_h #define cmCTestCVS_h
#include <cmConfigure.h>
#include "cmCTestVC.h" #include "cmCTestVC.h"
#include <iosfwd>
#include <map> #include <map>
#include <string>
#include <vector> #include <vector>
class cmCTest;
class cmXMLWriter;
/** \class cmCTestCVS /** \class cmCTestCVS
* \brief Interaction with cvs command-line tool * \brief Interaction with cvs command-line tool
* *
@ -47,10 +54,11 @@ private:
Directory const& dir); Directory const& dir);
// Parsing helper classes. // Parsing helper classes.
class UpdateParser;
class LogParser; class LogParser;
friend class UpdateParser; class UpdateParser;
friend class LogParser; friend class LogParser;
friend class UpdateParser;
}; };
#endif #endif

7
Source/CTest/cmCTestConfigureCommand.cxx
View File

@ -14,6 +14,13 @@
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestGenericHandler.h" #include "cmCTestGenericHandler.h"
#include "cmGlobalGenerator.h" #include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmSystemTools.h"
#include "cmake.h"
#include <sstream>
#include <string.h>
#include <vector>
cmCTestConfigureCommand::cmCTestConfigureCommand() cmCTestConfigureCommand::cmCTestConfigureCommand()
{ {

8
Source/CTest/cmCTestConfigureCommand.h
View File

@ -12,7 +12,15 @@
#ifndef cmCTestConfigureCommand_h #ifndef cmCTestConfigureCommand_h
#define cmCTestConfigureCommand_h #define cmCTestConfigureCommand_h
#include <cmConfigure.h>
#include "cmCTestHandlerCommand.h" #include "cmCTestHandlerCommand.h"
#include "cmTypeMacro.h"
#include <string>
class cmCTestGenericHandler;
class cmCommand;
/** \class cmCTestConfigure /** \class cmCTestConfigure
* \brief Run a ctest script * \brief Run a ctest script

6
Source/CTest/cmCTestConfigureHandler.cxx
View File

@ -14,9 +14,11 @@
#include "cmCTest.h" #include "cmCTest.h"
#include "cmGeneratedFileStream.h" #include "cmGeneratedFileStream.h"
#include "cmSystemTools.h"
#include "cmXMLWriter.h" #include "cmXMLWriter.h"
#include "cmake.h"
#include <cmsys/Process.h> #include <ostream>
#include <string>
cmCTestConfigureHandler::cmCTestConfigureHandler() cmCTestConfigureHandler::cmCTestConfigureHandler()
{ {

5
Source/CTest/cmCTestConfigureHandler.h
View File

@ -13,9 +13,10 @@
#ifndef cmCTestConfigureHandler_h #ifndef cmCTestConfigureHandler_h
#define cmCTestConfigureHandler_h #define cmCTestConfigureHandler_h
#include "cmCTestGenericHandler.h" #include <cmConfigure.h>
#include "cmListFileCache.h" #include "cmCTestGenericHandler.h"
#include "cmTypeMacro.h"
/** \class cmCTestConfigureHandler /** \class cmCTestConfigureHandler
* \brief A class that handles ctest -S invocations * \brief A class that handles ctest -S invocations

2
Source/CTest/cmCTestCoverageCommand.cxx
View File

@ -14,6 +14,8 @@
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestCoverageHandler.h" #include "cmCTestCoverageHandler.h"
class cmCTestGenericHandler;
cmCTestCoverageCommand::cmCTestCoverageCommand() cmCTestCoverageCommand::cmCTestCoverageCommand()
{ {
this->LabelsMentioned = false; this->LabelsMentioned = false;

9
Source/CTest/cmCTestCoverageCommand.h
View File

@ -12,7 +12,16 @@
#ifndef cmCTestCoverageCommand_h #ifndef cmCTestCoverageCommand_h
#define cmCTestCoverageCommand_h #define cmCTestCoverageCommand_h
#include <cmConfigure.h>
#include "cmCTestHandlerCommand.h" #include "cmCTestHandlerCommand.h"
#include "cmTypeMacro.h"
#include <set>
#include <string>
class cmCTestGenericHandler;
class cmCommand;
/** \class cmCTestCoverage /** \class cmCTestCoverage
* \brief Run a ctest script * \brief Run a ctest script

12
Source/CTest/cmCTestCoverageHandler.cxx
View File

@ -13,7 +13,6 @@
#include "cmCTest.h" #include "cmCTest.h"
#include "cmGeneratedFileStream.h" #include "cmGeneratedFileStream.h"
#include "cmMakefile.h"
#include "cmParseBlanketJSCoverage.h" #include "cmParseBlanketJSCoverage.h"
#include "cmParseCacheCoverage.h" #include "cmParseCacheCoverage.h"
#include "cmParseCoberturaCoverage.h" #include "cmParseCoberturaCoverage.h"
@ -25,14 +24,19 @@
#include "cmXMLWriter.h" #include "cmXMLWriter.h"
#include "cmake.h" #include "cmake.h"
#include <algorithm>
#include <cmsys/FStream.hxx> #include <cmsys/FStream.hxx>
#include <cmsys/Glob.hxx> #include <cmsys/Glob.hxx>
#include <cmsys/Process.h> #include <cmsys/Process.h>
#include <cmsys/RegularExpression.hxx> #include <cmsys/RegularExpression.hxx>
#include <iomanip>
#include <float.h> #include <iterator>
#include <math.h> #include <sstream>
#include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <utility>
class cmMakefile;
#define SAFEDIV(x, y) (((y) != 0) ? ((x) / (y)) : (0)) #define SAFEDIV(x, y) (((y) != 0) ? ((x) / (y)) : (0))

12
Source/CTest/cmCTestCoverageHandler.h
View File

@ -13,14 +13,22 @@
#ifndef cmCTestCoverageHandler_h #ifndef cmCTestCoverageHandler_h
#define cmCTestCoverageHandler_h #define cmCTestCoverageHandler_h
#include "cmCTestGenericHandler.h" #include <cmConfigure.h>
#include "cmListFileCache.h" #include "cmCTestGenericHandler.h"
#include "cmTypeMacro.h"
#include <cmsys/RegularExpression.hxx> #include <cmsys/RegularExpression.hxx>
#include <iosfwd>
#include <map>
#include <set>
#include <string>
#include <vector>
class cmGeneratedFileStream; class cmGeneratedFileStream;
class cmMakefile;
class cmXMLWriter; class cmXMLWriter;
class cmCTestCoverageHandlerContainer class cmCTestCoverageHandlerContainer
{ {
public: public:

4
Source/CTest/cmCTestCurl.cxx
View File

@ -14,6 +14,10 @@
#include "cmCTest.h" #include "cmCTest.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include <cmConfigure.h>
#include <ostream>
#include <stdio.h>
cmCTestCurl::cmCTestCurl(cmCTest* ctest) cmCTestCurl::cmCTestCurl(cmCTest* ctest)
{ {
this->CTest = ctest; this->CTest = ctest;

6
Source/CTest/cmCTestCurl.h
View File

@ -12,9 +12,11 @@
#ifndef cmCTestCurl_h #ifndef cmCTestCurl_h
#define cmCTestCurl_h #define cmCTestCurl_h
#include "cmStandardIncludes.h" #include <cmConfigure.h> // IWYU pragma: keep
#include "cm_curl.h" #include <cm_curl.h>
#include <string>
#include <vector>
class cmCTest; class cmCTest;

4
Source/CTest/cmCTestEmptyBinaryDirectoryCommand.cxx
View File

@ -13,6 +13,10 @@
#include "cmCTestScriptHandler.h" #include "cmCTestScriptHandler.h"
#include <sstream>
class cmExecutionStatus;
bool cmCTestEmptyBinaryDirectoryCommand::InitialPass( bool cmCTestEmptyBinaryDirectoryCommand::InitialPass(
std::vector<std::string> const& args, cmExecutionStatus& /*unused*/) std::vector<std::string> const& args, cmExecutionStatus& /*unused*/)
{ {

9
Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h
View File

@ -12,7 +12,16 @@
#ifndef cmCTestEmptyBinaryDirectoryCommand_h #ifndef cmCTestEmptyBinaryDirectoryCommand_h
#define cmCTestEmptyBinaryDirectoryCommand_h #define cmCTestEmptyBinaryDirectoryCommand_h
#include <cmConfigure.h>
#include "cmCTestCommand.h" #include "cmCTestCommand.h"
#include "cmTypeMacro.h"
#include <string>
#include <vector>
class cmCommand;
class cmExecutionStatus;
/** \class cmCTestEmptyBinaryDirectory /** \class cmCTestEmptyBinaryDirectory
* \brief Run a ctest script * \brief Run a ctest script

8
Source/CTest/cmCTestGIT.cxx
View File

@ -13,15 +13,17 @@
#include "cmAlgorithms.h" #include "cmAlgorithms.h"
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestVC.h"
#include "cmProcessTools.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include <cmsys/FStream.hxx> #include <cmsys/FStream.hxx>
#include <cmsys/Process.h> #include <cmsys/Process.h>
#include <cmsys/RegularExpression.hxx>
#include <ctype.h> #include <ctype.h>
#include <sys/types.h> #include <stdio.h>
#include <stdlib.h>
#include <time.h> #include <time.h>
#include <vector>
static unsigned int cmCTestGITVersion(unsigned int epic, unsigned int major, static unsigned int cmCTestGITVersion(unsigned int epic, unsigned int major,
unsigned int minor, unsigned int fix) unsigned int minor, unsigned int fix)

16
Source/CTest/cmCTestGIT.h
View File

@ -12,8 +12,15 @@
#ifndef cmCTestGIT_h #ifndef cmCTestGIT_h
#define cmCTestGIT_h #define cmCTestGIT_h
#include <cmConfigure.h>
#include "cmCTestGlobalVC.h" #include "cmCTestGlobalVC.h"
#include <iosfwd>
#include <string>
class cmCTest;
/** \class cmCTestGIT /** \class cmCTestGIT
* \brief Interaction with git command-line tool * \brief Interaction with git command-line tool
* *
@ -47,12 +54,13 @@ private:
// "public" needed by older Sun compilers // "public" needed by older Sun compilers
public: public:
// Parsing helper classes. // Parsing helper classes.
class OneLineParser;
class DiffParser;
class CommitParser; class CommitParser;
friend class OneLineParser; class DiffParser;
friend class DiffParser; class OneLineParser;
friend class CommitParser; friend class CommitParser;
friend class DiffParser;
friend class OneLineParser;
}; };
#endif #endif

4
Source/CTest/cmCTestGenericHandler.cxx
View File

@ -12,9 +12,11 @@
#include "cmCTestGenericHandler.h" #include "cmCTestGenericHandler.h"
#include "cmCTest.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include "cmCTest.h" #include <sstream>
#include <utility>
cmCTestGenericHandler::cmCTestGenericHandler() cmCTestGenericHandler::cmCTestGenericHandler()
{ {

12
Source/CTest/cmCTestGenericHandler.h
View File

@ -13,14 +13,20 @@
#ifndef cmCTestGenericHandler_h #ifndef cmCTestGenericHandler_h
#define cmCTestGenericHandler_h #define cmCTestGenericHandler_h
#include "cmObject.h" #include <cmConfigure.h>
#include "cmCTest.h" #include "cmCTest.h"
#include "cmSystemTools.h" //OutputOption #include "cmObject.h"
#include "cmSystemTools.h"
#include <map>
#include <stddef.h>
#include <string>
#include <vector>
class cmMakefile;
class cmCTestCommand; class cmCTestCommand;
class cmGeneratedFileStream; class cmGeneratedFileStream;
class cmMakefile;
/** \class cmCTestGenericHandler /** \class cmCTestGenericHandler
* \brief A superclass of all CTest Handlers * \brief A superclass of all CTest Handlers

3
Source/CTest/cmCTestGlobalVC.cxx
View File

@ -15,7 +15,8 @@
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include "cmXMLWriter.h" #include "cmXMLWriter.h"
#include <cmsys/RegularExpression.hxx> #include <ostream>
#include <utility>
cmCTestGlobalVC::cmCTestGlobalVC(cmCTest* ct, std::ostream& log) cmCTestGlobalVC::cmCTestGlobalVC(cmCTest* ct, std::ostream& log)
: cmCTestVC(ct, log) : cmCTestVC(ct, log)

7
Source/CTest/cmCTestGlobalVC.h
View File

@ -12,12 +12,19 @@
#ifndef cmCTestGlobalVC_h #ifndef cmCTestGlobalVC_h
#define cmCTestGlobalVC_h #define cmCTestGlobalVC_h
#include <cmConfigure.h>
#include "cmCTestVC.h" #include "cmCTestVC.h"
#include <iosfwd>
#include <list> #include <list>
#include <map> #include <map>
#include <string>
#include <vector> #include <vector>
class cmCTest;
class cmXMLWriter;
/** \class cmCTestGlobalVC /** \class cmCTestGlobalVC
* \brief Base class for handling globally-versioned trees * \brief Base class for handling globally-versioned trees
* *

4
Source/CTest/cmCTestHG.cxx
View File

@ -12,10 +12,14 @@
#include "cmCTestHG.h" #include "cmCTestHG.h"
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestVC.h"
#include "cmProcessTools.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include "cmXMLParser.h" #include "cmXMLParser.h"
#include <cmsys/RegularExpression.hxx> #include <cmsys/RegularExpression.hxx>
#include <ostream>
#include <vector>
cmCTestHG::cmCTestHG(cmCTest* ct, std::ostream& log) cmCTestHG::cmCTestHG(cmCTest* ct, std::ostream& log)
: cmCTestGlobalVC(ct, log) : cmCTestGlobalVC(ct, log)

12
Source/CTest/cmCTestHG.h
View File

@ -12,8 +12,15 @@
#ifndef cmCTestHG_h #ifndef cmCTestHG_h
#define cmCTestHG_h #define cmCTestHG_h
#include <cmConfigure.h>
#include "cmCTestGlobalVC.h" #include "cmCTestGlobalVC.h"
#include <iosfwd>
#include <string>
class cmCTest;
/** \class cmCTestHG /** \class cmCTestHG
* \brief Interaction with Mercurial command-line tool * \brief Interaction with Mercurial command-line tool
* *
@ -37,11 +44,12 @@ private:
// Parsing helper classes. // Parsing helper classes.
class IdentifyParser; class IdentifyParser;
class StatusParser;
class LogParser; class LogParser;
class StatusParser;
friend class IdentifyParser; friend class IdentifyParser;
friend class StatusParser;
friend class LogParser; friend class LogParser;
friend class StatusParser;
}; };
#endif #endif

8
Source/CTest/cmCTestHandlerCommand.cxx
View File

@ -13,6 +13,14 @@
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestGenericHandler.h" #include "cmCTestGenericHandler.h"
#include "cmMakefile.h"
#include "cmSystemTools.h"
#include "cmake.h"
#include <sstream>
#include <stdlib.h>
class cmExecutionStatus;
cmCTestHandlerCommand::cmCTestHandlerCommand() cmCTestHandlerCommand::cmCTestHandlerCommand()
{ {

8
Source/CTest/cmCTestHandlerCommand.h
View File

@ -12,9 +12,17 @@
#ifndef cmCTestHandlerCommand_h #ifndef cmCTestHandlerCommand_h
#define cmCTestHandlerCommand_h #define cmCTestHandlerCommand_h
#include <cmConfigure.h>
#include "cmCTestCommand.h" #include "cmCTestCommand.h"
#include "cmTypeMacro.h"
#include <stddef.h>
#include <string>
#include <vector>
class cmCTestGenericHandler; class cmCTestGenericHandler;
class cmExecutionStatus;
/** \class cmCTestHandler /** \class cmCTestHandler
* \brief Run a ctest script * \brief Run a ctest script

13
Source/CTest/cmCTestLaunch.cxx
View File

@ -11,15 +11,24 @@
============================================================================*/ ============================================================================*/
#include "cmCTestLaunch.h" #include "cmCTestLaunch.h"
#include <cmConfigure.h>
#include "cmGeneratedFileStream.h" #include "cmGeneratedFileStream.h"
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmState.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include "cmXMLWriter.h" #include "cmXMLWriter.h"
#include "cmake.h" #include "cmake.h"
#include <cm_auto_ptr.hxx>
#include <cmsys/FStream.hxx> #include <cmsys/FStream.hxx>
#include <cmsys/MD5.h> #include <cmsys/MD5.h>
#include <cmsys/Process.h> #include <cmsys/Process.h>
#include <cmsys/RegularExpression.hxx> #include <cmsys/RegularExpression.hxx>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#ifdef _WIN32 #ifdef _WIN32
#include <fcntl.h> // for _O_BINARY #include <fcntl.h> // for _O_BINARY
@ -608,10 +617,6 @@ int cmCTestLaunch::Main(int argc, const char* const argv[])
return self.Run(); return self.Run();
} }
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmake.h"
#include <cm_auto_ptr.hxx>
void cmCTestLaunch::LoadConfig() void cmCTestLaunch::LoadConfig()
{ {
cmake cm; cmake cm;

5
Source/CTest/cmCTestLaunch.h
View File

@ -12,9 +12,12 @@
#ifndef cmCTestLaunch_h #ifndef cmCTestLaunch_h
#define cmCTestLaunch_h #define cmCTestLaunch_h
#include "cmStandardIncludes.h" #include <cmConfigure.h> // IWYU pragma: keep
#include <cmsys/RegularExpression.hxx> #include <cmsys/RegularExpression.hxx>
#include <set>
#include <string>
#include <vector>
class cmXMLWriter; class cmXMLWriter;

6
Source/CTest/cmCTestMemCheckCommand.h
View File

@ -12,9 +12,15 @@
#ifndef cmCTestMemCheckCommand_h #ifndef cmCTestMemCheckCommand_h
#define cmCTestMemCheckCommand_h #define cmCTestMemCheckCommand_h
#include <cmConfigure.h>
#include "cmCTestTestCommand.h" #include "cmCTestTestCommand.h"
#include "cmTypeMacro.h"
#include <string>
class cmCTestGenericHandler; class cmCTestGenericHandler;
class cmCommand;
/** \class cmCTestMemCheck /** \class cmCTestMemCheck
* \brief Run a ctest script * \brief Run a ctest script

14
Source/CTest/cmCTestMemCheckHandler.cxx
View File

@ -13,20 +13,16 @@
#include "cmCTestMemCheckHandler.h" #include "cmCTestMemCheckHandler.h"
#include "cmCTest.h" #include "cmCTest.h"
#include "cmGeneratedFileStream.h" #include "cmSystemTools.h"
#include "cmMakefile.h"
#include "cmXMLParser.h" #include "cmXMLParser.h"
#include "cmXMLWriter.h" #include "cmXMLWriter.h"
#include "cmake.h"
#include <cmsys/Base64.h>
#include <cmsys/FStream.hxx> #include <cmsys/FStream.hxx>
#include <cmsys/Glob.hxx> #include <cmsys/Glob.hxx>
#include <cmsys/Process.h>
#include <cmsys/RegularExpression.hxx> #include <cmsys/RegularExpression.hxx>
#include <iostream>
#include <float.h> #include <sstream>
#include <math.h> #include <string.h>
#include <stdlib.h>
struct CatToErrorType struct CatToErrorType
{ {

6
Source/CTest/cmCTestMemCheckHandler.h
View File

@ -13,9 +13,11 @@
#ifndef cmCTestMemCheckHandler_h #ifndef cmCTestMemCheckHandler_h
#define cmCTestMemCheckHandler_h #define cmCTestMemCheckHandler_h
#include "cmCTestTestHandler.h" #include <cmConfigure.h>
#include "cmCTestTestHandler.h"
#include "cmTypeMacro.h"
#include "cmListFileCache.h"
#include <string> #include <string>
#include <vector> #include <vector>

11
Source/CTest/cmCTestMultiProcessHandler.cxx
View File

@ -12,17 +12,22 @@
#include "cmCTestMultiProcessHandler.h" #include "cmCTestMultiProcessHandler.h"
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestRunTest.h"
#include "cmCTestScriptHandler.h" #include "cmCTestScriptHandler.h"
#include "cmProcess.h" #include "cmCTestTestHandler.h"
#include "cmStandardIncludes.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include <algorithm>
#include <cmsys/FStream.hxx> #include <cmsys/FStream.hxx>
#include <cmsys/String.hxx>
#include <cmsys/SystemInformation.hxx> #include <cmsys/SystemInformation.hxx>
#include <float.h> #include <iomanip>
#include <list> #include <list>
#include <math.h> #include <math.h>
#include <sstream>
#include <stack> #include <stack>
#include <stdlib.h> #include <stdlib.h>
#include <utility>
class TestComparator class TestComparator
{ {

12
Source/CTest/cmCTestMultiProcessHandler.h
View File

@ -12,9 +12,17 @@
#ifndef cmCTestMultiProcessHandler_h #ifndef cmCTestMultiProcessHandler_h
#define cmCTestMultiProcessHandler_h #define cmCTestMultiProcessHandler_h
#include <cmCTestTestHandler.h> #include <cmConfigure.h> // IWYU pragma: keep
#include <cmCTestRunTest.h> #include <cmCTestTestHandler.h>
#include <map>
#include <set>
#include <stddef.h>
#include <string>
#include <vector>
class cmCTest;
class cmCTestRunTest;
/** \class cmCTestMultiProcessHandler /** \class cmCTestMultiProcessHandler
* \brief run parallel ctest * \brief run parallel ctest

9
Source/CTest/cmCTestP4.cxx
View File

@ -12,14 +12,15 @@
#include "cmCTestP4.h" #include "cmCTestP4.h"
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestVC.h"
#include "cmProcessTools.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include <cmsys/Process.h> #include <algorithm>
#include <cmsys/RegularExpression.hxx> #include <cmsys/RegularExpression.hxx>
#include <ostream>
#include <ctype.h>
#include <sys/types.h>
#include <time.h> #include <time.h>
#include <utility>
cmCTestP4::cmCTestP4(cmCTest* ct, std::ostream& log) cmCTestP4::cmCTestP4(cmCTest* ct, std::ostream& log)
: cmCTestGlobalVC(ct, log) : cmCTestGlobalVC(ct, log)

13
Source/CTest/cmCTestP4.h
View File

@ -12,11 +12,17 @@
#ifndef cmCTestP4_h #ifndef cmCTestP4_h
#define cmCTestP4_h #define cmCTestP4_h
#include <cmConfigure.h>
#include "cmCTestGlobalVC.h" #include "cmCTestGlobalVC.h"
#include <iosfwd>
#include <map> #include <map>
#include <string>
#include <vector> #include <vector>
class cmCTest;
/** \class cmCTestP4 /** \class cmCTestP4
* \brief Interaction with the Perforce command-line tool * \brief Interaction with the Perforce command-line tool
* *
@ -62,12 +68,13 @@ private:
void LoadRevisions() CM_OVERRIDE; void LoadRevisions() CM_OVERRIDE;
void LoadModifications() CM_OVERRIDE; void LoadModifications() CM_OVERRIDE;
// Parsing helper classes.
class IdentifyParser;
class ChangesParser; class ChangesParser;
class UserParser;
class DescribeParser; class DescribeParser;
class DiffParser; class DiffParser;
// Parsing helper classes.
class IdentifyParser;
class UserParser;
friend class IdentifyParser; friend class IdentifyParser;
friend class ChangesParser; friend class ChangesParser;
friend class UserParser; friend class UserParser;

2
Source/CTest/cmCTestReadCustomFilesCommand.cxx
View File

@ -13,6 +13,8 @@
#include "cmCTest.h" #include "cmCTest.h"
class cmExecutionStatus;
bool cmCTestReadCustomFilesCommand::InitialPass( bool cmCTestReadCustomFilesCommand::InitialPass(
std::vector<std::string> const& args, cmExecutionStatus& /*unused*/) std::vector<std::string> const& args, cmExecutionStatus& /*unused*/)
{ {

9
Source/CTest/cmCTestReadCustomFilesCommand.h
View File

@ -12,7 +12,16 @@
#ifndef cmCTestReadCustomFilesCommand_h #ifndef cmCTestReadCustomFilesCommand_h
#define cmCTestReadCustomFilesCommand_h #define cmCTestReadCustomFilesCommand_h
#include <cmConfigure.h>
#include "cmCTestCommand.h" #include "cmCTestCommand.h"
#include "cmTypeMacro.h"
#include <string>
#include <vector>
class cmCommand;
class cmExecutionStatus;
/** \class cmCTestReadCustomFiles /** \class cmCTestReadCustomFiles
* \brief Run a ctest script * \brief Run a ctest script

5
Source/CTest/cmCTestRunScriptCommand.cxx
View File

@ -12,6 +12,11 @@
#include "cmCTestRunScriptCommand.h" #include "cmCTestRunScriptCommand.h"
#include "cmCTestScriptHandler.h" #include "cmCTestScriptHandler.h"
#include "cmMakefile.h"
#include <sstream>
class cmExecutionStatus;
bool cmCTestRunScriptCommand::InitialPass(std::vector<std::string> const& args, bool cmCTestRunScriptCommand::InitialPass(std::vector<std::string> const& args,
cmExecutionStatus& /*unused*/) cmExecutionStatus& /*unused*/)

9
Source/CTest/cmCTestRunScriptCommand.h
View File

@ -12,7 +12,16 @@
#ifndef cmCTestRunScriptCommand_h #ifndef cmCTestRunScriptCommand_h
#define cmCTestRunScriptCommand_h #define cmCTestRunScriptCommand_h
#include <cmConfigure.h>
#include "cmCTestCommand.h" #include "cmCTestCommand.h"
#include "cmTypeMacro.h"
#include <string>
#include <vector>
class cmCommand;
class cmExecutionStatus;
/** \class cmCTestRunScript /** \class cmCTestRunScript
* \brief Run a ctest script * \brief Run a ctest script

12
Source/CTest/cmCTestRunTest.cxx
View File

@ -14,11 +14,21 @@
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestMemCheckHandler.h" #include "cmCTestMemCheckHandler.h"
#include "cmCTestTestHandler.h"
#include "cmProcess.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include "cm_curl.h"
#include <cmConfigure.h>
#include <cm_curl.h>
#include <cm_zlib.h> #include <cm_zlib.h>
#include <cmsys/Base64.h> #include <cmsys/Base64.h>
#include <cmsys/Process.h>
#include <cmsys/RegularExpression.hxx>
#include <iomanip>
#include <sstream>
#include <stdio.h>
#include <time.h>
#include <utility>
cmCTestRunTest::cmCTestRunTest(cmCTestTestHandler* handler) cmCTestRunTest::cmCTestRunTest(cmCTestTestHandler* handler)
{ {

10
Source/CTest/cmCTestRunTest.h
View File

@ -12,9 +12,15 @@
#ifndef cmCTestRunTest_h #ifndef cmCTestRunTest_h
#define cmCTestRunTest_h #define cmCTestRunTest_h
#include <cmCTestTestHandler.h> #include <cmConfigure.h> // IWYU pragma: keep
#include <cmProcess.h> #include <cmCTestTestHandler.h>
#include <stddef.h>
#include <string>
#include <vector>
class cmCTest;
class cmProcess;
/** \class cmRunTest /** \class cmRunTest
* \brief represents a single test to be run * \brief represents a single test to be run

6
Source/CTest/cmCTestSVN.cxx
View File

@ -12,11 +12,17 @@
#include "cmCTestSVN.h" #include "cmCTestSVN.h"
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestVC.h"
#include "cmProcessTools.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include "cmXMLParser.h" #include "cmXMLParser.h"
#include "cmXMLWriter.h" #include "cmXMLWriter.h"
#include <cmsys/RegularExpression.hxx> #include <cmsys/RegularExpression.hxx>
#include <map>
#include <ostream>
#include <stdlib.h>
#include <string.h>
struct cmCTestSVN::Revision : public cmCTestVC::Revision struct cmCTestSVN::Revision : public cmCTestVC::Revision
{ {

12
Source/CTest/cmCTestSVN.h
View File

@ -12,9 +12,17 @@
#ifndef cmCTestSVN_h #ifndef cmCTestSVN_h
#define cmCTestSVN_h #define cmCTestSVN_h
#include <cmConfigure.h>
#include "cmCTestGlobalVC.h" #include "cmCTestGlobalVC.h"
#include <iosfwd>
#include <list> #include <list>
#include <string>
#include <vector>
class cmCTest;
class cmXMLWriter;
/** \class cmCTestSVN /** \class cmCTestSVN
* \brief Interaction with subversion command-line tool * \brief Interaction with subversion command-line tool
@ -68,6 +76,7 @@ private:
// Extended revision structure to include info about external it refers to. // Extended revision structure to include info about external it refers to.
struct Revision; struct Revision;
friend struct Revision; friend struct Revision;
// Info of all the repositories (root, externals and nested ones). // Info of all the repositories (root, externals and nested ones).
@ -89,12 +98,13 @@ private:
void WriteXMLGlobal(cmXMLWriter& xml) CM_OVERRIDE; void WriteXMLGlobal(cmXMLWriter& xml) CM_OVERRIDE;
class ExternalParser;
// Parsing helper classes. // Parsing helper classes.
class InfoParser; class InfoParser;
class LogParser; class LogParser;
class StatusParser; class StatusParser;
class UpdateParser; class UpdateParser;
class ExternalParser;
friend class InfoParser; friend class InfoParser;
friend class LogParser; friend class LogParser;
friend class StatusParser; friend class StatusParser;

51
Source/CTest/cmCTestScriptHandler.cxx
View File

@ -13,32 +13,8 @@
#include "cmCTestScriptHandler.h" #include "cmCTestScriptHandler.h"
#include "cmCTest.h" #include "cmCTest.h"
#include "cmFunctionBlocker.h"
#include "cmGeneratedFileStream.h"
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmake.h"
//#include <cmsys/RegularExpression.hxx>
#include <cmsys/Directory.hxx>
#include <cmsys/Process.h>
// used for sleep
#ifdef _WIN32
#include "windows.h"
#endif
#include <float.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
// needed for sleep
#if !defined(_WIN32)
#include <unistd.h>
#endif
#include "cmCTestBuildCommand.h" #include "cmCTestBuildCommand.h"
#include "cmCTestCommand.h"
#include "cmCTestConfigureCommand.h" #include "cmCTestConfigureCommand.h"
#include "cmCTestCoverageCommand.h" #include "cmCTestCoverageCommand.h"
#include "cmCTestEmptyBinaryDirectoryCommand.h" #include "cmCTestEmptyBinaryDirectoryCommand.h"
@ -51,6 +27,31 @@
#include "cmCTestTestCommand.h" #include "cmCTestTestCommand.h"
#include "cmCTestUpdateCommand.h" #include "cmCTestUpdateCommand.h"
#include "cmCTestUploadCommand.h" #include "cmCTestUploadCommand.h"
#include "cmFunctionBlocker.h"
#include "cmGeneratedFileStream.h"
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmState.h"
#include "cmSystemTools.h"
#include "cmake.h"
#include <cmsys/Directory.hxx>
#include <cmsys/Process.h>
#include <map>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <utility>
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif
class cmExecutionStatus;
struct cmListFileFunction;
#define CTEST_INITIAL_CMAKE_OUTPUT_FILE_NAME "CTestInitialCMakeOutput.log" #define CTEST_INITIAL_CMAKE_OUTPUT_FILE_NAME "CTestInitialCMakeOutput.log"

13
Source/CTest/cmCTestScriptHandler.h
View File

@ -13,14 +13,19 @@
#ifndef cmCTestScriptHandler_h #ifndef cmCTestScriptHandler_h
#define cmCTestScriptHandler_h #define cmCTestScriptHandler_h
#include <cmConfigure.h>
#include "cmCTestGenericHandler.h" #include "cmCTestGenericHandler.h"
#include "cmTypeMacro.h"
#include "cmListFileCache.h" #include <string>
#include <vector>
class cmMakefile; class cmCTest;
class cmGlobalGenerator;
class cmake;
class cmCTestCommand; class cmCTestCommand;
class cmGlobalGenerator;
class cmMakefile;
class cmake;
/** \class cmCTestScriptHandler /** \class cmCTestScriptHandler
* \brief A class that handles ctest -S invocations * \brief A class that handles ctest -S invocations

5
Source/CTest/cmCTestSleepCommand.cxx
View File

@ -12,7 +12,10 @@
#include "cmCTestSleepCommand.h" #include "cmCTestSleepCommand.h"
#include "cmCTestScriptHandler.h" #include "cmCTestScriptHandler.h"
#include <stdlib.h> // required for atoi
#include <stdlib.h>
class cmExecutionStatus;
bool cmCTestSleepCommand::InitialPass(std::vector<std::string> const& args, bool cmCTestSleepCommand::InitialPass(std::vector<std::string> const& args,
cmExecutionStatus& /*unused*/) cmExecutionStatus& /*unused*/)

9
Source/CTest/cmCTestSleepCommand.h
View File

@ -12,7 +12,16 @@
#ifndef cmCTestSleepCommand_h #ifndef cmCTestSleepCommand_h
#define cmCTestSleepCommand_h #define cmCTestSleepCommand_h
#include <cmConfigure.h>
#include "cmCTestCommand.h" #include "cmCTestCommand.h"
#include "cmTypeMacro.h"
#include <string>
#include <vector>
class cmCommand;
class cmExecutionStatus;
/** \class cmCTestSleep /** \class cmCTestSleep
* \brief Run a ctest script * \brief Run a ctest script

8
Source/CTest/cmCTestStartCommand.cxx
View File

@ -14,7 +14,13 @@
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestVC.h" #include "cmCTestVC.h"
#include "cmGeneratedFileStream.h" #include "cmGeneratedFileStream.h"
#include "cmGlobalGenerator.h" #include "cmMakefile.h"
#include "cmSystemTools.h"
#include <sstream>
#include <stddef.h>
class cmExecutionStatus;
cmCTestStartCommand::cmCTestStartCommand() cmCTestStartCommand::cmCTestStartCommand()
{ {

10
Source/CTest/cmCTestStartCommand.h
View File

@ -12,7 +12,17 @@
#ifndef cmCTestStartCommand_h #ifndef cmCTestStartCommand_h
#define cmCTestStartCommand_h #define cmCTestStartCommand_h
#include <cmConfigure.h>
#include "cmCTestCommand.h" #include "cmCTestCommand.h"
#include "cmTypeMacro.h"
#include <iosfwd>
#include <string>
#include <vector>
class cmCommand;
class cmExecutionStatus;
/** \class cmCTestStart /** \class cmCTestStart
* \brief Run a ctest script * \brief Run a ctest script

7
Source/CTest/cmCTestSubmitCommand.cxx
View File

@ -14,6 +14,13 @@
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestGenericHandler.h" #include "cmCTestGenericHandler.h"
#include "cmCTestSubmitHandler.h" #include "cmCTestSubmitHandler.h"
#include "cmMakefile.h"
#include "cmSystemTools.h"
#include "cmake.h"
#include <sstream>
class cmExecutionStatus;
cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler() cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler()
{ {

12
Source/CTest/cmCTestSubmitCommand.h
View File

@ -12,9 +12,19 @@
#ifndef cmCTestSubmitCommand_h #ifndef cmCTestSubmitCommand_h
#define cmCTestSubmitCommand_h #define cmCTestSubmitCommand_h
#include "cmCTestHandlerCommand.h" #include <cmConfigure.h>
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestHandlerCommand.h"
#include "cmTypeMacro.h"
#include <set>
#include <string>
#include <vector>
class cmCTestGenericHandler;
class cmCommand;
class cmExecutionStatus;
/** \class cmCTestSubmit /** \class cmCTestSubmit
* \brief Run a ctest script * \brief Run a ctest script

22
Source/CTest/cmCTestSubmitHandler.cxx
View File

@ -12,26 +12,28 @@
#include "cmCTestSubmitHandler.h" #include "cmCTestSubmitHandler.h"
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestCurl.h"
#include "cmCTestScriptHandler.h" #include "cmCTestScriptHandler.h"
#include "cmCurl.h"
#include "cmGeneratedFileStream.h" #include "cmGeneratedFileStream.h"
#include "cmState.h" #include "cmState.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include "cmVersion.h"
#include "cmXMLParser.h" #include "cmXMLParser.h"
#include "cmake.h" #include "cmake.h"
#include <cmsys/Base64.h> #include <cm_curl.h>
#include <cmsys/Process.h>
// For XML-RPC submission
#include "cm_xmlrpc.h"
#include <cm_jsoncpp_reader.h> #include <cm_jsoncpp_reader.h>
// For curl submission #include <cm_jsoncpp_value.h>
#include "cmCTestCurl.h" #include <cmsys/Process.h>
#include "cmCurl.h" #include <sstream>
#include <stdio.h>
#include <stdlib.h>
#if defined(CTEST_USE_XMLRPC)
#include "cmVersion.h"
#include <cm_xmlrpc.h>
#include <sys/stat.h> #include <sys/stat.h>
#endif
#define SUBMIT_TIMEOUT_IN_SECONDS_DEFAULT 120 #define SUBMIT_TIMEOUT_IN_SECONDS_DEFAULT 120

10
Source/CTest/cmCTestSubmitHandler.h
View File

@ -12,7 +12,16 @@
#ifndef cmCTestSubmitHandler_h #ifndef cmCTestSubmitHandler_h
#define cmCTestSubmitHandler_h #define cmCTestSubmitHandler_h
#include <cmConfigure.h>
#include "cmCTest.h"
#include "cmCTestGenericHandler.h" #include "cmCTestGenericHandler.h"
#include "cmTypeMacro.h"
#include <iosfwd>
#include <set>
#include <string>
#include <vector>
/** \class cmCTestSubmitHandler /** \class cmCTestSubmitHandler
* \brief Helper class for CTest * \brief Helper class for CTest
@ -84,6 +93,7 @@ private:
std::string GetSubmitResultsPrefix(); std::string GetSubmitResultsPrefix();
class ResponseParser; class ResponseParser;
std::string HTTPProxy; std::string HTTPProxy;
int HTTPProxyType; int HTTPProxyType;
std::string HTTPProxyAuth; std::string HTTPProxyAuth;

6
Source/CTest/cmCTestTestCommand.cxx
View File

@ -13,6 +13,12 @@
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestGenericHandler.h" #include "cmCTestGenericHandler.h"
#include "cmMakefile.h"
#include "cmSystemTools.h"
#include <sstream>
#include <stdlib.h>
#include <vector>
cmCTestTestCommand::cmCTestTestCommand() cmCTestTestCommand::cmCTestTestCommand()
{ {

8
Source/CTest/cmCTestTestCommand.h
View File

@ -12,7 +12,15 @@
#ifndef cmCTestTestCommand_h #ifndef cmCTestTestCommand_h
#define cmCTestTestCommand_h #define cmCTestTestCommand_h
#include <cmConfigure.h>
#include "cmCTestHandlerCommand.h" #include "cmCTestHandlerCommand.h"
#include "cmTypeMacro.h"
#include <string>
class cmCTestGenericHandler;
class cmCommand;
/** \class cmCTestTest /** \class cmCTestTest
* \brief Run a ctest script * \brief Run a ctest script

20
Source/CTest/cmCTestTestHandler.cxx
View File

@ -15,26 +15,32 @@
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestBatchTestHandler.h" #include "cmCTestBatchTestHandler.h"
#include "cmCTestMultiProcessHandler.h" #include "cmCTestMultiProcessHandler.h"
#include "cmCTestRunTest.h"
#include "cmCommand.h" #include "cmCommand.h"
#include "cmGeneratedFileStream.h" #include "cmGeneratedFileStream.h"
#include "cmGlobalGenerator.h" #include "cmGlobalGenerator.h"
#include "cmMakefile.h" #include "cmMakefile.h"
#include "cmState.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include "cmXMLWriter.h" #include "cmXMLWriter.h"
#include "cm_auto_ptr.hxx"
#include "cm_utf8.h" #include "cm_utf8.h"
#include "cmake.h" #include "cmake.h"
#include <algorithm>
#include <cmsys/Base64.h> #include <cmsys/Base64.h>
#include <cmsys/Directory.hxx> #include <cmsys/Directory.hxx>
#include <cmsys/FStream.hxx> #include <cmsys/FStream.hxx>
#include <cmsys/Process.h>
#include <cmsys/RegularExpression.hxx> #include <cmsys/RegularExpression.hxx>
#include <functional>
#include <float.h> #include <iomanip>
#include <math.h>
#include <stdlib.h>
#include <set> #include <set>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
class cmExecutionStatus;
class cmCTestSubdirCommand : public cmCommand class cmCTestSubdirCommand : public cmCommand
{ {

11
Source/CTest/cmCTestTestHandler.h
View File

@ -13,10 +13,21 @@
#ifndef cmCTestTestHandler_h #ifndef cmCTestTestHandler_h
#define cmCTestTestHandler_h #define cmCTestTestHandler_h
#include <cmConfigure.h>
#include "cmCTestGenericHandler.h" #include "cmCTestGenericHandler.h"
#include "cmTypeMacro.h"
#include <cmsys/RegularExpression.hxx> #include <cmsys/RegularExpression.hxx>
#include <iosfwd>
#include <map>
#include <set>
#include <stddef.h>
#include <string>
#include <utility>
#include <vector>
class cmCTest;
class cmMakefile; class cmMakefile;
class cmXMLWriter; class cmXMLWriter;

4
Source/CTest/cmCTestUpdateCommand.cxx
View File

@ -13,6 +13,10 @@
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestGenericHandler.h" #include "cmCTestGenericHandler.h"
#include "cmMakefile.h"
#include "cmSystemTools.h"
#include <vector>
cmCTestGenericHandler* cmCTestUpdateCommand::InitializeHandler() cmCTestGenericHandler* cmCTestUpdateCommand::InitializeHandler()
{ {

8
Source/CTest/cmCTestUpdateCommand.h
View File

@ -12,7 +12,15 @@
#ifndef cmCTestUpdateCommand_h #ifndef cmCTestUpdateCommand_h
#define cmCTestUpdateCommand_h #define cmCTestUpdateCommand_h
#include <cmConfigure.h>
#include "cmCTestHandlerCommand.h" #include "cmCTestHandlerCommand.h"
#include "cmTypeMacro.h"
#include <string>
class cmCTestGenericHandler;
class cmCommand;
/** \class cmCTestUpdate /** \class cmCTestUpdate
* \brief Run a ctest script * \brief Run a ctest script

25
Source/CTest/cmCTestUpdateHandler.cxx
View File

@ -14,14 +14,6 @@
#include "cmCLocaleEnvironmentScope.h" #include "cmCLocaleEnvironmentScope.h"
#include "cmCTest.h" #include "cmCTest.h"
#include "cmGeneratedFileStream.h"
#include "cmGlobalGenerator.h"
#include "cmMakefile.h"
#include "cmVersion.h"
#include "cmXMLParser.h"
#include "cmXMLWriter.h"
#include "cmake.h"
#include "cmCTestBZR.h" #include "cmCTestBZR.h"
#include "cmCTestCVS.h" #include "cmCTestCVS.h"
#include "cmCTestGIT.h" #include "cmCTestGIT.h"
@ -29,20 +21,13 @@
#include "cmCTestP4.h" #include "cmCTestP4.h"
#include "cmCTestSVN.h" #include "cmCTestSVN.h"
#include "cmCTestVC.h" #include "cmCTestVC.h"
#include "cmGeneratedFileStream.h"
#include "cmSystemTools.h"
#include "cmVersion.h"
#include "cmXMLWriter.h"
#include <cm_auto_ptr.hxx> #include <cm_auto_ptr.hxx>
#include <sstream>
//#include <cmsys/RegularExpression.hxx>
#include <cmsys/Process.h>
// used for sleep
#ifdef _WIN32
#include "windows.h"
#endif
#include <float.h>
#include <math.h>
#include <stdlib.h>
static const char* cmCTestUpdateHandlerUpdateStrings[] = { static const char* cmCTestUpdateHandlerUpdateStrings[] = {
"Unknown", "CVS", "SVN", "BZR", "GIT", "HG", "P4" "Unknown", "CVS", "SVN", "BZR", "GIT", "HG", "P4"

9
Source/CTest/cmCTestUpdateHandler.h
View File

@ -13,9 +13,14 @@
#ifndef cmCTestUpdateHandler_h #ifndef cmCTestUpdateHandler_h
#define cmCTestUpdateHandler_h #define cmCTestUpdateHandler_h
#include "cmCTestGenericHandler.h" #include <cmConfigure.h>
#include "cmListFileCache.h" #include "cmCTestGenericHandler.h"
#include "cmTypeMacro.h"
#include <string>
#include <utility>
#include <vector>
/** \class cmCTestUpdateHandler /** \class cmCTestUpdateHandler
* \brief A class that handles ctest -S invocations * \brief A class that handles ctest -S invocations

5
Source/CTest/cmCTestUploadCommand.cxx
View File

@ -14,6 +14,11 @@
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestGenericHandler.h" #include "cmCTestGenericHandler.h"
#include "cmCTestUploadHandler.h" #include "cmCTestUploadHandler.h"
#include "cmMakefile.h"
#include "cmSystemTools.h"
#include "cmake.h"
#include <sstream>
cmCTestGenericHandler* cmCTestUploadCommand::InitializeHandler() cmCTestGenericHandler* cmCTestUploadCommand::InitializeHandler()
{ {

9
Source/CTest/cmCTestUploadCommand.h
View File

@ -12,9 +12,16 @@
#ifndef cmCTestUploadCommand_h #ifndef cmCTestUploadCommand_h
#define cmCTestUploadCommand_h #define cmCTestUploadCommand_h
#include "cmCTestHandlerCommand.h" #include <cmConfigure.h>
#include "cmCTest.h" #include "cmCTest.h"
#include "cmCTestHandlerCommand.h"
#include "cmTypeMacro.h"
#include <string>
class cmCTestGenericHandler;
class cmCommand;
/** \class cmCTestUpload /** \class cmCTestUpload
* \brief Run a ctest script * \brief Run a ctest script

4
Source/CTest/cmCTestUploadHandler.cxx
View File

@ -15,6 +15,10 @@
#include "cmVersion.h" #include "cmVersion.h"
#include "cmXMLWriter.h" #include "cmXMLWriter.h"
#include <ostream>
#include <set>
#include <string>
cmCTestUploadHandler::cmCTestUploadHandler() cmCTestUploadHandler::cmCTestUploadHandler()
{ {
this->Initialize(); this->Initialize();

4
Source/CTest/cmCTestUploadHandler.h
View File

@ -12,7 +12,11 @@
#ifndef cmCTestUploadHandler_h #ifndef cmCTestUploadHandler_h
#define cmCTestUploadHandler_h #define cmCTestUploadHandler_h
#include <cmConfigure.h>
#include "cmCTest.h"
#include "cmCTestGenericHandler.h" #include "cmCTestGenericHandler.h"
#include "cmTypeMacro.h"
/** \class cmCTestUploadHandler /** \class cmCTestUploadHandler
* \brief Helper class for CTest * \brief Helper class for CTest

4
Source/CTest/cmCTestVC.cxx
View File

@ -16,6 +16,10 @@
#include "cmXMLWriter.h" #include "cmXMLWriter.h"
#include <cmsys/Process.h> #include <cmsys/Process.h>
#include <sstream>
#include <stdio.h>
#include <time.h>
#include <vector>
cmCTestVC::cmCTestVC(cmCTest* ct, std::ostream& log) cmCTestVC::cmCTestVC(cmCTest* ct, std::ostream& log)
: CTest(ct) : CTest(ct)

6
Source/CTest/cmCTestVC.h
View File

@ -12,8 +12,13 @@
#ifndef cmCTestVC_h #ifndef cmCTestVC_h
#define cmCTestVC_h #define cmCTestVC_h
#include <cmConfigure.h>
#include "cmProcessTools.h" #include "cmProcessTools.h"
#include <iosfwd>
#include <string>
class cmCTest; class cmCTest;
class cmXMLWriter; class cmXMLWriter;
@ -93,7 +98,6 @@ public:
}; };
protected: protected:
struct File;
friend struct File; friend struct File;
/** Represent change to one file. */ /** Represent change to one file. */

5
Source/CTest/cmParseBlanketJSCoverage.cxx
View File

@ -11,10 +11,11 @@
============================================================================*/ ============================================================================*/
#include "cmParseBlanketJSCoverage.h" #include "cmParseBlanketJSCoverage.h"
#include "cmCTest.h"
#include "cmCTestCoverageHandler.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include <cmsys/Directory.hxx>
#include <cmsys/FStream.hxx> #include <cmsys/FStream.hxx>
#include <cmsys/Glob.hxx>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

9
Source/CTest/cmParseBlanketJSCoverage.h
View File

@ -13,7 +13,13 @@
#ifndef cmParseBlanketJSCoverage_h #ifndef cmParseBlanketJSCoverage_h
#define cmParseBlanketJSCoverage_h #define cmParseBlanketJSCoverage_h
#include "cmCTestCoverageHandler.h" #include <cmConfigure.h> // IWYU pragma: keep
#include <string>
#include <vector>
class cmCTest;
class cmCTestCoverageHandlerContainer;
/** \class cmParseBlanketJSCoverage /** \class cmParseBlanketJSCoverage
* \brief Parse BlanketJS coverage information * \brief Parse BlanketJS coverage information
@ -39,6 +45,7 @@ public:
protected: protected:
class JSONParser; class JSONParser;
cmCTestCoverageHandlerContainer& Coverage; cmCTestCoverageHandlerContainer& Coverage;
cmCTest* CTest; cmCTest* CTest;
}; };

6
Source/CTest/cmParseCacheCoverage.cxx
View File

@ -1,11 +1,15 @@
#include "cmParseCacheCoverage.h" #include "cmParseCacheCoverage.h"
#include "cmCTest.h"
#include "cmCTestCoverageHandler.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include <cmsys/Directory.hxx> #include <cmsys/Directory.hxx>
#include <cmsys/FStream.hxx> #include <cmsys/FStream.hxx>
#include <cmsys/Glob.hxx> #include <map>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <utility>
cmParseCacheCoverage::cmParseCacheCoverage( cmParseCacheCoverage::cmParseCacheCoverage(
cmCTestCoverageHandlerContainer& cont, cmCTest* ctest) cmCTestCoverageHandlerContainer& cont, cmCTest* ctest)

8
Source/CTest/cmParseCacheCoverage.h
View File

@ -13,8 +13,16 @@
#ifndef cmParseCacheCoverage_h #ifndef cmParseCacheCoverage_h
#define cmParseCacheCoverage_h #define cmParseCacheCoverage_h
#include <cmConfigure.h>
#include "cmParseMumpsCoverage.h" #include "cmParseMumpsCoverage.h"
#include <string>
#include <vector>
class cmCTest;
class cmCTestCoverageHandlerContainer;
/** \class cmParseCacheCoverage /** \class cmParseCacheCoverage
* \brief Parse Cache coverage information * \brief Parse Cache coverage information
* *

7
Source/CTest/cmParseCoberturaCoverage.cxx
View File

@ -1,9 +1,14 @@
#include "cmParseCoberturaCoverage.h" #include "cmParseCoberturaCoverage.h"
#include "cmCTest.h"
#include "cmCTestCoverageHandler.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include "cmXMLParser.h" #include "cmXMLParser.h"
#include <cmsys/Directory.hxx>
#include <cmConfigure.h>
#include <cmsys/FStream.hxx> #include <cmsys/FStream.hxx>
#include <stdlib.h>
#include <string.h>
class cmParseCoberturaCoverage::XMLParser : public cmXMLParser class cmParseCoberturaCoverage::XMLParser : public cmXMLParser
{ {

9
Source/CTest/cmParseCoberturaCoverage.h
View File

@ -13,7 +13,13 @@
#ifndef cmParseCoberturaCoverage_h #ifndef cmParseCoberturaCoverage_h
#define cmParseCoberturaCoverage_h #define cmParseCoberturaCoverage_h
#include "cmCTestCoverageHandler.h" #include <cmConfigure.h> // IWYU pragma: keep
#include <string>
#include <vector>
class cmCTest;
class cmCTestCoverageHandlerContainer;
/** \class cmParsePythonCoverage /** \class cmParsePythonCoverage
* \brief Parse coverage.py Python coverage information * \brief Parse coverage.py Python coverage information
@ -40,6 +46,7 @@ public:
private: private:
class XMLParser; class XMLParser;
cmCTestCoverageHandlerContainer& Coverage; cmCTestCoverageHandlerContainer& Coverage;
cmCTest* CTest; cmCTest* CTest;
std::string CurFileName; std::string CurFileName;

5
Source/CTest/cmParseDelphiCoverage.cxx
View File

@ -1,8 +1,9 @@
#include "cmParseDelphiCoverage.h" #include "cmParseDelphiCoverage.h"
#include "cmCTest.h"
#include "cmCTestCoverageHandler.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include "cmXMLParser.h"
#include <cmsys/Directory.hxx>
#include <cmsys/FStream.hxx> #include <cmsys/FStream.hxx>
#include <cmsys/Glob.hxx> #include <cmsys/Glob.hxx>
#include <stdio.h> #include <stdio.h>

9
Source/CTest/cmParseDelphiCoverage.h
View File

@ -13,7 +13,13 @@
#ifndef cmParseDelphiCoverage_h #ifndef cmParseDelphiCoverage_h
#define cmParseDelphiCoverage_h #define cmParseDelphiCoverage_h
#include "cmCTestCoverageHandler.h" #include <cmConfigure.h> // IWYU pragma: keep
#include <string>
#include <vector>
class cmCTest;
class cmCTestCoverageHandlerContainer;
/** \class cmParseDelphiCoverage /** \class cmParseDelphiCoverage
* \brief Parse Delphi coverage information * \brief Parse Delphi coverage information
@ -35,6 +41,7 @@ public:
protected: protected:
class HTMLParser; class HTMLParser;
cmCTestCoverageHandlerContainer& Coverage; cmCTestCoverageHandlerContainer& Coverage;
cmCTest* CTest; cmCTest* CTest;
}; };

6
Source/CTest/cmParseGTMCoverage.cxx
View File

@ -1,11 +1,15 @@
#include "cmParseGTMCoverage.h" #include "cmParseGTMCoverage.h"
#include "cmCTest.h"
#include "cmCTestCoverageHandler.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include <cmsys/Directory.hxx> #include <cmsys/Directory.hxx>
#include <cmsys/FStream.hxx> #include <cmsys/FStream.hxx>
#include <cmsys/Glob.hxx> #include <map>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <vector>
cmParseGTMCoverage::cmParseGTMCoverage(cmCTestCoverageHandlerContainer& cont, cmParseGTMCoverage::cmParseGTMCoverage(cmCTestCoverageHandlerContainer& cont,
cmCTest* ctest) cmCTest* ctest)

7
Source/CTest/cmParseGTMCoverage.h
View File

@ -13,8 +13,15 @@
#ifndef cmParseGTMCoverage_h #ifndef cmParseGTMCoverage_h
#define cmParseGTMCoverage_h #define cmParseGTMCoverage_h
#include <cmConfigure.h>
#include "cmParseMumpsCoverage.h" #include "cmParseMumpsCoverage.h"
#include <string>
class cmCTest;
class cmCTestCoverageHandlerContainer;
/** \class cmParseGTMCoverage /** \class cmParseGTMCoverage
* \brief Parse GTM coverage information * \brief Parse GTM coverage information
* *

7
Source/CTest/cmParseJacocoCoverage.cxx
View File

@ -1,12 +1,17 @@
#include "cmParseJacocoCoverage.h" #include "cmParseJacocoCoverage.h"
#include <cmConfigure.h>
#include "cmCTest.h"
#include "cmCTestCoverageHandler.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include "cmXMLParser.h" #include "cmXMLParser.h"
#include <cmsys/Directory.hxx> #include <cmsys/Directory.hxx>
#include <cmsys/FStream.hxx> #include <cmsys/FStream.hxx>
#include <cmsys/Glob.hxx> #include <cmsys/Glob.hxx>
#include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h>
class cmParseJacocoCoverage::XMLParser : public cmXMLParser class cmParseJacocoCoverage::XMLParser : public cmXMLParser
{ {

10
Source/CTest/cmParseJacocoCoverage.h
View File

@ -13,7 +13,14 @@
#ifndef cmParseJacocoCoverage_h #ifndef cmParseJacocoCoverage_h
#define cmParseJacocoCoverage_h #define cmParseJacocoCoverage_h
#include "cmCTestCoverageHandler.h" #include <cmConfigure.h> // IWYU pragma: keep
#include <map>
#include <string>
#include <vector>
class cmCTest;
class cmCTestCoverageHandlerContainer;
/** \class cmParseJacocoCoverage /** \class cmParseJacocoCoverage
* \brief Parse JaCoCO coverage information * \brief Parse JaCoCO coverage information
@ -47,6 +54,7 @@ private:
bool LoadSource(std::string d); bool LoadSource(std::string d);
class XMLParser; class XMLParser;
std::map<std::string, std::string> RoutineToDirectory; std::map<std::string, std::string> RoutineToDirectory;
cmCTestCoverageHandlerContainer& Coverage; cmCTestCoverageHandlerContainer& Coverage;
cmCTest* CTest; cmCTest* CTest;

13
Source/CTest/cmParseMumpsCoverage.cxx
View File

@ -1,11 +1,16 @@
#include "cmParseGTMCoverage.h" #include "cmParseMumpsCoverage.h"
#include "cmCTest.h"
#include "cmCTestCoverageHandler.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include <cmsys/Directory.hxx>
#include <cmConfigure.h>
#include <cmsys/FStream.hxx> #include <cmsys/FStream.hxx>
#include <cmsys/Glob.hxx> #include <cmsys/Glob.hxx>
#include <stdio.h> #include <map>
#include <stdlib.h> #include <string>
#include <utility>
#include <vector>
cmParseMumpsCoverage::cmParseMumpsCoverage( cmParseMumpsCoverage::cmParseMumpsCoverage(
cmCTestCoverageHandlerContainer& cont, cmCTest* ctest) cmCTestCoverageHandlerContainer& cont, cmCTest* ctest)

8
Source/CTest/cmParseMumpsCoverage.h
View File

@ -13,7 +13,13 @@
#ifndef cmParseMumpsCoverage_h #ifndef cmParseMumpsCoverage_h
#define cmParseMumpsCoverage_h #define cmParseMumpsCoverage_h
#include "cmCTestCoverageHandler.h" #include <cmConfigure.h> // IWYU pragma: keep
#include <map>
#include <string>
class cmCTest;
class cmCTestCoverageHandlerContainer;
/** \class cmParseMumpsCoverage /** \class cmParseMumpsCoverage
* \brief Parse Mumps coverage information * \brief Parse Mumps coverage information

5
Source/CTest/cmParsePHPCoverage.cxx
View File

@ -1,8 +1,13 @@
#include "cmParsePHPCoverage.h" #include "cmParsePHPCoverage.h"
#include "cmCTest.h"
#include "cmCTestCoverageHandler.h"
#include "cmSystemTools.h" #include "cmSystemTools.h"
#include <cmsys/Directory.hxx> #include <cmsys/Directory.hxx>
#include <cmsys/FStream.hxx> #include <cmsys/FStream.hxx>
#include <stdlib.h>
#include <string.h>
/* /*
To setup coverage for php. To setup coverage for php.

8
Source/CTest/cmParsePHPCoverage.h
View File

@ -13,7 +13,13 @@
#ifndef cmParsePHPCoverage_h #ifndef cmParsePHPCoverage_h
#define cmParsePHPCoverage_h #define cmParsePHPCoverage_h
#include "cmCTestCoverageHandler.h" #include <cmConfigure.h> // IWYU pragma: keep
#include <iosfwd>
#include <string>
class cmCTest;
class cmCTestCoverageHandlerContainer;
/** \class cmParsePHPCoverage /** \class cmParsePHPCoverage
* \brief Parse xdebug PHP coverage information * \brief Parse xdebug PHP coverage information

5
Source/CTest/cmProcess.cxx
View File

@ -9,10 +9,11 @@
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information. See the License for more information.
============================================================================*/ ============================================================================*/
#include "cmProcess.h"
#include <cmProcess.h> #include <cmConfigure.h>
#include <cmSystemTools.h> #include <cmSystemTools.h>
#include <iostream>
cmProcess::cmProcess() cmProcess::cmProcess()
{ {

4
Source/CTest/cmProcess.h
View File

@ -12,9 +12,11 @@
#ifndef cmProcess_h #ifndef cmProcess_h
#define cmProcess_h #define cmProcess_h
#include "cmStandardIncludes.h" #include <cmConfigure.h> // IWYU pragma: keep
#include <cmsys/Process.h> #include <cmsys/Process.h>
#include <string>
#include <vector>
/** \class cmProcess /** \class cmProcess
* \brief run a process with c++ * \brief run a process with c++