$$ -*- mode: c++; -*-$var n = 50  $$ Maximum length of Values arguments we want to support.$var maxtuple = 10  $$ Maximum number of Combine arguments we want to support.// Copyright 2008 Google Inc.// All Rights Reserved.//// Redistribution and use in source and binary forms, with or without// modification, are permitted provided that the following conditions are// met:////     * Redistributions of source code must retain the above copyright// notice, this list of conditions and the following disclaimer.//     * Redistributions in binary form must reproduce the above// copyright notice, this list of conditions and the following disclaimer// in the documentation and/or other materials provided with the// distribution.//     * Neither the name of Google Inc. nor the names of its// contributors may be used to endorse or promote products derived from// this software without specific prior written permission.//// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.//// Author: vladl@google.com (Vlad Losev)// Type and function utilities for implementing parameterized tests.// This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!//// Currently Google Test supports at most $n arguments in Values,// and at most $maxtuple arguments in Combine. Please contact// googletestframework@googlegroups.com if you need more.// Please note that the number of arguments to Combine is limited// by the maximum arity of the implementation of tr1::tuple which is// currently set at $maxtuple.#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_#include <gtest/internal/gtest-port.h>#ifdef GTEST_HAS_PARAM_TEST#include <gtest/internal/gtest-param-util.h>namespace testing {namespace internal {// Used in the Values() function to provide polymorphic capabilities.template <typename T1>class ValueArray1 { public:  explicit ValueArray1(T1 v1) : v1_(v1) {}  template <typename T>  operator ParamGenerator<T>() const { return ValuesIn(&v1_, &v1_ + 1); } private:  const T1 v1_;};$range i 2..n$for i [[$range j 1..itemplate <$for j, [[typename T$j]]>class ValueArray$i { public:  ValueArray$i($for j, [[T$j v$j]]) : $for j, [[v$(j)_(v$j)]] {}  template <typename T>  operator ParamGenerator<T>() const {    const T array[] = {$for j, [[v$(j)_]]};    return ValuesIn(array);  } private:$for j [[  const T$j v$(j)_;]]};]]#ifdef GTEST_HAS_COMBINE// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.//// Generates values from the Cartesian product of values produced// by the argument generators.//$range i 2..maxtuple$for i [[$range j 1..i$range k 2..itemplate <$for j, [[typename T$j]]>class CartesianProductGenerator$i    : public ParamGeneratorInterface< ::std::tr1::tuple<$for j, [[T$j]]> > { public:  typedef ::std::tr1::tuple<$for j, [[T$j]]> ParamType;  CartesianProductGenerator$i($for j, [[const ParamGenerator<T$j>& g$j]])      : $for j, [[g$(j)_(g$j)]] {}  virtual ~CartesianProductGenerator$i() {}  virtual ParamIteratorInterface<ParamType>* Begin() const {    return new Iterator(this, $for j, [[g$(j)_, g$(j)_.begin()]]);  }  virtual ParamIteratorInterface<ParamType>* End() const {    return new Iterator(this, $for j, [[g$(j)_, g$(j)_.end()]]);  } private:  class Iterator : public ParamIteratorInterface<ParamType> {   public:    Iterator(const ParamGeneratorInterface<ParamType>* base, $for j, [[      const ParamGenerator<T$j>& g$j,      const typename ParamGenerator<T$j>::iterator& current$(j)]])        : base_(base),$for j, [[          begin$(j)_(g$j.begin()), end$(j)_(g$j.end()), current$(j)_(current$j)]]    {      ComputeCurrentValue();    }    virtual ~Iterator() {}    virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {      return base_;    }    // Advance should not be called on beyond-of-range iterators    // so no component iterators must be beyond end of range, either.    virtual void Advance() {      assert(!AtEnd());      ++current$(i)_;$for k [[      if (current$(i+2-k)_ == end$(i+2-k)_) {        current$(i+2-k)_ = begin$(i+2-k)_;        ++current$(i+2-k-1)_;      }]]      ComputeCurrentValue();    }    virtual ParamIteratorInterface<ParamType>* Clone() const {      return new Iterator(*this);    }    virtual const ParamType* Current() const { return &current_value_; }    virtual bool Equals(const ParamIteratorInterface<ParamType>& 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;      const Iterator* typed_other =          CheckedDowncastToActualType<const Iterator>(&other);      // We must report iterators equal if they both point beyond their      // respective ranges. That can happen in a variety of fashions,      // so we have to consult AtEnd().      return (AtEnd() && typed_other->AtEnd()) ||         ($for j  && [[          current$(j)_ == typed_other->current$(j)_]]);    }   private:    Iterator(const Iterator& other)        : base_(other.base_), $for j, [[        begin$(j)_(other.begin$(j)_),        end$(j)_(other.end$(j)_),        current$(j)_(other.current$(j)_)]] {      ComputeCurrentValue();    }    void ComputeCurrentValue() {      if (!AtEnd())        current_value_ = ParamType($for j, [[*current$(j)_]]);    }    bool AtEnd() const {      // We must report iterator past the end of the range when either of the      // component iterators has reached the end of its range.      return$for j  || [[          current$(j)_ == end$(j)_]];    }    const ParamGeneratorInterface<ParamType>* const base_;    // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.    // current[i]_ is the actual traversing iterator.$for j [[    const typename ParamGenerator<T$j>::iterator begin$(j)_;    const typename ParamGenerator<T$j>::iterator end$(j)_;    typename ParamGenerator<T$j>::iterator current$(j)_;]]    ParamType current_value_;  };$for j [[  const ParamGenerator<T$j> g$(j)_;]]};]]// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.//// Helper classes providing Combine() with polymorphic features. They allow// casting CartesianProductGeneratorN<T> to ParamGenerator<U> if T is// convertible to U.//$range i 2..maxtuple$for i [[$range j 1..itemplate <$for j, [[class Generator$j]]>class CartesianProductHolder$i { public:CartesianProductHolder$i($for j, [[const Generator$j& g$j]])      : $for j, [[g$(j)_(g$j)]] {}  template <$for j, [[typename T$j]]>  operator ParamGenerator< ::std::tr1::tuple<$for j, [[T$j]]> >() const {    return ParamGenerator< ::std::tr1::tuple<$for j, [[T$j]]> >(        new CartesianProductGenerator$i<$for j, [[T$j]]>($for j,[[        static_cast<ParamGenerator<T$j> >(g$(j)_)]]));  } private:$for j [[  const Generator$j g$(j)_;]]};]]#endif  // GTEST_HAS_COMBINE}  // namespace internal}  // namespace testing#endif  //  GTEST_HAS_PARAM_TEST#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_