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#include "gtest/internal/gtest-string.h"
47
48// #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
49// libstdc++ (which is where cxxabi.h comes from).
50# ifdef __GLIBCXX__
51#  include <cxxabi.h>
52# elif defined(__HP_aCC)
53#  include <acxx_demangle.h>
54# endif  // __GLIBCXX__
55
56namespace testing {
57namespace internal {
58
59// GetTypeName<T>() returns a human-readable name of type T.
60// NB: This function is also used in Google Mock, so don't move it inside of
61// the typed-test-only section below.
62template <typename T>
63String GetTypeName() {
64# if GTEST_HAS_RTTI
65
66  const char* const name = typeid(T).name();
67#  if defined(__GLIBCXX__) || defined(__HP_aCC)
68  int status = 0;
69  // gcc's implementation of typeid(T).name() mangles the type name,
70  // so we have to demangle it.
71#   ifdef __GLIBCXX__
72  using abi::__cxa_demangle;
73#   endif // __GLIBCXX__
74  char* const readable_name = __cxa_demangle(name, 0, 0, &status);
75  const String name_str(status == 0 ? readable_name : name);
76  free(readable_name);
77  return name_str;
78#  else
79  return name;
80#  endif  // __GLIBCXX__ || __HP_aCC
81
82# else
83
84  return "<type>";
85
86# endif  // GTEST_HAS_RTTI
87}
88
89#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
90
91// AssertyTypeEq<T1, T2>::type is defined iff T1 and T2 are the same
92// type.  This can be used as a compile-time assertion to ensure that
93// two types are equal.
94
95template <typename T1, typename T2>
96struct AssertTypeEq;
97
98template <typename T>
99struct AssertTypeEq<T, T> {
100  typedef bool type;
101};
102
103// A unique type used as the default value for the arguments of class
104// template Types.  This allows us to simulate variadic templates
105// (e.g. Types<int>, Type<int, double>, and etc), which C++ doesn't
106// support directly.
107struct None {};
108
109// The following family of struct and struct templates are used to
110// represent type lists.  In particular, TypesN<T1, T2, ..., TN>
111// represents a type list with N types (T1, T2, ..., and TN) in it.
112// Except for Types0, every struct in the family has two member types:
113// Head for the first type in the list, and Tail for the rest of the
114// list.
115
116// The empty type list.
117struct Types0 {};
118
119// Type lists of length 1, 2, 3, and so on.
120
121template <typename T1>
122struct Types1 {
123  typedef T1 Head;
124  typedef Types0 Tail;
125};
126
127$range i 2..n
128
129$for i [[
130$range j 1..i
131$range k 2..i
132template <$for j, [[typename T$j]]>
133struct Types$i {
134  typedef T1 Head;
135  typedef Types$(i-1)<$for k, [[T$k]]> Tail;
136};
137
138
139]]
140
141}  // namespace internal
142
143// We don't want to require the users to write TypesN<...> directly,
144// as that would require them to count the length.  Types<...> is much
145// easier to write, but generates horrible messages when there is a
146// compiler error, as gcc insists on printing out each template
147// argument, even if it has the default value (this means Types<int>
148// will appear as Types<int, None, None, ..., None> in the compiler
149// errors).
150//
151// Our solution is to combine the best part of the two approaches: a
152// user would write Types<T1, ..., TN>, and Google Test will translate
153// that to TypesN<T1, ..., TN> internally to make error messages
154// readable.  The translation is done by the 'type' member of the
155// Types template.
156
157$range i 1..n
158template <$for i, [[typename T$i = internal::None]]>
159struct Types {
160  typedef internal::Types$n<$for i, [[T$i]]> type;
161};
162
163template <>
164struct Types<$for i, [[internal::None]]> {
165  typedef internal::Types0 type;
166};
167
168$range i 1..n-1
169$for i [[
170$range j 1..i
171$range k i+1..n
172template <$for j, [[typename T$j]]>
173struct Types<$for j, [[T$j]]$for k[[, internal::None]]> {
174  typedef internal::Types$i<$for j, [[T$j]]> type;
175};
176
177]]
178
179namespace internal {
180
181# define GTEST_TEMPLATE_ template <typename T> class
182
183// The template "selector" struct TemplateSel<Tmpl> is used to
184// represent Tmpl, which must be a class template with one type
185// parameter, as a type.  TemplateSel<Tmpl>::Bind<T>::type is defined
186// as the type Tmpl<T>.  This allows us to actually instantiate the
187// template "selected" by TemplateSel<Tmpl>.
188//
189// This trick is necessary for simulating typedef for class templates,
190// which C++ doesn't support directly.
191template <GTEST_TEMPLATE_ Tmpl>
192struct TemplateSel {
193  template <typename T>
194  struct Bind {
195    typedef Tmpl<T> type;
196  };
197};
198
199# define GTEST_BIND_(TmplSel, T) \
200  TmplSel::template Bind<T>::type
201
202// A unique struct template used as the default value for the
203// arguments of class template Templates.  This allows us to simulate
204// variadic templates (e.g. Templates<int>, Templates<int, double>,
205// and etc), which C++ doesn't support directly.
206template <typename T>
207struct NoneT {};
208
209// The following family of struct and struct templates are used to
210// represent template lists.  In particular, TemplatesN<T1, T2, ...,
211// TN> represents a list of N templates (T1, T2, ..., and TN).  Except
212// for Templates0, every struct in the family has two member types:
213// Head for the selector of the first template in the list, and Tail
214// for the rest of the list.
215
216// The empty template list.
217struct Templates0 {};
218
219// Template lists of length 1, 2, 3, and so on.
220
221template <GTEST_TEMPLATE_ T1>
222struct Templates1 {
223  typedef TemplateSel<T1> Head;
224  typedef Templates0 Tail;
225};
226
227$range i 2..n
228
229$for i [[
230$range j 1..i
231$range k 2..i
232template <$for j, [[GTEST_TEMPLATE_ T$j]]>
233struct Templates$i {
234  typedef TemplateSel<T1> Head;
235  typedef Templates$(i-1)<$for k, [[T$k]]> Tail;
236};
237
238
239]]
240
241// We don't want to require the users to write TemplatesN<...> directly,
242// as that would require them to count the length.  Templates<...> is much
243// easier to write, but generates horrible messages when there is a
244// compiler error, as gcc insists on printing out each template
245// argument, even if it has the default value (this means Templates<list>
246// will appear as Templates<list, NoneT, NoneT, ..., NoneT> in the compiler
247// errors).
248//
249// Our solution is to combine the best part of the two approaches: a
250// user would write Templates<T1, ..., TN>, and Google Test will translate
251// that to TemplatesN<T1, ..., TN> internally to make error messages
252// readable.  The translation is done by the 'type' member of the
253// Templates template.
254
255$range i 1..n
256template <$for i, [[GTEST_TEMPLATE_ T$i = NoneT]]>
257struct Templates {
258  typedef Templates$n<$for i, [[T$i]]> type;
259};
260
261template <>
262struct Templates<$for i, [[NoneT]]> {
263  typedef Templates0 type;
264};
265
266$range i 1..n-1
267$for i [[
268$range j 1..i
269$range k i+1..n
270template <$for j, [[GTEST_TEMPLATE_ T$j]]>
271struct Templates<$for j, [[T$j]]$for k[[, NoneT]]> {
272  typedef Templates$i<$for j, [[T$j]]> type;
273};
274
275]]
276
277// The TypeList template makes it possible to use either a single type
278// or a Types<...> list in TYPED_TEST_CASE() and
279// INSTANTIATE_TYPED_TEST_CASE_P().
280
281template <typename T>
282struct TypeList { typedef Types1<T> type; };
283
284
285$range i 1..n
286template <$for i, [[typename T$i]]>
287struct TypeList<Types<$for i, [[T$i]]> > {
288  typedef typename Types<$for i, [[T$i]]>::type type;
289};
290
291#endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
292
293}  // namespace internal
294}  // namespace testing
295
296#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
297