"Fossies" - the Fresh Open Source Software Archive

Member "ponyc-0.33.0/lib/gtest/gtest/internal/gtest-param-util.h" (1 Nov 2019, 27901 Bytes) of package /linux/misc/ponyc-0.33.0.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "gtest-param-util.h" see the Fossies "Dox" file reference documentation.

    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 std::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 std::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 std::string& instantiation_name,
  533                                GeneratorCreationFunc* func,
  534                                ParamNameGeneratorFunc* name_func,
  535                                const char* file, int line) {
  536     instantiations_.push_back(
  537         InstantiationInfo(instantiation_name, func, name_func, file, line));
  538     return 0;  // Return value used only to run this method in namespace scope.
  539   }
  540   // UnitTest class invokes this method to register tests in this test case
  541   // test cases right before running tests in RUN_ALL_TESTS macro.
  542   // This method should not be called more then once on any single
  543   // instance of a ParameterizedTestCaseInfoBase derived class.
  544   // UnitTest has a guard to prevent from calling this method more then once.
  545   virtual void RegisterTests() {
  546     for (typename TestInfoContainer::iterator test_it = tests_.begin();
  547          test_it != tests_.end(); ++test_it) {
  548       linked_ptr<TestInfo> test_info = *test_it;
  549       for (typename InstantiationContainer::iterator gen_it =
  550                instantiations_.begin(); gen_it != instantiations_.end();
  551                ++gen_it) {
  552         const std::string& instantiation_name = gen_it->name;
  553         ParamGenerator<ParamType> generator((*gen_it->generator)());
  554         ParamNameGeneratorFunc* name_func = gen_it->name_func;
  555         const char* file = gen_it->file;
  556         int line = gen_it->line;
  557 
  558         std::string test_case_name;
  559         if ( !instantiation_name.empty() )
  560           test_case_name = instantiation_name + "/";
  561         test_case_name += test_info->test_case_base_name;
  562 
  563         size_t i = 0;
  564         std::set<std::string> test_param_names;
  565         for (typename ParamGenerator<ParamType>::iterator param_it =
  566                  generator.begin();
  567              param_it != generator.end(); ++param_it, ++i) {
  568           Message test_name_stream;
  569 
  570           std::string param_name = name_func(
  571               TestParamInfo<ParamType>(*param_it, i));
  572 
  573           GTEST_CHECK_(IsValidParamName(param_name))
  574               << "Parameterized test name '" << param_name
  575               << "' is invalid, in " << file
  576               << " line " << line << std::endl;
  577 
  578           GTEST_CHECK_(test_param_names.count(param_name) == 0)
  579               << "Duplicate parameterized test name '" << param_name
  580               << "', in " << file << " line " << line << std::endl;
  581 
  582           test_param_names.insert(param_name);
  583 
  584           test_name_stream << test_info->test_base_name << "/" << param_name;
  585           MakeAndRegisterTestInfo(
  586               test_case_name.c_str(),
  587               test_name_stream.GetString().c_str(),
  588               NULL,  // No type parameter.
  589               PrintToString(*param_it).c_str(),
  590               code_location_,
  591               GetTestCaseTypeId(),
  592               TestCase::SetUpTestCase,
  593               TestCase::TearDownTestCase,
  594               test_info->test_meta_factory->CreateTestFactory(*param_it));
  595         }  // for param_it
  596       }  // for gen_it
  597     }  // for test_it
  598   }  // RegisterTests
  599 
  600  private:
  601   // LocalTestInfo structure keeps information about a single test registered
  602   // with TEST_P macro.
  603   struct TestInfo {
  604     TestInfo(const char* a_test_case_base_name,
  605              const char* a_test_base_name,
  606              TestMetaFactoryBase<ParamType>* a_test_meta_factory) :
  607         test_case_base_name(a_test_case_base_name),
  608         test_base_name(a_test_base_name),
  609         test_meta_factory(a_test_meta_factory) {}
  610 
  611     const std::string test_case_base_name;
  612     const std::string test_base_name;
  613     const scoped_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory;
  614   };
  615   typedef ::std::vector<linked_ptr<TestInfo> > TestInfoContainer;
  616   // Records data received from INSTANTIATE_TEST_CASE_P macros:
  617   //  <Instantiation name, Sequence generator creation function,
  618   //     Name generator function, Source file, Source line>
  619   struct InstantiationInfo {
  620       InstantiationInfo(const std::string &name_in,
  621                         GeneratorCreationFunc* generator_in,
  622                         ParamNameGeneratorFunc* name_func_in,
  623                         const char* file_in,
  624                         int line_in)
  625           : name(name_in),
  626             generator(generator_in),
  627             name_func(name_func_in),
  628             file(file_in),
  629             line(line_in) {}
  630 
  631       std::string name;
  632       GeneratorCreationFunc* generator;
  633       ParamNameGeneratorFunc* name_func;
  634       const char* file;
  635       int line;
  636   };
  637   typedef ::std::vector<InstantiationInfo> InstantiationContainer;
  638 
  639   static bool IsValidParamName(const std::string& name) {
  640     // Check for empty string
  641     if (name.empty())
  642       return false;
  643 
  644     // Check for invalid characters
  645     for (std::string::size_type index = 0; index < name.size(); ++index) {
  646       if (!isalnum(name[index]) && name[index] != '_')
  647         return false;
  648     }
  649 
  650     return true;
  651   }
  652 
  653   const std::string test_case_name_;
  654   CodeLocation code_location_;
  655   TestInfoContainer tests_;
  656   InstantiationContainer instantiations_;
  657 
  658   GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfo);
  659 };  // class ParameterizedTestCaseInfo
  660 
  661 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
  662 //
  663 // ParameterizedTestCaseRegistry contains a map of ParameterizedTestCaseInfoBase
  664 // classes accessed by test case names. TEST_P and INSTANTIATE_TEST_CASE_P
  665 // macros use it to locate their corresponding ParameterizedTestCaseInfo
  666 // descriptors.
  667 class ParameterizedTestCaseRegistry {
  668  public:
  669   ParameterizedTestCaseRegistry() {}
  670   ~ParameterizedTestCaseRegistry() {
  671     for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
  672          it != test_case_infos_.end(); ++it) {
  673       delete *it;
  674     }
  675   }
  676 
  677   // Looks up or creates and returns a structure containing information about
  678   // tests and instantiations of a particular test case.
  679   template <class TestCase>
  680   ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
  681       const char* test_case_name,
  682       CodeLocation code_location) {
  683     ParameterizedTestCaseInfo<TestCase>* typed_test_info = NULL;
  684     for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
  685          it != test_case_infos_.end(); ++it) {
  686       if ((*it)->GetTestCaseName() == test_case_name) {
  687         if ((*it)->GetTestCaseTypeId() != GetTypeId<TestCase>()) {
  688           // Complain about incorrect usage of Google Test facilities
  689           // and terminate the program since we cannot guaranty correct
  690           // test case setup and tear-down in this case.
  691           ReportInvalidTestCaseType(test_case_name, code_location);
  692           posix::Abort();
  693         } else {
  694           // At this point we are sure that the object we found is of the same
  695           // type we are looking for, so we downcast it to that type
  696           // without further checks.
  697           typed_test_info = CheckedDowncastToActualType<
  698               ParameterizedTestCaseInfo<TestCase> >(*it);
  699         }
  700         break;
  701       }
  702     }
  703     if (typed_test_info == NULL) {
  704       typed_test_info = new ParameterizedTestCaseInfo<TestCase>(
  705           test_case_name, code_location);
  706       test_case_infos_.push_back(typed_test_info);
  707     }
  708     return typed_test_info;
  709   }
  710   void RegisterTests() {
  711     for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
  712          it != test_case_infos_.end(); ++it) {
  713       (*it)->RegisterTests();
  714     }
  715   }
  716 
  717  private:
  718   typedef ::std::vector<ParameterizedTestCaseInfoBase*> TestCaseInfoContainer;
  719 
  720   TestCaseInfoContainer test_case_infos_;
  721 
  722   GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseRegistry);
  723 };
  724 
  725 }  // namespace internal
  726 }  // namespace testing
  727 
  728 #endif  //  GTEST_HAS_PARAM_TEST
  729 
  730 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_