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