diff options
| author | misterg <misterg@google.com> | 2019-01-11 18:57:36 (GMT) |
|---|---|---|
| committer | Gennadiy Civil <misterg@google.com> | 2019-01-11 18:59:22 (GMT) |
| commit | 0599a7b8410dc5cfdb477900b280475ae775d7f9 (patch) | |
| tree | 4ec1e2f02276fdee489d60e6420561b801d6aa4f /googletest/test | |
| parent | 2edadcedf350b175211642704d1ef5f739a31ca9 (diff) | |
| download | googletest-0599a7b8410dc5cfdb477900b280475ae775d7f9.zip googletest-0599a7b8410dc5cfdb477900b280475ae775d7f9.tar.gz googletest-0599a7b8410dc5cfdb477900b280475ae775d7f9.tar.bz2 | |
Googletest export
Change tests to use new Test Suite API
PiperOrigin-RevId: 228908894
Diffstat (limited to 'googletest/test')
24 files changed, 486 insertions, 494 deletions
diff --git a/googletest/test/googletest-catch-exceptions-test.py b/googletest/test/googletest-catch-exceptions-test.py index 6a4dce2..4e90be7 100755 --- a/googletest/test/googletest-catch-exceptions-test.py +++ b/googletest/test/googletest-catch-exceptions-test.py @@ -89,9 +89,9 @@ if SUPPORTS_SEH_EXCEPTIONS: self.assert_('SEH exception with code 0x2a thrown ' 'in the test fixture\'s destructor' in test_output) - self.assert_('SEH exception with code 0x2a thrown in SetUpTestCase()' + self.assert_('SEH exception with code 0x2a thrown in SetUpTestSuite()' in test_output) - self.assert_('SEH exception with code 0x2a thrown in TearDownTestCase()' + self.assert_('SEH exception with code 0x2a thrown in TearDownTestSuite()' in test_output) self.assert_('SEH exception with code 0x2a thrown in SetUp()' in test_output) @@ -134,29 +134,29 @@ class CatchCxxExceptionsTest(gtest_test_utils.TestCase): '"Standard C++ exception" thrown ' 'in the test fixture\'s destructor' in EX_BINARY_OUTPUT) - self.assert_('CxxExceptionInDestructorTest::TearDownTestCase() ' + self.assert_('CxxExceptionInDestructorTest::TearDownTestSuite() ' 'called as expected.' in EX_BINARY_OUTPUT) def testCatchesCxxExceptionsInSetUpTestCase(self): self.assert_('C++ exception with description "Standard C++ exception"' ' thrown in SetUpTestSuite()' in EX_BINARY_OUTPUT) - self.assert_('CxxExceptionInConstructorTest::TearDownTestCase() ' + self.assert_('CxxExceptionInConstructorTest::TearDownTestSuite() ' 'called as expected.' in EX_BINARY_OUTPUT) - self.assert_('CxxExceptionInSetUpTestCaseTest constructor ' + self.assert_('CxxExceptionInSetUpTestSuiteTest constructor ' 'called as expected.' in EX_BINARY_OUTPUT) - self.assert_('CxxExceptionInSetUpTestCaseTest destructor ' + self.assert_('CxxExceptionInSetUpTestSuiteTest destructor ' 'called as expected.' in EX_BINARY_OUTPUT) - self.assert_('CxxExceptionInSetUpTestCaseTest::SetUp() ' + self.assert_('CxxExceptionInSetUpTestSuiteTest::SetUp() ' 'called as expected.' in EX_BINARY_OUTPUT) - self.assert_('CxxExceptionInSetUpTestCaseTest::TearDown() ' + self.assert_('CxxExceptionInSetUpTestSuiteTest::TearDown() ' 'called as expected.' in EX_BINARY_OUTPUT) - self.assert_('CxxExceptionInSetUpTestCaseTest test body ' + self.assert_('CxxExceptionInSetUpTestSuiteTest test body ' 'called as expected.' in EX_BINARY_OUTPUT) @@ -168,7 +168,7 @@ class CatchCxxExceptionsTest(gtest_test_utils.TestCase): self.assert_('C++ exception with description "Standard C++ exception"' ' thrown in SetUp()' in EX_BINARY_OUTPUT) - self.assert_('CxxExceptionInSetUpTest::TearDownTestCase() ' + self.assert_('CxxExceptionInSetUpTest::TearDownTestSuite() ' 'called as expected.' in EX_BINARY_OUTPUT) self.assert_('CxxExceptionInSetUpTest destructor ' @@ -186,7 +186,7 @@ class CatchCxxExceptionsTest(gtest_test_utils.TestCase): self.assert_('C++ exception with description "Standard C++ exception"' ' thrown in TearDown()' in EX_BINARY_OUTPUT) - self.assert_('CxxExceptionInTearDownTest::TearDownTestCase() ' + self.assert_('CxxExceptionInTearDownTest::TearDownTestSuite() ' 'called as expected.' in EX_BINARY_OUTPUT) self.assert_('CxxExceptionInTearDownTest destructor ' @@ -197,7 +197,7 @@ class CatchCxxExceptionsTest(gtest_test_utils.TestCase): self.assert_('C++ exception with description "Standard C++ exception"' ' thrown in the test body' in EX_BINARY_OUTPUT) - self.assert_('CxxExceptionInTestBodyTest::TearDownTestCase() ' + self.assert_('CxxExceptionInTestBodyTest::TearDownTestSuite() ' 'called as expected.' in EX_BINARY_OUTPUT) self.assert_('CxxExceptionInTestBodyTest destructor ' diff --git a/googletest/test/googletest-catch-exceptions-test_.cc b/googletest/test/googletest-catch-exceptions-test_.cc index 8270f64..8c127d4 100644 --- a/googletest/test/googletest-catch-exceptions-test_.cc +++ b/googletest/test/googletest-catch-exceptions-test_.cc @@ -64,19 +64,20 @@ class SehExceptionInDestructorTest : public Test { TEST_F(SehExceptionInDestructorTest, ThrowsExceptionInDestructor) {} -class SehExceptionInSetUpTestCaseTest : public Test { +class SehExceptionInSetUpTestSuiteTest : public Test { public: - static void SetUpTestCase() { RaiseException(42, 0, 0, NULL); } + static void SetUpTestSuite() { RaiseException(42, 0, 0, NULL); } }; -TEST_F(SehExceptionInSetUpTestCaseTest, ThrowsExceptionInSetUpTestCase) {} +TEST_F(SehExceptionInSetUpTestSuiteTest, ThrowsExceptionInSetUpTestSuite) {} -class SehExceptionInTearDownTestCaseTest : public Test { +class SehExceptionInTearDownTestSuiteTest : public Test { public: - static void TearDownTestCase() { RaiseException(42, 0, 0, NULL); } + static void TearDownTestSuite() { RaiseException(42, 0, 0, NULL); } }; -TEST_F(SehExceptionInTearDownTestCaseTest, ThrowsExceptionInTearDownTestCase) {} +TEST_F(SehExceptionInTearDownTestSuiteTest, + ThrowsExceptionInTearDownTestSuite) {} class SehExceptionInSetUpTest : public Test { protected: @@ -109,9 +110,9 @@ class CxxExceptionInConstructorTest : public Test { throw std::runtime_error("Standard C++ exception")); } - static void TearDownTestCase() { + static void TearDownTestSuite() { printf("%s", - "CxxExceptionInConstructorTest::TearDownTestCase() " + "CxxExceptionInConstructorTest::TearDownTestSuite() " "called as expected.\n"); } @@ -137,65 +138,65 @@ TEST_F(CxxExceptionInConstructorTest, ThrowsExceptionInConstructor) { << "called unexpectedly."; } - -class CxxExceptionInSetUpTestCaseTest : public Test { +class CxxExceptionInSetUpTestSuiteTest : public Test { public: - CxxExceptionInSetUpTestCaseTest() { + CxxExceptionInSetUpTestSuiteTest() { printf("%s", - "CxxExceptionInSetUpTestCaseTest constructor " + "CxxExceptionInSetUpTestSuiteTest constructor " "called as expected.\n"); } - static void SetUpTestCase() { + static void SetUpTestSuite() { throw std::runtime_error("Standard C++ exception"); } - static void TearDownTestCase() { + static void TearDownTestSuite() { printf("%s", - "CxxExceptionInSetUpTestCaseTest::TearDownTestCase() " + "CxxExceptionInSetUpTestSuiteTest::TearDownTestSuite() " "called as expected.\n"); } protected: - ~CxxExceptionInSetUpTestCaseTest() override { + ~CxxExceptionInSetUpTestSuiteTest() override { printf("%s", - "CxxExceptionInSetUpTestCaseTest destructor " + "CxxExceptionInSetUpTestSuiteTest destructor " "called as expected.\n"); } void SetUp() override { printf("%s", - "CxxExceptionInSetUpTestCaseTest::SetUp() " + "CxxExceptionInSetUpTestSuiteTest::SetUp() " "called as expected.\n"); } void TearDown() override { printf("%s", - "CxxExceptionInSetUpTestCaseTest::TearDown() " + "CxxExceptionInSetUpTestSuiteTest::TearDown() " "called as expected.\n"); } }; -TEST_F(CxxExceptionInSetUpTestCaseTest, ThrowsExceptionInSetUpTestCase) { +TEST_F(CxxExceptionInSetUpTestSuiteTest, ThrowsExceptionInSetUpTestSuite) { printf("%s", - "CxxExceptionInSetUpTestCaseTest test body " + "CxxExceptionInSetUpTestSuiteTest test body " "called as expected.\n"); } -class CxxExceptionInTearDownTestCaseTest : public Test { +class CxxExceptionInTearDownTestSuiteTest : public Test { public: - static void TearDownTestCase() { + static void TearDownTestSuite() { throw std::runtime_error("Standard C++ exception"); } }; -TEST_F(CxxExceptionInTearDownTestCaseTest, ThrowsExceptionInTearDownTestCase) {} +TEST_F(CxxExceptionInTearDownTestSuiteTest, + ThrowsExceptionInTearDownTestSuite) {} class CxxExceptionInSetUpTest : public Test { public: - static void TearDownTestCase() { + static void TearDownTestSuite() { printf("%s", - "CxxExceptionInSetUpTest::TearDownTestCase() " + "CxxExceptionInSetUpTest::TearDownTestSuite() " "called as expected.\n"); } @@ -222,9 +223,9 @@ TEST_F(CxxExceptionInSetUpTest, ThrowsExceptionInSetUp) { class CxxExceptionInTearDownTest : public Test { public: - static void TearDownTestCase() { + static void TearDownTestSuite() { printf("%s", - "CxxExceptionInTearDownTest::TearDownTestCase() " + "CxxExceptionInTearDownTest::TearDownTestSuite() " "called as expected.\n"); } @@ -244,9 +245,9 @@ TEST_F(CxxExceptionInTearDownTest, ThrowsExceptionInTearDown) {} class CxxExceptionInTestBodyTest : public Test { public: - static void TearDownTestCase() { + static void TearDownTestSuite() { printf("%s", - "CxxExceptionInTestBodyTest::TearDownTestCase() " + "CxxExceptionInTestBodyTest::TearDownTestSuite() " "called as expected.\n"); } diff --git a/googletest/test/googletest-death-test-test.cc b/googletest/test/googletest-death-test-test.cc index 78e05eb..01837ea 100644 --- a/googletest/test/googletest-death-test-test.cc +++ b/googletest/test/googletest-death-test-test.cc @@ -1017,12 +1017,12 @@ class MacroLogicDeathTest : public testing::Test { static testing::internal::ReplaceDeathTestFactory* replacer_; static MockDeathTestFactory* factory_; - static void SetUpTestCase() { + static void SetUpTestSuite() { factory_ = new MockDeathTestFactory; replacer_ = new testing::internal::ReplaceDeathTestFactory(factory_); } - static void TearDownTestCase() { + static void TearDownTestSuite() { delete replacer_; replacer_ = nullptr; delete factory_; diff --git a/googletest/test/googletest-filter-unittest_.cc b/googletest/test/googletest-filter-unittest_.cc index d335b60..d30ec9c 100644 --- a/googletest/test/googletest-filter-unittest_.cc +++ b/googletest/test/googletest-filter-unittest_.cc @@ -125,8 +125,8 @@ TEST_P(ParamTest, TestX) { TEST_P(ParamTest, TestY) { } -INSTANTIATE_TEST_CASE_P(SeqP, ParamTest, testing::Values(1, 2)); -INSTANTIATE_TEST_CASE_P(SeqQ, ParamTest, testing::Values(5, 6)); +INSTANTIATE_TEST_SUITE_P(SeqP, ParamTest, testing::Values(1, 2)); +INSTANTIATE_TEST_SUITE_P(SeqQ, ParamTest, testing::Values(5, 6)); } // namespace diff --git a/googletest/test/googletest-json-output-unittest.py b/googletest/test/googletest-json-output-unittest.py index b09b590..93028ff 100644 --- a/googletest/test/googletest-json-output-unittest.py +++ b/googletest/test/googletest-json-output-unittest.py @@ -241,8 +241,8 @@ EXPECTED_NON_EMPTY = { u'disabled': 0, u'errors': 0, u'time': u'*', - u'SetUpTestCase': u'yes', - u'TearDownTestCase': u'aye', + u'SetUpTestSuite': u'yes', + u'TearDownTestSuite': u'aye', u'testsuite': [ { u'name': u'OneProperty', @@ -343,7 +343,7 @@ EXPECTED_NON_EMPTY = { ] }, { - u'name': u'Single/TypeParameterizedTestCase/0', + u'name': u'Single/TypeParameterizedTestSuite/0', u'tests': 1, u'failures': 0, u'disabled': 0, @@ -355,12 +355,12 @@ EXPECTED_NON_EMPTY = { u'type_param': u'int', u'status': u'RUN', u'time': u'*', - u'classname': u'Single/TypeParameterizedTestCase/0' + u'classname': u'Single/TypeParameterizedTestSuite/0' } ] }, { - u'name': u'Single/TypeParameterizedTestCase/1', + u'name': u'Single/TypeParameterizedTestSuite/1', u'tests': 1, u'failures': 0, u'disabled': 0, @@ -372,7 +372,7 @@ EXPECTED_NON_EMPTY = { u'type_param': u'long', u'status': u'RUN', u'time': u'*', - u'classname': u'Single/TypeParameterizedTestCase/1' + u'classname': u'Single/TypeParameterizedTestSuite/1' } ] }, diff --git a/googletest/test/googletest-list-tests-unittest_.cc b/googletest/test/googletest-list-tests-unittest_.cc index f473c7d..493c6f0 100644 --- a/googletest/test/googletest-list-tests-unittest_.cc +++ b/googletest/test/googletest-list-tests-unittest_.cc @@ -99,7 +99,7 @@ TEST_P(ValueParamTest, TestA) { TEST_P(ValueParamTest, TestB) { } -INSTANTIATE_TEST_CASE_P( +INSTANTIATE_TEST_SUITE_P( MyInstantiation, ValueParamTest, testing::Values(MyType("one line"), MyType("two\nlines"), @@ -123,7 +123,7 @@ class MyArray { typedef testing::Types<VeryLoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooogName, // NOLINT int*, MyArray<bool, 42> > MyTypes; -TYPED_TEST_CASE(TypedTest, MyTypes); +TYPED_TEST_SUITE(TypedTest, MyTypes); TYPED_TEST(TypedTest, TestA) { } @@ -137,7 +137,7 @@ template <typename T> class TypeParamTest : public testing::Test { }; -TYPED_TEST_CASE_P(TypeParamTest); +TYPED_TEST_SUITE_P(TypeParamTest); TYPED_TEST_P(TypeParamTest, TestA) { } @@ -145,9 +145,9 @@ TYPED_TEST_P(TypeParamTest, TestA) { TYPED_TEST_P(TypeParamTest, TestB) { } -REGISTER_TYPED_TEST_CASE_P(TypeParamTest, TestA, TestB); +REGISTER_TYPED_TEST_SUITE_P(TypeParamTest, TestA, TestB); -INSTANTIATE_TYPED_TEST_CASE_P(My, TypeParamTest, MyTypes); +INSTANTIATE_TYPED_TEST_SUITE_P(My, TypeParamTest, MyTypes); int main(int argc, char **argv) { ::testing::InitGoogleTest(&argc, argv); diff --git a/googletest/test/googletest-listener-test.cc b/googletest/test/googletest-listener-test.cc index e033109..f50faaf 100644 --- a/googletest/test/googletest-listener-test.cc +++ b/googletest/test/googletest-listener-test.cc @@ -40,7 +40,7 @@ using ::testing::AddGlobalTestEnvironment; using ::testing::Environment; using ::testing::InitGoogleTest; using ::testing::Test; -using ::testing::TestCase; +using ::testing::TestSuite; using ::testing::TestEventListener; using ::testing::TestInfo; using ::testing::TestPartResult; @@ -206,12 +206,12 @@ class EnvironmentInvocationCatcher : public Environment { class ListenerTest : public Test { protected: - static void SetUpTestCase() { - g_events->push_back("ListenerTest::SetUpTestCase"); + static void SetUpTestSuite() { + g_events->push_back("ListenerTest::SetUpTestSuite"); } - static void TearDownTestCase() { - g_events->push_back("ListenerTest::TearDownTestCase"); + static void TearDownTestSuite() { + g_events->push_back("ListenerTest::TearDownTestSuite"); } void SetUp() override { g_events->push_back("ListenerTest::SetUp"); } @@ -299,7 +299,7 @@ int main(int argc, char **argv) { "3rd.OnTestSuiteStart", "1st.OnTestCaseStart", "2nd.OnTestCaseStart", - "ListenerTest::SetUpTestCase", + "ListenerTest::SetUpTestSuite", "1st.OnTestStart", "2nd.OnTestStart", "3rd.OnTestStart", @@ -324,7 +324,7 @@ int main(int argc, char **argv) { "3rd.OnTestEnd", "2nd.OnTestEnd", "1st.OnTestEnd", - "ListenerTest::TearDownTestCase", + "ListenerTest::TearDownTestSuite", "3rd.OnTestSuiteEnd", "2nd.OnTestCaseEnd", "1st.OnTestCaseEnd", @@ -351,7 +351,7 @@ int main(int argc, char **argv) { "3rd.OnTestSuiteStart", "1st.OnTestCaseStart", "2nd.OnTestCaseStart", - "ListenerTest::SetUpTestCase", + "ListenerTest::SetUpTestSuite", "1st.OnTestStart", "2nd.OnTestStart", "3rd.OnTestStart", @@ -376,7 +376,7 @@ int main(int argc, char **argv) { "3rd.OnTestEnd", "2nd.OnTestEnd", "1st.OnTestEnd", - "ListenerTest::TearDownTestCase", + "ListenerTest::TearDownTestSuite", "3rd.OnTestSuiteEnd", "2nd.OnTestCaseEnd", "1st.OnTestCaseEnd", diff --git a/googletest/test/googletest-output-test-golden-lin.txt b/googletest/test/googletest-output-test-golden-lin.txt index 464a03a..29507fc 100644 --- a/googletest/test/googletest-output-test-golden-lin.txt +++ b/googletest/test/googletest-output-test-golden-lin.txt @@ -384,16 +384,16 @@ Expected failure in foo.cc Stack trace: (omitted) [0;31m[ FAILED ] [mAddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber -[0;32m[----------] [m4 tests from MixedUpTestCaseTest -[0;32m[ RUN ] [mMixedUpTestCaseTest.FirstTestFromNamespaceFoo -[0;32m[ OK ] [mMixedUpTestCaseTest.FirstTestFromNamespaceFoo -[0;32m[ RUN ] [mMixedUpTestCaseTest.SecondTestFromNamespaceFoo -[0;32m[ OK ] [mMixedUpTestCaseTest.SecondTestFromNamespaceFoo -[0;32m[ RUN ] [mMixedUpTestCaseTest.ThisShouldFail +[0;32m[----------] [m4 tests from MixedUpTestSuiteTest +[0;32m[ RUN ] [mMixedUpTestSuiteTest.FirstTestFromNamespaceFoo +[0;32m[ OK ] [mMixedUpTestSuiteTest.FirstTestFromNamespaceFoo +[0;32m[ RUN ] [mMixedUpTestSuiteTest.SecondTestFromNamespaceFoo +[0;32m[ OK ] [mMixedUpTestSuiteTest.SecondTestFromNamespaceFoo +[0;32m[ RUN ] [mMixedUpTestSuiteTest.ThisShouldFail gtest.cc:#: Failure Failed All tests in the same test suite must use the same test fixture -class. However, in test suite MixedUpTestCaseTest, +class. However, in test suite MixedUpTestSuiteTest, you defined test FirstTestFromNamespaceFoo and test ThisShouldFail using two different test fixture classes. This can happen if the two classes are from different namespaces or translation @@ -401,12 +401,12 @@ units and have the same name. You should probably rename one of the classes to put the tests into different test suites. Stack trace: (omitted) -[0;31m[ FAILED ] [mMixedUpTestCaseTest.ThisShouldFail -[0;32m[ RUN ] [mMixedUpTestCaseTest.ThisShouldFailToo +[0;31m[ FAILED ] [mMixedUpTestSuiteTest.ThisShouldFail +[0;32m[ RUN ] [mMixedUpTestSuiteTest.ThisShouldFailToo gtest.cc:#: Failure Failed All tests in the same test suite must use the same test fixture -class. However, in test suite MixedUpTestCaseTest, +class. However, in test suite MixedUpTestSuiteTest, you defined test FirstTestFromNamespaceFoo and test ThisShouldFailToo using two different test fixture classes. This can happen if the two classes are from different namespaces or translation @@ -414,15 +414,15 @@ units and have the same name. You should probably rename one of the classes to put the tests into different test suites. Stack trace: (omitted) -[0;31m[ FAILED ] [mMixedUpTestCaseTest.ThisShouldFailToo -[0;32m[----------] [m2 tests from MixedUpTestCaseWithSameTestNameTest -[0;32m[ RUN ] [mMixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail -[0;32m[ OK ] [mMixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail -[0;32m[ RUN ] [mMixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail +[0;31m[ FAILED ] [mMixedUpTestSuiteTest.ThisShouldFailToo +[0;32m[----------] [m2 tests from MixedUpTestSuiteWithSameTestNameTest +[0;32m[ RUN ] [mMixedUpTestSuiteWithSameTestNameTest.TheSecondTestWithThisNameShouldFail +[0;32m[ OK ] [mMixedUpTestSuiteWithSameTestNameTest.TheSecondTestWithThisNameShouldFail +[0;32m[ RUN ] [mMixedUpTestSuiteWithSameTestNameTest.TheSecondTestWithThisNameShouldFail gtest.cc:#: Failure Failed All tests in the same test suite must use the same test fixture -class. However, in test suite MixedUpTestCaseWithSameTestNameTest, +class. However, in test suite MixedUpTestSuiteWithSameTestNameTest, you defined test TheSecondTestWithThisNameShouldFail and test TheSecondTestWithThisNameShouldFail using two different test fixture classes. This can happen if the two classes are from different namespaces or translation @@ -430,7 +430,7 @@ units and have the same name. You should probably rename one of the classes to put the tests into different test suites. Stack trace: (omitted) -[0;31m[ FAILED ] [mMixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail +[0;31m[ FAILED ] [mMixedUpTestSuiteWithSameTestNameTest.TheSecondTestWithThisNameShouldFail [0;32m[----------] [m2 tests from TEST_F_before_TEST_in_same_test_case [0;32m[ RUN ] [mTEST_F_before_TEST_in_same_test_case.DefinedUsingTEST_F [0;32m[ OK ] [mTEST_F_before_TEST_in_same_test_case.DefinedUsingTEST_F @@ -871,7 +871,7 @@ Stack trace: (omitted) [0;31m[ FAILED ] [mScopedFakeTestPartResultReporterTest.InterceptOnlyCurrentThread [0;32m[----------] [m2 tests from DynamicFixture -DynamicFixture::SetUpTestCase +DynamicFixture::SetUpTestSuite [0;32m[ RUN ] [mDynamicFixture.DynamicTestPass DynamicFixture() DynamicFixture::SetUp @@ -890,18 +890,18 @@ Stack trace: (omitted) DynamicFixture::TearDown ~DynamicFixture() [0;31m[ FAILED ] [mDynamicFixture.DynamicTestFail -DynamicFixture::TearDownTestCase +DynamicFixture::TearDownTestSuite [0;32m[----------] [m1 test from DynamicFixtureAnotherName -DynamicFixture::SetUpTestCase +DynamicFixture::SetUpTestSuite [0;32m[ RUN ] [mDynamicFixtureAnotherName.DynamicTestPass DynamicFixture() DynamicFixture::SetUp DynamicFixture::TearDown ~DynamicFixture() [0;32m[ OK ] [mDynamicFixtureAnotherName.DynamicTestPass -DynamicFixture::TearDownTestCase +DynamicFixture::TearDownTestSuite [0;32m[----------] [m2 tests from BadDynamicFixture1 -DynamicFixture::SetUpTestCase +DynamicFixture::SetUpTestSuite [0;32m[ RUN ] [mBadDynamicFixture1.FixtureBase DynamicFixture() DynamicFixture::SetUp @@ -923,9 +923,9 @@ Stack trace: (omitted) ~DynamicFixture() [0;31m[ FAILED ] [mBadDynamicFixture1.TestBase -DynamicFixture::TearDownTestCase +DynamicFixture::TearDownTestSuite [0;32m[----------] [m2 tests from BadDynamicFixture2 -DynamicFixture::SetUpTestCase +DynamicFixture::SetUpTestSuite [0;32m[ RUN ] [mBadDynamicFixture2.FixtureBase DynamicFixture() DynamicFixture::SetUp @@ -947,7 +947,7 @@ Stack trace: (omitted) ~DynamicFixture() [0;31m[ FAILED ] [mBadDynamicFixture2.Derived -DynamicFixture::TearDownTestCase +DynamicFixture::TearDownTestSuite [0;32m[----------] [m1 test from PrintingFailingParams/FailingParamTest [0;32m[ RUN ] [mPrintingFailingParams/FailingParamTest.Fails/0 googletest-output-test_.cc:#: Failure @@ -1006,9 +1006,9 @@ Stack trace: (omitted) [0;31m[ FAILED ] [mNonFatalFailureInSetUpTest.FailureInSetUp [0;31m[ FAILED ] [mFatalFailureInSetUpTest.FailureInSetUp [0;31m[ FAILED ] [mAddFailureAtTest.MessageContainsSpecifiedFileAndLineNumber -[0;31m[ FAILED ] [mMixedUpTestCaseTest.ThisShouldFail -[0;31m[ FAILED ] [mMixedUpTestCaseTest.ThisShouldFailToo -[0;31m[ FAILED ] [mMixedUpTestCaseWithSameTestNameTest.TheSecondTestWithThisNameShouldFail +[0;31m[ FAILED ] [mMixedUpTestSuiteTest.ThisShouldFail +[0;31m[ FAILED ] [mMixedUpTestSuiteTest.ThisShouldFailToo +[0;31m[ FAILED ] [mMixedUpTestSuiteWithSameTestNameTest.TheSecondTestWithThisNameShouldFail [0;31m[ FAILED ] [mTEST_F_before_TEST_in_same_test_case.DefinedUsingTESTAndShouldFail [0;31m[ FAILED ] [mTEST_before_TEST_F_in_same_test_case.DefinedUsingTEST_FAndShouldFail [0;31m[ FAILED ] [mExpectNonfatalFailureTest.FailsWhenThereIsNoNonfatalFailure diff --git a/googletest/test/googletest-output-test_.cc b/googletest/test/googletest-output-test_.cc index f86d814..c6ce59e 100644 --- a/googletest/test/googletest-output-test_.cc +++ b/googletest/test/googletest-output-test_.cc @@ -92,9 +92,9 @@ TEST_P(FailingParamTest, Fails) { // This generates a test which will fail. Google Test is expected to print // its parameter when it outputs the list of all failed tests. -INSTANTIATE_TEST_CASE_P(PrintingFailingParams, - FailingParamTest, - testing::Values(2)); +INSTANTIATE_TEST_SUITE_P(PrintingFailingParams, + FailingParamTest, + testing::Values(2)); static const char kGoldenString[] = "\"Line\0 1\"\nLine 2"; @@ -521,48 +521,48 @@ class DeathTestAndMultiThreadsTest : public testing::Test { #endif // GTEST_IS_THREADSAFE -// The MixedUpTestCaseTest test case verifies that Google Test will fail a +// The MixedUpTestSuiteTest test case verifies that Google Test will fail a // test if it uses a different fixture class than what other tests in // the same test case use. It deliberately contains two fixture // classes with the same name but defined in different namespaces. -// The MixedUpTestCaseWithSameTestNameTest test case verifies that +// The MixedUpTestSuiteWithSameTestNameTest test case verifies that // when the user defines two tests with the same test case name AND // same test name (but in different namespaces), the second test will // fail. namespace foo { -class MixedUpTestCaseTest : public testing::Test { +class MixedUpTestSuiteTest : public testing::Test { }; -TEST_F(MixedUpTestCaseTest, FirstTestFromNamespaceFoo) {} -TEST_F(MixedUpTestCaseTest, SecondTestFromNamespaceFoo) {} +TEST_F(MixedUpTestSuiteTest, FirstTestFromNamespaceFoo) {} +TEST_F(MixedUpTestSuiteTest, SecondTestFromNamespaceFoo) {} -class MixedUpTestCaseWithSameTestNameTest : public testing::Test { +class MixedUpTestSuiteWithSameTestNameTest : public testing::Test { }; -TEST_F(MixedUpTestCaseWithSameTestNameTest, +TEST_F(MixedUpTestSuiteWithSameTestNameTest, TheSecondTestWithThisNameShouldFail) {} } // namespace foo namespace bar { -class MixedUpTestCaseTest : public testing::Test { +class MixedUpTestSuiteTest : public testing::Test { }; // The following two tests are expected to fail. We rely on the // golden file to check that Google Test generates the right error message. -TEST_F(MixedUpTestCaseTest, ThisShouldFail) {} -TEST_F(MixedUpTestCaseTest, ThisShouldFailToo) {} +TEST_F(MixedUpTestSuiteTest, ThisShouldFail) {} +TEST_F(MixedUpTestSuiteTest, ThisShouldFailToo) {} -class MixedUpTestCaseWithSameTestNameTest : public testing::Test { +class MixedUpTestSuiteWithSameTestNameTest : public testing::Test { }; // Expected to fail. We rely on the golden file to check that Google Test // generates the right error message. -TEST_F(MixedUpTestCaseWithSameTestNameTest, +TEST_F(MixedUpTestSuiteWithSameTestNameTest, TheSecondTestWithThisNameShouldFail) {} } // namespace bar @@ -773,10 +773,10 @@ TEST_P(ParamTest, Failure) { EXPECT_EQ("b", GetParam()) << "Expected failure"; } -INSTANTIATE_TEST_CASE_P(PrintingStrings, - ParamTest, - testing::Values(std::string("a")), - ParamNameFunc); +INSTANTIATE_TEST_SUITE_P(PrintingStrings, + ParamTest, + testing::Values(std::string("a")), + ParamNameFunc); // This #ifdef block tests the output of typed tests. #if GTEST_HAS_TYPED_TEST @@ -785,7 +785,7 @@ template <typename T> class TypedTest : public testing::Test { }; -TYPED_TEST_CASE(TypedTest, testing::Types<int>); +TYPED_TEST_SUITE(TypedTest, testing::Types<int>); TYPED_TEST(TypedTest, Success) { EXPECT_EQ(0, TypeParam()); @@ -811,7 +811,7 @@ class TypedTestNames { } }; -TYPED_TEST_CASE(TypedTestWithNames, TypesForTestWithNames, TypedTestNames); +TYPED_TEST_SUITE(TypedTestWithNames, TypesForTestWithNames, TypedTestNames); TYPED_TEST(TypedTestWithNames, Success) {} @@ -826,7 +826,7 @@ template <typename T> class TypedTestP : public testing::Test { }; -TYPED_TEST_CASE_P(TypedTestP); +TYPED_TEST_SUITE_P(TypedTestP); TYPED_TEST_P(TypedTestP, Success) { EXPECT_EQ(0U, TypeParam()); @@ -836,10 +836,10 @@ TYPED_TEST_P(TypedTestP, Failure) { EXPECT_EQ(1U, TypeParam()) << "Expected failure"; } -REGISTER_TYPED_TEST_CASE_P(TypedTestP, Success, Failure); +REGISTER_TYPED_TEST_SUITE_P(TypedTestP, Success, Failure); typedef testing::Types<unsigned char, unsigned int> UnsignedTypes; -INSTANTIATE_TYPED_TEST_CASE_P(Unsigned, TypedTestP, UnsignedTypes); +INSTANTIATE_TYPED_TEST_SUITE_P(Unsigned, TypedTestP, UnsignedTypes); class TypedTestPNames { public: @@ -854,7 +854,7 @@ class TypedTestPNames { } }; -INSTANTIATE_TYPED_TEST_CASE_P(UnsignedCustomName, TypedTestP, UnsignedTypes, +INSTANTIATE_TYPED_TEST_SUITE_P(UnsignedCustomName, TypedTestP, UnsignedTypes, TypedTestPNames); #endif // GTEST_HAS_TYPED_TEST_P @@ -877,7 +877,7 @@ class ATypedDeathTest : public testing::Test { }; typedef testing::Types<int, double> NumericTypes; -TYPED_TEST_CASE(ATypedDeathTest, NumericTypes); +TYPED_TEST_SUITE(ATypedDeathTest, NumericTypes); TYPED_TEST(ATypedDeathTest, ShouldRunFirst) { } @@ -894,14 +894,14 @@ template <typename T> class ATypeParamDeathTest : public testing::Test { }; -TYPED_TEST_CASE_P(ATypeParamDeathTest); +TYPED_TEST_SUITE_P(ATypeParamDeathTest); TYPED_TEST_P(ATypeParamDeathTest, ShouldRunFirst) { } -REGISTER_TYPED_TEST_CASE_P(ATypeParamDeathTest, ShouldRunFirst); +REGISTER_TYPED_TEST_SUITE_P(ATypeParamDeathTest, ShouldRunFirst); -INSTANTIATE_TYPED_TEST_CASE_P(My, ATypeParamDeathTest, NumericTypes); +INSTANTIATE_TYPED_TEST_SUITE_P(My, ATypeParamDeathTest, NumericTypes); # endif // GTEST_HAS_TYPED_TEST_P @@ -1031,9 +1031,9 @@ class DynamicFixture : public testing::Test { void SetUp() override { printf("DynamicFixture::SetUp\n"); } void TearDown() override { printf("DynamicFixture::TearDown\n"); } - static void SetUpTestCase() { printf("DynamicFixture::SetUpTestCase\n"); } - static void TearDownTestCase() { - printf("DynamicFixture::TearDownTestCase\n"); + static void SetUpTestSuite() { printf("DynamicFixture::SetUpTestSuite\n"); } + static void TearDownTestSuite() { + printf("DynamicFixture::TearDownTestSuite\n"); } }; diff --git a/googletest/test/googletest-param-test-invalid-name1-test_.cc b/googletest/test/googletest-param-test-invalid-name1-test_.cc index 5a95155..955d699 100644 --- a/googletest/test/googletest-param-test-invalid-name1-test_.cc +++ b/googletest/test/googletest-param-test-invalid-name1-test_.cc @@ -36,10 +36,10 @@ class DummyTest : public ::testing::TestWithParam<const char *> {}; TEST_P(DummyTest, Dummy) { } -INSTANTIATE_TEST_CASE_P(InvalidTestName, - DummyTest, - ::testing::Values("InvalidWithQuotes"), - ::testing::PrintToStringParamName()); +INSTANTIATE_TEST_SUITE_P(InvalidTestName, + DummyTest, + ::testing::Values("InvalidWithQuotes"), + ::testing::PrintToStringParamName()); } // namespace diff --git a/googletest/test/googletest-param-test-invalid-name2-test_.cc b/googletest/test/googletest-param-test-invalid-name2-test_.cc index ef09349..76371df 100644 --- a/googletest/test/googletest-param-test-invalid-name2-test_.cc +++ b/googletest/test/googletest-param-test-invalid-name2-test_.cc @@ -41,10 +41,10 @@ std::string StringParamTestSuffix( TEST_P(DummyTest, Dummy) { } -INSTANTIATE_TEST_CASE_P(DuplicateTestNames, - DummyTest, - ::testing::Values("a", "b", "a", "c"), - StringParamTestSuffix); +INSTANTIATE_TEST_SUITE_P(DuplicateTestNames, + DummyTest, + ::testing::Values("a", "b", "a", "c"), + StringParamTestSuffix); } // namespace int main(int argc, char *argv[]) { diff --git a/googletest/test/googletest-param-test-test.cc b/googletest/test/googletest-param-test-test.cc index fc33378..626c1b9 100644 --- a/googletest/test/googletest-param-test-test.cc +++ b/googletest/test/googletest-param-test-test.cc @@ -542,12 +542,12 @@ TEST(ParamGeneratorTest, AssignmentWorks) { // This test verifies that the tests are expanded and run as specified: // one test per element from the sequence produced by the generator -// specified in INSTANTIATE_TEST_CASE_P. It also verifies that the test's +// specified in INSTANTIATE_TEST_SUITE_P. It also verifies that the test's // fixture constructor, SetUp(), and TearDown() have run and have been // supplied with the correct parameters. // The use of environment object allows detection of the case where no test -// case functionality is run at all. In this case TestCaseTearDown will not +// case functionality is run at all. In this case TearDownTestSuite will not // be able to detect missing tests, naturally. template <int kExpectedCalls> class TestGenerationEnvironment : public ::testing::Environment { @@ -628,7 +628,7 @@ class TestGenerationTest : public TestWithParam<int> { EXPECT_EQ(current_parameter_, GetParam()); } - static void SetUpTestCase() { + static void SetUpTestSuite() { bool all_tests_in_test_case_selected = true; for (int i = 0; i < PARAMETER_COUNT; ++i) { @@ -649,7 +649,7 @@ class TestGenerationTest : public TestWithParam<int> { collected_parameters_.clear(); } - static void TearDownTestCase() { + static void TearDownTestSuite() { vector<int> expected_values(test_generation_params, test_generation_params + PARAMETER_COUNT); // Test execution order is not guaranteed by Google Test, @@ -675,17 +675,17 @@ TEST_P(TestGenerationTest, TestsExpandedAndRun) { EXPECT_EQ(current_parameter_, GetParam()); collected_parameters_.push_back(GetParam()); } -INSTANTIATE_TEST_CASE_P(TestExpansionModule, TestGenerationTest, - ValuesIn(test_generation_params)); +INSTANTIATE_TEST_SUITE_P(TestExpansionModule, TestGenerationTest, + ValuesIn(test_generation_params)); // This test verifies that the element sequence (third parameter of -// INSTANTIATE_TEST_CASE_P) is evaluated in InitGoogleTest() and neither at -// the call site of INSTANTIATE_TEST_CASE_P nor in RUN_ALL_TESTS(). For +// INSTANTIATE_TEST_SUITE_P) is evaluated in InitGoogleTest() and neither at +// the call site of INSTANTIATE_TEST_SUITE_P nor in RUN_ALL_TESTS(). For // that, we declare param_value_ to be a static member of // GeneratorEvaluationTest and initialize it to 0. We set it to 1 in // main(), just before invocation of InitGoogleTest(). After calling // InitGoogleTest(), we set the value to 2. If the sequence is evaluated -// before or after InitGoogleTest, INSTANTIATE_TEST_CASE_P will create a +// before or after InitGoogleTest, INSTANTIATE_TEST_SUITE_P will create a // test with parameter other than 1, and the test body will fail the // assertion. class GeneratorEvaluationTest : public TestWithParam<int> { @@ -701,9 +701,8 @@ int GeneratorEvaluationTest::param_value_ = 0; TEST_P(GeneratorEvaluationTest, GeneratorsEvaluatedInMain) { EXPECT_EQ(1, GetParam()); } -INSTANTIATE_TEST_CASE_P(GenEvalModule, - GeneratorEvaluationTest, - Values(GeneratorEvaluationTest::param_value())); +INSTANTIATE_TEST_SUITE_P(GenEvalModule, GeneratorEvaluationTest, + Values(GeneratorEvaluationTest::param_value())); // Tests that generators defined in a different translation unit are // functional. Generator extern_gen is defined in gtest-param-test_test2.cc. @@ -714,9 +713,8 @@ TEST_P(ExternalGeneratorTest, ExternalGenerator) { // which we verify here. EXPECT_EQ(GetParam(), 33); } -INSTANTIATE_TEST_CASE_P(ExternalGeneratorModule, - ExternalGeneratorTest, - extern_gen); +INSTANTIATE_TEST_SUITE_P(ExternalGeneratorModule, ExternalGeneratorTest, + extern_gen); // Tests that a parameterized test case can be defined in one translation // unit and instantiated in another. This test will be instantiated in @@ -731,20 +729,19 @@ TEST_P(ExternalInstantiationTest, IsMultipleOf33) { class MultipleInstantiationTest : public TestWithParam<int> {}; TEST_P(MultipleInstantiationTest, AllowsMultipleInstances) { } -INSTANTIATE_TEST_CASE_P(Sequence1, MultipleInstantiationTest, Values(1, 2)); -INSTANTIATE_TEST_CASE_P(Sequence2, MultipleInstantiationTest, Range(3, 5)); +INSTANTIATE_TEST_SUITE_P(Sequence1, MultipleInstantiationTest, Values(1, 2)); +INSTANTIATE_TEST_SUITE_P(Sequence2, MultipleInstantiationTest, Range(3, 5)); // Tests that a parameterized test case can be instantiated // in multiple translation units. This test will be instantiated // here and in gtest-param-test_test2.cc. // InstantiationInMultipleTranslationUnitsTest fixture class // is defined in gtest-param-test_test.h. -TEST_P(InstantiationInMultipleTranslaionUnitsTest, IsMultipleOf42) { +TEST_P(InstantiationInMultipleTranslationUnitsTest, IsMultipleOf42) { EXPECT_EQ(0, GetParam() % 42); } -INSTANTIATE_TEST_CASE_P(Sequence1, - InstantiationInMultipleTranslaionUnitsTest, - Values(42, 42*2)); +INSTANTIATE_TEST_SUITE_P(Sequence1, InstantiationInMultipleTranslationUnitsTest, + Values(42, 42 * 2)); // Tests that each iteration of parameterized test runs in a separate test // object. @@ -752,7 +749,7 @@ class SeparateInstanceTest : public TestWithParam<int> { public: SeparateInstanceTest() : count_(0) {} - static void TearDownTestCase() { + static void TearDownTestSuite() { EXPECT_GE(global_count_, 2) << "If some (but not all) SeparateInstanceTest tests have been " << "filtered out this test will fail. Make sure that all " @@ -770,20 +767,20 @@ TEST_P(SeparateInstanceTest, TestsRunInSeparateInstances) { EXPECT_EQ(0, count_++); global_count_++; } -INSTANTIATE_TEST_CASE_P(FourElemSequence, SeparateInstanceTest, Range(1, 4)); +INSTANTIATE_TEST_SUITE_P(FourElemSequence, SeparateInstanceTest, Range(1, 4)); // Tests that all instantiations of a test have named appropriately. Test -// defined with TEST_P(TestCaseName, TestName) and instantiated with -// INSTANTIATE_TEST_CASE_P(SequenceName, TestCaseName, generator) must be named -// SequenceName/TestCaseName.TestName/i, where i is the 0-based index of the -// sequence element used to instantiate the test. +// defined with TEST_P(TestSuiteName, TestName) and instantiated with +// INSTANTIATE_TEST_SUITE_P(SequenceName, TestSuiteName, generator) must be +// named SequenceName/TestSuiteName.TestName/i, where i is the 0-based index of +// the sequence element used to instantiate the test. class NamingTest : public TestWithParam<int> {}; TEST_P(NamingTest, TestsReportCorrectNamesAndParameters) { const ::testing::TestInfo* const test_info = ::testing::UnitTest::GetInstance()->current_test_info(); - EXPECT_STREQ("ZeroToFiveSequence/NamingTest", test_info->test_case_name()); + EXPECT_STREQ("ZeroToFiveSequence/NamingTest", test_info->test_suite_name()); Message index_stream; index_stream << "TestsReportCorrectNamesAndParameters/" << GetParam(); @@ -792,7 +789,7 @@ TEST_P(NamingTest, TestsReportCorrectNamesAndParameters) { EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param()); } -INSTANTIATE_TEST_CASE_P(ZeroToFiveSequence, NamingTest, Range(0, 5)); +INSTANTIATE_TEST_SUITE_P(ZeroToFiveSequence, NamingTest, Range(0, 5)); // Tests that macros in test names are expanded correctly. class MacroNamingTest : public TestWithParam<int> {}; @@ -804,11 +801,11 @@ TEST_P(PREFIX_WITH_MACRO(NamingTest), PREFIX_WITH_FOO(SomeTestName)) { const ::testing::TestInfo* const test_info = ::testing::UnitTest::GetInstance()->current_test_info(); - EXPECT_STREQ("FortyTwo/MacroNamingTest", test_info->test_case_name()); + EXPECT_STREQ("FortyTwo/MacroNamingTest", test_info->test_suite_name()); EXPECT_STREQ("FooSomeTestName", test_info->name()); } -INSTANTIATE_TEST_CASE_P(FortyTwo, MacroNamingTest, Values(42)); +INSTANTIATE_TEST_SUITE_P(FortyTwo, MacroNamingTest, Values(42)); // Tests the same thing for non-parametrized tests. class MacroNamingTestNonParametrized : public ::testing::Test {}; @@ -818,7 +815,7 @@ TEST_F(PREFIX_WITH_MACRO(NamingTestNonParametrized), const ::testing::TestInfo* const test_info = ::testing::UnitTest::GetInstance()->current_test_info(); - EXPECT_STREQ("MacroNamingTestNonParametrized", test_info->test_case_name()); + EXPECT_STREQ("MacroNamingTestNonParametrized", test_info->test_suite_name()); EXPECT_STREQ("FooSomeTestName", test_info->name()); } @@ -835,17 +832,14 @@ struct CustomParamNameFunctor { } }; -INSTANTIATE_TEST_CASE_P(CustomParamNameFunctor, - CustomFunctorNamingTest, - Values(std::string("FunctorName")), - CustomParamNameFunctor()); +INSTANTIATE_TEST_SUITE_P(CustomParamNameFunctor, CustomFunctorNamingTest, + Values(std::string("FunctorName")), + CustomParamNameFunctor()); -INSTANTIATE_TEST_CASE_P(AllAllowedCharacters, - CustomFunctorNamingTest, - Values("abcdefghijklmnopqrstuvwxyz", - "ABCDEFGHIJKLMNOPQRSTUVWXYZ", - "01234567890_"), - CustomParamNameFunctor()); +INSTANTIATE_TEST_SUITE_P(AllAllowedCharacters, CustomFunctorNamingTest, + Values("abcdefghijklmnopqrstuvwxyz", + "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "01234567890_"), + CustomParamNameFunctor()); inline std::string CustomParamNameFunction( const ::testing::TestParamInfo<std::string>& inf) { @@ -855,33 +849,30 @@ inline std::string CustomParamNameFunction( class CustomFunctionNamingTest : public TestWithParam<std::string> {}; TEST_P(CustomFunctionNamingTest, CustomTestNames) {} -INSTANTIATE_TEST_CASE_P(CustomParamNameFunction, - CustomFunctionNamingTest, - Values(std::string("FunctionName")), - CustomParamNameFunction); +INSTANTIATE_TEST_SUITE_P(CustomParamNameFunction, CustomFunctionNamingTest, + Values(std::string("FunctionName")), + CustomParamNameFunction); // Test custom naming with a lambda class CustomLambdaNamingTest : public TestWithParam<std::string> {}; TEST_P(CustomLambdaNamingTest, CustomTestNames) {} -INSTANTIATE_TEST_CASE_P(CustomParamNameLambda, CustomLambdaNamingTest, - Values(std::string("LambdaName")), - [](const ::testing::TestParamInfo<std::string>& inf) { - return inf.param; - }); +INSTANTIATE_TEST_SUITE_P(CustomParamNameLambda, CustomLambdaNamingTest, + Values(std::string("LambdaName")), + [](const ::testing::TestParamInfo<std::string>& inf) { + return inf.param; + }); TEST(CustomNamingTest, CheckNameRegistry) { ::testing::UnitTest* unit_test = ::testing::UnitTest::GetInstance(); std::set<std::string> test_names; - for (int case_num = 0; - case_num < unit_test->total_test_case_count(); - ++case_num) { - const ::testing::TestCase* test_case = unit_test->GetTestCase(case_num); - for (int test_num = 0; - test_num < test_case->total_test_count(); + for (int suite_num = 0; suite_num < unit_test->total_test_suite_count(); + ++suite_num) { + const ::testing::TestSuite* test_suite = unit_test->GetTestSuite(suite_num); + for (int test_num = 0; test_num < test_suite->total_test_count(); ++test_num) { - const ::testing::TestInfo* test_info = test_case->GetTestInfo(test_num); + const ::testing::TestInfo* test_info = test_suite->GetTestInfo(test_num); test_names.insert(std::string(test_info->name())); } } @@ -902,10 +893,8 @@ TEST_P(CustomIntegerNamingTest, TestsReportCorrectNames) { EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name()); } -INSTANTIATE_TEST_CASE_P(PrintToString, - CustomIntegerNamingTest, - Range(0, 5), - ::testing::PrintToStringParamName()); +INSTANTIATE_TEST_SUITE_P(PrintToString, CustomIntegerNamingTest, Range(0, 5), + ::testing::PrintToStringParamName()); // Test a custom struct with PrintToString. @@ -929,10 +918,9 @@ TEST_P(CustomStructNamingTest, TestsReportCorrectNames) { EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name()); } -INSTANTIATE_TEST_CASE_P(PrintToString, - CustomStructNamingTest, - Values(CustomStruct(0), CustomStruct(1)), - ::testing::PrintToStringParamName()); +INSTANTIATE_TEST_SUITE_P(PrintToString, CustomStructNamingTest, + Values(CustomStruct(0), CustomStruct(1)), + ::testing::PrintToStringParamName()); // Test that using a stateful parameter naming function works as expected. @@ -961,10 +949,8 @@ TEST_P(StatefulNamingTest, TestsReportCorrectNames) { EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name()); } -INSTANTIATE_TEST_CASE_P(StatefulNamingFunctor, - StatefulNamingTest, - Range(0, 5), - StatefulNamingFunctor()); +INSTANTIATE_TEST_SUITE_P(StatefulNamingFunctor, StatefulNamingTest, Range(0, 5), + StatefulNamingFunctor()); // Class that cannot be streamed into an ostream. It needs to be copyable // (and, in case of MSVC, also assignable) in order to be a test parameter @@ -987,9 +973,8 @@ TEST_P(CommentTest, TestsCorrectlyReportUnstreamableParams) { EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param()); } -INSTANTIATE_TEST_CASE_P(InstantiationWithComments, - CommentTest, - Values(Unstreamable(1))); +INSTANTIATE_TEST_SUITE_P(InstantiationWithComments, CommentTest, + Values(Unstreamable(1))); // Verify that we can create a hierarchy of test fixtures, where the base // class fixture is not parameterized and the derived class is. In this case @@ -1029,7 +1014,8 @@ TEST_F(ParameterizedDeathTest, GetParamDiesFromTestF) { ".* value-parameterized test .*"); } -INSTANTIATE_TEST_CASE_P(RangeZeroToFive, ParameterizedDerivedTest, Range(0, 5)); +INSTANTIATE_TEST_SUITE_P(RangeZeroToFive, ParameterizedDerivedTest, + Range(0, 5)); // Tests param generator working with Enums enum MyEnums { @@ -1041,19 +1027,19 @@ enum MyEnums { class MyEnumTest : public testing::TestWithParam<MyEnums> {}; TEST_P(MyEnumTest, ChecksParamMoreThanZero) { EXPECT_GE(10, GetParam()); } -INSTANTIATE_TEST_CASE_P(MyEnumTests, MyEnumTest, - ::testing::Values(ENUM1, ENUM2, 0)); +INSTANTIATE_TEST_SUITE_P(MyEnumTests, MyEnumTest, + ::testing::Values(ENUM1, ENUM2, 0)); int main(int argc, char **argv) { - // Used in TestGenerationTest test case. + // Used in TestGenerationTest test suite. AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance()); - // Used in GeneratorEvaluationTest test case. Tests that the updated value + // Used in GeneratorEvaluationTest test suite. Tests that the updated value // will be picked up for instantiating tests in GeneratorEvaluationTest. GeneratorEvaluationTest::set_param_value(1); ::testing::InitGoogleTest(&argc, argv); - // Used in GeneratorEvaluationTest test case. Tests that value updated + // Used in GeneratorEvaluationTest test suite. Tests that value updated // here will NOT be used for instantiating tests in // GeneratorEvaluationTest. GeneratorEvaluationTest::set_param_value(2); diff --git a/googletest/test/googletest-param-test-test.h b/googletest/test/googletest-param-test-test.h index 632a61f..6480570 100644 --- a/googletest/test/googletest-param-test-test.h +++ b/googletest/test/googletest-param-test-test.h @@ -44,7 +44,7 @@ class ExternalInstantiationTest : public ::testing::TestWithParam<int> { // Test fixture for testing instantiation of a test in multiple // translation units. -class InstantiationInMultipleTranslaionUnitsTest +class InstantiationInMultipleTranslationUnitsTest : public ::testing::TestWithParam<int> { }; diff --git a/googletest/test/googletest-param-test2-test.cc b/googletest/test/googletest-param-test2-test.cc index 25bb945..2a29fb1 100644 --- a/googletest/test/googletest-param-test2-test.cc +++ b/googletest/test/googletest-param-test2-test.cc @@ -46,16 +46,16 @@ ParamGenerator<int> extern_gen = Values(33); // and instantiated in another. The test is defined in // googletest-param-test-test.cc and ExternalInstantiationTest fixture class is // defined in gtest-param-test_test.h. -INSTANTIATE_TEST_CASE_P(MultiplesOf33, - ExternalInstantiationTest, - Values(33, 66)); +INSTANTIATE_TEST_SUITE_P(MultiplesOf33, + ExternalInstantiationTest, + Values(33, 66)); // Tests that a parameterized test case can be instantiated // in multiple translation units. Another instantiation is defined // in googletest-param-test-test.cc and -// InstantiationInMultipleTranslaionUnitsTest fixture is defined in +// InstantiationInMultipleTranslationUnitsTest fixture is defined in // gtest-param-test_test.h -INSTANTIATE_TEST_CASE_P(Sequence2, - InstantiationInMultipleTranslaionUnitsTest, - Values(42*3, 42*4, 42*5)); +INSTANTIATE_TEST_SUITE_P(Sequence2, + InstantiationInMultipleTranslationUnitsTest, + Values(42*3, 42*4, 42*5)); diff --git a/googletest/test/googletest-port-test.cc b/googletest/test/googletest-port-test.cc index e6a227b..8d6aa28 100644 --- a/googletest/test/googletest-port-test.cc +++ b/googletest/test/googletest-port-test.cc @@ -393,7 +393,7 @@ typedef testing::Types< # endif // GTEST_HAS_GLOBAL_STRING const char*> StringTypes; -TYPED_TEST_CASE(RETest, StringTypes); +TYPED_TEST_SUITE(RETest, StringTypes); // Tests RE's implicit constructors. TYPED_TEST(RETest, ImplicitConstructorWorks) { diff --git a/googletest/test/googletest-test2_test.cc b/googletest/test/googletest-test2_test.cc index c2f98dc..2e425da 100644 --- a/googletest/test/googletest-test2_test.cc +++ b/googletest/test/googletest-test2_test.cc @@ -46,16 +46,16 @@ ParamGenerator<int> extern_gen_2 = Values(33); // and instantiated in another. The test is defined in // googletest-param-test-test.cc and ExternalInstantiationTest fixture class is // defined in gtest-param-test_test.h. -INSTANTIATE_TEST_CASE_P(MultiplesOf33, - ExternalInstantiationTest, - Values(33, 66)); +INSTANTIATE_TEST_SUITE_P(MultiplesOf33, + ExternalInstantiationTest, + Values(33, 66)); // Tests that a parameterized test case can be instantiated // in multiple translation units. Another instantiation is defined // in googletest-param-test-test.cc and -// InstantiationInMultipleTranslaionUnitsTest fixture is defined in +// InstantiationInMultipleTranslationUnitsTest fixture is defined in // gtest-param-test_test.h -INSTANTIATE_TEST_CASE_P(Sequence2, - InstantiationInMultipleTranslaionUnitsTest, - Values(42*3, 42*4, 42*5)); +INSTANTIATE_TEST_SUITE_P(Sequence2, + InstantiationInMultipleTranslationUnitsTest, + Values(42*3, 42*4, 42*5)); diff --git a/googletest/test/gtest-typed-test2_test.cc b/googletest/test/gtest-typed-test2_test.cc index ed96421..7000160 100644 --- a/googletest/test/gtest-typed-test2_test.cc +++ b/googletest/test/gtest-typed-test2_test.cc @@ -38,7 +38,7 @@ // Tests that the same type-parameterized test case can be // instantiated in different translation units linked together. // (ContainerTest is also instantiated in gtest-typed-test_test.cc.) -INSTANTIATE_TYPED_TEST_CASE_P(Vector, ContainerTest, - testing::Types<std::vector<int> >); +INSTANTIATE_TYPED_TEST_SUITE_P(Vector, ContainerTest, + testing::Types<std::vector<int> >); #endif // GTEST_HAS_TYPED_TEST_P diff --git a/googletest/test/gtest-typed-test_test.cc b/googletest/test/gtest-typed-test_test.cc index 4b0ae08..f1ca937 100644 --- a/googletest/test/gtest-typed-test_test.cc +++ b/googletest/test/gtest-typed-test_test.cc @@ -41,19 +41,19 @@ GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127 /* conditional expression is constant */) using testing::Test; -// Used for testing that SetUpTestCase()/TearDownTestCase(), fixture +// Used for testing that SetUpTestSuite()/TearDownTestSuite(), fixture // ctor/dtor, and SetUp()/TearDown() work correctly in typed tests and // type-parameterized test. template <typename T> class CommonTest : public Test { - // For some technical reason, SetUpTestCase() and TearDownTestCase() + // For some technical reason, SetUpTestSuite() and TearDownTestSuite() // must be public. public: - static void SetUpTestCase() { + static void SetUpTestSuite() { shared_ = new T(5); } - static void TearDownTestCase() { + static void TearDownTestSuite() { delete shared_; shared_ = nullptr; } @@ -92,11 +92,11 @@ T* CommonTest<T>::shared_ = nullptr; using testing::Types; -// Tests that SetUpTestCase()/TearDownTestCase(), fixture ctor/dtor, +// Tests that SetUpTestSuite()/TearDownTestSuite(), fixture ctor/dtor, // and SetUp()/TearDown() work correctly in typed tests typedef Types<char, int> TwoTypes; -TYPED_TEST_CASE(CommonTest, TwoTypes); +TYPED_TEST_SUITE(CommonTest, TwoTypes); TYPED_TEST(CommonTest, ValuesAreCorrect) { // Static members of the fixture class template can be visited via @@ -128,25 +128,25 @@ TYPED_TEST(CommonTest, ValuesAreStillCorrect) { EXPECT_EQ(static_cast<TypeParam>(2), this->value_); } -// Tests that multiple TYPED_TEST_CASE's can be defined in the same +// Tests that multiple TYPED_TEST_SUITE's can be defined in the same // translation unit. template <typename T> class TypedTest1 : public Test { }; -// Verifies that the second argument of TYPED_TEST_CASE can be a +// Verifies that the second argument of TYPED_TEST_SUITE can be a // single type. -TYPED_TEST_CASE(TypedTest1, int); +TYPED_TEST_SUITE(TypedTest1, int); TYPED_TEST(TypedTest1, A) {} template <typename T> class TypedTest2 : public Test { }; -// Verifies that the second argument of TYPED_TEST_CASE can be a +// Verifies that the second argument of TYPED_TEST_SUITE can be a // Types<...> type list. -TYPED_TEST_CASE(TypedTest2, Types<int>); +TYPED_TEST_SUITE(TypedTest2, Types<int>); // This also verifies that tests from different typed test cases can // share the same name. @@ -161,7 +161,7 @@ class NumericTest : public Test { }; typedef Types<int, long> NumericTypes; -TYPED_TEST_CASE(NumericTest, NumericTypes); +TYPED_TEST_SUITE(NumericTest, NumericTypes); TYPED_TEST(NumericTest, DefaultIsZero) { EXPECT_EQ(0, TypeParam()); @@ -186,9 +186,9 @@ class TypedTestNames { } }; -TYPED_TEST_CASE(TypedTestWithNames, TwoTypes, TypedTestNames); +TYPED_TEST_SUITE(TypedTestWithNames, TwoTypes, TypedTestNames); -TYPED_TEST(TypedTestWithNames, TestCaseName) { +TYPED_TEST(TypedTestWithNames, TestSuiteName) { if (testing::internal::IsSame<TypeParam, char>::value) { EXPECT_STREQ(::testing::UnitTest::GetInstance() ->current_test_info() @@ -209,11 +209,11 @@ TYPED_TEST(TypedTestWithNames, TestCaseName) { #if GTEST_HAS_TYPED_TEST_P using testing::Types; -using testing::internal::TypedTestCasePState; +using testing::internal::TypedTestSuitePState; -// Tests TypedTestCasePState. +// Tests TypedTestSuitePState. -class TypedTestCasePStateTest : public Test { +class TypedTestSuitePStateTest : public Test { protected: void SetUp() override { state_.AddTestName("foo.cc", 0, "FooTest", "A"); @@ -221,10 +221,10 @@ class TypedTestCasePStateTest : public Test { state_.AddTestName("foo.cc", 0, "FooTest", "C"); } - TypedTestCasePState state_; + TypedTestSuitePState state_; }; -TEST_F(TypedTestCasePStateTest, SucceedsForMatchingList) { +TEST_F(TypedTestSuitePStateTest, SucceedsForMatchingList) { const char* tests = "A, B, C"; EXPECT_EQ(tests, state_.VerifyRegisteredTestNames("foo.cc", 1, tests)); @@ -232,27 +232,27 @@ TEST_F(TypedTestCasePStateTest, SucceedsForMatchingList) { // Makes sure that the order of the tests and spaces around the names // don't matter. -TEST_F(TypedTestCasePStateTest, IgnoresOrderAndSpaces) { +TEST_F(TypedTestSuitePStateTest, IgnoresOrderAndSpaces) { const char* tests = "A,C, B"; EXPECT_EQ(tests, state_.VerifyRegisteredTestNames("foo.cc", 1, tests)); } -typedef TypedTestCasePStateTest TypedTestCasePStateDeathTest; +using TypedTestSuitePStateDeathTest = TypedTestSuitePStateTest; -TEST_F(TypedTestCasePStateDeathTest, DetectsDuplicates) { +TEST_F(TypedTestSuitePStateDeathTest, DetectsDuplicates) { EXPECT_DEATH_IF_SUPPORTED( state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, A, C"), "foo\\.cc.1.?: Test A is listed more than once\\."); } -TEST_F(TypedTestCasePStateDeathTest, DetectsExtraTest) { +TEST_F(TypedTestSuitePStateDeathTest, DetectsExtraTest) { EXPECT_DEATH_IF_SUPPORTED( state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, C, D"), "foo\\.cc.1.?: No test named D can be found in this test suite\\."); } -TEST_F(TypedTestCasePStateDeathTest, DetectsMissedTest) { +TEST_F(TypedTestSuitePStateDeathTest, DetectsMissedTest) { EXPECT_DEATH_IF_SUPPORTED( state_.VerifyRegisteredTestNames("foo.cc", 1, "A, C"), "foo\\.cc.1.?: You forgot to list test B\\."); @@ -260,7 +260,7 @@ TEST_F(TypedTestCasePStateDeathTest, DetectsMissedTest) { // Tests that defining a test for a parameterized test case generates // a run-time error if the test case has been registered. -TEST_F(TypedTestCasePStateDeathTest, DetectsTestAfterRegistration) { +TEST_F(TypedTestSuitePStateDeathTest, DetectsTestAfterRegistration) { state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, C"); EXPECT_DEATH_IF_SUPPORTED( state_.AddTestName("foo.cc", 2, "FooTest", "D"), @@ -268,14 +268,14 @@ TEST_F(TypedTestCasePStateDeathTest, DetectsTestAfterRegistration) { "\\(FooTest, \\.\\.\\.\\)\\."); } -// Tests that SetUpTestCase()/TearDownTestCase(), fixture ctor/dtor, +// Tests that SetUpTestSuite()/TearDownTestSuite(), fixture ctor/dtor, // and SetUp()/TearDown() work correctly in type-parameterized tests. template <typename T> class DerivedTest : public CommonTest<T> { }; -TYPED_TEST_CASE_P(DerivedTest); +TYPED_TEST_SUITE_P(DerivedTest); TYPED_TEST_P(DerivedTest, ValuesAreCorrect) { // Static members of the fixture class template can be visited via @@ -297,20 +297,20 @@ TYPED_TEST_P(DerivedTest, ValuesAreStillCorrect) { EXPECT_EQ(2, this->value_); } -REGISTER_TYPED_TEST_CASE_P(DerivedTest, +REGISTER_TYPED_TEST_SUITE_P(DerivedTest, ValuesAreCorrect, ValuesAreStillCorrect); typedef Types<short, long> MyTwoTypes; -INSTANTIATE_TYPED_TEST_CASE_P(My, DerivedTest, MyTwoTypes); +INSTANTIATE_TYPED_TEST_SUITE_P(My, DerivedTest, MyTwoTypes); // Tests that custom names work with type parametrized tests. We reuse the // TwoTypes from above here. template <typename T> class TypeParametrizedTestWithNames : public Test {}; -TYPED_TEST_CASE_P(TypeParametrizedTestWithNames); +TYPED_TEST_SUITE_P(TypeParametrizedTestWithNames); -TYPED_TEST_P(TypeParametrizedTestWithNames, TestCaseName) { +TYPED_TEST_P(TypeParametrizedTestWithNames, TestSuiteName) { if (testing::internal::IsSame<TypeParam, char>::value) { EXPECT_STREQ(::testing::UnitTest::GetInstance() ->current_test_info() @@ -325,7 +325,7 @@ TYPED_TEST_P(TypeParametrizedTestWithNames, TestCaseName) { } } -REGISTER_TYPED_TEST_CASE_P(TypeParametrizedTestWithNames, TestCaseName); +REGISTER_TYPED_TEST_SUITE_P(TypeParametrizedTestWithNames, TestSuiteName); class TypeParametrizedTestNames { public: @@ -340,62 +340,62 @@ class TypeParametrizedTestNames { } }; -INSTANTIATE_TYPED_TEST_CASE_P(CustomName, TypeParametrizedTestWithNames, +INSTANTIATE_TYPED_TEST_SUITE_P(CustomName, TypeParametrizedTestWithNames, TwoTypes, TypeParametrizedTestNames); -// Tests that multiple TYPED_TEST_CASE_P's can be defined in the same +// Tests that multiple TYPED_TEST_SUITE_P's can be defined in the same // translation unit. template <typename T> class TypedTestP1 : public Test { }; -TYPED_TEST_CASE_P(TypedTestP1); +TYPED_TEST_SUITE_P(TypedTestP1); -// For testing that the code between TYPED_TEST_CASE_P() and +// For testing that the code between TYPED_TEST_SUITE_P() and // TYPED_TEST_P() is not enclosed in a namespace. -typedef int IntAfterTypedTestCaseP; +using IntAfterTypedTestSuiteP = int; TYPED_TEST_P(TypedTestP1, A) {} TYPED_TEST_P(TypedTestP1, B) {} // For testing that the code between TYPED_TEST_P() and -// REGISTER_TYPED_TEST_CASE_P() is not enclosed in a namespace. -typedef int IntBeforeRegisterTypedTestCaseP; +// REGISTER_TYPED_TEST_SUITE_P() is not enclosed in a namespace. +using IntBeforeRegisterTypedTestSuiteP = int; -REGISTER_TYPED_TEST_CASE_P(TypedTestP1, A, B); +REGISTER_TYPED_TEST_SUITE_P(TypedTestP1, A, B); template <typename T> class TypedTestP2 : public Test { }; -TYPED_TEST_CASE_P(TypedTestP2); +TYPED_TEST_SUITE_P(TypedTestP2); // This also verifies that tests from different type-parameterized // test cases can share the same name. TYPED_TEST_P(TypedTestP2, A) {} -REGISTER_TYPED_TEST_CASE_P(TypedTestP2, A); +REGISTER_TYPED_TEST_SUITE_P(TypedTestP2, A); -// Verifies that the code between TYPED_TEST_CASE_P() and -// REGISTER_TYPED_TEST_CASE_P() is not enclosed in a namespace. -IntAfterTypedTestCaseP after = 0; -IntBeforeRegisterTypedTestCaseP before = 0; +// Verifies that the code between TYPED_TEST_SUITE_P() and +// REGISTER_TYPED_TEST_SUITE_P() is not enclosed in a namespace. +IntAfterTypedTestSuiteP after = 0; +IntBeforeRegisterTypedTestSuiteP before = 0; -// Verifies that the last argument of INSTANTIATE_TYPED_TEST_CASE_P() +// Verifies that the last argument of INSTANTIATE_TYPED_TEST_SUITE_P() // can be either a single type or a Types<...> type list. -INSTANTIATE_TYPED_TEST_CASE_P(Int, TypedTestP1, int); -INSTANTIATE_TYPED_TEST_CASE_P(Int, TypedTestP2, Types<int>); +INSTANTIATE_TYPED_TEST_SUITE_P(Int, TypedTestP1, int); +INSTANTIATE_TYPED_TEST_SUITE_P(Int, TypedTestP2, Types<int>); // Tests that the same type-parameterized test case can be // instantiated more than once in the same translation unit. -INSTANTIATE_TYPED_TEST_CASE_P(Double, TypedTestP2, Types<double>); +INSTANTIATE_TYPED_TEST_SUITE_P(Double, TypedTestP2, Types<double>); // Tests that the same type-parameterized test case can be // instantiated in different translation units linked together. // (ContainerTest is also instantiated in gtest-typed-test_test.cc.) typedef Types<std::vector<double>, std::set<char> > MyContainers; -INSTANTIATE_TYPED_TEST_CASE_P(My, ContainerTest, MyContainers); +INSTANTIATE_TYPED_TEST_SUITE_P(My, ContainerTest, MyContainers); // Tests that a type-parameterized test case can be defined and // instantiated in a namespace. @@ -406,7 +406,7 @@ template <typename T> class NumericTest : public Test { }; -TYPED_TEST_CASE_P(NumericTest); +TYPED_TEST_SUITE_P(NumericTest); TYPED_TEST_P(NumericTest, DefaultIsZero) { EXPECT_EQ(0, TypeParam()); @@ -416,29 +416,29 @@ TYPED_TEST_P(NumericTest, ZeroIsLessThanOne) { EXPECT_LT(TypeParam(0), TypeParam(1)); } -REGISTER_TYPED_TEST_CASE_P(NumericTest, +REGISTER_TYPED_TEST_SUITE_P(NumericTest, DefaultIsZero, ZeroIsLessThanOne); typedef Types<int, double> NumericTypes; -INSTANTIATE_TYPED_TEST_CASE_P(My, NumericTest, NumericTypes); +INSTANTIATE_TYPED_TEST_SUITE_P(My, NumericTest, NumericTypes); static const char* GetTestName() { return testing::UnitTest::GetInstance()->current_test_info()->name(); } // Test the stripping of space from test names template <typename T> class TrimmedTest : public Test { }; -TYPED_TEST_CASE_P(TrimmedTest); +TYPED_TEST_SUITE_P(TrimmedTest); TYPED_TEST_P(TrimmedTest, Test1) { EXPECT_STREQ("Test1", GetTestName()); } TYPED_TEST_P(TrimmedTest, Test2) { EXPECT_STREQ("Test2", GetTestName()); } TYPED_TEST_P(TrimmedTest, Test3) { EXPECT_STREQ("Test3", GetTestName()); } TYPED_TEST_P(TrimmedTest, Test4) { EXPECT_STREQ("Test4", GetTestName()); } TYPED_TEST_P(TrimmedTest, Test5) { EXPECT_STREQ("Test5", GetTestName()); } -REGISTER_TYPED_TEST_CASE_P( +REGISTER_TYPED_TEST_SUITE_P( TrimmedTest, Test1, Test2,Test3 , Test4 ,Test5 ); // NOLINT template <typename T1, typename T2> struct MyPair {}; // Be sure to try a type with a comma in its name just in case it matters. typedef Types<int, double, MyPair<int, int> > TrimTypes; -INSTANTIATE_TYPED_TEST_CASE_P(My, TrimmedTest, TrimTypes); +INSTANTIATE_TYPED_TEST_SUITE_P(My, TrimmedTest, TrimTypes); } // namespace library2 diff --git a/googletest/test/gtest-typed-test_test.h b/googletest/test/gtest-typed-test_test.h index 2cce67c..23137b7 100644 --- a/googletest/test/gtest-typed-test_test.h +++ b/googletest/test/gtest-typed-test_test.h @@ -46,7 +46,7 @@ template <typename T> class ContainerTest : public Test { }; -TYPED_TEST_CASE_P(ContainerTest); +TYPED_TEST_SUITE_P(ContainerTest); TYPED_TEST_P(ContainerTest, CanBeDefaultConstructed) { TypeParam container; @@ -57,8 +57,8 @@ TYPED_TEST_P(ContainerTest, InitialSizeIsZero) { EXPECT_EQ(0U, container.size()); } -REGISTER_TYPED_TEST_CASE_P(ContainerTest, - CanBeDefaultConstructed, InitialSizeIsZero); +REGISTER_TYPED_TEST_SUITE_P(ContainerTest, + CanBeDefaultConstructed, InitialSizeIsZero); #endif // GTEST_HAS_TYPED_TEST_P diff --git a/googletest/test/gtest-unittest-api_test.cc b/googletest/test/gtest-unittest-api_test.cc index 2bcbedf..480a41f 100644 --- a/googletest/test/gtest-unittest-api_test.cc +++ b/googletest/test/gtest-unittest-api_test.cc @@ -51,59 +51,59 @@ struct LessByName { class UnitTestHelper { public: - // Returns the array of pointers to all test cases sorted by the test case + // Returns the array of pointers to all test suites sorted by the test suite // name. The caller is responsible for deleting the array. - static TestCase const** GetSortedTestCases() { + static TestSuite const** GetSortedTestSuites() { UnitTest& unit_test = *UnitTest::GetInstance(); - TestCase const** const test_cases = - new const TestCase*[unit_test.total_test_case_count()]; + auto const** const test_suites = + new const TestSuite*[unit_test.total_test_suite_count()]; - for (int i = 0; i < unit_test.total_test_case_count(); ++i) - test_cases[i] = unit_test.GetTestCase(i); + for (int i = 0; i < unit_test.total_test_suite_count(); ++i) + test_suites[i] = unit_test.GetTestSuite(i); - std::sort(test_cases, - test_cases + unit_test.total_test_case_count(), - LessByName<TestCase>()); - return test_cases; + std::sort(test_suites, + test_suites + unit_test.total_test_suite_count(), + LessByName<TestSuite>()); + return test_suites; } - // Returns the test case by its name. The caller doesn't own the returned + // Returns the test suite by its name. The caller doesn't own the returned // pointer. - static const TestCase* FindTestCase(const char* name) { + static const TestSuite* FindTestSuite(const char* name) { UnitTest& unit_test = *UnitTest::GetInstance(); - for (int i = 0; i < unit_test.total_test_case_count(); ++i) { - const TestCase* test_case = unit_test.GetTestCase(i); - if (0 == strcmp(test_case->name(), name)) - return test_case; + for (int i = 0; i < unit_test.total_test_suite_count(); ++i) { + const TestSuite* test_suite = unit_test.GetTestSuite(i); + if (0 == strcmp(test_suite->name(), name)) + return test_suite; } return nullptr; } - // Returns the array of pointers to all tests in a particular test case + // Returns the array of pointers to all tests in a particular test suite // sorted by the test name. The caller is responsible for deleting the // array. - static TestInfo const** GetSortedTests(const TestCase* test_case) { + static TestInfo const** GetSortedTests(const TestSuite* test_suite) { TestInfo const** const tests = - new const TestInfo*[test_case->total_test_count()]; + new const TestInfo*[test_suite->total_test_count()]; - for (int i = 0; i < test_case->total_test_count(); ++i) - tests[i] = test_case->GetTestInfo(i); + for (int i = 0; i < test_suite->total_test_count(); ++i) + tests[i] = test_suite->GetTestInfo(i); - std::sort(tests, tests + test_case->total_test_count(), + std::sort(tests, tests + test_suite->total_test_count(), LessByName<TestInfo>()); return tests; } }; #if GTEST_HAS_TYPED_TEST -template <typename T> class TestCaseWithCommentTest : public Test {}; -TYPED_TEST_CASE(TestCaseWithCommentTest, Types<int>); -TYPED_TEST(TestCaseWithCommentTest, Dummy) {} +template <typename T> class TestSuiteWithCommentTest : public Test {}; +TYPED_TEST_SUITE(TestSuiteWithCommentTest, Types<int>); +TYPED_TEST(TestSuiteWithCommentTest, Dummy) {} -const int kTypedTestCases = 1; +const int kTypedTestSuites = 1; const int kTypedTests = 1; #else -const int kTypedTestCases = 0; +const int kTypedTestSuites = 0; const int kTypedTests = 0; #endif // GTEST_HAS_TYPED_TEST @@ -113,21 +113,21 @@ const int kTypedTests = 0; TEST(ApiTest, UnitTestImmutableAccessorsWork) { UnitTest* unit_test = UnitTest::GetInstance(); - ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count()); - EXPECT_EQ(1 + kTypedTestCases, unit_test->test_case_to_run_count()); + ASSERT_EQ(2 + kTypedTestSuites, unit_test->total_test_suite_count()); + EXPECT_EQ(1 + kTypedTestSuites, unit_test->test_suite_to_run_count()); EXPECT_EQ(2, unit_test->disabled_test_count()); EXPECT_EQ(5 + kTypedTests, unit_test->total_test_count()); EXPECT_EQ(3 + kTypedTests, unit_test->test_to_run_count()); - const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases(); + const TestSuite** const test_suites = UnitTestHelper::GetSortedTestSuites(); - EXPECT_STREQ("ApiTest", test_cases[0]->name()); - EXPECT_STREQ("DISABLED_Test", test_cases[1]->name()); + EXPECT_STREQ("ApiTest", test_suites[0]->name()); + EXPECT_STREQ("DISABLED_Test", test_suites[1]->name()); #if GTEST_HAS_TYPED_TEST - EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name()); + EXPECT_STREQ("TestSuiteWithCommentTest/0", test_suites[2]->name()); #endif // GTEST_HAS_TYPED_TEST - delete[] test_cases; + delete[] test_suites; // The following lines initiate actions to verify certain methods in // FinalSuccessChecker::TearDown. @@ -143,39 +143,39 @@ AssertionResult IsNull(const char* str) { return AssertionSuccess(); } -TEST(ApiTest, TestCaseImmutableAccessorsWork) { - const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest"); - ASSERT_TRUE(test_case != nullptr); +TEST(ApiTest, TestSuiteImmutableAccessorsWork) { + const TestSuite* test_suite = UnitTestHelper::FindTestSuite("ApiTest"); + ASSERT_TRUE(test_suite != nullptr); - EXPECT_STREQ("ApiTest", test_case->name()); - EXPECT_TRUE(IsNull(test_case->type_param())); - EXPECT_TRUE(test_case->should_run()); - EXPECT_EQ(1, test_case->disabled_test_count()); - EXPECT_EQ(3, test_case->test_to_run_count()); - ASSERT_EQ(4, test_case->total_test_count()); + EXPECT_STREQ("ApiTest", test_suite->name()); + EXPECT_TRUE(IsNull(test_suite->type_param())); + EXPECT_TRUE(test_suite->should_run()); + EXPECT_EQ(1, test_suite->disabled_test_count()); + EXPECT_EQ(3, test_suite->test_to_run_count()); + ASSERT_EQ(4, test_suite->total_test_count()); - const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case); + const TestInfo** tests = UnitTestHelper::GetSortedTests(test_suite); EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name()); - EXPECT_STREQ("ApiTest", tests[0]->test_case_name()); + EXPECT_STREQ("ApiTest", tests[0]->test_suite_name()); EXPECT_TRUE(IsNull(tests[0]->value_param())); EXPECT_TRUE(IsNull(tests[0]->type_param())); EXPECT_FALSE(tests[0]->should_run()); - EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name()); - EXPECT_STREQ("ApiTest", tests[1]->test_case_name()); + EXPECT_STREQ("TestSuiteDisabledAccessorsWork", tests[1]->name()); + EXPECT_STREQ("ApiTest", tests[1]->test_suite_name()); EXPECT_TRUE(IsNull(tests[1]->value_param())); EXPECT_TRUE(IsNull(tests[1]->type_param())); EXPECT_TRUE(tests[1]->should_run()); - EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name()); - EXPECT_STREQ("ApiTest", tests[2]->test_case_name()); + EXPECT_STREQ("TestSuiteImmutableAccessorsWork", tests[2]->name()); + EXPECT_STREQ("ApiTest", tests[2]->test_suite_name()); EXPECT_TRUE(IsNull(tests[2]->value_param())); EXPECT_TRUE(IsNull(tests[2]->type_param())); EXPECT_TRUE(tests[2]->should_run()); EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name()); - EXPECT_STREQ("ApiTest", tests[3]->test_case_name()); + EXPECT_STREQ("ApiTest", tests[3]->test_suite_name()); EXPECT_TRUE(IsNull(tests[3]->value_param())); EXPECT_TRUE(IsNull(tests[3]->type_param())); EXPECT_TRUE(tests[3]->should_run()); @@ -184,20 +184,20 @@ TEST(ApiTest, TestCaseImmutableAccessorsWork) { tests = nullptr; #if GTEST_HAS_TYPED_TEST - test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0"); - ASSERT_TRUE(test_case != nullptr); + test_suite = UnitTestHelper::FindTestSuite("TestSuiteWithCommentTest/0"); + ASSERT_TRUE(test_suite != nullptr); - EXPECT_STREQ("TestCaseWithCommentTest/0", test_case->name()); - EXPECT_STREQ(GetTypeName<int>().c_str(), test_case->type_param()); - EXPECT_TRUE(test_case->should_run()); - EXPECT_EQ(0, test_case->disabled_test_count()); - EXPECT_EQ(1, test_case->test_to_run_count()); - ASSERT_EQ(1, test_case->total_test_count()); + EXPECT_STREQ("TestSuiteWithCommentTest/0", test_suite->name()); + EXPECT_STREQ(GetTypeName<int>().c_str(), test_suite->type_param()); + EXPECT_TRUE(test_suite->should_run()); + EXPECT_EQ(0, test_suite->disabled_test_count()); + EXPECT_EQ(1, test_suite->test_to_run_count()); + ASSERT_EQ(1, test_suite->total_test_count()); - tests = UnitTestHelper::GetSortedTests(test_case); + tests = UnitTestHelper::GetSortedTests(test_suite); EXPECT_STREQ("Dummy", tests[0]->name()); - EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name()); + EXPECT_STREQ("TestSuiteWithCommentTest/0", tests[0]->test_suite_name()); EXPECT_TRUE(IsNull(tests[0]->value_param())); EXPECT_STREQ(GetTypeName<int>().c_str(), tests[0]->type_param()); EXPECT_TRUE(tests[0]->should_run()); @@ -206,27 +206,27 @@ TEST(ApiTest, TestCaseImmutableAccessorsWork) { #endif // GTEST_HAS_TYPED_TEST } -TEST(ApiTest, TestCaseDisabledAccessorsWork) { - const TestCase* test_case = UnitTestHelper::FindTestCase("DISABLED_Test"); - ASSERT_TRUE(test_case != nullptr); +TEST(ApiTest, TestSuiteDisabledAccessorsWork) { + const TestSuite* test_suite = UnitTestHelper::FindTestSuite("DISABLED_Test"); + ASSERT_TRUE(test_suite != nullptr); - EXPECT_STREQ("DISABLED_Test", test_case->name()); - EXPECT_TRUE(IsNull(test_case->type_param())); - EXPECT_FALSE(test_case->should_run()); - EXPECT_EQ(1, test_case->disabled_test_count()); - EXPECT_EQ(0, test_case->test_to_run_count()); - ASSERT_EQ(1, test_case->total_test_count()); + EXPECT_STREQ("DISABLED_Test", test_suite->name()); + EXPECT_TRUE(IsNull(test_suite->type_param())); + EXPECT_FALSE(test_suite->should_run()); + EXPECT_EQ(1, test_suite->disabled_test_count()); + EXPECT_EQ(0, test_suite->test_to_run_count()); + ASSERT_EQ(1, test_suite->total_test_count()); - const TestInfo* const test_info = test_case->GetTestInfo(0); + const TestInfo* const test_info = test_suite->GetTestInfo(0); EXPECT_STREQ("Dummy2", test_info->name()); - EXPECT_STREQ("DISABLED_Test", test_info->test_case_name()); + EXPECT_STREQ("DISABLED_Test", test_info->test_suite_name()); EXPECT_TRUE(IsNull(test_info->value_param())); EXPECT_TRUE(IsNull(test_info->type_param())); EXPECT_FALSE(test_info->should_run()); } // These two tests are here to provide support for testing -// test_case_to_run_count, disabled_test_count, and test_to_run_count. +// test_suite_to_run_count, disabled_test_count, and test_to_run_count. TEST(ApiTest, DISABLED_Dummy1) {} TEST(DISABLED_Test, Dummy2) {} @@ -235,62 +235,62 @@ class FinalSuccessChecker : public Environment { void TearDown() override { UnitTest* unit_test = UnitTest::GetInstance(); - EXPECT_EQ(1 + kTypedTestCases, unit_test->successful_test_case_count()); + EXPECT_EQ(1 + kTypedTestSuites, unit_test->successful_test_suite_count()); EXPECT_EQ(3 + kTypedTests, unit_test->successful_test_count()); - EXPECT_EQ(0, unit_test->failed_test_case_count()); + EXPECT_EQ(0, unit_test->failed_test_suite_count()); EXPECT_EQ(0, unit_test->failed_test_count()); EXPECT_TRUE(unit_test->Passed()); EXPECT_FALSE(unit_test->Failed()); - ASSERT_EQ(2 + kTypedTestCases, unit_test->total_test_case_count()); - - const TestCase** const test_cases = UnitTestHelper::GetSortedTestCases(); - - EXPECT_STREQ("ApiTest", test_cases[0]->name()); - EXPECT_TRUE(IsNull(test_cases[0]->type_param())); - EXPECT_TRUE(test_cases[0]->should_run()); - EXPECT_EQ(1, test_cases[0]->disabled_test_count()); - ASSERT_EQ(4, test_cases[0]->total_test_count()); - EXPECT_EQ(3, test_cases[0]->successful_test_count()); - EXPECT_EQ(0, test_cases[0]->failed_test_count()); - EXPECT_TRUE(test_cases[0]->Passed()); - EXPECT_FALSE(test_cases[0]->Failed()); - - EXPECT_STREQ("DISABLED_Test", test_cases[1]->name()); - EXPECT_TRUE(IsNull(test_cases[1]->type_param())); - EXPECT_FALSE(test_cases[1]->should_run()); - EXPECT_EQ(1, test_cases[1]->disabled_test_count()); - ASSERT_EQ(1, test_cases[1]->total_test_count()); - EXPECT_EQ(0, test_cases[1]->successful_test_count()); - EXPECT_EQ(0, test_cases[1]->failed_test_count()); + ASSERT_EQ(2 + kTypedTestSuites, unit_test->total_test_suite_count()); + + const TestSuite** const test_suites = UnitTestHelper::GetSortedTestSuites(); + + EXPECT_STREQ("ApiTest", test_suites[0]->name()); + EXPECT_TRUE(IsNull(test_suites[0]->type_param())); + EXPECT_TRUE(test_suites[0]->should_run()); + EXPECT_EQ(1, test_suites[0]->disabled_test_count()); + ASSERT_EQ(4, test_suites[0]->total_test_count()); + EXPECT_EQ(3, test_suites[0]->successful_test_count()); + EXPECT_EQ(0, test_suites[0]->failed_test_count()); + EXPECT_TRUE(test_suites[0]->Passed()); + EXPECT_FALSE(test_suites[0]->Failed()); + + EXPECT_STREQ("DISABLED_Test", test_suites[1]->name()); + EXPECT_TRUE(IsNull(test_suites[1]->type_param())); + EXPECT_FALSE(test_suites[1]->should_run()); + EXPECT_EQ(1, test_suites[1]->disabled_test_count()); + ASSERT_EQ(1, test_suites[1]->total_test_count()); + EXPECT_EQ(0, test_suites[1]->successful_test_count()); + EXPECT_EQ(0, test_suites[1]->failed_test_count()); #if GTEST_HAS_TYPED_TEST - EXPECT_STREQ("TestCaseWithCommentTest/0", test_cases[2]->name()); - EXPECT_STREQ(GetTypeName<int>().c_str(), test_cases[2]->type_param()); - EXPECT_TRUE(test_cases[2]->should_run()); - EXPECT_EQ(0, test_cases[2]->disabled_test_count()); - ASSERT_EQ(1, test_cases[2]->total_test_count()); - EXPECT_EQ(1, test_cases[2]->successful_test_count()); - EXPECT_EQ(0, test_cases[2]->failed_test_count()); - EXPECT_TRUE(test_cases[2]->Passed()); - EXPECT_FALSE(test_cases[2]->Failed()); + EXPECT_STREQ("TestSuiteWithCommentTest/0", test_suites[2]->name()); + EXPECT_STREQ(GetTypeName<int>().c_str(), test_suites[2]->type_param()); + EXPECT_TRUE(test_suites[2]->should_run()); + EXPECT_EQ(0, test_suites[2]->disabled_test_count()); + ASSERT_EQ(1, test_suites[2]->total_test_count()); + EXPECT_EQ(1, test_suites[2]->successful_test_count()); + EXPECT_EQ(0, test_suites[2]->failed_test_count()); + EXPECT_TRUE(test_suites[2]->Passed()); + EXPECT_FALSE(test_suites[2]->Failed()); #endif // GTEST_HAS_TYPED_TEST - const TestCase* test_case = UnitTestHelper::FindTestCase("ApiTest"); - const TestInfo** tests = UnitTestHelper::GetSortedTests(test_case); + const TestSuite* test_suite = UnitTestHelper::FindTestSuite("ApiTest"); + const TestInfo** tests = UnitTestHelper::GetSortedTests(test_suite); EXPECT_STREQ("DISABLED_Dummy1", tests[0]->name()); - EXPECT_STREQ("ApiTest", tests[0]->test_case_name()); + EXPECT_STREQ("ApiTest", tests[0]->test_suite_name()); EXPECT_FALSE(tests[0]->should_run()); - EXPECT_STREQ("TestCaseDisabledAccessorsWork", tests[1]->name()); - EXPECT_STREQ("ApiTest", tests[1]->test_case_name()); + EXPECT_STREQ("TestSuiteDisabledAccessorsWork", tests[1]->name()); + EXPECT_STREQ("ApiTest", tests[1]->test_suite_name()); EXPECT_TRUE(IsNull(tests[1]->value_param())); EXPECT_TRUE(IsNull(tests[1]->type_param())); EXPECT_TRUE(tests[1]->should_run()); EXPECT_TRUE(tests[1]->result()->Passed()); EXPECT_EQ(0, tests[1]->result()->test_property_count()); - EXPECT_STREQ("TestCaseImmutableAccessorsWork", tests[2]->name()); - EXPECT_STREQ("ApiTest", tests[2]->test_case_name()); + EXPECT_STREQ("TestSuiteImmutableAccessorsWork", tests[2]->name()); + EXPECT_STREQ("ApiTest", tests[2]->test_suite_name()); EXPECT_TRUE(IsNull(tests[2]->value_param())); EXPECT_TRUE(IsNull(tests[2]->type_param())); EXPECT_TRUE(tests[2]->should_run()); @@ -298,7 +298,7 @@ class FinalSuccessChecker : public Environment { EXPECT_EQ(0, tests[2]->result()->test_property_count()); EXPECT_STREQ("UnitTestImmutableAccessorsWork", tests[3]->name()); - EXPECT_STREQ("ApiTest", tests[3]->test_case_name()); + EXPECT_STREQ("ApiTest", tests[3]->test_suite_name()); EXPECT_TRUE(IsNull(tests[3]->value_param())); EXPECT_TRUE(IsNull(tests[3]->type_param())); EXPECT_TRUE(tests[3]->should_run()); @@ -311,11 +311,11 @@ class FinalSuccessChecker : public Environment { delete[] tests; #if GTEST_HAS_TYPED_TEST - test_case = UnitTestHelper::FindTestCase("TestCaseWithCommentTest/0"); - tests = UnitTestHelper::GetSortedTests(test_case); + test_suite = UnitTestHelper::FindTestSuite("TestSuiteWithCommentTest/0"); + tests = UnitTestHelper::GetSortedTests(test_suite); EXPECT_STREQ("Dummy", tests[0]->name()); - EXPECT_STREQ("TestCaseWithCommentTest/0", tests[0]->test_case_name()); + EXPECT_STREQ("TestSuiteWithCommentTest/0", tests[0]->test_suite_name()); EXPECT_TRUE(IsNull(tests[0]->value_param())); EXPECT_STREQ(GetTypeName<int>().c_str(), tests[0]->type_param()); EXPECT_TRUE(tests[0]->should_run()); @@ -324,7 +324,7 @@ class FinalSuccessChecker : public Environment { delete[] tests; #endif // GTEST_HAS_TYPED_TEST - delete[] test_cases; + delete[] test_suites; } }; diff --git a/googletest/test/gtest_repeat_test.cc b/googletest/test/gtest_repeat_test.cc index 3ec416f..7da4a15 100644 --- a/googletest/test/gtest_repeat_test.cc +++ b/googletest/test/gtest_repeat_test.cc @@ -120,9 +120,9 @@ TEST_P(MyParamTest, ShouldPass) { GTEST_CHECK_INT_EQ_(g_param_test_count % kNumberOfParamTests, GetParam()); g_param_test_count++; } -INSTANTIATE_TEST_CASE_P(MyParamSequence, - MyParamTest, - testing::Range(0, kNumberOfParamTests)); +INSTANTIATE_TEST_SUITE_P(MyParamSequence, + MyParamTest, + testing::Range(0, kNumberOfParamTests)); // Resets the count for each test. void ResetCounts() { diff --git a/googletest/test/gtest_unittest.cc b/googletest/test/gtest_unittest.cc index 3b18af6..4ab298c 100644 --- a/googletest/test/gtest_unittest.cc +++ b/googletest/test/gtest_unittest.cc @@ -1570,7 +1570,7 @@ class GTestFlagSaverTest : public Test { // Saves the Google Test flags such that we can restore them later, and // then sets them to their default values. This will be called // before the first test in this test case is run. - static void SetUpTestCase() { + static void SetUpTestSuite() { saver_ = new GTestFlagSaver; GTEST_FLAG(also_run_disabled_tests) = false; @@ -1592,7 +1592,7 @@ class GTestFlagSaverTest : public Test { // Restores the Google Test flags that the tests have modified. This will // be called after the last test in this test case is run. - static void TearDownTestCase() { + static void TearDownTestSuite() { delete saver_; saver_ = nullptr; } @@ -1956,7 +1956,7 @@ TEST(ShouldRunTestOnShardTest, IsPartitionWhenThereAreFiveShards) { // Test class, there are no separate tests for the following classes // (except for some trivial cases): // -// TestCase, UnitTest, UnitTestResultPrinter. +// TestSuite, UnitTest, UnitTestResultPrinter. // // Similarly, there are no separate tests for the following macros: // @@ -1990,7 +1990,7 @@ void ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest( key); } -void ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( +void ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestSuite( const char* key) { const TestCase* test_case = UnitTest::GetInstance()->current_test_case(); ASSERT_TRUE(test_case != nullptr); @@ -1998,7 +1998,7 @@ void ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( test_case->ad_hoc_test_result(), key); } -void ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( +void ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestSuite( const char* key) { ExpectNonFatalFailureRecordingPropertyWithReservedKey( UnitTest::GetInstance()->ad_hoc_test_result(), key); @@ -2010,29 +2010,30 @@ void ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( class UnitTestRecordPropertyTest : public testing::internal::UnitTestRecordPropertyTestHelper { public: - static void SetUpTestCase() { - ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( + static void SetUpTestSuite() { + ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestSuite( "disabled"); - ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( + ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestSuite( "errors"); - ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( + ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestSuite( "failures"); - ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( + ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestSuite( "name"); - ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( + ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestSuite( "tests"); - ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestCase( + ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTestSuite( "time"); Test::RecordProperty("test_case_key_1", "1"); - const TestCase* test_case = UnitTest::GetInstance()->current_test_case(); - ASSERT_TRUE(test_case != nullptr); + const testing::TestSuite* test_suite = + UnitTest::GetInstance()->current_test_case(); + ASSERT_TRUE(test_suite != nullptr); - ASSERT_EQ(1, test_case->ad_hoc_test_result().test_property_count()); + ASSERT_EQ(1, test_suite->ad_hoc_test_result().test_property_count()); EXPECT_STREQ("test_case_key_1", - test_case->ad_hoc_test_result().GetTestProperty(0).key()); + test_suite->ad_hoc_test_result().GetTestProperty(0).key()); EXPECT_STREQ("1", - test_case->ad_hoc_test_result().GetTestProperty(0).value()); + test_suite->ad_hoc_test_result().GetTestProperty(0).value()); } }; @@ -2085,7 +2086,7 @@ TEST_F(UnitTestRecordPropertyTest, OverridesValuesForDuplicateKeys) { } TEST_F(UnitTestRecordPropertyTest, - AddFailureInsideTestsWhenUsingTestCaseReservedKeys) { + AddFailureInsideTestsWhenUsingTestSuiteReservedKeys) { ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest( "name"); ExpectNonFatalFailureRecordingPropertyWithReservedKeyForCurrentTest( @@ -2111,21 +2112,21 @@ TEST_F(UnitTestRecordPropertyTest, class UnitTestRecordPropertyTestEnvironment : public Environment { public: void TearDown() override { - ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( + ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestSuite( "tests"); - ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( + ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestSuite( "failures"); - ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( + ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestSuite( "disabled"); - ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( + ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestSuite( "errors"); - ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( + ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestSuite( "name"); - ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( + ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestSuite( "timestamp"); - ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( + ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestSuite( "time"); - ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestCase( + ExpectNonFatalFailureRecordingPropertyWithReservedKeyOutsideOfTestSuite( "random_seed"); } }; @@ -3119,28 +3120,28 @@ TEST(DisabledTest, NotDISABLED_TestShouldRun) { // A test case whose name starts with DISABLED_. // Should not run. -TEST(DISABLED_TestCase, TestShouldNotRun) { +TEST(DISABLED_TestSuite, TestShouldNotRun) { FAIL() << "Unexpected failure: Test in disabled test case should not be run."; } // A test case and test whose names start with DISABLED_. // Should not run. -TEST(DISABLED_TestCase, DISABLED_TestShouldNotRun) { +TEST(DISABLED_TestSuite, DISABLED_TestShouldNotRun) { FAIL() << "Unexpected failure: Test in disabled test case should not be run."; } -// Check that when all tests in a test case are disabled, SetUpTestCase() and -// TearDownTestCase() are not called. +// Check that when all tests in a test case are disabled, SetUpTestSuite() and +// TearDownTestSuite() are not called. class DisabledTestsTest : public Test { protected: - static void SetUpTestCase() { + static void SetUpTestSuite() { FAIL() << "Unexpected failure: All tests disabled in test case. " - "SetUpTestCase() should not be called."; + "SetUpTestSuite() should not be called."; } - static void TearDownTestCase() { + static void TearDownTestSuite() { FAIL() << "Unexpected failure: All tests disabled in test case. " - "TearDownTestCase() should not be called."; + "TearDownTestSuite() should not be called."; } }; @@ -3161,7 +3162,7 @@ class TypedTest : public Test { }; typedef testing::Types<int, double> NumericTypes; -TYPED_TEST_CASE(TypedTest, NumericTypes); +TYPED_TEST_SUITE(TypedTest, NumericTypes); TYPED_TEST(TypedTest, DISABLED_ShouldNotRun) { FAIL() << "Unexpected failure: Disabled typed test should not run."; @@ -3171,7 +3172,7 @@ template <typename T> class DISABLED_TypedTest : public Test { }; -TYPED_TEST_CASE(DISABLED_TypedTest, NumericTypes); +TYPED_TEST_SUITE(DISABLED_TypedTest, NumericTypes); TYPED_TEST(DISABLED_TypedTest, ShouldNotRun) { FAIL() << "Unexpected failure: Disabled typed test should not run."; @@ -3187,31 +3188,31 @@ template <typename T> class TypedTestP : public Test { }; -TYPED_TEST_CASE_P(TypedTestP); +TYPED_TEST_SUITE_P(TypedTestP); TYPED_TEST_P(TypedTestP, DISABLED_ShouldNotRun) { FAIL() << "Unexpected failure: " << "Disabled type-parameterized test should not run."; } -REGISTER_TYPED_TEST_CASE_P(TypedTestP, DISABLED_ShouldNotRun); +REGISTER_TYPED_TEST_SUITE_P(TypedTestP, DISABLED_ShouldNotRun); -INSTANTIATE_TYPED_TEST_CASE_P(My, TypedTestP, NumericTypes); +INSTANTIATE_TYPED_TEST_SUITE_P(My, TypedTestP, NumericTypes); template <typename T> class DISABLED_TypedTestP : public Test { }; -TYPED_TEST_CASE_P(DISABLED_TypedTestP); +TYPED_TEST_SUITE_P(DISABLED_TypedTestP); TYPED_TEST_P(DISABLED_TypedTestP, ShouldNotRun) { FAIL() << "Unexpected failure: " << "Disabled type-parameterized test should not run."; } -REGISTER_TYPED_TEST_CASE_P(DISABLED_TypedTestP, ShouldNotRun); +REGISTER_TYPED_TEST_SUITE_P(DISABLED_TypedTestP, ShouldNotRun); -INSTANTIATE_TYPED_TEST_CASE_P(My, DISABLED_TypedTestP, NumericTypes); +INSTANTIATE_TYPED_TEST_SUITE_P(My, DISABLED_TypedTestP, NumericTypes); #endif // GTEST_HAS_TYPED_TEST_P @@ -3487,7 +3488,7 @@ std::vector<std::string> CharsToLines(const std::string& str) { return out; } -TEST(EditDistance, TestCases) { +TEST(EditDistance, TestSuites) { struct Case { int line; const char* left; @@ -5310,11 +5311,11 @@ namespace testing { class TestInfoTest : public Test { protected: static const TestInfo* GetTestInfo(const char* test_name) { - const TestCase* const test_case = - GetUnitTestImpl()->GetTestCase("TestInfoTest", "", nullptr, nullptr); + const TestSuite* const test_suite = + GetUnitTestImpl()->GetTestSuite("TestInfoTest", "", nullptr, nullptr); - for (int i = 0; i < test_case->total_test_count(); ++i) { - const TestInfo* const test_info = test_case->GetTestInfo(i); + for (int i = 0; i < test_suite->total_test_count(); ++i) { + const TestInfo* const test_info = test_suite->GetTestInfo(i); if (strcmp(test_name, test_info->name()) == 0) return test_info; } @@ -5371,13 +5372,13 @@ TEST_P(CodeLocationForTESTP, Verify) { VERIFY_CODE_LOCATION; } -INSTANTIATE_TEST_CASE_P(, CodeLocationForTESTP, Values(0)); +INSTANTIATE_TEST_SUITE_P(, CodeLocationForTESTP, Values(0)); template <typename T> class CodeLocationForTYPEDTEST : public Test { }; -TYPED_TEST_CASE(CodeLocationForTYPEDTEST, int); +TYPED_TEST_SUITE(CodeLocationForTYPEDTEST, int); TYPED_TEST(CodeLocationForTYPEDTEST, Verify) { VERIFY_CODE_LOCATION; @@ -5387,20 +5388,21 @@ template <typename T> class CodeLocationForTYPEDTESTP : public Test { }; -TYPED_TEST_CASE_P(CodeLocationForTYPEDTESTP); +TYPED_TEST_SUITE_P(CodeLocationForTYPEDTESTP); TYPED_TEST_P(CodeLocationForTYPEDTESTP, Verify) { VERIFY_CODE_LOCATION; } -REGISTER_TYPED_TEST_CASE_P(CodeLocationForTYPEDTESTP, Verify); +REGISTER_TYPED_TEST_SUITE_P(CodeLocationForTYPEDTESTP, Verify); -INSTANTIATE_TYPED_TEST_CASE_P(My, CodeLocationForTYPEDTESTP, int); +INSTANTIATE_TYPED_TEST_SUITE_P(My, CodeLocationForTYPEDTESTP, int); #undef VERIFY_CODE_LOCATION // Tests setting up and tearing down a test case. - +// Legacy API is deprecated but still available +#ifndef REMOVE_LEGACY_TEST_CASEAPI class SetUpTestCaseTest : public Test { protected: // This will be called once before the first test in this test case @@ -5459,8 +5461,9 @@ TEST_F(SetUpTestCaseTest, Test1) { EXPECT_STRNE(nullptr, shared_resource_); } TEST_F(SetUpTestCaseTest, Test2) { EXPECT_STREQ("123", shared_resource_); } +#endif // REMOVE_LEGACY_TEST_CASEAPI -// Tests SetupTestSuite/TearDown TestSuite API +// Tests SetupTestSuite/TearDown TestSuite class SetUpTestSuiteTest : public Test { protected: // This will be called once before the first test in this test case @@ -6278,7 +6281,7 @@ class CurrentTestInfoTest : public Test { protected: // Tests that current_test_info() returns NULL before the first test in // the test case is run. - static void SetUpTestCase() { + static void SetUpTestSuite() { // There should be no tests running at this point. const TestInfo* test_info = UnitTest::GetInstance()->current_test_info(); @@ -6288,7 +6291,7 @@ class CurrentTestInfoTest : public Test { // Tests that current_test_info() returns NULL after the last test in // the test case has run. - static void TearDownTestCase() { + static void TearDownTestSuite() { const TestInfo* test_info = UnitTest::GetInstance()->current_test_info(); EXPECT_TRUE(test_info == nullptr) @@ -6298,14 +6301,14 @@ class CurrentTestInfoTest : public Test { // Tests that current_test_info() returns TestInfo for currently running // test by checking the expected test name against the actual one. -TEST_F(CurrentTestInfoTest, WorksForFirstTestInATestCase) { +TEST_F(CurrentTestInfoTest, WorksForFirstTestInATestSuite) { const TestInfo* test_info = UnitTest::GetInstance()->current_test_info(); ASSERT_TRUE(nullptr != test_info) << "There is a test running so we should have a valid TestInfo."; EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name()) << "Expected the name of the currently running test case."; - EXPECT_STREQ("WorksForFirstTestInATestCase", test_info->name()) + EXPECT_STREQ("WorksForFirstTestInATestSuite", test_info->name()) << "Expected the name of the currently running test."; } @@ -6313,14 +6316,14 @@ TEST_F(CurrentTestInfoTest, WorksForFirstTestInATestCase) { // test by checking the expected test name against the actual one. We // use this test to see that the TestInfo object actually changed from // the previous invocation. -TEST_F(CurrentTestInfoTest, WorksForSecondTestInATestCase) { +TEST_F(CurrentTestInfoTest, WorksForSecondTestInATestSuite) { const TestInfo* test_info = UnitTest::GetInstance()->current_test_info(); ASSERT_TRUE(nullptr != test_info) << "There is a test running so we should have a valid TestInfo."; EXPECT_STREQ("CurrentTestInfoTest", test_info->test_case_name()) << "Expected the name of the currently running test case."; - EXPECT_STREQ("WorksForSecondTestInATestCase", test_info->name()) + EXPECT_STREQ("WorksForSecondTestInATestSuite", test_info->name()) << "Expected the name of the currently running test."; } @@ -7549,14 +7552,14 @@ TEST(SkipPrefixTest, DoesNotSkipWhenPrefixDoesNotMatch) { class AdHocTestResultTest : public testing::Test { protected: - static void SetUpTestCase() { - FAIL() << "A failure happened inside SetUpTestCase()."; + static void SetUpTestSuite() { + FAIL() << "A failure happened inside SetUpTestSuite()."; } }; -TEST_F(AdHocTestResultTest, AdHocTestResultForTestCaseShowsFailure) { +TEST_F(AdHocTestResultTest, AdHocTestResultForTestSuiteShowsFailure) { const testing::TestResult& test_result = testing::UnitTest::GetInstance() - ->current_test_case() + ->current_test_suite() ->ad_hoc_test_result(); EXPECT_TRUE(test_result.Failed()); } @@ -7579,8 +7582,8 @@ auto* dynamic_test = testing::RegisterTest( TEST(RegisterTest, WasRegistered) { auto* unittest = testing::UnitTest::GetInstance(); - for (int i = 0; i < unittest->total_test_case_count(); ++i) { - auto* tests = unittest->GetTestCase(i); + for (int i = 0; i < unittest->total_test_suite_count(); ++i) { + auto* tests = unittest->GetTestSuite(i); if (tests->name() != std::string("DynamicUnitTestFixture")) continue; for (int j = 0; j < tests->total_test_count(); ++j) { if (tests->GetTestInfo(j)->name() != std::string("DynamicTest")) continue; diff --git a/googletest/test/gtest_xml_output_unittest.py b/googletest/test/gtest_xml_output_unittest.py index ab733d1..ce444f0 100755 --- a/googletest/test/gtest_xml_output_unittest.py +++ b/googletest/test/gtest_xml_output_unittest.py @@ -111,7 +111,7 @@ Invalid characters in brackets []%(stack)s]]></failure> <testsuite name="SkippedTest" tests="1" failures="0" disabled="0" errors="0" time="*"> <testcase name="Skipped" status="skipped" time="*" classname="SkippedTest"/> </testsuite> - <testsuite name="PropertyRecordingTest" tests="4" failures="0" disabled="0" errors="0" time="*" SetUpTestCase="yes" TearDownTestCase="aye"> + <testsuite name="PropertyRecordingTest" tests="4" failures="0" disabled="0" errors="0" time="*" SetUpTestSuite="yes" TearDownTestSuite="aye"> <testcase name="OneProperty" status="run" time="*" classname="PropertyRecordingTest"> <properties> <property name="key_1" value="1"/> @@ -164,11 +164,11 @@ Invalid characters in brackets []%(stack)s]]></failure> <testsuite name="TypedTest/1" tests="1" failures="0" disabled="0" errors="0" time="*"> <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="TypedTest/1" /> </testsuite> - <testsuite name="Single/TypeParameterizedTestCase/0" tests="1" failures="0" disabled="0" errors="0" time="*"> - <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="Single/TypeParameterizedTestCase/0" /> + <testsuite name="Single/TypeParameterizedTestSuite/0" tests="1" failures="0" disabled="0" errors="0" time="*"> + <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="Single/TypeParameterizedTestSuite/0" /> </testsuite> - <testsuite name="Single/TypeParameterizedTestCase/1" tests="1" failures="0" disabled="0" errors="0" time="*"> - <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="Single/TypeParameterizedTestCase/1" /> + <testsuite name="Single/TypeParameterizedTestSuite/1" tests="1" failures="0" disabled="0" errors="0" time="*"> + <testcase name="HasTypeParamAttribute" type_param="*" status="run" time="*" classname="Single/TypeParameterizedTestSuite/1" /> </testsuite> </testsuites>""" % {'stack': STACK_TRACE_TEMPLATE} @@ -186,7 +186,7 @@ EXPECTED_SHARDED_TEST_XML = """<?xml version="1.0" encoding="UTF-8"?> <testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0" errors="0" time="*"> <testcase name="Succeeds" status="run" time="*" classname="SuccessfulTest"/> </testsuite> - <testsuite name="PropertyRecordingTest" tests="1" failures="0" disabled="0" errors="0" time="*" SetUpTestCase="yes" TearDownTestCase="aye"> + <testsuite name="PropertyRecordingTest" tests="1" failures="0" disabled="0" errors="0" time="*" SetUpTestSuite="yes" TearDownTestSuite="aye"> <testcase name="TwoValuesForOneKeyUsesLastValue" status="run" time="*" classname="PropertyRecordingTest"> <properties> <property name="key_1" value="2"/> diff --git a/googletest/test/gtest_xml_output_unittest_.cc b/googletest/test/gtest_xml_output_unittest_.cc index 39d9b4e..c95fd66 100644 --- a/googletest/test/gtest_xml_output_unittest_.cc +++ b/googletest/test/gtest_xml_output_unittest_.cc @@ -101,8 +101,10 @@ TEST(InvalidCharactersTest, InvalidCharactersInMessage) { class PropertyRecordingTest : public Test { public: - static void SetUpTestCase() { RecordProperty("SetUpTestCase", "yes"); } - static void TearDownTestCase() { RecordProperty("TearDownTestCase", "aye"); } + static void SetUpTestSuite() { RecordProperty("SetUpTestSuite", "yes"); } + static void TearDownTestSuite() { + RecordProperty("TearDownTestSuite", "aye"); + } }; TEST_F(PropertyRecordingTest, OneProperty) { @@ -150,28 +152,28 @@ TEST(NoFixtureTest, ExternalUtilityThatCallsRecordStringValuedProperty) { class ValueParamTest : public TestWithParam<int> {}; TEST_P(ValueParamTest, HasValueParamAttribute) {} TEST_P(ValueParamTest, AnotherTestThatHasValueParamAttribute) {} -INSTANTIATE_TEST_CASE_P(Single, ValueParamTest, Values(33, 42)); +INSTANTIATE_TEST_SUITE_P(Single, ValueParamTest, Values(33, 42)); #if GTEST_HAS_TYPED_TEST // Verifies that the type parameter name is output in the 'type_param' // XML attribute for typed tests. template <typename T> class TypedTest : public Test {}; typedef testing::Types<int, long> TypedTestTypes; -TYPED_TEST_CASE(TypedTest, TypedTestTypes); +TYPED_TEST_SUITE(TypedTest, TypedTestTypes); TYPED_TEST(TypedTest, HasTypeParamAttribute) {} #endif #if GTEST_HAS_TYPED_TEST_P // Verifies that the type parameter name is output in the 'type_param' // XML attribute for type-parameterized tests. -template <typename T> class TypeParameterizedTestCase : public Test {}; -TYPED_TEST_CASE_P(TypeParameterizedTestCase); -TYPED_TEST_P(TypeParameterizedTestCase, HasTypeParamAttribute) {} -REGISTER_TYPED_TEST_CASE_P(TypeParameterizedTestCase, HasTypeParamAttribute); -typedef testing::Types<int, long> TypeParameterizedTestCaseTypes; -INSTANTIATE_TYPED_TEST_CASE_P(Single, - TypeParameterizedTestCase, - TypeParameterizedTestCaseTypes); +template <typename T> +class TypeParameterizedTestSuite : public Test {}; +TYPED_TEST_SUITE_P(TypeParameterizedTestSuite); +TYPED_TEST_P(TypeParameterizedTestSuite, HasTypeParamAttribute) {} +REGISTER_TYPED_TEST_SUITE_P(TypeParameterizedTestSuite, HasTypeParamAttribute); +typedef testing::Types<int, long> TypeParameterizedTestSuiteTypes; // NOLINT +INSTANTIATE_TYPED_TEST_SUITE_P(Single, TypeParameterizedTestSuite, + TypeParameterizedTestSuiteTypes); #endif int main(int argc, char** argv) { |