1027 lines · c
1// Copyright 2008 Google Inc.2// All Rights Reserved.3//4// Redistribution and use in source and binary forms, with or without5// modification, are permitted provided that the following conditions are6// met:7//8// * Redistributions of source code must retain the above copyright9// notice, this list of conditions and the following disclaimer.10// * Redistributions in binary form must reproduce the above11// copyright notice, this list of conditions and the following disclaimer12// in the documentation and/or other materials provided with the13// distribution.14// * Neither the name of Google Inc. nor the names of its15// contributors may be used to endorse or promote products derived from16// this software without specific prior written permission.17//18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.29 30// Type and function utilities for implementing parameterized tests.31 32// IWYU pragma: private, include "gtest/gtest.h"33// IWYU pragma: friend gtest/.*34// IWYU pragma: friend gmock/.*35 36#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_37#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_38 39#include <ctype.h>40 41#include <cassert>42#include <iterator>43#include <map>44#include <memory>45#include <ostream>46#include <set>47#include <string>48#include <tuple>49#include <type_traits>50#include <utility>51#include <vector>52 53#include "gtest/gtest-printers.h"54#include "gtest/gtest-test-part.h"55#include "gtest/internal/gtest-internal.h"56#include "gtest/internal/gtest-port.h"57 58namespace testing {59// Input to a parameterized test name generator, describing a test parameter.60// Consists of the parameter value and the integer parameter index.61template <class ParamType>62struct TestParamInfo {63 TestParamInfo(const ParamType& a_param, size_t an_index)64 : param(a_param), index(an_index) {}65 ParamType param;66 size_t index;67};68 69// A builtin parameterized test name generator which returns the result of70// testing::PrintToString.71struct PrintToStringParamName {72 template <class ParamType>73 std::string operator()(const TestParamInfo<ParamType>& info) const {74 return PrintToString(info.param);75 }76};77 78namespace internal {79 80// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.81// Utility Functions82 83// Outputs a message explaining invalid registration of different84// fixture class for the same test suite. This may happen when85// TEST_P macro is used to define two tests with the same name86// but in different namespaces.87GTEST_API_ void ReportInvalidTestSuiteType(const char* test_suite_name,88 CodeLocation code_location);89 90template <typename>91class ParamGeneratorInterface;92template <typename>93class ParamGenerator;94 95// Interface for iterating over elements provided by an implementation96// of ParamGeneratorInterface<T>.97template <typename T>98class ParamIteratorInterface {99 public:100 virtual ~ParamIteratorInterface() = default;101 // A pointer to the base generator instance.102 // Used only for the purposes of iterator comparison103 // to make sure that two iterators belong to the same generator.104 virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0;105 // Advances iterator to point to the next element106 // provided by the generator. The caller is responsible107 // for not calling Advance() on an iterator equal to108 // BaseGenerator()->End().109 virtual void Advance() = 0;110 // Clones the iterator object. Used for implementing copy semantics111 // of ParamIterator<T>.112 virtual ParamIteratorInterface* Clone() const = 0;113 // Dereferences the current iterator and provides (read-only) access114 // to the pointed value. It is the caller's responsibility not to call115 // Current() on an iterator equal to BaseGenerator()->End().116 // Used for implementing ParamGenerator<T>::operator*().117 virtual const T* Current() const = 0;118 // Determines whether the given iterator and other point to the same119 // element in the sequence generated by the generator.120 // Used for implementing ParamGenerator<T>::operator==().121 virtual bool Equals(const ParamIteratorInterface& other) const = 0;122};123 124// Class iterating over elements provided by an implementation of125// ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T>126// and implements the const forward iterator concept.127template <typename T>128class ParamIterator {129 public:130 typedef T value_type;131 typedef const T& reference;132 typedef ptrdiff_t difference_type;133 134 // ParamIterator assumes ownership of the impl_ pointer.135 ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {}136 ParamIterator& operator=(const ParamIterator& other) {137 if (this != &other) impl_.reset(other.impl_->Clone());138 return *this;139 }140 141 const T& operator*() const { return *impl_->Current(); }142 const T* operator->() const { return impl_->Current(); }143 // Prefix version of operator++.144 ParamIterator& operator++() {145 impl_->Advance();146 return *this;147 }148 // Postfix version of operator++.149 ParamIterator operator++(int /*unused*/) {150 ParamIteratorInterface<T>* clone = impl_->Clone();151 impl_->Advance();152 return ParamIterator(clone);153 }154 bool operator==(const ParamIterator& other) const {155 return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_);156 }157 bool operator!=(const ParamIterator& other) const {158 return !(*this == other);159 }160 161 private:162 friend class ParamGenerator<T>;163 explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {}164 std::unique_ptr<ParamIteratorInterface<T>> impl_;165};166 167// ParamGeneratorInterface<T> is the binary interface to access generators168// defined in other translation units.169template <typename T>170class ParamGeneratorInterface {171 public:172 typedef T ParamType;173 174 virtual ~ParamGeneratorInterface() = default;175 176 // Generator interface definition177 virtual ParamIteratorInterface<T>* Begin() const = 0;178 virtual ParamIteratorInterface<T>* End() const = 0;179};180 181// Wraps ParamGeneratorInterface<T> and provides general generator syntax182// compatible with the STL Container concept.183// This class implements copy initialization semantics and the contained184// ParamGeneratorInterface<T> instance is shared among all copies185// of the original object. This is possible because that instance is immutable.186template <typename T>187class ParamGenerator {188 public:189 typedef ParamIterator<T> iterator;190 191 explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {}192 ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {}193 194 ParamGenerator& operator=(const ParamGenerator& other) {195 impl_ = other.impl_;196 return *this;197 }198 199 iterator begin() const { return iterator(impl_->Begin()); }200 iterator end() const { return iterator(impl_->End()); }201 202 private:203 std::shared_ptr<const ParamGeneratorInterface<T>> impl_;204};205 206// Generates values from a range of two comparable values. Can be used to207// generate sequences of user-defined types that implement operator+() and208// operator<().209// This class is used in the Range() function.210template <typename T, typename IncrementT>211class RangeGenerator : public ParamGeneratorInterface<T> {212 public:213 RangeGenerator(T begin, T end, IncrementT step)214 : begin_(begin),215 end_(end),216 step_(step),217 end_index_(CalculateEndIndex(begin, end, step)) {}218 ~RangeGenerator() override = default;219 220 ParamIteratorInterface<T>* Begin() const override {221 return new Iterator(this, begin_, 0, step_);222 }223 ParamIteratorInterface<T>* End() const override {224 return new Iterator(this, end_, end_index_, step_);225 }226 227 private:228 class Iterator : public ParamIteratorInterface<T> {229 public:230 Iterator(const ParamGeneratorInterface<T>* base, T value, int index,231 IncrementT step)232 : base_(base), value_(value), index_(index), step_(step) {}233 ~Iterator() override = default;234 235 const ParamGeneratorInterface<T>* BaseGenerator() const override {236 return base_;237 }238 void Advance() override {239 value_ = static_cast<T>(value_ + step_);240 index_++;241 }242 ParamIteratorInterface<T>* Clone() const override {243 return new Iterator(*this);244 }245 const T* Current() const override { return &value_; }246 bool Equals(const ParamIteratorInterface<T>& other) const override {247 // Having the same base generator guarantees that the other248 // iterator is of the same type and we can downcast.249 GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())250 << "The program attempted to compare iterators "251 << "from different generators." << std::endl;252 const int other_index =253 CheckedDowncastToActualType<const Iterator>(&other)->index_;254 return index_ == other_index;255 }256 257 private:258 Iterator(const Iterator& other)259 : ParamIteratorInterface<T>(),260 base_(other.base_),261 value_(other.value_),262 index_(other.index_),263 step_(other.step_) {}264 265 // No implementation - assignment is unsupported.266 void operator=(const Iterator& other);267 268 const ParamGeneratorInterface<T>* const base_;269 T value_;270 int index_;271 const IncrementT step_;272 }; // class RangeGenerator::Iterator273 274 static int CalculateEndIndex(const T& begin, const T& end,275 const IncrementT& step) {276 int end_index = 0;277 for (T i = begin; i < end; i = static_cast<T>(i + step)) end_index++;278 return end_index;279 }280 281 // No implementation - assignment is unsupported.282 void operator=(const RangeGenerator& other);283 284 const T begin_;285 const T end_;286 const IncrementT step_;287 // The index for the end() iterator. All the elements in the generated288 // sequence are indexed (0-based) to aid iterator comparison.289 const int end_index_;290}; // class RangeGenerator291 292// Generates values from a pair of STL-style iterators. Used in the293// ValuesIn() function. The elements are copied from the source range294// since the source can be located on the stack, and the generator295// is likely to persist beyond that stack frame.296template <typename T>297class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {298 public:299 template <typename ForwardIterator>300 ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)301 : container_(begin, end) {}302 ~ValuesInIteratorRangeGenerator() override = default;303 304 ParamIteratorInterface<T>* Begin() const override {305 return new Iterator(this, container_.begin());306 }307 ParamIteratorInterface<T>* End() const override {308 return new Iterator(this, container_.end());309 }310 311 private:312 typedef typename ::std::vector<T> ContainerType;313 314 class Iterator : public ParamIteratorInterface<T> {315 public:316 Iterator(const ParamGeneratorInterface<T>* base,317 typename ContainerType::const_iterator iterator)318 : base_(base), iterator_(iterator) {}319 ~Iterator() override = default;320 321 const ParamGeneratorInterface<T>* BaseGenerator() const override {322 return base_;323 }324 void Advance() override {325 ++iterator_;326 value_.reset();327 }328 ParamIteratorInterface<T>* Clone() const override {329 return new Iterator(*this);330 }331 // We need to use cached value referenced by iterator_ because *iterator_332 // can return a temporary object (and of type other then T), so just333 // having "return &*iterator_;" doesn't work.334 // value_ is updated here and not in Advance() because Advance()335 // can advance iterator_ beyond the end of the range, and we cannot336 // detect that fact. The client code, on the other hand, is337 // responsible for not calling Current() on an out-of-range iterator.338 const T* Current() const override {339 if (value_.get() == nullptr) value_.reset(new T(*iterator_));340 return value_.get();341 }342 bool Equals(const ParamIteratorInterface<T>& other) const override {343 // Having the same base generator guarantees that the other344 // iterator is of the same type and we can downcast.345 GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())346 << "The program attempted to compare iterators "347 << "from different generators." << std::endl;348 return iterator_ ==349 CheckedDowncastToActualType<const Iterator>(&other)->iterator_;350 }351 352 private:353 Iterator(const Iterator& other)354 // The explicit constructor call suppresses a false warning355 // emitted by gcc when supplied with the -Wextra option.356 : ParamIteratorInterface<T>(),357 base_(other.base_),358 iterator_(other.iterator_) {}359 360 const ParamGeneratorInterface<T>* const base_;361 typename ContainerType::const_iterator iterator_;362 // A cached value of *iterator_. We keep it here to allow access by363 // pointer in the wrapping iterator's operator->().364 // value_ needs to be mutable to be accessed in Current().365 // Use of std::unique_ptr helps manage cached value's lifetime,366 // which is bound by the lifespan of the iterator itself.367 mutable std::unique_ptr<const T> value_;368 }; // class ValuesInIteratorRangeGenerator::Iterator369 370 // No implementation - assignment is unsupported.371 void operator=(const ValuesInIteratorRangeGenerator& other);372 373 const ContainerType container_;374}; // class ValuesInIteratorRangeGenerator375 376// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.377//378// Default parameterized test name generator, returns a string containing the379// integer test parameter index.380template <class ParamType>381std::string DefaultParamName(const TestParamInfo<ParamType>& info) {382 Message name_stream;383 name_stream << info.index;384 return name_stream.GetString();385}386 387template <typename T = int>388void TestNotEmpty() {389 static_assert(sizeof(T) == 0, "Empty arguments are not allowed.");390}391template <typename T = int>392void TestNotEmpty(const T&) {}393 394// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.395//396// Stores a parameter value and later creates tests parameterized with that397// value.398template <class TestClass>399class ParameterizedTestFactory : public TestFactoryBase {400 public:401 typedef typename TestClass::ParamType ParamType;402 explicit ParameterizedTestFactory(ParamType parameter)403 : parameter_(parameter) {}404 Test* CreateTest() override {405 TestClass::SetParam(¶meter_);406 return new TestClass();407 }408 409 private:410 const ParamType parameter_;411 412 ParameterizedTestFactory(const ParameterizedTestFactory&) = delete;413 ParameterizedTestFactory& operator=(const ParameterizedTestFactory&) = delete;414};415 416// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.417//418// TestMetaFactoryBase is a base class for meta-factories that create419// test factories for passing into MakeAndRegisterTestInfo function.420template <class ParamType>421class TestMetaFactoryBase {422 public:423 virtual ~TestMetaFactoryBase() = default;424 425 virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0;426};427 428// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.429//430// TestMetaFactory creates test factories for passing into431// MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives432// ownership of test factory pointer, same factory object cannot be passed433// into that method twice. But ParameterizedTestSuiteInfo is going to call434// it for each Test/Parameter value combination. Thus it needs meta factory435// creator class.436template <class TestSuite>437class TestMetaFactory438 : public TestMetaFactoryBase<typename TestSuite::ParamType> {439 public:440 using ParamType = typename TestSuite::ParamType;441 442 TestMetaFactory() = default;443 444 TestFactoryBase* CreateTestFactory(ParamType parameter) override {445 return new ParameterizedTestFactory<TestSuite>(parameter);446 }447 448 private:449 TestMetaFactory(const TestMetaFactory&) = delete;450 TestMetaFactory& operator=(const TestMetaFactory&) = delete;451};452 453// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.454//455// ParameterizedTestSuiteInfoBase is a generic interface456// to ParameterizedTestSuiteInfo classes. ParameterizedTestSuiteInfoBase457// accumulates test information provided by TEST_P macro invocations458// and generators provided by INSTANTIATE_TEST_SUITE_P macro invocations459// and uses that information to register all resulting test instances460// in RegisterTests method. The ParameterizeTestSuiteRegistry class holds461// a collection of pointers to the ParameterizedTestSuiteInfo objects462// and calls RegisterTests() on each of them when asked.463class ParameterizedTestSuiteInfoBase {464 public:465 virtual ~ParameterizedTestSuiteInfoBase() = default;466 467 // Base part of test suite name for display purposes.468 virtual const std::string& GetTestSuiteName() const = 0;469 // Test suite id to verify identity.470 virtual TypeId GetTestSuiteTypeId() const = 0;471 // UnitTest class invokes this method to register tests in this472 // test suite right before running them in RUN_ALL_TESTS macro.473 // This method should not be called more than once on any single474 // instance of a ParameterizedTestSuiteInfoBase derived class.475 virtual void RegisterTests() = 0;476 477 protected:478 ParameterizedTestSuiteInfoBase() {}479 480 private:481 ParameterizedTestSuiteInfoBase(const ParameterizedTestSuiteInfoBase&) =482 delete;483 ParameterizedTestSuiteInfoBase& operator=(484 const ParameterizedTestSuiteInfoBase&) = delete;485};486 487// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.488//489// Report a the name of a test_suit as safe to ignore490// as the side effect of construction of this type.491struct GTEST_API_ MarkAsIgnored {492 explicit MarkAsIgnored(const char* test_suite);493};494 495GTEST_API_ void InsertSyntheticTestCase(const std::string& name,496 CodeLocation location, bool has_test_p);497 498// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.499//500// ParameterizedTestSuiteInfo accumulates tests obtained from TEST_P501// macro invocations for a particular test suite and generators502// obtained from INSTANTIATE_TEST_SUITE_P macro invocations for that503// test suite. It registers tests with all values generated by all504// generators when asked.505template <class TestSuite>506class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {507 public:508 // ParamType and GeneratorCreationFunc are private types but are required509 // for declarations of public methods AddTestPattern() and510 // AddTestSuiteInstantiation().511 using ParamType = typename TestSuite::ParamType;512 // A function that returns an instance of appropriate generator type.513 typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();514 using ParamNameGeneratorFunc = std::string(const TestParamInfo<ParamType>&);515 516 explicit ParameterizedTestSuiteInfo(const char* name,517 CodeLocation code_location)518 : test_suite_name_(name), code_location_(code_location) {}519 520 // Test suite base name for display purposes.521 const std::string& GetTestSuiteName() const override {522 return test_suite_name_;523 }524 // Test suite id to verify identity.525 TypeId GetTestSuiteTypeId() const override { return GetTypeId<TestSuite>(); }526 // TEST_P macro uses AddTestPattern() to record information527 // about a single test in a LocalTestInfo structure.528 // test_suite_name is the base name of the test suite (without invocation529 // prefix). test_base_name is the name of an individual test without530 // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is531 // test suite base name and DoBar is test base name.532 void AddTestPattern(const char* test_suite_name, const char* test_base_name,533 TestMetaFactoryBase<ParamType>* meta_factory,534 CodeLocation code_location) {535 tests_.push_back(std::shared_ptr<TestInfo>(new TestInfo(536 test_suite_name, test_base_name, meta_factory, code_location)));537 }538 // INSTANTIATE_TEST_SUITE_P macro uses AddGenerator() to record information539 // about a generator.540 int AddTestSuiteInstantiation(const std::string& instantiation_name,541 GeneratorCreationFunc* func,542 ParamNameGeneratorFunc* name_func,543 const char* file, int line) {544 instantiations_.push_back(545 InstantiationInfo(instantiation_name, func, name_func, file, line));546 return 0; // Return value used only to run this method in namespace scope.547 }548 // UnitTest class invokes this method to register tests in this test suite549 // right before running tests in RUN_ALL_TESTS macro.550 // This method should not be called more than once on any single551 // instance of a ParameterizedTestSuiteInfoBase derived class.552 // UnitTest has a guard to prevent from calling this method more than once.553 void RegisterTests() override {554 bool generated_instantiations = false;555 556 for (typename TestInfoContainer::iterator test_it = tests_.begin();557 test_it != tests_.end(); ++test_it) {558 std::shared_ptr<TestInfo> test_info = *test_it;559 for (typename InstantiationContainer::iterator gen_it =560 instantiations_.begin();561 gen_it != instantiations_.end(); ++gen_it) {562 const std::string& instantiation_name = gen_it->name;563 ParamGenerator<ParamType> generator((*gen_it->generator)());564 ParamNameGeneratorFunc* name_func = gen_it->name_func;565 const char* file = gen_it->file;566 int line = gen_it->line;567 568 std::string test_suite_name;569 if (!instantiation_name.empty())570 test_suite_name = instantiation_name + "/";571 test_suite_name += test_info->test_suite_base_name;572 573 size_t i = 0;574 std::set<std::string> test_param_names;575 for (typename ParamGenerator<ParamType>::iterator param_it =576 generator.begin();577 param_it != generator.end(); ++param_it, ++i) {578 generated_instantiations = true;579 580 Message test_name_stream;581 582 std::string param_name =583 name_func(TestParamInfo<ParamType>(*param_it, i));584 585 GTEST_CHECK_(IsValidParamName(param_name))586 << "Parameterized test name '" << param_name587 << "' is invalid, in " << file << " line " << line << std::endl;588 589 GTEST_CHECK_(test_param_names.count(param_name) == 0)590 << "Duplicate parameterized test name '" << param_name << "', in "591 << file << " line " << line << std::endl;592 593 test_param_names.insert(param_name);594 595 if (!test_info->test_base_name.empty()) {596 test_name_stream << test_info->test_base_name << "/";597 }598 test_name_stream << param_name;599 MakeAndRegisterTestInfo(600 test_suite_name.c_str(), test_name_stream.GetString().c_str(),601 nullptr, // No type parameter.602 PrintToString(*param_it).c_str(), test_info->code_location,603 GetTestSuiteTypeId(),604 SuiteApiResolver<TestSuite>::GetSetUpCaseOrSuite(file, line),605 SuiteApiResolver<TestSuite>::GetTearDownCaseOrSuite(file, line),606 test_info->test_meta_factory->CreateTestFactory(*param_it));607 } // for param_it608 } // for gen_it609 } // for test_it610 611 if (!generated_instantiations) {612 // There are no generaotrs, or they all generate nothing ...613 InsertSyntheticTestCase(GetTestSuiteName(), code_location_,614 !tests_.empty());615 }616 } // RegisterTests617 618 private:619 // LocalTestInfo structure keeps information about a single test registered620 // with TEST_P macro.621 struct TestInfo {622 TestInfo(const char* a_test_suite_base_name, const char* a_test_base_name,623 TestMetaFactoryBase<ParamType>* a_test_meta_factory,624 CodeLocation a_code_location)625 : test_suite_base_name(a_test_suite_base_name),626 test_base_name(a_test_base_name),627 test_meta_factory(a_test_meta_factory),628 code_location(a_code_location) {}629 630 const std::string test_suite_base_name;631 const std::string test_base_name;632 const std::unique_ptr<TestMetaFactoryBase<ParamType>> test_meta_factory;633 const CodeLocation code_location;634 };635 using TestInfoContainer = ::std::vector<std::shared_ptr<TestInfo>>;636 // Records data received from INSTANTIATE_TEST_SUITE_P macros:637 // <Instantiation name, Sequence generator creation function,638 // Name generator function, Source file, Source line>639 struct InstantiationInfo {640 InstantiationInfo(const std::string& name_in,641 GeneratorCreationFunc* generator_in,642 ParamNameGeneratorFunc* name_func_in, const char* file_in,643 int line_in)644 : name(name_in),645 generator(generator_in),646 name_func(name_func_in),647 file(file_in),648 line(line_in) {}649 650 std::string name;651 GeneratorCreationFunc* generator;652 ParamNameGeneratorFunc* name_func;653 const char* file;654 int line;655 };656 typedef ::std::vector<InstantiationInfo> InstantiationContainer;657 658 static bool IsValidParamName(const std::string& name) {659 // Check for empty string660 if (name.empty()) return false;661 662 // Check for invalid characters663 for (std::string::size_type index = 0; index < name.size(); ++index) {664 if (!IsAlNum(name[index]) && name[index] != '_') return false;665 }666 667 return true;668 }669 670 const std::string test_suite_name_;671 CodeLocation code_location_;672 TestInfoContainer tests_;673 InstantiationContainer instantiations_;674 675 ParameterizedTestSuiteInfo(const ParameterizedTestSuiteInfo&) = delete;676 ParameterizedTestSuiteInfo& operator=(const ParameterizedTestSuiteInfo&) =677 delete;678}; // class ParameterizedTestSuiteInfo679 680// Legacy API is deprecated but still available681#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_682template <class TestCase>683using ParameterizedTestCaseInfo = ParameterizedTestSuiteInfo<TestCase>;684#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_685 686// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.687//688// ParameterizedTestSuiteRegistry contains a map of689// ParameterizedTestSuiteInfoBase classes accessed by test suite names. TEST_P690// and INSTANTIATE_TEST_SUITE_P macros use it to locate their corresponding691// ParameterizedTestSuiteInfo descriptors.692class ParameterizedTestSuiteRegistry {693 public:694 ParameterizedTestSuiteRegistry() = default;695 ~ParameterizedTestSuiteRegistry() {696 for (auto& test_suite_info : test_suite_infos_) {697 delete test_suite_info;698 }699 }700 701 // Looks up or creates and returns a structure containing information about702 // tests and instantiations of a particular test suite.703 template <class TestSuite>704 ParameterizedTestSuiteInfo<TestSuite>* GetTestSuitePatternHolder(705 const char* test_suite_name, CodeLocation code_location) {706 ParameterizedTestSuiteInfo<TestSuite>* typed_test_info = nullptr;707 for (auto& test_suite_info : test_suite_infos_) {708 if (test_suite_info->GetTestSuiteName() == test_suite_name) {709 if (test_suite_info->GetTestSuiteTypeId() != GetTypeId<TestSuite>()) {710 // Complain about incorrect usage of Google Test facilities711 // and terminate the program since we cannot guaranty correct712 // test suite setup and tear-down in this case.713 ReportInvalidTestSuiteType(test_suite_name, code_location);714 posix::Abort();715 } else {716 // At this point we are sure that the object we found is of the same717 // type we are looking for, so we downcast it to that type718 // without further checks.719 typed_test_info = CheckedDowncastToActualType<720 ParameterizedTestSuiteInfo<TestSuite>>(test_suite_info);721 }722 break;723 }724 }725 if (typed_test_info == nullptr) {726 typed_test_info = new ParameterizedTestSuiteInfo<TestSuite>(727 test_suite_name, code_location);728 test_suite_infos_.push_back(typed_test_info);729 }730 return typed_test_info;731 }732 void RegisterTests() {733 for (auto& test_suite_info : test_suite_infos_) {734 test_suite_info->RegisterTests();735 }736 }737// Legacy API is deprecated but still available738#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_739 template <class TestCase>740 ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(741 const char* test_case_name, CodeLocation code_location) {742 return GetTestSuitePatternHolder<TestCase>(test_case_name, code_location);743 }744 745#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_746 747 private:748 using TestSuiteInfoContainer = ::std::vector<ParameterizedTestSuiteInfoBase*>;749 750 TestSuiteInfoContainer test_suite_infos_;751 752 ParameterizedTestSuiteRegistry(const ParameterizedTestSuiteRegistry&) =753 delete;754 ParameterizedTestSuiteRegistry& operator=(755 const ParameterizedTestSuiteRegistry&) = delete;756};757 758// Keep track of what type-parameterized test suite are defined and759// where as well as which are intatiated. This allows susequently760// identifying suits that are defined but never used.761class TypeParameterizedTestSuiteRegistry {762 public:763 // Add a suite definition764 void RegisterTestSuite(const char* test_suite_name,765 CodeLocation code_location);766 767 // Add an instantiation of a suit.768 void RegisterInstantiation(const char* test_suite_name);769 770 // For each suit repored as defined but not reported as instantiation,771 // emit a test that reports that fact (configurably, as an error).772 void CheckForInstantiations();773 774 private:775 struct TypeParameterizedTestSuiteInfo {776 explicit TypeParameterizedTestSuiteInfo(CodeLocation c)777 : code_location(c), instantiated(false) {}778 779 CodeLocation code_location;780 bool instantiated;781 };782 783 std::map<std::string, TypeParameterizedTestSuiteInfo> suites_;784};785 786} // namespace internal787 788// Forward declarations of ValuesIn(), which is implemented in789// include/gtest/gtest-param-test.h.790template <class Container>791internal::ParamGenerator<typename Container::value_type> ValuesIn(792 const Container& container);793 794namespace internal {795// Used in the Values() function to provide polymorphic capabilities.796 797GTEST_DISABLE_MSC_WARNINGS_PUSH_(4100)798 799template <typename... Ts>800class ValueArray {801 public:802 explicit ValueArray(Ts... v) : v_(FlatTupleConstructTag{}, std::move(v)...) {}803 804 template <typename T>805 operator ParamGenerator<T>() const { // NOLINT806 return ValuesIn(MakeVector<T>(MakeIndexSequence<sizeof...(Ts)>()));807 }808 809 private:810 template <typename T, size_t... I>811 std::vector<T> MakeVector(IndexSequence<I...>) const {812 return std::vector<T>{static_cast<T>(v_.template Get<I>())...};813 }814 815 FlatTuple<Ts...> v_;816};817 818GTEST_DISABLE_MSC_WARNINGS_POP_() // 4100819 820template <typename... T>821class CartesianProductGenerator822 : public ParamGeneratorInterface<::std::tuple<T...>> {823 public:824 typedef ::std::tuple<T...> ParamType;825 826 CartesianProductGenerator(const std::tuple<ParamGenerator<T>...>& g)827 : generators_(g) {}828 ~CartesianProductGenerator() override = default;829 830 ParamIteratorInterface<ParamType>* Begin() const override {831 return new Iterator(this, generators_, false);832 }833 ParamIteratorInterface<ParamType>* End() const override {834 return new Iterator(this, generators_, true);835 }836 837 private:838 template <class I>839 class IteratorImpl;840 template <size_t... I>841 class IteratorImpl<IndexSequence<I...>>842 : public ParamIteratorInterface<ParamType> {843 public:844 IteratorImpl(const ParamGeneratorInterface<ParamType>* base,845 const std::tuple<ParamGenerator<T>...>& generators,846 bool is_end)847 : base_(base),848 begin_(std::get<I>(generators).begin()...),849 end_(std::get<I>(generators).end()...),850 current_(is_end ? end_ : begin_) {851 ComputeCurrentValue();852 }853 ~IteratorImpl() override = default;854 855 const ParamGeneratorInterface<ParamType>* BaseGenerator() const override {856 return base_;857 }858 // Advance should not be called on beyond-of-range iterators859 // so no component iterators must be beyond end of range, either.860 void Advance() override {861 assert(!AtEnd());862 // Advance the last iterator.863 ++std::get<sizeof...(T) - 1>(current_);864 // if that reaches end, propagate that up.865 AdvanceIfEnd<sizeof...(T) - 1>();866 ComputeCurrentValue();867 }868 ParamIteratorInterface<ParamType>* Clone() const override {869 return new IteratorImpl(*this);870 }871 872 const ParamType* Current() const override { return current_value_.get(); }873 874 bool Equals(const ParamIteratorInterface<ParamType>& other) const override {875 // Having the same base generator guarantees that the other876 // iterator is of the same type and we can downcast.877 GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())878 << "The program attempted to compare iterators "879 << "from different generators." << std::endl;880 const IteratorImpl* typed_other =881 CheckedDowncastToActualType<const IteratorImpl>(&other);882 883 // We must report iterators equal if they both point beyond their884 // respective ranges. That can happen in a variety of fashions,885 // so we have to consult AtEnd().886 if (AtEnd() && typed_other->AtEnd()) return true;887 888 bool same = true;889 bool dummy[] = {890 (same = same && std::get<I>(current_) ==891 std::get<I>(typed_other->current_))...};892 (void)dummy;893 return same;894 }895 896 private:897 template <size_t ThisI>898 void AdvanceIfEnd() {899 if (std::get<ThisI>(current_) != std::get<ThisI>(end_)) return;900 901 bool last = ThisI == 0;902 if (last) {903 // We are done. Nothing else to propagate.904 return;905 }906 907 constexpr size_t NextI = ThisI - (ThisI != 0);908 std::get<ThisI>(current_) = std::get<ThisI>(begin_);909 ++std::get<NextI>(current_);910 AdvanceIfEnd<NextI>();911 }912 913 void ComputeCurrentValue() {914 if (!AtEnd())915 current_value_ = std::make_shared<ParamType>(*std::get<I>(current_)...);916 }917 bool AtEnd() const {918 bool at_end = false;919 bool dummy[] = {920 (at_end = at_end || std::get<I>(current_) == std::get<I>(end_))...};921 (void)dummy;922 return at_end;923 }924 925 const ParamGeneratorInterface<ParamType>* const base_;926 std::tuple<typename ParamGenerator<T>::iterator...> begin_;927 std::tuple<typename ParamGenerator<T>::iterator...> end_;928 std::tuple<typename ParamGenerator<T>::iterator...> current_;929 std::shared_ptr<ParamType> current_value_;930 };931 932 using Iterator = IteratorImpl<typename MakeIndexSequence<sizeof...(T)>::type>;933 934 std::tuple<ParamGenerator<T>...> generators_;935};936 937template <class... Gen>938class CartesianProductHolder {939 public:940 CartesianProductHolder(const Gen&... g) : generators_(g...) {}941 template <typename... T>942 operator ParamGenerator<::std::tuple<T...>>() const {943 return ParamGenerator<::std::tuple<T...>>(944 new CartesianProductGenerator<T...>(generators_));945 }946 947 private:948 std::tuple<Gen...> generators_;949};950 951template <typename From, typename To>952class ParamGeneratorConverter : public ParamGeneratorInterface<To> {953 public:954 ParamGeneratorConverter(ParamGenerator<From> gen) // NOLINT955 : generator_(std::move(gen)) {}956 957 ParamIteratorInterface<To>* Begin() const override {958 return new Iterator(this, generator_.begin(), generator_.end());959 }960 ParamIteratorInterface<To>* End() const override {961 return new Iterator(this, generator_.end(), generator_.end());962 }963 964 private:965 class Iterator : public ParamIteratorInterface<To> {966 public:967 Iterator(const ParamGeneratorInterface<To>* base, ParamIterator<From> it,968 ParamIterator<From> end)969 : base_(base), it_(it), end_(end) {970 if (it_ != end_) value_ = std::make_shared<To>(static_cast<To>(*it_));971 }972 ~Iterator() override = default;973 974 const ParamGeneratorInterface<To>* BaseGenerator() const override {975 return base_;976 }977 void Advance() override {978 ++it_;979 if (it_ != end_) value_ = std::make_shared<To>(static_cast<To>(*it_));980 }981 ParamIteratorInterface<To>* Clone() const override {982 return new Iterator(*this);983 }984 const To* Current() const override { return value_.get(); }985 bool Equals(const ParamIteratorInterface<To>& other) const override {986 // Having the same base generator guarantees that the other987 // iterator is of the same type and we can downcast.988 GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())989 << "The program attempted to compare iterators "990 << "from different generators." << std::endl;991 const ParamIterator<From> other_it =992 CheckedDowncastToActualType<const Iterator>(&other)->it_;993 return it_ == other_it;994 }995 996 private:997 Iterator(const Iterator& other) = default;998 999 const ParamGeneratorInterface<To>* const base_;1000 ParamIterator<From> it_;1001 ParamIterator<From> end_;1002 std::shared_ptr<To> value_;1003 }; // class ParamGeneratorConverter::Iterator1004 1005 ParamGenerator<From> generator_;1006}; // class ParamGeneratorConverter1007 1008template <class Gen>1009class ParamConverterGenerator {1010 public:1011 ParamConverterGenerator(ParamGenerator<Gen> g) // NOLINT1012 : generator_(std::move(g)) {}1013 1014 template <typename T>1015 operator ParamGenerator<T>() const { // NOLINT1016 return ParamGenerator<T>(new ParamGeneratorConverter<Gen, T>(generator_));1017 }1018 1019 private:1020 ParamGenerator<Gen> generator_;1021};1022 1023} // namespace internal1024} // namespace testing1025 1026#endif // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_1027