gtest-internal-inl.h 45.8 KB
Newer Older
shiqian's avatar
shiqian committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Gennadiy Civil's avatar
 
Gennadiy Civil committed
30
// Utility functions and classes used by the Google C++ testing framework.//
shiqian's avatar
shiqian committed
31
32
33
// This file contains purely Google Test's internal implementation.  Please
// DO NOT #INCLUDE IT IN A USER PROGRAM.

Abseil Team's avatar
Abseil Team committed
34
35
#ifndef GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_
#define GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_
shiqian's avatar
shiqian committed
36

37
#ifndef _WIN32_WCE
38
# include <errno.h>
39
#endif  // !_WIN32_WCE
shiqian's avatar
shiqian committed
40
#include <stddef.h>
41
42
#include <stdlib.h>  // For strtoll/_strtoul64/malloc/free.
#include <string.h>  // For memmove.
shiqian's avatar
shiqian committed
43

44
#include <algorithm>
Abseil Team's avatar
Abseil Team committed
45
#include <cstdint>
misterg's avatar
misterg committed
46
#include <memory>
47
#include <string>
48
#include <vector>
49

50
#include "gtest/internal/gtest-port.h"
51

kosak's avatar
kosak committed
52
53
54
55
56
#if GTEST_CAN_STREAM_RESULTS_
# include <arpa/inet.h>  // NOLINT
# include <netdb.h>  // NOLINT
#endif

zhanyong.wan's avatar
zhanyong.wan committed
57
#if GTEST_OS_WINDOWS
58
# include <windows.h>  // NOLINT
shiqian's avatar
shiqian committed
59
60
#endif  // GTEST_OS_WINDOWS

Gennadiy Civil's avatar
Gennadiy Civil committed
61
#include "gtest/gtest.h"
62
#include "gtest/gtest-spi.h"
shiqian's avatar
shiqian committed
63

misterg's avatar
misterg committed
64
65
66
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
/* class A needs to have dll-interface to be used by clients of class B */)

shiqian's avatar
shiqian committed
67
68
// Declares the flags.
//
69
70
71
// We don't want the users to modify this flag in the code, but want
// Google Test's own unit tests to be able to access it. Therefore we
// declare it here as opposed to in gtest.h.
72
GTEST_DECLARE_bool_(death_test_use_fork);
shiqian's avatar
shiqian committed
73

Abseil Team's avatar
Abseil Team committed
74
namespace testing {
shiqian's avatar
shiqian committed
75
76
namespace internal {

77
78
// The value of GetTestTypeId() as seen from within the Google Test
// library.  This is solely for testing GetTestTypeId().
zhanyong.wan's avatar
zhanyong.wan committed
79
GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest;
80

81
// A valid random seed must be in [1, kMaxRandomSeed].
82
const int kMaxRandomSeed = 99999;
83

84
85
// g_help_flag is true if and only if the --help flag or an equivalent form
// is specified on the command line.
zhanyong.wan's avatar
zhanyong.wan committed
86
87
GTEST_API_ extern bool g_help_flag;

88
// Returns the current time in milliseconds.
zhanyong.wan's avatar
zhanyong.wan committed
89
90
GTEST_API_ TimeInMillis GetTimeInMillis();

91
// Returns true if and only if Google Test should use colors in the output.
zhanyong.wan's avatar
zhanyong.wan committed
92
93
94
95
96
GTEST_API_ bool ShouldUseColor(bool stdout_is_tty);

// Formats the given time in milliseconds as seconds.
GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms);

97
98
99
100
101
102
// Converts the given time in milliseconds to a date string in the ISO 8601
// format, without the timezone information.  N.B.: due to the use the
// non-reentrant localtime() function, this function is not thread safe.  Do
// not use it in any code that can be called from multiple threads.
GTEST_API_ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms);

zhanyong.wan's avatar
zhanyong.wan committed
103
104
105
106
// Parses a string for an Int32 flag, in the form of "--flag=value".
//
// On success, stores the value of the flag in *value, and returns
// true.  On failure, returns false without changing *value.
Abseil Team's avatar
Abseil Team committed
107
GTEST_API_ bool ParseFlag(const char* str, const char* flag, int32_t* value);
108
109
110

// Returns a random seed in range [1, kMaxRandomSeed] based on the
// given --gtest_random_seed flag value.
Abseil Team's avatar
Abseil Team committed
111
inline int GetRandomSeedFromFlag(int32_t random_seed_flag) {
112
113
114
115
116
117
118
  const unsigned int raw_seed = (random_seed_flag == 0) ?
      static_cast<unsigned int>(GetTimeInMillis()) :
      static_cast<unsigned int>(random_seed_flag);

  // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
  // it's easy to type.
  const int normalized_seed =
119
120
      static_cast<int>((raw_seed - 1U) %
                       static_cast<unsigned int>(kMaxRandomSeed)) + 1;
121
122
123
124
125
126
127
128
129
130
131
132
133
134
  return normalized_seed;
}

// Returns the first valid random seed after 'seed'.  The behavior is
// undefined if 'seed' is invalid.  The seed after kMaxRandomSeed is
// considered to be 1.
inline int GetNextRandomSeed(int seed) {
  GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
      << "Invalid random seed " << seed << " - must be in [1, "
      << kMaxRandomSeed << "].";
  const int next_seed = seed + 1;
  return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
}

shiqian's avatar
shiqian committed
135
136
137
138
139
140
// This class saves the values of all Google Test flags in its c'tor, and
// restores them in its d'tor.
class GTestFlagSaver {
 public:
  // The c'tor.
  GTestFlagSaver() {
Abseil Team's avatar
Abseil Team committed
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
    also_run_disabled_tests_ = GTEST_FLAG_GET(also_run_disabled_tests);
    break_on_failure_ = GTEST_FLAG_GET(break_on_failure);
    catch_exceptions_ = GTEST_FLAG_GET(catch_exceptions);
    color_ = GTEST_FLAG_GET(color);
    death_test_style_ = GTEST_FLAG_GET(death_test_style);
    death_test_use_fork_ = GTEST_FLAG_GET(death_test_use_fork);
    fail_fast_ = GTEST_FLAG_GET(fail_fast);
    filter_ = GTEST_FLAG_GET(filter);
    internal_run_death_test_ = GTEST_FLAG_GET(internal_run_death_test);
    list_tests_ = GTEST_FLAG_GET(list_tests);
    output_ = GTEST_FLAG_GET(output);
    brief_ = GTEST_FLAG_GET(brief);
    print_time_ = GTEST_FLAG_GET(print_time);
    print_utf8_ = GTEST_FLAG_GET(print_utf8);
    random_seed_ = GTEST_FLAG_GET(random_seed);
    repeat_ = GTEST_FLAG_GET(repeat);
Abseil Team's avatar
Abseil Team committed
157
    recreate_environments_when_repeating_ =
Abseil Team's avatar
Abseil Team committed
158
159
160
161
162
        GTEST_FLAG_GET(recreate_environments_when_repeating);
    shuffle_ = GTEST_FLAG_GET(shuffle);
    stack_trace_depth_ = GTEST_FLAG_GET(stack_trace_depth);
    stream_result_to_ = GTEST_FLAG_GET(stream_result_to);
    throw_on_failure_ = GTEST_FLAG_GET(throw_on_failure);
shiqian's avatar
shiqian committed
163
164
165
166
  }

  // The d'tor is not virtual.  DO NOT INHERIT FROM THIS CLASS.
  ~GTestFlagSaver() {
Abseil Team's avatar
Abseil Team committed
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
    GTEST_FLAG_SET(also_run_disabled_tests, also_run_disabled_tests_);
    GTEST_FLAG_SET(break_on_failure, break_on_failure_);
    GTEST_FLAG_SET(catch_exceptions, catch_exceptions_);
    GTEST_FLAG_SET(color, color_);
    GTEST_FLAG_SET(death_test_style, death_test_style_);
    GTEST_FLAG_SET(death_test_use_fork, death_test_use_fork_);
    GTEST_FLAG_SET(filter, filter_);
    GTEST_FLAG_SET(fail_fast, fail_fast_);
    GTEST_FLAG_SET(internal_run_death_test, internal_run_death_test_);
    GTEST_FLAG_SET(list_tests, list_tests_);
    GTEST_FLAG_SET(output, output_);
    GTEST_FLAG_SET(brief, brief_);
    GTEST_FLAG_SET(print_time, print_time_);
    GTEST_FLAG_SET(print_utf8, print_utf8_);
    GTEST_FLAG_SET(random_seed, random_seed_);
    GTEST_FLAG_SET(repeat, repeat_);
    GTEST_FLAG_SET(recreate_environments_when_repeating,
                   recreate_environments_when_repeating_);
    GTEST_FLAG_SET(shuffle, shuffle_);
    GTEST_FLAG_SET(stack_trace_depth, stack_trace_depth_);
    GTEST_FLAG_SET(stream_result_to, stream_result_to_);
    GTEST_FLAG_SET(throw_on_failure, throw_on_failure_);
shiqian's avatar
shiqian committed
189
  }
190

shiqian's avatar
shiqian committed
191
192
 private:
  // Fields for saving the original values of flags.
193
  bool also_run_disabled_tests_;
shiqian's avatar
shiqian committed
194
195
  bool break_on_failure_;
  bool catch_exceptions_;
196
197
  std::string color_;
  std::string death_test_style_;
198
  bool death_test_use_fork_;
Abseil Team's avatar
Abseil Team committed
199
  bool fail_fast_;
200
201
  std::string filter_;
  std::string internal_run_death_test_;
shiqian's avatar
shiqian committed
202
  bool list_tests_;
203
  std::string output_;
Calum Robinson's avatar
Calum Robinson committed
204
  bool brief_;
205
  bool print_time_;
Gennadiy Civil's avatar
Gennadiy Civil committed
206
  bool print_utf8_;
Abseil Team's avatar
Abseil Team committed
207
208
  int32_t random_seed_;
  int32_t repeat_;
Abseil Team's avatar
Abseil Team committed
209
  bool recreate_environments_when_repeating_;
210
  bool shuffle_;
Abseil Team's avatar
Abseil Team committed
211
  int32_t stack_trace_depth_;
212
  std::string stream_result_to_;
213
  bool throw_on_failure_;
shiqian's avatar
shiqian committed
214
} GTEST_ATTRIBUTE_UNUSED_;
shiqian's avatar
shiqian committed
215

216
217
218
219
// Converts a Unicode code point to a narrow string in UTF-8 encoding.
// code_point parameter is of type UInt32 because wchar_t may not be
// wide enough to contain a code point.
// If the code_point is not a valid Unicode code point
220
221
// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
// to "(Invalid Unicode 0xXXXXXXXX)".
Abseil Team's avatar
Abseil Team committed
222
GTEST_API_ std::string CodePointToUtf8(uint32_t code_point);
223
224
225

// Converts a wide string to a narrow string in UTF-8 encoding.
// The wide string is assumed to have the following encoding:
Abseil Team's avatar
Abseil Team committed
226
//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin)
227
228
229
230
231
232
233
234
235
236
//   UTF-32 if sizeof(wchar_t) == 4 (on Linux)
// Parameter str points to a null-terminated wide string.
// Parameter num_chars may additionally limit the number
// of wchar_t characters processed. -1 is used when the entire string
// should be processed.
// If the string contains code points that are not valid Unicode code points
// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
// and contains invalid UTF-16 surrogate pairs, values in those pairs
// will be encoded as individual Unicode characters from Basic Normal Plane.
237
GTEST_API_ std::string WideStringToUtf8(const wchar_t* str, int num_chars);
shiqian's avatar
shiqian committed
238

239
240
241
242
243
244
245
246
247
248
249
250
// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
// if the variable is present. If a file already exists at this location, this
// function will write over it. If the variable is present, but the file cannot
// be created, prints an error and exits.
void WriteToShardStatusFileIfNeeded();

// Checks whether sharding is enabled by examining the relevant
// environment variable values. If the variables are present,
// but inconsistent (e.g., shard_index >= total_shards), prints
// an error and exits. If in_subprocess_for_death_test, sharding is
// disabled because it must only be applied to the original test
// process. Otherwise, we could filter out death tests we intended to execute.
zhanyong.wan's avatar
zhanyong.wan committed
251
252
253
GTEST_API_ bool ShouldShard(const char* total_shards_str,
                            const char* shard_index_str,
                            bool in_subprocess_for_death_test);
254

Abseil Team's avatar
Abseil Team committed
255
256
// Parses the environment variable var as a 32-bit integer. If it is unset,
// returns default_val. If it is not a 32-bit integer, prints an error and
257
// and aborts.
Abseil Team's avatar
Abseil Team committed
258
GTEST_API_ int32_t Int32FromEnvOrDie(const char* env_var, int32_t default_val);
259
260

// Given the total number of shards, the shard index, and the test id,
261
262
// returns true if and only if the test should be run on this shard. The test id
// is some arbitrary but unique non-negative integer assigned to each test
263
// method. Assumes that 0 <= shard_index < total_shards.
zhanyong.wan's avatar
zhanyong.wan committed
264
265
GTEST_API_ bool ShouldRunTestOnShard(
    int total_shards, int shard_index, int test_id);
266

267
// STL container utilities.
shiqian's avatar
shiqian committed
268

269
270
271
272
// Returns the number of elements in the given container that satisfy
// the given predicate.
template <class Container, typename Predicate>
inline int CountIf(const Container& c, Predicate predicate) {
273
274
275
  // Implemented as an explicit loop since std::count_if() in libCstd on
  // Solaris has a non-standard signature.
  int count = 0;
276
  for (auto it = c.begin(); it != c.end(); ++it) {
277
278
279
280
    if (predicate(*it))
      ++count;
  }
  return count;
281
}
282

283
284
285
286
287
// Applies a function/functor to each element in the container.
template <class Container, typename Functor>
void ForEach(const Container& c, Functor functor) {
  std::for_each(c.begin(), c.end(), functor);
}
288

289
290
291
292
// Returns the i-th element of the vector, or default_value if i is not
// in range [0, v.size()).
template <typename E>
inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
293
294
  return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
                                                    : v[static_cast<size_t>(i)];
295
}
296

297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
// Performs an in-place shuffle of a range of the vector's elements.
// 'begin' and 'end' are element indices as an STL-style range;
// i.e. [begin, end) are shuffled, where 'end' == size() means to
// shuffle to the end of the vector.
template <typename E>
void ShuffleRange(internal::Random* random, int begin, int end,
                  std::vector<E>* v) {
  const int size = static_cast<int>(v->size());
  GTEST_CHECK_(0 <= begin && begin <= size)
      << "Invalid shuffle range start " << begin << ": must be in range [0, "
      << size << "].";
  GTEST_CHECK_(begin <= end && end <= size)
      << "Invalid shuffle range finish " << end << ": must be in range ["
      << begin << ", " << size << "].";

  // Fisher-Yates shuffle, from
  // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
  for (int range_width = end - begin; range_width >= 2; range_width--) {
    const int last_in_range = begin + range_width - 1;
316
317
    const int selected =
        begin +
Abseil Team's avatar
Abseil Team committed
318
        static_cast<int>(random->Generate(static_cast<uint32_t>(range_width)));
319
320
    std::swap((*v)[static_cast<size_t>(selected)],
              (*v)[static_cast<size_t>(last_in_range)]);
321
  }
322
}
323

324
325
326
// Performs an in-place shuffle of the vector's elements.
template <typename E>
inline void Shuffle(internal::Random* random, std::vector<E>* v) {
327
  ShuffleRange(random, 0, static_cast<int>(v->size()), v);
328
}
shiqian's avatar
shiqian committed
329
330
331
332

// A function for deleting an object.  Handy for being used as a
// functor.
template <typename T>
333
static void Delete(T* x) {
shiqian's avatar
shiqian committed
334
335
336
337
338
339
340
341
342
343
344
  delete x;
}

// A predicate that checks the key of a TestProperty against a known key.
//
// TestPropertyKeyIs is copyable.
class TestPropertyKeyIs {
 public:
  // Constructor.
  //
  // TestPropertyKeyIs has NO default constructor.
345
  explicit TestPropertyKeyIs(const std::string& key) : key_(key) {}
shiqian's avatar
shiqian committed
346

347
  // Returns true if and only if the test name of test property matches on key_.
shiqian's avatar
shiqian committed
348
  bool operator()(const TestProperty& test_property) const {
349
    return test_property.key() == key_;
shiqian's avatar
shiqian committed
350
351
352
  }

 private:
353
  std::string key_;
shiqian's avatar
shiqian committed
354
355
356
357
358
359
360
361
362
363
364
365
};

// Class UnitTestOptions.
//
// This class contains functions for processing options the user
// specifies when running the tests.  It has only static members.
//
// In most cases, the user can specify an option using either an
// environment variable or a command line flag.  E.g. you can set the
// test filter using either GTEST_FILTER or --gtest_filter.  If both
// the variable and the flag are present, the latter overrides the
// former.
zhanyong.wan's avatar
zhanyong.wan committed
366
class GTEST_API_ UnitTestOptions {
shiqian's avatar
shiqian committed
367
368
369
370
 public:
  // Functions for processing the gtest_output flag.

  // Returns the output format, or "" for normal printed output.
371
  static std::string GetOutputFormat();
shiqian's avatar
shiqian committed
372

373
374
375
  // Returns the absolute path of the requested output file, or the
  // default (test_detail.xml in the original working directory) if
  // none was explicitly specified.
376
  static std::string GetAbsolutePathToOutputFile();
shiqian's avatar
shiqian committed
377
378
379

  // Functions for processing the gtest_filter flag.

380
381
  // Returns true if and only if the user-specified filter matches the test
  // suite name and the test name.
misterg's avatar
misterg committed
382
383
  static bool FilterMatchesTest(const std::string& test_suite_name,
                                const std::string& test_name);
shiqian's avatar
shiqian committed
384

zhanyong.wan's avatar
zhanyong.wan committed
385
#if GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
386
387
388
389
390
391
392
  // Function for supporting the gtest_catch_exception flag.

  // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
  // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
  // This function is useful as an __except condition.
  static int GTestShouldProcessSEH(DWORD exception_code);
#endif  // GTEST_OS_WINDOWS
393

shiqian's avatar
shiqian committed
394
395
  // Returns true if "name" matches the ':' separated list of glob-style
  // filters in "filter".
396
  static bool MatchesFilter(const std::string& name, const char* filter);
shiqian's avatar
shiqian committed
397
398
399
400
};

// Returns the current application's name, removing directory path if that
// is present.  Used by UnitTestOptions::GetOutputFile.
zhanyong.wan's avatar
zhanyong.wan committed
401
GTEST_API_ FilePath GetCurrentExecutableName();
shiqian's avatar
shiqian committed
402
403
404
405
406
407
408

// The role interface for getting the OS stack trace as a string.
class OsStackTraceGetterInterface {
 public:
  OsStackTraceGetterInterface() {}
  virtual ~OsStackTraceGetterInterface() {}

409
  // Returns the current OS stack trace as an std::string.  Parameters:
shiqian's avatar
shiqian committed
410
411
412
413
414
  //
  //   max_depth  - the maximum number of stack frames to be included
  //                in the trace.
  //   skip_count - the number of top frames to be skipped; doesn't count
  //                against max_depth.
415
  virtual std::string CurrentStackTrace(int max_depth, int skip_count) = 0;
shiqian's avatar
shiqian committed
416
417
418
419
420
421

  // UponLeavingGTest() should be called immediately before Google Test calls
  // user code. It saves some information about the current stack that
  // CurrentStackTrace() will use to find and hide Google Test stack frames.
  virtual void UponLeavingGTest() = 0;

422
423
424
425
  // This string is inserted in place of stack frames that are part of
  // Google Test's implementation.
  static const char* const kElidedFramesMarker;

shiqian's avatar
shiqian committed
426
 private:
shiqian's avatar
shiqian committed
427
  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface);
shiqian's avatar
shiqian committed
428
429
};

430
// A working implementation of the OsStackTraceGetterInterface interface.
shiqian's avatar
shiqian committed
431
432
class OsStackTraceGetter : public OsStackTraceGetterInterface {
 public:
433
  OsStackTraceGetter() {}
434

Abseil Team's avatar
Abseil Team committed
435
436
  std::string CurrentStackTrace(int max_depth, int skip_count) override;
  void UponLeavingGTest() override;
shiqian's avatar
shiqian committed
437
438

 private:
439
440
441
442
443
444
445
446
447
448
#if GTEST_HAS_ABSL
  Mutex mutex_;  // Protects all internal state.

  // We save the stack frame below the frame that calls user code.
  // We do this because the address of the frame immediately below
  // the user code changes between the call to UponLeavingGTest()
  // and any calls to the stack trace code from within the user code.
  void* caller_frame_ = nullptr;
#endif  // GTEST_HAS_ABSL

shiqian's avatar
shiqian committed
449
  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter);
shiqian's avatar
shiqian committed
450
451
452
453
454
455
};

// Information about a Google Test trace point.
struct TraceInfo {
  const char* file;
  int line;
456
  std::string message;
shiqian's avatar
shiqian committed
457
458
};

shiqian's avatar
shiqian committed
459
460
461
462
463
464
465
466
// This is the default global test part result reporter used in UnitTestImpl.
// This class should only be used by UnitTestImpl.
class DefaultGlobalTestPartResultReporter
  : public TestPartResultReporterInterface {
 public:
  explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test);
  // Implements the TestPartResultReporterInterface. Reports the test part
  // result in the current test.
Abseil Team's avatar
Abseil Team committed
467
  void ReportTestPartResult(const TestPartResult& result) override;
shiqian's avatar
shiqian committed
468
469
470

 private:
  UnitTestImpl* const unit_test_;
471
472

  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter);
shiqian's avatar
shiqian committed
473
474
475
476
477
478
479
480
481
482
};

// This is the default per thread test part result reporter used in
// UnitTestImpl. This class should only be used by UnitTestImpl.
class DefaultPerThreadTestPartResultReporter
    : public TestPartResultReporterInterface {
 public:
  explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test);
  // Implements the TestPartResultReporterInterface. The implementation just
  // delegates to the current global test part result reporter of *unit_test_.
Abseil Team's avatar
Abseil Team committed
483
  void ReportTestPartResult(const TestPartResult& result) override;
shiqian's avatar
shiqian committed
484
485
486

 private:
  UnitTestImpl* const unit_test_;
487
488

  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter);
shiqian's avatar
shiqian committed
489
490
};

shiqian's avatar
shiqian committed
491
492
493
494
// The private implementation of the UnitTest class.  We don't protect
// the methods under a mutex, as this class is not accessible by a
// user and the UnitTest class that delegates work to this class does
// proper locking.
zhanyong.wan's avatar
zhanyong.wan committed
495
class GTEST_API_ UnitTestImpl {
shiqian's avatar
shiqian committed
496
497
498
499
 public:
  explicit UnitTestImpl(UnitTest* parent);
  virtual ~UnitTestImpl();

shiqian's avatar
shiqian committed
500
501
502
503
504
505
506
507
508
  // There are two different ways to register your own TestPartResultReporter.
  // You can register your own repoter to listen either only for test results
  // from the current thread or for results from all threads.
  // By default, each per-thread test result repoter just passes a new
  // TestPartResult to the global test result reporter, which registers the
  // test part result for the currently running test.

  // Returns the global test part result reporter.
  TestPartResultReporterInterface* GetGlobalTestPartResultReporter();
shiqian's avatar
shiqian committed
509

shiqian's avatar
shiqian committed
510
511
512
  // Sets the global test part result reporter.
  void SetGlobalTestPartResultReporter(
      TestPartResultReporterInterface* reporter);
shiqian's avatar
shiqian committed
513

shiqian's avatar
shiqian committed
514
515
516
517
518
519
  // Returns the test part result reporter for the current thread.
  TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread();

  // Sets the test part result reporter for the current thread.
  void SetTestPartResultReporterForCurrentThread(
      TestPartResultReporterInterface* reporter);
shiqian's avatar
shiqian committed
520

misterg's avatar
misterg committed
521
522
  // Gets the number of successful test suites.
  int successful_test_suite_count() const;
shiqian's avatar
shiqian committed
523

misterg's avatar
misterg committed
524
525
  // Gets the number of failed test suites.
  int failed_test_suite_count() const;
shiqian's avatar
shiqian committed
526

misterg's avatar
misterg committed
527
528
  // Gets the number of all test suites.
  int total_test_suite_count() const;
shiqian's avatar
shiqian committed
529

misterg's avatar
misterg committed
530
  // Gets the number of all test suites that contain at least one test
shiqian's avatar
shiqian committed
531
  // that should run.
misterg's avatar
misterg committed
532
  int test_suite_to_run_count() const;
shiqian's avatar
shiqian committed
533
534
535
536

  // Gets the number of successful tests.
  int successful_test_count() const;

537
538
539
  // Gets the number of skipped tests.
  int skipped_test_count() const;

shiqian's avatar
shiqian committed
540
541
542
  // Gets the number of failed tests.
  int failed_test_count() const;

543
544
545
  // Gets the number of disabled tests that will be reported in the XML report.
  int reportable_disabled_test_count() const;

shiqian's avatar
shiqian committed
546
547
548
  // Gets the number of disabled tests.
  int disabled_test_count() const;

549
550
551
  // Gets the number of tests to be printed in the XML report.
  int reportable_test_count() const;

shiqian's avatar
shiqian committed
552
553
554
555
556
557
  // Gets the number of all tests.
  int total_test_count() const;

  // Gets the number of tests that should run.
  int test_to_run_count() const;

558
559
560
561
  // Gets the time of the test program start, in ms from the start of the
  // UNIX epoch.
  TimeInMillis start_timestamp() const { return start_timestamp_; }

shiqian's avatar
shiqian committed
562
563
564
  // Gets the elapsed time, in milliseconds.
  TimeInMillis elapsed_time() const { return elapsed_time_; }

565
566
  // Returns true if and only if the unit test passed (i.e. all test suites
  // passed).
shiqian's avatar
shiqian committed
567
568
  bool Passed() const { return !Failed(); }

569
570
  // Returns true if and only if the unit test failed (i.e. some test suite
  // failed or something outside of all tests failed).
shiqian's avatar
shiqian committed
571
  bool Failed() const {
misterg's avatar
misterg committed
572
    return failed_test_suite_count() > 0 || ad_hoc_test_result()->Failed();
shiqian's avatar
shiqian committed
573
574
  }

misterg's avatar
misterg committed
575
576
577
578
  // Gets the i-th test suite among all the test suites. i can range from 0 to
  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
  const TestSuite* GetTestSuite(int i) const {
    const int index = GetElementOr(test_suite_indices_, i, -1);
579
    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(i)];
580
581
  }

misterg's avatar
misterg committed
582
583
584
585
586
587
588
589
590
  //  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  const TestCase* GetTestCase(int i) const { return GetTestSuite(i); }
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_

  // Gets the i-th test suite among all the test suites. i can range from 0 to
  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
  TestSuite* GetMutableSuiteCase(int i) {
    const int index = GetElementOr(test_suite_indices_, i, -1);
591
    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(index)];
592
593
  }

594
  // Provides access to the event listener list.
595
  TestEventListeners* listeners() { return &listeners_; }
596

shiqian's avatar
shiqian committed
597
598
  // Returns the TestResult for the test that's currently running, or
  // the TestResult for the ad hoc test if no test is running.
599
  TestResult* current_test_result();
shiqian's avatar
shiqian committed
600
601

  // Returns the TestResult for the ad hoc test.
602
  const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; }
shiqian's avatar
shiqian committed
603
604
605
606
607
608
609
610
611
612
613
614
615

  // Sets the OS stack trace getter.
  //
  // Does nothing if the input and the current OS stack trace getter
  // are the same; otherwise, deletes the old getter and makes the
  // input the current getter.
  void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter);

  // Returns the current OS stack trace getter if it is not NULL;
  // otherwise, creates an OsStackTraceGetter, makes it the current
  // getter, and returns it.
  OsStackTraceGetterInterface* os_stack_trace_getter();

616
  // Returns the current OS stack trace as an std::string.
shiqian's avatar
shiqian committed
617
618
619
620
621
622
623
624
625
  //
  // The maximum number of stack frames to be included is specified by
  // the gtest_stack_trace_depth flag.  The skip_count parameter
  // specifies the number of top frames to be skipped, which doesn't
  // count against the number of frames to be included.
  //
  // For example, if Foo() calls Bar(), which in turn calls
  // CurrentOsStackTraceExceptTop(1), Foo() will be included in the
  // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
626
627
  std::string CurrentOsStackTraceExceptTop(int skip_count)
      GTEST_NO_INLINE_ GTEST_NO_TAIL_CALL_;
shiqian's avatar
shiqian committed
628

misterg's avatar
misterg committed
629
  // Finds and returns a TestSuite with the given name.  If one doesn't
shiqian's avatar
shiqian committed
630
631
632
633
  // exist, creates one and returns it.
  //
  // Arguments:
  //
misterg's avatar
misterg committed
634
  //   test_suite_name: name of the test suite
Hyuk Myeong's avatar
Hyuk Myeong committed
635
636
637
638
  //   type_param:      the name of the test's type parameter, or NULL if
  //                    this is not a typed or a type-parameterized test.
  //   set_up_tc:       pointer to the function that sets up the test suite
  //   tear_down_tc:    pointer to the function that tears down the test suite
misterg's avatar
misterg committed
639
640
641
642
643
644
645
646
647
648
649
650
  TestSuite* GetTestSuite(const char* test_suite_name, const char* type_param,
                          internal::SetUpTestSuiteFunc set_up_tc,
                          internal::TearDownTestSuiteFunc tear_down_tc);

//  Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  TestCase* GetTestCase(const char* test_case_name, const char* type_param,
                        internal::SetUpTestSuiteFunc set_up_tc,
                        internal::TearDownTestSuiteFunc tear_down_tc) {
    return GetTestSuite(test_case_name, type_param, set_up_tc, tear_down_tc);
  }
#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
shiqian's avatar
shiqian committed
651
652
653
654
655

  // Adds a TestInfo to the unit test.
  //
  // Arguments:
  //
misterg's avatar
misterg committed
656
657
  //   set_up_tc:    pointer to the function that sets up the test suite
  //   tear_down_tc: pointer to the function that tears down the test suite
shiqian's avatar
shiqian committed
658
  //   test_info:    the TestInfo object
misterg's avatar
misterg committed
659
660
  void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc,
                   internal::TearDownTestSuiteFunc tear_down_tc,
661
                   TestInfo* test_info) {
662
#if GTEST_HAS_DEATH_TEST
663
664
665
666
667
668
669
670
671
    // In order to support thread-safe death tests, we need to
    // remember the original working directory when the test program
    // was first invoked.  We cannot do this in RUN_ALL_TESTS(), as
    // the user may have changed the current directory before calling
    // RUN_ALL_TESTS().  Therefore we capture the current directory in
    // AddTestInfo(), which is called to register a TEST or TEST_F
    // before main() is reached.
    if (original_working_dir_.IsEmpty()) {
      original_working_dir_.Set(FilePath::GetCurrentDir());
672
673
      GTEST_CHECK_(!original_working_dir_.IsEmpty())
          << "Failed to get the current working directory.";
674
    }
675
#endif  // GTEST_HAS_DEATH_TEST
676

misterg's avatar
misterg committed
677
678
679
    GetTestSuite(test_info->test_suite_name(), test_info->type_param(),
                 set_up_tc, tear_down_tc)
        ->AddTestInfo(test_info);
shiqian's avatar
shiqian committed
680
681
  }

misterg's avatar
misterg committed
682
  // Returns ParameterizedTestSuiteRegistry object used to keep track of
683
  // value-parameterized tests and instantiate and register them.
misterg's avatar
misterg committed
684
  internal::ParameterizedTestSuiteRegistry& parameterized_test_registry() {
685
686
687
    return parameterized_test_registry_;
  }

Abseil Team's avatar
Abseil Team committed
688
689
690
691
  std::set<std::string>* ignored_parameterized_test_suites() {
    return &ignored_parameterized_test_suites_;
  }

Abseil Team's avatar
Abseil Team committed
692
693
694
695
696
697
698
  // Returns TypeParameterizedTestSuiteRegistry object used to keep track of
  // type-parameterized tests and instantiations of them.
  internal::TypeParameterizedTestSuiteRegistry&
  type_parameterized_test_registry() {
    return type_parameterized_test_registry_;
  }

misterg's avatar
misterg committed
699
700
701
  // Sets the TestSuite object for the test that's currently running.
  void set_current_test_suite(TestSuite* a_current_test_suite) {
    current_test_suite_ = a_current_test_suite;
shiqian's avatar
shiqian committed
702
703
704
705
706
  }

  // Sets the TestInfo object for the test that's currently running.  If
  // current_test_info is NULL, the assertion results will be stored in
  // ad_hoc_test_result_.
707
708
  void set_current_test_info(TestInfo* a_current_test_info) {
    current_test_info_ = a_current_test_info;
shiqian's avatar
shiqian committed
709
710
  }

711
  // Registers all parameterized tests defined using TEST_P and
misterg's avatar
misterg committed
712
  // INSTANTIATE_TEST_SUITE_P, creating regular tests for each test/parameter
vladlosev's avatar
vladlosev committed
713
714
715
716
  // combination. This method can be called more then once; it has guards
  // protecting from registering the tests more then once.  If
  // value-parameterized tests are disabled, RegisterParameterizedTests is
  // present but does nothing.
717
718
  void RegisterParameterizedTests();

shiqian's avatar
shiqian committed
719
  // Runs all tests in this UnitTest object, prints the result, and
720
721
722
723
  // returns true if all tests are successful.  If any exception is
  // thrown during a test, this test is considered to be failed, but
  // the rest of the tests will still be run.
  bool RunAllTests();
shiqian's avatar
shiqian committed
724

725
726
  // Clears the results of all tests, except the ad hoc tests.
  void ClearNonAdHocTestResult() {
misterg's avatar
misterg committed
727
    ForEach(test_suites_, TestSuite::ClearTestSuiteResult);
728
729
730
731
  }

  // Clears the results of ad-hoc test assertions.
  void ClearAdHocTestResult() {
shiqian's avatar
shiqian committed
732
733
734
    ad_hoc_test_result_.Clear();
  }

735
  // Adds a TestProperty to the current TestResult object when invoked in a
misterg's avatar
misterg committed
736
  // context of a test or a test suite, or to the global property set. If the
737
738
739
740
  // result already contains a property with the same key, the value will be
  // updated.
  void RecordProperty(const TestProperty& test_property);

741
742
743
744
745
  enum ReactionToSharding {
    HONOR_SHARDING_PROTOCOL,
    IGNORE_SHARDING_PROTOCOL
  };

shiqian's avatar
shiqian committed
746
747
  // Matches the full name of each test against the user-specified
  // filter to decide whether the test should run, then records the
misterg's avatar
misterg committed
748
  // result in each TestSuite and TestInfo object.
749
750
  // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests
  // based on sharding variables in the environment.
shiqian's avatar
shiqian committed
751
  // Returns the number of tests that should run.
752
  int FilterTests(ReactionToSharding shard_tests);
shiqian's avatar
shiqian committed
753

754
755
  // Prints the names of the tests matching the user-specified filter flag.
  void ListTestsMatchingFilter();
shiqian's avatar
shiqian committed
756

misterg's avatar
misterg committed
757
  const TestSuite* current_test_suite() const { return current_test_suite_; }
shiqian's avatar
shiqian committed
758
759
760
  TestInfo* current_test_info() { return current_test_info_; }
  const TestInfo* current_test_info() const { return current_test_info_; }

761
  // Returns the vector of environments that need to be set-up/torn-down
shiqian's avatar
shiqian committed
762
  // before/after the tests are run.
763
  std::vector<Environment*>& environments() { return environments_; }
shiqian's avatar
shiqian committed
764
765

  // Getters for the per-thread Google Test trace stack.
766
767
  std::vector<TraceInfo>& gtest_trace_stack() {
    return *(gtest_trace_stack_.pointer());
shiqian's avatar
shiqian committed
768
  }
769
770
  const std::vector<TraceInfo>& gtest_trace_stack() const {
    return gtest_trace_stack_.get();
shiqian's avatar
shiqian committed
771
772
  }

zhanyong.wan's avatar
zhanyong.wan committed
773
#if GTEST_HAS_DEATH_TEST
774
775
776
  void InitDeathTestSubprocessControlInfo() {
    internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag());
  }
shiqian's avatar
shiqian committed
777
778
779
  // Returns a pointer to the parsed --gtest_internal_run_death_test
  // flag, or NULL if that flag was not specified.
  // This information is useful only in a death test child process.
780
  // Must not be called before a call to InitGoogleTest.
shiqian's avatar
shiqian committed
781
782
783
784
785
786
787
788
789
  const InternalRunDeathTestFlag* internal_run_death_test_flag() const {
    return internal_run_death_test_flag_.get();
  }

  // Returns a pointer to the current death test factory.
  internal::DeathTestFactory* death_test_factory() {
    return death_test_factory_.get();
  }

790
791
  void SuppressTestEventsIfInSubprocess();

shiqian's avatar
shiqian committed
792
793
794
  friend class ReplaceDeathTestFactory;
#endif  // GTEST_HAS_DEATH_TEST

795
796
797
798
  // Initializes the event listener performing XML output as specified by
  // UnitTestOptions. Must not be called before InitGoogleTest.
  void ConfigureXmlOutput();

799
800
801
802
803
804
#if GTEST_CAN_STREAM_RESULTS_
  // Initializes the event listener for streaming test results to a socket.
  // Must not be called before InitGoogleTest.
  void ConfigureStreamingOutput();
#endif

805
806
807
808
809
  // Performs initialization dependent upon flag values obtained in
  // ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
  // ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
  // this function is also called from RunAllTests.  Since this function can be
  // called more than once, it has to be idempotent.
810
811
  void PostFlagParsingInit();

812
  // Gets the random seed used at the start of the current test iteration.
813
814
  int random_seed() const { return random_seed_; }

815
816
817
  // Gets the random number generator.
  internal::Random* random() { return &random_; }

misterg's avatar
misterg committed
818
  // Shuffles all test suites, and the tests within each test suite,
819
820
821
  // making sure that death tests are still run first.
  void ShuffleTests();

misterg's avatar
misterg committed
822
  // Restores the test suites and tests to their order before the first shuffle.
823
824
  void UnshuffleTests();

825
826
827
828
  // Returns the value of GTEST_FLAG(catch_exceptions) at the moment
  // UnitTest::Run() starts.
  bool catch_exceptions() const { return catch_exceptions_; }

shiqian's avatar
shiqian committed
829
 private:
830
831
  friend class ::testing::UnitTest;

832
833
834
835
  // Used by UnitTest::Run() to capture the state of
  // GTEST_FLAG(catch_exceptions) at the moment it starts.
  void set_catch_exceptions(bool value) { catch_exceptions_ = value; }

shiqian's avatar
shiqian committed
836
837
838
  // The UnitTest object that owns this implementation object.
  UnitTest* const parent_;

839
840
841
842
  // The working directory when the first TEST() or TEST_F() was
  // executed.
  internal::FilePath original_working_dir_;

shiqian's avatar
shiqian committed
843
844
845
846
847
848
849
850
851
852
853
854
855
856
  // The default test part result reporters.
  DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_;
  DefaultPerThreadTestPartResultReporter
      default_per_thread_test_part_result_reporter_;

  // Points to (but doesn't own) the global test part result reporter.
  TestPartResultReporterInterface* global_test_part_result_repoter_;

  // Protects read and write access to global_test_part_result_reporter_.
  internal::Mutex global_test_part_result_reporter_mutex_;

  // Points to (but doesn't own) the per-thread test part result reporter.
  internal::ThreadLocal<TestPartResultReporterInterface*>
      per_thread_test_part_result_reporter_;
shiqian's avatar
shiqian committed
857

858
  // The vector of environments that need to be set-up/torn-down
859
860
  // before/after the tests are run.
  std::vector<Environment*> environments_;
shiqian's avatar
shiqian committed
861

misterg's avatar
misterg committed
862
  // The vector of TestSuites in their original order.  It owns the
863
  // elements in the vector.
misterg's avatar
misterg committed
864
  std::vector<TestSuite*> test_suites_;
865

misterg's avatar
misterg committed
866
867
868
  // Provides a level of indirection for the test suite list to allow
  // easy shuffling and restoring the test suite order.  The i-th
  // element of this vector is the index of the i-th test suite in the
869
  // shuffled order.
misterg's avatar
misterg committed
870
  std::vector<int> test_suite_indices_;
shiqian's avatar
shiqian committed
871

872
873
  // ParameterizedTestRegistry object used to register value-parameterized
  // tests.
misterg's avatar
misterg committed
874
  internal::ParameterizedTestSuiteRegistry parameterized_test_registry_;
Abseil Team's avatar
Abseil Team committed
875
876
  internal::TypeParameterizedTestSuiteRegistry
      type_parameterized_test_registry_;
877

Abseil Team's avatar
Abseil Team committed
878
879
880
881
  // The set holding the name of parameterized
  // test suites that may go uninstantiated.
  std::set<std::string> ignored_parameterized_test_suites_;

882
883
884
  // Indicates whether RegisterParameterizedTests() has been called already.
  bool parameterized_tests_registered_;

misterg's avatar
misterg committed
885
886
  // Index of the last death test suite registered.  Initially -1.
  int last_death_test_suite_;
shiqian's avatar
shiqian committed
887

misterg's avatar
misterg committed
888
889
  // This points to the TestSuite for the currently running test.  It
  // changes as Google Test goes through one test suite after another.
shiqian's avatar
shiqian committed
890
  // When no test is running, this is set to NULL and Google Test
891
  // stores assertion results in ad_hoc_test_result_.  Initially NULL.
misterg's avatar
misterg committed
892
  TestSuite* current_test_suite_;
shiqian's avatar
shiqian committed
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907

  // This points to the TestInfo for the currently running test.  It
  // changes as Google Test goes through one test after another.  When
  // no test is running, this is set to NULL and Google Test stores
  // assertion results in ad_hoc_test_result_.  Initially NULL.
  TestInfo* current_test_info_;

  // Normally, a user only writes assertions inside a TEST or TEST_F,
  // or inside a function called by a TEST or TEST_F.  Since Google
  // Test keeps track of which test is current running, it can
  // associate such an assertion with the test it belongs to.
  //
  // If an assertion is encountered when no TEST or TEST_F is running,
  // Google Test attributes the assertion result to an imaginary "ad hoc"
  // test, and records the result in ad_hoc_test_result_.
908
  TestResult ad_hoc_test_result_;
shiqian's avatar
shiqian committed
909

910
911
  // The list of event listeners that can be used to track events inside
  // Google Test.
912
  TestEventListeners listeners_;
shiqian's avatar
shiqian committed
913
914
915
916
917
918
919

  // The OS stack trace getter.  Will be deleted when the UnitTest
  // object is destructed.  By default, an OsStackTraceGetter is used,
  // but the user can set this field to use a custom getter if that is
  // desired.
  OsStackTraceGetterInterface* os_stack_trace_getter_;

920
  // True if and only if PostFlagParsingInit() has been called.
921
922
  bool post_flag_parse_init_performed_;

923
924
925
  // The random number seed used at the beginning of the test run.
  int random_seed_;

926
927
928
  // Our random number generator.
  internal::Random random_;

929
930
931
932
  // The time of the test program start, in ms from the start of the
  // UNIX epoch.
  TimeInMillis start_timestamp_;

shiqian's avatar
shiqian committed
933
934
935
  // How long the test took to run, in milliseconds.
  TimeInMillis elapsed_time_;

zhanyong.wan's avatar
zhanyong.wan committed
936
#if GTEST_HAS_DEATH_TEST
shiqian's avatar
shiqian committed
937
938
  // The decomposed components of the gtest_internal_run_death_test flag,
  // parsed when RUN_ALL_TESTS is called.
misterg's avatar
misterg committed
939
940
  std::unique_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_;
  std::unique_ptr<internal::DeathTestFactory> death_test_factory_;
shiqian's avatar
shiqian committed
941
942
943
#endif  // GTEST_HAS_DEATH_TEST

  // A per-thread stack of traces created by the SCOPED_TRACE() macro.
944
  internal::ThreadLocal<std::vector<TraceInfo> > gtest_trace_stack_;
shiqian's avatar
shiqian committed
945

946
947
948
949
  // The value of GTEST_FLAG(catch_exceptions) at the moment RunAllTests()
  // starts.
  bool catch_exceptions_;

shiqian's avatar
shiqian committed
950
  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl);
shiqian's avatar
shiqian committed
951
952
953
954
955
956
957
958
};  // class UnitTestImpl

// Convenience function for accessing the global UnitTest
// implementation object.
inline UnitTestImpl* GetUnitTestImpl() {
  return UnitTest::GetInstance()->impl();
}

959
960
#if GTEST_USES_SIMPLE_RE

961
962
// Internal helper functions for implementing the simple regular
// expression matcher.
zhanyong.wan's avatar
zhanyong.wan committed
963
GTEST_API_ bool IsInSet(char ch, const char* str);
964
965
GTEST_API_ bool IsAsciiDigit(char ch);
GTEST_API_ bool IsAsciiPunct(char ch);
zhanyong.wan's avatar
zhanyong.wan committed
966
GTEST_API_ bool IsRepeat(char ch);
967
968
GTEST_API_ bool IsAsciiWhiteSpace(char ch);
GTEST_API_ bool IsAsciiWordChar(char ch);
zhanyong.wan's avatar
zhanyong.wan committed
969
970
971
972
973
GTEST_API_ bool IsValidEscape(char ch);
GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch);
GTEST_API_ bool ValidateRegex(const char* regex);
GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str);
GTEST_API_ bool MatchRepetitionAndRegexAtHead(
974
    bool escaped, char ch, char repeat, const char* regex, const char* str);
zhanyong.wan's avatar
zhanyong.wan committed
975
GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str);
976

977
978
#endif  // GTEST_USES_SIMPLE_RE

979
980
// Parses the command line for Google Test flags, without initializing
// other parts of Google Test.
zhanyong.wan's avatar
zhanyong.wan committed
981
982
GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv);
GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv);
983

984
985
986
987
#if GTEST_HAS_DEATH_TEST

// Returns the message describing the last system error, regardless of the
// platform.
988
GTEST_API_ std::string GetLastErrnoDescription();
989
990
991
992
993
994
995
996
997
998

// Attempts to parse a string into a positive integer pointed to by the
// number parameter.  Returns true if that is possible.
// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use
// it here.
template <typename Integer>
bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
  // Fail fast if the given string does not begin with a digit;
  // this bypasses strtoXXX's "optional leading whitespace and plus
  // or minus sign" semantics, which are undesirable here.
999
  if (str.empty() || !IsDigit(str[0])) {
1000
1001
1002
1003
1004
1005
1006
    return false;
  }
  errno = 0;

  char* end;
  // BiggestConvertible is the largest integer type that system-provided
  // string-to-number conversion routines can return.
Abseil Team's avatar
Abseil Team committed
1007
  using BiggestConvertible = unsigned long long;  // NOLINT
1008

Abseil Team's avatar
Abseil Team committed
1009
  const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10);  // NOLINT
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
  const bool parse_success = *end == '\0' && errno == 0;

  GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed));

  const Integer result = static_cast<Integer>(parsed);
  if (parse_success && static_cast<BiggestConvertible>(result) == parsed) {
    *number = result;
    return true;
  }
  return false;
}
#endif  // GTEST_HAS_DEATH_TEST

1023
1024
1025
// TestResult contains some private methods that should be hidden from
// Google Test user but are required for testing. This class allow our tests
// to access them.
1026
1027
1028
//
// This class is supplied only for the purpose of testing Google Test's own
// constructs. Do not use it in user tests, either directly or indirectly.
1029
1030
1031
class TestResultAccessor {
 public:
  static void RecordProperty(TestResult* test_result,
1032
                             const std::string& xml_element,
1033
                             const TestProperty& property) {
1034
    test_result->RecordProperty(xml_element, property);
1035
1036
1037
1038
1039
1040
  }

  static void ClearTestPartResults(TestResult* test_result) {
    test_result->ClearTestPartResults();
  }

1041
  static const std::vector<testing::TestPartResult>& test_part_results(
1042
1043
1044
1045
1046
      const TestResult& test_result) {
    return test_result.test_part_results();
  }
};

kosak's avatar
kosak committed
1047
1048
1049
#if GTEST_CAN_STREAM_RESULTS_

// Streams test results to the given port on the given host machine.
Gennadiy Civil's avatar
Gennadiy Civil committed
1050
class StreamingListener : public EmptyTestEventListener {
kosak's avatar
kosak committed
1051
1052
1053
1054
1055
1056
1057
 public:
  // Abstract base class for writing strings to a socket.
  class AbstractSocketWriter {
   public:
    virtual ~AbstractSocketWriter() {}

    // Sends a string to the socket.
1058
    virtual void Send(const std::string& message) = 0;
kosak's avatar
kosak committed
1059
1060
1061
1062
1063

    // Closes the socket.
    virtual void CloseConnection() {}

    // Sends a string and a newline to the socket.
1064
    void SendLn(const std::string& message) { Send(message + "\n"); }
kosak's avatar
kosak committed
1065
1066
1067
1068
1069
  };

  // Concrete class for actually writing strings to a socket.
  class SocketWriter : public AbstractSocketWriter {
   public:
1070
    SocketWriter(const std::string& host, const std::string& port)
kosak's avatar
kosak committed
1071
1072
1073
1074
        : sockfd_(-1), host_name_(host), port_num_(port) {
      MakeConnection();
    }

Abseil Team's avatar
Abseil Team committed
1075
    ~SocketWriter() override {
kosak's avatar
kosak committed
1076
1077
1078
1079
1080
      if (sockfd_ != -1)
        CloseConnection();
    }

    // Sends a string to the socket.
Abseil Team's avatar
Abseil Team committed
1081
    void Send(const std::string& message) override {
kosak's avatar
kosak committed
1082
1083
1084
      GTEST_CHECK_(sockfd_ != -1)
          << "Send() can be called only when there is a connection.";

1085
      const auto len = static_cast<size_t>(message.length());
1086
      if (write(sockfd_, message.c_str(), len) != static_cast<ssize_t>(len)) {
kosak's avatar
kosak committed
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
        GTEST_LOG_(WARNING)
            << "stream_result_to: failed to stream to "
            << host_name_ << ":" << port_num_;
      }
    }

   private:
    // Creates a client socket and connects to the server.
    void MakeConnection();

    // Closes the socket.
Abseil Team's avatar
Abseil Team committed
1098
    void CloseConnection() override {
kosak's avatar
kosak committed
1099
1100
1101
1102
1103
1104
1105
1106
      GTEST_CHECK_(sockfd_ != -1)
          << "CloseConnection() can be called only when there is a connection.";

      close(sockfd_);
      sockfd_ = -1;
    }

    int sockfd_;  // socket file descriptor
1107
1108
    const std::string host_name_;
    const std::string port_num_;
kosak's avatar
kosak committed
1109
1110
1111
1112
1113

    GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter);
  };  // class SocketWriter

  // Escapes '=', '&', '%', and '\n' characters in str as "%xx".
1114
  static std::string UrlEncode(const char* str);
kosak's avatar
kosak committed
1115

1116
1117
1118
1119
  StreamingListener(const std::string& host, const std::string& port)
      : socket_writer_(new SocketWriter(host, port)) {
    Start();
  }
kosak's avatar
kosak committed
1120
1121
1122
1123

  explicit StreamingListener(AbstractSocketWriter* socket_writer)
      : socket_writer_(socket_writer) { Start(); }

Abseil Team's avatar
Abseil Team committed
1124
  void OnTestProgramStart(const UnitTest& /* unit_test */) override {
kosak's avatar
kosak committed
1125
1126
1127
    SendLn("event=TestProgramStart");
  }

Abseil Team's avatar
Abseil Team committed
1128
  void OnTestProgramEnd(const UnitTest& unit_test) override {
kosak's avatar
kosak committed
1129
1130
1131
1132
1133
1134
1135
1136
    // Note that Google Test current only report elapsed time for each
    // test iteration, not for the entire test program.
    SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));

    // Notify the streaming server to stop.
    socket_writer_->CloseConnection();
  }

Abseil Team's avatar
Abseil Team committed
1137
1138
  void OnTestIterationStart(const UnitTest& /* unit_test */,
                            int iteration) override {
kosak's avatar
kosak committed
1139
1140
1141
1142
    SendLn("event=TestIterationStart&iteration=" +
           StreamableToString(iteration));
  }

Abseil Team's avatar
Abseil Team committed
1143
1144
  void OnTestIterationEnd(const UnitTest& unit_test,
                          int /* iteration */) override {
kosak's avatar
kosak committed
1145
1146
1147
1148
1149
    SendLn("event=TestIterationEnd&passed=" +
           FormatBool(unit_test.Passed()) + "&elapsed_time=" +
           StreamableToString(unit_test.elapsed_time()) + "ms");
  }

misterg's avatar
misterg committed
1150
  // Note that "event=TestCaseStart" is a wire format and has to remain
John Bampton's avatar
John Bampton committed
1151
  // "case" for compatibility
1152
1153
  void OnTestSuiteStart(const TestSuite& test_suite) override {
    SendLn(std::string("event=TestCaseStart&name=") + test_suite.name());
kosak's avatar
kosak committed
1154
1155
  }

misterg's avatar
misterg committed
1156
  // Note that "event=TestCaseEnd" is a wire format and has to remain
John Bampton's avatar
John Bampton committed
1157
  // "case" for compatibility
1158
1159
1160
  void OnTestSuiteEnd(const TestSuite& test_suite) override {
    SendLn("event=TestCaseEnd&passed=" + FormatBool(test_suite.Passed()) +
           "&elapsed_time=" + StreamableToString(test_suite.elapsed_time()) +
misterg's avatar
misterg committed
1161
           "ms");
kosak's avatar
kosak committed
1162
1163
  }

Abseil Team's avatar
Abseil Team committed
1164
  void OnTestStart(const TestInfo& test_info) override {
kosak's avatar
kosak committed
1165
1166
1167
    SendLn(std::string("event=TestStart&name=") + test_info.name());
  }

Abseil Team's avatar
Abseil Team committed
1168
  void OnTestEnd(const TestInfo& test_info) override {
kosak's avatar
kosak committed
1169
1170
1171
1172
1173
1174
    SendLn("event=TestEnd&passed=" +
           FormatBool((test_info.result())->Passed()) +
           "&elapsed_time=" +
           StreamableToString((test_info.result())->elapsed_time()) + "ms");
  }

Abseil Team's avatar
Abseil Team committed
1175
  void OnTestPartResult(const TestPartResult& test_part_result) override {
kosak's avatar
kosak committed
1176
    const char* file_name = test_part_result.file_name();
1177
    if (file_name == nullptr) file_name = "";
kosak's avatar
kosak committed
1178
1179
1180
1181
1182
1183
1184
    SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
           "&line=" + StreamableToString(test_part_result.line_number()) +
           "&message=" + UrlEncode(test_part_result.message()));
  }

 private:
  // Sends the given message and a newline to the socket.
1185
  void SendLn(const std::string& message) { socket_writer_->SendLn(message); }
kosak's avatar
kosak committed
1186
1187
1188
1189
1190

  // Called at the start of streaming to notify the receiver what
  // protocol we are using.
  void Start() { SendLn("gtest_streaming_protocol_version=1.0"); }

1191
  std::string FormatBool(bool value) { return value ? "1" : "0"; }
kosak's avatar
kosak committed
1192

misterg's avatar
misterg committed
1193
  const std::unique_ptr<AbstractSocketWriter> socket_writer_;
kosak's avatar
kosak committed
1194
1195
1196
1197
1198
1199

  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener);
};  // class StreamingListener

#endif  // GTEST_CAN_STREAM_RESULTS_

shiqian's avatar
shiqian committed
1200
1201
1202
}  // namespace internal
}  // namespace testing

misterg's avatar
misterg committed
1203
1204
GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251

Abseil Team's avatar
Abseil Team committed
1205
#endif  // GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_