Source/CTest/cmCTestTestHandler.h

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmCTestTestHandler.h,v $
   5   Language:  C++
   6   Date:      $Date: 2009-09-10 15:16:08 $
   7   Version:   $Revision: 1.49 $
   8
   9   Copyright (c) 2002 Kitware, Inc. All rights reserved.
  10   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notices for more information.
  15
  16 =========================================================================*/
  17
  18 #ifndef cmCTestTestHandler_h
  19 #define cmCTestTestHandler_h
  20
  21
  22 #include "cmCTestGenericHandler.h"
  23 #include <cmsys/RegularExpression.hxx>
  24
  25 class cmMakefile;
  26
  27 /** \class cmCTestTestHandler
  28  * \brief A class that handles ctest -S invocations
  29  *
  30  */
  31 class cmCTestTestHandler : public cmCTestGenericHandler
  32 {
  33   friend class cmCTestRunTest;
  34   friend class cmCTestMultiProcessHandler;
  35   friend class cmCTestBatchTestHandler;
  36 public:
  37   cmTypeMacro(cmCTestTestHandler, cmCTestGenericHandler);
  38
  39   /**
  40    * The main entry point for this class
  41    */
  42   int ProcessHandler();
  43
  44   /**
  45    * When both -R and -I are used should te resulting test list be the
  46    * intersection or the union of the lists. By default it is the
  47    * intersection.
  48    */
  49   void SetUseUnion(bool val) { this->UseUnion = val; }
  50
  51   /**
  52    * This method is called when reading CTest custom file
  53    */
  54   void PopulateCustomVectors(cmMakefile *mf);
  55
  56   ///! Control the use of the regular expresisons, call these methods to turn
  57   ///them on
  58   void UseIncludeRegExp();
  59   void UseExcludeRegExp();
  60   void SetIncludeRegExp(const char *);
  61   void SetExcludeRegExp(const char *);
  62
  63   void SetMaxIndex(int n) {this->MaxIndex = n;}
  64   int GetMaxIndex() {return this->MaxIndex;}
  65
  66   ///! pass the -I argument down
  67   void SetTestsToRunInformation(const char*);
  68
  69   cmCTestTestHandler();
  70
  71   /*
  72    * Add the test to the list of tests to be executed
  73    */
  74   bool AddTest(const std::vector<std::string>& args);
  75
  76   /*
  77    * Set tests properties
  78    */
  79   bool SetTestsProperties(const std::vector<std::string>& args);
  80
  81   void Initialize();
  82
  83   // NOTE: This struct is Saved/Restored
  84   // in cmCTestTestHandler, if you add to this class
  85   // then you must add the new members to that code or
  86   // ctest -j N will break for that feature
  87   struct cmCTestTestProperties
  88   {
  89     cmStdString Name;
  90     cmStdString Directory;
  91     std::vector<std::string> Args;
  92     std::vector<std::string> Depends;
  93     std::vector<std::pair<cmsys::RegularExpression,
  94                           std::string> > ErrorRegularExpressions;
  95     std::vector<std::pair<cmsys::RegularExpression,
  96                           std::string> > RequiredRegularExpressions;
  97     std::map<cmStdString, cmStdString> Measurements;
  98     bool IsInBasedOnREOptions;
  99     bool WillFail;
 100     float Cost;
 101     bool RunSerial;
 102     double Timeout;
 103     int Index;
 104     //Requested number of process slots
 105     int Processors;
 106     std::vector<std::string> Environment;
 107     std::vector<std::string> Labels;
 108   };
 109
 110   struct cmCTestTestResult
 111   {
 112     std::string Name;
 113     std::string Path;
 114     std::string Reason;
 115     std::string FullCommandLine;
 116     double      ExecutionTime;
 117     int         ReturnValue;
 118     int         Status;
 119     std::string CompletionStatus;
 120     std::string Output;
 121     std::string RegressionImages;
 122     int         TestCount;
 123     cmCTestTestProperties* Properties;
 124   };
 125
 126   // add configuraitons to a search path for an executable
 127   static void AddConfigurations(cmCTest *ctest,
 128                                 std::vector<std::string> &attempted,
 129                                 std::vector<std::string> &attemptedConfigs,
 130                                 std::string filepath,
 131                                 std::string &filename);
 132
 133   // full signature static method to find an executable
 134   static std::string FindExecutable(cmCTest *ctest,
 135                                     const char *testCommand,
 136                                     std::string &resultingConfig,
 137                                     std::vector<std::string> &extraPaths,
 138                                     std::vector<std::string> &failed);
 139
 140   typedef std::vector<cmCTestTestProperties> ListOfTests;
 141 protected:
 142   // comput a final test list
 143   virtual int PreProcessHandler();
 144   virtual int PostProcessHandler();
 145   virtual void GenerateTestCommand(std::vector<std::string>& args);
 146   int ExecuteCommands(std::vector<cmStdString>& vec);
 147
 148   void WriteTestResultHeader(std::ostream& os, cmCTestTestResult* result);
 149   void WriteTestResultFooter(std::ostream& os, cmCTestTestResult* result);
 150
 151   //! Clean test output to specified length
 152   bool CleanTestOutput(std::string& output, size_t length);
 153
 154   double                  ElapsedTestingTime;
 155
 156   typedef std::vector<cmCTestTestResult> TestResultsVector;
 157   TestResultsVector    TestResults;
 158
 159   std::vector<cmStdString> CustomTestsIgnore;
 160   std::string             StartTest;
 161   std::string             EndTest;
 162   unsigned int            StartTestTime;
 163   unsigned int            EndTestTime;
 164   bool MemCheck;
 165   int CustomMaximumPassedTestOutputSize;
 166   int CustomMaximumFailedTestOutputSize;
 167   int MaxIndex;
 168 public:
 169   enum { // Program statuses
 170     NOT_RUN = 0,
 171     TIMEOUT,
 172     SEGFAULT,
 173     ILLEGAL,
 174     INTERRUPT,
 175     NUMERICAL,
 176     OTHER_FAULT,
 177     FAILED,
 178     BAD_COMMAND,
 179     COMPLETED
 180   };
 181
 182 private:
 183   /**
 184    * Generate the Dart compatible output
 185    */
 186   virtual void GenerateDartOutput(std::ostream& os);
 187
 188   void PrintLabelSummary();
 189   /**
 190    * Run the tests for a directory and any subdirectories
 191    */
 192   void ProcessDirectory(std::vector<cmStdString> &passed,
 193                         std::vector<cmStdString> &failed);
 194
 195   /**
 196    * Get the list of tests in directory and subdirectories.
 197    */
 198   void GetListOfTests();
 199   // compute the lists of tests that will actually run
 200   // based on union regex and -I stuff
 201   void ComputeTestList();
 202
 203   bool GetValue(const char* tag,
 204                 std::string& value,
 205                 std::ifstream& fin);
 206   bool GetValue(const char* tag,
 207                 int& value,
 208                 std::ifstream& fin);
 209   bool GetValue(const char* tag,
 210                 size_t& value,
 211                 std::ifstream& fin);
 212   bool GetValue(const char* tag,
 213                 bool& value,
 214                 std::ifstream& fin);
 215   bool GetValue(const char* tag,
 216                 double& value,
 217                 std::ifstream& fin);
 218   /**
 219    * Find the executable for a test
 220    */
 221   std::string FindTheExecutable(const char *exe);
 222
 223   const char* GetTestStatus(int status);
 224   void ExpandTestsToRunInformation(size_t numPossibleTests);
 225
 226   std::vector<cmStdString> CustomPreTest;
 227   std::vector<cmStdString> CustomPostTest;
 228
 229   std::vector<int>        TestsToRun;
 230
 231   bool UseIncludeLabelRegExpFlag;
 232   bool UseExcludeLabelRegExpFlag;
 233   bool UseIncludeRegExpFlag;
 234   bool UseExcludeRegExpFlag;
 235   bool UseExcludeRegExpFirst;
 236   std::string IncludeLabelRegExp;
 237   std::string ExcludeLabelRegExp;
 238   std::string IncludeRegExp;
 239   std::string ExcludeRegExp;
 240   cmsys::RegularExpression IncludeLabelRegularExpression;
 241   cmsys::RegularExpression ExcludeLabelRegularExpression;
 242   cmsys::RegularExpression IncludeTestsRegularExpression;
 243   cmsys::RegularExpression ExcludeTestsRegularExpression;
 244
 245   std::string GenerateRegressionImages(const std::string& xml);
 246   cmsys::RegularExpression DartStuff1;
 247   void CheckLabelFilter(cmCTestTestProperties& it);
 248   void CheckLabelFilterExclude(cmCTestTestProperties& it);
 249   void CheckLabelFilterInclude(cmCTestTestProperties& it);
 250
 251   std::string TestsToRunString;
 252   bool UseUnion;
 253   ListOfTests TestList;
 254   size_t TotalNumberOfTests;
 255   cmsys::RegularExpression DartStuff;
 256
 257   std::ostream* LogFile;
 258 };
 259
 260 #endif