gtest.h
Go to the documentation of this file.
1 // Copyright 2005, 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 // The Google C++ Testing Framework (Google Test)
33 //
34 // This header file defines the public API for Google Test. It should be
35 // included by any test program that uses Google Test.
36 //
37 // IMPORTANT NOTE: Due to limitation of the C++ language, we have to
38 // leave some internal implementation details in this header file.
39 // They are clearly marked by comments like this:
40 //
41 // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
42 //
43 // Such code is NOT meant to be used by a user directly, and is subject
44 // to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user
45 // program!
46 //
47 // Acknowledgment: Google Test borrowed the idea of automatic test
48 // registration from Barthelemy Dagenais' (barthelemy@prologique.com)
49 // easyUnit framework.
50 
51 #ifndef GTEST_INCLUDE_GTEST_GTEST_H_
52 #define GTEST_INCLUDE_GTEST_GTEST_H_
53 
54 #include <limits>
55 #include <ostream>
56 #include <vector>
57 
58 // Copyright 2005, Google Inc.
59 // All rights reserved.
60 //
61 // Redistribution and use in source and binary forms, with or without
62 // modification, are permitted provided that the following conditions are
63 // met:
64 //
65 // * Redistributions of source code must retain the above copyright
66 // notice, this list of conditions and the following disclaimer.
67 // * Redistributions in binary form must reproduce the above
68 // copyright notice, this list of conditions and the following disclaimer
69 // in the documentation and/or other materials provided with the
70 // distribution.
71 // * Neither the name of Google Inc. nor the names of its
72 // contributors may be used to endorse or promote products derived from
73 // this software without specific prior written permission.
74 //
75 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
76 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
77 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
78 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
79 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
80 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
81 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
82 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
83 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
84 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
85 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
86 //
87 // Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
88 //
89 // The Google C++ Testing Framework (Google Test)
90 //
91 // This header file declares functions and macros used internally by
92 // Google Test. They are subject to change without notice.
93 
94 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
95 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
96 
97 // Copyright 2005, Google Inc.
98 // All rights reserved.
99 //
100 // Redistribution and use in source and binary forms, with or without
101 // modification, are permitted provided that the following conditions are
102 // met:
103 //
104 // * Redistributions of source code must retain the above copyright
105 // notice, this list of conditions and the following disclaimer.
106 // * Redistributions in binary form must reproduce the above
107 // copyright notice, this list of conditions and the following disclaimer
108 // in the documentation and/or other materials provided with the
109 // distribution.
110 // * Neither the name of Google Inc. nor the names of its
111 // contributors may be used to endorse or promote products derived from
112 // this software without specific prior written permission.
113 //
114 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
115 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
116 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
117 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
118 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
119 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
120 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
121 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
122 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
123 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
124 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
125 //
126 // Authors: wan@google.com (Zhanyong Wan)
127 //
128 // Low-level types and utilities for porting Google Test to various
129 // platforms. They are subject to change without notice. DO NOT USE
130 // THEM IN USER CODE.
131 //
132 // This file is fundamental to Google Test. All other Google Test source
133 // files are expected to #include this. Therefore, it cannot #include
134 // any other Google Test header.
135 
136 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
137 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
138 
139 // The user can define the following macros in the build script to
140 // control Google Test's behavior. If the user doesn't define a macro
141 // in this list, Google Test will define it.
142 //
143 // GTEST_HAS_CLONE - Define it to 1/0 to indicate that clone(2)
144 // is/isn't available.
145 // GTEST_HAS_EXCEPTIONS - Define it to 1/0 to indicate that exceptions
146 // are enabled.
147 // GTEST_HAS_GLOBAL_STRING - Define it to 1/0 to indicate that ::string
148 // is/isn't available (some systems define
149 // ::string, which is different to std::string).
150 // GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string
151 // is/isn't available (some systems define
152 // ::wstring, which is different to std::wstring).
153 // GTEST_HAS_POSIX_RE - Define it to 1/0 to indicate that POSIX regular
154 // expressions are/aren't available.
155 // GTEST_HAS_PTHREAD - Define it to 1/0 to indicate that <pthread.h>
156 // is/isn't available.
157 // GTEST_HAS_RTTI - Define it to 1/0 to indicate that RTTI is/isn't
158 // enabled.
159 // GTEST_HAS_STD_WSTRING - Define it to 1/0 to indicate that
160 // std::wstring does/doesn't work (Google Test can
161 // be used where std::wstring is unavailable).
162 // GTEST_HAS_TR1_TUPLE - Define it to 1/0 to indicate tr1::tuple
163 // is/isn't available.
164 // GTEST_HAS_SEH - Define it to 1/0 to indicate whether the
165 // compiler supports Microsoft's "Structured
166 // Exception Handling".
167 // GTEST_HAS_STREAM_REDIRECTION
168 // - Define it to 1/0 to indicate whether the
169 // platform supports I/O stream redirection using
170 // dup() and dup2().
171 // GTEST_USE_OWN_TR1_TUPLE - Define it to 1/0 to indicate whether Google
172 // Test's own tr1 tuple implementation should be
173 // used. Unused when the user sets
174 // GTEST_HAS_TR1_TUPLE to 0.
175 // GTEST_LANG_CXX11 - Define it to 1/0 to indicate that Google Test
176 // is building in C++11/C++98 mode.
177 // GTEST_LINKED_AS_SHARED_LIBRARY
178 // - Define to 1 when compiling tests that use
179 // Google Test as a shared library (known as
180 // DLL on Windows).
181 // GTEST_CREATE_SHARED_LIBRARY
182 // - Define to 1 when compiling Google Test itself
183 // as a shared library.
184 
185 // This header defines the following utilities:
186 //
187 // Macros indicating the current platform (defined to 1 if compiled on
188 // the given platform; otherwise undefined):
189 // GTEST_OS_AIX - IBM AIX
190 // GTEST_OS_CYGWIN - Cygwin
191 // GTEST_OS_HPUX - HP-UX
192 // GTEST_OS_LINUX - Linux
193 // GTEST_OS_LINUX_ANDROID - Google Android
194 // GTEST_OS_MAC - Mac OS X
195 // GTEST_OS_IOS - iOS
196 // GTEST_OS_IOS_SIMULATOR - iOS simulator
197 // GTEST_OS_NACL - Google Native Client (NaCl)
198 // GTEST_OS_OPENBSD - OpenBSD
199 // GTEST_OS_QNX - QNX
200 // GTEST_OS_SOLARIS - Sun Solaris
201 // GTEST_OS_SYMBIAN - Symbian
202 // GTEST_OS_WINDOWS - Windows (Desktop, MinGW, or Mobile)
203 // GTEST_OS_WINDOWS_DESKTOP - Windows Desktop
204 // GTEST_OS_WINDOWS_MINGW - MinGW
205 // GTEST_OS_WINDOWS_MOBILE - Windows Mobile
206 // GTEST_OS_ZOS - z/OS
207 //
208 // Among the platforms, Cygwin, Linux, Max OS X, and Windows have the
209 // most stable support. Since core members of the Google Test project
210 // don't have access to other platforms, support for them may be less
211 // stable. If you notice any problems on your platform, please notify
212 // googletestframework@googlegroups.com (patches for fixing them are
213 // even more welcome!).
214 //
215 // Note that it is possible that none of the GTEST_OS_* macros are defined.
216 //
217 // Macros indicating available Google Test features (defined to 1 if
218 // the corresponding feature is supported; otherwise undefined):
219 // GTEST_HAS_COMBINE - the Combine() function (for value-parameterized
220 // tests)
221 // GTEST_HAS_DEATH_TEST - death tests
222 // GTEST_HAS_PARAM_TEST - value-parameterized tests
223 // GTEST_HAS_TYPED_TEST - typed tests
224 // GTEST_HAS_TYPED_TEST_P - type-parameterized tests
225 // GTEST_USES_POSIX_RE - enhanced POSIX regex is used. Do not confuse with
226 // GTEST_HAS_POSIX_RE (see above) which users can
227 // define themselves.
228 // GTEST_USES_SIMPLE_RE - our own simple regex is used;
229 // the above two are mutually exclusive.
230 // GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ().
231 //
232 // Macros for basic C++ coding:
233 // GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
234 // GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a
235 // variable don't have to be used.
236 // GTEST_DISALLOW_ASSIGN_ - disables operator=.
237 // GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
238 // GTEST_MUST_USE_RESULT_ - declares that a function's result must be used.
239 //
240 // Synchronization:
241 // Mutex, MutexLock, ThreadLocal, GetThreadCount()
242 // - synchronization primitives.
243 // GTEST_IS_THREADSAFE - defined to 1 to indicate that the above
244 // synchronization primitives have real implementations
245 // and Google Test is thread-safe; or 0 otherwise.
246 //
247 // Template meta programming:
248 // is_pointer - as in TR1; needed on Symbian and IBM XL C/C++ only.
249 // IteratorTraits - partial implementation of std::iterator_traits, which
250 // is not available in libCstd when compiled with Sun C++.
251 //
252 // Smart pointers:
253 // scoped_ptr - as in TR2.
254 //
255 // Regular expressions:
256 // RE - a simple regular expression class using the POSIX
257 // Extended Regular Expression syntax on UNIX-like
258 // platforms, or a reduced regular exception syntax on
259 // other platforms, including Windows.
260 //
261 // Logging:
262 // GTEST_LOG_() - logs messages at the specified severity level.
263 // LogToStderr() - directs all log messages to stderr.
264 // FlushInfoLog() - flushes informational log messages.
265 //
266 // Stdout and stderr capturing:
267 // CaptureStdout() - starts capturing stdout.
268 // GetCapturedStdout() - stops capturing stdout and returns the captured
269 // string.
270 // CaptureStderr() - starts capturing stderr.
271 // GetCapturedStderr() - stops capturing stderr and returns the captured
272 // string.
273 //
274 // Integer types:
275 // TypeWithSize - maps an integer to a int type.
276 // Int32, UInt32, Int64, UInt64, TimeInMillis
277 // - integers of known sizes.
278 // BiggestInt - the biggest signed integer type.
279 //
280 // Command-line utilities:
281 // GTEST_FLAG() - references a flag.
282 // GTEST_DECLARE_*() - declares a flag.
283 // GTEST_DEFINE_*() - defines a flag.
284 // GetInjectableArgvs() - returns the command line as a vector of strings.
285 //
286 // Environment variable utilities:
287 // GetEnv() - gets the value of an environment variable.
288 // BoolFromGTestEnv() - parses a bool environment variable.
289 // Int32FromGTestEnv() - parses an Int32 environment variable.
290 // StringFromGTestEnv() - parses a string environment variable.
291 
292 #include <ctype.h> // for isspace, etc
293 #include <stddef.h> // for ptrdiff_t
294 #include <stdlib.h>
295 #include <stdio.h>
296 #include <string.h>
297 #ifndef _WIN32_WCE
298 # include <sys/types.h>
299 # include <sys/stat.h>
300 #endif // !_WIN32_WCE
301 
302 #if defined __APPLE__
303 # include <AvailabilityMacros.h>
304 # include <TargetConditionals.h>
305 #endif
306 
307 #include <iostream> // NOLINT
308 #include <sstream> // NOLINT
309 #include <string> // NOLINT
310 
311 #define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
312 #define GTEST_FLAG_PREFIX_ "gtest_"
313 #define GTEST_FLAG_PREFIX_DASH_ "gtest-"
314 #define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
315 #define GTEST_NAME_ "Google Test"
316 #define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/"
317 
318 // Determines the version of gcc that is used to compile this.
319 #ifdef __GNUC__
320 // 40302 means version 4.3.2.
321 # define GTEST_GCC_VER_ \
322  (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
323 #endif // __GNUC__
324 
325 // Determines the platform on which Google Test is compiled.
326 #ifdef __CYGWIN__
327 # define GTEST_OS_CYGWIN 1
328 #elif defined __SYMBIAN32__
329 # define GTEST_OS_SYMBIAN 1
330 #elif defined _WIN32
331 # define GTEST_OS_WINDOWS 1
332 # ifdef _WIN32_WCE
333 # define GTEST_OS_WINDOWS_MOBILE 1
334 # elif defined(__MINGW__) || defined(__MINGW32__)
335 # define GTEST_OS_WINDOWS_MINGW 1
336 # else
337 # define GTEST_OS_WINDOWS_DESKTOP 1
338 # endif // _WIN32_WCE
339 #elif defined __APPLE__
340 # define GTEST_OS_MAC 1
341 # if TARGET_OS_IPHONE
342 # define GTEST_OS_IOS 1
343 # if TARGET_IPHONE_SIMULATOR
344 # define GTEST_OS_IOS_SIMULATOR 1
345 # endif
346 # endif
347 #elif defined __linux__
348 # define GTEST_OS_LINUX 1
349 # if defined __ANDROID__
350 # define GTEST_OS_LINUX_ANDROID 1
351 # endif
352 #elif defined __MVS__
353 # define GTEST_OS_ZOS 1
354 #elif defined(__sun) && defined(__SVR4)
355 # define GTEST_OS_SOLARIS 1
356 #elif defined(_AIX)
357 # define GTEST_OS_AIX 1
358 #elif defined(__hpux)
359 # define GTEST_OS_HPUX 1
360 #elif defined __native_client__
361 # define GTEST_OS_NACL 1
362 #elif defined __OpenBSD__
363 # define GTEST_OS_OPENBSD 1
364 #elif defined __QNX__
365 # define GTEST_OS_QNX 1
366 #endif // __CYGWIN__
367 
368 #ifndef GTEST_LANG_CXX11
369 // gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when
370 // -std={c,gnu}++{0x,11} is passed. The C++11 standard specifies a
371 // value for __cplusplus, and recent versions of clang, gcc, and
372 // probably other compilers set that too in C++11 mode.
373 # if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L
374 // Compiling in at least C++11 mode.
375 # define GTEST_LANG_CXX11 1
376 # else
377 # define GTEST_LANG_CXX11 0
378 # endif
379 #endif
380 
381 // Brings in definitions for functions used in the testing::internal::posix
382 // namespace (read, write, close, chdir, isatty, stat). We do not currently
383 // use them on Windows Mobile.
384 #if !GTEST_OS_WINDOWS
385 // This assumes that non-Windows OSes provide unistd.h. For OSes where this
386 // is not the case, we need to include headers that provide the functions
387 // mentioned above.
388 # include <unistd.h>
389 # include <strings.h>
390 #elif !GTEST_OS_WINDOWS_MOBILE
391 # include <direct.h>
392 # include <io.h>
393 #endif
394 
395 #if GTEST_OS_LINUX_ANDROID
396 // Used to define __ANDROID_API__ matching the target NDK API level.
397 # include <android/api-level.h> // NOLINT
398 #endif
399 
400 // Defines this to true iff Google Test can use POSIX regular expressions.
401 #ifndef GTEST_HAS_POSIX_RE
402 # if GTEST_OS_LINUX_ANDROID
403 // On Android, <regex.h> is only available starting with Gingerbread.
404 # define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
405 # else
406 # define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS)
407 # endif
408 #endif
409 
410 #if GTEST_HAS_POSIX_RE
411 
412 // On some platforms, <regex.h> needs someone to define size_t, and
413 // won't compile otherwise. We can #include it here as we already
414 // included <stdlib.h>, which is guaranteed to define size_t through
415 // <stddef.h>.
416 # include <regex.h> // NOLINT
417 
418 # define GTEST_USES_POSIX_RE 1
419 
420 #elif GTEST_OS_WINDOWS
421 
422 // <regex.h> is not available on Windows. Use our own simple regex
423 // implementation instead.
424 # define GTEST_USES_SIMPLE_RE 1
425 
426 #else
427 
428 // <regex.h> may not be available on this platform. Use our own
429 // simple regex implementation instead.
430 # define GTEST_USES_SIMPLE_RE 1
431 
432 #endif // GTEST_HAS_POSIX_RE
433 
434 #ifndef GTEST_HAS_EXCEPTIONS
435 // The user didn't tell us whether exceptions are enabled, so we need
436 // to figure it out.
437 # if defined(_MSC_VER) || defined(__BORLANDC__)
438 // MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS
439 // macro to enable exceptions, so we'll do the same.
440 // Assumes that exceptions are enabled by default.
441 # ifndef _HAS_EXCEPTIONS
442 # define _HAS_EXCEPTIONS 1
443 # endif // _HAS_EXCEPTIONS
444 # define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
445 # elif defined(__GNUC__) && __EXCEPTIONS
446 // gcc defines __EXCEPTIONS to 1 iff exceptions are enabled.
447 # define GTEST_HAS_EXCEPTIONS 1
448 # elif defined(__SUNPRO_CC)
449 // Sun Pro CC supports exceptions. However, there is no compile-time way of
450 // detecting whether they are enabled or not. Therefore, we assume that
451 // they are enabled unless the user tells us otherwise.
452 # define GTEST_HAS_EXCEPTIONS 1
453 # elif defined(__IBMCPP__) && __EXCEPTIONS
454 // xlC defines __EXCEPTIONS to 1 iff exceptions are enabled.
455 # define GTEST_HAS_EXCEPTIONS 1
456 # elif defined(__HP_aCC)
457 // Exception handling is in effect by default in HP aCC compiler. It has to
458 // be turned of by +noeh compiler option if desired.
459 # define GTEST_HAS_EXCEPTIONS 1
460 # else
461 // For other compilers, we assume exceptions are disabled to be
462 // conservative.
463 # define GTEST_HAS_EXCEPTIONS 0
464 # endif // defined(_MSC_VER) || defined(__BORLANDC__)
465 #endif // GTEST_HAS_EXCEPTIONS
466 
467 #if !defined(GTEST_HAS_STD_STRING)
468 // Even though we don't use this macro any longer, we keep it in case
469 // some clients still depend on it.
470 # define GTEST_HAS_STD_STRING 1
471 #elif !GTEST_HAS_STD_STRING
472 // The user told us that ::std::string isn't available.
473 # error "Google Test cannot be used where ::std::string isn't available."
474 #endif // !defined(GTEST_HAS_STD_STRING)
475 
476 #ifndef GTEST_HAS_GLOBAL_STRING
477 // The user didn't tell us whether ::string is available, so we need
478 // to figure it out.
479 
480 # define GTEST_HAS_GLOBAL_STRING 0
481 
482 #endif // GTEST_HAS_GLOBAL_STRING
483 
484 #ifndef GTEST_HAS_STD_WSTRING
485 // The user didn't tell us whether ::std::wstring is available, so we need
486 // to figure it out.
487 // TODO(wan@google.com): uses autoconf to detect whether ::std::wstring
488 // is available.
489 
490 // Cygwin 1.7 and below doesn't support ::std::wstring.
491 // Solaris' libc++ doesn't support it either. Android has
492 // no support for it at least as recent as Froyo (2.2).
493 # define GTEST_HAS_STD_WSTRING \
494  (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS))
495 
496 #endif // GTEST_HAS_STD_WSTRING
497 
498 #ifndef GTEST_HAS_GLOBAL_WSTRING
499 // The user didn't tell us whether ::wstring is available, so we need
500 // to figure it out.
501 # define GTEST_HAS_GLOBAL_WSTRING \
502  (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
503 #endif // GTEST_HAS_GLOBAL_WSTRING
504 
505 // Determines whether RTTI is available.
506 #ifndef GTEST_HAS_RTTI
507 // The user didn't tell us whether RTTI is enabled, so we need to
508 // figure it out.
509 
510 # ifdef _MSC_VER
511 
512 # ifdef _CPPRTTI // MSVC defines this macro iff RTTI is enabled.
513 # define GTEST_HAS_RTTI 1
514 # else
515 # define GTEST_HAS_RTTI 0
516 # endif
517 
518 // Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled.
519 # elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302)
520 
521 # ifdef __GXX_RTTI
522 // When building against STLport with the Android NDK and with
523 // -frtti -fno-exceptions, the build fails at link time with undefined
524 // references to __cxa_bad_typeid. Note sure if STL or toolchain bug,
525 // so disable RTTI when detected.
526 # if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
527  !defined(__EXCEPTIONS)
528 # define GTEST_HAS_RTTI 0
529 # else
530 # define GTEST_HAS_RTTI 1
531 # endif // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS
532 # else
533 # define GTEST_HAS_RTTI 0
534 # endif // __GXX_RTTI
535 
536 // Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends
537 // using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the
538 // first version with C++ support.
539 # elif defined(__clang__)
540 
541 # define GTEST_HAS_RTTI __has_feature(cxx_rtti)
542 
543 // Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
544 // both the typeid and dynamic_cast features are present.
545 # elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
546 
547 # ifdef __RTTI_ALL__
548 # define GTEST_HAS_RTTI 1
549 # else
550 # define GTEST_HAS_RTTI 0
551 # endif
552 
553 # else
554 
555 // For all other compilers, we assume RTTI is enabled.
556 # define GTEST_HAS_RTTI 1
557 
558 # endif // _MSC_VER
559 
560 #endif // GTEST_HAS_RTTI
561 
562 // It's this header's responsibility to #include <typeinfo> when RTTI
563 // is enabled.
564 #if GTEST_HAS_RTTI
565 # include <typeinfo>
566 #endif
567 
568 // Determines whether Google Test can use the pthreads library.
569 #ifndef GTEST_HAS_PTHREAD
570 // The user didn't tell us explicitly, so we assume pthreads support is
571 // available on Linux and Mac.
572 //
573 // To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
574 // to your compiler flags.
575 # define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX \
576  || GTEST_OS_QNX)
577 #endif // GTEST_HAS_PTHREAD
578 
579 #if GTEST_HAS_PTHREAD
580 // gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is
581 // true.
582 # include <pthread.h> // NOLINT
583 
584 // For timespec and nanosleep, used below.
585 # include <time.h> // NOLINT
586 #endif
587 
588 // Determines whether Google Test can use tr1/tuple. You can define
589 // this macro to 0 to prevent Google Test from using tuple (any
590 // feature depending on tuple with be disabled in this mode).
591 #ifndef GTEST_HAS_TR1_TUPLE
592 # if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR)
593 // STLport, provided with the Android NDK, has neither <tr1/tuple> or <tuple>.
594 # define GTEST_HAS_TR1_TUPLE 0
595 # else
596 // The user didn't tell us not to do it, so we assume it's OK.
597 # define GTEST_HAS_TR1_TUPLE 1
598 # endif
599 #endif // GTEST_HAS_TR1_TUPLE
600 
601 // Determines whether Google Test's own tr1 tuple implementation
602 // should be used.
603 #ifndef GTEST_USE_OWN_TR1_TUPLE
604 // The user didn't tell us, so we need to figure it out.
605 
606 // We use our own TR1 tuple if we aren't sure the user has an
607 // implementation of it already. At this time, libstdc++ 4.0.0+ and
608 // MSVC 2010 are the only mainstream standard libraries that come
609 // with a TR1 tuple implementation. NVIDIA's CUDA NVCC compiler
610 // pretends to be GCC by defining __GNUC__ and friends, but cannot
611 // compile GCC's tuple implementation. MSVC 2008 (9.0) provides TR1
612 // tuple in a 323 MB Feature Pack download, which we cannot assume the
613 // user has. QNX's QCC compiler is a modified GCC but it doesn't
614 // support TR1 tuple. libc++ only provides std::tuple, in C++11 mode,
615 // and it can be used with some compilers that define __GNUC__.
616 # if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \
617  && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) || _MSC_VER >= 1600
618 # define GTEST_ENV_HAS_TR1_TUPLE_ 1
619 # endif
620 
621 // C++11 specifies that <tuple> provides std::tuple. Use that if gtest is used
622 // in C++11 mode and libstdc++ isn't very old (binaries targeting OS X 10.6
623 // can build with clang but need to use gcc4.2's libstdc++).
624 # if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325)
625 # define GTEST_ENV_HAS_STD_TUPLE_ 1
626 # endif
627 
628 # if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_
629 # define GTEST_USE_OWN_TR1_TUPLE 0
630 # else
631 # define GTEST_USE_OWN_TR1_TUPLE 1
632 # endif
633 
634 #endif // GTEST_USE_OWN_TR1_TUPLE
635 
636 // To avoid conditional compilation everywhere, we make it
637 // gtest-port.h's responsibility to #include the header implementing
638 // tr1/tuple.
639 #if GTEST_HAS_TR1_TUPLE
640 
641 # if GTEST_USE_OWN_TR1_TUPLE
642 // This file was GENERATED by command:
643 // pump.py gtest-tuple.h.pump
644 // DO NOT EDIT BY HAND!!!
645 
646 // Copyright 2009 Google Inc.
647 // All Rights Reserved.
648 //
649 // Redistribution and use in source and binary forms, with or without
650 // modification, are permitted provided that the following conditions are
651 // met:
652 //
653 // * Redistributions of source code must retain the above copyright
654 // notice, this list of conditions and the following disclaimer.
655 // * Redistributions in binary form must reproduce the above
656 // copyright notice, this list of conditions and the following disclaimer
657 // in the documentation and/or other materials provided with the
658 // distribution.
659 // * Neither the name of Google Inc. nor the names of its
660 // contributors may be used to endorse or promote products derived from
661 // this software without specific prior written permission.
662 //
663 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
664 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
665 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
666 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
667 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
668 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
669 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
670 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
671 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
672 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
673 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
674 //
675 // Author: wan@google.com (Zhanyong Wan)
676 
677 // Implements a subset of TR1 tuple needed by Google Test and Google Mock.
678 
679 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
680 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
681 
682 #include <utility> // For ::std::pair.
683 
684 // The compiler used in Symbian has a bug that prevents us from declaring the
685 // tuple template as a friend (it complains that tuple is redefined). This
686 // hack bypasses the bug by declaring the members that should otherwise be
687 // private as public.
688 // Sun Studio versions < 12 also have the above bug.
689 #if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)
690 # define GTEST_DECLARE_TUPLE_AS_FRIEND_ public:
691 #else
692 # define GTEST_DECLARE_TUPLE_AS_FRIEND_ \
693  template <GTEST_10_TYPENAMES_(U)> friend class tuple; \
694  private:
695 #endif
696 
697 // GTEST_n_TUPLE_(T) is the type of an n-tuple.
698 #define GTEST_0_TUPLE_(T) tuple<>
699 #define GTEST_1_TUPLE_(T) tuple<T##0, void, void, void, void, void, void, \
700  void, void, void>
701 #define GTEST_2_TUPLE_(T) tuple<T##0, T##1, void, void, void, void, void, \
702  void, void, void>
703 #define GTEST_3_TUPLE_(T) tuple<T##0, T##1, T##2, void, void, void, void, \
704  void, void, void>
705 #define GTEST_4_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, void, void, void, \
706  void, void, void>
707 #define GTEST_5_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, void, void, \
708  void, void, void>
709 #define GTEST_6_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, void, \
710  void, void, void>
711 #define GTEST_7_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
712  void, void, void>
713 #define GTEST_8_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
714  T##7, void, void>
715 #define GTEST_9_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
716  T##7, T##8, void>
717 #define GTEST_10_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
718  T##7, T##8, T##9>
719 
720 // GTEST_n_TYPENAMES_(T) declares a list of n typenames.
721 #define GTEST_0_TYPENAMES_(T)
722 #define GTEST_1_TYPENAMES_(T) typename T##0
723 #define GTEST_2_TYPENAMES_(T) typename T##0, typename T##1
724 #define GTEST_3_TYPENAMES_(T) typename T##0, typename T##1, typename T##2
725 #define GTEST_4_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
726  typename T##3
727 #define GTEST_5_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
728  typename T##3, typename T##4
729 #define GTEST_6_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
730  typename T##3, typename T##4, typename T##5
731 #define GTEST_7_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
732  typename T##3, typename T##4, typename T##5, typename T##6
733 #define GTEST_8_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
734  typename T##3, typename T##4, typename T##5, typename T##6, typename T##7
735 #define GTEST_9_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
736  typename T##3, typename T##4, typename T##5, typename T##6, \
737  typename T##7, typename T##8
738 #define GTEST_10_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
739  typename T##3, typename T##4, typename T##5, typename T##6, \
740  typename T##7, typename T##8, typename T##9
741 
742 // In theory, defining stuff in the ::std namespace is undefined
743 // behavior. We can do this as we are playing the role of a standard
744 // library vendor.
745 namespace std {
746 namespace tr1 {
747 
748 template <typename T0 = void, typename T1 = void, typename T2 = void,
749  typename T3 = void, typename T4 = void, typename T5 = void,
750  typename T6 = void, typename T7 = void, typename T8 = void,
751  typename T9 = void>
752 class tuple;
753 
754 // Anything in namespace gtest_internal is Google Test's INTERNAL
755 // IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code.
756 namespace gtest_internal {
757 
758 // ByRef<T>::type is T if T is a reference; otherwise it's const T&.
759 template <typename T>
760 struct ByRef { typedef const T& type; }; // NOLINT
761 template <typename T>
762 struct ByRef<T&> { typedef T& type; }; // NOLINT
763 
764 // A handy wrapper for ByRef.
765 #define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type
766 
767 // AddRef<T>::type is T if T is a reference; otherwise it's T&. This
768 // is the same as tr1::add_reference<T>::type.
769 template <typename T>
770 struct AddRef { typedef T& type; }; // NOLINT
771 template <typename T>
772 struct AddRef<T&> { typedef T& type; }; // NOLINT
773 
774 // A handy wrapper for AddRef.
775 #define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type
776 
777 // A helper for implementing get<k>().
778 template <int k> class Get;
779 
780 // A helper for implementing tuple_element<k, T>. kIndexValid is true
781 // iff k < the number of fields in tuple type T.
782 template <bool kIndexValid, int kIndex, class Tuple>
784 
785 template <GTEST_10_TYPENAMES_(T)>
786 struct TupleElement<true, 0, GTEST_10_TUPLE_(T) > {
787  typedef T0 type;
788 };
789 
790 template <GTEST_10_TYPENAMES_(T)>
791 struct TupleElement<true, 1, GTEST_10_TUPLE_(T) > {
792  typedef T1 type;
793 };
794 
795 template <GTEST_10_TYPENAMES_(T)>
796 struct TupleElement<true, 2, GTEST_10_TUPLE_(T) > {
797  typedef T2 type;
798 };
799 
800 template <GTEST_10_TYPENAMES_(T)>
801 struct TupleElement<true, 3, GTEST_10_TUPLE_(T) > {
802  typedef T3 type;
803 };
804 
805 template <GTEST_10_TYPENAMES_(T)>
806 struct TupleElement<true, 4, GTEST_10_TUPLE_(T) > {
807  typedef T4 type;
808 };
809 
810 template <GTEST_10_TYPENAMES_(T)>
811 struct TupleElement<true, 5, GTEST_10_TUPLE_(T) > {
812  typedef T5 type;
813 };
814 
815 template <GTEST_10_TYPENAMES_(T)>
816 struct TupleElement<true, 6, GTEST_10_TUPLE_(T) > {
817  typedef T6 type;
818 };
819 
820 template <GTEST_10_TYPENAMES_(T)>
821 struct TupleElement<true, 7, GTEST_10_TUPLE_(T) > {
822  typedef T7 type;
823 };
824 
825 template <GTEST_10_TYPENAMES_(T)>
826 struct TupleElement<true, 8, GTEST_10_TUPLE_(T) > {
827  typedef T8 type;
828 };
829 
830 template <GTEST_10_TYPENAMES_(T)>
831 struct TupleElement<true, 9, GTEST_10_TUPLE_(T) > {
832  typedef T9 type;
833 };
834 
835 } // namespace gtest_internal
836 
837 template <>
838 class tuple<> {
839  public:
840  tuple() {}
841  tuple(const tuple& /* t */) {}
842  tuple& operator=(const tuple& /* t */) { return *this; }
843 };
844 
845 template <GTEST_1_TYPENAMES_(T)>
846 class GTEST_1_TUPLE_(T) {
847  public:
848  template <int k> friend class gtest_internal::Get;
849 
850  tuple() : f0_() {}
851 
852  explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {}
853 
854  tuple(const tuple& t) : f0_(t.f0_) {}
855 
856  template <GTEST_1_TYPENAMES_(U)>
857  tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {}
858 
859  tuple& operator=(const tuple& t) { return CopyFrom(t); }
860 
861  template <GTEST_1_TYPENAMES_(U)>
862  tuple& operator=(const GTEST_1_TUPLE_(U)& t) {
863  return CopyFrom(t);
864  }
865 
867 
868  template <GTEST_1_TYPENAMES_(U)>
869  tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) {
870  f0_ = t.f0_;
871  return *this;
872  }
873 
874  T0 f0_;
875 };
876 
877 template <GTEST_2_TYPENAMES_(T)>
878 class GTEST_2_TUPLE_(T) {
879  public:
880  template <int k> friend class gtest_internal::Get;
881 
882  tuple() : f0_(), f1_() {}
883 
884  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0),
885  f1_(f1) {}
886 
887  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {}
888 
889  template <GTEST_2_TYPENAMES_(U)>
890  tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {}
891  template <typename U0, typename U1>
892  tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {}
893 
894  tuple& operator=(const tuple& t) { return CopyFrom(t); }
895 
896  template <GTEST_2_TYPENAMES_(U)>
897  tuple& operator=(const GTEST_2_TUPLE_(U)& t) {
898  return CopyFrom(t);
899  }
900  template <typename U0, typename U1>
901  tuple& operator=(const ::std::pair<U0, U1>& p) {
902  f0_ = p.first;
903  f1_ = p.second;
904  return *this;
905  }
906 
908 
909  template <GTEST_2_TYPENAMES_(U)>
910  tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) {
911  f0_ = t.f0_;
912  f1_ = t.f1_;
913  return *this;
914  }
915 
916  T0 f0_;
917  T1 f1_;
918 };
919 
920 template <GTEST_3_TYPENAMES_(T)>
921 class GTEST_3_TUPLE_(T) {
922  public:
923  template <int k> friend class gtest_internal::Get;
924 
925  tuple() : f0_(), f1_(), f2_() {}
926 
927  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
928  GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {}
929 
930  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
931 
932  template <GTEST_3_TYPENAMES_(U)>
933  tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
934 
935  tuple& operator=(const tuple& t) { return CopyFrom(t); }
936 
937  template <GTEST_3_TYPENAMES_(U)>
938  tuple& operator=(const GTEST_3_TUPLE_(U)& t) {
939  return CopyFrom(t);
940  }
941 
943 
944  template <GTEST_3_TYPENAMES_(U)>
945  tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) {
946  f0_ = t.f0_;
947  f1_ = t.f1_;
948  f2_ = t.f2_;
949  return *this;
950  }
951 
952  T0 f0_;
953  T1 f1_;
954  T2 f2_;
955 };
956 
957 template <GTEST_4_TYPENAMES_(T)>
958 class GTEST_4_TUPLE_(T) {
959  public:
960  template <int k> friend class gtest_internal::Get;
961 
962  tuple() : f0_(), f1_(), f2_(), f3_() {}
963 
964  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
965  GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1), f2_(f2),
966  f3_(f3) {}
967 
968  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {}
969 
970  template <GTEST_4_TYPENAMES_(U)>
971  tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
972  f3_(t.f3_) {}
973 
974  tuple& operator=(const tuple& t) { return CopyFrom(t); }
975 
976  template <GTEST_4_TYPENAMES_(U)>
977  tuple& operator=(const GTEST_4_TUPLE_(U)& t) {
978  return CopyFrom(t);
979  }
980 
982 
983  template <GTEST_4_TYPENAMES_(U)>
984  tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) {
985  f0_ = t.f0_;
986  f1_ = t.f1_;
987  f2_ = t.f2_;
988  f3_ = t.f3_;
989  return *this;
990  }
991 
992  T0 f0_;
993  T1 f1_;
994  T2 f2_;
995  T3 f3_;
996 };
997 
998 template <GTEST_5_TYPENAMES_(T)>
999 class GTEST_5_TUPLE_(T) {
1000  public:
1001  template <int k> friend class gtest_internal::Get;
1002 
1003  tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {}
1004 
1005  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1006  GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3,
1007  GTEST_BY_REF_(T4) f4) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4) {}
1008 
1009  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1010  f4_(t.f4_) {}
1011 
1012  template <GTEST_5_TYPENAMES_(U)>
1013  tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1014  f3_(t.f3_), f4_(t.f4_) {}
1015 
1016  tuple& operator=(const tuple& t) { return CopyFrom(t); }
1017 
1018  template <GTEST_5_TYPENAMES_(U)>
1019  tuple& operator=(const GTEST_5_TUPLE_(U)& t) {
1020  return CopyFrom(t);
1021  }
1022 
1024 
1025  template <GTEST_5_TYPENAMES_(U)>
1026  tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) {
1027  f0_ = t.f0_;
1028  f1_ = t.f1_;
1029  f2_ = t.f2_;
1030  f3_ = t.f3_;
1031  f4_ = t.f4_;
1032  return *this;
1033  }
1034 
1035  T0 f0_;
1036  T1 f1_;
1037  T2 f2_;
1038  T3 f3_;
1039  T4 f4_;
1040 };
1041 
1042 template <GTEST_6_TYPENAMES_(T)>
1043 class GTEST_6_TUPLE_(T) {
1044  public:
1045  template <int k> friend class gtest_internal::Get;
1046 
1047  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {}
1048 
1049  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1051  GTEST_BY_REF_(T5) f5) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
1052  f5_(f5) {}
1053 
1054  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1055  f4_(t.f4_), f5_(t.f5_) {}
1056 
1057  template <GTEST_6_TYPENAMES_(U)>
1058  tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1059  f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {}
1060 
1061  tuple& operator=(const tuple& t) { return CopyFrom(t); }
1062 
1063  template <GTEST_6_TYPENAMES_(U)>
1064  tuple& operator=(const GTEST_6_TUPLE_(U)& t) {
1065  return CopyFrom(t);
1066  }
1067 
1069 
1070  template <GTEST_6_TYPENAMES_(U)>
1071  tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) {
1072  f0_ = t.f0_;
1073  f1_ = t.f1_;
1074  f2_ = t.f2_;
1075  f3_ = t.f3_;
1076  f4_ = t.f4_;
1077  f5_ = t.f5_;
1078  return *this;
1079  }
1080 
1081  T0 f0_;
1082  T1 f1_;
1083  T2 f2_;
1084  T3 f3_;
1085  T4 f4_;
1086  T5 f5_;
1087 };
1088 
1089 template <GTEST_7_TYPENAMES_(T)>
1090 class GTEST_7_TUPLE_(T) {
1091  public:
1092  template <int k> friend class gtest_internal::Get;
1093 
1094  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {}
1095 
1096  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1098  GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6) : f0_(f0), f1_(f1), f2_(f2),
1099  f3_(f3), f4_(f4), f5_(f5), f6_(f6) {}
1100 
1101  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1102  f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
1103 
1104  template <GTEST_7_TYPENAMES_(U)>
1105  tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1106  f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
1107 
1108  tuple& operator=(const tuple& t) { return CopyFrom(t); }
1109 
1110  template <GTEST_7_TYPENAMES_(U)>
1111  tuple& operator=(const GTEST_7_TUPLE_(U)& t) {
1112  return CopyFrom(t);
1113  }
1114 
1116 
1117  template <GTEST_7_TYPENAMES_(U)>
1118  tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) {
1119  f0_ = t.f0_;
1120  f1_ = t.f1_;
1121  f2_ = t.f2_;
1122  f3_ = t.f3_;
1123  f4_ = t.f4_;
1124  f5_ = t.f5_;
1125  f6_ = t.f6_;
1126  return *this;
1127  }
1128 
1129  T0 f0_;
1130  T1 f1_;
1131  T2 f2_;
1132  T3 f3_;
1133  T4 f4_;
1134  T5 f5_;
1135  T6 f6_;
1136 };
1137 
1138 template <GTEST_8_TYPENAMES_(T)>
1139 class GTEST_8_TUPLE_(T) {
1140  public:
1141  template <int k> friend class gtest_internal::Get;
1142 
1143  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {}
1144 
1145  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1147  GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6,
1148  GTEST_BY_REF_(T7) f7) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
1149  f5_(f5), f6_(f6), f7_(f7) {}
1150 
1151  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1152  f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
1153 
1154  template <GTEST_8_TYPENAMES_(U)>
1155  tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1156  f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
1157 
1158  tuple& operator=(const tuple& t) { return CopyFrom(t); }
1159 
1160  template <GTEST_8_TYPENAMES_(U)>
1161  tuple& operator=(const GTEST_8_TUPLE_(U)& t) {
1162  return CopyFrom(t);
1163  }
1164 
1166 
1167  template <GTEST_8_TYPENAMES_(U)>
1168  tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) {
1169  f0_ = t.f0_;
1170  f1_ = t.f1_;
1171  f2_ = t.f2_;
1172  f3_ = t.f3_;
1173  f4_ = t.f4_;
1174  f5_ = t.f5_;
1175  f6_ = t.f6_;
1176  f7_ = t.f7_;
1177  return *this;
1178  }
1179 
1180  T0 f0_;
1181  T1 f1_;
1182  T2 f2_;
1183  T3 f3_;
1184  T4 f4_;
1185  T5 f5_;
1186  T6 f6_;
1187  T7 f7_;
1188 };
1189 
1190 template <GTEST_9_TYPENAMES_(T)>
1191 class GTEST_9_TUPLE_(T) {
1192  public:
1193  template <int k> friend class gtest_internal::Get;
1194 
1195  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_() {}
1196 
1197  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1200  GTEST_BY_REF_(T8) f8) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
1201  f5_(f5), f6_(f6), f7_(f7), f8_(f8) {}
1202 
1203  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1204  f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
1205 
1206  template <GTEST_9_TYPENAMES_(U)>
1207  tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1208  f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
1209 
1210  tuple& operator=(const tuple& t) { return CopyFrom(t); }
1211 
1212  template <GTEST_9_TYPENAMES_(U)>
1213  tuple& operator=(const GTEST_9_TUPLE_(U)& t) {
1214  return CopyFrom(t);
1215  }
1216 
1218 
1219  template <GTEST_9_TYPENAMES_(U)>
1220  tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) {
1221  f0_ = t.f0_;
1222  f1_ = t.f1_;
1223  f2_ = t.f2_;
1224  f3_ = t.f3_;
1225  f4_ = t.f4_;
1226  f5_ = t.f5_;
1227  f6_ = t.f6_;
1228  f7_ = t.f7_;
1229  f8_ = t.f8_;
1230  return *this;
1231  }
1232 
1233  T0 f0_;
1234  T1 f1_;
1235  T2 f2_;
1236  T3 f3_;
1237  T4 f4_;
1238  T5 f5_;
1239  T6 f6_;
1240  T7 f7_;
1241  T8 f8_;
1242 };
1243 
1244 template <GTEST_10_TYPENAMES_(T)>
1245 class tuple {
1246  public:
1247  template <int k> friend class gtest_internal::Get;
1248 
1249  tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(),
1250  f9_() {}
1251 
1252  explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1255  GTEST_BY_REF_(T8) f8, GTEST_BY_REF_(T9) f9) : f0_(f0), f1_(f1), f2_(f2),
1256  f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8), f9_(f9) {}
1257 
1258  tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1259  f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {}
1260 
1261  template <GTEST_10_TYPENAMES_(U)>
1262  tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1263  f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_),
1264  f9_(t.f9_) {}
1265 
1266  tuple& operator=(const tuple& t) { return CopyFrom(t); }
1267 
1268  template <GTEST_10_TYPENAMES_(U)>
1270  return CopyFrom(t);
1271  }
1272 
1274 
1275  template <GTEST_10_TYPENAMES_(U)>
1277  f0_ = t.f0_;
1278  f1_ = t.f1_;
1279  f2_ = t.f2_;
1280  f3_ = t.f3_;
1281  f4_ = t.f4_;
1282  f5_ = t.f5_;
1283  f6_ = t.f6_;
1284  f7_ = t.f7_;
1285  f8_ = t.f8_;
1286  f9_ = t.f9_;
1287  return *this;
1288  }
1289 
1290  T0 f0_;
1291  T1 f1_;
1292  T2 f2_;
1293  T3 f3_;
1294  T4 f4_;
1295  T5 f5_;
1296  T6 f6_;
1297  T7 f7_;
1298  T8 f8_;
1299  T9 f9_;
1300 };
1301 
1302 // 6.1.3.2 Tuple creation functions.
1303 
1304 // Known limitations: we don't support passing an
1305 // std::tr1::reference_wrapper<T> to make_tuple(). And we don't
1306 // implement tie().
1307 
1308 inline tuple<> make_tuple() { return tuple<>(); }
1309 
1310 template <GTEST_1_TYPENAMES_(T)>
1311 inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) {
1312  return GTEST_1_TUPLE_(T)(f0);
1313 }
1314 
1315 template <GTEST_2_TYPENAMES_(T)>
1316 inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) {
1317  return GTEST_2_TUPLE_(T)(f0, f1);
1318 }
1319 
1320 template <GTEST_3_TYPENAMES_(T)>
1321 inline GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) {
1322  return GTEST_3_TUPLE_(T)(f0, f1, f2);
1323 }
1324 
1325 template <GTEST_4_TYPENAMES_(T)>
1326 inline GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1327  const T3& f3) {
1328  return GTEST_4_TUPLE_(T)(f0, f1, f2, f3);
1329 }
1330 
1331 template <GTEST_5_TYPENAMES_(T)>
1332 inline GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1333  const T3& f3, const T4& f4) {
1334  return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4);
1335 }
1336 
1337 template <GTEST_6_TYPENAMES_(T)>
1338 inline GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1339  const T3& f3, const T4& f4, const T5& f5) {
1340  return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5);
1341 }
1342 
1343 template <GTEST_7_TYPENAMES_(T)>
1344 inline GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1345  const T3& f3, const T4& f4, const T5& f5, const T6& f6) {
1346  return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6);
1347 }
1348 
1349 template <GTEST_8_TYPENAMES_(T)>
1350 inline GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1351  const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7) {
1352  return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7);
1353 }
1354 
1355 template <GTEST_9_TYPENAMES_(T)>
1356 inline GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1357  const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
1358  const T8& f8) {
1359  return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8);
1360 }
1361 
1362 template <GTEST_10_TYPENAMES_(T)>
1363 inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1364  const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
1365  const T8& f8, const T9& f9) {
1366  return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9);
1367 }
1368 
1369 // 6.1.3.3 Tuple helper classes.
1370 
1371 template <typename Tuple> struct tuple_size;
1372 
1373 template <GTEST_0_TYPENAMES_(T)>
1375  static const int value = 0;
1376 };
1377 
1378 template <GTEST_1_TYPENAMES_(T)>
1380  static const int value = 1;
1381 };
1382 
1383 template <GTEST_2_TYPENAMES_(T)>
1385  static const int value = 2;
1386 };
1387 
1388 template <GTEST_3_TYPENAMES_(T)>
1390  static const int value = 3;
1391 };
1392 
1393 template <GTEST_4_TYPENAMES_(T)>
1395  static const int value = 4;
1396 };
1397 
1398 template <GTEST_5_TYPENAMES_(T)>
1400  static const int value = 5;
1401 };
1402 
1403 template <GTEST_6_TYPENAMES_(T)>
1405  static const int value = 6;
1406 };
1407 
1408 template <GTEST_7_TYPENAMES_(T)>
1410  static const int value = 7;
1411 };
1412 
1413 template <GTEST_8_TYPENAMES_(T)>
1415  static const int value = 8;
1416 };
1417 
1418 template <GTEST_9_TYPENAMES_(T)>
1420  static const int value = 9;
1421 };
1422 
1423 template <GTEST_10_TYPENAMES_(T)>
1425  static const int value = 10;
1426 };
1427 
1428 template <int k, class Tuple>
1430  typedef typename gtest_internal::TupleElement<
1431  k < (tuple_size<Tuple>::value), k, Tuple>::type type;
1432 };
1433 
1434 #define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type
1435 
1436 // 6.1.3.4 Element access.
1437 
1438 namespace gtest_internal {
1439 
1440 template <>
1441 class Get<0> {
1442  public:
1443  template <class Tuple>
1445  Field(Tuple& t) { return t.f0_; } // NOLINT
1446 
1447  template <class Tuple>
1449  ConstField(const Tuple& t) { return t.f0_; }
1450 };
1451 
1452 template <>
1453 class Get<1> {
1454  public:
1455  template <class Tuple>
1457  Field(Tuple& t) { return t.f1_; } // NOLINT
1458 
1459  template <class Tuple>
1461  ConstField(const Tuple& t) { return t.f1_; }
1462 };
1463 
1464 template <>
1465 class Get<2> {
1466  public:
1467  template <class Tuple>
1469  Field(Tuple& t) { return t.f2_; } // NOLINT
1470 
1471  template <class Tuple>
1473  ConstField(const Tuple& t) { return t.f2_; }
1474 };
1475 
1476 template <>
1477 class Get<3> {
1478  public:
1479  template <class Tuple>
1481  Field(Tuple& t) { return t.f3_; } // NOLINT
1482 
1483  template <class Tuple>
1485  ConstField(const Tuple& t) { return t.f3_; }
1486 };
1487 
1488 template <>
1489 class Get<4> {
1490  public:
1491  template <class Tuple>
1493  Field(Tuple& t) { return t.f4_; } // NOLINT
1494 
1495  template <class Tuple>
1497  ConstField(const Tuple& t) { return t.f4_; }
1498 };
1499 
1500 template <>
1501 class Get<5> {
1502  public:
1503  template <class Tuple>
1505  Field(Tuple& t) { return t.f5_; } // NOLINT
1506 
1507  template <class Tuple>
1509  ConstField(const Tuple& t) { return t.f5_; }
1510 };
1511 
1512 template <>
1513 class Get<6> {
1514  public:
1515  template <class Tuple>
1517  Field(Tuple& t) { return t.f6_; } // NOLINT
1518 
1519  template <class Tuple>
1521  ConstField(const Tuple& t) { return t.f6_; }
1522 };
1523 
1524 template <>
1525 class Get<7> {
1526  public:
1527  template <class Tuple>
1529  Field(Tuple& t) { return t.f7_; } // NOLINT
1530 
1531  template <class Tuple>
1533  ConstField(const Tuple& t) { return t.f7_; }
1534 };
1535 
1536 template <>
1537 class Get<8> {
1538  public:
1539  template <class Tuple>
1541  Field(Tuple& t) { return t.f8_; } // NOLINT
1542 
1543  template <class Tuple>
1545  ConstField(const Tuple& t) { return t.f8_; }
1546 };
1547 
1548 template <>
1549 class Get<9> {
1550  public:
1551  template <class Tuple>
1553  Field(Tuple& t) { return t.f9_; } // NOLINT
1554 
1555  template <class Tuple>
1557  ConstField(const Tuple& t) { return t.f9_; }
1558 };
1559 
1560 } // namespace gtest_internal
1561 
1562 template <int k, GTEST_10_TYPENAMES_(T)>
1564 get(GTEST_10_TUPLE_(T)& t) {
1566 }
1567 
1568 template <int k, GTEST_10_TYPENAMES_(T)>
1570 get(const GTEST_10_TUPLE_(T)& t) {
1572 }
1573 
1574 // 6.1.3.5 Relational operators
1575 
1576 // We only implement == and !=, as we don't have a need for the rest yet.
1577 
1578 namespace gtest_internal {
1579 
1580 // SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the
1581 // first k fields of t1 equals the first k fields of t2.
1582 // SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if
1583 // k1 != k2.
1584 template <int kSize1, int kSize2>
1586 
1587 template <>
1589  template <class Tuple1, class Tuple2>
1590  static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) {
1591  return true;
1592  }
1593 };
1594 
1595 template <int k>
1597  template <class Tuple1, class Tuple2>
1598  static bool Eq(const Tuple1& t1, const Tuple2& t2) {
1600  ::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2);
1601  }
1602 };
1603 
1604 } // namespace gtest_internal
1605 
1606 template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
1607 inline bool operator==(const GTEST_10_TUPLE_(T)& t,
1608  const GTEST_10_TUPLE_(U)& u) {
1612 }
1613 
1614 template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
1615 inline bool operator!=(const GTEST_10_TUPLE_(T)& t,
1616  const GTEST_10_TUPLE_(U)& u) { return !(t == u); }
1617 
1618 // 6.1.4 Pairs.
1619 // Unimplemented.
1620 
1621 } // namespace tr1
1622 } // namespace std
1623 
1624 #undef GTEST_0_TUPLE_
1625 #undef GTEST_1_TUPLE_
1626 #undef GTEST_2_TUPLE_
1627 #undef GTEST_3_TUPLE_
1628 #undef GTEST_4_TUPLE_
1629 #undef GTEST_5_TUPLE_
1630 #undef GTEST_6_TUPLE_
1631 #undef GTEST_7_TUPLE_
1632 #undef GTEST_8_TUPLE_
1633 #undef GTEST_9_TUPLE_
1634 #undef GTEST_10_TUPLE_
1635 
1636 #undef GTEST_0_TYPENAMES_
1637 #undef GTEST_1_TYPENAMES_
1638 #undef GTEST_2_TYPENAMES_
1639 #undef GTEST_3_TYPENAMES_
1640 #undef GTEST_4_TYPENAMES_
1641 #undef GTEST_5_TYPENAMES_
1642 #undef GTEST_6_TYPENAMES_
1643 #undef GTEST_7_TYPENAMES_
1644 #undef GTEST_8_TYPENAMES_
1645 #undef GTEST_9_TYPENAMES_
1646 #undef GTEST_10_TYPENAMES_
1647 
1648 #undef GTEST_DECLARE_TUPLE_AS_FRIEND_
1649 #undef GTEST_BY_REF_
1650 #undef GTEST_ADD_REF_
1651 #undef GTEST_TUPLE_ELEMENT_
1652 
1653 #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
1654 # elif GTEST_ENV_HAS_STD_TUPLE_
1655 # include <tuple>
1656 // C++11 puts its tuple into the ::std namespace rather than
1657 // ::std::tr1. gtest expects tuple to live in ::std::tr1, so put it there.
1658 // This causes undefined behavior, but supported compilers react in
1659 // the way we intend.
1660 namespace std {
1661 namespace tr1 {
1662 using ::std::get;
1664 using ::std::tuple;
1665 using ::std::tuple_element;
1666 using ::std::tuple_size;
1667 }
1668 }
1669 
1670 # elif GTEST_OS_SYMBIAN
1671 
1672 // On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to
1673 // use STLport's tuple implementation, which unfortunately doesn't
1674 // work as the copy of STLport distributed with Symbian is incomplete.
1675 // By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to
1676 // use its own tuple implementation.
1677 # ifdef BOOST_HAS_TR1_TUPLE
1678 # undef BOOST_HAS_TR1_TUPLE
1679 # endif // BOOST_HAS_TR1_TUPLE
1680 
1681 // This prevents <boost/tr1/detail/config.hpp>, which defines
1682 // BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>.
1683 # define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED
1684 # include <tuple>
1685 
1686 # elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
1687 // GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header. This does
1688 // not conform to the TR1 spec, which requires the header to be <tuple>.
1689 
1690 # if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
1691 // Until version 4.3.2, gcc has a bug that causes <tr1/functional>,
1692 // which is #included by <tr1/tuple>, to not compile when RTTI is
1693 // disabled. _TR1_FUNCTIONAL is the header guard for
1694 // <tr1/functional>. Hence the following #define is a hack to prevent
1695 // <tr1/functional> from being included.
1696 # define _TR1_FUNCTIONAL 1
1697 # include <tr1/tuple>
1698 # undef _TR1_FUNCTIONAL // Allows the user to #include
1699  // <tr1/functional> if he chooses to.
1700 # else
1701 # include <tr1/tuple> // NOLINT
1702 # endif // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
1703 
1704 # else
1705 // If the compiler is not GCC 4.0+, we assume the user is using a
1706 // spec-conforming TR1 implementation.
1707 # include <tuple> // NOLINT
1708 # endif // GTEST_USE_OWN_TR1_TUPLE
1709 
1710 #endif // GTEST_HAS_TR1_TUPLE
1711 
1712 // Determines whether clone(2) is supported.
1713 // Usually it will only be available on Linux, excluding
1714 // Linux on the Itanium architecture.
1715 // Also see http://linux.die.net/man/2/clone.
1716 #ifndef GTEST_HAS_CLONE
1717 // The user didn't tell us, so we need to figure it out.
1718 
1719 # if GTEST_OS_LINUX && !defined(__ia64__)
1720 # if GTEST_OS_LINUX_ANDROID
1721 // On Android, clone() is only available on ARM starting with Gingerbread.
1722 # if defined(__arm__) && __ANDROID_API__ >= 9
1723 # define GTEST_HAS_CLONE 1
1724 # else
1725 # define GTEST_HAS_CLONE 0
1726 # endif
1727 # else
1728 # define GTEST_HAS_CLONE 1
1729 # endif
1730 # else
1731 # define GTEST_HAS_CLONE 0
1732 # endif // GTEST_OS_LINUX && !defined(__ia64__)
1733 
1734 #endif // GTEST_HAS_CLONE
1735 
1736 // Determines whether to support stream redirection. This is used to test
1737 // output correctness and to implement death tests.
1738 #ifndef GTEST_HAS_STREAM_REDIRECTION
1739 // By default, we assume that stream redirection is supported on all
1740 // platforms except known mobile ones.
1741 # if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN
1742 # define GTEST_HAS_STREAM_REDIRECTION 0
1743 # else
1744 # define GTEST_HAS_STREAM_REDIRECTION 1
1745 # endif // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN
1746 #endif // GTEST_HAS_STREAM_REDIRECTION
1747 
1748 // Determines whether to support death tests.
1749 // Google Test does not support death tests for VC 7.1 and earlier as
1750 // abort() in a VC 7.1 application compiled as GUI in debug config
1751 // pops up a dialog window that cannot be suppressed programmatically.
1752 #if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
1753  (GTEST_OS_MAC && !GTEST_OS_IOS) || GTEST_OS_IOS_SIMULATOR || \
1754  (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \
1755  GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \
1756  GTEST_OS_OPENBSD || GTEST_OS_QNX)
1757 # define GTEST_HAS_DEATH_TEST 1
1758 # include <vector> // NOLINT
1759 #endif
1760 
1761 // We don't support MSVC 7.1 with exceptions disabled now. Therefore
1762 // all the compilers we care about are adequate for supporting
1763 // value-parameterized tests.
1764 #define GTEST_HAS_PARAM_TEST 1
1765 
1766 // Determines whether to support type-driven tests.
1767 
1768 // Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0,
1769 // Sun Pro CC, IBM Visual Age, and HP aCC support.
1770 #if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \
1771  defined(__IBMCPP__) || defined(__HP_aCC)
1772 # define GTEST_HAS_TYPED_TEST 1
1773 # define GTEST_HAS_TYPED_TEST_P 1
1774 #endif
1775 
1776 // Determines whether to support Combine(). This only makes sense when
1777 // value-parameterized tests are enabled. The implementation doesn't
1778 // work on Sun Studio since it doesn't understand templated conversion
1779 // operators.
1780 #if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC)
1781 # define GTEST_HAS_COMBINE 1
1782 #endif
1783 
1784 // Determines whether the system compiler uses UTF-16 for encoding wide strings.
1785 #define GTEST_WIDE_STRING_USES_UTF16_ \
1786  (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX)
1787 
1788 // Determines whether test results can be streamed to a socket.
1789 #if GTEST_OS_LINUX
1790 # define GTEST_CAN_STREAM_RESULTS_ 1
1791 #endif
1792 
1793 // Defines some utility macros.
1794 
1795 // The GNU compiler emits a warning if nested "if" statements are followed by
1796 // an "else" statement and braces are not used to explicitly disambiguate the
1797 // "else" binding. This leads to problems with code like:
1798 //
1799 // if (gate)
1800 // ASSERT_*(condition) << "Some message";
1801 //
1802 // The "switch (0) case 0:" idiom is used to suppress this.
1803 #ifdef __INTEL_COMPILER
1804 # define GTEST_AMBIGUOUS_ELSE_BLOCKER_
1805 #else
1806 # define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default: // NOLINT
1807 #endif
1808 
1809 // Use this annotation at the end of a struct/class definition to
1810 // prevent the compiler from optimizing away instances that are never
1811 // used. This is useful when all interesting logic happens inside the
1812 // c'tor and / or d'tor. Example:
1813 //
1814 // struct Foo {
1815 // Foo() { ... }
1816 // } GTEST_ATTRIBUTE_UNUSED_;
1817 //
1818 // Also use it after a variable or parameter declaration to tell the
1819 // compiler the variable/parameter does not have to be used.
1820 #if defined(__GNUC__) && !defined(COMPILER_ICC)
1821 # define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
1822 #else
1823 # define GTEST_ATTRIBUTE_UNUSED_
1824 #endif
1825 
1826 // A macro to disallow operator=
1827 // This should be used in the private: declarations for a class.
1828 #define GTEST_DISALLOW_ASSIGN_(type)\
1829  void operator=(type const &)
1830 
1831 // A macro to disallow copy constructor and operator=
1832 // This should be used in the private: declarations for a class.
1833 #define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\
1834  type(type const &);\
1835  GTEST_DISALLOW_ASSIGN_(type)
1836 
1837 // Tell the compiler to warn about unused return values for functions declared
1838 // with this macro. The macro should be used on function declarations
1839 // following the argument list:
1840 //
1841 // Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
1842 #if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)
1843 # define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
1844 #else
1845 # define GTEST_MUST_USE_RESULT_
1846 #endif // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC
1847 
1848 // Determine whether the compiler supports Microsoft's Structured Exception
1849 // Handling. This is supported by several Windows compilers but generally
1850 // does not exist on any other system.
1851 #ifndef GTEST_HAS_SEH
1852 // The user didn't tell us, so we need to figure it out.
1853 
1854 # if defined(_MSC_VER) || defined(__BORLANDC__)
1855 // These two compilers are known to support SEH.
1856 # define GTEST_HAS_SEH 1
1857 # else
1858 // Assume no SEH.
1859 # define GTEST_HAS_SEH 0
1860 # endif
1861 
1862 #endif // GTEST_HAS_SEH
1863 
1864 #ifdef _MSC_VER
1865 
1866 # if GTEST_LINKED_AS_SHARED_LIBRARY
1867 # define GTEST_API_ __declspec(dllimport)
1868 # elif GTEST_CREATE_SHARED_LIBRARY
1869 # define GTEST_API_ __declspec(dllexport)
1870 # endif
1871 
1872 #endif // _MSC_VER
1873 
1874 #ifndef GTEST_API_
1875 # define GTEST_API_
1876 #endif
1877 
1878 #ifdef __GNUC__
1879 // Ask the compiler to never inline a given function.
1880 # define GTEST_NO_INLINE_ __attribute__((noinline))
1881 #else
1882 # define GTEST_NO_INLINE_
1883 #endif
1884 
1885 // _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
1886 #if defined(__GLIBCXX__) || defined(_LIBCPP_VERSION)
1887 # define GTEST_HAS_CXXABI_H_ 1
1888 #else
1889 # define GTEST_HAS_CXXABI_H_ 0
1890 #endif
1891 
1892 namespace testing {
1893 
1894 class Message;
1895 
1896 namespace internal {
1897 
1898 // A secret type that Google Test users don't know about. It has no
1899 // definition on purpose. Therefore it's impossible to create a
1900 // Secret object, which is what we want.
1901 class Secret;
1902 
1903 // The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time
1904 // expression is true. For example, you could use it to verify the
1905 // size of a static array:
1906 //
1907 // GTEST_COMPILE_ASSERT_(ARRAYSIZE(content_type_names) == CONTENT_NUM_TYPES,
1908 // content_type_names_incorrect_size);
1909 //
1910 // or to make sure a struct is smaller than a certain size:
1911 //
1912 // GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large);
1913 //
1914 // The second argument to the macro is the name of the variable. If
1915 // the expression is false, most compilers will issue a warning/error
1916 // containing the name of the variable.
1917 
1918 template <bool>
1920 };
1921 
1922 #define GTEST_COMPILE_ASSERT_(expr, msg) \
1923  typedef ::testing::internal::CompileAssert<(static_cast<bool>(expr))> \
1924  msg[static_cast<bool>(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_
1925 
1926 // Implementation details of GTEST_COMPILE_ASSERT_:
1927 //
1928 // - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1
1929 // elements (and thus is invalid) when the expression is false.
1930 //
1931 // - The simpler definition
1932 //
1933 // #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1]
1934 //
1935 // does not work, as gcc supports variable-length arrays whose sizes
1936 // are determined at run-time (this is gcc's extension and not part
1937 // of the C++ standard). As a result, gcc fails to reject the
1938 // following code with the simple definition:
1939 //
1940 // int foo;
1941 // GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is
1942 // // not a compile-time constant.
1943 //
1944 // - By using the type CompileAssert<(bool(expr))>, we ensures that
1945 // expr is a compile-time constant. (Template arguments must be
1946 // determined at compile-time.)
1947 //
1948 // - The outter parentheses in CompileAssert<(bool(expr))> are necessary
1949 // to work around a bug in gcc 3.4.4 and 4.0.1. If we had written
1950 //
1951 // CompileAssert<bool(expr)>
1952 //
1953 // instead, these compilers will refuse to compile
1954 //
1955 // GTEST_COMPILE_ASSERT_(5 > 0, some_message);
1956 //
1957 // (They seem to think the ">" in "5 > 0" marks the end of the
1958 // template argument list.)
1959 //
1960 // - The array size is (bool(expr) ? 1 : -1), instead of simply
1961 //
1962 // ((expr) ? 1 : -1).
1963 //
1964 // This is to avoid running into a bug in MS VC 7.1, which
1965 // causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
1966 
1967 // StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h.
1968 //
1969 // This template is declared, but intentionally undefined.
1970 template <typename T1, typename T2>
1972 
1973 template <typename T>
1975 
1976 #if GTEST_HAS_GLOBAL_STRING
1978 #else
1980 #endif // GTEST_HAS_GLOBAL_STRING
1981 
1982 #if GTEST_HAS_GLOBAL_WSTRING
1984 #elif GTEST_HAS_STD_WSTRING
1986 #endif // GTEST_HAS_GLOBAL_WSTRING
1987 
1988 // A helper for suppressing warnings on constant condition. It just
1989 // returns 'condition'.
1990 GTEST_API_ bool IsTrue(bool condition);
1991 
1992 // Defines scoped_ptr.
1993 
1994 // This implementation of scoped_ptr is PARTIAL - it only contains
1995 // enough stuff to satisfy Google Test's need.
1996 template <typename T>
1997 class scoped_ptr {
1998  public:
1999  typedef T element_type;
2000 
2001  explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
2002  ~scoped_ptr() { reset(); }
2003 
2004  T& operator*() const { return *ptr_; }
2005  T* operator->() const { return ptr_; }
2006  T* get() const { return ptr_; }
2007 
2008  T* release() {
2009  T* const ptr = ptr_;
2010  ptr_ = NULL;
2011  return ptr;
2012  }
2013 
2014  void reset(T* p = NULL) {
2015  if (p != ptr_) {
2016  if (IsTrue(sizeof(T) > 0)) { // Makes sure T is a complete type.
2017  delete ptr_;
2018  }
2019  ptr_ = p;
2020  }
2021  }
2022 
2023  private:
2024  T* ptr_;
2025 
2027 };
2028 
2029 // Defines RE.
2030 
2031 // A simple C++ wrapper for <regex.h>. It uses the POSIX Extended
2032 // Regular Expression syntax.
2034  public:
2035  // A copy constructor is required by the Standard to initialize object
2036  // references from r-values.
2037  RE(const RE& other) { Init(other.pattern()); }
2038 
2039  // Constructs an RE from a string.
2040  RE(const ::std::string& regex) { Init(regex.c_str()); } // NOLINT
2041 
2042 #if GTEST_HAS_GLOBAL_STRING
2043 
2044  RE(const ::string& regex) { Init(regex.c_str()); } // NOLINT
2045 
2046 #endif // GTEST_HAS_GLOBAL_STRING
2047 
2048  RE(const char* regex) { Init(regex); } // NOLINT
2049  ~RE();
2050 
2051  // Returns the string representation of the regex.
2052  const char* pattern() const { return pattern_; }
2053 
2054  // FullMatch(str, re) returns true iff regular expression re matches
2055  // the entire str.
2056  // PartialMatch(str, re) returns true iff regular expression re
2057  // matches a substring of str (including str itself).
2058  //
2059  // TODO(wan@google.com): make FullMatch() and PartialMatch() work
2060  // when str contains NUL characters.
2061  static bool FullMatch(const ::std::string& str, const RE& re) {
2062  return FullMatch(str.c_str(), re);
2063  }
2064  static bool PartialMatch(const ::std::string& str, const RE& re) {
2065  return PartialMatch(str.c_str(), re);
2066  }
2067 
2068 #if GTEST_HAS_GLOBAL_STRING
2069 
2070  static bool FullMatch(const ::string& str, const RE& re) {
2071  return FullMatch(str.c_str(), re);
2072  }
2073  static bool PartialMatch(const ::string& str, const RE& re) {
2074  return PartialMatch(str.c_str(), re);
2075  }
2076 
2077 #endif // GTEST_HAS_GLOBAL_STRING
2078 
2079  static bool FullMatch(const char* str, const RE& re);
2080  static bool PartialMatch(const char* str, const RE& re);
2081 
2082  private:
2083  void Init(const char* regex);
2084 
2085  // We use a const char* instead of an std::string, as Google Test used to be
2086  // used where std::string is not available. TODO(wan@google.com): change to
2087  // std::string.
2088  const char* pattern_;
2090 
2091 #if GTEST_USES_POSIX_RE
2092 
2093  regex_t full_regex_; // For FullMatch().
2094  regex_t partial_regex_; // For PartialMatch().
2095 
2096 #else // GTEST_USES_SIMPLE_RE
2097 
2098  const char* full_pattern_; // For FullMatch();
2099 
2100 #endif
2101 
2103 };
2104 
2105 // Formats a source file path and a line number as they would appear
2106 // in an error message from the compiler used to compile this code.
2107 GTEST_API_ ::std::string FormatFileLocation(const char* file, int line);
2108 
2109 // Formats a file location for compiler-independent XML output.
2110 // Although this function is not platform dependent, we put it next to
2111 // FormatFileLocation in order to contrast the two functions.
2113  int line);
2114 
2115 // Defines logging utilities:
2116 // GTEST_LOG_(severity) - logs messages at the specified severity level. The
2117 // message itself is streamed into the macro.
2118 // LogToStderr() - directs all log messages to stderr.
2119 // FlushInfoLog() - flushes informational log messages.
2120 
2126 };
2127 
2128 // Formats log entry severity, provides a stream object for streaming the
2129 // log message, and terminates the message with a newline when going out of
2130 // scope.
2132  public:
2133  GTestLog(GTestLogSeverity severity, const char* file, int line);
2134 
2135  // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
2136  ~GTestLog();
2137 
2138  ::std::ostream& GetStream() { return ::std::cerr; }
2139 
2140  private:
2142 
2144 };
2145 
2146 #define GTEST_LOG_(severity) \
2147  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
2148  __FILE__, __LINE__).GetStream()
2149 
2150 inline void LogToStderr() {}
2151 inline void FlushInfoLog() { fflush(NULL); }
2152 
2153 // INTERNAL IMPLEMENTATION - DO NOT USE.
2154 //
2155 // GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
2156 // is not satisfied.
2157 // Synopsys:
2158 // GTEST_CHECK_(boolean_condition);
2159 // or
2160 // GTEST_CHECK_(boolean_condition) << "Additional message";
2161 //
2162 // This checks the condition and if the condition is not satisfied
2163 // it prints message about the condition violation, including the
2164 // condition itself, plus additional message streamed into it, if any,
2165 // and then it aborts the program. It aborts the program irrespective of
2166 // whether it is built in the debug mode or not.
2167 #define GTEST_CHECK_(condition) \
2168  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
2169  if (::testing::internal::IsTrue(condition)) \
2170  ; \
2171  else \
2172  GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
2173 
2174 // An all-mode assert to verify that the given POSIX-style function
2175 // call returns 0 (indicating success). Known limitation: this
2176 // doesn't expand to a balanced 'if' statement, so enclose the macro
2177 // in {} if you need to use it as the only statement in an 'if'
2178 // branch.
2179 #define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
2180  if (const int gtest_error = (posix_call)) \
2181  GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
2182  << gtest_error
2183 
2184 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
2185 //
2186 // Use ImplicitCast_ as a safe version of static_cast for upcasting in
2187 // the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a
2188 // const Foo*). When you use ImplicitCast_, the compiler checks that
2189 // the cast is safe. Such explicit ImplicitCast_s are necessary in
2190 // surprisingly many situations where C++ demands an exact type match
2191 // instead of an argument type convertable to a target type.
2192 //
2193 // The syntax for using ImplicitCast_ is the same as for static_cast:
2194 //
2195 // ImplicitCast_<ToType>(expr)
2196 //
2197 // ImplicitCast_ would have been part of the C++ standard library,
2198 // but the proposal was submitted too late. It will probably make
2199 // its way into the language in the future.
2200 //
2201 // This relatively ugly name is intentional. It prevents clashes with
2202 // similar functions users may have (e.g., implicit_cast). The internal
2203 // namespace alone is not enough because the function can be found by ADL.
2204 template<typename To>
2205 inline To ImplicitCast_(To x) { return x; }
2206 
2207 // When you upcast (that is, cast a pointer from type Foo to type
2208 // SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts
2209 // always succeed. When you downcast (that is, cast a pointer from
2210 // type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
2211 // how do you know the pointer is really of type SubclassOfFoo? It
2212 // could be a bare Foo, or of type DifferentSubclassOfFoo. Thus,
2213 // when you downcast, you should use this macro. In debug mode, we
2214 // use dynamic_cast<> to double-check the downcast is legal (we die
2215 // if it's not). In normal mode, we do the efficient static_cast<>
2216 // instead. Thus, it's important to test in debug mode to make sure
2217 // the cast is legal!
2218 // This is the only place in the code we should use dynamic_cast<>.
2219 // In particular, you SHOULDN'T be using dynamic_cast<> in order to
2220 // do RTTI (eg code like this:
2221 // if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
2222 // if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
2223 // You should design the code some other way not to need this.
2224 //
2225 // This relatively ugly name is intentional. It prevents clashes with
2226 // similar functions users may have (e.g., down_cast). The internal
2227 // namespace alone is not enough because the function can be found by ADL.
2228 template<typename To, typename From> // use like this: DownCast_<T*>(foo);
2229 inline To DownCast_(From* f) { // so we only accept pointers
2230  // Ensures that To is a sub-type of From *. This test is here only
2231  // for compile-time type checking, and has no overhead in an
2232  // optimized build at run-time, as it will be optimized away
2233  // completely.
2234  if (false) {
2235  const To to = NULL;
2236  ::testing::internal::ImplicitCast_<From*>(to);
2237  }
2238 
2239 #if GTEST_HAS_RTTI
2240  // RTTI: debug mode only!
2241  GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL);
2242 #endif
2243  return static_cast<To>(f);
2244 }
2245 
2246 // Downcasts the pointer of type Base to Derived.
2247 // Derived must be a subclass of Base. The parameter MUST
2248 // point to a class of type Derived, not any subclass of it.
2249 // When RTTI is available, the function performs a runtime
2250 // check to enforce this.
2251 template <class Derived, class Base>
2253 #if GTEST_HAS_RTTI
2254  GTEST_CHECK_(typeid(*base) == typeid(Derived));
2255  return dynamic_cast<Derived*>(base); // NOLINT
2256 #else
2257  return static_cast<Derived*>(base); // Poor man's downcast.
2258 #endif
2259 }
2260 
2261 #if GTEST_HAS_STREAM_REDIRECTION
2262 
2263 // Defines the stderr capturer:
2264 // CaptureStdout - starts capturing stdout.
2265 // GetCapturedStdout - stops capturing stdout and returns the captured string.
2266 // CaptureStderr - starts capturing stderr.
2267 // GetCapturedStderr - stops capturing stderr and returns the captured string.
2268 //
2269 GTEST_API_ void CaptureStdout();
2271 GTEST_API_ void CaptureStderr();
2273 
2274 #endif // GTEST_HAS_STREAM_REDIRECTION
2275 
2276 
2277 #if GTEST_HAS_DEATH_TEST
2278 
2279 const ::std::vector<testing::internal::string>& GetInjectableArgvs();
2280 void SetInjectableArgvs(const ::std::vector<testing::internal::string>*
2281  new_argvs);
2282 
2283 // A copy of all command line arguments. Set by InitGoogleTest().
2284 extern ::std::vector<testing::internal::string> g_argvs;
2285 
2286 #endif // GTEST_HAS_DEATH_TEST
2287 
2288 // Defines synchronization primitives.
2289 
2290 #if GTEST_HAS_PTHREAD
2291 
2292 // Sleeps for (roughly) n milli-seconds. This function is only for
2293 // testing Google Test's own constructs. Don't use it in user tests,
2294 // either directly or indirectly.
2295 inline void SleepMilliseconds(int n) {
2296  const timespec time = {
2297  0, // 0 seconds.
2298  n * 1000L * 1000L, // And n ms.
2299  };
2300  nanosleep(&time, NULL);
2301 }
2302 
2303 // Allows a controller thread to pause execution of newly created
2304 // threads until notified. Instances of this class must be created
2305 // and destroyed in the controller thread.
2306 //
2307 // This class is only for testing Google Test's own constructs. Do not
2308 // use it in user tests, either directly or indirectly.
2309 class Notification {
2310  public:
2311  Notification() : notified_(false) {
2312  GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
2313  }
2314  ~Notification() {
2315  pthread_mutex_destroy(&mutex_);
2316  }
2317 
2318  // Notifies all threads created with this notification to start. Must
2319  // be called from the controller thread.
2320  void Notify() {
2321  pthread_mutex_lock(&mutex_);
2322  notified_ = true;
2323  pthread_mutex_unlock(&mutex_);
2324  }
2325 
2326  // Blocks until the controller thread notifies. Must be called from a test
2327  // thread.
2328  void WaitForNotification() {
2329  for (;;) {
2330  pthread_mutex_lock(&mutex_);
2331  const bool notified = notified_;
2332  pthread_mutex_unlock(&mutex_);
2333  if (notified)
2334  break;
2335  SleepMilliseconds(10);
2336  }
2337  }
2338 
2339  private:
2340  pthread_mutex_t mutex_;
2341  bool notified_;
2342 
2343  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
2344 };
2345 
2346 // As a C-function, ThreadFuncWithCLinkage cannot be templated itself.
2347 // Consequently, it cannot select a correct instantiation of ThreadWithParam
2348 // in order to call its Run(). Introducing ThreadWithParamBase as a
2349 // non-templated base class for ThreadWithParam allows us to bypass this
2350 // problem.
2351 class ThreadWithParamBase {
2352  public:
2353  virtual ~ThreadWithParamBase() {}
2354  virtual void Run() = 0;
2355 };
2356 
2357 // pthread_create() accepts a pointer to a function type with the C linkage.
2358 // According to the Standard (7.5/1), function types with different linkages
2359 // are different even if they are otherwise identical. Some compilers (for
2360 // example, SunStudio) treat them as different types. Since class methods
2361 // cannot be defined with C-linkage we need to define a free C-function to
2362 // pass into pthread_create().
2363 extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
2364  static_cast<ThreadWithParamBase*>(thread)->Run();
2365  return NULL;
2366 }
2367 
2368 // Helper class for testing Google Test's multi-threading constructs.
2369 // To use it, write:
2370 //
2371 // void ThreadFunc(int param) { /* Do things with param */ }
2372 // Notification thread_can_start;
2373 // ...
2374 // // The thread_can_start parameter is optional; you can supply NULL.
2375 // ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start);
2376 // thread_can_start.Notify();
2377 //
2378 // These classes are only for testing Google Test's own constructs. Do
2379 // not use them in user tests, either directly or indirectly.
2380 template <typename T>
2381 class ThreadWithParam : public ThreadWithParamBase {
2382  public:
2383  typedef void (*UserThreadFunc)(T);
2384 
2385  ThreadWithParam(
2386  UserThreadFunc func, T param, Notification* thread_can_start)
2387  : func_(func),
2388  param_(param),
2389  thread_can_start_(thread_can_start),
2390  finished_(false) {
2391  ThreadWithParamBase* const base = this;
2392  // The thread can be created only after all fields except thread_
2393  // have been initialized.
2395  pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base));
2396  }
2397  ~ThreadWithParam() { Join(); }
2398 
2399  void Join() {
2400  if (!finished_) {
2401  GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0));
2402  finished_ = true;
2403  }
2404  }
2405 
2406  virtual void Run() {
2407  if (thread_can_start_ != NULL)
2408  thread_can_start_->WaitForNotification();
2409  func_(param_);
2410  }
2411 
2412  private:
2413  const UserThreadFunc func_; // User-supplied thread function.
2414  const T param_; // User-supplied parameter to the thread function.
2415  // When non-NULL, used to block execution until the controller thread
2416  // notifies.
2417  Notification* const thread_can_start_;
2418  bool finished_; // true iff we know that the thread function has finished.
2419  pthread_t thread_; // The native thread object.
2420 
2421  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
2422 };
2423 
2424 // MutexBase and Mutex implement mutex on pthreads-based platforms. They
2425 // are used in conjunction with class MutexLock:
2426 //
2427 // Mutex mutex;
2428 // ...
2429 // MutexLock lock(&mutex); // Acquires the mutex and releases it at the end
2430 // // of the current scope.
2431 //
2432 // MutexBase implements behavior for both statically and dynamically
2433 // allocated mutexes. Do not use MutexBase directly. Instead, write
2434 // the following to define a static mutex:
2435 //
2436 // GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);
2437 //
2438 // You can forward declare a static mutex like this:
2439 //
2440 // GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);
2441 //
2442 // To create a dynamic mutex, just define an object of type Mutex.
2443 class MutexBase {
2444  public:
2445  // Acquires this mutex.
2446  void Lock() {
2447  GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
2448  owner_ = pthread_self();
2449  has_owner_ = true;
2450  }
2451 
2452  // Releases this mutex.
2453  void Unlock() {
2454  // Since the lock is being released the owner_ field should no longer be
2455  // considered valid. We don't protect writing to has_owner_ here, as it's
2456  // the caller's responsibility to ensure that the current thread holds the
2457  // mutex when this is called.
2458  has_owner_ = false;
2459  GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
2460  }
2461 
2462  // Does nothing if the current thread holds the mutex. Otherwise, crashes
2463  // with high probability.
2464  void AssertHeld() const {
2465  GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
2466  << "The current thread is not holding the mutex @" << this;
2467  }
2468 
2469  // A static mutex may be used before main() is entered. It may even
2470  // be used before the dynamic initialization stage. Therefore we
2471  // must be able to initialize a static mutex object at link time.
2472  // This means MutexBase has to be a POD and its member variables
2473  // have to be public.
2474  public:
2475  pthread_mutex_t mutex_; // The underlying pthread mutex.
2476  // has_owner_ indicates whether the owner_ field below contains a valid thread
2477  // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All
2478  // accesses to the owner_ field should be protected by a check of this field.
2479  // An alternative might be to memset() owner_ to all zeros, but there's no
2480  // guarantee that a zero'd pthread_t is necessarily invalid or even different
2481  // from pthread_self().
2482  bool has_owner_;
2483  pthread_t owner_; // The thread holding the mutex.
2484 };
2485 
2486 // Forward-declares a static mutex.
2487 # define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
2488  extern ::testing::internal::MutexBase mutex
2489 
2490 // Defines and statically (i.e. at link time) initializes a static mutex.
2491 // The initialization list here does not explicitly initialize each field,
2492 // instead relying on default initialization for the unspecified fields. In
2493 // particular, the owner_ field (a pthread_t) is not explicitly initialized.
2494 // This allows initialization to work whether pthread_t is a scalar or struct.
2495 // The flag -Wmissing-field-initializers must not be specified for this to work.
2496 # define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
2497  ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, false }
2498 
2499 // The Mutex class can only be used for mutexes created at runtime. It
2500 // shares its API with MutexBase otherwise.
2501 class Mutex : public MutexBase {
2502  public:
2503  Mutex() {
2504  GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
2505  has_owner_ = false;
2506  }
2507  ~Mutex() {
2508  GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
2509  }
2510 
2511  private:
2513 };
2514 
2515 // We cannot name this class MutexLock as the ctor declaration would
2516 // conflict with a macro named MutexLock, which is defined on some
2517 // platforms. Hence the typedef trick below.
2518 class GTestMutexLock {
2519  public:
2520  explicit GTestMutexLock(MutexBase* mutex)
2521  : mutex_(mutex) { mutex_->Lock(); }
2522 
2523  ~GTestMutexLock() { mutex_->Unlock(); }
2524 
2525  private:
2526  MutexBase* const mutex_;
2527 
2529 };
2530 
2531 typedef GTestMutexLock MutexLock;
2532 
2533 // Helpers for ThreadLocal.
2534 
2535 // pthread_key_create() requires DeleteThreadLocalValue() to have
2536 // C-linkage. Therefore it cannot be templatized to access
2537 // ThreadLocal<T>. Hence the need for class
2538 // ThreadLocalValueHolderBase.
2539 class ThreadLocalValueHolderBase {
2540  public:
2541  virtual ~ThreadLocalValueHolderBase() {}
2542 };
2543 
2544 // Called by pthread to delete thread-local data stored by
2545 // pthread_setspecific().
2546 extern "C" inline void DeleteThreadLocalValue(void* value_holder) {
2547  delete static_cast<ThreadLocalValueHolderBase*>(value_holder);
2548 }
2549 
2550 // Implements thread-local storage on pthreads-based systems.
2551 //
2552 // // Thread 1
2553 // ThreadLocal<int> tl(100); // 100 is the default value for each thread.
2554 //
2555 // // Thread 2
2556 // tl.set(150); // Changes the value for thread 2 only.
2557 // EXPECT_EQ(150, tl.get());
2558 //
2559 // // Thread 1
2560 // EXPECT_EQ(100, tl.get()); // In thread 1, tl has the original value.
2561 // tl.set(200);
2562 // EXPECT_EQ(200, tl.get());
2563 //
2564 // The template type argument T must have a public copy constructor.
2565 // In addition, the default ThreadLocal constructor requires T to have
2566 // a public default constructor.
2567 //
2568 // An object managed for a thread by a ThreadLocal instance is deleted
2569 // when the thread exits. Or, if the ThreadLocal instance dies in
2570 // that thread, when the ThreadLocal dies. It's the user's
2571 // responsibility to ensure that all other threads using a ThreadLocal
2572 // have exited when it dies, or the per-thread objects for those
2573 // threads will not be deleted.
2574 //
2575 // Google Test only uses global ThreadLocal objects. That means they
2576 // will die after main() has returned. Therefore, no per-thread
2577 // object managed by Google Test will be leaked as long as all threads
2578 // using Google Test have exited when main() returns.
2579 template <typename T>
2580 class ThreadLocal {
2581  public:
2582  ThreadLocal() : key_(CreateKey()),
2583  default_() {}
2584  explicit ThreadLocal(const T& value) : key_(CreateKey()),
2585  default_(value) {}
2586 
2587  ~ThreadLocal() {
2588  // Destroys the managed object for the current thread, if any.
2589  DeleteThreadLocalValue(pthread_getspecific(key_));
2590 
2591  // Releases resources associated with the key. This will *not*
2592  // delete managed objects for other threads.
2593  GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
2594  }
2595 
2596  T* pointer() { return GetOrCreateValue(); }
2597  const T* pointer() const { return GetOrCreateValue(); }
2598  const T& get() const { return *pointer(); }
2599  void set(const T& value) { *pointer() = value; }
2600 
2601  private:
2602  // Holds a value of type T.
2603  class ValueHolder : public ThreadLocalValueHolderBase {
2604  public:
2605  explicit ValueHolder(const T& value) : value_(value) {}
2606 
2607  T* pointer() { return &value_; }
2608 
2609  private:
2610  T value_;
2611  GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
2612  };
2613 
2614  static pthread_key_t CreateKey() {
2615  pthread_key_t key;
2616  // When a thread exits, DeleteThreadLocalValue() will be called on
2617  // the object managed for that thread.
2619  pthread_key_create(&key, &DeleteThreadLocalValue));
2620  return key;
2621  }
2622 
2623  T* GetOrCreateValue() const {
2624  ThreadLocalValueHolderBase* const holder =
2625  static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
2626  if (holder != NULL) {
2627  return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
2628  }
2629 
2630  ValueHolder* const new_holder = new ValueHolder(default_);
2631  ThreadLocalValueHolderBase* const holder_base = new_holder;
2632  GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
2633  return new_holder->pointer();
2634  }
2635 
2636  // A key pthreads uses for looking up per-thread values.
2637  const pthread_key_t key_;
2638  const T default_; // The default value for each thread.
2639 
2641 };
2642 
2643 # define GTEST_IS_THREADSAFE 1
2644 
2645 #else // GTEST_HAS_PTHREAD
2646 
2647 // A dummy implementation of synchronization primitives (mutex, lock,
2648 // and thread-local variable). Necessary for compiling Google Test where
2649 // mutex is not supported - using Google Test in multiple threads is not
2650 // supported on such platforms.
2651 
2652 class Mutex {
2653  public:
2654  Mutex() {}
2655  void Lock() {}
2656  void Unlock() {}
2657  void AssertHeld() const {}
2658 };
2659 
2660 # define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
2661  extern ::testing::internal::Mutex mutex
2662 
2663 # define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
2664 
2666  public:
2667  explicit GTestMutexLock(Mutex*) {} // NOLINT
2668 };
2669 
2671 
2672 template <typename T>
2674  public:
2675  ThreadLocal() : value_() {}
2676  explicit ThreadLocal(const T& value) : value_(value) {}
2677  T* pointer() { return &value_; }
2678  const T* pointer() const { return &value_; }
2679  const T& get() const { return value_; }
2680  void set(const T& value) { value_ = value; }
2681  private:
2683 };
2684 
2685 // The above synchronization primitives have dummy implementations.
2686 // Therefore Google Test is not thread-safe.
2687 # define GTEST_IS_THREADSAFE 0
2688 
2689 #endif // GTEST_HAS_PTHREAD
2690 
2691 // Returns the number of threads running in the process, or 0 to indicate that
2692 // we cannot detect it.
2693 GTEST_API_ size_t GetThreadCount();
2694 
2695 // Passing non-POD classes through ellipsis (...) crashes the ARM
2696 // compiler and generates a warning in Sun Studio. The Nokia Symbian
2697 // and the IBM XL C/C++ compiler try to instantiate a copy constructor
2698 // for objects passed through ellipsis (...), failing for uncopyable
2699 // objects. We define this to ensure that only POD is passed through
2700 // ellipsis on these systems.
2701 #if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC)
2702 // We lose support for NULL detection where the compiler doesn't like
2703 // passing non-POD classes through ellipsis (...).
2704 # define GTEST_ELLIPSIS_NEEDS_POD_ 1
2705 #else
2706 # define GTEST_CAN_COMPARE_NULL 1
2707 #endif
2708 
2709 // The Nokia Symbian and IBM XL C/C++ compilers cannot decide between
2710 // const T& and const T* in a function template. These compilers
2711 // _can_ decide between class template specializations for T and T*,
2712 // so a tr1::type_traits-like is_pointer works.
2713 #if defined(__SYMBIAN32__) || defined(__IBMCPP__)
2714 # define GTEST_NEEDS_IS_POINTER_ 1
2715 #endif
2716 
2717 template <bool bool_value>
2720  static const bool value = bool_value;
2721 };
2722 template <bool bool_value> const bool bool_constant<bool_value>::value;
2723 
2726 
2727 template <typename T>
2728 struct is_pointer : public false_type {};
2729 
2730 template <typename T>
2731 struct is_pointer<T*> : public true_type {};
2732 
2733 template <typename Iterator>
2735  typedef typename Iterator::value_type value_type;
2736 };
2737 
2738 template <typename T>
2739 struct IteratorTraits<T*> {
2740  typedef T value_type;
2741 };
2742 
2743 template <typename T>
2744 struct IteratorTraits<const T*> {
2745  typedef T value_type;
2746 };
2747 
2748 #if GTEST_OS_WINDOWS
2749 # define GTEST_PATH_SEP_ "\\"
2750 # define GTEST_HAS_ALT_PATH_SEP_ 1
2751 // The biggest signed integer type the compiler supports.
2752 typedef __int64 BiggestInt;
2753 #else
2754 # define GTEST_PATH_SEP_ "/"
2755 # define GTEST_HAS_ALT_PATH_SEP_ 0
2756 typedef long long BiggestInt; // NOLINT
2757 #endif // GTEST_OS_WINDOWS
2758 
2759 // Utilities for char.
2760 
2761 // isspace(int ch) and friends accept an unsigned char or EOF. char
2762 // may be signed, depending on the compiler (or compiler flags).
2763 // Therefore we need to cast a char to unsigned char before calling
2764 // isspace(), etc.
2765 
2766 inline bool IsAlpha(char ch) {
2767  return isalpha(static_cast<unsigned char>(ch)) != 0;
2768 }
2769 inline bool IsAlNum(char ch) {
2770  return isalnum(static_cast<unsigned char>(ch)) != 0;
2771 }
2772 inline bool IsDigit(char ch) {
2773  return isdigit(static_cast<unsigned char>(ch)) != 0;
2774 }
2775 inline bool IsLower(char ch) {
2776  return islower(static_cast<unsigned char>(ch)) != 0;
2777 }
2778 inline bool IsSpace(char ch) {
2779  return isspace(static_cast<unsigned char>(ch)) != 0;
2780 }
2781 inline bool IsUpper(char ch) {
2782  return isupper(static_cast<unsigned char>(ch)) != 0;
2783 }
2784 inline bool IsXDigit(char ch) {
2785  return isxdigit(static_cast<unsigned char>(ch)) != 0;
2786 }
2787 inline bool IsXDigit(wchar_t ch) {
2788  const unsigned char low_byte = static_cast<unsigned char>(ch);
2789  return ch == low_byte && isxdigit(low_byte) != 0;
2790 }
2791 
2792 inline char ToLower(char ch) {
2793  return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
2794 }
2795 inline char ToUpper(char ch) {
2796  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
2797 }
2798 
2799 // The testing::internal::posix namespace holds wrappers for common
2800 // POSIX functions. These wrappers hide the differences between
2801 // Windows/MSVC and POSIX systems. Since some compilers define these
2802 // standard functions as macros, the wrapper cannot have the same name
2803 // as the wrapped function.
2804 
2805 namespace posix {
2806 
2807 // Functions with a different name on Windows.
2808 
2809 #if GTEST_OS_WINDOWS
2810 
2811 typedef struct _stat StatStruct;
2812 
2813 # ifdef __BORLANDC__
2814 inline int IsATTY(int fd) { return isatty(fd); }
2815 inline int StrCaseCmp(const char* s1, const char* s2) {
2816  return stricmp(s1, s2);
2817 }
2818 inline char* StrDup(const char* src) { return strdup(src); }
2819 # else // !__BORLANDC__
2820 # if GTEST_OS_WINDOWS_MOBILE
2821 inline int IsATTY(int /* fd */) { return 0; }
2822 # else
2823 inline int IsATTY(int fd) { return _isatty(fd); }
2824 # endif // GTEST_OS_WINDOWS_MOBILE
2825 inline int StrCaseCmp(const char* s1, const char* s2) {
2826  return _stricmp(s1, s2);
2827 }
2828 inline char* StrDup(const char* src) { return _strdup(src); }
2829 # endif // __BORLANDC__
2830 
2831 # if GTEST_OS_WINDOWS_MOBILE
2832 inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
2833 // Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
2834 // time and thus not defined there.
2835 # else
2836 inline int FileNo(FILE* file) { return _fileno(file); }
2837 inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
2838 inline int RmDir(const char* dir) { return _rmdir(dir); }
2839 inline bool IsDir(const StatStruct& st) {
2840  return (_S_IFDIR & st.st_mode) != 0;
2841 }
2842 # endif // GTEST_OS_WINDOWS_MOBILE
2843 
2844 #else
2845 
2846 typedef struct stat StatStruct;
2847 
2848 inline int FileNo(FILE* file) { return fileno(file); }
2849 inline int IsATTY(int fd) { return isatty(fd); }
2850 inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
2851 inline int StrCaseCmp(const char* s1, const char* s2) {
2852  return strcasecmp(s1, s2);
2853 }
2854 inline char* StrDup(const char* src) { return strdup(src); }
2855 inline int RmDir(const char* dir) { return rmdir(dir); }
2856 inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
2857 
2858 #endif // GTEST_OS_WINDOWS
2859 
2860 // Functions deprecated by MSVC 8.0.
2861 
2862 #ifdef _MSC_VER
2863 // Temporarily disable warning 4996 (deprecated function).
2864 # pragma warning(push)
2865 # pragma warning(disable:4996)
2866 #endif
2867 
2868 inline const char* StrNCpy(char* dest, const char* src, size_t n) {
2869  return strncpy(dest, src, n);
2870 }
2871 
2872 // ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and
2873 // StrError() aren't needed on Windows CE at this time and thus not
2874 // defined there.
2875 
2876 #if !GTEST_OS_WINDOWS_MOBILE
2877 inline int ChDir(const char* dir) { return chdir(dir); }
2878 #endif
2879 inline FILE* FOpen(const char* path, const char* mode) {
2880  return fopen(path, mode);
2881 }
2882 #if !GTEST_OS_WINDOWS_MOBILE
2883 inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
2884  return freopen(path, mode, stream);
2885 }
2886 inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
2887 #endif
2888 inline int FClose(FILE* fp) { return fclose(fp); }
2889 #if !GTEST_OS_WINDOWS_MOBILE
2890 inline int Read(int fd, void* buf, unsigned int count) {
2891  return static_cast<int>(read(fd, buf, count));
2892 }
2893 inline int Write(int fd, const void* buf, unsigned int count) {
2894  return static_cast<int>(write(fd, buf, count));
2895 }
2896 inline int Close(int fd) { return close(fd); }
2897 inline const char* StrError(int errnum) { return strerror(errnum); }
2898 #endif
2899 inline const char* GetEnv(const char* name) {
2900 #if GTEST_OS_WINDOWS_MOBILE
2901  // We are on Windows CE, which has no environment variables.
2902  return NULL;
2903 #elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
2904  // Environment variables which we programmatically clear will be set to the
2905  // empty string rather than unset (NULL). Handle that case.
2906  const char* const env = getenv(name);
2907  return (env != NULL && env[0] != '\0') ? env : NULL;
2908 #else
2909  return getenv(name);
2910 #endif
2911 }
2912 
2913 #ifdef _MSC_VER
2914 # pragma warning(pop) // Restores the warning state.
2915 #endif
2916 
2917 #if GTEST_OS_WINDOWS_MOBILE
2918 // Windows CE has no C library. The abort() function is used in
2919 // several places in Google Test. This implementation provides a reasonable
2920 // imitation of standard behaviour.
2921 void Abort();
2922 #else
2923 inline void Abort() { abort(); }
2924 #endif // GTEST_OS_WINDOWS_MOBILE
2925 
2926 } // namespace posix
2927 
2928 // MSVC "deprecates" snprintf and issues warnings wherever it is used. In
2929 // order to avoid these warnings, we need to use _snprintf or _snprintf_s on
2930 // MSVC-based platforms. We map the GTEST_SNPRINTF_ macro to the appropriate
2931 // function in order to achieve that. We use macro definition here because
2932 // snprintf is a variadic function.
2933 #if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE
2934 // MSVC 2005 and above support variadic macros.
2935 # define GTEST_SNPRINTF_(buffer, size, format, ...) \
2936  _snprintf_s(buffer, size, size, format, __VA_ARGS__)
2937 #elif defined(_MSC_VER)
2938 // Windows CE does not define _snprintf_s and MSVC prior to 2005 doesn't
2939 // complain about _snprintf.
2940 # define GTEST_SNPRINTF_ _snprintf
2941 #else
2942 # define GTEST_SNPRINTF_ snprintf
2943 #endif
2944 
2945 // The maximum number a BiggestInt can represent. This definition
2946 // works no matter BiggestInt is represented in one's complement or
2947 // two's complement.
2948 //
2949 // We cannot rely on numeric_limits in STL, as __int64 and long long
2950 // are not part of standard C++ and numeric_limits doesn't need to be
2951 // defined for them.
2952 const BiggestInt kMaxBiggestInt =
2953  ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1));
2954 
2955 // This template class serves as a compile-time function from size to
2956 // type. It maps a size in bytes to a primitive type with that
2957 // size. e.g.
2958 //
2959 // TypeWithSize<4>::UInt
2960 //
2961 // is typedef-ed to be unsigned int (unsigned integer made up of 4
2962 // bytes).
2963 //
2964 // Such functionality should belong to STL, but I cannot find it
2965 // there.
2966 //
2967 // Google Test uses this class in the implementation of floating-point
2968 // comparison.
2969 //
2970 // For now it only handles UInt (unsigned int) as that's all Google Test
2971 // needs. Other types can be easily added in the future if need
2972 // arises.
2973 template <size_t size>
2975  public:
2976  // This prevents the user from using TypeWithSize<N> with incorrect
2977  // values of N.
2978  typedef void UInt;
2979 };
2980 
2981 // The specialization for size 4.
2982 template <>
2983 class TypeWithSize<4> {
2984  public:
2985  // unsigned int has size 4 in both gcc and MSVC.
2986  //
2987  // As base/basictypes.h doesn't compile on Windows, we cannot use
2988  // uint32, uint64, and etc here.
2989  typedef int Int;
2990  typedef unsigned int UInt;
2991 };
2992 
2993 // The specialization for size 8.
2994 template <>
2995 class TypeWithSize<8> {
2996  public:
2997 #if GTEST_OS_WINDOWS
2998  typedef __int64 Int;
2999  typedef unsigned __int64 UInt;
3000 #else
3001  typedef long long Int; // NOLINT
3002  typedef unsigned long long UInt; // NOLINT
3003 #endif // GTEST_OS_WINDOWS
3004 };
3005 
3006 // Integer types of known sizes.
3011 typedef TypeWithSize<8>::Int TimeInMillis; // Represents time in milliseconds.
3012 
3013 // Utilities for command line flags and environment variables.
3014 
3015 // Macro for referencing flags.
3016 #define GTEST_FLAG(name) FLAGS_gtest_##name
3017 
3018 // Macros for declaring flags.
3019 #define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
3020 #define GTEST_DECLARE_int32_(name) \
3021  GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name)
3022 #define GTEST_DECLARE_string_(name) \
3023  GTEST_API_ extern ::std::string GTEST_FLAG(name)
3024 
3025 // Macros for defining flags.
3026 #define GTEST_DEFINE_bool_(name, default_val, doc) \
3027  GTEST_API_ bool GTEST_FLAG(name) = (default_val)
3028 #define GTEST_DEFINE_int32_(name, default_val, doc) \
3029  GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
3030 #define GTEST_DEFINE_string_(name, default_val, doc) \
3031  GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)
3032 
3033 // Thread annotations
3034 #define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
3035 #define GTEST_LOCK_EXCLUDED_(locks)
3036 
3037 // Parses 'str' for a 32-bit signed integer. If successful, writes the result
3038 // to *value and returns true; otherwise leaves *value unchanged and returns
3039 // false.
3040 // TODO(chandlerc): Find a better way to refactor flag and environment parsing
3041 // out of both gtest-port.cc and gtest.cc to avoid exporting this utility
3042 // function.
3043 bool ParseInt32(const Message& src_text, const char* str, Int32* value);
3044 
3045 // Parses a bool/Int32/string from the environment variable
3046 // corresponding to the given Google Test flag.
3047 bool BoolFromGTestEnv(const char* flag, bool default_val);
3048 GTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val);
3049 const char* StringFromGTestEnv(const char* flag, const char* default_val);
3050 
3051 } // namespace internal
3052 } // namespace testing
3053 
3054 #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
3055 
3056 #if GTEST_OS_LINUX
3057 # include <stdlib.h>
3058 # include <sys/types.h>
3059 # include <sys/wait.h>
3060 # include <unistd.h>
3061 #endif // GTEST_OS_LINUX
3062 
3063 #if GTEST_HAS_EXCEPTIONS
3064 # include <stdexcept>
3065 #endif
3066 
3067 #include <ctype.h>
3068 #include <float.h>
3069 #include <string.h>
3070 #include <iomanip>
3071 #include <limits>
3072 #include <set>
3073 
3074 // Copyright 2005, Google Inc.
3075 // All rights reserved.
3076 //
3077 // Redistribution and use in source and binary forms, with or without
3078 // modification, are permitted provided that the following conditions are
3079 // met:
3080 //
3081 // * Redistributions of source code must retain the above copyright
3082 // notice, this list of conditions and the following disclaimer.
3083 // * Redistributions in binary form must reproduce the above
3084 // copyright notice, this list of conditions and the following disclaimer
3085 // in the documentation and/or other materials provided with the
3086 // distribution.
3087 // * Neither the name of Google Inc. nor the names of its
3088 // contributors may be used to endorse or promote products derived from
3089 // this software without specific prior written permission.
3090 //
3091 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
3092 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
3093 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
3094 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
3095 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
3096 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
3097 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
3098 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
3099 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
3100 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
3101 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
3102 //
3103 // Author: wan@google.com (Zhanyong Wan)
3104 //
3105 // The Google C++ Testing Framework (Google Test)
3106 //
3107 // This header file defines the Message class.
3108 //
3109 // IMPORTANT NOTE: Due to limitation of the C++ language, we have to
3110 // leave some internal implementation details in this header file.
3111 // They are clearly marked by comments like this:
3112 //
3113 // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
3114 //
3115 // Such code is NOT meant to be used by a user directly, and is subject
3116 // to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user
3117 // program!
3118 
3119 #ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
3120 #define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
3121 
3122 #include <limits>
3123 
3124 
3125 // Ensures that there is at least one operator<< in the global namespace.
3126 // See Message& operator<<(...) below for why.
3127 void operator<<(const testing::internal::Secret&, int);
3128 
3129 namespace testing {
3130 
3131 // The Message class works like an ostream repeater.
3132 //
3133 // Typical usage:
3134 //
3135 // 1. You stream a bunch of values to a Message object.
3136 // It will remember the text in a stringstream.
3137 // 2. Then you stream the Message object to an ostream.
3138 // This causes the text in the Message to be streamed
3139 // to the ostream.
3140 //
3141 // For example;
3142 //
3143 // testing::Message foo;
3144 // foo << 1 << " != " << 2;
3145 // std::cout << foo;
3146 //
3147 // will print "1 != 2".
3148 //
3149 // Message is not intended to be inherited from. In particular, its
3150 // destructor is not virtual.
3151 //
3152 // Note that stringstream behaves differently in gcc and in MSVC. You
3153 // can stream a NULL char pointer to it in the former, but not in the
3154 // latter (it causes an access violation if you do). The Message
3155 // class hides this difference by treating a NULL char pointer as
3156 // "(null)".
3158  private:
3159  // The type of basic IO manipulators (endl, ends, and flush) for
3160  // narrow streams.
3161  typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
3162 
3163  public:
3164  // Constructs an empty Message.
3165  Message();
3166 
3167  // Copy constructor.
3168  Message(const Message& msg) : ss_(new ::std::stringstream) { // NOLINT
3169  *ss_ << msg.GetString();
3170  }
3171 
3172  // Constructs a Message from a C-string.
3173  explicit Message(const char* str) : ss_(new ::std::stringstream) {
3174  *ss_ << str;
3175  }
3176 
3177 #if GTEST_OS_SYMBIAN
3178  // Streams a value (either a pointer or not) to this object.
3179  template <typename T>
3180  inline Message& operator <<(const T& value) {
3181  StreamHelper(typename internal::is_pointer<T>::type(), value);
3182  return *this;
3183  }
3184 #else
3185  // Streams a non-pointer value to this object.
3186  template <typename T>
3187  inline Message& operator <<(const T& val) {
3188  // Some libraries overload << for STL containers. These
3189  // overloads are defined in the global namespace instead of ::std.
3190  //
3191  // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
3192  // overloads are visible in either the std namespace or the global
3193  // namespace, but not other namespaces, including the testing
3194  // namespace which Google Test's Message class is in.
3195  //
3196  // To allow STL containers (and other types that has a << operator
3197  // defined in the global namespace) to be used in Google Test
3198  // assertions, testing::Message must access the custom << operator
3199  // from the global namespace. With this using declaration,
3200  // overloads of << defined in the global namespace and those
3201  // visible via Koenig lookup are both exposed in this function.
3202  using ::operator <<;
3203  *ss_ << val;
3204  return *this;
3205  }
3206 
3207  // Streams a pointer value to this object.
3208  //
3209  // This function is an overload of the previous one. When you
3210  // stream a pointer to a Message, this definition will be used as it
3211  // is more specialized. (The C++ Standard, section
3212  // [temp.func.order].) If you stream a non-pointer, then the
3213  // previous definition will be used.
3214  //
3215  // The reason for this overload is that streaming a NULL pointer to
3216  // ostream is undefined behavior. Depending on the compiler, you
3217  // may get "0", "(nil)", "(null)", or an access violation. To
3218  // ensure consistent result across compilers, we always treat NULL
3219  // as "(null)".
3220  template <typename T>
3221  inline Message& operator <<(T* const& pointer) { // NOLINT
3222  if (pointer == NULL) {
3223  *ss_ << "(null)";
3224  } else {
3225  *ss_ << pointer;
3226  }
3227  return *this;
3228  }
3229 #endif // GTEST_OS_SYMBIAN
3230 
3231  // Since the basic IO manipulators are overloaded for both narrow
3232  // and wide streams, we have to provide this specialized definition
3233  // of operator <<, even though its body is the same as the
3234  // templatized version above. Without this definition, streaming
3235  // endl or other basic IO manipulators to Message will confuse the
3236  // compiler.
3237  Message& operator <<(BasicNarrowIoManip val) {
3238  *ss_ << val;
3239  return *this;
3240  }
3241 
3242  // Instead of 1/0, we want to see true/false for bool values.
3244  return *this << (b ? "true" : "false");
3245  }
3246 
3247  // These two overloads allow streaming a wide C string to a Message
3248  // using the UTF-8 encoding.
3249  Message& operator <<(const wchar_t* wide_c_str);
3250  Message& operator <<(wchar_t* wide_c_str);
3251 
3252 #if GTEST_HAS_STD_WSTRING
3253  // Converts the given wide string to a narrow string using the UTF-8
3254  // encoding, and streams the result to this Message object.
3256 #endif // GTEST_HAS_STD_WSTRING
3257 
3258 #if GTEST_HAS_GLOBAL_WSTRING
3259  // Converts the given wide string to a narrow string using the UTF-8
3260  // encoding, and streams the result to this Message object.
3262 #endif // GTEST_HAS_GLOBAL_WSTRING
3263 
3264  // Gets the text streamed to this object so far as an std::string.
3265  // Each '\0' character in the buffer is replaced with "\\0".
3266  //
3267  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
3268  std::string GetString() const;
3269 
3270  private:
3271 
3272 #if GTEST_OS_SYMBIAN
3273  // These are needed as the Nokia Symbian Compiler cannot decide between
3274  // const T& and const T* in a function template. The Nokia compiler _can_
3275  // decide between class template specializations for T and T*, so a
3276  // tr1::type_traits-like is_pointer works, and we can overload on that.
3277  template <typename T>
3278  inline void StreamHelper(internal::true_type /*is_pointer*/, T* pointer) {
3279  if (pointer == NULL) {
3280  *ss_ << "(null)";
3281  } else {
3282  *ss_ << pointer;
3283  }
3284  }
3285  template <typename T>
3286  inline void StreamHelper(internal::false_type /*is_pointer*/,
3287  const T& value) {
3288  // See the comments in Message& operator <<(const T&) above for why
3289  // we need this using statement.
3290  using ::operator <<;
3291  *ss_ << value;
3292  }
3293 #endif // GTEST_OS_SYMBIAN
3294 
3295  // We'll hold the text streamed to this object here.
3297 
3298  // We declare (but don't implement) this to prevent the compiler
3299  // from implementing the assignment operator.
3300  void operator=(const Message&);
3301 };
3302 
3303 // Streams a Message to an ostream.
3304 inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
3305  return os << sb.GetString();
3306 }
3307 
3308 namespace internal {
3309 
3310 // Converts a streamable value to an std::string. A NULL pointer is
3311 // converted to "(null)". When the input value is a ::string,
3312 // ::std::string, ::wstring, or ::std::wstring object, each NUL
3313 // character in it is replaced with "\\0".
3314 template <typename T>
3315 std::string StreamableToString(const T& streamable) {
3316  return (Message() << streamable).GetString();
3317 }
3318 
3319 } // namespace internal
3320 } // namespace testing
3321 
3322 #endif // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
3323 // Copyright 2005, Google Inc.
3324 // All rights reserved.
3325 //
3326 // Redistribution and use in source and binary forms, with or without
3327 // modification, are permitted provided that the following conditions are
3328 // met:
3329 //
3330 // * Redistributions of source code must retain the above copyright
3331 // notice, this list of conditions and the following disclaimer.
3332 // * Redistributions in binary form must reproduce the above
3333 // copyright notice, this list of conditions and the following disclaimer
3334 // in the documentation and/or other materials provided with the
3335 // distribution.
3336 // * Neither the name of Google Inc. nor the names of its
3337 // contributors may be used to endorse or promote products derived from
3338 // this software without specific prior written permission.
3339 //
3340 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
3341 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
3342 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
3343 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
3344 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
3345 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
3346 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
3347 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
3348 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
3349 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
3350 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
3351 //
3352 // Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
3353 //
3354 // The Google C++ Testing Framework (Google Test)
3355 //
3356 // This header file declares the String class and functions used internally by
3357 // Google Test. They are subject to change without notice. They should not used
3358 // by code external to Google Test.
3359 //
3360 // This header file is #included by <gtest/internal/gtest-internal.h>.
3361 // It should not be #included by other files.
3362 
3363 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
3364 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
3365 
3366 #ifdef __BORLANDC__
3367 // string.h is not guaranteed to provide strcpy on C++ Builder.
3368 # include <mem.h>
3369 #endif
3370 
3371 #include <string.h>
3372 #include <string>
3373 
3374 
3375 namespace testing {
3376 namespace internal {
3377 
3378 // String - an abstract class holding static string utilities.
3380  public:
3381  // Static utility methods
3382 
3383  // Clones a 0-terminated C string, allocating memory using new. The
3384  // caller is responsible for deleting the return value using
3385  // delete[]. Returns the cloned string, or NULL if the input is
3386  // NULL.
3387  //
3388  // This is different from strdup() in string.h, which allocates
3389  // memory using malloc().
3390  static const char* CloneCString(const char* c_str);
3391 
3392 #if GTEST_OS_WINDOWS_MOBILE
3393  // Windows CE does not have the 'ANSI' versions of Win32 APIs. To be
3394  // able to pass strings to Win32 APIs on CE we need to convert them
3395  // to 'Unicode', UTF-16.
3396 
3397  // Creates a UTF-16 wide string from the given ANSI string, allocating
3398  // memory using new. The caller is responsible for deleting the return
3399  // value using delete[]. Returns the wide string, or NULL if the
3400  // input is NULL.
3401  //
3402  // The wide string is created using the ANSI codepage (CP_ACP) to
3403  // match the behaviour of the ANSI versions of Win32 calls and the
3404  // C runtime.
3405  static LPCWSTR AnsiToUtf16(const char* c_str);
3406 
3407  // Creates an ANSI string from the given wide string, allocating
3408  // memory using new. The caller is responsible for deleting the return
3409  // value using delete[]. Returns the ANSI string, or NULL if the
3410  // input is NULL.
3411  //
3412  // The returned string is created using the ANSI codepage (CP_ACP) to
3413  // match the behaviour of the ANSI versions of Win32 calls and the
3414  // C runtime.
3415  static const char* Utf16ToAnsi(LPCWSTR utf16_str);
3416 #endif
3417 
3418  // Compares two C strings. Returns true iff they have the same content.
3419  //
3420  // Unlike strcmp(), this function can handle NULL argument(s). A
3421  // NULL C string is considered different to any non-NULL C string,
3422  // including the empty string.
3423  static bool CStringEquals(const char* lhs, const char* rhs);
3424 
3425  // Converts a wide C string to a String using the UTF-8 encoding.
3426  // NULL will be converted to "(null)". If an error occurred during
3427  // the conversion, "(failed to convert from wide string)" is
3428  // returned.
3429  static std::string ShowWideCString(const wchar_t* wide_c_str);
3430 
3431  // Compares two wide C strings. Returns true iff they have the same
3432  // content.
3433  //
3434  // Unlike wcscmp(), this function can handle NULL argument(s). A
3435  // NULL C string is considered different to any non-NULL C string,
3436  // including the empty string.
3437  static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs);
3438 
3439  // Compares two C strings, ignoring case. Returns true iff they
3440  // have the same content.
3441  //
3442  // Unlike strcasecmp(), this function can handle NULL argument(s).
3443  // A NULL C string is considered different to any non-NULL C string,
3444  // including the empty string.
3445  static bool CaseInsensitiveCStringEquals(const char* lhs,
3446  const char* rhs);
3447 
3448  // Compares two wide C strings, ignoring case. Returns true iff they
3449  // have the same content.
3450  //
3451  // Unlike wcscasecmp(), this function can handle NULL argument(s).
3452  // A NULL C string is considered different to any non-NULL wide C string,
3453  // including the empty string.
3454  // NB: The implementations on different platforms slightly differ.
3455  // On windows, this method uses _wcsicmp which compares according to LC_CTYPE
3456  // environment variable. On GNU platform this method uses wcscasecmp
3457  // which compares according to LC_CTYPE category of the current locale.
3458  // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
3459  // current locale.
3460  static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
3461  const wchar_t* rhs);
3462 
3463  // Returns true iff the given string ends with the given suffix, ignoring
3464  // case. Any string is considered to end with an empty suffix.
3465  static bool EndsWithCaseInsensitive(
3466  const std::string& str, const std::string& suffix);
3467 
3468  // Formats an int value as "%02d".
3469  static std::string FormatIntWidth2(int value); // "%02d" for width == 2
3470 
3471  // Formats an int value as "%X".
3472  static std::string FormatHexInt(int value);
3473 
3474  // Formats a byte as "%02X".
3475  static std::string FormatByte(unsigned char value);
3476 
3477  private:
3478  String(); // Not meant to be instantiated.
3479 }; // class String
3480 
3481 // Gets the content of the stringstream's buffer as an std::string. Each '\0'
3482 // character in the buffer is replaced with "\\0".
3483 GTEST_API_ std::string StringStreamToString(::std::stringstream* stream);
3484 
3485 } // namespace internal
3486 } // namespace testing
3487 
3488 #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
3489 // Copyright 2008, Google Inc.
3490 // All rights reserved.
3491 //
3492 // Redistribution and use in source and binary forms, with or without
3493 // modification, are permitted provided that the following conditions are
3494 // met:
3495 //
3496 // * Redistributions of source code must retain the above copyright
3497 // notice, this list of conditions and the following disclaimer.
3498 // * Redistributions in binary form must reproduce the above
3499 // copyright notice, this list of conditions and the following disclaimer
3500 // in the documentation and/or other materials provided with the
3501 // distribution.
3502 // * Neither the name of Google Inc. nor the names of its
3503 // contributors may be used to endorse or promote products derived from
3504 // this software without specific prior written permission.
3505 //
3506 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
3507 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
3508 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
3509 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
3510 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
3511 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
3512 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
3513 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
3514 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
3515 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
3516 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
3517 //
3518 // Author: keith.ray@gmail.com (Keith Ray)
3519 //
3520 // Google Test filepath utilities
3521 //
3522 // This header file declares classes and functions used internally by
3523 // Google Test. They are subject to change without notice.
3524 //
3525 // This file is #included in <gtest/internal/gtest-internal.h>.
3526 // Do not include this header file separately!
3527 
3528 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
3529 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
3530 
3531 
3532 namespace testing {
3533 namespace internal {
3534 
3535 // FilePath - a class for file and directory pathname manipulation which
3536 // handles platform-specific conventions (like the pathname separator).
3537 // Used for helper functions for naming files in a directory for xml output.
3538 // Except for Set methods, all methods are const or static, which provides an
3539 // "immutable value object" -- useful for peace of mind.
3540 // A FilePath with a value ending in a path separator ("like/this/") represents
3541 // a directory, otherwise it is assumed to represent a file. In either case,
3542 // it may or may not represent an actual file or directory in the file system.
3543 // Names are NOT checked for syntax correctness -- no checking for illegal
3544 // characters, malformed paths, etc.
3545 
3547  public:
3548  FilePath() : pathname_("") { }
3549  FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
3550 
3551  explicit FilePath(const std::string& pathname) : pathname_(pathname) {
3552  Normalize();
3553  }
3554 
3555  FilePath& operator=(const FilePath& rhs) {
3556  Set(rhs);
3557  return *this;
3558  }
3559 
3560  void Set(const FilePath& rhs) {
3561  pathname_ = rhs.pathname_;
3562  }
3563 
3564  const std::string& string() const { return pathname_; }
3565  const char* c_str() const { return pathname_.c_str(); }
3566 
3567  // Returns the current working directory, or "" if unsuccessful.
3568  static FilePath GetCurrentDir();
3569 
3570  // Given directory = "dir", base_name = "test", number = 0,
3571  // extension = "xml", returns "dir/test.xml". If number is greater
3572  // than zero (e.g., 12), returns "dir/test_12.xml".
3573  // On Windows platform, uses \ as the separator rather than /.
3574  static FilePath MakeFileName(const FilePath& directory,
3575  const FilePath& base_name,
3576  int number,
3577  const char* extension);
3578 
3579  // Given directory = "dir", relative_path = "test.xml",
3580  // returns "dir/test.xml".
3581  // On Windows, uses \ as the separator rather than /.
3582  static FilePath ConcatPaths(const FilePath& directory,
3583  const FilePath& relative_path);
3584 
3585  // Returns a pathname for a file that does not currently exist. The pathname
3586  // will be directory/base_name.extension or
3587  // directory/base_name_<number>.extension if directory/base_name.extension
3588  // already exists. The number will be incremented until a pathname is found
3589  // that does not already exist.
3590  // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
3591  // There could be a race condition if two or more processes are calling this
3592  // function at the same time -- they could both pick the same filename.
3593  static FilePath GenerateUniqueFileName(const FilePath& directory,
3594  const FilePath& base_name,
3595  const char* extension);
3596 
3597  // Returns true iff the path is "".
3598  bool IsEmpty() const { return pathname_.empty(); }
3599 
3600  // If input name has a trailing separator character, removes it and returns
3601  // the name, otherwise return the name string unmodified.
3602  // On Windows platform, uses \ as the separator, other platforms use /.
3603  FilePath RemoveTrailingPathSeparator() const;
3604 
3605  // Returns a copy of the FilePath with the directory part removed.
3606  // Example: FilePath("path/to/file").RemoveDirectoryName() returns
3607  // FilePath("file"). If there is no directory part ("just_a_file"), it returns
3608  // the FilePath unmodified. If there is no file part ("just_a_dir/") it
3609  // returns an empty FilePath ("").
3610  // On Windows platform, '\' is the path separator, otherwise it is '/'.
3611  FilePath RemoveDirectoryName() const;
3612 
3613  // RemoveFileName returns the directory path with the filename removed.
3614  // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
3615  // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
3616  // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
3617  // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
3618  // On Windows platform, '\' is the path separator, otherwise it is '/'.
3619  FilePath RemoveFileName() const;
3620 
3621  // Returns a copy of the FilePath with the case-insensitive extension removed.
3622  // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
3623  // FilePath("dir/file"). If a case-insensitive extension is not
3624  // found, returns a copy of the original FilePath.
3625  FilePath RemoveExtension(const char* extension) const;
3626 
3627  // Creates directories so that path exists. Returns true if successful or if
3628  // the directories already exist; returns false if unable to create
3629  // directories for any reason. Will also return false if the FilePath does
3630  // not represent a directory (that is, it doesn't end with a path separator).
3631  bool CreateDirectoriesRecursively() const;
3632 
3633  // Create the directory so that path exists. Returns true if successful or
3634  // if the directory already exists; returns false if unable to create the
3635  // directory for any reason, including if the parent directory does not
3636  // exist. Not named "CreateDirectory" because that's a macro on Windows.
3637  bool CreateFolder() const;
3638 
3639  // Returns true if FilePath describes something in the file-system,
3640  // either a file, directory, or whatever, and that something exists.
3641  bool FileOrDirectoryExists() const;
3642 
3643  // Returns true if pathname describes a directory in the file-system
3644  // that exists.
3645  bool DirectoryExists() const;
3646 
3647  // Returns true if FilePath ends with a path separator, which indicates that
3648  // it is intended to represent a directory. Returns false otherwise.
3649  // This does NOT check that a directory (or file) actually exists.
3650  bool IsDirectory() const;
3651 
3652  // Returns true if pathname describes a root directory. (Windows has one
3653  // root directory per disk drive.)
3654  bool IsRootDirectory() const;
3655 
3656  // Returns true if pathname describes an absolute path.
3657  bool IsAbsolutePath() const;
3658 
3659  private:
3660  // Replaces multiple consecutive separators with a single separator.
3661  // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
3662  // redundancies that might be in a pathname involving "." or "..".
3663  //
3664  // A pathname with multiple consecutive separators may occur either through
3665  // user error or as a result of some scripts or APIs that generate a pathname
3666  // with a trailing separator. On other platforms the same API or script
3667  // may NOT generate a pathname with a trailing "/". Then elsewhere that
3668  // pathname may have another "/" and pathname components added to it,
3669  // without checking for the separator already being there.
3670  // The script language and operating system may allow paths like "foo//bar"
3671  // but some of the functions in FilePath will not handle that correctly. In
3672  // particular, RemoveTrailingPathSeparator() only removes one separator, and
3673  // it is called in CreateDirectoriesRecursively() assuming that it will change
3674  // a pathname from directory syntax (trailing separator) to filename syntax.
3675  //
3676  // On Windows this method also replaces the alternate path separator '/' with
3677  // the primary path separator '\\', so that for example "bar\\/\\foo" becomes
3678  // "bar\\foo".
3679 
3680  void Normalize();
3681 
3682  // Returns a pointer to the last occurence of a valid path separator in
3683  // the FilePath. On Windows, for example, both '/' and '\' are valid path
3684  // separators. Returns NULL if no path separator was found.
3685  const char* FindLastPathSeparator() const;
3686 
3688 }; // class FilePath
3689 
3690 } // namespace internal
3691 } // namespace testing
3692 
3693 #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
3694 // This file was GENERATED by command:
3695 // pump.py gtest-type-util.h.pump
3696 // DO NOT EDIT BY HAND!!!
3697 
3698 // Copyright 2008 Google Inc.
3699 // All Rights Reserved.
3700 //
3701 // Redistribution and use in source and binary forms, with or without
3702 // modification, are permitted provided that the following conditions are
3703 // met:
3704 //
3705 // * Redistributions of source code must retain the above copyright
3706 // notice, this list of conditions and the following disclaimer.
3707 // * Redistributions in binary form must reproduce the above
3708 // copyright notice, this list of conditions and the following disclaimer
3709 // in the documentation and/or other materials provided with the
3710 // distribution.
3711 // * Neither the name of Google Inc. nor the names of its
3712 // contributors may be used to endorse or promote products derived from
3713 // this software without specific prior written permission.
3714 //
3715 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
3716 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
3717 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
3718 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
3719 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
3720 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
3721 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
3722 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
3723 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
3724 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
3725 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
3726 //
3727 // Author: wan@google.com (Zhanyong Wan)
3728 
3729 // Type utilities needed for implementing typed and type-parameterized
3730 // tests. This file is generated by a SCRIPT. DO NOT EDIT BY HAND!
3731 //
3732 // Currently we support at most 50 types in a list, and at most 50
3733 // type-parameterized tests in one type-parameterized test case.
3734 // Please contact googletestframework@googlegroups.com if you need
3735 // more.
3736 
3737 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
3738 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
3739 
3740 
3741 // #ifdef __GNUC__ is too general here. It is possible to use gcc without using
3742 // libstdc++ (which is where cxxabi.h comes from).
3743 # if GTEST_HAS_CXXABI_H_
3744 # include <cxxabi.h>
3745 # elif defined(__HP_aCC)
3746 # include <acxx_demangle.h>
3747 # endif // GTEST_HASH_CXXABI_H_
3748 
3749 namespace testing {
3750 namespace internal {
3751 
3752 // GetTypeName<T>() returns a human-readable name of type T.
3753 // NB: This function is also used in Google Mock, so don't move it inside of
3754 // the typed-test-only section below.
3755 template <typename T>
3757 # if GTEST_HAS_RTTI
3758 
3759  const char* const name = typeid(T).name();
3760 # if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC)
3761  int status = 0;
3762  // gcc's implementation of typeid(T).name() mangles the type name,
3763  // so we have to demangle it.
3764 # if GTEST_HAS_CXXABI_H_
3765  using abi::__cxa_demangle;
3766 # endif // GTEST_HAS_CXXABI_H_
3767  char* const readable_name = __cxa_demangle(name, 0, 0, &status);
3768  const std::string name_str(status == 0 ? readable_name : name);
3769  free(readable_name);
3770  return name_str;
3771 # else
3772  return name;
3773 # endif // GTEST_HAS_CXXABI_H_ || __HP_aCC
3774 
3775 # else
3776 
3777  return "<type>";
3778 
3779 # endif // GTEST_HAS_RTTI
3780 }
3781 
3782 #if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
3783 
3784 // AssertyTypeEq<T1, T2>::type is defined iff T1 and T2 are the same
3785 // type. This can be used as a compile-time assertion to ensure that
3786 // two types are equal.
3787 
3788 template <typename T1, typename T2>
3789 struct AssertTypeEq;
3790 
3791 template <typename T>
3792 struct AssertTypeEq<T, T> {
3793  typedef bool type;
3794 };
3795 
3796 // A unique type used as the default value for the arguments of class
3797 // template Types. This allows us to simulate variadic templates
3798 // (e.g. Types<int>, Type<int, double>, and etc), which C++ doesn't
3799 // support directly.
3800 struct None {};
3801 
3802 // The following family of struct and struct templates are used to
3803 // represent type lists. In particular, TypesN<T1, T2, ..., TN>
3804 // represents a type list with N types (T1, T2, ..., and TN) in it.
3805 // Except for Types0, every struct in the family has two member types:
3806 // Head for the first type in the list, and Tail for the rest of the
3807 // list.
3808 
3809 // The empty type list.
3810 struct Types0 {};
3811 
3812 // Type lists of length 1, 2, 3, and so on.
3813 
3814 template <typename T1>
3815 struct Types1 {
3816  typedef T1 Head;
3817  typedef Types0 Tail;
3818 };
3819 template <typename T1, typename T2>
3820 struct Types2 {
3821  typedef T1 Head;
3822  typedef Types1<T2> Tail;
3823 };
3824 
3825 template <typename T1, typename T2, typename T3>
3826 struct Types3 {
3827  typedef T1 Head;
3828  typedef Types2<T2, T3> Tail;
3829 };
3830 
3831 template <typename T1, typename T2, typename T3, typename T4>
3832 struct Types4 {
3833  typedef T1 Head;
3834  typedef Types3<T2, T3, T4> Tail;
3835 };
3836 
3837 template <typename T1, typename T2, typename T3, typename T4, typename T5>
3838 struct Types5 {
3839  typedef T1 Head;
3840  typedef Types4<T2, T3, T4, T5> Tail;
3841 };
3842 
3843 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3844  typename T6>
3845 struct Types6 {
3846  typedef T1 Head;
3847  typedef Types5<T2, T3, T4, T5, T6> Tail;
3848 };
3849 
3850 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3851  typename T6, typename T7>
3852 struct Types7 {
3853  typedef T1 Head;
3854  typedef Types6<T2, T3, T4, T5, T6, T7> Tail;
3855 };
3856 
3857 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3858  typename T6, typename T7, typename T8>
3859 struct Types8 {
3860  typedef T1 Head;
3861  typedef Types7<T2, T3, T4, T5, T6, T7, T8> Tail;
3862 };
3863 
3864 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3865  typename T6, typename T7, typename T8, typename T9>
3866 struct Types9 {
3867  typedef T1 Head;
3868  typedef Types8<T2, T3, T4, T5, T6, T7, T8, T9> Tail;
3869 };
3870 
3871 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3872  typename T6, typename T7, typename T8, typename T9, typename T10>
3873 struct Types10 {
3874  typedef T1 Head;
3875  typedef Types9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail;
3876 };
3877 
3878 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3879  typename T6, typename T7, typename T8, typename T9, typename T10,
3880  typename T11>
3881 struct Types11 {
3882  typedef T1 Head;
3883  typedef Types10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail;
3884 };
3885 
3886 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3887  typename T6, typename T7, typename T8, typename T9, typename T10,
3888  typename T11, typename T12>
3889 struct Types12 {
3890  typedef T1 Head;
3891  typedef Types11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail;
3892 };
3893 
3894 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3895  typename T6, typename T7, typename T8, typename T9, typename T10,
3896  typename T11, typename T12, typename T13>
3897 struct Types13 {
3898  typedef T1 Head;
3899  typedef Types12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Tail;
3900 };
3901 
3902 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3903  typename T6, typename T7, typename T8, typename T9, typename T10,
3904  typename T11, typename T12, typename T13, typename T14>
3905 struct Types14 {
3906  typedef T1 Head;
3907  typedef Types13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Tail;
3908 };
3909 
3910 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3911  typename T6, typename T7, typename T8, typename T9, typename T10,
3912  typename T11, typename T12, typename T13, typename T14, typename T15>
3913 struct Types15 {
3914  typedef T1 Head;
3915  typedef Types14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
3916  T15> Tail;
3917 };
3918 
3919 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3920  typename T6, typename T7, typename T8, typename T9, typename T10,
3921  typename T11, typename T12, typename T13, typename T14, typename T15,
3922  typename T16>
3923 struct Types16 {
3924  typedef T1 Head;
3925  typedef Types15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
3926  T16> Tail;
3927 };
3928 
3929 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3930  typename T6, typename T7, typename T8, typename T9, typename T10,
3931  typename T11, typename T12, typename T13, typename T14, typename T15,
3932  typename T16, typename T17>
3933 struct Types17 {
3934  typedef T1 Head;
3935  typedef Types16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
3936  T16, T17> Tail;
3937 };
3938 
3939 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3940  typename T6, typename T7, typename T8, typename T9, typename T10,
3941  typename T11, typename T12, typename T13, typename T14, typename T15,
3942  typename T16, typename T17, typename T18>
3943 struct Types18 {
3944  typedef T1 Head;
3945  typedef Types17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
3946  T16, T17, T18> Tail;
3947 };
3948 
3949 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3950  typename T6, typename T7, typename T8, typename T9, typename T10,
3951  typename T11, typename T12, typename T13, typename T14, typename T15,
3952  typename T16, typename T17, typename T18, typename T19>
3953 struct Types19 {
3954  typedef T1 Head;
3955  typedef Types18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
3956  T16, T17, T18, T19> Tail;
3957 };
3958 
3959 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3960  typename T6, typename T7, typename T8, typename T9, typename T10,
3961  typename T11, typename T12, typename T13, typename T14, typename T15,
3962  typename T16, typename T17, typename T18, typename T19, typename T20>
3963 struct Types20 {
3964  typedef T1 Head;
3965  typedef Types19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
3966  T16, T17, T18, T19, T20> Tail;
3967 };
3968 
3969 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3970  typename T6, typename T7, typename T8, typename T9, typename T10,
3971  typename T11, typename T12, typename T13, typename T14, typename T15,
3972  typename T16, typename T17, typename T18, typename T19, typename T20,
3973  typename T21>
3974 struct Types21 {
3975  typedef T1 Head;
3976  typedef Types20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
3977  T16, T17, T18, T19, T20, T21> Tail;
3978 };
3979 
3980 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3981  typename T6, typename T7, typename T8, typename T9, typename T10,
3982  typename T11, typename T12, typename T13, typename T14, typename T15,
3983  typename T16, typename T17, typename T18, typename T19, typename T20,
3984  typename T21, typename T22>
3985 struct Types22 {
3986  typedef T1 Head;
3987  typedef Types21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
3988  T16, T17, T18, T19, T20, T21, T22> Tail;
3989 };
3990 
3991 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3992  typename T6, typename T7, typename T8, typename T9, typename T10,
3993  typename T11, typename T12, typename T13, typename T14, typename T15,
3994  typename T16, typename T17, typename T18, typename T19, typename T20,
3995  typename T21, typename T22, typename T23>
3996 struct Types23 {
3997  typedef T1 Head;
3998  typedef Types22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
3999  T16, T17, T18, T19, T20, T21, T22, T23> Tail;
4000 };
4001 
4002 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4003  typename T6, typename T7, typename T8, typename T9, typename T10,
4004  typename T11, typename T12, typename T13, typename T14, typename T15,
4005  typename T16, typename T17, typename T18, typename T19, typename T20,
4006  typename T21, typename T22, typename T23, typename T24>
4007 struct Types24 {
4008  typedef T1 Head;
4009  typedef Types23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4010  T16, T17, T18, T19, T20, T21, T22, T23, T24> Tail;
4011 };
4012 
4013 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4014  typename T6, typename T7, typename T8, typename T9, typename T10,
4015  typename T11, typename T12, typename T13, typename T14, typename T15,
4016  typename T16, typename T17, typename T18, typename T19, typename T20,
4017  typename T21, typename T22, typename T23, typename T24, typename T25>
4018 struct Types25 {
4019  typedef T1 Head;
4020  typedef Types24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4021  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Tail;
4022 };
4023 
4024 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4025  typename T6, typename T7, typename T8, typename T9, typename T10,
4026  typename T11, typename T12, typename T13, typename T14, typename T15,
4027  typename T16, typename T17, typename T18, typename T19, typename T20,
4028  typename T21, typename T22, typename T23, typename T24, typename T25,
4029  typename T26>
4030 struct Types26 {
4031  typedef T1 Head;
4032  typedef Types25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4033  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Tail;
4034 };
4035 
4036 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4037  typename T6, typename T7, typename T8, typename T9, typename T10,
4038  typename T11, typename T12, typename T13, typename T14, typename T15,
4039  typename T16, typename T17, typename T18, typename T19, typename T20,
4040  typename T21, typename T22, typename T23, typename T24, typename T25,
4041  typename T26, typename T27>
4042 struct Types27 {
4043  typedef T1 Head;
4044  typedef Types26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4045  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> Tail;
4046 };
4047 
4048 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4049  typename T6, typename T7, typename T8, typename T9, typename T10,
4050  typename T11, typename T12, typename T13, typename T14, typename T15,
4051  typename T16, typename T17, typename T18, typename T19, typename T20,
4052  typename T21, typename T22, typename T23, typename T24, typename T25,
4053  typename T26, typename T27, typename T28>
4054 struct Types28 {
4055  typedef T1 Head;
4056  typedef Types27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4057  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28> Tail;
4058 };
4059 
4060 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4061  typename T6, typename T7, typename T8, typename T9, typename T10,
4062  typename T11, typename T12, typename T13, typename T14, typename T15,
4063  typename T16, typename T17, typename T18, typename T19, typename T20,
4064  typename T21, typename T22, typename T23, typename T24, typename T25,
4065  typename T26, typename T27, typename T28, typename T29>
4066 struct Types29 {
4067  typedef T1 Head;
4068  typedef Types28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4069  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
4070  T29> Tail;
4071 };
4072 
4073 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4074  typename T6, typename T7, typename T8, typename T9, typename T10,
4075  typename T11, typename T12, typename T13, typename T14, typename T15,
4076  typename T16, typename T17, typename T18, typename T19, typename T20,
4077  typename T21, typename T22, typename T23, typename T24, typename T25,
4078  typename T26, typename T27, typename T28, typename T29, typename T30>
4079 struct Types30 {
4080  typedef T1 Head;
4081  typedef Types29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4082  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4083  T30> Tail;
4084 };
4085 
4086 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4087  typename T6, typename T7, typename T8, typename T9, typename T10,
4088  typename T11, typename T12, typename T13, typename T14, typename T15,
4089  typename T16, typename T17, typename T18, typename T19, typename T20,
4090  typename T21, typename T22, typename T23, typename T24, typename T25,
4091  typename T26, typename T27, typename T28, typename T29, typename T30,
4092  typename T31>
4093 struct Types31 {
4094  typedef T1 Head;
4095  typedef Types30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4096  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4097  T30, T31> Tail;
4098 };
4099 
4100 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4101  typename T6, typename T7, typename T8, typename T9, typename T10,
4102  typename T11, typename T12, typename T13, typename T14, typename T15,
4103  typename T16, typename T17, typename T18, typename T19, typename T20,
4104  typename T21, typename T22, typename T23, typename T24, typename T25,
4105  typename T26, typename T27, typename T28, typename T29, typename T30,
4106  typename T31, typename T32>
4107 struct Types32 {
4108  typedef T1 Head;
4109  typedef Types31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4110  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4111  T30, T31, T32> Tail;
4112 };
4113 
4114 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4115  typename T6, typename T7, typename T8, typename T9, typename T10,
4116  typename T11, typename T12, typename T13, typename T14, typename T15,
4117  typename T16, typename T17, typename T18, typename T19, typename T20,
4118  typename T21, typename T22, typename T23, typename T24, typename T25,
4119  typename T26, typename T27, typename T28, typename T29, typename T30,
4120  typename T31, typename T32, typename T33>
4121 struct Types33 {
4122  typedef T1 Head;
4123  typedef Types32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4124  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4125  T30, T31, T32, T33> Tail;
4126 };
4127 
4128 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4129  typename T6, typename T7, typename T8, typename T9, typename T10,
4130  typename T11, typename T12, typename T13, typename T14, typename T15,
4131  typename T16, typename T17, typename T18, typename T19, typename T20,
4132  typename T21, typename T22, typename T23, typename T24, typename T25,
4133  typename T26, typename T27, typename T28, typename T29, typename T30,
4134  typename T31, typename T32, typename T33, typename T34>
4135 struct Types34 {
4136  typedef T1 Head;
4137  typedef Types33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4138  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4139  T30, T31, T32, T33, T34> Tail;
4140 };
4141 
4142 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4143  typename T6, typename T7, typename T8, typename T9, typename T10,
4144  typename T11, typename T12, typename T13, typename T14, typename T15,
4145  typename T16, typename T17, typename T18, typename T19, typename T20,
4146  typename T21, typename T22, typename T23, typename T24, typename T25,
4147  typename T26, typename T27, typename T28, typename T29, typename T30,
4148  typename T31, typename T32, typename T33, typename T34, typename T35>
4149 struct Types35 {
4150  typedef T1 Head;
4151  typedef Types34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4152  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4153  T30, T31, T32, T33, T34, T35> Tail;
4154 };
4155 
4156 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4157  typename T6, typename T7, typename T8, typename T9, typename T10,
4158  typename T11, typename T12, typename T13, typename T14, typename T15,
4159  typename T16, typename T17, typename T18, typename T19, typename T20,
4160  typename T21, typename T22, typename T23, typename T24, typename T25,
4161  typename T26, typename T27, typename T28, typename T29, typename T30,
4162  typename T31, typename T32, typename T33, typename T34, typename T35,
4163  typename T36>
4164 struct Types36 {
4165  typedef T1 Head;
4166  typedef Types35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4167  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4168  T30, T31, T32, T33, T34, T35, T36> Tail;
4169 };
4170 
4171 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4172  typename T6, typename T7, typename T8, typename T9, typename T10,
4173  typename T11, typename T12, typename T13, typename T14, typename T15,
4174  typename T16, typename T17, typename T18, typename T19, typename T20,
4175  typename T21, typename T22, typename T23, typename T24, typename T25,
4176  typename T26, typename T27, typename T28, typename T29, typename T30,
4177  typename T31, typename T32, typename T33, typename T34, typename T35,
4178  typename T36, typename T37>
4179 struct Types37 {
4180  typedef T1 Head;
4181  typedef Types36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4182  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4183  T30, T31, T32, T33, T34, T35, T36, T37> Tail;
4184 };
4185 
4186 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4187  typename T6, typename T7, typename T8, typename T9, typename T10,
4188  typename T11, typename T12, typename T13, typename T14, typename T15,
4189  typename T16, typename T17, typename T18, typename T19, typename T20,
4190  typename T21, typename T22, typename T23, typename T24, typename T25,
4191  typename T26, typename T27, typename T28, typename T29, typename T30,
4192  typename T31, typename T32, typename T33, typename T34, typename T35,
4193  typename T36, typename T37, typename T38>
4194 struct Types38 {
4195  typedef T1 Head;
4196  typedef Types37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4197  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4198  T30, T31, T32, T33, T34, T35, T36, T37, T38> Tail;
4199 };
4200 
4201 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4202  typename T6, typename T7, typename T8, typename T9, typename T10,
4203  typename T11, typename T12, typename T13, typename T14, typename T15,
4204  typename T16, typename T17, typename T18, typename T19, typename T20,
4205  typename T21, typename T22, typename T23, typename T24, typename T25,
4206  typename T26, typename T27, typename T28, typename T29, typename T30,
4207  typename T31, typename T32, typename T33, typename T34, typename T35,
4208  typename T36, typename T37, typename T38, typename T39>
4209 struct Types39 {
4210  typedef T1 Head;
4211  typedef Types38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4212  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4213  T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Tail;
4214 };
4215 
4216 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4217  typename T6, typename T7, typename T8, typename T9, typename T10,
4218  typename T11, typename T12, typename T13, typename T14, typename T15,
4219  typename T16, typename T17, typename T18, typename T19, typename T20,
4220  typename T21, typename T22, typename T23, typename T24, typename T25,
4221  typename T26, typename T27, typename T28, typename T29, typename T30,
4222  typename T31, typename T32, typename T33, typename T34, typename T35,
4223  typename T36, typename T37, typename T38, typename T39, typename T40>
4224 struct Types40 {
4225  typedef T1 Head;
4226  typedef Types39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4227  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4228  T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Tail;
4229 };
4230 
4231 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4232  typename T6, typename T7, typename T8, typename T9, typename T10,
4233  typename T11, typename T12, typename T13, typename T14, typename T15,
4234  typename T16, typename T17, typename T18, typename T19, typename T20,
4235  typename T21, typename T22, typename T23, typename T24, typename T25,
4236  typename T26, typename T27, typename T28, typename T29, typename T30,
4237  typename T31, typename T32, typename T33, typename T34, typename T35,
4238  typename T36, typename T37, typename T38, typename T39, typename T40,
4239  typename T41>
4240 struct Types41 {
4241  typedef T1 Head;
4242  typedef Types40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4243  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4244  T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41> Tail;
4245 };
4246 
4247 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4248  typename T6, typename T7, typename T8, typename T9, typename T10,
4249  typename T11, typename T12, typename T13, typename T14, typename T15,
4250  typename T16, typename T17, typename T18, typename T19, typename T20,
4251  typename T21, typename T22, typename T23, typename T24, typename T25,
4252  typename T26, typename T27, typename T28, typename T29, typename T30,
4253  typename T31, typename T32, typename T33, typename T34, typename T35,
4254  typename T36, typename T37, typename T38, typename T39, typename T40,
4255  typename T41, typename T42>
4256 struct Types42 {
4257  typedef T1 Head;
4258  typedef Types41<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4259  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4260  T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42> Tail;
4261 };
4262 
4263 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4264  typename T6, typename T7, typename T8, typename T9, typename T10,
4265  typename T11, typename T12, typename T13, typename T14, typename T15,
4266  typename T16, typename T17, typename T18, typename T19, typename T20,
4267  typename T21, typename T22, typename T23, typename T24, typename T25,
4268  typename T26, typename T27, typename T28, typename T29, typename T30,
4269  typename T31, typename T32, typename T33, typename T34, typename T35,
4270  typename T36, typename T37, typename T38, typename T39, typename T40,
4271  typename T41, typename T42, typename T43>
4272 struct Types43 {
4273  typedef T1 Head;
4274  typedef Types42<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4275  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4276  T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
4277  T43> Tail;
4278 };
4279 
4280 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4281  typename T6, typename T7, typename T8, typename T9, typename T10,
4282  typename T11, typename T12, typename T13, typename T14, typename T15,
4283  typename T16, typename T17, typename T18, typename T19, typename T20,
4284  typename T21, typename T22, typename T23, typename T24, typename T25,
4285  typename T26, typename T27, typename T28, typename T29, typename T30,
4286  typename T31, typename T32, typename T33, typename T34, typename T35,
4287  typename T36, typename T37, typename T38, typename T39, typename T40,
4288  typename T41, typename T42, typename T43, typename T44>
4289 struct Types44 {
4290  typedef T1 Head;
4291  typedef Types43<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4292  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4293  T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
4294  T44> Tail;
4295 };
4296 
4297 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4298  typename T6, typename T7, typename T8, typename T9, typename T10,
4299  typename T11, typename T12, typename T13, typename T14, typename T15,
4300  typename T16, typename T17, typename T18, typename T19, typename T20,
4301  typename T21, typename T22, typename T23, typename T24, typename T25,
4302  typename T26, typename T27, typename T28, typename T29, typename T30,
4303  typename T31, typename T32, typename T33, typename T34, typename T35,
4304  typename T36, typename T37, typename T38, typename T39, typename T40,
4305  typename T41, typename T42, typename T43, typename T44, typename T45>
4306 struct Types45 {
4307  typedef T1 Head;
4308  typedef Types44<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4309  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4310  T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
4311  T44, T45> Tail;
4312 };
4313 
4314 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4315  typename T6, typename T7, typename T8, typename T9, typename T10,
4316  typename T11, typename T12, typename T13, typename T14, typename T15,
4317  typename T16, typename T17, typename T18, typename T19, typename T20,
4318  typename T21, typename T22, typename T23, typename T24, typename T25,
4319  typename T26, typename T27, typename T28, typename T29, typename T30,
4320  typename T31, typename T32, typename T33, typename T34, typename T35,
4321  typename T36, typename T37, typename T38, typename T39, typename T40,
4322  typename T41, typename T42, typename T43, typename T44, typename T45,
4323  typename T46>
4324 struct Types46 {
4325  typedef T1 Head;
4326  typedef Types45<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4327  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4328  T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
4329  T44, T45, T46> Tail;
4330 };
4331 
4332 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4333  typename T6, typename T7, typename T8, typename T9, typename T10,
4334  typename T11, typename T12, typename T13, typename T14, typename T15,
4335  typename T16, typename T17, typename T18, typename T19, typename T20,
4336  typename T21, typename T22, typename T23, typename T24, typename T25,
4337  typename T26, typename T27, typename T28, typename T29, typename T30,
4338  typename T31, typename T32, typename T33, typename T34, typename T35,
4339  typename T36, typename T37, typename T38, typename T39, typename T40,
4340  typename T41, typename T42, typename T43, typename T44, typename T45,
4341  typename T46, typename T47>
4342 struct Types47 {
4343  typedef T1 Head;
4344  typedef Types46<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4345  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4346  T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
4347  T44, T45, T46, T47> Tail;
4348 };
4349 
4350 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4351  typename T6, typename T7, typename T8, typename T9, typename T10,
4352  typename T11, typename T12, typename T13, typename T14, typename T15,
4353  typename T16, typename T17, typename T18, typename T19, typename T20,
4354  typename T21, typename T22, typename T23, typename T24, typename T25,
4355  typename T26, typename T27, typename T28, typename T29, typename T30,
4356  typename T31, typename T32, typename T33, typename T34, typename T35,
4357  typename T36, typename T37, typename T38, typename T39, typename T40,
4358  typename T41, typename T42, typename T43, typename T44, typename T45,
4359  typename T46, typename T47, typename T48>
4360 struct Types48 {
4361  typedef T1 Head;
4362  typedef Types47<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4363  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4364  T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
4365  T44, T45, T46, T47, T48> Tail;
4366 };
4367 
4368 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4369  typename T6, typename T7, typename T8, typename T9, typename T10,
4370  typename T11, typename T12, typename T13, typename T14, typename T15,
4371  typename T16, typename T17, typename T18, typename T19, typename T20,
4372  typename T21, typename T22, typename T23, typename T24, typename T25,
4373  typename T26, typename T27, typename T28, typename T29, typename T30,
4374  typename T31, typename T32, typename T33, typename T34, typename T35,
4375  typename T36, typename T37, typename T38, typename T39, typename T40,
4376  typename T41, typename T42, typename T43, typename T44, typename T45,
4377  typename T46, typename T47, typename T48, typename T49>
4378 struct Types49 {
4379  typedef T1 Head;
4380  typedef Types48<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4381  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4382  T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
4383  T44, T45, T46, T47, T48, T49> Tail;
4384 };
4385 
4386 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4387  typename T6, typename T7, typename T8, typename T9, typename T10,
4388  typename T11, typename T12, typename T13, typename T14, typename T15,
4389  typename T16, typename T17, typename T18, typename T19, typename T20,
4390  typename T21, typename T22, typename T23, typename T24, typename T25,
4391  typename T26, typename T27, typename T28, typename T29, typename T30,
4392  typename T31, typename T32, typename T33, typename T34, typename T35,
4393  typename T36, typename T37, typename T38, typename T39, typename T40,
4394  typename T41, typename T42, typename T43, typename T44, typename T45,
4395  typename T46, typename T47, typename T48, typename T49, typename T50>
4396 struct Types50 {
4397  typedef T1 Head;
4398  typedef Types49<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4399  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4400  T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
4401  T44, T45, T46, T47, T48, T49, T50> Tail;
4402 };
4403 
4404 
4405 } // namespace internal
4406 
4407 // We don't want to require the users to write TypesN<...> directly,
4408 // as that would require them to count the length. Types<...> is much
4409 // easier to write, but generates horrible messages when there is a
4410 // compiler error, as gcc insists on printing out each template
4411 // argument, even if it has the default value (this means Types<int>
4412 // will appear as Types<int, None, None, ..., None> in the compiler
4413 // errors).
4414 //
4415 // Our solution is to combine the best part of the two approaches: a
4416 // user would write Types<T1, ..., TN>, and Google Test will translate
4417 // that to TypesN<T1, ..., TN> internally to make error messages
4418 // readable. The translation is done by the 'type' member of the
4419 // Types template.
4420 template <typename T1 = internal::None, typename T2 = internal::None,
4421  typename T3 = internal::None, typename T4 = internal::None,
4422  typename T5 = internal::None, typename T6 = internal::None,
4423  typename T7 = internal::None, typename T8 = internal::None,
4424  typename T9 = internal::None, typename T10 = internal::None,
4425  typename T11 = internal::None, typename T12 = internal::None,
4426  typename T13 = internal::None, typename T14 = internal::None,
4427  typename T15 = internal::None, typename T16 = internal::None,
4428  typename T17 = internal::None, typename T18 = internal::None,
4429  typename T19 = internal::None, typename T20 = internal::None,
4430  typename T21 = internal::None, typename T22 = internal::None,
4431  typename T23 = internal::None, typename T24 = internal::None,
4432  typename T25 = internal::None, typename T26 = internal::None,
4433  typename T27 = internal::None, typename T28 = internal::None,
4434  typename T29 = internal::None, typename T30 = internal::None,
4435  typename T31 = internal::None, typename T32 = internal::None,
4436  typename T33 = internal::None, typename T34 = internal::None,
4437  typename T35 = internal::None, typename T36 = internal::None,
4438  typename T37 = internal::None, typename T38 = internal::None,
4439  typename T39 = internal::None, typename T40 = internal::None,
4440  typename T41 = internal::None, typename T42 = internal::None,
4441  typename T43 = internal::None, typename T44 = internal::None,
4442  typename T45 = internal::None, typename T46 = internal::None,
4443  typename T47 = internal::None, typename T48 = internal::None,
4444  typename T49 = internal::None, typename T50 = internal::None>
4445 struct Types {
4446  typedef internal::Types50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4447  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
4448  T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
4449  T41, T42, T43, T44, T45, T46, T47, T48, T49, T50> type;
4450 };
4451 
4452 template <>
4453 struct Types<internal::None, internal::None, internal::None, internal::None,
4454  internal::None, internal::None, internal::None, internal::None,
4455  internal::None, internal::None, internal::None, internal::None,
4456  internal::None, internal::None, internal::None, internal::None,
4457  internal::None, internal::None, internal::None, internal::None,
4458  internal::None, internal::None, internal::None, internal::None,
4459  internal::None, internal::None, internal::None, internal::None,
4460  internal::None, internal::None, internal::None, internal::None,
4461  internal::None, internal::None, internal::None, internal::None,
4462  internal::None, internal::None, internal::None, internal::None,
4463  internal::None, internal::None, internal::None, internal::None,
4464  internal::None, internal::None, internal::None, internal::None,
4465  internal::None, internal::None> {
4466  typedef internal::Types0 type;
4467 };
4468 template <typename T1>
4469 struct Types<T1, internal::None, internal::None, internal::None,
4470  internal::None, internal::None, internal::None, internal::None,
4471  internal::None, internal::None, internal::None, internal::None,
4472  internal::None, internal::None, internal::None, internal::None,
4473  internal::None, internal::None, internal::None, internal::None,
4474  internal::None, internal::None, internal::None, internal::None,
4475  internal::None, internal::None, internal::None, internal::None,
4476  internal::None, internal::None, internal::None, internal::None,
4477  internal::None, internal::None, internal::None, internal::None,
4478  internal::None, internal::None, internal::None, internal::None,
4479  internal::None, internal::None, internal::None, internal::None,
4480  internal::None, internal::None, internal::None, internal::None,
4481  internal::None, internal::None> {
4482  typedef internal::Types1<T1> type;
4483 };
4484 template <typename T1, typename T2>
4485 struct Types<T1, T2, internal::None, internal::None, internal::None,
4486  internal::None, internal::None, internal::None, internal::None,
4487  internal::None, internal::None, internal::None, internal::None,
4488  internal::None, internal::None, internal::None, internal::None,
4489  internal::None, internal::None, internal::None, internal::None,
4490  internal::None, internal::None, internal::None, internal::None,
4491  internal::None, internal::None, internal::None, internal::None,
4492  internal::None, internal::None, internal::None, internal::None,
4493  internal::None, internal::None, internal::None, internal::None,
4494  internal::None, internal::None, internal::None, internal::None,
4495  internal::None, internal::None, internal::None, internal::None,
4496  internal::None, internal::None, internal::None, internal::None,
4497  internal::None> {
4498  typedef internal::Types2<T1, T2> type;
4499 };
4500 template <typename T1, typename T2, typename T3>
4501 struct Types<T1, T2, T3, internal::None, internal::None, internal::None,
4502  internal::None, internal::None, internal::None, internal::None,
4503  internal::None, internal::None, internal::None, internal::None,
4504  internal::None, internal::None, internal::None, internal::None,
4505  internal::None, internal::None, internal::None, internal::None,
4506  internal::None, internal::None, internal::None, internal::None,
4507  internal::None, internal::None, internal::None, internal::None,
4508  internal::None, internal::None, internal::None, internal::None,
4509  internal::None, internal::None, internal::None, internal::None,
4510  internal::None, internal::None, internal::None, internal::None,
4511  internal::None, internal::None, internal::None, internal::None,
4512  internal::None, internal::None, internal::None, internal::None> {
4513  typedef internal::Types3<T1, T2, T3> type;
4514 };
4515 template <typename T1, typename T2, typename T3, typename T4>
4516 struct Types<T1, T2, T3, T4, internal::None, internal::None, internal::None,
4517  internal::None, internal::None, internal::None, internal::None,
4518  internal::None, internal::None, internal::None, internal::None,
4519  internal::None, internal::None, internal::None, internal::None,
4520  internal::None, internal::None, internal::None, internal::None,
4521  internal::None, internal::None, internal::None, internal::None,
4522  internal::None, internal::None, internal::None, internal::None,
4523  internal::None, internal::None, internal::None, internal::None,
4524  internal::None, internal::None, internal::None, internal::None,
4525  internal::None, internal::None, internal::None, internal::None,
4526  internal::None, internal::None, internal::None, internal::None,
4527  internal::None, internal::None, internal::None> {
4528  typedef internal::Types4<T1, T2, T3, T4> type;
4529 };
4530 template <typename T1, typename T2, typename T3, typename T4, typename T5>
4531 struct Types<T1, T2, T3, T4, T5, internal::None, internal::None,
4532  internal::None, internal::None, internal::None, internal::None,
4533  internal::None, internal::None, internal::None, internal::None,
4534  internal::None, internal::None, internal::None, internal::None,
4535  internal::None, internal::None, internal::None, internal::None,
4536  internal::None, internal::None, internal::None, internal::None,
4537  internal::None, internal::None, internal::None, internal::None,
4538  internal::None, internal::None, internal::None, internal::None,
4539  internal::None, internal::None, internal::None, internal::None,
4540  internal::None, internal::None, internal::None, internal::None,
4541  internal::None, internal::None, internal::None, internal::None,
4542  internal::None, internal::None, internal::None> {
4543  typedef internal::Types5<T1, T2, T3, T4, T5> type;
4544 };
4545 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4546  typename T6>
4547 struct Types<T1, T2, T3, T4, T5, T6, internal::None, internal::None,
4548  internal::None, internal::None, internal::None, internal::None,
4549  internal::None, internal::None, internal::None, internal::None,
4550  internal::None, internal::None, internal::None, internal::None,
4551  internal::None, internal::None, internal::None, internal::None,
4552  internal::None, internal::None, internal::None, internal::None,
4553  internal::None, internal::None, internal::None, internal::None,
4554  internal::None, internal::None, internal::None, internal::None,
4555  internal::None, internal::None, internal::None, internal::None,
4556  internal::None, internal::None, internal::None, internal::None,
4557  internal::None, internal::None, internal::None, internal::None,
4558  internal::None, internal::None> {
4559  typedef internal::Types6<T1, T2, T3, T4, T5, T6> type;
4560 };
4561 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4562  typename T6, typename T7>
4563 struct Types<T1, T2, T3, T4, T5, T6, T7, internal::None, internal::None,
4564  internal::None, internal::None, internal::None, internal::None,
4565  internal::None, internal::None, internal::None, internal::None,
4566  internal::None, internal::None, internal::None, internal::None,
4567  internal::None, internal::None, internal::None, internal::None,
4568  internal::None, internal::None, internal::None, internal::None,
4569  internal::None, internal::None, internal::None, internal::None,
4570  internal::None, internal::None, internal::None, internal::None,
4571  internal::None, internal::None, internal::None, internal::None,
4572  internal::None, internal::None, internal::None, internal::None,
4573  internal::None, internal::None, internal::None, internal::None,
4574  internal::None> {
4575  typedef internal::Types7<T1, T2, T3, T4, T5, T6, T7> type;
4576 };
4577 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4578  typename T6, typename T7, typename T8>
4579 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, internal::None, internal::None,
4580  internal::None, internal::None, internal::None, internal::None,
4581  internal::None, internal::None, internal::None, internal::None,
4582  internal::None, internal::None, internal::None, internal::None,
4583  internal::None, internal::None, internal::None, internal::None,
4584  internal::None, internal::None, internal::None, internal::None,
4585  internal::None, internal::None, internal::None, internal::None,
4586  internal::None, internal::None, internal::None, internal::None,
4587  internal::None, internal::None, internal::None, internal::None,
4588  internal::None, internal::None, internal::None, internal::None,
4589  internal::None, internal::None, internal::None, internal::None> {
4590  typedef internal::Types8<T1, T2, T3, T4, T5, T6, T7, T8> type;
4591 };
4592 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4593  typename T6, typename T7, typename T8, typename T9>
4594 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, internal::None,
4595  internal::None, internal::None, internal::None, internal::None,
4596  internal::None, internal::None, internal::None, internal::None,
4597  internal::None, internal::None, internal::None, internal::None,
4598  internal::None, internal::None, internal::None, internal::None,
4599  internal::None, internal::None, internal::None, internal::None,
4600  internal::None, internal::None, internal::None, internal::None,
4601  internal::None, internal::None, internal::None, internal::None,
4602  internal::None, internal::None, internal::None, internal::None,
4603  internal::None, internal::None, internal::None, internal::None,
4604  internal::None, internal::None, internal::None, internal::None> {
4605  typedef internal::Types9<T1, T2, T3, T4, T5, T6, T7, T8, T9> type;
4606 };
4607 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4608  typename T6, typename T7, typename T8, typename T9, typename T10>
4609 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, internal::None,
4610  internal::None, internal::None, internal::None, internal::None,
4611  internal::None, internal::None, internal::None, internal::None,
4612  internal::None, internal::None, internal::None, internal::None,
4613  internal::None, internal::None, internal::None, internal::None,
4614  internal::None, internal::None, internal::None, internal::None,
4615  internal::None, internal::None, internal::None, internal::None,
4616  internal::None, internal::None, internal::None, internal::None,
4617  internal::None, internal::None, internal::None, internal::None,
4618  internal::None, internal::None, internal::None, internal::None,
4619  internal::None, internal::None, internal::None> {
4620  typedef internal::Types10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> type;
4621 };
4622 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4623  typename T6, typename T7, typename T8, typename T9, typename T10,
4624  typename T11>
4625 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, internal::None,
4626  internal::None, internal::None, internal::None, internal::None,
4627  internal::None, internal::None, internal::None, internal::None,
4628  internal::None, internal::None, internal::None, internal::None,
4629  internal::None, internal::None, internal::None, internal::None,
4630  internal::None, internal::None, internal::None, internal::None,
4631  internal::None, internal::None, internal::None, internal::None,
4632  internal::None, internal::None, internal::None, internal::None,
4633  internal::None, internal::None, internal::None, internal::None,
4634  internal::None, internal::None, internal::None, internal::None,
4635  internal::None, internal::None> {
4636  typedef internal::Types11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> type;
4637 };
4638 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4639  typename T6, typename T7, typename T8, typename T9, typename T10,
4640  typename T11, typename T12>
4641 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, internal::None,
4642  internal::None, internal::None, internal::None, internal::None,
4643  internal::None, internal::None, internal::None, internal::None,
4644  internal::None, internal::None, internal::None, internal::None,
4645  internal::None, internal::None, internal::None, internal::None,
4646  internal::None, internal::None, internal::None, internal::None,
4647  internal::None, internal::None, internal::None, internal::None,
4648  internal::None, internal::None, internal::None, internal::None,
4649  internal::None, internal::None, internal::None, internal::None,
4650  internal::None, internal::None, internal::None, internal::None,
4651  internal::None> {
4652  typedef internal::Types12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
4653  T12> type;
4654 };
4655 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4656  typename T6, typename T7, typename T8, typename T9, typename T10,
4657  typename T11, typename T12, typename T13>
4658 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
4659  internal::None, internal::None, internal::None, internal::None,
4660  internal::None, internal::None, internal::None, internal::None,
4661  internal::None, internal::None, internal::None, internal::None,
4662  internal::None, internal::None, internal::None, internal::None,
4663  internal::None, internal::None, internal::None, internal::None,
4664  internal::None, internal::None, internal::None, internal::None,
4665  internal::None, internal::None, internal::None, internal::None,
4666  internal::None, internal::None, internal::None, internal::None,
4667  internal::None, internal::None, internal::None, internal::None,
4668  internal::None> {
4669  typedef internal::Types13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4670  T13> type;
4671 };
4672 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4673  typename T6, typename T7, typename T8, typename T9, typename T10,
4674  typename T11, typename T12, typename T13, typename T14>
4675 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
4676  internal::None, internal::None, internal::None, internal::None,
4677  internal::None, internal::None, internal::None, internal::None,
4678  internal::None, internal::None, internal::None, internal::None,
4679  internal::None, internal::None, internal::None, internal::None,
4680  internal::None, internal::None, internal::None, internal::None,
4681  internal::None, internal::None, internal::None, internal::None,
4682  internal::None, internal::None, internal::None, internal::None,
4683  internal::None, internal::None, internal::None, internal::None,
4684  internal::None, internal::None, internal::None, internal::None> {
4685  typedef internal::Types14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4686  T13, T14> type;
4687 };
4688 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4689  typename T6, typename T7, typename T8, typename T9, typename T10,
4690  typename T11, typename T12, typename T13, typename T14, typename T15>
4691 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4692  internal::None, internal::None, internal::None, internal::None,
4693  internal::None, internal::None, internal::None, internal::None,
4694  internal::None, internal::None, internal::None, internal::None,
4695  internal::None, internal::None, internal::None, internal::None,
4696  internal::None, internal::None, internal::None, internal::None,
4697  internal::None, internal::None, internal::None, internal::None,
4698  internal::None, internal::None, internal::None, internal::None,
4699  internal::None, internal::None, internal::None, internal::None,
4700  internal::None, internal::None, internal::None> {
4701  typedef internal::Types15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4702  T13, T14, T15> type;
4703 };
4704 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4705  typename T6, typename T7, typename T8, typename T9, typename T10,
4706  typename T11, typename T12, typename T13, typename T14, typename T15,
4707  typename T16>
4708 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4709  T16, internal::None, internal::None, internal::None, internal::None,
4710  internal::None, internal::None, internal::None, internal::None,
4711  internal::None, internal::None, internal::None, internal::None,
4712  internal::None, internal::None, internal::None, internal::None,
4713  internal::None, internal::None, internal::None, internal::None,
4714  internal::None, internal::None, internal::None, internal::None,
4715  internal::None, internal::None, internal::None, internal::None,
4716  internal::None, internal::None, internal::None, internal::None,
4717  internal::None, internal::None> {
4718  typedef internal::Types16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4719  T13, T14, T15, T16> type;
4720 };
4721 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4722  typename T6, typename T7, typename T8, typename T9, typename T10,
4723  typename T11, typename T12, typename T13, typename T14, typename T15,
4724  typename T16, typename T17>
4725 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4726  T16, T17, internal::None, internal::None, internal::None, internal::None,
4727  internal::None, internal::None, internal::None, internal::None,
4728  internal::None, internal::None, internal::None, internal::None,
4729  internal::None, internal::None, internal::None, internal::None,
4730  internal::None, internal::None, internal::None, internal::None,
4731  internal::None, internal::None, internal::None, internal::None,
4732  internal::None, internal::None, internal::None, internal::None,
4733  internal::None, internal::None, internal::None, internal::None,
4734  internal::None> {
4735  typedef internal::Types17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4736  T13, T14, T15, T16, T17> type;
4737 };
4738 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4739  typename T6, typename T7, typename T8, typename T9, typename T10,
4740  typename T11, typename T12, typename T13, typename T14, typename T15,
4741  typename T16, typename T17, typename T18>
4742 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4743  T16, T17, T18, internal::None, internal::None, internal::None,
4744  internal::None, internal::None, internal::None, internal::None,
4745  internal::None, internal::None, internal::None, internal::None,
4746  internal::None, internal::None, internal::None, internal::None,
4747  internal::None, internal::None, internal::None, internal::None,
4748  internal::None, internal::None, internal::None, internal::None,
4749  internal::None, internal::None, internal::None, internal::None,
4750  internal::None, internal::None, internal::None, internal::None,
4751  internal::None> {
4752  typedef internal::Types18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4753  T13, T14, T15, T16, T17, T18> type;
4754 };
4755 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4756  typename T6, typename T7, typename T8, typename T9, typename T10,
4757  typename T11, typename T12, typename T13, typename T14, typename T15,
4758  typename T16, typename T17, typename T18, typename T19>
4759 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4760  T16, T17, T18, T19, internal::None, internal::None, internal::None,
4761  internal::None, internal::None, internal::None, internal::None,
4762  internal::None, internal::None, internal::None, internal::None,
4763  internal::None, internal::None, internal::None, internal::None,
4764  internal::None, internal::None, internal::None, internal::None,
4765  internal::None, internal::None, internal::None, internal::None,
4766  internal::None, internal::None, internal::None, internal::None,
4767  internal::None, internal::None, internal::None, internal::None> {
4768  typedef internal::Types19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4769  T13, T14, T15, T16, T17, T18, T19> type;
4770 };
4771 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4772  typename T6, typename T7, typename T8, typename T9, typename T10,
4773  typename T11, typename T12, typename T13, typename T14, typename T15,
4774  typename T16, typename T17, typename T18, typename T19, typename T20>
4775 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4776  T16, T17, T18, T19, T20, internal::None, internal::None, internal::None,
4777  internal::None, internal::None, internal::None, internal::None,
4778  internal::None, internal::None, internal::None, internal::None,
4779  internal::None, internal::None, internal::None, internal::None,
4780  internal::None, internal::None, internal::None, internal::None,
4781  internal::None, internal::None, internal::None, internal::None,
4782  internal::None, internal::None, internal::None, internal::None,
4783  internal::None, internal::None, internal::None> {
4784  typedef internal::Types20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4785  T13, T14, T15, T16, T17, T18, T19, T20> type;
4786 };
4787 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4788  typename T6, typename T7, typename T8, typename T9, typename T10,
4789  typename T11, typename T12, typename T13, typename T14, typename T15,
4790  typename T16, typename T17, typename T18, typename T19, typename T20,
4791  typename T21>
4792 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4793  T16, T17, T18, T19, T20, T21, internal::None, internal::None,
4794  internal::None, internal::None, internal::None, internal::None,
4795  internal::None, internal::None, internal::None, internal::None,
4796  internal::None, internal::None, internal::None, internal::None,
4797  internal::None, internal::None, internal::None, internal::None,
4798  internal::None, internal::None, internal::None, internal::None,
4799  internal::None, internal::None, internal::None, internal::None,
4800  internal::None, internal::None, internal::None> {
4801  typedef internal::Types21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4802  T13, T14, T15, T16, T17, T18, T19, T20, T21> type;
4803 };
4804 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4805  typename T6, typename T7, typename T8, typename T9, typename T10,
4806  typename T11, typename T12, typename T13, typename T14, typename T15,
4807  typename T16, typename T17, typename T18, typename T19, typename T20,
4808  typename T21, typename T22>
4809 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4810  T16, T17, T18, T19, T20, T21, T22, internal::None, internal::None,
4811  internal::None, internal::None, internal::None, internal::None,
4812  internal::None, internal::None, internal::None, internal::None,
4813  internal::None, internal::None, internal::None, internal::None,
4814  internal::None, internal::None, internal::None, internal::None,
4815  internal::None, internal::None, internal::None, internal::None,
4816  internal::None, internal::None, internal::None, internal::None,
4817  internal::None, internal::None> {
4818  typedef internal::Types22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4819  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> type;
4820 };
4821 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4822  typename T6, typename T7, typename T8, typename T9, typename T10,
4823  typename T11, typename T12, typename T13, typename T14, typename T15,
4824  typename T16, typename T17, typename T18, typename T19, typename T20,
4825  typename T21, typename T22, typename T23>
4826 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4827  T16, T17, T18, T19, T20, T21, T22, T23, internal::None, internal::None,
4828  internal::None, internal::None, internal::None, internal::None,
4829  internal::None, internal::None, internal::None, internal::None,
4830  internal::None, internal::None, internal::None, internal::None,
4831  internal::None, internal::None, internal::None, internal::None,
4832  internal::None, internal::None, internal::None, internal::None,
4833  internal::None, internal::None, internal::None, internal::None,
4834  internal::None> {
4835  typedef internal::Types23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4836  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> type;
4837 };
4838 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4839  typename T6, typename T7, typename T8, typename T9, typename T10,
4840  typename T11, typename T12, typename T13, typename T14, typename T15,
4841  typename T16, typename T17, typename T18, typename T19, typename T20,
4842  typename T21, typename T22, typename T23, typename T24>
4843 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4844  T16, T17, T18, T19, T20, T21, T22, T23, T24, internal::None,
4845  internal::None, internal::None, internal::None, internal::None,
4846  internal::None, internal::None, internal::None, internal::None,
4847  internal::None, internal::None, internal::None, internal::None,
4848  internal::None, internal::None, internal::None, internal::None,
4849  internal::None, internal::None, internal::None, internal::None,
4850  internal::None, internal::None, internal::None, internal::None,
4851  internal::None> {
4852  typedef internal::Types24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4853  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> type;
4854 };
4855 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4856  typename T6, typename T7, typename T8, typename T9, typename T10,
4857  typename T11, typename T12, typename T13, typename T14, typename T15,
4858  typename T16, typename T17, typename T18, typename T19, typename T20,
4859  typename T21, typename T22, typename T23, typename T24, typename T25>
4860 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4861  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, internal::None,
4862  internal::None, internal::None, internal::None, internal::None,
4863  internal::None, internal::None, internal::None, internal::None,
4864  internal::None, internal::None, internal::None, internal::None,
4865  internal::None, internal::None, internal::None, internal::None,
4866  internal::None, internal::None, internal::None, internal::None,
4867  internal::None, internal::None, internal::None, internal::None> {
4868  typedef internal::Types25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4869  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> type;
4870 };
4871 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4872  typename T6, typename T7, typename T8, typename T9, typename T10,
4873  typename T11, typename T12, typename T13, typename T14, typename T15,
4874  typename T16, typename T17, typename T18, typename T19, typename T20,
4875  typename T21, typename T22, typename T23, typename T24, typename T25,
4876  typename T26>
4877 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4878  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, internal::None,
4879  internal::None, internal::None, internal::None, internal::None,
4880  internal::None, internal::None, internal::None, internal::None,
4881  internal::None, internal::None, internal::None, internal::None,
4882  internal::None, internal::None, internal::None, internal::None,
4883  internal::None, internal::None, internal::None, internal::None,
4884  internal::None, internal::None, internal::None> {
4885  typedef internal::Types26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4886  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
4887  T26> type;
4888 };
4889 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4890  typename T6, typename T7, typename T8, typename T9, typename T10,
4891  typename T11, typename T12, typename T13, typename T14, typename T15,
4892  typename T16, typename T17, typename T18, typename T19, typename T20,
4893  typename T21, typename T22, typename T23, typename T24, typename T25,
4894  typename T26, typename T27>
4895 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4896  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, internal::None,
4897  internal::None, internal::None, internal::None, internal::None,
4898  internal::None, internal::None, internal::None, internal::None,
4899  internal::None, internal::None, internal::None, internal::None,
4900  internal::None, internal::None, internal::None, internal::None,
4901  internal::None, internal::None, internal::None, internal::None,
4902  internal::None, internal::None> {
4903  typedef internal::Types27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4904  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
4905  T27> type;
4906 };
4907 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4908  typename T6, typename T7, typename T8, typename T9, typename T10,
4909  typename T11, typename T12, typename T13, typename T14, typename T15,
4910  typename T16, typename T17, typename T18, typename T19, typename T20,
4911  typename T21, typename T22, typename T23, typename T24, typename T25,
4912  typename T26, typename T27, typename T28>
4913 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4914  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
4915  internal::None, internal::None, internal::None, internal::None,
4916  internal::None, internal::None, internal::None, internal::None,
4917  internal::None, internal::None, internal::None, internal::None,
4918  internal::None, internal::None, internal::None, internal::None,
4919  internal::None, internal::None, internal::None, internal::None,
4920  internal::None, internal::None> {
4921  typedef internal::Types28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4922  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
4923  T27, T28> type;
4924 };
4925 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4926  typename T6, typename T7, typename T8, typename T9, typename T10,
4927  typename T11, typename T12, typename T13, typename T14, typename T15,
4928  typename T16, typename T17, typename T18, typename T19, typename T20,
4929  typename T21, typename T22, typename T23, typename T24, typename T25,
4930  typename T26, typename T27, typename T28, typename T29>
4931 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4932  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
4933  internal::None, internal::None, internal::None, internal::None,
4934  internal::None, internal::None, internal::None, internal::None,
4935  internal::None, internal::None, internal::None, internal::None,
4936  internal::None, internal::None, internal::None, internal::None,
4937  internal::None, internal::None, internal::None, internal::None,
4938  internal::None> {
4939  typedef internal::Types29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4940  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
4941  T27, T28, T29> type;
4942 };
4943 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4944  typename T6, typename T7, typename T8, typename T9, typename T10,
4945  typename T11, typename T12, typename T13, typename T14, typename T15,
4946  typename T16, typename T17, typename T18, typename T19, typename T20,
4947  typename T21, typename T22, typename T23, typename T24, typename T25,
4948  typename T26, typename T27, typename T28, typename T29, typename T30>
4949 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4950  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
4951  internal::None, internal::None, internal::None, internal::None,
4952  internal::None, internal::None, internal::None, internal::None,
4953  internal::None, internal::None, internal::None, internal::None,
4954  internal::None, internal::None, internal::None, internal::None,
4955  internal::None, internal::None, internal::None, internal::None> {
4956  typedef internal::Types30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4957  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
4958  T27, T28, T29, T30> type;
4959 };
4960 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4961  typename T6, typename T7, typename T8, typename T9, typename T10,
4962  typename T11, typename T12, typename T13, typename T14, typename T15,
4963  typename T16, typename T17, typename T18, typename T19, typename T20,
4964  typename T21, typename T22, typename T23, typename T24, typename T25,
4965  typename T26, typename T27, typename T28, typename T29, typename T30,
4966  typename T31>
4967 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4968  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
4969  T31, internal::None, internal::None, internal::None, internal::None,
4970  internal::None, internal::None, internal::None, internal::None,
4971  internal::None, internal::None, internal::None, internal::None,
4972  internal::None, internal::None, internal::None, internal::None,
4973  internal::None, internal::None, internal::None> {
4974  typedef internal::Types31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4975  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
4976  T27, T28, T29, T30, T31> type;
4977 };
4978 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4979  typename T6, typename T7, typename T8, typename T9, typename T10,
4980  typename T11, typename T12, typename T13, typename T14, typename T15,
4981  typename T16, typename T17, typename T18, typename T19, typename T20,
4982  typename T21, typename T22, typename T23, typename T24, typename T25,
4983  typename T26, typename T27, typename T28, typename T29, typename T30,
4984  typename T31, typename T32>
4985 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
4986  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
4987  T31, T32, internal::None, internal::None, internal::None, internal::None,
4988  internal::None, internal::None, internal::None, internal::None,
4989  internal::None, internal::None, internal::None, internal::None,
4990  internal::None, internal::None, internal::None, internal::None,
4991  internal::None, internal::None> {
4992  typedef internal::Types32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
4993  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
4994  T27, T28, T29, T30, T31, T32> type;
4995 };
4996 template <typename T1, typename T2, typename T3, typename T4, typename T5,
4997  typename T6, typename T7, typename T8, typename T9, typename T10,
4998  typename T11, typename T12, typename T13, typename T14, typename T15,
4999  typename T16, typename T17, typename T18, typename T19, typename T20,
5000  typename T21, typename T22, typename T23, typename T24, typename T25,
5001  typename T26, typename T27, typename T28, typename T29, typename T30,
5002  typename T31, typename T32, typename T33>
5003 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
5004  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
5005  T31, T32, T33, internal::None, internal::None, internal::None,
5006  internal::None, internal::None, internal::None, internal::None,
5007  internal::None, internal::None, internal::None, internal::None,
5008  internal::None, internal::None, internal::None, internal::None,
5009  internal::None, internal::None> {
5010  typedef internal::Types33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
5011  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
5012  T27, T28, T29, T30, T31, T32, T33> type;
5013 };
5014 template <typename T1, typename T2, typename T3, typename T4, typename T5,
5015  typename T6, typename T7, typename T8, typename T9, typename T10,
5016  typename T11, typename T12, typename T13, typename T14, typename T15,
5017  typename T16, typename T17, typename T18, typename T19, typename T20,
5018  typename T21, typename T22, typename T23, typename T24, typename T25,
5019  typename T26, typename T27, typename T28, typename T29, typename T30,
5020  typename T31, typename T32, typename T33, typename T34>
5021 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
5022  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
5023  T31, T32, T33, T34, internal::None, internal::None, internal::None,
5024  internal::None, internal::None, internal::None, internal::None,
5025  internal::None, internal::None, internal::None, internal::None,
5026  internal::None, internal::None, internal::None, internal::None,
5027  internal::None> {
5028  typedef internal::Types34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
5029  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
5030  T27, T28, T29, T30, T31, T32, T33, T34> type;
5031 };
5032 template <typename T1, typename T2, typename T3, typename T4, typename T5,
5033  typename T6, typename T7, typename T8, typename T9, typename T10,
5034  typename T11, typename T12, typename T13, typename T14, typename T15,
5035  typename T16, typename T17, typename T18, typename T19, typename T20,
5036  typename T21, typename T22, typename T23, typename T24, typename T25,
5037  typename T26, typename T27, typename T28, typename T29, typename T30,
5038  typename T31, typename T32, typename T33, typename T34, typename T35>
5039 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
5040  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
5041  T31, T32, T33, T34, T35, internal::None, internal::None, internal::None,
5042  internal::None, internal::None, internal::None, internal::None,
5043  internal::None, internal::None, internal::None, internal::None,
5044  internal::None, internal::None, internal::None, internal::None> {
5045  typedef internal::Types35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
5046  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
5047  T27, T28, T29, T30, T31, T32, T33, T34, T35> type;
5048 };
5049 template <typename T1, typename T2, typename T3, typename T4, typename T5,
5050  typename T6, typename T7, typename T8, typename T9, typename T10,
5051  typename T11, typename T12, typename T13, typename T14, typename T15,
5052  typename T16, typename T17, typename T18, typename T19, typename T20,
5053  typename T21, typename T22, typename T23, typename T24, typename T25,
5054  typename T26, typename T27, typename T28, typename T29, typename T30,
5055  typename T31, typename T32, typename T33, typename T34, typename T35,
5056  typename T36>
5057 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
5058  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
5059  T31, T32, T33, T34, T35, T36, internal::None, internal::None,
5060  internal::None, internal::None, internal::None, internal::None,
5061  internal::None, internal::None, internal::None, internal::None,
5062  internal::None, internal::None, internal::None, internal::None> {
5063  typedef internal::Types36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
5064  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
5065  T27, T28, T29, T30, T31, T32, T33, T34, T35, T36> type;
5066 };
5067 template <typename T1, typename T2, typename T3, typename T4, typename T5,
5068  typename T6, typename T7, typename T8, typename T9, typename T10,
5069  typename T11, typename T12, typename T13, typename T14, typename T15,
5070  typename T16, typename T17, typename T18, typename T19, typename T20,
5071  typename T21, typename T22, typename T23, typename T24, typename T25,
5072  typename T26, typename T27, typename T28, typename T29, typename T30,
5073  typename T31, typename T32, typename T33, typename T34, typename T35,
5074  typename T36, typename T37>
5075 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
5076  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
5077  T31, T32, T33, T34, T35, T36, T37, internal::None, internal::None,
5078  internal::None, internal::None, internal::None, internal::None,
5079  internal::None, internal::None, internal::None, internal::None,
5080  internal::None, internal::None, internal::None> {
5081  typedef internal::Types37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
5082  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
5083  T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37> type;
5084 };
5085 template <typename T1, typename T2, typename T3, typename T4, typename T5,
5086  typename T6, typename T7, typename T8, typename T9, typename T10,
5087  typename T11, typename T12, typename T13, typename T14, typename T15,
5088  typename T16, typename T17, typename T18, typename T19, typename T20,
5089  typename T21, typename T22, typename T23, typename T24, typename T25,
5090  typename T26, typename T27, typename T28, typename T29, typename T30,
5091  typename T31, typename T32, typename T33, typename T34, typename T35,
5092  typename T36, typename T37, typename T38>
5093 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
5094  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
5095  T31, T32, T33, T34, T35, T36, T37, T38, internal::None, internal::None,
5096  internal::None, internal::None, internal::None, internal::None,
5097  internal::None, internal::None, internal::None, internal::None,
5098  internal::None, internal::None> {
5099  typedef internal::Types38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
5100  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
5101  T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> type;
5102 };
5103 template <typename T1, typename T2, typename T3, typename T4, typename T5,
5104  typename T6, typename T7, typename T8, typename T9, typename T10,
5105  typename T11, typename T12, typename T13, typename T14, typename T15,
5106  typename T16, typename T17, typename T18, typename T19, typename T20,
5107  typename T21, typename T22, typename T23, typename T24, typename T25,
5108  typename T26, typename T27, typename T28, typename T29, typename T30,
5109  typename T31, typename T32, typename T33, typename T34, typename T35,
5110  typename T36, typename T37, typename T38, typename T39>
5111 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
5112  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
5113  T31, T32, T33, T34, T35, T36, T37, T38, T39, internal::None,
5114  internal::None, internal::None, internal::None, internal::None,
5115  internal::None, internal::None, internal::None, internal::None,
5116  internal::None, internal::None> {
5117  typedef internal::Types39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
5118  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
5119  T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> type;
5120 };
5121 template <typename T1, typename T2, typename T3, typename T4, typename T5,
5122  typename T6, typename T7, typename T8, typename T9, typename T10,
5123  typename T11, typename T12, typename T13, typename T14, typename T15,
5124  typename T16, typename T17, typename T18, typename T19, typename T20,
5125  typename T21, typename T22, typename T23, typename T24, typename T25,
5126  typename T26, typename T27, typename T28, typename T29, typename T30,
5127  typename T31, typename T32, typename T33, typename T34, typename T35,
5128  typename T36, typename T37, typename T38, typename T39, typename T40>
5129 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
5130  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
5131  T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, internal::None,
5132  internal::None, internal::None, internal::None, internal::None,
5133  internal::None, internal::None, internal::None, internal::None,
5134  internal::None> {
5135  typedef internal::Types40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
5136  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
5137  T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
5138  T40> type;
5139 };
5140 template <typename T1, typename T2, typename T3, typename T4, typename T5,
5141  typename T6, typename T7, typename T8, typename T9, typename T10,
5142  typename T11, typename T12, typename T13, typename T14, typename T15,
5143  typename T16, typename T17, typename T18, typename T19, typename T20,
5144  typename T21, typename T22, typename T23, typename T24, typename T25,
5145  typename T26, typename T27, typename T28, typename T29, typename T30,
5146  typename T31, typename T32, typename T33, typename T34, typename T35,
5147  typename T36, typename T37, typename T38, typename T39, typename T40,
5148  typename T41>
5149 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
5150  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
5151  T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, internal::None,
5152  internal::None, internal::None, internal::None, internal::None,
5153  internal::None, internal::None, internal::None, internal::None> {
5154  typedef internal::Types41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
5155  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
5156  T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
5157  T41> type;
5158 };
5159 template <typename T1, typename T2, typename T3, typename T4, typename T5,
5160  typename T6, typename T7, typename T8, typename T9, typename T10,
5161  typename T11, typename T12, typename T13, typename T14, typename T15,
5162  typename T16, typename T17, typename T18, typename T19, typename T20,
5163  typename T21, typename T22, typename T23, typename T24, typename T25,
5164  typename T26, typename T27, typename T28, typename T29, typename T30,
5165  typename T31, typename T32, typename T33, typename T34, typename T35,
5166  typename T36, typename T37, typename T38, typename T39, typename T40,
5167  typename T41, typename T42>
5168 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
5169  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
5170  T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, internal::None,
5171  internal::None, internal::None, internal::None, internal::None,
5172  internal::None, internal::None, internal::None> {
5173  typedef internal::Types42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
5174  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
5175  T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
5176  T41, T42> type;
5177 };
5178 template <typename T1, typename T2, typename T3, typename T4, typename T5,
5179  typename T6, typename T7, typename T8, typename T9, typename T10,
5180  typename T11, typename T12, typename T13, typename T14, typename T15,
5181  typename T16, typename T17, typename T18, typename T19, typename T20,
5182  typename T21, typename T22, typename T23, typename T24, typename T25,
5183  typename T26, typename T27, typename T28, typename T29, typename T30,
5184  typename T31, typename T32, typename T33, typename T34, typename T35,
5185  typename T36, typename T37, typename T38, typename T39, typename T40,
5186  typename T41, typename T42, typename T43>
5187 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
5188  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
5189  T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
5190  internal::None, internal::None, internal::None, internal::None,
5191  internal::None, internal::None, internal::None> {
5192  typedef internal::Types43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
5193  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
5194  T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
5195  T41, T42, T43> type;
5196 };
5197 template <typename T1, typename T2, typename T3, typename T4, typename T5,
5198  typename T6, typename T7, typename T8, typename T9, typename T10,
5199  typename T11, typename T12, typename T13, typename T14, typename T15,
5200  typename T16, typename T17, typename T18, typename T19, typename T20,
5201  typename T21, typename T22, typename T23, typename T24, typename T25,
5202  typename T26, typename T27, typename T28, typename T29, typename T30,
5203  typename T31, typename T32, typename T33, typename T34, typename T35,
5204  typename T36, typename T37, typename T38, typename T39, typename T40,
5205  typename T41, typename T42, typename T43, typename T44>
5206 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
5207  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
5208  T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
5209  internal::None, internal::None, internal::None, internal::None,
5210  internal::None, internal::None> {
5211  typedef internal::Types44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
5212  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
5213  T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
5214  T41, T42, T43, T44> type;
5215 };
5216 template <typename T1, typename T2, typename T3, typename T4, typename T5,
5217  typename T6, typename T7, typename T8, typename T9, typename T10,
5218  typename T11, typename T12, typename T13, typename T14, typename T15,
5219  typename T16, typename T17, typename T18, typename T19, typename T20,
5220  typename T21, typename T22, typename T23, typename T24, typename T25,
5221  typename T26, typename T27, typename T28, typename T29, typename T30,
5222  typename T31, typename T32, typename T33, typename T34, typename T35,
5223  typename T36, typename T37, typename T38, typename T39, typename T40,
5224  typename T41, typename T42, typename T43, typename T44, typename T45>
5225 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
5226  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
5227  T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
5228  internal::None, internal::None, internal::None, internal::None,
5229  internal::None> {
5230  typedef internal::Types45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
5231  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
5232  T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
5233  T41, T42, T43, T44, T45> type;
5234 };
5235 template <typename T1, typename T2, typename T3, typename T4, typename T5,
5236  typename T6, typename T7, typename T8, typename T9, typename T10,
5237  typename T11, typename T12, typename T13, typename T14, typename T15,
5238  typename T16, typename T17, typename T18, typename T19, typename T20,
5239  typename T21, typename T22, typename T23, typename T24, typename T25,
5240  typename T26, typename T27, typename T28, typename T29, typename T30,
5241  typename T31, typename T32, typename T33, typename T34, typename T35,
5242  typename T36, typename T37, typename T38, typename T39, typename T40,
5243  typename T41, typename T42, typename T43, typename T44, typename T45,
5244  typename T46>
5245 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
5246  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
5247  T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
5248  T46, internal::None, internal::None, internal::None, internal::None> {
5249  typedef internal::Types46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
5250  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
5251  T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
5252  T41, T42, T43, T44, T45, T46> type;
5253 };
5254 template <typename T1, typename T2, typename T3, typename T4, typename T5,
5255  typename T6, typename T7, typename T8, typename T9, typename T10,
5256  typename T11, typename T12, typename T13, typename T14, typename T15,
5257  typename T16, typename T17, typename T18, typename T19, typename T20,
5258  typename T21, typename T22, typename T23, typename T24, typename T25,
5259  typename T26, typename T27, typename T28, typename T29, typename T30,
5260  typename T31, typename T32, typename T33, typename T34, typename T35,
5261  typename T36, typename T37, typename T38, typename T39, typename T40,
5262  typename T41, typename T42, typename T43, typename T44, typename T45,
5263  typename T46, typename T47>
5264 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
5265  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
5266  T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
5267  T46, T47, internal::None, internal::None, internal::None> {
5268  typedef internal::Types47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
5269  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
5270  T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
5271  T41, T42, T43, T44, T45, T46, T47> type;
5272 };
5273 template <typename T1, typename T2, typename T3, typename T4, typename T5,
5274  typename T6, typename T7, typename T8, typename T9, typename T10,
5275  typename T11, typename T12, typename T13, typename T14, typename T15,
5276  typename T16, typename T17, typename T18, typename T19, typename T20,
5277  typename T21, typename T22, typename T23, typename T24, typename T25,
5278  typename T26, typename T27, typename T28, typename T29, typename T30,
5279  typename T31, typename T32, typename T33, typename T34, typename T35,
5280  typename T36, typename T37, typename T38, typename T39, typename T40,
5281  typename T41, typename T42, typename T43, typename T44, typename T45,
5282  typename T46, typename T47, typename T48>
5283 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
5284  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
5285  T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
5286  T46, T47, T48, internal::None, internal::None> {
5287  typedef internal::Types48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
5288  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
5289  T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
5290  T41, T42, T43, T44, T45, T46, T47, T48> type;
5291 };
5292 template <typename T1, typename T2, typename T3, typename T4, typename T5,
5293  typename T6, typename T7, typename T8, typename T9, typename T10,
5294  typename T11, typename T12, typename T13, typename T14, typename T15,
5295  typename T16, typename T17, typename T18, typename T19, typename T20,
5296  typename T21, typename T22, typename T23, typename T24, typename T25,
5297  typename T26, typename T27, typename T28, typename T29, typename T30,
5298  typename T31, typename T32, typename T33, typename T34, typename T35,
5299  typename T36, typename T37, typename T38, typename T39, typename T40,
5300  typename T41, typename T42, typename T43, typename T44, typename T45,
5301  typename T46, typename T47, typename T48, typename T49>
5302 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
5303  T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
5304  T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
5305  T46, T47, T48, T49, internal::None> {
5306  typedef internal::Types49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
5307  T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
5308  T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
5309  T41, T42, T43, T44, T45, T46, T47, T48, T49> type;
5310 };
5311 
5312 namespace internal {
5313 
5314 # define GTEST_TEMPLATE_ template <typename T> class
5315 
5316 // The template "selector" struct TemplateSel<Tmpl> is used to
5317 // represent Tmpl, which must be a class template with one type
5318 // parameter, as a type. TemplateSel<Tmpl>::Bind<T>::type is defined
5319 // as the type Tmpl<T>. This allows us to actually instantiate the
5320 // template "selected" by TemplateSel<Tmpl>.
5321 //
5322 // This trick is necessary for simulating typedef for class templates,
5323 // which C++ doesn't support directly.
5324 template <GTEST_TEMPLATE_ Tmpl>
5325 struct TemplateSel {
5326  template <typename T>
5327  struct Bind {
5328  typedef Tmpl<T> type;
5329  };
5330 };
5331 
5332 # define GTEST_BIND_(TmplSel, T) \
5333  TmplSel::template Bind<T>::type
5334 
5335 // A unique struct template used as the default value for the
5336 // arguments of class template Templates. This allows us to simulate
5337 // variadic templates (e.g. Templates<int>, Templates<int, double>,
5338 // and etc), which C++ doesn't support directly.
5339 template <typename T>
5340 struct NoneT {};
5341 
5342 // The following family of struct and struct templates are used to
5343 // represent template lists. In particular, TemplatesN<T1, T2, ...,
5344 // TN> represents a list of N templates (T1, T2, ..., and TN). Except
5345 // for Templates0, every struct in the family has two member types:
5346 // Head for the selector of the first template in the list, and Tail
5347 // for the rest of the list.
5348 
5349 // The empty template list.
5350 struct Templates0 {};
5351 
5352 // Template lists of length 1, 2, 3, and so on.
5353 
5354 template <GTEST_TEMPLATE_ T1>
5355 struct Templates1 {
5356  typedef TemplateSel<T1> Head;
5357  typedef Templates0 Tail;
5358 };
5359 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2>
5360 struct Templates2 {
5361  typedef TemplateSel<T1> Head;
5362  typedef Templates1<T2> Tail;
5363 };
5364 
5365 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3>
5366 struct Templates3 {
5367  typedef TemplateSel<T1> Head;
5368  typedef Templates2<T2, T3> Tail;
5369 };
5370 
5371 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5372  GTEST_TEMPLATE_ T4>
5373 struct Templates4 {
5374  typedef TemplateSel<T1> Head;
5375  typedef Templates3<T2, T3, T4> Tail;
5376 };
5377 
5378 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5379  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5>
5380 struct Templates5 {
5381  typedef TemplateSel<T1> Head;
5382  typedef Templates4<T2, T3, T4, T5> Tail;
5383 };
5384 
5385 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5386  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6>
5387 struct Templates6 {
5388  typedef TemplateSel<T1> Head;
5389  typedef Templates5<T2, T3, T4, T5, T6> Tail;
5390 };
5391 
5392 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5393  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5394  GTEST_TEMPLATE_ T7>
5395 struct Templates7 {
5396  typedef TemplateSel<T1> Head;
5397  typedef Templates6<T2, T3, T4, T5, T6, T7> Tail;
5398 };
5399 
5400 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5401  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5402  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8>
5403 struct Templates8 {
5404  typedef TemplateSel<T1> Head;
5405  typedef Templates7<T2, T3, T4, T5, T6, T7, T8> Tail;
5406 };
5407 
5408 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5409  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5410  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9>
5411 struct Templates9 {
5412  typedef TemplateSel<T1> Head;
5413  typedef Templates8<T2, T3, T4, T5, T6, T7, T8, T9> Tail;
5414 };
5415 
5416 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5417  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5418  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5419  GTEST_TEMPLATE_ T10>
5420 struct Templates10 {
5421  typedef TemplateSel<T1> Head;
5422  typedef Templates9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail;
5423 };
5424 
5425 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5426  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5427  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5428  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11>
5429 struct Templates11 {
5430  typedef TemplateSel<T1> Head;
5431  typedef Templates10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail;
5432 };
5433 
5434 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5435  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5436  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5437  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12>
5438 struct Templates12 {
5439  typedef TemplateSel<T1> Head;
5440  typedef Templates11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail;
5441 };
5442 
5443 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5444  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5445  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5446  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5447  GTEST_TEMPLATE_ T13>
5448 struct Templates13 {
5449  typedef TemplateSel<T1> Head;
5450  typedef Templates12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Tail;
5451 };
5452 
5453 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5454  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5455  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5456  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5457  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14>
5458 struct Templates14 {
5459  typedef TemplateSel<T1> Head;
5460  typedef Templates13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
5461  T14> Tail;
5462 };
5463 
5464 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5465  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5466  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5467  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5468  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15>
5469 struct Templates15 {
5470  typedef TemplateSel<T1> Head;
5471  typedef Templates14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5472  T15> Tail;
5473 };
5474 
5475 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5476  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5477  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5478  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5479  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5480  GTEST_TEMPLATE_ T16>
5481 struct Templates16 {
5482  typedef TemplateSel<T1> Head;
5483  typedef Templates15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5484  T15, T16> Tail;
5485 };
5486 
5487 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5488  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5489  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5490  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5491  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5492  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17>
5493 struct Templates17 {
5494  typedef TemplateSel<T1> Head;
5495  typedef Templates16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5496  T15, T16, T17> Tail;
5497 };
5498 
5499 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5500  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5501  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5502  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5503  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5504  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18>
5505 struct Templates18 {
5506  typedef TemplateSel<T1> Head;
5507  typedef Templates17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5508  T15, T16, T17, T18> Tail;
5509 };
5510 
5511 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5512  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5513  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5514  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5515  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5516  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5517  GTEST_TEMPLATE_ T19>
5518 struct Templates19 {
5519  typedef TemplateSel<T1> Head;
5520  typedef Templates18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5521  T15, T16, T17, T18, T19> Tail;
5522 };
5523 
5524 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5525  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5526  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5527  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5528  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5529  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5530  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20>
5531 struct Templates20 {
5532  typedef TemplateSel<T1> Head;
5533  typedef Templates19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5534  T15, T16, T17, T18, T19, T20> Tail;
5535 };
5536 
5537 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5538  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5539  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5540  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5541  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5542  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5543  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21>
5544 struct Templates21 {
5545  typedef TemplateSel<T1> Head;
5546  typedef Templates20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5547  T15, T16, T17, T18, T19, T20, T21> Tail;
5548 };
5549 
5550 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5551  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5552  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5553  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5554  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5555  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5556  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5557  GTEST_TEMPLATE_ T22>
5558 struct Templates22 {
5559  typedef TemplateSel<T1> Head;
5560  typedef Templates21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5561  T15, T16, T17, T18, T19, T20, T21, T22> Tail;
5562 };
5563 
5564 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5565  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5566  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5567  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5568  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5569  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5570  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5571  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23>
5572 struct Templates23 {
5573  typedef TemplateSel<T1> Head;
5574  typedef Templates22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5575  T15, T16, T17, T18, T19, T20, T21, T22, T23> Tail;
5576 };
5577 
5578 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5579  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5580  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5581  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5582  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5583  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5584  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5585  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24>
5586 struct Templates24 {
5587  typedef TemplateSel<T1> Head;
5588  typedef Templates23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5589  T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Tail;
5590 };
5591 
5592 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5593  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5594  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5595  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5596  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5597  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5598  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5599  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
5600  GTEST_TEMPLATE_ T25>
5601 struct Templates25 {
5602  typedef TemplateSel<T1> Head;
5603  typedef Templates24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5604  T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Tail;
5605 };
5606 
5607 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5608  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5609  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5610  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5611  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5612  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5613  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5614  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
5615  GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26>
5616 struct Templates26 {
5617  typedef TemplateSel<T1> Head;
5618  typedef Templates25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5619  T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Tail;
5620 };
5621 
5622 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5623  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5624  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5625  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5626  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5627  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5628  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5629  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
5630  GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27>
5631 struct Templates27 {
5632  typedef TemplateSel<T1> Head;
5633  typedef Templates26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5634  T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> Tail;
5635 };
5636 
5637 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5638  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5639  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5640  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5641  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5642  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5643  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5644  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
5645  GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
5646  GTEST_TEMPLATE_ T28>
5647 struct Templates28 {
5648  typedef TemplateSel<T1> Head;
5649  typedef Templates27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5650  T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
5651  T28> Tail;
5652 };
5653 
5654 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5655  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5656  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5657  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5658  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5659  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5660  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5661  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
5662  GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
5663  GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29>
5664 struct Templates29 {
5665  typedef TemplateSel<T1> Head;
5666  typedef Templates28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5667  T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
5668  T29> Tail;
5669 };
5670 
5671 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5672  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5673  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5674  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5675  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5676  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5677  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5678  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
5679  GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
5680  GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30>
5681 struct Templates30 {
5682  typedef TemplateSel<T1> Head;
5683  typedef Templates29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5684  T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
5685  T29, T30> Tail;
5686 };
5687 
5688 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5689  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5690  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5691  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5692  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5693  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5694  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5695  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
5696  GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
5697  GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
5698  GTEST_TEMPLATE_ T31>
5699 struct Templates31 {
5700  typedef TemplateSel<T1> Head;
5701  typedef Templates30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5702  T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
5703  T29, T30, T31> Tail;
5704 };
5705 
5706 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5707  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5708  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5709  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5710  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5711  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5712  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5713  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
5714  GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
5715  GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
5716  GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32>
5717 struct Templates32 {
5718  typedef TemplateSel<T1> Head;
5719  typedef Templates31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5720  T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
5721  T29, T30, T31, T32> Tail;
5722 };
5723 
5724 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5725  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5726  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5727  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5728  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5729  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5730  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5731  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
5732  GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
5733  GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
5734  GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33>
5735 struct Templates33 {
5736  typedef TemplateSel<T1> Head;
5737  typedef Templates32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5738  T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
5739  T29, T30, T31, T32, T33> Tail;
5740 };
5741 
5742 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5743  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5744  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5745  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5746  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5747  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5748  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5749  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
5750  GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
5751  GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
5752  GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
5753  GTEST_TEMPLATE_ T34>
5754 struct Templates34 {
5755  typedef TemplateSel<T1> Head;
5756  typedef Templates33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5757  T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
5758  T29, T30, T31, T32, T33, T34> Tail;
5759 };
5760 
5761 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5762  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5763  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5764  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5765  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5766  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5767  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5768  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
5769  GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
5770  GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
5771  GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
5772  GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35>
5773 struct Templates35 {
5774  typedef TemplateSel<T1> Head;
5775  typedef Templates34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5776  T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
5777  T29, T30, T31, T32, T33, T34, T35> Tail;
5778 };
5779 
5780 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5781  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5782  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5783  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5784  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5785  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5786  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5787  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
5788  GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
5789  GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
5790  GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
5791  GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36>
5792 struct Templates36 {
5793  typedef TemplateSel<T1> Head;
5794  typedef Templates35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5795  T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
5796  T29, T30, T31, T32, T33, T34, T35, T36> Tail;
5797 };
5798 
5799 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5800  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5801  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5802  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5803  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5804  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5805  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5806  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
5807  GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
5808  GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
5809  GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
5810  GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
5811  GTEST_TEMPLATE_ T37>
5812 struct Templates37 {
5813  typedef TemplateSel<T1> Head;
5814  typedef Templates36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5815  T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
5816  T29, T30, T31, T32, T33, T34, T35, T36, T37> Tail;
5817 };
5818 
5819 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5820  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5821  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5822  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5823  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5824  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5825  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5826  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
5827  GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
5828  GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
5829  GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
5830  GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
5831  GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38>
5832 struct Templates38 {
5833  typedef TemplateSel<T1> Head;
5834  typedef Templates37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5835  T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
5836  T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> Tail;
5837 };
5838 
5839 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5840  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5841  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5842  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5843  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5844  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5845  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5846  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
5847  GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
5848  GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
5849  GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
5850  GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
5851  GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39>
5852 struct Templates39 {
5853  typedef TemplateSel<T1> Head;
5854  typedef Templates38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5855  T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
5856  T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Tail;
5857 };
5858 
5859 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5860  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5861  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5862  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5863  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5864  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5865  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5866  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
5867  GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
5868  GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
5869  GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
5870  GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
5871  GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
5872  GTEST_TEMPLATE_ T40>
5873 struct Templates40 {
5874  typedef TemplateSel<T1> Head;
5875  typedef Templates39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5876  T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
5877  T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Tail;
5878 };
5879 
5880 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
5881  GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
5882  GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
5883  GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
5884  GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
5885  GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
5886  GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
5887  GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
5888  GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
5889  GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
5890  GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
5891  GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
5892  GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
5893  GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41>
5894 struct Templates41 {
5895  typedef TemplateSel<T1> Head;
5896  typedef Templates40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
5897  T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
5898  T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41> Tail;
5899 };
5900 
5901 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,