gtest-internal-inl.h 42.7 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
56
57
58
#include <string>

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

zhanyong.wan's avatar
zhanyong.wan committed
59
#if GTEST_OS_WINDOWS
60
#include <windows.h>  // For DWORD.
shiqian's avatar
shiqian committed
61
62
63
64
65
66
67
68
69
#endif  // GTEST_OS_WINDOWS

#include <gtest/gtest.h>
#include <gtest/gtest-spi.h>

namespace testing {

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

namespace internal {

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

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

95
// A valid random seed must be in [1, kMaxRandomSeed].
96
const int kMaxRandomSeed = 99999;
97
98
99
100
101
102
103
104
105
106
107
108
109
110

// Returns the current time in milliseconds.
TimeInMillis GetTimeInMillis();

// 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 =
111
112
      static_cast<int>((raw_seed - 1U) %
                       static_cast<unsigned int>(kMaxRandomSeed)) + 1;
113
114
115
116
117
118
119
120
121
122
123
124
125
126
  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
127
128
129
130
131
132
// 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() {
133
    also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests);
shiqian's avatar
shiqian committed
134
135
136
137
    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);
138
    death_test_use_fork_ = GTEST_FLAG(death_test_use_fork);
shiqian's avatar
shiqian committed
139
140
141
142
    filter_ = GTEST_FLAG(filter);
    internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);
    list_tests_ = GTEST_FLAG(list_tests);
    output_ = GTEST_FLAG(output);
143
    print_time_ = GTEST_FLAG(print_time);
144
    random_seed_ = GTEST_FLAG(random_seed);
shiqian's avatar
shiqian committed
145
    repeat_ = GTEST_FLAG(repeat);
146
    shuffle_ = GTEST_FLAG(shuffle);
147
    throw_on_failure_ = GTEST_FLAG(throw_on_failure);
shiqian's avatar
shiqian committed
148
149
150
151
  }

  // The d'tor is not virtual.  DO NOT INHERIT FROM THIS CLASS.
  ~GTestFlagSaver() {
152
    GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
shiqian's avatar
shiqian committed
153
154
155
156
    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_;
157
    GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
shiqian's avatar
shiqian committed
158
159
160
161
    GTEST_FLAG(filter) = filter_;
    GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
    GTEST_FLAG(list_tests) = list_tests_;
    GTEST_FLAG(output) = output_;
162
    GTEST_FLAG(print_time) = print_time_;
163
    GTEST_FLAG(random_seed) = random_seed_;
shiqian's avatar
shiqian committed
164
    GTEST_FLAG(repeat) = repeat_;
165
    GTEST_FLAG(shuffle) = shuffle_;
166
    GTEST_FLAG(throw_on_failure) = throw_on_failure_;
shiqian's avatar
shiqian committed
167
168
169
  }
 private:
  // Fields for saving the original values of flags.
170
  bool also_run_disabled_tests_;
shiqian's avatar
shiqian committed
171
172
173
174
  bool break_on_failure_;
  bool catch_exceptions_;
  String color_;
  String death_test_style_;
175
  bool death_test_use_fork_;
shiqian's avatar
shiqian committed
176
177
178
179
  String filter_;
  String internal_run_death_test_;
  bool list_tests_;
  String output_;
180
  bool print_time_;
shiqian's avatar
shiqian committed
181
  bool pretty_;
182
  internal::Int32 random_seed_;
shiqian's avatar
shiqian committed
183
  internal::Int32 repeat_;
184
  bool shuffle_;
185
  bool throw_on_failure_;
shiqian's avatar
shiqian committed
186
} GTEST_ATTRIBUTE_UNUSED_;
shiqian's avatar
shiqian committed
187

188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
// 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)'.
char* CodePointToUtf8(UInt32 code_point, char* str);

// 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.
String WideStringToUtf8(const wchar_t* str, int num_chars);
shiqian's avatar
shiqian committed
212
213
214
215

// Returns the number of active threads, or 0 when there is an error.
size_t GetThreadCount();

216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
// 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.
bool ShouldShard(const char* total_shards_str, const char* shard_index_str,
                 bool in_subprocess_for_death_test);

// 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.
Int32 Int32FromEnvOrDie(const char* env_var, Int32 default_val);

// 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.
bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id);

242
// Vector is an ordered container that supports random access to the
243
// elements.
shiqian's avatar
shiqian committed
244
//
245
246
247
248
// We cannot use std::vector, as Visual C++ 7.1's implementation of
// STL has problems compiling when exceptions are disabled.  There is
// a hack to work around the problems, but we've seen cases where the
// hack fails to work.
shiqian's avatar
shiqian committed
249
//
250
// The element type must support copy constructor and operator=.
shiqian's avatar
shiqian committed
251
template <typename E>  // E is the element type.
252
class Vector {
shiqian's avatar
shiqian committed
253
 public:
254
255
  // Creates an empty Vector.
  Vector() : elements_(NULL), capacity_(0), size_(0) {}
shiqian's avatar
shiqian committed
256
257

  // D'tor.
258
  virtual ~Vector() { Clear(); }
shiqian's avatar
shiqian committed
259

260
  // Clears the Vector.
shiqian's avatar
shiqian committed
261
  void Clear() {
262
263
264
    if (elements_ != NULL) {
      for (int i = 0; i < size_; i++) {
        delete elements_[i];
shiqian's avatar
shiqian committed
265
266
      }

267
268
269
      free(elements_);
      elements_ = NULL;
      capacity_ = size_ = 0;
shiqian's avatar
shiqian committed
270
271
272
273
274
275
    }
  }

  // Gets the number of elements.
  int size() const { return size_; }

276
277
278
279
  // Adds an element to the end of the Vector.  A copy of the element
  // is created using the copy constructor, and then stored in the
  // Vector.  Changes made to the element in the Vector doesn't affect
  // the source object, and vice versa.
280
  void PushBack(const E & element) { Insert(element, size_); }
shiqian's avatar
shiqian committed
281

282
  // Adds an element to the beginning of this Vector.
283
  void PushFront(const E& element) { Insert(element, 0); }
shiqian's avatar
shiqian committed
284

285
  // Removes an element from the beginning of this Vector.  If the
shiqian's avatar
shiqian committed
286
287
  // result argument is not NULL, the removed element is stored in the
  // memory it points to.  Otherwise the element is thrown away.
288
  // Returns true iff the vector wasn't empty before the operation.
shiqian's avatar
shiqian committed
289
  bool PopFront(E* result) {
290
291
    if (size_ == 0)
      return false;
shiqian's avatar
shiqian committed
292

293
    if (result != NULL)
294
      *result = GetElement(0);
shiqian's avatar
shiqian committed
295

296
    Erase(0);
shiqian's avatar
shiqian committed
297
298
299
    return true;
  }

300
301
302
303
304
305
306
  // Inserts an element at the given index.  It's the caller's
  // responsibility to ensure that the given index is in the range [0,
  // size()].
  void Insert(const E& element, int index) {
    GrowIfNeeded();
    MoveElements(index, size_ - index, index + 1);
    elements_[index] = new E(element);
shiqian's avatar
shiqian committed
307
308
309
    size_++;
  }

310
311
312
313
314
315
316
317
318
319
320
321
  // Erases the element at the specified index, or aborts the program if the
  // index is not in range [0, size()).
  void Erase(int index) {
    GTEST_CHECK_(0 <= index && index < size_)
        << "Invalid Vector index " << index << ": must be in range [0, "
        << (size_ - 1) << "].";

    delete elements_[index];
    MoveElements(index + 1, size_ - index - 1, index);
    size_--;
  }

shiqian's avatar
shiqian committed
322
323
324
325
326
327
  // Returns the number of elements that satisfy a given predicate.
  // The parameter 'predicate' is a Boolean function or functor that
  // accepts a 'const E &', where E is the element type.
  template <typename P>  // P is the type of the predicate function/functor
  int CountIf(P predicate) const {
    int count = 0;
328
329
    for (int i = 0; i < size_; i++) {
      if (predicate(*(elements_[i]))) {
shiqian's avatar
shiqian committed
330
331
332
333
334
335
336
        count++;
      }
    }

    return count;
  }

337
  // Applies a function/functor to each element in the Vector.  The
shiqian's avatar
shiqian committed
338
339
340
341
342
  // parameter 'functor' is a function/functor that accepts a 'const
  // E &', where E is the element type.  This method does not change
  // the elements.
  template <typename F>  // F is the type of the function/functor
  void ForEach(F functor) const {
343
344
    for (int i = 0; i < size_; i++) {
      functor(*(elements_[i]));
shiqian's avatar
shiqian committed
345
346
347
348
349
350
351
352
    }
  }

  // Returns the first node whose element satisfies a given predicate,
  // or NULL if none is found.  The parameter 'predicate' is a
  // function/functor that accepts a 'const E &', where E is the
  // element type.  This method does not change the elements.
  template <typename P>  // P is the type of the predicate function/functor.
353
354
355
356
  const E* FindIf(P predicate) const {
    for (int i = 0; i < size_; i++) {
      if (predicate(*elements_[i])) {
        return elements_[i];
shiqian's avatar
shiqian committed
357
358
359
360
361
362
      }
    }
    return NULL;
  }

  template <typename P>
363
364
365
366
  E* FindIf(P predicate) {
    for (int i = 0; i < size_; i++) {
      if (predicate(*elements_[i])) {
        return elements_[i];
shiqian's avatar
shiqian committed
367
368
369
370
371
      }
    }
    return NULL;
  }

372
373
374
375
  // Returns the i-th element of the list, or aborts the program if i
  // is not in range [0, size()).
  const E& GetElement(int i) const {
    GTEST_CHECK_(0 <= i && i < size_)
376
        << "Invalid Vector index " << i << ": must be in range [0, "
377
        << (size_ - 1) << "].";
378

379
    return *(elements_[i]);
380
381
382
  }

  // Returns the i-th element of the list, or default_value if i is not
383
  // in range [0, size()).
384
  E GetElementOr(int i, E default_value) const {
385
    return (i < 0 || i >= size_) ? default_value : *(elements_[i]);
386
387
  }

shiqian's avatar
shiqian committed
388
 private:
389
390
391
392
393
394
395
396
397
398
  // Grows the buffer if it is not big enough to hold one more element.
  void GrowIfNeeded() {
    if (size_ < capacity_)
      return;

    // Exponential bump-up is necessary to ensure that inserting N
    // elements is O(N) instead of O(N^2).  The factor 3/2 means that
    // no more than 1/3 of the slots are wasted.
    const int new_capacity = 3*(capacity_/2 + 1);
    GTEST_CHECK_(new_capacity > capacity_)  // Does the new capacity overflow?
399
        << "Cannot grow a Vector with " << capacity_ << " elements already.";
400
401
402
403
404
    capacity_ = new_capacity;
    elements_ = static_cast<E**>(
        realloc(elements_, capacity_*sizeof(elements_[0])));
  }

405
  // Moves the give consecutive elements to a new index in the Vector.
406
407
408
409
410
411
412
  void MoveElements(int source, int count, int dest) {
    memmove(elements_ + dest, elements_ + source, count*sizeof(elements_[0]));
  }

  E** elements_;
  int capacity_;  // The number of elements allocated for elements_.
  int size_;      // The number of elements; in the range [0, capacity_].
413

414
415
416
  // We disallow copying Vector.
  GTEST_DISALLOW_COPY_AND_ASSIGN_(Vector);
};  // class Vector
shiqian's avatar
shiqian committed
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447

// A function for deleting an object.  Handy for being used as a
// functor.
template <typename T>
static void Delete(T * x) {
  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 TestInfoImpl {
 public:
  TestInfoImpl(TestInfo* parent, const char* test_case_name,
448
449
               const char* name, const char* test_case_comment,
               const char* comment, TypeId fixture_class_id,
450
               internal::TestFactoryBase* factory);
shiqian's avatar
shiqian committed
451
452
453
454
455
456
457
458
459
460
461
462
463
464
  ~TestInfoImpl();

  // Returns true if this test should run.
  bool should_run() const { return should_run_; }

  // Sets the should_run member.
  void set_should_run(bool should) { should_run_ = should; }

  // Returns true if this test is disabled. Disabled tests are not run.
  bool is_disabled() const { return is_disabled_; }

  // Sets the is_disabled member.
  void set_is_disabled(bool is) { is_disabled_ = is; }

465
466
467
468
469
470
  // Returns true if this test matches the filter specified by the user.
  bool matches_filter() const { return matches_filter_; }

  // Sets the matches_filter member.
  void set_matches_filter(bool matches) { matches_filter_ = matches; }

shiqian's avatar
shiqian committed
471
472
473
474
475
476
  // Returns the test case name.
  const char* test_case_name() const { return test_case_name_.c_str(); }

  // Returns the test name.
  const char* name() const { return name_.c_str(); }

477
478
479
480
481
482
  // Returns the test case comment.
  const char* test_case_comment() const { return test_case_comment_.c_str(); }

  // Returns the test comment.
  const char* comment() const { return comment_.c_str(); }

shiqian's avatar
shiqian committed
483
484
485
486
  // Returns the ID of the test fixture class.
  TypeId fixture_class_id() const { return fixture_class_id_; }

  // Returns the test result.
487
488
  TestResult* result() { return &result_; }
  const TestResult* result() const { return &result_; }
shiqian's avatar
shiqian committed
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508

  // Creates the test object, runs it, records its result, and then
  // deletes it.
  void Run();

  // Calls the given TestInfo object's Run() method.
  static void RunTest(TestInfo * test_info) {
    test_info->impl()->Run();
  }

  // Clears the test result.
  void ClearResult() { result_.Clear(); }

  // Clears the test result in the given TestInfo object.
  static void ClearTestResult(TestInfo * test_info) {
    test_info->impl()->ClearResult();
  }

 private:
  // These fields are immutable properties of the test.
509
510
511
512
513
514
515
516
  TestInfo* const parent_;          // The owner of this object
  const String test_case_name_;     // Test case name
  const String name_;               // Test name
  const String test_case_comment_;  // Test case comment
  const String comment_;            // Test comment
  const TypeId fixture_class_id_;   // ID of the test fixture class
  bool should_run_;                 // True iff this test should run
  bool is_disabled_;                // True iff this test is disabled
517
518
  bool matches_filter_;             // True if this test matches the
                                    // user-specified filter.
519
520
  internal::TestFactoryBase* const factory_;  // The factory that creates
                                              // the test object
shiqian's avatar
shiqian committed
521
522
523

  // This field is mutable and needs to be reset before running the
  // test for the second time.
524
  TestResult result_;
shiqian's avatar
shiqian committed
525

shiqian's avatar
shiqian committed
526
  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfoImpl);
shiqian's avatar
shiqian committed
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
};

// 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.
class UnitTestOptions {
 public:
  // Functions for processing the gtest_output flag.

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

546
547
548
549
  // 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
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564

  // 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
565
#if GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
566
567
568
569
570
571
572
  // 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
573

shiqian's avatar
shiqian committed
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
  // 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.
FilePath GetCurrentExecutableName();

// 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
603
  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface);
shiqian's avatar
shiqian committed
604
605
};

606
// A working implementation of the OsStackTraceGetterInterface interface.
shiqian's avatar
shiqian committed
607
608
class OsStackTraceGetter : public OsStackTraceGetterInterface {
 public:
609
  OsStackTraceGetter() : caller_frame_(NULL) {}
shiqian's avatar
shiqian committed
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
  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
626
  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter);
shiqian's avatar
shiqian committed
627
628
629
630
631
632
633
634
635
};

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

shiqian's avatar
shiqian committed
636
637
638
639
640
641
642
643
644
645
646
647
// 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_;
648
649

  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter);
shiqian's avatar
shiqian committed
650
651
652
653
654
655
656
657
658
659
660
661
662
663
};

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

  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter);
shiqian's avatar
shiqian committed
666
667
};

shiqian's avatar
shiqian committed
668
669
670
671
// 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.
shiqian's avatar
shiqian committed
672
class UnitTestImpl {
shiqian's avatar
shiqian committed
673
674
675
676
 public:
  explicit UnitTestImpl(UnitTest* parent);
  virtual ~UnitTestImpl();

shiqian's avatar
shiqian committed
677
678
679
680
681
682
683
684
685
  // 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
686

shiqian's avatar
shiqian committed
687
688
689
  // Sets the global test part result reporter.
  void SetGlobalTestPartResultReporter(
      TestPartResultReporterInterface* reporter);
shiqian's avatar
shiqian committed
690

shiqian's avatar
shiqian committed
691
692
693
694
695
696
  // 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
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737

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

738
739
740
741
742
743
  // 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 {
    return test_cases_.GetElementOr(i, NULL);
  }

744
745
746
  // Provides access to the event listener list.
  EventListeners* listeners() { return &listeners_; }

shiqian's avatar
shiqian committed
747
748
  // Returns the TestResult for the test that's currently running, or
  // the TestResult for the ad hoc test if no test is running.
749
  TestResult* current_test_result();
shiqian's avatar
shiqian committed
750
751

  // Returns the TestResult for the ad hoc test.
752
  const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; }
shiqian's avatar
shiqian committed
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786

  // 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,
787
                        const char* comment,
shiqian's avatar
shiqian committed
788
789
790
791
792
793
794
795
796
797
798
799
800
                        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) {
801
802
803
804
805
806
807
808
809
    // 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());
810
811
      GTEST_CHECK_(!original_working_dir_.IsEmpty())
          << "Failed to get the current working directory.";
812
813
    }

shiqian's avatar
shiqian committed
814
    GetTestCase(test_info->test_case_name(),
815
                test_info->test_case_comment(),
shiqian's avatar
shiqian committed
816
817
818
819
                set_up_tc,
                tear_down_tc)->AddTestInfo(test_info);
  }

zhanyong.wan's avatar
zhanyong.wan committed
820
#if GTEST_HAS_PARAM_TEST
821
822
823
824
825
826
827
  // 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
828
829
830
831
832
833
834
835
836
837
838
839
  // Sets the TestCase object for the test that's currently running.
  void set_current_test_case(TestCase* current_test_case) {
    current_test_case_ = current_test_case;
  }

  // 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_.
  void set_current_test_info(TestInfo* current_test_info) {
    current_test_info_ = current_test_info;
  }

840
841
842
843
844
845
846
847
  // Registers all parameterized tests defined using TEST_P and
  // INSTANTIATE_TEST_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.
  void RegisterParameterizedTests();

shiqian's avatar
shiqian committed
848
849
850
851
852
853
854
855
856
857
858
859
860
861
  // Runs all tests in this UnitTest object, prints the result, and
  // returns 0 if all tests are successful, or 1 otherwise.  If any
  // exception is thrown during a test on Windows, this test is
  // considered to be failed, but the rest of the tests will still be
  // run.  (We disable exceptions on Linux and Mac OS X, so the issue
  // doesn't apply there.)
  int RunAllTests();

  // Clears the results of all tests, including the ad hoc test.
  void ClearResult() {
    test_cases_.ForEach(TestCase::ClearTestCaseResult);
    ad_hoc_test_result_.Clear();
  }

862
863
864
865
866
  enum ReactionToSharding {
    HONOR_SHARDING_PROTOCOL,
    IGNORE_SHARDING_PROTOCOL
  };

shiqian's avatar
shiqian committed
867
868
869
  // 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.
870
871
  // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests
  // based on sharding variables in the environment.
shiqian's avatar
shiqian committed
872
  // Returns the number of tests that should run.
873
  int FilterTests(ReactionToSharding shard_tests);
shiqian's avatar
shiqian committed
874

875
876
  // Prints the names of the tests matching the user-specified filter flag.
  void ListTestsMatchingFilter();
shiqian's avatar
shiqian committed
877
878
879
880
881

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

882
  // Returns the vector of environments that need to be set-up/torn-down
shiqian's avatar
shiqian committed
883
  // before/after the tests are run.
884
885
  internal::Vector<Environment*>* environments() { return &environments_; }
  internal::Vector<Environment*>* environments_in_reverse_order() {
shiqian's avatar
shiqian committed
886
887
888
    return &environments_in_reverse_order_;
  }

889
890
  internal::Vector<TestCase*>* test_cases() { return &test_cases_; }
  const internal::Vector<TestCase*>* test_cases() const { return &test_cases_; }
shiqian's avatar
shiqian committed
891
892

  // Getters for the per-thread Google Test trace stack.
893
  internal::Vector<TraceInfo>* gtest_trace_stack() {
shiqian's avatar
shiqian committed
894
895
    return gtest_trace_stack_.pointer();
  }
896
  const internal::Vector<TraceInfo>* gtest_trace_stack() const {
shiqian's avatar
shiqian committed
897
898
899
    return gtest_trace_stack_.pointer();
  }

zhanyong.wan's avatar
zhanyong.wan committed
900
#if GTEST_HAS_DEATH_TEST
901
902
903
  void InitDeathTestSubprocessControlInfo() {
    internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag());
  }
shiqian's avatar
shiqian committed
904
905
906
  // 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.
907
  // Must not be called before a call to InitGoogleTest.
shiqian's avatar
shiqian committed
908
909
910
911
912
913
914
915
916
  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();
  }

917
918
  void SuppressTestEventsIfInSubprocess();

shiqian's avatar
shiqian committed
919
920
921
  friend class ReplaceDeathTestFactory;
#endif  // GTEST_HAS_DEATH_TEST

922
923
924
925
926
927
928
929
930
931
932
  // Initializes the event listener performing XML output as specified by
  // UnitTestOptions. Must not be called before InitGoogleTest.
  void ConfigureXmlOutput();

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

933
934
935
  // Gets the random seed used at the start of the current test run.
  int random_seed() const { return random_seed_; }

shiqian's avatar
shiqian committed
936
 private:
937
938
  friend class ::testing::UnitTest;

shiqian's avatar
shiqian committed
939
940
941
  // The UnitTest object that owns this implementation object.
  UnitTest* const parent_;

942
943
944
945
  // The working directory when the first TEST() or TEST_F() was
  // executed.
  internal::FilePath original_working_dir_;

shiqian's avatar
shiqian committed
946
947
948
949
950
951
952
953
954
955
956
957
958
959
  // 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
960

961
  // The vector of environments that need to be set-up/torn-down
shiqian's avatar
shiqian committed
962
963
  // before/after the tests are run.  environments_in_reverse_order_
  // simply mirrors environments_ in reverse order.
964
965
  internal::Vector<Environment*> environments_;
  internal::Vector<Environment*> environments_in_reverse_order_;
shiqian's avatar
shiqian committed
966

967
  internal::Vector<TestCase*> test_cases_;  // The vector of TestCases.
shiqian's avatar
shiqian committed
968

zhanyong.wan's avatar
zhanyong.wan committed
969
#if GTEST_HAS_PARAM_TEST
970
971
972
973
974
975
976
977
  // 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

978
979
  // Index of the last death test case registered.  Initially -1.
  int last_death_test_case_;
shiqian's avatar
shiqian committed
980
981
982
983

  // 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
984
  // stores assertion results in ad_hoc_test_result_.  Initially NULL.
shiqian's avatar
shiqian committed
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
  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_.
1001
  TestResult ad_hoc_test_result_;
shiqian's avatar
shiqian committed
1002

1003
1004
1005
  // The list of event listeners that can be used to track events inside
  // Google Test.
  EventListeners listeners_;
shiqian's avatar
shiqian committed
1006
1007
1008
1009
1010
1011
1012

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

1013
1014
1015
  // True iff PostFlagParsingInit() has been called.
  bool post_flag_parse_init_performed_;

1016
1017
1018
  // The random number seed used at the beginning of the test run.
  int random_seed_;

shiqian's avatar
shiqian committed
1019
1020
1021
  // How long the test took to run, in milliseconds.
  TimeInMillis elapsed_time_;

zhanyong.wan's avatar
zhanyong.wan committed
1022
#if GTEST_HAS_DEATH_TEST
shiqian's avatar
shiqian committed
1023
1024
1025
1026
1027
1028
1029
  // 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.
1030
  internal::ThreadLocal<internal::Vector<TraceInfo> > gtest_trace_stack_;
shiqian's avatar
shiqian committed
1031

shiqian's avatar
shiqian committed
1032
  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl);
shiqian's avatar
shiqian committed
1033
1034
1035
1036
1037
1038
1039
1040
};  // class UnitTestImpl

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

1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
// Internal helper functions for implementing the simple regular
// expression matcher.
bool IsInSet(char ch, const char* str);
bool IsDigit(char ch);
bool IsPunct(char ch);
bool IsRepeat(char ch);
bool IsWhiteSpace(char ch);
bool IsWordChar(char ch);
bool IsValidEscape(char ch);
bool AtomMatchesChar(bool escaped, char pattern, char ch);
bool ValidateRegex(const char* regex);
bool MatchRegexAtHead(const char* regex, const char* str);
bool MatchRepetitionAndRegexAtHead(
    bool escaped, char ch, char repeat, const char* regex, const char* str);
bool MatchRegexAnywhere(const char* regex, const char* str);

1057
1058
1059
1060
1061
// Parses the command line for Google Test flags, without initializing
// other parts of Google Test.
void ParseGoogleTestFlagsOnly(int* argc, char** argv);
void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv);

1062
1063
1064
1065
#if GTEST_HAS_DEATH_TEST

// Returns the message describing the last system error, regardless of the
// platform.
1066
String GetLastErrnoDescription();
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132

#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.
  if (str.empty() || !isdigit(str[0])) {
    return false;
  }
  errno = 0;

  char* end;
  // BiggestConvertible is the largest integer type that system-provided
  // string-to-number conversion routines can return.
#if GTEST_OS_WINDOWS
  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);
#endif  // GTEST_OS_WINDOWS
  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

1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
// 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.
class TestResultAccessor {
 public:
  static void RecordProperty(TestResult* test_result,
                             const TestProperty& property) {
    test_result->RecordProperty(property);
  }

  static bool Passed(const TestResult& result) { return result.Passed(); }

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

  static const Vector<testing::TestPartResult>& test_part_results(
      const TestResult& test_result) {
    return test_result.test_part_results();
  }
};

shiqian's avatar
shiqian committed
1155
1156
1157
1158
}  // namespace internal
}  // namespace testing

#endif  // GTEST_SRC_GTEST_INTERNAL_INL_H_