Google test源码阅读（二）：参数化测试执行流程

参数化测试or数据驱动可以利用大量的数据跑一个具体的Case，有利于发现问题。至于Google test如何写数据驱动，请参考google的文档。

先介绍求Prime素数的类：

// The prime table interface.
class PrimeTable {
 public:
  virtual ~PrimeTable() {}

  // Returns true iff n is a prime number.
  virtual bool IsPrime(int n) const = 0;

  // Returns the smallest prime number greater than p; or returns -1
  // if the next prime is beyond the capacity of the table.
  virtual int GetNextPrime(int p) const = 0;
};

// Implementation #1 calculates the primes on-the-fly.
class OnTheFlyPrimeTable : public PrimeTable {
 public:
  virtual bool IsPrime(int n) const {
    if (n <= 1) return false;

    for (int i = 2; i*i <= n; i++) {
      // n is divisible by an integer other than 1 and itself.
      if ((n % i) == 0) return false;
    }

    return true;
  }

  virtual int GetNextPrime(int p) const {
    for (int n = p + 1; n > 0; n++) {
      if (IsPrime(n)) return n;
    }

    return -1;
  }
};

// Implementation #2 pre-calculates the primes and stores the result
// in an array.
class PreCalculatedPrimeTable : public PrimeTable {
 public:
  // 'max' specifies the maximum number the prime table holds.
  explicit PreCalculatedPrimeTable(int max)
      : is_prime_size_(max + 1), is_prime_(new bool[max + 1]) {
    CalculatePrimesUpTo(max);
  }
  virtual ~PreCalculatedPrimeTable() { delete[] is_prime_; }

  virtual bool IsPrime(int n) const {
    return 0 <= n && n < is_prime_size_ && is_prime_[n];
  }

  virtual int GetNextPrime(int p) const {
    for (int n = p + 1; n < is_prime_size_; n++) {
      if (is_prime_[n]) return n;
    }

    return -1;
  }

 private:
  void CalculatePrimesUpTo(int max) {
    ::std::fill(is_prime_, is_prime_ + is_prime_size_, true);
    is_prime_[0] = is_prime_[1] = false;

    for (int i = 2; i <= max; i++) {
      if (!is_prime_[i]) continue;

      // Marks all multiples of i (except i itself) as non-prime.
      for (int j = 2*i; j <= max; j += i) {
        is_prime_[j] = false;
      }
    }
  }

  const int is_prime_size_;
  bool* const is_prime_;

  // Disables compiler warning "assignment operator could not be generated."
  void operator=(const PreCalculatedPrimeTable& rhs);
};

下面开始写具体的Case:

 

typedef PrimeTable* CreatePrimeTableFunc();

PrimeTable* CreateOnTheFlyPrimeTable() {
  return new OnTheFlyPrimeTable();
}

template <size_t max_precalculated>
PrimeTable* CreatePreCalculatedPrimeTable() {
  return new PreCalculatedPrimeTable(max_precalculated);
}

class PrimeTableTest : public TestWithParam<CreatePrimeTableFunc*> {
 public:
  virtual ~PrimeTableTest() { delete table_; }
  virtual void SetUp() { table_ = (*GetParam())(); }
  virtual void TearDown() {
    delete table_;
    table_ = NULL;
  }

 protected:
  PrimeTable* table_;

测试的Case如下所示：

TEST_P(PrimeTableTest, ReturnsFalseForNonPrimes) {
  EXPECT_FALSE(table_->IsPrime(-5));
}

TEST_P(PrimeTableTest, ReturnsTrueForPrimes) {
  EXPECT_TRUE(table_->IsPrime(2));
}

TEST_P(PrimeTableTest, CanGetNextPrime) {
  EXPECT_EQ(2, table_->GetNextPrime(0));
}

INSTANTIATE_TEST_CASE_P(
    OnTheFlyAndPreCalculated,
    PrimeTableTest,
    Values(&CreateOnTheFlyPrimeTable, &CreatePreCalculatedPrimeTable<1000>));

按照上一篇文档的方法进行宏扩展，扩展后Case的具体实现如下：

class PrimeTableTest_ReturnsFalseForNonPrimes_Test : public PrimeTableTest 
{ 
public: PrimeTableTest_ReturnsFalseForNonPrimes_Test() {} 
        virtual void TestBody(); 
private: static int AddToRegistry() 
         { 
             ::testing::UnitTest::GetInstance()->parameterized_test_registry(). GetTestCasePatternHolder<PrimeTableTest>( 
                 "PrimeTableTest",                  "d:\\gtest\\gtest_all\\gtest_all\\sample7_unittest.cc", 
                 50)->AddTestPattern( 
                    "PrimeTableTest", 
                    "ReturnsFalseForNonPrimes", 
                    new ::testing::internal::TestMetaFactory< PrimeTableTest_ReturnsFalseForNonPrimes_Test>()
                    ); 
             return 0; 
         } 
         static int gtest_registering_dummy_; 
         PrimeTableTest_ReturnsFalseForNonPrimes_Test(PrimeTableTest_ReturnsFalseForNonPrimes_Test const &); 
         void operator=(PrimeTableTest_ReturnsFalseForNonPrimes_Test const &); 
}; 

int PrimeTableTest_ReturnsFalseForNonPrimes_Test::gtest_registering_dummy_ = 
    PrimeTableTest_ReturnsFalseForNonPrimes_Test::AddToRegistry(); 

void PrimeTableTest_ReturnsFalseForNonPrimes_Test::TestBody() {
    switch (0) 
    case 0: 
    default: if (const ::testing::AssertionResult gtest_ar_ = 
                    ::testing::AssertionResult(!(table_->IsPrime(-5)))) ; 
             else 
                 ::testing::internal::AssertHelper(
                    ::testing::TestPartResult::kNonFatalFailure, 
                    "d:\\gtest\\gtest_all\\gtest_all\\sample7_unittest.cc", 
                    51, 
                    ::testing::internal::GetBoolAssertionFailureMessage( 
                        gtest_ar_, 
                        "table_->IsPrime(-5)", 
                        "true", 
                        "false"
                    ).c_str()
                ) = ::testing::Message();
}
//

//
class PrimeTableTest_ReturnsTrueForPrimes_Test : public PrimeTableTest 
{ public: PrimeTableTest_ReturnsTrueForPrimes_Test() {} 
    virtual void TestBody(); 
    private: static int AddToRegistry() 
             { 
                 ::testing::UnitTest::GetInstance()->parameterized_test_registry(). GetTestCasePatternHolder<PrimeTableTest>( 
                    "PrimeTableTest", 
                    "d:\\gtest\\gtest_all\\gtest_all\\sample7_unittest.cc", 
                    59)->AddTestPattern( 
                            "PrimeTableTest", 
                            "ReturnsTrueForPrimes", 
                            new ::testing::internal::TestMetaFactory< PrimeTableTest_ReturnsTrueForPrimes_Test>()); 
                return 0; 
             } 
             static int gtest_registering_dummy_; 
             PrimeTableTest_ReturnsTrueForPrimes_Test(PrimeTableTest_ReturnsTrueForPrimes_Test const &); 
             void operator=(PrimeTableTest_ReturnsTrueForPrimes_Test const &); 
}; 

int PrimeTableTest_ReturnsTrueForPrimes_Test::gtest_registering_dummy_ = 
    PrimeTableTest_ReturnsTrueForPrimes_Test::AddToRegistry(); 

void PrimeTableTest_ReturnsTrueForPrimes_Test::TestBody() 
{
    switch (0) 
    case 0: 
    default: if (const ::testing::AssertionResult gtest_ar_ = 
                 ::testing::AssertionResult(table_->IsPrime(2))) ; 
             else 
                 ::testing::internal::AssertHelper(
                    ::testing::TestPartResult::kNonFatalFailure, 
                    "d:\\gtest\\gtest_all\\gtest_all\\sample7_unittest.cc", 
                    60, 
                    ::testing::internal::GetBoolAssertionFailureMessage( 
                        gtest_ar_, 
                        "table_->IsPrime(2)", 
                        "false", 
                        "true"
                    ).c_str()
                ) = ::testing::Message();
}
//

//
class PrimeTableTest_CanGetNextPrime_Test : public PrimeTableTest 
{ 
public: PrimeTableTest_CanGetNextPrime_Test() {} 
        virtual void TestBody(); 
private: static int AddToRegistry() 
         {
             ::testing::UnitTest::GetInstance()->parameterized_test_registry(). GetTestCasePatternHolder<PrimeTableTest>( 
                 "PrimeTableTest", 
                 "d:\\gtest\\gtest_all\\gtest_all\\sample7_unittest.cc", 
                 68)->AddTestPattern( 
                        "PrimeTableTest", 
                        "CanGetNextPrime", 
                        new ::testing::internal::TestMetaFactory< PrimeTableTest_CanGetNextPrime_Test>()); 
             return 0; 
         } 
         static int gtest_registering_dummy_; 
         PrimeTableTest_CanGetNextPrime_Test(PrimeTableTest_CanGetNextPrime_Test const &); 
         void operator=(PrimeTableTest_CanGetNextPrime_Test const &); 
}; 

int PrimeTableTest_CanGetNextPrime_Test::gtest_registering_dummy_ = 
    PrimeTableTest_CanGetNextPrime_Test::AddToRegistry(); 

void PrimeTableTest_CanGetNextPrime_Test::TestBody() {
    switch (0) 
    case 0: 
    default: 
        if (const ::testing::AssertionResult gtest_ar = 
            (::testing::internal:: EqHelper<(sizeof(::testing::internal::IsNullLiteralHelper(2)) == 1)>::Compare(
                "2", 
                "table_->GetNextPrime(0)", 
                2, 
                table_->GetNextPrime(0)
                )
            )
        ) ; 
        else 
            ::testing::internal::AssertHelper(
                ::testing::TestPartResult::kNonFatalFailure, 
                "d:\\gtest\\gtest_all\\gtest_all\\sample7_unittest.cc", 
                69, 
                gtest_ar.failure_message()
            ) = ::testing::Message();
}
//

//
::testing::internal::ParamGenerator<PrimeTableTest::ParamType> gtest_OnTheFlyAndPreCalculatedPrimeTableTest_EvalGenerator_() 
{ 
    return Values(&CreateOnTheFlyPrimeTable, &CreatePreCalculatedPrimeTable<1000>); 
} 

int gtest_OnTheFlyAndPreCalculatedPrimeTableTest_dummy_ = 
    ::testing::UnitTest::GetInstance()->parameterized_test_registry(). GetTestCasePatternHolder<PrimeTableTest>( 
        "PrimeTableTest", 
        "d:\\gtest\\gtest_all\\gtest_all\\sample7_unittest.cc", 
        87)->AddTestCaseInstantiation( 
                "OnTheFlyAndPreCalculated",                 &gtest_OnTheFlyAndPreCalculatedPrimeTableTest_EvalGenerator_,                 "d:\\gtest\\gtest_all\\gtest_all\\sample7_unittest.cc", 
                87);

（一）在主线程进入main函数之前首先初始化类中的静态变量。因此首先会执行：

int PrimeTableTest_ReturnsFalseForNonPrimes_Test::gtest_registering_dummy_ = 
    PrimeTableTest_ReturnsFalseForNonPrimes_Test::AddToRegistry(); 

AddToRegistry的对应代码如下：

static int AddToRegistry() 
             { 
                 ::testing::UnitTest::GetInstance()->parameterized_test_registry(). GetTestCasePatternHolder<PrimeTableTest>( 
                    "PrimeTableTest", 
                    "d:\\gtest\\gtest_all\\gtest_all\\sample7_unittest.cc", 
                    59)->AddTestPattern( 
                            "PrimeTableTest", 
                            "ReturnsTrueForPrimes", 
                            new ::testing::internal::TestMetaFactory< PrimeTableTest_ReturnsTrueForPrimes_Test>()); 
                return 0; 
             } 

GetTestCasePatternHolder和AddTestPattern方法如下：

class ParameterizedTestCaseRegistry {
…  …
// Looks up or creates and returns a structure containing information about
  // tests and instantiations of a particular test case.
  template <class TestCase>
  ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
      const char* test_case_name,
      const char* file,
      int line) {
    ParameterizedTestCaseInfo<TestCase>* typed_test_info = NULL;
    for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
         it != test_case_infos_.end(); ++it) {
      if ((*it)->GetTestCaseName() == test_case_name) {
        if ((*it)->GetTestCaseTypeId() != GetTypeId<TestCase>()) {
          // Complain about incorrect usage of Google Test facilities
          // and terminate the program since we cannot guaranty correct
          // test case setup and tear-down in this case.
          ReportInvalidTestCaseType(test_case_name,  file, line);
          posix::Abort();
        } else {
         // At this point we are sure that the object we found is of the same
         // type we are looking for, so we downcast it to that type
         // without further checks.
          typed_test_info = CheckedDowncastToActualType<
              ParameterizedTestCaseInfo<TestCase> >(*it);
        }
        break;
      }
    }
    if (typed_test_info == NULL) {
      typed_test_info = new ParameterizedTestCaseInfo<TestCase>(test_case_name);
      test_case_infos_.push_back(typed_test_info);
    }
    return typed_test_info;
  }
… …
}

 

template <class TestCase>
class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase {
…
void AddTestPattern(const char* test_case_name,
                      const char* test_base_name,
                      TestMetaFactoryBase<ParamType>* meta_factory) {
    tests_.push_back(linked_ptr<TestInfo>(new TestInfo(test_case_name,
                                                       test_base_name,
                                                       meta_factory)));
  }
…
}

 

（二）在进入main函数之前，在初始化上面的类中静态变量之后，将初始化全局变量：

int gtest_OnTheFlyAndPreCalculatedPrimeTableTest_dummy_ = 
    ::testing::UnitTest::GetInstance()->parameterized_test_registry(). GetTestCasePatternHolder<PrimeTableTest>( 
        "PrimeTableTest", 
        "d:\\gtest\\gtest_all\\gtest_all\\sample7_unittest.cc", 
        87)->AddTestCaseInstantiation( 
                "OnTheFlyAndPreCalculated",                 &gtest_OnTheFlyAndPreCalculatedPrimeTableTest_EvalGenerator_,                 "d:\\gtest\\gtest_all\\gtest_all\\sample7_unittest.cc", 
                87);

 

AddTestCaseInstantiation的方法实现如下：

template <class TestCase>
class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase  {
…
// INSTANTIATE_TEST_CASE_P macro uses AddGenerator() to record information
  // about a generator.
  int AddTestCaseInstantiation(const string& instantiation_name,
                               GeneratorCreationFunc* func,
                               const char* /* file */,
                               int /* line */) {
    instantiations_.push_back(::std::make_pair(instantiation_name, func));
    return 0;  // Return value used only to run this method in namespace scope.
  }
…
}

 

（三）进入main函数之后的执行流程如下：

int main(int argc, char **argv) {
    //testing::FLAGS_gtest_filter = "OnTheFlyAndPreCalculated*";
    testing::InitGoogleTest(&argc, argv);
    return (::testing::UnitTest::GetInstance()->Run());
}

void InitGoogleTest(int* argc, char** argv) {
  internal::InitGoogleTestImpl(argc, argv);
}

// The internal implementation of InitGoogleTest().
//
// The type parameter CharType can be instantiated to either char or
// wchar_t.
template <typename CharType>
void InitGoogleTestImpl(int* argc, CharType** argv) {
  …
  GetUnitTestImpl()->PostFlagParsingInit();
}

// Performs initialization dependent upon flag values obtained in
// ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
// ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
// this function is also called from RunAllTests.  Since this function can be
// called more than once, it has to be idempotent.
void UnitTestImpl::PostFlagParsingInit() {
…
    // Registers parameterized tests. This makes parameterized tests
    // available to the UnitTest reflection API without running
    // RUN_ALL_TESTS.
    RegisterParameterizedTests();
…
  }

 

 

// This method expands all parameterized tests registered with macros TEST_P
// and INSTANTIATE_TEST_CASE_P into regular tests and registers those.
// This will be done just once during the program runtime.
void UnitTestImpl::RegisterParameterizedTests() {
#if GTEST_HAS_PARAM_TEST
  if (!parameterized_tests_registered_) {
    parameterized_test_registry_.RegisterTests();
    parameterized_tests_registered_ = true;
  }
#endif
}

 

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// ParameterizedTestCaseRegistry contains a map of ParameterizedTestCaseInfoBase
// classes accessed by test case names. TEST_P and INSTANTIATE_TEST_CASE_P
// macros use it to locate their corresponding ParameterizedTestCaseInfo
// descriptors.
class ParameterizedTestCaseRegistry {
… 
  void RegisterTests() {
    for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
         it != test_case_infos_.end(); ++it) {
      (*it)->RegisterTests();
    }
  }//注意对照上面的ParameterizedTestCaseRegistry::GetTestCasePatternHolder方法
…
};

 注意：下面的RegisterTests方法和上面已经介绍的AddTestPattern，AddTestCaseInstantiation同属于类ParameterizedTestCaseInfo。

template <class TestCase>
class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase {
 public:
…
  // TEST_P macro uses AddTestPattern() to record information
  // about a single test in a LocalTestInfo structure.
  // test_case_name is the base name of the test case (without invocation
  // prefix). test_base_name is the name of an individual test without
  // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
  // test case base name and DoBar is test base name.
  void AddTestPattern(const char* test_case_name,
                      const char* test_base_name,
                      TestMetaFactoryBase<ParamType>* meta_factory) {
    tests_.push_back(linked_ptr<TestInfo>(new TestInfo(test_case_name,
                                                       test_base_name,
                                                       meta_factory)));
  }

  // INSTANTIATE_TEST_CASE_P macro uses AddGenerator() to record information
  // about a generator.
  int AddTestCaseInstantiation(const string& instantiation_name,
                               GeneratorCreationFunc* func,
                               const char* /* file */,
                               int /* line */) {
    instantiations_.push_back(::std::make_pair(instantiation_name, func));
    return 0;  // Return value used only to run this method in namespace scope.
  }

  // UnitTest class invokes this method to register tests in this test case
  // test cases right before running tests in RUN_ALL_TESTS macro.
  // This method should not be called more then once on any single
  // instance of a ParameterizedTestCaseInfoBase derived class.
  // UnitTest has a guard to prevent from calling this method more then once.
  virtual void RegisterTests() {
    for (typename TestInfoContainer::iterator test_it = tests_.begin();
         test_it != tests_.end(); ++test_it) {////很显然，tests_是在AddTestPattern方法中增加元素的。
      linked_ptr<TestInfo> test_info = *test_it;
      for (typename InstantiationContainer::iterator gen_it =
               instantiations_.begin(); gen_it != instantiations_.end();
               ++gen_it) { //很显然，instantiations_是在AddTestCaseInstantiation方法中增加元素的。
        const string& instantiation_name = gen_it->first;
        ParamGenerator<ParamType> generator((*gen_it->second)());

        Message test_case_name_stream;
        if ( !instantiation_name.empty() )
          test_case_name_stream << instantiation_name << "/";
        test_case_name_stream << test_info->test_case_base_name;

        int i = 0;
        for (typename ParamGenerator<ParamType>::iterator param_it =
                 generator.begin();
             param_it != generator.end(); ++param_it, ++i) {
          Message test_name_stream;
          test_name_stream << test_info->test_base_name << "/" << i;
          MakeAndRegisterTestInfo(
              test_case_name_stream.GetString().c_str(),
              test_name_stream.GetString().c_str(),
              NULL,  // No type parameter.
              PrintToString(*param_it).c_str(),
              GetTestCaseTypeId(),
              TestCase::SetUpTestCase,
              TestCase::TearDownTestCase,
              test_info->test_meta_factory->CreateTestFactory(*param_it));
        }  // for param_it
      }  // for gen_it
    }  // for test_it
  }  // RegisterTests
 private:
  // LocalTestInfo structure keeps information about a single test registered
  // with TEST_P macro.
  struct TestInfo {
    TestInfo(const char* a_test_case_base_name,
             const char* a_test_base_name,
             TestMetaFactoryBase<ParamType>* a_test_meta_factory) :
        test_case_base_name(a_test_case_base_name),
        test_base_name(a_test_base_name),
        test_meta_factory(a_test_meta_factory) {}

    const string test_case_base_name;
    const string test_base_name;
    const scoped_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory;
  };
  typedef ::std::vector<linked_ptr<TestInfo> > TestInfoContainer;
  // Keeps pairs of <Instantiation name, Sequence generator creation function>
  // received from INSTANTIATE_TEST_CASE_P macros.
  typedef ::std::vector<std::pair<string, GeneratorCreationFunc*> >
      InstantiationContainer;
  InstantiationContainer instantiations_;
  … 
};  // class ParameterizedTestCaseInfo

 

 MakeAndRegisterTestInfo方法正是我们在上一篇分析中介绍的方法。

TestInfo* MakeAndRegisterTestInfo(
    const char* test_case_name, const char* name,
    const char* type_param,
    const char* value_param,
    TypeId fixture_class_id,
    SetUpTestCaseFunc set_up_tc,
    TearDownTestCaseFunc tear_down_tc,
    TestFactoryBase* factory) {
  TestInfo* const test_info =
      new TestInfo(test_case_name, name, type_param, value_param,
                   fixture_class_id, factory);
  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
  return test_info;
}

 

 在结束本文之前， 我们对ParameterizedTestCaseInfo：：RegisterTests方法中的一段代码感兴趣。

ParamGenerator<ParamType> generator((*gen_it->second)());



首先看刚开始的一段代码：

int gtest_OnTheFlyAndPreCalculatedPrimeTableTest_dummy_ = 
    ::testing::UnitTest::GetInstance()->parameterized_test_registry(). GetTestCasePatternHolder<PrimeTableTest>( 
        "PrimeTableTest", 
        "d:\\gtest\\gtest_all\\gtest_all\\sample7_unittest.cc", 
        87)->AddTestCaseInstantiation( 
                "OnTheFlyAndPreCalculated",                 &gtest_OnTheFlyAndPreCalculatedPrimeTableTest_EvalGenerator_,                 "d:\\gtest\\gtest_all\\gtest_all\\sample7_unittest.cc", 
                87);

查看一下AddTestCaseInstantiation方法。我们知道，(*gen_it->second)()实际上就是执行gtest_OnTheFlyAndPreCalculatedPrimeTableTest_EvalGenerator_方法。

::testing::internal::ParamGenerator<PrimeTableTest::ParamType> gtest_OnTheFlyAndPreCalculatedPrimeTableTest_EvalGenerator_() { 
return Values(&CreateOnTheFlyPrimeTable,&reatePreCalculatedPrimeTable<1000>); 
}

template <typename T1, typename T2>
internal::ValueArray2<T1, T2> Values(T1 v1, T2 v2) {
  return internal::ValueArray2<T1, T2>(v1, v2);
}

template <typename T1, typename T2>
class ValueArray2 {
 public:
  ValueArray2(T1 v1, T2 v2) : v1_(v1), v2_(v2) {}

  template <typename T>
  operator ParamGenerator<T>() const {
    const T array[] = {v1_, v2_};
    return ValuesIn(array);
  }

 private:
  // No implementation - assignment is unsupported.
  void operator=(const ValueArray2& other);

  const T1 v1_;
  const T2 v2_;
};

template <typename T, size_t N>
internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
  return ValuesIn(array, array + N);
}

template <typename ForwardIterator>
internal::ParamGenerator<
  typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
ValuesIn(ForwardIterator begin, ForwardIterator end) {
  typedef typename ::testing::internal::IteratorTraits<ForwardIterator>
      ::value_type ParamType;
  return internal::ParamGenerator<ParamType>(
      new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
}

// Generates values from a pair of STL-style iterators. Used in the
// ValuesIn() function. The elements are copied from the source range
// since the source can be located on the stack, and the generator
// is likely to persist beyond that stack frame.
template <typename T>
class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
 public:
  template <typename ForwardIterator>
  ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
      : container_(begin, end) {}
  virtual ~ValuesInIteratorRangeGenerator() {}

  virtual ParamIteratorInterface<T>* Begin() const {
    return new Iterator(this, container_.begin());
  }
  virtual ParamIteratorInterface<T>* End() const {
    return new Iterator(this, container_.end());
  }

 private:
  typedef typename ::std::vector<T> ContainerType;

  //内部类，并且是一个迭代器的实现
class Iterator : public ParamIteratorInterface<T> {
   public:
    Iterator(const ParamGeneratorInterface<T>* base,
             typename ContainerType::const_iterator iterator)
        : base_(base), iterator_(iterator) {}
    virtual ~Iterator() {}

    virtual const ParamGeneratorInterface<T>* BaseGenerator() const {
      return base_;
    }
    virtual void Advance() {
      ++iterator_;
      value_.reset();
    }
    virtual ParamIteratorInterface<T>* Clone() const {
      return new Iterator(*this);
    }
    // We need to use cached value referenced by iterator_ because *iterator_
    // can return a temporary object (and of type other then T), so just
    // having "return &*iterator_;" doesn't work.
    // value_ is updated here and not in Advance() because Advance()
    // can advance iterator_ beyond the end of the range, and we cannot
    // detect that fact. The client code, on the other hand, is
    // responsible for not calling Current() on an out-of-range iterator.
    virtual const T* Current() const {
      if (value_.get() == NULL)
        value_.reset(new T(*iterator_));
      return value_.get();
    }
    virtual bool Equals(const ParamIteratorInterface<T>& other) const {
      // Having the same base generator guarantees that the other
      // iterator is of the same type and we can downcast.
      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
          << "The program attempted to compare iterators "
          << "from different generators." << std::endl;
      return iterator_ ==
          CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
    }

   private:
    Iterator(const Iterator& other)
          // The explicit constructor call suppresses a false warning
          // emitted by gcc when supplied with the -Wextra option.
        : ParamIteratorInterface<T>(),
          base_(other.base_),
          iterator_(other.iterator_) {}

    const ParamGeneratorInterface<T>* const base_;
    typename ContainerType::const_iterator iterator_;
    // A cached value of *iterator_. We keep it here to allow access by
    // pointer in the wrapping iterator's operator->().
    // value_ needs to be mutable to be accessed in Current().
    // Use of scoped_ptr helps manage cached value's lifetime,
    // which is bound by the lifespan of the iterator itself.
    mutable scoped_ptr<const T> value_;
  };  // class ValuesInIteratorRangeGenerator::Iterator


  // No implementation - assignment is unsupported.
  void operator=(const ValuesInIteratorRangeGenerator& other);

  const ContainerType container_;
};  // class ValuesInIteratorRangeGenerator

 

// Wraps ParamGeneratorInterface<T> and provides general generator syntax
// compatible with the STL Container concept.
// This class implements copy initialization semantics and the contained
// ParamGeneratorInterface<T> instance is shared among all copies
// of the original object. This is possible because that instance is immutable.
template<typename T>
class ParamGenerator {
 public:
  typedef ParamIterator<T> iterator;

  explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {}
  ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {}

  ParamGenerator& operator=(const ParamGenerator& other) {
    impl_ = other.impl_;
    return *this;
  }

  iterator begin() const { return iterator(impl_->Begin()); }
  iterator end() const { return iterator(impl_->End()); }

 private:
  linked_ptr<const ParamGeneratorInterface<T> > impl_;
};