1 // Copyright 2008, Google Inc. 2 // All rights reserved. 3 // 4 // Redistribution and use in source and binary forms, with or without 5 // modification, are permitted provided that the following conditions are 6 // met: 7 // 8 // * Redistributions of source code must retain the above copyright 9 // notice, this list of conditions and the following disclaimer. 10 // * Redistributions in binary form must reproduce the above 11 // copyright notice, this list of conditions and the following disclaimer 12 // in the documentation and/or other materials provided with the 13 // distribution. 14 // * Neither the name of Google Inc. nor the names of its 15 // contributors may be used to endorse or promote products derived from 16 // this software without specific prior written permission. 17 // 18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 30 // 31 // Tests for Google Test itself. This file verifies that the parameter 32 // generators objects produce correct parameter sequences and that 33 // Google Test runtime instantiates correct tests from those sequences. 34 35 #include "gtest/gtest.h" 36 37 # include <algorithm> 38 # include <iostream> 39 # include <list> 40 # include <sstream> 41 # include <string> 42 # include <vector> 43 44 # include "src/gtest-internal-inl.h" // for UnitTestOptions 45 # include "test/googletest-param-test-test.h" 46 47 using ::std::vector; 48 using ::std::sort; 49 50 using ::testing::AddGlobalTestEnvironment; 51 using ::testing::Bool; 52 using ::testing::Message; 53 using ::testing::Range; 54 using ::testing::TestWithParam; 55 using ::testing::Values; 56 using ::testing::ValuesIn; 57 58 # if GTEST_HAS_COMBINE 59 using ::testing::Combine; 60 using ::testing::get; 61 using ::testing::make_tuple; 62 using ::testing::tuple; 63 # endif // GTEST_HAS_COMBINE 64 65 using ::testing::internal::ParamGenerator; 66 using ::testing::internal::UnitTestOptions; 67 68 // Prints a value to a string. 69 // 70 // FIXME: remove PrintValue() when we move matchers and 71 // EXPECT_THAT() from Google Mock to Google Test. At that time, we 72 // can write EXPECT_THAT(x, Eq(y)) to compare two tuples x and y, as 73 // EXPECT_THAT() and the matchers know how to print tuples. 74 template <typename T> 75 ::std::string PrintValue(const T& value) { 76 ::std::stringstream stream; 77 stream << value; 78 return stream.str(); 79 } 80 81 # if GTEST_HAS_COMBINE 82 83 // These overloads allow printing tuples in our tests. We cannot 84 // define an operator<< for tuples, as that definition needs to be in 85 // the std namespace in order to be picked up by Google Test via 86 // Argument-Dependent Lookup, yet defining anything in the std 87 // namespace in non-STL code is undefined behavior. 88 89 template <typename T1, typename T2> 90 ::std::string PrintValue(const tuple<T1, T2>& value) { 91 ::std::stringstream stream; 92 stream << "(" << get<0>(value) << ", " << get<1>(value) << ")"; 93 return stream.str(); 94 } 95 96 template <typename T1, typename T2, typename T3> 97 ::std::string PrintValue(const tuple<T1, T2, T3>& value) { 98 ::std::stringstream stream; 99 stream << "(" << get<0>(value) << ", " << get<1>(value) 100 << ", "<< get<2>(value) << ")"; 101 return stream.str(); 102 } 103 104 template <typename T1, typename T2, typename T3, typename T4, typename T5, 105 typename T6, typename T7, typename T8, typename T9, typename T10> 106 ::std::string PrintValue( 107 const tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& value) { 108 ::std::stringstream stream; 109 stream << "(" << get<0>(value) << ", " << get<1>(value) 110 << ", "<< get<2>(value) << ", " << get<3>(value) 111 << ", "<< get<4>(value) << ", " << get<5>(value) 112 << ", "<< get<6>(value) << ", " << get<7>(value) 113 << ", "<< get<8>(value) << ", " << get<9>(value) << ")"; 114 return stream.str(); 115 } 116 117 # endif // GTEST_HAS_COMBINE 118 119 // Verifies that a sequence generated by the generator and accessed 120 // via the iterator object matches the expected one using Google Test 121 // assertions. 122 template <typename T, size_t N> 123 void VerifyGenerator(const ParamGenerator<T>& generator, 124 const T (&expected_values)[N]) { 125 typename ParamGenerator<T>::iterator it = generator.begin(); 126 for (size_t i = 0; i < N; ++i) { 127 ASSERT_FALSE(it == generator.end()) 128 << "At element " << i << " when accessing via an iterator " 129 << "created with the copy constructor.\n"; 130 // We cannot use EXPECT_EQ() here as the values may be tuples, 131 // which don't support <<. 132 EXPECT_TRUE(expected_values[i] == *it) 133 << "where i is " << i 134 << ", expected_values[i] is " << PrintValue(expected_values[i]) 135 << ", *it is " << PrintValue(*it) 136 << ", and 'it' is an iterator created with the copy constructor.\n"; 137 ++it; 138 } 139 EXPECT_TRUE(it == generator.end()) 140 << "At the presumed end of sequence when accessing via an iterator " 141 << "created with the copy constructor.\n"; 142 143 // Test the iterator assignment. The following lines verify that 144 // the sequence accessed via an iterator initialized via the 145 // assignment operator (as opposed to a copy constructor) matches 146 // just the same. 147 it = generator.begin(); 148 for (size_t i = 0; i < N; ++i) { 149 ASSERT_FALSE(it == generator.end()) 150 << "At element " << i << " when accessing via an iterator " 151 << "created with the assignment operator.\n"; 152 EXPECT_TRUE(expected_values[i] == *it) 153 << "where i is " << i 154 << ", expected_values[i] is " << PrintValue(expected_values[i]) 155 << ", *it is " << PrintValue(*it) 156 << ", and 'it' is an iterator created with the copy constructor.\n"; 157 ++it; 158 } 159 EXPECT_TRUE(it == generator.end()) 160 << "At the presumed end of sequence when accessing via an iterator " 161 << "created with the assignment operator.\n"; 162 } 163 164 template <typename T> 165 void VerifyGeneratorIsEmpty(const ParamGenerator<T>& generator) { 166 typename ParamGenerator<T>::iterator it = generator.begin(); 167 EXPECT_TRUE(it == generator.end()); 168 169 it = generator.begin(); 170 EXPECT_TRUE(it == generator.end()); 171 } 172 173 // Generator tests. They test that each of the provided generator functions 174 // generates an expected sequence of values. The general test pattern 175 // instantiates a generator using one of the generator functions, 176 // checks the sequence produced by the generator using its iterator API, 177 // and then resets the iterator back to the beginning of the sequence 178 // and checks the sequence again. 179 180 // Tests that iterators produced by generator functions conform to the 181 // ForwardIterator concept. 182 TEST(IteratorTest, ParamIteratorConformsToForwardIteratorConcept) { 183 const ParamGenerator<int> gen = Range(0, 10); 184 ParamGenerator<int>::iterator it = gen.begin(); 185 186 // Verifies that iterator initialization works as expected. 187 ParamGenerator<int>::iterator it2 = it; 188 EXPECT_TRUE(*it == *it2) << "Initialized iterators must point to the " 189 << "element same as its source points to"; 190 191 // Verifies that iterator assignment works as expected. 192 ++it; 193 EXPECT_FALSE(*it == *it2); 194 it2 = it; 195 EXPECT_TRUE(*it == *it2) << "Assigned iterators must point to the " 196 << "element same as its source points to"; 197 198 // Verifies that prefix operator++() returns *this. 199 EXPECT_EQ(&it, &(++it)) << "Result of the prefix operator++ must be " 200 << "refer to the original object"; 201 202 // Verifies that the result of the postfix operator++ points to the value 203 // pointed to by the original iterator. 204 int original_value = *it; // Have to compute it outside of macro call to be 205 // unaffected by the parameter evaluation order. 206 EXPECT_EQ(original_value, *(it++)); 207 208 // Verifies that prefix and postfix operator++() advance an iterator 209 // all the same. 210 it2 = it; 211 ++it; 212 ++it2; 213 EXPECT_TRUE(*it == *it2); 214 } 215 216 // Tests that Range() generates the expected sequence. 217 TEST(RangeTest, IntRangeWithDefaultStep) { 218 const ParamGenerator<int> gen = Range(0, 3); 219 const int expected_values[] = {0, 1, 2}; 220 VerifyGenerator(gen, expected_values); 221 } 222 223 // Edge case. Tests that Range() generates the single element sequence 224 // as expected when provided with range limits that are equal. 225 TEST(RangeTest, IntRangeSingleValue) { 226 const ParamGenerator<int> gen = Range(0, 1); 227 const int expected_values[] = {0}; 228 VerifyGenerator(gen, expected_values); 229 } 230 231 // Edge case. Tests that Range() with generates empty sequence when 232 // supplied with an empty range. 233 TEST(RangeTest, IntRangeEmpty) { 234 const ParamGenerator<int> gen = Range(0, 0); 235 VerifyGeneratorIsEmpty(gen); 236 } 237 238 // Tests that Range() with custom step (greater then one) generates 239 // the expected sequence. 240 TEST(RangeTest, IntRangeWithCustomStep) { 241 const ParamGenerator<int> gen = Range(0, 9, 3); 242 const int expected_values[] = {0, 3, 6}; 243 VerifyGenerator(gen, expected_values); 244 } 245 246 // Tests that Range() with custom step (greater then one) generates 247 // the expected sequence when the last element does not fall on the 248 // upper range limit. Sequences generated by Range() must not have 249 // elements beyond the range limits. 250 TEST(RangeTest, IntRangeWithCustomStepOverUpperBound) { 251 const ParamGenerator<int> gen = Range(0, 4, 3); 252 const int expected_values[] = {0, 3}; 253 VerifyGenerator(gen, expected_values); 254 } 255 256 // Verifies that Range works with user-defined types that define 257 // copy constructor, operator=(), operator+(), and operator<(). 258 class DogAdder { 259 public: 260 explicit DogAdder(const char* a_value) : value_(a_value) {} 261 DogAdder(const DogAdder& other) : value_(other.value_.c_str()) {} 262 263 DogAdder operator=(const DogAdder& other) { 264 if (this != &other) 265 value_ = other.value_; 266 return *this; 267 } 268 DogAdder operator+(const DogAdder& other) const { 269 Message msg; 270 msg << value_.c_str() << other.value_.c_str(); 271 return DogAdder(msg.GetString().c_str()); 272 } 273 bool operator<(const DogAdder& other) const { 274 return value_ < other.value_; 275 } 276 const std::string& value() const { return value_; } 277 278 private: 279 std::string value_; 280 }; 281 282 TEST(RangeTest, WorksWithACustomType) { 283 const ParamGenerator<DogAdder> gen = 284 Range(DogAdder("cat"), DogAdder("catdogdog"), DogAdder("dog")); 285 ParamGenerator<DogAdder>::iterator it = gen.begin(); 286 287 ASSERT_FALSE(it == gen.end()); 288 EXPECT_STREQ("cat", it->value().c_str()); 289 290 ASSERT_FALSE(++it == gen.end()); 291 EXPECT_STREQ("catdog", it->value().c_str()); 292 293 EXPECT_TRUE(++it == gen.end()); 294 } 295 296 class IntWrapper { 297 public: 298 explicit IntWrapper(int a_value) : value_(a_value) {} 299 IntWrapper(const IntWrapper& other) : value_(other.value_) {} 300 301 IntWrapper operator=(const IntWrapper& other) { 302 value_ = other.value_; 303 return *this; 304 } 305 // operator+() adds a different type. 306 IntWrapper operator+(int other) const { return IntWrapper(value_ + other); } 307 bool operator<(const IntWrapper& other) const { 308 return value_ < other.value_; 309 } 310 int value() const { return value_; } 311 312 private: 313 int value_; 314 }; 315 316 TEST(RangeTest, WorksWithACustomTypeWithDifferentIncrementType) { 317 const ParamGenerator<IntWrapper> gen = Range(IntWrapper(0), IntWrapper(2)); 318 ParamGenerator<IntWrapper>::iterator it = gen.begin(); 319 320 ASSERT_FALSE(it == gen.end()); 321 EXPECT_EQ(0, it->value()); 322 323 ASSERT_FALSE(++it == gen.end()); 324 EXPECT_EQ(1, it->value()); 325 326 EXPECT_TRUE(++it == gen.end()); 327 } 328 329 // Tests that ValuesIn() with an array parameter generates 330 // the expected sequence. 331 TEST(ValuesInTest, ValuesInArray) { 332 int array[] = {3, 5, 8}; 333 const ParamGenerator<int> gen = ValuesIn(array); 334 VerifyGenerator(gen, array); 335 } 336 337 // Tests that ValuesIn() with a const array parameter generates 338 // the expected sequence. 339 TEST(ValuesInTest, ValuesInConstArray) { 340 const int array[] = {3, 5, 8}; 341 const ParamGenerator<int> gen = ValuesIn(array); 342 VerifyGenerator(gen, array); 343 } 344 345 // Edge case. Tests that ValuesIn() with an array parameter containing a 346 // single element generates the single element sequence. 347 TEST(ValuesInTest, ValuesInSingleElementArray) { 348 int array[] = {42}; 349 const ParamGenerator<int> gen = ValuesIn(array); 350 VerifyGenerator(gen, array); 351 } 352 353 // Tests that ValuesIn() generates the expected sequence for an STL 354 // container (vector). 355 TEST(ValuesInTest, ValuesInVector) { 356 typedef ::std::vector<int> ContainerType; 357 ContainerType values; 358 values.push_back(3); 359 values.push_back(5); 360 values.push_back(8); 361 const ParamGenerator<int> gen = ValuesIn(values); 362 363 const int expected_values[] = {3, 5, 8}; 364 VerifyGenerator(gen, expected_values); 365 } 366 367 // Tests that ValuesIn() generates the expected sequence. 368 TEST(ValuesInTest, ValuesInIteratorRange) { 369 typedef ::std::vector<int> ContainerType; 370 ContainerType values; 371 values.push_back(3); 372 values.push_back(5); 373 values.push_back(8); 374 const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end()); 375 376 const int expected_values[] = {3, 5, 8}; 377 VerifyGenerator(gen, expected_values); 378 } 379 380 // Edge case. Tests that ValuesIn() provided with an iterator range specifying a 381 // single value generates a single-element sequence. 382 TEST(ValuesInTest, ValuesInSingleElementIteratorRange) { 383 typedef ::std::vector<int> ContainerType; 384 ContainerType values; 385 values.push_back(42); 386 const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end()); 387 388 const int expected_values[] = {42}; 389 VerifyGenerator(gen, expected_values); 390 } 391 392 // Edge case. Tests that ValuesIn() provided with an empty iterator range 393 // generates an empty sequence. 394 TEST(ValuesInTest, ValuesInEmptyIteratorRange) { 395 typedef ::std::vector<int> ContainerType; 396 ContainerType values; 397 const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end()); 398 399 VerifyGeneratorIsEmpty(gen); 400 } 401 402 // Tests that the Values() generates the expected sequence. 403 TEST(ValuesTest, ValuesWorks) { 404 const ParamGenerator<int> gen = Values(3, 5, 8); 405 406 const int expected_values[] = {3, 5, 8}; 407 VerifyGenerator(gen, expected_values); 408 } 409 410 // Tests that Values() generates the expected sequences from elements of 411 // different types convertible to ParamGenerator's parameter type. 412 TEST(ValuesTest, ValuesWorksForValuesOfCompatibleTypes) { 413 const ParamGenerator<double> gen = Values(3, 5.0f, 8.0); 414 415 const double expected_values[] = {3.0, 5.0, 8.0}; 416 VerifyGenerator(gen, expected_values); 417 } 418 419 TEST(ValuesTest, ValuesWorksForMaxLengthList) { 420 const ParamGenerator<int> gen = Values( 421 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 422 110, 120, 130, 140, 150, 160, 170, 180, 190, 200, 423 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 424 310, 320, 330, 340, 350, 360, 370, 380, 390, 400, 425 410, 420, 430, 440, 450, 460, 470, 480, 490, 500); 426 427 const int expected_values[] = { 428 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 429 110, 120, 130, 140, 150, 160, 170, 180, 190, 200, 430 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 431 310, 320, 330, 340, 350, 360, 370, 380, 390, 400, 432 410, 420, 430, 440, 450, 460, 470, 480, 490, 500}; 433 VerifyGenerator(gen, expected_values); 434 } 435 436 // Edge case test. Tests that single-parameter Values() generates the sequence 437 // with the single value. 438 TEST(ValuesTest, ValuesWithSingleParameter) { 439 const ParamGenerator<int> gen = Values(42); 440 441 const int expected_values[] = {42}; 442 VerifyGenerator(gen, expected_values); 443 } 444 445 // Tests that Bool() generates sequence (false, true). 446 TEST(BoolTest, BoolWorks) { 447 const ParamGenerator<bool> gen = Bool(); 448 449 const bool expected_values[] = {false, true}; 450 VerifyGenerator(gen, expected_values); 451 } 452 453 # if GTEST_HAS_COMBINE 454 455 // Tests that Combine() with two parameters generates the expected sequence. 456 TEST(CombineTest, CombineWithTwoParameters) { 457 const char* foo = "foo"; 458 const char* bar = "bar"; 459 const ParamGenerator<tuple<const char*, int> > gen = 460 Combine(Values(foo, bar), Values(3, 4)); 461 462 tuple<const char*, int> expected_values[] = { 463 make_tuple(foo, 3), make_tuple(foo, 4), 464 make_tuple(bar, 3), make_tuple(bar, 4)}; 465 VerifyGenerator(gen, expected_values); 466 } 467 468 // Tests that Combine() with three parameters generates the expected sequence. 469 TEST(CombineTest, CombineWithThreeParameters) { 470 const ParamGenerator<tuple<int, int, int> > gen = Combine(Values(0, 1), 471 Values(3, 4), 472 Values(5, 6)); 473 tuple<int, int, int> expected_values[] = { 474 make_tuple(0, 3, 5), make_tuple(0, 3, 6), 475 make_tuple(0, 4, 5), make_tuple(0, 4, 6), 476 make_tuple(1, 3, 5), make_tuple(1, 3, 6), 477 make_tuple(1, 4, 5), make_tuple(1, 4, 6)}; 478 VerifyGenerator(gen, expected_values); 479 } 480 481 // Tests that the Combine() with the first parameter generating a single value 482 // sequence generates a sequence with the number of elements equal to the 483 // number of elements in the sequence generated by the second parameter. 484 TEST(CombineTest, CombineWithFirstParameterSingleValue) { 485 const ParamGenerator<tuple<int, int> > gen = Combine(Values(42), 486 Values(0, 1)); 487 488 tuple<int, int> expected_values[] = {make_tuple(42, 0), make_tuple(42, 1)}; 489 VerifyGenerator(gen, expected_values); 490 } 491 492 // Tests that the Combine() with the second parameter generating a single value 493 // sequence generates a sequence with the number of elements equal to the 494 // number of elements in the sequence generated by the first parameter. 495 TEST(CombineTest, CombineWithSecondParameterSingleValue) { 496 const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1), 497 Values(42)); 498 499 tuple<int, int> expected_values[] = {make_tuple(0, 42), make_tuple(1, 42)}; 500 VerifyGenerator(gen, expected_values); 501 } 502 503 // Tests that when the first parameter produces an empty sequence, 504 // Combine() produces an empty sequence, too. 505 TEST(CombineTest, CombineWithFirstParameterEmptyRange) { 506 const ParamGenerator<tuple<int, int> > gen = Combine(Range(0, 0), 507 Values(0, 1)); 508 VerifyGeneratorIsEmpty(gen); 509 } 510 511 // Tests that when the second parameter produces an empty sequence, 512 // Combine() produces an empty sequence, too. 513 TEST(CombineTest, CombineWithSecondParameterEmptyRange) { 514 const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1), 515 Range(1, 1)); 516 VerifyGeneratorIsEmpty(gen); 517 } 518 519 // Edge case. Tests that combine works with the maximum number 520 // of parameters supported by Google Test (currently 10). 521 TEST(CombineTest, CombineWithMaxNumberOfParameters) { 522 const char* foo = "foo"; 523 const char* bar = "bar"; 524 const ParamGenerator<tuple<const char*, int, int, int, int, int, int, int, 525 int, int> > gen = Combine(Values(foo, bar), 526 Values(1), Values(2), 527 Values(3), Values(4), 528 Values(5), Values(6), 529 Values(7), Values(8), 530 Values(9)); 531 532 tuple<const char*, int, int, int, int, int, int, int, int, int> 533 expected_values[] = {make_tuple(foo, 1, 2, 3, 4, 5, 6, 7, 8, 9), 534 make_tuple(bar, 1, 2, 3, 4, 5, 6, 7, 8, 9)}; 535 VerifyGenerator(gen, expected_values); 536 } 537 538 #if GTEST_LANG_CXX11 539 540 class NonDefaultConstructAssignString { 541 public: 542 NonDefaultConstructAssignString(const std::string& s) : str_(s) {} 543 544 const std::string& str() const { return str_; } 545 546 private: 547 std::string str_; 548 549 // Not default constructible 550 NonDefaultConstructAssignString(); 551 // Not assignable 552 void operator=(const NonDefaultConstructAssignString&); 553 }; 554 555 TEST(CombineTest, NonDefaultConstructAssign) { 556 const ParamGenerator<tuple<int, NonDefaultConstructAssignString> > gen = 557 Combine(Values(0, 1), Values(NonDefaultConstructAssignString("A"), 558 NonDefaultConstructAssignString("B"))); 559 560 ParamGenerator<tuple<int, NonDefaultConstructAssignString> >::iterator it = 561 gen.begin(); 562 563 EXPECT_EQ(0, std::get<0>(*it)); 564 EXPECT_EQ("A", std::get<1>(*it).str()); 565 ++it; 566 567 EXPECT_EQ(0, std::get<0>(*it)); 568 EXPECT_EQ("B", std::get<1>(*it).str()); 569 ++it; 570 571 EXPECT_EQ(1, std::get<0>(*it)); 572 EXPECT_EQ("A", std::get<1>(*it).str()); 573 ++it; 574 575 EXPECT_EQ(1, std::get<0>(*it)); 576 EXPECT_EQ("B", std::get<1>(*it).str()); 577 ++it; 578 579 EXPECT_TRUE(it == gen.end()); 580 } 581 582 #endif // GTEST_LANG_CXX11 583 # endif // GTEST_HAS_COMBINE 584 585 // Tests that an generator produces correct sequence after being 586 // assigned from another generator. 587 TEST(ParamGeneratorTest, AssignmentWorks) { 588 ParamGenerator<int> gen = Values(1, 2); 589 const ParamGenerator<int> gen2 = Values(3, 4); 590 gen = gen2; 591 592 const int expected_values[] = {3, 4}; 593 VerifyGenerator(gen, expected_values); 594 } 595 596 // This test verifies that the tests are expanded and run as specified: 597 // one test per element from the sequence produced by the generator 598 // specified in INSTANTIATE_TEST_CASE_P. It also verifies that the test's 599 // fixture constructor, SetUp(), and TearDown() have run and have been 600 // supplied with the correct parameters. 601 602 // The use of environment object allows detection of the case where no test 603 // case functionality is run at all. In this case TestCaseTearDown will not 604 // be able to detect missing tests, naturally. 605 template <int kExpectedCalls> 606 class TestGenerationEnvironment : public ::testing::Environment { 607 public: 608 static TestGenerationEnvironment* Instance() { 609 static TestGenerationEnvironment* instance = new TestGenerationEnvironment; 610 return instance; 611 } 612 613 void FixtureConstructorExecuted() { fixture_constructor_count_++; } 614 void SetUpExecuted() { set_up_count_++; } 615 void TearDownExecuted() { tear_down_count_++; } 616 void TestBodyExecuted() { test_body_count_++; } 617 618 virtual void TearDown() { 619 // If all MultipleTestGenerationTest tests have been de-selected 620 // by the filter flag, the following checks make no sense. 621 bool perform_check = false; 622 623 for (int i = 0; i < kExpectedCalls; ++i) { 624 Message msg; 625 msg << "TestsExpandedAndRun/" << i; 626 if (UnitTestOptions::FilterMatchesTest( 627 "TestExpansionModule/MultipleTestGenerationTest", 628 msg.GetString().c_str())) { 629 perform_check = true; 630 } 631 } 632 if (perform_check) { 633 EXPECT_EQ(kExpectedCalls, fixture_constructor_count_) 634 << "Fixture constructor of ParamTestGenerationTest test case " 635 << "has not been run as expected."; 636 EXPECT_EQ(kExpectedCalls, set_up_count_) 637 << "Fixture SetUp method of ParamTestGenerationTest test case " 638 << "has not been run as expected."; 639 EXPECT_EQ(kExpectedCalls, tear_down_count_) 640 << "Fixture TearDown method of ParamTestGenerationTest test case " 641 << "has not been run as expected."; 642 EXPECT_EQ(kExpectedCalls, test_body_count_) 643 << "Test in ParamTestGenerationTest test case " 644 << "has not been run as expected."; 645 } 646 } 647 648 private: 649 TestGenerationEnvironment() : fixture_constructor_count_(0), set_up_count_(0), 650 tear_down_count_(0), test_body_count_(0) {} 651 652 int fixture_constructor_count_; 653 int set_up_count_; 654 int tear_down_count_; 655 int test_body_count_; 656 657 GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationEnvironment); 658 }; 659 660 const int test_generation_params[] = {36, 42, 72}; 661 662 class TestGenerationTest : public TestWithParam<int> { 663 public: 664 enum { 665 PARAMETER_COUNT = 666 sizeof(test_generation_params)/sizeof(test_generation_params[0]) 667 }; 668 669 typedef TestGenerationEnvironment<PARAMETER_COUNT> Environment; 670 671 TestGenerationTest() { 672 Environment::Instance()->FixtureConstructorExecuted(); 673 current_parameter_ = GetParam(); 674 } 675 virtual void SetUp() { 676 Environment::Instance()->SetUpExecuted(); 677 EXPECT_EQ(current_parameter_, GetParam()); 678 } 679 virtual void TearDown() { 680 Environment::Instance()->TearDownExecuted(); 681 EXPECT_EQ(current_parameter_, GetParam()); 682 } 683 684 static void SetUpTestCase() { 685 bool all_tests_in_test_case_selected = true; 686 687 for (int i = 0; i < PARAMETER_COUNT; ++i) { 688 Message test_name; 689 test_name << "TestsExpandedAndRun/" << i; 690 if ( !UnitTestOptions::FilterMatchesTest( 691 "TestExpansionModule/MultipleTestGenerationTest", 692 test_name.GetString())) { 693 all_tests_in_test_case_selected = false; 694 } 695 } 696 EXPECT_TRUE(all_tests_in_test_case_selected) 697 << "When running the TestGenerationTest test case all of its tests\n" 698 << "must be selected by the filter flag for the test case to pass.\n" 699 << "If not all of them are enabled, we can't reliably conclude\n" 700 << "that the correct number of tests have been generated."; 701 702 collected_parameters_.clear(); 703 } 704 705 static void TearDownTestCase() { 706 vector<int> expected_values(test_generation_params, 707 test_generation_params + PARAMETER_COUNT); 708 // Test execution order is not guaranteed by Google Test, 709 // so the order of values in collected_parameters_ can be 710 // different and we have to sort to compare. 711 sort(expected_values.begin(), expected_values.end()); 712 sort(collected_parameters_.begin(), collected_parameters_.end()); 713 714 EXPECT_TRUE(collected_parameters_ == expected_values); 715 } 716 717 protected: 718 int current_parameter_; 719 static vector<int> collected_parameters_; 720 721 private: 722 GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationTest); 723 }; 724 vector<int> TestGenerationTest::collected_parameters_; 725 726 TEST_P(TestGenerationTest, TestsExpandedAndRun) { 727 Environment::Instance()->TestBodyExecuted(); 728 EXPECT_EQ(current_parameter_, GetParam()); 729 collected_parameters_.push_back(GetParam()); 730 } 731 INSTANTIATE_TEST_CASE_P(TestExpansionModule, TestGenerationTest, 732 ValuesIn(test_generation_params)); 733 734 // This test verifies that the element sequence (third parameter of 735 // INSTANTIATE_TEST_CASE_P) is evaluated in InitGoogleTest() and neither at 736 // the call site of INSTANTIATE_TEST_CASE_P nor in RUN_ALL_TESTS(). For 737 // that, we declare param_value_ to be a static member of 738 // GeneratorEvaluationTest and initialize it to 0. We set it to 1 in 739 // main(), just before invocation of InitGoogleTest(). After calling 740 // InitGoogleTest(), we set the value to 2. If the sequence is evaluated 741 // before or after InitGoogleTest, INSTANTIATE_TEST_CASE_P will create a 742 // test with parameter other than 1, and the test body will fail the 743 // assertion. 744 class GeneratorEvaluationTest : public TestWithParam<int> { 745 public: 746 static int param_value() { return param_value_; } 747 static void set_param_value(int param_value) { param_value_ = param_value; } 748 749 private: 750 static int param_value_; 751 }; 752 int GeneratorEvaluationTest::param_value_ = 0; 753 754 TEST_P(GeneratorEvaluationTest, GeneratorsEvaluatedInMain) { 755 EXPECT_EQ(1, GetParam()); 756 } 757 INSTANTIATE_TEST_CASE_P(GenEvalModule, 758 GeneratorEvaluationTest, 759 Values(GeneratorEvaluationTest::param_value())); 760 761 // Tests that generators defined in a different translation unit are 762 // functional. Generator extern_gen is defined in gtest-param-test_test2.cc. 763 extern ParamGenerator<int> extern_gen; 764 class ExternalGeneratorTest : public TestWithParam<int> {}; 765 TEST_P(ExternalGeneratorTest, ExternalGenerator) { 766 // Sequence produced by extern_gen contains only a single value 767 // which we verify here. 768 EXPECT_EQ(GetParam(), 33); 769 } 770 INSTANTIATE_TEST_CASE_P(ExternalGeneratorModule, 771 ExternalGeneratorTest, 772 extern_gen); 773 774 // Tests that a parameterized test case can be defined in one translation 775 // unit and instantiated in another. This test will be instantiated in 776 // gtest-param-test_test2.cc. ExternalInstantiationTest fixture class is 777 // defined in gtest-param-test_test.h. 778 TEST_P(ExternalInstantiationTest, IsMultipleOf33) { 779 EXPECT_EQ(0, GetParam() % 33); 780 } 781 782 // Tests that a parameterized test case can be instantiated with multiple 783 // generators. 784 class MultipleInstantiationTest : public TestWithParam<int> {}; 785 TEST_P(MultipleInstantiationTest, AllowsMultipleInstances) { 786 } 787 INSTANTIATE_TEST_CASE_P(Sequence1, MultipleInstantiationTest, Values(1, 2)); 788 INSTANTIATE_TEST_CASE_P(Sequence2, MultipleInstantiationTest, Range(3, 5)); 789 790 // Tests that a parameterized test case can be instantiated 791 // in multiple translation units. This test will be instantiated 792 // here and in gtest-param-test_test2.cc. 793 // InstantiationInMultipleTranslationUnitsTest fixture class 794 // is defined in gtest-param-test_test.h. 795 TEST_P(InstantiationInMultipleTranslaionUnitsTest, IsMultipleOf42) { 796 EXPECT_EQ(0, GetParam() % 42); 797 } 798 INSTANTIATE_TEST_CASE_P(Sequence1, 799 InstantiationInMultipleTranslaionUnitsTest, 800 Values(42, 42*2)); 801 802 // Tests that each iteration of parameterized test runs in a separate test 803 // object. 804 class SeparateInstanceTest : public TestWithParam<int> { 805 public: 806 SeparateInstanceTest() : count_(0) {} 807 808 static void TearDownTestCase() { 809 EXPECT_GE(global_count_, 2) 810 << "If some (but not all) SeparateInstanceTest tests have been " 811 << "filtered out this test will fail. Make sure that all " 812 << "GeneratorEvaluationTest are selected or de-selected together " 813 << "by the test filter."; 814 } 815 816 protected: 817 int count_; 818 static int global_count_; 819 }; 820 int SeparateInstanceTest::global_count_ = 0; 821 822 TEST_P(SeparateInstanceTest, TestsRunInSeparateInstances) { 823 EXPECT_EQ(0, count_++); 824 global_count_++; 825 } 826 INSTANTIATE_TEST_CASE_P(FourElemSequence, SeparateInstanceTest, Range(1, 4)); 827 828 // Tests that all instantiations of a test have named appropriately. Test 829 // defined with TEST_P(TestCaseName, TestName) and instantiated with 830 // INSTANTIATE_TEST_CASE_P(SequenceName, TestCaseName, generator) must be named 831 // SequenceName/TestCaseName.TestName/i, where i is the 0-based index of the 832 // sequence element used to instantiate the test. 833 class NamingTest : public TestWithParam<int> {}; 834 835 TEST_P(NamingTest, TestsReportCorrectNamesAndParameters) { 836 const ::testing::TestInfo* const test_info = 837 ::testing::UnitTest::GetInstance()->current_test_info(); 838 839 EXPECT_STREQ("ZeroToFiveSequence/NamingTest", test_info->test_case_name()); 840 841 Message index_stream; 842 index_stream << "TestsReportCorrectNamesAndParameters/" << GetParam(); 843 EXPECT_STREQ(index_stream.GetString().c_str(), test_info->name()); 844 845 EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param()); 846 } 847 848 INSTANTIATE_TEST_CASE_P(ZeroToFiveSequence, NamingTest, Range(0, 5)); 849 850 // Tests that macros in test names are expanded correctly. 851 class MacroNamingTest : public TestWithParam<int> {}; 852 853 #define PREFIX_WITH_FOO(test_name) Foo##test_name 854 #define PREFIX_WITH_MACRO(test_name) Macro##test_name 855 856 TEST_P(PREFIX_WITH_MACRO(NamingTest), PREFIX_WITH_FOO(SomeTestName)) { 857 const ::testing::TestInfo* const test_info = 858 ::testing::UnitTest::GetInstance()->current_test_info(); 859 860 EXPECT_STREQ("FortyTwo/MacroNamingTest", test_info->test_case_name()); 861 EXPECT_STREQ("FooSomeTestName", test_info->name()); 862 } 863 864 INSTANTIATE_TEST_CASE_P(FortyTwo, MacroNamingTest, Values(42)); 865 866 // Tests the same thing for non-parametrized tests. 867 class MacroNamingTestNonParametrized : public ::testing::Test {}; 868 869 TEST_F(PREFIX_WITH_MACRO(NamingTestNonParametrized), 870 PREFIX_WITH_FOO(SomeTestName)) { 871 const ::testing::TestInfo* const test_info = 872 ::testing::UnitTest::GetInstance()->current_test_info(); 873 874 EXPECT_STREQ("MacroNamingTestNonParametrized", test_info->test_case_name()); 875 EXPECT_STREQ("FooSomeTestName", test_info->name()); 876 } 877 878 // Tests that user supplied custom parameter names are working correctly. 879 // Runs the test with a builtin helper method which uses PrintToString, 880 // as well as a custom function and custom functor to ensure all possible 881 // uses work correctly. 882 class CustomFunctorNamingTest : public TestWithParam<std::string> {}; 883 TEST_P(CustomFunctorNamingTest, CustomTestNames) {} 884 885 struct CustomParamNameFunctor { 886 std::string operator()(const ::testing::TestParamInfo<std::string>& inf) { 887 return inf.param; 888 } 889 }; 890 891 INSTANTIATE_TEST_CASE_P(CustomParamNameFunctor, 892 CustomFunctorNamingTest, 893 Values(std::string("FunctorName")), 894 CustomParamNameFunctor()); 895 896 INSTANTIATE_TEST_CASE_P(AllAllowedCharacters, 897 CustomFunctorNamingTest, 898 Values("abcdefghijklmnopqrstuvwxyz", 899 "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 900 "01234567890_"), 901 CustomParamNameFunctor()); 902 903 inline std::string CustomParamNameFunction( 904 const ::testing::TestParamInfo<std::string>& inf) { 905 return inf.param; 906 } 907 908 class CustomFunctionNamingTest : public TestWithParam<std::string> {}; 909 TEST_P(CustomFunctionNamingTest, CustomTestNames) {} 910 911 INSTANTIATE_TEST_CASE_P(CustomParamNameFunction, 912 CustomFunctionNamingTest, 913 Values(std::string("FunctionName")), 914 CustomParamNameFunction); 915 916 #if GTEST_LANG_CXX11 917 918 // Test custom naming with a lambda 919 920 class CustomLambdaNamingTest : public TestWithParam<std::string> {}; 921 TEST_P(CustomLambdaNamingTest, CustomTestNames) {} 922 923 INSTANTIATE_TEST_CASE_P(CustomParamNameLambda, CustomLambdaNamingTest, 924 Values(std::string("LambdaName")), 925 [](const ::testing::TestParamInfo<std::string>& inf) { 926 return inf.param; 927 }); 928 929 #endif // GTEST_LANG_CXX11 930 931 TEST(CustomNamingTest, CheckNameRegistry) { 932 ::testing::UnitTest* unit_test = ::testing::UnitTest::GetInstance(); 933 std::set<std::string> test_names; 934 for (int case_num = 0; 935 case_num < unit_test->total_test_case_count(); 936 ++case_num) { 937 const ::testing::TestCase* test_case = unit_test->GetTestCase(case_num); 938 for (int test_num = 0; 939 test_num < test_case->total_test_count(); 940 ++test_num) { 941 const ::testing::TestInfo* test_info = test_case->GetTestInfo(test_num); 942 test_names.insert(std::string(test_info->name())); 943 } 944 } 945 EXPECT_EQ(1u, test_names.count("CustomTestNames/FunctorName")); 946 EXPECT_EQ(1u, test_names.count("CustomTestNames/FunctionName")); 947 #if GTEST_LANG_CXX11 948 EXPECT_EQ(1u, test_names.count("CustomTestNames/LambdaName")); 949 #endif // GTEST_LANG_CXX11 950 } 951 952 // Test a numeric name to ensure PrintToStringParamName works correctly. 953 954 class CustomIntegerNamingTest : public TestWithParam<int> {}; 955 956 TEST_P(CustomIntegerNamingTest, TestsReportCorrectNames) { 957 const ::testing::TestInfo* const test_info = 958 ::testing::UnitTest::GetInstance()->current_test_info(); 959 Message test_name_stream; 960 test_name_stream << "TestsReportCorrectNames/" << GetParam(); 961 EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name()); 962 } 963 964 INSTANTIATE_TEST_CASE_P(PrintToString, 965 CustomIntegerNamingTest, 966 Range(0, 5), 967 ::testing::PrintToStringParamName()); 968 969 // Test a custom struct with PrintToString. 970 971 struct CustomStruct { 972 explicit CustomStruct(int value) : x(value) {} 973 int x; 974 }; 975 976 std::ostream& operator<<(std::ostream& stream, const CustomStruct& val) { 977 stream << val.x; 978 return stream; 979 } 980 981 class CustomStructNamingTest : public TestWithParam<CustomStruct> {}; 982 983 TEST_P(CustomStructNamingTest, TestsReportCorrectNames) { 984 const ::testing::TestInfo* const test_info = 985 ::testing::UnitTest::GetInstance()->current_test_info(); 986 Message test_name_stream; 987 test_name_stream << "TestsReportCorrectNames/" << GetParam(); 988 EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name()); 989 } 990 991 INSTANTIATE_TEST_CASE_P(PrintToString, 992 CustomStructNamingTest, 993 Values(CustomStruct(0), CustomStruct(1)), 994 ::testing::PrintToStringParamName()); 995 996 // Test that using a stateful parameter naming function works as expected. 997 998 struct StatefulNamingFunctor { 999 StatefulNamingFunctor() : sum(0) {} 1000 std::string operator()(const ::testing::TestParamInfo<int>& info) { 1001 int value = info.param + sum; 1002 sum += info.param; 1003 return ::testing::PrintToString(value); 1004 } 1005 int sum; 1006 }; 1007 1008 class StatefulNamingTest : public ::testing::TestWithParam<int> { 1009 protected: 1010 StatefulNamingTest() : sum_(0) {} 1011 int sum_; 1012 }; 1013 1014 TEST_P(StatefulNamingTest, TestsReportCorrectNames) { 1015 const ::testing::TestInfo* const test_info = 1016 ::testing::UnitTest::GetInstance()->current_test_info(); 1017 sum_ += GetParam(); 1018 Message test_name_stream; 1019 test_name_stream << "TestsReportCorrectNames/" << sum_; 1020 EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name()); 1021 } 1022 1023 INSTANTIATE_TEST_CASE_P(StatefulNamingFunctor, 1024 StatefulNamingTest, 1025 Range(0, 5), 1026 StatefulNamingFunctor()); 1027 1028 // Class that cannot be streamed into an ostream. It needs to be copyable 1029 // (and, in case of MSVC, also assignable) in order to be a test parameter 1030 // type. Its default copy constructor and assignment operator do exactly 1031 // what we need. 1032 class Unstreamable { 1033 public: 1034 explicit Unstreamable(int value) : value_(value) {} 1035 1036 private: 1037 int value_; 1038 }; 1039 1040 class CommentTest : public TestWithParam<Unstreamable> {}; 1041 1042 TEST_P(CommentTest, TestsCorrectlyReportUnstreamableParams) { 1043 const ::testing::TestInfo* const test_info = 1044 ::testing::UnitTest::GetInstance()->current_test_info(); 1045 1046 EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param()); 1047 } 1048 1049 INSTANTIATE_TEST_CASE_P(InstantiationWithComments, 1050 CommentTest, 1051 Values(Unstreamable(1))); 1052 1053 // Verify that we can create a hierarchy of test fixtures, where the base 1054 // class fixture is not parameterized and the derived class is. In this case 1055 // ParameterizedDerivedTest inherits from NonParameterizedBaseTest. We 1056 // perform simple tests on both. 1057 class NonParameterizedBaseTest : public ::testing::Test { 1058 public: 1059 NonParameterizedBaseTest() : n_(17) { } 1060 protected: 1061 int n_; 1062 }; 1063 1064 class ParameterizedDerivedTest : public NonParameterizedBaseTest, 1065 public ::testing::WithParamInterface<int> { 1066 protected: 1067 ParameterizedDerivedTest() : count_(0) { } 1068 int count_; 1069 static int global_count_; 1070 }; 1071 1072 int ParameterizedDerivedTest::global_count_ = 0; 1073 1074 TEST_F(NonParameterizedBaseTest, FixtureIsInitialized) { 1075 EXPECT_EQ(17, n_); 1076 } 1077 1078 TEST_P(ParameterizedDerivedTest, SeesSequence) { 1079 EXPECT_EQ(17, n_); 1080 EXPECT_EQ(0, count_++); 1081 EXPECT_EQ(GetParam(), global_count_++); 1082 } 1083 1084 class ParameterizedDeathTest : public ::testing::TestWithParam<int> { }; 1085 1086 TEST_F(ParameterizedDeathTest, GetParamDiesFromTestF) { 1087 EXPECT_DEATH_IF_SUPPORTED(GetParam(), 1088 ".* value-parameterized test .*"); 1089 } 1090 1091 INSTANTIATE_TEST_CASE_P(RangeZeroToFive, ParameterizedDerivedTest, Range(0, 5)); 1092 1093 1094 int main(int argc, char **argv) { 1095 // Used in TestGenerationTest test case. 1096 AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance()); 1097 // Used in GeneratorEvaluationTest test case. Tests that the updated value 1098 // will be picked up for instantiating tests in GeneratorEvaluationTest. 1099 GeneratorEvaluationTest::set_param_value(1); 1100 1101 ::testing::InitGoogleTest(&argc, argv); 1102 1103 // Used in GeneratorEvaluationTest test case. Tests that value updated 1104 // here will NOT be used for instantiating tests in 1105 // GeneratorEvaluationTest. 1106 GeneratorEvaluationTest::set_param_value(2); 1107 1108 return RUN_ALL_TESTS(); 1109 } 1110