Lines Matching defs:Test
32 // The Google C++ Testing Framework (Google Test)
34 // This header file defines the public API for Google Test. It should be
35 // included by any test program that uses Google Test.
47 // Acknowledgment: Google Test borrowed the idea of automatic test
89 // The Google C++ Testing Framework (Google Test)
92 // Google Test. They are subject to change without notice.
128 // Low-level types and utilities for porting Google Test to various
132 // This file is fundamental to Google Test. All other Google Test source
134 // any other Google Test header.
140 // control Google Test's behavior. If the user doesn't define a macro
141 // in this list, Google Test will define it.
160 // std::wstring does/doesn't work (Google Test can
172 // Test's own tr1 tuple implementation should be
175 // GTEST_LANG_CXX11 - Define it to 1/0 to indicate that Google Test
179 // Google Test as a shared library (known as
182 // - Define to 1 when compiling Google Test itself
209 // most stable support. Since core members of the Google Test project
217 // Macros indicating available Google Test features (defined to 1 if
245 // and Google Test is thread-safe; or 0 otherwise.
315 #define GTEST_NAME_ "Google Test"
325 // Determines the platform on which Google Test is compiled.
400 // Defines this to true iff Google Test can use POSIX regular expressions.
473 # error "Google Test cannot be used where ::std::string isn't available."
568 // Determines whether Google Test can use the pthreads library.
573 // To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
588 // Determines whether Google Test can use tr1/tuple. You can define
589 // this macro to 0 to prevent Google Test from using tuple (any
601 // Determines whether Google Test's own tr1 tuple implementation
677 // Implements a subset of TR1 tuple needed by Google Test and Google Mock.
754 // Anything in namespace gtest_internal is Google Test's INTERNAL
1736 // Determines whether to support stream redirection. This is used to test
1749 // Google Test does not support death tests for VC 7.1 and earlier as
1788 // Determines whether test results can be streamed to a socket.
1898 // A secret type that Google Test users don't know about. It has no
1995 // enough stuff to satisfy Google Test's need.
2085 // We use a const char* instead of an std::string, as Google Test used to be
2216 // instead. Thus, it's important to test in debug mode to make sure
2230 // Ensures that To is a sub-type of From *. This test is here only
2293 // testing Google Test's own constructs. Don't use it in user tests,
2307 // This class is only for testing Google Test's own constructs. Do not
2326 // Blocks until the controller thread notifies. Must be called from a test
2368 // Helper class for testing Google Test's multi-threading constructs.
2378 // These classes are only for testing Google Test's own constructs. Do
2575 // Google Test only uses global ThreadLocal objects. That means they
2577 // object managed by Google Test will be leaked as long as all threads
2578 // using Google Test have exited when main() returns.
2648 // and thread-local variable). Necessary for compiling Google Test where
2649 // mutex is not supported - using Google Test in multiple threads is not
2686 // Therefore Google Test is not thread-safe.
2919 // several places in Google Test. This implementation provides a reasonable
2967 // Google Test uses this class in the implementation of floating-point
2970 // For now it only handles UInt (unsigned int) as that's all Google Test
3046 // corresponding to the given Google Test flag.
3105 // The Google C++ Testing Framework (Google Test)
3194 // namespace which Google Test's Message class is in.
3197 // defined in the global namespace) to be used in Google Test
3354 // The Google C++ Testing Framework (Google Test)
3357 // Google Test. They are subject to change without notice. They should not used
3358 // by code external to Google Test.
3520 // Google Test filepath utilities
3523 // Google Test. They are subject to change without notice.
3570 // Given directory = "dir", base_name = "test", number = 0,
3571 // extension = "xml", returns "dir/test.xml". If number is greater
3579 // Given directory = "dir", relative_path = "test.xml",
3580 // returns "dir/test.xml".
3733 // type-parameterized tests in one type-parameterized test case.
3754 // the typed-test-only section below.
4417 // user would write Types<T1, ..., TN>, and Google Test will translate
6125 // user would write Templates<T1, ..., TN>, and Google Test will translate
7046 class Test; // Represents a test.
7047 class TestInfo; // Information about a test.
7048 class TestPartResult; // Result of a test part.
7049 class UnitTest; // A collection of test cases.
7071 // different sizes, so we can use sizeof() to test which version is
7097 // Appends the user-supplied message to the Google-Test-generated message.
7103 // This exception is thrown by (and only by) a failed Google Test
7120 // a trace stack maintained by Google Test.
7247 // This function is needed to test the AlmostEquals() method.
7355 // test fixture classes in the same test case, we need to assign
7386 // Returns the type ID of ::testing::Test. Always call this instead
7387 // of GetTypeId< ::testing::Test>() to get the type ID of
7388 // ::testing::Test, as the latter may give the wrong result due to a
7389 // suspected linker bug when compiling Google Test as a Mac OS X
7394 // of a Test object.
7399 // Creates a test instance to run. The instance is both created and destroyed
7401 virtual Test* CreateTest() = 0;
7411 TEST and TEST_F macros.
7415 virtual Test* CreateTest() { return new TestClass; }
7435 // Creates a new TestInfo object and registers it with Google Test;
7440 // test_case_name: name of the test case
7441 // name: name of the test
7442 // type_param the name of the test's type parameter, or NULL if
7443 // this is not a typed or a type-parameterized test.
7444 // value_param text representation of the test's value parameter,
7445 // or NULL if this is not a type-parameterized test.
7446 // fixture_class_id: ID of the test fixture class
7447 // set_up_tc: pointer to the function that sets up the test case
7448 // tear_down_tc: pointer to the function that tears down the test case
7449 // factory: pointer to the factory that creates a test object.
7469 // State of the definition of a type-parameterized test case.
7474 // Adds the given test name to defined_test_names_ and return true
7475 // if the test case hasn't been registered; otherwise aborts the
7480 fprintf(stderr, "%s Test %s must be defined before "
7490 // Verifies that registered_tests match the test names in
7520 // registers a list of type-parameterized tests with Google Test. The
7529 // 'index' is the index of the test in the type list 'Types'
7539 // First, registers the first type-parameterized test in the type
7570 // Test. The return value is insignificant - we just need to return
7579 // First, register the first test in 'Test' for each type in 'Types'.
7583 // Next, recurses (at compile time) with the tail of the test list.
8066 // Implements Boolean test assertions such as EXPECT_TRUE. expression can be
8092 // Expands to the name of the class that implements the given test.
8151 // The Google C++ Testing Framework (Google Test)
8191 // The Google C++ Testing Framework (Google Test)
8207 // Names of the flags (needed for parsing Google Test flags).
8216 // returns a concrete class that depends on the prevailing death test
8230 // appropriate action to take for the current death test; for example,
8233 // case. Otherwise, the DeathTest pointer pointed to by the "test"
8234 // argument is set. If the death test should be skipped, the pointer
8236 // DeathTest object that controls the execution of the current test.
8238 const char* file, int line, DeathTest** test);
8242 // A helper class that aborts a death test when it's deleted.
8245 explicit ReturnSentinel(DeathTest* test) : test_(test) { }
8253 // test is encountered. EXECUTE means that the death test logic should
8256 // test, then wait for it to complete.
8259 // An enumeration of the three reasons that a test might be aborted.
8269 // Waits for the death test to finish and returns its status.
8272 // Returns true if the death test passed; that is, the test process
8273 // exited during the test, its exit status matches a user-supplied
8281 // Signals that the death test did not die as expected.
8285 // the last death test.
8291 // A string containing a description of the outcome of the last death test.
8302 const char* file, int line, DeathTest** test) = 0;
8309 const char* file, int line, DeathTest** test);
8316 // Traps C++ exceptions escaping statement and reports them as test
8326 "death test statement. Exception message: %s\n", \
8433 // compile on a death-test supporting system.
8436 // statement - A statement that a macro such as EXPECT_DEATH would test
8441 // regex - A regex that a macro such as EXPECT_DEATH would use to test
8482 // meaning that the death test child process will re-execute the test binary
8483 // from the start, running only a single death test, or "fast",
8484 // meaning that the child process will execute the test logic immediately
8493 // executing in the context of the death test child process. Tools such as
8511 // test in it; the sub-process exits with code 0 at the end of the
8512 // death test, if it hasn't exited already.
8542 // syntax implemented as part of Google Test. This limited
8584 // death test, which already incurs significant overhead by launching
8589 // A "threadsafe" style death test obtains the path to the test
8593 // invoke the test program via a path that contains at least one
8596 // is rarely a problem as people usually don't put the test binary
8608 // test case, if any:
8619 // test case, if any:
8654 // In practice, this can be used to test functions that utilize the
8665 // TEST(TestCase, TestDieOr12WorksInDgbAndOpt) {
8682 // need to test that a function has appropriate side-effects in opt
8714 // useful when you are combining death test assertions with normal test
8715 // assertions in one test.
8732 // pump.py gtest-param-test.h.pump
8767 // in Google C++ Testing Framework (Google Test)
8775 // Value-parameterized tests allow you to test your code with different
8776 // parameters without writing multiple copies of the same test.
8786 // TestWithParam<T> is itself derived from testing::Test. T can be any
8799 // Inside a test, access the test parameter with the GetParam() method
8809 // Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test
8810 // case with any set of parameters you want. Google Test defines a number
8811 // of functions for generating test parameters. They return what we call
8830 // The following statement will instantiate tests from the FooTest test case
8840 // actual test case name. Remember to pick unique prefixes for different
8867 // in the given test case, whether their definitions come before or
8874 // give the user a chance to inspect the generated tests with Google Test
8885 // A parameterized test fixture must be derived from testing::Test and from
8888 // TestWithParam<T> inherits from both Test and WithParamInterface. In more
8890 // separately from Test and WithParamInterface. For example:
8892 class BaseTest : public ::testing::Test {
8893 // You can inherit all the usual members for a non-parameterized test
8898 // The usual test fixture members go here too.
8902 // This is an ordinary non-parameterized test.
9226 // Google Test - The Google C++ Testing Framework
10057 // fixture class for the same test case. This may happen when
10358 virtual Test* CreateTest() {
10372 // test factories for passing into MakeAndRegisterTestInfo function.
10383 // TestMetaFactory creates test factories for passing into
10385 // ownership of test factory pointer, same factory object cannot be passed
10387 // it for each Test/Parameter value combination. Thus it needs meta factory
10409 // accumulates test information provided by TEST_P macro invocations
10411 // and uses that information to register all resulting test instances
10419 // Base part of test case name for display purposes.
10421 // Test case id to verify identity.
10424 // test case right before running them in RUN_ALL_TESTS macro.
10439 // macro invocations for a particular test case and generators
10441 // test case. It registers tests with all values generated by all
10456 // Test case base name for display purposes.
10458 // Test case id to verify identity.
10461 // about a single test in a LocalTestInfo structure.
10462 // test_case_name is the base name of the test case (without invocation
10463 // prefix). test_base_name is the name of an individual test without
10464 // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
10465 // test case base name and DoBar is test base name.
10482 // UnitTest class invokes this method to register tests in this test case
10483 // test cases right before running tests in RUN_ALL_TESTS macro.
10523 // LocalTestInfo structure keeps information about a single test registered
10553 // classes accessed by test case names. TEST_P and INSTANTIATE_TEST_CASE_P
10567 // tests and instantiations of a particular test case.
10578 // Complain about incorrect usage of Google Test facilities
10580 // test case setup and tear-down in this case.
10658 // Currently Google Test supports at most 50 arguments in Values,
10677 // include/gtest/gtest-param-test.h.
15768 // Google Test uses these generators to produce parameters for value-
15769 // parameterized tests. When a parameterized test case is instantiated
15770 // with a particular generator, Google Test creates and runs tests
15773 // In the following sample, tests from test case FooTest are instantiated
15839 // This instantiates tests from test case StringTest
15845 // This instantiates tests from test case StlStringTest
15902 // For example, this instantiates tests from test case BarTest each
15907 // This instantiates tests from test case BazTest each with values 1, 2, 3.5.
16777 // In the following example all tests in the test case FlagDependentTest
16805 // Test.
16809 // This will instantiate tests in test case AnimalTest each one with
16835 // // Test your code using external_flag_1 and external_flag_2 here.
17025 // When you need to test the private or protected members of a class,
17035 // class MyClassTest : public testing::Test {
17087 // A copyable object representing the result of a test part (i.e. an
17093 // The possible outcomes of a test part (i.e. an assertion or an
17097 kNonFatalFailure, // Failed but the test can continue.
17098 kFatalFailure // Failed and the test should be terminated.
17115 // Gets the outcome of the test part.
17118 // Gets the name of the source file where the test part took place, or
17124 // Gets the line in the source file where the test part took place,
17131 // Gets the message associated with the test part.
17134 // Returns true iff the test part passed.
17137 // Returns true iff the test part failed.
17140 // Returns true iff the test part non-fatally failed.
17143 // Returns true iff the test part fatally failed.
17153 // The name of the source file where the test part took place, or
17156 // The line in the source file where the test part took place, or -1
17159 std::string summary_; // The test failure summary.
17160 std::string message_; // The test failure message.
17189 // This interface knows how to report a test part result.
17201 // current test part result reporter. Besides checking if fatal failures were
17260 // Typed (aka type-driven) tests repeat the same test for types in a
17261 // list. You must know which types you want to test with when writing
17267 // by a type. Remember to derive it from testing::Test.
17269 class FooTest : public testing::Test {
17277 // Next, associate a list of types with the test case, which will be
17288 // tests for this test case as you want.
17290 // Inside a test, refer to TypeParam to get the type parameter.
17310 // Type-parameterized tests are abstract test patterns parameterized
17312 // allow you to define the test pattern without knowing what the type
17320 // each implementation can easily instantiate the test suite to verify
17327 // by a type. Remember to derive it from testing::Test.
17329 class FooTest : public testing::Test {
17333 // Next, declare that you will define a type-parameterized test case
17339 // for this type-parameterized test case as you want.
17341 // Inside a test, refer to TypeParam to get the type parameter.
17348 // Now the tricky part: you need to register all test patterns before
17350 // test case name; the rest are the names of the tests in this test
17361 // to the actual test case name. Remember to pick unique prefixes for
17380 // given test case.
17418 // the given type-parameterized test case are defined in. The exact
17426 // the defined tests in the given test case.
17433 // the registered tests in the given test case.
17437 // The variables defined in the type-parameterized test macros are
17507 // This flag controls whether Google Test catches all test-thrown exceptions
17513 // to let Google Test decide.
17520 // This flag causes the Google Test to list tests. None of the tests listed
17524 // This flag controls whether Google Test emits a detailed XML report to a file
17528 // This flags control whether Google Test prints the elapsed time for each
17529 // test.
17539 // This flag controls whether Google Test includes Google Test internal
17556 // platforms test results are streamed to the specified port on
17586 class Test;
17599 // 1. Defining predicate functions to be used with Boolean test assertions
17684 // Returns the text streamed into this AssertionResult. Test assertions
17722 // with test assertions.
17740 // In Google Test, a unit test program contains one or many TestCases, and
17743 // When you define a test using the TEST macro, you don't need to
17744 // explicitly derive from Test - the TEST macro automatically does
17747 // The only time you derive from Test is when defining a test fixture
17750 // class FooTest : public testing::Test {
17760 // Test is not copyable.
17761 class GTEST_API_ Test {
17766 // a test case.
17770 // The d'tor is virtual as we intend to inherit from Test.
17771 virtual ~Test();
17773 // Sets up the stuff shared by all tests in this test case.
17775 // Google Test will call Foo::SetUpTestCase() before running the first
17776 // test in test case Foo. Hence a sub-class can define its own
17781 // Tears down the stuff shared by all tests in this test case.
17783 // Google Test will call Foo::TearDownTestCase() after running the last
17784 // test in test case Foo. Hence a sub-class can define its own
17789 // Returns true iff the current test has a fatal failure.
17792 // Returns true iff the current test has a non-fatal failure.
17795 // Returns true iff the current test has a (either fatal or
17799 // Logs a property for the current test, test case, or for the entire
17800 // invocation of the test program when used outside of the context of a
17801 // test case. Only the last value for a given key is remembered. These
17803 // not members of the test fixture. Calls to RecordProperty made during
17804 // lifespan of the test (from the moment its constructor starts to the
17811 // Test) will be output as attributes of the <testsuites> element.
17816 // Creates a Test object.
17817 Test();
17819 // Sets up the test fixture.
17822 // Tears down the test fixture.
17826 // Returns true iff the current test has the same fixture class as
17827 // the first test in the current test case.
17830 // Runs the test after the test fixture has been set up.
17832 // A sub-class must implement this to define the test logic.
17835 // Instead, use the TEST or TEST_F macro.
17838 // Sets up, executes, and tears down the test.
17845 // Uses a GTestFlagSaver to save and restore all Google Test flags.
17849 // wondering why it is never called by Google Test. The declaration of
17854 // will be a conflict if a user declares void Setup() in his test
17858 // if a user calls it from his test fixture.
17868 GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
17873 // A copyable object representing a user specified test property which can be
17908 // The result of a single Test. This includes a list of
17910 // death tests there are in the Test, and how much time it took to run
17911 // the Test.
17922 // Gets the number of all test parts. This is the sum of the number
17923 // of successful test parts and the number of failed test parts.
17926 // Returns the number of the test properties.
17929 // Returns true iff the test passed (i.e. no test part failed).
17932 // Returns true iff the test failed.
17935 // Returns true iff the test fatally failed.
17938 // Returns true iff the test has a non-fatal failure.
17944 // Returns the i-th test part result among all the results. i can range
17949 // Returns the i-th test property. i can range from 0 to
17977 // Adds a test property to the list. The property is validated and may add
17986 // Adds a failure if the key is a reserved attribute of Google Test
17992 // Adds a test part result to the list.
17995 // Returns the death test count.
17998 // Increments the death test count, returning the new count.
18001 // Clears the test part results.
18024 // A TestInfo object stores the following information about a test:
18026 // Test case name
18027 // Test name
18028 // Whether the test should be run
18029 // A function pointer that creates the test object when invoked
18030 // Test result
18041 // Returns the test case name.
18044 // Returns the test name.
18048 // or a type-parameterized test.
18056 // is not a value-parameterized test.
18063 // Returns true if this test should run, that is if the test is not
18067 // Google Test allows the user to filter the tests by their full names.
18068 // The full name of a test Bar in test case Foo is defined as
18073 // negative patterns (tests to exclude). A test is run if it
18081 // Returns true iff this test will appear in the XML report.
18089 // Returns the result of the test.
18096 friend class Test;
18106 Test::SetUpTestCaseFunc set_up_tc,
18107 Test::TearDownTestCaseFunc tear_down_tc,
18114 const char* a_type_param, // NULL if not a type-parameterized test
18115 const char* a_value_param, // NULL if not a value-parameterized test
18119 // Increments the number of death tests encountered in this test so
18125 // Creates the test object, runs it, records its result, and then
18133 // These fields are immutable properties of the test.
18134 const std::string test_case_name_; // Test case name
18135 const std::string name_; // Test name
18137 // type-parameterized test.
18140 // value-parameterized test.
18142 const internal::TypeId fixture_class_id_; // ID of the test fixture class
18143 bool should_run_; // True iff this test should run
18144 bool is_disabled_; // True iff this test is disabled
18145 test matches the
18148 // the test object
18151 // test for the second time.
18157 // A test case, which consists of a vector of TestInfos.
18169 // name: name of the test case
18170 // a_type_param: the name of the test's type parameter, or NULL if
18171 // this is not a type-parameterized test.
18172 // set_up_tc: pointer to the function that sets up the test case
18173 // tear_down_tc: pointer to the function that tears down the test case
18175 Test::SetUpTestCaseFunc set_up_tc,
18176 Test::TearDownTestCaseFunc tear_down_tc);
18185 // type-parameterized test case.
18192 // Returns true if any test in this test case should run.
18195 // Gets the number of successful tests in this test case.
18198 // Gets the number of failed tests in this test case.
18204 // Gets the number of disabled tests in this test case.
18210 // Get the number of tests in this test case that should run.
18213 // Gets the number of all tests in this test case.
18216 // Returns true iff the test case passed.
18219 // Returns true iff the test case failed.
18225 // Returns the i-th test among all the tests. i can range from 0 to
18229 // Returns the TestResult that holds test properties recorded during
18234 friend class Test;
18245 // Returns the i-th test among all the tests. i can range from 0 to
18252 // Adds a TestInfo to this test case. Will delete the TestInfo upon
18256 // Clears the results of all tests in this test case.
18259 // Clears the results of all tests in the given test case.
18264 // Runs every test in this TestCase.
18275 // Returns true iff test passed.
18280 // Returns true iff test failed.
18285 // Returns true iff the test is disabled and will be reported in the XML
18291 // Returns true iff test is disabled.
18296 // Returns true iff this test will appear in the XML report.
18301 // Returns true if the given test should run.
18306 // Shuffles the tests in this test case.
18309 // Restores the test order to before the first shuffle.
18312 // Name of the test case.
18315 // type-parameterized test.
18320 // Provides a level of indirection for the test list to allow easy
18321 // shuffling and restoring the test order. The i-th element in this
18322 // vector is the index of the i-th test in the shuffled test list.
18324 // Pointer to the function that sets up the test case.
18325 Test::SetUpTestCaseFunc set_up_tc_;
18326 // Pointer to the function that tears down the test case.
18327 Test::TearDownTestCaseFunc tear_down_tc_;
18328 // True iff any test in this test case should run.
18332 // Holds test properties recorded during execution of SetUpTestCase and
18349 // as in some cases Google Test is used where exceptions are enabled, and
18377 // Fired before any test activity starts.
18392 // Fired before the test case starts.
18395 // Fired before the test starts.
18401 // Fired after the test ends.
18404 // Fired after the test case ends.
18417 // Fired after all test activities have ended.
18445 // TestEventListeners lets users add listeners to track events in Google Test.
18451 // Appends an event listener to the end of the list. Google Test assumes
18453 // the test program finishes).
18548 // Returns the working directory when the first TEST() or TEST_F()
18552 // Returns the TestCase object for the test that's currently running,
18553 // or NULL if no test is running.
18557 // Returns the TestInfo object for the test that's currently running,
18558 // or NULL if no test is running.
18562 // Returns the random seed used at the start of the current test run.
18574 // Gets the number of successful test cases.
18577 // Gets the number of failed test cases.
18580 // Gets the number of all test cases.
18583 // Gets the number of all test cases that contain at least one test
18608 // Gets the time of the test program start, in ms from the start of the
18615 // Returns true iff the unit test passed (i.e. all test cases passed).
18618 // Returns true iff the unit test failed (i.e. some test case failed
18622 // Gets the i-th test case among all the test cases. i can range from 0 to
18626 // Returns the TestResult containing information on test failures and
18627 // properties logged outside of individual test cases.
18631 // inside Google Test.
18635 // Registers and returns a global test environment. When a test
18636 // program is run, all global test environments will be set-up in
18638 // have finished, all global test environments will be torn-down in
18647 // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc)
18658 // inside a test, to current TestCase's ad_hoc_test_result_ when invoked
18664 // Gets the i-th test case among all the test cases. i can range from 0 to
18674 friend class Test;
18692 // Google Test trace stack.
18696 // Pops a trace from the per-thread Google Test trace stack.
18714 // A convenient wrapper for adding an environment for the test
18736 // Initializes Google Test. This must be called before calling
18738 // flags that Google Test recognizes. Whenever a Google Test flag is
18741 // No value is returned. Instead, the Google Test flag variables are
19180 // A value-parameterized class must inherit from both ::testing::Test and
19182 // from ::testing::TestWithParam, but more complicated test hierarchies
19183 // may need to inherit from Test and WithParamInterface at different levels.
19185 // This interface has support for accessing the test parameter value via
19219 // The current parameter value. Is also available in the test fixture's
19222 // like writing 'WithParamInterface<bool>::GetParam()' for a test that
19226 << "GetParam() can only be called inside a value-parameterized test "
19233 // remains alive and unchanged throughout the current test.
19238 // Static value used for accessing parameter during a test lifetime.
19241 // TestClass must be a subclass of WithParamInterface<T> and Test.
19252 class TestWithParam : public Test, public WithParamInterface<T> {
19257 // Macros for indicating success/failure in test code.
19259 // ADD_FAILURE unconditionally adds a failure to the current test.
19261 // current test successful, as a test is only successful when it has
19711 // When they are not, Google Test prints both the tested expressions and
19848 // Google Test uses ULP-based comparison to automatically pick a default
19892 // Macros that test for HRESULT failure and success, these are only useful
19897 // When expr unexpectedly fails or succeeds, Google Test prints the
19931 // number, and the given message) to be included in every test failure
19981 // Defines a test.
19983 // The first parameter is the name of the test case, and the second
19984 // parameter is the name of the test within the test case.
19986 // The convention is to end the test case name with "Test". For
19987 // example, a test case for the Foo class can be named FooTest.
19989 // The user should put his test code between braces after using this
19992 // TEST(FooTest, InitializesCorrectly) {
19998 // ::testing::Test>() here to get the type ID of testing::Test. This
19999 // is to work around a suspected linker bug when using Google Test as
20001 // ::testing::Test>() to return different values depending on whether
20002 // the call is from the Google Test framework itself or from user test
20004 // value, as it always calls GetTypeId<>() from the Google Test
20008 ::testing::Test, ::testing::internal::GetTestTypeId())
20010 // Define this macro to 1 to omit the definition of TEST(), which
20013 # define TEST(test_case_name, test_name) GTEST_TEST(test_case_name, test_name)
20016 // Defines a test that uses a test fixture.
20018 // The first parameter is the name of the test fixture class, which
20019 // also doubles as the test case name. The second parameter is the
20020 // name of the test within the test case.
20022 // A test fixture class must be declared earlier. The user should put
20023 // his test code between braces after using this macro. Example:
20025 // class FooTest : public testing::Test {
