PageRenderTime 83ms CodeModel.GetById 46ms app.highlight 30ms RepoModel.GetById 1ms app.codeStats 0ms

/thirdparty/breakpad/third_party/protobuf/protobuf/gtest/include/gtest/internal/gtest-param-util.h

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