← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/mozc/oneiric

« back to all changes in this revision

Viewing changes to third_party/gtest/include/gtest/internal/gtest-param-util-generated.h.pump

  • Committer: Bazaar Package Importer
  • Author(s): Nobuhiro Iwamatsu
  • Date: 2010-07-14 03:26:47 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100714032647-13qjisj6m8cm8jdx
Tags: 0.12.410.102-1
http://bugs.debian.org/588971
http://bugs.debian.org/588972
* New upstream release (Closes: #588971).
  - Add mozc-server, mozc-utils-gui and scim-mozc packages.
* Update debian/rules.
  Add --gypdir option to build_mozc.py.
* Update debian/control.
  - Bumped standards-version to 3.9.0.
  - Update description.
* Add mozc icon (Closes: #588972).
* Add patch which revises issue 18.
  ibus_mozc_issue18.patch
* kFreeBSD build support.
  support_kfreebsd.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
third_party/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 ::std::iterator_traits<ForwardIterator>::value_type> ValuesIn(
63
 
        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_