"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "googletest/test/gtest-typed-test_test.cc" between
googletest-release-1.11.0.tar.gz and googletest-release-1.12.0.tar.gz

About: GoogleTest is Google's (unit) testing and mocking framework for C++ tests.

gtest-typed-test_test.cc  (googletest-release-1.11.0):gtest-typed-test_test.cc  (googletest-release-1.12.0)
skipping to change at line 52 skipping to change at line 52
using testing::Test; using testing::Test;
// Used for testing that SetUpTestSuite()/TearDownTestSuite(), fixture // Used for testing that SetUpTestSuite()/TearDownTestSuite(), fixture
// ctor/dtor, and SetUp()/TearDown() work correctly in typed tests and // ctor/dtor, and SetUp()/TearDown() work correctly in typed tests and
// type-parameterized test. // type-parameterized test.
template <typename T> template <typename T>
class CommonTest : public Test { class CommonTest : public Test {
// For some technical reason, SetUpTestSuite() and TearDownTestSuite() // For some technical reason, SetUpTestSuite() and TearDownTestSuite()
// must be public. // must be public.
public: public:
static void SetUpTestSuite() { static void SetUpTestSuite() { shared_ = new T(5); }
shared_ = new T(5);
}
static void TearDownTestSuite() { static void TearDownTestSuite() {
delete shared_; delete shared_;
shared_ = nullptr; shared_ = nullptr;
} }
// This 'protected:' is optional. There's no harm in making all // This 'protected:' is optional. There's no harm in making all
// members of this fixture class template public. // members of this fixture class template public.
protected: protected:
// We used to use std::list here, but switched to std::vector since // We used to use std::list here, but switched to std::vector since
skipping to change at line 132 skipping to change at line 130
EXPECT_EQ(5, *this->shared_); EXPECT_EQ(5, *this->shared_);
// TypeParam can be used to refer to the type parameter. // TypeParam can be used to refer to the type parameter.
EXPECT_EQ(static_cast<TypeParam>(2), this->value_); EXPECT_EQ(static_cast<TypeParam>(2), this->value_);
} }
// Tests that multiple TYPED_TEST_SUITE's can be defined in the same // Tests that multiple TYPED_TEST_SUITE's can be defined in the same
// translation unit. // translation unit.
template <typename T> template <typename T>
class TypedTest1 : public Test { class TypedTest1 : public Test {};
};
// Verifies that the second argument of TYPED_TEST_SUITE can be a // Verifies that the second argument of TYPED_TEST_SUITE can be a
// single type. // single type.
TYPED_TEST_SUITE(TypedTest1, int); TYPED_TEST_SUITE(TypedTest1, int);
TYPED_TEST(TypedTest1, A) {} TYPED_TEST(TypedTest1, A) {}
template <typename T> template <typename T>
class TypedTest2 : public Test { class TypedTest2 : public Test {};
};
// Verifies that the second argument of TYPED_TEST_SUITE can be a // Verifies that the second argument of TYPED_TEST_SUITE can be a
// Types<...> type list. // Types<...> type list.
TYPED_TEST_SUITE(TypedTest2, Types<int>); TYPED_TEST_SUITE(TypedTest2, Types<int>);
// This also verifies that tests from different typed test cases can // This also verifies that tests from different typed test cases can
// share the same name. // share the same name.
TYPED_TEST(TypedTest2, A) {} TYPED_TEST(TypedTest2, A) {}
// Tests that a typed test case can be defined in a namespace. // Tests that a typed test case can be defined in a namespace.
namespace library1 { namespace library1 {
template <typename T> template <typename T>
class NumericTest : public Test { class NumericTest : public Test {};
};
typedef Types<int, long> NumericTypes; typedef Types<int, long> NumericTypes;
TYPED_TEST_SUITE(NumericTest, NumericTypes); TYPED_TEST_SUITE(NumericTest, NumericTypes);
TYPED_TEST(NumericTest, DefaultIsZero) { TYPED_TEST(NumericTest, DefaultIsZero) { EXPECT_EQ(0, TypeParam()); }
EXPECT_EQ(0, TypeParam());
}
} // namespace library1 } // namespace library1
// Tests that custom names work. // Tests that custom names work.
template <typename T> template <typename T>
class TypedTestWithNames : public Test {}; class TypedTestWithNames : public Test {};
class TypedTestNames { class TypedTestNames {
public: public:
template <typename T> template <typename T>
skipping to change at line 267 skipping to change at line 260
EXPECT_DEATH_IF_SUPPORTED( EXPECT_DEATH_IF_SUPPORTED(
state_.AddTestName("foo.cc", 2, "FooTest", "D"), state_.AddTestName("foo.cc", 2, "FooTest", "D"),
"foo\\.cc.2.?: Test D must be defined before REGISTER_TYPED_TEST_SUITE_P" "foo\\.cc.2.?: Test D must be defined before REGISTER_TYPED_TEST_SUITE_P"
"\\(FooTest, \\.\\.\\.\\)\\."); "\\(FooTest, \\.\\.\\.\\)\\.");
} }
// Tests that SetUpTestSuite()/TearDownTestSuite(), fixture ctor/dtor, // Tests that SetUpTestSuite()/TearDownTestSuite(), fixture ctor/dtor,
// and SetUp()/TearDown() work correctly in type-parameterized tests. // and SetUp()/TearDown() work correctly in type-parameterized tests.
template <typename T> template <typename T>
class DerivedTest : public CommonTest<T> { class DerivedTest : public CommonTest<T> {};
};
TYPED_TEST_SUITE_P(DerivedTest); TYPED_TEST_SUITE_P(DerivedTest);
TYPED_TEST_P(DerivedTest, ValuesAreCorrect) { TYPED_TEST_P(DerivedTest, ValuesAreCorrect) {
// Static members of the fixture class template can be visited via // Static members of the fixture class template can be visited via
// the TestFixture:: prefix. // the TestFixture:: prefix.
EXPECT_EQ(5, *TestFixture::shared_); EXPECT_EQ(5, *TestFixture::shared_);
// Non-static members of the fixture class must be visited via // Non-static members of the fixture class must be visited via
// 'this', as required by C++ for class templates. // 'this', as required by C++ for class templates.
skipping to change at line 292 skipping to change at line 284
// The second test makes sure shared_ is not deleted after the first // The second test makes sure shared_ is not deleted after the first
// test. // test.
TYPED_TEST_P(DerivedTest, ValuesAreStillCorrect) { TYPED_TEST_P(DerivedTest, ValuesAreStillCorrect) {
// Static members of the fixture class template can also be visited // Static members of the fixture class template can also be visited
// via 'this'. // via 'this'.
ASSERT_TRUE(this->shared_ != nullptr); ASSERT_TRUE(this->shared_ != nullptr);
EXPECT_EQ(5, *this->shared_); EXPECT_EQ(5, *this->shared_);
EXPECT_EQ(2, this->value_); EXPECT_EQ(2, this->value_);
} }
REGISTER_TYPED_TEST_SUITE_P(DerivedTest, REGISTER_TYPED_TEST_SUITE_P(DerivedTest, ValuesAreCorrect,
ValuesAreCorrect, ValuesAreStillCorrect); ValuesAreStillCorrect);
typedef Types<short, long> MyTwoTypes; typedef Types<short, long> MyTwoTypes;
INSTANTIATE_TYPED_TEST_SUITE_P(My, DerivedTest, MyTwoTypes); INSTANTIATE_TYPED_TEST_SUITE_P(My, DerivedTest, MyTwoTypes);
// Tests that custom names work with type parametrized tests. We reuse the // Tests that custom names work with type parametrized tests. We reuse the
// TwoTypes from above here. // TwoTypes from above here.
template <typename T> template <typename T>
class TypeParametrizedTestWithNames : public Test {}; class TypeParametrizedTestWithNames : public Test {};
TYPED_TEST_SUITE_P(TypeParametrizedTestWithNames); TYPED_TEST_SUITE_P(TypeParametrizedTestWithNames);
skipping to change at line 336 skipping to change at line 328
if (std::is_same<T, char>::value) { if (std::is_same<T, char>::value) {
return std::string("parChar") + ::testing::PrintToString(i); return std::string("parChar") + ::testing::PrintToString(i);
} }
if (std::is_same<T, int>::value) { if (std::is_same<T, int>::value) {
return std::string("parInt") + ::testing::PrintToString(i); return std::string("parInt") + ::testing::PrintToString(i);
} }
} }
}; };
INSTANTIATE_TYPED_TEST_SUITE_P(CustomName, TypeParametrizedTestWithNames, INSTANTIATE_TYPED_TEST_SUITE_P(CustomName, TypeParametrizedTestWithNames,
TwoTypes, TypeParametrizedTestNames); TwoTypes, TypeParametrizedTestNames);
// Tests that multiple TYPED_TEST_SUITE_P's can be defined in the same // Tests that multiple TYPED_TEST_SUITE_P's can be defined in the same
// translation unit. // translation unit.
template <typename T> template <typename T>
class TypedTestP1 : public Test { class TypedTestP1 : public Test {};
};
TYPED_TEST_SUITE_P(TypedTestP1); TYPED_TEST_SUITE_P(TypedTestP1);
// For testing that the code between TYPED_TEST_SUITE_P() and // For testing that the code between TYPED_TEST_SUITE_P() and
// TYPED_TEST_P() is not enclosed in a namespace. // TYPED_TEST_P() is not enclosed in a namespace.
using IntAfterTypedTestSuiteP = int; using IntAfterTypedTestSuiteP = int;
TYPED_TEST_P(TypedTestP1, A) {} TYPED_TEST_P(TypedTestP1, A) {}
TYPED_TEST_P(TypedTestP1, B) {} TYPED_TEST_P(TypedTestP1, B) {}
// For testing that the code between TYPED_TEST_P() and // For testing that the code between TYPED_TEST_P() and
// REGISTER_TYPED_TEST_SUITE_P() is not enclosed in a namespace. // REGISTER_TYPED_TEST_SUITE_P() is not enclosed in a namespace.
using IntBeforeRegisterTypedTestSuiteP = int; using IntBeforeRegisterTypedTestSuiteP = int;
REGISTER_TYPED_TEST_SUITE_P(TypedTestP1, A, B); REGISTER_TYPED_TEST_SUITE_P(TypedTestP1, A, B);
template <typename T> template <typename T>
class TypedTestP2 : public Test { class TypedTestP2 : public Test {};
};
TYPED_TEST_SUITE_P(TypedTestP2); TYPED_TEST_SUITE_P(TypedTestP2);
// This also verifies that tests from different type-parameterized // This also verifies that tests from different type-parameterized
// test cases can share the same name. // test cases can share the same name.
TYPED_TEST_P(TypedTestP2, A) {} TYPED_TEST_P(TypedTestP2, A) {}
REGISTER_TYPED_TEST_SUITE_P(TypedTestP2, A); REGISTER_TYPED_TEST_SUITE_P(TypedTestP2, A);
// Verifies that the code between TYPED_TEST_SUITE_P() and // Verifies that the code between TYPED_TEST_SUITE_P() and
skipping to change at line 398 skipping to change at line 388
// (ContainerTest is also instantiated in gtest-typed-test_test.cc.) // (ContainerTest is also instantiated in gtest-typed-test_test.cc.)
typedef Types<std::vector<double>, std::set<char> > MyContainers; typedef Types<std::vector<double>, std::set<char> > MyContainers;
INSTANTIATE_TYPED_TEST_SUITE_P(My, ContainerTest, MyContainers); INSTANTIATE_TYPED_TEST_SUITE_P(My, ContainerTest, MyContainers);
// Tests that a type-parameterized test case can be defined and // Tests that a type-parameterized test case can be defined and
// instantiated in a namespace. // instantiated in a namespace.
namespace library2 { namespace library2 {
template <typename T> template <typename T>
class NumericTest : public Test { class NumericTest : public Test {};
};
TYPED_TEST_SUITE_P(NumericTest); TYPED_TEST_SUITE_P(NumericTest);
TYPED_TEST_P(NumericTest, DefaultIsZero) { TYPED_TEST_P(NumericTest, DefaultIsZero) { EXPECT_EQ(0, TypeParam()); }
EXPECT_EQ(0, TypeParam());
}
TYPED_TEST_P(NumericTest, ZeroIsLessThanOne) { TYPED_TEST_P(NumericTest, ZeroIsLessThanOne) {
EXPECT_LT(TypeParam(0), TypeParam(1)); EXPECT_LT(TypeParam(0), TypeParam(1));
} }
REGISTER_TYPED_TEST_SUITE_P(NumericTest, REGISTER_TYPED_TEST_SUITE_P(NumericTest, DefaultIsZero, ZeroIsLessThanOne);
DefaultIsZero, ZeroIsLessThanOne);
typedef Types<int, double> NumericTypes; typedef Types<int, double> NumericTypes;
INSTANTIATE_TYPED_TEST_SUITE_P(My, NumericTest, NumericTypes); INSTANTIATE_TYPED_TEST_SUITE_P(My, NumericTest, NumericTypes);
static const char* GetTestName() { static const char* GetTestName() {
return testing::UnitTest::GetInstance()->current_test_info()->name(); return testing::UnitTest::GetInstance()->current_test_info()->name();
} }
// Test the stripping of space from test names // Test the stripping of space from test names
template <typename T> class TrimmedTest : public Test { }; template <typename T>
class TrimmedTest : public Test {};
TYPED_TEST_SUITE_P(TrimmedTest); TYPED_TEST_SUITE_P(TrimmedTest);
TYPED_TEST_P(TrimmedTest, Test1) { EXPECT_STREQ("Test1", GetTestName()); } TYPED_TEST_P(TrimmedTest, Test1) { EXPECT_STREQ("Test1", GetTestName()); }
TYPED_TEST_P(TrimmedTest, Test2) { EXPECT_STREQ("Test2", GetTestName()); } TYPED_TEST_P(TrimmedTest, Test2) { EXPECT_STREQ("Test2", GetTestName()); }
TYPED_TEST_P(TrimmedTest, Test3) { EXPECT_STREQ("Test3", GetTestName()); } TYPED_TEST_P(TrimmedTest, Test3) { EXPECT_STREQ("Test3", GetTestName()); }
TYPED_TEST_P(TrimmedTest, Test4) { EXPECT_STREQ("Test4", GetTestName()); } TYPED_TEST_P(TrimmedTest, Test4) { EXPECT_STREQ("Test4", GetTestName()); }
TYPED_TEST_P(TrimmedTest, Test5) { EXPECT_STREQ("Test5", GetTestName()); } TYPED_TEST_P(TrimmedTest, Test5) { EXPECT_STREQ("Test5", GetTestName()); }
REGISTER_TYPED_TEST_SUITE_P( REGISTER_TYPED_TEST_SUITE_P(TrimmedTest, Test1, Test2, Test3, Test4,
TrimmedTest, Test5); // NOLINT
Test1, Test2,Test3 , Test4 ,Test5 ); // NOLINT template <typename T1, typename T2>
template <typename T1, typename T2> struct MyPair {}; struct MyPair {};
// Be sure to try a type with a comma in its name just in case it matters. // 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; typedef Types<int, double, MyPair<int, int> > TrimTypes;
INSTANTIATE_TYPED_TEST_SUITE_P(My, TrimmedTest, TrimTypes); INSTANTIATE_TYPED_TEST_SUITE_P(My, TrimmedTest, TrimTypes);
} // namespace library2 } // namespace library2
 End of changes. 15 change blocks. 
33 lines changed or deleted 20 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)