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