Line data Source code
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 :
58 : #include "gtest/internal/gtest-internal.h"
59 : #include "gtest/internal/gtest-string.h"
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();
164 : void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
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 : //
256 312522 : class GTEST_API_ AssertionResult {
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 312775 : explicit AssertionResult(bool success) : success_(success) {}
263 :
264 : // Returns true iff the assertion succeeded.
265 312786 : 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 0 : const char* message() const {
275 0 : 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 0 : const char* failure_message() const { return message(); }
280 :
281 : // Streams a custom failure message into this object.
282 0 : template <typename T> AssertionResult& operator<<(const T& value) {
283 0 : AppendMessage(Message() << value);
284 0 : return *this;
285 : }
286 :
287 : // Allows streaming basic output manipulators such as endl or flush into
288 : // this object.
289 : AssertionResult& operator<<(
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 0 : void AppendMessage(const Message& a_message) {
298 0 : if (message_.get() == NULL)
299 0 : message_.reset(new ::std::string);
300 0 : message_->append(a_message.GetString().c_str());
301 0 : }
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.
309 : internal::scoped_ptr< ::std::string> message_;
310 :
311 : GTEST_DISALLOW_ASSIGN_(AssertionResult);
312 : };
313 :
314 : // Makes a successful assertion result.
315 : GTEST_API_ AssertionResult AssertionSuccess();
316 :
317 : // Makes a failed assertion result.
318 : GTEST_API_ AssertionResult AssertionFailure();
319 :
320 : // Makes a failed assertion result with the given failure message.
321 : // Deprecated; use AssertionFailure() << msg.
322 : GTEST_API_ AssertionResult AssertionFailure(const Message& 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.
347 : class GTEST_API_ Test {
348 : public:
349 : friend class TestInfo;
350 :
351 : // Defines types for pointers to functions that set up and tear down
352 : // a test case.
353 : typedef internal::SetUpTestCaseFunc SetUpTestCaseFunc;
354 : typedef internal::TearDownTestCaseFunc TearDownTestCaseFunc;
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 22 : 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 22 : 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.
432 : const internal::GTestFlagSaver* const gtest_flag_saver_;
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().
450 : struct Setup_should_be_spelled_SetUp {};
451 0 : virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
452 :
453 : // We disallow copying Tests.
454 : GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
455 : };
456 :
457 : typedef internal::TimeInMillis TimeInMillis;
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.
463 : class TestProperty {
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.
489 : std::string key_;
490 : // The value supplied by the user.
491 : std::string value_;
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.
500 : class GTEST_API_ TestResult {
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;
544 : friend class internal::DefaultGlobalTestPartResultReporter;
545 : friend class internal::ExecDeathTest;
546 : friend class internal::TestResultAccessor;
547 : friend class internal::UnitTestImpl;
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.
595 : internal::Mutex test_properites_mutex_;
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.
602 : int death_test_count_;
603 : // The elapsed time, in milliseconds.
604 : TimeInMillis elapsed_time_;
605 :
606 : // We disallow copying TestResult.
607 : GTEST_DISALLOW_COPY_AND_ASSIGN_(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.
621 : class GTEST_API_ TestInfo {
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;
684 : friend class internal::UnitTestImpl;
685 : friend class internal::StreamingListenerTest;
686 : friend TestInfo* internal::MakeAndRegisterTestInfo(
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.
707 : int increment_death_test_count() {
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.
724 : const internal::scoped_ptr<const ::std::string> type_param_;
725 : // Text representation of the value parameter, or NULL if this is not a
726 : // value-parameterized test.
727 : const internal::scoped_ptr<const ::std::string> value_param_;
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.
738 : TestResult result_;
739 :
740 : GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
741 : };
742 :
743 : // A test case, which consists of a vector of TestInfos.
744 : //
745 : // TestCase is not copyable.
746 : class GTEST_API_ TestCase {
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;
821 : friend class internal::UnitTestImpl;
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.
899 : std::string name_;
900 : // Name of the parameter type, or NULL if this is not a typed or a
901 : // type-parameterized test.
902 : const internal::scoped_ptr<const ::std::string> type_param_;
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.
911 : Test::SetUpTestCaseFunc set_up_tc_;
912 : // Pointer to the function that tears down the test case.
913 : Test::TearDownTestCaseFunc tear_down_tc_;
914 : // True iff any test in this test case should run.
915 : bool should_run_;
916 : // Elapsed time, in milliseconds.
917 : TimeInMillis elapsed_time_;
918 : // Holds test properties recorded during execution of SetUpTestCase and
919 : // TearDownTestCase.
920 : TestResult ad_hoc_test_result_;
921 :
922 : // We disallow copying TestCases.
923 : GTEST_DISALLOW_COPY_AND_ASSIGN_(TestCase);
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().
953 : struct Setup_should_be_spelled_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.
959 : class TestEventListener {
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.
1012 : class EmptyTestEventListener : public TestEventListener {
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.
1032 : class GTEST_API_ TestEventListeners {
1033 : public:
1034 : TestEventListeners();
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.
1052 : TestEventListener* default_result_printer() const {
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.
1063 : TestEventListener* default_xml_generator() const {
1064 : return default_xml_generator_;
1065 : }
1066 :
1067 : private:
1068 : friend class TestCase;
1069 : friend class TestInfo;
1070 : friend class internal::DefaultGlobalTestPartResultReporter;
1071 : friend class internal::NoExecDeathTest;
1072 : friend class internal::TestEventListenersAccessor;
1073 : friend class internal::UnitTestImpl;
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.
1099 : internal::TestEventRepeater* repeater_;
1100 : // Listener responsible for the standard result output.
1101 : TestEventListener* default_result_printer_;
1102 : // Listener responsible for the creation of the XML output file.
1103 : TestEventListener* default_xml_generator_;
1104 :
1105 : // We disallow copying TestEventListeners.
1106 : GTEST_DISALLOW_COPY_AND_ASSIGN_(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.
1119 : class GTEST_API_ UnitTest {
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;
1261 : friend class internal::AssertHelper;
1262 : friend class internal::ScopedTrace;
1263 : friend class internal::StreamingListenerTest;
1264 : friend class internal::UnitTestRecordPropertyTestHelper;
1265 : friend Environment* AddGlobalTestEnvironment(Environment* env);
1266 : friend internal::UnitTestImpl* internal::GetUnitTestImpl();
1267 : friend void internal::ReportFailureInUnknownLocation(
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.
1297 : GTEST_DISALLOW_COPY_AND_ASSIGN_(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).
1318 : inline Environment* AddGlobalTestEnvironment(Environment* env) {
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>
1355 : class FormatForComparison {
1356 : public:
1357 0 : static ::std::string Format(const ToPrint& value) {
1358 0 : return ::testing::PrintToString(value);
1359 : }
1360 : };
1361 :
1362 : // Array.
1363 : template <typename ToPrint, size_t N, typename OtherOperand>
1364 : class FormatForComparison<ToPrint[N], OtherOperand> {
1365 : public:
1366 0 : static ::std::string Format(const ToPrint* value) {
1367 0 : return FormatForComparison<const ToPrint*, OtherOperand>::Format(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 :
1383 : GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
1384 0 : GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
1385 : GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
1386 : GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
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 :
1402 : GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
1403 0 : GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
1404 :
1405 : #if GTEST_HAS_GLOBAL_STRING
1406 : GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::string);
1407 : GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::string);
1408 : #endif
1409 :
1410 : #if GTEST_HAS_GLOBAL_WSTRING
1411 : GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::wstring);
1412 : GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::wstring);
1413 : #endif
1414 :
1415 : #if GTEST_HAS_STD_WSTRING
1416 : GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
1417 : GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::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>
1431 0 : std::string FormatForComparisonFailureMessage(
1432 : const T1& value, const T2& /* other_operand */) {
1433 0 : return FormatForComparison<T1, T2>::Format(value);
1434 : }
1435 :
1436 : // The helper function for {ASSERT|EXPECT}_EQ.
1437 : template <typename T1, typename T2>
1438 101222 : 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 101222 : if (expected == actual) {
1449 101220 : 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 0 : 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 101204 : 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 101204 : 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>
1513 16 : static AssertionResult Compare(
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 16 : 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>
1531 2 : static AssertionResult Compare(
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 2 : 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 9 : GTEST_IMPL_CMP_HELPER_(NE, !=);
1578 : // Implements the helper function for {ASSERT|EXPECT}_LE
1579 7 : GTEST_IMPL_CMP_HELPER_(LE, <=);
1580 : // Implements the helper function for {ASSERT|EXPECT}_LT
1581 1 : GTEST_IMPL_CMP_HELPER_(LT, <);
1582 : // Implements the helper function for {ASSERT|EXPECT}_GE
1583 18 : GTEST_IMPL_CMP_HELPER_(GE, >=);
1584 : // Implements the helper function for {ASSERT|EXPECT}_GT
1585 7 : 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.
1714 : GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
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
1723 : class GTEST_API_ AssertHelper {
1724 : public:
1725 : // Constructor.
1726 : AssertHelper(TestPartResult::Type type,
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.
1741 : struct AssertHelperData {
1742 : AssertHelperData(TestPartResult::Type t,
1743 : const char* srcfile,
1744 : int line_num,
1745 : const char* msg)
1746 : : type(t), file(srcfile), line(line_num), message(msg) { }
1747 :
1748 : TestPartResult::Type const type;
1749 : const char* const file;
1750 : int const line;
1751 : std::string const message;
1752 :
1753 : private:
1754 : GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
1755 : };
1756 :
1757 : AssertHelperData* const data_;
1758 :
1759 : GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
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 110 : class WithParamInterface {
1801 : public:
1802 : typedef T ParamType;
1803 110 : 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 529 : const ParamType& GetParam() const {
1811 529 : GTEST_CHECK_(parameter_ != NULL)
1812 0 : << "GetParam() can only be called inside a value-parameterized test "
1813 : << "-- did you intend to write TEST_P instead of TEST_F?";
1814 529 : 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 110 : static void SetParam(const ParamType* parameter) {
1821 110 : parameter_ = parameter;
1822 110 : }
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 220 : 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>
2205 : bool StaticAssertTypeEq() {
2206 : (void)internal::StaticAssertTypeEqHelper<T1, 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.
2285 : int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
2286 :
2287 20 : inline int RUN_ALL_TESTS() {
2288 20 : return ::testing::UnitTest::GetInstance()->Run();
2289 : }
2290 :
2291 : #endif // GTEST_INCLUDE_GTEST_GTEST_H_
|
