1 // Copyright 2008, Google Inc.
2 // All rights reserved.
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
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
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.
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.
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.
35 #include "gtest/gtest.h"
45 # include "src/gtest-internal-inl.h" // for UnitTestOptions
46 # include "test/googletest-param-test-test.h"
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
;
60 using ::testing::internal::ParamGenerator
;
61 using ::testing::internal::UnitTestOptions
;
63 // Prints a value to a string.
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.
70 ::std::string
PrintValue(const T
& value
) {
71 return testing::PrintToString(value
);
74 // Verifies that a sequence generated by the generator and accessed
75 // via the iterator object matches the expected one using Google Test
77 template <typename T
, size_t 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
)
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";
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";
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
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";
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";
119 template <typename T
>
120 void VerifyGeneratorIsEmpty(const ParamGenerator
<T
>& generator
) {
121 typename ParamGenerator
<T
>::iterator it
= generator
.begin();
122 EXPECT_TRUE(it
== generator
.end());
124 it
= generator
.begin();
125 EXPECT_TRUE(it
== generator
.end());
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.
135 // Tests that iterators produced by generator functions conform to the
136 // ForwardIterator concept.
137 TEST(IteratorTest
, ParamIteratorConformsToForwardIteratorConcept
) {
138 const ParamGenerator
<int> gen
= Range(0, 10);
139 ParamGenerator
<int>::iterator it
= gen
.begin();
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";
146 // Verifies that iterator assignment works as expected.
148 EXPECT_FALSE(*it
== *it2
);
150 EXPECT_TRUE(*it
== *it2
) << "Assigned iterators must point to the "
151 << "element same as its source points to";
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";
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
++));
163 // Verifies that prefix and postfix operator++() advance an iterator
168 EXPECT_TRUE(*it
== *it2
);
171 // Tests that Range() generates the expected sequence.
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
);
178 // Edge case. Tests that Range() generates the single element sequence
179 // as expected when provided with range limits that are equal.
180 TEST(RangeTest
, IntRangeSingleValue
) {
181 const ParamGenerator
<int> gen
= Range(0, 1);
182 const int expected_values
[] = {0};
183 VerifyGenerator(gen
, expected_values
);
186 // Edge case. Tests that Range() with generates empty sequence when
187 // supplied with an empty range.
188 TEST(RangeTest
, IntRangeEmpty
) {
189 const ParamGenerator
<int> gen
= Range(0, 0);
190 VerifyGeneratorIsEmpty(gen
);
193 // Tests that Range() with custom step (greater then one) generates
194 // the expected sequence.
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
);
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.
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
);
211 // Verifies that Range works with user-defined types that define
212 // copy constructor, operator=(), operator+(), and operator<().
215 explicit DogAdder(const char* a_value
) : value_(a_value
) {}
216 DogAdder(const DogAdder
& other
) : value_(other
.value_
.c_str()) {}
218 DogAdder
operator=(const DogAdder
& other
) {
220 value_
= other
.value_
;
223 DogAdder
operator+(const DogAdder
& other
) const {
225 msg
<< value_
.c_str() << other
.value_
.c_str();
226 return DogAdder(msg
.GetString().c_str());
228 bool operator<(const DogAdder
& other
) const {
229 return value_
< other
.value_
;
231 const std::string
& value() const { return value_
; }
237 TEST(RangeTest
, WorksWithACustomType
) {
238 const ParamGenerator
<DogAdder
> gen
=
239 Range(DogAdder("cat"), DogAdder("catdogdog"), DogAdder("dog"));
240 ParamGenerator
<DogAdder
>::iterator it
= gen
.begin();
242 ASSERT_FALSE(it
== gen
.end());
243 EXPECT_STREQ("cat", it
->value().c_str());
245 ASSERT_FALSE(++it
== gen
.end());
246 EXPECT_STREQ("catdog", it
->value().c_str());
248 EXPECT_TRUE(++it
== gen
.end());
253 explicit IntWrapper(int a_value
) : value_(a_value
) {}
254 IntWrapper(const IntWrapper
& other
) : value_(other
.value_
) {}
256 IntWrapper
operator=(const IntWrapper
& other
) {
257 value_
= other
.value_
;
260 // operator+() adds a different type.
261 IntWrapper
operator+(int other
) const { return IntWrapper(value_
+ other
); }
262 bool operator<(const IntWrapper
& other
) const {
263 return value_
< other
.value_
;
265 int value() const { return value_
; }
271 TEST(RangeTest
, WorksWithACustomTypeWithDifferentIncrementType
) {
272 const ParamGenerator
<IntWrapper
> gen
= Range(IntWrapper(0), IntWrapper(2));
273 ParamGenerator
<IntWrapper
>::iterator it
= gen
.begin();
275 ASSERT_FALSE(it
== gen
.end());
276 EXPECT_EQ(0, it
->value());
278 ASSERT_FALSE(++it
== gen
.end());
279 EXPECT_EQ(1, it
->value());
281 EXPECT_TRUE(++it
== gen
.end());
284 // Tests that ValuesIn() with an array parameter generates
285 // the expected sequence.
286 TEST(ValuesInTest
, ValuesInArray
) {
287 int array
[] = {3, 5, 8};
288 const ParamGenerator
<int> gen
= ValuesIn(array
);
289 VerifyGenerator(gen
, array
);
292 // Tests that ValuesIn() with a const array parameter generates
293 // the expected sequence.
294 TEST(ValuesInTest
, ValuesInConstArray
) {
295 const int array
[] = {3, 5, 8};
296 const ParamGenerator
<int> gen
= ValuesIn(array
);
297 VerifyGenerator(gen
, array
);
300 // Edge case. Tests that ValuesIn() with an array parameter containing a
301 // single element generates the single element sequence.
302 TEST(ValuesInTest
, ValuesInSingleElementArray
) {
304 const ParamGenerator
<int> gen
= ValuesIn(array
);
305 VerifyGenerator(gen
, array
);
308 // Tests that ValuesIn() generates the expected sequence for an STL
309 // container (vector).
310 TEST(ValuesInTest
, ValuesInVector
) {
311 typedef ::std::vector
<int> ContainerType
;
312 ContainerType values
;
316 const ParamGenerator
<int> gen
= ValuesIn(values
);
318 const int expected_values
[] = {3, 5, 8};
319 VerifyGenerator(gen
, expected_values
);
322 // Tests that ValuesIn() generates the expected sequence.
323 TEST(ValuesInTest
, ValuesInIteratorRange
) {
324 typedef ::std::vector
<int> ContainerType
;
325 ContainerType values
;
329 const ParamGenerator
<int> gen
= ValuesIn(values
.begin(), values
.end());
331 const int expected_values
[] = {3, 5, 8};
332 VerifyGenerator(gen
, expected_values
);
335 // Edge case. Tests that ValuesIn() provided with an iterator range specifying a
336 // single value generates a single-element sequence.
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());
343 const int expected_values
[] = {42};
344 VerifyGenerator(gen
, expected_values
);
347 // Edge case. Tests that ValuesIn() provided with an empty iterator range
348 // generates an empty sequence.
349 TEST(ValuesInTest
, ValuesInEmptyIteratorRange
) {
350 typedef ::std::vector
<int> ContainerType
;
351 ContainerType values
;
352 const ParamGenerator
<int> gen
= ValuesIn(values
.begin(), values
.end());
354 VerifyGeneratorIsEmpty(gen
);
357 // Tests that the Values() generates the expected sequence.
358 TEST(ValuesTest
, ValuesWorks
) {
359 const ParamGenerator
<int> gen
= Values(3, 5, 8);
361 const int expected_values
[] = {3, 5, 8};
362 VerifyGenerator(gen
, expected_values
);
365 // Tests that Values() generates the expected sequences from elements of
366 // different types convertible to ParamGenerator's parameter type.
367 TEST(ValuesTest
, ValuesWorksForValuesOfCompatibleTypes
) {
368 const ParamGenerator
<double> gen
= Values(3, 5.0f
, 8.0);
370 const double expected_values
[] = {3.0, 5.0, 8.0};
371 VerifyGenerator(gen
, expected_values
);
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);
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
);
391 // Edge case test. Tests that single-parameter Values() generates the sequence
392 // with the single value.
393 TEST(ValuesTest
, ValuesWithSingleParameter
) {
394 const ParamGenerator
<int> gen
= Values(42);
396 const int expected_values
[] = {42};
397 VerifyGenerator(gen
, expected_values
);
400 // Tests that Bool() generates sequence (false, true).
401 TEST(BoolTest
, BoolWorks
) {
402 const ParamGenerator
<bool> gen
= Bool();
404 const bool expected_values
[] = {false, true};
405 VerifyGenerator(gen
, expected_values
);
408 // Tests that Combine() with two parameters generates the expected sequence.
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));
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
);
421 // Tests that Combine() with three parameters generates the expected sequence.
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
);
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.
436 TEST(CombineTest
, CombineWithFirstParameterSingleValue
) {
437 const ParamGenerator
<std::tuple
<int, int> > gen
=
438 Combine(Values(42), Values(0, 1));
440 std::tuple
<int, int> expected_values
[] = {std::make_tuple(42, 0),
441 std::make_tuple(42, 1)};
442 VerifyGenerator(gen
, expected_values
);
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.
448 TEST(CombineTest
, CombineWithSecondParameterSingleValue
) {
449 const ParamGenerator
<std::tuple
<int, int> > gen
=
450 Combine(Values(0, 1), Values(42));
452 std::tuple
<int, int> expected_values
[] = {std::make_tuple(0, 42),
453 std::make_tuple(1, 42)};
454 VerifyGenerator(gen
, expected_values
);
457 // Tests that when the first parameter produces an empty sequence,
458 // Combine() produces an empty sequence, too.
459 TEST(CombineTest
, CombineWithFirstParameterEmptyRange
) {
460 const ParamGenerator
<std::tuple
<int, int> > gen
=
461 Combine(Range(0, 0), Values(0, 1));
462 VerifyGeneratorIsEmpty(gen
);
465 // Tests that when the second parameter produces an empty sequence,
466 // Combine() produces an empty sequence, too.
467 TEST(CombineTest
, CombineWithSecondParameterEmptyRange
) {
468 const ParamGenerator
<std::tuple
<int, int> > gen
=
469 Combine(Values(0, 1), Range(1, 1));
470 VerifyGeneratorIsEmpty(gen
);
473 // Edge case. Tests that combine works with the maximum number
474 // of parameters supported by Google Test (currently 10).
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> >
481 Combine(Values(foo
, bar
), Values(1), Values(2), Values(3), Values(4),
482 Values(5), Values(6), Values(7), Values(8), Values(9));
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
);
490 class NonDefaultConstructAssignString
{
492 NonDefaultConstructAssignString(const std::string
& s
) : str_(s
) {}
493 NonDefaultConstructAssignString() = delete;
494 NonDefaultConstructAssignString(const NonDefaultConstructAssignString
&) =
496 NonDefaultConstructAssignString
& operator=(
497 const NonDefaultConstructAssignString
&) = delete;
498 ~NonDefaultConstructAssignString() = default;
500 const std::string
& str() const { return str_
; }
506 TEST(CombineTest
, NonDefaultConstructAssign
) {
507 const ParamGenerator
<std::tuple
<int, NonDefaultConstructAssignString
> > gen
=
508 Combine(Values(0, 1), Values(NonDefaultConstructAssignString("A"),
509 NonDefaultConstructAssignString("B")));
511 ParamGenerator
<std::tuple
<int, NonDefaultConstructAssignString
> >::iterator
514 EXPECT_EQ(0, std::get
<0>(*it
));
515 EXPECT_EQ("A", std::get
<1>(*it
).str());
518 EXPECT_EQ(0, std::get
<0>(*it
));
519 EXPECT_EQ("B", std::get
<1>(*it
).str());
522 EXPECT_EQ(1, std::get
<0>(*it
));
523 EXPECT_EQ("A", std::get
<1>(*it
).str());
526 EXPECT_EQ(1, std::get
<0>(*it
));
527 EXPECT_EQ("B", std::get
<1>(*it
).str());
530 EXPECT_TRUE(it
== gen
.end());
534 // Tests that an generator produces correct sequence after being
535 // assigned from another generator.
536 TEST(ParamGeneratorTest
, AssignmentWorks
) {
537 ParamGenerator
<int> gen
= Values(1, 2);
538 const ParamGenerator
<int> gen2
= Values(3, 4);
541 const int expected_values
[] = {3, 4};
542 VerifyGenerator(gen
, expected_values
);
545 // This test verifies that the tests are expanded and run as specified:
546 // one test per element from the sequence produced by the generator
547 // specified in INSTANTIATE_TEST_SUITE_P. It also verifies that the test's
548 // fixture constructor, SetUp(), and TearDown() have run and have been
549 // supplied with the correct parameters.
551 // The use of environment object allows detection of the case where no test
552 // case functionality is run at all. In this case TearDownTestSuite will not
553 // be able to detect missing tests, naturally.
554 template <int kExpectedCalls
>
555 class TestGenerationEnvironment
: public ::testing::Environment
{
557 static TestGenerationEnvironment
* Instance() {
558 static TestGenerationEnvironment
* instance
= new TestGenerationEnvironment
;
562 void FixtureConstructorExecuted() { fixture_constructor_count_
++; }
563 void SetUpExecuted() { set_up_count_
++; }
564 void TearDownExecuted() { tear_down_count_
++; }
565 void TestBodyExecuted() { test_body_count_
++; }
567 void TearDown() override
{
568 // If all MultipleTestGenerationTest tests have been de-selected
569 // by the filter flag, the following checks make no sense.
570 bool perform_check
= false;
572 for (int i
= 0; i
< kExpectedCalls
; ++i
) {
574 msg
<< "TestsExpandedAndRun/" << i
;
575 if (UnitTestOptions::FilterMatchesTest(
576 "TestExpansionModule/MultipleTestGenerationTest",
577 msg
.GetString().c_str())) {
578 perform_check
= true;
582 EXPECT_EQ(kExpectedCalls
, fixture_constructor_count_
)
583 << "Fixture constructor of ParamTestGenerationTest test case "
584 << "has not been run as expected.";
585 EXPECT_EQ(kExpectedCalls
, set_up_count_
)
586 << "Fixture SetUp method of ParamTestGenerationTest test case "
587 << "has not been run as expected.";
588 EXPECT_EQ(kExpectedCalls
, tear_down_count_
)
589 << "Fixture TearDown method of ParamTestGenerationTest test case "
590 << "has not been run as expected.";
591 EXPECT_EQ(kExpectedCalls
, test_body_count_
)
592 << "Test in ParamTestGenerationTest test case "
593 << "has not been run as expected.";
598 TestGenerationEnvironment() : fixture_constructor_count_(0), set_up_count_(0),
599 tear_down_count_(0), test_body_count_(0) {}
601 int fixture_constructor_count_
;
603 int tear_down_count_
;
604 int test_body_count_
;
606 GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationEnvironment
);
609 const int test_generation_params
[] = {36, 42, 72};
611 class TestGenerationTest
: public TestWithParam
<int> {
615 sizeof(test_generation_params
)/sizeof(test_generation_params
[0])
618 typedef TestGenerationEnvironment
<PARAMETER_COUNT
> Environment
;
620 TestGenerationTest() {
621 Environment::Instance()->FixtureConstructorExecuted();
622 current_parameter_
= GetParam();
624 void SetUp() override
{
625 Environment::Instance()->SetUpExecuted();
626 EXPECT_EQ(current_parameter_
, GetParam());
628 void TearDown() override
{
629 Environment::Instance()->TearDownExecuted();
630 EXPECT_EQ(current_parameter_
, GetParam());
633 static void SetUpTestSuite() {
634 bool all_tests_in_test_case_selected
= true;
636 for (int i
= 0; i
< PARAMETER_COUNT
; ++i
) {
638 test_name
<< "TestsExpandedAndRun/" << i
;
639 if ( !UnitTestOptions::FilterMatchesTest(
640 "TestExpansionModule/MultipleTestGenerationTest",
641 test_name
.GetString())) {
642 all_tests_in_test_case_selected
= false;
645 EXPECT_TRUE(all_tests_in_test_case_selected
)
646 << "When running the TestGenerationTest test case all of its tests\n"
647 << "must be selected by the filter flag for the test case to pass.\n"
648 << "If not all of them are enabled, we can't reliably conclude\n"
649 << "that the correct number of tests have been generated.";
651 collected_parameters_
.clear();
654 static void TearDownTestSuite() {
655 vector
<int> expected_values(test_generation_params
,
656 test_generation_params
+ PARAMETER_COUNT
);
657 // Test execution order is not guaranteed by Google Test,
658 // so the order of values in collected_parameters_ can be
659 // different and we have to sort to compare.
660 sort(expected_values
.begin(), expected_values
.end());
661 sort(collected_parameters_
.begin(), collected_parameters_
.end());
663 EXPECT_TRUE(collected_parameters_
== expected_values
);
667 int current_parameter_
;
668 static vector
<int> collected_parameters_
;
671 GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationTest
);
673 vector
<int> TestGenerationTest::collected_parameters_
;
675 TEST_P(TestGenerationTest
, TestsExpandedAndRun
) {
676 Environment::Instance()->TestBodyExecuted();
677 EXPECT_EQ(current_parameter_
, GetParam());
678 collected_parameters_
.push_back(GetParam());
680 INSTANTIATE_TEST_SUITE_P(TestExpansionModule
, TestGenerationTest
,
681 ValuesIn(test_generation_params
));
683 // This test verifies that the element sequence (third parameter of
684 // INSTANTIATE_TEST_SUITE_P) is evaluated in InitGoogleTest() and neither at
685 // the call site of INSTANTIATE_TEST_SUITE_P nor in RUN_ALL_TESTS(). For
686 // that, we declare param_value_ to be a static member of
687 // GeneratorEvaluationTest and initialize it to 0. We set it to 1 in
688 // main(), just before invocation of InitGoogleTest(). After calling
689 // InitGoogleTest(), we set the value to 2. If the sequence is evaluated
690 // before or after InitGoogleTest, INSTANTIATE_TEST_SUITE_P will create a
691 // test with parameter other than 1, and the test body will fail the
693 class GeneratorEvaluationTest
: public TestWithParam
<int> {
695 static int param_value() { return param_value_
; }
696 static void set_param_value(int param_value
) { param_value_
= param_value
; }
699 static int param_value_
;
701 int GeneratorEvaluationTest::param_value_
= 0;
703 TEST_P(GeneratorEvaluationTest
, GeneratorsEvaluatedInMain
) {
704 EXPECT_EQ(1, GetParam());
706 INSTANTIATE_TEST_SUITE_P(GenEvalModule
, GeneratorEvaluationTest
,
707 Values(GeneratorEvaluationTest::param_value()));
709 // Tests that generators defined in a different translation unit are
710 // functional. Generator extern_gen is defined in gtest-param-test_test2.cc.
711 extern ParamGenerator
<int> extern_gen
;
712 class ExternalGeneratorTest
: public TestWithParam
<int> {};
713 TEST_P(ExternalGeneratorTest
, ExternalGenerator
) {
714 // Sequence produced by extern_gen contains only a single value
715 // which we verify here.
716 EXPECT_EQ(GetParam(), 33);
718 INSTANTIATE_TEST_SUITE_P(ExternalGeneratorModule
, ExternalGeneratorTest
,
721 // Tests that a parameterized test case can be defined in one translation
722 // unit and instantiated in another. This test will be instantiated in
723 // gtest-param-test_test2.cc. ExternalInstantiationTest fixture class is
724 // defined in gtest-param-test_test.h.
725 TEST_P(ExternalInstantiationTest
, IsMultipleOf33
) {
726 EXPECT_EQ(0, GetParam() % 33);
729 // Tests that a parameterized test case can be instantiated with multiple
731 class MultipleInstantiationTest
: public TestWithParam
<int> {};
732 TEST_P(MultipleInstantiationTest
, AllowsMultipleInstances
) {
734 INSTANTIATE_TEST_SUITE_P(Sequence1
, MultipleInstantiationTest
, Values(1, 2));
735 INSTANTIATE_TEST_SUITE_P(Sequence2
, MultipleInstantiationTest
, Range(3, 5));
737 // Tests that a parameterized test case can be instantiated
738 // in multiple translation units. This test will be instantiated
739 // here and in gtest-param-test_test2.cc.
740 // InstantiationInMultipleTranslationUnitsTest fixture class
741 // is defined in gtest-param-test_test.h.
742 TEST_P(InstantiationInMultipleTranslationUnitsTest
, IsMultipleOf42
) {
743 EXPECT_EQ(0, GetParam() % 42);
745 INSTANTIATE_TEST_SUITE_P(Sequence1
, InstantiationInMultipleTranslationUnitsTest
,
748 // Tests that each iteration of parameterized test runs in a separate test
750 class SeparateInstanceTest
: public TestWithParam
<int> {
752 SeparateInstanceTest() : count_(0) {}
754 static void TearDownTestSuite() {
755 EXPECT_GE(global_count_
, 2)
756 << "If some (but not all) SeparateInstanceTest tests have been "
757 << "filtered out this test will fail. Make sure that all "
758 << "GeneratorEvaluationTest are selected or de-selected together "
759 << "by the test filter.";
764 static int global_count_
;
766 int SeparateInstanceTest::global_count_
= 0;
768 TEST_P(SeparateInstanceTest
, TestsRunInSeparateInstances
) {
769 EXPECT_EQ(0, count_
++);
772 INSTANTIATE_TEST_SUITE_P(FourElemSequence
, SeparateInstanceTest
, Range(1, 4));
774 // Tests that all instantiations of a test have named appropriately. Test
775 // defined with TEST_P(TestSuiteName, TestName) and instantiated with
776 // INSTANTIATE_TEST_SUITE_P(SequenceName, TestSuiteName, generator) must be
777 // named SequenceName/TestSuiteName.TestName/i, where i is the 0-based index of
778 // the sequence element used to instantiate the test.
779 class NamingTest
: public TestWithParam
<int> {};
781 TEST_P(NamingTest
, TestsReportCorrectNamesAndParameters
) {
782 const ::testing::TestInfo
* const test_info
=
783 ::testing::UnitTest::GetInstance()->current_test_info();
785 EXPECT_STREQ("ZeroToFiveSequence/NamingTest", test_info
->test_suite_name());
787 Message index_stream
;
788 index_stream
<< "TestsReportCorrectNamesAndParameters/" << GetParam();
789 EXPECT_STREQ(index_stream
.GetString().c_str(), test_info
->name());
791 EXPECT_EQ(::testing::PrintToString(GetParam()), test_info
->value_param());
794 INSTANTIATE_TEST_SUITE_P(ZeroToFiveSequence
, NamingTest
, Range(0, 5));
796 // Tests that macros in test names are expanded correctly.
797 class MacroNamingTest
: public TestWithParam
<int> {};
799 #define PREFIX_WITH_FOO(test_name) Foo##test_name
800 #define PREFIX_WITH_MACRO(test_name) Macro##test_name
802 TEST_P(PREFIX_WITH_MACRO(NamingTest
), PREFIX_WITH_FOO(SomeTestName
)) {
803 const ::testing::TestInfo
* const test_info
=
804 ::testing::UnitTest::GetInstance()->current_test_info();
806 EXPECT_STREQ("FortyTwo/MacroNamingTest", test_info
->test_suite_name());
807 EXPECT_STREQ("FooSomeTestName/0", test_info
->name());
810 INSTANTIATE_TEST_SUITE_P(FortyTwo
, MacroNamingTest
, Values(42));
812 // Tests the same thing for non-parametrized tests.
813 class MacroNamingTestNonParametrized
: public ::testing::Test
{};
815 TEST_F(PREFIX_WITH_MACRO(NamingTestNonParametrized
),
816 PREFIX_WITH_FOO(SomeTestName
)) {
817 const ::testing::TestInfo
* const test_info
=
818 ::testing::UnitTest::GetInstance()->current_test_info();
820 EXPECT_STREQ("MacroNamingTestNonParametrized", test_info
->test_suite_name());
821 EXPECT_STREQ("FooSomeTestName", test_info
->name());
824 TEST(MacroNameing
, LookupNames
) {
825 std::set
<std::string
> know_suite_names
, know_test_names
;
827 auto ins
= testing::UnitTest::GetInstance();
829 while (const testing::TestSuite
* suite
= ins
->GetTestSuite(ts
++)) {
830 know_suite_names
.insert(suite
->name());
833 while (const testing::TestInfo
* info
= suite
->GetTestInfo(ti
++)) {
834 know_test_names
.insert(std::string(suite
->name()) + "." + info
->name());
838 // Check that the expected form of the test suit name actualy exists.
840 know_suite_names
.find("FortyTwo/MacroNamingTest"),
841 know_suite_names
.end());
843 know_suite_names
.find("MacroNamingTestNonParametrized"),
844 know_suite_names
.end());
845 // Check that the expected form of the test name actualy exists.
847 know_test_names
.find("FortyTwo/MacroNamingTest.FooSomeTestName/0"),
848 know_test_names
.end());
850 know_test_names
.find("MacroNamingTestNonParametrized.FooSomeTestName"),
851 know_test_names
.end());
854 // Tests that user supplied custom parameter names are working correctly.
855 // Runs the test with a builtin helper method which uses PrintToString,
856 // as well as a custom function and custom functor to ensure all possible
857 // uses work correctly.
858 class CustomFunctorNamingTest
: public TestWithParam
<std::string
> {};
859 TEST_P(CustomFunctorNamingTest
, CustomTestNames
) {}
861 struct CustomParamNameFunctor
{
862 std::string
operator()(const ::testing::TestParamInfo
<std::string
>& inf
) {
867 INSTANTIATE_TEST_SUITE_P(CustomParamNameFunctor
, CustomFunctorNamingTest
,
868 Values(std::string("FunctorName")),
869 CustomParamNameFunctor());
871 INSTANTIATE_TEST_SUITE_P(AllAllowedCharacters
, CustomFunctorNamingTest
,
872 Values("abcdefghijklmnopqrstuvwxyz",
873 "ABCDEFGHIJKLMNOPQRSTUVWXYZ", "01234567890_"),
874 CustomParamNameFunctor());
876 inline std::string
CustomParamNameFunction(
877 const ::testing::TestParamInfo
<std::string
>& inf
) {
881 class CustomFunctionNamingTest
: public TestWithParam
<std::string
> {};
882 TEST_P(CustomFunctionNamingTest
, CustomTestNames
) {}
884 INSTANTIATE_TEST_SUITE_P(CustomParamNameFunction
, CustomFunctionNamingTest
,
885 Values(std::string("FunctionName")),
886 CustomParamNameFunction
);
888 INSTANTIATE_TEST_SUITE_P(CustomParamNameFunctionP
, CustomFunctionNamingTest
,
889 Values(std::string("FunctionNameP")),
890 &CustomParamNameFunction
);
892 // Test custom naming with a lambda
894 class CustomLambdaNamingTest
: public TestWithParam
<std::string
> {};
895 TEST_P(CustomLambdaNamingTest
, CustomTestNames
) {}
897 INSTANTIATE_TEST_SUITE_P(CustomParamNameLambda
, CustomLambdaNamingTest
,
898 Values(std::string("LambdaName")),
899 [](const ::testing::TestParamInfo
<std::string
>& inf
) {
903 TEST(CustomNamingTest
, CheckNameRegistry
) {
904 ::testing::UnitTest
* unit_test
= ::testing::UnitTest::GetInstance();
905 std::set
<std::string
> test_names
;
906 for (int suite_num
= 0; suite_num
< unit_test
->total_test_suite_count();
908 const ::testing::TestSuite
* test_suite
= unit_test
->GetTestSuite(suite_num
);
909 for (int test_num
= 0; test_num
< test_suite
->total_test_count();
911 const ::testing::TestInfo
* test_info
= test_suite
->GetTestInfo(test_num
);
912 test_names
.insert(std::string(test_info
->name()));
915 EXPECT_EQ(1u, test_names
.count("CustomTestNames/FunctorName"));
916 EXPECT_EQ(1u, test_names
.count("CustomTestNames/FunctionName"));
917 EXPECT_EQ(1u, test_names
.count("CustomTestNames/FunctionNameP"));
918 EXPECT_EQ(1u, test_names
.count("CustomTestNames/LambdaName"));
921 // Test a numeric name to ensure PrintToStringParamName works correctly.
923 class CustomIntegerNamingTest
: public TestWithParam
<int> {};
925 TEST_P(CustomIntegerNamingTest
, TestsReportCorrectNames
) {
926 const ::testing::TestInfo
* const test_info
=
927 ::testing::UnitTest::GetInstance()->current_test_info();
928 Message test_name_stream
;
929 test_name_stream
<< "TestsReportCorrectNames/" << GetParam();
930 EXPECT_STREQ(test_name_stream
.GetString().c_str(), test_info
->name());
933 INSTANTIATE_TEST_SUITE_P(PrintToString
, CustomIntegerNamingTest
, Range(0, 5),
934 ::testing::PrintToStringParamName());
936 // Test a custom struct with PrintToString.
938 struct CustomStruct
{
939 explicit CustomStruct(int value
) : x(value
) {}
943 std::ostream
& operator<<(std::ostream
& stream
, const CustomStruct
& val
) {
948 class CustomStructNamingTest
: public TestWithParam
<CustomStruct
> {};
950 TEST_P(CustomStructNamingTest
, TestsReportCorrectNames
) {
951 const ::testing::TestInfo
* const test_info
=
952 ::testing::UnitTest::GetInstance()->current_test_info();
953 Message test_name_stream
;
954 test_name_stream
<< "TestsReportCorrectNames/" << GetParam();
955 EXPECT_STREQ(test_name_stream
.GetString().c_str(), test_info
->name());
958 INSTANTIATE_TEST_SUITE_P(PrintToString
, CustomStructNamingTest
,
959 Values(CustomStruct(0), CustomStruct(1)),
960 ::testing::PrintToStringParamName());
962 // Test that using a stateful parameter naming function works as expected.
964 struct StatefulNamingFunctor
{
965 StatefulNamingFunctor() : sum(0) {}
966 std::string
operator()(const ::testing::TestParamInfo
<int>& info
) {
967 int value
= info
.param
+ sum
;
969 return ::testing::PrintToString(value
);
974 class StatefulNamingTest
: public ::testing::TestWithParam
<int> {
976 StatefulNamingTest() : sum_(0) {}
980 TEST_P(StatefulNamingTest
, TestsReportCorrectNames
) {
981 const ::testing::TestInfo
* const test_info
=
982 ::testing::UnitTest::GetInstance()->current_test_info();
984 Message test_name_stream
;
985 test_name_stream
<< "TestsReportCorrectNames/" << sum_
;
986 EXPECT_STREQ(test_name_stream
.GetString().c_str(), test_info
->name());
989 INSTANTIATE_TEST_SUITE_P(StatefulNamingFunctor
, StatefulNamingTest
, Range(0, 5),
990 StatefulNamingFunctor());
992 // Class that cannot be streamed into an ostream. It needs to be copyable
993 // (and, in case of MSVC, also assignable) in order to be a test parameter
994 // type. Its default copy constructor and assignment operator do exactly
998 explicit Unstreamable(int value
) : value_(value
) {}
999 // -Wunused-private-field: dummy accessor for `value_`.
1000 const int& dummy_value() const { return value_
; }
1006 class CommentTest
: public TestWithParam
<Unstreamable
> {};
1008 TEST_P(CommentTest
, TestsCorrectlyReportUnstreamableParams
) {
1009 const ::testing::TestInfo
* const test_info
=
1010 ::testing::UnitTest::GetInstance()->current_test_info();
1012 EXPECT_EQ(::testing::PrintToString(GetParam()), test_info
->value_param());
1015 INSTANTIATE_TEST_SUITE_P(InstantiationWithComments
, CommentTest
,
1016 Values(Unstreamable(1)));
1018 // Verify that we can create a hierarchy of test fixtures, where the base
1019 // class fixture is not parameterized and the derived class is. In this case
1020 // ParameterizedDerivedTest inherits from NonParameterizedBaseTest. We
1021 // perform simple tests on both.
1022 class NonParameterizedBaseTest
: public ::testing::Test
{
1024 NonParameterizedBaseTest() : n_(17) { }
1029 class ParameterizedDerivedTest
: public NonParameterizedBaseTest
,
1030 public ::testing::WithParamInterface
<int> {
1032 ParameterizedDerivedTest() : count_(0) { }
1034 static int global_count_
;
1037 int ParameterizedDerivedTest::global_count_
= 0;
1039 TEST_F(NonParameterizedBaseTest
, FixtureIsInitialized
) {
1043 TEST_P(ParameterizedDerivedTest
, SeesSequence
) {
1045 EXPECT_EQ(0, count_
++);
1046 EXPECT_EQ(GetParam(), global_count_
++);
1049 class ParameterizedDeathTest
: public ::testing::TestWithParam
<int> { };
1051 TEST_F(ParameterizedDeathTest
, GetParamDiesFromTestF
) {
1052 EXPECT_DEATH_IF_SUPPORTED(GetParam(),
1053 ".* value-parameterized test .*");
1056 INSTANTIATE_TEST_SUITE_P(RangeZeroToFive
, ParameterizedDerivedTest
,
1059 // Tests param generator working with Enums
1066 class MyEnumTest
: public testing::TestWithParam
<MyEnums
> {};
1068 TEST_P(MyEnumTest
, ChecksParamMoreThanZero
) { EXPECT_GE(10, GetParam()); }
1069 INSTANTIATE_TEST_SUITE_P(MyEnumTests
, MyEnumTest
,
1070 ::testing::Values(ENUM1
, ENUM2
, 0));
1072 namespace works_here
{
1073 // Never used not instantiated, this should work.
1074 class NotUsedTest
: public testing::TestWithParam
<int> {};
1077 // Never used not instantiated, this should work.
1078 template <typename T
>
1079 class NotUsedTypeTest
: public testing::Test
{};
1080 TYPED_TEST_SUITE_P(NotUsedTypeTest
);
1082 // Used but not instantiated, this would fail. but...
1083 class NotInstantiatedTest
: public testing::TestWithParam
<int> {};
1084 // ... we mark is as allowed.
1085 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(NotInstantiatedTest
);
1087 TEST_P(NotInstantiatedTest
, Used
) { }
1089 using OtherName
= NotInstantiatedTest
;
1090 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(OtherName
);
1091 TEST_P(OtherName
, Used
) { }
1093 // Used but not instantiated, this would fail. but...
1094 template <typename T
>
1095 class NotInstantiatedTypeTest
: public testing::Test
{};
1096 TYPED_TEST_SUITE_P(NotInstantiatedTypeTest
);
1097 // ... we mark is as allowed.
1098 GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(NotInstantiatedTypeTest
);
1100 TYPED_TEST_P(NotInstantiatedTypeTest
, Used
) { }
1101 REGISTER_TYPED_TEST_SUITE_P(NotInstantiatedTypeTest
, Used
);
1102 } // namespace works_here
1104 int main(int argc
, char **argv
) {
1105 // Used in TestGenerationTest test suite.
1106 AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance());
1107 // Used in GeneratorEvaluationTest test suite. Tests that the updated value
1108 // will be picked up for instantiating tests in GeneratorEvaluationTest.
1109 GeneratorEvaluationTest::set_param_value(1);
1111 ::testing::InitGoogleTest(&argc
, argv
);
1113 // Used in GeneratorEvaluationTest test suite. Tests that value updated
1114 // here will NOT be used for instantiating tests in
1115 // GeneratorEvaluationTest.
1116 GeneratorEvaluationTest::set_param_value(2);
1118 return RUN_ALL_TESTS();