cmCTestTestHandler.h 5.43 KB
Newer Older
Ken Martin's avatar
Ken Martin committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/*=========================================================================

  Program:   CMake - Cross-Platform Makefile Generator
  Module:    $RCSfile$
  Language:  C++
  Date:      $Date$
  Version:   $Revision$

  Copyright (c) 2002 Kitware, Inc. All rights reserved.
  See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.

     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.

=========================================================================*/

#ifndef cmCTestTestHandler_h
#define cmCTestTestHandler_h


22
#include "cmCTestGenericHandler.h"
Ken Martin's avatar
Ken Martin committed
23
24
25
26
27
28
29
30
#include "cmListFileCache.h"

class cmMakefile;

/** \class cmCTestTestHandler
 * \brief A class that handles ctest -S invocations
 *
 */
31
class cmCTestTestHandler : public cmCTestGenericHandler
Ken Martin's avatar
Ken Martin committed
32
33
34
35
36
37
{
public:

  /*
   * The main entry point for this class
   */
38
  int TestDirectory(bool memcheck);
Ken Martin's avatar
Ken Martin committed
39
  
40
41
42
43
44
45
46
47
48
  /*
   * When both -R and -I are used should te resulting test list be the
   * intersection or the union of the lists. By default it is the
   * intersection.
   */
  void SetUseUnion(bool val) { m_UseUnion = val; }

  void PopulateCustomVectors(cmMakefile *mf);
  
Ken Martin's avatar
Ken Martin committed
49
50
51
52
53
54
55
56
57
58
59
60
  ///! Control the use of the regular expresisons, call these methods to turn
  ///them on
  void UseIncludeRegExp();
  void UseExcludeRegExp();
  void SetIncludeRegExp(const char *);
  void SetExcludeRegExp(const char *);
  
  cmCTestTestHandler();

  ///! pass the -I argument down
  void SetTestsToRunInformation(const char*);

Ken Martin's avatar
Ken Martin committed
61
  typedef std::vector<cmListFileArgument> tm_VectorOfListFileArgs;
62
  
Ken Martin's avatar
Ken Martin committed
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
private:

  enum { // Memory checkers
    UNKNOWN = 0,
    VALGRIND,
    PURIFY,
    BOUNDS_CHECKER
  };

  enum { // Memory faults
    ABR = 0,
    ABW,
    ABWL,
    COR,
    EXU,
    FFM,
    FIM,
    FMM,
    FMR,
    FMW,
    FUM,
    IPR,
    IPW,
    MAF,
    MLK,
    MPK,
    NPR,
    ODS,
    PAR,
    PLK,
    UMC,
    UMR,
    NO_MEMORY_FAULT
  };
  
  enum { // Program statuses
    NOT_RUN = 0,
    TIMEOUT,
    SEGFAULT,
    ILLEGAL,
    INTERRUPT,
    NUMERICAL,
    OTHER_FAULT,
    FAILED,
    BAD_COMMAND,
    COMPLETED
  };

  std::string              m_MemoryTester;
  std::vector<cmStdString> m_MemoryTesterOptionsParsed;
  std::string              m_MemoryTesterOptions;
  int                      m_MemoryTesterStyle;
  std::string              m_MemoryTesterOutputFile;
  int                      m_MemoryTesterGlobalResults[NO_MEMORY_FAULT];

  
  struct cmCTestTestResult
  {
    std::string m_Name;
    std::string m_Path;
    std::string m_FullCommandLine;
    double      m_ExecutionTime;
    int         m_ReturnValue;
    int         m_Status;
    std::string m_CompletionStatus;
    std::string m_Output;
    std::string m_RegressionImages;
    int         m_TestCount;
  };

  typedef std::vector<cmCTestTestResult> tm_TestResultsVector;
  tm_TestResultsVector    m_TestResults;

  int ExecuteCommands(std::vector<cmStdString>& vec);

  ///! Initialize memory checking subsystem.
  bool InitializeMemoryChecking();

  /**
   * Generate the Dart compatible output
   */
  void GenerateDartTestOutput(std::ostream& os);
  void GenerateDartMemCheckOutput(std::ostream& os);

  /**
   * Run the test for a directory and any subdirectories
   */
  void ProcessDirectory(std::vector<cmStdString> &passed, 
                        std::vector<cmStdString> &failed,
                        bool memcheck);
153
  
Ken Martin's avatar
Ken Martin committed
154
  struct cmCTestTestProperties
155
  {
Ken Martin's avatar
Ken Martin committed
156
157
158
    cmStdString m_Name;
    cmStdString m_Directory;
    tm_VectorOfListFileArgs m_Args;
159
160
    bool m_IsInBasedOnREOptions;
  };
Ken Martin's avatar
Ken Martin committed
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182

  typedef std::vector<cmCTestTestProperties> tm_ListOfTests;
  /**
   * Get the list of tests in directory and subdirectories.
   */
  void GetListOfTests(tm_ListOfTests* testlist, bool memcheck);

  /**
   * Find the executable for a test
   */
  std::string FindTheExecutable(const char *exe);

  const char* GetTestStatus(int status);
  void ExpandTestsToRunInformation(int numPossibleTests);

  std::vector<cmStdString> m_CustomPreTest;
  std::vector<cmStdString> m_CustomPostTest;
  std::vector<cmStdString> m_CustomPreMemCheck;
  std::vector<cmStdString> m_CustomPostMemCheck;
  std::vector<cmStdString> m_CustomTestsIgnore;
  std::vector<cmStdString> m_CustomMemCheckIgnore;

183
184
185
  int m_CustomMaximumPassedTestOutputSize;
  int m_CustomMaximumFailedTestOutputSize;

Ken Martin's avatar
Ken Martin committed
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
  std::string             m_StartTest;
  std::string             m_EndTest;
  double                  m_ElapsedTestingTime;
  std::vector<int>        m_TestsToRun;

  bool m_UseIncludeRegExp;
  bool m_UseExcludeRegExp;
  bool m_UseExcludeRegExpFirst;
  std::string m_IncludeRegExp;
  std::string m_ExcludeRegExp;

  std::string GenerateRegressionImages(const std::string& xml);

  //! Parse Valgrind/Purify/Bounds Checker result out of the output
  //string. After running, log holds the output and results hold the
  //different memmory errors.
  bool ProcessMemCheckOutput(const std::string& str, 
                             std::string& log, int* results);
  bool ProcessMemCheckValgrindOutput(const std::string& str, 
                                     std::string& log, int* results);
  bool ProcessMemCheckPurifyOutput(const std::string& str, 
                                   std::string& log, int* results);

209
210
211
  //! Clean test output to specified length
  bool CleanTestOutput(std::string& output, size_t length);

Ken Martin's avatar
Ken Martin committed
212
  std::string TestsToRunString;
213
  bool m_UseUnion;
Ken Martin's avatar
Ken Martin committed
214
215
216
};

#endif