1 // Copyright 2008 Google Inc. 2 // All Rights Reserved. 3 // 4 // Redistribution and use in source and binary forms, with or without 5 // modification, are permitted provided that the following conditions are 6 // met: 7 // 8 // * Redistributions of source code must retain the above copyright 9 // notice, this list of conditions and the following disclaimer. 10 // * Redistributions in binary form must reproduce the above 11 // copyright notice, this list of conditions and the following disclaimer 12 // in the documentation and/or other materials provided with the 13 // distribution. 14 // * Neither the name of Google Inc. nor the names of its 15 // contributors may be used to endorse or promote products derived from 16 // this software without specific prior written permission. 17 // 18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 // 30 // Author: vladl (at) google.com (Vlad Losev) 31 32 // Type and function utilities for implementing parameterized tests. 33 34 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ 35 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ 36 37 #include <iterator> 38 #include <utility> 39 #include <vector> 40 41 // scripts/fuse_gtest.py depends on gtest's own header being #included 42 // *unconditionally*. Therefore these #includes cannot be moved 43 // inside #if GTEST_HAS_PARAM_TEST. 44 #include "gtest/internal/gtest-internal.h" 45 #include "gtest/internal/gtest-linked_ptr.h" 46 #include "gtest/internal/gtest-port.h" 47 #include "gtest/gtest-printers.h" 48 49 #if GTEST_HAS_PARAM_TEST 50 51 namespace testing { 52 namespace internal { 53 54 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. 55 // 56 // Outputs a message explaining invalid registration of different 57 // fixture class for the same test case. This may happen when 58 // TEST_P macro is used to define two tests with the same name 59 // but in different namespaces. 60 GTEST_API_ void ReportInvalidTestCaseType(const char* test_case_name, 61 const char* file, int line); 62 63 template <typename> class ParamGeneratorInterface; 64 template <typename> class ParamGenerator; 65 66 // Interface for iterating over elements provided by an implementation 67 // of ParamGeneratorInterface<T>. 68 template <typename T> 69 class ParamIteratorInterface { 70 public: 71 virtual ~ParamIteratorInterface() {} 72 // A pointer to the base generator instance. 73 // Used only for the purposes of iterator comparison 74 // to make sure that two iterators belong to the same generator. 75 virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0; 76 // Advances iterator to point to the next element 77 // provided by the generator. The caller is responsible 78 // for not calling Advance() on an iterator equal to 79 // BaseGenerator()->End(). 80 virtual void Advance() = 0; 81 // Clones the iterator object. Used for implementing copy semantics 82 // of ParamIterator<T>. 83 virtual ParamIteratorInterface* Clone() const = 0; 84 // Dereferences the current iterator and provides (read-only) access 85 // to the pointed value. It is the caller's responsibility not to call 86 // Current() on an iterator equal to BaseGenerator()->End(). 87 // Used for implementing ParamGenerator<T>::operator*(). 88 virtual const T* Current() const = 0; 89 // Determines whether the given iterator and other point to the same 90 // element in the sequence generated by the generator. 91 // Used for implementing ParamGenerator<T>::operator==(). 92 virtual bool Equals(const ParamIteratorInterface& other) const = 0; 93 }; 94 95 // Class iterating over elements provided by an implementation of 96 // ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T> 97 // and implements the const forward iterator concept. 98 template <typename T> 99 class ParamIterator { 100 public: 101 typedef T value_type; 102 typedef const T& reference; 103 typedef ptrdiff_t difference_type; 104 105 // ParamIterator assumes ownership of the impl_ pointer. 106 ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {} 107 ParamIterator& operator=(const ParamIterator& other) { 108 if (this != &other) 109 impl_.reset(other.impl_->Clone()); 110 return *this; 111 } 112 113 const T& operator*() const { return *impl_->Current(); } 114 const T* operator->() const { return impl_->Current(); } 115 // Prefix version of operator++. 116 ParamIterator& operator++() { 117 impl_->Advance(); 118 return *this; 119 } 120 // Postfix version of operator++. 121 ParamIterator operator++(int /*unused*/) { 122 ParamIteratorInterface<T>* clone = impl_->Clone(); 123 impl_->Advance(); 124 return ParamIterator(clone); 125 } 126 bool operator==(const ParamIterator& other) const { 127 return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_); 128 } 129 bool operator!=(const ParamIterator& other) const { 130 return !(*this == other); 131 } 132 133 private: 134 friend class ParamGenerator<T>; 135 explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {} 136 scoped_ptr<ParamIteratorInterface<T> > impl_; 137 }; 138 139 // ParamGeneratorInterface<T> is the binary interface to access generators 140 // defined in other translation units. 141 template <typename T> 142 class ParamGeneratorInterface { 143 public: 144 typedef T ParamType; 145 146 virtual ~ParamGeneratorInterface() {} 147 148 // Generator interface definition 149 virtual ParamIteratorInterface<T>* Begin() const = 0; 150 virtual ParamIteratorInterface<T>* End() const = 0; 151 }; 152 153 // Wraps ParamGeneratorInterface<T> and provides general generator syntax 154 // compatible with the STL Container concept. 155 // This class implements copy initialization semantics and the contained 156 // ParamGeneratorInterface<T> instance is shared among all copies 157 // of the original object. This is possible because that instance is immutable. 158 template<typename T> 159 class ParamGenerator { 160 public: 161 typedef ParamIterator<T> iterator; 162 163 explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {} 164 ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {} 165 166 ParamGenerator& operator=(const ParamGenerator& other) { 167 impl_ = other.impl_; 168 return *this; 169 } 170 171 iterator begin() const { return iterator(impl_->Begin()); } 172 iterator end() const { return iterator(impl_->End()); } 173 174 private: 175 linked_ptr<const ParamGeneratorInterface<T> > impl_; 176 }; 177 178 // Generates values from a range of two comparable values. Can be used to 179 // generate sequences of user-defined types that implement operator+() and 180 // operator<(). 181 // This class is used in the Range() function. 182 template <typename T, typename IncrementT> 183 class RangeGenerator : public ParamGeneratorInterface<T> { 184 public: 185 RangeGenerator(T begin, T end, IncrementT step) 186 : begin_(begin), end_(end), 187 step_(step), end_index_(CalculateEndIndex(begin, end, step)) {} 188 virtual ~RangeGenerator() {} 189 190 virtual ParamIteratorInterface<T>* Begin() const { 191 return new Iterator(this, begin_, 0, step_); 192 } 193 virtual ParamIteratorInterface<T>* End() const { 194 return new Iterator(this, end_, end_index_, step_); 195 } 196 197 private: 198 class Iterator : public ParamIteratorInterface<T> { 199 public: 200 Iterator(const ParamGeneratorInterface<T>* base, T value, int index, 201 IncrementT step) 202 : base_(base), value_(value), index_(index), step_(step) {} 203 virtual ~Iterator() {} 204 205 virtual const ParamGeneratorInterface<T>* BaseGenerator() const { 206 return base_; 207 } 208 virtual void Advance() { 209 value_ = value_ + step_; 210 index_++; 211 } 212 virtual ParamIteratorInterface<T>* Clone() const { 213 return new Iterator(*this); 214 } 215 virtual const T* Current() const { return &value_; } 216 virtual bool Equals(const ParamIteratorInterface<T>& other) const { 217 // Having the same base generator guarantees that the other 218 // iterator is of the same type and we can downcast. 219 GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) 220 << "The program attempted to compare iterators " 221 << "from different generators." << std::endl; 222 const int other_index = 223 CheckedDowncastToActualType<const Iterator>(&other)->index_; 224 return index_ == other_index; 225 } 226 227 private: 228 Iterator(const Iterator& other) 229 : ParamIteratorInterface<T>(), 230 base_(other.base_), value_(other.value_), index_(other.index_), 231 step_(other.step_) {} 232 233 // No implementation - assignment is unsupported. 234 void operator=(const Iterator& other); 235 236 const ParamGeneratorInterface<T>* const base_; 237 T value_; 238 int index_; 239 const IncrementT step_; 240 }; // class RangeGenerator::Iterator 241 242 static int CalculateEndIndex(const T& begin, 243 const T& end, 244 const IncrementT& step) { 245 int end_index = 0; 246 for (T i = begin; i < end; i = i + step) 247 end_index++; 248 return end_index; 249 } 250 251 // No implementation - assignment is unsupported. 252 void operator=(const RangeGenerator& other); 253 254 const T begin_; 255 const T end_; 256 const IncrementT step_; 257 // The index for the end() iterator. All the elements in the generated 258 // sequence are indexed (0-based) to aid iterator comparison. 259 const int end_index_; 260 }; // class RangeGenerator 261 262 263 // Generates values from a pair of STL-style iterators. Used in the 264 // ValuesIn() function. The elements are copied from the source range 265 // since the source can be located on the stack, and the generator 266 // is likely to persist beyond that stack frame. 267 template <typename T> 268 class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> { 269 public: 270 template <typename ForwardIterator> 271 ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end) 272 : container_(begin, end) {} 273 virtual ~ValuesInIteratorRangeGenerator() {} 274 275 virtual ParamIteratorInterface<T>* Begin() const { 276 return new Iterator(this, container_.begin()); 277 } 278 virtual ParamIteratorInterface<T>* End() const { 279 return new Iterator(this, container_.end()); 280 } 281 282 private: 283 typedef typename ::std::vector<T> ContainerType; 284 285 class Iterator : public ParamIteratorInterface<T> { 286 public: 287 Iterator(const ParamGeneratorInterface<T>* base, 288 typename ContainerType::const_iterator iterator) 289 : base_(base), iterator_(iterator) {} 290 virtual ~Iterator() {} 291 292 virtual const ParamGeneratorInterface<T>* BaseGenerator() const { 293 return base_; 294 } 295 virtual void Advance() { 296 ++iterator_; 297 value_.reset(); 298 } 299 virtual ParamIteratorInterface<T>* Clone() const { 300 return new Iterator(*this); 301 } 302 // We need to use cached value referenced by iterator_ because *iterator_ 303 // can return a temporary object (and of type other then T), so just 304 // having "return &*iterator_;" doesn't work. 305 // value_ is updated here and not in Advance() because Advance() 306 // can advance iterator_ beyond the end of the range, and we cannot 307 // detect that fact. The client code, on the other hand, is 308 // responsible for not calling Current() on an out-of-range iterator. 309 virtual const T* Current() const { 310 if (value_.get() == NULL) 311 value_.reset(new T(*iterator_)); 312 return value_.get(); 313 } 314 virtual bool Equals(const ParamIteratorInterface<T>& other) const { 315 // Having the same base generator guarantees that the other 316 // iterator is of the same type and we can downcast. 317 GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) 318 << "The program attempted to compare iterators " 319 << "from different generators." << std::endl; 320 return iterator_ == 321 CheckedDowncastToActualType<const Iterator>(&other)->iterator_; 322 } 323 324 private: 325 Iterator(const Iterator& other) 326 // The explicit constructor call suppresses a false warning 327 // emitted by gcc when supplied with the -Wextra option. 328 : ParamIteratorInterface<T>(), 329 base_(other.base_), 330 iterator_(other.iterator_) {} 331 332 const ParamGeneratorInterface<T>* const base_; 333 typename ContainerType::const_iterator iterator_; 334 // A cached value of *iterator_. We keep it here to allow access by 335 // pointer in the wrapping iterator's operator->(). 336 // value_ needs to be mutable to be accessed in Current(). 337 // Use of scoped_ptr helps manage cached value's lifetime, 338 // which is bound by the lifespan of the iterator itself. 339 mutable scoped_ptr<const T> value_; 340 }; // class ValuesInIteratorRangeGenerator::Iterator 341 342 // No implementation - assignment is unsupported. 343 void operator=(const ValuesInIteratorRangeGenerator& other); 344 345 const ContainerType container_; 346 }; // class ValuesInIteratorRangeGenerator 347 348 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. 349 // 350 // Stores a parameter value and later creates tests parameterized with that 351 // value. 352 template <class TestClass> 353 class ParameterizedTestFactory : public TestFactoryBase { 354 public: 355 typedef typename TestClass::ParamType ParamType; 356 explicit ParameterizedTestFactory(ParamType parameter) : 357 parameter_(parameter) {} 358 virtual Test* CreateTest() { 359 TestClass::SetParam(¶meter_); 360 return new TestClass(); 361 } 362 363 private: 364 const ParamType parameter_; 365 366 GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory); 367 }; 368 369 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. 370 // 371 // TestMetaFactoryBase is a base class for meta-factories that create 372 // test factories for passing into MakeAndRegisterTestInfo function. 373 template <class ParamType> 374 class TestMetaFactoryBase { 375 public: 376 virtual ~TestMetaFactoryBase() {} 377 378 virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0; 379 }; 380 381 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. 382 // 383 // TestMetaFactory creates test factories for passing into 384 // MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives 385 // ownership of test factory pointer, same factory object cannot be passed 386 // into that method twice. But ParameterizedTestCaseInfo is going to call 387 // it for each Test/Parameter value combination. Thus it needs meta factory 388 // creator class. 389 template <class TestCase> 390 class TestMetaFactory 391 : public TestMetaFactoryBase<typename TestCase::ParamType> { 392 public: 393 typedef typename TestCase::ParamType ParamType; 394 395 TestMetaFactory() {} 396 397 virtual TestFactoryBase* CreateTestFactory(ParamType parameter) { 398 return new ParameterizedTestFactory<TestCase>(parameter); 399 } 400 401 private: 402 GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory); 403 }; 404 405 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. 406 // 407 // ParameterizedTestCaseInfoBase is a generic interface 408 // to ParameterizedTestCaseInfo classes. ParameterizedTestCaseInfoBase 409 // accumulates test information provided by TEST_P macro invocations 410 // and generators provided by INSTANTIATE_TEST_CASE_P macro invocations 411 // and uses that information to register all resulting test instances 412 // in RegisterTests method. The ParameterizeTestCaseRegistry class holds 413 // a collection of pointers to the ParameterizedTestCaseInfo objects 414 // and calls RegisterTests() on each of them when asked. 415 class ParameterizedTestCaseInfoBase { 416 public: 417 virtual ~ParameterizedTestCaseInfoBase(); 418 419 // Base part of test case name for display purposes. 420 virtual const string& GetTestCaseName() const = 0; 421 // Test case id to verify identity. 422 virtual TypeId GetTestCaseTypeId() const = 0; 423 // UnitTest class invokes this method to register tests in this 424 // test case right before running them in RUN_ALL_TESTS macro. 425 // This method should not be called more then once on any single 426 // instance of a ParameterizedTestCaseInfoBase derived class. 427 virtual void RegisterTests() = 0; 428 429 protected: 430 ParameterizedTestCaseInfoBase() {} 431 432 private: 433 GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfoBase); 434 }; 435 436 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. 437 // 438 // ParameterizedTestCaseInfo accumulates tests obtained from TEST_P 439 // macro invocations for a particular test case and generators 440 // obtained from INSTANTIATE_TEST_CASE_P macro invocations for that 441 // test case. It registers tests with all values generated by all 442 // generators when asked. 443 template <class TestCase> 444 class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase { 445 public: 446 // ParamType and GeneratorCreationFunc are private types but are required 447 // for declarations of public methods AddTestPattern() and 448 // AddTestCaseInstantiation(). 449 typedef typename TestCase::ParamType ParamType; 450 // A function that returns an instance of appropriate generator type. 451 typedef ParamGenerator<ParamType>(GeneratorCreationFunc)(); 452 453 explicit ParameterizedTestCaseInfo(const char* name) 454 : test_case_name_(name) {} 455 456 // Test case base name for display purposes. 457 virtual const string& GetTestCaseName() const { return test_case_name_; } 458 // Test case id to verify identity. 459 virtual TypeId GetTestCaseTypeId() const { return GetTypeId<TestCase>(); } 460 // TEST_P macro uses AddTestPattern() to record information 461 // about a single test in a LocalTestInfo structure. 462 // test_case_name is the base name of the test case (without invocation 463 // prefix). test_base_name is the name of an individual test without 464 // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is 465 // test case base name and DoBar is test base name. 466 void AddTestPattern(const char* test_case_name, 467 const char* test_base_name, 468 TestMetaFactoryBase<ParamType>* meta_factory) { 469 tests_.push_back(linked_ptr<TestInfo>(new TestInfo(test_case_name, 470 test_base_name, 471 meta_factory))); 472 } 473 // INSTANTIATE_TEST_CASE_P macro uses AddGenerator() to record information 474 // about a generator. 475 int AddTestCaseInstantiation(const string& instantiation_name, 476 GeneratorCreationFunc* func, 477 const char* /* file */, 478 int /* line */) { 479 instantiations_.push_back(::std::make_pair(instantiation_name, func)); 480 return 0; // Return value used only to run this method in namespace scope. 481 } 482 // UnitTest class invokes this method to register tests in this test case 483 // test cases right before running tests in RUN_ALL_TESTS macro. 484 // This method should not be called more then once on any single 485 // instance of a ParameterizedTestCaseInfoBase derived class. 486 // UnitTest has a guard to prevent from calling this method more then once. 487 virtual void RegisterTests() { 488 for (typename TestInfoContainer::iterator test_it = tests_.begin(); 489 test_it != tests_.end(); ++test_it) { 490 linked_ptr<TestInfo> test_info = *test_it; 491 for (typename InstantiationContainer::iterator gen_it = 492 instantiations_.begin(); gen_it != instantiations_.end(); 493 ++gen_it) { 494 const string& instantiation_name = gen_it->first; 495 ParamGenerator<ParamType> generator((*gen_it->second)()); 496 497 Message test_case_name_stream; 498 if ( !instantiation_name.empty() ) 499 test_case_name_stream << instantiation_name << "/"; 500 test_case_name_stream << test_info->test_case_base_name; 501 502 int i = 0; 503 for (typename ParamGenerator<ParamType>::iterator param_it = 504 generator.begin(); 505 param_it != generator.end(); ++param_it, ++i) { 506 Message test_name_stream; 507 test_name_stream << test_info->test_base_name << "/" << i; 508 MakeAndRegisterTestInfo( 509 test_case_name_stream.GetString().c_str(), 510 test_name_stream.GetString().c_str(), 511 NULL, // No type parameter. 512 PrintToString(*param_it).c_str(), 513 GetTestCaseTypeId(), 514 TestCase::SetUpTestCase, 515 TestCase::TearDownTestCase, 516 test_info->test_meta_factory->CreateTestFactory(*param_it)); 517 } // for param_it 518 } // for gen_it 519 } // for test_it 520 } // RegisterTests 521 522 private: 523 // LocalTestInfo structure keeps information about a single test registered 524 // with TEST_P macro. 525 struct TestInfo { 526 TestInfo(const char* a_test_case_base_name, 527 const char* a_test_base_name, 528 TestMetaFactoryBase<ParamType>* a_test_meta_factory) : 529 test_case_base_name(a_test_case_base_name), 530 test_base_name(a_test_base_name), 531 test_meta_factory(a_test_meta_factory) {} 532 533 const string test_case_base_name; 534 const string test_base_name; 535 const scoped_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory; 536 }; 537 typedef ::std::vector<linked_ptr<TestInfo> > TestInfoContainer; 538 // Keeps pairs of <Instantiation name, Sequence generator creation function> 539 // received from INSTANTIATE_TEST_CASE_P macros. 540 typedef ::std::vector<std::pair<string, GeneratorCreationFunc*> > 541 InstantiationContainer; 542 543 const string test_case_name_; 544 TestInfoContainer tests_; 545 InstantiationContainer instantiations_; 546 547 GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfo); 548 }; // class ParameterizedTestCaseInfo 549 550 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. 551 // 552 // ParameterizedTestCaseRegistry contains a map of ParameterizedTestCaseInfoBase 553 // classes accessed by test case names. TEST_P and INSTANTIATE_TEST_CASE_P 554 // macros use it to locate their corresponding ParameterizedTestCaseInfo 555 // descriptors. 556 class ParameterizedTestCaseRegistry { 557 public: 558 ParameterizedTestCaseRegistry() {} 559 ~ParameterizedTestCaseRegistry() { 560 for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); 561 it != test_case_infos_.end(); ++it) { 562 delete *it; 563 } 564 } 565 566 // Looks up or creates and returns a structure containing information about 567 // tests and instantiations of a particular test case. 568 template <class TestCase> 569 ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder( 570 const char* test_case_name, 571 const char* file, 572 int line) { 573 ParameterizedTestCaseInfo<TestCase>* typed_test_info = NULL; 574 for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); 575 it != test_case_infos_.end(); ++it) { 576 if ((*it)->GetTestCaseName() == test_case_name) { 577 if ((*it)->GetTestCaseTypeId() != GetTypeId<TestCase>()) { 578 // Complain about incorrect usage of Google Test facilities 579 // and terminate the program since we cannot guaranty correct 580 // test case setup and tear-down in this case. 581 ReportInvalidTestCaseType(test_case_name, file, line); 582 posix::Abort(); 583 } else { 584 // At this point we are sure that the object we found is of the same 585 // type we are looking for, so we downcast it to that type 586 // without further checks. 587 typed_test_info = CheckedDowncastToActualType< 588 ParameterizedTestCaseInfo<TestCase> >(*it); 589 } 590 break; 591 } 592 } 593 if (typed_test_info == NULL) { 594 typed_test_info = new ParameterizedTestCaseInfo<TestCase>(test_case_name); 595 test_case_infos_.push_back(typed_test_info); 596 } 597 return typed_test_info; 598 } 599 void RegisterTests() { 600 for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); 601 it != test_case_infos_.end(); ++it) { 602 (*it)->RegisterTests(); 603 } 604 } 605 606 private: 607 typedef ::std::vector<ParameterizedTestCaseInfoBase*> TestCaseInfoContainer; 608 609 TestCaseInfoContainer test_case_infos_; 610 611 GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseRegistry); 612 }; 613 614 } // namespace internal 615 } // namespace testing 616 617 #endif // GTEST_HAS_PARAM_TEST 618 619 #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ 620