113481Sgiacomo.travaglini@arm.com// Copyright 2008, Google Inc. 213481Sgiacomo.travaglini@arm.com// All rights reserved. 313481Sgiacomo.travaglini@arm.com// 413481Sgiacomo.travaglini@arm.com// Redistribution and use in source and binary forms, with or without 513481Sgiacomo.travaglini@arm.com// modification, are permitted provided that the following conditions are 613481Sgiacomo.travaglini@arm.com// met: 713481Sgiacomo.travaglini@arm.com// 813481Sgiacomo.travaglini@arm.com// * Redistributions of source code must retain the above copyright 913481Sgiacomo.travaglini@arm.com// notice, this list of conditions and the following disclaimer. 1013481Sgiacomo.travaglini@arm.com// * Redistributions in binary form must reproduce the above 1113481Sgiacomo.travaglini@arm.com// copyright notice, this list of conditions and the following disclaimer 1213481Sgiacomo.travaglini@arm.com// in the documentation and/or other materials provided with the 1313481Sgiacomo.travaglini@arm.com// distribution. 1413481Sgiacomo.travaglini@arm.com// * Neither the name of Google Inc. nor the names of its 1513481Sgiacomo.travaglini@arm.com// contributors may be used to endorse or promote products derived from 1613481Sgiacomo.travaglini@arm.com// this software without specific prior written permission. 1713481Sgiacomo.travaglini@arm.com// 1813481Sgiacomo.travaglini@arm.com// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 1913481Sgiacomo.travaglini@arm.com// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 2013481Sgiacomo.travaglini@arm.com// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 2113481Sgiacomo.travaglini@arm.com// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 2213481Sgiacomo.travaglini@arm.com// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 2313481Sgiacomo.travaglini@arm.com// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 2413481Sgiacomo.travaglini@arm.com// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 2513481Sgiacomo.travaglini@arm.com// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 2613481Sgiacomo.travaglini@arm.com// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 2713481Sgiacomo.travaglini@arm.com// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 2813481Sgiacomo.travaglini@arm.com// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 2913481Sgiacomo.travaglini@arm.com// 3013481Sgiacomo.travaglini@arm.com// Author: vladl@google.com (Vlad Losev) 3113481Sgiacomo.travaglini@arm.com// 3213481Sgiacomo.travaglini@arm.com// Tests for Google Test itself. This file verifies that the parameter 3313481Sgiacomo.travaglini@arm.com// generators objects produce correct parameter sequences and that 3413481Sgiacomo.travaglini@arm.com// Google Test runtime instantiates correct tests from those sequences. 3513481Sgiacomo.travaglini@arm.com 3613481Sgiacomo.travaglini@arm.com#include "gtest/gtest.h" 3713481Sgiacomo.travaglini@arm.com 3813481Sgiacomo.travaglini@arm.com#if GTEST_HAS_PARAM_TEST 3913481Sgiacomo.travaglini@arm.com 4013481Sgiacomo.travaglini@arm.com# include <algorithm> 4113481Sgiacomo.travaglini@arm.com# include <iostream> 4213481Sgiacomo.travaglini@arm.com# include <list> 4313481Sgiacomo.travaglini@arm.com# include <sstream> 4413481Sgiacomo.travaglini@arm.com# include <string> 4513481Sgiacomo.travaglini@arm.com# include <vector> 4613481Sgiacomo.travaglini@arm.com 4713481Sgiacomo.travaglini@arm.com// To include gtest-internal-inl.h. 4813481Sgiacomo.travaglini@arm.com# define GTEST_IMPLEMENTATION_ 1 4913481Sgiacomo.travaglini@arm.com# include "src/gtest-internal-inl.h" // for UnitTestOptions 5013481Sgiacomo.travaglini@arm.com# undef GTEST_IMPLEMENTATION_ 5113481Sgiacomo.travaglini@arm.com 5213481Sgiacomo.travaglini@arm.com# include "test/gtest-param-test_test.h" 5313481Sgiacomo.travaglini@arm.com 5413481Sgiacomo.travaglini@arm.comusing ::std::vector; 5513481Sgiacomo.travaglini@arm.comusing ::std::sort; 5613481Sgiacomo.travaglini@arm.com 5713481Sgiacomo.travaglini@arm.comusing ::testing::AddGlobalTestEnvironment; 5813481Sgiacomo.travaglini@arm.comusing ::testing::Bool; 5913481Sgiacomo.travaglini@arm.comusing ::testing::Message; 6013481Sgiacomo.travaglini@arm.comusing ::testing::Range; 6113481Sgiacomo.travaglini@arm.comusing ::testing::TestWithParam; 6213481Sgiacomo.travaglini@arm.comusing ::testing::Values; 6313481Sgiacomo.travaglini@arm.comusing ::testing::ValuesIn; 6413481Sgiacomo.travaglini@arm.com 6513481Sgiacomo.travaglini@arm.com# if GTEST_HAS_COMBINE 6613481Sgiacomo.travaglini@arm.comusing ::testing::Combine; 6713481Sgiacomo.travaglini@arm.comusing ::testing::get; 6813481Sgiacomo.travaglini@arm.comusing ::testing::make_tuple; 6913481Sgiacomo.travaglini@arm.comusing ::testing::tuple; 7013481Sgiacomo.travaglini@arm.com# endif // GTEST_HAS_COMBINE 7113481Sgiacomo.travaglini@arm.com 7213481Sgiacomo.travaglini@arm.comusing ::testing::internal::ParamGenerator; 7313481Sgiacomo.travaglini@arm.comusing ::testing::internal::UnitTestOptions; 7413481Sgiacomo.travaglini@arm.com 7513481Sgiacomo.travaglini@arm.com// Prints a value to a string. 7613481Sgiacomo.travaglini@arm.com// 7713481Sgiacomo.travaglini@arm.com// TODO(wan@google.com): remove PrintValue() when we move matchers and 7813481Sgiacomo.travaglini@arm.com// EXPECT_THAT() from Google Mock to Google Test. At that time, we 7913481Sgiacomo.travaglini@arm.com// can write EXPECT_THAT(x, Eq(y)) to compare two tuples x and y, as 8013481Sgiacomo.travaglini@arm.com// EXPECT_THAT() and the matchers know how to print tuples. 8113481Sgiacomo.travaglini@arm.comtemplate <typename T> 8213481Sgiacomo.travaglini@arm.com::std::string PrintValue(const T& value) { 8313481Sgiacomo.travaglini@arm.com ::std::stringstream stream; 8413481Sgiacomo.travaglini@arm.com stream << value; 8513481Sgiacomo.travaglini@arm.com return stream.str(); 8613481Sgiacomo.travaglini@arm.com} 8713481Sgiacomo.travaglini@arm.com 8813481Sgiacomo.travaglini@arm.com# if GTEST_HAS_COMBINE 8913481Sgiacomo.travaglini@arm.com 9013481Sgiacomo.travaglini@arm.com// These overloads allow printing tuples in our tests. We cannot 9113481Sgiacomo.travaglini@arm.com// define an operator<< for tuples, as that definition needs to be in 9213481Sgiacomo.travaglini@arm.com// the std namespace in order to be picked up by Google Test via 9313481Sgiacomo.travaglini@arm.com// Argument-Dependent Lookup, yet defining anything in the std 9413481Sgiacomo.travaglini@arm.com// namespace in non-STL code is undefined behavior. 9513481Sgiacomo.travaglini@arm.com 9613481Sgiacomo.travaglini@arm.comtemplate <typename T1, typename T2> 9713481Sgiacomo.travaglini@arm.com::std::string PrintValue(const tuple<T1, T2>& value) { 9813481Sgiacomo.travaglini@arm.com ::std::stringstream stream; 9913481Sgiacomo.travaglini@arm.com stream << "(" << get<0>(value) << ", " << get<1>(value) << ")"; 10013481Sgiacomo.travaglini@arm.com return stream.str(); 10113481Sgiacomo.travaglini@arm.com} 10213481Sgiacomo.travaglini@arm.com 10313481Sgiacomo.travaglini@arm.comtemplate <typename T1, typename T2, typename T3> 10413481Sgiacomo.travaglini@arm.com::std::string PrintValue(const tuple<T1, T2, T3>& value) { 10513481Sgiacomo.travaglini@arm.com ::std::stringstream stream; 10613481Sgiacomo.travaglini@arm.com stream << "(" << get<0>(value) << ", " << get<1>(value) 10713481Sgiacomo.travaglini@arm.com << ", "<< get<2>(value) << ")"; 10813481Sgiacomo.travaglini@arm.com return stream.str(); 10913481Sgiacomo.travaglini@arm.com} 11013481Sgiacomo.travaglini@arm.com 11113481Sgiacomo.travaglini@arm.comtemplate <typename T1, typename T2, typename T3, typename T4, typename T5, 11213481Sgiacomo.travaglini@arm.com typename T6, typename T7, typename T8, typename T9, typename T10> 11313481Sgiacomo.travaglini@arm.com::std::string PrintValue( 11413481Sgiacomo.travaglini@arm.com const tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& value) { 11513481Sgiacomo.travaglini@arm.com ::std::stringstream stream; 11613481Sgiacomo.travaglini@arm.com stream << "(" << get<0>(value) << ", " << get<1>(value) 11713481Sgiacomo.travaglini@arm.com << ", "<< get<2>(value) << ", " << get<3>(value) 11813481Sgiacomo.travaglini@arm.com << ", "<< get<4>(value) << ", " << get<5>(value) 11913481Sgiacomo.travaglini@arm.com << ", "<< get<6>(value) << ", " << get<7>(value) 12013481Sgiacomo.travaglini@arm.com << ", "<< get<8>(value) << ", " << get<9>(value) << ")"; 12113481Sgiacomo.travaglini@arm.com return stream.str(); 12213481Sgiacomo.travaglini@arm.com} 12313481Sgiacomo.travaglini@arm.com 12413481Sgiacomo.travaglini@arm.com# endif // GTEST_HAS_COMBINE 12513481Sgiacomo.travaglini@arm.com 12613481Sgiacomo.travaglini@arm.com// Verifies that a sequence generated by the generator and accessed 12713481Sgiacomo.travaglini@arm.com// via the iterator object matches the expected one using Google Test 12813481Sgiacomo.travaglini@arm.com// assertions. 12913481Sgiacomo.travaglini@arm.comtemplate <typename T, size_t N> 13013481Sgiacomo.travaglini@arm.comvoid VerifyGenerator(const ParamGenerator<T>& generator, 13113481Sgiacomo.travaglini@arm.com const T (&expected_values)[N]) { 13213481Sgiacomo.travaglini@arm.com typename ParamGenerator<T>::iterator it = generator.begin(); 13313481Sgiacomo.travaglini@arm.com for (size_t i = 0; i < N; ++i) { 13413481Sgiacomo.travaglini@arm.com ASSERT_FALSE(it == generator.end()) 13513481Sgiacomo.travaglini@arm.com << "At element " << i << " when accessing via an iterator " 13613481Sgiacomo.travaglini@arm.com << "created with the copy constructor.\n"; 13713481Sgiacomo.travaglini@arm.com // We cannot use EXPECT_EQ() here as the values may be tuples, 13813481Sgiacomo.travaglini@arm.com // which don't support <<. 13913481Sgiacomo.travaglini@arm.com EXPECT_TRUE(expected_values[i] == *it) 14013481Sgiacomo.travaglini@arm.com << "where i is " << i 14113481Sgiacomo.travaglini@arm.com << ", expected_values[i] is " << PrintValue(expected_values[i]) 14213481Sgiacomo.travaglini@arm.com << ", *it is " << PrintValue(*it) 14313481Sgiacomo.travaglini@arm.com << ", and 'it' is an iterator created with the copy constructor.\n"; 14413481Sgiacomo.travaglini@arm.com it++; 14513481Sgiacomo.travaglini@arm.com } 14613481Sgiacomo.travaglini@arm.com EXPECT_TRUE(it == generator.end()) 14713481Sgiacomo.travaglini@arm.com << "At the presumed end of sequence when accessing via an iterator " 14813481Sgiacomo.travaglini@arm.com << "created with the copy constructor.\n"; 14913481Sgiacomo.travaglini@arm.com 15013481Sgiacomo.travaglini@arm.com // Test the iterator assignment. The following lines verify that 15113481Sgiacomo.travaglini@arm.com // the sequence accessed via an iterator initialized via the 15213481Sgiacomo.travaglini@arm.com // assignment operator (as opposed to a copy constructor) matches 15313481Sgiacomo.travaglini@arm.com // just the same. 15413481Sgiacomo.travaglini@arm.com it = generator.begin(); 15513481Sgiacomo.travaglini@arm.com for (size_t i = 0; i < N; ++i) { 15613481Sgiacomo.travaglini@arm.com ASSERT_FALSE(it == generator.end()) 15713481Sgiacomo.travaglini@arm.com << "At element " << i << " when accessing via an iterator " 15813481Sgiacomo.travaglini@arm.com << "created with the assignment operator.\n"; 15913481Sgiacomo.travaglini@arm.com EXPECT_TRUE(expected_values[i] == *it) 16013481Sgiacomo.travaglini@arm.com << "where i is " << i 16113481Sgiacomo.travaglini@arm.com << ", expected_values[i] is " << PrintValue(expected_values[i]) 16213481Sgiacomo.travaglini@arm.com << ", *it is " << PrintValue(*it) 16313481Sgiacomo.travaglini@arm.com << ", and 'it' is an iterator created with the copy constructor.\n"; 16413481Sgiacomo.travaglini@arm.com it++; 16513481Sgiacomo.travaglini@arm.com } 16613481Sgiacomo.travaglini@arm.com EXPECT_TRUE(it == generator.end()) 16713481Sgiacomo.travaglini@arm.com << "At the presumed end of sequence when accessing via an iterator " 16813481Sgiacomo.travaglini@arm.com << "created with the assignment operator.\n"; 16913481Sgiacomo.travaglini@arm.com} 17013481Sgiacomo.travaglini@arm.com 17113481Sgiacomo.travaglini@arm.comtemplate <typename T> 17213481Sgiacomo.travaglini@arm.comvoid VerifyGeneratorIsEmpty(const ParamGenerator<T>& generator) { 17313481Sgiacomo.travaglini@arm.com typename ParamGenerator<T>::iterator it = generator.begin(); 17413481Sgiacomo.travaglini@arm.com EXPECT_TRUE(it == generator.end()); 17513481Sgiacomo.travaglini@arm.com 17613481Sgiacomo.travaglini@arm.com it = generator.begin(); 17713481Sgiacomo.travaglini@arm.com EXPECT_TRUE(it == generator.end()); 17813481Sgiacomo.travaglini@arm.com} 17913481Sgiacomo.travaglini@arm.com 18013481Sgiacomo.travaglini@arm.com// Generator tests. They test that each of the provided generator functions 18113481Sgiacomo.travaglini@arm.com// generates an expected sequence of values. The general test pattern 18213481Sgiacomo.travaglini@arm.com// instantiates a generator using one of the generator functions, 18313481Sgiacomo.travaglini@arm.com// checks the sequence produced by the generator using its iterator API, 18413481Sgiacomo.travaglini@arm.com// and then resets the iterator back to the beginning of the sequence 18513481Sgiacomo.travaglini@arm.com// and checks the sequence again. 18613481Sgiacomo.travaglini@arm.com 18713481Sgiacomo.travaglini@arm.com// Tests that iterators produced by generator functions conform to the 18813481Sgiacomo.travaglini@arm.com// ForwardIterator concept. 18913481Sgiacomo.travaglini@arm.comTEST(IteratorTest, ParamIteratorConformsToForwardIteratorConcept) { 19013481Sgiacomo.travaglini@arm.com const ParamGenerator<int> gen = Range(0, 10); 19113481Sgiacomo.travaglini@arm.com ParamGenerator<int>::iterator it = gen.begin(); 19213481Sgiacomo.travaglini@arm.com 19313481Sgiacomo.travaglini@arm.com // Verifies that iterator initialization works as expected. 19413481Sgiacomo.travaglini@arm.com ParamGenerator<int>::iterator it2 = it; 19513481Sgiacomo.travaglini@arm.com EXPECT_TRUE(*it == *it2) << "Initialized iterators must point to the " 19613481Sgiacomo.travaglini@arm.com << "element same as its source points to"; 19713481Sgiacomo.travaglini@arm.com 19813481Sgiacomo.travaglini@arm.com // Verifies that iterator assignment works as expected. 19913481Sgiacomo.travaglini@arm.com it++; 20013481Sgiacomo.travaglini@arm.com EXPECT_FALSE(*it == *it2); 20113481Sgiacomo.travaglini@arm.com it2 = it; 20213481Sgiacomo.travaglini@arm.com EXPECT_TRUE(*it == *it2) << "Assigned iterators must point to the " 20313481Sgiacomo.travaglini@arm.com << "element same as its source points to"; 20413481Sgiacomo.travaglini@arm.com 20513481Sgiacomo.travaglini@arm.com // Verifies that prefix operator++() returns *this. 20613481Sgiacomo.travaglini@arm.com EXPECT_EQ(&it, &(++it)) << "Result of the prefix operator++ must be " 20713481Sgiacomo.travaglini@arm.com << "refer to the original object"; 20813481Sgiacomo.travaglini@arm.com 20913481Sgiacomo.travaglini@arm.com // Verifies that the result of the postfix operator++ points to the value 21013481Sgiacomo.travaglini@arm.com // pointed to by the original iterator. 21113481Sgiacomo.travaglini@arm.com int original_value = *it; // Have to compute it outside of macro call to be 21213481Sgiacomo.travaglini@arm.com // unaffected by the parameter evaluation order. 21313481Sgiacomo.travaglini@arm.com EXPECT_EQ(original_value, *(it++)); 21413481Sgiacomo.travaglini@arm.com 21513481Sgiacomo.travaglini@arm.com // Verifies that prefix and postfix operator++() advance an iterator 21613481Sgiacomo.travaglini@arm.com // all the same. 21713481Sgiacomo.travaglini@arm.com it2 = it; 21813481Sgiacomo.travaglini@arm.com it++; 21913481Sgiacomo.travaglini@arm.com ++it2; 22013481Sgiacomo.travaglini@arm.com EXPECT_TRUE(*it == *it2); 22113481Sgiacomo.travaglini@arm.com} 22213481Sgiacomo.travaglini@arm.com 22313481Sgiacomo.travaglini@arm.com// Tests that Range() generates the expected sequence. 22413481Sgiacomo.travaglini@arm.comTEST(RangeTest, IntRangeWithDefaultStep) { 22513481Sgiacomo.travaglini@arm.com const ParamGenerator<int> gen = Range(0, 3); 22613481Sgiacomo.travaglini@arm.com const int expected_values[] = {0, 1, 2}; 22713481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, expected_values); 22813481Sgiacomo.travaglini@arm.com} 22913481Sgiacomo.travaglini@arm.com 23013481Sgiacomo.travaglini@arm.com// Edge case. Tests that Range() generates the single element sequence 23113481Sgiacomo.travaglini@arm.com// as expected when provided with range limits that are equal. 23213481Sgiacomo.travaglini@arm.comTEST(RangeTest, IntRangeSingleValue) { 23313481Sgiacomo.travaglini@arm.com const ParamGenerator<int> gen = Range(0, 1); 23413481Sgiacomo.travaglini@arm.com const int expected_values[] = {0}; 23513481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, expected_values); 23613481Sgiacomo.travaglini@arm.com} 23713481Sgiacomo.travaglini@arm.com 23813481Sgiacomo.travaglini@arm.com// Edge case. Tests that Range() with generates empty sequence when 23913481Sgiacomo.travaglini@arm.com// supplied with an empty range. 24013481Sgiacomo.travaglini@arm.comTEST(RangeTest, IntRangeEmpty) { 24113481Sgiacomo.travaglini@arm.com const ParamGenerator<int> gen = Range(0, 0); 24213481Sgiacomo.travaglini@arm.com VerifyGeneratorIsEmpty(gen); 24313481Sgiacomo.travaglini@arm.com} 24413481Sgiacomo.travaglini@arm.com 24513481Sgiacomo.travaglini@arm.com// Tests that Range() with custom step (greater then one) generates 24613481Sgiacomo.travaglini@arm.com// the expected sequence. 24713481Sgiacomo.travaglini@arm.comTEST(RangeTest, IntRangeWithCustomStep) { 24813481Sgiacomo.travaglini@arm.com const ParamGenerator<int> gen = Range(0, 9, 3); 24913481Sgiacomo.travaglini@arm.com const int expected_values[] = {0, 3, 6}; 25013481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, expected_values); 25113481Sgiacomo.travaglini@arm.com} 25213481Sgiacomo.travaglini@arm.com 25313481Sgiacomo.travaglini@arm.com// Tests that Range() with custom step (greater then one) generates 25413481Sgiacomo.travaglini@arm.com// the expected sequence when the last element does not fall on the 25513481Sgiacomo.travaglini@arm.com// upper range limit. Sequences generated by Range() must not have 25613481Sgiacomo.travaglini@arm.com// elements beyond the range limits. 25713481Sgiacomo.travaglini@arm.comTEST(RangeTest, IntRangeWithCustomStepOverUpperBound) { 25813481Sgiacomo.travaglini@arm.com const ParamGenerator<int> gen = Range(0, 4, 3); 25913481Sgiacomo.travaglini@arm.com const int expected_values[] = {0, 3}; 26013481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, expected_values); 26113481Sgiacomo.travaglini@arm.com} 26213481Sgiacomo.travaglini@arm.com 26313481Sgiacomo.travaglini@arm.com// Verifies that Range works with user-defined types that define 26413481Sgiacomo.travaglini@arm.com// copy constructor, operator=(), operator+(), and operator<(). 26513481Sgiacomo.travaglini@arm.comclass DogAdder { 26613481Sgiacomo.travaglini@arm.com public: 26713481Sgiacomo.travaglini@arm.com explicit DogAdder(const char* a_value) : value_(a_value) {} 26813481Sgiacomo.travaglini@arm.com DogAdder(const DogAdder& other) : value_(other.value_.c_str()) {} 26913481Sgiacomo.travaglini@arm.com 27013481Sgiacomo.travaglini@arm.com DogAdder operator=(const DogAdder& other) { 27113481Sgiacomo.travaglini@arm.com if (this != &other) 27213481Sgiacomo.travaglini@arm.com value_ = other.value_; 27313481Sgiacomo.travaglini@arm.com return *this; 27413481Sgiacomo.travaglini@arm.com } 27513481Sgiacomo.travaglini@arm.com DogAdder operator+(const DogAdder& other) const { 27613481Sgiacomo.travaglini@arm.com Message msg; 27713481Sgiacomo.travaglini@arm.com msg << value_.c_str() << other.value_.c_str(); 27813481Sgiacomo.travaglini@arm.com return DogAdder(msg.GetString().c_str()); 27913481Sgiacomo.travaglini@arm.com } 28013481Sgiacomo.travaglini@arm.com bool operator<(const DogAdder& other) const { 28113481Sgiacomo.travaglini@arm.com return value_ < other.value_; 28213481Sgiacomo.travaglini@arm.com } 28313481Sgiacomo.travaglini@arm.com const std::string& value() const { return value_; } 28413481Sgiacomo.travaglini@arm.com 28513481Sgiacomo.travaglini@arm.com private: 28613481Sgiacomo.travaglini@arm.com std::string value_; 28713481Sgiacomo.travaglini@arm.com}; 28813481Sgiacomo.travaglini@arm.com 28913481Sgiacomo.travaglini@arm.comTEST(RangeTest, WorksWithACustomType) { 29013481Sgiacomo.travaglini@arm.com const ParamGenerator<DogAdder> gen = 29113481Sgiacomo.travaglini@arm.com Range(DogAdder("cat"), DogAdder("catdogdog"), DogAdder("dog")); 29213481Sgiacomo.travaglini@arm.com ParamGenerator<DogAdder>::iterator it = gen.begin(); 29313481Sgiacomo.travaglini@arm.com 29413481Sgiacomo.travaglini@arm.com ASSERT_FALSE(it == gen.end()); 29513481Sgiacomo.travaglini@arm.com EXPECT_STREQ("cat", it->value().c_str()); 29613481Sgiacomo.travaglini@arm.com 29713481Sgiacomo.travaglini@arm.com ASSERT_FALSE(++it == gen.end()); 29813481Sgiacomo.travaglini@arm.com EXPECT_STREQ("catdog", it->value().c_str()); 29913481Sgiacomo.travaglini@arm.com 30013481Sgiacomo.travaglini@arm.com EXPECT_TRUE(++it == gen.end()); 30113481Sgiacomo.travaglini@arm.com} 30213481Sgiacomo.travaglini@arm.com 30313481Sgiacomo.travaglini@arm.comclass IntWrapper { 30413481Sgiacomo.travaglini@arm.com public: 30513481Sgiacomo.travaglini@arm.com explicit IntWrapper(int a_value) : value_(a_value) {} 30613481Sgiacomo.travaglini@arm.com IntWrapper(const IntWrapper& other) : value_(other.value_) {} 30713481Sgiacomo.travaglini@arm.com 30813481Sgiacomo.travaglini@arm.com IntWrapper operator=(const IntWrapper& other) { 30913481Sgiacomo.travaglini@arm.com value_ = other.value_; 31013481Sgiacomo.travaglini@arm.com return *this; 31113481Sgiacomo.travaglini@arm.com } 31213481Sgiacomo.travaglini@arm.com // operator+() adds a different type. 31313481Sgiacomo.travaglini@arm.com IntWrapper operator+(int other) const { return IntWrapper(value_ + other); } 31413481Sgiacomo.travaglini@arm.com bool operator<(const IntWrapper& other) const { 31513481Sgiacomo.travaglini@arm.com return value_ < other.value_; 31613481Sgiacomo.travaglini@arm.com } 31713481Sgiacomo.travaglini@arm.com int value() const { return value_; } 31813481Sgiacomo.travaglini@arm.com 31913481Sgiacomo.travaglini@arm.com private: 32013481Sgiacomo.travaglini@arm.com int value_; 32113481Sgiacomo.travaglini@arm.com}; 32213481Sgiacomo.travaglini@arm.com 32313481Sgiacomo.travaglini@arm.comTEST(RangeTest, WorksWithACustomTypeWithDifferentIncrementType) { 32413481Sgiacomo.travaglini@arm.com const ParamGenerator<IntWrapper> gen = Range(IntWrapper(0), IntWrapper(2)); 32513481Sgiacomo.travaglini@arm.com ParamGenerator<IntWrapper>::iterator it = gen.begin(); 32613481Sgiacomo.travaglini@arm.com 32713481Sgiacomo.travaglini@arm.com ASSERT_FALSE(it == gen.end()); 32813481Sgiacomo.travaglini@arm.com EXPECT_EQ(0, it->value()); 32913481Sgiacomo.travaglini@arm.com 33013481Sgiacomo.travaglini@arm.com ASSERT_FALSE(++it == gen.end()); 33113481Sgiacomo.travaglini@arm.com EXPECT_EQ(1, it->value()); 33213481Sgiacomo.travaglini@arm.com 33313481Sgiacomo.travaglini@arm.com EXPECT_TRUE(++it == gen.end()); 33413481Sgiacomo.travaglini@arm.com} 33513481Sgiacomo.travaglini@arm.com 33613481Sgiacomo.travaglini@arm.com// Tests that ValuesIn() with an array parameter generates 33713481Sgiacomo.travaglini@arm.com// the expected sequence. 33813481Sgiacomo.travaglini@arm.comTEST(ValuesInTest, ValuesInArray) { 33913481Sgiacomo.travaglini@arm.com int array[] = {3, 5, 8}; 34013481Sgiacomo.travaglini@arm.com const ParamGenerator<int> gen = ValuesIn(array); 34113481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, array); 34213481Sgiacomo.travaglini@arm.com} 34313481Sgiacomo.travaglini@arm.com 34413481Sgiacomo.travaglini@arm.com// Tests that ValuesIn() with a const array parameter generates 34513481Sgiacomo.travaglini@arm.com// the expected sequence. 34613481Sgiacomo.travaglini@arm.comTEST(ValuesInTest, ValuesInConstArray) { 34713481Sgiacomo.travaglini@arm.com const int array[] = {3, 5, 8}; 34813481Sgiacomo.travaglini@arm.com const ParamGenerator<int> gen = ValuesIn(array); 34913481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, array); 35013481Sgiacomo.travaglini@arm.com} 35113481Sgiacomo.travaglini@arm.com 35213481Sgiacomo.travaglini@arm.com// Edge case. Tests that ValuesIn() with an array parameter containing a 35313481Sgiacomo.travaglini@arm.com// single element generates the single element sequence. 35413481Sgiacomo.travaglini@arm.comTEST(ValuesInTest, ValuesInSingleElementArray) { 35513481Sgiacomo.travaglini@arm.com int array[] = {42}; 35613481Sgiacomo.travaglini@arm.com const ParamGenerator<int> gen = ValuesIn(array); 35713481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, array); 35813481Sgiacomo.travaglini@arm.com} 35913481Sgiacomo.travaglini@arm.com 36013481Sgiacomo.travaglini@arm.com// Tests that ValuesIn() generates the expected sequence for an STL 36113481Sgiacomo.travaglini@arm.com// container (vector). 36213481Sgiacomo.travaglini@arm.comTEST(ValuesInTest, ValuesInVector) { 36313481Sgiacomo.travaglini@arm.com typedef ::std::vector<int> ContainerType; 36413481Sgiacomo.travaglini@arm.com ContainerType values; 36513481Sgiacomo.travaglini@arm.com values.push_back(3); 36613481Sgiacomo.travaglini@arm.com values.push_back(5); 36713481Sgiacomo.travaglini@arm.com values.push_back(8); 36813481Sgiacomo.travaglini@arm.com const ParamGenerator<int> gen = ValuesIn(values); 36913481Sgiacomo.travaglini@arm.com 37013481Sgiacomo.travaglini@arm.com const int expected_values[] = {3, 5, 8}; 37113481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, expected_values); 37213481Sgiacomo.travaglini@arm.com} 37313481Sgiacomo.travaglini@arm.com 37413481Sgiacomo.travaglini@arm.com// Tests that ValuesIn() generates the expected sequence. 37513481Sgiacomo.travaglini@arm.comTEST(ValuesInTest, ValuesInIteratorRange) { 37613481Sgiacomo.travaglini@arm.com typedef ::std::vector<int> ContainerType; 37713481Sgiacomo.travaglini@arm.com ContainerType values; 37813481Sgiacomo.travaglini@arm.com values.push_back(3); 37913481Sgiacomo.travaglini@arm.com values.push_back(5); 38013481Sgiacomo.travaglini@arm.com values.push_back(8); 38113481Sgiacomo.travaglini@arm.com const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end()); 38213481Sgiacomo.travaglini@arm.com 38313481Sgiacomo.travaglini@arm.com const int expected_values[] = {3, 5, 8}; 38413481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, expected_values); 38513481Sgiacomo.travaglini@arm.com} 38613481Sgiacomo.travaglini@arm.com 38713481Sgiacomo.travaglini@arm.com// Edge case. Tests that ValuesIn() provided with an iterator range specifying a 38813481Sgiacomo.travaglini@arm.com// single value generates a single-element sequence. 38913481Sgiacomo.travaglini@arm.comTEST(ValuesInTest, ValuesInSingleElementIteratorRange) { 39013481Sgiacomo.travaglini@arm.com typedef ::std::vector<int> ContainerType; 39113481Sgiacomo.travaglini@arm.com ContainerType values; 39213481Sgiacomo.travaglini@arm.com values.push_back(42); 39313481Sgiacomo.travaglini@arm.com const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end()); 39413481Sgiacomo.travaglini@arm.com 39513481Sgiacomo.travaglini@arm.com const int expected_values[] = {42}; 39613481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, expected_values); 39713481Sgiacomo.travaglini@arm.com} 39813481Sgiacomo.travaglini@arm.com 39913481Sgiacomo.travaglini@arm.com// Edge case. Tests that ValuesIn() provided with an empty iterator range 40013481Sgiacomo.travaglini@arm.com// generates an empty sequence. 40113481Sgiacomo.travaglini@arm.comTEST(ValuesInTest, ValuesInEmptyIteratorRange) { 40213481Sgiacomo.travaglini@arm.com typedef ::std::vector<int> ContainerType; 40313481Sgiacomo.travaglini@arm.com ContainerType values; 40413481Sgiacomo.travaglini@arm.com const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end()); 40513481Sgiacomo.travaglini@arm.com 40613481Sgiacomo.travaglini@arm.com VerifyGeneratorIsEmpty(gen); 40713481Sgiacomo.travaglini@arm.com} 40813481Sgiacomo.travaglini@arm.com 40913481Sgiacomo.travaglini@arm.com// Tests that the Values() generates the expected sequence. 41013481Sgiacomo.travaglini@arm.comTEST(ValuesTest, ValuesWorks) { 41113481Sgiacomo.travaglini@arm.com const ParamGenerator<int> gen = Values(3, 5, 8); 41213481Sgiacomo.travaglini@arm.com 41313481Sgiacomo.travaglini@arm.com const int expected_values[] = {3, 5, 8}; 41413481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, expected_values); 41513481Sgiacomo.travaglini@arm.com} 41613481Sgiacomo.travaglini@arm.com 41713481Sgiacomo.travaglini@arm.com// Tests that Values() generates the expected sequences from elements of 41813481Sgiacomo.travaglini@arm.com// different types convertible to ParamGenerator's parameter type. 41913481Sgiacomo.travaglini@arm.comTEST(ValuesTest, ValuesWorksForValuesOfCompatibleTypes) { 42013481Sgiacomo.travaglini@arm.com const ParamGenerator<double> gen = Values(3, 5.0f, 8.0); 42113481Sgiacomo.travaglini@arm.com 42213481Sgiacomo.travaglini@arm.com const double expected_values[] = {3.0, 5.0, 8.0}; 42313481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, expected_values); 42413481Sgiacomo.travaglini@arm.com} 42513481Sgiacomo.travaglini@arm.com 42613481Sgiacomo.travaglini@arm.comTEST(ValuesTest, ValuesWorksForMaxLengthList) { 42713481Sgiacomo.travaglini@arm.com const ParamGenerator<int> gen = Values( 42813481Sgiacomo.travaglini@arm.com 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 42913481Sgiacomo.travaglini@arm.com 110, 120, 130, 140, 150, 160, 170, 180, 190, 200, 43013481Sgiacomo.travaglini@arm.com 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 43113481Sgiacomo.travaglini@arm.com 310, 320, 330, 340, 350, 360, 370, 380, 390, 400, 43213481Sgiacomo.travaglini@arm.com 410, 420, 430, 440, 450, 460, 470, 480, 490, 500); 43313481Sgiacomo.travaglini@arm.com 43413481Sgiacomo.travaglini@arm.com const int expected_values[] = { 43513481Sgiacomo.travaglini@arm.com 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 43613481Sgiacomo.travaglini@arm.com 110, 120, 130, 140, 150, 160, 170, 180, 190, 200, 43713481Sgiacomo.travaglini@arm.com 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 43813481Sgiacomo.travaglini@arm.com 310, 320, 330, 340, 350, 360, 370, 380, 390, 400, 43913481Sgiacomo.travaglini@arm.com 410, 420, 430, 440, 450, 460, 470, 480, 490, 500}; 44013481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, expected_values); 44113481Sgiacomo.travaglini@arm.com} 44213481Sgiacomo.travaglini@arm.com 44313481Sgiacomo.travaglini@arm.com// Edge case test. Tests that single-parameter Values() generates the sequence 44413481Sgiacomo.travaglini@arm.com// with the single value. 44513481Sgiacomo.travaglini@arm.comTEST(ValuesTest, ValuesWithSingleParameter) { 44613481Sgiacomo.travaglini@arm.com const ParamGenerator<int> gen = Values(42); 44713481Sgiacomo.travaglini@arm.com 44813481Sgiacomo.travaglini@arm.com const int expected_values[] = {42}; 44913481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, expected_values); 45013481Sgiacomo.travaglini@arm.com} 45113481Sgiacomo.travaglini@arm.com 45213481Sgiacomo.travaglini@arm.com// Tests that Bool() generates sequence (false, true). 45313481Sgiacomo.travaglini@arm.comTEST(BoolTest, BoolWorks) { 45413481Sgiacomo.travaglini@arm.com const ParamGenerator<bool> gen = Bool(); 45513481Sgiacomo.travaglini@arm.com 45613481Sgiacomo.travaglini@arm.com const bool expected_values[] = {false, true}; 45713481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, expected_values); 45813481Sgiacomo.travaglini@arm.com} 45913481Sgiacomo.travaglini@arm.com 46013481Sgiacomo.travaglini@arm.com# if GTEST_HAS_COMBINE 46113481Sgiacomo.travaglini@arm.com 46213481Sgiacomo.travaglini@arm.com// Tests that Combine() with two parameters generates the expected sequence. 46313481Sgiacomo.travaglini@arm.comTEST(CombineTest, CombineWithTwoParameters) { 46413481Sgiacomo.travaglini@arm.com const char* foo = "foo"; 46513481Sgiacomo.travaglini@arm.com const char* bar = "bar"; 46613481Sgiacomo.travaglini@arm.com const ParamGenerator<tuple<const char*, int> > gen = 46713481Sgiacomo.travaglini@arm.com Combine(Values(foo, bar), Values(3, 4)); 46813481Sgiacomo.travaglini@arm.com 46913481Sgiacomo.travaglini@arm.com tuple<const char*, int> expected_values[] = { 47013481Sgiacomo.travaglini@arm.com make_tuple(foo, 3), make_tuple(foo, 4), 47113481Sgiacomo.travaglini@arm.com make_tuple(bar, 3), make_tuple(bar, 4)}; 47213481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, expected_values); 47313481Sgiacomo.travaglini@arm.com} 47413481Sgiacomo.travaglini@arm.com 47513481Sgiacomo.travaglini@arm.com// Tests that Combine() with three parameters generates the expected sequence. 47613481Sgiacomo.travaglini@arm.comTEST(CombineTest, CombineWithThreeParameters) { 47713481Sgiacomo.travaglini@arm.com const ParamGenerator<tuple<int, int, int> > gen = Combine(Values(0, 1), 47813481Sgiacomo.travaglini@arm.com Values(3, 4), 47913481Sgiacomo.travaglini@arm.com Values(5, 6)); 48013481Sgiacomo.travaglini@arm.com tuple<int, int, int> expected_values[] = { 48113481Sgiacomo.travaglini@arm.com make_tuple(0, 3, 5), make_tuple(0, 3, 6), 48213481Sgiacomo.travaglini@arm.com make_tuple(0, 4, 5), make_tuple(0, 4, 6), 48313481Sgiacomo.travaglini@arm.com make_tuple(1, 3, 5), make_tuple(1, 3, 6), 48413481Sgiacomo.travaglini@arm.com make_tuple(1, 4, 5), make_tuple(1, 4, 6)}; 48513481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, expected_values); 48613481Sgiacomo.travaglini@arm.com} 48713481Sgiacomo.travaglini@arm.com 48813481Sgiacomo.travaglini@arm.com// Tests that the Combine() with the first parameter generating a single value 48913481Sgiacomo.travaglini@arm.com// sequence generates a sequence with the number of elements equal to the 49013481Sgiacomo.travaglini@arm.com// number of elements in the sequence generated by the second parameter. 49113481Sgiacomo.travaglini@arm.comTEST(CombineTest, CombineWithFirstParameterSingleValue) { 49213481Sgiacomo.travaglini@arm.com const ParamGenerator<tuple<int, int> > gen = Combine(Values(42), 49313481Sgiacomo.travaglini@arm.com Values(0, 1)); 49413481Sgiacomo.travaglini@arm.com 49513481Sgiacomo.travaglini@arm.com tuple<int, int> expected_values[] = {make_tuple(42, 0), make_tuple(42, 1)}; 49613481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, expected_values); 49713481Sgiacomo.travaglini@arm.com} 49813481Sgiacomo.travaglini@arm.com 49913481Sgiacomo.travaglini@arm.com// Tests that the Combine() with the second parameter generating a single value 50013481Sgiacomo.travaglini@arm.com// sequence generates a sequence with the number of elements equal to the 50113481Sgiacomo.travaglini@arm.com// number of elements in the sequence generated by the first parameter. 50213481Sgiacomo.travaglini@arm.comTEST(CombineTest, CombineWithSecondParameterSingleValue) { 50313481Sgiacomo.travaglini@arm.com const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1), 50413481Sgiacomo.travaglini@arm.com Values(42)); 50513481Sgiacomo.travaglini@arm.com 50613481Sgiacomo.travaglini@arm.com tuple<int, int> expected_values[] = {make_tuple(0, 42), make_tuple(1, 42)}; 50713481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, expected_values); 50813481Sgiacomo.travaglini@arm.com} 50913481Sgiacomo.travaglini@arm.com 51013481Sgiacomo.travaglini@arm.com// Tests that when the first parameter produces an empty sequence, 51113481Sgiacomo.travaglini@arm.com// Combine() produces an empty sequence, too. 51213481Sgiacomo.travaglini@arm.comTEST(CombineTest, CombineWithFirstParameterEmptyRange) { 51313481Sgiacomo.travaglini@arm.com const ParamGenerator<tuple<int, int> > gen = Combine(Range(0, 0), 51413481Sgiacomo.travaglini@arm.com Values(0, 1)); 51513481Sgiacomo.travaglini@arm.com VerifyGeneratorIsEmpty(gen); 51613481Sgiacomo.travaglini@arm.com} 51713481Sgiacomo.travaglini@arm.com 51813481Sgiacomo.travaglini@arm.com// Tests that when the second parameter produces an empty sequence, 51913481Sgiacomo.travaglini@arm.com// Combine() produces an empty sequence, too. 52013481Sgiacomo.travaglini@arm.comTEST(CombineTest, CombineWithSecondParameterEmptyRange) { 52113481Sgiacomo.travaglini@arm.com const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1), 52213481Sgiacomo.travaglini@arm.com Range(1, 1)); 52313481Sgiacomo.travaglini@arm.com VerifyGeneratorIsEmpty(gen); 52413481Sgiacomo.travaglini@arm.com} 52513481Sgiacomo.travaglini@arm.com 52613481Sgiacomo.travaglini@arm.com// Edge case. Tests that combine works with the maximum number 52713481Sgiacomo.travaglini@arm.com// of parameters supported by Google Test (currently 10). 52813481Sgiacomo.travaglini@arm.comTEST(CombineTest, CombineWithMaxNumberOfParameters) { 52913481Sgiacomo.travaglini@arm.com const char* foo = "foo"; 53013481Sgiacomo.travaglini@arm.com const char* bar = "bar"; 53113481Sgiacomo.travaglini@arm.com const ParamGenerator<tuple<const char*, int, int, int, int, int, int, int, 53213481Sgiacomo.travaglini@arm.com int, int> > gen = Combine(Values(foo, bar), 53313481Sgiacomo.travaglini@arm.com Values(1), Values(2), 53413481Sgiacomo.travaglini@arm.com Values(3), Values(4), 53513481Sgiacomo.travaglini@arm.com Values(5), Values(6), 53613481Sgiacomo.travaglini@arm.com Values(7), Values(8), 53713481Sgiacomo.travaglini@arm.com Values(9)); 53813481Sgiacomo.travaglini@arm.com 53913481Sgiacomo.travaglini@arm.com tuple<const char*, int, int, int, int, int, int, int, int, int> 54013481Sgiacomo.travaglini@arm.com expected_values[] = {make_tuple(foo, 1, 2, 3, 4, 5, 6, 7, 8, 9), 54113481Sgiacomo.travaglini@arm.com make_tuple(bar, 1, 2, 3, 4, 5, 6, 7, 8, 9)}; 54213481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, expected_values); 54313481Sgiacomo.travaglini@arm.com} 54413481Sgiacomo.travaglini@arm.com 54513481Sgiacomo.travaglini@arm.com# endif // GTEST_HAS_COMBINE 54613481Sgiacomo.travaglini@arm.com 54713481Sgiacomo.travaglini@arm.com// Tests that an generator produces correct sequence after being 54813481Sgiacomo.travaglini@arm.com// assigned from another generator. 54913481Sgiacomo.travaglini@arm.comTEST(ParamGeneratorTest, AssignmentWorks) { 55013481Sgiacomo.travaglini@arm.com ParamGenerator<int> gen = Values(1, 2); 55113481Sgiacomo.travaglini@arm.com const ParamGenerator<int> gen2 = Values(3, 4); 55213481Sgiacomo.travaglini@arm.com gen = gen2; 55313481Sgiacomo.travaglini@arm.com 55413481Sgiacomo.travaglini@arm.com const int expected_values[] = {3, 4}; 55513481Sgiacomo.travaglini@arm.com VerifyGenerator(gen, expected_values); 55613481Sgiacomo.travaglini@arm.com} 55713481Sgiacomo.travaglini@arm.com 55813481Sgiacomo.travaglini@arm.com// This test verifies that the tests are expanded and run as specified: 55913481Sgiacomo.travaglini@arm.com// one test per element from the sequence produced by the generator 56013481Sgiacomo.travaglini@arm.com// specified in INSTANTIATE_TEST_CASE_P. It also verifies that the test's 56113481Sgiacomo.travaglini@arm.com// fixture constructor, SetUp(), and TearDown() have run and have been 56213481Sgiacomo.travaglini@arm.com// supplied with the correct parameters. 56313481Sgiacomo.travaglini@arm.com 56413481Sgiacomo.travaglini@arm.com// The use of environment object allows detection of the case where no test 56513481Sgiacomo.travaglini@arm.com// case functionality is run at all. In this case TestCaseTearDown will not 56613481Sgiacomo.travaglini@arm.com// be able to detect missing tests, naturally. 56713481Sgiacomo.travaglini@arm.comtemplate <int kExpectedCalls> 56813481Sgiacomo.travaglini@arm.comclass TestGenerationEnvironment : public ::testing::Environment { 56913481Sgiacomo.travaglini@arm.com public: 57013481Sgiacomo.travaglini@arm.com static TestGenerationEnvironment* Instance() { 57113481Sgiacomo.travaglini@arm.com static TestGenerationEnvironment* instance = new TestGenerationEnvironment; 57213481Sgiacomo.travaglini@arm.com return instance; 57313481Sgiacomo.travaglini@arm.com } 57413481Sgiacomo.travaglini@arm.com 57513481Sgiacomo.travaglini@arm.com void FixtureConstructorExecuted() { fixture_constructor_count_++; } 57613481Sgiacomo.travaglini@arm.com void SetUpExecuted() { set_up_count_++; } 57713481Sgiacomo.travaglini@arm.com void TearDownExecuted() { tear_down_count_++; } 57813481Sgiacomo.travaglini@arm.com void TestBodyExecuted() { test_body_count_++; } 57913481Sgiacomo.travaglini@arm.com 58013481Sgiacomo.travaglini@arm.com virtual void TearDown() { 58113481Sgiacomo.travaglini@arm.com // If all MultipleTestGenerationTest tests have been de-selected 58213481Sgiacomo.travaglini@arm.com // by the filter flag, the following checks make no sense. 58313481Sgiacomo.travaglini@arm.com bool perform_check = false; 58413481Sgiacomo.travaglini@arm.com 58513481Sgiacomo.travaglini@arm.com for (int i = 0; i < kExpectedCalls; ++i) { 58613481Sgiacomo.travaglini@arm.com Message msg; 58713481Sgiacomo.travaglini@arm.com msg << "TestsExpandedAndRun/" << i; 58813481Sgiacomo.travaglini@arm.com if (UnitTestOptions::FilterMatchesTest( 58913481Sgiacomo.travaglini@arm.com "TestExpansionModule/MultipleTestGenerationTest", 59013481Sgiacomo.travaglini@arm.com msg.GetString().c_str())) { 59113481Sgiacomo.travaglini@arm.com perform_check = true; 59213481Sgiacomo.travaglini@arm.com } 59313481Sgiacomo.travaglini@arm.com } 59413481Sgiacomo.travaglini@arm.com if (perform_check) { 59513481Sgiacomo.travaglini@arm.com EXPECT_EQ(kExpectedCalls, fixture_constructor_count_) 59613481Sgiacomo.travaglini@arm.com << "Fixture constructor of ParamTestGenerationTest test case " 59713481Sgiacomo.travaglini@arm.com << "has not been run as expected."; 59813481Sgiacomo.travaglini@arm.com EXPECT_EQ(kExpectedCalls, set_up_count_) 59913481Sgiacomo.travaglini@arm.com << "Fixture SetUp method of ParamTestGenerationTest test case " 60013481Sgiacomo.travaglini@arm.com << "has not been run as expected."; 60113481Sgiacomo.travaglini@arm.com EXPECT_EQ(kExpectedCalls, tear_down_count_) 60213481Sgiacomo.travaglini@arm.com << "Fixture TearDown method of ParamTestGenerationTest test case " 60313481Sgiacomo.travaglini@arm.com << "has not been run as expected."; 60413481Sgiacomo.travaglini@arm.com EXPECT_EQ(kExpectedCalls, test_body_count_) 60513481Sgiacomo.travaglini@arm.com << "Test in ParamTestGenerationTest test case " 60613481Sgiacomo.travaglini@arm.com << "has not been run as expected."; 60713481Sgiacomo.travaglini@arm.com } 60813481Sgiacomo.travaglini@arm.com } 60913481Sgiacomo.travaglini@arm.com 61013481Sgiacomo.travaglini@arm.com private: 61113481Sgiacomo.travaglini@arm.com TestGenerationEnvironment() : fixture_constructor_count_(0), set_up_count_(0), 61213481Sgiacomo.travaglini@arm.com tear_down_count_(0), test_body_count_(0) {} 61313481Sgiacomo.travaglini@arm.com 61413481Sgiacomo.travaglini@arm.com int fixture_constructor_count_; 61513481Sgiacomo.travaglini@arm.com int set_up_count_; 61613481Sgiacomo.travaglini@arm.com int tear_down_count_; 61713481Sgiacomo.travaglini@arm.com int test_body_count_; 61813481Sgiacomo.travaglini@arm.com 61913481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationEnvironment); 62013481Sgiacomo.travaglini@arm.com}; 62113481Sgiacomo.travaglini@arm.com 62213481Sgiacomo.travaglini@arm.comconst int test_generation_params[] = {36, 42, 72}; 62313481Sgiacomo.travaglini@arm.com 62413481Sgiacomo.travaglini@arm.comclass TestGenerationTest : public TestWithParam<int> { 62513481Sgiacomo.travaglini@arm.com public: 62613481Sgiacomo.travaglini@arm.com enum { 62713481Sgiacomo.travaglini@arm.com PARAMETER_COUNT = 62813481Sgiacomo.travaglini@arm.com sizeof(test_generation_params)/sizeof(test_generation_params[0]) 62913481Sgiacomo.travaglini@arm.com }; 63013481Sgiacomo.travaglini@arm.com 63113481Sgiacomo.travaglini@arm.com typedef TestGenerationEnvironment<PARAMETER_COUNT> Environment; 63213481Sgiacomo.travaglini@arm.com 63313481Sgiacomo.travaglini@arm.com TestGenerationTest() { 63413481Sgiacomo.travaglini@arm.com Environment::Instance()->FixtureConstructorExecuted(); 63513481Sgiacomo.travaglini@arm.com current_parameter_ = GetParam(); 63613481Sgiacomo.travaglini@arm.com } 63713481Sgiacomo.travaglini@arm.com virtual void SetUp() { 63813481Sgiacomo.travaglini@arm.com Environment::Instance()->SetUpExecuted(); 63913481Sgiacomo.travaglini@arm.com EXPECT_EQ(current_parameter_, GetParam()); 64013481Sgiacomo.travaglini@arm.com } 64113481Sgiacomo.travaglini@arm.com virtual void TearDown() { 64213481Sgiacomo.travaglini@arm.com Environment::Instance()->TearDownExecuted(); 64313481Sgiacomo.travaglini@arm.com EXPECT_EQ(current_parameter_, GetParam()); 64413481Sgiacomo.travaglini@arm.com } 64513481Sgiacomo.travaglini@arm.com 64613481Sgiacomo.travaglini@arm.com static void SetUpTestCase() { 64713481Sgiacomo.travaglini@arm.com bool all_tests_in_test_case_selected = true; 64813481Sgiacomo.travaglini@arm.com 64913481Sgiacomo.travaglini@arm.com for (int i = 0; i < PARAMETER_COUNT; ++i) { 65013481Sgiacomo.travaglini@arm.com Message test_name; 65113481Sgiacomo.travaglini@arm.com test_name << "TestsExpandedAndRun/" << i; 65213481Sgiacomo.travaglini@arm.com if ( !UnitTestOptions::FilterMatchesTest( 65313481Sgiacomo.travaglini@arm.com "TestExpansionModule/MultipleTestGenerationTest", 65413481Sgiacomo.travaglini@arm.com test_name.GetString())) { 65513481Sgiacomo.travaglini@arm.com all_tests_in_test_case_selected = false; 65613481Sgiacomo.travaglini@arm.com } 65713481Sgiacomo.travaglini@arm.com } 65813481Sgiacomo.travaglini@arm.com EXPECT_TRUE(all_tests_in_test_case_selected) 65913481Sgiacomo.travaglini@arm.com << "When running the TestGenerationTest test case all of its tests\n" 66013481Sgiacomo.travaglini@arm.com << "must be selected by the filter flag for the test case to pass.\n" 66113481Sgiacomo.travaglini@arm.com << "If not all of them are enabled, we can't reliably conclude\n" 66213481Sgiacomo.travaglini@arm.com << "that the correct number of tests have been generated."; 66313481Sgiacomo.travaglini@arm.com 66413481Sgiacomo.travaglini@arm.com collected_parameters_.clear(); 66513481Sgiacomo.travaglini@arm.com } 66613481Sgiacomo.travaglini@arm.com 66713481Sgiacomo.travaglini@arm.com static void TearDownTestCase() { 66813481Sgiacomo.travaglini@arm.com vector<int> expected_values(test_generation_params, 66913481Sgiacomo.travaglini@arm.com test_generation_params + PARAMETER_COUNT); 67013481Sgiacomo.travaglini@arm.com // Test execution order is not guaranteed by Google Test, 67113481Sgiacomo.travaglini@arm.com // so the order of values in collected_parameters_ can be 67213481Sgiacomo.travaglini@arm.com // different and we have to sort to compare. 67313481Sgiacomo.travaglini@arm.com sort(expected_values.begin(), expected_values.end()); 67413481Sgiacomo.travaglini@arm.com sort(collected_parameters_.begin(), collected_parameters_.end()); 67513481Sgiacomo.travaglini@arm.com 67613481Sgiacomo.travaglini@arm.com EXPECT_TRUE(collected_parameters_ == expected_values); 67713481Sgiacomo.travaglini@arm.com } 67813481Sgiacomo.travaglini@arm.com 67913481Sgiacomo.travaglini@arm.com protected: 68013481Sgiacomo.travaglini@arm.com int current_parameter_; 68113481Sgiacomo.travaglini@arm.com static vector<int> collected_parameters_; 68213481Sgiacomo.travaglini@arm.com 68313481Sgiacomo.travaglini@arm.com private: 68413481Sgiacomo.travaglini@arm.com GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationTest); 68513481Sgiacomo.travaglini@arm.com}; 68613481Sgiacomo.travaglini@arm.comvector<int> TestGenerationTest::collected_parameters_; 68713481Sgiacomo.travaglini@arm.com 68813481Sgiacomo.travaglini@arm.comTEST_P(TestGenerationTest, TestsExpandedAndRun) { 68913481Sgiacomo.travaglini@arm.com Environment::Instance()->TestBodyExecuted(); 69013481Sgiacomo.travaglini@arm.com EXPECT_EQ(current_parameter_, GetParam()); 69113481Sgiacomo.travaglini@arm.com collected_parameters_.push_back(GetParam()); 69213481Sgiacomo.travaglini@arm.com} 69313481Sgiacomo.travaglini@arm.comINSTANTIATE_TEST_CASE_P(TestExpansionModule, TestGenerationTest, 69413481Sgiacomo.travaglini@arm.com ValuesIn(test_generation_params)); 69513481Sgiacomo.travaglini@arm.com 69613481Sgiacomo.travaglini@arm.com// This test verifies that the element sequence (third parameter of 69713481Sgiacomo.travaglini@arm.com// INSTANTIATE_TEST_CASE_P) is evaluated in InitGoogleTest() and neither at 69813481Sgiacomo.travaglini@arm.com// the call site of INSTANTIATE_TEST_CASE_P nor in RUN_ALL_TESTS(). For 69913481Sgiacomo.travaglini@arm.com// that, we declare param_value_ to be a static member of 70013481Sgiacomo.travaglini@arm.com// GeneratorEvaluationTest and initialize it to 0. We set it to 1 in 70113481Sgiacomo.travaglini@arm.com// main(), just before invocation of InitGoogleTest(). After calling 70213481Sgiacomo.travaglini@arm.com// InitGoogleTest(), we set the value to 2. If the sequence is evaluated 70313481Sgiacomo.travaglini@arm.com// before or after InitGoogleTest, INSTANTIATE_TEST_CASE_P will create a 70413481Sgiacomo.travaglini@arm.com// test with parameter other than 1, and the test body will fail the 70513481Sgiacomo.travaglini@arm.com// assertion. 70613481Sgiacomo.travaglini@arm.comclass GeneratorEvaluationTest : public TestWithParam<int> { 70713481Sgiacomo.travaglini@arm.com public: 70813481Sgiacomo.travaglini@arm.com static int param_value() { return param_value_; } 70913481Sgiacomo.travaglini@arm.com static void set_param_value(int param_value) { param_value_ = param_value; } 71013481Sgiacomo.travaglini@arm.com 71113481Sgiacomo.travaglini@arm.com private: 71213481Sgiacomo.travaglini@arm.com static int param_value_; 71313481Sgiacomo.travaglini@arm.com}; 71413481Sgiacomo.travaglini@arm.comint GeneratorEvaluationTest::param_value_ = 0; 71513481Sgiacomo.travaglini@arm.com 71613481Sgiacomo.travaglini@arm.comTEST_P(GeneratorEvaluationTest, GeneratorsEvaluatedInMain) { 71713481Sgiacomo.travaglini@arm.com EXPECT_EQ(1, GetParam()); 71813481Sgiacomo.travaglini@arm.com} 71913481Sgiacomo.travaglini@arm.comINSTANTIATE_TEST_CASE_P(GenEvalModule, 72013481Sgiacomo.travaglini@arm.com GeneratorEvaluationTest, 72113481Sgiacomo.travaglini@arm.com Values(GeneratorEvaluationTest::param_value())); 72213481Sgiacomo.travaglini@arm.com 72313481Sgiacomo.travaglini@arm.com// Tests that generators defined in a different translation unit are 72413481Sgiacomo.travaglini@arm.com// functional. Generator extern_gen is defined in gtest-param-test_test2.cc. 72513481Sgiacomo.travaglini@arm.comextern ParamGenerator<int> extern_gen; 72613481Sgiacomo.travaglini@arm.comclass ExternalGeneratorTest : public TestWithParam<int> {}; 72713481Sgiacomo.travaglini@arm.comTEST_P(ExternalGeneratorTest, ExternalGenerator) { 72813481Sgiacomo.travaglini@arm.com // Sequence produced by extern_gen contains only a single value 72913481Sgiacomo.travaglini@arm.com // which we verify here. 73013481Sgiacomo.travaglini@arm.com EXPECT_EQ(GetParam(), 33); 73113481Sgiacomo.travaglini@arm.com} 73213481Sgiacomo.travaglini@arm.comINSTANTIATE_TEST_CASE_P(ExternalGeneratorModule, 73313481Sgiacomo.travaglini@arm.com ExternalGeneratorTest, 73413481Sgiacomo.travaglini@arm.com extern_gen); 73513481Sgiacomo.travaglini@arm.com 73613481Sgiacomo.travaglini@arm.com// Tests that a parameterized test case can be defined in one translation 73713481Sgiacomo.travaglini@arm.com// unit and instantiated in another. This test will be instantiated in 73813481Sgiacomo.travaglini@arm.com// gtest-param-test_test2.cc. ExternalInstantiationTest fixture class is 73913481Sgiacomo.travaglini@arm.com// defined in gtest-param-test_test.h. 74013481Sgiacomo.travaglini@arm.comTEST_P(ExternalInstantiationTest, IsMultipleOf33) { 74113481Sgiacomo.travaglini@arm.com EXPECT_EQ(0, GetParam() % 33); 74213481Sgiacomo.travaglini@arm.com} 74313481Sgiacomo.travaglini@arm.com 74413481Sgiacomo.travaglini@arm.com// Tests that a parameterized test case can be instantiated with multiple 74513481Sgiacomo.travaglini@arm.com// generators. 74613481Sgiacomo.travaglini@arm.comclass MultipleInstantiationTest : public TestWithParam<int> {}; 74713481Sgiacomo.travaglini@arm.comTEST_P(MultipleInstantiationTest, AllowsMultipleInstances) { 74813481Sgiacomo.travaglini@arm.com} 74913481Sgiacomo.travaglini@arm.comINSTANTIATE_TEST_CASE_P(Sequence1, MultipleInstantiationTest, Values(1, 2)); 75013481Sgiacomo.travaglini@arm.comINSTANTIATE_TEST_CASE_P(Sequence2, MultipleInstantiationTest, Range(3, 5)); 75113481Sgiacomo.travaglini@arm.com 75213481Sgiacomo.travaglini@arm.com// Tests that a parameterized test case can be instantiated 75313481Sgiacomo.travaglini@arm.com// in multiple translation units. This test will be instantiated 75413481Sgiacomo.travaglini@arm.com// here and in gtest-param-test_test2.cc. 75513481Sgiacomo.travaglini@arm.com// InstantiationInMultipleTranslationUnitsTest fixture class 75613481Sgiacomo.travaglini@arm.com// is defined in gtest-param-test_test.h. 75713481Sgiacomo.travaglini@arm.comTEST_P(InstantiationInMultipleTranslaionUnitsTest, IsMultipleOf42) { 75813481Sgiacomo.travaglini@arm.com EXPECT_EQ(0, GetParam() % 42); 75913481Sgiacomo.travaglini@arm.com} 76013481Sgiacomo.travaglini@arm.comINSTANTIATE_TEST_CASE_P(Sequence1, 76113481Sgiacomo.travaglini@arm.com InstantiationInMultipleTranslaionUnitsTest, 76213481Sgiacomo.travaglini@arm.com Values(42, 42*2)); 76313481Sgiacomo.travaglini@arm.com 76413481Sgiacomo.travaglini@arm.com// Tests that each iteration of parameterized test runs in a separate test 76513481Sgiacomo.travaglini@arm.com// object. 76613481Sgiacomo.travaglini@arm.comclass SeparateInstanceTest : public TestWithParam<int> { 76713481Sgiacomo.travaglini@arm.com public: 76813481Sgiacomo.travaglini@arm.com SeparateInstanceTest() : count_(0) {} 76913481Sgiacomo.travaglini@arm.com 77013481Sgiacomo.travaglini@arm.com static void TearDownTestCase() { 77113481Sgiacomo.travaglini@arm.com EXPECT_GE(global_count_, 2) 77213481Sgiacomo.travaglini@arm.com << "If some (but not all) SeparateInstanceTest tests have been " 77313481Sgiacomo.travaglini@arm.com << "filtered out this test will fail. Make sure that all " 77413481Sgiacomo.travaglini@arm.com << "GeneratorEvaluationTest are selected or de-selected together " 77513481Sgiacomo.travaglini@arm.com << "by the test filter."; 77613481Sgiacomo.travaglini@arm.com } 77713481Sgiacomo.travaglini@arm.com 77813481Sgiacomo.travaglini@arm.com protected: 77913481Sgiacomo.travaglini@arm.com int count_; 78013481Sgiacomo.travaglini@arm.com static int global_count_; 78113481Sgiacomo.travaglini@arm.com}; 78213481Sgiacomo.travaglini@arm.comint SeparateInstanceTest::global_count_ = 0; 78313481Sgiacomo.travaglini@arm.com 78413481Sgiacomo.travaglini@arm.comTEST_P(SeparateInstanceTest, TestsRunInSeparateInstances) { 78513481Sgiacomo.travaglini@arm.com EXPECT_EQ(0, count_++); 78613481Sgiacomo.travaglini@arm.com global_count_++; 78713481Sgiacomo.travaglini@arm.com} 78813481Sgiacomo.travaglini@arm.comINSTANTIATE_TEST_CASE_P(FourElemSequence, SeparateInstanceTest, Range(1, 4)); 78913481Sgiacomo.travaglini@arm.com 79013481Sgiacomo.travaglini@arm.com// Tests that all instantiations of a test have named appropriately. Test 79113481Sgiacomo.travaglini@arm.com// defined with TEST_P(TestCaseName, TestName) and instantiated with 79213481Sgiacomo.travaglini@arm.com// INSTANTIATE_TEST_CASE_P(SequenceName, TestCaseName, generator) must be named 79313481Sgiacomo.travaglini@arm.com// SequenceName/TestCaseName.TestName/i, where i is the 0-based index of the 79413481Sgiacomo.travaglini@arm.com// sequence element used to instantiate the test. 79513481Sgiacomo.travaglini@arm.comclass NamingTest : public TestWithParam<int> {}; 79613481Sgiacomo.travaglini@arm.com 79713481Sgiacomo.travaglini@arm.comTEST_P(NamingTest, TestsReportCorrectNamesAndParameters) { 79813481Sgiacomo.travaglini@arm.com const ::testing::TestInfo* const test_info = 79913481Sgiacomo.travaglini@arm.com ::testing::UnitTest::GetInstance()->current_test_info(); 80013481Sgiacomo.travaglini@arm.com 80113481Sgiacomo.travaglini@arm.com EXPECT_STREQ("ZeroToFiveSequence/NamingTest", test_info->test_case_name()); 80213481Sgiacomo.travaglini@arm.com 80313481Sgiacomo.travaglini@arm.com Message index_stream; 80413481Sgiacomo.travaglini@arm.com index_stream << "TestsReportCorrectNamesAndParameters/" << GetParam(); 80513481Sgiacomo.travaglini@arm.com EXPECT_STREQ(index_stream.GetString().c_str(), test_info->name()); 80613481Sgiacomo.travaglini@arm.com 80713481Sgiacomo.travaglini@arm.com EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param()); 80813481Sgiacomo.travaglini@arm.com} 80913481Sgiacomo.travaglini@arm.com 81013481Sgiacomo.travaglini@arm.comINSTANTIATE_TEST_CASE_P(ZeroToFiveSequence, NamingTest, Range(0, 5)); 81113481Sgiacomo.travaglini@arm.com 81213481Sgiacomo.travaglini@arm.com// Tests that user supplied custom parameter names are working correctly. 81313481Sgiacomo.travaglini@arm.com// Runs the test with a builtin helper method which uses PrintToString, 81413481Sgiacomo.travaglini@arm.com// as well as a custom function and custom functor to ensure all possible 81513481Sgiacomo.travaglini@arm.com// uses work correctly. 81613481Sgiacomo.travaglini@arm.comclass CustomFunctorNamingTest : public TestWithParam<std::string> {}; 81713481Sgiacomo.travaglini@arm.comTEST_P(CustomFunctorNamingTest, CustomTestNames) {} 81813481Sgiacomo.travaglini@arm.com 81913481Sgiacomo.travaglini@arm.comstruct CustomParamNameFunctor { 82013481Sgiacomo.travaglini@arm.com std::string operator()(const ::testing::TestParamInfo<std::string>& info) { 82113481Sgiacomo.travaglini@arm.com return info.param; 82213481Sgiacomo.travaglini@arm.com } 82313481Sgiacomo.travaglini@arm.com}; 82413481Sgiacomo.travaglini@arm.com 82513481Sgiacomo.travaglini@arm.comINSTANTIATE_TEST_CASE_P(CustomParamNameFunctor, 82613481Sgiacomo.travaglini@arm.com CustomFunctorNamingTest, 82713481Sgiacomo.travaglini@arm.com Values(std::string("FunctorName")), 82813481Sgiacomo.travaglini@arm.com CustomParamNameFunctor()); 82913481Sgiacomo.travaglini@arm.com 83013481Sgiacomo.travaglini@arm.comINSTANTIATE_TEST_CASE_P(AllAllowedCharacters, 83113481Sgiacomo.travaglini@arm.com CustomFunctorNamingTest, 83213481Sgiacomo.travaglini@arm.com Values("abcdefghijklmnopqrstuvwxyz", 83313481Sgiacomo.travaglini@arm.com "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 83413481Sgiacomo.travaglini@arm.com "01234567890_"), 83513481Sgiacomo.travaglini@arm.com CustomParamNameFunctor()); 83613481Sgiacomo.travaglini@arm.com 83713481Sgiacomo.travaglini@arm.cominline std::string CustomParamNameFunction( 83813481Sgiacomo.travaglini@arm.com const ::testing::TestParamInfo<std::string>& info) { 83913481Sgiacomo.travaglini@arm.com return info.param; 84013481Sgiacomo.travaglini@arm.com} 84113481Sgiacomo.travaglini@arm.com 84213481Sgiacomo.travaglini@arm.comclass CustomFunctionNamingTest : public TestWithParam<std::string> {}; 84313481Sgiacomo.travaglini@arm.comTEST_P(CustomFunctionNamingTest, CustomTestNames) {} 84413481Sgiacomo.travaglini@arm.com 84513481Sgiacomo.travaglini@arm.comINSTANTIATE_TEST_CASE_P(CustomParamNameFunction, 84613481Sgiacomo.travaglini@arm.com CustomFunctionNamingTest, 84713481Sgiacomo.travaglini@arm.com Values(std::string("FunctionName")), 84813481Sgiacomo.travaglini@arm.com CustomParamNameFunction); 84913481Sgiacomo.travaglini@arm.com 85013481Sgiacomo.travaglini@arm.com#if GTEST_LANG_CXX11 85113481Sgiacomo.travaglini@arm.com 85213481Sgiacomo.travaglini@arm.com// Test custom naming with a lambda 85313481Sgiacomo.travaglini@arm.com 85413481Sgiacomo.travaglini@arm.comclass CustomLambdaNamingTest : public TestWithParam<std::string> {}; 85513481Sgiacomo.travaglini@arm.comTEST_P(CustomLambdaNamingTest, CustomTestNames) {} 85613481Sgiacomo.travaglini@arm.com 85713481Sgiacomo.travaglini@arm.comINSTANTIATE_TEST_CASE_P(CustomParamNameLambda, 85813481Sgiacomo.travaglini@arm.com CustomLambdaNamingTest, 85913481Sgiacomo.travaglini@arm.com Values(std::string("LambdaName")), 86013481Sgiacomo.travaglini@arm.com [](const ::testing::TestParamInfo<std::string>& info) { 86113481Sgiacomo.travaglini@arm.com return info.param; 86213481Sgiacomo.travaglini@arm.com }); 86313481Sgiacomo.travaglini@arm.com 86413481Sgiacomo.travaglini@arm.com#endif // GTEST_LANG_CXX11 86513481Sgiacomo.travaglini@arm.com 86613481Sgiacomo.travaglini@arm.comTEST(CustomNamingTest, CheckNameRegistry) { 86713481Sgiacomo.travaglini@arm.com ::testing::UnitTest* unit_test = ::testing::UnitTest::GetInstance(); 86813481Sgiacomo.travaglini@arm.com std::set<std::string> test_names; 86913481Sgiacomo.travaglini@arm.com for (int case_num = 0; 87013481Sgiacomo.travaglini@arm.com case_num < unit_test->total_test_case_count(); 87113481Sgiacomo.travaglini@arm.com ++case_num) { 87213481Sgiacomo.travaglini@arm.com const ::testing::TestCase* test_case = unit_test->GetTestCase(case_num); 87313481Sgiacomo.travaglini@arm.com for (int test_num = 0; 87413481Sgiacomo.travaglini@arm.com test_num < test_case->total_test_count(); 87513481Sgiacomo.travaglini@arm.com ++test_num) { 87613481Sgiacomo.travaglini@arm.com const ::testing::TestInfo* test_info = test_case->GetTestInfo(test_num); 87713481Sgiacomo.travaglini@arm.com test_names.insert(std::string(test_info->name())); 87813481Sgiacomo.travaglini@arm.com } 87913481Sgiacomo.travaglini@arm.com } 88013481Sgiacomo.travaglini@arm.com EXPECT_EQ(1u, test_names.count("CustomTestNames/FunctorName")); 88113481Sgiacomo.travaglini@arm.com EXPECT_EQ(1u, test_names.count("CustomTestNames/FunctionName")); 88213481Sgiacomo.travaglini@arm.com#if GTEST_LANG_CXX11 88313481Sgiacomo.travaglini@arm.com EXPECT_EQ(1u, test_names.count("CustomTestNames/LambdaName")); 88413481Sgiacomo.travaglini@arm.com#endif // GTEST_LANG_CXX11 88513481Sgiacomo.travaglini@arm.com} 88613481Sgiacomo.travaglini@arm.com 88713481Sgiacomo.travaglini@arm.com// Test a numeric name to ensure PrintToStringParamName works correctly. 88813481Sgiacomo.travaglini@arm.com 88913481Sgiacomo.travaglini@arm.comclass CustomIntegerNamingTest : public TestWithParam<int> {}; 89013481Sgiacomo.travaglini@arm.com 89113481Sgiacomo.travaglini@arm.comTEST_P(CustomIntegerNamingTest, TestsReportCorrectNames) { 89213481Sgiacomo.travaglini@arm.com const ::testing::TestInfo* const test_info = 89313481Sgiacomo.travaglini@arm.com ::testing::UnitTest::GetInstance()->current_test_info(); 89413481Sgiacomo.travaglini@arm.com Message test_name_stream; 89513481Sgiacomo.travaglini@arm.com test_name_stream << "TestsReportCorrectNames/" << GetParam(); 89613481Sgiacomo.travaglini@arm.com EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name()); 89713481Sgiacomo.travaglini@arm.com} 89813481Sgiacomo.travaglini@arm.com 89913481Sgiacomo.travaglini@arm.comINSTANTIATE_TEST_CASE_P(PrintToString, 90013481Sgiacomo.travaglini@arm.com CustomIntegerNamingTest, 90113481Sgiacomo.travaglini@arm.com Range(0, 5), 90213481Sgiacomo.travaglini@arm.com ::testing::PrintToStringParamName()); 90313481Sgiacomo.travaglini@arm.com 90413481Sgiacomo.travaglini@arm.com// Test a custom struct with PrintToString. 90513481Sgiacomo.travaglini@arm.com 90613481Sgiacomo.travaglini@arm.comstruct CustomStruct { 90713481Sgiacomo.travaglini@arm.com explicit CustomStruct(int value) : x(value) {} 90813481Sgiacomo.travaglini@arm.com int x; 90913481Sgiacomo.travaglini@arm.com}; 91013481Sgiacomo.travaglini@arm.com 91113481Sgiacomo.travaglini@arm.comstd::ostream& operator<<(std::ostream& stream, const CustomStruct& val) { 91213481Sgiacomo.travaglini@arm.com stream << val.x; 91313481Sgiacomo.travaglini@arm.com return stream; 91413481Sgiacomo.travaglini@arm.com} 91513481Sgiacomo.travaglini@arm.com 91613481Sgiacomo.travaglini@arm.comclass CustomStructNamingTest : public TestWithParam<CustomStruct> {}; 91713481Sgiacomo.travaglini@arm.com 91813481Sgiacomo.travaglini@arm.comTEST_P(CustomStructNamingTest, TestsReportCorrectNames) { 91913481Sgiacomo.travaglini@arm.com const ::testing::TestInfo* const test_info = 92013481Sgiacomo.travaglini@arm.com ::testing::UnitTest::GetInstance()->current_test_info(); 92113481Sgiacomo.travaglini@arm.com Message test_name_stream; 92213481Sgiacomo.travaglini@arm.com test_name_stream << "TestsReportCorrectNames/" << GetParam(); 92313481Sgiacomo.travaglini@arm.com EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name()); 92413481Sgiacomo.travaglini@arm.com} 92513481Sgiacomo.travaglini@arm.com 92613481Sgiacomo.travaglini@arm.comINSTANTIATE_TEST_CASE_P(PrintToString, 92713481Sgiacomo.travaglini@arm.com CustomStructNamingTest, 92813481Sgiacomo.travaglini@arm.com Values(CustomStruct(0), CustomStruct(1)), 92913481Sgiacomo.travaglini@arm.com ::testing::PrintToStringParamName()); 93013481Sgiacomo.travaglini@arm.com 93113481Sgiacomo.travaglini@arm.com// Test that using a stateful parameter naming function works as expected. 93213481Sgiacomo.travaglini@arm.com 93313481Sgiacomo.travaglini@arm.comstruct StatefulNamingFunctor { 93413481Sgiacomo.travaglini@arm.com StatefulNamingFunctor() : sum(0) {} 93513481Sgiacomo.travaglini@arm.com std::string operator()(const ::testing::TestParamInfo<int>& info) { 93613481Sgiacomo.travaglini@arm.com int value = info.param + sum; 93713481Sgiacomo.travaglini@arm.com sum += info.param; 93813481Sgiacomo.travaglini@arm.com return ::testing::PrintToString(value); 93913481Sgiacomo.travaglini@arm.com } 94013481Sgiacomo.travaglini@arm.com int sum; 94113481Sgiacomo.travaglini@arm.com}; 94213481Sgiacomo.travaglini@arm.com 94313481Sgiacomo.travaglini@arm.comclass StatefulNamingTest : public ::testing::TestWithParam<int> { 94413481Sgiacomo.travaglini@arm.com protected: 94513481Sgiacomo.travaglini@arm.com StatefulNamingTest() : sum_(0) {} 94613481Sgiacomo.travaglini@arm.com int sum_; 94713481Sgiacomo.travaglini@arm.com}; 94813481Sgiacomo.travaglini@arm.com 94913481Sgiacomo.travaglini@arm.comTEST_P(StatefulNamingTest, TestsReportCorrectNames) { 95013481Sgiacomo.travaglini@arm.com const ::testing::TestInfo* const test_info = 95113481Sgiacomo.travaglini@arm.com ::testing::UnitTest::GetInstance()->current_test_info(); 95213481Sgiacomo.travaglini@arm.com sum_ += GetParam(); 95313481Sgiacomo.travaglini@arm.com Message test_name_stream; 95413481Sgiacomo.travaglini@arm.com test_name_stream << "TestsReportCorrectNames/" << sum_; 95513481Sgiacomo.travaglini@arm.com EXPECT_STREQ(test_name_stream.GetString().c_str(), test_info->name()); 95613481Sgiacomo.travaglini@arm.com} 95713481Sgiacomo.travaglini@arm.com 95813481Sgiacomo.travaglini@arm.comINSTANTIATE_TEST_CASE_P(StatefulNamingFunctor, 95913481Sgiacomo.travaglini@arm.com StatefulNamingTest, 96013481Sgiacomo.travaglini@arm.com Range(0, 5), 96113481Sgiacomo.travaglini@arm.com StatefulNamingFunctor()); 96213481Sgiacomo.travaglini@arm.com 96313481Sgiacomo.travaglini@arm.com// Class that cannot be streamed into an ostream. It needs to be copyable 96413481Sgiacomo.travaglini@arm.com// (and, in case of MSVC, also assignable) in order to be a test parameter 96513481Sgiacomo.travaglini@arm.com// type. Its default copy constructor and assignment operator do exactly 96613481Sgiacomo.travaglini@arm.com// what we need. 96713481Sgiacomo.travaglini@arm.comclass Unstreamable { 96813481Sgiacomo.travaglini@arm.com public: 96913481Sgiacomo.travaglini@arm.com explicit Unstreamable(int value) : value_(value) {} 97013481Sgiacomo.travaglini@arm.com 97113481Sgiacomo.travaglini@arm.com private: 97213481Sgiacomo.travaglini@arm.com int value_; 97313481Sgiacomo.travaglini@arm.com}; 97413481Sgiacomo.travaglini@arm.com 97513481Sgiacomo.travaglini@arm.comclass CommentTest : public TestWithParam<Unstreamable> {}; 97613481Sgiacomo.travaglini@arm.com 97713481Sgiacomo.travaglini@arm.comTEST_P(CommentTest, TestsCorrectlyReportUnstreamableParams) { 97813481Sgiacomo.travaglini@arm.com const ::testing::TestInfo* const test_info = 97913481Sgiacomo.travaglini@arm.com ::testing::UnitTest::GetInstance()->current_test_info(); 98013481Sgiacomo.travaglini@arm.com 98113481Sgiacomo.travaglini@arm.com EXPECT_EQ(::testing::PrintToString(GetParam()), test_info->value_param()); 98213481Sgiacomo.travaglini@arm.com} 98313481Sgiacomo.travaglini@arm.com 98413481Sgiacomo.travaglini@arm.comINSTANTIATE_TEST_CASE_P(InstantiationWithComments, 98513481Sgiacomo.travaglini@arm.com CommentTest, 98613481Sgiacomo.travaglini@arm.com Values(Unstreamable(1))); 98713481Sgiacomo.travaglini@arm.com 98813481Sgiacomo.travaglini@arm.com// Verify that we can create a hierarchy of test fixtures, where the base 98913481Sgiacomo.travaglini@arm.com// class fixture is not parameterized and the derived class is. In this case 99013481Sgiacomo.travaglini@arm.com// ParameterizedDerivedTest inherits from NonParameterizedBaseTest. We 99113481Sgiacomo.travaglini@arm.com// perform simple tests on both. 99213481Sgiacomo.travaglini@arm.comclass NonParameterizedBaseTest : public ::testing::Test { 99313481Sgiacomo.travaglini@arm.com public: 99413481Sgiacomo.travaglini@arm.com NonParameterizedBaseTest() : n_(17) { } 99513481Sgiacomo.travaglini@arm.com protected: 99613481Sgiacomo.travaglini@arm.com int n_; 99713481Sgiacomo.travaglini@arm.com}; 99813481Sgiacomo.travaglini@arm.com 99913481Sgiacomo.travaglini@arm.comclass ParameterizedDerivedTest : public NonParameterizedBaseTest, 100013481Sgiacomo.travaglini@arm.com public ::testing::WithParamInterface<int> { 100113481Sgiacomo.travaglini@arm.com protected: 100213481Sgiacomo.travaglini@arm.com ParameterizedDerivedTest() : count_(0) { } 100313481Sgiacomo.travaglini@arm.com int count_; 100413481Sgiacomo.travaglini@arm.com static int global_count_; 100513481Sgiacomo.travaglini@arm.com}; 100613481Sgiacomo.travaglini@arm.com 100713481Sgiacomo.travaglini@arm.comint ParameterizedDerivedTest::global_count_ = 0; 100813481Sgiacomo.travaglini@arm.com 100913481Sgiacomo.travaglini@arm.comTEST_F(NonParameterizedBaseTest, FixtureIsInitialized) { 101013481Sgiacomo.travaglini@arm.com EXPECT_EQ(17, n_); 101113481Sgiacomo.travaglini@arm.com} 101213481Sgiacomo.travaglini@arm.com 101313481Sgiacomo.travaglini@arm.comTEST_P(ParameterizedDerivedTest, SeesSequence) { 101413481Sgiacomo.travaglini@arm.com EXPECT_EQ(17, n_); 101513481Sgiacomo.travaglini@arm.com EXPECT_EQ(0, count_++); 101613481Sgiacomo.travaglini@arm.com EXPECT_EQ(GetParam(), global_count_++); 101713481Sgiacomo.travaglini@arm.com} 101813481Sgiacomo.travaglini@arm.com 101913481Sgiacomo.travaglini@arm.comclass ParameterizedDeathTest : public ::testing::TestWithParam<int> { }; 102013481Sgiacomo.travaglini@arm.com 102113481Sgiacomo.travaglini@arm.comTEST_F(ParameterizedDeathTest, GetParamDiesFromTestF) { 102213481Sgiacomo.travaglini@arm.com EXPECT_DEATH_IF_SUPPORTED(GetParam(), 102313481Sgiacomo.travaglini@arm.com ".* value-parameterized test .*"); 102413481Sgiacomo.travaglini@arm.com} 102513481Sgiacomo.travaglini@arm.com 102613481Sgiacomo.travaglini@arm.comINSTANTIATE_TEST_CASE_P(RangeZeroToFive, ParameterizedDerivedTest, Range(0, 5)); 102713481Sgiacomo.travaglini@arm.com 102813481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_PARAM_TEST 102913481Sgiacomo.travaglini@arm.com 103013481Sgiacomo.travaglini@arm.comTEST(CompileTest, CombineIsDefinedOnlyWhenGtestHasParamTestIsDefined) { 103113481Sgiacomo.travaglini@arm.com#if GTEST_HAS_COMBINE && !GTEST_HAS_PARAM_TEST 103213481Sgiacomo.travaglini@arm.com FAIL() << "GTEST_HAS_COMBINE is defined while GTEST_HAS_PARAM_TEST is not\n" 103313481Sgiacomo.travaglini@arm.com#endif 103413481Sgiacomo.travaglini@arm.com} 103513481Sgiacomo.travaglini@arm.com 103613481Sgiacomo.travaglini@arm.comint main(int argc, char **argv) { 103713481Sgiacomo.travaglini@arm.com#if GTEST_HAS_PARAM_TEST 103813481Sgiacomo.travaglini@arm.com // Used in TestGenerationTest test case. 103913481Sgiacomo.travaglini@arm.com AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance()); 104013481Sgiacomo.travaglini@arm.com // Used in GeneratorEvaluationTest test case. Tests that the updated value 104113481Sgiacomo.travaglini@arm.com // will be picked up for instantiating tests in GeneratorEvaluationTest. 104213481Sgiacomo.travaglini@arm.com GeneratorEvaluationTest::set_param_value(1); 104313481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_PARAM_TEST 104413481Sgiacomo.travaglini@arm.com 104513481Sgiacomo.travaglini@arm.com ::testing::InitGoogleTest(&argc, argv); 104613481Sgiacomo.travaglini@arm.com 104713481Sgiacomo.travaglini@arm.com#if GTEST_HAS_PARAM_TEST 104813481Sgiacomo.travaglini@arm.com // Used in GeneratorEvaluationTest test case. Tests that value updated 104913481Sgiacomo.travaglini@arm.com // here will NOT be used for instantiating tests in 105013481Sgiacomo.travaglini@arm.com // GeneratorEvaluationTest. 105113481Sgiacomo.travaglini@arm.com GeneratorEvaluationTest::set_param_value(2); 105213481Sgiacomo.travaglini@arm.com#endif // GTEST_HAS_PARAM_TEST 105313481Sgiacomo.travaglini@arm.com 105413481Sgiacomo.travaglini@arm.com return RUN_ALL_TESTS(); 105513481Sgiacomo.travaglini@arm.com} 1056