src/gtest/include/gtest/internal/gtest-param-util-generated.h.pump

   1 $$ -*- mode: c++; -*-
   2 $var n = 50  $$ Maximum length of Values arguments we want to support.
   3 $var maxtuple = 10  $$ Maximum number of Combine arguments we want to support.
   4 // Copyright 2008 Google Inc.
   5 // All Rights Reserved.
   6 //
   7 // Redistribution and use in source and binary forms, with or without
   8 // modification, are permitted provided that the following conditions are
   9 // met:
  10 //
  11 //     * Redistributions of source code must retain the above copyright
  12 // notice, this list of conditions and the following disclaimer.
  13 //     * Redistributions in binary form must reproduce the above
  14 // copyright notice, this list of conditions and the following disclaimer
  15 // in the documentation and/or other materials provided with the
  16 // distribution.
  17 //     * Neither the name of Google Inc. nor the names of its
  18 // contributors may be used to endorse or promote products derived from
  19 // this software without specific prior written permission.
  20 //
  21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32 //
  33 // Author: vladl@google.com (Vlad Losev)
  34
  35 // Type and function utilities for implementing parameterized tests.
  36 // This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
  37 //
  38 // Currently Google Test supports at most $n arguments in Values,
  39 // and at most $maxtuple arguments in Combine. Please contact
  40 // googletestframework@googlegroups.com if you need more.
  41 // Please note that the number of arguments to Combine is limited
  42 // by the maximum arity of the implementation of tr1::tuple which is
  43 // currently set at $maxtuple.
  44
  45 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
  46 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
  47
  48 // scripts/fuse_gtest.py depends on gtest's own header being #included
  49 // *unconditionally*.  Therefore these #includes cannot be moved
  50 // inside #if GTEST_HAS_PARAM_TEST.
  51 #include "gtest/internal/gtest-param-util.h"
  52 #include "gtest/internal/gtest-port.h"
  53
  54 #if GTEST_HAS_PARAM_TEST
  55
  56 namespace testing {
  57
  58 // Forward declarations of ValuesIn(), which is implemented in
  59 // include/gtest/gtest-param-test.h.
  60 template <typename ForwardIterator>
  61 internal::ParamGenerator<
  62   typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
  63 ValuesIn(ForwardIterator begin, ForwardIterator end);
  64
  65 template <typename T, size_t N>
  66 internal::ParamGenerator<T> ValuesIn(const T (&array)[N]);
  67
  68 template <class Container>
  69 internal::ParamGenerator<typename Container::value_type> ValuesIn(
  70     const Container& container);
  71
  72 namespace internal {
  73
  74 // Used in the Values() function to provide polymorphic capabilities.
  75 template <typename T1>
  76 class ValueArray1 {
  77  public:
  78   explicit ValueArray1(T1 v1) : v1_(v1) {}
  79
  80   template <typename T>
  81   operator ParamGenerator<T>() const { return ValuesIn(&v1_, &v1_ + 1); }
  82
  83  private:
  84   // No implementation - assignment is unsupported.
  85   void operator=(const ValueArray1& other);
  86
  87   const T1 v1_;
  88 };
  89
  90 $range i 2..n
  91 $for i [[
  92 $range j 1..i
  93
  94 template <$for j, [[typename T$j]]>
  95 class ValueArray$i {
  96  public:
  97   ValueArray$i($for j, [[T$j v$j]]) : $for j, [[v$(j)_(v$j)]] {}
  98
  99   template <typename T>
 100   operator ParamGenerator<T>() const {
 101     const T array[] = {$for j, [[v$(j)_]]};
 102     return ValuesIn(array);
 103   }
 104
 105  private:
 106   // No implementation - assignment is unsupported.
 107   void operator=(const ValueArray$i& other);
 108
 109 $for j [[
 110
 111   const T$j v$(j)_;
 112 ]]
 113
 114 };
 115
 116 ]]
 117
 118 # if GTEST_HAS_COMBINE
 119 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
 120 //
 121 // Generates values from the Cartesian product of values produced
 122 // by the argument generators.
 123 //
 124 $range i 2..maxtuple
 125 $for i [[
 126 $range j 1..i
 127 $range k 2..i
 128
 129 template <$for j, [[typename T$j]]>
 130 class CartesianProductGenerator$i
 131     : public ParamGeneratorInterface< ::std::tr1::tuple<$for j, [[T$j]]> > {
 132  public:
 133   typedef ::std::tr1::tuple<$for j, [[T$j]]> ParamType;
 134
 135   CartesianProductGenerator$i($for j, [[const ParamGenerator<T$j>& g$j]])
 136       : $for j, [[g$(j)_(g$j)]] {}
 137   virtual ~CartesianProductGenerator$i() {}
 138
 139   virtual ParamIteratorInterface<ParamType>* Begin() const {
 140     return new Iterator(this, $for j, [[g$(j)_, g$(j)_.begin()]]);
 141   }
 142   virtual ParamIteratorInterface<ParamType>* End() const {
 143     return new Iterator(this, $for j, [[g$(j)_, g$(j)_.end()]]);
 144   }
 145
 146  private:
 147   class Iterator : public ParamIteratorInterface<ParamType> {
 148    public:
 149     Iterator(const ParamGeneratorInterface<ParamType>* base, $for j, [[
 150
 151       const ParamGenerator<T$j>& g$j,
 152       const typename ParamGenerator<T$j>::iterator& current$(j)]])
 153         : base_(base),
 154 $for j, [[
 155
 156           begin$(j)_(g$j.begin()), end$(j)_(g$j.end()), current$(j)_(current$j)
 157 ]]    {
 158       ComputeCurrentValue();
 159     }
 160     virtual ~Iterator() {}
 161
 162     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
 163       return base_;
 164     }
 165     // Advance should not be called on beyond-of-range iterators
 166     // so no component iterators must be beyond end of range, either.
 167     virtual void Advance() {
 168       assert(!AtEnd());
 169       ++current$(i)_;
 170
 171 $for k [[
 172       if (current$(i+2-k)_ == end$(i+2-k)_) {
 173         current$(i+2-k)_ = begin$(i+2-k)_;
 174         ++current$(i+2-k-1)_;
 175       }
 176
 177 ]]
 178       ComputeCurrentValue();
 179     }
 180     virtual ParamIteratorInterface<ParamType>* Clone() const {
 181       return new Iterator(*this);
 182     }
 183     virtual const ParamType* Current() const { return &current_value_; }
 184     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
 185       // Having the same base generator guarantees that the other
 186       // iterator is of the same type and we can downcast.
 187       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
 188           << "The program attempted to compare iterators "
 189           << "from different generators." << std::endl;
 190       const Iterator* typed_other =
 191           CheckedDowncastToActualType<const Iterator>(&other);
 192       // We must report iterators equal if they both point beyond their
 193       // respective ranges. That can happen in a variety of fashions,
 194       // so we have to consult AtEnd().
 195       return (AtEnd() && typed_other->AtEnd()) ||
 196          ($for j  && [[
 197
 198           current$(j)_ == typed_other->current$(j)_
 199 ]]);
 200     }
 201
 202    private:
 203     Iterator(const Iterator& other)
 204         : base_(other.base_), $for j, [[
 205
 206         begin$(j)_(other.begin$(j)_),
 207         end$(j)_(other.end$(j)_),
 208         current$(j)_(other.current$(j)_)
 209 ]] {
 210       ComputeCurrentValue();
 211     }
 212
 213     void ComputeCurrentValue() {
 214       if (!AtEnd())
 215         current_value_ = ParamType($for j, [[*current$(j)_]]);
 216     }
 217     bool AtEnd() const {
 218       // We must report iterator past the end of the range when either of the
 219       // component iterators has reached the end of its range.
 220       return
 221 $for j  || [[
 222
 223           current$(j)_ == end$(j)_
 224 ]];
 225     }
 226
 227     // No implementation - assignment is unsupported.
 228     void operator=(const Iterator& other);
 229
 230     const ParamGeneratorInterface<ParamType>* const base_;
 231     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
 232     // current[i]_ is the actual traversing iterator.
 233 $for j [[
 234
 235     const typename ParamGenerator<T$j>::iterator begin$(j)_;
 236     const typename ParamGenerator<T$j>::iterator end$(j)_;
 237     typename ParamGenerator<T$j>::iterator current$(j)_;
 238 ]]
 239
 240     ParamType current_value_;
 241   };  // class CartesianProductGenerator$i::Iterator
 242
 243   // No implementation - assignment is unsupported.
 244   void operator=(const CartesianProductGenerator$i& other);
 245
 246
 247 $for j [[
 248   const ParamGenerator<T$j> g$(j)_;
 249
 250 ]]
 251 };  // class CartesianProductGenerator$i
 252
 253
 254 ]]
 255
 256 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
 257 //
 258 // Helper classes providing Combine() with polymorphic features. They allow
 259 // casting CartesianProductGeneratorN<T> to ParamGenerator<U> if T is
 260 // convertible to U.
 261 //
 262 $range i 2..maxtuple
 263 $for i [[
 264 $range j 1..i
 265
 266 template <$for j, [[class Generator$j]]>
 267 class CartesianProductHolder$i {
 268  public:
 269 CartesianProductHolder$i($for j, [[const Generator$j& g$j]])
 270       : $for j, [[g$(j)_(g$j)]] {}
 271   template <$for j, [[typename T$j]]>
 272   operator ParamGenerator< ::std::tr1::tuple<$for j, [[T$j]]> >() const {
 273     return ParamGenerator< ::std::tr1::tuple<$for j, [[T$j]]> >(
 274         new CartesianProductGenerator$i<$for j, [[T$j]]>(
 275 $for j,[[
 276
 277         static_cast<ParamGenerator<T$j> >(g$(j)_)
 278 ]]));
 279   }
 280
 281  private:
 282   // No implementation - assignment is unsupported.
 283   void operator=(const CartesianProductHolder$i& other);
 284
 285
 286 $for j [[
 287   const Generator$j g$(j)_;
 288
 289 ]]
 290 };  // class CartesianProductHolder$i
 291
 292 ]]
 293
 294 # endif  // GTEST_HAS_COMBINE
 295
 296 }  // namespace internal
 297 }  // namespace testing
 298
 299 #endif  //  GTEST_HAS_PARAM_TEST
 300
 301 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_