Analysis Software
Documentation for sPHENIX simulation software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
gtest-param-util.h
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file 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.
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;
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 
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_