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