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@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
54using ::std::vector;
55using ::std::sort;
56
57using ::testing::AddGlobalTestEnvironment;
58using ::testing::Bool;
59using ::testing::Message;
60using ::testing::Range;
61using ::testing::TestWithParam;
62using ::testing::Values;
63using ::testing::ValuesIn;
64
65# if GTEST_HAS_COMBINE
66using ::testing::Combine;
67using ::std::tr1::get;
68using ::std::tr1::make_tuple;
69using ::std::tr1::tuple;
70# endif  // GTEST_HAS_COMBINE
71
72using ::testing::internal::ParamGenerator;
73using ::testing::internal::UnitTestOptions;
74
75// Prints a value to a string.
76//
77// TODO(wan@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.
81template <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
96template <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
103template <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
111template <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.
129template <typename T, size_t N>
130void 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
171template <typename T>
172void 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.
189TEST(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.
224TEST(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.
232TEST(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.
240TEST(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.
247TEST(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.
257TEST(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<().
265class 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
289TEST(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
303class 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
323TEST(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.
338TEST(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.
346TEST(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.
354TEST(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).
362TEST(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.
375TEST(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.
389TEST(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.
401TEST(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.
410TEST(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.
419TEST(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
426TEST(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.
445TEST(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).
453TEST(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.
463TEST(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.
476TEST(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.
491TEST(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.
502TEST(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.
512TEST(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.
520TEST(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).
528TEST(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.
549TEST(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.
567template <int kExpectedCalls>
568class 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
622const int test_generation_params[] = {36, 42, 72};
623
624class 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};
686vector<int> TestGenerationTest::collected_parameters_;
687
688TEST_P(TestGenerationTest, TestsExpandedAndRun) {
689  Environment::Instance()->TestBodyExecuted();
690  EXPECT_EQ(current_parameter_, GetParam());
691  collected_parameters_.push_back(GetParam());
692}
693INSTANTIATE_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.
706class 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};
714int GeneratorEvaluationTest::param_value_ = 0;
715
716TEST_P(GeneratorEvaluationTest, GeneratorsEvaluatedInMain) {
717  EXPECT_EQ(1, GetParam());
718}
719INSTANTIATE_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.
725extern ParamGenerator<int> extern_gen;
726class ExternalGeneratorTest : public TestWithParam<int> {};
727TEST_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}
732INSTANTIATE_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.
740TEST_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.
746class MultipleInstantiationTest : public TestWithParam<int> {};
747TEST_P(MultipleInstantiationTest, AllowsMultipleInstances) {
748}
749INSTANTIATE_TEST_CASE_P(Sequence1, MultipleInstantiationTest, Values(1, 2));
750INSTANTIATE_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.
757TEST_P(InstantiationInMultipleTranslaionUnitsTest, IsMultipleOf42) {
758  EXPECT_EQ(0, GetParam() % 42);
759}
760INSTANTIATE_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.
766class 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};
782int SeparateInstanceTest::global_count_ = 0;
783
784TEST_P(SeparateInstanceTest, TestsRunInSeparateInstances) {
785  EXPECT_EQ(0, count_++);
786  global_count_++;
787}
788INSTANTIATE_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.
795class NamingTest : public TestWithParam<int> {};
796
797TEST_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
810INSTANTIATE_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.
816class Unstreamable {
817 public:
818  explicit Unstreamable(int value) : value_(value) {}
819
820 private:
821  int value_;
822};
823
824class CommentTest : public TestWithParam<Unstreamable> {};
825
826TEST_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
833INSTANTIATE_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.
841class NonParameterizedBaseTest : public ::testing::Test {
842 public:
843  NonParameterizedBaseTest() : n_(17) { }
844 protected:
845  int n_;
846};
847
848class ParameterizedDerivedTest : public NonParameterizedBaseTest,
849                                 public ::testing::WithParamInterface<int> {
850 protected:
851  ParameterizedDerivedTest() : count_(0) { }
852  int count_;
853  static int global_count_;
854};
855
856int ParameterizedDerivedTest::global_count_ = 0;
857
858TEST_F(NonParameterizedBaseTest, FixtureIsInitialized) {
859  EXPECT_EQ(17, n_);
860}
861
862TEST_P(ParameterizedDerivedTest, SeesSequence) {
863  EXPECT_EQ(17, n_);
864  EXPECT_EQ(0, count_++);
865  EXPECT_EQ(GetParam(), global_count_++);
866}
867
868INSTANTIATE_TEST_CASE_P(RangeZeroToFive, ParameterizedDerivedTest, Range(0, 5));
869
870#endif  // GTEST_HAS_PARAM_TEST
871
872TEST(CompileTest, CombineIsDefinedOnlyWhenGtestHasParamTestIsDefined) {
873#if GTEST_HAS_COMBINE && !GTEST_HAS_PARAM_TEST
874  FAIL() << "GTEST_HAS_COMBINE is defined while GTEST_HAS_PARAM_TEST is not\n"
875#endif
876}
877
878int main(int argc, char **argv) {
879#if GTEST_HAS_PARAM_TEST
880  // Used in TestGenerationTest test case.
881  AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance());
882  // Used in GeneratorEvaluationTest test case. Tests that the updated value
883  // will be picked up for instantiating tests in GeneratorEvaluationTest.
884  GeneratorEvaluationTest::set_param_value(1);
885#endif  // GTEST_HAS_PARAM_TEST
886
887  ::testing::InitGoogleTest(&argc, argv);
888
889#if GTEST_HAS_PARAM_TEST
890  // Used in GeneratorEvaluationTest test case. Tests that value updated
891  // here will NOT be used for instantiating tests in
892  // GeneratorEvaluationTest.
893  GeneratorEvaluationTest::set_param_value(2);
894#endif  // GTEST_HAS_PARAM_TEST
895
896  return RUN_ALL_TESTS();
897}
898