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@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 <ctype.h>
38
39#include <iterator>
40#include <set>
41#include <utility>
42#include <vector>
43
44// scripts/fuse_gtest.py depends on gtest's own header being #included
45// *unconditionally*. Therefore these #includes cannot be moved
46// inside #if GTEST_HAS_PARAM_TEST.
47#include "gtest/internal/gtest-internal.h"
48#include "gtest/internal/gtest-linked_ptr.h"
49#include "gtest/internal/gtest-port.h"
50#include "gtest/gtest-printers.h"
51
52#if GTEST_HAS_PARAM_TEST
53
54namespace testing {
55
56// Input to a parameterized test name generator, describing a test parameter.
57// Consists of the parameter value and the integer parameter index.
58template <class ParamType>
59struct TestParamInfo {
60 TestParamInfo(const ParamType& a_param, size_t an_index) :
61 param(a_param),
62 index(an_index) {}
63 ParamType param;
64 size_t index;
65};
66
67// A builtin parameterized test name generator which returns the result of
68// testing::PrintToString.
69struct PrintToStringParamName {
70 template <class ParamType>
71 std::string operator()(const TestParamInfo<ParamType>& info) const {
72 return PrintToString(info.param);
73 }
74};
75
76namespace internal {
77
78// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
79//
80// Outputs a message explaining invalid registration of different
81// fixture class for the same test case. This may happen when
82// TEST_P macro is used to define two tests with the same name
83// but in different namespaces.
84GTEST_API_ void ReportInvalidTestCaseType(const char* test_case_name,
85 CodeLocation code_location);
86
87template <typename> class ParamGeneratorInterface;
88template <typename> class ParamGenerator;
89
90// Interface for iterating over elements provided by an implementation
91// of ParamGeneratorInterface<T>.
92template <typename T>
93class ParamIteratorInterface {
94 public:
95 virtual ~ParamIteratorInterface() {}
96 // A pointer to the base generator instance.
97 // Used only for the purposes of iterator comparison
98 // to make sure that two iterators belong to the same generator.
99 virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0;
100 // Advances iterator to point to the next element
101 // provided by the generator. The caller is responsible
102 // for not calling Advance() on an iterator equal to
103 // BaseGenerator()->End().
104 virtual void Advance() = 0;
105 // Clones the iterator object. Used for implementing copy semantics
106 // of ParamIterator<T>.
107 virtual ParamIteratorInterface* Clone() const = 0;
108 // Dereferences the current iterator and provides (read-only) access
109 // to the pointed value. It is the caller's responsibility not to call
110 // Current() on an iterator equal to BaseGenerator()->End().
111 // Used for implementing ParamGenerator<T>::operator*().
112 virtual const T* Current() const = 0;
113 // Determines whether the given iterator and other point to the same
114 // element in the sequence generated by the generator.
115 // Used for implementing ParamGenerator<T>::operator==().
116 virtual bool Equals(const ParamIteratorInterface& other) const = 0;
117};
118
119// Class iterating over elements provided by an implementation of
120// ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T>
121// and implements the const forward iterator concept.
122template <typename T>
123class ParamIterator {
124 public:
125 typedef T value_type;
126 typedef const T& reference;
127 typedef ptrdiff_t difference_type;
128
129 // ParamIterator assumes ownership of the impl_ pointer.
130 ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {}
131 ParamIterator& operator=(const ParamIterator& other) {
132 if (this != &other)
133 impl_.reset(other.impl_->Clone());
134 return *this;
135 }
136
137 const T& operator*() const { return *impl_->Current(); }
138 const T* operator->() const { return impl_->Current(); }
139 // Prefix version of operator++.
140 ParamIterator& operator++() {
141 impl_->Advance();
142 return *this;
143 }
144 // Postfix version of operator++.
145 ParamIterator operator++(int /*unused*/) {
146 ParamIteratorInterface<T>* clone = impl_->Clone();
147 impl_->Advance();
148 return ParamIterator(clone);
149 }
150 bool operator==(const ParamIterator& other) const {
151 return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_);
152 }
153 bool operator!=(const ParamIterator& other) const {
154 return !(*this == other);
155 }
156
157 private:
158 friend class ParamGenerator<T>;
159 explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {}
160 scoped_ptr<ParamIteratorInterface<T> > impl_;
161};
162
163// ParamGeneratorInterface<T> is the binary interface to access generators
164// defined in other translation units.
165template <typename T>
166class ParamGeneratorInterface {
167 public:
168 typedef T ParamType;
169
170 virtual ~ParamGeneratorInterface() {}
171
172 // Generator interface definition
173 virtual ParamIteratorInterface<T>* Begin() const = 0;
174 virtual ParamIteratorInterface<T>* End() const = 0;
175};
176
177// Wraps ParamGeneratorInterface<T> and provides general generator syntax
178// compatible with the STL Container concept.
179// This class implements copy initialization semantics and the contained
180// ParamGeneratorInterface<T> instance is shared among all copies
181// of the original object. This is possible because that instance is immutable.
182template<typename T>
183class ParamGenerator {
184 public:
185 typedef ParamIterator<T> iterator;
186
187 explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {}
188 ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {}
189
190 ParamGenerator& operator=(const ParamGenerator& other) {
191 impl_ = other.impl_;
192 return *this;
193 }
194
195 iterator begin() const { return iterator(impl_->Begin()); }
196 iterator end() const { return iterator(impl_->End()); }
197
198 private:
199 linked_ptr<const ParamGeneratorInterface<T> > impl_;
200};
201
202// Generates values from a range of two comparable values. Can be used to
203// generate sequences of user-defined types that implement operator+() and
204// operator<().
205// This class is used in the Range() function.
206template <typename T, typename IncrementT>
207class RangeGenerator : public ParamGeneratorInterface<T> {
208 public:
209 RangeGenerator(T begin, T end, IncrementT step)
210 : begin_(begin), end_(end),
211 step_(step), end_index_(CalculateEndIndex(begin, end, step)) {}
212 virtual ~RangeGenerator() {}
213
214 virtual ParamIteratorInterface<T>* Begin() const {
215 return new Iterator(this, begin_, 0, step_);
216 }
217 virtual ParamIteratorInterface<T>* End() const {
218 return new Iterator(this, end_, end_index_, step_);
219 }
220
221 private:
222 class Iterator : public ParamIteratorInterface<T> {
223 public:
224 Iterator(const ParamGeneratorInterface<T>* base, T value, int index,
225 IncrementT step)
226 : base_(base), value_(value), index_(index), step_(step) {}
227 virtual ~Iterator() {}
228
229 virtual const ParamGeneratorInterface<T>* BaseGenerator() const {
230 return base_;
231 }
232 virtual void Advance() {
233 value_ = static_cast<T>(value_ + step_);
234 index_++;
235 }
236 virtual ParamIteratorInterface<T>* Clone() const {
237 return new Iterator(*this);
238 }
239 virtual const T* Current() const { return &value_; }
240 virtual bool Equals(const ParamIteratorInterface<T>& other) const {
241 // Having the same base generator guarantees that the other
242 // iterator is of the same type and we can downcast.
243 GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
244 << "The program attempted to compare iterators "
245 << "from different generators." << std::endl;
246 const int other_index =
247 CheckedDowncastToActualType<const Iterator>(&other)->index_;
248 return index_ == other_index;
249 }
250
251 private:
252 Iterator(const Iterator& other)
253 : ParamIteratorInterface<T>(),
254 base_(other.base_), value_(other.value_), index_(other.index_),
255 step_(other.step_) {}
256
257 // No implementation - assignment is unsupported.
258 void operator=(const Iterator& other);
259
260 const ParamGeneratorInterface<T>* const base_;
261 T value_;
262 int index_;
263 const IncrementT step_;
264 }; // class RangeGenerator::Iterator
265
266 static int CalculateEndIndex(const T& begin,
267 const T& end,
268 const IncrementT& step) {
269 int end_index = 0;
270 for (T i = begin; i < end; i = static_cast<T>(i + step))
271 end_index++;
272 return end_index;
273 }
274
275 // No implementation - assignment is unsupported.
276 void operator=(const RangeGenerator& other);
277
278 const T begin_;
279 const T end_;
280 const IncrementT step_;
281 // The index for the end() iterator. All the elements in the generated
282 // sequence are indexed (0-based) to aid iterator comparison.
283 const int end_index_;
284}; // class RangeGenerator
285
286
287// Generates values from a pair of STL-style iterators. Used in the
288// ValuesIn() function. The elements are copied from the source range
289// since the source can be located on the stack, and the generator
290// is likely to persist beyond that stack frame.
291template <typename T>
292class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
293 public:
294 template <typename ForwardIterator>
295 ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
296 : container_(begin, end) {}
297 virtual ~ValuesInIteratorRangeGenerator() {}
298
299 virtual ParamIteratorInterface<T>* Begin() const {
300 return new Iterator(this, container_.begin());
301 }
302 virtual ParamIteratorInterface<T>* End() const {
303 return new Iterator(this, container_.end());
304 }
305
306 private:
307 typedef typename ::std::vector<T> ContainerType;
308
309 class Iterator : public ParamIteratorInterface<T> {
310 public:
311 Iterator(const ParamGeneratorInterface<T>* base,
312 typename ContainerType::const_iterator iterator)
313 : base_(base), iterator_(iterator) {}
314 virtual ~Iterator() {}
315
316 virtual const ParamGeneratorInterface<T>* BaseGenerator() const {
317 return base_;
318 }
319 virtual void Advance() {
320 ++iterator_;
321 value_.reset();
322 }
323 virtual ParamIteratorInterface<T>* Clone() const {
324 return new Iterator(*this);
325 }
326 // We need to use cached value referenced by iterator_ because *iterator_
327 // can return a temporary object (and of type other then T), so just
328 // having "return &*iterator_;" doesn't work.
329 // value_ is updated here and not in Advance() because Advance()
330 // can advance iterator_ beyond the end of the range, and we cannot
331 // detect that fact. The client code, on the other hand, is
332 // responsible for not calling Current() on an out-of-range iterator.
333 virtual const T* Current() const {
334 if (value_.get() == NULL)
335 value_.reset(new T(*iterator_));
336 return value_.get();
337 }
338 virtual bool Equals(const ParamIteratorInterface<T>& other) const {
339 // Having the same base generator guarantees that the other
340 // iterator is of the same type and we can downcast.
341 GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
342 << "The program attempted to compare iterators "
343 << "from different generators." << std::endl;
344 return iterator_ ==
345 CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
346 }
347
348 private:
349 Iterator(const Iterator& other)
350 // The explicit constructor call suppresses a false warning
351 // emitted by gcc when supplied with the -Wextra option.
352 : ParamIteratorInterface<T>(),
353 base_(other.base_),
354 iterator_(other.iterator_) {}
355
356 const ParamGeneratorInterface<T>* const base_;
357 typename ContainerType::const_iterator iterator_;
358 // A cached value of *iterator_. We keep it here to allow access by
359 // pointer in the wrapping iterator's operator->().
360 // value_ needs to be mutable to be accessed in Current().
361 // Use of scoped_ptr helps manage cached value's lifetime,
362 // which is bound by the lifespan of the iterator itself.
363 mutable scoped_ptr<const T> value_;
364 }; // class ValuesInIteratorRangeGenerator::Iterator
365
366 // No implementation - assignment is unsupported.
367 void operator=(const ValuesInIteratorRangeGenerator& other);
368
369 const ContainerType container_;
370}; // class ValuesInIteratorRangeGenerator
371
372// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
373//
374// Default parameterized test name generator, returns a string containing the
375// integer test parameter index.
376template <class ParamType>
377std::string DefaultParamName(const TestParamInfo<ParamType>& info) {
378 Message name_stream;
379 name_stream << info.index;
380 return name_stream.GetString();
381}
382
383// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
384//
385// Parameterized test name overload helpers, which help the
386// INSTANTIATE_TEST_CASE_P macro choose between the default parameterized
387// test name generator and user param name generator.
388template <class ParamType, class ParamNameGenFunctor>
389ParamNameGenFunctor GetParamNameGen(ParamNameGenFunctor func) {
390 return func;
391}
392
393template <class ParamType>
394struct ParamNameGenFunc {
395 typedef std::string Type(const TestParamInfo<ParamType>&);
396};
397
398template <class ParamType>
399typename ParamNameGenFunc<ParamType>::Type *GetParamNameGen() {
400 return DefaultParamName;
401}
402
403// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
404//
405// Stores a parameter value and later creates tests parameterized with that
406// value.
407template <class TestClass>
408class ParameterizedTestFactory : public TestFactoryBase {
409 public:
410 typedef typename TestClass::ParamType ParamType;
411 explicit ParameterizedTestFactory(ParamType parameter) :
412 parameter_(parameter) {}
413 virtual Test* CreateTest() {
414 TestClass::SetParam(&parameter_);
415 return new TestClass();
416 }
417
418 private:
419 const ParamType parameter_;
420
421 GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory);
422};
423
424// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
425//
426// TestMetaFactoryBase is a base class for meta-factories that create
427// test factories for passing into MakeAndRegisterTestInfo function.
428template <class ParamType>
429class TestMetaFactoryBase {
430 public:
431 virtual ~TestMetaFactoryBase() {}
432
433 virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0;
434};
435
436// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
437//
438// TestMetaFactory creates test factories for passing into
439// MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives
440// ownership of test factory pointer, same factory object cannot be passed
441// into that method twice. But ParameterizedTestCaseInfo is going to call
442// it for each Test/Parameter value combination. Thus it needs meta factory
443// creator class.
444template <class TestCase>
445class TestMetaFactory
446 : public TestMetaFactoryBase<typename TestCase::ParamType> {
447 public:
448 typedef typename TestCase::ParamType ParamType;
449
450 TestMetaFactory() {}
451
452 virtual TestFactoryBase* CreateTestFactory(ParamType parameter) {
453 return new ParameterizedTestFactory<TestCase>(parameter);
454 }
455
456 private:
457 GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory);
458};
459
460// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
461//
462// ParameterizedTestCaseInfoBase is a generic interface
463// to ParameterizedTestCaseInfo classes. ParameterizedTestCaseInfoBase
464// accumulates test information provided by TEST_P macro invocations
465// and generators provided by INSTANTIATE_TEST_CASE_P macro invocations
466// and uses that information to register all resulting test instances
467// in RegisterTests method. The ParameterizeTestCaseRegistry class holds
468// a collection of pointers to the ParameterizedTestCaseInfo objects
469// and calls RegisterTests() on each of them when asked.
470class ParameterizedTestCaseInfoBase {
471 public:
472 virtual ~ParameterizedTestCaseInfoBase() {}
473
474 // Base part of test case name for display purposes.
475 virtual const string& GetTestCaseName() const = 0;
476 // Test case id to verify identity.
477 virtual TypeId GetTestCaseTypeId() const = 0;
478 // UnitTest class invokes this method to register tests in this
479 // test case right before running them in RUN_ALL_TESTS macro.
480 // This method should not be called more then once on any single
481 // instance of a ParameterizedTestCaseInfoBase derived class.
482 virtual void RegisterTests() = 0;
483
484 protected:
485 ParameterizedTestCaseInfoBase() {}
486
487 private:
488 GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfoBase);
489};
490
491// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
492//
493// ParameterizedTestCaseInfo accumulates tests obtained from TEST_P
494// macro invocations for a particular test case and generators
495// obtained from INSTANTIATE_TEST_CASE_P macro invocations for that
496// test case. It registers tests with all values generated by all
497// generators when asked.
498template <class TestCase>
499class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase {
500 public:
501 // ParamType and GeneratorCreationFunc are private types but are required
502 // for declarations of public methods AddTestPattern() and
503 // AddTestCaseInstantiation().
504 typedef typename TestCase::ParamType ParamType;
505 // A function that returns an instance of appropriate generator type.
506 typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
507 typedef typename ParamNameGenFunc<ParamType>::Type ParamNameGeneratorFunc;
508
509 explicit ParameterizedTestCaseInfo(
510 const char* name, CodeLocation code_location)
511 : test_case_name_(name), code_location_(code_location) {}
512
513 // Test case base name for display purposes.
514 virtual const string& GetTestCaseName() const { return test_case_name_; }
515 // Test case id to verify identity.
516 virtual TypeId GetTestCaseTypeId() const { return GetTypeId<TestCase>(); }
517 // TEST_P macro uses AddTestPattern() to record information
518 // about a single test in a LocalTestInfo structure.
519 // test_case_name is the base name of the test case (without invocation
520 // prefix). test_base_name is the name of an individual test without
521 // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
522 // test case base name and DoBar is test base name.
523 void AddTestPattern(const char* test_case_name,
524 const char* test_base_name,
525 TestMetaFactoryBase<ParamType>* meta_factory) {
526 tests_.push_back(linked_ptr<TestInfo>(new TestInfo(test_case_name,
527 test_base_name,
528 meta_factory)));
529 }
530 // INSTANTIATE_TEST_CASE_P macro uses AddGenerator() to record information
531 // about a generator.
532 int AddTestCaseInstantiation(const string& instantiation_name,
533 GeneratorCreationFunc* func,
534 ParamNameGeneratorFunc* name_func,
535 const char* file,
536 int line) {
537 instantiations_.push_back(
538 InstantiationInfo(instantiation_name, func, name_func, file, line));
539 return 0; // Return value used only to run this method in namespace scope.
540 }
541 // UnitTest class invokes this method to register tests in this test case
542 // test cases right before running tests in RUN_ALL_TESTS macro.
543 // This method should not be called more then once on any single
544 // instance of a ParameterizedTestCaseInfoBase derived class.
545 // UnitTest has a guard to prevent from calling this method more then once.
546 virtual void RegisterTests() {
547 for (typename TestInfoContainer::iterator test_it = tests_.begin();
548 test_it != tests_.end(); ++test_it) {
549 linked_ptr<TestInfo> test_info = *test_it;
550 for (typename InstantiationContainer::iterator gen_it =
551 instantiations_.begin(); gen_it != instantiations_.end();
552 ++gen_it) {
553 const string& instantiation_name = gen_it->name;
554 ParamGenerator<ParamType> generator((*gen_it->generator)());
555 ParamNameGeneratorFunc* name_func = gen_it->name_func;
556 const char* file = gen_it->file;
557 int line = gen_it->line;
558
559 string test_case_name;
560 if ( !instantiation_name.empty() )
561 test_case_name = instantiation_name + "/";
562 test_case_name += test_info->test_case_base_name;
563
564 size_t i = 0;
565 std::set<std::string> test_param_names;
566 for (typename ParamGenerator<ParamType>::iterator param_it =
567 generator.begin();
568 param_it != generator.end(); ++param_it, ++i) {
569 Message test_name_stream;
570
571 std::string param_name = name_func(
572 TestParamInfo<ParamType>(*param_it, i));
573
574 GTEST_CHECK_(IsValidParamName(param_name))
575 << "Parameterized test name '" << param_name
576 << "' is invalid, in " << file
577 << " line " << line << std::endl;
578
579 GTEST_CHECK_(test_param_names.count(param_name) == 0)
580 << "Duplicate parameterized test name '" << param_name
581 << "', in " << file << " line " << line << std::endl;
582
583 test_param_names.insert(param_name);
584
585 test_name_stream << test_info->test_base_name << "/" << param_name;
586 MakeAndRegisterTestInfo(
587 test_case_name.c_str(),
588 test_name_stream.GetString().c_str(),
589 NULL, // No type parameter.
590 PrintToString(*param_it).c_str(),
591 code_location_,
592 GetTestCaseTypeId(),
593 TestCase::SetUpTestCase,
594 TestCase::TearDownTestCase,
595 test_info->test_meta_factory->CreateTestFactory(*param_it));
596 } // for param_it
597 } // for gen_it
598 } // for test_it
599 } // RegisterTests
600
601 private:
602 // LocalTestInfo structure keeps information about a single test registered
603 // with TEST_P macro.
604 struct TestInfo {
605 TestInfo(const char* a_test_case_base_name,
606 const char* a_test_base_name,
607 TestMetaFactoryBase<ParamType>* a_test_meta_factory) :
608 test_case_base_name(a_test_case_base_name),
609 test_base_name(a_test_base_name),
610 test_meta_factory(a_test_meta_factory) {}
611
612 const string test_case_base_name;
613 const string test_base_name;
614 const scoped_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory;
615 };
616 typedef ::std::vector<linked_ptr<TestInfo> > TestInfoContainer;
617 // Records data received from INSTANTIATE_TEST_CASE_P macros:
618 // <Instantiation name, Sequence generator creation function,
619 // Name generator function, Source file, Source line>
620 struct InstantiationInfo {
621 InstantiationInfo(const std::string &name_in,
622 GeneratorCreationFunc* generator_in,
623 ParamNameGeneratorFunc* name_func_in,
624 const char* file_in,
625 int line_in)
626 : name(name_in),
627 generator(generator_in),
628 name_func(name_func_in),
629 file(file_in),
630 line(line_in) {}
631
632 std::string name;
633 GeneratorCreationFunc* generator;
634 ParamNameGeneratorFunc* name_func;
635 const char* file;
636 int line;
637 };
638 typedef ::std::vector<InstantiationInfo> InstantiationContainer;
639
640 static bool IsValidParamName(const std::string& name) {
641 // Check for empty string
642 if (name.empty())
643 return false;
644
645 // Check for invalid characters
646 for (std::string::size_type index = 0; index < name.size(); ++index) {
647 if (!isalnum(name[index]) && name[index] != '_')
648 return false;
649 }
650
651 return true;
652 }
653
654 const string test_case_name_;
655 CodeLocation code_location_;
656 TestInfoContainer tests_;
657 InstantiationContainer instantiations_;
658
659 GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfo);
660}; // class ParameterizedTestCaseInfo
661
662// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
663//
664// ParameterizedTestCaseRegistry contains a map of ParameterizedTestCaseInfoBase
665// classes accessed by test case names. TEST_P and INSTANTIATE_TEST_CASE_P
666// macros use it to locate their corresponding ParameterizedTestCaseInfo
667// descriptors.
668class ParameterizedTestCaseRegistry {
669 public:
670 ParameterizedTestCaseRegistry() {}
671 ~ParameterizedTestCaseRegistry() {
672 for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
673 it != test_case_infos_.end(); ++it) {
674 delete *it;
675 }
676 }
677
678 // Looks up or creates and returns a structure containing information about
679 // tests and instantiations of a particular test case.
680 template <class TestCase>
681 ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
682 const char* test_case_name,
683 CodeLocation code_location) {
684 ParameterizedTestCaseInfo<TestCase>* typed_test_info = NULL;
685 for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
686 it != test_case_infos_.end(); ++it) {
687 if ((*it)->GetTestCaseName() == test_case_name) {
688 if ((*it)->GetTestCaseTypeId() != GetTypeId<TestCase>()) {
689 // Complain about incorrect usage of Google Test facilities
690 // and terminate the program since we cannot guaranty correct
691 // test case setup and tear-down in this case.
692 ReportInvalidTestCaseType(test_case_name, code_location);
693 posix::Abort();
694 } else {
695 // At this point we are sure that the object we found is of the same
696 // type we are looking for, so we downcast it to that type
697 // without further checks.
698 typed_test_info = CheckedDowncastToActualType<
699 ParameterizedTestCaseInfo<TestCase> >(*it);
700 }
701 break;
702 }
703 }
704 if (typed_test_info == NULL) {
705 typed_test_info = new ParameterizedTestCaseInfo<TestCase>(
706 test_case_name, code_location);
707 test_case_infos_.push_back(typed_test_info);
708 }
709 return typed_test_info;
710 }
711 void RegisterTests() {
712 for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
713 it != test_case_infos_.end(); ++it) {
714 (*it)->RegisterTests();
715 }
716 }
717
718 private:
719 typedef ::std::vector<ParameterizedTestCaseInfoBase*> TestCaseInfoContainer;
720
721 TestCaseInfoContainer test_case_infos_;
722
723 GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseRegistry);
724};
725
726} // namespace internal
727} // namespace testing
728
729#endif // GTEST_HAS_PARAM_TEST
730
731#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
732