gtest.h
Go to the documentation of this file.
1 // Copyright 2005, Google Inc.
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
6 // met:
7 //
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above
11 // copyright notice, this list of conditions and the following disclaimer
12 // in the documentation and/or other materials provided with the
13 // distribution.
14 // * Neither the name of Google Inc. nor the names of its
15 // contributors may be used to endorse or promote products derived from
16 // this software without specific prior written permission.
17 //
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 //
30 // Author: wan@google.com (Zhanyong Wan)
31 //
32 // The Google C++ Testing Framework (Google Test)
33 //
34 // This header file defines the public API for Google Test. It should be
35 // included by any test program that uses Google Test.
36 //
37 // IMPORTANT NOTE: Due to limitation of the C++ language, we have to
38 // leave some internal implementation details in this header file.
39 // They are clearly marked by comments like this:
40 //
41 // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
42 //
43 // Such code is NOT meant to be used by a user directly, and is subject
44 // to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user
45 // program!
46 //
47 // Acknowledgment: Google Test borrowed the idea of automatic test
48 // registration from Barthelemy Dagenais' (barthelemy@prologique.com)
49 // easyUnit framework.
50 
51 #ifndef GTEST_INCLUDE_GTEST_GTEST_H_
52 #define GTEST_INCLUDE_GTEST_GTEST_H_
53 
54 #include <limits>
55 #include <ostream>
56 #include <vector>
57 
60 #include "gtest/gtest-death-test.h"
61 #include "gtest/gtest-message.h"
62 #include "gtest/gtest-param-test.h"
63 #include "gtest/gtest-printers.h"
64 #include "gtest/gtest_prod.h"
65 #include "gtest/gtest-test-part.h"
66 #include "gtest/gtest-typed-test.h"
67 
68 // Depending on the platform, different string classes are available.
69 // On Linux, in addition to ::std::string, Google also makes use of
70 // class ::string, which has the same interface as ::std::string, but
71 // has a different implementation.
72 //
73 // The user can define GTEST_HAS_GLOBAL_STRING to 1 to indicate that
74 // ::string is available AND is a distinct type to ::std::string, or
75 // define it to 0 to indicate otherwise.
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.
79 //
80 // If the user doesn't define GTEST_HAS_GLOBAL_STRING, it is defined
81 // heuristically.
82 
83 namespace testing {
84 
85 // Declares the flags.
86 
87 // This flag temporary enables the disabled tests.
88 GTEST_DECLARE_bool_(also_run_disabled_tests);
89 
90 // This flag brings the debugger on an assertion failure.
91 GTEST_DECLARE_bool_(break_on_failure);
92 
93 // This flag controls whether Google Test catches all test-thrown exceptions
94 // and logs them as failures.
95 GTEST_DECLARE_bool_(catch_exceptions);
96 
97 // This flag enables using colors in terminal output. Available values are
98 // "yes" to enable colors, "no" (disable colors), or "auto" (the default)
99 // to let Google Test decide.
100 GTEST_DECLARE_string_(color);
101 
102 // This flag sets up the filter to select by name using a glob pattern
103 // the tests to run. If the filter is not given all tests are executed.
104 GTEST_DECLARE_string_(filter);
105 
106 // This flag causes the Google Test to list tests. None of the tests listed
107 // are actually run if the flag is provided.
108 GTEST_DECLARE_bool_(list_tests);
109 
110 // This flag controls whether Google Test emits a detailed XML report to a file
111 // in addition to its normal textual output.
112 GTEST_DECLARE_string_(output);
113 
114 // This flags control whether Google Test prints the elapsed time for each
115 // test.
116 GTEST_DECLARE_bool_(print_time);
117 
118 // This flag specifies the random number seed.
119 GTEST_DECLARE_int32_(random_seed);
120 
121 // This flag sets how many times the tests are repeated. The default value
122 // is 1. If the value is -1 the tests are repeating forever.
123 GTEST_DECLARE_int32_(repeat);
124 
125 // This flag controls whether Google Test includes Google Test internal
126 // stack frames in failure stack traces.
127 GTEST_DECLARE_bool_(show_internal_stack_frames);
128 
129 // When this flag is specified, tests' order is randomized on every iteration.
130 GTEST_DECLARE_bool_(shuffle);
131 
132 // This flag specifies the maximum number of stack frames to be
133 // printed in a failure message.
134 GTEST_DECLARE_int32_(stack_trace_depth);
135 
136 // When this flag is specified, a failed assertion will throw an
137 // exception if exceptions are enabled, or exit the program with a
138 // non-zero code otherwise.
139 GTEST_DECLARE_bool_(throw_on_failure);
140 
141 // When this flag is set with a "host:port" string, on supported
142 // platforms test results are streamed to the specified port on
143 // the specified host machine.
144 GTEST_DECLARE_string_(stream_result_to);
145 
146 // The upper limit for valid stack trace depths.
147 const int kMaxStackTraceDepth = 100;
148 
149 namespace internal {
150 
151 class AssertHelper;
152 class DefaultGlobalTestPartResultReporter;
153 class ExecDeathTest;
154 class NoExecDeathTest;
155 class FinalSuccessChecker;
156 class GTestFlagSaver;
157 class StreamingListenerTest;
158 class TestResultAccessor;
159 class TestEventListenersAccessor;
160 class TestEventRepeater;
161 class UnitTestRecordPropertyTestHelper;
162 class WindowsDeathTest;
163 class UnitTestImpl* GetUnitTestImpl();
165  const std::string& message);
166 
167 } // namespace internal
168 
169 // The friend relationship of some of these classes is cyclic.
170 // If we don't forward declare them the compiler might confuse the classes
171 // in friendship clauses with same named classes on the scope.
172 class Test;
173 class TestCase;
174 class TestInfo;
175 class UnitTest;
176 
177 // A class for indicating whether an assertion was successful. When
178 // the assertion wasn't successful, the AssertionResult object
179 // remembers a non-empty message that describes how it failed.
180 //
181 // To create an instance of this class, use one of the factory functions
182 // (AssertionSuccess() and AssertionFailure()).
183 //
184 // This class is useful for two purposes:
185 // 1. Defining predicate functions to be used with Boolean test assertions
186 // EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts
187 // 2. Defining predicate-format functions to be
188 // used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
189 //
190 // For example, if you define IsEven predicate:
191 //
192 // testing::AssertionResult IsEven(int n) {
193 // if ((n % 2) == 0)
194 // return testing::AssertionSuccess();
195 // else
196 // return testing::AssertionFailure() << n << " is odd";
197 // }
198 //
199 // Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))
200 // will print the message
201 //
202 // Value of: IsEven(Fib(5))
203 // Actual: false (5 is odd)
204 // Expected: true
205 //
206 // instead of a more opaque
207 //
208 // Value of: IsEven(Fib(5))
209 // Actual: false
210 // Expected: true
211 //
212 // in case IsEven is a simple Boolean predicate.
213 //
214 // If you expect your predicate to be reused and want to support informative
215 // messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up
216 // about half as often as positive ones in our tests), supply messages for
217 // both success and failure cases:
218 //
219 // testing::AssertionResult IsEven(int n) {
220 // if ((n % 2) == 0)
221 // return testing::AssertionSuccess() << n << " is even";
222 // else
223 // return testing::AssertionFailure() << n << " is odd";
224 // }
225 //
226 // Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print
227 //
228 // Value of: IsEven(Fib(6))
229 // Actual: true (8 is even)
230 // Expected: false
231 //
232 // NB: Predicates that support negative Boolean assertions have reduced
233 // performance in positive ones so be careful not to use them in tests
234 // that have lots (tens of thousands) of positive Boolean assertions.
235 //
236 // To use this class with EXPECT_PRED_FORMAT assertions such as:
237 //
238 // // Verifies that Foo() returns an even number.
239 // EXPECT_PRED_FORMAT1(IsEven, Foo());
240 //
241 // you need to define:
242 //
243 // testing::AssertionResult IsEven(const char* expr, int n) {
244 // if ((n % 2) == 0)
245 // return testing::AssertionSuccess();
246 // else
247 // return testing::AssertionFailure()
248 // << "Expected: " << expr << " is even\n Actual: it's " << n;
249 // }
250 //
251 // If Foo() returns 5, you will see the following message:
252 //
253 // Expected: Foo() is even
254 // Actual: it's 5
255 //
257  public:
258  // Copy constructor.
259  // Used in EXPECT_TRUE/FALSE(assertion_result).
260  AssertionResult(const AssertionResult& other);
261  // Used in the EXPECT_TRUE/FALSE(bool_expression).
262  explicit AssertionResult(bool success) : success_(success) {}
263 
264  // Returns true iff the assertion succeeded.
265  operator bool() const { return success_; } // NOLINT
266 
267  // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
268  AssertionResult operator!() const;
269 
270  // Returns the text streamed into this AssertionResult. Test assertions
271  // use it when they fail (i.e., the predicate's outcome doesn't match the
272  // assertion's expectation). When nothing has been streamed into the
273  // object, returns an empty string.
274  const char* message() const {
275  return message_.get() != NULL ? message_->c_str() : "";
276  }
277  // TODO(vladl@google.com): Remove this after making sure no clients use it.
278  // Deprecated; please use message() instead.
279  const char* failure_message() const { return message(); }
280 
281  // Streams a custom failure message into this object.
282  template <typename T> AssertionResult& operator<<(const T& value) {
283  AppendMessage(Message() << value);
284  return *this;
285  }
286 
287  // Allows streaming basic output manipulators such as endl or flush into
288  // this object.
290  ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
291  AppendMessage(Message() << basic_manipulator);
292  return *this;
293  }
294 
295  private:
296  // Appends the contents of message to message_.
297  void AppendMessage(const Message& a_message) {
298  if (message_.get() == NULL)
299  message_.reset(new ::std::string);
300  message_->append(a_message.GetString().c_str());
301  }
302 
303  // Stores result of the assertion predicate.
304  bool success_;
305  // Stores the message describing the condition in case the expectation
306  // construct is not satisfied with the predicate's outcome.
307  // Referenced via a pointer to avoid taking too much stack frame space
308  // with test assertions.
310 
312 };
313 
314 // Makes a successful assertion result.
316 
317 // Makes a failed assertion result.
319 
320 // Makes a failed assertion result with the given failure message.
321 // Deprecated; use AssertionFailure() << msg.
323 
324 // The abstract class that all tests inherit from.
325 //
326 // In Google Test, a unit test program contains one or many TestCases, and
327 // each TestCase contains one or many Tests.
328 //
329 // When you define a test using the TEST macro, you don't need to
330 // explicitly derive from Test - the TEST macro automatically does
331 // this for you.
332 //
333 // The only time you derive from Test is when defining a test fixture
334 // to be used a TEST_F. For example:
335 //
336 // class FooTest : public testing::Test {
337 // protected:
338 // virtual void SetUp() { ... }
339 // virtual void TearDown() { ... }
340 // ...
341 // };
342 //
343 // TEST_F(FooTest, Bar) { ... }
344 // TEST_F(FooTest, Baz) { ... }
345 //
346 // Test is not copyable.
348  public:
349  friend class TestInfo;
350 
351  // Defines types for pointers to functions that set up and tear down
352  // a test case.
355 
356  // The d'tor is virtual as we intend to inherit from Test.
357  virtual ~Test();
358 
359  // Sets up the stuff shared by all tests in this test case.
360  //
361  // Google Test will call Foo::SetUpTestCase() before running the first
362  // test in test case Foo. Hence a sub-class can define its own
363  // SetUpTestCase() method to shadow the one defined in the super
364  // class.
365  static void SetUpTestCase() {}
366 
367  // Tears down the stuff shared by all tests in this test case.
368  //
369  // Google Test will call Foo::TearDownTestCase() after running the last
370  // test in test case Foo. Hence a sub-class can define its own
371  // TearDownTestCase() method to shadow the one defined in the super
372  // class.
373  static void TearDownTestCase() {}
374 
375  // Returns true iff the current test has a fatal failure.
376  static bool HasFatalFailure();
377 
378  // Returns true iff the current test has a non-fatal failure.
379  static bool HasNonfatalFailure();
380 
381  // Returns true iff the current test has a (either fatal or
382  // non-fatal) failure.
383  static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); }
384 
385  // Logs a property for the current test, test case, or for the entire
386  // invocation of the test program when used outside of the context of a
387  // test case. Only the last value for a given key is remembered. These
388  // are public static so they can be called from utility functions that are
389  // not members of the test fixture. Calls to RecordProperty made during
390  // lifespan of the test (from the moment its constructor starts to the
391  // moment its destructor finishes) will be output in XML as attributes of
392  // the <testcase> element. Properties recorded from fixture's
393  // SetUpTestCase or TearDownTestCase are logged as attributes of the
394  // corresponding <testsuite> element. Calls to RecordProperty made in the
395  // global context (before or after invocation of RUN_ALL_TESTS and from
396  // SetUp/TearDown method of Environment objects registered with Google
397  // Test) will be output as attributes of the <testsuites> element.
398  static void RecordProperty(const std::string& key, const std::string& value);
399  static void RecordProperty(const std::string& key, int value);
400 
401  protected:
402  // Creates a Test object.
403  Test();
404 
405  // Sets up the test fixture.
406  virtual void SetUp();
407 
408  // Tears down the test fixture.
409  virtual void TearDown();
410 
411  private:
412  // Returns true iff the current test has the same fixture class as
413  // the first test in the current test case.
414  static bool HasSameFixtureClass();
415 
416  // Runs the test after the test fixture has been set up.
417  //
418  // A sub-class must implement this to define the test logic.
419  //
420  // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM.
421  // Instead, use the TEST or TEST_F macro.
422  virtual void TestBody() = 0;
423 
424  // Sets up, executes, and tears down the test.
425  void Run();
426 
427  // Deletes self. We deliberately pick an unusual name for this
428  // internal method to avoid clashing with names used in user TESTs.
429  void DeleteSelf_() { delete this; }
430 
431  // Uses a GTestFlagSaver to save and restore all Google Test flags.
433 
434  // Often a user mis-spells SetUp() as Setup() and spends a long time
435  // wondering why it is never called by Google Test. The declaration of
436  // the following method is solely for catching such an error at
437  // compile time:
438  //
439  // - The return type is deliberately chosen to be not void, so it
440  // will be a conflict if a user declares void Setup() in his test
441  // fixture.
442  //
443  // - This method is private, so it will be another compiler error
444  // if a user calls it from his test fixture.
445  //
446  // DO NOT OVERRIDE THIS FUNCTION.
447  //
448  // If you see an error about overriding the following function or
449  // about it being private, you have mis-spelled SetUp() as Setup().
451  virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
452 
453  // We disallow copying Tests.
455 };
456 
458 
459 // A copyable object representing a user specified test property which can be
460 // output as a key/value string pair.
461 //
462 // Don't inherit from TestProperty as its destructor is not virtual.
464  public:
465  // C'tor. TestProperty does NOT have a default constructor.
466  // Always use this constructor (with parameters) to create a
467  // TestProperty object.
468  TestProperty(const std::string& a_key, const std::string& a_value) :
469  key_(a_key), value_(a_value) {
470  }
471 
472  // Gets the user supplied key.
473  const char* key() const {
474  return key_.c_str();
475  }
476 
477  // Gets the user supplied value.
478  const char* value() const {
479  return value_.c_str();
480  }
481 
482  // Sets a new value, overriding the one supplied in the constructor.
483  void SetValue(const std::string& new_value) {
484  value_ = new_value;
485  }
486 
487  private:
488  // The key supplied by the user.
490  // The value supplied by the user.
492 };
493 
494 // The result of a single Test. This includes a list of
495 // TestPartResults, a list of TestProperties, a count of how many
496 // death tests there are in the Test, and how much time it took to run
497 // the Test.
498 //
499 // TestResult is not copyable.
501  public:
502  // Creates an empty TestResult.
503  TestResult();
504 
505  // D'tor. Do not inherit from TestResult.
506  ~TestResult();
507 
508  // Gets the number of all test parts. This is the sum of the number
509  // of successful test parts and the number of failed test parts.
510  int total_part_count() const;
511 
512  // Returns the number of the test properties.
513  int test_property_count() const;
514 
515  // Returns true iff the test passed (i.e. no test part failed).
516  bool Passed() const { return !Failed(); }
517 
518  // Returns true iff the test failed.
519  bool Failed() const;
520 
521  // Returns true iff the test fatally failed.
522  bool HasFatalFailure() const;
523 
524  // Returns true iff the test has a non-fatal failure.
525  bool HasNonfatalFailure() const;
526 
527  // Returns the elapsed time, in milliseconds.
528  TimeInMillis elapsed_time() const { return elapsed_time_; }
529 
530  // Returns the i-th test part result among all the results. i can range
531  // from 0 to test_property_count() - 1. If i is not in that range, aborts
532  // the program.
533  const TestPartResult& GetTestPartResult(int i) const;
534 
535  // Returns the i-th test property. i can range from 0 to
536  // test_property_count() - 1. If i is not in that range, aborts the
537  // program.
538  const TestProperty& GetTestProperty(int i) const;
539 
540  private:
541  friend class TestInfo;
542  friend class TestCase;
543  friend class UnitTest;
545  friend class internal::ExecDeathTest;
548  friend class internal::WindowsDeathTest;
549 
550  // Gets the vector of TestPartResults.
551  const std::vector<TestPartResult>& test_part_results() const {
552  return test_part_results_;
553  }
554 
555  // Gets the vector of TestProperties.
556  const std::vector<TestProperty>& test_properties() const {
557  return test_properties_;
558  }
559 
560  // Sets the elapsed time.
561  void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }
562 
563  // Adds a test property to the list. The property is validated and may add
564  // a non-fatal failure if invalid (e.g., if it conflicts with reserved
565  // key names). If a property is already recorded for the same key, the
566  // value will be updated, rather than storing multiple values for the same
567  // key. xml_element specifies the element for which the property is being
568  // recorded and is used for validation.
569  void RecordProperty(const std::string& xml_element,
570  const TestProperty& test_property);
571 
572  // Adds a failure if the key is a reserved attribute of Google Test
573  // testcase tags. Returns true if the property is valid.
574  // TODO(russr): Validate attribute names are legal and human readable.
575  static bool ValidateTestProperty(const std::string& xml_element,
576  const TestProperty& test_property);
577 
578  // Adds a test part result to the list.
579  void AddTestPartResult(const TestPartResult& test_part_result);
580 
581  // Returns the death test count.
582  int death_test_count() const { return death_test_count_; }
583 
584  // Increments the death test count, returning the new count.
585  int increment_death_test_count() { return ++death_test_count_; }
586 
587  // Clears the test part results.
588  void ClearTestPartResults();
589 
590  // Clears the object.
591  void Clear();
592 
593  // Protects mutable state of the property vector and of owned
594  // properties, whose values may be updated.
596 
597  // The vector of TestPartResults
598  std::vector<TestPartResult> test_part_results_;
599  // The vector of TestProperties
600  std::vector<TestProperty> test_properties_;
601  // Running count of death tests.
603  // The elapsed time, in milliseconds.
605 
606  // We disallow copying TestResult.
608 }; // class TestResult
609 
610 // A TestInfo object stores the following information about a test:
611 //
612 // Test case name
613 // Test name
614 // Whether the test should be run
615 // A function pointer that creates the test object when invoked
616 // Test result
617 //
618 // The constructor of TestInfo registers itself with the UnitTest
619 // singleton such that the RUN_ALL_TESTS() macro knows which tests to
620 // run.
622  public:
623  // Destructs a TestInfo object. This function is not virtual, so
624  // don't inherit from TestInfo.
625  ~TestInfo();
626 
627  // Returns the test case name.
628  const char* test_case_name() const { return test_case_name_.c_str(); }
629 
630  // Returns the test name.
631  const char* name() const { return name_.c_str(); }
632 
633  // Returns the name of the parameter type, or NULL if this is not a typed
634  // or a type-parameterized test.
635  const char* type_param() const {
636  if (type_param_.get() != NULL)
637  return type_param_->c_str();
638  return NULL;
639  }
640 
641  // Returns the text representation of the value parameter, or NULL if this
642  // is not a value-parameterized test.
643  const char* value_param() const {
644  if (value_param_.get() != NULL)
645  return value_param_->c_str();
646  return NULL;
647  }
648 
649  // Returns true if this test should run, that is if the test is not
650  // disabled (or it is disabled but the also_run_disabled_tests flag has
651  // been specified) and its full name matches the user-specified filter.
652  //
653  // Google Test allows the user to filter the tests by their full names.
654  // The full name of a test Bar in test case Foo is defined as
655  // "Foo.Bar". Only the tests that match the filter will run.
656  //
657  // A filter is a colon-separated list of glob (not regex) patterns,
658  // optionally followed by a '-' and a colon-separated list of
659  // negative patterns (tests to exclude). A test is run if it
660  // matches one of the positive patterns and does not match any of
661  // the negative patterns.
662  //
663  // For example, *A*:Foo.* is a filter that matches any string that
664  // contains the character 'A' or starts with "Foo.".
665  bool should_run() const { return should_run_; }
666 
667  // Returns true iff this test will appear in the XML report.
668  bool is_reportable() const {
669  // For now, the XML report includes all tests matching the filter.
670  // In the future, we may trim tests that are excluded because of
671  // sharding.
672  return matches_filter_;
673  }
674 
675  // Returns the result of the test.
676  const TestResult* result() const { return &result_; }
677 
678  private:
679 #if GTEST_HAS_DEATH_TEST
680  friend class internal::DefaultDeathTestFactory;
681 #endif // GTEST_HAS_DEATH_TEST
682  friend class Test;
683  friend class TestCase;
685  friend class internal::StreamingListenerTest;
687  const char* test_case_name,
688  const char* name,
689  const char* type_param,
690  const char* value_param,
691  internal::TypeId fixture_class_id,
692  Test::SetUpTestCaseFunc set_up_tc,
693  Test::TearDownTestCaseFunc tear_down_tc,
694  internal::TestFactoryBase* factory);
695 
696  // Constructs a TestInfo object. The newly constructed instance assumes
697  // ownership of the factory object.
698  TestInfo(const std::string& test_case_name,
699  const std::string& name,
700  const char* a_type_param, // NULL if not a type-parameterized test
701  const char* a_value_param, // NULL if not a value-parameterized test
702  internal::TypeId fixture_class_id,
703  internal::TestFactoryBase* factory);
704 
705  // Increments the number of death tests encountered in this test so
706  // far.
708  return result_.increment_death_test_count();
709  }
710 
711  // Creates the test object, runs it, records its result, and then
712  // deletes it.
713  void Run();
714 
715  static void ClearTestResult(TestInfo* test_info) {
716  test_info->result_.Clear();
717  }
718 
719  // These fields are immutable properties of the test.
720  const std::string test_case_name_; // Test case name
721  const std::string name_; // Test name
722  // Name of the parameter type, or NULL if this is not a typed or a
723  // type-parameterized test.
725  // Text representation of the value parameter, or NULL if this is not a
726  // value-parameterized test.
728  const internal::TypeId fixture_class_id_; // ID of the test fixture class
729  bool should_run_; // True iff this test should run
730  bool is_disabled_; // True iff this test is disabled
731  bool matches_filter_; // True if this test matches the
732  // user-specified filter.
733  internal::TestFactoryBase* const factory_; // The factory that creates
734  // the test object
735 
736  // This field is mutable and needs to be reset before running the
737  // test for the second time.
739 
741 };
742 
743 // A test case, which consists of a vector of TestInfos.
744 //
745 // TestCase is not copyable.
747  public:
748  // Creates a TestCase with the given name.
749  //
750  // TestCase does NOT have a default constructor. Always use this
751  // constructor to create a TestCase object.
752  //
753  // Arguments:
754  //
755  // name: name of the test case
756  // a_type_param: the name of the test's type parameter, or NULL if
757  // this is not a type-parameterized test.
758  // set_up_tc: pointer to the function that sets up the test case
759  // tear_down_tc: pointer to the function that tears down the test case
760  TestCase(const char* name, const char* a_type_param,
761  Test::SetUpTestCaseFunc set_up_tc,
762  Test::TearDownTestCaseFunc tear_down_tc);
763 
764  // Destructor of TestCase.
765  virtual ~TestCase();
766 
767  // Gets the name of the TestCase.
768  const char* name() const { return name_.c_str(); }
769 
770  // Returns the name of the parameter type, or NULL if this is not a
771  // type-parameterized test case.
772  const char* type_param() const {
773  if (type_param_.get() != NULL)
774  return type_param_->c_str();
775  return NULL;
776  }
777 
778  // Returns true if any test in this test case should run.
779  bool should_run() const { return should_run_; }
780 
781  // Gets the number of successful tests in this test case.
782  int successful_test_count() const;
783 
784  // Gets the number of failed tests in this test case.
785  int failed_test_count() const;
786 
787  // Gets the number of disabled tests that will be reported in the XML report.
788  int reportable_disabled_test_count() const;
789 
790  // Gets the number of disabled tests in this test case.
791  int disabled_test_count() const;
792 
793  // Gets the number of tests to be printed in the XML report.
794  int reportable_test_count() const;
795 
796  // Get the number of tests in this test case that should run.
797  int test_to_run_count() const;
798 
799  // Gets the number of all tests in this test case.
800  int total_test_count() const;
801 
802  // Returns true iff the test case passed.
803  bool Passed() const { return !Failed(); }
804 
805  // Returns true iff the test case failed.
806  bool Failed() const { return failed_test_count() > 0; }
807 
808  // Returns the elapsed time, in milliseconds.
809  TimeInMillis elapsed_time() const { return elapsed_time_; }
810 
811  // Returns the i-th test among all the tests. i can range from 0 to
812  // total_test_count() - 1. If i is not in that range, returns NULL.
813  const TestInfo* GetTestInfo(int i) const;
814 
815  // Returns the TestResult that holds test properties recorded during
816  // execution of SetUpTestCase and TearDownTestCase.
817  const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; }
818 
819  private:
820  friend class Test;
822 
823  // Gets the (mutable) vector of TestInfos in this TestCase.
824  std::vector<TestInfo*>& test_info_list() { return test_info_list_; }
825 
826  // Gets the (immutable) vector of TestInfos in this TestCase.
827  const std::vector<TestInfo*>& test_info_list() const {
828  return test_info_list_;
829  }
830 
831  // Returns the i-th test among all the tests. i can range from 0 to
832  // total_test_count() - 1. If i is not in that range, returns NULL.
833  TestInfo* GetMutableTestInfo(int i);
834 
835  // Sets the should_run member.
836  void set_should_run(bool should) { should_run_ = should; }
837 
838  // Adds a TestInfo to this test case. Will delete the TestInfo upon
839  // destruction of the TestCase object.
840  void AddTestInfo(TestInfo * test_info);
841 
842  // Clears the results of all tests in this test case.
843  void ClearResult();
844 
845  // Clears the results of all tests in the given test case.
846  static void ClearTestCaseResult(TestCase* test_case) {
847  test_case->ClearResult();
848  }
849 
850  // Runs every test in this TestCase.
851  void Run();
852 
853  // Runs SetUpTestCase() for this TestCase. This wrapper is needed
854  // for catching exceptions thrown from SetUpTestCase().
855  void RunSetUpTestCase() { (*set_up_tc_)(); }
856 
857  // Runs TearDownTestCase() for this TestCase. This wrapper is
858  // needed for catching exceptions thrown from TearDownTestCase().
859  void RunTearDownTestCase() { (*tear_down_tc_)(); }
860 
861  // Returns true iff test passed.
862  static bool TestPassed(const TestInfo* test_info) {
863  return test_info->should_run() && test_info->result()->Passed();
864  }
865 
866  // Returns true iff test failed.
867  static bool TestFailed(const TestInfo* test_info) {
868  return test_info->should_run() && test_info->result()->Failed();
869  }
870 
871  // Returns true iff the test is disabled and will be reported in the XML
872  // report.
873  static bool TestReportableDisabled(const TestInfo* test_info) {
874  return test_info->is_reportable() && test_info->is_disabled_;
875  }
876 
877  // Returns true iff test is disabled.
878  static bool TestDisabled(const TestInfo* test_info) {
879  return test_info->is_disabled_;
880  }
881 
882  // Returns true iff this test will appear in the XML report.
883  static bool TestReportable(const TestInfo* test_info) {
884  return test_info->is_reportable();
885  }
886 
887  // Returns true if the given test should run.
888  static bool ShouldRunTest(const TestInfo* test_info) {
889  return test_info->should_run();
890  }
891 
892  // Shuffles the tests in this test case.
893  void ShuffleTests(internal::Random* random);
894 
895  // Restores the test order to before the first shuffle.
896  void UnshuffleTests();
897 
898  // Name of the test case.
900  // Name of the parameter type, or NULL if this is not a typed or a
901  // type-parameterized test.
903  // The vector of TestInfos in their original order. It owns the
904  // elements in the vector.
905  std::vector<TestInfo*> test_info_list_;
906  // Provides a level of indirection for the test list to allow easy
907  // shuffling and restoring the test order. The i-th element in this
908  // vector is the index of the i-th test in the shuffled test list.
909  std::vector<int> test_indices_;
910  // Pointer to the function that sets up the test case.
912  // Pointer to the function that tears down the test case.
914  // True iff any test in this test case should run.
916  // Elapsed time, in milliseconds.
918  // Holds test properties recorded during execution of SetUpTestCase and
919  // TearDownTestCase.
921 
922  // We disallow copying TestCases.
924 };
925 
926 // An Environment object is capable of setting up and tearing down an
927 // environment. The user should subclass this to define his own
928 // environment(s).
929 //
930 // An Environment object does the set-up and tear-down in virtual
931 // methods SetUp() and TearDown() instead of the constructor and the
932 // destructor, as:
933 //
934 // 1. You cannot safely throw from a destructor. This is a problem
935 // as in some cases Google Test is used where exceptions are enabled, and
936 // we may want to implement ASSERT_* using exceptions where they are
937 // available.
938 // 2. You cannot use ASSERT_* directly in a constructor or
939 // destructor.
940 class Environment {
941  public:
942  // The d'tor is virtual as we need to subclass Environment.
943  virtual ~Environment() {}
944 
945  // Override this to define how to set up the environment.
946  virtual void SetUp() {}
947 
948  // Override this to define how to tear down the environment.
949  virtual void TearDown() {}
950  private:
951  // If you see an error about overriding the following function or
952  // about it being private, you have mis-spelled SetUp() as Setup().
954  virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
955 };
956 
957 // The interface for tracing execution of tests. The methods are organized in
958 // the order the corresponding events are fired.
960  public:
961  virtual ~TestEventListener() {}
962 
963  // Fired before any test activity starts.
964  virtual void OnTestProgramStart(const UnitTest& unit_test) = 0;
965 
966  // Fired before each iteration of tests starts. There may be more than
967  // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration
968  // index, starting from 0.
969  virtual void OnTestIterationStart(const UnitTest& unit_test,
970  int iteration) = 0;
971 
972  // Fired before environment set-up for each iteration of tests starts.
973  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0;
974 
975  // Fired after environment set-up for each iteration of tests ends.
976  virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0;
977 
978  // Fired before the test case starts.
979  virtual void OnTestCaseStart(const TestCase& test_case) = 0;
980 
981  // Fired before the test starts.
982  virtual void OnTestStart(const TestInfo& test_info) = 0;
983 
984  // Fired after a failed assertion or a SUCCEED() invocation.
985  virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0;
986 
987  // Fired after the test ends.
988  virtual void OnTestEnd(const TestInfo& test_info) = 0;
989 
990  // Fired after the test case ends.
991  virtual void OnTestCaseEnd(const TestCase& test_case) = 0;
992 
993  // Fired before environment tear-down for each iteration of tests starts.
994  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0;
995 
996  // Fired after environment tear-down for each iteration of tests ends.
997  virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0;
998 
999  // Fired after each iteration of tests finishes.
1000  virtual void OnTestIterationEnd(const UnitTest& unit_test,
1001  int iteration) = 0;
1002 
1003  // Fired after all test activities have ended.
1004  virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0;
1005 };
1006 
1007 // The convenience class for users who need to override just one or two
1008 // methods and are not concerned that a possible change to a signature of
1009 // the methods they override will not be caught during the build. For
1010 // comments about each method please see the definition of TestEventListener
1011 // above.
1013  public:
1014  virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
1015  virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
1016  int /*iteration*/) {}
1017  virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {}
1018  virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
1019  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
1020  virtual void OnTestStart(const TestInfo& /*test_info*/) {}
1021  virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {}
1022  virtual void OnTestEnd(const TestInfo& /*test_info*/) {}
1023  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
1024  virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {}
1025  virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {}
1026  virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
1027  int /*iteration*/) {}
1028  virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
1029 };
1030 
1031 // TestEventListeners lets users add listeners to track events in Google Test.
1033  public:
1035  ~TestEventListeners();
1036 
1037  // Appends an event listener to the end of the list. Google Test assumes
1038  // the ownership of the listener (i.e. it will delete the listener when
1039  // the test program finishes).
1040  void Append(TestEventListener* listener);
1041 
1042  // Removes the given event listener from the list and returns it. It then
1043  // becomes the caller's responsibility to delete the listener. Returns
1044  // NULL if the listener is not found in the list.
1045  TestEventListener* Release(TestEventListener* listener);
1046 
1047  // Returns the standard listener responsible for the default console
1048  // output. Can be removed from the listeners list to shut down default
1049  // console output. Note that removing this object from the listener list
1050  // with Release transfers its ownership to the caller and makes this
1051  // function return NULL the next time.
1053  return default_result_printer_;
1054  }
1055 
1056  // Returns the standard listener responsible for the default XML output
1057  // controlled by the --gtest_output=xml flag. Can be removed from the
1058  // listeners list by users who want to shut down the default XML output
1059  // controlled by this flag and substitute it with custom one. Note that
1060  // removing this object from the listener list with Release transfers its
1061  // ownership to the caller and makes this function return NULL the next
1062  // time.
1064  return default_xml_generator_;
1065  }
1066 
1067  private:
1068  friend class TestCase;
1069  friend class TestInfo;
1071  friend class internal::NoExecDeathTest;
1072  friend class internal::TestEventListenersAccessor;
1074 
1075  // Returns repeater that broadcasts the TestEventListener events to all
1076  // subscribers.
1077  TestEventListener* repeater();
1078 
1079  // Sets the default_result_printer attribute to the provided listener.
1080  // The listener is also added to the listener list and previous
1081  // default_result_printer is removed from it and deleted. The listener can
1082  // also be NULL in which case it will not be added to the list. Does
1083  // nothing if the previous and the current listener objects are the same.
1084  void SetDefaultResultPrinter(TestEventListener* listener);
1085 
1086  // Sets the default_xml_generator attribute to the provided listener. The
1087  // listener is also added to the listener list and previous
1088  // default_xml_generator is removed from it and deleted. The listener can
1089  // also be NULL in which case it will not be added to the list. Does
1090  // nothing if the previous and the current listener objects are the same.
1091  void SetDefaultXmlGenerator(TestEventListener* listener);
1092 
1093  // Controls whether events will be forwarded by the repeater to the
1094  // listeners in the list.
1095  bool EventForwardingEnabled() const;
1096  void SuppressEventForwarding();
1097 
1098  // The actual list of listeners.
1100  // Listener responsible for the standard result output.
1102  // Listener responsible for the creation of the XML output file.
1104 
1105  // We disallow copying TestEventListeners.
1107 };
1108 
1109 // A UnitTest consists of a vector of TestCases.
1110 //
1111 // This is a singleton class. The only instance of UnitTest is
1112 // created when UnitTest::GetInstance() is first called. This
1113 // instance is never deleted.
1114 //
1115 // UnitTest is not copyable.
1116 //
1117 // This class is thread-safe as long as the methods are called
1118 // according to their specification.
1120  public:
1121  // Gets the singleton UnitTest object. The first time this method
1122  // is called, a UnitTest object is constructed and returned.
1123  // Consecutive calls will return the same object.
1124  static UnitTest* GetInstance();
1125 
1126  // Runs all tests in this UnitTest object and prints the result.
1127  // Returns 0 if successful, or 1 otherwise.
1128  //
1129  // This method can only be called from the main thread.
1130  //
1131  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1132  int Run() GTEST_MUST_USE_RESULT_;
1133 
1134  // Returns the working directory when the first TEST() or TEST_F()
1135  // was executed. The UnitTest object owns the string.
1136  const char* original_working_dir() const;
1137 
1138  // Returns the TestCase object for the test that's currently running,
1139  // or NULL if no test is running.
1140  const TestCase* current_test_case() const
1141  GTEST_LOCK_EXCLUDED_(mutex_);
1142 
1143  // Returns the TestInfo object for the test that's currently running,
1144  // or NULL if no test is running.
1145  const TestInfo* current_test_info() const
1146  GTEST_LOCK_EXCLUDED_(mutex_);
1147 
1148  // Returns the random seed used at the start of the current test run.
1149  int random_seed() const;
1150 
1151 #if GTEST_HAS_PARAM_TEST
1152  // Returns the ParameterizedTestCaseRegistry object used to keep track of
1153  // value-parameterized tests and instantiate and register them.
1154  //
1155  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1156  internal::ParameterizedTestCaseRegistry& parameterized_test_registry()
1157  GTEST_LOCK_EXCLUDED_(mutex_);
1158 #endif // GTEST_HAS_PARAM_TEST
1159 
1160  // Gets the number of successful test cases.
1161  int successful_test_case_count() const;
1162 
1163  // Gets the number of failed test cases.
1164  int failed_test_case_count() const;
1165 
1166  // Gets the number of all test cases.
1167  int total_test_case_count() const;
1168 
1169  // Gets the number of all test cases that contain at least one test
1170  // that should run.
1171  int test_case_to_run_count() const;
1172 
1173  // Gets the number of successful tests.
1174  int successful_test_count() const;
1175 
1176  // Gets the number of failed tests.
1177  int failed_test_count() const;
1178 
1179  // Gets the number of disabled tests that will be reported in the XML report.
1180  int reportable_disabled_test_count() const;
1181 
1182  // Gets the number of disabled tests.
1183  int disabled_test_count() const;
1184 
1185  // Gets the number of tests to be printed in the XML report.
1186  int reportable_test_count() const;
1187 
1188  // Gets the number of all tests.
1189  int total_test_count() const;
1190 
1191  // Gets the number of tests that should run.
1192  int test_to_run_count() const;
1193 
1194  // Gets the time of the test program start, in ms from the start of the
1195  // UNIX epoch.
1196  TimeInMillis start_timestamp() const;
1197 
1198  // Gets the elapsed time, in milliseconds.
1199  TimeInMillis elapsed_time() const;
1200 
1201  // Returns true iff the unit test passed (i.e. all test cases passed).
1202  bool Passed() const;
1203 
1204  // Returns true iff the unit test failed (i.e. some test case failed
1205  // or something outside of all tests failed).
1206  bool Failed() const;
1207 
1208  // Gets the i-th test case among all the test cases. i can range from 0 to
1209  // total_test_case_count() - 1. If i is not in that range, returns NULL.
1210  const TestCase* GetTestCase(int i) const;
1211 
1212  // Returns the TestResult containing information on test failures and
1213  // properties logged outside of individual test cases.
1214  const TestResult& ad_hoc_test_result() const;
1215 
1216  // Returns the list of event listeners that can be used to track events
1217  // inside Google Test.
1218  TestEventListeners& listeners();
1219 
1220  private:
1221  // Registers and returns a global test environment. When a test
1222  // program is run, all global test environments will be set-up in
1223  // the order they were registered. After all tests in the program
1224  // have finished, all global test environments will be torn-down in
1225  // the *reverse* order they were registered.
1226  //
1227  // The UnitTest object takes ownership of the given environment.
1228  //
1229  // This method can only be called from the main thread.
1230  Environment* AddEnvironment(Environment* env);
1231 
1232  // Adds a TestPartResult to the current TestResult object. All
1233  // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc)
1234  // eventually call this to report their results. The user code
1235  // should use the assertion macros instead of calling this directly.
1236  void AddTestPartResult(TestPartResult::Type result_type,
1237  const char* file_name,
1238  int line_number,
1239  const std::string& message,
1240  const std::string& os_stack_trace)
1241  GTEST_LOCK_EXCLUDED_(mutex_);
1242 
1243  // Adds a TestProperty to the current TestResult object when invoked from
1244  // inside a test, to current TestCase's ad_hoc_test_result_ when invoked
1245  // from SetUpTestCase or TearDownTestCase, or to the global property set
1246  // when invoked elsewhere. If the result already contains a property with
1247  // the same key, the value will be updated.
1248  void RecordProperty(const std::string& key, const std::string& value);
1249 
1250  // Gets the i-th test case among all the test cases. i can range from 0 to
1251  // total_test_case_count() - 1. If i is not in that range, returns NULL.
1252  TestCase* GetMutableTestCase(int i);
1253 
1254  // Accessors for the implementation object.
1255  internal::UnitTestImpl* impl() { return impl_; }
1256  const internal::UnitTestImpl* impl() const { return impl_; }
1257 
1258  // These classes and funcions are friends as they need to access private
1259  // members of UnitTest.
1260  friend class Test;
1263  friend class internal::StreamingListenerTest;
1264  friend class internal::UnitTestRecordPropertyTestHelper;
1268  TestPartResult::Type result_type,
1269  const std::string& message);
1270 
1271  // Creates an empty UnitTest.
1272  UnitTest();
1273 
1274  // D'tor
1275  virtual ~UnitTest();
1276 
1277  // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
1278  // Google Test trace stack.
1279  void PushGTestTrace(const internal::TraceInfo& trace)
1280  GTEST_LOCK_EXCLUDED_(mutex_);
1281 
1282  // Pops a trace from the per-thread Google Test trace stack.
1283  void PopGTestTrace()
1284  GTEST_LOCK_EXCLUDED_(mutex_);
1285 
1286  // Protects mutable state in *impl_. This is mutable as some const
1287  // methods need to lock it too.
1288  mutable internal::Mutex mutex_;
1289 
1290  // Opaque implementation object. This field is never changed once
1291  // the object is constructed. We don't mark it as const here, as
1292  // doing so will cause a warning in the constructor of UnitTest.
1293  // Mutable state in *impl_ is protected by mutex_.
1294  internal::UnitTestImpl* impl_;
1295 
1296  // We disallow copying UnitTest.
1298 };
1299 
1300 // A convenient wrapper for adding an environment for the test
1301 // program.
1302 //
1303 // You should call this before RUN_ALL_TESTS() is called, probably in
1304 // main(). If you use gtest_main, you need to call this before main()
1305 // starts for it to take effect. For example, you can define a global
1306 // variable like this:
1307 //
1308 // testing::Environment* const foo_env =
1309 // testing::AddGlobalTestEnvironment(new FooEnvironment);
1310 //
1311 // However, we strongly recommend you to write your own main() and
1312 // call AddGlobalTestEnvironment() there, as relying on initialization
1313 // of global variables makes the code harder to read and may cause
1314 // problems when you register multiple environments from different
1315 // translation units and the environments have dependencies among them
1316 // (remember that the compiler doesn't guarantee the order in which
1317 // global variables from different translation units are initialized).
1319  return UnitTest::GetInstance()->AddEnvironment(env);
1320 }
1321 
1322 // Initializes Google Test. This must be called before calling
1323 // RUN_ALL_TESTS(). In particular, it parses a command line for the
1324 // flags that Google Test recognizes. Whenever a Google Test flag is
1325 // seen, it is removed from argv, and *argc is decremented.
1326 //
1327 // No value is returned. Instead, the Google Test flag variables are
1328 // updated.
1329 //
1330 // Calling the function for the second time has no user-visible effect.
1331 GTEST_API_ void InitGoogleTest(int* argc, char** argv);
1332 
1333 // This overloaded version can be used in Windows programs compiled in
1334 // UNICODE mode.
1335 GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);
1336 
1337 namespace internal {
1338 
1339 // FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
1340 // value of type ToPrint that is an operand of a comparison assertion
1341 // (e.g. ASSERT_EQ). OtherOperand is the type of the other operand in
1342 // the comparison, and is used to help determine the best way to
1343 // format the value. In particular, when the value is a C string
1344 // (char pointer) and the other operand is an STL string object, we
1345 // want to format the C string as a string, since we know it is
1346 // compared by value with the string object. If the value is a char
1347 // pointer but the other operand is not an STL string object, we don't
1348 // know whether the pointer is supposed to point to a NUL-terminated
1349 // string, and thus want to print it as a pointer to be safe.
1350 //
1351 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1352 
1353 // The default case.
1354 template <typename ToPrint, typename OtherOperand>
1356  public:
1357  static ::std::string Format(const ToPrint& value) {
1359  }
1360 };
1361 
1362 // Array.
1363 template <typename ToPrint, size_t N, typename OtherOperand>
1364 class FormatForComparison<ToPrint[N], OtherOperand> {
1365  public:
1366  static ::std::string Format(const ToPrint* value) {
1368  }
1369 };
1370 
1371 // By default, print C string as pointers to be safe, as we don't know
1372 // whether they actually point to a NUL-terminated string.
1373 
1374 #define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType) \
1375  template <typename OtherOperand> \
1376  class FormatForComparison<CharType*, OtherOperand> { \
1377  public: \
1378  static ::std::string Format(CharType* value) { \
1379  return ::testing::PrintToString(static_cast<const void*>(value)); \
1380  } \
1381  }
1382 
1387 
1388 #undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
1389 
1390 // If a C string is compared with an STL string object, we know it's meant
1391 // to point to a NUL-terminated string, and thus can print it as a string.
1392 
1393 #define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
1394  template <> \
1395  class FormatForComparison<CharType*, OtherStringType> { \
1396  public: \
1397  static ::std::string Format(CharType* value) { \
1398  return ::testing::PrintToString(value); \
1399  } \
1400  }
1401 
1404 
1405 #if GTEST_HAS_GLOBAL_STRING
1407 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::string);
1408 #endif
1409 
1410 #if GTEST_HAS_GLOBAL_WSTRING
1413 #endif
1414 
1415 #if GTEST_HAS_STD_WSTRING
1418 #endif
1419 
1420 #undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_
1421 
1422 // Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
1423 // operand to be used in a failure message. The type (but not value)
1424 // of the other operand may affect the format. This allows us to
1425 // print a char* as a raw pointer when it is compared against another
1426 // char* or void*, and print it as a C string when it is compared
1427 // against an std::string object, for example.
1428 //
1429 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1430 template <typename T1, typename T2>
1432  const T1& value, const T2& /* other_operand */) {
1434 }
1435 
1436 // The helper function for {ASSERT|EXPECT}_EQ.
1437 template <typename T1, typename T2>
1438 AssertionResult CmpHelperEQ(const char* expected_expression,
1439  const char* actual_expression,
1440  const T1& expected,
1441  const T2& actual) {
1442 #ifdef _MSC_VER
1443 # pragma warning(push) // Saves the current warning state.
1444 # pragma warning(disable:4389) // Temporarily disables warning on
1445  // signed/unsigned mismatch.
1446 #endif
1447 
1448  if (expected == actual) {
1449  return AssertionSuccess();
1450  }
1451 
1452 #ifdef _MSC_VER
1453 # pragma warning(pop) // Restores the warning state.
1454 #endif
1455 
1456  return EqFailure(expected_expression,
1457  actual_expression,
1458  FormatForComparisonFailureMessage(expected, actual),
1459  FormatForComparisonFailureMessage(actual, expected),
1460  false);
1461 }
1462 
1463 // With this overloaded version, we allow anonymous enums to be used
1464 // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums
1465 // can be implicitly cast to BiggestInt.
1466 GTEST_API_ AssertionResult CmpHelperEQ(const char* expected_expression,
1467  const char* actual_expression,
1468  BiggestInt expected,
1469  BiggestInt actual);
1470 
1471 // The helper class for {ASSERT|EXPECT}_EQ. The template argument
1472 // lhs_is_null_literal is true iff the first argument to ASSERT_EQ()
1473 // is a null pointer literal. The following default implementation is
1474 // for lhs_is_null_literal being false.
1475 template <bool lhs_is_null_literal>
1476 class EqHelper {
1477  public:
1478  // This templatized version is for the general case.
1479  template <typename T1, typename T2>
1480  static AssertionResult Compare(const char* expected_expression,
1481  const char* actual_expression,
1482  const T1& expected,
1483  const T2& actual) {
1484  return CmpHelperEQ(expected_expression, actual_expression, expected,
1485  actual);
1486  }
1487 
1488  // With this overloaded version, we allow anonymous enums to be used
1489  // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous
1490  // enums can be implicitly cast to BiggestInt.
1491  //
1492  // Even though its body looks the same as the above version, we
1493  // cannot merge the two, as it will make anonymous enums unhappy.
1494  static AssertionResult Compare(const char* expected_expression,
1495  const char* actual_expression,
1496  BiggestInt expected,
1497  BiggestInt actual) {
1498  return CmpHelperEQ(expected_expression, actual_expression, expected,
1499  actual);
1500  }
1501 };
1502 
1503 // This specialization is used when the first argument to ASSERT_EQ()
1504 // is a null pointer literal, like NULL, false, or 0.
1505 template <>
1506 class EqHelper<true> {
1507  public:
1508  // We define two overloaded versions of Compare(). The first
1509  // version will be picked when the second argument to ASSERT_EQ() is
1510  // NOT a pointer, e.g. ASSERT_EQ(0, AnIntFunction()) or
1511  // EXPECT_EQ(false, a_bool).
1512  template <typename T1, typename T2>
1514  const char* expected_expression,
1515  const char* actual_expression,
1516  const T1& expected,
1517  const T2& actual,
1518  // The following line prevents this overload from being considered if T2
1519  // is not a pointer type. We need this because ASSERT_EQ(NULL, my_ptr)
1520  // expands to Compare("", "", NULL, my_ptr), which requires a conversion
1521  // to match the Secret* in the other overload, which would otherwise make
1522  // this template match better.
1523  typename EnableIf<!is_pointer<T2>::value>::type* = 0) {
1524  return CmpHelperEQ(expected_expression, actual_expression, expected,
1525  actual);
1526  }
1527 
1528  // This version will be picked when the second argument to ASSERT_EQ() is a
1529  // pointer, e.g. ASSERT_EQ(NULL, a_pointer).
1530  template <typename T>
1532  const char* expected_expression,
1533  const char* actual_expression,
1534  // We used to have a second template parameter instead of Secret*. That
1535  // template parameter would deduce to 'long', making this a better match
1536  // than the first overload even without the first overload's EnableIf.
1537  // Unfortunately, gcc with -Wconversion-null warns when "passing NULL to
1538  // non-pointer argument" (even a deduced integral argument), so the old
1539  // implementation caused warnings in user code.
1540  Secret* /* expected (NULL) */,
1541  T* actual) {
1542  // We already know that 'expected' is a null pointer.
1543  return CmpHelperEQ(expected_expression, actual_expression,
1544  static_cast<T*>(NULL), actual);
1545  }
1546 };
1547 
1548 // A macro for implementing the helper functions needed to implement
1549 // ASSERT_?? and EXPECT_??. It is here just to avoid copy-and-paste
1550 // of similar code.
1551 //
1552 // For each templatized helper function, we also define an overloaded
1553 // version for BiggestInt in order to reduce code bloat and allow
1554 // anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled
1555 // with gcc 4.
1556 //
1557 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1558 #define GTEST_IMPL_CMP_HELPER_(op_name, op)\
1559 template <typename T1, typename T2>\
1560 AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
1561  const T1& val1, const T2& val2) {\
1562  if (val1 op val2) {\
1563  return AssertionSuccess();\
1564  } else {\
1565  return AssertionFailure() \
1566  << "Expected: (" << expr1 << ") " #op " (" << expr2\
1567  << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\
1568  << " vs " << FormatForComparisonFailureMessage(val2, val1);\
1569  }\
1570 }\
1571 GTEST_API_ AssertionResult CmpHelper##op_name(\
1572  const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2)
1573 
1574 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1575 
1576 // Implements the helper function for {ASSERT|EXPECT}_NE
1577 GTEST_IMPL_CMP_HELPER_(NE, !=);
1578 // Implements the helper function for {ASSERT|EXPECT}_LE
1579 GTEST_IMPL_CMP_HELPER_(LE, <=);
1580 // Implements the helper function for {ASSERT|EXPECT}_LT
1581 GTEST_IMPL_CMP_HELPER_(LT, <);
1582 // Implements the helper function for {ASSERT|EXPECT}_GE
1583 GTEST_IMPL_CMP_HELPER_(GE, >=);
1584 // Implements the helper function for {ASSERT|EXPECT}_GT
1585 GTEST_IMPL_CMP_HELPER_(GT, >);
1586 
1587 #undef GTEST_IMPL_CMP_HELPER_
1588 
1589 // The helper function for {ASSERT|EXPECT}_STREQ.
1590 //
1591 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1592 GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression,
1593  const char* actual_expression,
1594  const char* expected,
1595  const char* actual);
1596 
1597 // The helper function for {ASSERT|EXPECT}_STRCASEEQ.
1598 //
1599 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1600 GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression,
1601  const char* actual_expression,
1602  const char* expected,
1603  const char* actual);
1604 
1605 // The helper function for {ASSERT|EXPECT}_STRNE.
1606 //
1607 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1608 GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
1609  const char* s2_expression,
1610  const char* s1,
1611  const char* s2);
1612 
1613 // The helper function for {ASSERT|EXPECT}_STRCASENE.
1614 //
1615 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1616 GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
1617  const char* s2_expression,
1618  const char* s1,
1619  const char* s2);
1620 
1621 
1622 // Helper function for *_STREQ on wide strings.
1623 //
1624 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1625 GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression,
1626  const char* actual_expression,
1627  const wchar_t* expected,
1628  const wchar_t* actual);
1629 
1630 // Helper function for *_STRNE on wide strings.
1631 //
1632 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1633 GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
1634  const char* s2_expression,
1635  const wchar_t* s1,
1636  const wchar_t* s2);
1637 
1638 } // namespace internal
1639 
1640 // IsSubstring() and IsNotSubstring() are intended to be used as the
1641 // first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by
1642 // themselves. They check whether needle is a substring of haystack
1643 // (NULL is considered a substring of itself only), and return an
1644 // appropriate error message when they fail.
1645 //
1646 // The {needle,haystack}_expr arguments are the stringified
1647 // expressions that generated the two real arguments.
1648 GTEST_API_ AssertionResult IsSubstring(
1649  const char* needle_expr, const char* haystack_expr,
1650  const char* needle, const char* haystack);
1651 GTEST_API_ AssertionResult IsSubstring(
1652  const char* needle_expr, const char* haystack_expr,
1653  const wchar_t* needle, const wchar_t* haystack);
1654 GTEST_API_ AssertionResult IsNotSubstring(
1655  const char* needle_expr, const char* haystack_expr,
1656  const char* needle, const char* haystack);
1657 GTEST_API_ AssertionResult IsNotSubstring(
1658  const char* needle_expr, const char* haystack_expr,
1659  const wchar_t* needle, const wchar_t* haystack);
1660 GTEST_API_ AssertionResult IsSubstring(
1661  const char* needle_expr, const char* haystack_expr,
1662  const ::std::string& needle, const ::std::string& haystack);
1663 GTEST_API_ AssertionResult IsNotSubstring(
1664  const char* needle_expr, const char* haystack_expr,
1665  const ::std::string& needle, const ::std::string& haystack);
1666 
1667 #if GTEST_HAS_STD_WSTRING
1668 GTEST_API_ AssertionResult IsSubstring(
1669  const char* needle_expr, const char* haystack_expr,
1670  const ::std::wstring& needle, const ::std::wstring& haystack);
1671 GTEST_API_ AssertionResult IsNotSubstring(
1672  const char* needle_expr, const char* haystack_expr,
1673  const ::std::wstring& needle, const ::std::wstring& haystack);
1674 #endif // GTEST_HAS_STD_WSTRING
1675 
1676 namespace internal {
1677 
1678 // Helper template function for comparing floating-points.
1679 //
1680 // Template parameter:
1681 //
1682 // RawType: the raw floating-point type (either float or double)
1683 //
1684 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1685 template <typename RawType>
1686 AssertionResult CmpHelperFloatingPointEQ(const char* expected_expression,
1687  const char* actual_expression,
1688  RawType expected,
1689  RawType actual) {
1690  const FloatingPoint<RawType> lhs(expected), rhs(actual);
1691 
1692  if (lhs.AlmostEquals(rhs)) {
1693  return AssertionSuccess();
1694  }
1695 
1696  ::std::stringstream expected_ss;
1697  expected_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
1698  << expected;
1699 
1700  ::std::stringstream actual_ss;
1701  actual_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
1702  << actual;
1703 
1704  return EqFailure(expected_expression,
1705  actual_expression,
1706  StringStreamToString(&expected_ss),
1707  StringStreamToString(&actual_ss),
1708  false);
1709 }
1710 
1711 // Helper function for implementing ASSERT_NEAR.
1712 //
1713 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
1715  const char* expr2,
1716  const char* abs_error_expr,
1717  double val1,
1718  double val2,
1719  double abs_error);
1720 
1721 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
1722 // A class that enables one to stream messages to assertion macros
1724  public:
1725  // Constructor.
1727  const char* file,
1728  int line,
1729  const char* message);
1730  ~AssertHelper();
1731 
1732  // Message assignment is a semantic trick to enable assertion
1733  // streaming; see the GTEST_MESSAGE_ macro below.
1734  void operator=(const Message& message) const;
1735 
1736  private:
1737  // We put our data in a struct so that the size of the AssertHelper class can
1738  // be as small as possible. This is important because gcc is incapable of
1739  // re-using stack space even for temporary variables, so every EXPECT_EQ
1740  // reserves stack space for another AssertHelper.
1743  const char* srcfile,
1744  int line_num,
1745  const char* msg)
1746  : type(t), file(srcfile), line(line_num), message(msg) { }
1747 
1749  const char* const file;
1750  int const line;
1752 
1753  private:
1755  };
1756 
1758 
1760 };
1761 
1762 } // namespace internal
1763 
1764 #if GTEST_HAS_PARAM_TEST
1765 // The pure interface class that all value-parameterized tests inherit from.
1766 // A value-parameterized class must inherit from both ::testing::Test and
1767 // ::testing::WithParamInterface. In most cases that just means inheriting
1768 // from ::testing::TestWithParam, but more complicated test hierarchies
1769 // may need to inherit from Test and WithParamInterface at different levels.
1770 //
1771 // This interface has support for accessing the test parameter value via
1772 // the GetParam() method.
1773 //
1774 // Use it with one of the parameter generator defining functions, like Range(),
1775 // Values(), ValuesIn(), Bool(), and Combine().
1776 //
1777 // class FooTest : public ::testing::TestWithParam<int> {
1778 // protected:
1779 // FooTest() {
1780 // // Can use GetParam() here.
1781 // }
1782 // virtual ~FooTest() {
1783 // // Can use GetParam() here.
1784 // }
1785 // virtual void SetUp() {
1786 // // Can use GetParam() here.
1787 // }
1788 // virtual void TearDown {
1789 // // Can use GetParam() here.
1790 // }
1791 // };
1792 // TEST_P(FooTest, DoesBar) {
1793 // // Can use GetParam() method here.
1794 // Foo foo;
1795 // ASSERT_TRUE(foo.DoesBar(GetParam()));
1796 // }
1797 // INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));
1798 
1799 template <typename T>
1800 class WithParamInterface {
1801  public:
1802  typedef T ParamType;
1803  virtual ~WithParamInterface() {}
1804 
1805  // The current parameter value. Is also available in the test fixture's
1806  // constructor. This member function is non-static, even though it only
1807  // references static data, to reduce the opportunity for incorrect uses
1808  // like writing 'WithParamInterface<bool>::GetParam()' for a test that
1809  // uses a fixture whose parameter type is int.
1810  const ParamType& GetParam() const {
1811  GTEST_CHECK_(parameter_ != NULL)
1812  << "GetParam() can only be called inside a value-parameterized test "
1813  << "-- did you intend to write TEST_P instead of TEST_F?";
1814  return *parameter_;
1815  }
1816 
1817  private:
1818  // Sets parameter value. The caller is responsible for making sure the value
1819  // remains alive and unchanged throughout the current test.
1820  static void SetParam(const ParamType* parameter) {
1821  parameter_ = parameter;
1822  }
1823 
1824  // Static value used for accessing parameter during a test lifetime.
1825  static const ParamType* parameter_;
1826 
1827  // TestClass must be a subclass of WithParamInterface<T> and Test.
1828  template <class TestClass> friend class internal::ParameterizedTestFactory;
1829 };
1830 
1831 template <typename T>
1832 const T* WithParamInterface<T>::parameter_ = NULL;
1833 
1834 // Most value-parameterized classes can ignore the existence of
1835 // WithParamInterface, and can just inherit from ::testing::TestWithParam.
1836 
1837 template <typename T>
1838 class TestWithParam : public Test, public WithParamInterface<T> {
1839 };
1840 
1841 #endif // GTEST_HAS_PARAM_TEST
1842 
1843 // Macros for indicating success/failure in test code.
1844 
1845 // ADD_FAILURE unconditionally adds a failure to the current test.
1846 // SUCCEED generates a success - it doesn't automatically make the
1847 // current test successful, as a test is only successful when it has
1848 // no failure.
1849 //
1850 // EXPECT_* verifies that a certain condition is satisfied. If not,
1851 // it behaves like ADD_FAILURE. In particular:
1852 //
1853 // EXPECT_TRUE verifies that a Boolean condition is true.
1854 // EXPECT_FALSE verifies that a Boolean condition is false.
1855 //
1856 // FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except
1857 // that they will also abort the current function on failure. People
1858 // usually want the fail-fast behavior of FAIL and ASSERT_*, but those
1859 // writing data-driven tests often find themselves using ADD_FAILURE
1860 // and EXPECT_* more.
1861 
1862 // Generates a nonfatal failure with a generic message.
1863 #define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
1864 
1865 // Generates a nonfatal failure at the given source file location with
1866 // a generic message.
1867 #define ADD_FAILURE_AT(file, line) \
1868  GTEST_MESSAGE_AT_(file, line, "Failed", \
1869  ::testing::TestPartResult::kNonFatalFailure)
1870 
1871 // Generates a fatal failure with a generic message.
1872 #define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")
1873 
1874 // Define this macro to 1 to omit the definition of FAIL(), which is a
1875 // generic name and clashes with some other libraries.
1876 #if !GTEST_DONT_DEFINE_FAIL
1877 # define FAIL() GTEST_FAIL()
1878 #endif
1879 
1880 // Generates a success with a generic message.
1881 #define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded")
1882 
1883 // Define this macro to 1 to omit the definition of SUCCEED(), which
1884 // is a generic name and clashes with some other libraries.
1885 #if !GTEST_DONT_DEFINE_SUCCEED
1886 # define SUCCEED() GTEST_SUCCEED()
1887 #endif
1888 
1889 // Macros for testing exceptions.
1890 //
1891 // * {ASSERT|EXPECT}_THROW(statement, expected_exception):
1892 // Tests that the statement throws the expected exception.
1893 // * {ASSERT|EXPECT}_NO_THROW(statement):
1894 // Tests that the statement doesn't throw any exception.
1895 // * {ASSERT|EXPECT}_ANY_THROW(statement):
1896 // Tests that the statement throws an exception.
1897 
1898 #define EXPECT_THROW(statement, expected_exception) \
1899  GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
1900 #define EXPECT_NO_THROW(statement) \
1901  GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
1902 #define EXPECT_ANY_THROW(statement) \
1903  GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)
1904 #define ASSERT_THROW(statement, expected_exception) \
1905  GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
1906 #define ASSERT_NO_THROW(statement) \
1907  GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
1908 #define ASSERT_ANY_THROW(statement) \
1909  GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)
1910 
1911 // Boolean assertions. Condition can be either a Boolean expression or an
1912 // AssertionResult. For more information on how to use AssertionResult with
1913 // these macros see comments on that class.
1914 #define EXPECT_TRUE(condition) \
1915  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
1916  GTEST_NONFATAL_FAILURE_)
1917 #define EXPECT_FALSE(condition) \
1918  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
1919  GTEST_NONFATAL_FAILURE_)
1920 #define ASSERT_TRUE(condition) \
1921  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
1922  GTEST_FATAL_FAILURE_)
1923 #define ASSERT_FALSE(condition) \
1924  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
1925  GTEST_FATAL_FAILURE_)
1926 
1927 // Includes the auto-generated header that implements a family of
1928 // generic predicate assertion macros.
1929 #include "gtest/gtest_pred_impl.h"
1930 
1931 // Macros for testing equalities and inequalities.
1932 //
1933 // * {ASSERT|EXPECT}_EQ(expected, actual): Tests that expected == actual
1934 // * {ASSERT|EXPECT}_NE(v1, v2): Tests that v1 != v2
1935 // * {ASSERT|EXPECT}_LT(v1, v2): Tests that v1 < v2
1936 // * {ASSERT|EXPECT}_LE(v1, v2): Tests that v1 <= v2
1937 // * {ASSERT|EXPECT}_GT(v1, v2): Tests that v1 > v2
1938 // * {ASSERT|EXPECT}_GE(v1, v2): Tests that v1 >= v2
1939 //
1940 // When they are not, Google Test prints both the tested expressions and
1941 // their actual values. The values must be compatible built-in types,
1942 // or you will get a compiler error. By "compatible" we mean that the
1943 // values can be compared by the respective operator.
1944 //
1945 // Note:
1946 //
1947 // 1. It is possible to make a user-defined type work with
1948 // {ASSERT|EXPECT}_??(), but that requires overloading the
1949 // comparison operators and is thus discouraged by the Google C++
1950 // Usage Guide. Therefore, you are advised to use the
1951 // {ASSERT|EXPECT}_TRUE() macro to assert that two objects are
1952 // equal.
1953 //
1954 // 2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on
1955 // pointers (in particular, C strings). Therefore, if you use it
1956 // with two C strings, you are testing how their locations in memory
1957 // are related, not how their content is related. To compare two C
1958 // strings by content, use {ASSERT|EXPECT}_STR*().
1959 //
1960 // 3. {ASSERT|EXPECT}_EQ(expected, actual) is preferred to
1961 // {ASSERT|EXPECT}_TRUE(expected == actual), as the former tells you
1962 // what the actual value is when it fails, and similarly for the
1963 // other comparisons.
1964 //
1965 // 4. Do not depend on the order in which {ASSERT|EXPECT}_??()
1966 // evaluate their arguments, which is undefined.
1967 //
1968 // 5. These macros evaluate their arguments exactly once.
1969 //
1970 // Examples:
1971 //
1972 // EXPECT_NE(5, Foo());
1973 // EXPECT_EQ(NULL, a_pointer);
1974 // ASSERT_LT(i, array_size);
1975 // ASSERT_GT(records.size(), 0) << "There is no record left.";
1976 
1977 #define EXPECT_EQ(expected, actual) \
1978  EXPECT_PRED_FORMAT2(::testing::internal:: \
1979  EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \
1980  expected, actual)
1981 #define EXPECT_NE(expected, actual) \
1982  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, expected, actual)
1983 #define EXPECT_LE(val1, val2) \
1984  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
1985 #define EXPECT_LT(val1, val2) \
1986  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
1987 #define EXPECT_GE(val1, val2) \
1988  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
1989 #define EXPECT_GT(val1, val2) \
1990  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
1991 
1992 #define GTEST_ASSERT_EQ(expected, actual) \
1993  ASSERT_PRED_FORMAT2(::testing::internal:: \
1994  EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \
1995  expected, actual)
1996 #define GTEST_ASSERT_NE(val1, val2) \
1997  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
1998 #define GTEST_ASSERT_LE(val1, val2) \
1999  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
2000 #define GTEST_ASSERT_LT(val1, val2) \
2001  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
2002 #define GTEST_ASSERT_GE(val1, val2) \
2003  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
2004 #define GTEST_ASSERT_GT(val1, val2) \
2005  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
2006 
2007 // Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of
2008 // ASSERT_XY(), which clashes with some users' own code.
2009 
2010 #if !GTEST_DONT_DEFINE_ASSERT_EQ
2011 # define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
2012 #endif
2013 
2014 #if !GTEST_DONT_DEFINE_ASSERT_NE
2015 # define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
2016 #endif
2017 
2018 #if !GTEST_DONT_DEFINE_ASSERT_LE
2019 # define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
2020 #endif
2021 
2022 #if !GTEST_DONT_DEFINE_ASSERT_LT
2023 # define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
2024 #endif
2025 
2026 #if !GTEST_DONT_DEFINE_ASSERT_GE
2027 # define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
2028 #endif
2029 
2030 #if !GTEST_DONT_DEFINE_ASSERT_GT
2031 # define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
2032 #endif
2033 
2034 // C-string Comparisons. All tests treat NULL and any non-NULL string
2035 // as different. Two NULLs are equal.
2036 //
2037 // * {ASSERT|EXPECT}_STREQ(s1, s2): Tests that s1 == s2
2038 // * {ASSERT|EXPECT}_STRNE(s1, s2): Tests that s1 != s2
2039 // * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case
2040 // * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case
2041 //
2042 // For wide or narrow string objects, you can use the
2043 // {ASSERT|EXPECT}_??() macros.
2044 //
2045 // Don't depend on the order in which the arguments are evaluated,
2046 // which is undefined.
2047 //
2048 // These macros evaluate their arguments exactly once.
2049 
2050 #define EXPECT_STREQ(expected, actual) \
2051  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual)
2052 #define EXPECT_STRNE(s1, s2) \
2053  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
2054 #define EXPECT_STRCASEEQ(expected, actual) \
2055  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual)
2056 #define EXPECT_STRCASENE(s1, s2)\
2057  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
2058 
2059 #define ASSERT_STREQ(expected, actual) \
2060  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual)
2061 #define ASSERT_STRNE(s1, s2) \
2062  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
2063 #define ASSERT_STRCASEEQ(expected, actual) \
2064  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual)
2065 #define ASSERT_STRCASENE(s1, s2)\
2066  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
2067 
2068 // Macros for comparing floating-point numbers.
2069 //
2070 // * {ASSERT|EXPECT}_FLOAT_EQ(expected, actual):
2071 // Tests that two float values are almost equal.
2072 // * {ASSERT|EXPECT}_DOUBLE_EQ(expected, actual):
2073 // Tests that two double values are almost equal.
2074 // * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error):
2075 // Tests that v1 and v2 are within the given distance to each other.
2076 //
2077 // Google Test uses ULP-based comparison to automatically pick a default
2078 // error bound that is appropriate for the operands. See the
2079 // FloatingPoint template class in gtest-internal.h if you are
2080 // interested in the implementation details.
2081 
2082 #define EXPECT_FLOAT_EQ(expected, actual)\
2083  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
2084  expected, actual)
2085 
2086 #define EXPECT_DOUBLE_EQ(expected, actual)\
2087  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
2088  expected, actual)
2089 
2090 #define ASSERT_FLOAT_EQ(expected, actual)\
2091  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
2092  expected, actual)
2093 
2094 #define ASSERT_DOUBLE_EQ(expected, actual)\
2095  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
2096  expected, actual)
2097 
2098 #define EXPECT_NEAR(val1, val2, abs_error)\
2099  EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
2100  val1, val2, abs_error)
2101 
2102 #define ASSERT_NEAR(val1, val2, abs_error)\
2103  ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
2104  val1, val2, abs_error)
2105 
2106 // These predicate format functions work on floating-point values, and
2107 // can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g.
2108 //
2109 // EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0);
2110 
2111 // Asserts that val1 is less than, or almost equal to, val2. Fails
2112 // otherwise. In particular, it fails if either val1 or val2 is NaN.
2113 GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2,
2114  float val1, float val2);
2115 GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
2116  double val1, double val2);
2117 
2118 
2119 #if GTEST_OS_WINDOWS
2120 
2121 // Macros that test for HRESULT failure and success, these are only useful
2122 // on Windows, and rely on Windows SDK macros and APIs to compile.
2123 //
2124 // * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr)
2125 //
2126 // When expr unexpectedly fails or succeeds, Google Test prints the
2127 // expected result and the actual result with both a human-readable
2128 // string representation of the error, if available, as well as the
2129 // hex result code.
2130 # define EXPECT_HRESULT_SUCCEEDED(expr) \
2131  EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
2132 
2133 # define ASSERT_HRESULT_SUCCEEDED(expr) \
2134  ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
2135 
2136 # define EXPECT_HRESULT_FAILED(expr) \
2137  EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
2138 
2139 # define ASSERT_HRESULT_FAILED(expr) \
2140  ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
2141 
2142 #endif // GTEST_OS_WINDOWS
2143 
2144 // Macros that execute statement and check that it doesn't generate new fatal
2145 // failures in the current thread.
2146 //
2147 // * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement);
2148 //
2149 // Examples:
2150 //
2151 // EXPECT_NO_FATAL_FAILURE(Process());
2152 // ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed";
2153 //
2154 #define ASSERT_NO_FATAL_FAILURE(statement) \
2155  GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
2156 #define EXPECT_NO_FATAL_FAILURE(statement) \
2157  GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)
2158 
2159 // Causes a trace (including the source file path, the current line
2160 // number, and the given message) to be included in every test failure
2161 // message generated by code in the current scope. The effect is
2162 // undone when the control leaves the current scope.
2163 //
2164 // The message argument can be anything streamable to std::ostream.
2165 //
2166 // In the implementation, we include the current line number as part
2167 // of the dummy variable name, thus allowing multiple SCOPED_TRACE()s
2168 // to appear in the same block - as long as they are on different
2169 // lines.
2170 #define SCOPED_TRACE(message) \
2171  ::testing::internal::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
2172  __FILE__, __LINE__, ::testing::Message() << (message))
2173 
2174 // Compile-time assertion for type equality.
2175 // StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are
2176 // the same type. The value it returns is not interesting.
2177 //
2178 // Instead of making StaticAssertTypeEq a class template, we make it a
2179 // function template that invokes a helper class template. This
2180 // prevents a user from misusing StaticAssertTypeEq<T1, T2> by
2181 // defining objects of that type.
2182 //
2183 // CAVEAT:
2184 //
2185 // When used inside a method of a class template,
2186 // StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is
2187 // instantiated. For example, given:
2188 //
2189 // template <typename T> class Foo {
2190 // public:
2191 // void Bar() { testing::StaticAssertTypeEq<int, T>(); }
2192 // };
2193 //
2194 // the code:
2195 //
2196 // void Test1() { Foo<bool> foo; }
2197 //
2198 // will NOT generate a compiler error, as Foo<bool>::Bar() is never
2199 // actually instantiated. Instead, you need:
2200 //
2201 // void Test2() { Foo<bool> foo; foo.Bar(); }
2202 //
2203 // to cause a compiler error.
2204 template <typename T1, typename T2>
2207  return true;
2208 }
2209 
2210 // Defines a test.
2211 //
2212 // The first parameter is the name of the test case, and the second
2213 // parameter is the name of the test within the test case.
2214 //
2215 // The convention is to end the test case name with "Test". For
2216 // example, a test case for the Foo class can be named FooTest.
2217 //
2218 // The user should put his test code between braces after using this
2219 // macro. Example:
2220 //
2221 // TEST(FooTest, InitializesCorrectly) {
2222 // Foo foo;
2223 // EXPECT_TRUE(foo.StatusIsOK());
2224 // }
2225 
2226 // Note that we call GetTestTypeId() instead of GetTypeId<
2227 // ::testing::Test>() here to get the type ID of testing::Test. This
2228 // is to work around a suspected linker bug when using Google Test as
2229 // a framework on Mac OS X. The bug causes GetTypeId<
2230 // ::testing::Test>() to return different values depending on whether
2231 // the call is from the Google Test framework itself or from user test
2232 // code. GetTestTypeId() is guaranteed to always return the same
2233 // value, as it always calls GetTypeId<>() from the Google Test
2234 // framework.
2235 #define GTEST_TEST(test_case_name, test_name)\
2236  GTEST_TEST_(test_case_name, test_name, \
2237  ::testing::Test, ::testing::internal::GetTestTypeId())
2238 
2239 // Define this macro to 1 to omit the definition of TEST(), which
2240 // is a generic name and clashes with some other libraries.
2241 #if !GTEST_DONT_DEFINE_TEST
2242 # define TEST(test_case_name, test_name) GTEST_TEST(test_case_name, test_name)
2243 #endif
2244 
2245 // Defines a test that uses a test fixture.
2246 //
2247 // The first parameter is the name of the test fixture class, which
2248 // also doubles as the test case name. The second parameter is the
2249 // name of the test within the test case.
2250 //
2251 // A test fixture class must be declared earlier. The user should put
2252 // his test code between braces after using this macro. Example:
2253 //
2254 // class FooTest : public testing::Test {
2255 // protected:
2256 // virtual void SetUp() { b_.AddElement(3); }
2257 //
2258 // Foo a_;
2259 // Foo b_;
2260 // };
2261 //
2262 // TEST_F(FooTest, InitializesCorrectly) {
2263 // EXPECT_TRUE(a_.StatusIsOK());
2264 // }
2265 //
2266 // TEST_F(FooTest, ReturnsElementCountCorrectly) {
2267 // EXPECT_EQ(0, a_.size());
2268 // EXPECT_EQ(1, b_.size());
2269 // }
2270 
2271 #define TEST_F(test_fixture, test_name)\
2272  GTEST_TEST_(test_fixture, test_name, test_fixture, \
2273  ::testing::internal::GetTypeId<test_fixture>())
2274 
2275 } // namespace testing
2276 
2277 // Use this function in main() to run all tests. It returns 0 if all
2278 // tests are successful, or 1 otherwise.
2279 //
2280 // RUN_ALL_TESTS() should be invoked after the command line has been
2281 // parsed by InitGoogleTest().
2282 //
2283 // This function was formerly a macro; thus, it is in the global
2284 // namespace and has an all-caps name.
2286 
2287 inline int RUN_ALL_TESTS() {
2288  return ::testing::UnitTest::GetInstance()->Run();
2289 }
2290 
2291 #endif // GTEST_INCLUDE_GTEST_GTEST_H_
testing::EmptyTestEventListener::OnTestIterationStart
virtual void OnTestIterationStart(const UnitTest &, int)
Definition: gtest.h:1015
testing::internal::CmpHelperSTRCASENE
GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char *s1_expression, const char *s2_expression, const char *s1, const char *s2)
Definition: gtest.cc:1213
testing
Definition: gtest-death-test.h:43
testing::AssertionFailure
GTEST_API_ AssertionResult AssertionFailure()
Definition: gtest.cc:976
testing::internal::DefaultGlobalTestPartResultReporter
Definition: gtest-internal-inl.h:474
testing::internal::TestResultAccessor
Definition: gtest-internal-inl.h:1049
testing::TestPartResult
Definition: gtest-test-part.h:47
testing::TestInfo
Definition: gtest.h:621
testing::internal::EqHelper
Definition: gtest.h:1476
testing::internal::AssertHelper::data_
AssertHelperData *const data_
Definition: gtest.h:1757
testing::EmptyTestEventListener::OnTestProgramStart
virtual void OnTestProgramStart(const UnitTest &)
Definition: gtest.h:1014
testing::TestResult::test_properties
const std::vector< TestProperty > & test_properties() const
Definition: gtest.h:556
testing::GTEST_DECLARE_int32_
GTEST_DECLARE_int32_(random_seed)
testing::internal::FloatingPoint
Definition: gtest-internal.h:232
testing::EmptyTestEventListener::OnEnvironmentsTearDownStart
virtual void OnEnvironmentsTearDownStart(const UnitTest &)
Definition: gtest.h:1024
testing::internal::AssertHelper::AssertHelperData::file
const char *const file
Definition: gtest.h:1749
testing::TestCase::TestReportable
static bool TestReportable(const TestInfo *test_info)
Definition: gtest.h:883
testing::TestInfo::factory_
internal::TestFactoryBase *const factory_
Definition: gtest.h:733
testing::TestCase::TestFailed
static bool TestFailed(const TestInfo *test_info)
Definition: gtest.h:867
testing::internal::Mutex
Definition: gtest-port.h:1548
testing::Test::DeleteSelf_
void DeleteSelf_()
Definition: gtest.h:429
testing::Message::GetString
std::string GetString() const
Definition: gtest.cc:949
testing::TestInfo::matches_filter_
bool matches_filter_
Definition: gtest.h:731
testing::TestEventListener::OnEnvironmentsTearDownEnd
virtual void OnEnvironmentsTearDownEnd(const UnitTest &unit_test)=0
testing::TestEventListeners::default_xml_generator
TestEventListener * default_xml_generator() const
Definition: gtest.h:1063
name_
std::string name_
Definition: gtest.cc:2280
testing::TestEventListener::OnTestCaseStart
virtual void OnTestCaseStart(const TestCase &test_case)=0
testing::GTEST_DECLARE_bool_
GTEST_DECLARE_bool_(also_run_disabled_tests)
testing::TestResult
Definition: gtest.h:500
testing::UnitTest::impl
internal::UnitTestImpl * impl()
Definition: gtest.h:1255
testing::Environment::~Environment
virtual ~Environment()
Definition: gtest.h:943
testing::TestProperty::key_
std::string key_
Definition: gtest.h:489
testing::internal::CmpHelperSTREQ
GTEST_API_ AssertionResult CmpHelperSTREQ(const char *expected_expression, const char *actual_expression, const wchar_t *expected, const wchar_t *actual)
Definition: gtest.cc:1549
testing::AssertionResult::success_
bool success_
Definition: gtest.h:304
testing::internal::AssertHelper
Definition: gtest.h:1723
testing::TestCase::elapsed_time_
TimeInMillis elapsed_time_
Definition: gtest.h:917
testing::internal::GetUnitTestImpl
class UnitTestImpl * GetUnitTestImpl()
Definition: gtest-internal-inl.h:936
testing::internal::FormatForComparisonFailureMessage
std::string FormatForComparisonFailureMessage(const T1 &value, const T2 &)
Definition: gtest.h:1431
testing::internal::EqHelper< true >::Compare
static AssertionResult Compare(const char *expected_expression, const char *actual_expression, Secret *, T *actual)
Definition: gtest.h:1531
testing::AssertionResult::message_
internal::scoped_ptr< ::std::string > message_
Definition: gtest.h:309
testing::internal::TimeInMillis
TypeWithSize< 8 >::Int TimeInMillis
Definition: gtest-port.h:1907
testing::TestResult::test_part_results_
std::vector< TestPartResult > test_part_results_
Definition: gtest.h:598
testing::TestEventListeners::default_xml_generator_
TestEventListener * default_xml_generator_
Definition: gtest.h:1103
testing::TestEventListener::OnTestEnd
virtual void OnTestEnd(const TestInfo &test_info)=0
testing::AssertionResult::operator<<
AssertionResult & operator<<(::std::ostream &(*basic_manipulator)(::std::ostream &stream))
Definition: gtest.h:289
testing::TestEventListeners::repeater_
internal::TestEventRepeater * repeater_
Definition: gtest.h:1099
testing::TestCase::elapsed_time
TimeInMillis elapsed_time() const
Definition: gtest.h:809
testing::TestCase::TestDisabled
static bool TestDisabled(const TestInfo *test_info)
Definition: gtest.h:878
testing::internal::AssertHelper::AssertHelperData::line
const int line
Definition: gtest.h:1750
testing::internal::is_pointer
Definition: gtest-port.h:1624
testing::TestProperty::SetValue
void SetValue(const std::string &new_value)
Definition: gtest.h:483
testing::TestInfo::test_case_name
const char * test_case_name() const
Definition: gtest.h:628
testing::TestCase::name
const char * name() const
Definition: gtest.h:768
testing::internal::FormatForComparison
Definition: gtest.h:1355
testing::TestEventListeners
Definition: gtest.h:1032
testing::TestCase::RunTearDownTestCase
void RunTearDownTestCase()
Definition: gtest.h:859
gtest-internal.h
testing::Test::SetUpTestCase
static void SetUpTestCase()
Definition: gtest.h:365
testing::TestInfo::type_param
const char * type_param() const
Definition: gtest.h:635
testing::TestInfo::increment_death_test_count
int increment_death_test_count()
Definition: gtest.h:707
testing::TestInfo::is_reportable
bool is_reportable() const
Definition: gtest.h:668
testing::TestInfo::ClearTestResult
static void ClearTestResult(TestInfo *test_info)
Definition: gtest.h:715
testing::internal::CmpHelperEQ
GTEST_API_ AssertionResult CmpHelperEQ(const char *expected_expression, const char *actual_expression, BiggestInt expected, BiggestInt actual)
Definition: gtest.cc:1117
testing::internal::DoubleNearPredFormat
GTEST_API_ AssertionResult DoubleNearPredFormat(const char *expr1, const char *expr2, const char *abs_error_expr, double val1, double val2, double abs_error)
Definition: gtest.cc:1042
testing::Message
Definition: gtest-message.h:85
testing::TestInfo::test_case_name_
const std::string test_case_name_
Definition: gtest.h:720
testing::TestPartResult::Type
Type
Definition: gtest-test-part.h:51
testing::TestInfo::fixture_class_id_
const internal::TypeId fixture_class_id_
Definition: gtest.h:728
testing::internal::CmpHelperFloatingPointEQ
AssertionResult CmpHelperFloatingPointEQ(const char *expected_expression, const char *actual_expression, RawType expected, RawType actual)
Definition: gtest.h:1686
testing::TestCase::type_param
const char * type_param() const
Definition: gtest.h:772
testing::internal::EnableIf
Definition: gtest-internal.h:875
testing::Test
Definition: gtest.h:347
testing::TestCase::name_
std::string name_
Definition: gtest.h:899
testing::TestCase::test_info_list
std::vector< TestInfo * > & test_info_list()
Definition: gtest.h:824
testing::TestEventListener::OnTestPartResult
virtual void OnTestPartResult(const TestPartResult &test_part_result)=0
testing::TestResult::test_part_results
const std::vector< TestPartResult > & test_part_results() const
Definition: gtest.h:551
testing::internal::GTestFlagSaver
Definition: gtest-internal-inl.h:161
testing::TestResult::set_elapsed_time
void set_elapsed_time(TimeInMillis elapsed)
Definition: gtest.h:561
testing::EmptyTestEventListener::OnTestCaseStart
virtual void OnTestCaseStart(const TestCase &)
Definition: gtest.h:1019
testing::UnitTest::impl
const internal::UnitTestImpl * impl() const
Definition: gtest.h:1256
gtest-param-test.h
testing::internal::wstring
::std::wstring wstring
Definition: gtest-port.h:881
testing::internal::string
::std::string string
Definition: gtest-port.h:875
testing::TestInfo::type_param_
const internal::scoped_ptr< const ::std::string > type_param_
Definition: gtest.h:724
testing::internal::MakeAndRegisterTestInfo
GTEST_API_ TestInfo * MakeAndRegisterTestInfo(const char *test_case_name, const char *name, const char *type_param, const char *value_param, TypeId fixture_class_id, SetUpTestCaseFunc set_up_tc, TearDownTestCaseFunc tear_down_tc, TestFactoryBase *factory)
Definition: gtest.cc:2219
testing::EmptyTestEventListener::OnEnvironmentsSetUpStart
virtual void OnEnvironmentsSetUpStart(const UnitTest &)
Definition: gtest.h:1017
testing::TestCase
Definition: gtest.h:746
testing::TestEventListener::OnEnvironmentsSetUpEnd
virtual void OnEnvironmentsSetUpEnd(const UnitTest &unit_test)=0
testing::internal::StaticAssertTypeEqHelper
Definition: gtest-port.h:867
testing::AssertionResult::AssertionResult
AssertionResult(bool success)
Definition: gtest.h:262
testing::TestInfo::value_param_
const internal::scoped_ptr< const ::std::string > value_param_
Definition: gtest.h:727
testing::TestEventListener::OnTestProgramStart
virtual void OnTestProgramStart(const UnitTest &unit_test)=0
GTEST_CHECK_
#define GTEST_CHECK_(condition)
Definition: gtest-port.h:1063
gtest-typed-test.h
testing::internal::AssertHelper::AssertHelperData::type
const TestPartResult::Type type
Definition: gtest.h:1748
testing::AssertionResult::failure_message
const char * failure_message() const
Definition: gtest.h:279
testing::TestInfo::should_run_
bool should_run_
Definition: gtest.h:729
testing::Test::HasFailure
static bool HasFailure()
Definition: gtest.h:383
testing::EmptyTestEventListener::OnEnvironmentsTearDownEnd
virtual void OnEnvironmentsTearDownEnd(const UnitTest &)
Definition: gtest.h:1025
GTEST_LOCK_EXCLUDED_
#define GTEST_LOCK_EXCLUDED_(locks)
Definition: gtest-port.h:1931
name
std::string name
Definition: test_sphere_box.cpp:167
testing::TestCase::ShouldRunTest
static bool ShouldRunTest(const TestInfo *test_info)
Definition: gtest.h:888
testing::TestInfo::should_run
bool should_run() const
Definition: gtest.h:665
testing::Environment
Definition: gtest.h:940
GTEST_IMPL_CMP_HELPER_
#define GTEST_IMPL_CMP_HELPER_(op_name, op)
Definition: gtest.h:1558
testing::AssertionResult
Definition: gtest.h:256
testing::internal::TearDownTestCaseFunc
void(* TearDownTestCaseFunc)()
Definition: gtest-internal.h:472
testing::TestInfo::is_disabled_
bool is_disabled_
Definition: gtest.h:730
testing::Environment::SetUp
virtual void SetUp()
Definition: gtest.h:946
GTEST_API_
#define GTEST_API_
Definition: gtest-port.h:771
testing::TimeInMillis
internal::TimeInMillis TimeInMillis
Definition: gtest.h:457
testing::TestCase::ClearTestCaseResult
static void ClearTestCaseResult(TestCase *test_case)
Definition: gtest.h:846
testing::EmptyTestEventListener::OnTestCaseEnd
virtual void OnTestCaseEnd(const TestCase &)
Definition: gtest.h:1023
RUN_ALL_TESTS
int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_
Definition: gtest.h:2287
testing::TestProperty
Definition: gtest.h:463
gtest_prod.h
testing::TestProperty::key
const char * key() const
Definition: gtest.h:473
testing::AssertionSuccess
GTEST_API_ AssertionResult AssertionSuccess()
Definition: gtest.cc:971
testing::internal::AssertHelper::AssertHelperData::AssertHelperData
AssertHelperData(TestPartResult::Type t, const char *srcfile, int line_num, const char *msg)
Definition: gtest.h:1742
testing::TestCase::test_indices_
std::vector< int > test_indices_
Definition: gtest.h:909
testing::Environment::TearDown
virtual void TearDown()
Definition: gtest.h:949
testing::Test::gtest_flag_saver_
const internal::GTestFlagSaver *const gtest_flag_saver_
Definition: gtest.h:432
testing::internal::Random
Definition: gtest-internal.h:676
testing::internal::CmpHelperSTRCASEEQ
GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char *expected_expression, const char *actual_expression, const char *expected, const char *actual)
Definition: gtest.cc:1183
testing::TestCase::TestPassed
static bool TestPassed(const TestInfo *test_info)
Definition: gtest.h:862
testing::TestCase::TestReportableDisabled
static bool TestReportableDisabled(const TestInfo *test_info)
Definition: gtest.h:873
testing::TestInfo::result
const TestResult * result() const
Definition: gtest.h:676
testing::TestEventListener::~TestEventListener
virtual ~TestEventListener()
Definition: gtest.h:961
testing::internal::SetUpTestCaseFunc
void(* SetUpTestCaseFunc)()
Definition: gtest-internal.h:471
testing::Test::SetUpTestCaseFunc
internal::SetUpTestCaseFunc SetUpTestCaseFunc
Definition: gtest.h:353
testing::TestCase::Passed
bool Passed() const
Definition: gtest.h:803
gtest_pred_impl.h
testing::TestCase::should_run_
bool should_run_
Definition: gtest.h:915
testing::internal::CmpHelperSTRNE
GTEST_API_ AssertionResult CmpHelperSTRNE(const char *s1_expression, const char *s2_expression, const wchar_t *s1, const wchar_t *s2)
Definition: gtest.cc:1565
testing::EmptyTestEventListener::OnTestProgramEnd
virtual void OnTestProgramEnd(const UnitTest &)
Definition: gtest.h:1028
GTEST_DISALLOW_ASSIGN_
#define GTEST_DISALLOW_ASSIGN_(type)
Definition: gtest-port.h:724
testing::internal::FormatForComparison::Format
::std::string Format(const ToPrint &value)
Definition: gtest.h:1357
testing::TestEventListener::OnEnvironmentsTearDownStart
virtual void OnEnvironmentsTearDownStart(const UnitTest &unit_test)=0
testing::internal::UnitTestImpl
Definition: gtest-internal-inl.h:508
testing::internal::TypeId
const typedef void * TypeId
Definition: gtest-internal.h:399
testing::TestResult::death_test_count
int death_test_count() const
Definition: gtest.h:582
testing::StaticAssertTypeEq
bool StaticAssertTypeEq()
Definition: gtest.h:2205
testing::internal::BiggestInt
long long BiggestInt
Definition: gtest-port.h:1652
testing::GTEST_DECLARE_string_
GTEST_DECLARE_string_(death_test_style)
gtest-death-test.h
testing::kMaxStackTraceDepth
const int kMaxStackTraceDepth
Definition: gtest.h:147
testing::TestInfo::value_param
const char * value_param() const
Definition: gtest.h:643
testing::TestCase::RunSetUpTestCase
void RunSetUpTestCase()
Definition: gtest.h:855
testing::InitGoogleTest
GTEST_API_ void InitGoogleTest(int *argc, char **argv)
Definition: gtest.cc:5008
testing::Test::TearDownTestCaseFunc
internal::TearDownTestCaseFunc TearDownTestCaseFunc
Definition: gtest.h:354
testing::TestResult::elapsed_time
TimeInMillis elapsed_time() const
Definition: gtest.h:528
testing::EmptyTestEventListener::OnEnvironmentsSetUpEnd
virtual void OnEnvironmentsSetUpEnd(const UnitTest &)
Definition: gtest.h:1018
testing::TestInfo::name_
const std::string name_
Definition: gtest.h:721
testing::internal::EqFailure
GTEST_API_ AssertionResult EqFailure(const char *expected_expression, const char *actual_expression, const std::string &expected_value, const std::string &actual_value, bool ignoring_case)
Definition: gtest.cc:1003
testing::TestResult::increment_death_test_count
int increment_death_test_count()
Definition: gtest.h:585
testing::internal::AssertHelper::AssertHelperData
Definition: gtest.h:1741
gtest-string.h
testing::TestInfo::result_
TestResult result_
Definition: gtest.h:738
testing::TestProperty::value_
std::string value_
Definition: gtest.h:491
testing::Test::TearDownTestCase
static void TearDownTestCase()
Definition: gtest.h:373
testing::EmptyTestEventListener::OnTestPartResult
virtual void OnTestPartResult(const TestPartResult &)
Definition: gtest.h:1021
testing::TestInfo::name
const char * name() const
Definition: gtest.h:631
testing::AssertionResult::operator<<
AssertionResult & operator<<(const T &value)
Definition: gtest.h:282
testing::internal::AssertHelper::AssertHelperData::message
const std::string message
Definition: gtest.h:1751
testing::TestProperty::TestProperty
TestProperty(const std::string &a_key, const std::string &a_value)
Definition: gtest.h:468
testing::TestEventListeners::default_result_printer
TestEventListener * default_result_printer() const
Definition: gtest.h:1052
testing::internal::TestEventRepeater
Definition: gtest.cc:2902
testing::UnitTest
Definition: gtest.h:1119
testing::UnitTest::AddEnvironment
Environment * AddEnvironment(Environment *env)
Definition: gtest.cc:3767
gtest-printers.h
testing::TestCase::Failed
bool Failed() const
Definition: gtest.h:806
gtest-message.h
testing::TestCase::test_info_list
const std::vector< TestInfo * > & test_info_list() const
Definition: gtest.h:827
testing::TestCase::type_param_
const internal::scoped_ptr< const ::std::string > type_param_
Definition: gtest.h:902
testing::EmptyTestEventListener::OnTestIterationEnd
virtual void OnTestIterationEnd(const UnitTest &, int)
Definition: gtest.h:1026
testing::IsSubstring
GTEST_API_ AssertionResult IsSubstring(const char *needle_expr, const char *haystack_expr, const char *needle, const char *haystack)
Definition: gtest.cc:1286
testing::Test::Setup_should_be_spelled_SetUp
Definition: gtest.h:450
testing::internal::StringStreamToString
GTEST_API_ std::string StringStreamToString(::std::stringstream *stream)
Definition: gtest.cc:1662
testing::TestEventListener::OnEnvironmentsSetUpStart
virtual void OnEnvironmentsSetUpStart(const UnitTest &unit_test)=0
testing::TestEventListeners::default_result_printer_
TestEventListener * default_result_printer_
Definition: gtest.h:1101
testing::AssertionResult::AppendMessage
void AppendMessage(const Message &a_message)
Definition: gtest.h:297
testing::IsNotSubstring
GTEST_API_ AssertionResult IsNotSubstring(const char *needle_expr, const char *haystack_expr, const char *needle, const char *haystack)
Definition: gtest.cc:1298
testing::UnitTest::GetInstance
static UnitTest * GetInstance()
Definition: gtest.cc:3644
testing::TestCase::set_up_tc_
Test::SetUpTestCaseFunc set_up_tc_
Definition: gtest.h:911
testing::EmptyTestEventListener
Definition: gtest.h:1012
testing::TestResult::Passed
bool Passed() const
Definition: gtest.h:516
testing::EmptyTestEventListener::OnTestStart
virtual void OnTestStart(const TestInfo &)
Definition: gtest.h:1020
GTEST_MUST_USE_RESULT_
#define GTEST_MUST_USE_RESULT_
Definition: gtest-port.h:741
GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
#define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType)
Definition: gtest.h:1374
GTEST_DISALLOW_COPY_AND_ASSIGN_
#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)
Definition: gtest-port.h:729
testing::TestEventListener::OnTestIterationStart
virtual void OnTestIterationStart(const UnitTest &unit_test, int iteration)=0
testing::TestResult::test_properties_
std::vector< TestProperty > test_properties_
Definition: gtest.h:600
testing::TestCase::ad_hoc_test_result
const TestResult & ad_hoc_test_result() const
Definition: gtest.h:817
testing::Environment::Setup_should_be_spelled_SetUp
Definition: gtest.h:953
testing::TestCase::should_run
bool should_run() const
Definition: gtest.h:779
testing::TestEventListener::OnTestCaseEnd
virtual void OnTestCaseEnd(const TestCase &test_case)=0
testing::TestResult::Failed
bool Failed() const
Definition: gtest.cc:1850
testing::internal::EqHelper::Compare
static AssertionResult Compare(const char *expected_expression, const char *actual_expression, BiggestInt expected, BiggestInt actual)
Definition: gtest.h:1494
testing::TestCase::ClearResult
void ClearResult()
Definition: gtest.cc:2460
testing::FloatLE
GTEST_API_ AssertionResult FloatLE(const char *expr1, const char *expr2, float val1, float val2)
Definition: gtest.cc:1101
testing::TestCase::ad_hoc_test_result_
TestResult ad_hoc_test_result_
Definition: gtest.h:920
line
static char * line
Definition: svm.cpp:2902
testing::TestResult::Clear
void Clear()
Definition: gtest.cc:1842
testing::TestEventListener::OnTestStart
virtual void OnTestStart(const TestInfo &test_info)=0
testing::internal::ScopedTrace
Definition: gtest-internal.h:156
testing::EmptyTestEventListener::OnTestEnd
virtual void OnTestEnd(const TestInfo &)
Definition: gtest.h:1022
testing::TestResult::elapsed_time_
TimeInMillis elapsed_time_
Definition: gtest.h:604
testing::TestResult::test_properites_mutex_
internal::Mutex test_properites_mutex_
Definition: gtest.h:595
testing::TestProperty::value
const char * value() const
Definition: gtest.h:478
testing::internal::EqHelper::Compare
static AssertionResult Compare(const char *expected_expression, const char *actual_expression, const T1 &expected, const T2 &actual)
Definition: gtest.h:1480
testing::internal::EqHelper< true >::Compare
static AssertionResult Compare(const char *expected_expression, const char *actual_expression, const T1 &expected, const T2 &actual, typename EnableIf<!is_pointer< T2 >::value >::type *=0)
Definition: gtest.h:1513
testing::TestCase::tear_down_tc_
Test::TearDownTestCaseFunc tear_down_tc_
Definition: gtest.h:913
testing::AddGlobalTestEnvironment
Environment * AddGlobalTestEnvironment(Environment *env)
Definition: gtest.h:1318
testing::TestResult::death_test_count_
int death_test_count_
Definition: gtest.h:602
gtest-test-part.h
testing::Test::Setup
virtual Setup_should_be_spelled_SetUp * Setup()
Definition: gtest.h:451
testing::TestCase::test_info_list_
std::vector< TestInfo * > test_info_list_
Definition: gtest.h:905
testing::TestCase::set_should_run
void set_should_run(bool should)
Definition: gtest.h:836
testing::AssertionResult::message
const char * message() const
Definition: gtest.h:274
testing::TestEventListener::OnTestProgramEnd
virtual void OnTestProgramEnd(const UnitTest &unit_test)=0
testing::TestEventListener::OnTestIterationEnd
virtual void OnTestIterationEnd(const UnitTest &unit_test, int iteration)=0
testing::DoubleLE
GTEST_API_ AssertionResult DoubleLE(const char *expr1, const char *expr2, double val1, double val2)
Definition: gtest.cc:1108
testing::internal::TraceInfo
Definition: gtest-internal-inl.h:466
GTEST_IMPL_FORMAT_C_STRING_AS_STRING_
#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType)
Definition: gtest.h:1393
testing::internal::TestFactoryBase
Definition: gtest-internal.h:434
testing::internal::ReportFailureInUnknownLocation
void ReportFailureInUnknownLocation(TestPartResult::Type result_type, const std::string &message)
Definition: gtest.cc:1929
testing::internal::scoped_ptr< ::std::string >
testing::TestEventListener
Definition: gtest.h:959
testing::Environment::Setup
virtual Setup_should_be_spelled_SetUp * Setup()
Definition: gtest.h:954
testing::PrintToString
::std::string PrintToString(const T &value)
Definition: gtest-printers.h:850
testing::internal::FormatForComparison< ToPrint[N], OtherOperand >::Format
::std::string Format(const ToPrint *value)
Definition: gtest.h:1366


fcl
Author(s):
autogenerated on Wed Feb 17 2021 03:40:07