OpenCores
URL https://opencores.org/ocsvn/s80186/s80186/trunk

Subversion Repositories s80186

[/] [s80186/] [trunk/] [vendor/] [googletest/] [googletest/] [include/] [gtest/] [gtest-typed-test.h] - Blame information for rev 2

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 2 jamieiles
// 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
#ifndef GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
33
#define GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
34
 
35
// This header implements typed tests and type-parameterized tests.
36
 
37
// Typed (aka type-driven) tests repeat the same test for types in a
38
// list.  You must know which types you want to test with when writing
39
// typed tests. Here's how you do it:
40
 
41
#if 0
42
 
43
// First, define a fixture class template.  It should be parameterized
44
// by a type.  Remember to derive it from testing::Test.
45
template <typename T>
46
class FooTest : public testing::Test {
47
 public:
48
  ...
49
  typedef std::list<T> List;
50
  static T shared_;
51
  T value_;
52
};
53
 
54
// Next, associate a list of types with the test case, which will be
55
// repeated for each type in the list.  The typedef is necessary for
56
// the macro to parse correctly.
57
typedef testing::Types<char, int, unsigned int> MyTypes;
58
TYPED_TEST_CASE(FooTest, MyTypes);
59
 
60
// If the type list contains only one type, you can write that type
61
// directly without Types<...>:
62
//   TYPED_TEST_CASE(FooTest, int);
63
 
64
// Then, use TYPED_TEST() instead of TEST_F() to define as many typed
65
// tests for this test case as you want.
66
TYPED_TEST(FooTest, DoesBlah) {
67
  // Inside a test, refer to TypeParam to get the type parameter.
68
  // Since we are inside a derived class template, C++ requires use to
69
  // visit the members of FooTest via 'this'.
70
  TypeParam n = this->value_;
71
 
72
  // To visit static members of the fixture, add the TestFixture::
73
  // prefix.
74
  n += TestFixture::shared_;
75
 
76
  // To refer to typedefs in the fixture, add the "typename
77
  // TestFixture::" prefix.
78
  typename TestFixture::List values;
79
  values.push_back(n);
80
  ...
81
}
82
 
83
TYPED_TEST(FooTest, HasPropertyA) { ... }
84
 
85
#endif  // 0
86
 
87
// Type-parameterized tests are abstract test patterns parameterized
88
// by a type.  Compared with typed tests, type-parameterized tests
89
// allow you to define the test pattern without knowing what the type
90
// parameters are.  The defined pattern can be instantiated with
91
// different types any number of times, in any number of translation
92
// units.
93
//
94
// If you are designing an interface or concept, you can define a
95
// suite of type-parameterized tests to verify properties that any
96
// valid implementation of the interface/concept should have.  Then,
97
// each implementation can easily instantiate the test suite to verify
98
// that it conforms to the requirements, without having to write
99
// similar tests repeatedly.  Here's an example:
100
 
101
#if 0
102
 
103
// First, define a fixture class template.  It should be parameterized
104
// by a type.  Remember to derive it from testing::Test.
105
template <typename T>
106
class FooTest : public testing::Test {
107
  ...
108
};
109
 
110
// Next, declare that you will define a type-parameterized test case
111
// (the _P suffix is for "parameterized" or "pattern", whichever you
112
// prefer):
113
TYPED_TEST_CASE_P(FooTest);
114
 
115
// Then, use TYPED_TEST_P() to define as many type-parameterized tests
116
// for this type-parameterized test case as you want.
117
TYPED_TEST_P(FooTest, DoesBlah) {
118
  // Inside a test, refer to TypeParam to get the type parameter.
119
  TypeParam n = 0;
120
  ...
121
}
122
 
123
TYPED_TEST_P(FooTest, HasPropertyA) { ... }
124
 
125
// Now the tricky part: you need to register all test patterns before
126
// you can instantiate them.  The first argument of the macro is the
127
// test case name; the rest are the names of the tests in this test
128
// case.
129
REGISTER_TYPED_TEST_CASE_P(FooTest,
130
                           DoesBlah, HasPropertyA);
131
 
132
// Finally, you are free to instantiate the pattern with the types you
133
// want.  If you put the above code in a header file, you can #include
134
// it in multiple C++ source files and instantiate it multiple times.
135
//
136
// To distinguish different instances of the pattern, the first
137
// argument to the INSTANTIATE_* macro is a prefix that will be added
138
// to the actual test case name.  Remember to pick unique prefixes for
139
// different instances.
140
typedef testing::Types<char, int, unsigned int> MyTypes;
141
INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
142
 
143
// If the type list contains only one type, you can write that type
144
// directly without Types<...>:
145
//   INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
146
 
147
#endif  // 0
148
 
149
#include "gtest/internal/gtest-port.h"
150
#include "gtest/internal/gtest-type-util.h"
151
 
152
// Implements typed tests.
153
 
154
#if GTEST_HAS_TYPED_TEST
155
 
156
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
157
//
158
// Expands to the name of the typedef for the type parameters of the
159
// given test case.
160
# define GTEST_TYPE_PARAMS_(TestCaseName) gtest_type_params_##TestCaseName##_
161
 
162
// The 'Types' template argument below must have spaces around it
163
// since some compilers may choke on '>>' when passing a template
164
// instance (e.g. Types<int>)
165
# define TYPED_TEST_CASE(CaseName, Types) \
166
  typedef ::testing::internal::TypeList< Types >::type \
167
      GTEST_TYPE_PARAMS_(CaseName)
168
 
169
# define TYPED_TEST(CaseName, TestName) \
170
  template <typename gtest_TypeParam_> \
171
  class GTEST_TEST_CLASS_NAME_(CaseName, TestName) \
172
      : public CaseName<gtest_TypeParam_> { \
173
   private: \
174
    typedef CaseName<gtest_TypeParam_> TestFixture; \
175
    typedef gtest_TypeParam_ TypeParam; \
176
    virtual void TestBody(); \
177
  }; \
178
  bool gtest_##CaseName##_##TestName##_registered_ GTEST_ATTRIBUTE_UNUSED_ = \
179
      ::testing::internal::TypeParameterizedTest< \
180
          CaseName, \
181
          ::testing::internal::TemplateSel< \
182
              GTEST_TEST_CLASS_NAME_(CaseName, TestName)>, \
183
          GTEST_TYPE_PARAMS_(CaseName)>::Register(\
184
              "", ::testing::internal::CodeLocation(__FILE__, __LINE__), \
185
              #CaseName, #TestName, 0); \
186
  template <typename gtest_TypeParam_> \
187
  void GTEST_TEST_CLASS_NAME_(CaseName, TestName)<gtest_TypeParam_>::TestBody()
188
 
189
#endif  // GTEST_HAS_TYPED_TEST
190
 
191
// Implements type-parameterized tests.
192
 
193
#if GTEST_HAS_TYPED_TEST_P
194
 
195
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
196
//
197
// Expands to the namespace name that the type-parameterized tests for
198
// the given type-parameterized test case are defined in.  The exact
199
// name of the namespace is subject to change without notice.
200
# define GTEST_CASE_NAMESPACE_(TestCaseName) \
201
  gtest_case_##TestCaseName##_
202
 
203
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
204
//
205
// Expands to the name of the variable used to remember the names of
206
// the defined tests in the given test case.
207
# define GTEST_TYPED_TEST_CASE_P_STATE_(TestCaseName) \
208
  gtest_typed_test_case_p_state_##TestCaseName##_
209
 
210
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY.
211
//
212
// Expands to the name of the variable used to remember the names of
213
// the registered tests in the given test case.
214
# define GTEST_REGISTERED_TEST_NAMES_(TestCaseName) \
215
  gtest_registered_test_names_##TestCaseName##_
216
 
217
// The variables defined in the type-parameterized test macros are
218
// static as typically these macros are used in a .h file that can be
219
// #included in multiple translation units linked together.
220
# define TYPED_TEST_CASE_P(CaseName) \
221
  static ::testing::internal::TypedTestCasePState \
222
      GTEST_TYPED_TEST_CASE_P_STATE_(CaseName)
223
 
224
# define TYPED_TEST_P(CaseName, TestName) \
225
  namespace GTEST_CASE_NAMESPACE_(CaseName) { \
226
  template <typename gtest_TypeParam_> \
227
  class TestName : public CaseName<gtest_TypeParam_> { \
228
   private: \
229
    typedef CaseName<gtest_TypeParam_> TestFixture; \
230
    typedef gtest_TypeParam_ TypeParam; \
231
    virtual void TestBody(); \
232
  }; \
233
  static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
234
      GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).AddTestName(\
235
          __FILE__, __LINE__, #CaseName, #TestName); \
236
  } \
237
  template <typename gtest_TypeParam_> \
238
  void GTEST_CASE_NAMESPACE_(CaseName)::TestName<gtest_TypeParam_>::TestBody()
239
 
240
# define REGISTER_TYPED_TEST_CASE_P(CaseName, ...) \
241
  namespace GTEST_CASE_NAMESPACE_(CaseName) { \
242
  typedef ::testing::internal::Templates<__VA_ARGS__>::type gtest_AllTests_; \
243
  } \
244
  static const char* const GTEST_REGISTERED_TEST_NAMES_(CaseName) = \
245
      GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).VerifyRegisteredTestNames(\
246
          __FILE__, __LINE__, #__VA_ARGS__)
247
 
248
// The 'Types' template argument below must have spaces around it
249
// since some compilers may choke on '>>' when passing a template
250
// instance (e.g. Types<int>)
251
# define INSTANTIATE_TYPED_TEST_CASE_P(Prefix, CaseName, Types) \
252
  bool gtest_##Prefix##_##CaseName GTEST_ATTRIBUTE_UNUSED_ = \
253
      ::testing::internal::TypeParameterizedTestCase<CaseName, \
254
          GTEST_CASE_NAMESPACE_(CaseName)::gtest_AllTests_, \
255
          ::testing::internal::TypeList< Types >::type>::Register(\
256
              #Prefix, \
257
              ::testing::internal::CodeLocation(__FILE__, __LINE__), \
258
              &GTEST_TYPED_TEST_CASE_P_STATE_(CaseName), \
259
              #CaseName, GTEST_REGISTERED_TEST_NAMES_(CaseName))
260
 
261
#endif  // GTEST_HAS_TYPED_TEST_P
262
 
263
#endif  // GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.