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