00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032 #include "test/gtest-typed-test_test.h"
00033
00034 #include <set>
00035 #include <vector>
00036
00037 #include "gtest/gtest.h"
00038
00039 using testing::Test;
00040
00041
00042
00043
00044 template <typename T>
00045 class CommonTest : public Test {
00046
00047
00048 public:
00049 static void SetUpTestCase() {
00050 shared_ = new T(5);
00051 }
00052
00053 static void TearDownTestCase() {
00054 delete shared_;
00055 shared_ = NULL;
00056 }
00057
00058
00059
00060 protected:
00061
00062
00063 typedef std::vector<T> Vector;
00064 typedef std::set<int> IntSet;
00065
00066 CommonTest() : value_(1) {}
00067
00068 virtual ~CommonTest() { EXPECT_EQ(3, value_); }
00069
00070 virtual void SetUp() {
00071 EXPECT_EQ(1, value_);
00072 value_++;
00073 }
00074
00075 virtual void TearDown() {
00076 EXPECT_EQ(2, value_);
00077 value_++;
00078 }
00079
00080 T value_;
00081 static T* shared_;
00082 };
00083
00084 template <typename T>
00085 T* CommonTest<T>::shared_ = NULL;
00086
00087
00088 #if GTEST_HAS_TYPED_TEST
00089
00090 using testing::Types;
00091
00092
00093
00094
00095 typedef Types<char, int> TwoTypes;
00096 TYPED_TEST_CASE(CommonTest, TwoTypes);
00097
00098 TYPED_TEST(CommonTest, ValuesAreCorrect) {
00099
00100
00101 EXPECT_EQ(5, *TestFixture::shared_);
00102
00103
00104
00105 typename TestFixture::Vector empty;
00106 EXPECT_EQ(0U, empty.size());
00107
00108 typename TestFixture::IntSet empty2;
00109 EXPECT_EQ(0U, empty2.size());
00110
00111
00112
00113 EXPECT_EQ(2, this->value_);
00114 }
00115
00116
00117
00118 TYPED_TEST(CommonTest, ValuesAreStillCorrect) {
00119
00120
00121 ASSERT_TRUE(this->shared_ != NULL);
00122 EXPECT_EQ(5, *this->shared_);
00123
00124
00125 EXPECT_EQ(static_cast<TypeParam>(2), this->value_);
00126 }
00127
00128
00129
00130
00131 template <typename T>
00132 class TypedTest1 : public Test {
00133 };
00134
00135
00136
00137 TYPED_TEST_CASE(TypedTest1, int);
00138 TYPED_TEST(TypedTest1, A) {}
00139
00140 template <typename T>
00141 class TypedTest2 : public Test {
00142 };
00143
00144
00145
00146 TYPED_TEST_CASE(TypedTest2, Types<int>);
00147
00148
00149
00150 TYPED_TEST(TypedTest2, A) {}
00151
00152
00153
00154 namespace library1 {
00155
00156 template <typename T>
00157 class NumericTest : public Test {
00158 };
00159
00160 typedef Types<int, long> NumericTypes;
00161 TYPED_TEST_CASE(NumericTest, NumericTypes);
00162
00163 TYPED_TEST(NumericTest, DefaultIsZero) {
00164 EXPECT_EQ(0, TypeParam());
00165 }
00166
00167 }
00168
00169 #endif // GTEST_HAS_TYPED_TEST
00170
00171
00172 #if GTEST_HAS_TYPED_TEST_P
00173
00174 using testing::Types;
00175 using testing::internal::TypedTestCasePState;
00176
00177
00178
00179 class TypedTestCasePStateTest : public Test {
00180 protected:
00181 virtual void SetUp() {
00182 state_.AddTestName("foo.cc", 0, "FooTest", "A");
00183 state_.AddTestName("foo.cc", 0, "FooTest", "B");
00184 state_.AddTestName("foo.cc", 0, "FooTest", "C");
00185 }
00186
00187 TypedTestCasePState state_;
00188 };
00189
00190 TEST_F(TypedTestCasePStateTest, SucceedsForMatchingList) {
00191 const char* tests = "A, B, C";
00192 EXPECT_EQ(tests,
00193 state_.VerifyRegisteredTestNames("foo.cc", 1, tests));
00194 }
00195
00196
00197
00198 TEST_F(TypedTestCasePStateTest, IgnoresOrderAndSpaces) {
00199 const char* tests = "A,C, B";
00200 EXPECT_EQ(tests,
00201 state_.VerifyRegisteredTestNames("foo.cc", 1, tests));
00202 }
00203
00204 typedef TypedTestCasePStateTest TypedTestCasePStateDeathTest;
00205
00206 TEST_F(TypedTestCasePStateDeathTest, DetectsDuplicates) {
00207 EXPECT_DEATH_IF_SUPPORTED(
00208 state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, A, C"),
00209 "foo\\.cc.1.?: Test A is listed more than once\\.");
00210 }
00211
00212 TEST_F(TypedTestCasePStateDeathTest, DetectsExtraTest) {
00213 EXPECT_DEATH_IF_SUPPORTED(
00214 state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, C, D"),
00215 "foo\\.cc.1.?: No test named D can be found in this test case\\.");
00216 }
00217
00218 TEST_F(TypedTestCasePStateDeathTest, DetectsMissedTest) {
00219 EXPECT_DEATH_IF_SUPPORTED(
00220 state_.VerifyRegisteredTestNames("foo.cc", 1, "A, C"),
00221 "foo\\.cc.1.?: You forgot to list test B\\.");
00222 }
00223
00224
00225
00226 TEST_F(TypedTestCasePStateDeathTest, DetectsTestAfterRegistration) {
00227 state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, C");
00228 EXPECT_DEATH_IF_SUPPORTED(
00229 state_.AddTestName("foo.cc", 2, "FooTest", "D"),
00230 "foo\\.cc.2.?: Test D must be defined before REGISTER_TYPED_TEST_CASE_P"
00231 "\\(FooTest, \\.\\.\\.\\)\\.");
00232 }
00233
00234
00235
00236
00237 template <typename T>
00238 class DerivedTest : public CommonTest<T> {
00239 };
00240
00241 TYPED_TEST_CASE_P(DerivedTest);
00242
00243 TYPED_TEST_P(DerivedTest, ValuesAreCorrect) {
00244
00245
00246 EXPECT_EQ(5, *TestFixture::shared_);
00247
00248
00249
00250 EXPECT_EQ(2, this->value_);
00251 }
00252
00253
00254
00255 TYPED_TEST_P(DerivedTest, ValuesAreStillCorrect) {
00256
00257
00258 ASSERT_TRUE(this->shared_ != NULL);
00259 EXPECT_EQ(5, *this->shared_);
00260 EXPECT_EQ(2, this->value_);
00261 }
00262
00263 REGISTER_TYPED_TEST_CASE_P(DerivedTest,
00264 ValuesAreCorrect, ValuesAreStillCorrect);
00265
00266 typedef Types<short, long> MyTwoTypes;
00267 INSTANTIATE_TYPED_TEST_CASE_P(My, DerivedTest, MyTwoTypes);
00268
00269
00270
00271
00272 template <typename T>
00273 class TypedTestP1 : public Test {
00274 };
00275
00276 TYPED_TEST_CASE_P(TypedTestP1);
00277
00278
00279
00280 typedef int IntAfterTypedTestCaseP;
00281
00282 TYPED_TEST_P(TypedTestP1, A) {}
00283 TYPED_TEST_P(TypedTestP1, B) {}
00284
00285
00286
00287 typedef int IntBeforeRegisterTypedTestCaseP;
00288
00289 REGISTER_TYPED_TEST_CASE_P(TypedTestP1, A, B);
00290
00291 template <typename T>
00292 class TypedTestP2 : public Test {
00293 };
00294
00295 TYPED_TEST_CASE_P(TypedTestP2);
00296
00297
00298
00299 TYPED_TEST_P(TypedTestP2, A) {}
00300
00301 REGISTER_TYPED_TEST_CASE_P(TypedTestP2, A);
00302
00303
00304
00305 IntAfterTypedTestCaseP after = 0;
00306 IntBeforeRegisterTypedTestCaseP before = 0;
00307
00308
00309
00310 INSTANTIATE_TYPED_TEST_CASE_P(Int, TypedTestP1, int);
00311 INSTANTIATE_TYPED_TEST_CASE_P(Int, TypedTestP2, Types<int>);
00312
00313
00314
00315 INSTANTIATE_TYPED_TEST_CASE_P(Double, TypedTestP2, Types<double>);
00316
00317
00318
00319
00320 typedef Types<std::vector<double>, std::set<char> > MyContainers;
00321 INSTANTIATE_TYPED_TEST_CASE_P(My, ContainerTest, MyContainers);
00322
00323
00324
00325
00326 namespace library2 {
00327
00328 template <typename T>
00329 class NumericTest : public Test {
00330 };
00331
00332 TYPED_TEST_CASE_P(NumericTest);
00333
00334 TYPED_TEST_P(NumericTest, DefaultIsZero) {
00335 EXPECT_EQ(0, TypeParam());
00336 }
00337
00338 TYPED_TEST_P(NumericTest, ZeroIsLessThanOne) {
00339 EXPECT_LT(TypeParam(0), TypeParam(1));
00340 }
00341
00342 REGISTER_TYPED_TEST_CASE_P(NumericTest,
00343 DefaultIsZero, ZeroIsLessThanOne);
00344 typedef Types<int, double> NumericTypes;
00345 INSTANTIATE_TYPED_TEST_CASE_P(My, NumericTest, NumericTypes);
00346
00347 static const char* GetTestName() {
00348 return testing::UnitTest::GetInstance()->current_test_info()->name();
00349 }
00350
00351 template <typename T> class TrimmedTest : public Test { };
00352 TYPED_TEST_CASE_P(TrimmedTest);
00353 TYPED_TEST_P(TrimmedTest, Test1) { EXPECT_STREQ("Test1", GetTestName()); }
00354 TYPED_TEST_P(TrimmedTest, Test2) { EXPECT_STREQ("Test2", GetTestName()); }
00355 TYPED_TEST_P(TrimmedTest, Test3) { EXPECT_STREQ("Test3", GetTestName()); }
00356 TYPED_TEST_P(TrimmedTest, Test4) { EXPECT_STREQ("Test4", GetTestName()); }
00357 TYPED_TEST_P(TrimmedTest, Test5) { EXPECT_STREQ("Test5", GetTestName()); }
00358 REGISTER_TYPED_TEST_CASE_P(
00359 TrimmedTest,
00360 Test1, Test2,Test3 , Test4 ,Test5 );
00361 template <typename T1, typename T2> struct MyPair {};
00362
00363 typedef Types<int, double, MyPair<int, int> > TrimTypes;
00364 INSTANTIATE_TYPED_TEST_CASE_P(My, TrimmedTest, TrimTypes);
00365
00366 }
00367
00368 #endif // GTEST_HAS_TYPED_TEST_P
00369
00370 #if !defined(GTEST_HAS_TYPED_TEST) && !defined(GTEST_HAS_TYPED_TEST_P)
00371
00372
00373
00374
00375
00376
00377
00378 TEST(DummyTest, TypedTestsAreNotSupportedOnThisPlatform) {}
00379
00380 #endif // #if !defined(GTEST_HAS_TYPED_TEST) && !defined(GTEST_HAS_TYPED_TEST_P)