gtest-internal-inl.h 39 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
30
31
32
33
34
35
36
37
38
39
// 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.

// Utility functions and classes used by the Google C++ testing framework.
//
// Author: wan@google.com (Zhanyong Wan)
//
// This file contains purely Google Test's internal implementation.  Please
// DO NOT #INCLUDE IT IN A USER PROGRAM.

#ifndef GTEST_SRC_GTEST_INTERNAL_INL_H_
#define GTEST_SRC_GTEST_INTERNAL_INL_H_

zhanyong.wan's avatar
zhanyong.wan committed
40
41
42
// GTEST_IMPLEMENTATION_ is defined to 1 iff the current translation unit is
// part of Google Test's implementation; otherwise it's undefined.
#if !GTEST_IMPLEMENTATION_
shiqian's avatar
shiqian committed
43
44
45
// A user is trying to include this from his code - just say no.
#error "gtest-internal-inl.h is part of Google Test's internal implementation."
#error "It must not be included except by Google Test itself."
zhanyong.wan's avatar
zhanyong.wan committed
46
#endif  // GTEST_IMPLEMENTATION_
shiqian's avatar
shiqian committed
47

48
#ifndef _WIN32_WCE
49
#include <errno.h>
50
#endif  // !_WIN32_WCE
shiqian's avatar
shiqian committed
51
#include <stddef.h>
52
53
#include <stdlib.h>  // For strtoll/_strtoul64/malloc/free.
#include <string.h>  // For memmove.
shiqian's avatar
shiqian committed
54

55
#include <algorithm>
56
#include <string>
57
#include <vector>
58
59
60

#include <gtest/internal/gtest-port.h>

zhanyong.wan's avatar
zhanyong.wan committed
61
#if GTEST_OS_WINDOWS
62
#include <windows.h>  // For DWORD.
shiqian's avatar
shiqian committed
63
64
#endif  // GTEST_OS_WINDOWS

65
#include <gtest/gtest.h>  // NOLINT
shiqian's avatar
shiqian committed
66
67
68
69
70
71
#include <gtest/gtest-spi.h>

namespace testing {

// Declares the flags.
//
72
73
74
// 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.
75
GTEST_DECLARE_bool_(death_test_use_fork);
shiqian's avatar
shiqian committed
76
77
78

namespace internal {

79
80
// 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
81
GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest;
82

shiqian's avatar
shiqian committed
83
// Names of the flags (needed for parsing Google Test flags).
84
const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests";
shiqian's avatar
shiqian committed
85
86
const char kBreakOnFailureFlag[] = "break_on_failure";
const char kCatchExceptionsFlag[] = "catch_exceptions";
87
const char kColorFlag[] = "color";
shiqian's avatar
shiqian committed
88
89
90
const char kFilterFlag[] = "filter";
const char kListTestsFlag[] = "list_tests";
const char kOutputFlag[] = "output";
91
const char kPrintTimeFlag[] = "print_time";
92
const char kRandomSeedFlag[] = "random_seed";
shiqian's avatar
shiqian committed
93
const char kRepeatFlag[] = "repeat";
94
const char kShuffleFlag[] = "shuffle";
95
const char kStackTraceDepthFlag[] = "stack_trace_depth";
96
const char kStreamResultToFlag[] = "stream_result_to";
97
const char kThrowOnFailureFlag[] = "throw_on_failure";
shiqian's avatar
shiqian committed
98

99
// A valid random seed must be in [1, kMaxRandomSeed].
100
const int kMaxRandomSeed = 99999;
101

zhanyong.wan's avatar
zhanyong.wan committed
102
103
104
105
// g_help_flag is true iff the --help flag or an equivalent form is
// specified on the command line.
GTEST_API_ extern bool g_help_flag;

106
// Returns the current time in milliseconds.
zhanyong.wan's avatar
zhanyong.wan committed
107
108
109
110
111
112
113
114
115
116
117
118
119
120
GTEST_API_ TimeInMillis GetTimeInMillis();

// Returns true iff Google Test should use colors in the output.
GTEST_API_ bool ShouldUseColor(bool stdout_is_tty);

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

// 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.
GTEST_API_ bool ParseInt32Flag(
    const char* str, const char* flag, Int32* value);
121
122
123
124
125
126
127
128
129
130
131

// Returns a random seed in range [1, kMaxRandomSeed] based on the
// given --gtest_random_seed flag value.
inline int GetRandomSeedFromFlag(Int32 random_seed_flag) {
  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 =
132
133
      static_cast<int>((raw_seed - 1U) %
                       static_cast<unsigned int>(kMaxRandomSeed)) + 1;
134
135
136
137
138
139
140
141
142
143
144
145
146
147
  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
148
149
150
151
152
153
// 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() {
154
    also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests);
shiqian's avatar
shiqian committed
155
156
157
158
    break_on_failure_ = GTEST_FLAG(break_on_failure);
    catch_exceptions_ = GTEST_FLAG(catch_exceptions);
    color_ = GTEST_FLAG(color);
    death_test_style_ = GTEST_FLAG(death_test_style);
159
    death_test_use_fork_ = GTEST_FLAG(death_test_use_fork);
shiqian's avatar
shiqian committed
160
161
162
163
    filter_ = GTEST_FLAG(filter);
    internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);
    list_tests_ = GTEST_FLAG(list_tests);
    output_ = GTEST_FLAG(output);
164
    print_time_ = GTEST_FLAG(print_time);
165
    random_seed_ = GTEST_FLAG(random_seed);
shiqian's avatar
shiqian committed
166
    repeat_ = GTEST_FLAG(repeat);
167
    shuffle_ = GTEST_FLAG(shuffle);
168
    stack_trace_depth_ = GTEST_FLAG(stack_trace_depth);
169
    stream_result_to_ = GTEST_FLAG(stream_result_to);
170
    throw_on_failure_ = GTEST_FLAG(throw_on_failure);
shiqian's avatar
shiqian committed
171
172
173
174
  }

  // The d'tor is not virtual.  DO NOT INHERIT FROM THIS CLASS.
  ~GTestFlagSaver() {
175
    GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
shiqian's avatar
shiqian committed
176
177
178
179
    GTEST_FLAG(break_on_failure) = break_on_failure_;
    GTEST_FLAG(catch_exceptions) = catch_exceptions_;
    GTEST_FLAG(color) = color_;
    GTEST_FLAG(death_test_style) = death_test_style_;
180
    GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
shiqian's avatar
shiqian committed
181
182
183
184
    GTEST_FLAG(filter) = filter_;
    GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
    GTEST_FLAG(list_tests) = list_tests_;
    GTEST_FLAG(output) = output_;
185
    GTEST_FLAG(print_time) = print_time_;
186
    GTEST_FLAG(random_seed) = random_seed_;
shiqian's avatar
shiqian committed
187
    GTEST_FLAG(repeat) = repeat_;
188
    GTEST_FLAG(shuffle) = shuffle_;
189
    GTEST_FLAG(stack_trace_depth) = stack_trace_depth_;
190
    GTEST_FLAG(stream_result_to) = stream_result_to_;
191
    GTEST_FLAG(throw_on_failure) = throw_on_failure_;
shiqian's avatar
shiqian committed
192
193
194
  }
 private:
  // Fields for saving the original values of flags.
195
  bool also_run_disabled_tests_;
shiqian's avatar
shiqian committed
196
197
198
199
  bool break_on_failure_;
  bool catch_exceptions_;
  String color_;
  String death_test_style_;
200
  bool death_test_use_fork_;
shiqian's avatar
shiqian committed
201
202
203
204
  String filter_;
  String internal_run_death_test_;
  bool list_tests_;
  String output_;
205
  bool print_time_;
shiqian's avatar
shiqian committed
206
  bool pretty_;
207
  internal::Int32 random_seed_;
shiqian's avatar
shiqian committed
208
  internal::Int32 repeat_;
209
  bool shuffle_;
210
  internal::Int32 stack_trace_depth_;
211
  String stream_result_to_;
212
  bool throw_on_failure_;
shiqian's avatar
shiqian committed
213
} GTEST_ATTRIBUTE_UNUSED_;
shiqian's avatar
shiqian committed
214

215
216
217
218
219
220
221
222
// 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.
// The output buffer str must containt at least 32 characters.
// The function returns the address of the output buffer.
// If the code_point is not a valid Unicode code point
// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be output
// as '(Invalid Unicode 0xXXXXXXXX)'.
zhanyong.wan's avatar
zhanyong.wan committed
223
GTEST_API_ char* CodePointToUtf8(UInt32 code_point, char* str);
224
225
226
227
228
229
230
231
232
233
234
235
236
237

// Converts a wide string to a narrow string in UTF-8 encoding.
// The wide string is assumed to have the following encoding:
//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS)
//   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.
zhanyong.wan's avatar
zhanyong.wan committed
238
GTEST_API_ String WideStringToUtf8(const wchar_t* str, int num_chars);
shiqian's avatar
shiqian committed
239

240
241
242
243
244
245
246
247
248
249
250
251
// 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
252
253
254
GTEST_API_ bool ShouldShard(const char* total_shards_str,
                            const char* shard_index_str,
                            bool in_subprocess_for_death_test);
255
256
257
258

// Parses the environment variable var as an Int32. If it is unset,
// returns default_val. If it is not an Int32, prints an error and
// and aborts.
zhanyong.wan's avatar
zhanyong.wan committed
259
GTEST_API_ Int32 Int32FromEnvOrDie(const char* env_var, Int32 default_val);
260
261
262
263
264

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

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

270
271
272
273
// 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) {
274
  return static_cast<int>(std::count_if(c.begin(), c.end(), predicate));
275
}
276

277
278
279
280
281
// 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);
}
282

283
284
285
286
287
288
// 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) {
  return (i < 0 || i >= static_cast<int>(v.size())) ? default_value : v[i];
}
289

290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
// 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;
    const int selected = begin + random->Generate(range_width);
    std::swap((*v)[selected], (*v)[last_in_range]);
311
  }
312
}
313

314
315
316
// Performs an in-place shuffle of the vector's elements.
template <typename E>
inline void Shuffle(internal::Random* random, std::vector<E>* v) {
317
  ShuffleRange(random, 0, static_cast<int>(v->size()), v);
318
}
shiqian's avatar
shiqian committed
319
320
321
322

// A function for deleting an object.  Handy for being used as a
// functor.
template <typename T>
323
static void Delete(T* x) {
shiqian's avatar
shiqian committed
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
  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.
  explicit TestPropertyKeyIs(const char* key)
      : key_(key) {}

  // Returns true iff the test name of test property matches on key_.
  bool operator()(const TestProperty& test_property) const {
    return String(test_property.key()).Compare(key_) == 0;
  }

 private:
  String key_;
};

// 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
357
class GTEST_API_ UnitTestOptions {
shiqian's avatar
shiqian committed
358
359
360
361
362
363
 public:
  // Functions for processing the gtest_output flag.

  // Returns the output format, or "" for normal printed output.
  static String GetOutputFormat();

364
365
366
367
  // 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.
  static String GetAbsolutePathToOutputFile();
shiqian's avatar
shiqian committed
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382

  // Functions for processing the gtest_filter flag.

  // Returns true iff the wildcard pattern matches the string.  The
  // first ':' or '\0' character in pattern marks the end of it.
  //
  // This recursive algorithm isn't very efficient, but is clear and
  // works well enough for matching test names, which are short.
  static bool PatternMatchesString(const char *pattern, const char *str);

  // Returns true iff the user-specified filter matches the test case
  // name and the test name.
  static bool FilterMatchesTest(const String &test_case_name,
                                const String &test_name);

zhanyong.wan's avatar
zhanyong.wan committed
383
#if GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
384
385
386
387
388
389
390
  // 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
391

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

// Returns the current application's name, removing directory path if that
// is present.  Used by UnitTestOptions::GetOutputFile.
zhanyong.wan's avatar
zhanyong.wan committed
399
GTEST_API_ FilePath GetCurrentExecutableName();
shiqian's avatar
shiqian committed
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420

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

  // Returns the current OS stack trace as a String.  Parameters:
  //
  //   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.
  virtual String CurrentStackTrace(int max_depth, int skip_count) = 0;

  // 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;

 private:
shiqian's avatar
shiqian committed
421
  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface);
shiqian's avatar
shiqian committed
422
423
};

424
// A working implementation of the OsStackTraceGetterInterface interface.
shiqian's avatar
shiqian committed
425
426
class OsStackTraceGetter : public OsStackTraceGetterInterface {
 public:
427
  OsStackTraceGetter() : caller_frame_(NULL) {}
shiqian's avatar
shiqian committed
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
  virtual String CurrentStackTrace(int max_depth, int skip_count);
  virtual void UponLeavingGTest();

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

 private:
  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 CurrentStackTrace() from within the user code.
  void* caller_frame_;

shiqian's avatar
shiqian committed
444
  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter);
shiqian's avatar
shiqian committed
445
446
447
448
449
450
451
452
453
};

// Information about a Google Test trace point.
struct TraceInfo {
  const char* file;
  int line;
  String message;
};

shiqian's avatar
shiqian committed
454
455
456
457
458
459
460
461
462
463
464
465
// 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.
  virtual void ReportTestPartResult(const TestPartResult& result);

 private:
  UnitTestImpl* const unit_test_;
466
467

  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter);
shiqian's avatar
shiqian committed
468
469
470
471
472
473
474
475
476
477
478
479
480
481
};

// 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_.
  virtual void ReportTestPartResult(const TestPartResult& result);

 private:
  UnitTestImpl* const unit_test_;
482
483

  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter);
shiqian's avatar
shiqian committed
484
485
};

shiqian's avatar
shiqian committed
486
487
488
489
// 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
490
class GTEST_API_ UnitTestImpl {
shiqian's avatar
shiqian committed
491
492
493
494
 public:
  explicit UnitTestImpl(UnitTest* parent);
  virtual ~UnitTestImpl();

shiqian's avatar
shiqian committed
495
496
497
498
499
500
501
502
503
  // 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
504

shiqian's avatar
shiqian committed
505
506
507
  // Sets the global test part result reporter.
  void SetGlobalTestPartResultReporter(
      TestPartResultReporterInterface* reporter);
shiqian's avatar
shiqian committed
508

shiqian's avatar
shiqian committed
509
510
511
512
513
514
  // 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
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555

  // Gets the number of successful test cases.
  int successful_test_case_count() const;

  // Gets the number of failed test cases.
  int failed_test_case_count() const;

  // Gets the number of all test cases.
  int total_test_case_count() const;

  // Gets the number of all test cases that contain at least one test
  // that should run.
  int test_case_to_run_count() const;

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

  // Gets the number of failed tests.
  int failed_test_count() const;

  // Gets the number of disabled tests.
  int disabled_test_count() const;

  // 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;

  // Gets the elapsed time, in milliseconds.
  TimeInMillis elapsed_time() const { return elapsed_time_; }

  // Returns true iff the unit test passed (i.e. all test cases passed).
  bool Passed() const { return !Failed(); }

  // Returns true iff the unit test failed (i.e. some test case failed
  // or something outside of all tests failed).
  bool Failed() const {
    return failed_test_case_count() > 0 || ad_hoc_test_result()->Failed();
  }

556
557
558
  // Gets the i-th test case among all the test cases. i can range from 0 to
  // total_test_case_count() - 1. If i is not in that range, returns NULL.
  const TestCase* GetTestCase(int i) const {
559
560
    const int index = GetElementOr(test_case_indices_, i, -1);
    return index < 0 ? NULL : test_cases_[i];
561
562
563
564
565
  }

  // Gets the i-th test case among all the test cases. i can range from 0 to
  // total_test_case_count() - 1. If i is not in that range, returns NULL.
  TestCase* GetMutableTestCase(int i) {
566
567
    const int index = GetElementOr(test_case_indices_, i, -1);
    return index < 0 ? NULL : test_cases_[index];
568
569
  }

570
  // Provides access to the event listener list.
571
  TestEventListeners* listeners() { return &listeners_; }
572

shiqian's avatar
shiqian committed
573
574
  // Returns the TestResult for the test that's currently running, or
  // the TestResult for the ad hoc test if no test is running.
575
  TestResult* current_test_result();
shiqian's avatar
shiqian committed
576
577

  // Returns the TestResult for the ad hoc test.
578
  const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; }
shiqian's avatar
shiqian committed
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612

  // 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();

  // Returns the current OS stack trace as a String.
  //
  // 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.
  String CurrentOsStackTraceExceptTop(int skip_count);

  // Finds and returns a TestCase with the given name.  If one doesn't
  // exist, creates one and returns it.
  //
  // Arguments:
  //
  //   test_case_name: name of the test case
  //   set_up_tc:      pointer to the function that sets up the test case
  //   tear_down_tc:   pointer to the function that tears down the test case
  TestCase* GetTestCase(const char* test_case_name,
613
                        const char* comment,
shiqian's avatar
shiqian committed
614
615
616
617
618
619
620
621
622
623
624
625
626
                        Test::SetUpTestCaseFunc set_up_tc,
                        Test::TearDownTestCaseFunc tear_down_tc);

  // Adds a TestInfo to the unit test.
  //
  // Arguments:
  //
  //   set_up_tc:    pointer to the function that sets up the test case
  //   tear_down_tc: pointer to the function that tears down the test case
  //   test_info:    the TestInfo object
  void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc,
                   Test::TearDownTestCaseFunc tear_down_tc,
                   TestInfo * test_info) {
627
628
629
630
631
632
633
634
635
    // 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());
636
637
      GTEST_CHECK_(!original_working_dir_.IsEmpty())
          << "Failed to get the current working directory.";
638
639
    }

shiqian's avatar
shiqian committed
640
    GetTestCase(test_info->test_case_name(),
641
                test_info->test_case_comment(),
shiqian's avatar
shiqian committed
642
643
644
645
                set_up_tc,
                tear_down_tc)->AddTestInfo(test_info);
  }

zhanyong.wan's avatar
zhanyong.wan committed
646
#if GTEST_HAS_PARAM_TEST
647
648
649
650
651
652
653
  // Returns ParameterizedTestCaseRegistry object used to keep track of
  // value-parameterized tests and instantiate and register them.
  internal::ParameterizedTestCaseRegistry& parameterized_test_registry() {
    return parameterized_test_registry_;
  }
#endif  // GTEST_HAS_PARAM_TEST

shiqian's avatar
shiqian committed
654
  // Sets the TestCase object for the test that's currently running.
655
656
  void set_current_test_case(TestCase* a_current_test_case) {
    current_test_case_ = a_current_test_case;
shiqian's avatar
shiqian committed
657
658
659
660
661
  }

  // 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_.
662
663
  void set_current_test_info(TestInfo* a_current_test_info) {
    current_test_info_ = a_current_test_info;
shiqian's avatar
shiqian committed
664
665
  }

666
  // Registers all parameterized tests defined using TEST_P and
vladlosev's avatar
vladlosev committed
667
668
669
670
671
  // INSTANTIATE_TEST_CASE_P, creating regular tests for each test/parameter
  // 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.
672
673
  void RegisterParameterizedTests();

shiqian's avatar
shiqian committed
674
  // Runs all tests in this UnitTest object, prints the result, and
675
676
677
678
  // 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
679

680
681
  // Clears the results of all tests, except the ad hoc tests.
  void ClearNonAdHocTestResult() {
682
    ForEach(test_cases_, TestCase::ClearTestCaseResult);
683
684
685
686
  }

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

690
691
692
693
694
  enum ReactionToSharding {
    HONOR_SHARDING_PROTOCOL,
    IGNORE_SHARDING_PROTOCOL
  };

shiqian's avatar
shiqian committed
695
696
697
  // Matches the full name of each test against the user-specified
  // filter to decide whether the test should run, then records the
  // result in each TestCase and TestInfo object.
698
699
  // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests
  // based on sharding variables in the environment.
shiqian's avatar
shiqian committed
700
  // Returns the number of tests that should run.
701
  int FilterTests(ReactionToSharding shard_tests);
shiqian's avatar
shiqian committed
702

703
704
  // Prints the names of the tests matching the user-specified filter flag.
  void ListTestsMatchingFilter();
shiqian's avatar
shiqian committed
705
706
707
708
709

  const TestCase* current_test_case() const { return current_test_case_; }
  TestInfo* current_test_info() { return current_test_info_; }
  const TestInfo* current_test_info() const { return current_test_info_; }

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

  // Getters for the per-thread Google Test trace stack.
715
716
  std::vector<TraceInfo>& gtest_trace_stack() {
    return *(gtest_trace_stack_.pointer());
shiqian's avatar
shiqian committed
717
  }
718
719
  const std::vector<TraceInfo>& gtest_trace_stack() const {
    return gtest_trace_stack_.get();
shiqian's avatar
shiqian committed
720
721
  }

zhanyong.wan's avatar
zhanyong.wan committed
722
#if GTEST_HAS_DEATH_TEST
723
724
725
  void InitDeathTestSubprocessControlInfo() {
    internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag());
  }
shiqian's avatar
shiqian committed
726
727
728
  // 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.
729
  // Must not be called before a call to InitGoogleTest.
shiqian's avatar
shiqian committed
730
731
732
733
734
735
736
737
738
  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();
  }

739
740
  void SuppressTestEventsIfInSubprocess();

shiqian's avatar
shiqian committed
741
742
743
  friend class ReplaceDeathTestFactory;
#endif  // GTEST_HAS_DEATH_TEST

744
745
746
747
  // Initializes the event listener performing XML output as specified by
  // UnitTestOptions. Must not be called before InitGoogleTest.
  void ConfigureXmlOutput();

748
749
750
751
752
753
#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

754
755
756
757
758
  // 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.
759
760
  void PostFlagParsingInit();

761
  // Gets the random seed used at the start of the current test iteration.
762
763
  int random_seed() const { return random_seed_; }

764
765
766
767
768
769
770
771
772
773
  // Gets the random number generator.
  internal::Random* random() { return &random_; }

  // Shuffles all test cases, and the tests within each test case,
  // making sure that death tests are still run first.
  void ShuffleTests();

  // Restores the test cases and tests to their order before the first shuffle.
  void UnshuffleTests();

774
775
776
777
  // 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
778
 private:
779
780
  friend class ::testing::UnitTest;

781
782
783
784
  // 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
785
786
787
  // The UnitTest object that owns this implementation object.
  UnitTest* const parent_;

788
789
790
791
  // The working directory when the first TEST() or TEST_F() was
  // executed.
  internal::FilePath original_working_dir_;

shiqian's avatar
shiqian committed
792
793
794
795
796
797
798
799
800
801
802
803
804
805
  // 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
806

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

811
812
  // The vector of TestCases in their original order.  It owns the
  // elements in the vector.
813
  std::vector<TestCase*> test_cases_;
814
815
816
817
818

  // Provides a level of indirection for the test case list to allow
  // easy shuffling and restoring the test case order.  The i-th
  // element of this vector is the index of the i-th test case in the
  // shuffled order.
819
  std::vector<int> test_case_indices_;
shiqian's avatar
shiqian committed
820

zhanyong.wan's avatar
zhanyong.wan committed
821
#if GTEST_HAS_PARAM_TEST
822
823
824
825
826
827
828
829
  // ParameterizedTestRegistry object used to register value-parameterized
  // tests.
  internal::ParameterizedTestCaseRegistry parameterized_test_registry_;

  // Indicates whether RegisterParameterizedTests() has been called already.
  bool parameterized_tests_registered_;
#endif  // GTEST_HAS_PARAM_TEST

830
831
  // Index of the last death test case registered.  Initially -1.
  int last_death_test_case_;
shiqian's avatar
shiqian committed
832
833
834
835

  // This points to the TestCase for the currently running test.  It
  // changes as Google Test goes through one test case after another.
  // When no test is running, this is set to NULL and Google Test
836
  // stores assertion results in ad_hoc_test_result_.  Initially NULL.
shiqian's avatar
shiqian committed
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
  TestCase* current_test_case_;

  // 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_.
853
  TestResult ad_hoc_test_result_;
shiqian's avatar
shiqian committed
854

855
856
  // The list of event listeners that can be used to track events inside
  // Google Test.
857
  TestEventListeners listeners_;
shiqian's avatar
shiqian committed
858
859
860
861
862
863
864

  // 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_;

865
866
867
  // True iff PostFlagParsingInit() has been called.
  bool post_flag_parse_init_performed_;

868
869
870
  // The random number seed used at the beginning of the test run.
  int random_seed_;

871
872
873
  // Our random number generator.
  internal::Random random_;

shiqian's avatar
shiqian committed
874
875
876
  // How long the test took to run, in milliseconds.
  TimeInMillis elapsed_time_;

zhanyong.wan's avatar
zhanyong.wan committed
877
#if GTEST_HAS_DEATH_TEST
shiqian's avatar
shiqian committed
878
879
880
881
882
883
884
  // The decomposed components of the gtest_internal_run_death_test flag,
  // parsed when RUN_ALL_TESTS is called.
  internal::scoped_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_;
  internal::scoped_ptr<internal::DeathTestFactory> death_test_factory_;
#endif  // GTEST_HAS_DEATH_TEST

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

887
888
889
890
  // The value of GTEST_FLAG(catch_exceptions) at the moment RunAllTests()
  // starts.
  bool catch_exceptions_;

shiqian's avatar
shiqian committed
891
  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl);
shiqian's avatar
shiqian committed
892
893
894
895
896
897
898
899
};  // class UnitTestImpl

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

900
901
#if GTEST_USES_SIMPLE_RE

902
903
// Internal helper functions for implementing the simple regular
// expression matcher.
zhanyong.wan's avatar
zhanyong.wan committed
904
GTEST_API_ bool IsInSet(char ch, const char* str);
905
906
GTEST_API_ bool IsAsciiDigit(char ch);
GTEST_API_ bool IsAsciiPunct(char ch);
zhanyong.wan's avatar
zhanyong.wan committed
907
GTEST_API_ bool IsRepeat(char ch);
908
909
GTEST_API_ bool IsAsciiWhiteSpace(char ch);
GTEST_API_ bool IsAsciiWordChar(char ch);
zhanyong.wan's avatar
zhanyong.wan committed
910
911
912
913
914
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(
915
    bool escaped, char ch, char repeat, const char* regex, const char* str);
zhanyong.wan's avatar
zhanyong.wan committed
916
GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str);
917

918
919
#endif  // GTEST_USES_SIMPLE_RE

920
921
// Parses the command line for Google Test flags, without initializing
// other parts of Google Test.
zhanyong.wan's avatar
zhanyong.wan committed
922
923
GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv);
GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv);
924

925
926
927
928
#if GTEST_HAS_DEATH_TEST

// Returns the message describing the last system error, regardless of the
// platform.
929
GTEST_API_ String GetLastErrnoDescription();
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965

#if GTEST_OS_WINDOWS
// Provides leak-safe Windows kernel handle ownership.
class AutoHandle {
 public:
  AutoHandle() : handle_(INVALID_HANDLE_VALUE) {}
  explicit AutoHandle(HANDLE handle) : handle_(handle) {}

  ~AutoHandle() { Reset(); }

  HANDLE Get() const { return handle_; }
  void Reset() { Reset(INVALID_HANDLE_VALUE); }
  void Reset(HANDLE handle) {
    if (handle != handle_) {
      if (handle_ != INVALID_HANDLE_VALUE)
        ::CloseHandle(handle_);
      handle_ = handle;
    }
  }

 private:
  HANDLE handle_;

  GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);
};
#endif  // GTEST_OS_WINDOWS

// 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.
966
  if (str.empty() || !IsDigit(str[0])) {
967
968
969
970
971
972
973
    return false;
  }
  errno = 0;

  char* end;
  // BiggestConvertible is the largest integer type that system-provided
  // string-to-number conversion routines can return.
974
#if GTEST_OS_WINDOWS && !defined(__GNUC__)
975
  // MSVC and C++ Builder define __int64 instead of the standard long long.
976
977
978
979
980
  typedef unsigned __int64 BiggestConvertible;
  const BiggestConvertible parsed = _strtoui64(str.c_str(), &end, 10);
#else
  typedef unsigned long long BiggestConvertible;  // NOLINT
  const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10);
981
#endif  // GTEST_OS_WINDOWS && !defined(__GNUC__)
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
  const bool parse_success = *end == '\0' && errno == 0;

  // TODO(vladl@google.com): Convert this to compile time assertion when it is
  // available.
  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

997
998
999
// 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.
1000
1001
1002
//
// 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.
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
class TestResultAccessor {
 public:
  static void RecordProperty(TestResult* test_result,
                             const TestProperty& property) {
    test_result->RecordProperty(property);
  }

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

1014
  static const std::vector<testing::TestPartResult>& test_part_results(
1015
1016
1017
1018
1019
      const TestResult& test_result) {
    return test_result.test_part_results();
  }
};

shiqian's avatar
shiqian committed
1020
1021
1022
1023
}  // namespace internal
}  // namespace testing

#endif  // GTEST_SRC_GTEST_INTERNAL_INL_H_