Analysis Software
Documentation for sPHENIX simulation software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
gtest-param-test_test.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file gtest-param-test_test.cc
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 
53 
54 using ::std::vector;
56 
58 using ::testing::Bool;
59 using ::testing::Message;
61 using ::testing::TestWithParam;
62 using ::testing::Values;
63 using ::testing::ValuesIn;
64 
65 # if GTEST_HAS_COMBINE
66 using ::testing::Combine;
67 using ::testing::get;
69 using ::testing::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@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(
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 
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 =
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 // Tests that user supplied custom parameter names are working correctly.
813 // Runs the test with a builtin helper method which uses PrintToString,
814 // as well as a custom function and custom functor to ensure all possible
815 // uses work correctly.
816 class CustomFunctorNamingTest : public TestWithParam<std::string> {};
817 TEST_P(CustomFunctorNamingTest, CustomTestNames) {}
818 
819 struct CustomParamNameFunctor {
820  std::string operator()(const ::testing::TestParamInfo<std::string>& info) {
821  return info.param;
822  }
823 };
824 
825 INSTANTIATE_TEST_CASE_P(CustomParamNameFunctor,
826  CustomFunctorNamingTest,
827  Values(std::string("FunctorName")),
828  CustomParamNameFunctor());
829 
830 INSTANTIATE_TEST_CASE_P(AllAllowedCharacters,
831  CustomFunctorNamingTest,
832  Values("abcdefghijklmnopqrstuvwxyz",
833  "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
834  "01234567890_"),
835  CustomParamNameFunctor());
836 
837 inline std::string CustomParamNameFunction(
838  const ::testing::TestParamInfo<std::string>& info) {
839  return info.param;
840 }
841 
842 class CustomFunctionNamingTest : public TestWithParam<std::string> {};
843 TEST_P(CustomFunctionNamingTest, CustomTestNames) {}
844 
845 INSTANTIATE_TEST_CASE_P(CustomParamNameFunction,
846  CustomFunctionNamingTest,
847  Values(std::string("FunctionName")),
848  CustomParamNameFunction);
849 
850 #if GTEST_LANG_CXX11
851 
852 // Test custom naming with a lambda
853 
854 class CustomLambdaNamingTest : public TestWithParam<std::string> {};
855 TEST_P(CustomLambdaNamingTest, CustomTestNames) {}
856 
857 INSTANTIATE_TEST_CASE_P(CustomParamNameLambda,
858  CustomLambdaNamingTest,
859  Values(std::string("LambdaName")),
860  [](const ::testing::TestParamInfo<std::string>& info) {
861  return info.param;
862  });
863 
864 #endif // GTEST_LANG_CXX11
865 
866 TEST(CustomNamingTest, CheckNameRegistry) {
868  std::set<std::string> test_names;
869  for (int case_num = 0;
870  case_num < unit_test->total_test_case_count();
871  ++case_num) {
872  const ::testing::TestCase* test_case = unit_test->GetTestCase(case_num);
873  for (int test_num = 0;
874  test_num < test_case->total_test_count();
875  ++test_num) {
876  const ::testing::TestInfo* test_info = test_case->GetTestInfo(test_num);
877  test_names.insert(std::string(test_info->name()));
878  }
879  }
880  EXPECT_EQ(1u, test_names.count("CustomTestNames/FunctorName"));
881  EXPECT_EQ(1u, test_names.count("CustomTestNames/FunctionName"));
882 #if GTEST_LANG_CXX11
883  EXPECT_EQ(1u, test_names.count("CustomTestNames/LambdaName"));
884 #endif // GTEST_LANG_CXX11
885 }
886 
887 // Test a numeric name to ensure PrintToStringParamName works correctly.
888 
889 class CustomIntegerNamingTest : public TestWithParam<int> {};
890 
891 TEST_P(CustomIntegerNamingTest, TestsReportCorrectNames) {
892  const ::testing::TestInfo* const test_info =
894  Message test_name_stream;
895  test_name_stream << "TestsReportCorrectNames/" << GetParam();
896  EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
897 }
898 
900  CustomIntegerNamingTest,
901  Range(0, 5),
902  ::testing::PrintToStringParamName());
903 
904 // Test a custom struct with PrintToString.
905 
906 struct CustomStruct {
907  explicit CustomStruct(int value) : x(value) {}
908  int x;
909 };
910 
911 std::ostream& operator<<(std::ostream& stream, const CustomStruct& val) {
912  stream << val.x;
913  return stream;
914 }
915 
916 class CustomStructNamingTest : public TestWithParam<CustomStruct> {};
917 
918 TEST_P(CustomStructNamingTest, TestsReportCorrectNames) {
919  const ::testing::TestInfo* const test_info =
921  Message test_name_stream;
922  test_name_stream << "TestsReportCorrectNames/" << GetParam();
923  EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
924 }
925 
927  CustomStructNamingTest,
928  Values(CustomStruct(0), CustomStruct(1)),
929  ::testing::PrintToStringParamName());
930 
931 // Test that using a stateful parameter naming function works as expected.
932 
933 struct StatefulNamingFunctor {
934  StatefulNamingFunctor() : sum(0) {}
935  std::string operator()(const ::testing::TestParamInfo<int>& info) {
936  int value = info.param + sum;
937  sum += info.param;
939  }
940  int sum;
941 };
942 
943 class StatefulNamingTest : public ::testing::TestWithParam<int> {
944  protected:
945  StatefulNamingTest() : sum_(0) {}
946  int sum_;
947 };
948 
949 TEST_P(StatefulNamingTest, TestsReportCorrectNames) {
950  const ::testing::TestInfo* const test_info =
952  sum_ += GetParam();
953  Message test_name_stream;
954  test_name_stream << "TestsReportCorrectNames/" << sum_;
955  EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
956 }
957 
958 INSTANTIATE_TEST_CASE_P(StatefulNamingFunctor,
959  StatefulNamingTest,
960  Range(0, 5),
961  StatefulNamingFunctor());
962 
963 // Class that cannot be streamed into an ostream. It needs to be copyable
964 // (and, in case of MSVC, also assignable) in order to be a test parameter
965 // type. Its default copy constructor and assignment operator do exactly
966 // what we need.
967 class Unstreamable {
968  public:
969  explicit Unstreamable(int value) : value_(value) {}
970 
971  private:
972  int value_;
973 };
974 
975 class CommentTest : public TestWithParam<Unstreamable> {};
976 
977 TEST_P(CommentTest, TestsCorrectlyReportUnstreamableParams) {
978  const ::testing::TestInfo* const test_info =
980 
981  EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param());
982 }
983 
984 INSTANTIATE_TEST_CASE_P(InstantiationWithComments,
985  CommentTest,
986  Values(Unstreamable(1)));
987 
988 // Verify that we can create a hierarchy of test fixtures, where the base
989 // class fixture is not parameterized and the derived class is. In this case
990 // ParameterizedDerivedTest inherits from NonParameterizedBaseTest. We
991 // perform simple tests on both.
992 class NonParameterizedBaseTest : public ::testing::Test {
993  public:
994  NonParameterizedBaseTest() : n_(17) { }
995  protected:
996  int n_;
997 };
998 
999 class ParameterizedDerivedTest : public NonParameterizedBaseTest,
1000  public ::testing::WithParamInterface<int> {
1001  protected:
1002  ParameterizedDerivedTest() : count_(0) { }
1003  int count_;
1004  static int global_count_;
1005 };
1006 
1007 int ParameterizedDerivedTest::global_count_ = 0;
1008 
1009 TEST_F(NonParameterizedBaseTest, FixtureIsInitialized) {
1010  EXPECT_EQ(17, n_);
1011 }
1012 
1013 TEST_P(ParameterizedDerivedTest, SeesSequence) {
1014  EXPECT_EQ(17, n_);
1015  EXPECT_EQ(0, count_++);
1016  EXPECT_EQ(GetParam(), global_count_++);
1017 }
1018 
1019 class ParameterizedDeathTest : public ::testing::TestWithParam<int> { };
1020 
1021 TEST_F(ParameterizedDeathTest, GetParamDiesFromTestF) {
1022  EXPECT_DEATH_IF_SUPPORTED(GetParam(),
1023  ".* value-parameterized test .*");
1024 }
1025 
1026 INSTANTIATE_TEST_CASE_P(RangeZeroToFive, ParameterizedDerivedTest, Range(0, 5));
1027 
1028 #endif // GTEST_HAS_PARAM_TEST
1029 
1030 TEST(CompileTest, CombineIsDefinedOnlyWhenGtestHasParamTestIsDefined) {
1031 #if GTEST_HAS_COMBINE && !GTEST_HAS_PARAM_TEST
1032  FAIL() << "GTEST_HAS_COMBINE is defined while GTEST_HAS_PARAM_TEST is not\n"
1033 #endif
1034 }
1035 
1036 int main(int argc, char **argv) {
1037 #if GTEST_HAS_PARAM_TEST
1038  // Used in TestGenerationTest test case.
1039  AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance());
1040  // Used in GeneratorEvaluationTest test case. Tests that the updated value
1041  // will be picked up for instantiating tests in GeneratorEvaluationTest.
1042  GeneratorEvaluationTest::set_param_value(1);
1043 #endif // GTEST_HAS_PARAM_TEST
1044 
1045  ::testing::InitGoogleTest(&argc, argv);
1046 
1047 #if GTEST_HAS_PARAM_TEST
1048  // Used in GeneratorEvaluationTest test case. Tests that value updated
1049  // here will NOT be used for instantiating tests in
1050  // GeneratorEvaluationTest.
1051  GeneratorEvaluationTest::set_param_value(2);
1052 #endif // GTEST_HAS_PARAM_TEST
1053 
1054  return RUN_ALL_TESTS();
1055 }