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.
30 // Author: vladl@google.com (Vlad Losev)
32 // Tests for Google Test itself. This file verifies that the parameter
33 // generators objects produce correct parameter sequences and that
34 // Google Test runtime instantiates correct tests from those sequences.
36 #include "gtest/gtest.h"
38 #if GTEST_HAS_PARAM_TEST
47 // To include gtest-internal-inl.h.
48 # define GTEST_IMPLEMENTATION_ 1
49 # include "src/gtest-internal-inl.h" // for UnitTestOptions
50 # undef GTEST_IMPLEMENTATION_
52 # include "test/gtest-param-test_test.h"
57 using ::testing::AddGlobalTestEnvironment;
58 using ::testing::Bool;
59 using ::testing::Message;
60 using ::testing::Range;
61 using ::testing::TestWithParam;
62 using ::testing::Values;
63 using ::testing::ValuesIn;
65 # if GTEST_HAS_COMBINE
66 using ::testing::Combine;
68 using ::testing::make_tuple;
69 using ::testing::tuple;
70 # endif // GTEST_HAS_COMBINE
72 using ::testing::internal::ParamGenerator;
73 using ::testing::internal::UnitTestOptions;
75 // Prints a value to a string.
77 // TODO(wan@google.com): remove PrintValue() when we move matchers and
78 // EXPECT_THAT() from Google Mock to Google Test. At that time, we
79 // can write EXPECT_THAT(x, Eq(y)) to compare two tuples x and y, as
80 // EXPECT_THAT() and the matchers know how to print tuples.
82 ::std::string PrintValue(const T& value) {
83 ::std::stringstream stream;
88 # if GTEST_HAS_COMBINE
90 // These overloads allow printing tuples in our tests. We cannot
91 // define an operator<< for tuples, as that definition needs to be in
92 // the std namespace in order to be picked up by Google Test via
93 // Argument-Dependent Lookup, yet defining anything in the std
94 // namespace in non-STL code is undefined behavior.
96 template <typename T1, typename T2>
97 ::std::string PrintValue(const tuple<T1, T2>& value) {
98 ::std::stringstream stream;
99 stream << "(" << get<0>(value) << ", " << get<1>(value) << ")";
103 template <typename T1, typename T2, typename T3>
104 ::std::string PrintValue(const tuple<T1, T2, T3>& value) {
105 ::std::stringstream stream;
106 stream << "(" << get<0>(value) << ", " << get<1>(value)
107 << ", "<< get<2>(value) << ")";
111 template <typename T1, typename T2, typename T3, typename T4, typename T5,
112 typename T6, typename T7, typename T8, typename T9, typename T10>
113 ::std::string PrintValue(
114 const tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& value) {
115 ::std::stringstream stream;
116 stream << "(" << get<0>(value) << ", " << get<1>(value)
117 << ", "<< get<2>(value) << ", " << get<3>(value)
118 << ", "<< get<4>(value) << ", " << get<5>(value)
119 << ", "<< get<6>(value) << ", " << get<7>(value)
120 << ", "<< get<8>(value) << ", " << get<9>(value) << ")";
124 # endif // GTEST_HAS_COMBINE
126 // Verifies that a sequence generated by the generator and accessed
127 // via the iterator object matches the expected one using Google Test
129 template <typename T, size_t N>
130 void VerifyGenerator(const ParamGenerator<T>& generator,
131 const T (&expected_values)[N]) {
132 typename ParamGenerator<T>::iterator it = generator.begin();
133 for (size_t i = 0; i < N; ++i) {
134 ASSERT_FALSE(it == generator.end())
135 << "At element " << i << " when accessing via an iterator "
136 << "created with the copy constructor.\n";
137 // We cannot use EXPECT_EQ() here as the values may be tuples,
138 // which don't support <<.
139 EXPECT_TRUE(expected_values[i] == *it)
140 << "where i is " << i
141 << ", expected_values[i] is " << PrintValue(expected_values[i])
142 << ", *it is " << PrintValue(*it)
143 << ", and 'it' is an iterator created with the copy constructor.\n";
146 EXPECT_TRUE(it == generator.end())
147 << "At the presumed end of sequence when accessing via an iterator "
148 << "created with the copy constructor.\n";
150 // Test the iterator assignment. The following lines verify that
151 // the sequence accessed via an iterator initialized via the
152 // assignment operator (as opposed to a copy constructor) matches
154 it = generator.begin();
155 for (size_t i = 0; i < N; ++i) {
156 ASSERT_FALSE(it == generator.end())
157 << "At element " << i << " when accessing via an iterator "
158 << "created with the assignment operator.\n";
159 EXPECT_TRUE(expected_values[i] == *it)
160 << "where i is " << i
161 << ", expected_values[i] is " << PrintValue(expected_values[i])
162 << ", *it is " << PrintValue(*it)
163 << ", and 'it' is an iterator created with the copy constructor.\n";
166 EXPECT_TRUE(it == generator.end())
167 << "At the presumed end of sequence when accessing via an iterator "
168 << "created with the assignment operator.\n";
171 template <typename T>
172 void VerifyGeneratorIsEmpty(const ParamGenerator<T>& generator) {
173 typename ParamGenerator<T>::iterator it = generator.begin();
174 EXPECT_TRUE(it == generator.end());
176 it = generator.begin();
177 EXPECT_TRUE(it == generator.end());
180 // Generator tests. They test that each of the provided generator functions
181 // generates an expected sequence of values. The general test pattern
182 // instantiates a generator using one of the generator functions,
183 // checks the sequence produced by the generator using its iterator API,
184 // and then resets the iterator back to the beginning of the sequence
185 // and checks the sequence again.
187 // Tests that iterators produced by generator functions conform to the
188 // ForwardIterator concept.
189 TEST(IteratorTest, ParamIteratorConformsToForwardIteratorConcept) {
190 const ParamGenerator<int> gen = Range(0, 10);
191 ParamGenerator<int>::iterator it = gen.begin();
193 // Verifies that iterator initialization works as expected.
194 ParamGenerator<int>::iterator it2 = it;
195 EXPECT_TRUE(*it == *it2) << "Initialized iterators must point to the "
196 << "element same as its source points to";
198 // Verifies that iterator assignment works as expected.
200 EXPECT_FALSE(*it == *it2);
202 EXPECT_TRUE(*it == *it2) << "Assigned iterators must point to the "
203 << "element same as its source points to";
205 // Verifies that prefix operator++() returns *this.
206 EXPECT_EQ(&it, &(++it)) << "Result of the prefix operator++ must be "
207 << "refer to the original object";
209 // Verifies that the result of the postfix operator++ points to the value
210 // pointed to by the original iterator.
211 int original_value = *it; // Have to compute it outside of macro call to be
212 // unaffected by the parameter evaluation order.
213 EXPECT_EQ(original_value, *(it++));
215 // Verifies that prefix and postfix operator++() advance an iterator
220 EXPECT_TRUE(*it == *it2);
223 // Tests that Range() generates the expected sequence.
224 TEST(RangeTest, IntRangeWithDefaultStep) {
225 const ParamGenerator<int> gen = Range(0, 3);
226 const int expected_values[] = {0, 1, 2};
227 VerifyGenerator(gen, expected_values);
230 // Edge case. Tests that Range() generates the single element sequence
231 // as expected when provided with range limits that are equal.
232 TEST(RangeTest, IntRangeSingleValue) {
233 const ParamGenerator<int> gen = Range(0, 1);
234 const int expected_values[] = {0};
235 VerifyGenerator(gen, expected_values);
238 // Edge case. Tests that Range() with generates empty sequence when
239 // supplied with an empty range.
240 TEST(RangeTest, IntRangeEmpty) {
241 const ParamGenerator<int> gen = Range(0, 0);
242 VerifyGeneratorIsEmpty(gen);
245 // Tests that Range() with custom step (greater then one) generates
246 // the expected sequence.
247 TEST(RangeTest, IntRangeWithCustomStep) {
248 const ParamGenerator<int> gen = Range(0, 9, 3);
249 const int expected_values[] = {0, 3, 6};
250 VerifyGenerator(gen, expected_values);
253 // Tests that Range() with custom step (greater then one) generates
254 // the expected sequence when the last element does not fall on the
255 // upper range limit. Sequences generated by Range() must not have
256 // elements beyond the range limits.
257 TEST(RangeTest, IntRangeWithCustomStepOverUpperBound) {
258 const ParamGenerator<int> gen = Range(0, 4, 3);
259 const int expected_values[] = {0, 3};
260 VerifyGenerator(gen, expected_values);
263 // Verifies that Range works with user-defined types that define
264 // copy constructor, operator=(), operator+(), and operator<().
267 explicit DogAdder(const char* a_value) : value_(a_value) {}
268 DogAdder(const DogAdder& other) : value_(other.value_.c_str()) {}
270 DogAdder operator=(const DogAdder& other) {
272 value_ = other.value_;
275 DogAdder operator+(const DogAdder& other) const {
277 msg << value_.c_str() << other.value_.c_str();
278 return DogAdder(msg.GetString().c_str());
280 bool operator<(const DogAdder& other) const {
281 return value_ < other.value_;
283 const std::string& value() const { return value_; }
289 TEST(RangeTest, WorksWithACustomType) {
290 const ParamGenerator<DogAdder> gen =
291 Range(DogAdder("cat"), DogAdder("catdogdog"), DogAdder("dog"));
292 ParamGenerator<DogAdder>::iterator it = gen.begin();
294 ASSERT_FALSE(it == gen.end());
295 EXPECT_STREQ("cat", it->value().c_str());
297 ASSERT_FALSE(++it == gen.end());
298 EXPECT_STREQ("catdog", it->value().c_str());
300 EXPECT_TRUE(++it == gen.end());
305 explicit IntWrapper(int a_value) : value_(a_value) {}
306 IntWrapper(const IntWrapper& other) : value_(other.value_) {}
308 IntWrapper operator=(const IntWrapper& other) {
309 value_ = other.value_;
312 // operator+() adds a different type.
313 IntWrapper operator+(int other) const { return IntWrapper(value_ + other); }
314 bool operator<(const IntWrapper& other) const {
315 return value_ < other.value_;
317 int value() const { return value_; }
323 TEST(RangeTest, WorksWithACustomTypeWithDifferentIncrementType) {
324 const ParamGenerator<IntWrapper> gen = Range(IntWrapper(0), IntWrapper(2));
325 ParamGenerator<IntWrapper>::iterator it = gen.begin();
327 ASSERT_FALSE(it == gen.end());
328 EXPECT_EQ(0, it->value());
330 ASSERT_FALSE(++it == gen.end());
331 EXPECT_EQ(1, it->value());
333 EXPECT_TRUE(++it == gen.end());
336 // Tests that ValuesIn() with an array parameter generates
337 // the expected sequence.
338 TEST(ValuesInTest, ValuesInArray) {
339 int array[] = {3, 5, 8};
340 const ParamGenerator<int> gen = ValuesIn(array);
341 VerifyGenerator(gen, array);
344 // Tests that ValuesIn() with a const array parameter generates
345 // the expected sequence.
346 TEST(ValuesInTest, ValuesInConstArray) {
347 const int array[] = {3, 5, 8};
348 const ParamGenerator<int> gen = ValuesIn(array);
349 VerifyGenerator(gen, array);
352 // Edge case. Tests that ValuesIn() with an array parameter containing a
353 // single element generates the single element sequence.
354 TEST(ValuesInTest, ValuesInSingleElementArray) {
356 const ParamGenerator<int> gen = ValuesIn(array);
357 VerifyGenerator(gen, array);
360 // Tests that ValuesIn() generates the expected sequence for an STL
361 // container (vector).
362 TEST(ValuesInTest, ValuesInVector) {
363 typedef ::std::vector<int> ContainerType;
364 ContainerType values;
368 const ParamGenerator<int> gen = ValuesIn(values);
370 const int expected_values[] = {3, 5, 8};
371 VerifyGenerator(gen, expected_values);
374 // Tests that ValuesIn() generates the expected sequence.
375 TEST(ValuesInTest, ValuesInIteratorRange) {
376 typedef ::std::vector<int> ContainerType;
377 ContainerType values;
381 const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
383 const int expected_values[] = {3, 5, 8};
384 VerifyGenerator(gen, expected_values);
387 // Edge case. Tests that ValuesIn() provided with an iterator range specifying a
388 // single value generates a single-element sequence.
389 TEST(ValuesInTest, ValuesInSingleElementIteratorRange) {
390 typedef ::std::vector<int> ContainerType;
391 ContainerType values;
392 values.push_back(42);
393 const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
395 const int expected_values[] = {42};
396 VerifyGenerator(gen, expected_values);
399 // Edge case. Tests that ValuesIn() provided with an empty iterator range
400 // generates an empty sequence.
401 TEST(ValuesInTest, ValuesInEmptyIteratorRange) {
402 typedef ::std::vector<int> ContainerType;
403 ContainerType values;
404 const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end());
406 VerifyGeneratorIsEmpty(gen);
409 // Tests that the Values() generates the expected sequence.
410 TEST(ValuesTest, ValuesWorks) {
411 const ParamGenerator<int> gen = Values(3, 5, 8);
413 const int expected_values[] = {3, 5, 8};
414 VerifyGenerator(gen, expected_values);
417 // Tests that Values() generates the expected sequences from elements of
418 // different types convertible to ParamGenerator's parameter type.
419 TEST(ValuesTest, ValuesWorksForValuesOfCompatibleTypes) {
420 const ParamGenerator<double> gen = Values(3, 5.0f, 8.0);
422 const double expected_values[] = {3.0, 5.0, 8.0};
423 VerifyGenerator(gen, expected_values);
426 TEST(ValuesTest, ValuesWorksForMaxLengthList) {
427 const ParamGenerator<int> gen = Values(
428 10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
429 110, 120, 130, 140, 150, 160, 170, 180, 190, 200,
430 210, 220, 230, 240, 250, 260, 270, 280, 290, 300,
431 310, 320, 330, 340, 350, 360, 370, 380, 390, 400,
432 410, 420, 430, 440, 450, 460, 470, 480, 490, 500);
434 const int expected_values[] = {
435 10, 20, 30, 40, 50, 60, 70, 80, 90, 100,
436 110, 120, 130, 140, 150, 160, 170, 180, 190, 200,
437 210, 220, 230, 240, 250, 260, 270, 280, 290, 300,
438 310, 320, 330, 340, 350, 360, 370, 380, 390, 400,
439 410, 420, 430, 440, 450, 460, 470, 480, 490, 500};
440 VerifyGenerator(gen, expected_values);
443 // Edge case test. Tests that single-parameter Values() generates the sequence
444 // with the single value.
445 TEST(ValuesTest, ValuesWithSingleParameter) {
446 const ParamGenerator<int> gen = Values(42);
448 const int expected_values[] = {42};
449 VerifyGenerator(gen, expected_values);
452 // Tests that Bool() generates sequence (false, true).
453 TEST(BoolTest, BoolWorks) {
454 const ParamGenerator<bool> gen = Bool();
456 const bool expected_values[] = {false, true};
457 VerifyGenerator(gen, expected_values);
460 # if GTEST_HAS_COMBINE
462 // Tests that Combine() with two parameters generates the expected sequence.
463 TEST(CombineTest, CombineWithTwoParameters) {
464 const char* foo = "foo";
465 const char* bar = "bar";
466 const ParamGenerator<tuple<const char*, int> > gen =
467 Combine(Values(foo, bar), Values(3, 4));
469 tuple<const char*, int> expected_values[] = {
470 make_tuple(foo, 3), make_tuple(foo, 4),
471 make_tuple(bar, 3), make_tuple(bar, 4)};
472 VerifyGenerator(gen, expected_values);
475 // Tests that Combine() with three parameters generates the expected sequence.
476 TEST(CombineTest, CombineWithThreeParameters) {
477 const ParamGenerator<tuple<int, int, int> > gen = Combine(Values(0, 1),
480 tuple<int, int, int> expected_values[] = {
481 make_tuple(0, 3, 5), make_tuple(0, 3, 6),
482 make_tuple(0, 4, 5), make_tuple(0, 4, 6),
483 make_tuple(1, 3, 5), make_tuple(1, 3, 6),
484 make_tuple(1, 4, 5), make_tuple(1, 4, 6)};
485 VerifyGenerator(gen, expected_values);
488 // Tests that the Combine() with the first parameter generating a single value
489 // sequence generates a sequence with the number of elements equal to the
490 // number of elements in the sequence generated by the second parameter.
491 TEST(CombineTest, CombineWithFirstParameterSingleValue) {
492 const ParamGenerator<tuple<int, int> > gen = Combine(Values(42),
495 tuple<int, int> expected_values[] = {make_tuple(42, 0), make_tuple(42, 1)};
496 VerifyGenerator(gen, expected_values);
499 // Tests that the Combine() with the second parameter generating a single value
500 // sequence generates a sequence with the number of elements equal to the
501 // number of elements in the sequence generated by the first parameter.
502 TEST(CombineTest, CombineWithSecondParameterSingleValue) {
503 const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1),
506 tuple<int, int> expected_values[] = {make_tuple(0, 42), make_tuple(1, 42)};
507 VerifyGenerator(gen, expected_values);
510 // Tests that when the first parameter produces an empty sequence,
511 // Combine() produces an empty sequence, too.
512 TEST(CombineTest, CombineWithFirstParameterEmptyRange) {
513 const ParamGenerator<tuple<int, int> > gen = Combine(Range(0, 0),
515 VerifyGeneratorIsEmpty(gen);
518 // Tests that when the second parameter produces an empty sequence,
519 // Combine() produces an empty sequence, too.
520 TEST(CombineTest, CombineWithSecondParameterEmptyRange) {
521 const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1),
523 VerifyGeneratorIsEmpty(gen);
526 // Edge case. Tests that combine works with the maximum number
527 // of parameters supported by Google Test (currently 10).
528 TEST(CombineTest, CombineWithMaxNumberOfParameters) {
529 const char* foo = "foo";
530 const char* bar = "bar";
531 const ParamGenerator<tuple<const char*, int, int, int, int, int, int, int,
532 int, int> > gen = Combine(Values(foo, bar),
533 Values(1), Values(2),
534 Values(3), Values(4),
535 Values(5), Values(6),
536 Values(7), Values(8),
539 tuple<const char*, int, int, int, int, int, int, int, int, int>
540 expected_values[] = {make_tuple(foo, 1, 2, 3, 4, 5, 6, 7, 8, 9),
541 make_tuple(bar, 1, 2, 3, 4, 5, 6, 7, 8, 9)};
542 VerifyGenerator(gen, expected_values);
545 # endif // GTEST_HAS_COMBINE
547 // Tests that an generator produces correct sequence after being
548 // assigned from another generator.
549 TEST(ParamGeneratorTest, AssignmentWorks) {
550 ParamGenerator<int> gen = Values(1, 2);
551 const ParamGenerator<int> gen2 = Values(3, 4);
554 const int expected_values[] = {3, 4};
555 VerifyGenerator(gen, expected_values);
558 // This test verifies that the tests are expanded and run as specified:
559 // one test per element from the sequence produced by the generator
560 // specified in INSTANTIATE_TEST_CASE_P. It also verifies that the test's
561 // fixture constructor, SetUp(), and TearDown() have run and have been
562 // supplied with the correct parameters.
564 // The use of environment object allows detection of the case where no test
565 // case functionality is run at all. In this case TestCaseTearDown will not
566 // be able to detect missing tests, naturally.
567 template <int kExpectedCalls>
568 class TestGenerationEnvironment : public ::testing::Environment {
570 static TestGenerationEnvironment* Instance() {
571 static TestGenerationEnvironment* instance = new TestGenerationEnvironment;
575 void FixtureConstructorExecuted() { fixture_constructor_count_++; }
576 void SetUpExecuted() { set_up_count_++; }
577 void TearDownExecuted() { tear_down_count_++; }
578 void TestBodyExecuted() { test_body_count_++; }
580 virtual void TearDown() {
581 // If all MultipleTestGenerationTest tests have been de-selected
582 // by the filter flag, the following checks make no sense.
583 bool perform_check = false;
585 for (int i = 0; i < kExpectedCalls; ++i) {
587 msg << "TestsExpandedAndRun/" << i;
588 if (UnitTestOptions::FilterMatchesTest(
589 "TestExpansionModule/MultipleTestGenerationTest",
590 msg.GetString().c_str())) {
591 perform_check = true;
595 EXPECT_EQ(kExpectedCalls, fixture_constructor_count_)
596 << "Fixture constructor of ParamTestGenerationTest test case "
597 << "has not been run as expected.";
598 EXPECT_EQ(kExpectedCalls, set_up_count_)
599 << "Fixture SetUp method of ParamTestGenerationTest test case "
600 << "has not been run as expected.";
601 EXPECT_EQ(kExpectedCalls, tear_down_count_)
602 << "Fixture TearDown method of ParamTestGenerationTest test case "
603 << "has not been run as expected.";
604 EXPECT_EQ(kExpectedCalls, test_body_count_)
605 << "Test in ParamTestGenerationTest test case "
606 << "has not been run as expected.";
611 TestGenerationEnvironment() : fixture_constructor_count_(0), set_up_count_(0),
612 tear_down_count_(0), test_body_count_(0) {}
614 int fixture_constructor_count_;
616 int tear_down_count_;
617 int test_body_count_;
619 GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationEnvironment);
622 const int test_generation_params[] = {36, 42, 72};
624 class TestGenerationTest : public TestWithParam<int> {
628 sizeof(test_generation_params)/sizeof(test_generation_params[0])
631 typedef TestGenerationEnvironment<PARAMETER_COUNT> Environment;
633 TestGenerationTest() {
634 Environment::Instance()->FixtureConstructorExecuted();
635 current_parameter_ = GetParam();
637 virtual void SetUp() {
638 Environment::Instance()->SetUpExecuted();
639 EXPECT_EQ(current_parameter_, GetParam());
641 virtual void TearDown() {
642 Environment::Instance()->TearDownExecuted();
643 EXPECT_EQ(current_parameter_, GetParam());
646 static void SetUpTestCase() {
647 bool all_tests_in_test_case_selected = true;
649 for (int i = 0; i < PARAMETER_COUNT; ++i) {
651 test_name << "TestsExpandedAndRun/" << i;
652 if ( !UnitTestOptions::FilterMatchesTest(
653 "TestExpansionModule/MultipleTestGenerationTest",
654 test_name.GetString())) {
655 all_tests_in_test_case_selected = false;
658 EXPECT_TRUE(all_tests_in_test_case_selected)
659 << "When running the TestGenerationTest test case all of its tests\n"
660 << "must be selected by the filter flag for the test case to pass.\n"
661 << "If not all of them are enabled, we can't reliably conclude\n"
662 << "that the correct number of tests have been generated.";
664 collected_parameters_.clear();
667 static void TearDownTestCase() {
668 vector<int> expected_values(test_generation_params,
669 test_generation_params + PARAMETER_COUNT);
670 // Test execution order is not guaranteed by Google Test,
671 // so the order of values in collected_parameters_ can be
672 // different and we have to sort to compare.
673 sort(expected_values.begin(), expected_values.end());
674 sort(collected_parameters_.begin(), collected_parameters_.end());
676 EXPECT_TRUE(collected_parameters_ == expected_values);
680 int current_parameter_;
681 static vector<int> collected_parameters_;
684 GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationTest);
686 vector<int> TestGenerationTest::collected_parameters_;
688 TEST_P(TestGenerationTest, TestsExpandedAndRun) {
689 Environment::Instance()->TestBodyExecuted();
690 EXPECT_EQ(current_parameter_, GetParam());
691 collected_parameters_.push_back(GetParam());
693 INSTANTIATE_TEST_CASE_P(TestExpansionModule, TestGenerationTest,
694 ValuesIn(test_generation_params));
696 // This test verifies that the element sequence (third parameter of
697 // INSTANTIATE_TEST_CASE_P) is evaluated in InitGoogleTest() and neither at
698 // the call site of INSTANTIATE_TEST_CASE_P nor in RUN_ALL_TESTS(). For
699 // that, we declare param_value_ to be a static member of
700 // GeneratorEvaluationTest and initialize it to 0. We set it to 1 in
701 // main(), just before invocation of InitGoogleTest(). After calling
702 // InitGoogleTest(), we set the value to 2. If the sequence is evaluated
703 // before or after InitGoogleTest, INSTANTIATE_TEST_CASE_P will create a
704 // test with parameter other than 1, and the test body will fail the
706 class GeneratorEvaluationTest : public TestWithParam<int> {
708 static int param_value() { return param_value_; }
709 static void set_param_value(int param_value) { param_value_ = param_value; }
712 static int param_value_;
714 int GeneratorEvaluationTest::param_value_ = 0;
716 TEST_P(GeneratorEvaluationTest, GeneratorsEvaluatedInMain) {
717 EXPECT_EQ(1, GetParam());
719 INSTANTIATE_TEST_CASE_P(GenEvalModule,
720 GeneratorEvaluationTest,
721 Values(GeneratorEvaluationTest::param_value()));
723 // Tests that generators defined in a different translation unit are
724 // functional. Generator extern_gen is defined in gtest-param-test_test2.cc.
725 extern ParamGenerator<int> extern_gen;
726 class ExternalGeneratorTest : public TestWithParam<int> {};
727 TEST_P(ExternalGeneratorTest, ExternalGenerator) {
728 // Sequence produced by extern_gen contains only a single value
729 // which we verify here.
730 EXPECT_EQ(GetParam(), 33);
732 INSTANTIATE_TEST_CASE_P(ExternalGeneratorModule,
733 ExternalGeneratorTest,
736 // Tests that a parameterized test case can be defined in one translation
737 // unit and instantiated in another. This test will be instantiated in
738 // gtest-param-test_test2.cc. ExternalInstantiationTest fixture class is
739 // defined in gtest-param-test_test.h.
740 TEST_P(ExternalInstantiationTest, IsMultipleOf33) {
741 EXPECT_EQ(0, GetParam() % 33);
744 // Tests that a parameterized test case can be instantiated with multiple
746 class MultipleInstantiationTest : public TestWithParam<int> {};
747 TEST_P(MultipleInstantiationTest, AllowsMultipleInstances) {
749 INSTANTIATE_TEST_CASE_P(Sequence1, MultipleInstantiationTest, Values(1, 2));
750 INSTANTIATE_TEST_CASE_P(Sequence2, MultipleInstantiationTest, Range(3, 5));
752 // Tests that a parameterized test case can be instantiated
753 // in multiple translation units. This test will be instantiated
754 // here and in gtest-param-test_test2.cc.
755 // InstantiationInMultipleTranslationUnitsTest fixture class
756 // is defined in gtest-param-test_test.h.
757 TEST_P(InstantiationInMultipleTranslaionUnitsTest, IsMultipleOf42) {
758 EXPECT_EQ(0, GetParam() % 42);
760 INSTANTIATE_TEST_CASE_P(Sequence1,
761 InstantiationInMultipleTranslaionUnitsTest,
764 // Tests that each iteration of parameterized test runs in a separate test
766 class SeparateInstanceTest : public TestWithParam<int> {
768 SeparateInstanceTest() : count_(0) {}
770 static void TearDownTestCase() {
771 EXPECT_GE(global_count_, 2)
772 << "If some (but not all) SeparateInstanceTest tests have been "
773 << "filtered out this test will fail. Make sure that all "
774 << "GeneratorEvaluationTest are selected or de-selected together "
775 << "by the test filter.";
780 static int global_count_;
782 int SeparateInstanceTest::global_count_ = 0;
784 TEST_P(SeparateInstanceTest, TestsRunInSeparateInstances) {
785 EXPECT_EQ(0, count_++);
788 INSTANTIATE_TEST_CASE_P(FourElemSequence, SeparateInstanceTest, Range(1, 4));
790 // Tests that all instantiations of a test have named appropriately. Test
791 // defined with TEST_P(TestCaseName, TestName) and instantiated with
792 // INSTANTIATE_TEST_CASE_P(SequenceName, TestCaseName, generator) must be named
793 // SequenceName/TestCaseName.TestName/i, where i is the 0-based index of the
794 // sequence element used to instantiate the test.
795 class NamingTest : public TestWithParam<int> {};
797 TEST_P(NamingTest, TestsReportCorrectNamesAndParameters) {
798 const ::testing::TestInfo* const test_info =
799 ::testing::UnitTest::GetInstance()->current_test_info();
801 EXPECT_STREQ("ZeroToFiveSequence/NamingTest", test_info->test_case_name());
803 Message index_stream;
804 index_stream << "TestsReportCorrectNamesAndParameters/" << GetParam();
805 EXPECT_STREQ(index_stream.GetString().c_str(), test_info->name());
807 EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param());
810 INSTANTIATE_TEST_CASE_P(ZeroToFiveSequence, NamingTest, Range(0, 5));
812 // Tests that user supplied custom parameter names are working correctly.
813 // Runs the test with a builtin helper method which uses PrintToString,
814 // as well as a custom function and custom functor to ensure all possible
815 // uses work correctly.
816 class CustomFunctorNamingTest : public TestWithParam<std::string> {};
817 TEST_P(CustomFunctorNamingTest, CustomTestNames) {}
819 struct CustomParamNameFunctor {
820 std::string operator()(const ::testing::TestParamInfo<std::string>& info) {
825 INSTANTIATE_TEST_CASE_P(CustomParamNameFunctor,
826 CustomFunctorNamingTest,
827 Values(std::string("FunctorName")),
828 CustomParamNameFunctor());
830 INSTANTIATE_TEST_CASE_P(AllAllowedCharacters,
831 CustomFunctorNamingTest,
832 Values("abcdefghijklmnopqrstuvwxyz",
833 "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
835 CustomParamNameFunctor());
837 inline std::string CustomParamNameFunction(
838 const ::testing::TestParamInfo<std::string>& info) {
842 class CustomFunctionNamingTest : public TestWithParam<std::string> {};
843 TEST_P(CustomFunctionNamingTest, CustomTestNames) {}
845 INSTANTIATE_TEST_CASE_P(CustomParamNameFunction,
846 CustomFunctionNamingTest,
847 Values(std::string("FunctionName")),
848 CustomParamNameFunction);
852 // Test custom naming with a lambda
854 class CustomLambdaNamingTest : public TestWithParam<std::string> {};
855 TEST_P(CustomLambdaNamingTest, CustomTestNames) {}
857 INSTANTIATE_TEST_CASE_P(CustomParamNameLambda,
858 CustomLambdaNamingTest,
859 Values(std::string("LambdaName")),
860 [](const ::testing::TestParamInfo<std::string>& info) {
864 #endif // GTEST_LANG_CXX11
866 TEST(CustomNamingTest, CheckNameRegistry) {
867 ::testing::UnitTest* unit_test = ::testing::UnitTest::GetInstance();
868 std::set<std::string> test_names;
869 for (int case_num = 0;
870 case_num < unit_test->total_test_case_count();
872 const ::testing::TestCase* test_case = unit_test->GetTestCase(case_num);
873 for (int test_num = 0;
874 test_num < test_case->total_test_count();
876 const ::testing::TestInfo* test_info = test_case->GetTestInfo(test_num);
877 test_names.insert(std::string(test_info->name()));
880 EXPECT_EQ(1u, test_names.count("CustomTestNames/FunctorName"));
881 EXPECT_EQ(1u, test_names.count("CustomTestNames/FunctionName"));
883 EXPECT_EQ(1u, test_names.count("CustomTestNames/LambdaName"));
884 #endif // GTEST_LANG_CXX11
887 // Test a numeric name to ensure PrintToStringParamName works correctly.
889 class CustomIntegerNamingTest : public TestWithParam<int> {};
891 TEST_P(CustomIntegerNamingTest, TestsReportCorrectNames) {
892 const ::testing::TestInfo* const test_info =
893 ::testing::UnitTest::GetInstance()->current_test_info();
894 Message test_name_stream;
895 test_name_stream << "TestsReportCorrectNames/" << GetParam();
896 EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
899 INSTANTIATE_TEST_CASE_P(PrintToString,
900 CustomIntegerNamingTest,
902 ::testing::PrintToStringParamName());
904 // Test a custom struct with PrintToString.
906 struct CustomStruct {
907 explicit CustomStruct(int value) : x(value) {}
911 std::ostream& operator<<(std::ostream& stream, const CustomStruct& val) {
916 class CustomStructNamingTest : public TestWithParam<CustomStruct> {};
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());
926 INSTANTIATE_TEST_CASE_P(PrintToString,
927 CustomStructNamingTest,
928 Values(CustomStruct(0), CustomStruct(1)),
929 ::testing::PrintToStringParamName());
931 // Test that using a stateful parameter naming function works as expected.
933 struct StatefulNamingFunctor {
934 StatefulNamingFunctor() : sum(0) {}
935 std::string operator()(const ::testing::TestParamInfo<int>& info) {
936 int value = info.param + sum;
938 return ::testing::PrintToString(value);
943 class StatefulNamingTest : public ::testing::TestWithParam<int> {
945 StatefulNamingTest() : sum_(0) {}
949 TEST_P(StatefulNamingTest, TestsReportCorrectNames) {
950 const ::testing::TestInfo* const test_info =
951 ::testing::UnitTest::GetInstance()->current_test_info();
953 Message test_name_stream;
954 test_name_stream << "TestsReportCorrectNames/" << sum_;
955 EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name());
958 INSTANTIATE_TEST_CASE_P(StatefulNamingFunctor,
961 StatefulNamingFunctor());
963 // Class that cannot be streamed into an ostream. It needs to be copyable
964 // (and, in case of MSVC, also assignable) in order to be a test parameter
965 // type. Its default copy constructor and assignment operator do exactly
969 explicit Unstreamable(int value) : value_(value) {}
975 class CommentTest : public TestWithParam<Unstreamable> {};
977 TEST_P(CommentTest, TestsCorrectlyReportUnstreamableParams) {
978 const ::testing::TestInfo* const test_info =
979 ::testing::UnitTest::GetInstance()->current_test_info();
981 EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param());
984 INSTANTIATE_TEST_CASE_P(InstantiationWithComments,
986 Values(Unstreamable(1)));
988 // Verify that we can create a hierarchy of test fixtures, where the base
989 // class fixture is not parameterized and the derived class is. In this case
990 // ParameterizedDerivedTest inherits from NonParameterizedBaseTest. We
991 // perform simple tests on both.
992 class NonParameterizedBaseTest : public ::testing::Test {
994 NonParameterizedBaseTest() : n_(17) { }
999 class ParameterizedDerivedTest : public NonParameterizedBaseTest,
1000 public ::testing::WithParamInterface<int> {
1002 ParameterizedDerivedTest() : count_(0) { }
1004 static int global_count_;
1007 int ParameterizedDerivedTest::global_count_ = 0;
1009 TEST_F(NonParameterizedBaseTest, FixtureIsInitialized) {
1013 TEST_P(ParameterizedDerivedTest, SeesSequence) {
1015 EXPECT_EQ(0, count_++);
1016 EXPECT_EQ(GetParam(), global_count_++);
1019 class ParameterizedDeathTest : public ::testing::TestWithParam<int> { };
1021 TEST_F(ParameterizedDeathTest, GetParamDiesFromTestF) {
1022 EXPECT_DEATH_IF_SUPPORTED(GetParam(),
1023 ".* value-parameterized test .*");
1026 INSTANTIATE_TEST_CASE_P(RangeZeroToFive, ParameterizedDerivedTest, Range(0, 5));
1028 #endif // GTEST_HAS_PARAM_TEST
1030 TEST(CompileTest, CombineIsDefinedOnlyWhenGtestHasParamTestIsDefined) {
1031 #if GTEST_HAS_COMBINE && !GTEST_HAS_PARAM_TEST
1032 FAIL() << "GTEST_HAS_COMBINE is defined while GTEST_HAS_PARAM_TEST is not\n"
1036 int main(int argc, char **argv) {
1037 #if GTEST_HAS_PARAM_TEST
1038 // Used in TestGenerationTest test case.
1039 AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance());
1040 // Used in GeneratorEvaluationTest test case. Tests that the updated value
1041 // will be picked up for instantiating tests in GeneratorEvaluationTest.
1042 GeneratorEvaluationTest::set_param_value(1);
1043 #endif // GTEST_HAS_PARAM_TEST
1045 ::testing::InitGoogleTest(&argc, argv);
1047 #if GTEST_HAS_PARAM_TEST
1048 // Used in GeneratorEvaluationTest test case. Tests that value updated
1049 // here will NOT be used for instantiating tests in
1050 // GeneratorEvaluationTest.
1051 GeneratorEvaluationTest::set_param_value(2);
1052 #endif // GTEST_HAS_PARAM_TEST
1054 return RUN_ALL_TESTS();