← Back to branch summary

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

« back to all changes in this revision

Viewing changes to third_party/gtest/test/gtest-typed-test_test.cc

  • 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/test/gtest-typed-test_test.cc
1
 
// Copyright 2008 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
 
// Author: wan@google.com (Zhanyong Wan)
31
 
 
32
 
#include <set>
33
 
#include <vector>
34
 
 
35
 
#include "test/gtest-typed-test_test.h"
36
 
#include <gtest/gtest.h>
37
 
 
38
 
using testing::Test;
39
 
 
40
 
// Used for testing that SetUpTestCase()/TearDownTestCase(), fixture
41
 
// ctor/dtor, and SetUp()/TearDown() work correctly in typed tests and
42
 
// type-parameterized test.
43
 
template <typename T>
44
 
class CommonTest : public Test {
45
 
  // For some technical reason, SetUpTestCase() and TearDownTestCase()
46
 
  // must be public.
47
 
 public:
48
 
  static void SetUpTestCase() {
49
 
    shared_ = new T(5);
50
 
  }
51
 
 
52
 
  static void TearDownTestCase() {
53
 
    delete shared_;
54
 
    shared_ = NULL;
55
 
  }
56
 
 
57
 
  // This 'protected:' is optional.  There's no harm in making all
58
 
  // members of this fixture class template public.
59
 
 protected:
60
 
  // We used to use std::list here, but switched to std::vector since
61
 
  // MSVC's <list> doesn't compile cleanly with /W4.
62
 
  typedef std::vector<T> Vector;
63
 
  typedef std::set<int> IntSet;
64
 
 
65
 
  CommonTest() : value_(1) {}
66
 
 
67
 
  virtual ~CommonTest() { EXPECT_EQ(3, value_); }
68
 
 
69
 
  virtual void SetUp() {
70
 
    EXPECT_EQ(1, value_);
71
 
    value_++;
72
 
  }
73
 
 
74
 
  virtual void TearDown() {
75
 
    EXPECT_EQ(2, value_);
76
 
    value_++;
77
 
  }
78
 
 
79
 
  T value_;
80
 
  static T* shared_;
81
 
};
82
 
 
83
 
template <typename T>
84
 
T* CommonTest<T>::shared_ = NULL;
85
 
 
86
 
// This #ifdef block tests typed tests.
87
 
#if GTEST_HAS_TYPED_TEST
88
 
 
89
 
using testing::Types;
90
 
 
91
 
// Tests that SetUpTestCase()/TearDownTestCase(), fixture ctor/dtor,
92
 
// and SetUp()/TearDown() work correctly in typed tests
93
 
 
94
 
typedef Types<char, int> TwoTypes;
95
 
TYPED_TEST_CASE(CommonTest, TwoTypes);
96
 
 
97
 
TYPED_TEST(CommonTest, ValuesAreCorrect) {
98
 
  // Static members of the fixture class template can be visited via
99
 
  // the TestFixture:: prefix.
100
 
  EXPECT_EQ(5, *TestFixture::shared_);
101
 
 
102
 
  // Typedefs in the fixture class template can be visited via the
103
 
  // "typename TestFixture::" prefix.
104
 
  typename TestFixture::Vector empty;
105
 
  EXPECT_EQ(0U, empty.size());
106
 
 
107
 
  typename TestFixture::IntSet empty2;
108
 
  EXPECT_EQ(0U, empty2.size());
109
 
 
110
 
  // Non-static members of the fixture class must be visited via
111
 
  // 'this', as required by C++ for class templates.
112
 
  EXPECT_EQ(2, this->value_);
113
 
}
114
 
 
115
 
// The second test makes sure shared_ is not deleted after the first
116
 
// test.
117
 
TYPED_TEST(CommonTest, ValuesAreStillCorrect) {
118
 
  // Static members of the fixture class template can also be visited
119
 
  // via 'this'.
120
 
  ASSERT_TRUE(this->shared_ != NULL);
121
 
  EXPECT_EQ(5, *this->shared_);
122
 
 
123
 
  // TypeParam can be used to refer to the type parameter.
124
 
  EXPECT_EQ(static_cast<TypeParam>(2), this->value_);
125
 
}
126
 
 
127
 
// Tests that multiple TYPED_TEST_CASE's can be defined in the same
128
 
// translation unit.
129
 
 
130
 
template <typename T>
131
 
class TypedTest1 : public Test {
132
 
};
133
 
 
134
 
// Verifies that the second argument of TYPED_TEST_CASE can be a
135
 
// single type.
136
 
TYPED_TEST_CASE(TypedTest1, int);
137
 
TYPED_TEST(TypedTest1, A) {}
138
 
 
139
 
template <typename T>
140
 
class TypedTest2 : public Test {
141
 
};
142
 
 
143
 
// Verifies that the second argument of TYPED_TEST_CASE can be a
144
 
// Types<...> type list.
145
 
TYPED_TEST_CASE(TypedTest2, Types<int>);
146
 
 
147
 
// This also verifies that tests from different typed test cases can
148
 
// share the same name.
149
 
TYPED_TEST(TypedTest2, A) {}
150
 
 
151
 
// Tests that a typed test case can be defined in a namespace.
152
 
 
153
 
namespace library1 {
154
 
 
155
 
template <typename T>
156
 
class NumericTest : public Test {
157
 
};
158
 
 
159
 
typedef Types<int, long> NumericTypes;
160
 
TYPED_TEST_CASE(NumericTest, NumericTypes);
161
 
 
162
 
TYPED_TEST(NumericTest, DefaultIsZero) {
163
 
  EXPECT_EQ(0, TypeParam());
164
 
}
165
 
 
166
 
}  // namespace library1
167
 
 
168
 
#endif  // GTEST_HAS_TYPED_TEST
169
 
 
170
 
// This #ifdef block tests type-parameterized tests.
171
 
#if GTEST_HAS_TYPED_TEST_P
172
 
 
173
 
using testing::Types;
174
 
using testing::internal::TypedTestCasePState;
175
 
 
176
 
// Tests TypedTestCasePState.
177
 
 
178
 
class TypedTestCasePStateTest : public Test {
179
 
 protected:
180
 
  virtual void SetUp() {
181
 
    state_.AddTestName("foo.cc", 0, "FooTest", "A");
182
 
    state_.AddTestName("foo.cc", 0, "FooTest", "B");
183
 
    state_.AddTestName("foo.cc", 0, "FooTest", "C");
184
 
  }
185
 
 
186
 
  TypedTestCasePState state_;
187
 
};
188
 
 
189
 
TEST_F(TypedTestCasePStateTest, SucceedsForMatchingList) {
190
 
  const char* tests = "A, B, C";
191
 
  EXPECT_EQ(tests,
192
 
            state_.VerifyRegisteredTestNames("foo.cc", 1, tests));
193
 
}
194
 
 
195
 
// Makes sure that the order of the tests and spaces around the names
196
 
// don't matter.
197
 
TEST_F(TypedTestCasePStateTest, IgnoresOrderAndSpaces) {
198
 
  const char* tests = "A,C,   B";
199
 
  EXPECT_EQ(tests,
200
 
            state_.VerifyRegisteredTestNames("foo.cc", 1, tests));
201
 
}
202
 
 
203
 
typedef TypedTestCasePStateTest TypedTestCasePStateDeathTest;
204
 
 
205
 
TEST_F(TypedTestCasePStateDeathTest, DetectsDuplicates) {
206
 
  EXPECT_DEATH_IF_SUPPORTED(
207
 
      state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, A, C"),
208
 
      "foo\\.cc.1.?: Test A is listed more than once\\.");
209
 
}
210
 
 
211
 
TEST_F(TypedTestCasePStateDeathTest, DetectsExtraTest) {
212
 
  EXPECT_DEATH_IF_SUPPORTED(
213
 
      state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, C, D"),
214
 
      "foo\\.cc.1.?: No test named D can be found in this test case\\.");
215
 
}
216
 
 
217
 
TEST_F(TypedTestCasePStateDeathTest, DetectsMissedTest) {
218
 
  EXPECT_DEATH_IF_SUPPORTED(
219
 
      state_.VerifyRegisteredTestNames("foo.cc", 1, "A, C"),
220
 
      "foo\\.cc.1.?: You forgot to list test B\\.");
221
 
}
222
 
 
223
 
// Tests that defining a test for a parameterized test case generates
224
 
// a run-time error if the test case has been registered.
225
 
TEST_F(TypedTestCasePStateDeathTest, DetectsTestAfterRegistration) {
226
 
  state_.VerifyRegisteredTestNames("foo.cc", 1, "A, B, C");
227
 
  EXPECT_DEATH_IF_SUPPORTED(
228
 
      state_.AddTestName("foo.cc", 2, "FooTest", "D"),
229
 
      "foo\\.cc.2.?: Test D must be defined before REGISTER_TYPED_TEST_CASE_P"
230
 
      "\\(FooTest, \\.\\.\\.\\)\\.");
231
 
}
232
 
 
233
 
// Tests that SetUpTestCase()/TearDownTestCase(), fixture ctor/dtor,
234
 
// and SetUp()/TearDown() work correctly in type-parameterized tests.
235
 
 
236
 
template <typename T>
237
 
class DerivedTest : public CommonTest<T> {
238
 
};
239
 
 
240
 
TYPED_TEST_CASE_P(DerivedTest);
241
 
 
242
 
TYPED_TEST_P(DerivedTest, ValuesAreCorrect) {
243
 
  // Static members of the fixture class template can be visited via
244
 
  // the TestFixture:: prefix.
245
 
  EXPECT_EQ(5, *TestFixture::shared_);
246
 
 
247
 
  // Non-static members of the fixture class must be visited via
248
 
  // 'this', as required by C++ for class templates.
249
 
  EXPECT_EQ(2, this->value_);
250
 
}
251
 
 
252
 
// The second test makes sure shared_ is not deleted after the first
253
 
// test.
254
 
TYPED_TEST_P(DerivedTest, ValuesAreStillCorrect) {
255
 
  // Static members of the fixture class template can also be visited
256
 
  // via 'this'.
257
 
  ASSERT_TRUE(this->shared_ != NULL);
258
 
  EXPECT_EQ(5, *this->shared_);
259
 
  EXPECT_EQ(2, this->value_);
260
 
}
261
 
 
262
 
REGISTER_TYPED_TEST_CASE_P(DerivedTest,
263
 
                           ValuesAreCorrect, ValuesAreStillCorrect);
264
 
 
265
 
typedef Types<short, long> MyTwoTypes;
266
 
INSTANTIATE_TYPED_TEST_CASE_P(My, DerivedTest, MyTwoTypes);
267
 
 
268
 
// Tests that multiple TYPED_TEST_CASE_P's can be defined in the same
269
 
// translation unit.
270
 
 
271
 
template <typename T>
272
 
class TypedTestP1 : public Test {
273
 
};
274
 
 
275
 
TYPED_TEST_CASE_P(TypedTestP1);
276
 
 
277
 
// For testing that the code between TYPED_TEST_CASE_P() and
278
 
// TYPED_TEST_P() is not enclosed in a namespace.
279
 
typedef int IntAfterTypedTestCaseP;
280
 
 
281
 
TYPED_TEST_P(TypedTestP1, A) {}
282
 
TYPED_TEST_P(TypedTestP1, B) {}
283
 
 
284
 
// For testing that the code between TYPED_TEST_P() and
285
 
// REGISTER_TYPED_TEST_CASE_P() is not enclosed in a namespace.
286
 
typedef int IntBeforeRegisterTypedTestCaseP;
287
 
 
288
 
REGISTER_TYPED_TEST_CASE_P(TypedTestP1, A, B);
289
 
 
290
 
template <typename T>
291
 
class TypedTestP2 : public Test {
292
 
};
293
 
 
294
 
TYPED_TEST_CASE_P(TypedTestP2);
295
 
 
296
 
// This also verifies that tests from different type-parameterized
297
 
// test cases can share the same name.
298
 
TYPED_TEST_P(TypedTestP2, A) {}
299
 
 
300
 
REGISTER_TYPED_TEST_CASE_P(TypedTestP2, A);
301
 
 
302
 
// Verifies that the code between TYPED_TEST_CASE_P() and
303
 
// REGISTER_TYPED_TEST_CASE_P() is not enclosed in a namespace.
304
 
IntAfterTypedTestCaseP after = 0;
305
 
IntBeforeRegisterTypedTestCaseP before = 0;
306
 
 
307
 
// Verifies that the last argument of INSTANTIATE_TYPED_TEST_CASE_P()
308
 
// can be either a single type or a Types<...> type list.
309
 
INSTANTIATE_TYPED_TEST_CASE_P(Int, TypedTestP1, int);
310
 
INSTANTIATE_TYPED_TEST_CASE_P(Int, TypedTestP2, Types<int>);
311
 
 
312
 
// Tests that the same type-parameterized test case can be
313
 
// instantiated more than once in the same translation unit.
314
 
INSTANTIATE_TYPED_TEST_CASE_P(Double, TypedTestP2, Types<double>);
315
 
 
316
 
// Tests that the same type-parameterized test case can be
317
 
// instantiated in different translation units linked together.
318
 
// (ContainerTest is also instantiated in gtest-typed-test_test.cc.)
319
 
typedef Types<std::vector<double>, std::set<char> > MyContainers;
320
 
INSTANTIATE_TYPED_TEST_CASE_P(My, ContainerTest, MyContainers);
321
 
 
322
 
// Tests that a type-parameterized test case can be defined and
323
 
// instantiated in a namespace.
324
 
 
325
 
namespace library2 {
326
 
 
327
 
template <typename T>
328
 
class NumericTest : public Test {
329
 
};
330
 
 
331
 
TYPED_TEST_CASE_P(NumericTest);
332
 
 
333
 
TYPED_TEST_P(NumericTest, DefaultIsZero) {
334
 
  EXPECT_EQ(0, TypeParam());
335
 
}
336
 
 
337
 
TYPED_TEST_P(NumericTest, ZeroIsLessThanOne) {
338
 
  EXPECT_LT(TypeParam(0), TypeParam(1));
339
 
}
340
 
 
341
 
REGISTER_TYPED_TEST_CASE_P(NumericTest,
342
 
                           DefaultIsZero, ZeroIsLessThanOne);
343
 
typedef Types<int, double> NumericTypes;
344
 
INSTANTIATE_TYPED_TEST_CASE_P(My, NumericTest, NumericTypes);
345
 
 
346
 
}  // namespace library2
347
 
 
348
 
#endif  // GTEST_HAS_TYPED_TEST_P
349
 
 
350
 
#if !defined(GTEST_HAS_TYPED_TEST) && !defined(GTEST_HAS_TYPED_TEST_P)
351
 
 
352
 
// Google Test may not support type-parameterized tests with some
353
 
// compilers. If we use conditional compilation to compile out all
354
 
// code referring to the gtest_main library, MSVC linker will not link
355
 
// that library at all and consequently complain about missing entry
356
 
// point defined in that library (fatal error LNK1561: entry point
357
 
// must be defined). This dummy test keeps gtest_main linked in.
358
 
TEST(DummyTest, TypedTestsAreNotSupportedOnThisPlatform) {}
359
 
 
360
 
#endif  // #if !defined(GTEST_HAS_TYPED_TEST) && !defined(GTEST_HAS_TYPED_TEST_P)