Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
5564 | serge | 1 | $$ -*- mode: c++; -*- |
2 | $var n = 50 $$ Maximum length of type lists we want to support. |
||
3 | // Copyright 2008 Google Inc. |
||
4 | // All Rights Reserved. |
||
5 | // |
||
6 | // Redistribution and use in source and binary forms, with or without |
||
7 | // modification, are permitted provided that the following conditions are |
||
8 | // met: |
||
9 | // |
||
10 | // * Redistributions of source code must retain the above copyright |
||
11 | // notice, this list of conditions and the following disclaimer. |
||
12 | // * Redistributions in binary form must reproduce the above |
||
13 | // copyright notice, this list of conditions and the following disclaimer |
||
14 | // in the documentation and/or other materials provided with the |
||
15 | // distribution. |
||
16 | // * Neither the name of Google Inc. nor the names of its |
||
17 | // contributors may be used to endorse or promote products derived from |
||
18 | // this software without specific prior written permission. |
||
19 | // |
||
20 | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||
21 | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||
22 | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||
23 | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||
24 | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||
25 | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||
26 | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||
27 | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||
28 | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||
29 | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||
30 | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||
31 | // |
||
32 | // Author: wan@google.com (Zhanyong Wan) |
||
33 | |||
34 | // Type utilities needed for implementing typed and type-parameterized |
||
35 | // tests. This file is generated by a SCRIPT. DO NOT EDIT BY HAND! |
||
36 | // |
||
37 | // Currently we support at most $n types in a list, and at most $n |
||
38 | // type-parameterized tests in one type-parameterized test case. |
||
39 | // Please contact googletestframework@googlegroups.com if you need |
||
40 | // more. |
||
41 | |||
42 | #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ |
||
43 | #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ |
||
44 | |||
45 | #include "gtest/internal/gtest-port.h" |
||
46 | |||
47 | // #ifdef __GNUC__ is too general here. It is possible to use gcc without using |
||
48 | // libstdc++ (which is where cxxabi.h comes from). |
||
49 | # if GTEST_HAS_CXXABI_H_ |
||
50 | # include |
||
51 | # elif defined(__HP_aCC) |
||
52 | # include |
||
53 | # endif // GTEST_HASH_CXXABI_H_ |
||
54 | |||
55 | namespace testing { |
||
56 | namespace internal { |
||
57 | |||
58 | // GetTypeName |
||
59 | // NB: This function is also used in Google Mock, so don't move it inside of |
||
60 | // the typed-test-only section below. |
||
61 | template |
||
62 | std::string GetTypeName() { |
||
63 | # if GTEST_HAS_RTTI |
||
64 | |||
65 | const char* const name = typeid(T).name(); |
||
66 | # if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC) |
||
67 | int status = 0; |
||
68 | // gcc's implementation of typeid(T).name() mangles the type name, |
||
69 | // so we have to demangle it. |
||
70 | # if GTEST_HAS_CXXABI_H_ |
||
71 | using abi::__cxa_demangle; |
||
72 | # endif // GTEST_HAS_CXXABI_H_ |
||
73 | char* const readable_name = __cxa_demangle(name, 0, 0, &status); |
||
74 | const std::string name_str(status == 0 ? readable_name : name); |
||
75 | free(readable_name); |
||
76 | return name_str; |
||
77 | # else |
||
78 | return name; |
||
79 | # endif // GTEST_HAS_CXXABI_H_ || __HP_aCC |
||
80 | |||
81 | # else |
||
82 | |||
83 | return " |
||
84 | |||
85 | # endif // GTEST_HAS_RTTI |
||
86 | } |
||
87 | |||
88 | #if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P |
||
89 | |||
90 | // AssertyTypeEq |
||
91 | // type. This can be used as a compile-time assertion to ensure that |
||
92 | // two types are equal. |
||
93 | |||
94 | template |
||
95 | struct AssertTypeEq; |
||
96 | |||
97 | template |
||
98 | struct AssertTypeEq |
||
99 | typedef bool type; |
||
100 | }; |
||
101 | |||
102 | // A unique type used as the default value for the arguments of class |
||
103 | // template Types. This allows us to simulate variadic templates |
||
104 | // (e.g. Types |
||
105 | // support directly. |
||
106 | struct None {}; |
||
107 | |||
108 | // The following family of struct and struct templates are used to |
||
109 | // represent type lists. In particular, TypesN |
||
110 | // represents a type list with N types (T1, T2, ..., and TN) in it. |
||
111 | // Except for Types0, every struct in the family has two member types: |
||
112 | // Head for the first type in the list, and Tail for the rest of the |
||
113 | // list. |
||
114 | |||
115 | // The empty type list. |
||
116 | struct Types0 {}; |
||
117 | |||
118 | // Type lists of length 1, 2, 3, and so on. |
||
119 | |||
120 | template |
||
121 | struct Types1 { |
||
122 | typedef T1 Head; |
||
123 | typedef Types0 Tail; |
||
124 | }; |
||
125 | |||
126 | $range i 2..n |
||
127 | |||
128 | $for i [[ |
||
129 | $range j 1..i |
||
130 | $range k 2..i |
||
131 | template <$for j, [[typename T$j]]> |
||
132 | struct Types$i { |
||
133 | typedef T1 Head; |
||
134 | typedef Types$(i-1)<$for k, [[T$k]]> Tail; |
||
135 | }; |
||
136 | |||
137 | |||
138 | ]] |
||
139 | |||
140 | } // namespace internal |
||
141 | |||
142 | // We don't want to require the users to write TypesN<...> directly, |
||
143 | // as that would require them to count the length. Types<...> is much |
||
144 | // easier to write, but generates horrible messages when there is a |
||
145 | // compiler error, as gcc insists on printing out each template |
||
146 | // argument, even if it has the default value (this means Types |
||
147 | // will appear as Types |
||
148 | // errors). |
||
149 | // |
||
150 | // Our solution is to combine the best part of the two approaches: a |
||
151 | // user would write Types |
||
152 | // that to TypesN |
||
153 | // readable. The translation is done by the 'type' member of the |
||
154 | // Types template. |
||
155 | |||
156 | $range i 1..n |
||
157 | template <$for i, [[typename T$i = internal::None]]> |
||
158 | struct Types { |
||
159 | typedef internal::Types$n<$for i, [[T$i]]> type; |
||
160 | }; |
||
161 | |||
162 | template <> |
||
163 | struct Types<$for i, [[internal::None]]> { |
||
164 | typedef internal::Types0 type; |
||
165 | }; |
||
166 | |||
167 | $range i 1..n-1 |
||
168 | $for i [[ |
||
169 | $range j 1..i |
||
170 | $range k i+1..n |
||
171 | template <$for j, [[typename T$j]]> |
||
172 | struct Types<$for j, [[T$j]]$for k[[, internal::None]]> { |
||
173 | typedef internal::Types$i<$for j, [[T$j]]> type; |
||
174 | }; |
||
175 | |||
176 | ]] |
||
177 | |||
178 | namespace internal { |
||
179 | |||
180 | # define GTEST_TEMPLATE_ template |
||
181 | |||
182 | // The template "selector" struct TemplateSel |
||
183 | // represent Tmpl, which must be a class template with one type |
||
184 | // parameter, as a type. TemplateSel |
||
185 | // as the type Tmpl |
||
186 | // template "selected" by TemplateSel |
||
187 | // |
||
188 | // This trick is necessary for simulating typedef for class templates, |
||
189 | // which C++ doesn't support directly. |
||
190 | template |
||
191 | struct TemplateSel { |
||
192 | template |
||
193 | struct Bind { |
||
194 | typedef Tmpl |
||
195 | }; |
||
196 | }; |
||
197 | |||
198 | # define GTEST_BIND_(TmplSel, T) \ |
||
199 | TmplSel::template Bind |
||
200 | |||
201 | // A unique struct template used as the default value for the |
||
202 | // arguments of class template Templates. This allows us to simulate |
||
203 | // variadic templates (e.g. Templates |
||
204 | // and etc), which C++ doesn't support directly. |
||
205 | template |
||
206 | struct NoneT {}; |
||
207 | |||
208 | // The following family of struct and struct templates are used to |
||
209 | // represent template lists. In particular, TemplatesN |
||
210 | // TN> represents a list of N templates (T1, T2, ..., and TN). Except |
||
211 | // for Templates0, every struct in the family has two member types: |
||
212 | // Head for the selector of the first template in the list, and Tail |
||
213 | // for the rest of the list. |
||
214 | |||
215 | // The empty template list. |
||
216 | struct Templates0 {}; |
||
217 | |||
218 | // Template lists of length 1, 2, 3, and so on. |
||
219 | |||
220 | template |
||
221 | struct Templates1 { |
||
222 | typedef TemplateSel |
||
223 | typedef Templates0 Tail; |
||
224 | }; |
||
225 | |||
226 | $range i 2..n |
||
227 | |||
228 | $for i [[ |
||
229 | $range j 1..i |
||
230 | $range k 2..i |
||
231 | template <$for j, [[GTEST_TEMPLATE_ T$j]]> |
||
232 | struct Templates$i { |
||
233 | typedef TemplateSel |
||
234 | typedef Templates$(i-1)<$for k, [[T$k]]> Tail; |
||
235 | }; |
||
236 | |||
237 | |||
238 | ]] |
||
239 | |||
240 | // We don't want to require the users to write TemplatesN<...> directly, |
||
241 | // as that would require them to count the length. Templates<...> is much |
||
242 | // easier to write, but generates horrible messages when there is a |
||
243 | // compiler error, as gcc insists on printing out each template |
||
244 | // argument, even if it has the default value (this means Templates |
||
245 | // will appear as Templates |
||
246 | // errors). |
||
247 | // |
||
248 | // Our solution is to combine the best part of the two approaches: a |
||
249 | // user would write Templates |
||
250 | // that to TemplatesN |
||
251 | // readable. The translation is done by the 'type' member of the |
||
252 | // Templates template. |
||
253 | |||
254 | $range i 1..n |
||
255 | template <$for i, [[GTEST_TEMPLATE_ T$i = NoneT]]> |
||
256 | struct Templates { |
||
257 | typedef Templates$n<$for i, [[T$i]]> type; |
||
258 | }; |
||
259 | |||
260 | template <> |
||
261 | struct Templates<$for i, [[NoneT]]> { |
||
262 | typedef Templates0 type; |
||
263 | }; |
||
264 | |||
265 | $range i 1..n-1 |
||
266 | $for i [[ |
||
267 | $range j 1..i |
||
268 | $range k i+1..n |
||
269 | template <$for j, [[GTEST_TEMPLATE_ T$j]]> |
||
270 | struct Templates<$for j, [[T$j]]$for k[[, NoneT]]> { |
||
271 | typedef Templates$i<$for j, [[T$j]]> type; |
||
272 | }; |
||
273 | |||
274 | ]] |
||
275 | |||
276 | // The TypeList template makes it possible to use either a single type |
||
277 | // or a Types<...> list in TYPED_TEST_CASE() and |
||
278 | // INSTANTIATE_TYPED_TEST_CASE_P(). |
||
279 | |||
280 | template |
||
281 | struct TypeList { |
||
282 | typedef Types1 |
||
283 | }; |
||
284 | |||
285 | |||
286 | $range i 1..n |
||
287 | template <$for i, [[typename T$i]]> |
||
288 | struct TypeList |
||
289 | typedef typename Types<$for i, [[T$i]]>::type type; |
||
290 | }; |
||
291 | |||
292 | #endif // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P |
||
293 | |||
294 | } // namespace internal |
||
295 | } // namespace testing |
||
296 | |||
297 | #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_$for>$for>$for>$for>$for>$for>$for>>$for>$for>$for>$for>$for>$for>$for>$for>>$for>$for>$for>$for> |