1fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Copyright 2008, Google Inc. 2fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// All rights reserved. 3fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 4fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Redistribution and use in source and binary forms, with or without 5fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// modification, are permitted provided that the following conditions are 6fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// met: 7fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 8fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Redistributions of source code must retain the above copyright 9fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// notice, this list of conditions and the following disclaimer. 10fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Redistributions in binary form must reproduce the above 11fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// copyright notice, this list of conditions and the following disclaimer 12fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// in the documentation and/or other materials provided with the 13fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// distribution. 14fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// * Neither the name of Google Inc. nor the names of its 15fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// contributors may be used to endorse or promote products derived from 16fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// this software without specific prior written permission. 17fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 18fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 30fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Author: vladl@google.com (Vlad Losev) 31fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// 32fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests for Google Test itself. This file verifies that the parameter 33fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// generators objects produce correct parameter sequences and that 34fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Google Test runtime instantiates correct tests from those sequences. 35fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 36fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <gtest/gtest.h> 37fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 38fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_PARAM_TEST 39fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 40fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <algorithm> 41fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <iostream> 42fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <list> 43fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include <vector> 44fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 45fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// To include gtest-internal-inl.h. 46fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#define GTEST_IMPLEMENTATION_ 1 47fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include "src/gtest-internal-inl.h" // for UnitTestOptions 48fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#undef GTEST_IMPLEMENTATION_ 49fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 50fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#include "test/gtest-param-test_test.h" 51fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 52fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing ::std::vector; 53fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing ::std::sort; 54fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 55fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing ::testing::AddGlobalTestEnvironment; 56fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing ::testing::Bool; 57fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing ::testing::Message; 58fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing ::testing::Range; 59fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing ::testing::TestWithParam; 60fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing ::testing::Values; 61fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing ::testing::ValuesIn; 62fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 63fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_COMBINE 64fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing ::testing::Combine; 65fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing ::std::tr1::get; 66fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing ::std::tr1::make_tuple; 67fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing ::std::tr1::tuple; 68fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_COMBINE 69fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 70fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing ::testing::internal::ParamGenerator; 71fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleusing ::testing::internal::UnitTestOptions; 72fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 73fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Verifies that a sequence generated by the generator and accessed 74fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// via the iterator object matches the expected one using Google Test 75fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// assertions. 76fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T, size_t N> 77fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid VerifyGenerator(const ParamGenerator<T>& generator, 78fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const T (&expected_values)[N]) { 79fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typename ParamGenerator<T>::iterator it = generator.begin(); 80fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for (size_t i = 0; i < N; ++i) { 81fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_FALSE(it == generator.end()) 82fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "At element " << i << " when accessing via an iterator " 83fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "created with the copy constructor." << std::endl; 84fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(expected_values[i], *it) 85fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "At element " << i << " when accessing via an iterator " 86fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "created with the copy constructor." << std::endl; 87fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville it++; 88fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 89fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(it == generator.end()) 90fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "At the presumed end of sequence when accessing via an iterator " 91fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "created with the copy constructor." << std::endl; 92fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 93fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Test the iterator assignment. The following lines verify that 94fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // the sequence accessed via an iterator initialized via the 95fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // assignment operator (as opposed to a copy constructor) matches 96fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // just the same. 97fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville it = generator.begin(); 98fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for (size_t i = 0; i < N; ++i) { 99fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_FALSE(it == generator.end()) 100fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "At element " << i << " when accessing via an iterator " 101fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "created with the assignment operator." << std::endl; 102fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(expected_values[i], *it) 103fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "At element " << i << " when accessing via an iterator " 104fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "created with the assignment operator." << std::endl; 105fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville it++; 106fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 107fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(it == generator.end()) 108fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "At the presumed end of sequence when accessing via an iterator " 109fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "created with the assignment operator." << std::endl; 110fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 111fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 112fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T> 113fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevoid VerifyGeneratorIsEmpty(const ParamGenerator<T>& generator) { 114fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typename ParamGenerator<T>::iterator it = generator.begin(); 115fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(it == generator.end()); 116fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 117fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville it = generator.begin(); 118fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(it == generator.end()); 119fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 120fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 121fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Generator tests. They test that each of the provided generator functions 122fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// generates an expected sequence of values. The general test pattern 123fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// instantiates a generator using one of the generator functions, 124fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// checks the sequence produced by the generator using its iterator API, 125fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// and then resets the iterator back to the beginning of the sequence 126fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// and checks the sequence again. 127fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 128fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that iterators produced by generator functions conform to the 129fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// ForwardIterator concept. 130fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(IteratorTest, ParamIteratorConformsToForwardIteratorConcept) { 131fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<int> gen = Range(0, 10); 132fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ParamGenerator<int>::iterator it = gen.begin(); 133fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 134fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Verifies that iterator initialization works as expected. 135fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ParamGenerator<int>::iterator it2 = it; 136fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(*it == *it2) << "Initialized iterators must point to the " 137fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "element same as its source points to"; 138fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 139fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Verifies that iterator assignment works as expected. 140fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville it++; 141fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_FALSE(*it == *it2); 142fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville it2 = it; 143fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(*it == *it2) << "Assigned iterators must point to the " 144fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "element same as its source points to"; 145fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 146fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Verifies that prefix operator++() returns *this. 147fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(&it, &(++it)) << "Result of the prefix operator++ must be " 148fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "refer to the original object"; 149fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 150fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Verifies that the result of the postfix operator++ points to the value 151fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // pointed to by the original iterator. 152fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int original_value = *it; // Have to compute it outside of macro call to be 153fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // unaffected by the parameter evaluation order. 154fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(original_value, *(it++)); 155fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 156fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Verifies that prefix and postfix operator++() advance an iterator 157fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // all the same. 158fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville it2 = it; 159fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville it++; 160fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ++it2; 161fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(*it == *it2); 162fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 163fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 164fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that Range() generates the expected sequence. 165fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(RangeTest, IntRangeWithDefaultStep) { 166fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<int> gen = Range(0, 3); 167fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int expected_values[] = {0, 1, 2}; 168fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, expected_values); 169fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 170fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 171fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Edge case. Tests that Range() generates the single element sequence 172fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// as expected when provided with range limits that are equal. 173fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(RangeTest, IntRangeSingleValue) { 174fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<int> gen = Range(0, 1); 175fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int expected_values[] = {0}; 176fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, expected_values); 177fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 178fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 179fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Edge case. Tests that Range() with generates empty sequence when 180fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// supplied with an empty range. 181fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(RangeTest, IntRangeEmpty) { 182fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<int> gen = Range(0, 0); 183fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGeneratorIsEmpty(gen); 184fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 185fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 186fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that Range() with custom step (greater then one) generates 187fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the expected sequence. 188fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(RangeTest, IntRangeWithCustomStep) { 189fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<int> gen = Range(0, 9, 3); 190fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int expected_values[] = {0, 3, 6}; 191fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, expected_values); 192fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 193fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 194fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that Range() with custom step (greater then one) generates 195fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the expected sequence when the last element does not fall on the 196fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// upper range limit. Sequences generated by Range() must not have 197fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// elements beyond the range limits. 198fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(RangeTest, IntRangeWithCustomStepOverUpperBound) { 199fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<int> gen = Range(0, 4, 3); 200fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int expected_values[] = {0, 3}; 201fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, expected_values); 202fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 203fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 204fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Verifies that Range works with user-defined types that define 205fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// copy constructor, operator=(), operator+(), and operator<(). 206fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass DogAdder { 207fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 208fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville explicit DogAdder(const char* value) : value_(value) {} 209fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville DogAdder(const DogAdder& other) : value_(other.value_.c_str()) {} 210fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 211fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville DogAdder operator=(const DogAdder& other) { 212fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (this != &other) 213fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville value_ = other.value_; 214fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return *this; 215fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 216fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville DogAdder operator+(const DogAdder& other) const { 217fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Message msg; 218fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville msg << value_.c_str() << other.value_.c_str(); 219fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return DogAdder(msg.GetString().c_str()); 220fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 221fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool operator<(const DogAdder& other) const { 222fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return value_ < other.value_; 223fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 224fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ::testing::internal::String& value() const { return value_; } 225fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 226fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 227fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ::testing::internal::String value_; 228fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 229fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 230fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(RangeTest, WorksWithACustomType) { 231fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<DogAdder> gen = 232fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Range(DogAdder("cat"), DogAdder("catdogdog"), DogAdder("dog")); 233fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ParamGenerator<DogAdder>::iterator it = gen.begin(); 234fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 235fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_FALSE(it == gen.end()); 236fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_STREQ("cat", it->value().c_str()); 237fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 238fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_FALSE(++it == gen.end()); 239fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_STREQ("catdog", it->value().c_str()); 240fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 241fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(++it == gen.end()); 242fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 243fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 244fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass IntWrapper { 245fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 246fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville explicit IntWrapper(int value) : value_(value) {} 247fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville IntWrapper(const IntWrapper& other) : value_(other.value_) {} 248fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 249fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville IntWrapper operator=(const IntWrapper& other) { 250fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville value_ = other.value_; 251fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return *this; 252fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 253fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // operator+() adds a different type. 254fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville IntWrapper operator+(int other) const { return IntWrapper(value_ + other); } 255fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool operator<(const IntWrapper& other) const { 256fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return value_ < other.value_; 257fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 258fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int value() const { return value_; } 259fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 260fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 261fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int value_; 262fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 263fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 264fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(RangeTest, WorksWithACustomTypeWithDifferentIncrementType) { 265fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<IntWrapper> gen = Range(IntWrapper(0), IntWrapper(2)); 266fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ParamGenerator<IntWrapper>::iterator it = gen.begin(); 267fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 268fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_FALSE(it == gen.end()); 269fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0, it->value()); 270fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 271fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ASSERT_FALSE(++it == gen.end()); 272fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(1, it->value()); 273fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 274fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(++it == gen.end()); 275fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 276fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 277fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that ValuesIn() with an array parameter generates 278fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the expected sequence. 279fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ValuesInTest, ValuesInArray) { 280fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int array[] = {3, 5, 8}; 281fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<int> gen = ValuesIn(array); 282fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, array); 283fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 284fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 285fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that ValuesIn() with a const array parameter generates 286fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// the expected sequence. 287fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ValuesInTest, ValuesInConstArray) { 288fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int array[] = {3, 5, 8}; 289fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<int> gen = ValuesIn(array); 290fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, array); 291fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 292fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 293fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Edge case. Tests that ValuesIn() with an array parameter containing a 294fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// single element generates the single element sequence. 295fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ValuesInTest, ValuesInSingleElementArray) { 296fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int array[] = {42}; 297fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<int> gen = ValuesIn(array); 298fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, array); 299fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 300fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 301fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that ValuesIn() generates the expected sequence for an STL 302fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// container (vector). 303fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ValuesInTest, ValuesInVector) { 304fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef ::std::vector<int> ContainerType; 305fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ContainerType values; 306fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville values.push_back(3); 307fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville values.push_back(5); 308fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville values.push_back(8); 309fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<int> gen = ValuesIn(values); 310fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 311fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int expected_values[] = {3, 5, 8}; 312fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, expected_values); 313fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 314fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 315fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that ValuesIn() generates the expected sequence. 316fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ValuesInTest, ValuesInIteratorRange) { 317fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef ::std::vector<int> ContainerType; 318fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ContainerType values; 319fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville values.push_back(3); 320fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville values.push_back(5); 321fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville values.push_back(8); 322fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end()); 323fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 324fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int expected_values[] = {3, 5, 8}; 325fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, expected_values); 326fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 327fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 328fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Edge case. Tests that ValuesIn() provided with an iterator range specifying a 329fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// single value generates a single-element sequence. 330fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ValuesInTest, ValuesInSingleElementIteratorRange) { 331fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef ::std::vector<int> ContainerType; 332fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ContainerType values; 333fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville values.push_back(42); 334fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end()); 335fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 336fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int expected_values[] = {42}; 337fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, expected_values); 338fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 339fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 340fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Edge case. Tests that ValuesIn() provided with an empty iterator range 341fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// generates an empty sequence. 342fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ValuesInTest, ValuesInEmptyIteratorRange) { 343fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef ::std::vector<int> ContainerType; 344fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ContainerType values; 345fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<int> gen = ValuesIn(values.begin(), values.end()); 346fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 347fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGeneratorIsEmpty(gen); 348fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 349fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 350fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that the Values() generates the expected sequence. 351fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ValuesTest, ValuesWorks) { 352fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<int> gen = Values(3, 5, 8); 353fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 354fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int expected_values[] = {3, 5, 8}; 355fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, expected_values); 356fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 357fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 358fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that Values() generates the expected sequences from elements of 359fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// different types convertible to ParamGenerator's parameter type. 360fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ValuesTest, ValuesWorksForValuesOfCompatibleTypes) { 361fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<double> gen = Values(3, 5.0f, 8.0); 362fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 363fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const double expected_values[] = {3.0, 5.0, 8.0}; 364fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, expected_values); 365fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 366fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 367fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ValuesTest, ValuesWorksForMaxLengthList) { 368fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<int> gen = Values( 369fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 370fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 110, 120, 130, 140, 150, 160, 170, 180, 190, 200, 371fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 372fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 310, 320, 330, 340, 350, 360, 370, 380, 390, 400, 373fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 410, 420, 430, 440, 450, 460, 470, 480, 490, 500); 374fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 375fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int expected_values[] = { 376fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 377fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 110, 120, 130, 140, 150, 160, 170, 180, 190, 200, 378fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 379fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 310, 320, 330, 340, 350, 360, 370, 380, 390, 400, 380fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 410, 420, 430, 440, 450, 460, 470, 480, 490, 500}; 381fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, expected_values); 382fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 383fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 384fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Edge case test. Tests that single-parameter Values() generates the sequence 385fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// with the single value. 386fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ValuesTest, ValuesWithSingleParameter) { 387fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<int> gen = Values(42); 388fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 389fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int expected_values[] = {42}; 390fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, expected_values); 391fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 392fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 393fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that Bool() generates sequence (false, true). 394fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(BoolTest, BoolWorks) { 395fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<bool> gen = Bool(); 396fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 397fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const bool expected_values[] = {false, true}; 398fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, expected_values); 399fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 400fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 401fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_COMBINE 402fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 403fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T1, typename T2> 404fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville::std::ostream& operator<<(::std::ostream& stream, const tuple<T1, T2>& value) { 405fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville stream << "(" << get<0>(value) << ", " << get<1>(value) << ")"; 406fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return stream; 407fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 408fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 409fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T1, typename T2, typename T3> 410fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville::std::ostream& operator<<(::std::ostream& stream, 411fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const tuple<T1, T2, T3>& value) { 412fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville stream << "(" << get<0>(value) << ", " << get<1>(value) 413fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << ", "<< get<2>(value) << ")"; 414fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return stream; 415fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 416fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 417fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <typename T1, typename T2, typename T3, typename T4, typename T5, 418fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typename T6, typename T7, typename T8, typename T9, typename T10> 419fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville::std::ostream& operator<<( 420fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ::std::ostream& stream, 421fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& value) { 422fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville stream << "(" << get<0>(value) << ", " << get<1>(value) 423fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << ", "<< get<2>(value) << ", " << get<3>(value) 424fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << ", "<< get<4>(value) << ", " << get<5>(value) 425fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << ", "<< get<6>(value) << ", " << get<7>(value) 426fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << ", "<< get<8>(value) << ", " << get<9>(value) << ")"; 427fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return stream; 428fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 429fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 430fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that Combine() with two parameters generates the expected sequence. 431fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(CombineTest, CombineWithTwoParameters) { 432fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* foo = "foo"; 433fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* bar = "bar"; 434fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<tuple<const char*, int> > gen = 435fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Combine(Values(foo, bar), Values(3, 4)); 436fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 437fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville tuple<const char*, int> expected_values[] = { 438fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville make_tuple(foo, 3), make_tuple(foo, 4), 439fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville make_tuple(bar, 3), make_tuple(bar, 4)}; 440fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, expected_values); 441fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 442fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 443fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that Combine() with three parameters generates the expected sequence. 444fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(CombineTest, CombineWithThreeParameters) { 445fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<tuple<int, int, int> > gen = Combine(Values(0, 1), 446fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Values(3, 4), 447fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Values(5, 6)); 448fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville tuple<int, int, int> expected_values[] = { 449fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville make_tuple(0, 3, 5), make_tuple(0, 3, 6), 450fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville make_tuple(0, 4, 5), make_tuple(0, 4, 6), 451fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville make_tuple(1, 3, 5), make_tuple(1, 3, 6), 452fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville make_tuple(1, 4, 5), make_tuple(1, 4, 6)}; 453fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, expected_values); 454fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 455fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 456fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that the Combine() with the first parameter generating a single value 457fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// sequence generates a sequence with the number of elements equal to the 458fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// number of elements in the sequence generated by the second parameter. 459fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(CombineTest, CombineWithFirstParameterSingleValue) { 460fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<tuple<int, int> > gen = Combine(Values(42), 461fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Values(0, 1)); 462fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 463fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville tuple<int, int> expected_values[] = {make_tuple(42, 0), make_tuple(42, 1)}; 464fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, expected_values); 465fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 466fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 467fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that the Combine() with the second parameter generating a single value 468fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// sequence generates a sequence with the number of elements equal to the 469fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// number of elements in the sequence generated by the first parameter. 470fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(CombineTest, CombineWithSecondParameterSingleValue) { 471fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1), 472fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Values(42)); 473fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 474fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville tuple<int, int> expected_values[] = {make_tuple(0, 42), make_tuple(1, 42)}; 475fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, expected_values); 476fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 477fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 478fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that when the first parameter produces an empty sequence, 479fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Combine() produces an empty sequence, too. 480fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(CombineTest, CombineWithFirstParameterEmptyRange) { 481fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<tuple<int, int> > gen = Combine(Range(0, 0), 482fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Values(0, 1)); 483fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGeneratorIsEmpty(gen); 484fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 485fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 486fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that when the second parameter produces an empty sequence, 487fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Combine() produces an empty sequence, too. 488fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(CombineTest, CombineWithSecondParameterEmptyRange) { 489fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<tuple<int, int> > gen = Combine(Values(0, 1), 490fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Range(1, 1)); 491fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGeneratorIsEmpty(gen); 492fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 493fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 494fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Edge case. Tests that combine works with the maximum number 495fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// of parameters supported by Google Test (currently 10). 496fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(CombineTest, CombineWithMaxNumberOfParameters) { 497fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* foo = "foo"; 498fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const char* bar = "bar"; 499fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<tuple<const char*, int, int, int, int, int, int, int, 500fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int, int> > gen = Combine(Values(foo, bar), 501fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Values(1), Values(2), 502fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Values(3), Values(4), 503fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Values(5), Values(6), 504fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Values(7), Values(8), 505fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Values(9)); 506fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 507fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville tuple<const char*, int, int, int, int, int, int, int, int, int> 508fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville expected_values[] = {make_tuple(foo, 1, 2, 3, 4, 5, 6, 7, 8, 9), 509fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville make_tuple(bar, 1, 2, 3, 4, 5, 6, 7, 8, 9)}; 510fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, expected_values); 511fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 512fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 513fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_COMBINE 514fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 515fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that an generator produces correct sequence after being 516fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// assigned from another generator. 517fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(ParamGeneratorTest, AssignmentWorks) { 518fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ParamGenerator<int> gen = Values(1, 2); 519fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ParamGenerator<int> gen2 = Values(3, 4); 520fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville gen = gen2; 521fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 522fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const int expected_values[] = {3, 4}; 523fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville VerifyGenerator(gen, expected_values); 524fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 525fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 526fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This test verifies that the tests are expanded and run as specified: 527fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// one test per element from the sequence produced by the generator 528fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// specified in INSTANTIATE_TEST_CASE_P. It also verifies that the test's 529fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// fixture constructor, SetUp(), and TearDown() have run and have been 530fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// supplied with the correct parameters. 531fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 532fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// The use of environment object allows detection of the case where no test 533fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// case functionality is run at all. In this case TestCaseTearDown will not 534fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// be able to detect missing tests, naturally. 535fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilletemplate <int kExpectedCalls> 536fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass TestGenerationEnvironment : public ::testing::Environment { 537fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 538fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static TestGenerationEnvironment* Instance() { 539fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static TestGenerationEnvironment* instance = new TestGenerationEnvironment; 540fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return instance; 541fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 542fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 543fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void FixtureConstructorExecuted() { fixture_constructor_count_++; } 544fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void SetUpExecuted() { set_up_count_++; } 545fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void TearDownExecuted() { tear_down_count_++; } 546fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville void TestBodyExecuted() { test_body_count_++; } 547fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 548fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual void TearDown() { 549fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // If all MultipleTestGenerationTest tests have been de-selected 550fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // by the filter flag, the following checks make no sense. 551fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool perform_check = false; 552fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 553fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for (int i = 0; i < kExpectedCalls; ++i) { 554fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Message msg; 555fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville msg << "TestsExpandedAndRun/" << i; 556fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (UnitTestOptions::FilterMatchesTest( 557fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville "TestExpansionModule/MultipleTestGenerationTest", 558fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville msg.GetString().c_str())) { 559fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville perform_check = true; 560fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 561fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 562fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if (perform_check) { 563fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(kExpectedCalls, fixture_constructor_count_) 564fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "Fixture constructor of ParamTestGenerationTest test case " 565fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "has not been run as expected."; 566fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(kExpectedCalls, set_up_count_) 567fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "Fixture SetUp method of ParamTestGenerationTest test case " 568fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "has not been run as expected."; 569fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(kExpectedCalls, tear_down_count_) 570fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "Fixture TearDown method of ParamTestGenerationTest test case " 571fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "has not been run as expected."; 572fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(kExpectedCalls, test_body_count_) 573fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "Test in ParamTestGenerationTest test case " 574fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "has not been run as expected."; 575fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 576fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 577fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 578fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestGenerationEnvironment() : fixture_constructor_count_(0), set_up_count_(0), 579fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville tear_down_count_(0), test_body_count_(0) {} 580fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 581fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int fixture_constructor_count_; 582fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int set_up_count_; 583fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int tear_down_count_; 584fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int test_body_count_; 585fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 586fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationEnvironment); 587fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 588fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 589fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleconst int test_generation_params[] = {36, 42, 72}; 590fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 591fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass TestGenerationTest : public TestWithParam<int> { 592fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 593fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville enum { 594fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville PARAMETER_COUNT = 595fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville sizeof(test_generation_params)/sizeof(test_generation_params[0]) 596fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville }; 597fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 598fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville typedef TestGenerationEnvironment<PARAMETER_COUNT> Environment; 599fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 600fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville TestGenerationTest() { 601fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Environment::Instance()->FixtureConstructorExecuted(); 602fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville current_parameter_ = GetParam(); 603fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 604fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual void SetUp() { 605fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Environment::Instance()->SetUpExecuted(); 606fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(current_parameter_, GetParam()); 607fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 608fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville virtual void TearDown() { 609fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Environment::Instance()->TearDownExecuted(); 610fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(current_parameter_, GetParam()); 611fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 612fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 613fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static void SetUpTestCase() { 614fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville bool all_tests_in_test_case_selected = true; 615fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 616fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville for (int i = 0; i < PARAMETER_COUNT; ++i) { 617fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Message test_name; 618fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_name << "TestsExpandedAndRun/" << i; 619fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville if ( !UnitTestOptions::FilterMatchesTest( 620fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville "TestExpansionModule/MultipleTestGenerationTest", 621fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_name.GetString())) { 622fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville all_tests_in_test_case_selected = false; 623fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 624fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 625fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(all_tests_in_test_case_selected) 626fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "When running the TestGenerationTest test case all of its tests\n" 627fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "must be selected by the filter flag for the test case to pass.\n" 628fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "If not all of them are enabled, we can't reliably conclude\n" 629fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "that the correct number of tests have been generated."; 630fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 631fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville collected_parameters_.clear(); 632fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 633fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 634fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static void TearDownTestCase() { 635fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville vector<int> expected_values(test_generation_params, 636fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville test_generation_params + PARAMETER_COUNT); 637fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Test execution order is not guaranteed by Google Test, 638fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // so the order of values in collected_parameters_ can be 639fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // different and we have to sort to compare. 640fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville sort(expected_values.begin(), expected_values.end()); 641fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville sort(collected_parameters_.begin(), collected_parameters_.end()); 642fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 643fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_TRUE(collected_parameters_ == expected_values); 644fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 645fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville protected: 646fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int current_parameter_; 647fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static vector<int> collected_parameters_; 648fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 649fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 650fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GTEST_DISALLOW_COPY_AND_ASSIGN_(TestGenerationTest); 651fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 652fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savillevector<int> TestGenerationTest::collected_parameters_; 653fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 654fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_P(TestGenerationTest, TestsExpandedAndRun) { 655fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Environment::Instance()->TestBodyExecuted(); 656fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(current_parameter_, GetParam()); 657fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville collected_parameters_.push_back(GetParam()); 658fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 659fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleINSTANTIATE_TEST_CASE_P(TestExpansionModule, TestGenerationTest, 660fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ValuesIn(test_generation_params)); 661fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 662fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// This test verifies that the element sequence (third parameter of 663fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// INSTANTIATE_TEST_CASE_P) is evaluated in RUN_ALL_TESTS and not at the call 664fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// site of INSTANTIATE_TEST_CASE_P. 665fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// For that, we declare param_value_ to be a static member of 666fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// GeneratorEvaluationTest and initialize it to 0. We set it to 1 in main(), 667fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// just before invocation of RUN_ALL_TESTS. If the sequence is evaluated 668fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// before that moment, INSTANTIATE_TEST_CASE_P will create a test with 669fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// parameter 0, and the test body will fail the assertion. 670fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass GeneratorEvaluationTest : public TestWithParam<int> { 671fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 672fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static int param_value() { return param_value_; } 673fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static void set_param_value(int param_value) { param_value_ = param_value; } 674fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 675fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville private: 676fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static int param_value_; 677fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 678fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleint GeneratorEvaluationTest::param_value_ = 0; 679fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 680fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_P(GeneratorEvaluationTest, GeneratorsEvaluatedInMain) { 681fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(1, GetParam()); 682fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 683fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleINSTANTIATE_TEST_CASE_P(GenEvalModule, 684fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GeneratorEvaluationTest, 685fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Values(GeneratorEvaluationTest::param_value())); 686fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 687fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that generators defined in a different translation unit are 688fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// functional. Generator extern_gen is defined in gtest-param-test_test2.cc. 689fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleextern ParamGenerator<int> extern_gen; 690fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass ExternalGeneratorTest : public TestWithParam<int> {}; 691fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_P(ExternalGeneratorTest, ExternalGenerator) { 692fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Sequence produced by extern_gen contains only a single value 693fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // which we verify here. 694fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(GetParam(), 33); 695fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 696fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleINSTANTIATE_TEST_CASE_P(ExternalGeneratorModule, 697fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ExternalGeneratorTest, 698fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville extern_gen); 699fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 700fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that a parameterized test case can be defined in one translation 701fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// unit and instantiated in another. This test will be instantiated in 702fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// gtest-param-test_test2.cc. ExternalInstantiationTest fixture class is 703fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// defined in gtest-param-test_test.h. 704fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_P(ExternalInstantiationTest, IsMultipleOf33) { 705fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0, GetParam() % 33); 706fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 707fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 708fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that a parameterized test case can be instantiated with multiple 709fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// generators. 710fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass MultipleInstantiationTest : public TestWithParam<int> {}; 711fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_P(MultipleInstantiationTest, AllowsMultipleInstances) { 712fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 713fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleINSTANTIATE_TEST_CASE_P(Sequence1, MultipleInstantiationTest, Values(1, 2)); 714fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleINSTANTIATE_TEST_CASE_P(Sequence2, MultipleInstantiationTest, Range(3, 5)); 715fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 716fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that a parameterized test case can be instantiated 717fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// in multiple translation units. This test will be instantiated 718fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// here and in gtest-param-test_test2.cc. 719fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// InstantiationInMultipleTranslationUnitsTest fixture class 720fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// is defined in gtest-param-test_test.h. 721fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_P(InstantiationInMultipleTranslaionUnitsTest, IsMultipleOf42) { 722fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0, GetParam() % 42); 723fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 724fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleINSTANTIATE_TEST_CASE_P(Sequence1, 725fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville InstantiationInMultipleTranslaionUnitsTest, 726fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Values(42, 42*2)); 727fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 728fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that each iteration of parameterized test runs in a separate test 729fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// object. 730fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass SeparateInstanceTest : public TestWithParam<int> { 731fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville public: 732fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville SeparateInstanceTest() : count_(0) {} 733fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 734fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static void TearDownTestCase() { 735fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_GE(global_count_, 2) 736fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "If some (but not all) SeparateInstanceTest tests have been " 737fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "filtered out this test will fail. Make sure that all " 738fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "GeneratorEvaluationTest are selected or de-selected together " 739fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville << "by the test filter."; 740fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville } 741fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 742fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville protected: 743fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville int count_; 744fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville static int global_count_; 745fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville}; 746fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleint SeparateInstanceTest::global_count_ = 0; 747fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 748fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_P(SeparateInstanceTest, TestsRunInSeparateInstances) { 749fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_EQ(0, count_++); 750fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville global_count_++; 751fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 752fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleINSTANTIATE_TEST_CASE_P(FourElemSequence, SeparateInstanceTest, Range(1, 4)); 753fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 754fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// Tests that all instantiations of a test have named appropriately. Test 755fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// defined with TEST_P(TestCaseName, TestName) and instantiated with 756fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// INSTANTIATE_TEST_CASE_P(SequenceName, TestCaseName, generator) must be named 757fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// SequenceName/TestCaseName.TestName/i, where i is the 0-based index of the 758fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville// sequence element used to instantiate the test. 759fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleclass NamingTest : public TestWithParam<int> {}; 760fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 761fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST_P(NamingTest, TestsAreNamedAppropriately) { 762fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville const ::testing::TestInfo* const test_info = 763fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ::testing::UnitTest::GetInstance()->current_test_info(); 764fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 765fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_STREQ("ZeroToFiveSequence/NamingTest", test_info->test_case_name()); 766fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 767fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville Message msg; 768fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville msg << "TestsAreNamedAppropriately/" << GetParam(); 769fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville EXPECT_STREQ(msg.GetString().c_str(), test_info->name()); 770fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 771fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 772fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleINSTANTIATE_TEST_CASE_P(ZeroToFiveSequence, NamingTest, Range(0, 5)); 773fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 774fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_PARAM_TEST 775fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 776fbaaef999ba563838ebd00874ed8a1c01fbf286dWink SavilleTEST(CompileTest, CombineIsDefinedOnlyWhenGtestHasParamTestIsDefined) { 777fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_COMBINE && !GTEST_HAS_PARAM_TEST 778fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville FAIL() << "GTEST_HAS_COMBINE is defined while GTEST_HAS_PARAM_TEST is not\n" 779fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif 780fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 781fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 782fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Savilleint main(int argc, char **argv) { 783fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#if GTEST_HAS_PARAM_TEST 784fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Used in TestGenerationTest test case. 785fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville AddGlobalTestEnvironment(TestGenerationTest::Environment::Instance()); 786fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville // Used in GeneratorEvaluationTest test case. 787fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville GeneratorEvaluationTest::set_param_value(1); 788fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville#endif // GTEST_HAS_PARAM_TEST 789fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville 790fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville ::testing::InitGoogleTest(&argc, argv); 791fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville return RUN_ALL_TESTS(); 792fbaaef999ba563838ebd00874ed8a1c01fbf286dWink Saville} 793