Faiss

- Main Page
- Namespaces
- Classes
- Files

- File List

All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends
gtest-param-util.h
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
54 namespace 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.
58 template <class ParamType>
59 struct 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.
69 struct PrintToStringParamName {
70 template <class ParamType>
71 std::string operator()(const TestParamInfo<ParamType>& info) const {
72 return PrintToString(info.param);
73 }
74 };
75
76 namespace 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.
84 GTEST_API_ void ReportInvalidTestCaseType(const char* test_case_name,
85 CodeLocation code_location);
86
87 template <typename> class ParamGeneratorInterface;
88 template <typename> class ParamGenerator;
89
90 // Interface for iterating over elements provided by an implementation
91 // of ParamGeneratorInterface<T>.
92 template <typename T>
93 class 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.
122 template <typename T>
123 class 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.
165 template <typename T>
166 class 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.
182 template<typename T>
183 class 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.
206 template <typename T, typename IncrementT>
207 class 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.
291 template <typename T>
292 class 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.
376 template <class ParamType>
377 std::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.
388 template <class ParamType, class ParamNameGenFunctor>
389 ParamNameGenFunctor GetParamNameGen(ParamNameGenFunctor func) {
390 return func;
391 }
392
393 template <class ParamType>
394 struct ParamNameGenFunc {
395 typedef std::string Type(const TestParamInfo<ParamType>&);
396 };
397
398 template <class ParamType>
399 typename 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.
407 template <class TestClass>
408 class 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.
428 template <class ParamType>
429 class 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.
444 template <class TestCase>
445 class 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.
470 class 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.
498 template <class TestCase>
499 class 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.
668 class 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_