gtest.h 83.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
73
74
75
// 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.
//
// The user can define GTEST_HAS_GLOBAL_STRING to 1 to indicate that
// ::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
//
// If the user's ::std::string and ::string are the same class due to
78
// aliasing, he should define GTEST_HAS_GLOBAL_STRING to 0.
shiqian's avatar
shiqian committed
79
//
80
81
// If the user doesn't define GTEST_HAS_GLOBAL_STRING, it is defined
// 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 WindowsDeathTest;
162
class UnitTestImpl* GetUnitTestImpl();
163
void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
164
                                    const std::string& message);
shiqian's avatar
shiqian committed
165
166
167

}  // namespace internal

168
169
170
171
172
173
174
175
// 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
176
177
// A class for indicating whether an assertion was successful.  When
// the assertion wasn't successful, the AssertionResult object
178
// remembers a non-empty message that describes how it failed.
shiqian's avatar
shiqian committed
179
//
180
// To create an instance of this class, use one of the factory functions
shiqian's avatar
shiqian committed
181
182
// (AssertionSuccess() and AssertionFailure()).
//
183
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
// 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
236
237
238
239
//
//   // Verifies that Foo() returns an even number.
//   EXPECT_PRED_FORMAT1(IsEven, Foo());
//
240
// you need to define:
shiqian's avatar
shiqian committed
241
242
//
//   testing::AssertionResult IsEven(const char* expr, int n) {
243
244
245
246
247
//     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
248
249
250
251
252
253
//   }
//
// If Foo() returns 5, you will see the following message:
//
//   Expected: Foo() is even
//     Actual: it's 5
254
//
255
class GTEST_API_ AssertionResult {
shiqian's avatar
shiqian committed
256
 public:
257
258
259
260
261
  // Copy constructor.
  // Used in EXPECT_TRUE/FALSE(assertion_result).
  AssertionResult(const AssertionResult& other);
  // Used in the EXPECT_TRUE/FALSE(bool_expression).
  explicit AssertionResult(bool success) : success_(success) {}
shiqian's avatar
shiqian committed
262
263

  // Returns true iff the assertion succeeded.
264
265
266
267
268
269
270
271
272
273
  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 {
274
    return message_.get() != NULL ?  message_->c_str() : "";
275
276
277
278
  }
  // 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
279

280
  // Streams a custom failure message into this object.
281
282
283
284
285
286
287
288
289
290
291
292
  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
293
294

 private:
295
296
297
298
299
300
  // 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());
  }
301
302
303
304
305
306
307

  // 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.
308
  internal::scoped_ptr< ::std::string> message_;
309

310
311
  GTEST_DISALLOW_ASSIGN_(AssertionResult);
};
shiqian's avatar
shiqian committed
312
313

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

316
// Makes a failed assertion result.
317
GTEST_API_ AssertionResult AssertionFailure();
318

shiqian's avatar
shiqian committed
319
// Makes a failed assertion result with the given failure message.
320
// Deprecated; use AssertionFailure() << msg.
321
GTEST_API_ AssertionResult AssertionFailure(const Message& msg);
shiqian's avatar
shiqian committed
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345

// 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:
//     virtual void SetUp() { ... }
//     virtual void TearDown() { ... }
//     ...
//   };
//
//   TEST_F(FooTest, Bar) { ... }
//   TEST_F(FooTest, Baz) { ... }
//
// Test is not copyable.
346
class GTEST_API_ Test {
shiqian's avatar
shiqian committed
347
 public:
348
  friend class TestInfo;
shiqian's avatar
shiqian committed
349
350
351

  // Defines types for pointers to functions that set up and tear down
  // a test case.
352
353
  typedef internal::SetUpTestCaseFunc SetUpTestCaseFunc;
  typedef internal::TearDownTestCaseFunc TearDownTestCaseFunc;
shiqian's avatar
shiqian committed
354
355
356
357

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

358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
  // 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
374
375
376
  // Returns true iff the current test has a fatal failure.
  static bool HasFatalFailure();

377
378
379
380
381
382
383
  // 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(); }

shiqian's avatar
shiqian committed
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
  // Logs a property for the current test.  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.
  // The arguments are const char* instead strings, as Google Test is used
  // on platforms where string doesn't compile.
  //
  // Note that a driving consideration for these RecordProperty methods
  // was to produce xml output suited to the Greenspan charting utility,
  // which at present will only chart values that fit in a 32-bit int. It
  // is the user's responsibility to restrict their values to 32-bit ints
  // if they intend them to be used with Greenspan.
  static void RecordProperty(const char* key, const char* value);
  static void RecordProperty(const char* key, int value);

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

425
426
427
428
  // 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; }

shiqian's avatar
shiqian committed
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
  // Uses a GTestFlagSaver to save and restore all Google Test flags.
  const internal::GTestFlagSaver* const gtest_flag_saver_;

  // Often a user mis-spells SetUp() as Setup() and spends a long time
  // 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
  //   will be a conflict if a user declares void Setup() in his test
  //   fixture.
  //
  //   - This method is private, so it will be another compiler error
  //   if a user calls it from his test fixture.
  //
  // 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
452
  GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
shiqian's avatar
shiqian committed
453
454
};

455
456
typedef internal::TimeInMillis TimeInMillis;

457
458
459
460
461
462
463
464
465
// 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.
466
467
  TestProperty(const char* a_key, const char* a_value) :
    key_(a_key), value_(a_value) {
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
  }

  // 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.
  void SetValue(const char* new_value) {
    value_ = new_value;
  }

 private:
  // The key supplied by the user.
487
  std::string key_;
488
  // The value supplied by the user.
489
  std::string value_;
490
491
};

492
493
494
495
496
497
// 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.
498
class GTEST_API_ TestResult {
499
500
501
502
503
504
505
506
507
508
509
 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;

510
511
512
  // Returns the number of the test properties.
  int test_property_count() const;

513
514
515
516
  // Returns true iff the test passed (i.e. no test part failed).
  bool Passed() const { return !Failed(); }

  // Returns true iff the test failed.
517
  bool Failed() const;
518
519
520
521
522
523
524
525
526
527

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

528
  // Returns the i-th test part result among all the results. i can range
529
530
531
  // from 0 to test_property_count() - 1. If i is not in that range, aborts
  // the program.
  const TestPartResult& GetTestPartResult(int i) const;
532
533

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

538
 private:
539
540
  friend class TestInfo;
  friend class UnitTest;
541
542
543
544
545
  friend class internal::DefaultGlobalTestPartResultReporter;
  friend class internal::ExecDeathTest;
  friend class internal::TestResultAccessor;
  friend class internal::UnitTestImpl;
  friend class internal::WindowsDeathTest;
546

547
  // Gets the vector of TestPartResults.
548
549
  const std::vector<TestPartResult>& test_part_results() const {
    return test_part_results_;
550
551
  }

552
  // Gets the vector of TestProperties.
553
554
  const std::vector<TestProperty>& test_properties() const {
    return test_properties_;
555
556
557
558
  }

  // Sets the elapsed time.
  void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }
559
560
561
562
563
564

  // 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
  // key.
565
  void RecordProperty(const TestProperty& test_property);
566
567
568
569

  // 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.
570
  static bool ValidateTestProperty(const TestProperty& test_property);
571

572
573
574
  // Adds a test part result to the list.
  void AddTestPartResult(const TestPartResult& test_part_result);

575
576
577
578
579
580
581
582
583
584
585
  // 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();
586

587
588
  // Protects mutable state of the property vector and of owned
  // properties, whose values may be updated.
589
590
  internal::Mutex test_properites_mutex_;

591
  // The vector of TestPartResults
592
  std::vector<TestPartResult> test_part_results_;
593
  // The vector of TestProperties
594
  std::vector<TestProperty> test_properties_;
595
596
597
598
599
600
601
602
603
  // 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
604
605
606
607
608
609
610
611
612
613
614
// 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.
615
class GTEST_API_ TestInfo {
shiqian's avatar
shiqian committed
616
617
618
619
620
621
 public:
  // Destructs a TestInfo object.  This function is not virtual, so
  // don't inherit from TestInfo.
  ~TestInfo();

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

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

627
628
629
630
631
632
633
  // 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;
  }
634

635
636
637
638
639
640
641
  // 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;
  }
642

643
644
645
  // 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
646
647
648
649
650
651
652
653
654
655
656
657
658
  //
  // 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.".
659
  bool should_run() const { return should_run_; }
shiqian's avatar
shiqian committed
660
661

  // Returns the result of the test.
662
  const TestResult* result() const { return &result_; }
663

shiqian's avatar
shiqian committed
664
 private:
zhanyong.wan's avatar
zhanyong.wan committed
665
#if GTEST_HAS_DEATH_TEST
shiqian's avatar
shiqian committed
666
667
  friend class internal::DefaultDeathTestFactory;
#endif  // GTEST_HAS_DEATH_TEST
668
669
  friend class Test;
  friend class TestCase;
shiqian's avatar
shiqian committed
670
  friend class internal::UnitTestImpl;
kosak's avatar
kosak committed
671
  friend class internal::StreamingListenerTest;
672
  friend TestInfo* internal::MakeAndRegisterTestInfo(
673
674
      const char* test_case_name,
      const char* name,
675
676
      const char* type_param,
      const char* value_param,
677
678
679
680
      internal::TypeId fixture_class_id,
      Test::SetUpTestCaseFunc set_up_tc,
      Test::TearDownTestCaseFunc tear_down_tc,
      internal::TestFactoryBase* factory);
shiqian's avatar
shiqian committed
681

682
683
  // Constructs a TestInfo object. The newly constructed instance assumes
  // ownership of the factory object.
684
685
686
687
  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
688
689
           internal::TypeId fixture_class_id,
           internal::TestFactoryBase* factory);
shiqian's avatar
shiqian committed
690

691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
  // 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
708
709
710
711
712
713
  // 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_;
714
715
716
717
718
719
720
721
722
723
724
  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
725

shiqian's avatar
shiqian committed
726
  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
shiqian's avatar
shiqian committed
727
728
};

729
// A test case, which consists of a vector of TestInfos.
730
731
//
// TestCase is not copyable.
732
class GTEST_API_ TestCase {
733
734
735
736
737
738
739
740
741
 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
742
743
  //   a_type_param: the name of the test's type parameter, or NULL if
  //                 this is not a type-parameterized test.
744
745
  //   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
746
  TestCase(const char* name, const char* a_type_param,
747
748
749
750
751
752
753
754
755
           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(); }

756
757
758
759
760
761
762
  // 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;
  }
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788

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

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

  // 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.
789
  TimeInMillis elapsed_time() const { return elapsed_time_; }
790

791
792
793
794
  // 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;

795
 private:
796
  friend class Test;
797
  friend class internal::UnitTestImpl;
798

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

802
  // Gets the (immutable) vector of TestInfos in this TestCase.
803
804
  const std::vector<TestInfo*>& test_info_list() const {
    return test_info_list_;
805
806
  }

807
808
809
810
  // 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);

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

814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
  // 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();

829
830
831
832
833
834
835
836
  // 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_)(); }

837
  // Returns true iff test passed.
838
839
840
  static bool TestPassed(const TestInfo* test_info) {
    return test_info->should_run() && test_info->result()->Passed();
  }
841
842

  // Returns true iff test failed.
843
844
845
  static bool TestFailed(const TestInfo* test_info) {
    return test_info->should_run() && test_info->result()->Failed();
  }
846
847

  // Returns true iff test is disabled.
848
849
850
  static bool TestDisabled(const TestInfo* test_info) {
    return test_info->is_disabled_;
  }
851
852

  // Returns true if the given test should run.
853
854
855
  static bool ShouldRunTest(const TestInfo* test_info) {
    return test_info->should_run();
  }
856

857
858
859
860
861
862
  // Shuffles the tests in this test case.
  void ShuffleTests(internal::Random* random);

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

863
  // Name of the test case.
864
  std::string name_;
865
866
867
  // 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_;
868
869
  // The vector of TestInfos in their original order.  It owns the
  // elements in the vector.
870
  std::vector<TestInfo*> test_info_list_;
871
872
873
  // 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.
874
  std::vector<int> test_indices_;
875
876
877
878
879
880
881
  // 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.
882
  TimeInMillis elapsed_time_;
883
884
885
886
887

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

shiqian's avatar
shiqian committed
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
// An Environment object is capable of setting up and tearing down an
// environment.  The user should subclass this to define his own
// 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; }
};

919
920
// The interface for tracing execution of tests. The methods are organized in
// the order the corresponding events are fired.
921
class TestEventListener {
922
 public:
923
  virtual ~TestEventListener() {}
924

925
926
  // Fired before any test activity starts.
  virtual void OnTestProgramStart(const UnitTest& unit_test) = 0;
927

928
929
930
931
932
933
934
935
  // 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;
936

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

940
941
  // Fired before the test case starts.
  virtual void OnTestCaseStart(const TestCase& test_case) = 0;
942

943
  // Fired before the test starts.
944
945
  virtual void OnTestStart(const TestInfo& test_info) = 0;

946
  // Fired after a failed assertion or a SUCCEED() invocation.
947
948
  virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0;

949
  // Fired after the test ends.
950
951
  virtual void OnTestEnd(const TestInfo& test_info) = 0;

952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
  // 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;
967
968
969
970
};

// 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
971
972
973
974
// 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 {
975
 public:
976
977
978
979
980
  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*/) {}
981
982
  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
  virtual void OnTestStart(const TestInfo& /*test_info*/) {}
983
  virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {}
984
985
986
987
988
989
990
  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*/) {}
991
992
};

993
// TestEventListeners lets users add listeners to track events in Google Test.
994
class GTEST_API_ TestEventListeners {
995
 public:
996
997
  TestEventListeners();
  ~TestEventListeners();
998
999
1000
1001

  // 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).
1002
  void Append(TestEventListener* listener);
1003
1004
1005
1006

  // 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.
1007
  TestEventListener* Release(TestEventListener* listener);
1008
1009
1010
1011
1012
1013

  // 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.
1014
  TestEventListener* default_result_printer() const {
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
    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.
1025
  TestEventListener* default_xml_generator() const {
1026
1027
1028
1029
    return default_xml_generator_;
  }

 private:
1030
  friend class TestCase;
1031
  friend class TestInfo;
1032
1033
  friend class internal::DefaultGlobalTestPartResultReporter;
  friend class internal::NoExecDeathTest;
1034
  friend class internal::TestEventListenersAccessor;
1035
1036
  friend class internal::UnitTestImpl;

1037
1038
1039
  // Returns repeater that broadcasts the TestEventListener events to all
  // subscribers.
  TestEventListener* repeater();
1040
1041
1042
1043
1044
1045

  // 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.
1046
  void SetDefaultResultPrinter(TestEventListener* listener);
1047
1048
1049
1050
1051
1052

  // 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.
1053
  void SetDefaultXmlGenerator(TestEventListener* listener);
1054
1055
1056
1057
1058
1059
1060

  // 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.
1061
  internal::TestEventRepeater* repeater_;
1062
  // Listener responsible for the standard result output.
1063
  TestEventListener* default_result_printer_;
1064
  // Listener responsible for the creation of the XML output file.
1065
  TestEventListener* default_xml_generator_;
1066

1067
1068
  // We disallow copying TestEventListeners.
  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
1069
1070
};

1071
// A UnitTest consists of a vector of TestCases.
shiqian's avatar
shiqian committed
1072
1073
1074
1075
1076
1077
1078
1079
1080
//
// 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.
1081
class GTEST_API_ UnitTest {
shiqian's avatar
shiqian committed
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
 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
1094
  int Run() GTEST_MUST_USE_RESULT_;
shiqian's avatar
shiqian committed
1095

1096
1097
1098
1099
  // 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
1100
1101
  // Returns the TestCase object for the test that's currently running,
  // or NULL if no test is running.
1102
1103
  const TestCase* current_test_case() const
      GTEST_LOCK_EXCLUDED_(mutex_);
shiqian's avatar
shiqian committed
1104
1105
1106

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

1110
1111
1112
  // Returns the random seed used at the start of the current test run.
  int random_seed() const;

zhanyong.wan's avatar
zhanyong.wan committed
1113
#if GTEST_HAS_PARAM_TEST
1114
1115
  // Returns the ParameterizedTestCaseRegistry object used to keep track of
  // value-parameterized tests and instantiate and register them.
1116
1117
  //
  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1118
1119
  internal::ParameterizedTestCaseRegistry& parameterized_test_registry()
      GTEST_LOCK_EXCLUDED_(mutex_);
1120
1121
#endif  // GTEST_HAS_PARAM_TEST

1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
  // Gets the number of successful test cases.
  int successful_test_case_count() const;

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

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

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

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

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

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

  // Gets the number of all tests.
  int total_test_count() const;

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

1150
1151
1152
1153
  // Gets the time of the test program start, in ms from the start of the
  // UNIX epoch.
  TimeInMillis start_timestamp() const;

1154
  // Gets the elapsed time, in milliseconds.
1155
  TimeInMillis elapsed_time() const;
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165

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

1168
1169
  // Returns the list of event listeners that can be used to track events
  // inside Google Test.
1170
  TestEventListeners& listeners();
1171

1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
 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,
1191
1192
                         const std::string& message,
                         const std::string& os_stack_trace)
1193
      GTEST_LOCK_EXCLUDED_(mutex_);
1194
1195
1196
1197
1198

  // Adds a TestProperty to the current TestResult object. If the result already
  // contains a property with the same key, the value will be updated.
  void RecordPropertyForCurrentTest(const char* key, const char* value);

1199
1200
1201
1202
  // 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);

1203
1204
1205
1206
1207
1208
1209
1210
  // 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
1211
  friend class internal::ScopedTrace;
kosak's avatar
kosak committed
1212
  friend class internal::StreamingListenerTest;
1213
1214
1215
  friend Environment* AddGlobalTestEnvironment(Environment* env);
  friend internal::UnitTestImpl* internal::GetUnitTestImpl();
  friend void internal::ReportFailureInUnknownLocation(
1216
      TestPartResult::Type result_type,
1217
      const std::string& message);
shiqian's avatar
shiqian committed
1218
1219
1220
1221
1222
1223
1224
1225
1226

  // 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.
1227
1228
  void PushGTestTrace(const internal::TraceInfo& trace)
      GTEST_LOCK_EXCLUDED_(mutex_);
shiqian's avatar
shiqian committed
1229
1230

  // Pops a trace from the per-thread Google Test trace stack.
1231
1232
  void PopGTestTrace()
      GTEST_LOCK_EXCLUDED_(mutex_);
shiqian's avatar
shiqian committed
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244

  // 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
1245
  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest);
shiqian's avatar
shiqian committed
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
};

// 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.
1277
1278
//
// Calling the function for the second time has no user-visible effect.
1279
GTEST_API_ void InitGoogleTest(int* argc, char** argv);
shiqian's avatar
shiqian committed
1280
1281
1282

// This overloaded version can be used in Windows programs compiled in
// UNICODE mode.
1283
GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);
shiqian's avatar
shiqian committed
1284
1285
1286

namespace internal {

1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
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
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
// 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
1370
1371
1372
1373
// 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
1374
1375
// 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
1376
1377
1378
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
template <typename T1, typename T2>
1379
1380
std::string FormatForComparisonFailureMessage(
    const T1& value, const T2& /* other_operand */) {
1381
  return FormatForComparison<T1, T2>::Format(value);
shiqian's avatar
shiqian committed
1382
1383
1384
1385
1386
1387
1388
1389
}

// 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) {
1390
#ifdef _MSC_VER
1391
1392
# pragma warning(push)          // Saves the current warning state.
# pragma warning(disable:4389)  // Temporarily disables warning on
1393
                                // signed/unsigned mismatch.
1394
1395
#endif

shiqian's avatar
shiqian committed
1396
1397
1398
1399
  if (expected == actual) {
    return AssertionSuccess();
  }

1400
#ifdef _MSC_VER
1401
# pragma warning(pop)          // Restores the warning state.
1402
1403
#endif

shiqian's avatar
shiqian committed
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
  return EqFailure(expected_expression,
                   actual_expression,
                   FormatForComparisonFailureMessage(expected, actual),
                   FormatForComparisonFailureMessage(actual, expected),
                   false);
}

// 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
1414
1415
1416
1417
GTEST_API_ AssertionResult CmpHelperEQ(const char* expected_expression,
                                       const char* actual_expression,
                                       BiggestInt expected,
                                       BiggestInt actual);
shiqian's avatar
shiqian committed
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
1445
1446
1447
1448
1449
1450
1451

// 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()
1452
// is a null pointer literal, like NULL, false, or 0.
shiqian's avatar
shiqian committed
1453
1454
1455
1456
1457
1458
1459
1460
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>
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
  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
1472
1473
1474
1475
    return CmpHelperEQ(expected_expression, actual_expression, expected,
                       actual);
  }

1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
  // 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
1490
1491
    // We already know that 'expected' is a null pointer.
    return CmpHelperEQ(expected_expression, actual_expression,
1492
                       static_cast<T*>(NULL), actual);
shiqian's avatar
shiqian committed
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
  }
};

// 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.
shiqian's avatar
shiqian committed
1506
#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
shiqian's avatar
shiqian committed
1507
1508
1509
1510
1511
1512
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 {\
1513
1514
    return AssertionFailure() \
        << "Expected: (" << expr1 << ") " #op " (" << expr2\
shiqian's avatar
shiqian committed
1515
1516
1517
1518
        << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\
        << " vs " << FormatForComparisonFailureMessage(val2, val1);\
  }\
}\
zhanyong.wan's avatar
zhanyong.wan committed
1519
1520
GTEST_API_ AssertionResult CmpHelper##op_name(\
    const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2)
shiqian's avatar
shiqian committed
1521
1522
1523
1524

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

// Implements the helper function for {ASSERT|EXPECT}_NE
zhanyong.wan's avatar
zhanyong.wan committed
1525
GTEST_IMPL_CMP_HELPER_(NE, !=);
shiqian's avatar
shiqian committed
1526
// Implements the helper function for {ASSERT|EXPECT}_LE
zhanyong.wan's avatar
zhanyong.wan committed
1527
GTEST_IMPL_CMP_HELPER_(LE, <=);
shiqian's avatar
shiqian committed
1528
// Implements the helper function for {ASSERT|EXPECT}_LT
1529
GTEST_IMPL_CMP_HELPER_(LT, <);
shiqian's avatar
shiqian committed
1530
// Implements the helper function for {ASSERT|EXPECT}_GE
zhanyong.wan's avatar
zhanyong.wan committed
1531
GTEST_IMPL_CMP_HELPER_(GE, >=);
shiqian's avatar
shiqian committed
1532
// Implements the helper function for {ASSERT|EXPECT}_GT
1533
GTEST_IMPL_CMP_HELPER_(GT, >);
shiqian's avatar
shiqian committed
1534

shiqian's avatar
shiqian committed
1535
#undef GTEST_IMPL_CMP_HELPER_
shiqian's avatar
shiqian committed
1536
1537
1538
1539

// The helper function for {ASSERT|EXPECT}_STREQ.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1540
1541
1542
1543
GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression,
                                          const char* actual_expression,
                                          const char* expected,
                                          const char* actual);
shiqian's avatar
shiqian committed
1544
1545
1546
1547

// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1548
1549
1550
1551
GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression,
                                              const char* actual_expression,
                                              const char* expected,
                                              const char* actual);
shiqian's avatar
shiqian committed
1552
1553
1554
1555

// The helper function for {ASSERT|EXPECT}_STRNE.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1556
1557
1558
1559
GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
                                          const char* s2_expression,
                                          const char* s1,
                                          const char* s2);
shiqian's avatar
shiqian committed
1560
1561
1562
1563

// The helper function for {ASSERT|EXPECT}_STRCASENE.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1564
1565
1566
1567
GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
                                              const char* s2_expression,
                                              const char* s1,
                                              const char* s2);
shiqian's avatar
shiqian committed
1568
1569
1570
1571
1572


// Helper function for *_STREQ on wide strings.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1573
1574
1575
1576
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
1577
1578
1579
1580

// Helper function for *_STRNE on wide strings.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1581
1582
1583
1584
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
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595

}  // 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
1596
GTEST_API_ AssertionResult IsSubstring(
shiqian's avatar
shiqian committed
1597
1598
    const char* needle_expr, const char* haystack_expr,
    const char* needle, const char* haystack);
zhanyong.wan's avatar
zhanyong.wan committed
1599
GTEST_API_ AssertionResult IsSubstring(
shiqian's avatar
shiqian committed
1600
1601
    const char* needle_expr, const char* haystack_expr,
    const wchar_t* needle, const wchar_t* haystack);
zhanyong.wan's avatar
zhanyong.wan committed
1602
GTEST_API_ AssertionResult IsNotSubstring(
shiqian's avatar
shiqian committed
1603
1604
    const char* needle_expr, const char* haystack_expr,
    const char* needle, const char* haystack);
zhanyong.wan's avatar
zhanyong.wan committed
1605
GTEST_API_ AssertionResult IsNotSubstring(
shiqian's avatar
shiqian committed
1606
1607
    const char* needle_expr, const char* haystack_expr,
    const wchar_t* needle, const wchar_t* haystack);
zhanyong.wan's avatar
zhanyong.wan committed
1608
GTEST_API_ AssertionResult IsSubstring(
shiqian's avatar
shiqian committed
1609
1610
    const char* needle_expr, const char* haystack_expr,
    const ::std::string& needle, const ::std::string& haystack);
zhanyong.wan's avatar
zhanyong.wan committed
1611
GTEST_API_ AssertionResult IsNotSubstring(
shiqian's avatar
shiqian committed
1612
1613
1614
1615
    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
1616
GTEST_API_ AssertionResult IsSubstring(
shiqian's avatar
shiqian committed
1617
1618
    const char* needle_expr, const char* haystack_expr,
    const ::std::wstring& needle, const ::std::wstring& haystack);
zhanyong.wan's avatar
zhanyong.wan committed
1619
GTEST_API_ AssertionResult IsNotSubstring(
shiqian's avatar
shiqian committed
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
    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();
  }

1644
  ::std::stringstream expected_ss;
shiqian's avatar
shiqian committed
1645
1646
1647
  expected_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
              << expected;

1648
  ::std::stringstream actual_ss;
shiqian's avatar
shiqian committed
1649
1650
1651
1652
1653
  actual_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
            << actual;

  return EqFailure(expected_expression,
                   actual_expression,
1654
1655
                   StringStreamToString(&expected_ss),
                   StringStreamToString(&actual_ss),
shiqian's avatar
shiqian committed
1656
1657
1658
1659
1660
1661
                   false);
}

// Helper function for implementing ASSERT_NEAR.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1662
1663
1664
1665
1666
1667
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
1668
1669
1670

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
// A class that enables one to stream messages to assertion macros
1671
class GTEST_API_ AssertHelper {
shiqian's avatar
shiqian committed
1672
1673
 public:
  // Constructor.
1674
1675
1676
  AssertHelper(TestPartResult::Type type,
               const char* file,
               int line,
shiqian's avatar
shiqian committed
1677
               const char* message);
1678
1679
  ~AssertHelper();

shiqian's avatar
shiqian committed
1680
  // Message assignment is a semantic trick to enable assertion
shiqian's avatar
shiqian committed
1681
  // streaming; see the GTEST_MESSAGE_ macro below.
shiqian's avatar
shiqian committed
1682
  void operator=(const Message& message) const;
1683

shiqian's avatar
shiqian committed
1684
 private:
1685
1686
1687
1688
1689
  // 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 {
1690
1691
1692
    AssertHelperData(TestPartResult::Type t,
                     const char* srcfile,
                     int line_num,
1693
1694
1695
                     const char* msg)
        : type(t), file(srcfile), line(line_num), message(msg) { }

1696
    TestPartResult::Type const type;
1697
1698
1699
    const char* const file;
    int const line;
    std::string const message;
1700
1701
1702
1703
1704
1705

   private:
    GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
  };

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

shiqian's avatar
shiqian committed
1707
  GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
shiqian's avatar
shiqian committed
1708
1709
1710
1711
};

}  // namespace internal

zhanyong.wan's avatar
zhanyong.wan committed
1712
#if GTEST_HAS_PARAM_TEST
1713
1714
1715
1716
1717
// 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.
1718
//
1719
// This interface has support for accessing the test parameter value via
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
// 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>
1748
class WithParamInterface {
1749
1750
 public:
  typedef T ParamType;
1751
  virtual ~WithParamInterface() {}
1752
1753

  // The current parameter value. Is also available in the test fixture's
1754
1755
1756
1757
  // 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.
1758
1759
1760
1761
1762
1763
  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_;
  }
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774

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

1775
  // TestClass must be a subclass of WithParamInterface<T> and Test.
1776
1777
1778
1779
  template <class TestClass> friend class internal::ParameterizedTestFactory;
};

template <typename T>
1780
1781
1782
1783
1784
1785
1786
1787
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> {
};
1788
1789
1790

#endif  // GTEST_HAS_PARAM_TEST

shiqian's avatar
shiqian committed
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
// 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
1811
#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
shiqian's avatar
shiqian committed
1812

1813
1814
1815
1816
1817
1818
// 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
1819
// Generates a fatal failure with a generic message.
1820
1821
1822
1823
1824
#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
1825
# define FAIL() GTEST_FAIL()
1826
#endif
shiqian's avatar
shiqian committed
1827
1828

// Generates a success with a generic message.
1829
1830
1831
1832
1833
#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
1834
# define SUCCEED() GTEST_SUCCEED()
1835
#endif
shiqian's avatar
shiqian committed
1836

1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
// 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
1847
  GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
1848
#define EXPECT_NO_THROW(statement) \
shiqian's avatar
shiqian committed
1849
  GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
1850
#define EXPECT_ANY_THROW(statement) \
shiqian's avatar
shiqian committed
1851
  GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)
1852
#define ASSERT_THROW(statement, expected_exception) \
shiqian's avatar
shiqian committed
1853
  GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
1854
#define ASSERT_NO_THROW(statement) \
shiqian's avatar
shiqian committed
1855
  GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
1856
#define ASSERT_ANY_THROW(statement) \
shiqian's avatar
shiqian committed
1857
  GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)
1858

1859
1860
1861
// 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
1862
#define EXPECT_TRUE(condition) \
shiqian's avatar
shiqian committed
1863
1864
  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
                      GTEST_NONFATAL_FAILURE_)
shiqian's avatar
shiqian committed
1865
#define EXPECT_FALSE(condition) \
shiqian's avatar
shiqian committed
1866
1867
  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
                      GTEST_NONFATAL_FAILURE_)
shiqian's avatar
shiqian committed
1868
#define ASSERT_TRUE(condition) \
shiqian's avatar
shiqian committed
1869
1870
  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
                      GTEST_FATAL_FAILURE_)
shiqian's avatar
shiqian committed
1871
#define ASSERT_FALSE(condition) \
shiqian's avatar
shiqian committed
1872
1873
  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
                      GTEST_FATAL_FAILURE_)
shiqian's avatar
shiqian committed
1874
1875
1876

// Includes the auto-generated header that implements a family of
// generic predicate assertion macros.
1877
#include "gtest/gtest_pred_impl.h"
shiqian's avatar
shiqian committed
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926

// 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
1927
                      EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \
shiqian's avatar
shiqian committed
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
                      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)

1940
#define GTEST_ASSERT_EQ(expected, actual) \
shiqian's avatar
shiqian committed
1941
  ASSERT_PRED_FORMAT2(::testing::internal:: \
shiqian's avatar
shiqian committed
1942
                      EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \
shiqian's avatar
shiqian committed
1943
                      expected, actual)
1944
#define GTEST_ASSERT_NE(val1, val2) \
shiqian's avatar
shiqian committed
1945
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
1946
#define GTEST_ASSERT_LE(val1, val2) \
shiqian's avatar
shiqian committed
1947
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
1948
#define GTEST_ASSERT_LT(val1, val2) \
shiqian's avatar
shiqian committed
1949
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
1950
#define GTEST_ASSERT_GE(val1, val2) \
shiqian's avatar
shiqian committed
1951
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
1952
#define GTEST_ASSERT_GT(val1, val2) \
shiqian's avatar
shiqian committed
1953
1954
  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)

1955
1956
1957
1958
// 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
1959
# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
1960
1961
1962
#endif

#if !GTEST_DONT_DEFINE_ASSERT_NE
1963
# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
1964
1965
1966
#endif

#if !GTEST_DONT_DEFINE_ASSERT_LE
1967
# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
1968
1969
1970
#endif

#if !GTEST_DONT_DEFINE_ASSERT_LT
1971
# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
1972
1973
1974
#endif

#if !GTEST_DONT_DEFINE_ASSERT_GE
1975
# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
1976
1977
1978
#endif

#if !GTEST_DONT_DEFINE_ASSERT_GT
1979
# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
1980
1981
#endif

1982
// C-string Comparisons.  All tests treat NULL and any non-NULL string
shiqian's avatar
shiqian committed
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
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
// 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.
2061
2062
2063
2064
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
2065
2066


zhanyong.wan's avatar
zhanyong.wan committed
2067
#if GTEST_OS_WINDOWS
shiqian's avatar
shiqian committed
2068
2069
2070
2071
2072
2073

// 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)
//
2074
2075
2076
2077
// 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.
2078
# define EXPECT_HRESULT_SUCCEEDED(expr) \
shiqian's avatar
shiqian committed
2079
2080
    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))

2081
# define ASSERT_HRESULT_SUCCEEDED(expr) \
shiqian's avatar
shiqian committed
2082
2083
    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))

2084
# define EXPECT_HRESULT_FAILED(expr) \
shiqian's avatar
shiqian committed
2085
2086
    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))

2087
# define ASSERT_HRESULT_FAILED(expr) \
shiqian's avatar
shiqian committed
2088
2089
2090
2091
    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))

#endif  // GTEST_OS_WINDOWS

shiqian's avatar
shiqian committed
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
// 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
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118

// 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
2119
  ::testing::internal::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
shiqian's avatar
shiqian committed
2120
2121
    __FILE__, __LINE__, ::testing::Message() << (message))

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
2150
2151
2152
2153
// 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() {
2154
  (void)internal::StaticAssertTypeEqHelper<T1, T2>();
2155
2156
  return true;
}
shiqian's avatar
shiqian committed
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173

// 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.
//
// The user should put his test code between braces after using this
// macro.  Example:
//
//   TEST(FooTest, InitializesCorrectly) {
//     Foo foo;
//     EXPECT_TRUE(foo.StatusIsOK());
//   }

2174
2175
2176
2177
2178
2179
2180
2181
2182
// 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.
2183
#define GTEST_TEST(test_case_name, test_name)\
2184
  GTEST_TEST_(test_case_name, test_name, \
2185
              ::testing::Test, ::testing::internal::GetTestTypeId())
shiqian's avatar
shiqian committed
2186

2187
2188
2189
// 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
2190
# define TEST(test_case_name, test_name) GTEST_TEST(test_case_name, test_name)
2191
#endif
shiqian's avatar
shiqian committed
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219

// 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)\
2220
  GTEST_TEST_(test_fixture, test_name, test_fixture, \
2221
              ::testing::internal::GetTypeId<test_fixture>())
shiqian's avatar
shiqian committed
2222

2223
2224
2225
}  // namespace testing

// Use this function in main() to run all tests.  It returns 0 if all
shiqian's avatar
shiqian committed
2226
2227
2228
2229
// tests are successful, or 1 otherwise.
//
// RUN_ALL_TESTS() should be invoked after the command line has been
// parsed by InitGoogleTest().
2230
2231
2232
2233
//
// 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
2234

2235
2236
2237
inline int RUN_ALL_TESTS() {
  return ::testing::UnitTest::GetInstance()->Run();
}
shiqian's avatar
shiqian committed
2238
2239

#endif  // GTEST_INCLUDE_GTEST_GTEST_H_