Home | History | Annotate | Download | only in test
      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 // Author: vladl (at) google.com (Vlad Losev)
     31 //
     32 // Tests for Google Test itself. This file verifies that the parameter
     33 // generators objects produce correct parameter sequences and that
     34 // Google Test runtime instantiates correct tests from those sequences.
     35 
     36 #include "gtest/gtest.h"
     37 
     38 #if GTEST_HAS_PARAM_TEST
     39 
     40 # include <algorithm>
     41 # include <iostream>
     42 # include <list>
     43 # include <sstream>
     44 # include <string>
     45 # include <vector>
     46 
     47 // To include gtest-internal-inl.h.
     48 # define GTEST_IMPLEMENTATION_ 1
     49 # include "src/gtest-internal-inl.h"  // for UnitTestOptions
     50 # undef GTEST_IMPLEMENTATION_
     51 
     52 # include "test/gtest-param-test_test.h"
     53 
     54 using ::std::vector;
     55 using ::std::sort;
     56 
     57 using ::testing::AddGlobalTestEnvironment;
     58 using ::testing::Bool;
     59 using ::testing::Message;
     60 using ::testing::Range;
     61 using ::testing::TestWithParam;
     62 using ::testing::Values;
     63 using ::testing::ValuesIn;
     64 
     65 # if GTEST_HAS_COMBINE
     66 using ::testing::Combine;
     67 using ::std::tr1::get;
     68 using ::std::tr1::make_tuple;
     69 using ::std::tr1::tuple;
     70 # endif  // GTEST_HAS_COMBINE
     71 
     72 using ::testing::internal::ParamGenerator;
     73 using ::testing::internal::UnitTestOptions;
     74 
     75 // Prints a value to a string.
     76 //
     77 // TODO(wan (at) google.com): remove PrintValue() when we move matchers and
     78 // EXPECT_THAT() from Google Mock to Google Test.  At that time, we
     79 // can write EXPECT_THAT(x, Eq(y)) to compare two tuples x and y, as
     80 // EXPECT_THAT() and the matchers know how to print tuples.
     81 template <typename T>
     82 ::std::string PrintValue(const T& value) {
     83   ::std::stringstream stream;
     84   stream << value;
     85   return stream.str();
     86 }
     87 
     88 # if GTEST_HAS_COMBINE
     89 
     90 // These overloads allow printing tuples in our tests.  We cannot
     91 // define an operator<< for tuples, as that definition needs to be in
     92 // the std namespace in order to be picked up by Google Test via
     93 // Argument-Dependent Lookup, yet defining anything in the std
     94 // namespace in non-STL code is undefined behavior.
     95 
     96 template <typename T1, typename T2>
     97 ::std::string PrintValue(const tuple<T1, T2>& value) {
     98   ::std::stringstream stream;
     99   stream << "(" << get<0>(value) << ", " << get<1>(value) << ")";
    100   return stream.str();
    101 }
    102 
    103 template <typename T1, typename T2, typename T3>
    104 ::std::string PrintValue(const tuple<T1, T2, T3>& value) {
    105   ::std::stringstream stream;
    106   stream << "(" << get<0>(value) << ", " << get<1>(value)
    107          << ", "<< get<2>(value) << ")";
    108   return stream.str();
    109 }
    110 
    111 template <typename T1, typename T2, typename T3, typename T4, typename T5,
    112           typename T6, typename T7, typename T8, typename T9, typename T10>
    113 ::std::string PrintValue(
    114     const tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& value) {
    115   ::std::stringstream stream;
    116   stream << "(" << get<0>(value) << ", " << get<1>(value)
    117          << ", "<< get<2>(value) << ", " << get<3>(value)
    118          << ", "<< get<4>(value) << ", " << get<5>(value)
    119          << ", "<< get<6>(value) << ", " << get<7>(value)
    120          << ", "<< get<8>(value) << ", " << get<9>(value) << ")";
    121   return stream.str();
    122 }
    123 
    124 # endif  // GTEST_HAS_COMBINE
    125 
    126 // Verifies that a sequence generated by the generator and accessed
    127 // via the iterator object matches the expected one using Google Test
    128 // assertions.
    129 template <typename T, size_t N>
    130 void VerifyGenerator(const ParamGenerator<T>& generator,
    131                      const T (&expected_values)[N]) {
    132   typename ParamGenerator<T>::iterator it = generator.begin();
    133   for (size_t i = 0; i < N; ++i) {
    134     ASSERT_FALSE(it == generator.end())
    135         << "At element " << i << " when accessing via an iterator "
    136         << "created with the copy constructor.\n";
    137     // We cannot use EXPECT_EQ() here as the values may be tuples,
    138     // which don't support <<.
    139     EXPECT_TRUE(expected_values[i] == *it)
    140         << "where i is " << i
    141         << ", expected_values[i] is " << PrintValue(expected_values[i])
    142         << ", *it is " << PrintValue(*it)
    143         << ", and 'it' is an iterator created with the copy constructor.\n";
    144     it++;
    145   }
    146   EXPECT_TRUE(it == generator.end())
    147         << "At the presumed end of sequence when accessing via an iterator "
    148         << "created with the copy constructor.\n";
    149 
    150   // Test the iterator assignment. The following lines verify that
    151   // the sequence accessed via an iterator initialized via the
    152   // assignment operator (as opposed to a copy constructor) matches
    153   // just the same.
    154   it = generator.begin();
    155   for (size_t i = 0; i < N; ++i) {
    156     ASSERT_FALSE(it == generator.end())
    157         << "At element " << i << " when accessing via an iterator "
    158         << "created with the assignment operator.\n";
    159     EXPECT_TRUE(expected_values[i] == *it)
    160         << "where i is " << i
    161         << ", expected_values[i] is " << PrintValue(expected_values[i])
    162         << ", *it is " << PrintValue(*it)
    163         << ", and 'it' is an iterator created with the copy constructor.\n";
    164     it++;
    165   }
    166   EXPECT_TRUE(it == generator.end())
    167         << "At the presumed end of sequence when accessing via an iterator "
    168         << "created with the assignment operator.\n";
    169 }
    170 
    171 template <typename T>
    172 void VerifyGeneratorIsEmpty(const ParamGenerator<T>& generator) {
    173   typename ParamGenerator<T>::iterator it = generator.begin();
    174   EXPECT_TRUE(it == generator.end());
    175 
    176   it = generator.begin();
    177   EXPECT_TRUE(it == generator.end());
    178 }
    179 
    180 // Generator tests. They test that each of the provided generator functions
    181 // generates an expected sequence of values. The general test pattern
    182 // instantiates a generator using one of the generator functions,
    183 // checks the sequence produced by the generator using its iterator API,
    184 // and then resets the iterator back to the beginning of the sequence
    185 // and checks the sequence again.
    186 
    187 // Tests that iterators produced by generator functions conform to the
    188 // ForwardIterator concept.
    189 TEST(IteratorTest, ParamIteratorConformsToForwardIteratorConcept) {
    190   const ParamGenerator<int> gen = Range(0, 10);
    191   ParamGenerator<int>::iterator it = gen.begin();
    192 
    193   // Verifies that iterator initialization works as expected.
    194   ParamGenerator<int>::iterator it2 = it;
    195   EXPECT_TRUE(*it == *it2) << "Initialized iterators must point to the "
    196                            << "element same as its source points to";
    197 
    198   // Verifies that iterator assignment works as expected.
    199   it++;
    200   EXPECT_FALSE(*it == *it2);
    201   it2 = it;
    202   EXPECT_TRUE(*it == *it2) << "Assigned iterators must point to the "
    203                            << "element same as its source points to";
    204 
    205   // Verifies that prefix operator++() returns *this.
    206   EXPECT_EQ(&it, &(++it)) << "Result of the prefix operator++ must be "
    207                           << "refer to the original object";
    208 
    209   // Verifies that the result of the postfix operator++ points to the value
    210   // pointed to by the original iterator.
    211   int original_value = *it;  // Have to compute it outside of macro call to be
    212                              // unaffected by the parameter evaluation order.
    213   EXPECT_EQ(original_value, *(it++));
    214 
    215   // Verifies that prefix and postfix operator++() advance an iterator
    216   // all the same.
    217   it2 = it;
    218   it++;
    219   ++it2;
    220   EXPECT_TRUE(*it == *it2);
    221 }
    222 
    223 // Tests that Range() generates the expected sequence.
    224 TEST(RangeTest, IntRangeWithDefaultStep) {
    225   const ParamGenerator<int> gen = Range(0, 3);
    226   const int expected_values[] = {0, 1, 2};
    227   VerifyGenerator(gen, expected_values);
    228 }
    229 
    230 // Edge case. Tests that Range() generates the single element sequence
    231 // as expected when provided with range limits that are equal.
    232 TEST(RangeTest, IntRangeSingleValue) {
    233   const ParamGenerator<int> gen = Range(0, 1);
    234   const int expected_values[] = {0};
    235   VerifyGenerator(gen, expected_values);
    236 }
    237 
    238 // Edge case. Tests that Range() with generates empty sequence when
    239 // supplied with an empty range.
    240 TEST(RangeTest, IntRangeEmpty) {
    241   const ParamGenerator<int> gen = Range(0, 0);
    242   VerifyGeneratorIsEmpty(gen);
    243 }
    244 
    245 // Tests that Range() with custom step (greater then one) generates
    246 // the expected sequence.
    247 TEST(RangeTest, IntRangeWithCustomStep) {
    248   const ParamGenerator<int> gen = Range(0, 9, 3);
    249   const int expected_values[] = {0, 3, 6};
    250   VerifyGenerator(gen, expected_values);
    251 }
    252 
    253 // Tests that Range() with custom step (greater then one) generates
    254 // the expected sequence when the last element does not fall on the
    255 // upper range limit. Sequences generated by Range() must not have
    256 // elements beyond the range limits.
    257 TEST(RangeTest, IntRangeWithCustomStepOverUpperBound) {
    258   const ParamGenerator<int> gen = Range(0, 4, 3);
    259   const int expected_values[] = {0, 3};
    260   VerifyGenerator(gen, expected_values);
    261 }
    262 
    263 // Verifies that Range works with user-defined types that define
    264 // copy constructor, operator=(), operator+(), and operator<().
    265 class DogAdder {
    266  public:
    267   explicit DogAdder(const char* a_value) : value_(a_value) {}
    268   DogAdder(const DogAdder& other) : value_(other.value_.c_str()) {}
    269 
    270   DogAdder operator=(const DogAdder& other) {
    271     if (this != &other)
    272       value_ = other.value_;
    273     return *this;
    274   }
    275   DogAdder operator+(const DogAdder& other) const {
    276     Message msg;
    277     msg << value_.c_str() << other.value_.c_str();
    278     return DogAdder(msg.GetString().c_str());
    279   }
    280   bool operator<(const DogAdder& other) const {
    281     return value_ < other.value_;
    282   }
    283   const std::string& value() const { return value_; }
    284 
    285  private:
    286   std::string value_;
    287 };
    288 
    289 TEST(RangeTest, WorksWithACustomType) {
    290   const ParamGenerator<DogAdder> gen =
    291       Range(DogAdder("cat"), DogAdder("catdogdog"), DogAdder("dog"));
    292   ParamGenerator<DogAdder>::iterator it = gen.begin();
    293 
    294   ASSERT_FALSE(it == gen.end());
    295   EXPECT_STREQ("cat", it->value().c_str());
    296 
    297   ASSERT_FALSE(++it == gen.end());
    298   EXPECT_STREQ("catdog", it->value().c_str());
    299 
    300   EXPECT_TRUE(++it == gen.end());
    301 }
    302 
    303 class IntWrapper {
    304  public:
    305   explicit IntWrapper(int a_value) : value_(a_value) {}
    306   IntWrapper(const IntWrapper& other) : value_(other.value_) {}
    307 
    308   IntWrapper operator=(const IntWrapper& other) {
    309     value_ = other.value_;
    310     return *this;
    311   }
    312   // operator+() adds a different type.
    313   IntWrapper operator+(int other) const { return IntWrapper(value_ + other); }
    314   bool operator<(const IntWrapper& other) const {
    315     return value_ < other.value_;
    316   }
    317   int value() const { return value_; }
    318 
    319  private:
    320   int value_;
    321 };
    322 
    323 TEST(RangeTest, WorksWithACustomTypeWithDifferentIncrementType) {
    324   const ParamGenerator<IntWrapper> gen = Range(IntWrapper(0), IntWrapper(2));
    325   ParamGenerator<IntWrapper>::iterator it = gen.begin();
    326 
    327   ASSERT_FALSE(it == gen.end());
    328   EXPECT_EQ(0, it->value());
    329 
    330   ASSERT_FALSE(++it == gen.end());
    331   EXPECT_EQ(1, it->value());
    332 
    333   EXPECT_TRUE(++it == gen.end());
    334 }
    335 
    336 // Tests that ValuesIn() with an array parameter generates
    337 // the expected sequence.
    338 TEST(ValuesInTest, ValuesInArray) {
    339   int array[] = {3, 5, 8};
    340   const ParamGenerator<int> gen = ValuesIn(array);
    341   VerifyGenerator(gen, array);
    342 }
    343 
    344 // Tests that ValuesIn() with a const array parameter generates
    345 // the expected sequence.
    346 TEST(ValuesInTest, ValuesInConstArray) {
    347   const int array[] = {3, 5, 8};
    348   const ParamGenerator<int> gen = ValuesIn(array);
    349   VerifyGenerator(gen, array);
    350 }
    351 
    352 // Edge case. Tests that ValuesIn() with an array parameter containing a
    353 // single element generates the single element sequence.
    354 TEST(ValuesInTest, ValuesInSingleElementArray) {
    355   int array[] = {42};
    356   const ParamGenerator<int> gen = ValuesIn(array);
    357   VerifyGenerator(gen, array);
    358 }
    359 
    360 // Tests that ValuesIn() generates the expected sequence for an STL
    361 // container (vector).
    362 TEST(ValuesInTest, ValuesInVector) {
    363   typedef ::std::vector<int> ContainerType;
    364   ContainerType values;
    365   values.push_back(3);
    366   values.push_back(5);
    367   values.push_back(8);
    368   const ParamGenerator<int> gen = ValuesIn(values);
    369 
    370   const int expected_values[] = {3, 5, 8};
    371   VerifyGenerator(gen, expected_values);
    372 }
    373 
    374 // Tests that ValuesIn() generates the expected sequence.
    375 TEST(ValuesInTest, ValuesInIteratorRange) {
    376   typedef ::std::vector<int> ContainerType;
    377   ContainerType values;
    378   values.push_back(3);
    379   values.push_back(5);
    380   values.push_back(8);
    381   const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
    382 
    383   const int expected_values[] = {3, 5, 8};
    384   VerifyGenerator(gen, expected_values);
    385 }
    386 
    387 // Edge case. Tests that ValuesIn() provided with an iterator range specifying a
    388 // single value generates a single-element sequence.
    389 TEST(ValuesInTest, ValuesInSingleElementIteratorRange) {
    390   typedef ::std::vector<int> ContainerType;
    391   ContainerType values;
    392   values.push_back(42);
    393   const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
    394 
    395   const int expected_values[] = {42};
    396   VerifyGenerator(gen, expected_values);
    397 }
    398 
    399 // Edge case. Tests that ValuesIn() provided with an empty iterator range
    400 // generates an empty sequence.
    401 TEST(ValuesInTest, ValuesInEmptyIteratorRange) {
    402   typedef ::std::vector<int> ContainerType;
    403   ContainerType values;
    404   const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
    405 
    406   VerifyGeneratorIsEmpty(gen);
    407 }
    408 
    409 // Tests that the Values() generates the expected sequence.
    410 TEST(ValuesTest, ValuesWorks) {
    411   const ParamGenerator<int> gen = Values(3, 5, 8);
    412 
    413   const int expected_values[] = {3, 5, 8};
    414   VerifyGenerator(gen, expected_values);
    415 }
    416 
    417 // Tests that Values() generates the expected sequences from elements of
    418 // different types convertible to ParamGenerator's parameter type.
    419 TEST(ValuesTest, ValuesWorksForValuesOfCompatibleTypes) {
    420   const ParamGenerator<double> gen = Values(3, 5.0f, 8.0);
    421 
    422   const double expected_values[] = {3.0, 5.0, 8.0};
    423   VerifyGenerator(gen, expected_values);
    424 }
    425 
    426 TEST(ValuesTest, ValuesWorksForMaxLengthList) {
    427   const ParamGenerator<int> gen = 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 
    434   const int expected_values[] = {
    435       10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
    436       110, 120, 130, 140, 150, 160, 170, 180, 190, 200,
    437       210, 220, 230, 240, 250, 260, 270, 280, 290, 300,
    438       310, 320, 330, 340, 350, 360, 370, 380, 390, 400,
    439       410, 420, 430, 440, 450, 460, 470, 480, 490, 500};
    440   VerifyGenerator(gen, expected_values);
    441 }
    442 
    443 // Edge case test. Tests that single-parameter Values() generates the sequence
    444 // with the single value.
    445 TEST(ValuesTest, ValuesWithSingleParameter) {
    446   const ParamGenerator<int> gen = Values(42);
    447 
    448   const int expected_values[] = {42};
    449   VerifyGenerator(gen, expected_values);
    450 }
    451 
    452 // Tests that Bool() generates sequence (false, true).
    453 TEST(BoolTest, BoolWorks) {
    454   const ParamGenerator<bool> gen = Bool();
    455 
    456   const bool expected_values[] = {false, true};
    457   VerifyGenerator(gen, expected_values);
    458 }
    459 
    460 # if GTEST_HAS_COMBINE
    461 
    462 // Tests that Combine() with two parameters generates the expected sequence.
    463 TEST(CombineTest, CombineWithTwoParameters) {
    464   const char* foo = "foo";
    465   const char* bar = "bar";
    466   const ParamGenerator<tuple<const char*, int> > gen =
    467       Combine(Values(foo, bar), Values(3, 4));
    468 
    469   tuple<const char*, int> expected_values[] = {
    470     make_tuple(foo, 3), make_tuple(foo, 4),
    471     make_tuple(bar, 3), make_tuple(bar, 4)};
    472   VerifyGenerator(gen, expected_values);
    473 }
    474 
    475 // Tests that Combine() with three parameters generates the expected sequence.
    476 TEST(CombineTest, CombineWithThreeParameters) {
    477   const ParamGenerator<tuple<int, int, int> > gen = Combine(Values(0, 1),
    478                                                             Values(3, 4),
    479                                                             Values(5, 6));
    480   tuple<int, int, int> expected_values[] = {
    481     make_tuple(0, 3, 5), make_tuple(0, 3, 6),
    482     make_tuple(0, 4, 5), make_tuple(0, 4, 6),
    483     make_tuple(1, 3, 5), make_tuple(1, 3, 6),
    484     make_tuple(1, 4, 5), make_tuple(1, 4, 6)};
    485   VerifyGenerator(gen, expected_values);
    486 }
    487 
    488 // Tests that the Combine() with the first parameter generating a single value
    489 // sequence generates a sequence with the number of elements equal to the
    490 // number of elements in the sequence generated by the second parameter.
    491 TEST(CombineTest, CombineWithFirstParameterSingleValue) {
    492   const ParamGenerator<tuple<int, int> > gen = Combine(Values(42),
    493                                                        Values(0, 1));
    494 
    495   tuple<int, int> expected_values[] = {make_tuple(42, 0), make_tuple(42, 1)};
    496   VerifyGenerator(gen, expected_values);
    497 }
    498 
    499 // Tests that the Combine() with the second parameter generating a single value
    500 // sequence generates a sequence with the number of elements equal to the
    501 // number of elements in the sequence generated by the first parameter.
    502 TEST(CombineTest, CombineWithSecondParameterSingleValue) {
    503   const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1),
    504                                                        Values(42));
    505 
    506   tuple<int, int> expected_values[] = {make_tuple(0, 42), make_tuple(1, 42)};
    507   VerifyGenerator(gen, expected_values);
    508 }
    509 
    510 // Tests that when the first parameter produces an empty sequence,
    511 // Combine() produces an empty sequence, too.
    512 TEST(CombineTest, CombineWithFirstParameterEmptyRange) {
    513   const ParamGenerator<tuple<int, int> > gen = Combine(Range(0, 0),
    514                                                        Values(0, 1));
    515   VerifyGeneratorIsEmpty(gen);
    516 }
    517 
    518 // Tests that when the second parameter produces an empty sequence,
    519 // Combine() produces an empty sequence, too.
    520 TEST(CombineTest, CombineWithSecondParameterEmptyRange) {
    521   const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1),
    522                                                        Range(1, 1));
    523   VerifyGeneratorIsEmpty(gen);
    524 }
    525 
    526 // Edge case. Tests that combine works with the maximum number
    527 // of parameters supported by Google Test (currently 10).
    528 TEST(CombineTest, CombineWithMaxNumberOfParameters) {
    529   const char* foo = "foo";
    530   const char* bar = "bar";
    531   const ParamGenerator<tuple<const char*, int, int, int, int, int, int, int,
    532                              int, int> > gen = Combine(Values(foo, bar),
    533                                                        Values(1), Values(2),
    534                                                        Values(3), Values(4),
    535                                                        Values(5), Values(6),
    536                                                        Values(7), Values(8),
    537                                                        Values(9));
    538 
    539   tuple<const char*, int, int, int, int, int, int, int, int, int>
    540       expected_values[] = {make_tuple(foo, 1, 2, 3, 4, 5, 6, 7, 8, 9),
    541                            make_tuple(bar, 1, 2, 3, 4, 5, 6, 7, 8, 9)};
    542   VerifyGenerator(gen, expected_values);
    543 }
    544 
    545 # endif  // GTEST_HAS_COMBINE
    546 
    547 // Tests that an generator produces correct sequence after being
    548 // assigned from another generator.
    549 TEST(ParamGeneratorTest, AssignmentWorks) {
    550   ParamGenerator<int> gen = Values(1, 2);
    551   const ParamGenerator<int> gen2 = Values(3, 4);
    552   gen = gen2;
    553 
    554   const int expected_values[] = {3, 4};
    555   VerifyGenerator(gen, expected_values);
    556 }
    557 
    558 // This test verifies that the tests are expanded and run as specified:
    559 // one test per element from the sequence produced by the generator
    560 // specified in INSTANTIATE_TEST_CASE_P. It also verifies that the test's
    561 // fixture constructor, SetUp(), and TearDown() have run and have been
    562 // supplied with the correct parameters.
    563 
    564 // The use of environment object allows detection of the case where no test
    565 // case functionality is run at all. In this case TestCaseTearDown will not
    566 // be able to detect missing tests, naturally.
    567 template <int kExpectedCalls>
    568 class TestGenerationEnvironment : public ::testing::Environment {
    569  public:
    570   static TestGenerationEnvironment* Instance() {
    571     static TestGenerationEnvironment* instance = new TestGenerationEnvironment;
    572     return instance;
    573   }
    574 
    575   void FixtureConstructorExecuted() { fixture_constructor_count_++; }
    576   void SetUpExecuted() { set_up_count_++; }
    577   void TearDownExecuted() { tear_down_count_++; }
    578   void TestBodyExecuted() { test_body_count_++; }
    579 
    580   virtual void TearDown() {
    581     // If all MultipleTestGenerationTest tests have been de-selected
    582     // by the filter flag, the following checks make no sense.
    583     bool perform_check = false;
    584 
    585     for (int i = 0; i < kExpectedCalls; ++i) {
    586       Message msg;
    587       msg << "TestsExpandedAndRun/" << i;
    588       if (UnitTestOptions::FilterMatchesTest(
    589              "TestExpansionModule/MultipleTestGenerationTest",
    590               msg.GetString().c_str())) {
    591         perform_check = true;
    592       }
    593     }
    594     if (perform_check) {
    595       EXPECT_EQ(kExpectedCalls, fixture_constructor_count_)
    596           << "Fixture constructor of ParamTestGenerationTest test case "
    597           << "has not been run as expected.";
    598       EXPECT_EQ(kExpectedCalls, set_up_count_)
    599           << "Fixture SetUp method of ParamTestGenerationTest test case "
    600           << "has not been run as expected.";
    601       EXPECT_EQ(kExpectedCalls, tear_down_count_)
    602           << "Fixture TearDown method of ParamTestGenerationTest test case "
    603           << "has not been run as expected.";
    604       EXPECT_EQ(kExpectedCalls, test_body_count_)
    605           << "Test in ParamTestGenerationTest test case "
    606           << "has not been run as expected.";
    607     }
    608   }
    609 
    610  private:
    611   TestGenerationEnvironment() : fixture_constructor_count_(0), set_up_count_(0),
    612                                 tear_down_count_(0), test_body_count_(0) {}
    613 
    614   int fixture_constructor_count_;
    615   int set_up_count_;
    616   int tear_down_count_;
    617   int test_body_count_;
    618 
    619   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationEnvironment);
    620 };
    621 
    622 const int test_generation_params[] = {36, 42, 72};
    623 
    624 class TestGenerationTest : public TestWithParam<int> {
    625  public:
    626   enum {
    627     PARAMETER_COUNT =
    628         sizeof(test_generation_params)/sizeof(test_generation_params[0])
    629   };
    630 
    631   typedef TestGenerationEnvironment<PARAMETER_COUNT> Environment;
    632 
    633   TestGenerationTest() {
    634     Environment::Instance()->FixtureConstructorExecuted();
    635     current_parameter_ = GetParam();
    636   }
    637   virtual void SetUp() {
    638     Environment::Instance()->SetUpExecuted();
    639     EXPECT_EQ(current_parameter_, GetParam());
    640   }
    641   virtual void TearDown() {
    642     Environment::Instance()->TearDownExecuted();
    643     EXPECT_EQ(current_parameter_, GetParam());
    644   }
    645 
    646   static void SetUpTestCase() {
    647     bool all_tests_in_test_case_selected = true;
    648 
    649     for (int i = 0; i < PARAMETER_COUNT; ++i) {
    650       Message test_name;
    651       test_name << "TestsExpandedAndRun/" << i;
    652       if ( !UnitTestOptions::FilterMatchesTest(
    653                 "TestExpansionModule/MultipleTestGenerationTest",
    654                 test_name.GetString())) {
    655         all_tests_in_test_case_selected = false;
    656       }
    657     }
    658     EXPECT_TRUE(all_tests_in_test_case_selected)
    659         << "When running the TestGenerationTest test case all of its tests\n"
    660         << "must be selected by the filter flag for the test case to pass.\n"
    661         << "If not all of them are enabled, we can't reliably conclude\n"
    662         << "that the correct number of tests have been generated.";
    663 
    664     collected_parameters_.clear();
    665   }
    666 
    667   static void TearDownTestCase() {
    668     vector<int> expected_values(test_generation_params,
    669                                 test_generation_params + PARAMETER_COUNT);
    670     // Test execution order is not guaranteed by Google Test,
    671     // so the order of values in collected_parameters_ can be
    672     // different and we have to sort to compare.
    673     sort(expected_values.begin(), expected_values.end());
    674     sort(collected_parameters_.begin(), collected_parameters_.end());
    675 
    676     EXPECT_TRUE(collected_parameters_ == expected_values);
    677   }
    678 
    679  protected:
    680   int current_parameter_;
    681   static vector<int> collected_parameters_;
    682 
    683  private:
    684   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationTest);
    685 };
    686 vector<int> TestGenerationTest::collected_parameters_;
    687 
    688 TEST_P(TestGenerationTest, TestsExpandedAndRun) {
    689   Environment::Instance()->TestBodyExecuted();
    690   EXPECT_EQ(current_parameter_, GetParam());
    691   collected_parameters_.push_back(GetParam());
    692 }
    693 INSTANTIATE_TEST_CASE_P(TestExpansionModule, TestGenerationTest,
    694                         ValuesIn(test_generation_params));
    695 
    696 // This test verifies that the element sequence (third parameter of
    697 // INSTANTIATE_TEST_CASE_P) is evaluated in InitGoogleTest() and neither at
    698 // the call site of INSTANTIATE_TEST_CASE_P nor in RUN_ALL_TESTS().  For
    699 // that, we declare param_value_ to be a static member of
    700 // GeneratorEvaluationTest and initialize it to 0.  We set it to 1 in
    701 // main(), just before invocation of InitGoogleTest().  After calling
    702 // InitGoogleTest(), we set the value to 2.  If the sequence is evaluated
    703 // before or after InitGoogleTest, INSTANTIATE_TEST_CASE_P will create a
    704 // test with parameter other than 1, and the test body will fail the
    705 // assertion.
    706 class GeneratorEvaluationTest : public TestWithParam<int> {
    707  public:
    708   static int param_value() { return param_value_; }
    709   static void set_param_value(int param_value) { param_value_ = param_value; }
    710 
    711  private:
    712   static int param_value_;
    713 };
    714 int GeneratorEvaluationTest::param_value_ = 0;
    715 
    716 TEST_P(GeneratorEvaluationTest, GeneratorsEvaluatedInMain) {
    717   EXPECT_EQ(1, GetParam());
    718 }
    719 INSTANTIATE_TEST_CASE_P(GenEvalModule,
    720                         GeneratorEvaluationTest,
    721                         Values(GeneratorEvaluationTest::param_value()));
    722 
    723 // Tests that generators defined in a different translation unit are
    724 // functional. Generator extern_gen is defined in gtest-param-test_test2.cc.
    725 extern ParamGenerator<int> extern_gen;
    726 class ExternalGeneratorTest : public TestWithParam<int> {};
    727 TEST_P(ExternalGeneratorTest, ExternalGenerator) {
    728   // Sequence produced by extern_gen contains only a single value
    729   // which we verify here.
    730   EXPECT_EQ(GetParam(), 33);
    731 }
    732 INSTANTIATE_TEST_CASE_P(ExternalGeneratorModule,
    733                         ExternalGeneratorTest,
    734                         extern_gen);
    735 
    736 // Tests that a parameterized test case can be defined in one translation
    737 // unit and instantiated in another. This test will be instantiated in
    738 // gtest-param-test_test2.cc. ExternalInstantiationTest fixture class is
    739 // defined in gtest-param-test_test.h.
    740 TEST_P(ExternalInstantiationTest, IsMultipleOf33) {
    741   EXPECT_EQ(0, GetParam() % 33);
    742 }
    743 
    744 // Tests that a parameterized test case can be instantiated with multiple
    745 // generators.
    746 class MultipleInstantiationTest : public TestWithParam<int> {};
    747 TEST_P(MultipleInstantiationTest, AllowsMultipleInstances) {
    748 }
    749 INSTANTIATE_TEST_CASE_P(Sequence1, MultipleInstantiationTest, Values(1, 2));
    750 INSTANTIATE_TEST_CASE_P(Sequence2, MultipleInstantiationTest, Range(3, 5));
    751 
    752 // Tests that a parameterized test case can be instantiated
    753 // in multiple translation units. This test will be instantiated
    754 // here and in gtest-param-test_test2.cc.
    755 // InstantiationInMultipleTranslationUnitsTest fixture class
    756 // is defined in gtest-param-test_test.h.
    757 TEST_P(InstantiationInMultipleTranslaionUnitsTest, IsMultipleOf42) {
    758   EXPECT_EQ(0, GetParam() % 42);
    759 }
    760 INSTANTIATE_TEST_CASE_P(Sequence1,
    761                         InstantiationInMultipleTranslaionUnitsTest,
    762                         Values(42, 42*2));
    763 
    764 // Tests that each iteration of parameterized test runs in a separate test
    765 // object.
    766 class SeparateInstanceTest : public TestWithParam<int> {
    767  public:
    768   SeparateInstanceTest() : count_(0) {}
    769 
    770   static void TearDownTestCase() {
    771     EXPECT_GE(global_count_, 2)
    772         << "If some (but not all) SeparateInstanceTest tests have been "
    773         << "filtered out this test will fail. Make sure that all "
    774         << "GeneratorEvaluationTest are selected or de-selected together "
    775         << "by the test filter.";
    776   }
    777 
    778  protected:
    779   int count_;
    780   static int global_count_;
    781 };
    782 int SeparateInstanceTest::global_count_ = 0;
    783 
    784 TEST_P(SeparateInstanceTest, TestsRunInSeparateInstances) {
    785   EXPECT_EQ(0, count_++);
    786   global_count_++;
    787 }
    788 INSTANTIATE_TEST_CASE_P(FourElemSequence, SeparateInstanceTest, Range(1, 4));
    789 
    790 // Tests that all instantiations of a test have named appropriately. Test
    791 // defined with TEST_P(TestCaseName, TestName) and instantiated with
    792 // INSTANTIATE_TEST_CASE_P(SequenceName, TestCaseName, generator) must be named
    793 // SequenceName/TestCaseName.TestName/i, where i is the 0-based index of the
    794 // sequence element used to instantiate the test.
    795 class NamingTest : public TestWithParam<int> {};
    796 
    797 TEST_P(NamingTest, TestsReportCorrectNamesAndParameters) {
    798   const ::testing::TestInfo* const test_info =
    799      ::testing::UnitTest::GetInstance()->current_test_info();
    800 
    801   EXPECT_STREQ("ZeroToFiveSequence/NamingTest", test_info->test_case_name());
    802 
    803   Message index_stream;
    804   index_stream << "TestsReportCorrectNamesAndParameters/" << GetParam();
    805   EXPECT_STREQ(index_stream.GetString().c_str(), test_info->name());
    806 
    807   EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param());
    808 }
    809 
    810 INSTANTIATE_TEST_CASE_P(ZeroToFiveSequence, NamingTest, Range(0, 5));
    811 
    812 // Class that cannot be streamed into an ostream.  It needs to be copyable
    813 // (and, in case of MSVC, also assignable) in order to be a test parameter
    814 // type.  Its default copy constructor and assignment operator do exactly
    815 // what we need.
    816 class Unstreamable {
    817  public:
    818   explicit Unstreamable(int value) : value_(value) {}
    819 
    820  private:
    821   int value_;
    822 };
    823 
    824 class CommentTest : public TestWithParam<Unstreamable> {};
    825 
    826 TEST_P(CommentTest, TestsCorrectlyReportUnstreamableParams) {
    827   const ::testing::TestInfo* const test_info =
    828      ::testing::UnitTest::GetInstance()->current_test_info();
    829 
    830   EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param());
    831 }
    832 
    833 INSTANTIATE_TEST_CASE_P(InstantiationWithComments,
    834                         CommentTest,
    835                         Values(Unstreamable(1)));
    836 
    837 // Verify that we can create a hierarchy of test fixtures, where the base
    838 // class fixture is not parameterized and the derived class is. In this case
    839 // ParameterizedDerivedTest inherits from NonParameterizedBaseTest.  We
    840 // perform simple tests on both.
    841 class NonParameterizedBaseTest : public ::testing::Test {
    842  public:
    843   NonParameterizedBaseTest() : n_(17) { }
    844  protected:
    845   int n_;
    846 };
    847 
    848 class ParameterizedDerivedTest : public NonParameterizedBaseTest,
    849                                  public ::testing::WithParamInterface<int> {
    850  protected:
    851   ParameterizedDerivedTest() : count_(0) { }
    852   int count_;
    853   static int global_count_;
    854 };
    855 
    856 int ParameterizedDerivedTest::global_count_ = 0;
    857 
    858 TEST_F(NonParameterizedBaseTest, FixtureIsInitialized) {
    859   EXPECT_EQ(17, n_);
    860 }
    861 
    862 TEST_P(ParameterizedDerivedTest, SeesSequence) {
    863   EXPECT_EQ(17, n_);
    864   EXPECT_EQ(0, count_++);
    865   EXPECT_EQ(GetParam(), global_count_++);
    866 }
    867 
    868 class ParameterizedDeathTest : public ::testing::TestWithParam<int> { };
    869 
    870 TEST_F(ParameterizedDeathTest, GetParamDiesFromTestF) {
    871   EXPECT_DEATH_IF_SUPPORTED(GetParam(),
    872                             ".* value-parameterized test .*");
    873 }
    874 
    875 INSTANTIATE_TEST_CASE_P(RangeZeroToFive, ParameterizedDerivedTest, Range(0, 5));
    876 
    877 #endif  // GTEST_HAS_PARAM_TEST
    878 
    879 TEST(CompileTest, CombineIsDefinedOnlyWhenGtestHasParamTestIsDefined) {
    880 #if GTEST_HAS_COMBINE && !GTEST_HAS_PARAM_TEST
    881   FAIL() << "GTEST_HAS_COMBINE is defined while GTEST_HAS_PARAM_TEST is not\n"
    882 #endif
    883 }
    884 
    885 int main(int argc, char **argv) {
    886 #if GTEST_HAS_PARAM_TEST
    887   // Used in TestGenerationTest test case.
    888   AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance());
    889   // Used in GeneratorEvaluationTest test case. Tests that the updated value
    890   // will be picked up for instantiating tests in GeneratorEvaluationTest.
    891   GeneratorEvaluationTest::set_param_value(1);
    892 #endif  // GTEST_HAS_PARAM_TEST
    893 
    894   ::testing::InitGoogleTest(&argc, argv);
    895 
    896 #if GTEST_HAS_PARAM_TEST
    897   // Used in GeneratorEvaluationTest test case. Tests that value updated
    898   // here will NOT be used for instantiating tests in
    899   // GeneratorEvaluationTest.
    900   GeneratorEvaluationTest::set_param_value(2);
    901 #endif  // GTEST_HAS_PARAM_TEST
    902 
    903   return RUN_ALL_TESTS();
    904 }
    905