gtest.h 87.9 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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// 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.
//
// Author: wan@google.com (Zhanyong Wan)
//
// The Google C++ Testing Framework (Google Test)
//
// This header file defines the public API for Google Test.  It should be
// included by any test program that uses Google Test.
//
// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
// leave some internal implementation details in this header file.
// They are clearly marked by comments like this:
//
//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
//
// Such code is NOT meant to be used by a user directly, and is subject
// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
// program!
//
// Acknowledgment: Google Test borrowed the idea of automatic test
// registration from Barthelemy Dagenais' (barthelemy@prologique.com)
// easyUnit framework.

#ifndef GTEST_INCLUDE_GTEST_GTEST_H_
#define GTEST_INCLUDE_GTEST_GTEST_H_

54
#include <limits>
55
#include <ostream>
56
57
#include <vector>

58
59
60
61
62
63
64
65
66
#include "gtest/internal/gtest-internal.h"
#include "gtest/internal/gtest-string.h"
#include "gtest/gtest-death-test.h"
#include "gtest/gtest-message.h"
#include "gtest/gtest-param-test.h"
#include "gtest/gtest-printers.h"
#include "gtest/gtest_prod.h"
#include "gtest/gtest-test-part.h"
#include "gtest/gtest-typed-test.h"
shiqian's avatar
shiqian committed
67
68

// Depending on the platform, different string classes are available.
69
70
71
72
// On Linux, in addition to ::std::string, Google also makes use of
// class ::string, which has the same interface as ::std::string, but
// has a different implementation.
//
73
// You can define GTEST_HAS_GLOBAL_STRING to 1 to indicate that
74
75
// ::string is available AND is a distinct type to ::std::string, or
// define it to 0 to indicate otherwise.
shiqian's avatar
shiqian committed
76
//
77
78
// If ::std::string and ::string are the same class on your platform
// due to aliasing, you should define GTEST_HAS_GLOBAL_STRING to 0.
shiqian's avatar
shiqian committed
79
//
80
// If you do not define GTEST_HAS_GLOBAL_STRING, it is defined
81
// heuristically.
shiqian's avatar
shiqian committed
82
83
84

namespace testing {

85
// Declares the flags.
shiqian's avatar
shiqian committed
86

87
88
89
90
91
92
// This flag temporary enables the disabled tests.
GTEST_DECLARE_bool_(also_run_disabled_tests);

// This flag brings the debugger on an assertion failure.
GTEST_DECLARE_bool_(break_on_failure);

93
94
// This flag controls whether Google Test catches all test-thrown exceptions
// and logs them as failures.
95
96
GTEST_DECLARE_bool_(catch_exceptions);

97
98
// This flag enables using colors in terminal output. Available values are
// "yes" to enable colors, "no" (disable colors), or "auto" (the default)
99
100
101
// to let Google Test decide.
GTEST_DECLARE_string_(color);

102
// This flag sets up the filter to select by name using a glob pattern
103
104
105
// the tests to run. If the filter is not given all tests are executed.
GTEST_DECLARE_string_(filter);

106
// This flag causes the Google Test to list tests. None of the tests listed
107
108
109
110
111
112
113
// are actually run if the flag is provided.
GTEST_DECLARE_bool_(list_tests);

// This flag controls whether Google Test emits a detailed XML report to a file
// in addition to its normal textual output.
GTEST_DECLARE_string_(output);

114
// This flags control whether Google Test prints the elapsed time for each
115
116
117
// test.
GTEST_DECLARE_bool_(print_time);

118
119
120
// This flag specifies the random number seed.
GTEST_DECLARE_int32_(random_seed);

121
// This flag sets how many times the tests are repeated. The default value
122
123
// is 1. If the value is -1 the tests are repeating forever.
GTEST_DECLARE_int32_(repeat);
shiqian's avatar
shiqian committed
124
125
126

// This flag controls whether Google Test includes Google Test internal
// stack frames in failure stack traces.
shiqian's avatar
shiqian committed
127
GTEST_DECLARE_bool_(show_internal_stack_frames);
shiqian's avatar
shiqian committed
128

129
// When this flag is specified, tests' order is randomized on every iteration.
130
131
GTEST_DECLARE_bool_(shuffle);

132
133
134
135
// This flag specifies the maximum number of stack frames to be
// printed in a failure message.
GTEST_DECLARE_int32_(stack_trace_depth);

136
137
138
139
140
// When this flag is specified, a failed assertion will throw an
// exception if exceptions are enabled, or exit the program with a
// non-zero code otherwise.
GTEST_DECLARE_bool_(throw_on_failure);

141
142
143
144
145
// When this flag is set with a "host:port" string, on supported
// platforms test results are streamed to the specified port on
// the specified host machine.
GTEST_DECLARE_string_(stream_result_to);

146
147
148
// The upper limit for valid stack trace depths.
const int kMaxStackTraceDepth = 100;

shiqian's avatar
shiqian committed
149
150
namespace internal {

151
class AssertHelper;
152
153
class DefaultGlobalTestPartResultReporter;
class ExecDeathTest;
154
class NoExecDeathTest;
155
class FinalSuccessChecker;
shiqian's avatar
shiqian committed
156
class GTestFlagSaver;
kosak's avatar
kosak committed
157
class StreamingListenerTest;
158
class TestResultAccessor;
159
class TestEventListenersAccessor;
160
class TestEventRepeater;
161
class UnitTestRecordPropertyTestHelper;
162
class WindowsDeathTest;
163
class UnitTestImpl* GetUnitTestImpl();
164
void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
165
                                    const std::string& message);
shiqian's avatar
shiqian committed
166
167
168

}  // namespace internal

169
170
171
172
173
174
175
176
// The friend relationship of some of these classes is cyclic.
// If we don't forward declare them the compiler might confuse the classes
// in friendship clauses with same named classes on the scope.
class Test;
class TestCase;
class TestInfo;
class UnitTest;

shiqian's avatar
shiqian committed
177
178
// A class for indicating whether an assertion was successful.  When
// the assertion wasn't successful, the AssertionResult object
179
// remembers a non-empty message that describes how it failed.
shiqian's avatar
shiqian committed
180
//
181
// To create an instance of this class, use one of the factory functions
shiqian's avatar
shiqian committed
182
183
// (AssertionSuccess() and AssertionFailure()).
//
184
185
186
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
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
// This class is useful for two purposes:
//   1. Defining predicate functions to be used with Boolean test assertions
//      EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts
//   2. Defining predicate-format functions to be
//      used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
//
// For example, if you define IsEven predicate:
//
//   testing::AssertionResult IsEven(int n) {
//     if ((n % 2) == 0)
//       return testing::AssertionSuccess();
//     else
//       return testing::AssertionFailure() << n << " is odd";
//   }
//
// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))
// will print the message
//
//   Value of: IsEven(Fib(5))
//     Actual: false (5 is odd)
//   Expected: true
//
// instead of a more opaque
//
//   Value of: IsEven(Fib(5))
//     Actual: false
//   Expected: true
//
// in case IsEven is a simple Boolean predicate.
//
// If you expect your predicate to be reused and want to support informative
// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up
// about half as often as positive ones in our tests), supply messages for
// both success and failure cases:
//
//   testing::AssertionResult IsEven(int n) {
//     if ((n % 2) == 0)
//       return testing::AssertionSuccess() << n << " is even";
//     else
//       return testing::AssertionFailure() << n << " is odd";
//   }
//
// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print
//
//   Value of: IsEven(Fib(6))
//     Actual: true (8 is even)
//   Expected: false
//
// NB: Predicates that support negative Boolean assertions have reduced
// performance in positive ones so be careful not to use them in tests
// that have lots (tens of thousands) of positive Boolean assertions.
//
// To use this class with EXPECT_PRED_FORMAT assertions such as:
shiqian's avatar
shiqian committed
237
238
239
240
//
//   // Verifies that Foo() returns an even number.
//   EXPECT_PRED_FORMAT1(IsEven, Foo());
//
241
// you need to define:
shiqian's avatar
shiqian committed
242
243
//
//   testing::AssertionResult IsEven(const char* expr, int n) {
244
245
246
247
248
//     if ((n % 2) == 0)
//       return testing::AssertionSuccess();
//     else
//       return testing::AssertionFailure()
//         << "Expected: " << expr << " is even\n  Actual: it's " << n;
shiqian's avatar
shiqian committed
249
250
251
252
253
254
//   }
//
// If Foo() returns 5, you will see the following message:
//
//   Expected: Foo() is even
//     Actual: it's 5
255
//
256
class GTEST_API_ AssertionResult {
shiqian's avatar
shiqian committed
257
 public:
258
259
260
  // Copy constructor.
  // Used in EXPECT_TRUE/FALSE(assertion_result).
  AssertionResult(const AssertionResult& other);
billydonahue's avatar
billydonahue committed
261
262
263

  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)

264
  // Used in the EXPECT_TRUE/FALSE(bool_expression).
billydonahue's avatar
billydonahue committed
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
  //
  // T must be contextually convertible to bool.
  //
  // The second parameter prevents this overload from being considered if
  // the argument is implicitly convertible to AssertionResult. In that case
  // we want AssertionResult's copy constructor to be used.
  template <typename T>
  explicit AssertionResult(
      const T& success,
      typename internal::EnableIf<
          !internal::ImplicitlyConvertible<T, AssertionResult>::value>::type*
          /*enabler*/ = NULL)
      : success_(success) {}

  GTEST_DISABLE_MSC_WARNINGS_POP_()

  // Assignment operator.
  AssertionResult& operator=(AssertionResult other) {
    swap(other);
    return *this;
  }
shiqian's avatar
shiqian committed
286
287

  // Returns true iff the assertion succeeded.
288
289
290
291
292
293
294
295
296
297
  operator bool() const { return success_; }  // NOLINT

  // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
  AssertionResult operator!() const;

  // Returns the text streamed into this AssertionResult. Test assertions
  // use it when they fail (i.e., the predicate's outcome doesn't match the
  // assertion's expectation). When nothing has been streamed into the
  // object, returns an empty string.
  const char* message() const {
298
    return message_.get() != NULL ?  message_->c_str() : "";
299
300
301
302
  }
  // TODO(vladl@google.com): Remove this after making sure no clients use it.
  // Deprecated; please use message() instead.
  const char* failure_message() const { return message(); }
shiqian's avatar
shiqian committed
303

304
  // Streams a custom failure message into this object.
305
306
307
308
309
310
311
312
313
314
315
316
  template <typename T> AssertionResult& operator<<(const T& value) {
    AppendMessage(Message() << value);
    return *this;
  }

  // Allows streaming basic output manipulators such as endl or flush into
  // this object.
  AssertionResult& operator<<(
      ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
    AppendMessage(Message() << basic_manipulator);
    return *this;
  }
shiqian's avatar
shiqian committed
317
318

 private:
319
320
321
322
323
324
  // Appends the contents of message to message_.
  void AppendMessage(const Message& a_message) {
    if (message_.get() == NULL)
      message_.reset(new ::std::string);
    message_->append(a_message.GetString().c_str());
  }
325

billydonahue's avatar
billydonahue committed
326
327
328
  // Swap the contents of this AssertionResult with other.
  void swap(AssertionResult& other);

329
330
331
332
333
334
  // Stores result of the assertion predicate.
  bool success_;
  // Stores the message describing the condition in case the expectation
  // construct is not satisfied with the predicate's outcome.
  // Referenced via a pointer to avoid taking too much stack frame space
  // with test assertions.
335
336
  internal::scoped_ptr< ::std::string> message_;
};
shiqian's avatar
shiqian committed
337
338

// Makes a successful assertion result.
339
GTEST_API_ AssertionResult AssertionSuccess();
shiqian's avatar
shiqian committed
340

341
// Makes a failed assertion result.
342
GTEST_API_ AssertionResult AssertionFailure();
343

shiqian's avatar
shiqian committed
344
// Makes a failed assertion result with the given failure message.
345
// Deprecated; use AssertionFailure() << msg.
346
GTEST_API_ AssertionResult AssertionFailure(const Message& msg);
shiqian's avatar
shiqian committed
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361

// The abstract class that all tests inherit from.
//
// In Google Test, a unit test program contains one or many TestCases, and
// each TestCase contains one or many Tests.
//
// When you define a test using the TEST macro, you don't need to
// explicitly derive from Test - the TEST macro automatically does
// this for you.
//
// The only time you derive from Test is when defining a test fixture
// to be used a TEST_F.  For example:
//
//   class FooTest : public testing::Test {
//    protected:
362
363
//     void SetUp() override { ... }
//     void TearDown() override { ... }
shiqian's avatar
shiqian committed
364
365
366
367
368
369
370
//     ...
//   };
//
//   TEST_F(FooTest, Bar) { ... }
//   TEST_F(FooTest, Baz) { ... }
//
// Test is not copyable.
371
class GTEST_API_ Test {
shiqian's avatar
shiqian committed
372
 public:
373
  friend class TestInfo;
shiqian's avatar
shiqian committed
374
375
376

  // Defines types for pointers to functions that set up and tear down
  // a test case.
377
378
  typedef internal::SetUpTestCaseFunc SetUpTestCaseFunc;
  typedef internal::TearDownTestCaseFunc TearDownTestCaseFunc;
shiqian's avatar
shiqian committed
379
380
381
382

  // The d'tor is virtual as we intend to inherit from Test.
  virtual ~Test();

383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
  // Sets up the stuff shared by all tests in this test case.
  //
  // Google Test will call Foo::SetUpTestCase() before running the first
  // test in test case Foo.  Hence a sub-class can define its own
  // SetUpTestCase() method to shadow the one defined in the super
  // class.
  static void SetUpTestCase() {}

  // Tears down the stuff shared by all tests in this test case.
  //
  // Google Test will call Foo::TearDownTestCase() after running the last
  // test in test case Foo.  Hence a sub-class can define its own
  // TearDownTestCase() method to shadow the one defined in the super
  // class.
  static void TearDownTestCase() {}

shiqian's avatar
shiqian committed
399
400
401
  // Returns true iff the current test has a fatal failure.
  static bool HasFatalFailure();

402
403
404
405
406
407
408
  // Returns true iff the current test has a non-fatal failure.
  static bool HasNonfatalFailure();

  // Returns true iff the current test has a (either fatal or
  // non-fatal) failure.
  static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); }

409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
  // Logs a property for the current test, test case, or for the entire
  // invocation of the test program when used outside of the context of a
  // test case.  Only the last value for a given key is remembered.  These
  // are public static so they can be called from utility functions that are
  // not members of the test fixture.  Calls to RecordProperty made during
  // lifespan of the test (from the moment its constructor starts to the
  // moment its destructor finishes) will be output in XML as attributes of
  // the <testcase> element.  Properties recorded from fixture's
  // SetUpTestCase or TearDownTestCase are logged as attributes of the
  // corresponding <testsuite> element.  Calls to RecordProperty made in the
  // global context (before or after invocation of RUN_ALL_TESTS and from
  // SetUp/TearDown method of Environment objects registered with Google
  // Test) will be output as attributes of the <testsuites> element.
  static void RecordProperty(const std::string& key, const std::string& value);
  static void RecordProperty(const std::string& key, int value);
shiqian's avatar
shiqian committed
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450

 protected:
  // Creates a Test object.
  Test();

  // Sets up the test fixture.
  virtual void SetUp();

  // Tears down the test fixture.
  virtual void TearDown();

 private:
  // Returns true iff the current test has the same fixture class as
  // the first test in the current test case.
  static bool HasSameFixtureClass();

  // Runs the test after the test fixture has been set up.
  //
  // A sub-class must implement this to define the test logic.
  //
  // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM.
  // Instead, use the TEST or TEST_F macro.
  virtual void TestBody() = 0;

  // Sets up, executes, and tears down the test.
  void Run();

451
452
453
454
  // Deletes self.  We deliberately pick an unusual name for this
  // internal method to avoid clashing with names used in user TESTs.
  void DeleteSelf_() { delete this; }

455
  const internal::scoped_ptr< GTEST_FLAG_SAVER_ > gtest_flag_saver_;
shiqian's avatar
shiqian committed
456

457
  // Often a user misspells SetUp() as Setup() and spends a long time
shiqian's avatar
shiqian committed
458
459
460
461
462
  // wondering why it is never called by Google Test.  The declaration of
  // the following method is solely for catching such an error at
  // compile time:
  //
  //   - The return type is deliberately chosen to be not void, so it
463
464
  //   will be a conflict if void Setup() is declared in the user's
  //   test fixture.
shiqian's avatar
shiqian committed
465
466
  //
  //   - This method is private, so it will be another compiler error
467
  //   if the method is called from the user's test fixture.
shiqian's avatar
shiqian committed
468
469
470
471
472
473
474
475
476
  //
  // DO NOT OVERRIDE THIS FUNCTION.
  //
  // If you see an error about overriding the following function or
  // about it being private, you have mis-spelled SetUp() as Setup().
  struct Setup_should_be_spelled_SetUp {};
  virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }

  // We disallow copying Tests.
shiqian's avatar
shiqian committed
477
  GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
shiqian's avatar
shiqian committed
478
479
};

480
481
typedef internal::TimeInMillis TimeInMillis;

482
483
484
485
486
487
488
489
490
// A copyable object representing a user specified test property which can be
// output as a key/value string pair.
//
// Don't inherit from TestProperty as its destructor is not virtual.
class TestProperty {
 public:
  // C'tor.  TestProperty does NOT have a default constructor.
  // Always use this constructor (with parameters) to create a
  // TestProperty object.
491
  TestProperty(const std::string& a_key, const std::string& a_value) :
492
    key_(a_key), value_(a_value) {
493
494
495
496
497
498
499
500
501
502
503
504
505
  }

  // Gets the user supplied key.
  const char* key() const {
    return key_.c_str();
  }

  // Gets the user supplied value.
  const char* value() const {
    return value_.c_str();
  }

  // Sets a new value, overriding the one supplied in the constructor.
506
  void SetValue(const std::string& new_value) {
507
508
509
510
511
    value_ = new_value;
  }

 private:
  // The key supplied by the user.
512
  std::string key_;
513
  // The value supplied by the user.
514
  std::string value_;
515
516
};

517
518
519
520
521
522
// The result of a single Test.  This includes a list of
// TestPartResults, a list of TestProperties, a count of how many
// death tests there are in the Test, and how much time it took to run
// the Test.
//
// TestResult is not copyable.
523
class GTEST_API_ TestResult {
524
525
526
527
528
529
530
531
532
533
534
 public:
  // Creates an empty TestResult.
  TestResult();

  // D'tor.  Do not inherit from TestResult.
  ~TestResult();

  // Gets the number of all test parts.  This is the sum of the number
  // of successful test parts and the number of failed test parts.
  int total_part_count() const;

535
536
537
  // Returns the number of the test properties.
  int test_property_count() const;

538
539
540
541
  // Returns true iff the test passed (i.e. no test part failed).
  bool Passed() const { return !Failed(); }

  // Returns true iff the test failed.
542
  bool Failed() const;
543
544
545
546
547
548
549
550
551
552

  // Returns true iff the test fatally failed.
  bool HasFatalFailure() const;

  // Returns true iff the test has a non-fatal failure.
  bool HasNonfatalFailure() const;

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

553
  // Returns the i-th test part result among all the results. i can range
554
555
556
  // from 0 to test_property_count() - 1. If i is not in that range, aborts
  // the program.
  const TestPartResult& GetTestPartResult(int i) const;
557
558

  // Returns the i-th test property. i can range from 0 to
559
560
561
  // test_property_count() - 1. If i is not in that range, aborts the
  // program.
  const TestProperty& GetTestProperty(int i) const;
562

563
 private:
564
  friend class TestInfo;
565
  friend class TestCase;
566
  friend class UnitTest;
567
568
569
570
571
  friend class internal::DefaultGlobalTestPartResultReporter;
  friend class internal::ExecDeathTest;
  friend class internal::TestResultAccessor;
  friend class internal::UnitTestImpl;
  friend class internal::WindowsDeathTest;
572

573
  // Gets the vector of TestPartResults.
574
575
  const std::vector<TestPartResult>& test_part_results() const {
    return test_part_results_;
576
577
  }

578
  // Gets the vector of TestProperties.
579
580
  const std::vector<TestProperty>& test_properties() const {
    return test_properties_;
581
582
583
584
  }

  // Sets the elapsed time.
  void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }
585
586
587
588
589

  // Adds a test property to the list. The property is validated and may add
  // a non-fatal failure if invalid (e.g., if it conflicts with reserved
  // key names). If a property is already recorded for the same key, the
  // value will be updated, rather than storing multiple values for the same
590
591
592
593
  // key.  xml_element specifies the element for which the property is being
  // recorded and is used for validation.
  void RecordProperty(const std::string& xml_element,
                      const TestProperty& test_property);
594
595
596
597

  // Adds a failure if the key is a reserved attribute of Google Test
  // testcase tags.  Returns true if the property is valid.
  // TODO(russr): Validate attribute names are legal and human readable.
598
599
  static bool ValidateTestProperty(const std::string& xml_element,
                                   const TestProperty& test_property);
600

601
602
603
  // Adds a test part result to the list.
  void AddTestPartResult(const TestPartResult& test_part_result);

604
605
606
607
608
609
610
611
612
613
614
  // Returns the death test count.
  int death_test_count() const { return death_test_count_; }

  // Increments the death test count, returning the new count.
  int increment_death_test_count() { return ++death_test_count_; }

  // Clears the test part results.
  void ClearTestPartResults();

  // Clears the object.
  void Clear();
615

616
617
  // Protects mutable state of the property vector and of owned
  // properties, whose values may be updated.
618
619
  internal::Mutex test_properites_mutex_;

620
  // The vector of TestPartResults
621
  std::vector<TestPartResult> test_part_results_;
622
  // The vector of TestProperties
623
  std::vector<TestProperty> test_properties_;
624
625
626
627
628
629
630
631
632
  // Running count of death tests.
  int death_test_count_;
  // The elapsed time, in milliseconds.
  TimeInMillis elapsed_time_;

  // We disallow copying TestResult.
  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult);
};  // class TestResult

shiqian's avatar
shiqian committed
633
634
635
636
637
638
639
640
641
642
643
// A TestInfo object stores the following information about a test:
//
//   Test case name
//   Test name
//   Whether the test should be run
//   A function pointer that creates the test object when invoked
//   Test result
//
// The constructor of TestInfo registers itself with the UnitTest
// singleton such that the RUN_ALL_TESTS() macro knows which tests to
// run.
644
class GTEST_API_ TestInfo {
shiqian's avatar
shiqian committed
645
646
647
648
649
650
 public:
  // Destructs a TestInfo object.  This function is not virtual, so
  // don't inherit from TestInfo.
  ~TestInfo();

  // Returns the test case name.
651
  const char* test_case_name() const { return test_case_name_.c_str(); }
shiqian's avatar
shiqian committed
652
653

  // Returns the test name.
654
  const char* name() const { return name_.c_str(); }
shiqian's avatar
shiqian committed
655

656
657
658
659
660
661
662
  // Returns the name of the parameter type, or NULL if this is not a typed
  // or a type-parameterized test.
  const char* type_param() const {
    if (type_param_.get() != NULL)
      return type_param_->c_str();
    return NULL;
  }
663

664
665
666
667
668
669
670
  // Returns the text representation of the value parameter, or NULL if this
  // is not a value-parameterized test.
  const char* value_param() const {
    if (value_param_.get() != NULL)
      return value_param_->c_str();
    return NULL;
  }
671

672
673
674
  // Returns true if this test should run, that is if the test is not
  // disabled (or it is disabled but the also_run_disabled_tests flag has
  // been specified) and its full name matches the user-specified filter.
shiqian's avatar
shiqian committed
675
676
677
678
679
680
681
682
683
684
685
686
687
  //
  // Google Test allows the user to filter the tests by their full names.
  // The full name of a test Bar in test case Foo is defined as
  // "Foo.Bar".  Only the tests that match the filter will run.
  //
  // A filter is a colon-separated list of glob (not regex) patterns,
  // optionally followed by a '-' and a colon-separated list of
  // negative patterns (tests to exclude).  A test is run if it
  // matches one of the positive patterns and does not match any of
  // the negative patterns.
  //
  // For example, *A*:Foo.* is a filter that matches any string that
  // contains the character 'A' or starts with "Foo.".
688
  bool should_run() const { return should_run_; }
shiqian's avatar
shiqian committed
689

690
691
692
693
694
695
696
697
  // Returns true iff this test will appear in the XML report.
  bool is_reportable() const {
    // For now, the XML report includes all tests matching the filter.
    // In the future, we may trim tests that are excluded because of
    // sharding.
    return matches_filter_;
  }

shiqian's avatar
shiqian committed
698
  // Returns the result of the test.
699
  const TestResult* result() const { return &result_; }
700

shiqian's avatar
shiqian committed
701
 private:
zhanyong.wan's avatar
zhanyong.wan committed
702
#if GTEST_HAS_DEATH_TEST
shiqian's avatar
shiqian committed
703
704
  friend class internal::DefaultDeathTestFactory;
#endif  // GTEST_HAS_DEATH_TEST
705
706
  friend class Test;
  friend class TestCase;
shiqian's avatar
shiqian committed
707
  friend class internal::UnitTestImpl;
kosak's avatar
kosak committed
708
  friend class internal::StreamingListenerTest;
709
  friend TestInfo* internal::MakeAndRegisterTestInfo(
710
711
      const char* test_case_name,
      const char* name,
712
713
      const char* type_param,
      const char* value_param,
714
715
716
717
      internal::TypeId fixture_class_id,
      Test::SetUpTestCaseFunc set_up_tc,
      Test::TearDownTestCaseFunc tear_down_tc,
      internal::TestFactoryBase* factory);
shiqian's avatar
shiqian committed
718

719
720
  // Constructs a TestInfo object. The newly constructed instance assumes
  // ownership of the factory object.
721
722
723
724
  TestInfo(const std::string& test_case_name,
           const std::string& name,
           const char* a_type_param,   // NULL if not a type-parameterized test
           const char* a_value_param,  // NULL if not a value-parameterized test
725
726
           internal::TypeId fixture_class_id,
           internal::TestFactoryBase* factory);
shiqian's avatar
shiqian committed
727

728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
  // Increments the number of death tests encountered in this test so
  // far.
  int increment_death_test_count() {
    return result_.increment_death_test_count();
  }

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

  static void ClearTestResult(TestInfo* test_info) {
    test_info->result_.Clear();
  }

  // These fields are immutable properties of the test.
  const std::string test_case_name_;     // Test case name
  const std::string name_;               // Test name
745
746
747
748
749
750
  // Name of the parameter type, or NULL if this is not a typed or a
  // type-parameterized test.
  const internal::scoped_ptr<const ::std::string> type_param_;
  // Text representation of the value parameter, or NULL if this is not a
  // value-parameterized test.
  const internal::scoped_ptr<const ::std::string> value_param_;
751
752
753
754
755
756
757
758
759
760
761
  const internal::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
  bool matches_filter_;             // True if this test matches the
                                    // user-specified filter.
  internal::TestFactoryBase* const factory_;  // The factory that creates
                                              // the test object

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

shiqian's avatar
shiqian committed
763
  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
shiqian's avatar
shiqian committed
764
765
};

766
// A test case, which consists of a vector of TestInfos.
767
768
//
// TestCase is not copyable.
769
class GTEST_API_ TestCase {
770
771
772
773
774
775
776
777
778
 public:
  // Creates a TestCase with the given name.
  //
  // TestCase does NOT have a default constructor.  Always use this
  // constructor to create a TestCase object.
  //
  // Arguments:
  //
  //   name:         name of the test case
779
780
  //   a_type_param: the name of the test's type parameter, or NULL if
  //                 this is not a type-parameterized test.
781
782
  //   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
783
  TestCase(const char* name, const char* a_type_param,
784
785
786
787
788
789
790
791
792
           Test::SetUpTestCaseFunc set_up_tc,
           Test::TearDownTestCaseFunc tear_down_tc);

  // Destructor of TestCase.
  virtual ~TestCase();

  // Gets the name of the TestCase.
  const char* name() const { return name_.c_str(); }

793
794
795
796
797
798
799
  // Returns the name of the parameter type, or NULL if this is not a
  // type-parameterized test case.
  const char* type_param() const {
    if (type_param_.get() != NULL)
      return type_param_->c_str();
    return NULL;
  }
800
801
802
803
804
805
806
807
808
809

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

  // Gets the number of successful tests in this test case.
  int successful_test_count() const;

  // Gets the number of failed tests in this test case.
  int failed_test_count() const;

810
811
812
  // Gets the number of disabled tests that will be reported in the XML report.
  int reportable_disabled_test_count() const;

813
814
815
  // Gets the number of disabled tests in this test case.
  int disabled_test_count() const;

816
817
818
  // Gets the number of tests to be printed in the XML report.
  int reportable_test_count() const;

819
820
821
822
823
824
825
826
827
828
829
830
831
  // Get the number of tests in this test case that should run.
  int test_to_run_count() const;

  // Gets the number of all tests in this test case.
  int total_test_count() const;

  // Returns true iff the test case passed.
  bool Passed() const { return !Failed(); }

  // Returns true iff the test case failed.
  bool Failed() const { return failed_test_count() > 0; }

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

834
835
836
837
  // Returns the i-th test among all the tests. i can range from 0 to
  // total_test_count() - 1. If i is not in that range, returns NULL.
  const TestInfo* GetTestInfo(int i) const;

838
839
840
841
  // Returns the TestResult that holds test properties recorded during
  // execution of SetUpTestCase and TearDownTestCase.
  const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; }

842
 private:
843
  friend class Test;
844
  friend class internal::UnitTestImpl;
845

846
  // Gets the (mutable) vector of TestInfos in this TestCase.
847
  std::vector<TestInfo*>& test_info_list() { return test_info_list_; }
848

849
  // Gets the (immutable) vector of TestInfos in this TestCase.
850
851
  const std::vector<TestInfo*>& test_info_list() const {
    return test_info_list_;
852
853
  }

854
855
856
857
  // Returns the i-th test among all the tests. i can range from 0 to
  // total_test_count() - 1. If i is not in that range, returns NULL.
  TestInfo* GetMutableTestInfo(int i);

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

861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
  // Adds a TestInfo to this test case.  Will delete the TestInfo upon
  // destruction of the TestCase object.
  void AddTestInfo(TestInfo * test_info);

  // Clears the results of all tests in this test case.
  void ClearResult();

  // Clears the results of all tests in the given test case.
  static void ClearTestCaseResult(TestCase* test_case) {
    test_case->ClearResult();
  }

  // Runs every test in this TestCase.
  void Run();

876
877
878
879
880
881
882
883
  // Runs SetUpTestCase() for this TestCase.  This wrapper is needed
  // for catching exceptions thrown from SetUpTestCase().
  void RunSetUpTestCase() { (*set_up_tc_)(); }

  // Runs TearDownTestCase() for this TestCase.  This wrapper is
  // needed for catching exceptions thrown from TearDownTestCase().
  void RunTearDownTestCase() { (*tear_down_tc_)(); }

884
  // Returns true iff test passed.
885
886
887
  static bool TestPassed(const TestInfo* test_info) {
    return test_info->should_run() && test_info->result()->Passed();
  }
888
889

  // Returns true iff test failed.
890
891
892
  static bool TestFailed(const TestInfo* test_info) {
    return test_info->should_run() && test_info->result()->Failed();
  }
893

894
895
896
897
898
899
  // Returns true iff the test is disabled and will be reported in the XML
  // report.
  static bool TestReportableDisabled(const TestInfo* test_info) {
    return test_info->is_reportable() && test_info->is_disabled_;
  }

900
  // Returns true iff test is disabled.
901
902
903
  static bool TestDisabled(const TestInfo* test_info) {
    return test_info->is_disabled_;
  }
904

905
906
907
908
909
  // Returns true iff this test will appear in the XML report.
  static bool TestReportable(const TestInfo* test_info) {
    return test_info->is_reportable();
  }

910
  // Returns true if the given test should run.
911
912
913
  static bool ShouldRunTest(const TestInfo* test_info) {
    return test_info->should_run();
  }
914

915
916
917
918
919
920
  // Shuffles the tests in this test case.
  void ShuffleTests(internal::Random* random);

  // Restores the test order to before the first shuffle.
  void UnshuffleTests();

921
  // Name of the test case.
922
  std::string name_;
923
924
925
  // Name of the parameter type, or NULL if this is not a typed or a
  // type-parameterized test.
  const internal::scoped_ptr<const ::std::string> type_param_;
926
927
  // The vector of TestInfos in their original order.  It owns the
  // elements in the vector.
928
  std::vector<TestInfo*> test_info_list_;
929
930
931
  // Provides a level of indirection for the test list to allow easy
  // shuffling and restoring the test order.  The i-th element in this
  // vector is the index of the i-th test in the shuffled test list.
932
  std::vector<int> test_indices_;
933
934
935
936
937
938
939
  // Pointer to the function that sets up the test case.
  Test::SetUpTestCaseFunc set_up_tc_;
  // Pointer to the function that tears down the test case.
  Test::TearDownTestCaseFunc tear_down_tc_;
  // True iff any test in this test case should run.
  bool should_run_;
  // Elapsed time, in milliseconds.
940
  TimeInMillis elapsed_time_;
941
942
943
  // Holds test properties recorded during execution of SetUpTestCase and
  // TearDownTestCase.
  TestResult ad_hoc_test_result_;
944
945
946
947
948

  // We disallow copying TestCases.
  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestCase);
};

shiqian's avatar
shiqian committed
949
// An Environment object is capable of setting up and tearing down an
950
// environment.  You should subclass this to define your own
shiqian's avatar
shiqian committed
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
// environment(s).
//
// An Environment object does the set-up and tear-down in virtual
// methods SetUp() and TearDown() instead of the constructor and the
// destructor, as:
//
//   1. You cannot safely throw from a destructor.  This is a problem
//      as in some cases Google Test is used where exceptions are enabled, and
//      we may want to implement ASSERT_* using exceptions where they are
//      available.
//   2. You cannot use ASSERT_* directly in a constructor or
//      destructor.
class Environment {
 public:
  // The d'tor is virtual as we need to subclass Environment.
  virtual ~Environment() {}

  // Override this to define how to set up the environment.
  virtual void SetUp() {}

  // Override this to define how to tear down the environment.
  virtual void TearDown() {}
 private:
  // If you see an error about overriding the following function or
  // about it being private, you have mis-spelled SetUp() as Setup().
  struct Setup_should_be_spelled_SetUp {};
  virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
};

980
981
// The interface for tracing execution of tests. The methods are organized in
// the order the corresponding events are fired.
982
class TestEventListener {
983
 public:
984
  virtual ~TestEventListener() {}
985

986
987
  // Fired before any test activity starts.
  virtual void OnTestProgramStart(const UnitTest& unit_test) = 0;
988

989
990
991
992
993
994
995
996
  // Fired before each iteration of tests starts.  There may be more than
  // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration
  // index, starting from 0.
  virtual void OnTestIterationStart(const UnitTest& unit_test,
                                    int iteration) = 0;

  // Fired before environment set-up for each iteration of tests starts.
  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0;
997

998
999
  // Fired after environment set-up for each iteration of tests ends.
  virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0;
1000

1001
1002
  // Fired before the test case starts.
  virtual void OnTestCaseStart(const TestCase& test_case) = 0;
1003

1004
  // Fired before the test starts.
1005
1006
  virtual void OnTestStart(const TestInfo& test_info) = 0;

1007
  // Fired after a failed assertion or a SUCCEED() invocation.
1008
1009
  virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0;

1010
  // Fired after the test ends.
1011
1012
  virtual void OnTestEnd(const TestInfo& test_info) = 0;

1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
  // Fired after the test case ends.
  virtual void OnTestCaseEnd(const TestCase& test_case) = 0;

  // Fired before environment tear-down for each iteration of tests starts.
  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0;

  // Fired after environment tear-down for each iteration of tests ends.
  virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0;

  // Fired after each iteration of tests finishes.
  virtual void OnTestIterationEnd(const UnitTest& unit_test,
                                  int iteration) = 0;

  // Fired after all test activities have ended.
  virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0;
1028
1029
1030
1031
};

// The convenience class for users who need to override just one or two
// methods and are not concerned that a possible change to a signature of
1032
1033
1034
1035
// the methods they override will not be caught during the build.  For
// comments about each method please see the definition of TestEventListener
// above.
class EmptyTestEventListener : public TestEventListener {
1036
 public:
1037
1038
1039
1040
1041
  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
  virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
                                    int /*iteration*/) {}
  virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {}
  virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
1042
1043
  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
  virtual void OnTestStart(const TestInfo& /*test_info*/) {}
1044
  virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {}
1045
1046
1047
1048
1049
1050
1051
  virtual void OnTestEnd(const TestInfo& /*test_info*/) {}
  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
  virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {}
  virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {}
  virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
                                  int /*iteration*/) {}
  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
1052
1053
};

1054
// TestEventListeners lets users add listeners to track events in Google Test.
1055
class GTEST_API_ TestEventListeners {
1056
 public:
1057
1058
  TestEventListeners();
  ~TestEventListeners();
1059
1060
1061
1062

  // Appends an event listener to the end of the list. Google Test assumes
  // the ownership of the listener (i.e. it will delete the listener when
  // the test program finishes).
1063
  void Append(TestEventListener* listener);
1064
1065
1066
1067

  // Removes the given event listener from the list and returns it.  It then
  // becomes the caller's responsibility to delete the listener. Returns
  // NULL if the listener is not found in the list.
1068
  TestEventListener* Release(TestEventListener* listener);
1069
1070
1071
1072
1073
1074

  // Returns the standard listener responsible for the default console
  // output.  Can be removed from the listeners list to shut down default
  // console output.  Note that removing this object from the listener list
  // with Release transfers its ownership to the caller and makes this
  // function return NULL the next time.
1075
  TestEventListener* default_result_printer() const {
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
    return default_result_printer_;
  }

  // Returns the standard listener responsible for the default XML output
  // controlled by the --gtest_output=xml flag.  Can be removed from the
  // listeners list by users who want to shut down the default XML output
  // controlled by this flag and substitute it with custom one.  Note that
  // removing this object from the listener list with Release transfers its
  // ownership to the caller and makes this function return NULL the next
  // time.
1086
  TestEventListener* default_xml_generator() const {
1087
1088
1089
1090
    return default_xml_generator_;
  }

 private:
1091
  friend class TestCase;
1092
  friend class TestInfo;
1093
1094
  friend class internal::DefaultGlobalTestPartResultReporter;
  friend class internal::NoExecDeathTest;
1095
  friend class internal::TestEventListenersAccessor;
1096
1097
  friend class internal::UnitTestImpl;

1098
1099
1100
  // Returns repeater that broadcasts the TestEventListener events to all
  // subscribers.
  TestEventListener* repeater();
1101
1102
1103
1104
1105
1106

  // Sets the default_result_printer attribute to the provided listener.
  // The listener is also added to the listener list and previous
  // default_result_printer is removed from it and deleted. The listener can
  // also be NULL in which case it will not be added to the list. Does
  // nothing if the previous and the current listener objects are the same.
1107
  void SetDefaultResultPrinter(TestEventListener* listener);
1108
1109
1110
1111
1112
1113

  // Sets the default_xml_generator attribute to the provided listener.  The
  // listener is also added to the listener list and previous
  // default_xml_generator is removed from it and deleted. The listener can
  // also be NULL in which case it will not be added to the list. Does
  // nothing if the previous and the current listener objects are the same.
1114
  void SetDefaultXmlGenerator(TestEventListener* listener);
1115
1116
1117
1118
1119
1120
1121

  // Controls whether events will be forwarded by the repeater to the
  // listeners in the list.
  bool EventForwardingEnabled() const;
  void SuppressEventForwarding();

  // The actual list of listeners.
1122
  internal::TestEventRepeater* repeater_;
1123
  // Listener responsible for the standard result output.
1124
  TestEventListener* default_result_printer_;
1125
  // Listener responsible for the creation of the XML output file.
1126
  TestEventListener* default_xml_generator_;
1127

1128
1129
  // We disallow copying TestEventListeners.
  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
1130
1131
};

1132
// A UnitTest consists of a vector of TestCases.
shiqian's avatar
shiqian committed
1133
1134
1135
1136
1137
1138
1139
1140
1141
//
// This is a singleton class.  The only instance of UnitTest is
// created when UnitTest::GetInstance() is first called.  This
// instance is never deleted.
//
// UnitTest is not copyable.
//
// This class is thread-safe as long as the methods are called
// according to their specification.
1142
class GTEST_API_ UnitTest {
shiqian's avatar
shiqian committed
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
 public:
  // Gets the singleton UnitTest object.  The first time this method
  // is called, a UnitTest object is constructed and returned.
  // Consecutive calls will return the same object.
  static UnitTest* GetInstance();

  // Runs all tests in this UnitTest object and prints the result.
  // Returns 0 if successful, or 1 otherwise.
  //
  // This method can only be called from the main thread.
  //
  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
shiqian's avatar
shiqian committed
1155
  int Run() GTEST_MUST_USE_RESULT_;
shiqian's avatar
shiqian committed
1156

1157
1158
1159
1160
  // Returns the working directory when the first TEST() or TEST_F()
  // was executed.  The UnitTest object owns the string.
  const char* original_working_dir() const;

shiqian's avatar
shiqian committed
1161
1162
  // Returns the TestCase object for the test that's currently running,
  // or NULL if no test is running.
1163
1164
  const TestCase* current_test_case() const
      GTEST_LOCK_EXCLUDED_(mutex_);
shiqian's avatar
shiqian committed
1165
1166
1167

  // Returns the TestInfo object for the test that's currently running,
  // or NULL if no test is running.
1168
1169
  const TestInfo* current_test_info() const
      GTEST_LOCK_EXCLUDED_(mutex_);
shiqian's avatar
shiqian committed
1170

1171
1172
1173
  // Returns the random seed used at the start of the current test run.
  int random_seed() const;

zhanyong.wan's avatar
zhanyong.wan committed
1174
#if GTEST_HAS_PARAM_TEST
1175
1176
  // Returns the ParameterizedTestCaseRegistry object used to keep track of
  // value-parameterized tests and instantiate and register them.
1177
1178
  //
  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1179
1180
  internal::ParameterizedTestCaseRegistry& parameterized_test_registry()
      GTEST_LOCK_EXCLUDED_(mutex_);
1181
1182
#endif  // GTEST_HAS_PARAM_TEST

1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
  // 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;

1202
1203
1204
  // Gets the number of disabled tests that will be reported in the XML report.
  int reportable_disabled_test_count() const;

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

1208
1209
1210
  // Gets the number of tests to be printed in the XML report.
  int reportable_test_count() const;

1211
1212
1213
1214
1215
1216
  // 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;

1217
1218
1219
1220
  // Gets the time of the test program start, in ms from the start of the
  // UNIX epoch.
  TimeInMillis start_timestamp() const;

1221
  // Gets the elapsed time, in milliseconds.
1222
  TimeInMillis elapsed_time() const;
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232

  // Returns true iff the unit test passed (i.e. all test cases passed).
  bool Passed() const;

  // Returns true iff the unit test failed (i.e. some test case failed
  // or something outside of all tests failed).
  bool Failed() const;

  // 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.
1233
  const TestCase* GetTestCase(int i) const;
1234

1235
1236
1237
1238
  // Returns the TestResult containing information on test failures and
  // properties logged outside of individual test cases.
  const TestResult& ad_hoc_test_result() const;

1239
1240
  // Returns the list of event listeners that can be used to track events
  // inside Google Test.
1241
  TestEventListeners& listeners();
1242

1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
 private:
  // Registers and returns a global test environment.  When a test
  // program is run, all global test environments will be set-up in
  // the order they were registered.  After all tests in the program
  // have finished, all global test environments will be torn-down in
  // the *reverse* order they were registered.
  //
  // The UnitTest object takes ownership of the given environment.
  //
  // This method can only be called from the main thread.
  Environment* AddEnvironment(Environment* env);

  // Adds a TestPartResult to the current TestResult object.  All
  // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc)
  // eventually call this to report their results.  The user code
  // should use the assertion macros instead of calling this directly.
  void AddTestPartResult(TestPartResult::Type result_type,
                         const char* file_name,
                         int line_number,
1262
1263
                         const std::string& message,
                         const std::string& os_stack_trace)
1264
      GTEST_LOCK_EXCLUDED_(mutex_);
1265

1266
1267
1268
1269
1270
1271
  // Adds a TestProperty to the current TestResult object when invoked from
  // inside a test, to current TestCase's ad_hoc_test_result_ when invoked
  // from SetUpTestCase or TearDownTestCase, or to the global property set
  // when invoked elsewhere.  If the result already contains a property with
  // the same key, the value will be updated.
  void RecordProperty(const std::string& key, const std::string& value);
1272

1273
1274
1275
1276
  // 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);

1277
1278
1279
1280
1281
1282
1283
1284
  // Accessors for the implementation object.
  internal::UnitTestImpl* impl() { return impl_; }
  const internal::UnitTestImpl* impl() const { return impl_; }

  // These classes and funcions are friends as they need to access private
  // members of UnitTest.
  friend class Test;
  friend class internal::AssertHelper;
shiqian's avatar
shiqian committed
1285
  friend class internal::ScopedTrace;
kosak's avatar
kosak committed
1286
  friend class internal::StreamingListenerTest;
1287
  friend class internal::UnitTestRecordPropertyTestHelper;
1288
1289
1290
  friend Environment* AddGlobalTestEnvironment(Environment* env);
  friend internal::UnitTestImpl* internal::GetUnitTestImpl();
  friend void internal::ReportFailureInUnknownLocation(
1291
      TestPartResult::Type result_type,
1292
      const std::string& message);
shiqian's avatar
shiqian committed
1293
1294
1295
1296
1297
1298
1299
1300
1301

  // Creates an empty UnitTest.
  UnitTest();

  // D'tor
  virtual ~UnitTest();

  // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
  // Google Test trace stack.
1302
1303
  void PushGTestTrace(const internal::TraceInfo& trace)
      GTEST_LOCK_EXCLUDED_(mutex_);
shiqian's avatar
shiqian committed
1304
1305

  // Pops a trace from the per-thread Google Test trace stack.
1306
1307
  void PopGTestTrace()
      GTEST_LOCK_EXCLUDED_(mutex_);
shiqian's avatar
shiqian committed
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319

  // Protects mutable state in *impl_.  This is mutable as some const
  // methods need to lock it too.
  mutable internal::Mutex mutex_;

  // Opaque implementation object.  This field is never changed once
  // the object is constructed.  We don't mark it as const here, as
  // doing so will cause a warning in the constructor of UnitTest.
  // Mutable state in *impl_ is protected by mutex_.
  internal::UnitTestImpl* impl_;

  // We disallow copying UnitTest.
shiqian's avatar
shiqian committed
1320
  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest);
shiqian's avatar
shiqian committed
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
};

// A convenient wrapper for adding an environment for the test
// program.
//
// You should call this before RUN_ALL_TESTS() is called, probably in
// main().  If you use gtest_main, you need to call this before main()
// starts for it to take effect.  For example, you can define a global
// variable like this:
//
//   testing::Environment* const foo_env =
//       testing::AddGlobalTestEnvironment(new FooEnvironment);
//
// However, we strongly recommend you to write your own main() and
// call AddGlobalTestEnvironment() there, as relying on initialization
// of global variables makes the code harder to read and may cause
// problems when you register multiple environments from different
// translation units and the environments have dependencies among them
// (remember that the compiler doesn't guarantee the order in which
// global variables from different translation units are initialized).
inline Environment* AddGlobalTestEnvironment(Environment* env) {
  return UnitTest::GetInstance()->AddEnvironment(env);
}

// Initializes Google Test.  This must be called before calling
// RUN_ALL_TESTS().  In particular, it parses a command line for the
// flags that Google Test recognizes.  Whenever a Google Test flag is
// seen, it is removed from argv, and *argc is decremented.
//
// No value is returned.  Instead, the Google Test flag variables are
// updated.
1352
1353
//
// Calling the function for the second time has no user-visible effect.
1354
GTEST_API_ void InitGoogleTest(int* argc, char** argv);
shiqian's avatar
shiqian committed
1355
1356
1357

// This overloaded version can be used in Windows programs compiled in
// UNICODE mode.
1358
GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);
shiqian's avatar
shiqian committed
1359
1360
1361

namespace internal {

1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
// FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
// value of type ToPrint that is an operand of a comparison assertion
// (e.g. ASSERT_EQ).  OtherOperand is the type of the other operand in
// the comparison, and is used to help determine the best way to
// format the value.  In particular, when the value is a C string
// (char pointer) and the other operand is an STL string object, we
// want to format the C string as a string, since we know it is
// compared by value with the string object.  If the value is a char
// pointer but the other operand is not an STL string object, we don't
// know whether the pointer is supposed to point to a NUL-terminated
// string, and thus want to print it as a pointer to be safe.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.

// The default case.
template <typename ToPrint, typename OtherOperand>
class FormatForComparison {
 public:
  static ::std::string Format(const ToPrint& value) {
    return ::testing::PrintToString(value);
  }
};

// Array.
template <typename ToPrint, size_t N, typename OtherOperand>
class FormatForComparison<ToPrint[N], OtherOperand> {
 public:
  static ::std::string Format(const ToPrint* value) {
    return FormatForComparison<const ToPrint*, OtherOperand>::Format(value);
  }
};

// By default, print C string as pointers to be safe, as we don't know
// whether they actually point to a NUL-terminated string.

#define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType)                \
  template <typename OtherOperand>                                      \
  class FormatForComparison<CharType*, OtherOperand> {                  \
   public:                                                              \
    static ::std::string Format(CharType* value) {                      \
      return ::testing::PrintToString(static_cast<const void*>(value)); \
    }                                                                   \
  }

GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);

#undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_

// If a C string is compared with an STL string object, we know it's meant
// to point to a NUL-terminated string, and thus can print it as a string.

#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
  template <>                                                           \
  class FormatForComparison<CharType*, OtherStringType> {               \
   public:                                                              \
    static ::std::string Format(CharType* value) {                      \
      return ::testing::PrintToString(value);                           \
    }                                                                   \
  }

GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);

#if GTEST_HAS_GLOBAL_STRING
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::string);
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::string);
#endif

#if GTEST_HAS_GLOBAL_WSTRING
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::wstring);
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::wstring);
#endif

#if GTEST_HAS_STD_WSTRING
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring);
#endif

#undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_

shiqian's avatar
shiqian committed
1445
1446
1447
1448
// Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
// operand to be used in a failure message.  The type (but not value)
// of the other operand may affect the format.  This allows us to
// print a char* as a raw pointer when it is compared against another
1449
1450
// char* or void*, and print it as a C string when it is compared
// against an std::string object, for example.
shiqian's avatar
shiqian committed
1451
1452
1453
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
template <typename T1, typename T2>
1454
1455
std::string FormatForComparisonFailureMessage(
    const T1& value, const T2& /* other_operand */) {
1456
  return FormatForComparison<T1, T2>::Format(value);
shiqian's avatar
shiqian committed
1457
1458
}

1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
// Separate the error generating code from the code path to reduce the stack
// frame size of CmpHelperEQ. This helps reduce the overhead of some sanitizers
// when calling EXPECT_* in a tight loop.
template <typename T1, typename T2>
AssertionResult CmpHelperEQFailure(const char* expected_expression,
                                   const char* actual_expression,
                                   const T1& expected, const T2& actual) {
  return EqFailure(expected_expression,
                   actual_expression,
                   FormatForComparisonFailureMessage(expected, actual),
                   FormatForComparisonFailureMessage(actual, expected),
                   false);
}

shiqian's avatar
shiqian committed
1473
1474
1475
1476
1477
1478
// The helper function for {ASSERT|EXPECT}_EQ.
template <typename T1, typename T2>
AssertionResult CmpHelperEQ(const char* expected_expression,
                            const char* actual_expression,
                            const T1& expected,
                            const T2& actual) {
billydonahue's avatar
billydonahue committed
1479
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
shiqian's avatar
shiqian committed
1480
1481
1482
  if (expected == actual) {
    return AssertionSuccess();
  }
billydonahue's avatar
billydonahue committed
1483
GTEST_DISABLE_MSC_WARNINGS_POP_()
1484

1485
1486
  return CmpHelperEQFailure(expected_expression, actual_expression, expected,
                            actual);
shiqian's avatar
shiqian committed
1487
1488
1489
1490
1491
}

// With this overloaded version, we allow anonymous enums to be used
// in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums
// can be implicitly cast to BiggestInt.
zhanyong.wan's avatar
zhanyong.wan committed
1492
1493
1494
1495
GTEST_API_ AssertionResult CmpHelperEQ(const char* expected_expression,
                                       const char* actual_expression,
                                       BiggestInt expected,
                                       BiggestInt actual);
shiqian's avatar
shiqian committed
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529

// The helper class for {ASSERT|EXPECT}_EQ.  The template argument
// lhs_is_null_literal is true iff the first argument to ASSERT_EQ()
// is a null pointer literal.  The following default implementation is
// for lhs_is_null_literal being false.
template <bool lhs_is_null_literal>
class EqHelper {
 public:
  // This templatized version is for the general case.
  template <typename T1, typename T2>
  static AssertionResult Compare(const char* expected_expression,
                                 const char* actual_expression,
                                 const T1& expected,
                                 const T2& actual) {
    return CmpHelperEQ(expected_expression, actual_expression, expected,
                       actual);
  }

  // With this overloaded version, we allow anonymous enums to be used
  // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous
  // enums can be implicitly cast to BiggestInt.
  //
  // Even though its body looks the same as the above version, we
  // cannot merge the two, as it will make anonymous enums unhappy.
  static AssertionResult Compare(const char* expected_expression,
                                 const char* actual_expression,
                                 BiggestInt expected,
                                 BiggestInt actual) {
    return CmpHelperEQ(expected_expression, actual_expression, expected,
                       actual);
  }
};

// This specialization is used when the first argument to ASSERT_EQ()
1530
// is a null pointer literal, like NULL, false, or 0.
shiqian's avatar
shiqian committed
1531
1532
1533
1534
1535
1536
1537
1538
template <>
class EqHelper<true> {
 public:
  // We define two overloaded versions of Compare().  The first
  // version will be picked when the second argument to ASSERT_EQ() is
  // NOT a pointer, e.g. ASSERT_EQ(0, AnIntFunction()) or
  // EXPECT_EQ(false, a_bool).
  template <typename T1, typename T2>
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
  static AssertionResult Compare(
      const char* expected_expression,
      const char* actual_expression,
      const T1& expected,
      const T2& actual,
      // The following line prevents this overload from being considered if T2
      // is not a pointer type.  We need this because ASSERT_EQ(NULL, my_ptr)
      // expands to Compare("", "", NULL, my_ptr), which requires a conversion
      // to match the Secret* in the other overload, which would otherwise make
      // this template match better.
      typename EnableIf<!is_pointer<T2>::value>::type* = 0) {
shiqian's avatar
shiqian committed
1550
1551
1552
1553
    return CmpHelperEQ(expected_expression, actual_expression, expected,
                       actual);
  }

1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
  // This version will be picked when the second argument to ASSERT_EQ() is a
  // pointer, e.g. ASSERT_EQ(NULL, a_pointer).
  template <typename T>
  static AssertionResult Compare(
      const char* expected_expression,
      const char* actual_expression,
      // We used to have a second template parameter instead of Secret*.  That
      // template parameter would deduce to 'long', making this a better match
      // than the first overload even without the first overload's EnableIf.
      // Unfortunately, gcc with -Wconversion-null warns when "passing NULL to
      // non-pointer argument" (even a deduced integral argument), so the old
      // implementation caused warnings in user code.
      Secret* /* expected (NULL) */,
      T* actual) {
shiqian's avatar
shiqian committed
1568
1569
    // We already know that 'expected' is a null pointer.
    return CmpHelperEQ(expected_expression, actual_expression,
1570
                       static_cast<T*>(NULL), actual);
shiqian's avatar
shiqian committed
1571
1572
1573
  }
};

1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
// Separate the error generating code from the code path to reduce the stack
// frame size of CmpHelperOP. This helps reduce the overhead of some sanitizers
// when calling EXPECT_OP in a tight loop.
template <typename T1, typename T2>
AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
                                   const T1& val1, const T2& val2,
                                   const char* op) {
  return AssertionFailure()
         << "Expected: (" << expr1 << ") " << op << " (" << expr2
         << "), actual: " << FormatForComparisonFailureMessage(val1, val2)
         << " vs " << FormatForComparisonFailureMessage(val2, val1);
}

shiqian's avatar
shiqian committed
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
// A macro for implementing the helper functions needed to implement
// ASSERT_?? and EXPECT_??.  It is here just to avoid copy-and-paste
// of similar code.
//
// For each templatized helper function, we also define an overloaded
// version for BiggestInt in order to reduce code bloat and allow
// anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled
// with gcc 4.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1597

shiqian's avatar
shiqian committed
1598
#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
shiqian's avatar
shiqian committed
1599
1600
1601
1602
1603
1604
template <typename T1, typename T2>\
AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
                                   const T1& val1, const T2& val2) {\
  if (val1 op val2) {\
    return AssertionSuccess();\
  } else {\
1605
    return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\
shiqian's avatar
shiqian committed
1606
1607
  }\
}\
zhanyong.wan's avatar
zhanyong.wan committed
1608
1609
GTEST_API_ AssertionResult CmpHelper##op_name(\
    const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2)
shiqian's avatar
shiqian committed
1610
1611
1612
1613

// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.

// Implements the helper function for {ASSERT|EXPECT}_NE
zhanyong.wan's avatar
zhanyong.wan committed
1614
GTEST_IMPL_CMP_HELPER_(NE, !=);
shiqian's avatar
shiqian committed
1615
// Implements the helper function for {ASSERT|EXPECT}_LE
zhanyong.wan's avatar
zhanyong.wan committed
1616
GTEST_IMPL_CMP_HELPER_(LE, <=);
shiqian's avatar
shiqian committed
1617
// Implements the helper function for {ASSERT|EXPECT}_LT
1618
GTEST_IMPL_CMP_HELPER_(LT, <);
shiqian's avatar
shiqian committed
1619
// Implements the helper function for {ASSERT|EXPECT}_GE
zhanyong.wan's avatar
zhanyong.wan committed
1620
GTEST_IMPL_CMP_HELPER_(GE, >=);
shiqian's avatar
shiqian committed
1621
// Implements the helper function for {ASSERT|EXPECT}_GT
1622
GTEST_IMPL_CMP_HELPER_(GT, >);
shiqian's avatar
shiqian committed
1623

shiqian's avatar
shiqian committed
1624
#undef GTEST_IMPL_CMP_HELPER_
shiqian's avatar
shiqian committed
1625
1626
1627
1628

// The helper function for {ASSERT|EXPECT}_STREQ.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1629
1630
1631
1632
GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression,
                                          const char* actual_expression,
                                          const char* expected,
                                          const char* actual);
shiqian's avatar
shiqian committed
1633
1634
1635
1636

// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1637
1638
1639
1640
GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression,
                                              const char* actual_expression,
                                              const char* expected,
                                              const char* actual);
shiqian's avatar
shiqian committed
1641
1642
1643
1644

// The helper function for {ASSERT|EXPECT}_STRNE.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1645
1646
1647
1648
GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
                                          const char* s2_expression,
                                          const char* s1,
                                          const char* s2);
shiqian's avatar
shiqian committed
1649
1650
1651
1652

// The helper function for {ASSERT|EXPECT}_STRCASENE.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1653
1654
1655
1656
GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
                                              const char* s2_expression,
                                              const char* s1,
                                              const char* s2);
shiqian's avatar
shiqian committed
1657
1658
1659
1660
1661


// Helper function for *_STREQ on wide strings.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1662
1663
1664
1665
GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression,
                                          const char* actual_expression,
                                          const wchar_t* expected,
                                          const wchar_t* actual);
shiqian's avatar
shiqian committed
1666
1667
1668
1669

// Helper function for *_STRNE on wide strings.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1670
1671
1672
1673
GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
                                          const char* s2_expression,
                                          const wchar_t* s1,
                                          const wchar_t* s2);
shiqian's avatar
shiqian committed
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684

}  // namespace internal

// IsSubstring() and IsNotSubstring() are intended to be used as the
// first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by
// themselves.  They check whether needle is a substring of haystack
// (NULL is considered a substring of itself only), and return an
// appropriate error message when they fail.
//
// The {needle,haystack}_expr arguments are the stringified
// expressions that generated the two real arguments.
zhanyong.wan's avatar
zhanyong.wan committed
1685
GTEST_API_ AssertionResult IsSubstring(
shiqian's avatar
shiqian committed
1686
1687
    const char* needle_expr, const char* haystack_expr,
    const char* needle, const char* haystack);
zhanyong.wan's avatar
zhanyong.wan committed
1688
GTEST_API_ AssertionResult IsSubstring(
shiqian's avatar
shiqian committed
1689
1690
    const char* needle_expr, const char* haystack_expr,
    const wchar_t* needle, const wchar_t* haystack);
zhanyong.wan's avatar
zhanyong.wan committed
1691
GTEST_API_ AssertionResult IsNotSubstring(
shiqian's avatar
shiqian committed
1692
1693
    const char* needle_expr, const char* haystack_expr,
    const char* needle, const char* haystack);
zhanyong.wan's avatar
zhanyong.wan committed
1694
GTEST_API_ AssertionResult IsNotSubstring(
shiqian's avatar
shiqian committed
1695
1696
    const char* needle_expr, const char* haystack_expr,
    const wchar_t* needle, const wchar_t* haystack);
zhanyong.wan's avatar
zhanyong.wan committed
1697
GTEST_API_ AssertionResult IsSubstring(
shiqian's avatar
shiqian committed
1698
1699
    const char* needle_expr, const char* haystack_expr,
    const ::std::string& needle, const ::std::string& haystack);
zhanyong.wan's avatar
zhanyong.wan committed
1700
GTEST_API_ AssertionResult IsNotSubstring(
shiqian's avatar
shiqian committed
1701
1702
1703
1704
    const char* needle_expr, const char* haystack_expr,
    const ::std::string& needle, const ::std::string& haystack);

#if GTEST_HAS_STD_WSTRING
zhanyong.wan's avatar
zhanyong.wan committed
1705
GTEST_API_ AssertionResult IsSubstring(
shiqian's avatar
shiqian committed
1706
1707
    const char* needle_expr, const char* haystack_expr,
    const ::std::wstring& needle, const ::std::wstring& haystack);
zhanyong.wan's avatar
zhanyong.wan committed
1708
GTEST_API_ AssertionResult IsNotSubstring(
shiqian's avatar
shiqian committed
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
    const char* needle_expr, const char* haystack_expr,
    const ::std::wstring& needle, const ::std::wstring& haystack);
#endif  // GTEST_HAS_STD_WSTRING

namespace internal {

// Helper template function for comparing floating-points.
//
// Template parameter:
//
//   RawType: the raw floating-point type (either float or double)
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
template <typename RawType>
AssertionResult CmpHelperFloatingPointEQ(const char* expected_expression,
                                         const char* actual_expression,
                                         RawType expected,
                                         RawType actual) {
  const FloatingPoint<RawType> lhs(expected), rhs(actual);

  if (lhs.AlmostEquals(rhs)) {
    return AssertionSuccess();
  }

1733
  ::std::stringstream expected_ss;
shiqian's avatar
shiqian committed
1734
1735
1736
  expected_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
              << expected;

1737
  ::std::stringstream actual_ss;
shiqian's avatar
shiqian committed
1738
1739
1740
1741
1742
  actual_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
            << actual;

  return EqFailure(expected_expression,
                   actual_expression,
1743
1744
                   StringStreamToString(&expected_ss),
                   StringStreamToString(&actual_ss),
shiqian's avatar
shiqian committed
1745
1746
1747
1748
1749
1750
                   false);
}

// Helper function for implementing ASSERT_NEAR.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1751
1752
1753
1754
1755
1756
GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
                                                const char* expr2,
                                                const char* abs_error_expr,
                                                double val1,
                                                double val2,
                                                double abs_error);
shiqian's avatar
shiqian committed
1757
1758
1759

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
// A class that enables one to stream messages to assertion macros
1760
class GTEST_API_ AssertHelper {
shiqian's avatar
shiqian committed
1761
1762
 public:
  // Constructor.
1763
1764
1765
  AssertHelper(TestPartResult::Type type,
               const char* file,
               int line,
shiqian's avatar
shiqian committed
1766
               const char* message);
1767
1768
  ~AssertHelper();

shiqian's avatar
shiqian committed
1769
  // Message assignment is a semantic trick to enable assertion
shiqian's avatar
shiqian committed
1770
  // streaming; see the GTEST_MESSAGE_ macro below.
shiqian's avatar
shiqian committed
1771
  void operator=(const Message& message) const;
1772

shiqian's avatar
shiqian committed
1773
 private:
1774
1775
1776
1777
1778
  // We put our data in a struct so that the size of the AssertHelper class can
  // be as small as possible.  This is important because gcc is incapable of
  // re-using stack space even for temporary variables, so every EXPECT_EQ
  // reserves stack space for another AssertHelper.
  struct AssertHelperData {
1779
1780
1781
    AssertHelperData(TestPartResult::Type t,
                     const char* srcfile,
                     int line_num,
1782
1783
1784
                     const char* msg)
        : type(t), file(srcfile), line(line_num), message(msg) { }

1785
    TestPartResult::Type const type;
1786
1787
1788
    const char* const file;
    int const line;
    std::string const message;
1789
1790
1791
1792
1793
1794

   private:
    GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
  };

  AssertHelperData* const data_;
shiqian's avatar
shiqian committed
1795

shiqian's avatar
shiqian committed
1796
  GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
shiqian's avatar
shiqian committed
1797
1798
1799
1800
};

}  // namespace internal

zhanyong.wan's avatar
zhanyong.wan committed
1801
#if GTEST_HAS_PARAM_TEST
1802
1803
1804
1805
1806
// The pure interface class that all value-parameterized tests inherit from.
// A value-parameterized class must inherit from both ::testing::Test and
// ::testing::WithParamInterface. In most cases that just means inheriting
// from ::testing::TestWithParam, but more complicated test hierarchies
// may need to inherit from Test and WithParamInterface at different levels.
1807
//
1808
// This interface has support for accessing the test parameter value via
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
// the GetParam() method.
//
// Use it with one of the parameter generator defining functions, like Range(),
// Values(), ValuesIn(), Bool(), and Combine().
//
// class FooTest : public ::testing::TestWithParam<int> {
//  protected:
//   FooTest() {
//     // Can use GetParam() here.
//   }
//   virtual ~FooTest() {
//     // Can use GetParam() here.
//   }
//   virtual void SetUp() {
//     // Can use GetParam() here.
//   }
//   virtual void TearDown {
//     // Can use GetParam() here.
//   }
// };
// TEST_P(FooTest, DoesBar) {
//   // Can use GetParam() method here.
//   Foo foo;
//   ASSERT_TRUE(foo.DoesBar(GetParam()));
// }
// INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));

template <typename T>
1837
class WithParamInterface {
1838
1839
 public:
  typedef T ParamType;
1840
  virtual ~WithParamInterface() {}
1841
1842

  // The current parameter value. Is also available in the test fixture's
1843
1844
1845
1846
  // constructor. This member function is non-static, even though it only
  // references static data, to reduce the opportunity for incorrect uses
  // like writing 'WithParamInterface<bool>::GetParam()' for a test that
  // uses a fixture whose parameter type is int.
1847
1848
1849
1850
1851
1852
  const ParamType& GetParam() const {
    GTEST_CHECK_(parameter_ != NULL)
        << "GetParam() can only be called inside a value-parameterized test "
        << "-- did you intend to write TEST_P instead of TEST_F?";
    return *parameter_;
  }
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863

 private:
  // Sets parameter value. The caller is responsible for making sure the value
  // remains alive and unchanged throughout the current test.
  static void SetParam(const ParamType* parameter) {
    parameter_ = parameter;
  }

  // Static value used for accessing parameter during a test lifetime.
  static const ParamType* parameter_;

1864
  // TestClass must be a subclass of WithParamInterface<T> and Test.
1865
1866
1867
1868
  template <class TestClass> friend class internal::ParameterizedTestFactory;
};

template <typename T>
1869
1870
1871
1872
1873
1874
1875
1876
const T* WithParamInterface<T>::parameter_ = NULL;

// Most value-parameterized classes can ignore the existence of
// WithParamInterface, and can just inherit from ::testing::TestWithParam.

template <typename T>
class TestWithParam : public Test, public WithParamInterface<T> {
};
1877
1878
1879

#endif  // GTEST_HAS_PARAM_TEST

shiqian's avatar
shiqian committed
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
// Macros for indicating success/failure in test code.

// ADD_FAILURE unconditionally adds a failure to the current test.
// SUCCEED generates a success - it doesn't automatically make the
// current test successful, as a test is only successful when it has
// no failure.
//
// EXPECT_* verifies that a certain condition is satisfied.  If not,
// it behaves like ADD_FAILURE.  In particular:
//
//   EXPECT_TRUE  verifies that a Boolean condition is true.
//   EXPECT_FALSE verifies that a Boolean condition is false.
//
// FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except
// that they will also abort the current function on failure.  People
// usually want the fail-fast behavior of FAIL and ASSERT_*, but those
// writing data-driven tests often find themselves using ADD_FAILURE
// and EXPECT_* more.

// Generates a nonfatal failure with a generic message.
shiqian's avatar
shiqian committed
1900
#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
shiqian's avatar
shiqian committed
1901

1902
1903
1904
1905
1906
1907
// Generates a nonfatal failure at the given source file location with
// a generic message.
#define ADD_FAILURE_AT(file, line) \
  GTEST_MESSAGE_AT_(file, line, "Failed", \
                    ::testing::TestPartResult::kNonFatalFailure)

shiqian's avatar
shiqian committed
1908
// Generates a fatal failure with a generic message.
1909
1910
1911
1912
1913
#define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")

// Define this macro to 1 to omit the definition of FAIL(), which is a
// generic name and clashes with some other libraries.
#if !GTEST_DONT_DEFINE_FAIL
1914
# define FAIL() GTEST_FAIL()
1915
#endif
shiqian's avatar
shiqian committed
1916
1917

// Generates a success with a generic message.
1918
1919
1920
1921
1922
#define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded")

// Define this macro to 1 to omit the definition of SUCCEED(), which
// is a generic name and clashes with some other libraries.
#if !GTEST_DONT_DEFINE_SUCCEED
1923
# define SUCCEED() GTEST_SUCCEED()
1924
#endif
shiqian's avatar
shiqian committed
1925

1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
// Macros for testing exceptions.
//
//    * {ASSERT|EXPECT}_THROW(statement, expected_exception):
//         Tests that the statement throws the expected exception.
//    * {ASSERT|EXPECT}_NO_THROW(statement):
//         Tests that the statement doesn't throw any exception.
//    * {ASSERT|EXPECT}_ANY_THROW(statement):
//         Tests that the statement throws an exception.

#define EXPECT_THROW(statement, expected_exception) \
shiqian's avatar
shiqian committed
1936
  GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
1937
#define EXPECT_NO_THROW(statement) \
shiqian's avatar
shiqian committed
1938
  GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
1939
#define EXPECT_ANY_THROW(statement) \
shiqian's avatar
shiqian committed
1940
  GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)
1941
#define ASSERT_THROW(statement, expected_exception) \
shiqian's avatar
shiqian committed
1942
  GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
1943
#define ASSERT_NO_THROW(statement) \
shiqian's avatar
shiqian committed
1944
  GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
1945
#define ASSERT_ANY_THROW(statement) \
shiqian's avatar
shiqian committed
1946
  GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)
1947

1948
1949
1950
// Boolean assertions. Condition can be either a Boolean expression or an
// AssertionResult. For more information on how to use AssertionResult with
// these macros see comments on that class.
shiqian's avatar
shiqian committed
1951
#define EXPECT_TRUE(condition) \
shiqian's avatar
shiqian committed
1952
1953
  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
                      GTEST_NONFATAL_FAILURE_)
shiqian's avatar
shiqian committed
1954
#define EXPECT_FALSE(condition) \
shiqian's avatar
shiqian committed
1955
1956
  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
                      GTEST_NONFATAL_FAILURE_)
shiqian's avatar
shiqian committed
1957
#define ASSERT_TRUE(condition) \
shiqian's avatar
shiqian committed
1958
1959
  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
                      GTEST_FATAL_FAILURE_)
shiqian's avatar
shiqian committed
1960
#define ASSERT_FALSE(condition) \
shiqian's avatar
shiqian committed
1961
1962
  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
                      GTEST_FATAL_FAILURE_)
shiqian's avatar
shiqian committed
1963
1964
1965

// Includes the auto-generated header that implements a family of
// generic predicate assertion macros.
1966
#include "gtest/gtest_pred_impl.h"
shiqian's avatar
shiqian committed
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015

// Macros for testing equalities and inequalities.
//
//    * {ASSERT|EXPECT}_EQ(expected, actual): Tests that expected == actual
//    * {ASSERT|EXPECT}_NE(v1, v2):           Tests that v1 != v2
//    * {ASSERT|EXPECT}_LT(v1, v2):           Tests that v1 < v2
//    * {ASSERT|EXPECT}_LE(v1, v2):           Tests that v1 <= v2
//    * {ASSERT|EXPECT}_GT(v1, v2):           Tests that v1 > v2
//    * {ASSERT|EXPECT}_GE(v1, v2):           Tests that v1 >= v2
//
// When they are not, Google Test prints both the tested expressions and
// their actual values.  The values must be compatible built-in types,
// or you will get a compiler error.  By "compatible" we mean that the
// values can be compared by the respective operator.
//
// Note:
//
//   1. It is possible to make a user-defined type work with
//   {ASSERT|EXPECT}_??(), but that requires overloading the
//   comparison operators and is thus discouraged by the Google C++
//   Usage Guide.  Therefore, you are advised to use the
//   {ASSERT|EXPECT}_TRUE() macro to assert that two objects are
//   equal.
//
//   2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on
//   pointers (in particular, C strings).  Therefore, if you use it
//   with two C strings, you are testing how their locations in memory
//   are related, not how their content is related.  To compare two C
//   strings by content, use {ASSERT|EXPECT}_STR*().
//
//   3. {ASSERT|EXPECT}_EQ(expected, actual) is preferred to
//   {ASSERT|EXPECT}_TRUE(expected == actual), as the former tells you
//   what the actual value is when it fails, and similarly for the
//   other comparisons.
//
//   4. Do not depend on the order in which {ASSERT|EXPECT}_??()
//   evaluate their arguments, which is undefined.
//
//   5. These macros evaluate their arguments exactly once.
//
// Examples:
//
//   EXPECT_NE(5, Foo());
//   EXPECT_EQ(NULL, a_pointer);
//   ASSERT_LT(i, array_size);
//   ASSERT_GT(records.size(), 0) << "There is no record left.";

#define EXPECT_EQ(expected, actual) \
  EXPECT_PRED_FORMAT2(::testing::internal:: \
shiqian's avatar
shiqian committed
2016
                      EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \
shiqian's avatar
shiqian committed
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
                      expected, actual)
#define EXPECT_NE(expected, actual) \
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, expected, actual)
#define EXPECT_LE(val1, val2) \
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
#define EXPECT_LT(val1, val2) \
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
#define EXPECT_GE(val1, val2) \
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
#define EXPECT_GT(val1, val2) \
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)

2029
#define GTEST_ASSERT_EQ(expected, actual) \
shiqian's avatar
shiqian committed
2030
  ASSERT_PRED_FORMAT2(::testing::internal:: \
shiqian's avatar
shiqian committed
2031
                      EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \
shiqian's avatar
shiqian committed
2032
                      expected, actual)
2033
#define GTEST_ASSERT_NE(val1, val2) \
shiqian's avatar
shiqian committed
2034
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
2035
#define GTEST_ASSERT_LE(val1, val2) \
shiqian's avatar
shiqian committed
2036
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
2037
#define GTEST_ASSERT_LT(val1, val2) \
shiqian's avatar
shiqian committed
2038
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
2039
#define GTEST_ASSERT_GE(val1, val2) \
shiqian's avatar
shiqian committed
2040
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
2041
#define GTEST_ASSERT_GT(val1, val2) \
shiqian's avatar
shiqian committed
2042
2043
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)

2044
2045
2046
2047
// Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of
// ASSERT_XY(), which clashes with some users' own code.

#if !GTEST_DONT_DEFINE_ASSERT_EQ
2048
# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
2049
2050
2051
#endif

#if !GTEST_DONT_DEFINE_ASSERT_NE
2052
# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
2053
2054
2055
#endif

#if !GTEST_DONT_DEFINE_ASSERT_LE
2056
# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
2057
2058
2059
#endif

#if !GTEST_DONT_DEFINE_ASSERT_LT
2060
# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
2061
2062
2063
#endif

#if !GTEST_DONT_DEFINE_ASSERT_GE
2064
# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
2065
2066
2067
#endif

#if !GTEST_DONT_DEFINE_ASSERT_GT
2068
# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
2069
2070
#endif

2071
// C-string Comparisons.  All tests treat NULL and any non-NULL string
shiqian's avatar
shiqian committed
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
// as different.  Two NULLs are equal.
//
//    * {ASSERT|EXPECT}_STREQ(s1, s2):     Tests that s1 == s2
//    * {ASSERT|EXPECT}_STRNE(s1, s2):     Tests that s1 != s2
//    * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case
//    * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case
//
// For wide or narrow string objects, you can use the
// {ASSERT|EXPECT}_??() macros.
//
// Don't depend on the order in which the arguments are evaluated,
// which is undefined.
//
// These macros evaluate their arguments exactly once.

#define EXPECT_STREQ(expected, actual) \
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual)
#define EXPECT_STRNE(s1, s2) \
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
#define EXPECT_STRCASEEQ(expected, actual) \
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual)
#define EXPECT_STRCASENE(s1, s2)\
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)

#define ASSERT_STREQ(expected, actual) \
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual)
#define ASSERT_STRNE(s1, s2) \
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
#define ASSERT_STRCASEEQ(expected, actual) \
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual)
#define ASSERT_STRCASENE(s1, s2)\
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)

// Macros for comparing floating-point numbers.
//
//    * {ASSERT|EXPECT}_FLOAT_EQ(expected, actual):
//         Tests that two float values are almost equal.
//    * {ASSERT|EXPECT}_DOUBLE_EQ(expected, actual):
//         Tests that two double values are almost equal.
//    * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error):
//         Tests that v1 and v2 are within the given distance to each other.
//
// Google Test uses ULP-based comparison to automatically pick a default
// error bound that is appropriate for the operands.  See the
// FloatingPoint template class in gtest-internal.h if you are
// interested in the implementation details.

#define EXPECT_FLOAT_EQ(expected, actual)\
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
                      expected, actual)

#define EXPECT_DOUBLE_EQ(expected, actual)\
  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
                      expected, actual)

#define ASSERT_FLOAT_EQ(expected, actual)\
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
                      expected, actual)

#define ASSERT_DOUBLE_EQ(expected, actual)\
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
                      expected, actual)

#define EXPECT_NEAR(val1, val2, abs_error)\
  EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
                      val1, val2, abs_error)

#define ASSERT_NEAR(val1, val2, abs_error)\
  ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
                      val1, val2, abs_error)

// These predicate format functions work on floating-point values, and
// can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g.
//
//   EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0);

// Asserts that val1 is less than, or almost equal to, val2.  Fails
// otherwise.  In particular, it fails if either val1 or val2 is NaN.
2150
2151
2152
2153
GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2,
                                   float val1, float val2);
GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
                                    double val1, double val2);
shiqian's avatar
shiqian committed
2154
2155


zhanyong.wan's avatar
zhanyong.wan committed
2156
#if GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
2157
2158
2159
2160
2161
2162

// Macros that test for HRESULT failure and success, these are only useful
// on Windows, and rely on Windows SDK macros and APIs to compile.
//
//    * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr)
//
2163
2164
2165
2166
// When expr unexpectedly fails or succeeds, Google Test prints the
// expected result and the actual result with both a human-readable
// string representation of the error, if available, as well as the
// hex result code.
2167
# define EXPECT_HRESULT_SUCCEEDED(expr) \
shiqian's avatar
shiqian committed
2168
2169
    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))

2170
# define ASSERT_HRESULT_SUCCEEDED(expr) \
shiqian's avatar
shiqian committed
2171
2172
    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))

2173
# define EXPECT_HRESULT_FAILED(expr) \
shiqian's avatar
shiqian committed
2174
2175
    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))

2176
# define ASSERT_HRESULT_FAILED(expr) \
shiqian's avatar
shiqian committed
2177
2178
2179
2180
    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))

#endif  // GTEST_OS_WINDOWS

shiqian's avatar
shiqian committed
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
// Macros that execute statement and check that it doesn't generate new fatal
// failures in the current thread.
//
//   * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement);
//
// Examples:
//
//   EXPECT_NO_FATAL_FAILURE(Process());
//   ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed";
//
#define ASSERT_NO_FATAL_FAILURE(statement) \
    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
#define EXPECT_NO_FATAL_FAILURE(statement) \
    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)
shiqian's avatar
shiqian committed
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207

// Causes a trace (including the source file path, the current line
// number, and the given message) to be included in every test failure
// message generated by code in the current scope.  The effect is
// undone when the control leaves the current scope.
//
// The message argument can be anything streamable to std::ostream.
//
// In the implementation, we include the current line number as part
// of the dummy variable name, thus allowing multiple SCOPED_TRACE()s
// to appear in the same block - as long as they are on different
// lines.
#define SCOPED_TRACE(message) \
shiqian's avatar
shiqian committed
2208
  ::testing::internal::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
shiqian's avatar
shiqian committed
2209
2210
    __FILE__, __LINE__, ::testing::Message() << (message))

2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
// Compile-time assertion for type equality.
// StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are
// the same type.  The value it returns is not interesting.
//
// Instead of making StaticAssertTypeEq a class template, we make it a
// function template that invokes a helper class template.  This
// prevents a user from misusing StaticAssertTypeEq<T1, T2> by
// defining objects of that type.
//
// CAVEAT:
//
// When used inside a method of a class template,
// StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is
// instantiated.  For example, given:
//
//   template <typename T> class Foo {
//    public:
//     void Bar() { testing::StaticAssertTypeEq<int, T>(); }
//   };
//
// the code:
//
//   void Test1() { Foo<bool> foo; }
//
// will NOT generate a compiler error, as Foo<bool>::Bar() is never
// actually instantiated.  Instead, you need:
//
//   void Test2() { Foo<bool> foo; foo.Bar(); }
//
// to cause a compiler error.
template <typename T1, typename T2>
bool StaticAssertTypeEq() {
2243
  (void)internal::StaticAssertTypeEqHelper<T1, T2>();
2244
2245
  return true;
}
shiqian's avatar
shiqian committed
2246
2247
2248
2249
2250
2251
2252
2253
2254

// Defines a test.
//
// The first parameter is the name of the test case, and the second
// parameter is the name of the test within the test case.
//
// The convention is to end the test case name with "Test".  For
// example, a test case for the Foo class can be named FooTest.
//
2255
2256
// Test code should appear between braces after an invocation of
// this macro.  Example:
shiqian's avatar
shiqian committed
2257
2258
2259
2260
2261
2262
//
//   TEST(FooTest, InitializesCorrectly) {
//     Foo foo;
//     EXPECT_TRUE(foo.StatusIsOK());
//   }

2263
2264
2265
2266
2267
2268
2269
2270
2271
// Note that we call GetTestTypeId() instead of GetTypeId<
// ::testing::Test>() here to get the type ID of testing::Test.  This
// is to work around a suspected linker bug when using Google Test as
// a framework on Mac OS X.  The bug causes GetTypeId<
// ::testing::Test>() to return different values depending on whether
// the call is from the Google Test framework itself or from user test
// code.  GetTestTypeId() is guaranteed to always return the same
// value, as it always calls GetTypeId<>() from the Google Test
// framework.
2272
#define GTEST_TEST(test_case_name, test_name)\
2273
  GTEST_TEST_(test_case_name, test_name, \
2274
              ::testing::Test, ::testing::internal::GetTestTypeId())
shiqian's avatar
shiqian committed
2275

2276
2277
2278
// Define this macro to 1 to omit the definition of TEST(), which
// is a generic name and clashes with some other libraries.
#if !GTEST_DONT_DEFINE_TEST
2279
# define TEST(test_case_name, test_name) GTEST_TEST(test_case_name, test_name)
2280
#endif
shiqian's avatar
shiqian committed
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308

// Defines a test that uses a test fixture.
//
// The first parameter is the name of the test fixture class, which
// also doubles as the test case name.  The second parameter is the
// name of the test within the test case.
//
// A test fixture class must be declared earlier.  The user should put
// his test code between braces after using this macro.  Example:
//
//   class FooTest : public testing::Test {
//    protected:
//     virtual void SetUp() { b_.AddElement(3); }
//
//     Foo a_;
//     Foo b_;
//   };
//
//   TEST_F(FooTest, InitializesCorrectly) {
//     EXPECT_TRUE(a_.StatusIsOK());
//   }
//
//   TEST_F(FooTest, ReturnsElementCountCorrectly) {
//     EXPECT_EQ(0, a_.size());
//     EXPECT_EQ(1, b_.size());
//   }

#define TEST_F(test_fixture, test_name)\
2309
  GTEST_TEST_(test_fixture, test_name, test_fixture, \
2310
              ::testing::internal::GetTypeId<test_fixture>())
shiqian's avatar
shiqian committed
2311

2312
2313
2314
}  // namespace testing

// Use this function in main() to run all tests.  It returns 0 if all
shiqian's avatar
shiqian committed
2315
2316
2317
2318
// tests are successful, or 1 otherwise.
//
// RUN_ALL_TESTS() should be invoked after the command line has been
// parsed by InitGoogleTest().
2319
2320
2321
2322
//
// This function was formerly a macro; thus, it is in the global
// namespace and has an all-caps name.
int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
shiqian's avatar
shiqian committed
2323

2324
2325
2326
inline int RUN_ALL_TESTS() {
  return ::testing::UnitTest::GetInstance()->Run();
}
shiqian's avatar
shiqian committed
2327
2328

#endif  // GTEST_INCLUDE_GTEST_GTEST_H_