← 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/gtest_pred_impl.h

  • 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/gtest_pred_impl.h
1
 
// Copyright 2006, 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
 
// This file is AUTOMATICALLY GENERATED on 10/02/2008 by command
31
 
// 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
32
 
//
33
 
// Implements a family of generic predicate assertion macros.
34
 
 
35
 
#ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
36
 
#define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
37
 
 
38
 
// Makes sure this header is not included before gtest.h.
39
 
#ifndef GTEST_INCLUDE_GTEST_GTEST_H_
40
 
#error Do not include gtest_pred_impl.h directly.  Include gtest.h instead.
41
 
#endif  // GTEST_INCLUDE_GTEST_GTEST_H_
42
 
 
43
 
// This header implements a family of generic predicate assertion
44
 
// macros:
45
 
//
46
 
//   ASSERT_PRED_FORMAT1(pred_format, v1)
47
 
//   ASSERT_PRED_FORMAT2(pred_format, v1, v2)
48
 
//   ...
49
 
//
50
 
// where pred_format is a function or functor that takes n (in the
51
 
// case of ASSERT_PRED_FORMATn) values and their source expression
52
 
// text, and returns a testing::AssertionResult.  See the definition
53
 
// of ASSERT_EQ in gtest.h for an example.
54
 
//
55
 
// If you don't care about formatting, you can use the more
56
 
// restrictive version:
57
 
//
58
 
//   ASSERT_PRED1(pred, v1)
59
 
//   ASSERT_PRED2(pred, v1, v2)
60
 
//   ...
61
 
//
62
 
// where pred is an n-ary function or functor that returns bool,
63
 
// and the values v1, v2, ..., must support the << operator for
64
 
// streaming to std::ostream.
65
 
//
66
 
// We also define the EXPECT_* variations.
67
 
//
68
 
// For now we only support predicates whose arity is at most 5.
69
 
// Please email googletestframework@googlegroups.com if you need
70
 
// support for higher arities.
71
 
 
72
 
// GTEST_ASSERT_ is the basic statement to which all of the assertions
73
 
// in this file reduce.  Don't use this in your code.
74
 
 
75
 
#define GTEST_ASSERT_(expression, on_failure) \
76
 
  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
77
 
  if (const ::testing::AssertionResult gtest_ar = (expression)) \
78
 
    ; \
79
 
  else \
80
 
    on_failure(gtest_ar.failure_message())
81
 
 
82
 
 
83
 
// Helper function for implementing {EXPECT|ASSERT}_PRED1.  Don't use
84
 
// this in your code.
85
 
template <typename Pred,
86
 
          typename T1>
87
 
AssertionResult AssertPred1Helper(const char* pred_text,
88
 
                                  const char* e1,
89
 
                                  Pred pred,
90
 
                                  const T1& v1) {
91
 
  if (pred(v1)) return AssertionSuccess();
92
 
 
93
 
  Message msg;
94
 
  msg << pred_text << "("
95
 
      << e1 << ") evaluates to false, where"
96
 
      << "\n" << e1 << " evaluates to " << v1;
97
 
  return AssertionFailure(msg);
98
 
}
99
 
 
100
 
// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
101
 
// Don't use this in your code.
102
 
#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\
103
 
  GTEST_ASSERT_(pred_format(#v1, v1),\
104
 
                on_failure)
105
 
 
106
 
// Internal macro for implementing {EXPECT|ASSERT}_PRED1.  Don't use
107
 
// this in your code.
108
 
#define GTEST_PRED1_(pred, v1, on_failure)\
109
 
  GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \
110
 
                                             #v1, \
111
 
                                             pred, \
112
 
                                             v1), on_failure)
113
 
 
114
 
// Unary predicate assertion macros.
115
 
#define EXPECT_PRED_FORMAT1(pred_format, v1) \
116
 
  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_)
117
 
#define EXPECT_PRED1(pred, v1) \
118
 
  GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_)
119
 
#define ASSERT_PRED_FORMAT1(pred_format, v1) \
120
 
  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_)
121
 
#define ASSERT_PRED1(pred, v1) \
122
 
  GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_)
123
 
 
124
 
 
125
 
 
126
 
// Helper function for implementing {EXPECT|ASSERT}_PRED2.  Don't use
127
 
// this in your code.
128
 
template <typename Pred,
129
 
          typename T1,
130
 
          typename T2>
131
 
AssertionResult AssertPred2Helper(const char* pred_text,
132
 
                                  const char* e1,
133
 
                                  const char* e2,
134
 
                                  Pred pred,
135
 
                                  const T1& v1,
136
 
                                  const T2& v2) {
137
 
  if (pred(v1, v2)) return AssertionSuccess();
138
 
 
139
 
  Message msg;
140
 
  msg << pred_text << "("
141
 
      << e1 << ", "
142
 
      << e2 << ") evaluates to false, where"
143
 
      << "\n" << e1 << " evaluates to " << v1
144
 
      << "\n" << e2 << " evaluates to " << v2;
145
 
  return AssertionFailure(msg);
146
 
}
147
 
 
148
 
// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
149
 
// Don't use this in your code.
150
 
#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\
151
 
  GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2),\
152
 
                on_failure)
153
 
 
154
 
// Internal macro for implementing {EXPECT|ASSERT}_PRED2.  Don't use
155
 
// this in your code.
156
 
#define GTEST_PRED2_(pred, v1, v2, on_failure)\
157
 
  GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \
158
 
                                             #v1, \
159
 
                                             #v2, \
160
 
                                             pred, \
161
 
                                             v1, \
162
 
                                             v2), on_failure)
163
 
 
164
 
// Binary predicate assertion macros.
165
 
#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \
166
 
  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_)
167
 
#define EXPECT_PRED2(pred, v1, v2) \
168
 
  GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_)
169
 
#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \
170
 
  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_)
171
 
#define ASSERT_PRED2(pred, v1, v2) \
172
 
  GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_)
173
 
 
174
 
 
175
 
 
176
 
// Helper function for implementing {EXPECT|ASSERT}_PRED3.  Don't use
177
 
// this in your code.
178
 
template <typename Pred,
179
 
          typename T1,
180
 
          typename T2,
181
 
          typename T3>
182
 
AssertionResult AssertPred3Helper(const char* pred_text,
183
 
                                  const char* e1,
184
 
                                  const char* e2,
185
 
                                  const char* e3,
186
 
                                  Pred pred,
187
 
                                  const T1& v1,
188
 
                                  const T2& v2,
189
 
                                  const T3& v3) {
190
 
  if (pred(v1, v2, v3)) return AssertionSuccess();
191
 
 
192
 
  Message msg;
193
 
  msg << pred_text << "("
194
 
      << e1 << ", "
195
 
      << e2 << ", "
196
 
      << e3 << ") evaluates to false, where"
197
 
      << "\n" << e1 << " evaluates to " << v1
198
 
      << "\n" << e2 << " evaluates to " << v2
199
 
      << "\n" << e3 << " evaluates to " << v3;
200
 
  return AssertionFailure(msg);
201
 
}
202
 
 
203
 
// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
204
 
// Don't use this in your code.
205
 
#define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\
206
 
  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3),\
207
 
                on_failure)
208
 
 
209
 
// Internal macro for implementing {EXPECT|ASSERT}_PRED3.  Don't use
210
 
// this in your code.
211
 
#define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\
212
 
  GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \
213
 
                                             #v1, \
214
 
                                             #v2, \
215
 
                                             #v3, \
216
 
                                             pred, \
217
 
                                             v1, \
218
 
                                             v2, \
219
 
                                             v3), on_failure)
220
 
 
221
 
// Ternary predicate assertion macros.
222
 
#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \
223
 
  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
224
 
#define EXPECT_PRED3(pred, v1, v2, v3) \
225
 
  GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
226
 
#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \
227
 
  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_)
228
 
#define ASSERT_PRED3(pred, v1, v2, v3) \
229
 
  GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_)
230
 
 
231
 
 
232
 
 
233
 
// Helper function for implementing {EXPECT|ASSERT}_PRED4.  Don't use
234
 
// this in your code.
235
 
template <typename Pred,
236
 
          typename T1,
237
 
          typename T2,
238
 
          typename T3,
239
 
          typename T4>
240
 
AssertionResult AssertPred4Helper(const char* pred_text,
241
 
                                  const char* e1,
242
 
                                  const char* e2,
243
 
                                  const char* e3,
244
 
                                  const char* e4,
245
 
                                  Pred pred,
246
 
                                  const T1& v1,
247
 
                                  const T2& v2,
248
 
                                  const T3& v3,
249
 
                                  const T4& v4) {
250
 
  if (pred(v1, v2, v3, v4)) return AssertionSuccess();
251
 
 
252
 
  Message msg;
253
 
  msg << pred_text << "("
254
 
      << e1 << ", "
255
 
      << e2 << ", "
256
 
      << e3 << ", "
257
 
      << e4 << ") evaluates to false, where"
258
 
      << "\n" << e1 << " evaluates to " << v1
259
 
      << "\n" << e2 << " evaluates to " << v2
260
 
      << "\n" << e3 << " evaluates to " << v3
261
 
      << "\n" << e4 << " evaluates to " << v4;
262
 
  return AssertionFailure(msg);
263
 
}
264
 
 
265
 
// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
266
 
// Don't use this in your code.
267
 
#define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\
268
 
  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4),\
269
 
                on_failure)
270
 
 
271
 
// Internal macro for implementing {EXPECT|ASSERT}_PRED4.  Don't use
272
 
// this in your code.
273
 
#define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\
274
 
  GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \
275
 
                                             #v1, \
276
 
                                             #v2, \
277
 
                                             #v3, \
278
 
                                             #v4, \
279
 
                                             pred, \
280
 
                                             v1, \
281
 
                                             v2, \
282
 
                                             v3, \
283
 
                                             v4), on_failure)
284
 
 
285
 
// 4-ary predicate assertion macros.
286
 
#define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
287
 
  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
288
 
#define EXPECT_PRED4(pred, v1, v2, v3, v4) \
289
 
  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
290
 
#define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
291
 
  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
292
 
#define ASSERT_PRED4(pred, v1, v2, v3, v4) \
293
 
  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
294
 
 
295
 
 
296
 
 
297
 
// Helper function for implementing {EXPECT|ASSERT}_PRED5.  Don't use
298
 
// this in your code.
299
 
template <typename Pred,
300
 
          typename T1,
301
 
          typename T2,
302
 
          typename T3,
303
 
          typename T4,
304
 
          typename T5>
305
 
AssertionResult AssertPred5Helper(const char* pred_text,
306
 
                                  const char* e1,
307
 
                                  const char* e2,
308
 
                                  const char* e3,
309
 
                                  const char* e4,
310
 
                                  const char* e5,
311
 
                                  Pred pred,
312
 
                                  const T1& v1,
313
 
                                  const T2& v2,
314
 
                                  const T3& v3,
315
 
                                  const T4& v4,
316
 
                                  const T5& v5) {
317
 
  if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess();
318
 
 
319
 
  Message msg;
320
 
  msg << pred_text << "("
321
 
      << e1 << ", "
322
 
      << e2 << ", "
323
 
      << e3 << ", "
324
 
      << e4 << ", "
325
 
      << e5 << ") evaluates to false, where"
326
 
      << "\n" << e1 << " evaluates to " << v1
327
 
      << "\n" << e2 << " evaluates to " << v2
328
 
      << "\n" << e3 << " evaluates to " << v3
329
 
      << "\n" << e4 << " evaluates to " << v4
330
 
      << "\n" << e5 << " evaluates to " << v5;
331
 
  return AssertionFailure(msg);
332
 
}
333
 
 
334
 
// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
335
 
// Don't use this in your code.
336
 
#define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\
337
 
  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5),\
338
 
                on_failure)
339
 
 
340
 
// Internal macro for implementing {EXPECT|ASSERT}_PRED5.  Don't use
341
 
// this in your code.
342
 
#define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\
343
 
  GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \
344
 
                                             #v1, \
345
 
                                             #v2, \
346
 
                                             #v3, \
347
 
                                             #v4, \
348
 
                                             #v5, \
349
 
                                             pred, \
350
 
                                             v1, \
351
 
                                             v2, \
352
 
                                             v3, \
353
 
                                             v4, \
354
 
                                             v5), on_failure)
355
 
 
356
 
// 5-ary predicate assertion macros.
357
 
#define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
358
 
  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
359
 
#define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \
360
 
  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
361
 
#define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
362
 
  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
363
 
#define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \
364
 
  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
365
 
 
366
 
 
367
 
 
368
 
#endif  // GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_