Qucs-core  0.0.19
gtest.h
Go to the documentation of this file.
00001 // Copyright 2005, Google Inc.
00002 // All rights reserved.
00003 //
00004 // Redistribution and use in source and binary forms, with or without
00005 // modification, are permitted provided that the following conditions are
00006 // met:
00007 //
00008 //     * Redistributions of source code must retain the above copyright
00009 // notice, this list of conditions and the following disclaimer.
00010 //     * Redistributions in binary form must reproduce the above
00011 // copyright notice, this list of conditions and the following disclaimer
00012 // in the documentation and/or other materials provided with the
00013 // distribution.
00014 //     * Neither the name of Google Inc. nor the names of its
00015 // contributors may be used to endorse or promote products derived from
00016 // this software without specific prior written permission.
00017 //
00018 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00019 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00020 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00021 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
00022 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00023 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00024 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00025 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00026 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00027 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00028 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00029 //
00030 // Author: wan@google.com (Zhanyong Wan)
00031 //
00032 // The Google C++ Testing Framework (Google Test)
00033 //
00034 // This header file defines the public API for Google Test.  It should be
00035 // included by any test program that uses Google Test.
00036 //
00037 // IMPORTANT NOTE: Due to limitation of the C++ language, we have to
00038 // leave some internal implementation details in this header file.
00039 // They are clearly marked by comments like this:
00040 //
00041 //   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
00042 //
00043 // Such code is NOT meant to be used by a user directly, and is subject
00044 // to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
00045 // program!
00046 //
00047 // Acknowledgment: Google Test borrowed the idea of automatic test
00048 // registration from Barthelemy Dagenais' (barthelemy@prologique.com)
00049 // easyUnit framework.
00050 
00051 #ifndef GTEST_INCLUDE_GTEST_GTEST_H_
00052 #define GTEST_INCLUDE_GTEST_GTEST_H_
00053 
00054 #include <limits>
00055 #include <ostream>
00056 #include <vector>
00057 
00058 // Copyright 2005, Google Inc.
00059 // All rights reserved.
00060 //
00061 // Redistribution and use in source and binary forms, with or without
00062 // modification, are permitted provided that the following conditions are
00063 // met:
00064 //
00065 //     * Redistributions of source code must retain the above copyright
00066 // notice, this list of conditions and the following disclaimer.
00067 //     * Redistributions in binary form must reproduce the above
00068 // copyright notice, this list of conditions and the following disclaimer
00069 // in the documentation and/or other materials provided with the
00070 // distribution.
00071 //     * Neither the name of Google Inc. nor the names of its
00072 // contributors may be used to endorse or promote products derived from
00073 // this software without specific prior written permission.
00074 //
00075 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00076 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00077 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00078 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
00079 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00080 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00081 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00082 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00083 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00084 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00085 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00086 //
00087 // Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
00088 //
00089 // The Google C++ Testing Framework (Google Test)
00090 //
00091 // This header file declares functions and macros used internally by
00092 // Google Test.  They are subject to change without notice.
00093 
00094 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
00095 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
00096 
00097 // Copyright 2005, Google Inc.
00098 // All rights reserved.
00099 //
00100 // Redistribution and use in source and binary forms, with or without
00101 // modification, are permitted provided that the following conditions are
00102 // met:
00103 //
00104 //     * Redistributions of source code must retain the above copyright
00105 // notice, this list of conditions and the following disclaimer.
00106 //     * Redistributions in binary form must reproduce the above
00107 // copyright notice, this list of conditions and the following disclaimer
00108 // in the documentation and/or other materials provided with the
00109 // distribution.
00110 //     * Neither the name of Google Inc. nor the names of its
00111 // contributors may be used to endorse or promote products derived from
00112 // this software without specific prior written permission.
00113 //
00114 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00115 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00116 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00117 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
00118 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00119 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00120 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00121 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00122 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00123 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00124 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00125 //
00126 // Authors: wan@google.com (Zhanyong Wan)
00127 //
00128 // Low-level types and utilities for porting Google Test to various
00129 // platforms.  They are subject to change without notice.  DO NOT USE
00130 // THEM IN USER CODE.
00131 //
00132 // This file is fundamental to Google Test.  All other Google Test source
00133 // files are expected to #include this.  Therefore, it cannot #include
00134 // any other Google Test header.
00135 
00136 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
00137 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
00138 
00139 // The user can define the following macros in the build script to
00140 // control Google Test's behavior.  If the user doesn't define a macro
00141 // in this list, Google Test will define it.
00142 //
00143 //   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)
00144 //                              is/isn't available.
00145 //   GTEST_HAS_EXCEPTIONS     - Define it to 1/0 to indicate that exceptions
00146 //                              are enabled.
00147 //   GTEST_HAS_GLOBAL_STRING  - Define it to 1/0 to indicate that ::string
00148 //                              is/isn't available (some systems define
00149 //                              ::string, which is different to std::string).
00150 //   GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string
00151 //                              is/isn't available (some systems define
00152 //                              ::wstring, which is different to std::wstring).
00153 //   GTEST_HAS_POSIX_RE       - Define it to 1/0 to indicate that POSIX regular
00154 //                              expressions are/aren't available.
00155 //   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>
00156 //                              is/isn't available.
00157 //   GTEST_HAS_RTTI           - Define it to 1/0 to indicate that RTTI is/isn't
00158 //                              enabled.
00159 //   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that
00160 //                              std::wstring does/doesn't work (Google Test can
00161 //                              be used where std::wstring is unavailable).
00162 //   GTEST_HAS_TR1_TUPLE      - Define it to 1/0 to indicate tr1::tuple
00163 //                              is/isn't available.
00164 //   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the
00165 //                              compiler supports Microsoft's "Structured
00166 //                              Exception Handling".
00167 //   GTEST_HAS_STREAM_REDIRECTION
00168 //                            - Define it to 1/0 to indicate whether the
00169 //                              platform supports I/O stream redirection using
00170 //                              dup() and dup2().
00171 //   GTEST_USE_OWN_TR1_TUPLE  - Define it to 1/0 to indicate whether Google
00172 //                              Test's own tr1 tuple implementation should be
00173 //                              used.  Unused when the user sets
00174 //                              GTEST_HAS_TR1_TUPLE to 0.
00175 //   GTEST_LANG_CXX11         - Define it to 1/0 to indicate that Google Test
00176 //                              is building in C++11/C++98 mode.
00177 //   GTEST_LINKED_AS_SHARED_LIBRARY
00178 //                            - Define to 1 when compiling tests that use
00179 //                              Google Test as a shared library (known as
00180 //                              DLL on Windows).
00181 //   GTEST_CREATE_SHARED_LIBRARY
00182 //                            - Define to 1 when compiling Google Test itself
00183 //                              as a shared library.
00184 
00185 // This header defines the following utilities:
00186 //
00187 // Macros indicating the current platform (defined to 1 if compiled on
00188 // the given platform; otherwise undefined):
00189 //   GTEST_OS_AIX      - IBM AIX
00190 //   GTEST_OS_CYGWIN   - Cygwin
00191 //   GTEST_OS_HPUX     - HP-UX
00192 //   GTEST_OS_LINUX    - Linux
00193 //     GTEST_OS_LINUX_ANDROID - Google Android
00194 //   GTEST_OS_MAC      - Mac OS X
00195 //     GTEST_OS_IOS    - iOS
00196 //       GTEST_OS_IOS_SIMULATOR - iOS simulator
00197 //   GTEST_OS_NACL     - Google Native Client (NaCl)
00198 //   GTEST_OS_OPENBSD  - OpenBSD
00199 //   GTEST_OS_QNX      - QNX
00200 //   GTEST_OS_SOLARIS  - Sun Solaris
00201 //   GTEST_OS_SYMBIAN  - Symbian
00202 //   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
00203 //     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop
00204 //     GTEST_OS_WINDOWS_MINGW    - MinGW
00205 //     GTEST_OS_WINDOWS_MOBILE   - Windows Mobile
00206 //   GTEST_OS_ZOS      - z/OS
00207 //
00208 // Among the platforms, Cygwin, Linux, Max OS X, and Windows have the
00209 // most stable support.  Since core members of the Google Test project
00210 // don't have access to other platforms, support for them may be less
00211 // stable.  If you notice any problems on your platform, please notify
00212 // googletestframework@googlegroups.com (patches for fixing them are
00213 // even more welcome!).
00214 //
00215 // Note that it is possible that none of the GTEST_OS_* macros are defined.
00216 //
00217 // Macros indicating available Google Test features (defined to 1 if
00218 // the corresponding feature is supported; otherwise undefined):
00219 //   GTEST_HAS_COMBINE      - the Combine() function (for value-parameterized
00220 //                            tests)
00221 //   GTEST_HAS_DEATH_TEST   - death tests
00222 //   GTEST_HAS_PARAM_TEST   - value-parameterized tests
00223 //   GTEST_HAS_TYPED_TEST   - typed tests
00224 //   GTEST_HAS_TYPED_TEST_P - type-parameterized tests
00225 //   GTEST_USES_POSIX_RE    - enhanced POSIX regex is used. Do not confuse with
00226 //                            GTEST_HAS_POSIX_RE (see above) which users can
00227 //                            define themselves.
00228 //   GTEST_USES_SIMPLE_RE   - our own simple regex is used;
00229 //                            the above two are mutually exclusive.
00230 //   GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ().
00231 //
00232 // Macros for basic C++ coding:
00233 //   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
00234 //   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a
00235 //                              variable don't have to be used.
00236 //   GTEST_DISALLOW_ASSIGN_   - disables operator=.
00237 //   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
00238 //   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
00239 //
00240 // Synchronization:
00241 //   Mutex, MutexLock, ThreadLocal, GetThreadCount()
00242 //                  - synchronization primitives.
00243 //   GTEST_IS_THREADSAFE - defined to 1 to indicate that the above
00244 //                         synchronization primitives have real implementations
00245 //                         and Google Test is thread-safe; or 0 otherwise.
00246 //
00247 // Template meta programming:
00248 //   is_pointer     - as in TR1; needed on Symbian and IBM XL C/C++ only.
00249 //   IteratorTraits - partial implementation of std::iterator_traits, which
00250 //                    is not available in libCstd when compiled with Sun C++.
00251 //
00252 // Smart pointers:
00253 //   scoped_ptr     - as in TR2.
00254 //
00255 // Regular expressions:
00256 //   RE             - a simple regular expression class using the POSIX
00257 //                    Extended Regular Expression syntax on UNIX-like
00258 //                    platforms, or a reduced regular exception syntax on
00259 //                    other platforms, including Windows.
00260 //
00261 // Logging:
00262 //   GTEST_LOG_()   - logs messages at the specified severity level.
00263 //   LogToStderr()  - directs all log messages to stderr.
00264 //   FlushInfoLog() - flushes informational log messages.
00265 //
00266 // Stdout and stderr capturing:
00267 //   CaptureStdout()     - starts capturing stdout.
00268 //   GetCapturedStdout() - stops capturing stdout and returns the captured
00269 //                         string.
00270 //   CaptureStderr()     - starts capturing stderr.
00271 //   GetCapturedStderr() - stops capturing stderr and returns the captured
00272 //                         string.
00273 //
00274 // Integer types:
00275 //   TypeWithSize   - maps an integer to a int type.
00276 //   Int32, UInt32, Int64, UInt64, TimeInMillis
00277 //                  - integers of known sizes.
00278 //   BiggestInt     - the biggest signed integer type.
00279 //
00280 // Command-line utilities:
00281 //   GTEST_FLAG()       - references a flag.
00282 //   GTEST_DECLARE_*()  - declares a flag.
00283 //   GTEST_DEFINE_*()   - defines a flag.
00284 //   GetInjectableArgvs() - returns the command line as a vector of strings.
00285 //
00286 // Environment variable utilities:
00287 //   GetEnv()             - gets the value of an environment variable.
00288 //   BoolFromGTestEnv()   - parses a bool environment variable.
00289 //   Int32FromGTestEnv()  - parses an Int32 environment variable.
00290 //   StringFromGTestEnv() - parses a string environment variable.
00291 
00292 #include <ctype.h>   // for isspace, etc
00293 #include <stddef.h>  // for ptrdiff_t
00294 #include <stdlib.h>
00295 #include <stdio.h>
00296 #include <string.h>
00297 #ifndef _WIN32_WCE
00298 # include <sys/types.h>
00299 # include <sys/stat.h>
00300 #endif  // !_WIN32_WCE
00301 
00302 #if defined __APPLE__
00303 # include <AvailabilityMacros.h>
00304 # include <TargetConditionals.h>
00305 #endif
00306 
00307 #include <iostream>  // NOLINT
00308 #include <sstream>  // NOLINT
00309 #include <string>  // NOLINT
00310 
00311 #define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
00312 #define GTEST_FLAG_PREFIX_ "gtest_"
00313 #define GTEST_FLAG_PREFIX_DASH_ "gtest-"
00314 #define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
00315 #define GTEST_NAME_ "Google Test"
00316 #define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/"
00317 
00318 // Determines the version of gcc that is used to compile this.
00319 #ifdef __GNUC__
00320 // 40302 means version 4.3.2.
00321 # define GTEST_GCC_VER_ \
00322     (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
00323 #endif  // __GNUC__
00324 
00325 // Determines the platform on which Google Test is compiled.
00326 #ifdef __CYGWIN__
00327 # define GTEST_OS_CYGWIN 1
00328 #elif defined __SYMBIAN32__
00329 # define GTEST_OS_SYMBIAN 1
00330 #elif defined _WIN32
00331 # define GTEST_OS_WINDOWS 1
00332 # ifdef _WIN32_WCE
00333 #  define GTEST_OS_WINDOWS_MOBILE 1
00334 # elif defined(__MINGW__) || defined(__MINGW32__)
00335 #  define GTEST_OS_WINDOWS_MINGW 1
00336 # else
00337 #  define GTEST_OS_WINDOWS_DESKTOP 1
00338 # endif  // _WIN32_WCE
00339 #elif defined __APPLE__
00340 # define GTEST_OS_MAC 1
00341 # if TARGET_OS_IPHONE
00342 #  define GTEST_OS_IOS 1
00343 #  if TARGET_IPHONE_SIMULATOR
00344 #   define GTEST_OS_IOS_SIMULATOR 1
00345 #  endif
00346 # endif
00347 #elif defined __linux__
00348 # define GTEST_OS_LINUX 1
00349 # if defined __ANDROID__
00350 #  define GTEST_OS_LINUX_ANDROID 1
00351 # endif
00352 #elif defined __MVS__
00353 # define GTEST_OS_ZOS 1
00354 #elif defined(__sun) && defined(__SVR4)
00355 # define GTEST_OS_SOLARIS 1
00356 #elif defined(_AIX)
00357 # define GTEST_OS_AIX 1
00358 #elif defined(__hpux)
00359 # define GTEST_OS_HPUX 1
00360 #elif defined __native_client__
00361 # define GTEST_OS_NACL 1
00362 #elif defined __OpenBSD__
00363 # define GTEST_OS_OPENBSD 1
00364 #elif defined __QNX__
00365 # define GTEST_OS_QNX 1
00366 #endif  // __CYGWIN__
00367 
00368 #ifndef GTEST_LANG_CXX11
00369 // gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when
00370 // -std={c,gnu}++{0x,11} is passed.  The C++11 standard specifies a
00371 // value for __cplusplus, and recent versions of clang, gcc, and
00372 // probably other compilers set that too in C++11 mode.
00373 # if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L
00374 // Compiling in at least C++11 mode.
00375 #  define GTEST_LANG_CXX11 1
00376 # else
00377 #  define GTEST_LANG_CXX11 0
00378 # endif
00379 #endif
00380 
00381 // Brings in definitions for functions used in the testing::internal::posix
00382 // namespace (read, write, close, chdir, isatty, stat). We do not currently
00383 // use them on Windows Mobile.
00384 #if !GTEST_OS_WINDOWS
00385 // This assumes that non-Windows OSes provide unistd.h. For OSes where this
00386 // is not the case, we need to include headers that provide the functions
00387 // mentioned above.
00388 # include <unistd.h>
00389 # include <strings.h>
00390 #elif !GTEST_OS_WINDOWS_MOBILE
00391 # include <direct.h>
00392 # include <io.h>
00393 #endif
00394 
00395 #if GTEST_OS_LINUX_ANDROID
00396 // Used to define __ANDROID_API__ matching the target NDK API level.
00397 #  include <android/api-level.h>  // NOLINT
00398 #endif
00399 
00400 // Defines this to true iff Google Test can use POSIX regular expressions.
00401 #ifndef GTEST_HAS_POSIX_RE
00402 # if GTEST_OS_LINUX_ANDROID
00403 // On Android, <regex.h> is only available starting with Gingerbread.
00404 #  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
00405 # else
00406 #  define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS)
00407 # endif
00408 #endif
00409 
00410 #if GTEST_HAS_POSIX_RE
00411 
00412 // On some platforms, <regex.h> needs someone to define size_t, and
00413 // won't compile otherwise.  We can #include it here as we already
00414 // included <stdlib.h>, which is guaranteed to define size_t through
00415 // <stddef.h>.
00416 # include <regex.h>  // NOLINT
00417 
00418 # define GTEST_USES_POSIX_RE 1
00419 
00420 #elif GTEST_OS_WINDOWS
00421 
00422 // <regex.h> is not available on Windows.  Use our own simple regex
00423 // implementation instead.
00424 # define GTEST_USES_SIMPLE_RE 1
00425 
00426 #else
00427 
00428 // <regex.h> may not be available on this platform.  Use our own
00429 // simple regex implementation instead.
00430 # define GTEST_USES_SIMPLE_RE 1
00431 
00432 #endif  // GTEST_HAS_POSIX_RE
00433 
00434 #ifndef GTEST_HAS_EXCEPTIONS
00435 // The user didn't tell us whether exceptions are enabled, so we need
00436 // to figure it out.
00437 # if defined(_MSC_VER) || defined(__BORLANDC__)
00438 // MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS
00439 // macro to enable exceptions, so we'll do the same.
00440 // Assumes that exceptions are enabled by default.
00441 #  ifndef _HAS_EXCEPTIONS
00442 #   define _HAS_EXCEPTIONS 1
00443 #  endif  // _HAS_EXCEPTIONS
00444 #  define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
00445 # elif defined(__GNUC__) && __EXCEPTIONS
00446 // gcc defines __EXCEPTIONS to 1 iff exceptions are enabled.
00447 #  define GTEST_HAS_EXCEPTIONS 1
00448 # elif defined(__SUNPRO_CC)
00449 // Sun Pro CC supports exceptions.  However, there is no compile-time way of
00450 // detecting whether they are enabled or not.  Therefore, we assume that
00451 // they are enabled unless the user tells us otherwise.
00452 #  define GTEST_HAS_EXCEPTIONS 1
00453 # elif defined(__IBMCPP__) && __EXCEPTIONS
00454 // xlC defines __EXCEPTIONS to 1 iff exceptions are enabled.
00455 #  define GTEST_HAS_EXCEPTIONS 1
00456 # elif defined(__HP_aCC)
00457 // Exception handling is in effect by default in HP aCC compiler. It has to
00458 // be turned of by +noeh compiler option if desired.
00459 #  define GTEST_HAS_EXCEPTIONS 1
00460 # else
00461 // For other compilers, we assume exceptions are disabled to be
00462 // conservative.
00463 #  define GTEST_HAS_EXCEPTIONS 0
00464 # endif  // defined(_MSC_VER) || defined(__BORLANDC__)
00465 #endif  // GTEST_HAS_EXCEPTIONS
00466 
00467 #if !defined(GTEST_HAS_STD_STRING)
00468 // Even though we don't use this macro any longer, we keep it in case
00469 // some clients still depend on it.
00470 # define GTEST_HAS_STD_STRING 1
00471 #elif !GTEST_HAS_STD_STRING
00472 // The user told us that ::std::string isn't available.
00473 # error "Google Test cannot be used where ::std::string isn't available."
00474 #endif  // !defined(GTEST_HAS_STD_STRING)
00475 
00476 #ifndef GTEST_HAS_GLOBAL_STRING
00477 // The user didn't tell us whether ::string is available, so we need
00478 // to figure it out.
00479 
00480 # define GTEST_HAS_GLOBAL_STRING 0
00481 
00482 #endif  // GTEST_HAS_GLOBAL_STRING
00483 
00484 #ifndef GTEST_HAS_STD_WSTRING
00485 // The user didn't tell us whether ::std::wstring is available, so we need
00486 // to figure it out.
00487 // TODO(wan@google.com): uses autoconf to detect whether ::std::wstring
00488 //   is available.
00489 
00490 // Cygwin 1.7 and below doesn't support ::std::wstring.
00491 // Solaris' libc++ doesn't support it either.  Android has
00492 // no support for it at least as recent as Froyo (2.2).
00493 # define GTEST_HAS_STD_WSTRING \
00494     (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS))
00495 
00496 #endif  // GTEST_HAS_STD_WSTRING
00497 
00498 #ifndef GTEST_HAS_GLOBAL_WSTRING
00499 // The user didn't tell us whether ::wstring is available, so we need
00500 // to figure it out.
00501 # define GTEST_HAS_GLOBAL_WSTRING \
00502     (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
00503 #endif  // GTEST_HAS_GLOBAL_WSTRING
00504 
00505 // Determines whether RTTI is available.
00506 #ifndef GTEST_HAS_RTTI
00507 // The user didn't tell us whether RTTI is enabled, so we need to
00508 // figure it out.
00509 
00510 # ifdef _MSC_VER
00511 
00512 #  ifdef _CPPRTTI  // MSVC defines this macro iff RTTI is enabled.
00513 #   define GTEST_HAS_RTTI 1
00514 #  else
00515 #   define GTEST_HAS_RTTI 0
00516 #  endif
00517 
00518 // Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled.
00519 # elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302)
00520 
00521 #  ifdef __GXX_RTTI
00522 // When building against STLport with the Android NDK and with
00523 // -frtti -fno-exceptions, the build fails at link time with undefined
00524 // references to __cxa_bad_typeid. Note sure if STL or toolchain bug,
00525 // so disable RTTI when detected.
00526 #   if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
00527        !defined(__EXCEPTIONS)
00528 #    define GTEST_HAS_RTTI 0
00529 #   else
00530 #    define GTEST_HAS_RTTI 1
00531 #   endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS
00532 #  else
00533 #   define GTEST_HAS_RTTI 0
00534 #  endif  // __GXX_RTTI
00535 
00536 // Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends
00537 // using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the
00538 // first version with C++ support.
00539 # elif defined(__clang__)
00540 
00541 #  define GTEST_HAS_RTTI __has_feature(cxx_rtti)
00542 
00543 // Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
00544 // both the typeid and dynamic_cast features are present.
00545 # elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
00546 
00547 #  ifdef __RTTI_ALL__
00548 #   define GTEST_HAS_RTTI 1
00549 #  else
00550 #   define GTEST_HAS_RTTI 0
00551 #  endif
00552 
00553 # else
00554 
00555 // For all other compilers, we assume RTTI is enabled.
00556 #  define GTEST_HAS_RTTI 1
00557 
00558 # endif  // _MSC_VER
00559 
00560 #endif  // GTEST_HAS_RTTI
00561 
00562 // It's this header's responsibility to #include <typeinfo> when RTTI
00563 // is enabled.
00564 #if GTEST_HAS_RTTI
00565 # include <typeinfo>
00566 #endif
00567 
00568 // Determines whether Google Test can use the pthreads library.
00569 #ifndef GTEST_HAS_PTHREAD
00570 // The user didn't tell us explicitly, so we assume pthreads support is
00571 // available on Linux and Mac.
00572 //
00573 // To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
00574 // to your compiler flags.
00575 # define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX \
00576     || GTEST_OS_QNX)
00577 #endif  // GTEST_HAS_PTHREAD
00578 
00579 #if GTEST_HAS_PTHREAD
00580 // gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is
00581 // true.
00582 # include <pthread.h>  // NOLINT
00583 
00584 // For timespec and nanosleep, used below.
00585 # include <time.h>  // NOLINT
00586 #endif
00587 
00588 // Determines whether Google Test can use tr1/tuple.  You can define
00589 // this macro to 0 to prevent Google Test from using tuple (any
00590 // feature depending on tuple with be disabled in this mode).
00591 #ifndef GTEST_HAS_TR1_TUPLE
00592 # if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR)
00593 // STLport, provided with the Android NDK, has neither <tr1/tuple> or <tuple>.
00594 #  define GTEST_HAS_TR1_TUPLE 0
00595 # else
00596 // The user didn't tell us not to do it, so we assume it's OK.
00597 #  define GTEST_HAS_TR1_TUPLE 1
00598 # endif
00599 #endif  // GTEST_HAS_TR1_TUPLE
00600 
00601 // Determines whether Google Test's own tr1 tuple implementation
00602 // should be used.
00603 #ifndef GTEST_USE_OWN_TR1_TUPLE
00604 // The user didn't tell us, so we need to figure it out.
00605 
00606 // We use our own TR1 tuple if we aren't sure the user has an
00607 // implementation of it already.  At this time, libstdc++ 4.0.0+ and
00608 // MSVC 2010 are the only mainstream standard libraries that come
00609 // with a TR1 tuple implementation.  NVIDIA's CUDA NVCC compiler
00610 // pretends to be GCC by defining __GNUC__ and friends, but cannot
00611 // compile GCC's tuple implementation.  MSVC 2008 (9.0) provides TR1
00612 // tuple in a 323 MB Feature Pack download, which we cannot assume the
00613 // user has.  QNX's QCC compiler is a modified GCC but it doesn't
00614 // support TR1 tuple.  libc++ only provides std::tuple, in C++11 mode,
00615 // and it can be used with some compilers that define __GNUC__.
00616 # if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \
00617       && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) || _MSC_VER >= 1600
00618 #  define GTEST_ENV_HAS_TR1_TUPLE_ 1
00619 # endif
00620 
00621 // C++11 specifies that <tuple> provides std::tuple. Use that if gtest is used
00622 // in C++11 mode and libstdc++ isn't very old (binaries targeting OS X 10.6
00623 // can build with clang but need to use gcc4.2's libstdc++).
00624 # if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325)
00625 #  define GTEST_ENV_HAS_STD_TUPLE_ 1
00626 # endif
00627 
00628 # if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_
00629 #  define GTEST_USE_OWN_TR1_TUPLE 0
00630 # else
00631 #  define GTEST_USE_OWN_TR1_TUPLE 1
00632 # endif
00633 
00634 #endif  // GTEST_USE_OWN_TR1_TUPLE
00635 
00636 // To avoid conditional compilation everywhere, we make it
00637 // gtest-port.h's responsibility to #include the header implementing
00638 // tr1/tuple.
00639 #if GTEST_HAS_TR1_TUPLE
00640 
00641 # if GTEST_USE_OWN_TR1_TUPLE
00642 // This file was GENERATED by command:
00643 //     pump.py gtest-tuple.h.pump
00644 // DO NOT EDIT BY HAND!!!
00645 
00646 // Copyright 2009 Google Inc.
00647 // All Rights Reserved.
00648 //
00649 // Redistribution and use in source and binary forms, with or without
00650 // modification, are permitted provided that the following conditions are
00651 // met:
00652 //
00653 //     * Redistributions of source code must retain the above copyright
00654 // notice, this list of conditions and the following disclaimer.
00655 //     * Redistributions in binary form must reproduce the above
00656 // copyright notice, this list of conditions and the following disclaimer
00657 // in the documentation and/or other materials provided with the
00658 // distribution.
00659 //     * Neither the name of Google Inc. nor the names of its
00660 // contributors may be used to endorse or promote products derived from
00661 // this software without specific prior written permission.
00662 //
00663 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00664 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00665 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00666 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
00667 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
00668 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
00669 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00670 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00671 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00672 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
00673 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00674 //
00675 // Author: wan@google.com (Zhanyong Wan)
00676 
00677 // Implements a subset of TR1 tuple needed by Google Test and Google Mock.
00678 
00679 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
00680 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
00681 
00682 #include <utility>  // For ::std::pair.
00683 
00684 // The compiler used in Symbian has a bug that prevents us from declaring the
00685 // tuple template as a friend (it complains that tuple is redefined).  This
00686 // hack bypasses the bug by declaring the members that should otherwise be
00687 // private as public.
00688 // Sun Studio versions < 12 also have the above bug.
00689 #if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)
00690 # define GTEST_DECLARE_TUPLE_AS_FRIEND_ public:
00691 #else
00692 # define GTEST_DECLARE_TUPLE_AS_FRIEND_ \
00693     template <GTEST_10_TYPENAMES_(U)> friend class tuple; \
00694    private:
00695 #endif
00696 
00697 // GTEST_n_TUPLE_(T) is the type of an n-tuple.
00698 #define GTEST_0_TUPLE_(T) tuple<>
00699 #define GTEST_1_TUPLE_(T) tuple<T##0, void, void, void, void, void, void, \
00700     void, void, void>
00701 #define GTEST_2_TUPLE_(T) tuple<T##0, T##1, void, void, void, void, void, \
00702     void, void, void>
00703 #define GTEST_3_TUPLE_(T) tuple<T##0, T##1, T##2, void, void, void, void, \
00704     void, void, void>
00705 #define GTEST_4_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, void, void, void, \
00706     void, void, void>
00707 #define GTEST_5_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, void, void, \
00708     void, void, void>
00709 #define GTEST_6_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, void, \
00710     void, void, void>
00711 #define GTEST_7_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
00712     void, void, void>
00713 #define GTEST_8_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
00714     T##7, void, void>
00715 #define GTEST_9_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
00716     T##7, T##8, void>
00717 #define GTEST_10_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
00718     T##7, T##8, T##9>
00719 
00720 // GTEST_n_TYPENAMES_(T) declares a list of n typenames.
00721 #define GTEST_0_TYPENAMES_(T)
00722 #define GTEST_1_TYPENAMES_(T) typename T##0
00723 #define GTEST_2_TYPENAMES_(T) typename T##0, typename T##1
00724 #define GTEST_3_TYPENAMES_(T) typename T##0, typename T##1, typename T##2
00725 #define GTEST_4_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
00726     typename T##3
00727 #define GTEST_5_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
00728     typename T##3, typename T##4
00729 #define GTEST_6_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
00730     typename T##3, typename T##4, typename T##5
00731 #define GTEST_7_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
00732     typename T##3, typename T##4, typename T##5, typename T##6
00733 #define GTEST_8_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
00734     typename T##3, typename T##4, typename T##5, typename T##6, typename T##7
00735 #define GTEST_9_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
00736     typename T##3, typename T##4, typename T##5, typename T##6, \
00737     typename T##7, typename T##8
00738 #define GTEST_10_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
00739     typename T##3, typename T##4, typename T##5, typename T##6, \
00740     typename T##7, typename T##8, typename T##9
00741 
00742 // In theory, defining stuff in the ::std namespace is undefined
00743 // behavior.  We can do this as we are playing the role of a standard
00744 // library vendor.
00745 namespace std {
00746 namespace tr1 {
00747 
00748 template <typename T0 = void, typename T1 = void, typename T2 = void,
00749     typename T3 = void, typename T4 = void, typename T5 = void,
00750     typename T6 = void, typename T7 = void, typename T8 = void,
00751     typename T9 = void>
00752 class tuple;
00753 
00754 // Anything in namespace gtest_internal is Google Test's INTERNAL
00755 // IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code.
00756 namespace gtest_internal {
00757 
00758 // ByRef<T>::type is T if T is a reference; otherwise it's const T&.
00759 template <typename T>
00760 struct ByRef { typedef const T& type; };  // NOLINT
00761 template <typename T>
00762 struct ByRef<T&> { typedef T& type; };  // NOLINT
00763 
00764 // A handy wrapper for ByRef.
00765 #define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type
00766 
00767 // AddRef<T>::type is T if T is a reference; otherwise it's T&.  This
00768 // is the same as tr1::add_reference<T>::type.
00769 template <typename T>
00770 struct AddRef { typedef T& type; };  // NOLINT
00771 template <typename T>
00772 struct AddRef<T&> { typedef T& type; };  // NOLINT
00773 
00774 // A handy wrapper for AddRef.
00775 #define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type
00776 
00777 // A helper for implementing get<k>().
00778 template <int k> class Get;
00779 
00780 // A helper for implementing tuple_element<k, T>.  kIndexValid is true
00781 // iff k < the number of fields in tuple type T.
00782 template <bool kIndexValid, int kIndex, class Tuple>
00783 struct TupleElement;
00784 
00785 template <GTEST_10_TYPENAMES_(T)>
00786 struct TupleElement<true, 0, GTEST_10_TUPLE_(T) > {
00787   typedef T0 type;
00788 };
00789 
00790 template <GTEST_10_TYPENAMES_(T)>
00791 struct TupleElement<true, 1, GTEST_10_TUPLE_(T) > {
00792   typedef T1 type;
00793 };
00794 
00795 template <GTEST_10_TYPENAMES_(T)>
00796 struct TupleElement<true, 2, GTEST_10_TUPLE_(T) > {
00797   typedef T2 type;
00798 };
00799 
00800 template <GTEST_10_TYPENAMES_(T)>
00801 struct TupleElement<true, 3, GTEST_10_TUPLE_(T) > {
00802   typedef T3 type;
00803 };
00804 
00805 template <GTEST_10_TYPENAMES_(T)>
00806 struct TupleElement<true, 4, GTEST_10_TUPLE_(T) > {
00807   typedef T4 type;
00808 };
00809 
00810 template <GTEST_10_TYPENAMES_(T)>
00811 struct TupleElement<true, 5, GTEST_10_TUPLE_(T) > {
00812   typedef T5 type;
00813 };
00814 
00815 template <GTEST_10_TYPENAMES_(T)>
00816 struct TupleElement<true, 6, GTEST_10_TUPLE_(T) > {
00817   typedef T6 type;
00818 };
00819 
00820 template <GTEST_10_TYPENAMES_(T)>
00821 struct TupleElement<true, 7, GTEST_10_TUPLE_(T) > {
00822   typedef T7 type;
00823 };
00824 
00825 template <GTEST_10_TYPENAMES_(T)>
00826 struct TupleElement<true, 8, GTEST_10_TUPLE_(T) > {
00827   typedef T8 type;
00828 };
00829 
00830 template <GTEST_10_TYPENAMES_(T)>
00831 struct TupleElement<true, 9, GTEST_10_TUPLE_(T) > {
00832   typedef T9 type;
00833 };
00834 
00835 }  // namespace gtest_internal
00836 
00837 template <>
00838 class tuple<> {
00839  public:
00840   tuple() {}
00841   tuple(const tuple& /* t */)  {}
00842   tuple& operator=(const tuple& /* t */) { return *this; }
00843 };
00844 
00845 template <GTEST_1_TYPENAMES_(T)>
00846 class GTEST_1_TUPLE_(T) {
00847  public:
00848   template <int k> friend class gtest_internal::Get;
00849 
00850   tuple() : f0_() {}
00851 
00852   explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {}
00853 
00854   tuple(const tuple& t) : f0_(t.f0_) {}
00855 
00856   template <GTEST_1_TYPENAMES_(U)>
00857   tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {}
00858 
00859   tuple& operator=(const tuple& t) { return CopyFrom(t); }
00860 
00861   template <GTEST_1_TYPENAMES_(U)>
00862   tuple& operator=(const GTEST_1_TUPLE_(U)& t) {
00863     return CopyFrom(t);
00864   }
00865 
00866   GTEST_DECLARE_TUPLE_AS_FRIEND_
00867 
00868   template <GTEST_1_TYPENAMES_(U)>
00869   tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) {
00870     f0_ = t.f0_;
00871     return *this;
00872   }
00873 
00874   T0 f0_;
00875 };
00876 
00877 template <GTEST_2_TYPENAMES_(T)>
00878 class GTEST_2_TUPLE_(T) {
00879  public:
00880   template <int k> friend class gtest_internal::Get;
00881 
00882   tuple() : f0_(), f1_() {}
00883 
00884   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0),
00885       f1_(f1) {}
00886 
00887   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {}
00888 
00889   template <GTEST_2_TYPENAMES_(U)>
00890   tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {}
00891   template <typename U0, typename U1>
00892   tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {}
00893 
00894   tuple& operator=(const tuple& t) { return CopyFrom(t); }
00895 
00896   template <GTEST_2_TYPENAMES_(U)>
00897   tuple& operator=(const GTEST_2_TUPLE_(U)& t) {
00898     return CopyFrom(t);
00899   }
00900   template <typename U0, typename U1>
00901   tuple& operator=(const ::std::pair<U0, U1>& p) {
00902     f0_ = p.first;
00903     f1_ = p.second;
00904     return *this;
00905   }
00906 
00907   GTEST_DECLARE_TUPLE_AS_FRIEND_
00908 
00909   template <GTEST_2_TYPENAMES_(U)>
00910   tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) {
00911     f0_ = t.f0_;
00912     f1_ = t.f1_;
00913     return *this;
00914   }
00915 
00916   T0 f0_;
00917   T1 f1_;
00918 };
00919 
00920 template <GTEST_3_TYPENAMES_(T)>
00921 class GTEST_3_TUPLE_(T) {
00922  public:
00923   template <int k> friend class gtest_internal::Get;
00924 
00925   tuple() : f0_(), f1_(), f2_() {}
00926 
00927   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
00928       GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {}
00929 
00930   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
00931 
00932   template <GTEST_3_TYPENAMES_(U)>
00933   tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
00934 
00935   tuple& operator=(const tuple& t) { return CopyFrom(t); }
00936 
00937   template <GTEST_3_TYPENAMES_(U)>
00938   tuple& operator=(const GTEST_3_TUPLE_(U)& t) {
00939     return CopyFrom(t);
00940   }
00941 
00942   GTEST_DECLARE_TUPLE_AS_FRIEND_
00943 
00944   template <GTEST_3_TYPENAMES_(U)>
00945   tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) {
00946     f0_ = t.f0_;
00947     f1_ = t.f1_;
00948     f2_ = t.f2_;
00949     return *this;
00950   }
00951 
00952   T0 f0_;
00953   T1 f1_;
00954   T2 f2_;
00955 };
00956 
00957 template <GTEST_4_TYPENAMES_(T)>
00958 class GTEST_4_TUPLE_(T) {
00959  public:
00960   template <int k> friend class gtest_internal::Get;
00961 
00962   tuple() : f0_(), f1_(), f2_(), f3_() {}
00963 
00964   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
00965       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1), f2_(f2),
00966       f3_(f3) {}
00967 
00968   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {}
00969 
00970   template <GTEST_4_TYPENAMES_(U)>
00971   tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
00972       f3_(t.f3_) {}
00973 
00974   tuple& operator=(const tuple& t) { return CopyFrom(t); }
00975 
00976   template <GTEST_4_TYPENAMES_(U)>
00977   tuple& operator=(const GTEST_4_TUPLE_(U)& t) {
00978     return CopyFrom(t);
00979   }
00980 
00981   GTEST_DECLARE_TUPLE_AS_FRIEND_
00982 
00983   template <GTEST_4_TYPENAMES_(U)>
00984   tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) {
00985     f0_ = t.f0_;
00986     f1_ = t.f1_;
00987     f2_ = t.f2_;
00988     f3_ = t.f3_;
00989     return *this;
00990   }
00991 
00992   T0 f0_;
00993   T1 f1_;
00994   T2 f2_;
00995   T3 f3_;
00996 };
00997 
00998 template <GTEST_5_TYPENAMES_(T)>
00999 class GTEST_5_TUPLE_(T) {
01000  public:
01001   template <int k> friend class gtest_internal::Get;
01002 
01003   tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {}
01004 
01005   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
01006       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3,
01007       GTEST_BY_REF_(T4) f4) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4) {}
01008 
01009   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
01010       f4_(t.f4_) {}
01011 
01012   template <GTEST_5_TYPENAMES_(U)>
01013   tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
01014       f3_(t.f3_), f4_(t.f4_) {}
01015 
01016   tuple& operator=(const tuple& t) { return CopyFrom(t); }
01017 
01018   template <GTEST_5_TYPENAMES_(U)>
01019   tuple& operator=(const GTEST_5_TUPLE_(U)& t) {
01020     return CopyFrom(t);
01021   }
01022 
01023   GTEST_DECLARE_TUPLE_AS_FRIEND_
01024 
01025   template <GTEST_5_TYPENAMES_(U)>
01026   tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) {
01027     f0_ = t.f0_;
01028     f1_ = t.f1_;
01029     f2_ = t.f2_;
01030     f3_ = t.f3_;
01031     f4_ = t.f4_;
01032     return *this;
01033   }
01034 
01035   T0 f0_;
01036   T1 f1_;
01037   T2 f2_;
01038   T3 f3_;
01039   T4 f4_;
01040 };
01041 
01042 template <GTEST_6_TYPENAMES_(T)>
01043 class GTEST_6_TUPLE_(T) {
01044  public:
01045   template <int k> friend class gtest_internal::Get;
01046 
01047   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {}
01048 
01049   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
01050       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
01051       GTEST_BY_REF_(T5) f5) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
01052       f5_(f5) {}
01053 
01054   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
01055       f4_(t.f4_), f5_(t.f5_) {}
01056 
01057   template <GTEST_6_TYPENAMES_(U)>
01058   tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
01059       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {}
01060 
01061   tuple& operator=(const tuple& t) { return CopyFrom(t); }
01062 
01063   template <GTEST_6_TYPENAMES_(U)>
01064   tuple& operator=(const GTEST_6_TUPLE_(U)& t) {
01065     return CopyFrom(t);
01066   }
01067 
01068   GTEST_DECLARE_TUPLE_AS_FRIEND_
01069 
01070   template <GTEST_6_TYPENAMES_(U)>
01071   tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) {
01072     f0_ = t.f0_;
01073     f1_ = t.f1_;
01074     f2_ = t.f2_;
01075     f3_ = t.f3_;
01076     f4_ = t.f4_;
01077     f5_ = t.f5_;
01078     return *this;
01079   }
01080 
01081   T0 f0_;
01082   T1 f1_;
01083   T2 f2_;
01084   T3 f3_;
01085   T4 f4_;
01086   T5 f5_;
01087 };
01088 
01089 template <GTEST_7_TYPENAMES_(T)>
01090 class GTEST_7_TUPLE_(T) {
01091  public:
01092   template <int k> friend class gtest_internal::Get;
01093 
01094   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {}
01095 
01096   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
01097       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
01098       GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6) : f0_(f0), f1_(f1), f2_(f2),
01099       f3_(f3), f4_(f4), f5_(f5), f6_(f6) {}
01100 
01101   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
01102       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
01103 
01104   template <GTEST_7_TYPENAMES_(U)>
01105   tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
01106       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
01107 
01108   tuple& operator=(const tuple& t) { return CopyFrom(t); }
01109 
01110   template <GTEST_7_TYPENAMES_(U)>
01111   tuple& operator=(const GTEST_7_TUPLE_(U)& t) {
01112     return CopyFrom(t);
01113   }
01114 
01115   GTEST_DECLARE_TUPLE_AS_FRIEND_
01116 
01117   template <GTEST_7_TYPENAMES_(U)>
01118   tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) {
01119     f0_ = t.f0_;
01120     f1_ = t.f1_;
01121     f2_ = t.f2_;
01122     f3_ = t.f3_;
01123     f4_ = t.f4_;
01124     f5_ = t.f5_;
01125     f6_ = t.f6_;
01126     return *this;
01127   }
01128 
01129   T0 f0_;
01130   T1 f1_;
01131   T2 f2_;
01132   T3 f3_;
01133   T4 f4_;
01134   T5 f5_;
01135   T6 f6_;
01136 };
01137 
01138 template <GTEST_8_TYPENAMES_(T)>
01139 class GTEST_8_TUPLE_(T) {
01140  public:
01141   template <int k> friend class gtest_internal::Get;
01142 
01143   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {}
01144 
01145   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
01146       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
01147       GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6,
01148       GTEST_BY_REF_(T7) f7) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
01149       f5_(f5), f6_(f6), f7_(f7) {}
01150 
01151   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
01152       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
01153 
01154   template <GTEST_8_TYPENAMES_(U)>
01155   tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
01156       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
01157 
01158   tuple& operator=(const tuple& t) { return CopyFrom(t); }
01159 
01160   template <GTEST_8_TYPENAMES_(U)>
01161   tuple& operator=(const GTEST_8_TUPLE_(U)& t) {
01162     return CopyFrom(t);
01163   }
01164 
01165   GTEST_DECLARE_TUPLE_AS_FRIEND_
01166 
01167   template <GTEST_8_TYPENAMES_(U)>
01168   tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) {
01169     f0_ = t.f0_;
01170     f1_ = t.f1_;
01171     f2_ = t.f2_;
01172     f3_ = t.f3_;
01173     f4_ = t.f4_;
01174     f5_ = t.f5_;
01175     f6_ = t.f6_;
01176     f7_ = t.f7_;
01177     return *this;
01178   }
01179 
01180   T0 f0_;
01181   T1 f1_;
01182   T2 f2_;
01183   T3 f3_;
01184   T4 f4_;
01185   T5 f5_;
01186   T6 f6_;
01187   T7 f7_;
01188 };
01189 
01190 template <GTEST_9_TYPENAMES_(T)>
01191 class GTEST_9_TUPLE_(T) {
01192  public:
01193   template <int k> friend class gtest_internal::Get;
01194 
01195   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_() {}
01196 
01197   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
01198       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
01199       GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
01200       GTEST_BY_REF_(T8) f8) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
01201       f5_(f5), f6_(f6), f7_(f7), f8_(f8) {}
01202 
01203   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
01204       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
01205 
01206   template <GTEST_9_TYPENAMES_(U)>
01207   tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
01208       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
01209 
01210   tuple& operator=(const tuple& t) { return CopyFrom(t); }
01211 
01212   template <GTEST_9_TYPENAMES_(U)>
01213   tuple& operator=(const GTEST_9_TUPLE_(U)& t) {
01214     return CopyFrom(t);
01215   }
01216 
01217   GTEST_DECLARE_TUPLE_AS_FRIEND_
01218 
01219   template <GTEST_9_TYPENAMES_(U)>
01220   tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) {
01221     f0_ = t.f0_;
01222     f1_ = t.f1_;
01223     f2_ = t.f2_;
01224     f3_ = t.f3_;
01225     f4_ = t.f4_;
01226     f5_ = t.f5_;
01227     f6_ = t.f6_;
01228     f7_ = t.f7_;
01229     f8_ = t.f8_;
01230     return *this;
01231   }
01232 
01233   T0 f0_;
01234   T1 f1_;
01235   T2 f2_;
01236   T3 f3_;
01237   T4 f4_;
01238   T5 f5_;
01239   T6 f6_;
01240   T7 f7_;
01241   T8 f8_;
01242 };
01243 
01244 template <GTEST_10_TYPENAMES_(T)>
01245 class tuple {
01246  public:
01247   template <int k> friend class gtest_internal::Get;
01248 
01249   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(),
01250       f9_() {}
01251 
01252   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
01253       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
01254       GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
01255       GTEST_BY_REF_(T8) f8, GTEST_BY_REF_(T9) f9) : f0_(f0), f1_(f1), f2_(f2),
01256       f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8), f9_(f9) {}
01257 
01258   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
01259       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {}
01260 
01261   template <GTEST_10_TYPENAMES_(U)>
01262   tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
01263       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_),
01264       f9_(t.f9_) {}
01265 
01266   tuple& operator=(const tuple& t) { return CopyFrom(t); }
01267 
01268   template <GTEST_10_TYPENAMES_(U)>
01269   tuple& operator=(const GTEST_10_TUPLE_(U)& t) {
01270     return CopyFrom(t);
01271   }
01272 
01273   GTEST_DECLARE_TUPLE_AS_FRIEND_
01274 
01275   template <GTEST_10_TYPENAMES_(U)>
01276   tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) {
01277     f0_ = t.f0_;
01278     f1_ = t.f1_;
01279     f2_ = t.f2_;
01280     f3_ = t.f3_;
01281     f4_ = t.f4_;
01282     f5_ = t.f5_;
01283     f6_ = t.f6_;
01284     f7_ = t.f7_;
01285     f8_ = t.f8_;
01286     f9_ = t.f9_;
01287     return *this;
01288   }
01289 
01290   T0 f0_;
01291   T1 f1_;
01292   T2 f2_;
01293   T3 f3_;
01294   T4 f4_;
01295   T5 f5_;
01296   T6 f6_;
01297   T7 f7_;
01298   T8 f8_;
01299   T9 f9_;
01300 };
01301 
01302 // 6.1.3.2 Tuple creation functions.
01303 
01304 // Known limitations: we don't support passing an
01305 // std::tr1::reference_wrapper<T> to make_tuple().  And we don't
01306 // implement tie().
01307 
01308 inline tuple<> make_tuple() { return tuple<>(); }
01309 
01310 template <GTEST_1_TYPENAMES_(T)>
01311 inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) {
01312   return GTEST_1_TUPLE_(T)(f0);
01313 }
01314 
01315 template <GTEST_2_TYPENAMES_(T)>
01316 inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) {
01317   return GTEST_2_TUPLE_(T)(f0, f1);
01318 }
01319 
01320 template <GTEST_3_TYPENAMES_(T)>
01321 inline GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) {
01322   return GTEST_3_TUPLE_(T)(f0, f1, f2);
01323 }
01324 
01325 template <GTEST_4_TYPENAMES_(T)>
01326 inline GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
01327     const T3& f3) {
01328   return GTEST_4_TUPLE_(T)(f0, f1, f2, f3);
01329 }
01330 
01331 template <GTEST_5_TYPENAMES_(T)>
01332 inline GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
01333     const T3& f3, const T4& f4) {
01334   return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4);
01335 }
01336 
01337 template <GTEST_6_TYPENAMES_(T)>
01338 inline GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
01339     const T3& f3, const T4& f4, const T5& f5) {
01340   return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5);
01341 }
01342 
01343 template <GTEST_7_TYPENAMES_(T)>
01344 inline GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
01345     const T3& f3, const T4& f4, const T5& f5, const T6& f6) {
01346   return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6);
01347 }
01348 
01349 template <GTEST_8_TYPENAMES_(T)>
01350 inline GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
01351     const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7) {
01352   return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7);
01353 }
01354 
01355 template <GTEST_9_TYPENAMES_(T)>
01356 inline GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
01357     const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
01358     const T8& f8) {
01359   return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8);
01360 }
01361 
01362 template <GTEST_10_TYPENAMES_(T)>
01363 inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
01364     const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
01365     const T8& f8, const T9& f9) {
01366   return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9);
01367 }
01368 
01369 // 6.1.3.3 Tuple helper classes.
01370 
01371 template <typename Tuple> struct tuple_size;
01372 
01373 template <GTEST_0_TYPENAMES_(T)>
01374 struct tuple_size<GTEST_0_TUPLE_(T) > {
01375   static const int value = 0;
01376 };
01377 
01378 template <GTEST_1_TYPENAMES_(T)>
01379 struct tuple_size<GTEST_1_TUPLE_(T) > {
01380   static const int value = 1;
01381 };
01382 
01383 template <GTEST_2_TYPENAMES_(T)>
01384 struct tuple_size<GTEST_2_TUPLE_(T) > {
01385   static const int value = 2;
01386 };
01387 
01388 template <GTEST_3_TYPENAMES_(T)>
01389 struct tuple_size<GTEST_3_TUPLE_(T) > {
01390   static const int value = 3;
01391 };
01392 
01393 template <GTEST_4_TYPENAMES_(T)>
01394 struct tuple_size<GTEST_4_TUPLE_(T) > {
01395   static const int value = 4;
01396 };
01397 
01398 template <GTEST_5_TYPENAMES_(T)>
01399 struct tuple_size<GTEST_5_TUPLE_(T) > {
01400   static const int value = 5;
01401 };
01402 
01403 template <GTEST_6_TYPENAMES_(T)>
01404 struct tuple_size<GTEST_6_TUPLE_(T) > {
01405   static const int value = 6;
01406 };
01407 
01408 template <GTEST_7_TYPENAMES_(T)>
01409 struct tuple_size<GTEST_7_TUPLE_(T) > {
01410   static const int value = 7;
01411 };
01412 
01413 template <GTEST_8_TYPENAMES_(T)>
01414 struct tuple_size<GTEST_8_TUPLE_(T) > {
01415   static const int value = 8;
01416 };
01417 
01418 template <GTEST_9_TYPENAMES_(T)>
01419 struct tuple_size<GTEST_9_TUPLE_(T) > {
01420   static const int value = 9;
01421 };
01422 
01423 template <GTEST_10_TYPENAMES_(T)>
01424 struct tuple_size<GTEST_10_TUPLE_(T) > {
01425   static const int value = 10;
01426 };
01427 
01428 template <int k, class Tuple>
01429 struct tuple_element {
01430   typedef typename gtest_internal::TupleElement<
01431       k < (tuple_size<Tuple>::value), k, Tuple>::type type;
01432 };
01433 
01434 #define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type
01435 
01436 // 6.1.3.4 Element access.
01437 
01438 namespace gtest_internal {
01439 
01440 template <>
01441 class Get<0> {
01442  public:
01443   template <class Tuple>
01444   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
01445   Field(Tuple& t) { return t.f0_; }  // NOLINT
01446 
01447   template <class Tuple>
01448   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
01449   ConstField(const Tuple& t) { return t.f0_; }
01450 };
01451 
01452 template <>
01453 class Get<1> {
01454  public:
01455   template <class Tuple>
01456   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
01457   Field(Tuple& t) { return t.f1_; }  // NOLINT
01458 
01459   template <class Tuple>
01460   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
01461   ConstField(const Tuple& t) { return t.f1_; }
01462 };
01463 
01464 template <>
01465 class Get<2> {
01466  public:
01467   template <class Tuple>
01468   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
01469   Field(Tuple& t) { return t.f2_; }  // NOLINT
01470 
01471   template <class Tuple>
01472   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
01473   ConstField(const Tuple& t) { return t.f2_; }
01474 };
01475 
01476 template <>
01477 class Get<3> {
01478  public:
01479   template <class Tuple>
01480   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
01481   Field(Tuple& t) { return t.f3_; }  // NOLINT
01482 
01483   template <class Tuple>
01484   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
01485   ConstField(const Tuple& t) { return t.f3_; }
01486 };
01487 
01488 template <>
01489 class Get<4> {
01490  public:
01491   template <class Tuple>
01492   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
01493   Field(Tuple& t) { return t.f4_; }  // NOLINT
01494 
01495   template <class Tuple>
01496   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
01497   ConstField(const Tuple& t) { return t.f4_; }
01498 };
01499 
01500 template <>
01501 class Get<5> {
01502  public:
01503   template <class Tuple>
01504   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
01505   Field(Tuple& t) { return t.f5_; }  // NOLINT
01506 
01507   template <class Tuple>
01508   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
01509   ConstField(const Tuple& t) { return t.f5_; }
01510 };
01511 
01512 template <>
01513 class Get<6> {
01514  public:
01515   template <class Tuple>
01516   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
01517   Field(Tuple& t) { return t.f6_; }  // NOLINT
01518 
01519   template <class Tuple>
01520   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
01521   ConstField(const Tuple& t) { return t.f6_; }
01522 };
01523 
01524 template <>
01525 class Get<7> {
01526  public:
01527   template <class Tuple>
01528   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
01529   Field(Tuple& t) { return t.f7_; }  // NOLINT
01530 
01531   template <class Tuple>
01532   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
01533   ConstField(const Tuple& t) { return t.f7_; }
01534 };
01535 
01536 template <>
01537 class Get<8> {
01538  public:
01539   template <class Tuple>
01540   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
01541   Field(Tuple& t) { return t.f8_; }  // NOLINT
01542 
01543   template <class Tuple>
01544   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
01545   ConstField(const Tuple& t) { return t.f8_; }
01546 };
01547 
01548 template <>
01549 class Get<9> {
01550  public:
01551   template <class Tuple>
01552   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
01553   Field(Tuple& t) { return t.f9_; }  // NOLINT
01554 
01555   template <class Tuple>
01556   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
01557   ConstField(const Tuple& t) { return t.f9_; }
01558 };
01559 
01560 }  // namespace gtest_internal
01561 
01562 template <int k, GTEST_10_TYPENAMES_(T)>
01563 GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T)))
01564 get(GTEST_10_TUPLE_(T)& t) {
01565   return gtest_internal::Get<k>::Field(t);
01566 }
01567 
01568 template <int k, GTEST_10_TYPENAMES_(T)>
01569 GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k,  GTEST_10_TUPLE_(T)))
01570 get(const GTEST_10_TUPLE_(T)& t) {
01571   return gtest_internal::Get<k>::ConstField(t);
01572 }
01573 
01574 // 6.1.3.5 Relational operators
01575 
01576 // We only implement == and !=, as we don't have a need for the rest yet.
01577 
01578 namespace gtest_internal {
01579 
01580 // SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the
01581 // first k fields of t1 equals the first k fields of t2.
01582 // SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if
01583 // k1 != k2.
01584 template <int kSize1, int kSize2>
01585 struct SameSizeTuplePrefixComparator;
01586 
01587 template <>
01588 struct SameSizeTuplePrefixComparator<0, 0> {
01589   template <class Tuple1, class Tuple2>
01590   static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) {
01591     return true;
01592   }
01593 };
01594 
01595 template <int k>
01596 struct SameSizeTuplePrefixComparator<k, k> {
01597   template <class Tuple1, class Tuple2>
01598   static bool Eq(const Tuple1& t1, const Tuple2& t2) {
01599     return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) &&
01600         ::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2);
01601   }
01602 };
01603 
01604 }  // namespace gtest_internal
01605 
01606 template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
01607 inline bool operator==(const GTEST_10_TUPLE_(T)& t,
01608                        const GTEST_10_TUPLE_(U)& u) {
01609   return gtest_internal::SameSizeTuplePrefixComparator<
01610       tuple_size<GTEST_10_TUPLE_(T) >::value,
01611       tuple_size<GTEST_10_TUPLE_(U) >::value>::Eq(t, u);
01612 }
01613 
01614 template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
01615 inline bool operator!=(const GTEST_10_TUPLE_(T)& t,
01616                        const GTEST_10_TUPLE_(U)& u) { return !(t == u); }
01617 
01618 // 6.1.4 Pairs.
01619 // Unimplemented.
01620 
01621 }  // namespace tr1
01622 }  // namespace std
01623 
01624 #undef GTEST_0_TUPLE_
01625 #undef GTEST_1_TUPLE_
01626 #undef GTEST_2_TUPLE_
01627 #undef GTEST_3_TUPLE_
01628 #undef GTEST_4_TUPLE_
01629 #undef GTEST_5_TUPLE_
01630 #undef GTEST_6_TUPLE_
01631 #undef GTEST_7_TUPLE_
01632 #undef GTEST_8_TUPLE_
01633 #undef GTEST_9_TUPLE_
01634 #undef GTEST_10_TUPLE_
01635 
01636 #undef GTEST_0_TYPENAMES_
01637 #undef GTEST_1_TYPENAMES_
01638 #undef GTEST_2_TYPENAMES_
01639 #undef GTEST_3_TYPENAMES_
01640 #undef GTEST_4_TYPENAMES_
01641 #undef GTEST_5_TYPENAMES_
01642 #undef GTEST_6_TYPENAMES_
01643 #undef GTEST_7_TYPENAMES_
01644 #undef GTEST_8_TYPENAMES_
01645 #undef GTEST_9_TYPENAMES_
01646 #undef GTEST_10_TYPENAMES_
01647 
01648 #undef GTEST_DECLARE_TUPLE_AS_FRIEND_
01649 #undef GTEST_BY_REF_
01650 #undef GTEST_ADD_REF_
01651 #undef GTEST_TUPLE_ELEMENT_
01652 
01653 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
01654 # elif GTEST_ENV_HAS_STD_TUPLE_
01655 #  include <tuple>
01656 // C++11 puts its tuple into the ::std namespace rather than
01657 // ::std::tr1.  gtest expects tuple to live in ::std::tr1, so put it there.
01658 // This causes undefined behavior, but supported compilers react in
01659 // the way we intend.
01660 namespace std {
01661 namespace tr1 {
01662 using ::std::get;
01663 using ::std::make_tuple;
01664 using ::std::tuple;
01665 using ::std::tuple_element;
01666 using ::std::tuple_size;
01667 }
01668 }
01669 
01670 # elif GTEST_OS_SYMBIAN
01671 
01672 // On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to
01673 // use STLport's tuple implementation, which unfortunately doesn't
01674 // work as the copy of STLport distributed with Symbian is incomplete.
01675 // By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to
01676 // use its own tuple implementation.
01677 #  ifdef BOOST_HAS_TR1_TUPLE
01678 #   undef BOOST_HAS_TR1_TUPLE
01679 #  endif  // BOOST_HAS_TR1_TUPLE
01680 
01681 // This prevents <boost/tr1/detail/config.hpp>, which defines
01682 // BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>.
01683 #  define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED
01684 #  include <tuple>
01685 
01686 # elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
01687 // GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header.  This does
01688 // not conform to the TR1 spec, which requires the header to be <tuple>.
01689 
01690 #  if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
01691 // Until version 4.3.2, gcc has a bug that causes <tr1/functional>,
01692 // which is #included by <tr1/tuple>, to not compile when RTTI is
01693 // disabled.  _TR1_FUNCTIONAL is the header guard for
01694 // <tr1/functional>.  Hence the following #define is a hack to prevent
01695 // <tr1/functional> from being included.
01696 #   define _TR1_FUNCTIONAL 1
01697 #   include <tr1/tuple>
01698 #   undef _TR1_FUNCTIONAL  // Allows the user to #include
01699                         // <tr1/functional> if he chooses to.
01700 #  else
01701 #   include <tr1/tuple>  // NOLINT
01702 #  endif  // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
01703 
01704 # else
01705 // If the compiler is not GCC 4.0+, we assume the user is using a
01706 // spec-conforming TR1 implementation.
01707 #  include <tuple>  // NOLINT
01708 # endif  // GTEST_USE_OWN_TR1_TUPLE
01709 
01710 #endif  // GTEST_HAS_TR1_TUPLE
01711 
01712 // Determines whether clone(2) is supported.
01713 // Usually it will only be available on Linux, excluding
01714 // Linux on the Itanium architecture.
01715 // Also see http://linux.die.net/man/2/clone.
01716 #ifndef GTEST_HAS_CLONE
01717 // The user didn't tell us, so we need to figure it out.
01718 
01719 # if GTEST_OS_LINUX && !defined(__ia64__)
01720 #  if GTEST_OS_LINUX_ANDROID
01721 // On Android, clone() is only available on ARM starting with Gingerbread.
01722 #    if defined(__arm__) && __ANDROID_API__ >= 9
01723 #     define GTEST_HAS_CLONE 1
01724 #    else
01725 #     define GTEST_HAS_CLONE 0
01726 #    endif
01727 #  else
01728 #   define GTEST_HAS_CLONE 1
01729 #  endif
01730 # else
01731 #  define GTEST_HAS_CLONE 0
01732 # endif  // GTEST_OS_LINUX && !defined(__ia64__)
01733 
01734 #endif  // GTEST_HAS_CLONE
01735 
01736 // Determines whether to support stream redirection. This is used to test
01737 // output correctness and to implement death tests.
01738 #ifndef GTEST_HAS_STREAM_REDIRECTION
01739 // By default, we assume that stream redirection is supported on all
01740 // platforms except known mobile ones.
01741 # if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN
01742 #  define GTEST_HAS_STREAM_REDIRECTION 0
01743 # else
01744 #  define GTEST_HAS_STREAM_REDIRECTION 1
01745 # endif  // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN
01746 #endif  // GTEST_HAS_STREAM_REDIRECTION
01747 
01748 // Determines whether to support death tests.
01749 // Google Test does not support death tests for VC 7.1 and earlier as
01750 // abort() in a VC 7.1 application compiled as GUI in debug config
01751 // pops up a dialog window that cannot be suppressed programmatically.
01752 #if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
01753      (GTEST_OS_MAC && !GTEST_OS_IOS) || GTEST_OS_IOS_SIMULATOR || \
01754      (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \
01755      GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \
01756      GTEST_OS_OPENBSD || GTEST_OS_QNX)
01757 # define GTEST_HAS_DEATH_TEST 1
01758 # include <vector>  // NOLINT
01759 #endif
01760 
01761 // We don't support MSVC 7.1 with exceptions disabled now.  Therefore
01762 // all the compilers we care about are adequate for supporting
01763 // value-parameterized tests.
01764 #define GTEST_HAS_PARAM_TEST 1
01765 
01766 // Determines whether to support type-driven tests.
01767 
01768 // Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0,
01769 // Sun Pro CC, IBM Visual Age, and HP aCC support.
01770 #if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \
01771     defined(__IBMCPP__) || defined(__HP_aCC)
01772 # define GTEST_HAS_TYPED_TEST 1
01773 # define GTEST_HAS_TYPED_TEST_P 1
01774 #endif
01775 
01776 // Determines whether to support Combine(). This only makes sense when
01777 // value-parameterized tests are enabled.  The implementation doesn't
01778 // work on Sun Studio since it doesn't understand templated conversion
01779 // operators.
01780 #if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC)
01781 # define GTEST_HAS_COMBINE 1
01782 #endif
01783 
01784 // Determines whether the system compiler uses UTF-16 for encoding wide strings.
01785 #define GTEST_WIDE_STRING_USES_UTF16_ \
01786     (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX)
01787 
01788 // Determines whether test results can be streamed to a socket.
01789 #if GTEST_OS_LINUX
01790 # define GTEST_CAN_STREAM_RESULTS_ 1
01791 #endif
01792 
01793 // Defines some utility macros.
01794 
01795 // The GNU compiler emits a warning if nested "if" statements are followed by
01796 // an "else" statement and braces are not used to explicitly disambiguate the
01797 // "else" binding.  This leads to problems with code like:
01798 //
01799 //   if (gate)
01800 //     ASSERT_*(condition) << "Some message";
01801 //
01802 // The "switch (0) case 0:" idiom is used to suppress this.
01803 #ifdef __INTEL_COMPILER
01804 # define GTEST_AMBIGUOUS_ELSE_BLOCKER_
01805 #else
01806 # define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:  // NOLINT
01807 #endif
01808 
01809 // Use this annotation at the end of a struct/class definition to
01810 // prevent the compiler from optimizing away instances that are never
01811 // used.  This is useful when all interesting logic happens inside the
01812 // c'tor and / or d'tor.  Example:
01813 //
01814 //   struct Foo {
01815 //     Foo() { ... }
01816 //   } GTEST_ATTRIBUTE_UNUSED_;
01817 //
01818 // Also use it after a variable or parameter declaration to tell the
01819 // compiler the variable/parameter does not have to be used.
01820 #if defined(__GNUC__) && !defined(COMPILER_ICC)
01821 # define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
01822 #else
01823 # define GTEST_ATTRIBUTE_UNUSED_
01824 #endif
01825 
01826 // A macro to disallow operator=
01827 // This should be used in the private: declarations for a class.
01828 #define GTEST_DISALLOW_ASSIGN_(type)\
01829   void operator=(type const &)
01830 
01831 // A macro to disallow copy constructor and operator=
01832 // This should be used in the private: declarations for a class.
01833 #define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\
01834   type(type const &);\
01835   GTEST_DISALLOW_ASSIGN_(type)
01836 
01837 // Tell the compiler to warn about unused return values for functions declared
01838 // with this macro.  The macro should be used on function declarations
01839 // following the argument list:
01840 //
01841 //   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
01842 #if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)
01843 # define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
01844 #else
01845 # define GTEST_MUST_USE_RESULT_
01846 #endif  // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC
01847 
01848 // Determine whether the compiler supports Microsoft's Structured Exception
01849 // Handling.  This is supported by several Windows compilers but generally
01850 // does not exist on any other system.
01851 #ifndef GTEST_HAS_SEH
01852 // The user didn't tell us, so we need to figure it out.
01853 
01854 # if defined(_MSC_VER) || defined(__BORLANDC__)
01855 // These two compilers are known to support SEH.
01856 #  define GTEST_HAS_SEH 1
01857 # else
01858 // Assume no SEH.
01859 #  define GTEST_HAS_SEH 0
01860 # endif
01861 
01862 #endif  // GTEST_HAS_SEH
01863 
01864 #ifdef _MSC_VER
01865 
01866 # if GTEST_LINKED_AS_SHARED_LIBRARY
01867 #  define GTEST_API_ __declspec(dllimport)
01868 # elif GTEST_CREATE_SHARED_LIBRARY
01869 #  define GTEST_API_ __declspec(dllexport)
01870 # endif
01871 
01872 #endif  // _MSC_VER
01873 
01874 #ifndef GTEST_API_
01875 # define GTEST_API_
01876 #endif
01877 
01878 #ifdef __GNUC__
01879 // Ask the compiler to never inline a given function.
01880 # define GTEST_NO_INLINE_ __attribute__((noinline))
01881 #else
01882 # define GTEST_NO_INLINE_
01883 #endif
01884 
01885 // _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
01886 #if defined(__GLIBCXX__) || defined(_LIBCPP_VERSION)
01887 # define GTEST_HAS_CXXABI_H_ 1
01888 #else
01889 # define GTEST_HAS_CXXABI_H_ 0
01890 #endif
01891 
01892 namespace testing {
01893 
01894 class Message;
01895 
01896 namespace internal {
01897 
01898 // A secret type that Google Test users don't know about.  It has no
01899 // definition on purpose.  Therefore it's impossible to create a
01900 // Secret object, which is what we want.
01901 class Secret;
01902 
01903 // The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time
01904 // expression is true. For example, you could use it to verify the
01905 // size of a static array:
01906 //
01907 //   GTEST_COMPILE_ASSERT_(ARRAYSIZE(content_type_names) == CONTENT_NUM_TYPES,
01908 //                         content_type_names_incorrect_size);
01909 //
01910 // or to make sure a struct is smaller than a certain size:
01911 //
01912 //   GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large);
01913 //
01914 // The second argument to the macro is the name of the variable. If
01915 // the expression is false, most compilers will issue a warning/error
01916 // containing the name of the variable.
01917 
01918 template <bool>
01919 struct CompileAssert {
01920 };
01921 
01922 #define GTEST_COMPILE_ASSERT_(expr, msg) \
01923   typedef ::testing::internal::CompileAssert<(static_cast<bool>(expr))> \
01924       msg[static_cast<bool>(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_
01925 
01926 // Implementation details of GTEST_COMPILE_ASSERT_:
01927 //
01928 // - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1
01929 //   elements (and thus is invalid) when the expression is false.
01930 //
01931 // - The simpler definition
01932 //
01933 //    #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1]
01934 //
01935 //   does not work, as gcc supports variable-length arrays whose sizes
01936 //   are determined at run-time (this is gcc's extension and not part
01937 //   of the C++ standard).  As a result, gcc fails to reject the
01938 //   following code with the simple definition:
01939 //
01940 //     int foo;
01941 //     GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is
01942 //                                      // not a compile-time constant.
01943 //
01944 // - By using the type CompileAssert<(bool(expr))>, we ensures that
01945 //   expr is a compile-time constant.  (Template arguments must be
01946 //   determined at compile-time.)
01947 //
01948 // - The outter parentheses in CompileAssert<(bool(expr))> are necessary
01949 //   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
01950 //
01951 //     CompileAssert<bool(expr)>
01952 //
01953 //   instead, these compilers will refuse to compile
01954 //
01955 //     GTEST_COMPILE_ASSERT_(5 > 0, some_message);
01956 //
01957 //   (They seem to think the ">" in "5 > 0" marks the end of the
01958 //   template argument list.)
01959 //
01960 // - The array size is (bool(expr) ? 1 : -1), instead of simply
01961 //
01962 //     ((expr) ? 1 : -1).
01963 //
01964 //   This is to avoid running into a bug in MS VC 7.1, which
01965 //   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
01966 
01967 // StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h.
01968 //
01969 // This template is declared, but intentionally undefined.
01970 template <typename T1, typename T2>
01971 struct StaticAssertTypeEqHelper;
01972 
01973 template <typename T>
01974 struct StaticAssertTypeEqHelper<T, T> {};
01975 
01976 #if GTEST_HAS_GLOBAL_STRING
01977 typedef ::string string;
01978 #else
01979 typedef ::std::string string;
01980 #endif  // GTEST_HAS_GLOBAL_STRING
01981 
01982 #if GTEST_HAS_GLOBAL_WSTRING
01983 typedef ::wstring wstring;
01984 #elif GTEST_HAS_STD_WSTRING
01985 typedef ::std::wstring wstring;
01986 #endif  // GTEST_HAS_GLOBAL_WSTRING
01987 
01988 // A helper for suppressing warnings on constant condition.  It just
01989 // returns 'condition'.
01990 GTEST_API_ bool IsTrue(bool condition);
01991 
01992 // Defines scoped_ptr.
01993 
01994 // This implementation of scoped_ptr is PARTIAL - it only contains
01995 // enough stuff to satisfy Google Test's need.
01996 template <typename T>
01997 class scoped_ptr {
01998  public:
01999   typedef T element_type;
02000 
02001   explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
02002   ~scoped_ptr() { reset(); }
02003 
02004   T& operator*() const { return *ptr_; }
02005   T* operator->() const { return ptr_; }
02006   T* get() const { return ptr_; }
02007 
02008   T* release() {
02009     T* const ptr = ptr_;
02010     ptr_ = NULL;
02011     return ptr;
02012   }
02013 
02014   void reset(T* p = NULL) {
02015     if (p != ptr_) {
02016       if (IsTrue(sizeof(T) > 0)) {  // Makes sure T is a complete type.
02017         delete ptr_;
02018       }
02019       ptr_ = p;
02020     }
02021   }
02022 
02023  private:
02024   T* ptr_;
02025 
02026   GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
02027 };
02028 
02029 // Defines RE.
02030 
02031 // A simple C++ wrapper for <regex.h>.  It uses the POSIX Extended
02032 // Regular Expression syntax.
02033 class GTEST_API_ RE {
02034  public:
02035   // A copy constructor is required by the Standard to initialize object
02036   // references from r-values.
02037   RE(const RE& other) { Init(other.pattern()); }
02038 
02039   // Constructs an RE from a string.
02040   RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT
02041 
02042 #if GTEST_HAS_GLOBAL_STRING
02043 
02044   RE(const ::string& regex) { Init(regex.c_str()); }  // NOLINT
02045 
02046 #endif  // GTEST_HAS_GLOBAL_STRING
02047 
02048   RE(const char* regex) { Init(regex); }  // NOLINT
02049   ~RE();
02050 
02051   // Returns the string representation of the regex.
02052   const char* pattern() const { return pattern_; }
02053 
02054   // FullMatch(str, re) returns true iff regular expression re matches
02055   // the entire str.
02056   // PartialMatch(str, re) returns true iff regular expression re
02057   // matches a substring of str (including str itself).
02058   //
02059   // TODO(wan@google.com): make FullMatch() and PartialMatch() work
02060   // when str contains NUL characters.
02061   static bool FullMatch(const ::std::string& str, const RE& re) {
02062     return FullMatch(str.c_str(), re);
02063   }
02064   static bool PartialMatch(const ::std::string& str, const RE& re) {
02065     return PartialMatch(str.c_str(), re);
02066   }
02067 
02068 #if GTEST_HAS_GLOBAL_STRING
02069 
02070   static bool FullMatch(const ::string& str, const RE& re) {
02071     return FullMatch(str.c_str(), re);
02072   }
02073   static bool PartialMatch(const ::string& str, const RE& re) {
02074     return PartialMatch(str.c_str(), re);
02075   }
02076 
02077 #endif  // GTEST_HAS_GLOBAL_STRING
02078 
02079   static bool FullMatch(const char* str, const RE& re);
02080   static bool PartialMatch(const char* str, const RE& re);
02081 
02082  private:
02083   void Init(const char* regex);
02084 
02085   // We use a const char* instead of an std::string, as Google Test used to be
02086   // used where std::string is not available.  TODO(wan@google.com): change to
02087   // std::string.
02088   const char* pattern_;
02089   bool is_valid_;
02090 
02091 #if GTEST_USES_POSIX_RE
02092 
02093   regex_t full_regex_;     // For FullMatch().
02094   regex_t partial_regex_;  // For PartialMatch().
02095 
02096 #else  // GTEST_USES_SIMPLE_RE
02097 
02098   const char* full_pattern_;  // For FullMatch();
02099 
02100 #endif
02101 
02102   GTEST_DISALLOW_ASSIGN_(RE);
02103 };
02104 
02105 // Formats a source file path and a line number as they would appear
02106 // in an error message from the compiler used to compile this code.
02107 GTEST_API_ ::std::string FormatFileLocation(const char* file, int line);
02108 
02109 // Formats a file location for compiler-independent XML output.
02110 // Although this function is not platform dependent, we put it next to
02111 // FormatFileLocation in order to contrast the two functions.
02112 GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
02113                                                                int line);
02114 
02115 // Defines logging utilities:
02116 //   GTEST_LOG_(severity) - logs messages at the specified severity level. The
02117 //                          message itself is streamed into the macro.
02118 //   LogToStderr()  - directs all log messages to stderr.
02119 //   FlushInfoLog() - flushes informational log messages.
02120 
02121 enum GTestLogSeverity {
02122   GTEST_INFO,
02123   GTEST_WARNING,
02124   GTEST_ERROR,
02125   GTEST_FATAL
02126 };
02127 
02128 // Formats log entry severity, provides a stream object for streaming the
02129 // log message, and terminates the message with a newline when going out of
02130 // scope.
02131 class GTEST_API_ GTestLog {
02132  public:
02133   GTestLog(GTestLogSeverity severity, const char* file, int line);
02134 
02135   // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
02136   ~GTestLog();
02137 
02138   ::std::ostream& GetStream() { return ::std::cerr; }
02139 
02140  private:
02141   const GTestLogSeverity severity_;
02142 
02143   GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
02144 };
02145 
02146 #define GTEST_LOG_(severity) \
02147     ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
02148                                   __FILE__, __LINE__).GetStream()
02149 
02150 inline void LogToStderr() {}
02151 inline void FlushInfoLog() { fflush(NULL); }
02152 
02153 // INTERNAL IMPLEMENTATION - DO NOT USE.
02154 //
02155 // GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
02156 // is not satisfied.
02157 //  Synopsys:
02158 //    GTEST_CHECK_(boolean_condition);
02159 //     or
02160 //    GTEST_CHECK_(boolean_condition) << "Additional message";
02161 //
02162 //    This checks the condition and if the condition is not satisfied
02163 //    it prints message about the condition violation, including the
02164 //    condition itself, plus additional message streamed into it, if any,
02165 //    and then it aborts the program. It aborts the program irrespective of
02166 //    whether it is built in the debug mode or not.
02167 #define GTEST_CHECK_(condition) \
02168     GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
02169     if (::testing::internal::IsTrue(condition)) \
02170       ; \
02171     else \
02172       GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
02173 
02174 // An all-mode assert to verify that the given POSIX-style function
02175 // call returns 0 (indicating success).  Known limitation: this
02176 // doesn't expand to a balanced 'if' statement, so enclose the macro
02177 // in {} if you need to use it as the only statement in an 'if'
02178 // branch.
02179 #define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
02180   if (const int gtest_error = (posix_call)) \
02181     GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
02182                       << gtest_error
02183 
02184 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
02185 //
02186 // Use ImplicitCast_ as a safe version of static_cast for upcasting in
02187 // the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a
02188 // const Foo*).  When you use ImplicitCast_, the compiler checks that
02189 // the cast is safe.  Such explicit ImplicitCast_s are necessary in
02190 // surprisingly many situations where C++ demands an exact type match
02191 // instead of an argument type convertable to a target type.
02192 //
02193 // The syntax for using ImplicitCast_ is the same as for static_cast:
02194 //
02195 //   ImplicitCast_<ToType>(expr)
02196 //
02197 // ImplicitCast_ would have been part of the C++ standard library,
02198 // but the proposal was submitted too late.  It will probably make
02199 // its way into the language in the future.
02200 //
02201 // This relatively ugly name is intentional. It prevents clashes with
02202 // similar functions users may have (e.g., implicit_cast). The internal
02203 // namespace alone is not enough because the function can be found by ADL.
02204 template<typename To>
02205 inline To ImplicitCast_(To x) { return x; }
02206 
02207 // When you upcast (that is, cast a pointer from type Foo to type
02208 // SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts
02209 // always succeed.  When you downcast (that is, cast a pointer from
02210 // type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
02211 // how do you know the pointer is really of type SubclassOfFoo?  It
02212 // could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
02213 // when you downcast, you should use this macro.  In debug mode, we
02214 // use dynamic_cast<> to double-check the downcast is legal (we die
02215 // if it's not).  In normal mode, we do the efficient static_cast<>
02216 // instead.  Thus, it's important to test in debug mode to make sure
02217 // the cast is legal!
02218 //    This is the only place in the code we should use dynamic_cast<>.
02219 // In particular, you SHOULDN'T be using dynamic_cast<> in order to
02220 // do RTTI (eg code like this:
02221 //    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
02222 //    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
02223 // You should design the code some other way not to need this.
02224 //
02225 // This relatively ugly name is intentional. It prevents clashes with
02226 // similar functions users may have (e.g., down_cast). The internal
02227 // namespace alone is not enough because the function can be found by ADL.
02228 template<typename To, typename From>  // use like this: DownCast_<T*>(foo);
02229 inline To DownCast_(From* f) {  // so we only accept pointers
02230   // Ensures that To is a sub-type of From *.  This test is here only
02231   // for compile-time type checking, and has no overhead in an
02232   // optimized build at run-time, as it will be optimized away
02233   // completely.
02234   if (false) {
02235     const To to = NULL;
02236     ::testing::internal::ImplicitCast_<From*>(to);
02237   }
02238 
02239 #if GTEST_HAS_RTTI
02240   // RTTI: debug mode only!
02241   GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL);
02242 #endif
02243   return static_cast<To>(f);
02244 }
02245 
02246 // Downcasts the pointer of type Base to Derived.
02247 // Derived must be a subclass of Base. The parameter MUST
02248 // point to a class of type Derived, not any subclass of it.
02249 // When RTTI is available, the function performs a runtime
02250 // check to enforce this.
02251 template <class Derived, class Base>
02252 Derived* CheckedDowncastToActualType(Base* base) {
02253 #if GTEST_HAS_RTTI
02254   GTEST_CHECK_(typeid(*base) == typeid(Derived));
02255   return dynamic_cast<Derived*>(base);  // NOLINT
02256 #else
02257   return static_cast<Derived*>(base);  // Poor man's downcast.
02258 #endif
02259 }
02260 
02261 #if GTEST_HAS_STREAM_REDIRECTION
02262 
02263 // Defines the stderr capturer:
02264 //   CaptureStdout     - starts capturing stdout.
02265 //   GetCapturedStdout - stops capturing stdout and returns the captured string.
02266 //   CaptureStderr     - starts capturing stderr.
02267 //   GetCapturedStderr - stops capturing stderr and returns the captured string.
02268 //
02269 GTEST_API_ void CaptureStdout();
02270 GTEST_API_ std::string GetCapturedStdout();
02271 GTEST_API_ void CaptureStderr();
02272 GTEST_API_ std::string GetCapturedStderr();
02273 
02274 #endif  // GTEST_HAS_STREAM_REDIRECTION
02275 
02276 
02277 #if GTEST_HAS_DEATH_TEST
02278 
02279 const ::std::vector<testing::internal::string>& GetInjectableArgvs();
02280 void SetInjectableArgvs(const ::std::vector<testing::internal::string>*
02281                              new_argvs);
02282 
02283 // A copy of all command line arguments.  Set by InitGoogleTest().
02284 extern ::std::vector<testing::internal::string> g_argvs;
02285 
02286 #endif  // GTEST_HAS_DEATH_TEST
02287 
02288 // Defines synchronization primitives.
02289 
02290 #if GTEST_HAS_PTHREAD
02291 
02292 // Sleeps for (roughly) n milli-seconds.  This function is only for
02293 // testing Google Test's own constructs.  Don't use it in user tests,
02294 // either directly or indirectly.
02295 inline void SleepMilliseconds(int n) {
02296   const timespec time = {
02297     0,                  // 0 seconds.
02298     n * 1000L * 1000L,  // And n ms.
02299   };
02300   nanosleep(&time, NULL);
02301 }
02302 
02303 // Allows a controller thread to pause execution of newly created
02304 // threads until notified.  Instances of this class must be created
02305 // and destroyed in the controller thread.
02306 //
02307 // This class is only for testing Google Test's own constructs. Do not
02308 // use it in user tests, either directly or indirectly.
02309 class Notification {
02310  public:
02311   Notification() : notified_(false) {
02312     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
02313   }
02314   ~Notification() {
02315     pthread_mutex_destroy(&mutex_);
02316   }
02317 
02318   // Notifies all threads created with this notification to start. Must
02319   // be called from the controller thread.
02320   void Notify() {
02321     pthread_mutex_lock(&mutex_);
02322     notified_ = true;
02323     pthread_mutex_unlock(&mutex_);
02324   }
02325 
02326   // Blocks until the controller thread notifies. Must be called from a test
02327   // thread.
02328   void WaitForNotification() {
02329     for (;;) {
02330       pthread_mutex_lock(&mutex_);
02331       const bool notified = notified_;
02332       pthread_mutex_unlock(&mutex_);
02333       if (notified)
02334         break;
02335       SleepMilliseconds(10);
02336     }
02337   }
02338 
02339  private:
02340   pthread_mutex_t mutex_;
02341   bool notified_;
02342 
02343   GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
02344 };
02345 
02346 // As a C-function, ThreadFuncWithCLinkage cannot be templated itself.
02347 // Consequently, it cannot select a correct instantiation of ThreadWithParam
02348 // in order to call its Run(). Introducing ThreadWithParamBase as a
02349 // non-templated base class for ThreadWithParam allows us to bypass this
02350 // problem.
02351 class ThreadWithParamBase {
02352  public:
02353   virtual ~ThreadWithParamBase() {}
02354   virtual void Run() = 0;
02355 };
02356 
02357 // pthread_create() accepts a pointer to a function type with the C linkage.
02358 // According to the Standard (7.5/1), function types with different linkages
02359 // are different even if they are otherwise identical.  Some compilers (for
02360 // example, SunStudio) treat them as different types.  Since class methods
02361 // cannot be defined with C-linkage we need to define a free C-function to
02362 // pass into pthread_create().
02363 extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
02364   static_cast<ThreadWithParamBase*>(thread)->Run();
02365   return NULL;
02366 }
02367 
02368 // Helper class for testing Google Test's multi-threading constructs.
02369 // To use it, write:
02370 //
02371 //   void ThreadFunc(int param) { /* Do things with param */ }
02372 //   Notification thread_can_start;
02373 //   ...
02374 //   // The thread_can_start parameter is optional; you can supply NULL.
02375 //   ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start);
02376 //   thread_can_start.Notify();
02377 //
02378 // These classes are only for testing Google Test's own constructs. Do
02379 // not use them in user tests, either directly or indirectly.
02380 template <typename T>
02381 class ThreadWithParam : public ThreadWithParamBase {
02382  public:
02383   typedef void (*UserThreadFunc)(T);
02384 
02385   ThreadWithParam(
02386       UserThreadFunc func, T param, Notification* thread_can_start)
02387       : func_(func),
02388         param_(param),
02389         thread_can_start_(thread_can_start),
02390         finished_(false) {
02391     ThreadWithParamBase* const base = this;
02392     // The thread can be created only after all fields except thread_
02393     // have been initialized.
02394     GTEST_CHECK_POSIX_SUCCESS_(
02395         pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base));
02396   }
02397   ~ThreadWithParam() { Join(); }
02398 
02399   void Join() {
02400     if (!finished_) {
02401       GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0));
02402       finished_ = true;
02403     }
02404   }
02405 
02406   virtual void Run() {
02407     if (thread_can_start_ != NULL)
02408       thread_can_start_->WaitForNotification();
02409     func_(param_);
02410   }
02411 
02412  private:
02413   const UserThreadFunc func_;  // User-supplied thread function.
02414   const T param_;  // User-supplied parameter to the thread function.
02415   // When non-NULL, used to block execution until the controller thread
02416   // notifies.
02417   Notification* const thread_can_start_;
02418   bool finished_;  // true iff we know that the thread function has finished.
02419   pthread_t thread_;  // The native thread object.
02420 
02421   GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
02422 };
02423 
02424 // MutexBase and Mutex implement mutex on pthreads-based platforms. They
02425 // are used in conjunction with class MutexLock:
02426 //
02427 //   Mutex mutex;
02428 //   ...
02429 //   MutexLock lock(&mutex);  // Acquires the mutex and releases it at the end
02430 //                            // of the current scope.
02431 //
02432 // MutexBase implements behavior for both statically and dynamically
02433 // allocated mutexes.  Do not use MutexBase directly.  Instead, write
02434 // the following to define a static mutex:
02435 //
02436 //   GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);
02437 //
02438 // You can forward declare a static mutex like this:
02439 //
02440 //   GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);
02441 //
02442 // To create a dynamic mutex, just define an object of type Mutex.
02443 class MutexBase {
02444  public:
02445   // Acquires this mutex.
02446   void Lock() {
02447     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
02448     owner_ = pthread_self();
02449     has_owner_ = true;
02450   }
02451 
02452   // Releases this mutex.
02453   void Unlock() {
02454     // Since the lock is being released the owner_ field should no longer be
02455     // considered valid. We don't protect writing to has_owner_ here, as it's
02456     // the caller's responsibility to ensure that the current thread holds the
02457     // mutex when this is called.
02458     has_owner_ = false;
02459     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
02460   }
02461 
02462   // Does nothing if the current thread holds the mutex. Otherwise, crashes
02463   // with high probability.
02464   void AssertHeld() const {
02465     GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
02466         << "The current thread is not holding the mutex @" << this;
02467   }
02468 
02469   // A static mutex may be used before main() is entered.  It may even
02470   // be used before the dynamic initialization stage.  Therefore we
02471   // must be able to initialize a static mutex object at link time.
02472   // This means MutexBase has to be a POD and its member variables
02473   // have to be public.
02474  public:
02475   pthread_mutex_t mutex_;  // The underlying pthread mutex.
02476   // has_owner_ indicates whether the owner_ field below contains a valid thread
02477   // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All
02478   // accesses to the owner_ field should be protected by a check of this field.
02479   // An alternative might be to memset() owner_ to all zeros, but there's no
02480   // guarantee that a zero'd pthread_t is necessarily invalid or even different
02481   // from pthread_self().
02482   bool has_owner_;
02483   pthread_t owner_;  // The thread holding the mutex.
02484 };
02485 
02486 // Forward-declares a static mutex.
02487 # define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
02488     extern ::testing::internal::MutexBase mutex
02489 
02490 // Defines and statically (i.e. at link time) initializes a static mutex.
02491 // The initialization list here does not explicitly initialize each field,
02492 // instead relying on default initialization for the unspecified fields. In
02493 // particular, the owner_ field (a pthread_t) is not explicitly initialized.
02494 // This allows initialization to work whether pthread_t is a scalar or struct.
02495 // The flag -Wmissing-field-initializers must not be specified for this to work.
02496 # define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
02497     ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, false }
02498 
02499 // The Mutex class can only be used for mutexes created at runtime. It
02500 // shares its API with MutexBase otherwise.
02501 class Mutex : public MutexBase {
02502  public:
02503   Mutex() {
02504     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
02505     has_owner_ = false;
02506   }
02507   ~Mutex() {
02508     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
02509   }
02510 
02511  private:
02512   GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
02513 };
02514 
02515 // We cannot name this class MutexLock as the ctor declaration would
02516 // conflict with a macro named MutexLock, which is defined on some
02517 // platforms.  Hence the typedef trick below.
02518 class GTestMutexLock {
02519  public:
02520   explicit GTestMutexLock(MutexBase* mutex)
02521       : mutex_(mutex) { mutex_->Lock(); }
02522 
02523   ~GTestMutexLock() { mutex_->Unlock(); }
02524 
02525  private:
02526   MutexBase* const mutex_;
02527 
02528   GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
02529 };
02530 
02531 typedef GTestMutexLock MutexLock;
02532 
02533 // Helpers for ThreadLocal.
02534 
02535 // pthread_key_create() requires DeleteThreadLocalValue() to have
02536 // C-linkage.  Therefore it cannot be templatized to access
02537 // ThreadLocal<T>.  Hence the need for class
02538 // ThreadLocalValueHolderBase.
02539 class ThreadLocalValueHolderBase {
02540  public:
02541   virtual ~ThreadLocalValueHolderBase() {}
02542 };
02543 
02544 // Called by pthread to delete thread-local data stored by
02545 // pthread_setspecific().
02546 extern "C" inline void DeleteThreadLocalValue(void* value_holder) {
02547   delete static_cast<ThreadLocalValueHolderBase*>(value_holder);
02548 }
02549 
02550 // Implements thread-local storage on pthreads-based systems.
02551 //
02552 //   // Thread 1
02553 //   ThreadLocal<int> tl(100);  // 100 is the default value for each thread.
02554 //
02555 //   // Thread 2
02556 //   tl.set(150);  // Changes the value for thread 2 only.
02557 //   EXPECT_EQ(150, tl.get());
02558 //
02559 //   // Thread 1
02560 //   EXPECT_EQ(100, tl.get());  // In thread 1, tl has the original value.
02561 //   tl.set(200);
02562 //   EXPECT_EQ(200, tl.get());
02563 //
02564 // The template type argument T must have a public copy constructor.
02565 // In addition, the default ThreadLocal constructor requires T to have
02566 // a public default constructor.
02567 //
02568 // An object managed for a thread by a ThreadLocal instance is deleted
02569 // when the thread exits.  Or, if the ThreadLocal instance dies in
02570 // that thread, when the ThreadLocal dies.  It's the user's
02571 // responsibility to ensure that all other threads using a ThreadLocal
02572 // have exited when it dies, or the per-thread objects for those
02573 // threads will not be deleted.
02574 //
02575 // Google Test only uses global ThreadLocal objects.  That means they
02576 // will die after main() has returned.  Therefore, no per-thread
02577 // object managed by Google Test will be leaked as long as all threads
02578 // using Google Test have exited when main() returns.
02579 template <typename T>
02580 class ThreadLocal {
02581  public:
02582   ThreadLocal() : key_(CreateKey()),
02583                   default_() {}
02584   explicit ThreadLocal(const T& value) : key_(CreateKey()),
02585                                          default_(value) {}
02586 
02587   ~ThreadLocal() {
02588     // Destroys the managed object for the current thread, if any.
02589     DeleteThreadLocalValue(pthread_getspecific(key_));
02590 
02591     // Releases resources associated with the key.  This will *not*
02592     // delete managed objects for other threads.
02593     GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
02594   }
02595 
02596   T* pointer() { return GetOrCreateValue(); }
02597   const T* pointer() const { return GetOrCreateValue(); }
02598   const T& get() const { return *pointer(); }
02599   void set(const T& value) { *pointer() = value; }
02600 
02601  private:
02602   // Holds a value of type T.
02603   class ValueHolder : public ThreadLocalValueHolderBase {
02604    public:
02605     explicit ValueHolder(const T& value) : value_(value) {}
02606 
02607     T* pointer() { return &value_; }
02608 
02609    private:
02610     T value_;
02611     GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
02612   };
02613 
02614   static pthread_key_t CreateKey() {
02615     pthread_key_t key;
02616     // When a thread exits, DeleteThreadLocalValue() will be called on
02617     // the object managed for that thread.
02618     GTEST_CHECK_POSIX_SUCCESS_(
02619         pthread_key_create(&key, &DeleteThreadLocalValue));
02620     return key;
02621   }
02622 
02623   T* GetOrCreateValue() const {
02624     ThreadLocalValueHolderBase* const holder =
02625         static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
02626     if (holder != NULL) {
02627       return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
02628     }
02629 
02630     ValueHolder* const new_holder = new ValueHolder(default_);
02631     ThreadLocalValueHolderBase* const holder_base = new_holder;
02632     GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
02633     return new_holder->pointer();
02634   }
02635 
02636   // A key pthreads uses for looking up per-thread values.
02637   const pthread_key_t key_;
02638   const T default_;  // The default value for each thread.
02639 
02640   GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
02641 };
02642 
02643 # define GTEST_IS_THREADSAFE 1
02644 
02645 #else  // GTEST_HAS_PTHREAD
02646 
02647 // A dummy implementation of synchronization primitives (mutex, lock,
02648 // and thread-local variable).  Necessary for compiling Google Test where
02649 // mutex is not supported - using Google Test in multiple threads is not
02650 // supported on such platforms.
02651 
02652 class Mutex {
02653  public:
02654   Mutex() {}
02655   void Lock() {}
02656   void Unlock() {}
02657   void AssertHeld() const {}
02658 };
02659 
02660 # define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
02661   extern ::testing::internal::Mutex mutex
02662 
02663 # define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
02664 
02665 class GTestMutexLock {
02666  public:
02667   explicit GTestMutexLock(Mutex*) {}  // NOLINT
02668 };
02669 
02670 typedef GTestMutexLock MutexLock;
02671 
02672 template <typename T>
02673 class ThreadLocal {
02674  public:
02675   ThreadLocal() : value_() {}
02676   explicit ThreadLocal(const T& value) : value_(value) {}
02677   T* pointer() { return &value_; }
02678   const T* pointer() const { return &value_; }
02679   const T& get() const { return value_; }
02680   void set(const T& value) { value_ = value; }
02681  private:
02682   T value_;
02683 };
02684 
02685 // The above synchronization primitives have dummy implementations.
02686 // Therefore Google Test is not thread-safe.
02687 # define GTEST_IS_THREADSAFE 0
02688 
02689 #endif  // GTEST_HAS_PTHREAD
02690 
02691 // Returns the number of threads running in the process, or 0 to indicate that
02692 // we cannot detect it.
02693 GTEST_API_ size_t GetThreadCount();
02694 
02695 // Passing non-POD classes through ellipsis (...) crashes the ARM
02696 // compiler and generates a warning in Sun Studio.  The Nokia Symbian
02697 // and the IBM XL C/C++ compiler try to instantiate a copy constructor
02698 // for objects passed through ellipsis (...), failing for uncopyable
02699 // objects.  We define this to ensure that only POD is passed through
02700 // ellipsis on these systems.
02701 #if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC)
02702 // We lose support for NULL detection where the compiler doesn't like
02703 // passing non-POD classes through ellipsis (...).
02704 # define GTEST_ELLIPSIS_NEEDS_POD_ 1
02705 #else
02706 # define GTEST_CAN_COMPARE_NULL 1
02707 #endif
02708 
02709 // The Nokia Symbian and IBM XL C/C++ compilers cannot decide between
02710 // const T& and const T* in a function template.  These compilers
02711 // _can_ decide between class template specializations for T and T*,
02712 // so a tr1::type_traits-like is_pointer works.
02713 #if defined(__SYMBIAN32__) || defined(__IBMCPP__)
02714 # define GTEST_NEEDS_IS_POINTER_ 1
02715 #endif
02716 
02717 template <bool bool_value>
02718 struct bool_constant {
02719   typedef bool_constant<bool_value> type;
02720   static const bool value = bool_value;
02721 };
02722 template <bool bool_value> const bool bool_constant<bool_value>::value;
02723 
02724 typedef bool_constant<false> false_type;
02725 typedef bool_constant<true> true_type;
02726 
02727 template <typename T>
02728 struct is_pointer : public false_type {};
02729 
02730 template <typename T>
02731 struct is_pointer<T*> : public true_type {};
02732 
02733 template <typename Iterator>
02734 struct IteratorTraits {
02735   typedef typename Iterator::value_type value_type;
02736 };
02737 
02738 template <typename T>
02739 struct IteratorTraits<T*> {
02740   typedef T value_type;
02741 };
02742 
02743 template <typename T>
02744 struct IteratorTraits<const T*> {
02745   typedef T value_type;
02746 };
02747 
02748 #if GTEST_OS_WINDOWS
02749 # define GTEST_PATH_SEP_ "\\"
02750 # define GTEST_HAS_ALT_PATH_SEP_ 1
02751 // The biggest signed integer type the compiler supports.
02752 typedef __int64 BiggestInt;
02753 #else
02754 # define GTEST_PATH_SEP_ "/"
02755 # define GTEST_HAS_ALT_PATH_SEP_ 0
02756 typedef long long BiggestInt;  // NOLINT
02757 #endif  // GTEST_OS_WINDOWS
02758 
02759 // Utilities for char.
02760 
02761 // isspace(int ch) and friends accept an unsigned char or EOF.  char
02762 // may be signed, depending on the compiler (or compiler flags).
02763 // Therefore we need to cast a char to unsigned char before calling
02764 // isspace(), etc.
02765 
02766 inline bool IsAlpha(char ch) {
02767   return isalpha(static_cast<unsigned char>(ch)) != 0;
02768 }
02769 inline bool IsAlNum(char ch) {
02770   return isalnum(static_cast<unsigned char>(ch)) != 0;
02771 }
02772 inline bool IsDigit(char ch) {
02773   return isdigit(static_cast<unsigned char>(ch)) != 0;
02774 }
02775 inline bool IsLower(char ch) {
02776   return islower(static_cast<unsigned char>(ch)) != 0;
02777 }
02778 inline bool IsSpace(char ch) {
02779   return isspace(static_cast<unsigned char>(ch)) != 0;
02780 }
02781 inline bool IsUpper(char ch) {
02782   return isupper(static_cast<unsigned char>(ch)) != 0;
02783 }
02784 inline bool IsXDigit(char ch) {
02785   return isxdigit(static_cast<unsigned char>(ch)) != 0;
02786 }
02787 inline bool IsXDigit(wchar_t ch) {
02788   const unsigned char low_byte = static_cast<unsigned char>(ch);
02789   return ch == low_byte && isxdigit(low_byte) != 0;
02790 }
02791 
02792 inline char ToLower(char ch) {
02793   return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
02794 }
02795 inline char ToUpper(char ch) {
02796   return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
02797 }
02798 
02799 // The testing::internal::posix namespace holds wrappers for common
02800 // POSIX functions.  These wrappers hide the differences between
02801 // Windows/MSVC and POSIX systems.  Since some compilers define these
02802 // standard functions as macros, the wrapper cannot have the same name
02803 // as the wrapped function.
02804 
02805 namespace posix {
02806 
02807 // Functions with a different name on Windows.
02808 
02809 #if GTEST_OS_WINDOWS
02810 
02811 typedef struct _stat StatStruct;
02812 
02813 # ifdef __BORLANDC__
02814 inline int IsATTY(int fd) { return isatty(fd); }
02815 inline int StrCaseCmp(const char* s1, const char* s2) {
02816   return stricmp(s1, s2);
02817 }
02818 inline char* StrDup(const char* src) { return strdup(src); }
02819 # else  // !__BORLANDC__
02820 #  if GTEST_OS_WINDOWS_MOBILE
02821 inline int IsATTY(int /* fd */) { return 0; }
02822 #  else
02823 inline int IsATTY(int fd) { return _isatty(fd); }
02824 #  endif  // GTEST_OS_WINDOWS_MOBILE
02825 inline int StrCaseCmp(const char* s1, const char* s2) {
02826   return _stricmp(s1, s2);
02827 }
02828 inline char* StrDup(const char* src) { return _strdup(src); }
02829 # endif  // __BORLANDC__
02830 
02831 # if GTEST_OS_WINDOWS_MOBILE
02832 inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
02833 // Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
02834 // time and thus not defined there.
02835 # else
02836 inline int FileNo(FILE* file) { return _fileno(file); }
02837 inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
02838 inline int RmDir(const char* dir) { return _rmdir(dir); }
02839 inline bool IsDir(const StatStruct& st) {
02840   return (_S_IFDIR & st.st_mode) != 0;
02841 }
02842 # endif  // GTEST_OS_WINDOWS_MOBILE
02843 
02844 #else
02845 
02846 typedef struct stat StatStruct;
02847 
02848 inline int FileNo(FILE* file) { return fileno(file); }
02849 inline int IsATTY(int fd) { return isatty(fd); }
02850 inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
02851 inline int StrCaseCmp(const char* s1, const char* s2) {
02852   return strcasecmp(s1, s2);
02853 }
02854 inline char* StrDup(const char* src) { return strdup(src); }
02855 inline int RmDir(const char* dir) { return rmdir(dir); }
02856 inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
02857 
02858 #endif  // GTEST_OS_WINDOWS
02859 
02860 // Functions deprecated by MSVC 8.0.
02861 
02862 #ifdef _MSC_VER
02863 // Temporarily disable warning 4996 (deprecated function).
02864 # pragma warning(push)
02865 # pragma warning(disable:4996)
02866 #endif
02867 
02868 inline const char* StrNCpy(char* dest, const char* src, size_t n) {
02869   return strncpy(dest, src, n);
02870 }
02871 
02872 // ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and
02873 // StrError() aren't needed on Windows CE at this time and thus not
02874 // defined there.
02875 
02876 #if !GTEST_OS_WINDOWS_MOBILE
02877 inline int ChDir(const char* dir) { return chdir(dir); }
02878 #endif
02879 inline FILE* FOpen(const char* path, const char* mode) {
02880   return fopen(path, mode);
02881 }
02882 #if !GTEST_OS_WINDOWS_MOBILE
02883 inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
02884   return freopen(path, mode, stream);
02885 }
02886 inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
02887 #endif
02888 inline int FClose(FILE* fp) { return fclose(fp); }
02889 #if !GTEST_OS_WINDOWS_MOBILE
02890 inline int Read(int fd, void* buf, unsigned int count) {
02891   return static_cast<int>(read(fd, buf, count));
02892 }
02893 inline int Write(int fd, const void* buf, unsigned int count) {
02894   return static_cast<int>(write(fd, buf, count));
02895 }
02896 inline int Close(int fd) { return close(fd); }
02897 inline const char* StrError(int errnum) { return strerror(errnum); }
02898 #endif
02899 inline const char* GetEnv(const char* name) {
02900 #if GTEST_OS_WINDOWS_MOBILE
02901   // We are on Windows CE, which has no environment variables.
02902   return NULL;
02903 #elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
02904   // Environment variables which we programmatically clear will be set to the
02905   // empty string rather than unset (NULL).  Handle that case.
02906   const char* const env = getenv(name);
02907   return (env != NULL && env[0] != '\0') ? env : NULL;
02908 #else
02909   return getenv(name);
02910 #endif
02911 }
02912 
02913 #ifdef _MSC_VER
02914 # pragma warning(pop)  // Restores the warning state.
02915 #endif
02916 
02917 #if GTEST_OS_WINDOWS_MOBILE
02918 // Windows CE has no C library. The abort() function is used in
02919 // several places in Google Test. This implementation provides a reasonable
02920 // imitation of standard behaviour.
02921 void Abort();
02922 #else
02923 inline void Abort() { abort(); }
02924 #endif  // GTEST_OS_WINDOWS_MOBILE
02925 
02926 }  // namespace posix
02927 
02928 // MSVC "deprecates" snprintf and issues warnings wherever it is used.  In
02929 // order to avoid these warnings, we need to use _snprintf or _snprintf_s on
02930 // MSVC-based platforms.  We map the GTEST_SNPRINTF_ macro to the appropriate
02931 // function in order to achieve that.  We use macro definition here because
02932 // snprintf is a variadic function.
02933 #if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE
02934 // MSVC 2005 and above support variadic macros.
02935 # define GTEST_SNPRINTF_(buffer, size, format, ...) \
02936      _snprintf_s(buffer, size, size, format, __VA_ARGS__)
02937 #elif defined(_MSC_VER)
02938 // Windows CE does not define _snprintf_s and MSVC prior to 2005 doesn't
02939 // complain about _snprintf.
02940 # define GTEST_SNPRINTF_ _snprintf
02941 #else
02942 # define GTEST_SNPRINTF_ snprintf
02943 #endif
02944 
02945 // The maximum number a BiggestInt can represent.  This definition
02946 // works no matter BiggestInt is represented in one's complement or
02947 // two's complement.
02948 //
02949 // We cannot rely on numeric_limits in STL, as __int64 and long long
02950 // are not part of standard C++ and numeric_limits doesn't need to be
02951 // defined for them.
02952 const BiggestInt kMaxBiggestInt =
02953     ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1));
02954 
02955 // This template class serves as a compile-time function from size to
02956 // type.  It maps a size in bytes to a primitive type with that
02957 // size. e.g.
02958 //
02959 //   TypeWithSize<4>::UInt
02960 //
02961 // is typedef-ed to be unsigned int (unsigned integer made up of 4
02962 // bytes).
02963 //
02964 // Such functionality should belong to STL, but I cannot find it
02965 // there.
02966 //
02967 // Google Test uses this class in the implementation of floating-point
02968 // comparison.
02969 //
02970 // For now it only handles UInt (unsigned int) as that's all Google Test
02971 // needs.  Other types can be easily added in the future if need
02972 // arises.
02973 template <size_t size>
02974 class TypeWithSize {
02975  public:
02976   // This prevents the user from using TypeWithSize<N> with incorrect
02977   // values of N.
02978   typedef void UInt;
02979 };
02980 
02981 // The specialization for size 4.
02982 template <>
02983 class TypeWithSize<4> {
02984  public:
02985   // unsigned int has size 4 in both gcc and MSVC.
02986   //
02987   // As base/basictypes.h doesn't compile on Windows, we cannot use
02988   // uint32, uint64, and etc here.
02989   typedef int Int;
02990   typedef unsigned int UInt;
02991 };
02992 
02993 // The specialization for size 8.
02994 template <>
02995 class TypeWithSize<8> {
02996  public:
02997 #if GTEST_OS_WINDOWS
02998   typedef __int64 Int;
02999   typedef unsigned __int64 UInt;
03000 #else
03001   typedef long long Int;  // NOLINT
03002   typedef unsigned long long UInt;  // NOLINT
03003 #endif  // GTEST_OS_WINDOWS
03004 };
03005 
03006 // Integer types of known sizes.
03007 typedef TypeWithSize<4>::Int Int32;
03008 typedef TypeWithSize<4>::UInt UInt32;
03009 typedef TypeWithSize<8>::Int Int64;
03010 typedef TypeWithSize<8>::UInt UInt64;
03011 typedef TypeWithSize<8>::Int TimeInMillis;  // Represents time in milliseconds.
03012 
03013 // Utilities for command line flags and environment variables.
03014 
03015 // Macro for referencing flags.
03016 #define GTEST_FLAG(name) FLAGS_gtest_##name
03017 
03018 // Macros for declaring flags.
03019 #define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
03020 #define GTEST_DECLARE_int32_(name) \
03021     GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name)
03022 #define GTEST_DECLARE_string_(name) \
03023     GTEST_API_ extern ::std::string GTEST_FLAG(name)
03024 
03025 // Macros for defining flags.
03026 #define GTEST_DEFINE_bool_(name, default_val, doc) \
03027     GTEST_API_ bool GTEST_FLAG(name) = (default_val)
03028 #define GTEST_DEFINE_int32_(name, default_val, doc) \
03029     GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
03030 #define GTEST_DEFINE_string_(name, default_val, doc) \
03031     GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)
03032 
03033 // Thread annotations
03034 #define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
03035 #define GTEST_LOCK_EXCLUDED_(locks)
03036 
03037 // Parses 'str' for a 32-bit signed integer.  If successful, writes the result
03038 // to *value and returns true; otherwise leaves *value unchanged and returns
03039 // false.
03040 // TODO(chandlerc): Find a better way to refactor flag and environment parsing
03041 // out of both gtest-port.cc and gtest.cc to avoid exporting this utility
03042 // function.
03043 bool ParseInt32(const Message& src_text, const char* str, Int32* value);
03044 
03045 // Parses a bool/Int32/string from the environment variable
03046 // corresponding to the given Google Test flag.
03047 bool BoolFromGTestEnv(const char* flag, bool default_val);
03048 GTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val);
03049 const char* StringFromGTestEnv(const char* flag, const char* default_val);
03050 
03051 }  // namespace internal
03052 }  // namespace testing
03053 
03054 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
03055 
03056 #if GTEST_OS_LINUX
03057 # include <stdlib.h>
03058 # include <sys/types.h>
03059 # include <sys/wait.h>
03060 # include <unistd.h>
03061 #endif  // GTEST_OS_LINUX
03062 
03063 #if GTEST_HAS_EXCEPTIONS
03064 # include <stdexcept>
03065 #endif
03066 
03067 #include <ctype.h>
03068 #include <float.h>
03069 #include <string.h>
03070 #include <iomanip>
03071 #include <limits>
03072 #include <set>
03073 
03074 // Copyright 2005, Google Inc.
03075 // All rights reserved.
03076 //
03077 // Redistribution and use in source and binary forms, with or without
03078 // modification, are permitted provided that the following conditions are
03079 // met:
03080 //
03081 //     * Redistributions of source code must retain the above copyright
03082 // notice, this list of conditions and the following disclaimer.
03083 //     * Redistributions in binary form must reproduce the above
03084 // copyright notice, this list of conditions and the following disclaimer
03085 // in the documentation and/or other materials provided with the
03086 // distribution.
03087 //     * Neither the name of Google Inc. nor the names of its
03088 // contributors may be used to endorse or promote products derived from
03089 // this software without specific prior written permission.
03090 //
03091 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
03092 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
03093 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
03094 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
03095 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
03096 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
03097 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
03098 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
03099 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
03100 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
03101 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
03102 //
03103 // Author: wan@google.com (Zhanyong Wan)
03104 //
03105 // The Google C++ Testing Framework (Google Test)
03106 //
03107 // This header file defines the Message class.
03108 //
03109 // IMPORTANT NOTE: Due to limitation of the C++ language, we have to
03110 // leave some internal implementation details in this header file.
03111 // They are clearly marked by comments like this:
03112 //
03113 //   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
03114 //
03115 // Such code is NOT meant to be used by a user directly, and is subject
03116 // to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
03117 // program!
03118 
03119 #ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
03120 #define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
03121 
03122 #include <limits>
03123 
03124 
03125 // Ensures that there is at least one operator<< in the global namespace.
03126 // See Message& operator<<(...) below for why.
03127 void operator<<(const testing::internal::Secret&, int);
03128 
03129 namespace testing {
03130 
03131 // The Message class works like an ostream repeater.
03132 //
03133 // Typical usage:
03134 //
03135 //   1. You stream a bunch of values to a Message object.
03136 //      It will remember the text in a stringstream.
03137 //   2. Then you stream the Message object to an ostream.
03138 //      This causes the text in the Message to be streamed
03139 //      to the ostream.
03140 //
03141 // For example;
03142 //
03143 //   testing::Message foo;
03144 //   foo << 1 << " != " << 2;
03145 //   std::cout << foo;
03146 //
03147 // will print "1 != 2".
03148 //
03149 // Message is not intended to be inherited from.  In particular, its
03150 // destructor is not virtual.
03151 //
03152 // Note that stringstream behaves differently in gcc and in MSVC.  You
03153 // can stream a NULL char pointer to it in the former, but not in the
03154 // latter (it causes an access violation if you do).  The Message
03155 // class hides this difference by treating a NULL char pointer as
03156 // "(null)".
03157 class GTEST_API_ Message {
03158  private:
03159   // The type of basic IO manipulators (endl, ends, and flush) for
03160   // narrow streams.
03161   typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
03162 
03163  public:
03164   // Constructs an empty Message.
03165   Message();
03166 
03167   // Copy constructor.
03168   Message(const Message& msg) : ss_(new ::std::stringstream) {  // NOLINT
03169     *ss_ << msg.GetString();
03170   }
03171 
03172   // Constructs a Message from a C-string.
03173   explicit Message(const char* str) : ss_(new ::std::stringstream) {
03174     *ss_ << str;
03175   }
03176 
03177 #if GTEST_OS_SYMBIAN
03178   // Streams a value (either a pointer or not) to this object.
03179   template <typename T>
03180   inline Message& operator <<(const T& value) {
03181     StreamHelper(typename internal::is_pointer<T>::type(), value);
03182     return *this;
03183   }
03184 #else
03185   // Streams a non-pointer value to this object.
03186   template <typename T>
03187   inline Message& operator <<(const T& val) {
03188     // Some libraries overload << for STL containers.  These
03189     // overloads are defined in the global namespace instead of ::std.
03190     //
03191     // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
03192     // overloads are visible in either the std namespace or the global
03193     // namespace, but not other namespaces, including the testing
03194     // namespace which Google Test's Message class is in.
03195     //
03196     // To allow STL containers (and other types that has a << operator
03197     // defined in the global namespace) to be used in Google Test
03198     // assertions, testing::Message must access the custom << operator
03199     // from the global namespace.  With this using declaration,
03200     // overloads of << defined in the global namespace and those
03201     // visible via Koenig lookup are both exposed in this function.
03202     using ::operator <<;
03203     *ss_ << val;
03204     return *this;
03205   }
03206 
03207   // Streams a pointer value to this object.
03208   //
03209   // This function is an overload of the previous one.  When you
03210   // stream a pointer to a Message, this definition will be used as it
03211   // is more specialized.  (The C++ Standard, section
03212   // [temp.func.order].)  If you stream a non-pointer, then the
03213   // previous definition will be used.
03214   //
03215   // The reason for this overload is that streaming a NULL pointer to
03216   // ostream is undefined behavior.  Depending on the compiler, you
03217   // may get "0", "(nil)", "(null)", or an access violation.  To
03218   // ensure consistent result across compilers, we always treat NULL
03219   // as "(null)".
03220   template <typename T>
03221   inline Message& operator <<(T* const& pointer) {  // NOLINT
03222     if (pointer == NULL) {
03223       *ss_ << "(null)";
03224     } else {
03225       *ss_ << pointer;
03226     }
03227     return *this;
03228   }
03229 #endif  // GTEST_OS_SYMBIAN
03230 
03231   // Since the basic IO manipulators are overloaded for both narrow
03232   // and wide streams, we have to provide this specialized definition
03233   // of operator <<, even though its body is the same as the
03234   // templatized version above.  Without this definition, streaming
03235   // endl or other basic IO manipulators to Message will confuse the
03236   // compiler.
03237   Message& operator <<(BasicNarrowIoManip val) {
03238     *ss_ << val;
03239     return *this;
03240   }
03241 
03242   // Instead of 1/0, we want to see true/false for bool values.
03243   Message& operator <<(bool b) {
03244     return *this << (b ? "true" : "false");
03245   }
03246 
03247   // These two overloads allow streaming a wide C string to a Message
03248   // using the UTF-8 encoding.
03249   Message& operator <<(const wchar_t* wide_c_str);
03250   Message& operator <<(wchar_t* wide_c_str);
03251 
03252 #if GTEST_HAS_STD_WSTRING
03253   // Converts the given wide string to a narrow string using the UTF-8
03254   // encoding, and streams the result to this Message object.
03255   Message& operator <<(const ::std::wstring& wstr);
03256 #endif  // GTEST_HAS_STD_WSTRING
03257 
03258 #if GTEST_HAS_GLOBAL_WSTRING
03259   // Converts the given wide string to a narrow string using the UTF-8
03260   // encoding, and streams the result to this Message object.
03261   Message& operator <<(const ::wstring& wstr);
03262 #endif  // GTEST_HAS_GLOBAL_WSTRING
03263 
03264   // Gets the text streamed to this object so far as an std::string.
03265   // Each '\0' character in the buffer is replaced with "\\0".
03266   //
03267   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
03268   std::string GetString() const;
03269 
03270  private:
03271 
03272 #if GTEST_OS_SYMBIAN
03273   // These are needed as the Nokia Symbian Compiler cannot decide between
03274   // const T& and const T* in a function template. The Nokia compiler _can_
03275   // decide between class template specializations for T and T*, so a
03276   // tr1::type_traits-like is_pointer works, and we can overload on that.
03277   template <typename T>
03278   inline void StreamHelper(internal::true_type /*is_pointer*/, T* pointer) {
03279     if (pointer == NULL) {
03280       *ss_ << "(null)";
03281     } else {
03282       *ss_ << pointer;
03283     }
03284   }
03285   template <typename T>
03286   inline void StreamHelper(internal::false_type /*is_pointer*/,
03287                            const T& value) {
03288     // See the comments in Message& operator <<(const T&) above for why
03289     // we need this using statement.
03290     using ::operator <<;
03291     *ss_ << value;
03292   }
03293 #endif  // GTEST_OS_SYMBIAN
03294 
03295   // We'll hold the text streamed to this object here.
03296   const internal::scoped_ptr< ::std::stringstream> ss_;
03297 
03298   // We declare (but don't implement) this to prevent the compiler
03299   // from implementing the assignment operator.
03300   void operator=(const Message&);
03301 };
03302 
03303 // Streams a Message to an ostream.
03304 inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
03305   return os << sb.GetString();
03306 }
03307 
03308 namespace internal {
03309 
03310 // Converts a streamable value to an std::string.  A NULL pointer is
03311 // converted to "(null)".  When the input value is a ::string,
03312 // ::std::string, ::wstring, or ::std::wstring object, each NUL
03313 // character in it is replaced with "\\0".
03314 template <typename T>
03315 std::string StreamableToString(const T& streamable) {
03316   return (Message() << streamable).GetString();
03317 }
03318 
03319 }  // namespace internal
03320 }  // namespace testing
03321 
03322 #endif  // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
03323 // Copyright 2005, Google Inc.
03324 // All rights reserved.
03325 //
03326 // Redistribution and use in source and binary forms, with or without
03327 // modification, are permitted provided that the following conditions are
03328 // met:
03329 //
03330 //     * Redistributions of source code must retain the above copyright
03331 // notice, this list of conditions and the following disclaimer.
03332 //     * Redistributions in binary form must reproduce the above
03333 // copyright notice, this list of conditions and the following disclaimer
03334 // in the documentation and/or other materials provided with the
03335 // distribution.
03336 //     * Neither the name of Google Inc. nor the names of its
03337 // contributors may be used to endorse or promote products derived from
03338 // this software without specific prior written permission.
03339 //
03340 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
03341 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
03342 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
03343 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
03344 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
03345 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
03346 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
03347 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
03348 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
03349 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
03350 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
03351 //
03352 // Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
03353 //
03354 // The Google C++ Testing Framework (Google Test)
03355 //
03356 // This header file declares the String class and functions used internally by
03357 // Google Test.  They are subject to change without notice. They should not used
03358 // by code external to Google Test.
03359 //
03360 // This header file is #included by <gtest/internal/gtest-internal.h>.
03361 // It should not be #included by other files.
03362 
03363 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
03364 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
03365 
03366 #ifdef __BORLANDC__
03367 // string.h is not guaranteed to provide strcpy on C++ Builder.
03368 # include <mem.h>
03369 #endif
03370 
03371 #include <string.h>
03372 #include <string>
03373 
03374 
03375 namespace testing {
03376 namespace internal {
03377 
03378 // String - an abstract class holding static string utilities.
03379 class GTEST_API_ String {
03380  public:
03381   // Static utility methods
03382 
03383   // Clones a 0-terminated C string, allocating memory using new.  The
03384   // caller is responsible for deleting the return value using
03385   // delete[].  Returns the cloned string, or NULL if the input is
03386   // NULL.
03387   //
03388   // This is different from strdup() in string.h, which allocates
03389   // memory using malloc().
03390   static const char* CloneCString(const char* c_str);
03391 
03392 #if GTEST_OS_WINDOWS_MOBILE
03393   // Windows CE does not have the 'ANSI' versions of Win32 APIs. To be
03394   // able to pass strings to Win32 APIs on CE we need to convert them
03395   // to 'Unicode', UTF-16.
03396 
03397   // Creates a UTF-16 wide string from the given ANSI string, allocating
03398   // memory using new. The caller is responsible for deleting the return
03399   // value using delete[]. Returns the wide string, or NULL if the
03400   // input is NULL.
03401   //
03402   // The wide string is created using the ANSI codepage (CP_ACP) to
03403   // match the behaviour of the ANSI versions of Win32 calls and the
03404   // C runtime.
03405   static LPCWSTR AnsiToUtf16(const char* c_str);
03406 
03407   // Creates an ANSI string from the given wide string, allocating
03408   // memory using new. The caller is responsible for deleting the return
03409   // value using delete[]. Returns the ANSI string, or NULL if the
03410   // input is NULL.
03411   //
03412   // The returned string is created using the ANSI codepage (CP_ACP) to
03413   // match the behaviour of the ANSI versions of Win32 calls and the
03414   // C runtime.
03415   static const char* Utf16ToAnsi(LPCWSTR utf16_str);
03416 #endif
03417 
03418   // Compares two C strings.  Returns true iff they have the same content.
03419   //
03420   // Unlike strcmp(), this function can handle NULL argument(s).  A
03421   // NULL C string is considered different to any non-NULL C string,
03422   // including the empty string.
03423   static bool CStringEquals(const char* lhs, const char* rhs);
03424 
03425   // Converts a wide C string to a String using the UTF-8 encoding.
03426   // NULL will be converted to "(null)".  If an error occurred during
03427   // the conversion, "(failed to convert from wide string)" is
03428   // returned.
03429   static std::string ShowWideCString(const wchar_t* wide_c_str);
03430 
03431   // Compares two wide C strings.  Returns true iff they have the same
03432   // content.
03433   //
03434   // Unlike wcscmp(), this function can handle NULL argument(s).  A
03435   // NULL C string is considered different to any non-NULL C string,
03436   // including the empty string.
03437   static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs);
03438 
03439   // Compares two C strings, ignoring case.  Returns true iff they
03440   // have the same content.
03441   //
03442   // Unlike strcasecmp(), this function can handle NULL argument(s).
03443   // A NULL C string is considered different to any non-NULL C string,
03444   // including the empty string.
03445   static bool CaseInsensitiveCStringEquals(const char* lhs,
03446                                            const char* rhs);
03447 
03448   // Compares two wide C strings, ignoring case.  Returns true iff they
03449   // have the same content.
03450   //
03451   // Unlike wcscasecmp(), this function can handle NULL argument(s).
03452   // A NULL C string is considered different to any non-NULL wide C string,
03453   // including the empty string.
03454   // NB: The implementations on different platforms slightly differ.
03455   // On windows, this method uses _wcsicmp which compares according to LC_CTYPE
03456   // environment variable. On GNU platform this method uses wcscasecmp
03457   // which compares according to LC_CTYPE category of the current locale.
03458   // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
03459   // current locale.
03460   static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
03461                                                const wchar_t* rhs);
03462 
03463   // Returns true iff the given string ends with the given suffix, ignoring
03464   // case. Any string is considered to end with an empty suffix.
03465   static bool EndsWithCaseInsensitive(
03466       const std::string& str, const std::string& suffix);
03467 
03468   // Formats an int value as "%02d".
03469   static std::string FormatIntWidth2(int value);  // "%02d" for width == 2
03470 
03471   // Formats an int value as "%X".
03472   static std::string FormatHexInt(int value);
03473 
03474   // Formats a byte as "%02X".
03475   static std::string FormatByte(unsigned char value);
03476 
03477  private:
03478   String();  // Not meant to be instantiated.
03479 };  // class String
03480 
03481 // Gets the content of the stringstream's buffer as an std::string.  Each '\0'
03482 // character in the buffer is replaced with "\\0".
03483 GTEST_API_ std::string StringStreamToString(::std::stringstream* stream);
03484 
03485 }  // namespace internal
03486 }  // namespace testing
03487 
03488 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
03489 // Copyright 2008, Google Inc.
03490 // All rights reserved.
03491 //
03492 // Redistribution and use in source and binary forms, with or without
03493 // modification, are permitted provided that the following conditions are
03494 // met:
03495 //
03496 //     * Redistributions of source code must retain the above copyright
03497 // notice, this list of conditions and the following disclaimer.
03498 //     * Redistributions in binary form must reproduce the above
03499 // copyright notice, this list of conditions and the following disclaimer
03500 // in the documentation and/or other materials provided with the
03501 // distribution.
03502 //     * Neither the name of Google Inc. nor the names of its
03503 // contributors may be used to endorse or promote products derived from
03504 // this software without specific prior written permission.
03505 //
03506 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
03507 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
03508 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
03509 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
03510 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
03511 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
03512 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
03513 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
03514 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
03515 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
03516 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
03517 //
03518 // Author: keith.ray@gmail.com (Keith Ray)
03519 //
03520 // Google Test filepath utilities
03521 //
03522 // This header file declares classes and functions used internally by
03523 // Google Test.  They are subject to change without notice.
03524 //
03525 // This file is #included in <gtest/internal/gtest-internal.h>.
03526 // Do not include this header file separately!
03527 
03528 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
03529 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
03530 
03531 
03532 namespace testing {
03533 namespace internal {
03534 
03535 // FilePath - a class for file and directory pathname manipulation which
03536 // handles platform-specific conventions (like the pathname separator).
03537 // Used for helper functions for naming files in a directory for xml output.
03538 // Except for Set methods, all methods are const or static, which provides an
03539 // "immutable value object" -- useful for peace of mind.
03540 // A FilePath with a value ending in a path separator ("like/this/") represents
03541 // a directory, otherwise it is assumed to represent a file. In either case,
03542 // it may or may not represent an actual file or directory in the file system.
03543 // Names are NOT checked for syntax correctness -- no checking for illegal
03544 // characters, malformed paths, etc.
03545 
03546 class GTEST_API_ FilePath {
03547  public:
03548   FilePath() : pathname_("") { }
03549   FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
03550 
03551   explicit FilePath(const std::string& pathname) : pathname_(pathname) {
03552     Normalize();
03553   }
03554 
03555   FilePath& operator=(const FilePath& rhs) {
03556     Set(rhs);
03557     return *this;
03558   }
03559 
03560   void Set(const FilePath& rhs) {
03561     pathname_ = rhs.pathname_;
03562   }
03563 
03564   const std::string& string() const { return pathname_; }
03565   const char* c_str() const { return pathname_.c_str(); }
03566 
03567   // Returns the current working directory, or "" if unsuccessful.
03568   static FilePath GetCurrentDir();
03569 
03570   // Given directory = "dir", base_name = "test", number = 0,
03571   // extension = "xml", returns "dir/test.xml". If number is greater
03572   // than zero (e.g., 12), returns "dir/test_12.xml".
03573   // On Windows platform, uses \ as the separator rather than /.
03574   static FilePath MakeFileName(const FilePath& directory,
03575                                const FilePath& base_name,
03576                                int number,
03577                                const char* extension);
03578 
03579   // Given directory = "dir", relative_path = "test.xml",
03580   // returns "dir/test.xml".
03581   // On Windows, uses \ as the separator rather than /.
03582   static FilePath ConcatPaths(const FilePath& directory,
03583                               const FilePath& relative_path);
03584 
03585   // Returns a pathname for a file that does not currently exist. The pathname
03586   // will be directory/base_name.extension or
03587   // directory/base_name_<number>.extension if directory/base_name.extension
03588   // already exists. The number will be incremented until a pathname is found
03589   // that does not already exist.
03590   // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
03591   // There could be a race condition if two or more processes are calling this
03592   // function at the same time -- they could both pick the same filename.
03593   static FilePath GenerateUniqueFileName(const FilePath& directory,
03594                                          const FilePath& base_name,
03595                                          const char* extension);
03596 
03597   // Returns true iff the path is "".
03598   bool IsEmpty() const { return pathname_.empty(); }
03599 
03600   // If input name has a trailing separator character, removes it and returns
03601   // the name, otherwise return the name string unmodified.
03602   // On Windows platform, uses \ as the separator, other platforms use /.
03603   FilePath RemoveTrailingPathSeparator() const;
03604 
03605   // Returns a copy of the FilePath with the directory part removed.
03606   // Example: FilePath("path/to/file").RemoveDirectoryName() returns
03607   // FilePath("file"). If there is no directory part ("just_a_file"), it returns
03608   // the FilePath unmodified. If there is no file part ("just_a_dir/") it
03609   // returns an empty FilePath ("").
03610   // On Windows platform, '\' is the path separator, otherwise it is '/'.
03611   FilePath RemoveDirectoryName() const;
03612 
03613   // RemoveFileName returns the directory path with the filename removed.
03614   // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
03615   // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
03616   // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
03617   // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
03618   // On Windows platform, '\' is the path separator, otherwise it is '/'.
03619   FilePath RemoveFileName() const;
03620 
03621   // Returns a copy of the FilePath with the case-insensitive extension removed.
03622   // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
03623   // FilePath("dir/file"). If a case-insensitive extension is not
03624   // found, returns a copy of the original FilePath.
03625   FilePath RemoveExtension(const char* extension) const;
03626 
03627   // Creates directories so that path exists. Returns true if successful or if
03628   // the directories already exist; returns false if unable to create
03629   // directories for any reason. Will also return false if the FilePath does
03630   // not represent a directory (that is, it doesn't end with a path separator).
03631   bool CreateDirectoriesRecursively() const;
03632 
03633   // Create the directory so that path exists. Returns true if successful or
03634   // if the directory already exists; returns false if unable to create the
03635   // directory for any reason, including if the parent directory does not
03636   // exist. Not named "CreateDirectory" because that's a macro on Windows.
03637   bool CreateFolder() const;
03638 
03639   // Returns true if FilePath describes something in the file-system,
03640   // either a file, directory, or whatever, and that something exists.
03641   bool FileOrDirectoryExists() const;
03642 
03643   // Returns true if pathname describes a directory in the file-system
03644   // that exists.
03645   bool DirectoryExists() const;
03646 
03647   // Returns true if FilePath ends with a path separator, which indicates that
03648   // it is intended to represent a directory. Returns false otherwise.
03649   // This does NOT check that a directory (or file) actually exists.
03650   bool IsDirectory() const;
03651 
03652   // Returns true if pathname describes a root directory. (Windows has one
03653   // root directory per disk drive.)
03654   bool IsRootDirectory() const;
03655 
03656   // Returns true if pathname describes an absolute path.
03657   bool IsAbsolutePath() const;
03658 
03659  private:
03660   // Replaces multiple consecutive separators with a single separator.
03661   // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
03662   // redundancies that might be in a pathname involving "." or "..".
03663   //
03664   // A pathname with multiple consecutive separators may occur either through
03665   // user error or as a result of some scripts or APIs that generate a pathname
03666   // with a trailing separator. On other platforms the same API or script
03667   // may NOT generate a pathname with a trailing "/". Then elsewhere that
03668   // pathname may have another "/" and pathname components added to it,
03669   // without checking for the separator already being there.
03670   // The script language and operating system may allow paths like "foo//bar"
03671   // but some of the functions in FilePath will not handle that correctly. In
03672   // particular, RemoveTrailingPathSeparator() only removes one separator, and
03673   // it is called in CreateDirectoriesRecursively() assuming that it will change
03674   // a pathname from directory syntax (trailing separator) to filename syntax.
03675   //
03676   // On Windows this method also replaces the alternate path separator '/' with
03677   // the primary path separator '\\', so that for example "bar\\/\\foo" becomes
03678   // "bar\\foo".
03679 
03680   void Normalize();
03681 
03682   // Returns a pointer to the last occurence of a valid path separator in
03683   // the FilePath. On Windows, for example, both '/' and '\' are valid path
03684   // separators. Returns NULL if no path separator was found.
03685   const char* FindLastPathSeparator() const;
03686 
03687   std::string pathname_;
03688 };  // class FilePath
03689 
03690 }  // namespace internal
03691 }  // namespace testing
03692 
03693 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
03694 // This file was GENERATED by command:
03695 //     pump.py gtest-type-util.h.pump
03696 // DO NOT EDIT BY HAND!!!
03697 
03698 // Copyright 2008 Google Inc.
03699 // All Rights Reserved.
03700 //
03701 // Redistribution and use in source and binary forms, with or without
03702 // modification, are permitted provided that the following conditions are
03703 // met:
03704 //
03705 //     * Redistributions of source code must retain the above copyright
03706 // notice, this list of conditions and the following disclaimer.
03707 //     * Redistributions in binary form must reproduce the above
03708 // copyright notice, this list of conditions and the following disclaimer
03709 // in the documentation and/or other materials provided with the
03710 // distribution.
03711 //     * Neither the name of Google Inc. nor the names of its
03712 // contributors may be used to endorse or promote products derived from
03713 // this software without specific prior written permission.
03714 //
03715 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
03716 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
03717 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
03718 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
03719 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
03720 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
03721 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
03722 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
03723 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
03724 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
03725 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
03726 //
03727 // Author: wan@google.com (Zhanyong Wan)
03728 
03729 // Type utilities needed for implementing typed and type-parameterized
03730 // tests.  This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
03731 //
03732 // Currently we support at most 50 types in a list, and at most 50
03733 // type-parameterized tests in one type-parameterized test case.
03734 // Please contact googletestframework@googlegroups.com if you need
03735 // more.
03736 
03737 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
03738 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
03739 
03740 
03741 // #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
03742 // libstdc++ (which is where cxxabi.h comes from).
03743 # if GTEST_HAS_CXXABI_H_
03744 #  include <cxxabi.h>
03745 # elif defined(__HP_aCC)
03746 #  include <acxx_demangle.h>
03747 # endif  // GTEST_HASH_CXXABI_H_
03748 
03749 namespace testing {
03750 namespace internal {
03751 
03752 // GetTypeName<T>() returns a human-readable name of type T.
03753 // NB: This function is also used in Google Mock, so don't move it inside of
03754 // the typed-test-only section below.
03755 template <typename T>
03756 std::string GetTypeName() {
03757 # if GTEST_HAS_RTTI
03758 
03759   const char* const name = typeid(T).name();
03760 #  if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC)
03761   int status = 0;
03762   // gcc's implementation of typeid(T).name() mangles the type name,
03763   // so we have to demangle it.
03764 #   if GTEST_HAS_CXXABI_H_
03765   using abi::__cxa_demangle;
03766 #   endif  // GTEST_HAS_CXXABI_H_
03767   char* const readable_name = __cxa_demangle(name, 0, 0, &status);
03768   const std::string name_str(status == 0 ? readable_name : name);
03769   free(readable_name);
03770   return name_str;
03771 #  else
03772   return name;
03773 #  endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
03774 
03775 # else
03776 
03777   return "<type>";
03778 
03779 # endif  // GTEST_HAS_RTTI
03780 }
03781 
03782 #if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
03783 
03784 // AssertyTypeEq<T1, T2>::type is defined iff T1 and T2 are the same
03785 // type.  This can be used as a compile-time assertion to ensure that
03786 // two types are equal.
03787 
03788 template <typename T1, typename T2>
03789 struct AssertTypeEq;
03790 
03791 template <typename T>
03792 struct AssertTypeEq<T, T> {
03793   typedef bool type;
03794 };
03795 
03796 // A unique type used as the default value for the arguments of class
03797 // template Types.  This allows us to simulate variadic templates
03798 // (e.g. Types<int>, Type<int, double>, and etc), which C++ doesn't
03799 // support directly.
03800 struct None {};
03801 
03802 // The following family of struct and struct templates are used to
03803 // represent type lists.  In particular, TypesN<T1, T2, ..., TN>
03804 // represents a type list with N types (T1, T2, ..., and TN) in it.
03805 // Except for Types0, every struct in the family has two member types:
03806 // Head for the first type in the list, and Tail for the rest of the
03807 // list.
03808 
03809 // The empty type list.
03810 struct Types0 {};
03811 
03812 // Type lists of length 1, 2, 3, and so on.
03813 
03814 template <typename T1>
03815 struct Types1 {
03816   typedef T1 Head;
03817   typedef Types0 Tail;
03818 };
03819 template <typename T1, typename T2>
03820 struct Types2 {
03821   typedef T1 Head;
03822   typedef Types1<T2> Tail;
03823 };
03824 
03825 template <typename T1, typename T2, typename T3>
03826 struct Types3 {
03827   typedef T1 Head;
03828   typedef Types2<T2, T3> Tail;
03829 };
03830 
03831 template <typename T1, typename T2, typename T3, typename T4>
03832 struct Types4 {
03833   typedef T1 Head;
03834   typedef Types3<T2, T3, T4> Tail;
03835 };
03836 
03837 template <typename T1, typename T2, typename T3, typename T4, typename T5>
03838 struct Types5 {
03839   typedef T1 Head;
03840   typedef Types4<T2, T3, T4, T5> Tail;
03841 };
03842 
03843 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03844     typename T6>
03845 struct Types6 {
03846   typedef T1 Head;
03847   typedef Types5<T2, T3, T4, T5, T6> Tail;
03848 };
03849 
03850 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03851     typename T6, typename T7>
03852 struct Types7 {
03853   typedef T1 Head;
03854   typedef Types6<T2, T3, T4, T5, T6, T7> Tail;
03855 };
03856 
03857 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03858     typename T6, typename T7, typename T8>
03859 struct Types8 {
03860   typedef T1 Head;
03861   typedef Types7<T2, T3, T4, T5, T6, T7, T8> Tail;
03862 };
03863 
03864 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03865     typename T6, typename T7, typename T8, typename T9>
03866 struct Types9 {
03867   typedef T1 Head;
03868   typedef Types8<T2, T3, T4, T5, T6, T7, T8, T9> Tail;
03869 };
03870 
03871 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03872     typename T6, typename T7, typename T8, typename T9, typename T10>
03873 struct Types10 {
03874   typedef T1 Head;
03875   typedef Types9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail;
03876 };
03877 
03878 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03879     typename T6, typename T7, typename T8, typename T9, typename T10,
03880     typename T11>
03881 struct Types11 {
03882   typedef T1 Head;
03883   typedef Types10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail;
03884 };
03885 
03886 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03887     typename T6, typename T7, typename T8, typename T9, typename T10,
03888     typename T11, typename T12>
03889 struct Types12 {
03890   typedef T1 Head;
03891   typedef Types11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail;
03892 };
03893 
03894 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03895     typename T6, typename T7, typename T8, typename T9, typename T10,
03896     typename T11, typename T12, typename T13>
03897 struct Types13 {
03898   typedef T1 Head;
03899   typedef Types12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Tail;
03900 };
03901 
03902 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03903     typename T6, typename T7, typename T8, typename T9, typename T10,
03904     typename T11, typename T12, typename T13, typename T14>
03905 struct Types14 {
03906   typedef T1 Head;
03907   typedef Types13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Tail;
03908 };
03909 
03910 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03911     typename T6, typename T7, typename T8, typename T9, typename T10,
03912     typename T11, typename T12, typename T13, typename T14, typename T15>
03913 struct Types15 {
03914   typedef T1 Head;
03915   typedef Types14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
03916       T15> Tail;
03917 };
03918 
03919 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03920     typename T6, typename T7, typename T8, typename T9, typename T10,
03921     typename T11, typename T12, typename T13, typename T14, typename T15,
03922     typename T16>
03923 struct Types16 {
03924   typedef T1 Head;
03925   typedef Types15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
03926       T16> Tail;
03927 };
03928 
03929 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03930     typename T6, typename T7, typename T8, typename T9, typename T10,
03931     typename T11, typename T12, typename T13, typename T14, typename T15,
03932     typename T16, typename T17>
03933 struct Types17 {
03934   typedef T1 Head;
03935   typedef Types16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
03936       T16, T17> Tail;
03937 };
03938 
03939 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03940     typename T6, typename T7, typename T8, typename T9, typename T10,
03941     typename T11, typename T12, typename T13, typename T14, typename T15,
03942     typename T16, typename T17, typename T18>
03943 struct Types18 {
03944   typedef T1 Head;
03945   typedef Types17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
03946       T16, T17, T18> Tail;
03947 };
03948 
03949 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03950     typename T6, typename T7, typename T8, typename T9, typename T10,
03951     typename T11, typename T12, typename T13, typename T14, typename T15,
03952     typename T16, typename T17, typename T18, typename T19>
03953 struct Types19 {
03954   typedef T1 Head;
03955   typedef Types18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
03956       T16, T17, T18, T19> Tail;
03957 };
03958 
03959 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03960     typename T6, typename T7, typename T8, typename T9, typename T10,
03961     typename T11, typename T12, typename T13, typename T14, typename T15,
03962     typename T16, typename T17, typename T18, typename T19, typename T20>
03963 struct Types20 {
03964   typedef T1 Head;
03965   typedef Types19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
03966       T16, T17, T18, T19, T20> Tail;
03967 };
03968 
03969 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03970     typename T6, typename T7, typename T8, typename T9, typename T10,
03971     typename T11, typename T12, typename T13, typename T14, typename T15,
03972     typename T16, typename T17, typename T18, typename T19, typename T20,
03973     typename T21>
03974 struct Types21 {
03975   typedef T1 Head;
03976   typedef Types20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
03977       T16, T17, T18, T19, T20, T21> Tail;
03978 };
03979 
03980 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03981     typename T6, typename T7, typename T8, typename T9, typename T10,
03982     typename T11, typename T12, typename T13, typename T14, typename T15,
03983     typename T16, typename T17, typename T18, typename T19, typename T20,
03984     typename T21, typename T22>
03985 struct Types22 {
03986   typedef T1 Head;
03987   typedef Types21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
03988       T16, T17, T18, T19, T20, T21, T22> Tail;
03989 };
03990 
03991 template <typename T1, typename T2, typename T3, typename T4, typename T5,
03992     typename T6, typename T7, typename T8, typename T9, typename T10,
03993     typename T11, typename T12, typename T13, typename T14, typename T15,
03994     typename T16, typename T17, typename T18, typename T19, typename T20,
03995     typename T21, typename T22, typename T23>
03996 struct Types23 {
03997   typedef T1 Head;
03998   typedef Types22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
03999       T16, T17, T18, T19, T20, T21, T22, T23> Tail;
04000 };
04001 
04002 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04003     typename T6, typename T7, typename T8, typename T9, typename T10,
04004     typename T11, typename T12, typename T13, typename T14, typename T15,
04005     typename T16, typename T17, typename T18, typename T19, typename T20,
04006     typename T21, typename T22, typename T23, typename T24>
04007 struct Types24 {
04008   typedef T1 Head;
04009   typedef Types23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04010       T16, T17, T18, T19, T20, T21, T22, T23, T24> Tail;
04011 };
04012 
04013 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04014     typename T6, typename T7, typename T8, typename T9, typename T10,
04015     typename T11, typename T12, typename T13, typename T14, typename T15,
04016     typename T16, typename T17, typename T18, typename T19, typename T20,
04017     typename T21, typename T22, typename T23, typename T24, typename T25>
04018 struct Types25 {
04019   typedef T1 Head;
04020   typedef Types24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04021       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Tail;
04022 };
04023 
04024 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04025     typename T6, typename T7, typename T8, typename T9, typename T10,
04026     typename T11, typename T12, typename T13, typename T14, typename T15,
04027     typename T16, typename T17, typename T18, typename T19, typename T20,
04028     typename T21, typename T22, typename T23, typename T24, typename T25,
04029     typename T26>
04030 struct Types26 {
04031   typedef T1 Head;
04032   typedef Types25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04033       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Tail;
04034 };
04035 
04036 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04037     typename T6, typename T7, typename T8, typename T9, typename T10,
04038     typename T11, typename T12, typename T13, typename T14, typename T15,
04039     typename T16, typename T17, typename T18, typename T19, typename T20,
04040     typename T21, typename T22, typename T23, typename T24, typename T25,
04041     typename T26, typename T27>
04042 struct Types27 {
04043   typedef T1 Head;
04044   typedef Types26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04045       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> Tail;
04046 };
04047 
04048 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04049     typename T6, typename T7, typename T8, typename T9, typename T10,
04050     typename T11, typename T12, typename T13, typename T14, typename T15,
04051     typename T16, typename T17, typename T18, typename T19, typename T20,
04052     typename T21, typename T22, typename T23, typename T24, typename T25,
04053     typename T26, typename T27, typename T28>
04054 struct Types28 {
04055   typedef T1 Head;
04056   typedef Types27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04057       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28> Tail;
04058 };
04059 
04060 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04061     typename T6, typename T7, typename T8, typename T9, typename T10,
04062     typename T11, typename T12, typename T13, typename T14, typename T15,
04063     typename T16, typename T17, typename T18, typename T19, typename T20,
04064     typename T21, typename T22, typename T23, typename T24, typename T25,
04065     typename T26, typename T27, typename T28, typename T29>
04066 struct Types29 {
04067   typedef T1 Head;
04068   typedef Types28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04069       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
04070       T29> Tail;
04071 };
04072 
04073 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04074     typename T6, typename T7, typename T8, typename T9, typename T10,
04075     typename T11, typename T12, typename T13, typename T14, typename T15,
04076     typename T16, typename T17, typename T18, typename T19, typename T20,
04077     typename T21, typename T22, typename T23, typename T24, typename T25,
04078     typename T26, typename T27, typename T28, typename T29, typename T30>
04079 struct Types30 {
04080   typedef T1 Head;
04081   typedef Types29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04082       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04083       T30> Tail;
04084 };
04085 
04086 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04087     typename T6, typename T7, typename T8, typename T9, typename T10,
04088     typename T11, typename T12, typename T13, typename T14, typename T15,
04089     typename T16, typename T17, typename T18, typename T19, typename T20,
04090     typename T21, typename T22, typename T23, typename T24, typename T25,
04091     typename T26, typename T27, typename T28, typename T29, typename T30,
04092     typename T31>
04093 struct Types31 {
04094   typedef T1 Head;
04095   typedef Types30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04096       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04097       T30, T31> Tail;
04098 };
04099 
04100 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04101     typename T6, typename T7, typename T8, typename T9, typename T10,
04102     typename T11, typename T12, typename T13, typename T14, typename T15,
04103     typename T16, typename T17, typename T18, typename T19, typename T20,
04104     typename T21, typename T22, typename T23, typename T24, typename T25,
04105     typename T26, typename T27, typename T28, typename T29, typename T30,
04106     typename T31, typename T32>
04107 struct Types32 {
04108   typedef T1 Head;
04109   typedef Types31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04110       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04111       T30, T31, T32> Tail;
04112 };
04113 
04114 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04115     typename T6, typename T7, typename T8, typename T9, typename T10,
04116     typename T11, typename T12, typename T13, typename T14, typename T15,
04117     typename T16, typename T17, typename T18, typename T19, typename T20,
04118     typename T21, typename T22, typename T23, typename T24, typename T25,
04119     typename T26, typename T27, typename T28, typename T29, typename T30,
04120     typename T31, typename T32, typename T33>
04121 struct Types33 {
04122   typedef T1 Head;
04123   typedef Types32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04124       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04125       T30, T31, T32, T33> Tail;
04126 };
04127 
04128 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04129     typename T6, typename T7, typename T8, typename T9, typename T10,
04130     typename T11, typename T12, typename T13, typename T14, typename T15,
04131     typename T16, typename T17, typename T18, typename T19, typename T20,
04132     typename T21, typename T22, typename T23, typename T24, typename T25,
04133     typename T26, typename T27, typename T28, typename T29, typename T30,
04134     typename T31, typename T32, typename T33, typename T34>
04135 struct Types34 {
04136   typedef T1 Head;
04137   typedef Types33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04138       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04139       T30, T31, T32, T33, T34> Tail;
04140 };
04141 
04142 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04143     typename T6, typename T7, typename T8, typename T9, typename T10,
04144     typename T11, typename T12, typename T13, typename T14, typename T15,
04145     typename T16, typename T17, typename T18, typename T19, typename T20,
04146     typename T21, typename T22, typename T23, typename T24, typename T25,
04147     typename T26, typename T27, typename T28, typename T29, typename T30,
04148     typename T31, typename T32, typename T33, typename T34, typename T35>
04149 struct Types35 {
04150   typedef T1 Head;
04151   typedef Types34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04152       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04153       T30, T31, T32, T33, T34, T35> Tail;
04154 };
04155 
04156 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04157     typename T6, typename T7, typename T8, typename T9, typename T10,
04158     typename T11, typename T12, typename T13, typename T14, typename T15,
04159     typename T16, typename T17, typename T18, typename T19, typename T20,
04160     typename T21, typename T22, typename T23, typename T24, typename T25,
04161     typename T26, typename T27, typename T28, typename T29, typename T30,
04162     typename T31, typename T32, typename T33, typename T34, typename T35,
04163     typename T36>
04164 struct Types36 {
04165   typedef T1 Head;
04166   typedef Types35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04167       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04168       T30, T31, T32, T33, T34, T35, T36> Tail;
04169 };
04170 
04171 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04172     typename T6, typename T7, typename T8, typename T9, typename T10,
04173     typename T11, typename T12, typename T13, typename T14, typename T15,
04174     typename T16, typename T17, typename T18, typename T19, typename T20,
04175     typename T21, typename T22, typename T23, typename T24, typename T25,
04176     typename T26, typename T27, typename T28, typename T29, typename T30,
04177     typename T31, typename T32, typename T33, typename T34, typename T35,
04178     typename T36, typename T37>
04179 struct Types37 {
04180   typedef T1 Head;
04181   typedef Types36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04182       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04183       T30, T31, T32, T33, T34, T35, T36, T37> Tail;
04184 };
04185 
04186 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04187     typename T6, typename T7, typename T8, typename T9, typename T10,
04188     typename T11, typename T12, typename T13, typename T14, typename T15,
04189     typename T16, typename T17, typename T18, typename T19, typename T20,
04190     typename T21, typename T22, typename T23, typename T24, typename T25,
04191     typename T26, typename T27, typename T28, typename T29, typename T30,
04192     typename T31, typename T32, typename T33, typename T34, typename T35,
04193     typename T36, typename T37, typename T38>
04194 struct Types38 {
04195   typedef T1 Head;
04196   typedef Types37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04197       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04198       T30, T31, T32, T33, T34, T35, T36, T37, T38> Tail;
04199 };
04200 
04201 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04202     typename T6, typename T7, typename T8, typename T9, typename T10,
04203     typename T11, typename T12, typename T13, typename T14, typename T15,
04204     typename T16, typename T17, typename T18, typename T19, typename T20,
04205     typename T21, typename T22, typename T23, typename T24, typename T25,
04206     typename T26, typename T27, typename T28, typename T29, typename T30,
04207     typename T31, typename T32, typename T33, typename T34, typename T35,
04208     typename T36, typename T37, typename T38, typename T39>
04209 struct Types39 {
04210   typedef T1 Head;
04211   typedef Types38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04212       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04213       T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Tail;
04214 };
04215 
04216 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04217     typename T6, typename T7, typename T8, typename T9, typename T10,
04218     typename T11, typename T12, typename T13, typename T14, typename T15,
04219     typename T16, typename T17, typename T18, typename T19, typename T20,
04220     typename T21, typename T22, typename T23, typename T24, typename T25,
04221     typename T26, typename T27, typename T28, typename T29, typename T30,
04222     typename T31, typename T32, typename T33, typename T34, typename T35,
04223     typename T36, typename T37, typename T38, typename T39, typename T40>
04224 struct Types40 {
04225   typedef T1 Head;
04226   typedef Types39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04227       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04228       T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Tail;
04229 };
04230 
04231 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04232     typename T6, typename T7, typename T8, typename T9, typename T10,
04233     typename T11, typename T12, typename T13, typename T14, typename T15,
04234     typename T16, typename T17, typename T18, typename T19, typename T20,
04235     typename T21, typename T22, typename T23, typename T24, typename T25,
04236     typename T26, typename T27, typename T28, typename T29, typename T30,
04237     typename T31, typename T32, typename T33, typename T34, typename T35,
04238     typename T36, typename T37, typename T38, typename T39, typename T40,
04239     typename T41>
04240 struct Types41 {
04241   typedef T1 Head;
04242   typedef Types40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04243       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04244       T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41> Tail;
04245 };
04246 
04247 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04248     typename T6, typename T7, typename T8, typename T9, typename T10,
04249     typename T11, typename T12, typename T13, typename T14, typename T15,
04250     typename T16, typename T17, typename T18, typename T19, typename T20,
04251     typename T21, typename T22, typename T23, typename T24, typename T25,
04252     typename T26, typename T27, typename T28, typename T29, typename T30,
04253     typename T31, typename T32, typename T33, typename T34, typename T35,
04254     typename T36, typename T37, typename T38, typename T39, typename T40,
04255     typename T41, typename T42>
04256 struct Types42 {
04257   typedef T1 Head;
04258   typedef Types41<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04259       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04260       T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42> Tail;
04261 };
04262 
04263 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04264     typename T6, typename T7, typename T8, typename T9, typename T10,
04265     typename T11, typename T12, typename T13, typename T14, typename T15,
04266     typename T16, typename T17, typename T18, typename T19, typename T20,
04267     typename T21, typename T22, typename T23, typename T24, typename T25,
04268     typename T26, typename T27, typename T28, typename T29, typename T30,
04269     typename T31, typename T32, typename T33, typename T34, typename T35,
04270     typename T36, typename T37, typename T38, typename T39, typename T40,
04271     typename T41, typename T42, typename T43>
04272 struct Types43 {
04273   typedef T1 Head;
04274   typedef Types42<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04275       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04276       T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
04277       T43> Tail;
04278 };
04279 
04280 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04281     typename T6, typename T7, typename T8, typename T9, typename T10,
04282     typename T11, typename T12, typename T13, typename T14, typename T15,
04283     typename T16, typename T17, typename T18, typename T19, typename T20,
04284     typename T21, typename T22, typename T23, typename T24, typename T25,
04285     typename T26, typename T27, typename T28, typename T29, typename T30,
04286     typename T31, typename T32, typename T33, typename T34, typename T35,
04287     typename T36, typename T37, typename T38, typename T39, typename T40,
04288     typename T41, typename T42, typename T43, typename T44>
04289 struct Types44 {
04290   typedef T1 Head;
04291   typedef Types43<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04292       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04293       T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
04294       T44> Tail;
04295 };
04296 
04297 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04298     typename T6, typename T7, typename T8, typename T9, typename T10,
04299     typename T11, typename T12, typename T13, typename T14, typename T15,
04300     typename T16, typename T17, typename T18, typename T19, typename T20,
04301     typename T21, typename T22, typename T23, typename T24, typename T25,
04302     typename T26, typename T27, typename T28, typename T29, typename T30,
04303     typename T31, typename T32, typename T33, typename T34, typename T35,
04304     typename T36, typename T37, typename T38, typename T39, typename T40,
04305     typename T41, typename T42, typename T43, typename T44, typename T45>
04306 struct Types45 {
04307   typedef T1 Head;
04308   typedef Types44<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04309       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04310       T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
04311       T44, T45> Tail;
04312 };
04313 
04314 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04315     typename T6, typename T7, typename T8, typename T9, typename T10,
04316     typename T11, typename T12, typename T13, typename T14, typename T15,
04317     typename T16, typename T17, typename T18, typename T19, typename T20,
04318     typename T21, typename T22, typename T23, typename T24, typename T25,
04319     typename T26, typename T27, typename T28, typename T29, typename T30,
04320     typename T31, typename T32, typename T33, typename T34, typename T35,
04321     typename T36, typename T37, typename T38, typename T39, typename T40,
04322     typename T41, typename T42, typename T43, typename T44, typename T45,
04323     typename T46>
04324 struct Types46 {
04325   typedef T1 Head;
04326   typedef Types45<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04327       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04328       T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
04329       T44, T45, T46> Tail;
04330 };
04331 
04332 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04333     typename T6, typename T7, typename T8, typename T9, typename T10,
04334     typename T11, typename T12, typename T13, typename T14, typename T15,
04335     typename T16, typename T17, typename T18, typename T19, typename T20,
04336     typename T21, typename T22, typename T23, typename T24, typename T25,
04337     typename T26, typename T27, typename T28, typename T29, typename T30,
04338     typename T31, typename T32, typename T33, typename T34, typename T35,
04339     typename T36, typename T37, typename T38, typename T39, typename T40,
04340     typename T41, typename T42, typename T43, typename T44, typename T45,
04341     typename T46, typename T47>
04342 struct Types47 {
04343   typedef T1 Head;
04344   typedef Types46<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04345       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04346       T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
04347       T44, T45, T46, T47> Tail;
04348 };
04349 
04350 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04351     typename T6, typename T7, typename T8, typename T9, typename T10,
04352     typename T11, typename T12, typename T13, typename T14, typename T15,
04353     typename T16, typename T17, typename T18, typename T19, typename T20,
04354     typename T21, typename T22, typename T23, typename T24, typename T25,
04355     typename T26, typename T27, typename T28, typename T29, typename T30,
04356     typename T31, typename T32, typename T33, typename T34, typename T35,
04357     typename T36, typename T37, typename T38, typename T39, typename T40,
04358     typename T41, typename T42, typename T43, typename T44, typename T45,
04359     typename T46, typename T47, typename T48>
04360 struct Types48 {
04361   typedef T1 Head;
04362   typedef Types47<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04363       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04364       T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
04365       T44, T45, T46, T47, T48> Tail;
04366 };
04367 
04368 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04369     typename T6, typename T7, typename T8, typename T9, typename T10,
04370     typename T11, typename T12, typename T13, typename T14, typename T15,
04371     typename T16, typename T17, typename T18, typename T19, typename T20,
04372     typename T21, typename T22, typename T23, typename T24, typename T25,
04373     typename T26, typename T27, typename T28, typename T29, typename T30,
04374     typename T31, typename T32, typename T33, typename T34, typename T35,
04375     typename T36, typename T37, typename T38, typename T39, typename T40,
04376     typename T41, typename T42, typename T43, typename T44, typename T45,
04377     typename T46, typename T47, typename T48, typename T49>
04378 struct Types49 {
04379   typedef T1 Head;
04380   typedef Types48<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04381       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04382       T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
04383       T44, T45, T46, T47, T48, T49> Tail;
04384 };
04385 
04386 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04387     typename T6, typename T7, typename T8, typename T9, typename T10,
04388     typename T11, typename T12, typename T13, typename T14, typename T15,
04389     typename T16, typename T17, typename T18, typename T19, typename T20,
04390     typename T21, typename T22, typename T23, typename T24, typename T25,
04391     typename T26, typename T27, typename T28, typename T29, typename T30,
04392     typename T31, typename T32, typename T33, typename T34, typename T35,
04393     typename T36, typename T37, typename T38, typename T39, typename T40,
04394     typename T41, typename T42, typename T43, typename T44, typename T45,
04395     typename T46, typename T47, typename T48, typename T49, typename T50>
04396 struct Types50 {
04397   typedef T1 Head;
04398   typedef Types49<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04399       T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04400       T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
04401       T44, T45, T46, T47, T48, T49, T50> Tail;
04402 };
04403 
04404 
04405 }  // namespace internal
04406 
04407 // We don't want to require the users to write TypesN<...> directly,
04408 // as that would require them to count the length.  Types<...> is much
04409 // easier to write, but generates horrible messages when there is a
04410 // compiler error, as gcc insists on printing out each template
04411 // argument, even if it has the default value (this means Types<int>
04412 // will appear as Types<int, None, None, ..., None> in the compiler
04413 // errors).
04414 //
04415 // Our solution is to combine the best part of the two approaches: a
04416 // user would write Types<T1, ..., TN>, and Google Test will translate
04417 // that to TypesN<T1, ..., TN> internally to make error messages
04418 // readable.  The translation is done by the 'type' member of the
04419 // Types template.
04420 template <typename T1 = internal::None, typename T2 = internal::None,
04421     typename T3 = internal::None, typename T4 = internal::None,
04422     typename T5 = internal::None, typename T6 = internal::None,
04423     typename T7 = internal::None, typename T8 = internal::None,
04424     typename T9 = internal::None, typename T10 = internal::None,
04425     typename T11 = internal::None, typename T12 = internal::None,
04426     typename T13 = internal::None, typename T14 = internal::None,
04427     typename T15 = internal::None, typename T16 = internal::None,
04428     typename T17 = internal::None, typename T18 = internal::None,
04429     typename T19 = internal::None, typename T20 = internal::None,
04430     typename T21 = internal::None, typename T22 = internal::None,
04431     typename T23 = internal::None, typename T24 = internal::None,
04432     typename T25 = internal::None, typename T26 = internal::None,
04433     typename T27 = internal::None, typename T28 = internal::None,
04434     typename T29 = internal::None, typename T30 = internal::None,
04435     typename T31 = internal::None, typename T32 = internal::None,
04436     typename T33 = internal::None, typename T34 = internal::None,
04437     typename T35 = internal::None, typename T36 = internal::None,
04438     typename T37 = internal::None, typename T38 = internal::None,
04439     typename T39 = internal::None, typename T40 = internal::None,
04440     typename T41 = internal::None, typename T42 = internal::None,
04441     typename T43 = internal::None, typename T44 = internal::None,
04442     typename T45 = internal::None, typename T46 = internal::None,
04443     typename T47 = internal::None, typename T48 = internal::None,
04444     typename T49 = internal::None, typename T50 = internal::None>
04445 struct Types {
04446   typedef internal::Types50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04447       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
04448       T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
04449       T41, T42, T43, T44, T45, T46, T47, T48, T49, T50> type;
04450 };
04451 
04452 template <>
04453 struct Types<internal::None, internal::None, internal::None, internal::None,
04454     internal::None, internal::None, internal::None, internal::None,
04455     internal::None, internal::None, internal::None, internal::None,
04456     internal::None, internal::None, internal::None, internal::None,
04457     internal::None, internal::None, internal::None, internal::None,
04458     internal::None, internal::None, internal::None, internal::None,
04459     internal::None, internal::None, internal::None, internal::None,
04460     internal::None, internal::None, internal::None, internal::None,
04461     internal::None, internal::None, internal::None, internal::None,
04462     internal::None, internal::None, internal::None, internal::None,
04463     internal::None, internal::None, internal::None, internal::None,
04464     internal::None, internal::None, internal::None, internal::None,
04465     internal::None, internal::None> {
04466   typedef internal::Types0 type;
04467 };
04468 template <typename T1>
04469 struct Types<T1, internal::None, internal::None, internal::None,
04470     internal::None, internal::None, internal::None, internal::None,
04471     internal::None, internal::None, internal::None, internal::None,
04472     internal::None, internal::None, internal::None, internal::None,
04473     internal::None, internal::None, internal::None, internal::None,
04474     internal::None, internal::None, internal::None, internal::None,
04475     internal::None, internal::None, internal::None, internal::None,
04476     internal::None, internal::None, internal::None, internal::None,
04477     internal::None, internal::None, internal::None, internal::None,
04478     internal::None, internal::None, internal::None, internal::None,
04479     internal::None, internal::None, internal::None, internal::None,
04480     internal::None, internal::None, internal::None, internal::None,
04481     internal::None, internal::None> {
04482   typedef internal::Types1<T1> type;
04483 };
04484 template <typename T1, typename T2>
04485 struct Types<T1, T2, internal::None, internal::None, internal::None,
04486     internal::None, internal::None, internal::None, internal::None,
04487     internal::None, internal::None, internal::None, internal::None,
04488     internal::None, internal::None, internal::None, internal::None,
04489     internal::None, internal::None, internal::None, internal::None,
04490     internal::None, internal::None, internal::None, internal::None,
04491     internal::None, internal::None, internal::None, internal::None,
04492     internal::None, internal::None, internal::None, internal::None,
04493     internal::None, internal::None, internal::None, internal::None,
04494     internal::None, internal::None, internal::None, internal::None,
04495     internal::None, internal::None, internal::None, internal::None,
04496     internal::None, internal::None, internal::None, internal::None,
04497     internal::None> {
04498   typedef internal::Types2<T1, T2> type;
04499 };
04500 template <typename T1, typename T2, typename T3>
04501 struct Types<T1, T2, T3, internal::None, internal::None, internal::None,
04502     internal::None, internal::None, internal::None, internal::None,
04503     internal::None, internal::None, internal::None, internal::None,
04504     internal::None, internal::None, internal::None, internal::None,
04505     internal::None, internal::None, internal::None, internal::None,
04506     internal::None, internal::None, internal::None, internal::None,
04507     internal::None, internal::None, internal::None, internal::None,
04508     internal::None, internal::None, internal::None, internal::None,
04509     internal::None, internal::None, internal::None, internal::None,
04510     internal::None, internal::None, internal::None, internal::None,
04511     internal::None, internal::None, internal::None, internal::None,
04512     internal::None, internal::None, internal::None, internal::None> {
04513   typedef internal::Types3<T1, T2, T3> type;
04514 };
04515 template <typename T1, typename T2, typename T3, typename T4>
04516 struct Types<T1, T2, T3, T4, internal::None, internal::None, internal::None,
04517     internal::None, internal::None, internal::None, internal::None,
04518     internal::None, internal::None, internal::None, internal::None,
04519     internal::None, internal::None, internal::None, internal::None,
04520     internal::None, internal::None, internal::None, internal::None,
04521     internal::None, internal::None, internal::None, internal::None,
04522     internal::None, internal::None, internal::None, internal::None,
04523     internal::None, internal::None, internal::None, internal::None,
04524     internal::None, internal::None, internal::None, internal::None,
04525     internal::None, internal::None, internal::None, internal::None,
04526     internal::None, internal::None, internal::None, internal::None,
04527     internal::None, internal::None, internal::None> {
04528   typedef internal::Types4<T1, T2, T3, T4> type;
04529 };
04530 template <typename T1, typename T2, typename T3, typename T4, typename T5>
04531 struct Types<T1, T2, T3, T4, T5, internal::None, internal::None,
04532     internal::None, internal::None, internal::None, internal::None,
04533     internal::None, internal::None, internal::None, internal::None,
04534     internal::None, internal::None, internal::None, internal::None,
04535     internal::None, internal::None, internal::None, internal::None,
04536     internal::None, internal::None, internal::None, internal::None,
04537     internal::None, internal::None, internal::None, internal::None,
04538     internal::None, internal::None, internal::None, internal::None,
04539     internal::None, internal::None, internal::None, internal::None,
04540     internal::None, internal::None, internal::None, internal::None,
04541     internal::None, internal::None, internal::None, internal::None,
04542     internal::None, internal::None, internal::None> {
04543   typedef internal::Types5<T1, T2, T3, T4, T5> type;
04544 };
04545 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04546     typename T6>
04547 struct Types<T1, T2, T3, T4, T5, T6, internal::None, internal::None,
04548     internal::None, internal::None, internal::None, internal::None,
04549     internal::None, internal::None, internal::None, internal::None,
04550     internal::None, internal::None, internal::None, internal::None,
04551     internal::None, internal::None, internal::None, internal::None,
04552     internal::None, internal::None, internal::None, internal::None,
04553     internal::None, internal::None, internal::None, internal::None,
04554     internal::None, internal::None, internal::None, internal::None,
04555     internal::None, internal::None, internal::None, internal::None,
04556     internal::None, internal::None, internal::None, internal::None,
04557     internal::None, internal::None, internal::None, internal::None,
04558     internal::None, internal::None> {
04559   typedef internal::Types6<T1, T2, T3, T4, T5, T6> type;
04560 };
04561 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04562     typename T6, typename T7>
04563 struct Types<T1, T2, T3, T4, T5, T6, T7, internal::None, internal::None,
04564     internal::None, internal::None, internal::None, internal::None,
04565     internal::None, internal::None, internal::None, internal::None,
04566     internal::None, internal::None, internal::None, internal::None,
04567     internal::None, internal::None, internal::None, internal::None,
04568     internal::None, internal::None, internal::None, internal::None,
04569     internal::None, internal::None, internal::None, internal::None,
04570     internal::None, internal::None, internal::None, internal::None,
04571     internal::None, internal::None, internal::None, internal::None,
04572     internal::None, internal::None, internal::None, internal::None,
04573     internal::None, internal::None, internal::None, internal::None,
04574     internal::None> {
04575   typedef internal::Types7<T1, T2, T3, T4, T5, T6, T7> type;
04576 };
04577 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04578     typename T6, typename T7, typename T8>
04579 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, internal::None, internal::None,
04580     internal::None, internal::None, internal::None, internal::None,
04581     internal::None, internal::None, internal::None, internal::None,
04582     internal::None, internal::None, internal::None, internal::None,
04583     internal::None, internal::None, internal::None, internal::None,
04584     internal::None, internal::None, internal::None, internal::None,
04585     internal::None, internal::None, internal::None, internal::None,
04586     internal::None, internal::None, internal::None, internal::None,
04587     internal::None, internal::None, internal::None, internal::None,
04588     internal::None, internal::None, internal::None, internal::None,
04589     internal::None, internal::None, internal::None, internal::None> {
04590   typedef internal::Types8<T1, T2, T3, T4, T5, T6, T7, T8> type;
04591 };
04592 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04593     typename T6, typename T7, typename T8, typename T9>
04594 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, internal::None,
04595     internal::None, internal::None, internal::None, internal::None,
04596     internal::None, internal::None, internal::None, internal::None,
04597     internal::None, internal::None, internal::None, internal::None,
04598     internal::None, internal::None, internal::None, internal::None,
04599     internal::None, internal::None, internal::None, internal::None,
04600     internal::None, internal::None, internal::None, internal::None,
04601     internal::None, internal::None, internal::None, internal::None,
04602     internal::None, internal::None, internal::None, internal::None,
04603     internal::None, internal::None, internal::None, internal::None,
04604     internal::None, internal::None, internal::None, internal::None> {
04605   typedef internal::Types9<T1, T2, T3, T4, T5, T6, T7, T8, T9> type;
04606 };
04607 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04608     typename T6, typename T7, typename T8, typename T9, typename T10>
04609 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, internal::None,
04610     internal::None, internal::None, internal::None, internal::None,
04611     internal::None, internal::None, internal::None, internal::None,
04612     internal::None, internal::None, internal::None, internal::None,
04613     internal::None, internal::None, internal::None, internal::None,
04614     internal::None, internal::None, internal::None, internal::None,
04615     internal::None, internal::None, internal::None, internal::None,
04616     internal::None, internal::None, internal::None, internal::None,
04617     internal::None, internal::None, internal::None, internal::None,
04618     internal::None, internal::None, internal::None, internal::None,
04619     internal::None, internal::None, internal::None> {
04620   typedef internal::Types10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> type;
04621 };
04622 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04623     typename T6, typename T7, typename T8, typename T9, typename T10,
04624     typename T11>
04625 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, internal::None,
04626     internal::None, internal::None, internal::None, internal::None,
04627     internal::None, internal::None, internal::None, internal::None,
04628     internal::None, internal::None, internal::None, internal::None,
04629     internal::None, internal::None, internal::None, internal::None,
04630     internal::None, internal::None, internal::None, internal::None,
04631     internal::None, internal::None, internal::None, internal::None,
04632     internal::None, internal::None, internal::None, internal::None,
04633     internal::None, internal::None, internal::None, internal::None,
04634     internal::None, internal::None, internal::None, internal::None,
04635     internal::None, internal::None> {
04636   typedef internal::Types11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> type;
04637 };
04638 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04639     typename T6, typename T7, typename T8, typename T9, typename T10,
04640     typename T11, typename T12>
04641 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, internal::None,
04642     internal::None, internal::None, internal::None, internal::None,
04643     internal::None, internal::None, internal::None, internal::None,
04644     internal::None, internal::None, internal::None, internal::None,
04645     internal::None, internal::None, internal::None, internal::None,
04646     internal::None, internal::None, internal::None, internal::None,
04647     internal::None, internal::None, internal::None, internal::None,
04648     internal::None, internal::None, internal::None, internal::None,
04649     internal::None, internal::None, internal::None, internal::None,
04650     internal::None, internal::None, internal::None, internal::None,
04651     internal::None> {
04652   typedef internal::Types12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
04653       T12> type;
04654 };
04655 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04656     typename T6, typename T7, typename T8, typename T9, typename T10,
04657     typename T11, typename T12, typename T13>
04658 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
04659     internal::None, internal::None, internal::None, internal::None,
04660     internal::None, internal::None, internal::None, internal::None,
04661     internal::None, internal::None, internal::None, internal::None,
04662     internal::None, internal::None, internal::None, internal::None,
04663     internal::None, internal::None, internal::None, internal::None,
04664     internal::None, internal::None, internal::None, internal::None,
04665     internal::None, internal::None, internal::None, internal::None,
04666     internal::None, internal::None, internal::None, internal::None,
04667     internal::None, internal::None, internal::None, internal::None,
04668     internal::None> {
04669   typedef internal::Types13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04670       T13> type;
04671 };
04672 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04673     typename T6, typename T7, typename T8, typename T9, typename T10,
04674     typename T11, typename T12, typename T13, typename T14>
04675 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
04676     internal::None, internal::None, internal::None, internal::None,
04677     internal::None, internal::None, internal::None, internal::None,
04678     internal::None, internal::None, internal::None, internal::None,
04679     internal::None, internal::None, internal::None, internal::None,
04680     internal::None, internal::None, internal::None, internal::None,
04681     internal::None, internal::None, internal::None, internal::None,
04682     internal::None, internal::None, internal::None, internal::None,
04683     internal::None, internal::None, internal::None, internal::None,
04684     internal::None, internal::None, internal::None, internal::None> {
04685   typedef internal::Types14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04686       T13, T14> type;
04687 };
04688 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04689     typename T6, typename T7, typename T8, typename T9, typename T10,
04690     typename T11, typename T12, typename T13, typename T14, typename T15>
04691 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04692     internal::None, internal::None, internal::None, internal::None,
04693     internal::None, internal::None, internal::None, internal::None,
04694     internal::None, internal::None, internal::None, internal::None,
04695     internal::None, internal::None, internal::None, internal::None,
04696     internal::None, internal::None, internal::None, internal::None,
04697     internal::None, internal::None, internal::None, internal::None,
04698     internal::None, internal::None, internal::None, internal::None,
04699     internal::None, internal::None, internal::None, internal::None,
04700     internal::None, internal::None, internal::None> {
04701   typedef internal::Types15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04702       T13, T14, T15> type;
04703 };
04704 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04705     typename T6, typename T7, typename T8, typename T9, typename T10,
04706     typename T11, typename T12, typename T13, typename T14, typename T15,
04707     typename T16>
04708 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04709     T16, internal::None, internal::None, internal::None, internal::None,
04710     internal::None, internal::None, internal::None, internal::None,
04711     internal::None, internal::None, internal::None, internal::None,
04712     internal::None, internal::None, internal::None, internal::None,
04713     internal::None, internal::None, internal::None, internal::None,
04714     internal::None, internal::None, internal::None, internal::None,
04715     internal::None, internal::None, internal::None, internal::None,
04716     internal::None, internal::None, internal::None, internal::None,
04717     internal::None, internal::None> {
04718   typedef internal::Types16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04719       T13, T14, T15, T16> type;
04720 };
04721 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04722     typename T6, typename T7, typename T8, typename T9, typename T10,
04723     typename T11, typename T12, typename T13, typename T14, typename T15,
04724     typename T16, typename T17>
04725 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04726     T16, T17, internal::None, internal::None, internal::None, internal::None,
04727     internal::None, internal::None, internal::None, internal::None,
04728     internal::None, internal::None, internal::None, internal::None,
04729     internal::None, internal::None, internal::None, internal::None,
04730     internal::None, internal::None, internal::None, internal::None,
04731     internal::None, internal::None, internal::None, internal::None,
04732     internal::None, internal::None, internal::None, internal::None,
04733     internal::None, internal::None, internal::None, internal::None,
04734     internal::None> {
04735   typedef internal::Types17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04736       T13, T14, T15, T16, T17> type;
04737 };
04738 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04739     typename T6, typename T7, typename T8, typename T9, typename T10,
04740     typename T11, typename T12, typename T13, typename T14, typename T15,
04741     typename T16, typename T17, typename T18>
04742 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04743     T16, T17, T18, internal::None, internal::None, internal::None,
04744     internal::None, internal::None, internal::None, internal::None,
04745     internal::None, internal::None, internal::None, internal::None,
04746     internal::None, internal::None, internal::None, internal::None,
04747     internal::None, internal::None, internal::None, internal::None,
04748     internal::None, internal::None, internal::None, internal::None,
04749     internal::None, internal::None, internal::None, internal::None,
04750     internal::None, internal::None, internal::None, internal::None,
04751     internal::None> {
04752   typedef internal::Types18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04753       T13, T14, T15, T16, T17, T18> type;
04754 };
04755 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04756     typename T6, typename T7, typename T8, typename T9, typename T10,
04757     typename T11, typename T12, typename T13, typename T14, typename T15,
04758     typename T16, typename T17, typename T18, typename T19>
04759 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04760     T16, T17, T18, T19, internal::None, internal::None, internal::None,
04761     internal::None, internal::None, internal::None, internal::None,
04762     internal::None, internal::None, internal::None, internal::None,
04763     internal::None, internal::None, internal::None, internal::None,
04764     internal::None, internal::None, internal::None, internal::None,
04765     internal::None, internal::None, internal::None, internal::None,
04766     internal::None, internal::None, internal::None, internal::None,
04767     internal::None, internal::None, internal::None, internal::None> {
04768   typedef internal::Types19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04769       T13, T14, T15, T16, T17, T18, T19> type;
04770 };
04771 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04772     typename T6, typename T7, typename T8, typename T9, typename T10,
04773     typename T11, typename T12, typename T13, typename T14, typename T15,
04774     typename T16, typename T17, typename T18, typename T19, typename T20>
04775 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04776     T16, T17, T18, T19, T20, internal::None, internal::None, internal::None,
04777     internal::None, internal::None, internal::None, internal::None,
04778     internal::None, internal::None, internal::None, internal::None,
04779     internal::None, internal::None, internal::None, internal::None,
04780     internal::None, internal::None, internal::None, internal::None,
04781     internal::None, internal::None, internal::None, internal::None,
04782     internal::None, internal::None, internal::None, internal::None,
04783     internal::None, internal::None, internal::None> {
04784   typedef internal::Types20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04785       T13, T14, T15, T16, T17, T18, T19, T20> type;
04786 };
04787 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04788     typename T6, typename T7, typename T8, typename T9, typename T10,
04789     typename T11, typename T12, typename T13, typename T14, typename T15,
04790     typename T16, typename T17, typename T18, typename T19, typename T20,
04791     typename T21>
04792 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04793     T16, T17, T18, T19, T20, T21, internal::None, internal::None,
04794     internal::None, internal::None, internal::None, internal::None,
04795     internal::None, internal::None, internal::None, internal::None,
04796     internal::None, internal::None, internal::None, internal::None,
04797     internal::None, internal::None, internal::None, internal::None,
04798     internal::None, internal::None, internal::None, internal::None,
04799     internal::None, internal::None, internal::None, internal::None,
04800     internal::None, internal::None, internal::None> {
04801   typedef internal::Types21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04802       T13, T14, T15, T16, T17, T18, T19, T20, T21> type;
04803 };
04804 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04805     typename T6, typename T7, typename T8, typename T9, typename T10,
04806     typename T11, typename T12, typename T13, typename T14, typename T15,
04807     typename T16, typename T17, typename T18, typename T19, typename T20,
04808     typename T21, typename T22>
04809 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04810     T16, T17, T18, T19, T20, T21, T22, internal::None, internal::None,
04811     internal::None, internal::None, internal::None, internal::None,
04812     internal::None, internal::None, internal::None, internal::None,
04813     internal::None, internal::None, internal::None, internal::None,
04814     internal::None, internal::None, internal::None, internal::None,
04815     internal::None, internal::None, internal::None, internal::None,
04816     internal::None, internal::None, internal::None, internal::None,
04817     internal::None, internal::None> {
04818   typedef internal::Types22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04819       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> type;
04820 };
04821 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04822     typename T6, typename T7, typename T8, typename T9, typename T10,
04823     typename T11, typename T12, typename T13, typename T14, typename T15,
04824     typename T16, typename T17, typename T18, typename T19, typename T20,
04825     typename T21, typename T22, typename T23>
04826 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04827     T16, T17, T18, T19, T20, T21, T22, T23, internal::None, internal::None,
04828     internal::None, internal::None, internal::None, internal::None,
04829     internal::None, internal::None, internal::None, internal::None,
04830     internal::None, internal::None, internal::None, internal::None,
04831     internal::None, internal::None, internal::None, internal::None,
04832     internal::None, internal::None, internal::None, internal::None,
04833     internal::None, internal::None, internal::None, internal::None,
04834     internal::None> {
04835   typedef internal::Types23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04836       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> type;
04837 };
04838 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04839     typename T6, typename T7, typename T8, typename T9, typename T10,
04840     typename T11, typename T12, typename T13, typename T14, typename T15,
04841     typename T16, typename T17, typename T18, typename T19, typename T20,
04842     typename T21, typename T22, typename T23, typename T24>
04843 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04844     T16, T17, T18, T19, T20, T21, T22, T23, T24, internal::None,
04845     internal::None, internal::None, internal::None, internal::None,
04846     internal::None, internal::None, internal::None, internal::None,
04847     internal::None, internal::None, internal::None, internal::None,
04848     internal::None, internal::None, internal::None, internal::None,
04849     internal::None, internal::None, internal::None, internal::None,
04850     internal::None, internal::None, internal::None, internal::None,
04851     internal::None> {
04852   typedef internal::Types24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04853       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> type;
04854 };
04855 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04856     typename T6, typename T7, typename T8, typename T9, typename T10,
04857     typename T11, typename T12, typename T13, typename T14, typename T15,
04858     typename T16, typename T17, typename T18, typename T19, typename T20,
04859     typename T21, typename T22, typename T23, typename T24, typename T25>
04860 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04861     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, internal::None,
04862     internal::None, internal::None, internal::None, internal::None,
04863     internal::None, internal::None, internal::None, internal::None,
04864     internal::None, internal::None, internal::None, internal::None,
04865     internal::None, internal::None, internal::None, internal::None,
04866     internal::None, internal::None, internal::None, internal::None,
04867     internal::None, internal::None, internal::None, internal::None> {
04868   typedef internal::Types25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04869       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> type;
04870 };
04871 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04872     typename T6, typename T7, typename T8, typename T9, typename T10,
04873     typename T11, typename T12, typename T13, typename T14, typename T15,
04874     typename T16, typename T17, typename T18, typename T19, typename T20,
04875     typename T21, typename T22, typename T23, typename T24, typename T25,
04876     typename T26>
04877 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04878     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, internal::None,
04879     internal::None, internal::None, internal::None, internal::None,
04880     internal::None, internal::None, internal::None, internal::None,
04881     internal::None, internal::None, internal::None, internal::None,
04882     internal::None, internal::None, internal::None, internal::None,
04883     internal::None, internal::None, internal::None, internal::None,
04884     internal::None, internal::None, internal::None> {
04885   typedef internal::Types26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04886       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
04887       T26> type;
04888 };
04889 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04890     typename T6, typename T7, typename T8, typename T9, typename T10,
04891     typename T11, typename T12, typename T13, typename T14, typename T15,
04892     typename T16, typename T17, typename T18, typename T19, typename T20,
04893     typename T21, typename T22, typename T23, typename T24, typename T25,
04894     typename T26, typename T27>
04895 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04896     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, internal::None,
04897     internal::None, internal::None, internal::None, internal::None,
04898     internal::None, internal::None, internal::None, internal::None,
04899     internal::None, internal::None, internal::None, internal::None,
04900     internal::None, internal::None, internal::None, internal::None,
04901     internal::None, internal::None, internal::None, internal::None,
04902     internal::None, internal::None> {
04903   typedef internal::Types27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04904       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
04905       T27> type;
04906 };
04907 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04908     typename T6, typename T7, typename T8, typename T9, typename T10,
04909     typename T11, typename T12, typename T13, typename T14, typename T15,
04910     typename T16, typename T17, typename T18, typename T19, typename T20,
04911     typename T21, typename T22, typename T23, typename T24, typename T25,
04912     typename T26, typename T27, typename T28>
04913 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04914     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
04915     internal::None, internal::None, internal::None, internal::None,
04916     internal::None, internal::None, internal::None, internal::None,
04917     internal::None, internal::None, internal::None, internal::None,
04918     internal::None, internal::None, internal::None, internal::None,
04919     internal::None, internal::None, internal::None, internal::None,
04920     internal::None, internal::None> {
04921   typedef internal::Types28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04922       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
04923       T27, T28> type;
04924 };
04925 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04926     typename T6, typename T7, typename T8, typename T9, typename T10,
04927     typename T11, typename T12, typename T13, typename T14, typename T15,
04928     typename T16, typename T17, typename T18, typename T19, typename T20,
04929     typename T21, typename T22, typename T23, typename T24, typename T25,
04930     typename T26, typename T27, typename T28, typename T29>
04931 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04932     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
04933     internal::None, internal::None, internal::None, internal::None,
04934     internal::None, internal::None, internal::None, internal::None,
04935     internal::None, internal::None, internal::None, internal::None,
04936     internal::None, internal::None, internal::None, internal::None,
04937     internal::None, internal::None, internal::None, internal::None,
04938     internal::None> {
04939   typedef internal::Types29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04940       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
04941       T27, T28, T29> type;
04942 };
04943 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04944     typename T6, typename T7, typename T8, typename T9, typename T10,
04945     typename T11, typename T12, typename T13, typename T14, typename T15,
04946     typename T16, typename T17, typename T18, typename T19, typename T20,
04947     typename T21, typename T22, typename T23, typename T24, typename T25,
04948     typename T26, typename T27, typename T28, typename T29, typename T30>
04949 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04950     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
04951     internal::None, internal::None, internal::None, internal::None,
04952     internal::None, internal::None, internal::None, internal::None,
04953     internal::None, internal::None, internal::None, internal::None,
04954     internal::None, internal::None, internal::None, internal::None,
04955     internal::None, internal::None, internal::None, internal::None> {
04956   typedef internal::Types30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04957       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
04958       T27, T28, T29, T30> type;
04959 };
04960 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04961     typename T6, typename T7, typename T8, typename T9, typename T10,
04962     typename T11, typename T12, typename T13, typename T14, typename T15,
04963     typename T16, typename T17, typename T18, typename T19, typename T20,
04964     typename T21, typename T22, typename T23, typename T24, typename T25,
04965     typename T26, typename T27, typename T28, typename T29, typename T30,
04966     typename T31>
04967 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04968     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
04969     T31, internal::None, internal::None, internal::None, internal::None,
04970     internal::None, internal::None, internal::None, internal::None,
04971     internal::None, internal::None, internal::None, internal::None,
04972     internal::None, internal::None, internal::None, internal::None,
04973     internal::None, internal::None, internal::None> {
04974   typedef internal::Types31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04975       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
04976       T27, T28, T29, T30, T31> type;
04977 };
04978 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04979     typename T6, typename T7, typename T8, typename T9, typename T10,
04980     typename T11, typename T12, typename T13, typename T14, typename T15,
04981     typename T16, typename T17, typename T18, typename T19, typename T20,
04982     typename T21, typename T22, typename T23, typename T24, typename T25,
04983     typename T26, typename T27, typename T28, typename T29, typename T30,
04984     typename T31, typename T32>
04985 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
04986     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
04987     T31, T32, internal::None, internal::None, internal::None, internal::None,
04988     internal::None, internal::None, internal::None, internal::None,
04989     internal::None, internal::None, internal::None, internal::None,
04990     internal::None, internal::None, internal::None, internal::None,
04991     internal::None, internal::None> {
04992   typedef internal::Types32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
04993       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
04994       T27, T28, T29, T30, T31, T32> type;
04995 };
04996 template <typename T1, typename T2, typename T3, typename T4, typename T5,
04997     typename T6, typename T7, typename T8, typename T9, typename T10,
04998     typename T11, typename T12, typename T13, typename T14, typename T15,
04999     typename T16, typename T17, typename T18, typename T19, typename T20,
05000     typename T21, typename T22, typename T23, typename T24, typename T25,
05001     typename T26, typename T27, typename T28, typename T29, typename T30,
05002     typename T31, typename T32, typename T33>
05003 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
05004     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
05005     T31, T32, T33, internal::None, internal::None, internal::None,
05006     internal::None, internal::None, internal::None, internal::None,
05007     internal::None, internal::None, internal::None, internal::None,
05008     internal::None, internal::None, internal::None, internal::None,
05009     internal::None, internal::None> {
05010   typedef internal::Types33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
05011       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
05012       T27, T28, T29, T30, T31, T32, T33> type;
05013 };
05014 template <typename T1, typename T2, typename T3, typename T4, typename T5,
05015     typename T6, typename T7, typename T8, typename T9, typename T10,
05016     typename T11, typename T12, typename T13, typename T14, typename T15,
05017     typename T16, typename T17, typename T18, typename T19, typename T20,
05018     typename T21, typename T22, typename T23, typename T24, typename T25,
05019     typename T26, typename T27, typename T28, typename T29, typename T30,
05020     typename T31, typename T32, typename T33, typename T34>
05021 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
05022     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
05023     T31, T32, T33, T34, internal::None, internal::None, internal::None,
05024     internal::None, internal::None, internal::None, internal::None,
05025     internal::None, internal::None, internal::None, internal::None,
05026     internal::None, internal::None, internal::None, internal::None,
05027     internal::None> {
05028   typedef internal::Types34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
05029       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
05030       T27, T28, T29, T30, T31, T32, T33, T34> type;
05031 };
05032 template <typename T1, typename T2, typename T3, typename T4, typename T5,
05033     typename T6, typename T7, typename T8, typename T9, typename T10,
05034     typename T11, typename T12, typename T13, typename T14, typename T15,
05035     typename T16, typename T17, typename T18, typename T19, typename T20,
05036     typename T21, typename T22, typename T23, typename T24, typename T25,
05037     typename T26, typename T27, typename T28, typename T29, typename T30,
05038     typename T31, typename T32, typename T33, typename T34, typename T35>
05039 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
05040     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
05041     T31, T32, T33, T34, T35, internal::None, internal::None, internal::None,
05042     internal::None, internal::None, internal::None, internal::None,
05043     internal::None, internal::None, internal::None, internal::None,
05044     internal::None, internal::None, internal::None, internal::None> {
05045   typedef internal::Types35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
05046       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
05047       T27, T28, T29, T30, T31, T32, T33, T34, T35> type;
05048 };
05049 template <typename T1, typename T2, typename T3, typename T4, typename T5,
05050     typename T6, typename T7, typename T8, typename T9, typename T10,
05051     typename T11, typename T12, typename T13, typename T14, typename T15,
05052     typename T16, typename T17, typename T18, typename T19, typename T20,
05053     typename T21, typename T22, typename T23, typename T24, typename T25,
05054     typename T26, typename T27, typename T28, typename T29, typename T30,
05055     typename T31, typename T32, typename T33, typename T34, typename T35,
05056     typename T36>
05057 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
05058     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
05059     T31, T32, T33, T34, T35, T36, internal::None, internal::None,
05060     internal::None, internal::None, internal::None, internal::None,
05061     internal::None, internal::None, internal::None, internal::None,
05062     internal::None, internal::None, internal::None, internal::None> {
05063   typedef internal::Types36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
05064       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
05065       T27, T28, T29, T30, T31, T32, T33, T34, T35, T36> type;
05066 };
05067 template <typename T1, typename T2, typename T3, typename T4, typename T5,
05068     typename T6, typename T7, typename T8, typename T9, typename T10,
05069     typename T11, typename T12, typename T13, typename T14, typename T15,
05070     typename T16, typename T17, typename T18, typename T19, typename T20,
05071     typename T21, typename T22, typename T23, typename T24, typename T25,
05072     typename T26, typename T27, typename T28, typename T29, typename T30,
05073     typename T31, typename T32, typename T33, typename T34, typename T35,
05074     typename T36, typename T37>
05075 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
05076     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
05077     T31, T32, T33, T34, T35, T36, T37, internal::None, internal::None,
05078     internal::None, internal::None, internal::None, internal::None,
05079     internal::None, internal::None, internal::None, internal::None,
05080     internal::None, internal::None, internal::None> {
05081   typedef internal::Types37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
05082       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
05083       T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37> type;
05084 };
05085 template <typename T1, typename T2, typename T3, typename T4, typename T5,
05086     typename T6, typename T7, typename T8, typename T9, typename T10,
05087     typename T11, typename T12, typename T13, typename T14, typename T15,
05088     typename T16, typename T17, typename T18, typename T19, typename T20,
05089     typename T21, typename T22, typename T23, typename T24, typename T25,
05090     typename T26, typename T27, typename T28, typename T29, typename T30,
05091     typename T31, typename T32, typename T33, typename T34, typename T35,
05092     typename T36, typename T37, typename T38>
05093 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
05094     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
05095     T31, T32, T33, T34, T35, T36, T37, T38, internal::None, internal::None,
05096     internal::None, internal::None, internal::None, internal::None,
05097     internal::None, internal::None, internal::None, internal::None,
05098     internal::None, internal::None> {
05099   typedef internal::Types38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
05100       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
05101       T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> type;
05102 };
05103 template <typename T1, typename T2, typename T3, typename T4, typename T5,
05104     typename T6, typename T7, typename T8, typename T9, typename T10,
05105     typename T11, typename T12, typename T13, typename T14, typename T15,
05106     typename T16, typename T17, typename T18, typename T19, typename T20,
05107     typename T21, typename T22, typename T23, typename T24, typename T25,
05108     typename T26, typename T27, typename T28, typename T29, typename T30,
05109     typename T31, typename T32, typename T33, typename T34, typename T35,
05110     typename T36, typename T37, typename T38, typename T39>
05111 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
05112     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
05113     T31, T32, T33, T34, T35, T36, T37, T38, T39, internal::None,
05114     internal::None, internal::None, internal::None, internal::None,
05115     internal::None, internal::None, internal::None, internal::None,
05116     internal::None, internal::None> {
05117   typedef internal::Types39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
05118       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
05119       T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> type;
05120 };
05121 template <typename T1, typename T2, typename T3, typename T4, typename T5,
05122     typename T6, typename T7, typename T8, typename T9, typename T10,
05123     typename T11, typename T12, typename T13, typename T14, typename T15,
05124     typename T16, typename T17, typename T18, typename T19, typename T20,
05125     typename T21, typename T22, typename T23, typename T24, typename T25,
05126     typename T26, typename T27, typename T28, typename T29, typename T30,
05127     typename T31, typename T32, typename T33, typename T34, typename T35,
05128     typename T36, typename T37, typename T38, typename T39, typename T40>
05129 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
05130     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
05131     T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, internal::None,
05132     internal::None, internal::None, internal::None, internal::None,
05133     internal::None, internal::None, internal::None, internal::None,
05134     internal::None> {
05135   typedef internal::Types40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
05136       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
05137       T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
05138       T40> type;
05139 };
05140 template <typename T1, typename T2, typename T3, typename T4, typename T5,
05141     typename T6, typename T7, typename T8, typename T9, typename T10,
05142     typename T11, typename T12, typename T13, typename T14, typename T15,
05143     typename T16, typename T17, typename T18, typename T19, typename T20,
05144     typename T21, typename T22, typename T23, typename T24, typename T25,
05145     typename T26, typename T27, typename T28, typename T29, typename T30,
05146     typename T31, typename T32, typename T33, typename T34, typename T35,
05147     typename T36, typename T37, typename T38, typename T39, typename T40,
05148     typename T41>
05149 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
05150     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
05151     T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, internal::None,
05152     internal::None, internal::None, internal::None, internal::None,
05153     internal::None, internal::None, internal::None, internal::None> {
05154   typedef internal::Types41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
05155       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
05156       T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
05157       T41> type;
05158 };
05159 template <typename T1, typename T2, typename T3, typename T4, typename T5,
05160     typename T6, typename T7, typename T8, typename T9, typename T10,
05161     typename T11, typename T12, typename T13, typename T14, typename T15,
05162     typename T16, typename T17, typename T18, typename T19, typename T20,
05163     typename T21, typename T22, typename T23, typename T24, typename T25,
05164     typename T26, typename T27, typename T28, typename T29, typename T30,
05165     typename T31, typename T32, typename T33, typename T34, typename T35,
05166     typename T36, typename T37, typename T38, typename T39, typename T40,
05167     typename T41, typename T42>
05168 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
05169     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
05170     T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, internal::None,
05171     internal::None, internal::None, internal::None, internal::None,
05172     internal::None, internal::None, internal::None> {
05173   typedef internal::Types42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
05174       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
05175       T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
05176       T41, T42> type;
05177 };
05178 template <typename T1, typename T2, typename T3, typename T4, typename T5,
05179     typename T6, typename T7, typename T8, typename T9, typename T10,
05180     typename T11, typename T12, typename T13, typename T14, typename T15,
05181     typename T16, typename T17, typename T18, typename T19, typename T20,
05182     typename T21, typename T22, typename T23, typename T24, typename T25,
05183     typename T26, typename T27, typename T28, typename T29, typename T30,
05184     typename T31, typename T32, typename T33, typename T34, typename T35,
05185     typename T36, typename T37, typename T38, typename T39, typename T40,
05186     typename T41, typename T42, typename T43>
05187 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
05188     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
05189     T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
05190     internal::None, internal::None, internal::None, internal::None,
05191     internal::None, internal::None, internal::None> {
05192   typedef internal::Types43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
05193       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
05194       T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
05195       T41, T42, T43> type;
05196 };
05197 template <typename T1, typename T2, typename T3, typename T4, typename T5,
05198     typename T6, typename T7, typename T8, typename T9, typename T10,
05199     typename T11, typename T12, typename T13, typename T14, typename T15,
05200     typename T16, typename T17, typename T18, typename T19, typename T20,
05201     typename T21, typename T22, typename T23, typename T24, typename T25,
05202     typename T26, typename T27, typename T28, typename T29, typename T30,
05203     typename T31, typename T32, typename T33, typename T34, typename T35,
05204     typename T36, typename T37, typename T38, typename T39, typename T40,
05205     typename T41, typename T42, typename T43, typename T44>
05206 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
05207     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
05208     T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
05209     internal::None, internal::None, internal::None, internal::None,
05210     internal::None, internal::None> {
05211   typedef internal::Types44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
05212       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
05213       T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
05214       T41, T42, T43, T44> type;
05215 };
05216 template <typename T1, typename T2, typename T3, typename T4, typename T5,
05217     typename T6, typename T7, typename T8, typename T9, typename T10,
05218     typename T11, typename T12, typename T13, typename T14, typename T15,
05219     typename T16, typename T17, typename T18, typename T19, typename T20,
05220     typename T21, typename T22, typename T23, typename T24, typename T25,
05221     typename T26, typename T27, typename T28, typename T29, typename T30,
05222     typename T31, typename T32, typename T33, typename T34, typename T35,
05223     typename T36, typename T37, typename T38, typename T39, typename T40,
05224     typename T41, typename T42, typename T43, typename T44, typename T45>
05225 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
05226     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
05227     T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
05228     internal::None, internal::None, internal::None, internal::None,
05229     internal::None> {
05230   typedef internal::Types45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
05231       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
05232       T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
05233       T41, T42, T43, T44, T45> type;
05234 };
05235 template <typename T1, typename T2, typename T3, typename T4, typename T5,
05236     typename T6, typename T7, typename T8, typename T9, typename T10,
05237     typename T11, typename T12, typename T13, typename T14, typename T15,
05238     typename T16, typename T17, typename T18, typename T19, typename T20,
05239     typename T21, typename T22, typename T23, typename T24, typename T25,
05240     typename T26, typename T27, typename T28, typename T29, typename T30,
05241     typename T31, typename T32, typename T33, typename T34, typename T35,
05242     typename T36, typename T37, typename T38, typename T39, typename T40,
05243     typename T41, typename T42, typename T43, typename T44, typename T45,
05244     typename T46>
05245 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
05246     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
05247     T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
05248     T46, internal::None, internal::None, internal::None, internal::None> {
05249   typedef internal::Types46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
05250       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
05251       T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
05252       T41, T42, T43, T44, T45, T46> type;
05253 };
05254 template <typename T1, typename T2, typename T3, typename T4, typename T5,
05255     typename T6, typename T7, typename T8, typename T9, typename T10,
05256     typename T11, typename T12, typename T13, typename T14, typename T15,
05257     typename T16, typename T17, typename T18, typename T19, typename T20,
05258     typename T21, typename T22, typename T23, typename T24, typename T25,
05259     typename T26, typename T27, typename T28, typename T29, typename T30,
05260     typename T31, typename T32, typename T33, typename T34, typename T35,
05261     typename T36, typename T37, typename T38, typename T39, typename T40,
05262     typename T41, typename T42, typename T43, typename T44, typename T45,
05263     typename T46, typename T47>
05264 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
05265     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
05266     T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
05267     T46, T47, internal::None, internal::None, internal::None> {
05268   typedef internal::Types47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
05269       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
05270       T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
05271       T41, T42, T43, T44, T45, T46, T47> type;
05272 };
05273 template <typename T1, typename T2, typename T3, typename T4, typename T5,
05274     typename T6, typename T7, typename T8, typename T9, typename T10,
05275     typename T11, typename T12, typename T13, typename T14, typename T15,
05276     typename T16, typename T17, typename T18, typename T19, typename T20,
05277     typename T21, typename T22, typename T23, typename T24, typename T25,
05278     typename T26, typename T27, typename T28, typename T29, typename T30,
05279     typename T31, typename T32, typename T33, typename T34, typename T35,
05280     typename T36, typename T37, typename T38, typename T39, typename T40,
05281     typename T41, typename T42, typename T43, typename T44, typename T45,
05282     typename T46, typename T47, typename T48>
05283 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
05284     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
05285     T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
05286     T46, T47, T48, internal::None, internal::None> {
05287   typedef internal::Types48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
05288       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
05289       T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
05290       T41, T42, T43, T44, T45, T46, T47, T48> type;
05291 };
05292 template <typename T1, typename T2, typename T3, typename T4, typename T5,
05293     typename T6, typename T7, typename T8, typename T9, typename T10,
05294     typename T11, typename T12, typename T13, typename T14, typename T15,
05295     typename T16, typename T17, typename T18, typename T19, typename T20,
05296     typename T21, typename T22, typename T23, typename T24, typename T25,
05297     typename T26, typename T27, typename T28, typename T29, typename T30,
05298     typename T31, typename T32, typename T33, typename T34, typename T35,
05299     typename T36, typename T37, typename T38, typename T39, typename T40,
05300     typename T41, typename T42, typename T43, typename T44, typename T45,
05301     typename T46, typename T47, typename T48, typename T49>
05302 struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
05303     T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30,
05304     T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45,
05305     T46, T47, T48, T49, internal::None> {
05306   typedef internal::Types49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
05307       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
05308       T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
05309       T41, T42, T43, T44, T45, T46, T47, T48, T49> type;
05310 };
05311 
05312 namespace internal {
05313 
05314 # define GTEST_TEMPLATE_ template <typename T> class
05315 
05316 // The template "selector" struct TemplateSel<Tmpl> is used to
05317 // represent Tmpl, which must be a class template with one type
05318 // parameter, as a type.  TemplateSel<Tmpl>::Bind<T>::type is defined
05319 // as the type Tmpl<T>.  This allows us to actually instantiate the
05320 // template "selected" by TemplateSel<Tmpl>.
05321 //
05322 // This trick is necessary for simulating typedef for class templates,
05323 // which C++ doesn't support directly.
05324 template <GTEST_TEMPLATE_ Tmpl>
05325 struct TemplateSel {
05326   template <typename T>
05327   struct Bind {
05328     typedef Tmpl<T> type;
05329   };
05330 };
05331 
05332 # define GTEST_BIND_(TmplSel, T) \
05333   TmplSel::template Bind<T>::type
05334 
05335 // A unique struct template used as the default value for the
05336 // arguments of class template Templates.  This allows us to simulate
05337 // variadic templates (e.g. Templates<int>, Templates<int, double>,
05338 // and etc), which C++ doesn't support directly.
05339 template <typename T>
05340 struct NoneT {};
05341 
05342 // The following family of struct and struct templates are used to
05343 // represent template lists.  In particular, TemplatesN<T1, T2, ...,
05344 // TN> represents a list of N templates (T1, T2, ..., and TN).  Except
05345 // for Templates0, every struct in the family has two member types:
05346 // Head for the selector of the first template in the list, and Tail
05347 // for the rest of the list.
05348 
05349 // The empty template list.
05350 struct Templates0 {};
05351 
05352 // Template lists of length 1, 2, 3, and so on.
05353 
05354 template <GTEST_TEMPLATE_ T1>
05355 struct Templates1 {
05356   typedef TemplateSel<T1> Head;
05357   typedef Templates0 Tail;
05358 };
05359 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2>
05360 struct Templates2 {
05361   typedef TemplateSel<T1> Head;
05362   typedef Templates1<T2> Tail;
05363 };
05364 
05365 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3>
05366 struct Templates3 {
05367   typedef TemplateSel<T1> Head;
05368   typedef Templates2<T2, T3> Tail;
05369 };
05370 
05371 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05372     GTEST_TEMPLATE_ T4>
05373 struct Templates4 {
05374   typedef TemplateSel<T1> Head;
05375   typedef Templates3<T2, T3, T4> Tail;
05376 };
05377 
05378 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05379     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5>
05380 struct Templates5 {
05381   typedef TemplateSel<T1> Head;
05382   typedef Templates4<T2, T3, T4, T5> Tail;
05383 };
05384 
05385 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05386     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6>
05387 struct Templates6 {
05388   typedef TemplateSel<T1> Head;
05389   typedef Templates5<T2, T3, T4, T5, T6> Tail;
05390 };
05391 
05392 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05393     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05394     GTEST_TEMPLATE_ T7>
05395 struct Templates7 {
05396   typedef TemplateSel<T1> Head;
05397   typedef Templates6<T2, T3, T4, T5, T6, T7> Tail;
05398 };
05399 
05400 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05401     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05402     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8>
05403 struct Templates8 {
05404   typedef TemplateSel<T1> Head;
05405   typedef Templates7<T2, T3, T4, T5, T6, T7, T8> Tail;
05406 };
05407 
05408 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05409     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05410     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9>
05411 struct Templates9 {
05412   typedef TemplateSel<T1> Head;
05413   typedef Templates8<T2, T3, T4, T5, T6, T7, T8, T9> Tail;
05414 };
05415 
05416 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05417     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05418     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05419     GTEST_TEMPLATE_ T10>
05420 struct Templates10 {
05421   typedef TemplateSel<T1> Head;
05422   typedef Templates9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail;
05423 };
05424 
05425 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05426     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05427     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05428     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11>
05429 struct Templates11 {
05430   typedef TemplateSel<T1> Head;
05431   typedef Templates10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail;
05432 };
05433 
05434 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05435     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05436     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05437     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12>
05438 struct Templates12 {
05439   typedef TemplateSel<T1> Head;
05440   typedef Templates11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail;
05441 };
05442 
05443 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05444     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05445     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05446     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05447     GTEST_TEMPLATE_ T13>
05448 struct Templates13 {
05449   typedef TemplateSel<T1> Head;
05450   typedef Templates12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Tail;
05451 };
05452 
05453 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05454     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05455     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05456     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05457     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14>
05458 struct Templates14 {
05459   typedef TemplateSel<T1> Head;
05460   typedef Templates13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
05461       T14> Tail;
05462 };
05463 
05464 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05465     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05466     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05467     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05468     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15>
05469 struct Templates15 {
05470   typedef TemplateSel<T1> Head;
05471   typedef Templates14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05472       T15> Tail;
05473 };
05474 
05475 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05476     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05477     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05478     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05479     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05480     GTEST_TEMPLATE_ T16>
05481 struct Templates16 {
05482   typedef TemplateSel<T1> Head;
05483   typedef Templates15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05484       T15, T16> Tail;
05485 };
05486 
05487 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05488     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05489     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05490     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05491     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05492     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17>
05493 struct Templates17 {
05494   typedef TemplateSel<T1> Head;
05495   typedef Templates16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05496       T15, T16, T17> Tail;
05497 };
05498 
05499 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05500     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05501     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05502     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05503     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05504     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18>
05505 struct Templates18 {
05506   typedef TemplateSel<T1> Head;
05507   typedef Templates17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05508       T15, T16, T17, T18> Tail;
05509 };
05510 
05511 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05512     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05513     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05514     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05515     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05516     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05517     GTEST_TEMPLATE_ T19>
05518 struct Templates19 {
05519   typedef TemplateSel<T1> Head;
05520   typedef Templates18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05521       T15, T16, T17, T18, T19> Tail;
05522 };
05523 
05524 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05525     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05526     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05527     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05528     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05529     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05530     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20>
05531 struct Templates20 {
05532   typedef TemplateSel<T1> Head;
05533   typedef Templates19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05534       T15, T16, T17, T18, T19, T20> Tail;
05535 };
05536 
05537 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05538     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05539     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05540     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05541     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05542     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05543     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21>
05544 struct Templates21 {
05545   typedef TemplateSel<T1> Head;
05546   typedef Templates20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05547       T15, T16, T17, T18, T19, T20, T21> Tail;
05548 };
05549 
05550 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05551     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05552     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05553     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05554     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05555     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05556     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05557     GTEST_TEMPLATE_ T22>
05558 struct Templates22 {
05559   typedef TemplateSel<T1> Head;
05560   typedef Templates21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05561       T15, T16, T17, T18, T19, T20, T21, T22> Tail;
05562 };
05563 
05564 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05565     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05566     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05567     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05568     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05569     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05570     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05571     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23>
05572 struct Templates23 {
05573   typedef TemplateSel<T1> Head;
05574   typedef Templates22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05575       T15, T16, T17, T18, T19, T20, T21, T22, T23> Tail;
05576 };
05577 
05578 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05579     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05580     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05581     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05582     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05583     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05584     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05585     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24>
05586 struct Templates24 {
05587   typedef TemplateSel<T1> Head;
05588   typedef Templates23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05589       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Tail;
05590 };
05591 
05592 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05593     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05594     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05595     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05596     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05597     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05598     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05599     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05600     GTEST_TEMPLATE_ T25>
05601 struct Templates25 {
05602   typedef TemplateSel<T1> Head;
05603   typedef Templates24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05604       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Tail;
05605 };
05606 
05607 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05608     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05609     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05610     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05611     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05612     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05613     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05614     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05615     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26>
05616 struct Templates26 {
05617   typedef TemplateSel<T1> Head;
05618   typedef Templates25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05619       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Tail;
05620 };
05621 
05622 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05623     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05624     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05625     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05626     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05627     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05628     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05629     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05630     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27>
05631 struct Templates27 {
05632   typedef TemplateSel<T1> Head;
05633   typedef Templates26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05634       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> Tail;
05635 };
05636 
05637 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05638     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05639     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05640     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05641     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05642     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05643     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05644     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05645     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
05646     GTEST_TEMPLATE_ T28>
05647 struct Templates28 {
05648   typedef TemplateSel<T1> Head;
05649   typedef Templates27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05650       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
05651       T28> Tail;
05652 };
05653 
05654 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05655     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05656     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05657     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05658     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05659     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05660     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05661     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05662     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
05663     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29>
05664 struct Templates29 {
05665   typedef TemplateSel<T1> Head;
05666   typedef Templates28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05667       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
05668       T29> Tail;
05669 };
05670 
05671 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05672     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05673     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05674     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05675     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05676     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05677     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05678     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05679     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
05680     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30>
05681 struct Templates30 {
05682   typedef TemplateSel<T1> Head;
05683   typedef Templates29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05684       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
05685       T29, T30> Tail;
05686 };
05687 
05688 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05689     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05690     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05691     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05692     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05693     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05694     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05695     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05696     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
05697     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
05698     GTEST_TEMPLATE_ T31>
05699 struct Templates31 {
05700   typedef TemplateSel<T1> Head;
05701   typedef Templates30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05702       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
05703       T29, T30, T31> Tail;
05704 };
05705 
05706 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05707     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05708     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05709     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05710     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05711     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05712     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05713     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05714     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
05715     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
05716     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32>
05717 struct Templates32 {
05718   typedef TemplateSel<T1> Head;
05719   typedef Templates31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05720       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
05721       T29, T30, T31, T32> Tail;
05722 };
05723 
05724 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05725     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05726     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05727     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05728     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05729     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05730     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05731     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05732     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
05733     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
05734     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33>
05735 struct Templates33 {
05736   typedef TemplateSel<T1> Head;
05737   typedef Templates32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05738       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
05739       T29, T30, T31, T32, T33> Tail;
05740 };
05741 
05742 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05743     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05744     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05745     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05746     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05747     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05748     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05749     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05750     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
05751     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
05752     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
05753     GTEST_TEMPLATE_ T34>
05754 struct Templates34 {
05755   typedef TemplateSel<T1> Head;
05756   typedef Templates33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05757       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
05758       T29, T30, T31, T32, T33, T34> Tail;
05759 };
05760 
05761 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05762     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05763     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05764     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05765     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05766     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05767     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05768     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05769     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
05770     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
05771     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
05772     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35>
05773 struct Templates35 {
05774   typedef TemplateSel<T1> Head;
05775   typedef Templates34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05776       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
05777       T29, T30, T31, T32, T33, T34, T35> Tail;
05778 };
05779 
05780 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05781     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05782     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05783     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05784     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05785     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05786     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05787     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05788     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
05789     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
05790     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
05791     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36>
05792 struct Templates36 {
05793   typedef TemplateSel<T1> Head;
05794   typedef Templates35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05795       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
05796       T29, T30, T31, T32, T33, T34, T35, T36> Tail;
05797 };
05798 
05799 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05800     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05801     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05802     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05803     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05804     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05805     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05806     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05807     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
05808     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
05809     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
05810     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
05811     GTEST_TEMPLATE_ T37>
05812 struct Templates37 {
05813   typedef TemplateSel<T1> Head;
05814   typedef Templates36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05815       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
05816       T29, T30, T31, T32, T33, T34, T35, T36, T37> Tail;
05817 };
05818 
05819 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05820     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05821     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05822     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05823     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05824     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05825     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05826     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05827     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
05828     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
05829     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
05830     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
05831     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38>
05832 struct Templates38 {
05833   typedef TemplateSel<T1> Head;
05834   typedef Templates37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05835       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
05836       T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> Tail;
05837 };
05838 
05839 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05840     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05841     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05842     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05843     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05844     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05845     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05846     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05847     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
05848     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
05849     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
05850     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
05851     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39>
05852 struct Templates39 {
05853   typedef TemplateSel<T1> Head;
05854   typedef Templates38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05855       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
05856       T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Tail;
05857 };
05858 
05859 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05860     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05861     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05862     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05863     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05864     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05865     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05866     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05867     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
05868     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
05869     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
05870     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
05871     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
05872     GTEST_TEMPLATE_ T40>
05873 struct Templates40 {
05874   typedef TemplateSel<T1> Head;
05875   typedef Templates39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05876       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
05877       T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Tail;
05878 };
05879 
05880 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05881     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05882     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05883     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05884     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05885     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05886     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05887     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05888     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
05889     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
05890     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
05891     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
05892     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
05893     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41>
05894 struct Templates41 {
05895   typedef TemplateSel<T1> Head;
05896   typedef Templates40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05897       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
05898       T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41> Tail;
05899 };
05900 
05901 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05902     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05903     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05904     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05905     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05906     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05907     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05908     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05909     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
05910     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
05911     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
05912     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
05913     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
05914     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42>
05915 struct Templates42 {
05916   typedef TemplateSel<T1> Head;
05917   typedef Templates41<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05918       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
05919       T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
05920       T42> Tail;
05921 };
05922 
05923 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05924     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05925     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05926     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05927     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05928     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05929     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05930     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05931     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
05932     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
05933     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
05934     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
05935     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
05936     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
05937     GTEST_TEMPLATE_ T43>
05938 struct Templates43 {
05939   typedef TemplateSel<T1> Head;
05940   typedef Templates42<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05941       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
05942       T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
05943       T43> Tail;
05944 };
05945 
05946 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05947     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05948     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05949     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05950     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05951     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05952     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05953     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05954     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
05955     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
05956     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
05957     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
05958     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
05959     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
05960     GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44>
05961 struct Templates44 {
05962   typedef TemplateSel<T1> Head;
05963   typedef Templates43<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05964       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
05965       T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
05966       T43, T44> Tail;
05967 };
05968 
05969 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05970     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05971     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05972     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05973     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05974     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05975     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05976     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
05977     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
05978     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
05979     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
05980     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
05981     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
05982     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
05983     GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45>
05984 struct Templates45 {
05985   typedef TemplateSel<T1> Head;
05986   typedef Templates44<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
05987       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
05988       T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
05989       T43, T44, T45> Tail;
05990 };
05991 
05992 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
05993     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
05994     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
05995     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
05996     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
05997     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
05998     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
05999     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06000     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06001     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06002     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06003     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
06004     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
06005     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
06006     GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
06007     GTEST_TEMPLATE_ T46>
06008 struct Templates46 {
06009   typedef TemplateSel<T1> Head;
06010   typedef Templates45<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06011       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
06012       T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
06013       T43, T44, T45, T46> Tail;
06014 };
06015 
06016 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06017     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06018     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06019     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06020     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06021     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06022     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06023     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06024     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06025     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06026     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06027     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
06028     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
06029     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
06030     GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
06031     GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47>
06032 struct Templates47 {
06033   typedef TemplateSel<T1> Head;
06034   typedef Templates46<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06035       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
06036       T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
06037       T43, T44, T45, T46, T47> Tail;
06038 };
06039 
06040 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06041     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06042     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06043     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06044     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06045     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06046     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06047     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06048     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06049     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06050     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06051     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
06052     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
06053     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
06054     GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
06055     GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48>
06056 struct Templates48 {
06057   typedef TemplateSel<T1> Head;
06058   typedef Templates47<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06059       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
06060       T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
06061       T43, T44, T45, T46, T47, T48> Tail;
06062 };
06063 
06064 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06065     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06066     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06067     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06068     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06069     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06070     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06071     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06072     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06073     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06074     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06075     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
06076     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
06077     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
06078     GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
06079     GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48,
06080     GTEST_TEMPLATE_ T49>
06081 struct Templates49 {
06082   typedef TemplateSel<T1> Head;
06083   typedef Templates48<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06084       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
06085       T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
06086       T43, T44, T45, T46, T47, T48, T49> Tail;
06087 };
06088 
06089 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06090     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06091     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06092     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06093     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06094     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06095     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06096     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06097     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06098     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06099     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06100     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
06101     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
06102     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
06103     GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
06104     GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48,
06105     GTEST_TEMPLATE_ T49, GTEST_TEMPLATE_ T50>
06106 struct Templates50 {
06107   typedef TemplateSel<T1> Head;
06108   typedef Templates49<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06109       T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
06110       T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
06111       T43, T44, T45, T46, T47, T48, T49, T50> Tail;
06112 };
06113 
06114 
06115 // We don't want to require the users to write TemplatesN<...> directly,
06116 // as that would require them to count the length.  Templates<...> is much
06117 // easier to write, but generates horrible messages when there is a
06118 // compiler error, as gcc insists on printing out each template
06119 // argument, even if it has the default value (this means Templates<list>
06120 // will appear as Templates<list, NoneT, NoneT, ..., NoneT> in the compiler
06121 // errors).
06122 //
06123 // Our solution is to combine the best part of the two approaches: a
06124 // user would write Templates<T1, ..., TN>, and Google Test will translate
06125 // that to TemplatesN<T1, ..., TN> internally to make error messages
06126 // readable.  The translation is done by the 'type' member of the
06127 // Templates template.
06128 template <GTEST_TEMPLATE_ T1 = NoneT, GTEST_TEMPLATE_ T2 = NoneT,
06129     GTEST_TEMPLATE_ T3 = NoneT, GTEST_TEMPLATE_ T4 = NoneT,
06130     GTEST_TEMPLATE_ T5 = NoneT, GTEST_TEMPLATE_ T6 = NoneT,
06131     GTEST_TEMPLATE_ T7 = NoneT, GTEST_TEMPLATE_ T8 = NoneT,
06132     GTEST_TEMPLATE_ T9 = NoneT, GTEST_TEMPLATE_ T10 = NoneT,
06133     GTEST_TEMPLATE_ T11 = NoneT, GTEST_TEMPLATE_ T12 = NoneT,
06134     GTEST_TEMPLATE_ T13 = NoneT, GTEST_TEMPLATE_ T14 = NoneT,
06135     GTEST_TEMPLATE_ T15 = NoneT, GTEST_TEMPLATE_ T16 = NoneT,
06136     GTEST_TEMPLATE_ T17 = NoneT, GTEST_TEMPLATE_ T18 = NoneT,
06137     GTEST_TEMPLATE_ T19 = NoneT, GTEST_TEMPLATE_ T20 = NoneT,
06138     GTEST_TEMPLATE_ T21 = NoneT, GTEST_TEMPLATE_ T22 = NoneT,
06139     GTEST_TEMPLATE_ T23 = NoneT, GTEST_TEMPLATE_ T24 = NoneT,
06140     GTEST_TEMPLATE_ T25 = NoneT, GTEST_TEMPLATE_ T26 = NoneT,
06141     GTEST_TEMPLATE_ T27 = NoneT, GTEST_TEMPLATE_ T28 = NoneT,
06142     GTEST_TEMPLATE_ T29 = NoneT, GTEST_TEMPLATE_ T30 = NoneT,
06143     GTEST_TEMPLATE_ T31 = NoneT, GTEST_TEMPLATE_ T32 = NoneT,
06144     GTEST_TEMPLATE_ T33 = NoneT, GTEST_TEMPLATE_ T34 = NoneT,
06145     GTEST_TEMPLATE_ T35 = NoneT, GTEST_TEMPLATE_ T36 = NoneT,
06146     GTEST_TEMPLATE_ T37 = NoneT, GTEST_TEMPLATE_ T38 = NoneT,
06147     GTEST_TEMPLATE_ T39 = NoneT, GTEST_TEMPLATE_ T40 = NoneT,
06148     GTEST_TEMPLATE_ T41 = NoneT, GTEST_TEMPLATE_ T42 = NoneT,
06149     GTEST_TEMPLATE_ T43 = NoneT, GTEST_TEMPLATE_ T44 = NoneT,
06150     GTEST_TEMPLATE_ T45 = NoneT, GTEST_TEMPLATE_ T46 = NoneT,
06151     GTEST_TEMPLATE_ T47 = NoneT, GTEST_TEMPLATE_ T48 = NoneT,
06152     GTEST_TEMPLATE_ T49 = NoneT, GTEST_TEMPLATE_ T50 = NoneT>
06153 struct Templates {
06154   typedef Templates50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06155       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06156       T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
06157       T42, T43, T44, T45, T46, T47, T48, T49, T50> type;
06158 };
06159 
06160 template <>
06161 struct Templates<NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06162     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06163     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06164     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06165     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06166     NoneT> {
06167   typedef Templates0 type;
06168 };
06169 template <GTEST_TEMPLATE_ T1>
06170 struct Templates<T1, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06171     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06172     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06173     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06174     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06175     NoneT> {
06176   typedef Templates1<T1> type;
06177 };
06178 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2>
06179 struct Templates<T1, T2, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06180     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06181     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06182     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06183     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06184     NoneT> {
06185   typedef Templates2<T1, T2> type;
06186 };
06187 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3>
06188 struct Templates<T1, T2, T3, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06189     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06190     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06191     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06192     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06193   typedef Templates3<T1, T2, T3> type;
06194 };
06195 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06196     GTEST_TEMPLATE_ T4>
06197 struct Templates<T1, T2, T3, T4, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06198     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06199     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06200     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06201     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06202   typedef Templates4<T1, T2, T3, T4> type;
06203 };
06204 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06205     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5>
06206 struct Templates<T1, T2, T3, T4, T5, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06207     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06208     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06209     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06210     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06211   typedef Templates5<T1, T2, T3, T4, T5> type;
06212 };
06213 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06214     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6>
06215 struct Templates<T1, T2, T3, T4, T5, T6, NoneT, NoneT, NoneT, NoneT, NoneT,
06216     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06217     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06218     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06219     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06220   typedef Templates6<T1, T2, T3, T4, T5, T6> type;
06221 };
06222 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06223     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06224     GTEST_TEMPLATE_ T7>
06225 struct Templates<T1, T2, T3, T4, T5, T6, T7, NoneT, NoneT, NoneT, NoneT, NoneT,
06226     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06227     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06228     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06229     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06230   typedef Templates7<T1, T2, T3, T4, T5, T6, T7> type;
06231 };
06232 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06233     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06234     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8>
06235 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, NoneT, NoneT, NoneT, NoneT,
06236     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06237     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06238     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06239     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06240   typedef Templates8<T1, T2, T3, T4, T5, T6, T7, T8> type;
06241 };
06242 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06243     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06244     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9>
06245 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, NoneT, NoneT, NoneT,
06246     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06247     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06248     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06249     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06250   typedef Templates9<T1, T2, T3, T4, T5, T6, T7, T8, T9> type;
06251 };
06252 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06253     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06254     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06255     GTEST_TEMPLATE_ T10>
06256 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, NoneT, NoneT, NoneT,
06257     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06258     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06259     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06260     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06261   typedef Templates10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> type;
06262 };
06263 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06264     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06265     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06266     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11>
06267 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, NoneT, NoneT,
06268     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06269     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06270     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06271     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06272   typedef Templates11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> type;
06273 };
06274 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06275     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06276     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06277     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12>
06278 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, NoneT,
06279     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06280     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06281     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06282     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06283   typedef Templates12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> type;
06284 };
06285 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06286     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06287     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06288     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06289     GTEST_TEMPLATE_ T13>
06290 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, NoneT,
06291     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06292     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06293     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06294     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06295   typedef Templates13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
06296       T13> type;
06297 };
06298 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06299     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06300     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06301     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06302     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14>
06303 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06304     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06305     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06306     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06307     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06308   typedef Templates14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06309       T14> type;
06310 };
06311 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06312     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06313     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06314     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06315     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15>
06316 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06317     T15, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06318     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06319     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06320     NoneT, NoneT, NoneT, NoneT, NoneT> {
06321   typedef Templates15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06322       T14, T15> type;
06323 };
06324 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06325     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06326     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06327     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06328     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06329     GTEST_TEMPLATE_ T16>
06330 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06331     T15, T16, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06332     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06333     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06334     NoneT, NoneT, NoneT, NoneT, NoneT> {
06335   typedef Templates16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06336       T14, T15, T16> type;
06337 };
06338 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06339     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06340     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06341     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06342     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06343     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17>
06344 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06345     T15, T16, T17, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06346     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06347     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06348     NoneT, NoneT, NoneT, NoneT, NoneT> {
06349   typedef Templates17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06350       T14, T15, T16, T17> type;
06351 };
06352 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06353     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06354     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06355     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06356     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06357     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18>
06358 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06359     T15, T16, T17, T18, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06360     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06361     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06362     NoneT, NoneT, NoneT, NoneT> {
06363   typedef Templates18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06364       T14, T15, T16, T17, T18> type;
06365 };
06366 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06367     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06368     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06369     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06370     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06371     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06372     GTEST_TEMPLATE_ T19>
06373 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06374     T15, T16, T17, T18, T19, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06375     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06376     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06377     NoneT, NoneT, NoneT, NoneT> {
06378   typedef Templates19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06379       T14, T15, T16, T17, T18, T19> type;
06380 };
06381 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06382     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06383     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06384     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06385     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06386     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06387     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20>
06388 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06389     T15, T16, T17, T18, T19, T20, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06390     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06391     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06392     NoneT, NoneT, NoneT, NoneT> {
06393   typedef Templates20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06394       T14, T15, T16, T17, T18, T19, T20> type;
06395 };
06396 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06397     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06398     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06399     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06400     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06401     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06402     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21>
06403 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06404     T15, T16, T17, T18, T19, T20, T21, NoneT, NoneT, NoneT, NoneT, NoneT,
06405     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06406     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06407     NoneT, NoneT, NoneT, NoneT> {
06408   typedef Templates21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06409       T14, T15, T16, T17, T18, T19, T20, T21> type;
06410 };
06411 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06412     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06413     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06414     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06415     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06416     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06417     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06418     GTEST_TEMPLATE_ T22>
06419 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06420     T15, T16, T17, T18, T19, T20, T21, T22, NoneT, NoneT, NoneT, NoneT, NoneT,
06421     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06422     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06423     NoneT, NoneT, NoneT> {
06424   typedef Templates22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06425       T14, T15, T16, T17, T18, T19, T20, T21, T22> type;
06426 };
06427 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06428     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06429     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06430     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06431     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06432     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06433     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06434     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23>
06435 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06436     T15, T16, T17, T18, T19, T20, T21, T22, T23, NoneT, NoneT, NoneT, NoneT,
06437     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06438     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06439     NoneT, NoneT, NoneT> {
06440   typedef Templates23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06441       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> type;
06442 };
06443 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06444     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06445     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06446     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06447     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06448     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06449     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06450     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24>
06451 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06452     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, NoneT, NoneT, NoneT,
06453     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06454     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06455     NoneT, NoneT, NoneT> {
06456   typedef Templates24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06457       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> type;
06458 };
06459 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06460     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06461     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06462     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06463     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06464     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06465     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06466     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06467     GTEST_TEMPLATE_ T25>
06468 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06469     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, NoneT, NoneT, NoneT,
06470     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06471     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06472     NoneT, NoneT> {
06473   typedef Templates25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06474       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> type;
06475 };
06476 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06477     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06478     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06479     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06480     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06481     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06482     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06483     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06484     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26>
06485 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06486     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, NoneT, NoneT,
06487     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06488     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06489     NoneT, NoneT> {
06490   typedef Templates26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06491       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> type;
06492 };
06493 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06494     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06495     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06496     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06497     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06498     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06499     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06500     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06501     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27>
06502 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06503     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, NoneT,
06504     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06505     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06506     NoneT, NoneT> {
06507   typedef Templates27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06508       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
06509       T27> type;
06510 };
06511 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06512     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06513     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06514     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06515     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06516     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06517     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06518     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06519     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06520     GTEST_TEMPLATE_ T28>
06521 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06522     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
06523     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06524     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06525     NoneT, NoneT> {
06526   typedef Templates28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06527       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06528       T28> type;
06529 };
06530 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06531     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06532     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06533     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06534     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06535     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06536     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06537     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06538     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06539     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29>
06540 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06541     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06542     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06543     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06544     NoneT> {
06545   typedef Templates29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06546       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06547       T28, T29> type;
06548 };
06549 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06550     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06551     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06552     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06553     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06554     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06555     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06556     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06557     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06558     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30>
06559 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06560     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06561     T30, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06562     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06563   typedef Templates30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06564       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06565       T28, T29, T30> type;
06566 };
06567 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06568     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06569     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06570     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06571     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06572     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06573     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06574     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06575     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06576     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06577     GTEST_TEMPLATE_ T31>
06578 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06579     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06580     T30, T31, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06581     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06582   typedef Templates31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06583       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06584       T28, T29, T30, T31> type;
06585 };
06586 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06587     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06588     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06589     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06590     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06591     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06592     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06593     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06594     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06595     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06596     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32>
06597 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06598     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06599     T30, T31, T32, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06600     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06601   typedef Templates32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06602       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06603       T28, T29, T30, T31, T32> type;
06604 };
06605 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06606     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06607     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06608     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06609     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06610     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06611     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06612     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06613     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06614     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06615     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33>
06616 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06617     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06618     T30, T31, T32, T33, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06619     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06620   typedef Templates33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06621       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06622       T28, T29, T30, T31, T32, T33> type;
06623 };
06624 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06625     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06626     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06627     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06628     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06629     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06630     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06631     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06632     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06633     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06634     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06635     GTEST_TEMPLATE_ T34>
06636 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06637     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06638     T30, T31, T32, T33, T34, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06639     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06640   typedef Templates34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06641       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06642       T28, T29, T30, T31, T32, T33, T34> type;
06643 };
06644 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06645     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06646     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06647     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06648     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06649     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06650     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06651     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06652     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06653     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06654     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06655     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35>
06656 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06657     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06658     T30, T31, T32, T33, T34, T35, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT,
06659     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06660   typedef Templates35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06661       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06662       T28, T29, T30, T31, T32, T33, T34, T35> type;
06663 };
06664 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06665     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06666     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06667     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06668     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06669     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06670     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06671     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06672     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06673     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06674     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06675     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36>
06676 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06677     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06678     T30, T31, T32, T33, T34, T35, T36, NoneT, NoneT, NoneT, NoneT, NoneT,
06679     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06680   typedef Templates36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06681       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06682       T28, T29, T30, T31, T32, T33, T34, T35, T36> type;
06683 };
06684 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06685     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06686     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06687     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06688     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06689     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06690     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06691     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06692     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06693     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06694     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06695     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
06696     GTEST_TEMPLATE_ T37>
06697 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06698     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06699     T30, T31, T32, T33, T34, T35, T36, T37, NoneT, NoneT, NoneT, NoneT, NoneT,
06700     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06701   typedef Templates37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06702       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06703       T28, T29, T30, T31, T32, T33, T34, T35, T36, T37> type;
06704 };
06705 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06706     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06707     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06708     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06709     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06710     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06711     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06712     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06713     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06714     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06715     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06716     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
06717     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38>
06718 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06719     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06720     T30, T31, T32, T33, T34, T35, T36, T37, T38, NoneT, NoneT, NoneT, NoneT,
06721     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06722   typedef Templates38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06723       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06724       T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> type;
06725 };
06726 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06727     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06728     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06729     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06730     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06731     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06732     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06733     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06734     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06735     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06736     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06737     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
06738     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39>
06739 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06740     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06741     T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, NoneT, NoneT, NoneT,
06742     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06743   typedef Templates39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06744       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06745       T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> type;
06746 };
06747 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06748     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06749     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06750     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06751     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06752     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06753     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06754     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06755     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06756     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06757     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06758     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
06759     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
06760     GTEST_TEMPLATE_ T40>
06761 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06762     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06763     T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, NoneT, NoneT, NoneT,
06764     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06765   typedef Templates40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06766       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06767       T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> type;
06768 };
06769 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06770     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06771     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06772     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06773     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06774     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06775     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06776     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06777     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06778     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06779     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06780     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
06781     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
06782     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41>
06783 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06784     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06785     T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, NoneT, NoneT,
06786     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06787   typedef Templates41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06788       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06789       T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
06790       T41> type;
06791 };
06792 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06793     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06794     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06795     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06796     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06797     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06798     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06799     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06800     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06801     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06802     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06803     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
06804     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
06805     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42>
06806 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06807     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06808     T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, NoneT,
06809     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06810   typedef Templates42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06811       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06812       T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
06813       T42> type;
06814 };
06815 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06816     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06817     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06818     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06819     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06820     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06821     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06822     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06823     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06824     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06825     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06826     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
06827     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
06828     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
06829     GTEST_TEMPLATE_ T43>
06830 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06831     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06832     T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
06833     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06834   typedef Templates43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06835       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06836       T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
06837       T42, T43> type;
06838 };
06839 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06840     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06841     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06842     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06843     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06844     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06845     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06846     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06847     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06848     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06849     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06850     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
06851     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
06852     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
06853     GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44>
06854 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06855     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06856     T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
06857     NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> {
06858   typedef Templates44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06859       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06860       T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
06861       T42, T43, T44> type;
06862 };
06863 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06864     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06865     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06866     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06867     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06868     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06869     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06870     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06871     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06872     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06873     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06874     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
06875     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
06876     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
06877     GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45>
06878 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06879     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06880     T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
06881     T45, NoneT, NoneT, NoneT, NoneT, NoneT> {
06882   typedef Templates45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06883       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06884       T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
06885       T42, T43, T44, T45> type;
06886 };
06887 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06888     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06889     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06890     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06891     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06892     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06893     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06894     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06895     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06896     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06897     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06898     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
06899     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
06900     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
06901     GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
06902     GTEST_TEMPLATE_ T46>
06903 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06904     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06905     T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
06906     T45, T46, NoneT, NoneT, NoneT, NoneT> {
06907   typedef Templates46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06908       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06909       T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
06910       T42, T43, T44, T45, T46> type;
06911 };
06912 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06913     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06914     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06915     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06916     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06917     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06918     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06919     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06920     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06921     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06922     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06923     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
06924     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
06925     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
06926     GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
06927     GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47>
06928 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06929     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06930     T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
06931     T45, T46, T47, NoneT, NoneT, NoneT> {
06932   typedef Templates47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06933       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06934       T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
06935       T42, T43, T44, T45, T46, T47> type;
06936 };
06937 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06938     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06939     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06940     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06941     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06942     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06943     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06944     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06945     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06946     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06947     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06948     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
06949     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
06950     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
06951     GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
06952     GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48>
06953 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06954     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06955     T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
06956     T45, T46, T47, T48, NoneT, NoneT> {
06957   typedef Templates48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06958       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06959       T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
06960       T42, T43, T44, T45, T46, T47, T48> type;
06961 };
06962 template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3,
06963     GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6,
06964     GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9,
06965     GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12,
06966     GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15,
06967     GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18,
06968     GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21,
06969     GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24,
06970     GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27,
06971     GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30,
06972     GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33,
06973     GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36,
06974     GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39,
06975     GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42,
06976     GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45,
06977     GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48,
06978     GTEST_TEMPLATE_ T49>
06979 struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
06980     T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29,
06981     T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44,
06982     T45, T46, T47, T48, T49, NoneT> {
06983   typedef Templates49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
06984       T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
06985       T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
06986       T42, T43, T44, T45, T46, T47, T48, T49> type;
06987 };
06988 
06989 // The TypeList template makes it possible to use either a single type
06990 // or a Types<...> list in TYPED_TEST_CASE() and
06991 // INSTANTIATE_TYPED_TEST_CASE_P().
06992 
06993 template <typename T>
06994 struct TypeList {
06995   typedef Types1<T> type;
06996 };
06997 
06998 template <typename T1, typename T2, typename T3, typename T4, typename T5,
06999     typename T6, typename T7, typename T8, typename T9, typename T10,
07000     typename T11, typename T12, typename T13, typename T14, typename T15,
07001     typename T16, typename T17, typename T18, typename T19, typename T20,
07002     typename T21, typename T22, typename T23, typename T24, typename T25,
07003     typename T26, typename T27, typename T28, typename T29, typename T30,
07004     typename T31, typename T32, typename T33, typename T34, typename T35,
07005     typename T36, typename T37, typename T38, typename T39, typename T40,
07006     typename T41, typename T42, typename T43, typename T44, typename T45,
07007     typename T46, typename T47, typename T48, typename T49, typename T50>
07008 struct TypeList<Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
07009     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
07010     T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
07011     T44, T45, T46, T47, T48, T49, T50> > {
07012   typedef typename Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
07013       T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
07014       T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
07015       T41, T42, T43, T44, T45, T46, T47, T48, T49, T50>::type type;
07016 };
07017 
07018 #endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
07019 
07020 }  // namespace internal
07021 }  // namespace testing
07022 
07023 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
07024 
07025 // Due to C++ preprocessor weirdness, we need double indirection to
07026 // concatenate two tokens when one of them is __LINE__.  Writing
07027 //
07028 //   foo ## __LINE__
07029 //
07030 // will result in the token foo__LINE__, instead of foo followed by
07031 // the current line number.  For more details, see
07032 // http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
07033 #define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
07034 #define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar
07035 
07036 class ProtocolMessage;
07037 namespace proto2 { class Message; }
07038 
07039 namespace testing {
07040 
07041 // Forward declarations.
07042 
07043 class AssertionResult;                 // Result of an assertion.
07044 class Message;                         // Represents a failure message.
07045 class Test;                            // Represents a test.
07046 class TestInfo;                        // Information about a test.
07047 class TestPartResult;                  // Result of a test part.
07048 class UnitTest;                        // A collection of test cases.
07049 
07050 template <typename T>
07051 ::std::string PrintToString(const T& value);
07052 
07053 namespace internal {
07054 
07055 struct TraceInfo;                      // Information about a trace point.
07056 class ScopedTrace;                     // Implements scoped trace.
07057 class TestInfoImpl;                    // Opaque implementation of TestInfo
07058 class UnitTestImpl;                    // Opaque implementation of UnitTest
07059 
07060 // How many times InitGoogleTest() has been called.
07061 GTEST_API_ extern int g_init_gtest_count;
07062 
07063 // The text used in failure messages to indicate the start of the
07064 // stack trace.
07065 GTEST_API_ extern const char kStackTraceMarker[];
07066 
07067 // Two overloaded helpers for checking at compile time whether an
07068 // expression is a null pointer literal (i.e. NULL or any 0-valued
07069 // compile-time integral constant).  Their return values have
07070 // different sizes, so we can use sizeof() to test which version is
07071 // picked by the compiler.  These helpers have no implementations, as
07072 // we only need their signatures.
07073 //
07074 // Given IsNullLiteralHelper(x), the compiler will pick the first
07075 // version if x can be implicitly converted to Secret*, and pick the
07076 // second version otherwise.  Since Secret is a secret and incomplete
07077 // type, the only expression a user can write that has type Secret* is
07078 // a null pointer literal.  Therefore, we know that x is a null
07079 // pointer literal if and only if the first version is picked by the
07080 // compiler.
07081 char IsNullLiteralHelper(Secret* p);
07082 char (&IsNullLiteralHelper(...))[2];  // NOLINT
07083 
07084 // A compile-time bool constant that is true if and only if x is a
07085 // null pointer literal (i.e. NULL or any 0-valued compile-time
07086 // integral constant).
07087 #ifdef GTEST_ELLIPSIS_NEEDS_POD_
07088 // We lose support for NULL detection where the compiler doesn't like
07089 // passing non-POD classes through ellipsis (...).
07090 # define GTEST_IS_NULL_LITERAL_(x) false
07091 #else
07092 # define GTEST_IS_NULL_LITERAL_(x) \
07093     (sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1)
07094 #endif  // GTEST_ELLIPSIS_NEEDS_POD_
07095 
07096 // Appends the user-supplied message to the Google-Test-generated message.
07097 GTEST_API_ std::string AppendUserMessage(
07098     const std::string& gtest_msg, const Message& user_msg);
07099 
07100 #if GTEST_HAS_EXCEPTIONS
07101 
07102 // This exception is thrown by (and only by) a failed Google Test
07103 // assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions
07104 // are enabled).  We derive it from std::runtime_error, which is for
07105 // errors presumably detectable only at run time.  Since
07106 // std::runtime_error inherits from std::exception, many testing
07107 // frameworks know how to extract and print the message inside it.
07108 class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
07109  public:
07110   explicit GoogleTestFailureException(const TestPartResult& failure);
07111 };
07112 
07113 #endif  // GTEST_HAS_EXCEPTIONS
07114 
07115 // A helper class for creating scoped traces in user programs.
07116 class GTEST_API_ ScopedTrace {
07117  public:
07118   // The c'tor pushes the given source file location and message onto
07119   // a trace stack maintained by Google Test.
07120   ScopedTrace(const char* file, int line, const Message& message);
07121 
07122   // The d'tor pops the info pushed by the c'tor.
07123   //
07124   // Note that the d'tor is not virtual in order to be efficient.
07125   // Don't inherit from ScopedTrace!
07126   ~ScopedTrace();
07127 
07128  private:
07129   GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace);
07130 } GTEST_ATTRIBUTE_UNUSED_;  // A ScopedTrace object does its job in its
07131                             // c'tor and d'tor.  Therefore it doesn't
07132                             // need to be used otherwise.
07133 
07134 // Constructs and returns the message for an equality assertion
07135 // (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
07136 //
07137 // The first four parameters are the expressions used in the assertion
07138 // and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
07139 // where foo is 5 and bar is 6, we have:
07140 //
07141 //   expected_expression: "foo"
07142 //   actual_expression:   "bar"
07143 //   expected_value:      "5"
07144 //   actual_value:        "6"
07145 //
07146 // The ignoring_case parameter is true iff the assertion is a
07147 // *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will
07148 // be inserted into the message.
07149 GTEST_API_ AssertionResult EqFailure(const char* expected_expression,
07150                                      const char* actual_expression,
07151                                      const std::string& expected_value,
07152                                      const std::string& actual_value,
07153                                      bool ignoring_case);
07154 
07155 // Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
07156 GTEST_API_ std::string GetBoolAssertionFailureMessage(
07157     const AssertionResult& assertion_result,
07158     const char* expression_text,
07159     const char* actual_predicate_value,
07160     const char* expected_predicate_value);
07161 
07162 // This template class represents an IEEE floating-point number
07163 // (either single-precision or double-precision, depending on the
07164 // template parameters).
07165 //
07166 // The purpose of this class is to do more sophisticated number
07167 // comparison.  (Due to round-off error, etc, it's very unlikely that
07168 // two floating-points will be equal exactly.  Hence a naive
07169 // comparison by the == operation often doesn't work.)
07170 //
07171 // Format of IEEE floating-point:
07172 //
07173 //   The most-significant bit being the leftmost, an IEEE
07174 //   floating-point looks like
07175 //
07176 //     sign_bit exponent_bits fraction_bits
07177 //
07178 //   Here, sign_bit is a single bit that designates the sign of the
07179 //   number.
07180 //
07181 //   For float, there are 8 exponent bits and 23 fraction bits.
07182 //
07183 //   For double, there are 11 exponent bits and 52 fraction bits.
07184 //
07185 //   More details can be found at
07186 //   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
07187 //
07188 // Template parameter:
07189 //
07190 //   RawType: the raw floating-point type (either float or double)
07191 template <typename RawType>
07192 class FloatingPoint {
07193  public:
07194   // Defines the unsigned integer type that has the same size as the
07195   // floating point number.
07196   typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits;
07197 
07198   // Constants.
07199 
07200   // # of bits in a number.
07201   static const size_t kBitCount = 8*sizeof(RawType);
07202 
07203   // # of fraction bits in a number.
07204   static const size_t kFractionBitCount =
07205     std::numeric_limits<RawType>::digits - 1;
07206 
07207   // # of exponent bits in a number.
07208   static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;
07209 
07210   // The mask for the sign bit.
07211   static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);
07212 
07213   // The mask for the fraction bits.
07214   static const Bits kFractionBitMask =
07215     ~static_cast<Bits>(0) >> (kExponentBitCount + 1);
07216 
07217   // The mask for the exponent bits.
07218   static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);
07219 
07220   // How many ULP's (Units in the Last Place) we want to tolerate when
07221   // comparing two numbers.  The larger the value, the more error we
07222   // allow.  A 0 value means that two numbers must be exactly the same
07223   // to be considered equal.
07224   //
07225   // The maximum error of a single floating-point operation is 0.5
07226   // units in the last place.  On Intel CPU's, all floating-point
07227   // calculations are done with 80-bit precision, while double has 64
07228   // bits.  Therefore, 4 should be enough for ordinary use.
07229   //
07230   // See the following article for more details on ULP:
07231   // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
07232   static const size_t kMaxUlps = 4;
07233 
07234   // Constructs a FloatingPoint from a raw floating-point number.
07235   //
07236   // On an Intel CPU, passing a non-normalized NAN (Not a Number)
07237   // around may change its bits, although the new value is guaranteed
07238   // to be also a NAN.  Therefore, don't expect this constructor to
07239   // preserve the bits in x when x is a NAN.
07240   explicit FloatingPoint(const RawType& x) { u_.value_ = x; }
07241 
07242   // Static methods
07243 
07244   // Reinterprets a bit pattern as a floating-point number.
07245   //
07246   // This function is needed to test the AlmostEquals() method.
07247   static RawType ReinterpretBits(const Bits bits) {
07248     FloatingPoint fp(0);
07249     fp.u_.bits_ = bits;
07250     return fp.u_.value_;
07251   }
07252 
07253   // Returns the floating-point number that represent positive infinity.
07254   static RawType Infinity() {
07255     return ReinterpretBits(kExponentBitMask);
07256   }
07257 
07258   // Returns the maximum representable finite floating-point number.
07259   static RawType Max();
07260 
07261   // Non-static methods
07262 
07263   // Returns the bits that represents this number.
07264   const Bits &bits() const { return u_.bits_; }
07265 
07266   // Returns the exponent bits of this number.
07267   Bits exponent_bits() const { return kExponentBitMask & u_.bits_; }
07268 
07269   // Returns the fraction bits of this number.
07270   Bits fraction_bits() const { return kFractionBitMask & u_.bits_; }
07271 
07272   // Returns the sign bit of this number.
07273   Bits sign_bit() const { return kSignBitMask & u_.bits_; }
07274 
07275   // Returns true iff this is NAN (not a number).
07276   bool is_nan() const {
07277     // It's a NAN if the exponent bits are all ones and the fraction
07278     // bits are not entirely zeros.
07279     return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);
07280   }
07281 
07282   // Returns true iff this number is at most kMaxUlps ULP's away from
07283   // rhs.  In particular, this function:
07284   //
07285   //   - returns false if either number is (or both are) NAN.
07286   //   - treats really large numbers as almost equal to infinity.
07287   //   - thinks +0.0 and -0.0 are 0 DLP's apart.
07288   bool AlmostEquals(const FloatingPoint& rhs) const {
07289     // The IEEE standard says that any comparison operation involving
07290     // a NAN must return false.
07291     if (is_nan() || rhs.is_nan()) return false;
07292 
07293     return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
07294         <= kMaxUlps;
07295   }
07296 
07297  private:
07298   // The data type used to store the actual floating-point number.
07299   union FloatingPointUnion {
07300     RawType value_;  // The raw floating-point number.
07301     Bits bits_;      // The bits that represent the number.
07302   };
07303 
07304   // Converts an integer from the sign-and-magnitude representation to
07305   // the biased representation.  More precisely, let N be 2 to the
07306   // power of (kBitCount - 1), an integer x is represented by the
07307   // unsigned number x + N.
07308   //
07309   // For instance,
07310   //
07311   //   -N + 1 (the most negative number representable using
07312   //          sign-and-magnitude) is represented by 1;
07313   //   0      is represented by N; and
07314   //   N - 1  (the biggest number representable using
07315   //          sign-and-magnitude) is represented by 2N - 1.
07316   //
07317   // Read http://en.wikipedia.org/wiki/Signed_number_representations
07318   // for more details on signed number representations.
07319   static Bits SignAndMagnitudeToBiased(const Bits &sam) {
07320     if (kSignBitMask & sam) {
07321       // sam represents a negative number.
07322       return ~sam + 1;
07323     } else {
07324       // sam represents a positive number.
07325       return kSignBitMask | sam;
07326     }
07327   }
07328 
07329   // Given two numbers in the sign-and-magnitude representation,
07330   // returns the distance between them as an unsigned number.
07331   static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1,
07332                                                      const Bits &sam2) {
07333     const Bits biased1 = SignAndMagnitudeToBiased(sam1);
07334     const Bits biased2 = SignAndMagnitudeToBiased(sam2);
07335     return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
07336   }
07337 
07338   FloatingPointUnion u_;
07339 };
07340 
07341 // We cannot use std::numeric_limits<T>::max() as it clashes with the max()
07342 // macro defined by <windows.h>.
07343 template <>
07344 inline float FloatingPoint<float>::Max() { return FLT_MAX; }
07345 template <>
07346 inline double FloatingPoint<double>::Max() { return DBL_MAX; }
07347 
07348 // Typedefs the instances of the FloatingPoint template class that we
07349 // care to use.
07350 typedef FloatingPoint<float> Float;
07351 typedef FloatingPoint<double> Double;
07352 
07353 // In order to catch the mistake of putting tests that use different
07354 // test fixture classes in the same test case, we need to assign
07355 // unique IDs to fixture classes and compare them.  The TypeId type is
07356 // used to hold such IDs.  The user should treat TypeId as an opaque
07357 // type: the only operation allowed on TypeId values is to compare
07358 // them for equality using the == operator.
07359 typedef const void* TypeId;
07360 
07361 template <typename T>
07362 class TypeIdHelper {
07363  public:
07364   // dummy_ must not have a const type.  Otherwise an overly eager
07365   // compiler (e.g. MSVC 7.1 & 8.0) may try to merge
07366   // TypeIdHelper<T>::dummy_ for different Ts as an "optimization".
07367   static bool dummy_;
07368 };
07369 
07370 template <typename T>
07371 bool TypeIdHelper<T>::dummy_ = false;
07372 
07373 // GetTypeId<T>() returns the ID of type T.  Different values will be
07374 // returned for different types.  Calling the function twice with the
07375 // same type argument is guaranteed to return the same ID.
07376 template <typename T>
07377 TypeId GetTypeId() {
07378   // The compiler is required to allocate a different
07379   // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
07380   // the template.  Therefore, the address of dummy_ is guaranteed to
07381   // be unique.
07382   return &(TypeIdHelper<T>::dummy_);
07383 }
07384 
07385 // Returns the type ID of ::testing::Test.  Always call this instead
07386 // of GetTypeId< ::testing::Test>() to get the type ID of
07387 // ::testing::Test, as the latter may give the wrong result due to a
07388 // suspected linker bug when compiling Google Test as a Mac OS X
07389 // framework.
07390 GTEST_API_ TypeId GetTestTypeId();
07391 
07392 // Defines the abstract factory interface that creates instances
07393 // of a Test object.
07394 class TestFactoryBase {
07395  public:
07396   virtual ~TestFactoryBase() {}
07397 
07398   // Creates a test instance to run. The instance is both created and destroyed
07399   // within TestInfoImpl::Run()
07400   virtual Test* CreateTest() = 0;
07401 
07402  protected:
07403   TestFactoryBase() {}
07404 
07405  private:
07406   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase);
07407 };
07408 
07409 // This class provides implementation of TeastFactoryBase interface.
07410 // It is used in TEST and TEST_F macros.
07411 template <class TestClass>
07412 class TestFactoryImpl : public TestFactoryBase {
07413  public:
07414   virtual Test* CreateTest() { return new TestClass; }
07415 };
07416 
07417 #if GTEST_OS_WINDOWS
07418 
07419 // Predicate-formatters for implementing the HRESULT checking macros
07420 // {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}
07421 // We pass a long instead of HRESULT to avoid causing an
07422 // include dependency for the HRESULT type.
07423 GTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr,
07424                                             long hr);  // NOLINT
07425 GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr,
07426                                             long hr);  // NOLINT
07427 
07428 #endif  // GTEST_OS_WINDOWS
07429 
07430 // Types of SetUpTestCase() and TearDownTestCase() functions.
07431 typedef void (*SetUpTestCaseFunc)();
07432 typedef void (*TearDownTestCaseFunc)();
07433 
07434 // Creates a new TestInfo object and registers it with Google Test;
07435 // returns the created object.
07436 //
07437 // Arguments:
07438 //
07439 //   test_case_name:   name of the test case
07440 //   name:             name of the test
07441 //   type_param        the name of the test's type parameter, or NULL if
07442 //                     this is not a typed or a type-parameterized test.
07443 //   value_param       text representation of the test's value parameter,
07444 //                     or NULL if this is not a type-parameterized test.
07445 //   fixture_class_id: ID of the test fixture class
07446 //   set_up_tc:        pointer to the function that sets up the test case
07447 //   tear_down_tc:     pointer to the function that tears down the test case
07448 //   factory:          pointer to the factory that creates a test object.
07449 //                     The newly created TestInfo instance will assume
07450 //                     ownership of the factory object.
07451 GTEST_API_ TestInfo* MakeAndRegisterTestInfo(
07452     const char* test_case_name,
07453     const char* name,
07454     const char* type_param,
07455     const char* value_param,
07456     TypeId fixture_class_id,
07457     SetUpTestCaseFunc set_up_tc,
07458     TearDownTestCaseFunc tear_down_tc,
07459     TestFactoryBase* factory);
07460 
07461 // If *pstr starts with the given prefix, modifies *pstr to be right
07462 // past the prefix and returns true; otherwise leaves *pstr unchanged
07463 // and returns false.  None of pstr, *pstr, and prefix can be NULL.
07464 GTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr);
07465 
07466 #if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
07467 
07468 // State of the definition of a type-parameterized test case.
07469 class GTEST_API_ TypedTestCasePState {
07470  public:
07471   TypedTestCasePState() : registered_(false) {}
07472 
07473   // Adds the given test name to defined_test_names_ and return true
07474   // if the test case hasn't been registered; otherwise aborts the
07475   // program.
07476   bool AddTestName(const char* file, int line, const char* case_name,
07477                    const char* test_name) {
07478     if (registered_) {
07479       fprintf(stderr, "%s Test %s must be defined before "
07480               "REGISTER_TYPED_TEST_CASE_P(%s, ...).\n",
07481               FormatFileLocation(file, line).c_str(), test_name, case_name);
07482       fflush(stderr);
07483       posix::Abort();
07484     }
07485     defined_test_names_.insert(test_name);
07486     return true;
07487   }
07488 
07489   // Verifies that registered_tests match the test names in
07490   // defined_test_names_; returns registered_tests if successful, or
07491   // aborts the program otherwise.
07492   const char* VerifyRegisteredTestNames(
07493       const char* file, int line, const char* registered_tests);
07494 
07495  private:
07496   bool registered_;
07497   ::std::set<const char*> defined_test_names_;
07498 };
07499 
07500 // Skips to the first non-space char after the first comma in 'str';
07501 // returns NULL if no comma is found in 'str'.
07502 inline const char* SkipComma(const char* str) {
07503   const char* comma = strchr(str, ',');
07504   if (comma == NULL) {
07505     return NULL;
07506   }
07507   while (IsSpace(*(++comma))) {}
07508   return comma;
07509 }
07510 
07511 // Returns the prefix of 'str' before the first comma in it; returns
07512 // the entire string if it contains no comma.
07513 inline std::string GetPrefixUntilComma(const char* str) {
07514   const char* comma = strchr(str, ',');
07515   return comma == NULL ? str : std::string(str, comma);
07516 }
07517 
07518 // TypeParameterizedTest<Fixture, TestSel, Types>::Register()
07519 // registers a list of type-parameterized tests with Google Test.  The
07520 // return value is insignificant - we just need to return something
07521 // such that we can call this function in a namespace scope.
07522 //
07523 // Implementation note: The GTEST_TEMPLATE_ macro declares a template
07524 // template parameter.  It's defined in gtest-type-util.h.
07525 template <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types>
07526 class TypeParameterizedTest {
07527  public:
07528   // 'index' is the index of the test in the type list 'Types'
07529   // specified in INSTANTIATE_TYPED_TEST_CASE_P(Prefix, TestCase,
07530   // Types).  Valid values for 'index' are [0, N - 1] where N is the
07531   // length of Types.
07532   static bool Register(const char* prefix, const char* case_name,
07533                        const char* test_names, int index) {
07534     typedef typename Types::Head Type;
07535     typedef Fixture<Type> FixtureClass;
07536     typedef typename GTEST_BIND_(TestSel, Type) TestClass;
07537 
07538     // First, registers the first type-parameterized test in the type
07539     // list.
07540     MakeAndRegisterTestInfo(
07541         (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/"
07542          + StreamableToString(index)).c_str(),
07543         GetPrefixUntilComma(test_names).c_str(),
07544         GetTypeName<Type>().c_str(),
07545         NULL,  // No value parameter.
07546         GetTypeId<FixtureClass>(),
07547         TestClass::SetUpTestCase,
07548         TestClass::TearDownTestCase,
07549         new TestFactoryImpl<TestClass>);
07550 
07551     // Next, recurses (at compile time) with the tail of the type list.
07552     return TypeParameterizedTest<Fixture, TestSel, typename Types::Tail>
07553         ::Register(prefix, case_name, test_names, index + 1);
07554   }
07555 };
07556 
07557 // The base case for the compile time recursion.
07558 template <GTEST_TEMPLATE_ Fixture, class TestSel>
07559 class TypeParameterizedTest<Fixture, TestSel, Types0> {
07560  public:
07561   static bool Register(const char* /*prefix*/, const char* /*case_name*/,
07562                        const char* /*test_names*/, int /*index*/) {
07563     return true;
07564   }
07565 };
07566 
07567 // TypeParameterizedTestCase<Fixture, Tests, Types>::Register()
07568 // registers *all combinations* of 'Tests' and 'Types' with Google
07569 // Test.  The return value is insignificant - we just need to return
07570 // something such that we can call this function in a namespace scope.
07571 template <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types>
07572 class TypeParameterizedTestCase {
07573  public:
07574   static bool Register(const char* prefix, const char* case_name,
07575                        const char* test_names) {
07576     typedef typename Tests::Head Head;
07577 
07578     // First, register the first test in 'Test' for each type in 'Types'.
07579     TypeParameterizedTest<Fixture, Head, Types>::Register(
07580         prefix, case_name, test_names, 0);
07581 
07582     // Next, recurses (at compile time) with the tail of the test list.
07583     return TypeParameterizedTestCase<Fixture, typename Tests::Tail, Types>
07584         ::Register(prefix, case_name, SkipComma(test_names));
07585   }
07586 };
07587 
07588 // The base case for the compile time recursion.
07589 template <GTEST_TEMPLATE_ Fixture, typename Types>
07590 class TypeParameterizedTestCase<Fixture, Templates0, Types> {
07591  public:
07592   static bool Register(const char* /*prefix*/, const char* /*case_name*/,
07593                        const char* /*test_names*/) {
07594     return true;
07595   }
07596 };
07597 
07598 #endif  // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
07599 
07600 // Returns the current OS stack trace as an std::string.
07601 //
07602 // The maximum number of stack frames to be included is specified by
07603 // the gtest_stack_trace_depth flag.  The skip_count parameter
07604 // specifies the number of top frames to be skipped, which doesn't
07605 // count against the number of frames to be included.
07606 //
07607 // For example, if Foo() calls Bar(), which in turn calls
07608 // GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
07609 // the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
07610 GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(
07611     UnitTest* unit_test, int skip_count);
07612 
07613 // Helpers for suppressing warnings on unreachable code or constant
07614 // condition.
07615 
07616 // Always returns true.
07617 GTEST_API_ bool AlwaysTrue();
07618 
07619 // Always returns false.
07620 inline bool AlwaysFalse() { return !AlwaysTrue(); }
07621 
07622 // Helper for suppressing false warning from Clang on a const char*
07623 // variable declared in a conditional expression always being NULL in
07624 // the else branch.
07625 struct GTEST_API_ ConstCharPtr {
07626   ConstCharPtr(const char* str) : value(str) {}
07627   operator bool() const { return true; }
07628   const char* value;
07629 };
07630 
07631 // A simple Linear Congruential Generator for generating random
07632 // numbers with a uniform distribution.  Unlike rand() and srand(), it
07633 // doesn't use global state (and therefore can't interfere with user
07634 // code).  Unlike rand_r(), it's portable.  An LCG isn't very random,
07635 // but it's good enough for our purposes.
07636 class GTEST_API_ Random {
07637  public:
07638   static const UInt32 kMaxRange = 1u << 31;
07639 
07640   explicit Random(UInt32 seed) : state_(seed) {}
07641 
07642   void Reseed(UInt32 seed) { state_ = seed; }
07643 
07644   // Generates a random number from [0, range).  Crashes if 'range' is
07645   // 0 or greater than kMaxRange.
07646   UInt32 Generate(UInt32 range);
07647 
07648  private:
07649   UInt32 state_;
07650   GTEST_DISALLOW_COPY_AND_ASSIGN_(Random);
07651 };
07652 
07653 // Defining a variable of type CompileAssertTypesEqual<T1, T2> will cause a
07654 // compiler error iff T1 and T2 are different types.
07655 template <typename T1, typename T2>
07656 struct CompileAssertTypesEqual;
07657 
07658 template <typename T>
07659 struct CompileAssertTypesEqual<T, T> {
07660 };
07661 
07662 // Removes the reference from a type if it is a reference type,
07663 // otherwise leaves it unchanged.  This is the same as
07664 // tr1::remove_reference, which is not widely available yet.
07665 template <typename T>
07666 struct RemoveReference { typedef T type; };  // NOLINT
07667 template <typename T>
07668 struct RemoveReference<T&> { typedef T type; };  // NOLINT
07669 
07670 // A handy wrapper around RemoveReference that works when the argument
07671 // T depends on template parameters.
07672 #define GTEST_REMOVE_REFERENCE_(T) \
07673     typename ::testing::internal::RemoveReference<T>::type
07674 
07675 // Removes const from a type if it is a const type, otherwise leaves
07676 // it unchanged.  This is the same as tr1::remove_const, which is not
07677 // widely available yet.
07678 template <typename T>
07679 struct RemoveConst { typedef T type; };  // NOLINT
07680 template <typename T>
07681 struct RemoveConst<const T> { typedef T type; };  // NOLINT
07682 
07683 // MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above
07684 // definition to fail to remove the const in 'const int[3]' and 'const
07685 // char[3][4]'.  The following specialization works around the bug.
07686 template <typename T, size_t N>
07687 struct RemoveConst<const T[N]> {
07688   typedef typename RemoveConst<T>::type type[N];
07689 };
07690 
07691 #if defined(_MSC_VER) && _MSC_VER < 1400
07692 // This is the only specialization that allows VC++ 7.1 to remove const in
07693 // 'const int[3] and 'const int[3][4]'.  However, it causes trouble with GCC
07694 // and thus needs to be conditionally compiled.
07695 template <typename T, size_t N>
07696 struct RemoveConst<T[N]> {
07697   typedef typename RemoveConst<T>::type type[N];
07698 };
07699 #endif
07700 
07701 // A handy wrapper around RemoveConst that works when the argument
07702 // T depends on template parameters.
07703 #define GTEST_REMOVE_CONST_(T) \
07704     typename ::testing::internal::RemoveConst<T>::type
07705 
07706 // Turns const U&, U&, const U, and U all into U.
07707 #define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \
07708     GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T))
07709 
07710 // Adds reference to a type if it is not a reference type,
07711 // otherwise leaves it unchanged.  This is the same as
07712 // tr1::add_reference, which is not widely available yet.
07713 template <typename T>
07714 struct AddReference { typedef T& type; };  // NOLINT
07715 template <typename T>
07716 struct AddReference<T&> { typedef T& type; };  // NOLINT
07717 
07718 // A handy wrapper around AddReference that works when the argument T
07719 // depends on template parameters.
07720 #define GTEST_ADD_REFERENCE_(T) \
07721     typename ::testing::internal::AddReference<T>::type
07722 
07723 // Adds a reference to const on top of T as necessary.  For example,
07724 // it transforms
07725 //
07726 //   char         ==> const char&
07727 //   const char   ==> const char&
07728 //   char&        ==> const char&
07729 //   const char&  ==> const char&
07730 //
07731 // The argument T must depend on some template parameters.
07732 #define GTEST_REFERENCE_TO_CONST_(T) \
07733     GTEST_ADD_REFERENCE_(const GTEST_REMOVE_REFERENCE_(T))
07734 
07735 // ImplicitlyConvertible<From, To>::value is a compile-time bool
07736 // constant that's true iff type From can be implicitly converted to
07737 // type To.
07738 template <typename From, typename To>
07739 class ImplicitlyConvertible {
07740  private:
07741   // We need the following helper functions only for their types.
07742   // They have no implementations.
07743 
07744   // MakeFrom() is an expression whose type is From.  We cannot simply
07745   // use From(), as the type From may not have a public default
07746   // constructor.
07747   static From MakeFrom();
07748 
07749   // These two functions are overloaded.  Given an expression
07750   // Helper(x), the compiler will pick the first version if x can be
07751   // implicitly converted to type To; otherwise it will pick the
07752   // second version.
07753   //
07754   // The first version returns a value of size 1, and the second
07755   // version returns a value of size 2.  Therefore, by checking the
07756   // size of Helper(x), which can be done at compile time, we can tell
07757   // which version of Helper() is used, and hence whether x can be
07758   // implicitly converted to type To.
07759   static char Helper(To);
07760   static char (&Helper(...))[2];  // NOLINT
07761 
07762   // We have to put the 'public' section after the 'private' section,
07763   // or MSVC refuses to compile the code.
07764  public:
07765   // MSVC warns about implicitly converting from double to int for
07766   // possible loss of data, so we need to temporarily disable the
07767   // warning.
07768 #ifdef _MSC_VER
07769 # pragma warning(push)          // Saves the current warning state.
07770 # pragma warning(disable:4244)  // Temporarily disables warning 4244.
07771 
07772   static const bool value =
07773       sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1;
07774 # pragma warning(pop)           // Restores the warning state.
07775 #elif defined(__BORLANDC__)
07776   // C++Builder cannot use member overload resolution during template
07777   // instantiation.  The simplest workaround is to use its C++0x type traits
07778   // functions (C++Builder 2009 and above only).
07779   static const bool value = __is_convertible(From, To);
07780 #else
07781   static const bool value =
07782       sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1;
07783 #endif  // _MSV_VER
07784 };
07785 template <typename From, typename To>
07786 const bool ImplicitlyConvertible<From, To>::value;
07787 
07788 // IsAProtocolMessage<T>::value is a compile-time bool constant that's
07789 // true iff T is type ProtocolMessage, proto2::Message, or a subclass
07790 // of those.
07791 template <typename T>
07792 struct IsAProtocolMessage
07793     : public bool_constant<
07794   ImplicitlyConvertible<const T*, const ::ProtocolMessage*>::value ||
07795   ImplicitlyConvertible<const T*, const ::proto2::Message*>::value> {
07796 };
07797 
07798 // When the compiler sees expression IsContainerTest<C>(0), if C is an
07799 // STL-style container class, the first overload of IsContainerTest
07800 // will be viable (since both C::iterator* and C::const_iterator* are
07801 // valid types and NULL can be implicitly converted to them).  It will
07802 // be picked over the second overload as 'int' is a perfect match for
07803 // the type of argument 0.  If C::iterator or C::const_iterator is not
07804 // a valid type, the first overload is not viable, and the second
07805 // overload will be picked.  Therefore, we can determine whether C is
07806 // a container class by checking the type of IsContainerTest<C>(0).
07807 // The value of the expression is insignificant.
07808 //
07809 // Note that we look for both C::iterator and C::const_iterator.  The
07810 // reason is that C++ injects the name of a class as a member of the
07811 // class itself (e.g. you can refer to class iterator as either
07812 // 'iterator' or 'iterator::iterator').  If we look for C::iterator
07813 // only, for example, we would mistakenly think that a class named
07814 // iterator is an STL container.
07815 //
07816 // Also note that the simpler approach of overloading
07817 // IsContainerTest(typename C::const_iterator*) and
07818 // IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++.
07819 typedef int IsContainer;
07820 template <class C>
07821 IsContainer IsContainerTest(int /* dummy */,
07822                             typename C::iterator* /* it */ = NULL,
07823                             typename C::const_iterator* /* const_it */ = NULL) {
07824   return 0;
07825 }
07826 
07827 typedef char IsNotContainer;
07828 template <class C>
07829 IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; }
07830 
07831 // EnableIf<condition>::type is void when 'Cond' is true, and
07832 // undefined when 'Cond' is false.  To use SFINAE to make a function
07833 // overload only apply when a particular expression is true, add
07834 // "typename EnableIf<expression>::type* = 0" as the last parameter.
07835 template<bool> struct EnableIf;
07836 template<> struct EnableIf<true> { typedef void type; };  // NOLINT
07837 
07838 // Utilities for native arrays.
07839 
07840 // ArrayEq() compares two k-dimensional native arrays using the
07841 // elements' operator==, where k can be any integer >= 0.  When k is
07842 // 0, ArrayEq() degenerates into comparing a single pair of values.
07843 
07844 template <typename T, typename U>
07845 bool ArrayEq(const T* lhs, size_t size, const U* rhs);
07846 
07847 // This generic version is used when k is 0.
07848 template <typename T, typename U>
07849 inline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; }
07850 
07851 // This overload is used when k >= 1.
07852 template <typename T, typename U, size_t N>
07853 inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) {
07854   return internal::ArrayEq(lhs, N, rhs);
07855 }
07856 
07857 // This helper reduces code bloat.  If we instead put its logic inside
07858 // the previous ArrayEq() function, arrays with different sizes would
07859 // lead to different copies of the template code.
07860 template <typename T, typename U>
07861 bool ArrayEq(const T* lhs, size_t size, const U* rhs) {
07862   for (size_t i = 0; i != size; i++) {
07863     if (!internal::ArrayEq(lhs[i], rhs[i]))
07864       return false;
07865   }
07866   return true;
07867 }
07868 
07869 // Finds the first element in the iterator range [begin, end) that
07870 // equals elem.  Element may be a native array type itself.
07871 template <typename Iter, typename Element>
07872 Iter ArrayAwareFind(Iter begin, Iter end, const Element& elem) {
07873   for (Iter it = begin; it != end; ++it) {
07874     if (internal::ArrayEq(*it, elem))
07875       return it;
07876   }
07877   return end;
07878 }
07879 
07880 // CopyArray() copies a k-dimensional native array using the elements'
07881 // operator=, where k can be any integer >= 0.  When k is 0,
07882 // CopyArray() degenerates into copying a single value.
07883 
07884 template <typename T, typename U>
07885 void CopyArray(const T* from, size_t size, U* to);
07886 
07887 // This generic version is used when k is 0.
07888 template <typename T, typename U>
07889 inline void CopyArray(const T& from, U* to) { *to = from; }
07890 
07891 // This overload is used when k >= 1.
07892 template <typename T, typename U, size_t N>
07893 inline void CopyArray(const T(&from)[N], U(*to)[N]) {
07894   internal::CopyArray(from, N, *to);
07895 }
07896 
07897 // This helper reduces code bloat.  If we instead put its logic inside
07898 // the previous CopyArray() function, arrays with different sizes
07899 // would lead to different copies of the template code.
07900 template <typename T, typename U>
07901 void CopyArray(const T* from, size_t size, U* to) {
07902   for (size_t i = 0; i != size; i++) {
07903     internal::CopyArray(from[i], to + i);
07904   }
07905 }
07906 
07907 // The relation between an NativeArray object (see below) and the
07908 // native array it represents.
07909 enum RelationToSource {
07910   kReference,  // The NativeArray references the native array.
07911   kCopy        // The NativeArray makes a copy of the native array and
07912                // owns the copy.
07913 };
07914 
07915 // Adapts a native array to a read-only STL-style container.  Instead
07916 // of the complete STL container concept, this adaptor only implements
07917 // members useful for Google Mock's container matchers.  New members
07918 // should be added as needed.  To simplify the implementation, we only
07919 // support Element being a raw type (i.e. having no top-level const or
07920 // reference modifier).  It's the client's responsibility to satisfy
07921 // this requirement.  Element can be an array type itself (hence
07922 // multi-dimensional arrays are supported).
07923 template <typename Element>
07924 class NativeArray {
07925  public:
07926   // STL-style container typedefs.
07927   typedef Element value_type;
07928   typedef Element* iterator;
07929   typedef const Element* const_iterator;
07930 
07931   // Constructs from a native array.
07932   NativeArray(const Element* array, size_t count, RelationToSource relation) {
07933     Init(array, count, relation);
07934   }
07935 
07936   // Copy constructor.
07937   NativeArray(const NativeArray& rhs) {
07938     Init(rhs.array_, rhs.size_, rhs.relation_to_source_);
07939   }
07940 
07941   ~NativeArray() {
07942     // Ensures that the user doesn't instantiate NativeArray with a
07943     // const or reference type.
07944     static_cast<void>(StaticAssertTypeEqHelper<Element,
07945         GTEST_REMOVE_REFERENCE_AND_CONST_(Element)>());
07946     if (relation_to_source_ == kCopy)
07947       delete[] array_;
07948   }
07949 
07950   // STL-style container methods.
07951   size_t size() const { return size_; }
07952   const_iterator begin() const { return array_; }
07953   const_iterator end() const { return array_ + size_; }
07954   bool operator==(const NativeArray& rhs) const {
07955     return size() == rhs.size() &&
07956         ArrayEq(begin(), size(), rhs.begin());
07957   }
07958 
07959  private:
07960   // Initializes this object; makes a copy of the input array if
07961   // 'relation' is kCopy.
07962   void Init(const Element* array, size_t a_size, RelationToSource relation) {
07963     if (relation == kReference) {
07964       array_ = array;
07965     } else {
07966       Element* const copy = new Element[a_size];
07967       CopyArray(array, a_size, copy);
07968       array_ = copy;
07969     }
07970     size_ = a_size;
07971     relation_to_source_ = relation;
07972   }
07973 
07974   const Element* array_;
07975   size_t size_;
07976   RelationToSource relation_to_source_;
07977 
07978   GTEST_DISALLOW_ASSIGN_(NativeArray);
07979 };
07980 
07981 }  // namespace internal
07982 }  // namespace testing
07983 
07984 #define GTEST_MESSAGE_AT_(file, line, message, result_type) \
07985   ::testing::internal::AssertHelper(result_type, file, line, message) \
07986     = ::testing::Message()
07987 
07988 #define GTEST_MESSAGE_(message, result_type) \
07989   GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
07990 
07991 #define GTEST_FATAL_FAILURE_(message) \
07992   return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)
07993 
07994 #define GTEST_NONFATAL_FAILURE_(message) \
07995   GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
07996 
07997 #define GTEST_SUCCESS_(message) \
07998   GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)
07999 
08000 // Suppresses MSVC warnings 4072 (unreachable code) for the code following
08001 // statement if it returns or throws (or doesn't return or throw in some
08002 // situations).
08003 #define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
08004   if (::testing::internal::AlwaysTrue()) { statement; }
08005 
08006 #define GTEST_TEST_THROW_(statement, expected_exception, fail) \
08007   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
08008   if (::testing::internal::ConstCharPtr gtest_msg = "") { \
08009     bool gtest_caught_expected = false; \
08010     try { \
08011       GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
08012     } \
08013     catch (expected_exception const&) { \
08014       gtest_caught_expected = true; \
08015     } \
08016     catch (...) { \
08017       gtest_msg.value = \
08018           "Expected: " #statement " throws an exception of type " \
08019           #expected_exception ".\n  Actual: it throws a different type."; \
08020       goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
08021     } \
08022     if (!gtest_caught_expected) { \
08023       gtest_msg.value = \
08024           "Expected: " #statement " throws an exception of type " \
08025           #expected_exception ".\n  Actual: it throws nothing."; \
08026       goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \
08027     } \
08028   } else \
08029     GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \
08030       fail(gtest_msg.value)
08031 
08032 #define GTEST_TEST_NO_THROW_(statement, fail) \
08033   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
08034   if (::testing::internal::AlwaysTrue()) { \
08035     try { \
08036       GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
08037     } \
08038     catch (...) { \
08039       goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
08040     } \
08041   } else \
08042     GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \
08043       fail("Expected: " #statement " doesn't throw an exception.\n" \
08044            "  Actual: it throws.")
08045 
08046 #define GTEST_TEST_ANY_THROW_(statement, fail) \
08047   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
08048   if (::testing::internal::AlwaysTrue()) { \
08049     bool gtest_caught_any = false; \
08050     try { \
08051       GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
08052     } \
08053     catch (...) { \
08054       gtest_caught_any = true; \
08055     } \
08056     if (!gtest_caught_any) { \
08057       goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \
08058     } \
08059   } else \
08060     GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \
08061       fail("Expected: " #statement " throws an exception.\n" \
08062            "  Actual: it doesn't.")
08063 
08064 
08065 // Implements Boolean test assertions such as EXPECT_TRUE. expression can be
08066 // either a boolean expression or an AssertionResult. text is a textual
08067 // represenation of expression as it was passed into the EXPECT_TRUE.
08068 #define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
08069   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
08070   if (const ::testing::AssertionResult gtest_ar_ = \
08071       ::testing::AssertionResult(expression)) \
08072     ; \
08073   else \
08074     fail(::testing::internal::GetBoolAssertionFailureMessage(\
08075         gtest_ar_, text, #actual, #expected).c_str())
08076 
08077 #define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \
08078   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
08079   if (::testing::internal::AlwaysTrue()) { \
08080     ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
08081     GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
08082     if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
08083       goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
08084     } \
08085   } else \
08086     GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \
08087       fail("Expected: " #statement " doesn't generate new fatal " \
08088            "failures in the current thread.\n" \
08089            "  Actual: it does.")
08090 
08091 // Expands to the name of the class that implements the given test.
08092 #define GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
08093   test_case_name##_##test_name##_Test
08094 
08095 // Helper macro for defining tests.
08096 #define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\
08097 class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\
08098  public:\
08099   GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {}\
08100  private:\
08101   virtual void TestBody();\
08102   static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;\
08103   GTEST_DISALLOW_COPY_AND_ASSIGN_(\
08104       GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\
08105 };\
08106 \
08107 ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\
08108   ::test_info_ =\
08109     ::testing::internal::MakeAndRegisterTestInfo(\
08110         #test_case_name, #test_name, NULL, NULL, \
08111         (parent_id), \
08112         parent_class::SetUpTestCase, \
08113         parent_class::TearDownTestCase, \
08114         new ::testing::internal::TestFactoryImpl<\
08115             GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\
08116 void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
08117 
08118 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
08119 // Copyright 2005, Google Inc.
08120 // All rights reserved.
08121 //
08122 // Redistribution and use in source and binary forms, with or without
08123 // modification, are permitted provided that the following conditions are
08124 // met:
08125 //
08126 //     * Redistributions of source code must retain the above copyright
08127 // notice, this list of conditions and the following disclaimer.
08128 //     * Redistributions in binary form must reproduce the above
08129 // copyright notice, this list of conditions and the following disclaimer
08130 // in the documentation and/or other materials provided with the
08131 // distribution.
08132 //     * Neither the name of Google Inc. nor the names of its
08133 // contributors may be used to endorse or promote products derived from
08134 // this software without specific prior written permission.
08135 //
08136 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
08137 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
08138 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
08139 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
08140 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
08141 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
08142 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
08143 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
08144 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
08145 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
08146 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
08147 //
08148 // Author: wan@google.com (Zhanyong Wan)
08149 //
08150 // The Google C++ Testing Framework (Google Test)
08151 //
08152 // This header file defines the public API for death tests.  It is
08153 // #included by gtest.h so a user doesn't need to include this
08154 // directly.
08155 
08156 #ifndef GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
08157 #define GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
08158 
08159 // Copyright 2005, Google Inc.
08160 // All rights reserved.
08161 //
08162 // Redistribution and use in source and binary forms, with or without
08163 // modification, are permitted provided that the following conditions are
08164 // met:
08165 //
08166 //     * Redistributions of source code must retain the above copyright
08167 // notice, this list of conditions and the following disclaimer.
08168 //     * Redistributions in binary form must reproduce the above
08169 // copyright notice, this list of conditions and the following disclaimer
08170 // in the documentation and/or other materials provided with the
08171 // distribution.
08172 //     * Neither the name of Google Inc. nor the names of its
08173 // contributors may be used to endorse or promote products derived from
08174 // this software without specific prior written permission.
08175 //
08176 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
08177 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
08178 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
08179 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
08180 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
08181 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
08182 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
08183 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
08184 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
08185 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
08186 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
08187 //
08188 // Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
08189 //
08190 // The Google C++ Testing Framework (Google Test)
08191 //
08192 // This header file defines internal utilities needed for implementing
08193 // death tests.  They are subject to change without notice.
08194 
08195 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
08196 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
08197 
08198 
08199 #include <stdio.h>
08200 
08201 namespace testing {
08202 namespace internal {
08203 
08204 GTEST_DECLARE_string_(internal_run_death_test);
08205 
08206 // Names of the flags (needed for parsing Google Test flags).
08207 const char kDeathTestStyleFlag[] = "death_test_style";
08208 const char kDeathTestUseFork[] = "death_test_use_fork";
08209 const char kInternalRunDeathTestFlag[] = "internal_run_death_test";
08210 
08211 #if GTEST_HAS_DEATH_TEST
08212 
08213 // DeathTest is a class that hides much of the complexity of the
08214 // GTEST_DEATH_TEST_ macro.  It is abstract; its static Create method
08215 // returns a concrete class that depends on the prevailing death test
08216 // style, as defined by the --gtest_death_test_style and/or
08217 // --gtest_internal_run_death_test flags.
08218 
08219 // In describing the results of death tests, these terms are used with
08220 // the corresponding definitions:
08221 //
08222 // exit status:  The integer exit information in the format specified
08223 //               by wait(2)
08224 // exit code:    The integer code passed to exit(3), _exit(2), or
08225 //               returned from main()
08226 class GTEST_API_ DeathTest {
08227  public:
08228   // Create returns false if there was an error determining the
08229   // appropriate action to take for the current death test; for example,
08230   // if the gtest_death_test_style flag is set to an invalid value.
08231   // The LastMessage method will return a more detailed message in that
08232   // case.  Otherwise, the DeathTest pointer pointed to by the "test"
08233   // argument is set.  If the death test should be skipped, the pointer
08234   // is set to NULL; otherwise, it is set to the address of a new concrete
08235   // DeathTest object that controls the execution of the current test.
08236   static bool Create(const char* statement, const RE* regex,
08237                      const char* file, int line, DeathTest** test);
08238   DeathTest();
08239   virtual ~DeathTest() { }
08240 
08241   // A helper class that aborts a death test when it's deleted.
08242   class ReturnSentinel {
08243    public:
08244     explicit ReturnSentinel(DeathTest* test) : test_(test) { }
08245     ~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); }
08246    private:
08247     DeathTest* const test_;
08248     GTEST_DISALLOW_COPY_AND_ASSIGN_(ReturnSentinel);
08249   } GTEST_ATTRIBUTE_UNUSED_;
08250 
08251   // An enumeration of possible roles that may be taken when a death
08252   // test is encountered.  EXECUTE means that the death test logic should
08253   // be executed immediately.  OVERSEE means that the program should prepare
08254   // the appropriate environment for a child process to execute the death
08255   // test, then wait for it to complete.
08256   enum TestRole { OVERSEE_TEST, EXECUTE_TEST };
08257 
08258   // An enumeration of the three reasons that a test might be aborted.
08259   enum AbortReason {
08260     TEST_ENCOUNTERED_RETURN_STATEMENT,
08261     TEST_THREW_EXCEPTION,
08262     TEST_DID_NOT_DIE
08263   };
08264 
08265   // Assumes one of the above roles.
08266   virtual TestRole AssumeRole() = 0;
08267 
08268   // Waits for the death test to finish and returns its status.
08269   virtual int Wait() = 0;
08270 
08271   // Returns true if the death test passed; that is, the test process
08272   // exited during the test, its exit status matches a user-supplied
08273   // predicate, and its stderr output matches a user-supplied regular
08274   // expression.
08275   // The user-supplied predicate may be a macro expression rather
08276   // than a function pointer or functor, or else Wait and Passed could
08277   // be combined.
08278   virtual bool Passed(bool exit_status_ok) = 0;
08279 
08280   // Signals that the death test did not die as expected.
08281   virtual void Abort(AbortReason reason) = 0;
08282 
08283   // Returns a human-readable outcome message regarding the outcome of
08284   // the last death test.
08285   static const char* LastMessage();
08286 
08287   static void set_last_death_test_message(const std::string& message);
08288 
08289  private:
08290   // A string containing a description of the outcome of the last death test.
08291   static std::string last_death_test_message_;
08292 
08293   GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest);
08294 };
08295 
08296 // Factory interface for death tests.  May be mocked out for testing.
08297 class DeathTestFactory {
08298  public:
08299   virtual ~DeathTestFactory() { }
08300   virtual bool Create(const char* statement, const RE* regex,
08301                       const char* file, int line, DeathTest** test) = 0;
08302 };
08303 
08304 // A concrete DeathTestFactory implementation for normal use.
08305 class DefaultDeathTestFactory : public DeathTestFactory {
08306  public:
08307   virtual bool Create(const char* statement, const RE* regex,
08308                       const char* file, int line, DeathTest** test);
08309 };
08310 
08311 // Returns true if exit_status describes a process that was terminated
08312 // by a signal, or exited normally with a nonzero exit code.
08313 GTEST_API_ bool ExitedUnsuccessfully(int exit_status);
08314 
08315 // Traps C++ exceptions escaping statement and reports them as test
08316 // failures. Note that trapping SEH exceptions is not implemented here.
08317 # if GTEST_HAS_EXCEPTIONS
08318 #  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
08319   try { \
08320     GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
08321   } catch (const ::std::exception& gtest_exception) { \
08322     fprintf(\
08323         stderr, \
08324         "\n%s: Caught std::exception-derived exception escaping the " \
08325         "death test statement. Exception message: %s\n", \
08326         ::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \
08327         gtest_exception.what()); \
08328     fflush(stderr); \
08329     death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
08330   } catch (...) { \
08331     death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
08332   }
08333 
08334 # else
08335 #  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
08336   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
08337 
08338 # endif
08339 
08340 // This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*,
08341 // ASSERT_EXIT*, and EXPECT_EXIT*.
08342 # define GTEST_DEATH_TEST_(statement, predicate, regex, fail) \
08343   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
08344   if (::testing::internal::AlwaysTrue()) { \
08345     const ::testing::internal::RE& gtest_regex = (regex); \
08346     ::testing::internal::DeathTest* gtest_dt; \
08347     if (!::testing::internal::DeathTest::Create(#statement, &gtest_regex, \
08348         __FILE__, __LINE__, &gtest_dt)) { \
08349       goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \
08350     } \
08351     if (gtest_dt != NULL) { \
08352       ::testing::internal::scoped_ptr< ::testing::internal::DeathTest> \
08353           gtest_dt_ptr(gtest_dt); \
08354       switch (gtest_dt->AssumeRole()) { \
08355         case ::testing::internal::DeathTest::OVERSEE_TEST: \
08356           if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) { \
08357             goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \
08358           } \
08359           break; \
08360         case ::testing::internal::DeathTest::EXECUTE_TEST: { \
08361           ::testing::internal::DeathTest::ReturnSentinel \
08362               gtest_sentinel(gtest_dt); \
08363           GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt); \
08364           gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE); \
08365           break; \
08366         } \
08367         default: \
08368           break; \
08369       } \
08370     } \
08371   } else \
08372     GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__): \
08373       fail(::testing::internal::DeathTest::LastMessage())
08374 // The symbol "fail" here expands to something into which a message
08375 // can be streamed.
08376 
08377 // This macro is for implementing ASSERT/EXPECT_DEBUG_DEATH when compiled in
08378 // NDEBUG mode. In this case we need the statements to be executed, the regex is
08379 // ignored, and the macro must accept a streamed message even though the message
08380 // is never printed.
08381 # define GTEST_EXECUTE_STATEMENT_(statement, regex) \
08382   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
08383   if (::testing::internal::AlwaysTrue()) { \
08384      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
08385   } else \
08386     ::testing::Message()
08387 
08388 // A class representing the parsed contents of the
08389 // --gtest_internal_run_death_test flag, as it existed when
08390 // RUN_ALL_TESTS was called.
08391 class InternalRunDeathTestFlag {
08392  public:
08393   InternalRunDeathTestFlag(const std::string& a_file,
08394                            int a_line,
08395                            int an_index,
08396                            int a_write_fd)
08397       : file_(a_file), line_(a_line), index_(an_index),
08398         write_fd_(a_write_fd) {}
08399 
08400   ~InternalRunDeathTestFlag() {
08401     if (write_fd_ >= 0)
08402       posix::Close(write_fd_);
08403   }
08404 
08405   const std::string& file() const { return file_; }
08406   int line() const { return line_; }
08407   int index() const { return index_; }
08408   int write_fd() const { return write_fd_; }
08409 
08410  private:
08411   std::string file_;
08412   int line_;
08413   int index_;
08414   int write_fd_;
08415 
08416   GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag);
08417 };
08418 
08419 // Returns a newly created InternalRunDeathTestFlag object with fields
08420 // initialized from the GTEST_FLAG(internal_run_death_test) flag if
08421 // the flag is specified; otherwise returns NULL.
08422 InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag();
08423 
08424 #else  // GTEST_HAS_DEATH_TEST
08425 
08426 // This macro is used for implementing macros such as
08427 // EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems where
08428 // death tests are not supported. Those macros must compile on such systems
08429 // iff EXPECT_DEATH and ASSERT_DEATH compile with the same parameters on
08430 // systems that support death tests. This allows one to write such a macro
08431 // on a system that does not support death tests and be sure that it will
08432 // compile on a death-test supporting system.
08433 //
08434 // Parameters:
08435 //   statement -  A statement that a macro such as EXPECT_DEATH would test
08436 //                for program termination. This macro has to make sure this
08437 //                statement is compiled but not executed, to ensure that
08438 //                EXPECT_DEATH_IF_SUPPORTED compiles with a certain
08439 //                parameter iff EXPECT_DEATH compiles with it.
08440 //   regex     -  A regex that a macro such as EXPECT_DEATH would use to test
08441 //                the output of statement.  This parameter has to be
08442 //                compiled but not evaluated by this macro, to ensure that
08443 //                this macro only accepts expressions that a macro such as
08444 //                EXPECT_DEATH would accept.
08445 //   terminator - Must be an empty statement for EXPECT_DEATH_IF_SUPPORTED
08446 //                and a return statement for ASSERT_DEATH_IF_SUPPORTED.
08447 //                This ensures that ASSERT_DEATH_IF_SUPPORTED will not
08448 //                compile inside functions where ASSERT_DEATH doesn't
08449 //                compile.
08450 //
08451 //  The branch that has an always false condition is used to ensure that
08452 //  statement and regex are compiled (and thus syntactically correct) but
08453 //  never executed. The unreachable code macro protects the terminator
08454 //  statement from generating an 'unreachable code' warning in case
08455 //  statement unconditionally returns or throws. The Message constructor at
08456 //  the end allows the syntax of streaming additional messages into the
08457 //  macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH.
08458 # define GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, terminator) \
08459     GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
08460     if (::testing::internal::AlwaysTrue()) { \
08461       GTEST_LOG_(WARNING) \
08462           << "Death tests are not supported on this platform.\n" \
08463           << "Statement '" #statement "' cannot be verified."; \
08464     } else if (::testing::internal::AlwaysFalse()) { \
08465       ::testing::internal::RE::PartialMatch(".*", (regex)); \
08466       GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
08467       terminator; \
08468     } else \
08469       ::testing::Message()
08470 
08471 #endif  // GTEST_HAS_DEATH_TEST
08472 
08473 }  // namespace internal
08474 }  // namespace testing
08475 
08476 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
08477 
08478 namespace testing {
08479 
08480 // This flag controls the style of death tests.  Valid values are "threadsafe",
08481 // meaning that the death test child process will re-execute the test binary
08482 // from the start, running only a single death test, or "fast",
08483 // meaning that the child process will execute the test logic immediately
08484 // after forking.
08485 GTEST_DECLARE_string_(death_test_style);
08486 
08487 #if GTEST_HAS_DEATH_TEST
08488 
08489 namespace internal {
08490 
08491 // Returns a Boolean value indicating whether the caller is currently
08492 // executing in the context of the death test child process.  Tools such as
08493 // Valgrind heap checkers may need this to modify their behavior in death
08494 // tests.  IMPORTANT: This is an internal utility.  Using it may break the
08495 // implementation of death tests.  User code MUST NOT use it.
08496 GTEST_API_ bool InDeathTestChild();
08497 
08498 }  // namespace internal
08499 
08500 // The following macros are useful for writing death tests.
08501 
08502 // Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is
08503 // executed:
08504 //
08505 //   1. It generates a warning if there is more than one active
08506 //   thread.  This is because it's safe to fork() or clone() only
08507 //   when there is a single thread.
08508 //
08509 //   2. The parent process clone()s a sub-process and runs the death
08510 //   test in it; the sub-process exits with code 0 at the end of the
08511 //   death test, if it hasn't exited already.
08512 //
08513 //   3. The parent process waits for the sub-process to terminate.
08514 //
08515 //   4. The parent process checks the exit code and error message of
08516 //   the sub-process.
08517 //
08518 // Examples:
08519 //
08520 //   ASSERT_DEATH(server.SendMessage(56, "Hello"), "Invalid port number");
08521 //   for (int i = 0; i < 5; i++) {
08522 //     EXPECT_DEATH(server.ProcessRequest(i),
08523 //                  "Invalid request .* in ProcessRequest()")
08524 //                  << "Failed to die on request " << i;
08525 //   }
08526 //
08527 //   ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting");
08528 //
08529 //   bool KilledBySIGHUP(int exit_code) {
08530 //     return WIFSIGNALED(exit_code) && WTERMSIG(exit_code) == SIGHUP;
08531 //   }
08532 //
08533 //   ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!");
08534 //
08535 // On the regular expressions used in death tests:
08536 //
08537 //   On POSIX-compliant systems (*nix), we use the <regex.h> library,
08538 //   which uses the POSIX extended regex syntax.
08539 //
08540 //   On other platforms (e.g. Windows), we only support a simple regex
08541 //   syntax implemented as part of Google Test.  This limited
08542 //   implementation should be enough most of the time when writing
08543 //   death tests; though it lacks many features you can find in PCRE
08544 //   or POSIX extended regex syntax.  For example, we don't support
08545 //   union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and
08546 //   repetition count ("x{5,7}"), among others.
08547 //
08548 //   Below is the syntax that we do support.  We chose it to be a
08549 //   subset of both PCRE and POSIX extended regex, so it's easy to
08550 //   learn wherever you come from.  In the following: 'A' denotes a
08551 //   literal character, period (.), or a single \\ escape sequence;
08552 //   'x' and 'y' denote regular expressions; 'm' and 'n' are for
08553 //   natural numbers.
08554 //
08555 //     c     matches any literal character c
08556 //     \\d   matches any decimal digit
08557 //     \\D   matches any character that's not a decimal digit
08558 //     \\f   matches \f
08559 //     \\n   matches \n
08560 //     \\r   matches \r
08561 //     \\s   matches any ASCII whitespace, including \n
08562 //     \\S   matches any character that's not a whitespace
08563 //     \\t   matches \t
08564 //     \\v   matches \v
08565 //     \\w   matches any letter, _, or decimal digit
08566 //     \\W   matches any character that \\w doesn't match
08567 //     \\c   matches any literal character c, which must be a punctuation
08568 //     .     matches any single character except \n
08569 //     A?    matches 0 or 1 occurrences of A
08570 //     A*    matches 0 or many occurrences of A
08571 //     A+    matches 1 or many occurrences of A
08572 //     ^     matches the beginning of a string (not that of each line)
08573 //     $     matches the end of a string (not that of each line)
08574 //     xy    matches x followed by y
08575 //
08576 //   If you accidentally use PCRE or POSIX extended regex features
08577 //   not implemented by us, you will get a run-time failure.  In that
08578 //   case, please try to rewrite your regular expression within the
08579 //   above syntax.
08580 //
08581 //   This implementation is *not* meant to be as highly tuned or robust
08582 //   as a compiled regex library, but should perform well enough for a
08583 //   death test, which already incurs significant overhead by launching
08584 //   a child process.
08585 //
08586 // Known caveats:
08587 //
08588 //   A "threadsafe" style death test obtains the path to the test
08589 //   program from argv[0] and re-executes it in the sub-process.  For
08590 //   simplicity, the current implementation doesn't search the PATH
08591 //   when launching the sub-process.  This means that the user must
08592 //   invoke the test program via a path that contains at least one
08593 //   path separator (e.g. path/to/foo_test and
08594 //   /absolute/path/to/bar_test are fine, but foo_test is not).  This
08595 //   is rarely a problem as people usually don't put the test binary
08596 //   directory in PATH.
08597 //
08598 // TODO(wan@google.com): make thread-safe death tests search the PATH.
08599 
08600 // Asserts that a given statement causes the program to exit, with an
08601 // integer exit status that satisfies predicate, and emitting error output
08602 // that matches regex.
08603 # define ASSERT_EXIT(statement, predicate, regex) \
08604     GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_FATAL_FAILURE_)
08605 
08606 // Like ASSERT_EXIT, but continues on to successive tests in the
08607 // test case, if any:
08608 # define EXPECT_EXIT(statement, predicate, regex) \
08609     GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_NONFATAL_FAILURE_)
08610 
08611 // Asserts that a given statement causes the program to exit, either by
08612 // explicitly exiting with a nonzero exit code or being killed by a
08613 // signal, and emitting error output that matches regex.
08614 # define ASSERT_DEATH(statement, regex) \
08615     ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
08616 
08617 // Like ASSERT_DEATH, but continues on to successive tests in the
08618 // test case, if any:
08619 # define EXPECT_DEATH(statement, regex) \
08620     EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex)
08621 
08622 // Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*:
08623 
08624 // Tests that an exit code describes a normal exit with a given exit code.
08625 class GTEST_API_ ExitedWithCode {
08626  public:
08627   explicit ExitedWithCode(int exit_code);
08628   bool operator()(int exit_status) const;
08629  private:
08630   // No implementation - assignment is unsupported.
08631   void operator=(const ExitedWithCode& other);
08632 
08633   const int exit_code_;
08634 };
08635 
08636 # if !GTEST_OS_WINDOWS
08637 // Tests that an exit code describes an exit due to termination by a
08638 // given signal.
08639 class GTEST_API_ KilledBySignal {
08640  public:
08641   explicit KilledBySignal(int signum);
08642   bool operator()(int exit_status) const;
08643  private:
08644   const int signum_;
08645 };
08646 # endif  // !GTEST_OS_WINDOWS
08647 
08648 // EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode.
08649 // The death testing framework causes this to have interesting semantics,
08650 // since the sideeffects of the call are only visible in opt mode, and not
08651 // in debug mode.
08652 //
08653 // In practice, this can be used to test functions that utilize the
08654 // LOG(DFATAL) macro using the following style:
08655 //
08656 // int DieInDebugOr12(int* sideeffect) {
08657 //   if (sideeffect) {
08658 //     *sideeffect = 12;
08659 //   }
08660 //   LOG(DFATAL) << "death";
08661 //   return 12;
08662 // }
08663 //
08664 // TEST(TestCase, TestDieOr12WorksInDgbAndOpt) {
08665 //   int sideeffect = 0;
08666 //   // Only asserts in dbg.
08667 //   EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death");
08668 //
08669 // #ifdef NDEBUG
08670 //   // opt-mode has sideeffect visible.
08671 //   EXPECT_EQ(12, sideeffect);
08672 // #else
08673 //   // dbg-mode no visible sideeffect.
08674 //   EXPECT_EQ(0, sideeffect);
08675 // #endif
08676 // }
08677 //
08678 // This will assert that DieInDebugReturn12InOpt() crashes in debug
08679 // mode, usually due to a DCHECK or LOG(DFATAL), but returns the
08680 // appropriate fallback value (12 in this case) in opt mode. If you
08681 // need to test that a function has appropriate side-effects in opt
08682 // mode, include assertions against the side-effects.  A general
08683 // pattern for this is:
08684 //
08685 // EXPECT_DEBUG_DEATH({
08686 //   // Side-effects here will have an effect after this statement in
08687 //   // opt mode, but none in debug mode.
08688 //   EXPECT_EQ(12, DieInDebugOr12(&sideeffect));
08689 // }, "death");
08690 //
08691 # ifdef NDEBUG
08692 
08693 #  define EXPECT_DEBUG_DEATH(statement, regex) \
08694   GTEST_EXECUTE_STATEMENT_(statement, regex)
08695 
08696 #  define ASSERT_DEBUG_DEATH(statement, regex) \
08697   GTEST_EXECUTE_STATEMENT_(statement, regex)
08698 
08699 # else
08700 
08701 #  define EXPECT_DEBUG_DEATH(statement, regex) \
08702   EXPECT_DEATH(statement, regex)
08703 
08704 #  define ASSERT_DEBUG_DEATH(statement, regex) \
08705   ASSERT_DEATH(statement, regex)
08706 
08707 # endif  // NDEBUG for EXPECT_DEBUG_DEATH
08708 #endif  // GTEST_HAS_DEATH_TEST
08709 
08710 // EXPECT_DEATH_IF_SUPPORTED(statement, regex) and
08711 // ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if
08712 // death tests are supported; otherwise they just issue a warning.  This is
08713 // useful when you are combining death test assertions with normal test
08714 // assertions in one test.
08715 #if GTEST_HAS_DEATH_TEST
08716 # define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
08717     EXPECT_DEATH(statement, regex)
08718 # define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
08719     ASSERT_DEATH(statement, regex)
08720 #else
08721 # define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
08722     GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, )
08723 # define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
08724     GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, return)
08725 #endif
08726 
08727 }  // namespace testing
08728 
08729 #endif  // GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
08730 // This file was GENERATED by command:
08731 //     pump.py gtest-param-test.h.pump
08732 // DO NOT EDIT BY HAND!!!
08733 
08734 // Copyright 2008, Google Inc.
08735 // All rights reserved.
08736 //
08737 // Redistribution and use in source and binary forms, with or without
08738 // modification, are permitted provided that the following conditions are
08739 // met:
08740 //
08741 //     * Redistributions of source code must retain the above copyright
08742 // notice, this list of conditions and the following disclaimer.
08743 //     * Redistributions in binary form must reproduce the above
08744 // copyright notice, this list of conditions and the following disclaimer
08745 // in the documentation and/or other materials provided with the
08746 // distribution.
08747 //     * Neither the name of Google Inc. nor the names of its
08748 // contributors may be used to endorse or promote products derived from
08749 // this software without specific prior written permission.
08750 //
08751 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
08752 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
08753 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
08754 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
08755 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
08756 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
08757 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
08758 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
08759 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
08760 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
08761 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
08762 //
08763 // Authors: vladl@google.com (Vlad Losev)
08764 //
08765 // Macros and functions for implementing parameterized tests
08766 // in Google C++ Testing Framework (Google Test)
08767 //
08768 // This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
08769 //
08770 #ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
08771 #define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
08772 
08773 
08774 // Value-parameterized tests allow you to test your code with different
08775 // parameters without writing multiple copies of the same test.
08776 //
08777 // Here is how you use value-parameterized tests:
08778 
08779 #if 0
08780 
08781 // To write value-parameterized tests, first you should define a fixture
08782 // class. It is usually derived from testing::TestWithParam<T> (see below for
08783 // another inheritance scheme that's sometimes useful in more complicated
08784 // class hierarchies), where the type of your parameter values.
08785 // TestWithParam<T> is itself derived from testing::Test. T can be any
08786 // copyable type. If it's a raw pointer, you are responsible for managing the
08787 // lifespan of the pointed values.
08788 
08789 class FooTest : public ::testing::TestWithParam<const char*> {
08790   // You can implement all the usual class fixture members here.
08791 };
08792 
08793 // Then, use the TEST_P macro to define as many parameterized tests
08794 // for this fixture as you want. The _P suffix is for "parameterized"
08795 // or "pattern", whichever you prefer to think.
08796 
08797 TEST_P(FooTest, DoesBlah) {
08798   // Inside a test, access the test parameter with the GetParam() method
08799   // of the TestWithParam<T> class:
08800   EXPECT_TRUE(foo.Blah(GetParam()));
08801   ...
08802 }
08803 
08804 TEST_P(FooTest, HasBlahBlah) {
08805   ...
08806 }
08807 
08808 // Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test
08809 // case with any set of parameters you want. Google Test defines a number
08810 // of functions for generating test parameters. They return what we call
08811 // (surprise!) parameter generators. Here is a  summary of them, which
08812 // are all in the testing namespace:
08813 //
08814 //
08815 //  Range(begin, end [, step]) - Yields values {begin, begin+step,
08816 //                               begin+step+step, ...}. The values do not
08817 //                               include end. step defaults to 1.
08818 //  Values(v1, v2, ..., vN)    - Yields values {v1, v2, ..., vN}.
08819 //  ValuesIn(container)        - Yields values from a C-style array, an STL
08820 //  ValuesIn(begin,end)          container, or an iterator range [begin, end).
08821 //  Bool()                     - Yields sequence {false, true}.
08822 //  Combine(g1, g2, ..., gN)   - Yields all combinations (the Cartesian product
08823 //                               for the math savvy) of the values generated
08824 //                               by the N generators.
08825 //
08826 // For more details, see comments at the definitions of these functions below
08827 // in this file.
08828 //
08829 // The following statement will instantiate tests from the FooTest test case
08830 // each with parameter values "meeny", "miny", and "moe".
08831 
08832 INSTANTIATE_TEST_CASE_P(InstantiationName,
08833                         FooTest,
08834                         Values("meeny", "miny", "moe"));
08835 
08836 // To distinguish different instances of the pattern, (yes, you
08837 // can instantiate it more then once) the first argument to the
08838 // INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the
08839 // actual test case name. Remember to pick unique prefixes for different
08840 // instantiations. The tests from the instantiation above will have
08841 // these names:
08842 //
08843 //    * InstantiationName/FooTest.DoesBlah/0 for "meeny"
08844 //    * InstantiationName/FooTest.DoesBlah/1 for "miny"
08845 //    * InstantiationName/FooTest.DoesBlah/2 for "moe"
08846 //    * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"
08847 //    * InstantiationName/FooTest.HasBlahBlah/1 for "miny"
08848 //    * InstantiationName/FooTest.HasBlahBlah/2 for "moe"
08849 //
08850 // You can use these names in --gtest_filter.
08851 //
08852 // This statement will instantiate all tests from FooTest again, each
08853 // with parameter values "cat" and "dog":
08854 
08855 const char* pets[] = {"cat", "dog"};
08856 INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));
08857 
08858 // The tests from the instantiation above will have these names:
08859 //
08860 //    * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"
08861 //    * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"
08862 //    * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
08863 //    * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
08864 //
08865 // Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests
08866 // in the given test case, whether their definitions come before or
08867 // AFTER the INSTANTIATE_TEST_CASE_P statement.
08868 //
08869 // Please also note that generator expressions (including parameters to the
08870 // generators) are evaluated in InitGoogleTest(), after main() has started.
08871 // This allows the user on one hand, to adjust generator parameters in order
08872 // to dynamically determine a set of tests to run and on the other hand,
08873 // give the user a chance to inspect the generated tests with Google Test
08874 // reflection API before RUN_ALL_TESTS() is executed.
08875 //
08876 // You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc
08877 // for more examples.
08878 //
08879 // In the future, we plan to publish the API for defining new parameter
08880 // generators. But for now this interface remains part of the internal
08881 // implementation and is subject to change.
08882 //
08883 //
08884 // A parameterized test fixture must be derived from testing::Test and from
08885 // testing::WithParamInterface<T>, where T is the type of the parameter
08886 // values. Inheriting from TestWithParam<T> satisfies that requirement because
08887 // TestWithParam<T> inherits from both Test and WithParamInterface. In more
08888 // complicated hierarchies, however, it is occasionally useful to inherit
08889 // separately from Test and WithParamInterface. For example:
08890 
08891 class BaseTest : public ::testing::Test {
08892   // You can inherit all the usual members for a non-parameterized test
08893   // fixture here.
08894 };
08895 
08896 class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {
08897   // The usual test fixture members go here too.
08898 };
08899 
08900 TEST_F(BaseTest, HasFoo) {
08901   // This is an ordinary non-parameterized test.
08902 }
08903 
08904 TEST_P(DerivedTest, DoesBlah) {
08905   // GetParam works just the same here as if you inherit from TestWithParam.
08906   EXPECT_TRUE(foo.Blah(GetParam()));
08907 }
08908 
08909 #endif  // 0
08910 
08911 
08912 #if !GTEST_OS_SYMBIAN
08913 # include <utility>
08914 #endif
08915 
08916 // scripts/fuse_gtest.py depends on gtest's own header being #included
08917 // *unconditionally*.  Therefore these #includes cannot be moved
08918 // inside #if GTEST_HAS_PARAM_TEST.
08919 // Copyright 2008 Google Inc.
08920 // All Rights Reserved.
08921 //
08922 // Redistribution and use in source and binary forms, with or without
08923 // modification, are permitted provided that the following conditions are
08924 // met:
08925 //
08926 //     * Redistributions of source code must retain the above copyright
08927 // notice, this list of conditions and the following disclaimer.
08928 //     * Redistributions in binary form must reproduce the above
08929 // copyright notice, this list of conditions and the following disclaimer
08930 // in the documentation and/or other materials provided with the
08931 // distribution.
08932 //     * Neither the name of Google Inc. nor the names of its
08933 // contributors may be used to endorse or promote products derived from
08934 // this software without specific prior written permission.
08935 //
08936 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
08937 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
08938 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
08939 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
08940 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
08941 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
08942 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
08943 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
08944 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
08945 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
08946 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
08947 //
08948 // Author: vladl@google.com (Vlad Losev)
08949 
08950 // Type and function utilities for implementing parameterized tests.
08951 
08952 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
08953 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
08954 
08955 #include <iterator>
08956 #include <utility>
08957 #include <vector>
08958 
08959 // scripts/fuse_gtest.py depends on gtest's own header being #included
08960 // *unconditionally*.  Therefore these #includes cannot be moved
08961 // inside #if GTEST_HAS_PARAM_TEST.
08962 // Copyright 2003 Google Inc.
08963 // All rights reserved.
08964 //
08965 // Redistribution and use in source and binary forms, with or without
08966 // modification, are permitted provided that the following conditions are
08967 // met:
08968 //
08969 //     * Redistributions of source code must retain the above copyright
08970 // notice, this list of conditions and the following disclaimer.
08971 //     * Redistributions in binary form must reproduce the above
08972 // copyright notice, this list of conditions and the following disclaimer
08973 // in the documentation and/or other materials provided with the
08974 // distribution.
08975 //     * Neither the name of Google Inc. nor the names of its
08976 // contributors may be used to endorse or promote products derived from
08977 // this software without specific prior written permission.
08978 //
08979 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
08980 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
08981 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
08982 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
08983 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
08984 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
08985 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
08986 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
08987 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
08988 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
08989 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
08990 //
08991 // Authors: Dan Egnor (egnor@google.com)
08992 //
08993 // A "smart" pointer type with reference tracking.  Every pointer to a
08994 // particular object is kept on a circular linked list.  When the last pointer
08995 // to an object is destroyed or reassigned, the object is deleted.
08996 //
08997 // Used properly, this deletes the object when the last reference goes away.
08998 // There are several caveats:
08999 // - Like all reference counting schemes, cycles lead to leaks.
09000 // - Each smart pointer is actually two pointers (8 bytes instead of 4).
09001 // - Every time a pointer is assigned, the entire list of pointers to that
09002 //   object is traversed.  This class is therefore NOT SUITABLE when there
09003 //   will often be more than two or three pointers to a particular object.
09004 // - References are only tracked as long as linked_ptr<> objects are copied.
09005 //   If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS
09006 //   will happen (double deletion).
09007 //
09008 // A good use of this class is storing object references in STL containers.
09009 // You can safely put linked_ptr<> in a vector<>.
09010 // Other uses may not be as good.
09011 //
09012 // Note: If you use an incomplete type with linked_ptr<>, the class
09013 // *containing* linked_ptr<> must have a constructor and destructor (even
09014 // if they do nothing!).
09015 //
09016 // Bill Gibbons suggested we use something like this.
09017 //
09018 // Thread Safety:
09019 //   Unlike other linked_ptr implementations, in this implementation
09020 //   a linked_ptr object is thread-safe in the sense that:
09021 //     - it's safe to copy linked_ptr objects concurrently,
09022 //     - it's safe to copy *from* a linked_ptr and read its underlying
09023 //       raw pointer (e.g. via get()) concurrently, and
09024 //     - it's safe to write to two linked_ptrs that point to the same
09025 //       shared object concurrently.
09026 // TODO(wan@google.com): rename this to safe_linked_ptr to avoid
09027 // confusion with normal linked_ptr.
09028 
09029 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
09030 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
09031 
09032 #include <stdlib.h>
09033 #include <assert.h>
09034 
09035 
09036 namespace testing {
09037 namespace internal {
09038 
09039 // Protects copying of all linked_ptr objects.
09040 GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_linked_ptr_mutex);
09041 
09042 // This is used internally by all instances of linked_ptr<>.  It needs to be
09043 // a non-template class because different types of linked_ptr<> can refer to
09044 // the same object (linked_ptr<Superclass>(obj) vs linked_ptr<Subclass>(obj)).
09045 // So, it needs to be possible for different types of linked_ptr to participate
09046 // in the same circular linked list, so we need a single class type here.
09047 //
09048 // DO NOT USE THIS CLASS DIRECTLY YOURSELF.  Use linked_ptr<T>.
09049 class linked_ptr_internal {
09050  public:
09051   // Create a new circle that includes only this instance.
09052   void join_new() {
09053     next_ = this;
09054   }
09055 
09056   // Many linked_ptr operations may change p.link_ for some linked_ptr
09057   // variable p in the same circle as this object.  Therefore we need
09058   // to prevent two such operations from occurring concurrently.
09059   //
09060   // Note that different types of linked_ptr objects can coexist in a
09061   // circle (e.g. linked_ptr<Base>, linked_ptr<Derived1>, and
09062   // linked_ptr<Derived2>).  Therefore we must use a single mutex to
09063   // protect all linked_ptr objects.  This can create serious
09064   // contention in production code, but is acceptable in a testing
09065   // framework.
09066 
09067   // Join an existing circle.
09068   void join(linked_ptr_internal const* ptr)
09069       GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
09070     MutexLock lock(&g_linked_ptr_mutex);
09071 
09072     linked_ptr_internal const* p = ptr;
09073     while (p->next_ != ptr) p = p->next_;
09074     p->next_ = this;
09075     next_ = ptr;
09076   }
09077 
09078   // Leave whatever circle we're part of.  Returns true if we were the
09079   // last member of the circle.  Once this is done, you can join() another.
09080   bool depart()
09081       GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
09082     MutexLock lock(&g_linked_ptr_mutex);
09083 
09084     if (next_ == this) return true;
09085     linked_ptr_internal const* p = next_;
09086     while (p->next_ != this) p = p->next_;
09087     p->next_ = next_;
09088     return false;
09089   }
09090 
09091  private:
09092   mutable linked_ptr_internal const* next_;
09093 };
09094 
09095 template <typename T>
09096 class linked_ptr {
09097  public:
09098   typedef T element_type;
09099 
09100   // Take over ownership of a raw pointer.  This should happen as soon as
09101   // possible after the object is created.
09102   explicit linked_ptr(T* ptr = NULL) { capture(ptr); }
09103   ~linked_ptr() { depart(); }
09104 
09105   // Copy an existing linked_ptr<>, adding ourselves to the list of references.
09106   template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); }
09107   linked_ptr(linked_ptr const& ptr) {  // NOLINT
09108     assert(&ptr != this);
09109     copy(&ptr);
09110   }
09111 
09112   // Assignment releases the old value and acquires the new.
09113   template <typename U> linked_ptr& operator=(linked_ptr<U> const& ptr) {
09114     depart();
09115     copy(&ptr);
09116     return *this;
09117   }
09118 
09119   linked_ptr& operator=(linked_ptr const& ptr) {
09120     if (&ptr != this) {
09121       depart();
09122       copy(&ptr);
09123     }
09124     return *this;
09125   }
09126 
09127   // Smart pointer members.
09128   void reset(T* ptr = NULL) {
09129     depart();
09130     capture(ptr);
09131   }
09132   T* get() const { return value_; }
09133   T* operator->() const { return value_; }
09134   T& operator*() const { return *value_; }
09135 
09136   bool operator==(T* p) const { return value_ == p; }
09137   bool operator!=(T* p) const { return value_ != p; }
09138   template <typename U>
09139   bool operator==(linked_ptr<U> const& ptr) const {
09140     return value_ == ptr.get();
09141   }
09142   template <typename U>
09143   bool operator!=(linked_ptr<U> const& ptr) const {
09144     return value_ != ptr.get();
09145   }
09146 
09147  private:
09148   template <typename U>
09149   friend class linked_ptr;
09150 
09151   T* value_;
09152   linked_ptr_internal link_;
09153 
09154   void depart() {
09155     if (link_.depart()) delete value_;
09156   }
09157 
09158   void capture(T* ptr) {
09159     value_ = ptr;
09160     link_.join_new();
09161   }
09162 
09163   template <typename U> void copy(linked_ptr<U> const* ptr) {
09164     value_ = ptr->get();
09165     if (value_)
09166       link_.join(&ptr->link_);
09167     else
09168       link_.join_new();
09169   }
09170 };
09171 
09172 template<typename T> inline
09173 bool operator==(T* ptr, const linked_ptr<T>& x) {
09174   return ptr == x.get();
09175 }
09176 
09177 template<typename T> inline
09178 bool operator!=(T* ptr, const linked_ptr<T>& x) {
09179   return ptr != x.get();
09180 }
09181 
09182 // A function to convert T* into linked_ptr<T>
09183 // Doing e.g. make_linked_ptr(new FooBarBaz<type>(arg)) is a shorter notation
09184 // for linked_ptr<FooBarBaz<type> >(new FooBarBaz<type>(arg))
09185 template <typename T>
09186 linked_ptr<T> make_linked_ptr(T* ptr) {
09187   return linked_ptr<T>(ptr);
09188 }
09189 
09190 }  // namespace internal
09191 }  // namespace testing
09192 
09193 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
09194 // Copyright 2007, Google Inc.
09195 // All rights reserved.
09196 //
09197 // Redistribution and use in source and binary forms, with or without
09198 // modification, are permitted provided that the following conditions are
09199 // met:
09200 //
09201 //     * Redistributions of source code must retain the above copyright
09202 // notice, this list of conditions and the following disclaimer.
09203 //     * Redistributions in binary form must reproduce the above
09204 // copyright notice, this list of conditions and the following disclaimer
09205 // in the documentation and/or other materials provided with the
09206 // distribution.
09207 //     * Neither the name of Google Inc. nor the names of its
09208 // contributors may be used to endorse or promote products derived from
09209 // this software without specific prior written permission.
09210 //
09211 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
09212 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
09213 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
09214 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
09215 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
09216 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
09217 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
09218 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
09219 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
09220 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
09221 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
09222 //
09223 // Author: wan@google.com (Zhanyong Wan)
09224 
09225 // Google Test - The Google C++ Testing Framework
09226 //
09227 // This file implements a universal value printer that can print a
09228 // value of any type T:
09229 //
09230 //   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
09231 //
09232 // A user can teach this function how to print a class type T by
09233 // defining either operator<<() or PrintTo() in the namespace that
09234 // defines T.  More specifically, the FIRST defined function in the
09235 // following list will be used (assuming T is defined in namespace
09236 // foo):
09237 //
09238 //   1. foo::PrintTo(const T&, ostream*)
09239 //   2. operator<<(ostream&, const T&) defined in either foo or the
09240 //      global namespace.
09241 //
09242 // If none of the above is defined, it will print the debug string of
09243 // the value if it is a protocol buffer, or print the raw bytes in the
09244 // value otherwise.
09245 //
09246 // To aid debugging: when T is a reference type, the address of the
09247 // value is also printed; when T is a (const) char pointer, both the
09248 // pointer value and the NUL-terminated string it points to are
09249 // printed.
09250 //
09251 // We also provide some convenient wrappers:
09252 //
09253 //   // Prints a value to a string.  For a (const or not) char
09254 //   // pointer, the NUL-terminated string (but not the pointer) is
09255 //   // printed.
09256 //   std::string ::testing::PrintToString(const T& value);
09257 //
09258 //   // Prints a value tersely: for a reference type, the referenced
09259 //   // value (but not the address) is printed; for a (const or not) char
09260 //   // pointer, the NUL-terminated string (but not the pointer) is
09261 //   // printed.
09262 //   void ::testing::internal::UniversalTersePrint(const T& value, ostream*);
09263 //
09264 //   // Prints value using the type inferred by the compiler.  The difference
09265 //   // from UniversalTersePrint() is that this function prints both the
09266 //   // pointer and the NUL-terminated string for a (const or not) char pointer.
09267 //   void ::testing::internal::UniversalPrint(const T& value, ostream*);
09268 //
09269 //   // Prints the fields of a tuple tersely to a string vector, one
09270 //   // element for each field. Tuple support must be enabled in
09271 //   // gtest-port.h.
09272 //   std::vector<string> UniversalTersePrintTupleFieldsToStrings(
09273 //       const Tuple& value);
09274 //
09275 // Known limitation:
09276 //
09277 // The print primitives print the elements of an STL-style container
09278 // using the compiler-inferred type of *iter where iter is a
09279 // const_iterator of the container.  When const_iterator is an input
09280 // iterator but not a forward iterator, this inferred type may not
09281 // match value_type, and the print output may be incorrect.  In
09282 // practice, this is rarely a problem as for most containers
09283 // const_iterator is a forward iterator.  We'll fix this if there's an
09284 // actual need for it.  Note that this fix cannot rely on value_type
09285 // being defined as many user-defined container types don't have
09286 // value_type.
09287 
09288 #ifndef GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
09289 #define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
09290 
09291 #include <ostream>  // NOLINT
09292 #include <sstream>
09293 #include <string>
09294 #include <utility>
09295 #include <vector>
09296 
09297 namespace testing {
09298 
09299 // Definitions in the 'internal' and 'internal2' name spaces are
09300 // subject to change without notice.  DO NOT USE THEM IN USER CODE!
09301 namespace internal2 {
09302 
09303 // Prints the given number of bytes in the given object to the given
09304 // ostream.
09305 GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
09306                                      size_t count,
09307                                      ::std::ostream* os);
09308 
09309 // For selecting which printer to use when a given type has neither <<
09310 // nor PrintTo().
09311 enum TypeKind {
09312   kProtobuf,              // a protobuf type
09313   kConvertibleToInteger,  // a type implicitly convertible to BiggestInt
09314                           // (e.g. a named or unnamed enum type)
09315   kOtherType              // anything else
09316 };
09317 
09318 // TypeWithoutFormatter<T, kTypeKind>::PrintValue(value, os) is called
09319 // by the universal printer to print a value of type T when neither
09320 // operator<< nor PrintTo() is defined for T, where kTypeKind is the
09321 // "kind" of T as defined by enum TypeKind.
09322 template <typename T, TypeKind kTypeKind>
09323 class TypeWithoutFormatter {
09324  public:
09325   // This default version is called when kTypeKind is kOtherType.
09326   static void PrintValue(const T& value, ::std::ostream* os) {
09327     PrintBytesInObjectTo(reinterpret_cast<const unsigned char*>(&value),
09328                          sizeof(value), os);
09329   }
09330 };
09331 
09332 // We print a protobuf using its ShortDebugString() when the string
09333 // doesn't exceed this many characters; otherwise we print it using
09334 // DebugString() for better readability.
09335 const size_t kProtobufOneLinerMaxLength = 50;
09336 
09337 template <typename T>
09338 class TypeWithoutFormatter<T, kProtobuf> {
09339  public:
09340   static void PrintValue(const T& value, ::std::ostream* os) {
09341     const ::testing::internal::string short_str = value.ShortDebugString();
09342     const ::testing::internal::string pretty_str =
09343         short_str.length() <= kProtobufOneLinerMaxLength ?
09344         short_str : ("\n" + value.DebugString());
09345     *os << ("<" + pretty_str + ">");
09346   }
09347 };
09348 
09349 template <typename T>
09350 class TypeWithoutFormatter<T, kConvertibleToInteger> {
09351  public:
09352   // Since T has no << operator or PrintTo() but can be implicitly
09353   // converted to BiggestInt, we print it as a BiggestInt.
09354   //
09355   // Most likely T is an enum type (either named or unnamed), in which
09356   // case printing it as an integer is the desired behavior.  In case
09357   // T is not an enum, printing it as an integer is the best we can do
09358   // given that it has no user-defined printer.
09359   static void PrintValue(const T& value, ::std::ostream* os) {
09360     const internal::BiggestInt kBigInt = value;
09361     *os << kBigInt;
09362   }
09363 };
09364 
09365 // Prints the given value to the given ostream.  If the value is a
09366 // protocol message, its debug string is printed; if it's an enum or
09367 // of a type implicitly convertible to BiggestInt, it's printed as an
09368 // integer; otherwise the bytes in the value are printed.  This is
09369 // what UniversalPrinter<T>::Print() does when it knows nothing about
09370 // type T and T has neither << operator nor PrintTo().
09371 //
09372 // A user can override this behavior for a class type Foo by defining
09373 // a << operator in the namespace where Foo is defined.
09374 //
09375 // We put this operator in namespace 'internal2' instead of 'internal'
09376 // to simplify the implementation, as much code in 'internal' needs to
09377 // use << in STL, which would conflict with our own << were it defined
09378 // in 'internal'.
09379 //
09380 // Note that this operator<< takes a generic std::basic_ostream<Char,
09381 // CharTraits> type instead of the more restricted std::ostream.  If
09382 // we define it to take an std::ostream instead, we'll get an
09383 // "ambiguous overloads" compiler error when trying to print a type
09384 // Foo that supports streaming to std::basic_ostream<Char,
09385 // CharTraits>, as the compiler cannot tell whether
09386 // operator<<(std::ostream&, const T&) or
09387 // operator<<(std::basic_stream<Char, CharTraits>, const Foo&) is more
09388 // specific.
09389 template <typename Char, typename CharTraits, typename T>
09390 ::std::basic_ostream<Char, CharTraits>& operator<<(
09391     ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
09392   TypeWithoutFormatter<T,
09393       (internal::IsAProtocolMessage<T>::value ? kProtobuf :
09394        internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
09395        kConvertibleToInteger : kOtherType)>::PrintValue(x, &os);
09396   return os;
09397 }
09398 
09399 }  // namespace internal2
09400 }  // namespace testing
09401 
09402 // This namespace MUST NOT BE NESTED IN ::testing, or the name look-up
09403 // magic needed for implementing UniversalPrinter won't work.
09404 namespace testing_internal {
09405 
09406 // Used to print a value that is not an STL-style container when the
09407 // user doesn't define PrintTo() for it.
09408 template <typename T>
09409 void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
09410   // With the following statement, during unqualified name lookup,
09411   // testing::internal2::operator<< appears as if it was declared in
09412   // the nearest enclosing namespace that contains both
09413   // ::testing_internal and ::testing::internal2, i.e. the global
09414   // namespace.  For more details, refer to the C++ Standard section
09415   // 7.3.4-1 [namespace.udir].  This allows us to fall back onto
09416   // testing::internal2::operator<< in case T doesn't come with a <<
09417   // operator.
09418   //
09419   // We cannot write 'using ::testing::internal2::operator<<;', which
09420   // gcc 3.3 fails to compile due to a compiler bug.
09421   using namespace ::testing::internal2;  // NOLINT
09422 
09423   // Assuming T is defined in namespace foo, in the next statement,
09424   // the compiler will consider all of:
09425   //
09426   //   1. foo::operator<< (thanks to Koenig look-up),
09427   //   2. ::operator<< (as the current namespace is enclosed in ::),
09428   //   3. testing::internal2::operator<< (thanks to the using statement above).
09429   //
09430   // The operator<< whose type matches T best will be picked.
09431   //
09432   // We deliberately allow #2 to be a candidate, as sometimes it's
09433   // impossible to define #1 (e.g. when foo is ::std, defining
09434   // anything in it is undefined behavior unless you are a compiler
09435   // vendor.).
09436   *os << value;
09437 }
09438 
09439 }  // namespace testing_internal
09440 
09441 namespace testing {
09442 namespace internal {
09443 
09444 // UniversalPrinter<T>::Print(value, ostream_ptr) prints the given
09445 // value to the given ostream.  The caller must ensure that
09446 // 'ostream_ptr' is not NULL, or the behavior is undefined.
09447 //
09448 // We define UniversalPrinter as a class template (as opposed to a
09449 // function template), as we need to partially specialize it for
09450 // reference types, which cannot be done with function templates.
09451 template <typename T>
09452 class UniversalPrinter;
09453 
09454 template <typename T>
09455 void UniversalPrint(const T& value, ::std::ostream* os);
09456 
09457 // Used to print an STL-style container when the user doesn't define
09458 // a PrintTo() for it.
09459 template <typename C>
09460 void DefaultPrintTo(IsContainer /* dummy */,
09461                     false_type /* is not a pointer */,
09462                     const C& container, ::std::ostream* os) {
09463   const size_t kMaxCount = 32;  // The maximum number of elements to print.
09464   *os << '{';
09465   size_t count = 0;
09466   for (typename C::const_iterator it = container.begin();
09467        it != container.end(); ++it, ++count) {
09468     if (count > 0) {
09469       *os << ',';
09470       if (count == kMaxCount) {  // Enough has been printed.
09471         *os << " ...";
09472         break;
09473       }
09474     }
09475     *os << ' ';
09476     // We cannot call PrintTo(*it, os) here as PrintTo() doesn't
09477     // handle *it being a native array.
09478     internal::UniversalPrint(*it, os);
09479   }
09480 
09481   if (count > 0) {
09482     *os << ' ';
09483   }
09484   *os << '}';
09485 }
09486 
09487 // Used to print a pointer that is neither a char pointer nor a member
09488 // pointer, when the user doesn't define PrintTo() for it.  (A member
09489 // variable pointer or member function pointer doesn't really point to
09490 // a location in the address space.  Their representation is
09491 // implementation-defined.  Therefore they will be printed as raw
09492 // bytes.)
09493 template <typename T>
09494 void DefaultPrintTo(IsNotContainer /* dummy */,
09495                     true_type /* is a pointer */,
09496                     T* p, ::std::ostream* os) {
09497   if (p == NULL) {
09498     *os << "NULL";
09499   } else {
09500     // C++ doesn't allow casting from a function pointer to any object
09501     // pointer.
09502     //
09503     // IsTrue() silences warnings: "Condition is always true",
09504     // "unreachable code".
09505     if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {
09506       // T is not a function type.  We just call << to print p,
09507       // relying on ADL to pick up user-defined << for their pointer
09508       // types, if any.
09509       *os << p;
09510     } else {
09511       // T is a function type, so '*os << p' doesn't do what we want
09512       // (it just prints p as bool).  We want to print p as a const
09513       // void*.  However, we cannot cast it to const void* directly,
09514       // even using reinterpret_cast, as earlier versions of gcc
09515       // (e.g. 3.4.5) cannot compile the cast when p is a function
09516       // pointer.  Casting to UInt64 first solves the problem.
09517       *os << reinterpret_cast<const void*>(
09518           reinterpret_cast<internal::UInt64>(p));
09519     }
09520   }
09521 }
09522 
09523 // Used to print a non-container, non-pointer value when the user
09524 // doesn't define PrintTo() for it.
09525 template <typename T>
09526 void DefaultPrintTo(IsNotContainer /* dummy */,
09527                     false_type /* is not a pointer */,
09528                     const T& value, ::std::ostream* os) {
09529   ::testing_internal::DefaultPrintNonContainerTo(value, os);
09530 }
09531 
09532 // Prints the given value using the << operator if it has one;
09533 // otherwise prints the bytes in it.  This is what
09534 // UniversalPrinter<T>::Print() does when PrintTo() is not specialized
09535 // or overloaded for type T.
09536 //
09537 // A user can override this behavior for a class type Foo by defining
09538 // an overload of PrintTo() in the namespace where Foo is defined.  We
09539 // give the user this option as sometimes defining a << operator for
09540 // Foo is not desirable (e.g. the coding style may prevent doing it,
09541 // or there is already a << operator but it doesn't do what the user
09542 // wants).
09543 template <typename T>
09544 void PrintTo(const T& value, ::std::ostream* os) {
09545   // DefaultPrintTo() is overloaded.  The type of its first two
09546   // arguments determine which version will be picked.  If T is an
09547   // STL-style container, the version for container will be called; if
09548   // T is a pointer, the pointer version will be called; otherwise the
09549   // generic version will be called.
09550   //
09551   // Note that we check for container types here, prior to we check
09552   // for protocol message types in our operator<<.  The rationale is:
09553   //
09554   // For protocol messages, we want to give people a chance to
09555   // override Google Mock's format by defining a PrintTo() or
09556   // operator<<.  For STL containers, other formats can be
09557   // incompatible with Google Mock's format for the container
09558   // elements; therefore we check for container types here to ensure
09559   // that our format is used.
09560   //
09561   // The second argument of DefaultPrintTo() is needed to bypass a bug
09562   // in Symbian's C++ compiler that prevents it from picking the right
09563   // overload between:
09564   //
09565   //   PrintTo(const T& x, ...);
09566   //   PrintTo(T* x, ...);
09567   DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
09568 }
09569 
09570 // The following list of PrintTo() overloads tells
09571 // UniversalPrinter<T>::Print() how to print standard types (built-in
09572 // types, strings, plain arrays, and pointers).
09573 
09574 // Overloads for various char types.
09575 GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os);
09576 GTEST_API_ void PrintTo(signed char c, ::std::ostream* os);
09577 inline void PrintTo(char c, ::std::ostream* os) {
09578   // When printing a plain char, we always treat it as unsigned.  This
09579   // way, the output won't be affected by whether the compiler thinks
09580   // char is signed or not.
09581   PrintTo(static_cast<unsigned char>(c), os);
09582 }
09583 
09584 // Overloads for other simple built-in types.
09585 inline void PrintTo(bool x, ::std::ostream* os) {
09586   *os << (x ? "true" : "false");
09587 }
09588 
09589 // Overload for wchar_t type.
09590 // Prints a wchar_t as a symbol if it is printable or as its internal
09591 // code otherwise and also as its decimal code (except for L'\0').
09592 // The L'\0' char is printed as "L'\\0'". The decimal code is printed
09593 // as signed integer when wchar_t is implemented by the compiler
09594 // as a signed type and is printed as an unsigned integer when wchar_t
09595 // is implemented as an unsigned type.
09596 GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os);
09597 
09598 // Overloads for C strings.
09599 GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);
09600 inline void PrintTo(char* s, ::std::ostream* os) {
09601   PrintTo(ImplicitCast_<const char*>(s), os);
09602 }
09603 
09604 // signed/unsigned char is often used for representing binary data, so
09605 // we print pointers to it as void* to be safe.
09606 inline void PrintTo(const signed char* s, ::std::ostream* os) {
09607   PrintTo(ImplicitCast_<const void*>(s), os);
09608 }
09609 inline void PrintTo(signed char* s, ::std::ostream* os) {
09610   PrintTo(ImplicitCast_<const void*>(s), os);
09611 }
09612 inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
09613   PrintTo(ImplicitCast_<const void*>(s), os);
09614 }
09615 inline void PrintTo(unsigned char* s, ::std::ostream* os) {
09616   PrintTo(ImplicitCast_<const void*>(s), os);
09617 }
09618 
09619 // MSVC can be configured to define wchar_t as a typedef of unsigned
09620 // short.  It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native
09621 // type.  When wchar_t is a typedef, defining an overload for const
09622 // wchar_t* would cause unsigned short* be printed as a wide string,
09623 // possibly causing invalid memory accesses.
09624 #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
09625 // Overloads for wide C strings
09626 GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os);
09627 inline void PrintTo(wchar_t* s, ::std::ostream* os) {
09628   PrintTo(ImplicitCast_<const wchar_t*>(s), os);
09629 }
09630 #endif
09631 
09632 // Overload for C arrays.  Multi-dimensional arrays are printed
09633 // properly.
09634 
09635 // Prints the given number of elements in an array, without printing
09636 // the curly braces.
09637 template <typename T>
09638 void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
09639   UniversalPrint(a[0], os);
09640   for (size_t i = 1; i != count; i++) {
09641     *os << ", ";
09642     UniversalPrint(a[i], os);
09643   }
09644 }
09645 
09646 // Overloads for ::string and ::std::string.
09647 #if GTEST_HAS_GLOBAL_STRING
09648 GTEST_API_ void PrintStringTo(const ::string&s, ::std::ostream* os);
09649 inline void PrintTo(const ::string& s, ::std::ostream* os) {
09650   PrintStringTo(s, os);
09651 }
09652 #endif  // GTEST_HAS_GLOBAL_STRING
09653 
09654 GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os);
09655 inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
09656   PrintStringTo(s, os);
09657 }
09658 
09659 // Overloads for ::wstring and ::std::wstring.
09660 #if GTEST_HAS_GLOBAL_WSTRING
09661 GTEST_API_ void PrintWideStringTo(const ::wstring&s, ::std::ostream* os);
09662 inline void PrintTo(const ::wstring& s, ::std::ostream* os) {
09663   PrintWideStringTo(s, os);
09664 }
09665 #endif  // GTEST_HAS_GLOBAL_WSTRING
09666 
09667 #if GTEST_HAS_STD_WSTRING
09668 GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os);
09669 inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
09670   PrintWideStringTo(s, os);
09671 }
09672 #endif  // GTEST_HAS_STD_WSTRING
09673 
09674 #if GTEST_HAS_TR1_TUPLE
09675 // Overload for ::std::tr1::tuple.  Needed for printing function arguments,
09676 // which are packed as tuples.
09677 
09678 // Helper function for printing a tuple.  T must be instantiated with
09679 // a tuple type.
09680 template <typename T>
09681 void PrintTupleTo(const T& t, ::std::ostream* os);
09682 
09683 // Overloaded PrintTo() for tuples of various arities.  We support
09684 // tuples of up-to 10 fields.  The following implementation works
09685 // regardless of whether tr1::tuple is implemented using the
09686 // non-standard variadic template feature or not.
09687 
09688 inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) {
09689   PrintTupleTo(t, os);
09690 }
09691 
09692 template <typename T1>
09693 void PrintTo(const ::std::tr1::tuple<T1>& t, ::std::ostream* os) {
09694   PrintTupleTo(t, os);
09695 }
09696 
09697 template <typename T1, typename T2>
09698 void PrintTo(const ::std::tr1::tuple<T1, T2>& t, ::std::ostream* os) {
09699   PrintTupleTo(t, os);
09700 }
09701 
09702 template <typename T1, typename T2, typename T3>
09703 void PrintTo(const ::std::tr1::tuple<T1, T2, T3>& t, ::std::ostream* os) {
09704   PrintTupleTo(t, os);
09705 }
09706 
09707 template <typename T1, typename T2, typename T3, typename T4>
09708 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4>& t, ::std::ostream* os) {
09709   PrintTupleTo(t, os);
09710 }
09711 
09712 template <typename T1, typename T2, typename T3, typename T4, typename T5>
09713 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5>& t,
09714              ::std::ostream* os) {
09715   PrintTupleTo(t, os);
09716 }
09717 
09718 template <typename T1, typename T2, typename T3, typename T4, typename T5,
09719           typename T6>
09720 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6>& t,
09721              ::std::ostream* os) {
09722   PrintTupleTo(t, os);
09723 }
09724 
09725 template <typename T1, typename T2, typename T3, typename T4, typename T5,
09726           typename T6, typename T7>
09727 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7>& t,
09728              ::std::ostream* os) {
09729   PrintTupleTo(t, os);
09730 }
09731 
09732 template <typename T1, typename T2, typename T3, typename T4, typename T5,
09733           typename T6, typename T7, typename T8>
09734 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8>& t,
09735              ::std::ostream* os) {
09736   PrintTupleTo(t, os);
09737 }
09738 
09739 template <typename T1, typename T2, typename T3, typename T4, typename T5,
09740           typename T6, typename T7, typename T8, typename T9>
09741 void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>& t,
09742              ::std::ostream* os) {
09743   PrintTupleTo(t, os);
09744 }
09745 
09746 template <typename T1, typename T2, typename T3, typename T4, typename T5,
09747           typename T6, typename T7, typename T8, typename T9, typename T10>
09748 void PrintTo(
09749     const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& t,
09750     ::std::ostream* os) {
09751   PrintTupleTo(t, os);
09752 }
09753 #endif  // GTEST_HAS_TR1_TUPLE
09754 
09755 // Overload for std::pair.
09756 template <typename T1, typename T2>
09757 void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) {
09758   *os << '(';
09759   // We cannot use UniversalPrint(value.first, os) here, as T1 may be
09760   // a reference type.  The same for printing value.second.
09761   UniversalPrinter<T1>::Print(value.first, os);
09762   *os << ", ";
09763   UniversalPrinter<T2>::Print(value.second, os);
09764   *os << ')';
09765 }
09766 
09767 // Implements printing a non-reference type T by letting the compiler
09768 // pick the right overload of PrintTo() for T.
09769 template <typename T>
09770 class UniversalPrinter {
09771  public:
09772   // MSVC warns about adding const to a function type, so we want to
09773   // disable the warning.
09774 #ifdef _MSC_VER
09775 # pragma warning(push)          // Saves the current warning state.
09776 # pragma warning(disable:4180)  // Temporarily disables warning 4180.
09777 #endif  // _MSC_VER
09778 
09779   // Note: we deliberately don't call this PrintTo(), as that name
09780   // conflicts with ::testing::internal::PrintTo in the body of the
09781   // function.
09782   static void Print(const T& value, ::std::ostream* os) {
09783     // By default, ::testing::internal::PrintTo() is used for printing
09784     // the value.
09785     //
09786     // Thanks to Koenig look-up, if T is a class and has its own
09787     // PrintTo() function defined in its namespace, that function will
09788     // be visible here.  Since it is more specific than the generic ones
09789     // in ::testing::internal, it will be picked by the compiler in the
09790     // following statement - exactly what we want.
09791     PrintTo(value, os);
09792   }
09793 
09794 #ifdef _MSC_VER
09795 # pragma warning(pop)           // Restores the warning state.
09796 #endif  // _MSC_VER
09797 };
09798 
09799 // UniversalPrintArray(begin, len, os) prints an array of 'len'
09800 // elements, starting at address 'begin'.
09801 template <typename T>
09802 void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
09803   if (len == 0) {
09804     *os << "{}";
09805   } else {
09806     *os << "{ ";
09807     const size_t kThreshold = 18;
09808     const size_t kChunkSize = 8;
09809     // If the array has more than kThreshold elements, we'll have to
09810     // omit some details by printing only the first and the last
09811     // kChunkSize elements.
09812     // TODO(wan@google.com): let the user control the threshold using a flag.
09813     if (len <= kThreshold) {
09814       PrintRawArrayTo(begin, len, os);
09815     } else {
09816       PrintRawArrayTo(begin, kChunkSize, os);
09817       *os << ", ..., ";
09818       PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);
09819     }
09820     *os << " }";
09821   }
09822 }
09823 // This overload prints a (const) char array compactly.
09824 GTEST_API_ void UniversalPrintArray(
09825     const char* begin, size_t len, ::std::ostream* os);
09826 
09827 // This overload prints a (const) wchar_t array compactly.
09828 GTEST_API_ void UniversalPrintArray(
09829     const wchar_t* begin, size_t len, ::std::ostream* os);
09830 
09831 // Implements printing an array type T[N].
09832 template <typename T, size_t N>
09833 class UniversalPrinter<T[N]> {
09834  public:
09835   // Prints the given array, omitting some elements when there are too
09836   // many.
09837   static void Print(const T (&a)[N], ::std::ostream* os) {
09838     UniversalPrintArray(a, N, os);
09839   }
09840 };
09841 
09842 // Implements printing a reference type T&.
09843 template <typename T>
09844 class UniversalPrinter<T&> {
09845  public:
09846   // MSVC warns about adding const to a function type, so we want to
09847   // disable the warning.
09848 #ifdef _MSC_VER
09849 # pragma warning(push)          // Saves the current warning state.
09850 # pragma warning(disable:4180)  // Temporarily disables warning 4180.
09851 #endif  // _MSC_VER
09852 
09853   static void Print(const T& value, ::std::ostream* os) {
09854     // Prints the address of the value.  We use reinterpret_cast here
09855     // as static_cast doesn't compile when T is a function type.
09856     *os << "@" << reinterpret_cast<const void*>(&value) << " ";
09857 
09858     // Then prints the value itself.
09859     UniversalPrint(value, os);
09860   }
09861 
09862 #ifdef _MSC_VER
09863 # pragma warning(pop)           // Restores the warning state.
09864 #endif  // _MSC_VER
09865 };
09866 
09867 // Prints a value tersely: for a reference type, the referenced value
09868 // (but not the address) is printed; for a (const) char pointer, the
09869 // NUL-terminated string (but not the pointer) is printed.
09870 
09871 template <typename T>
09872 class UniversalTersePrinter {
09873  public:
09874   static void Print(const T& value, ::std::ostream* os) {
09875     UniversalPrint(value, os);
09876   }
09877 };
09878 template <typename T>
09879 class UniversalTersePrinter<T&> {
09880  public:
09881   static void Print(const T& value, ::std::ostream* os) {
09882     UniversalPrint(value, os);
09883   }
09884 };
09885 template <typename T, size_t N>
09886 class UniversalTersePrinter<T[N]> {
09887  public:
09888   static void Print(const T (&value)[N], ::std::ostream* os) {
09889     UniversalPrinter<T[N]>::Print(value, os);
09890   }
09891 };
09892 template <>
09893 class UniversalTersePrinter<const char*> {
09894  public:
09895   static void Print(const char* str, ::std::ostream* os) {
09896     if (str == NULL) {
09897       *os << "NULL";
09898     } else {
09899       UniversalPrint(string(str), os);
09900     }
09901   }
09902 };
09903 template <>
09904 class UniversalTersePrinter<char*> {
09905  public:
09906   static void Print(char* str, ::std::ostream* os) {
09907     UniversalTersePrinter<const char*>::Print(str, os);
09908   }
09909 };
09910 
09911 #if GTEST_HAS_STD_WSTRING
09912 template <>
09913 class UniversalTersePrinter<const wchar_t*> {
09914  public:
09915   static void Print(const wchar_t* str, ::std::ostream* os) {
09916     if (str == NULL) {
09917       *os << "NULL";
09918     } else {
09919       UniversalPrint(::std::wstring(str), os);
09920     }
09921   }
09922 };
09923 #endif
09924 
09925 template <>
09926 class UniversalTersePrinter<wchar_t*> {
09927  public:
09928   static void Print(wchar_t* str, ::std::ostream* os) {
09929     UniversalTersePrinter<const wchar_t*>::Print(str, os);
09930   }
09931 };
09932 
09933 template <typename T>
09934 void UniversalTersePrint(const T& value, ::std::ostream* os) {
09935   UniversalTersePrinter<T>::Print(value, os);
09936 }
09937 
09938 // Prints a value using the type inferred by the compiler.  The
09939 // difference between this and UniversalTersePrint() is that for a
09940 // (const) char pointer, this prints both the pointer and the
09941 // NUL-terminated string.
09942 template <typename T>
09943 void UniversalPrint(const T& value, ::std::ostream* os) {
09944   // A workarond for the bug in VC++ 7.1 that prevents us from instantiating
09945   // UniversalPrinter with T directly.
09946   typedef T T1;
09947   UniversalPrinter<T1>::Print(value, os);
09948 }
09949 
09950 #if GTEST_HAS_TR1_TUPLE
09951 typedef ::std::vector<string> Strings;
09952 
09953 // This helper template allows PrintTo() for tuples and
09954 // UniversalTersePrintTupleFieldsToStrings() to be defined by
09955 // induction on the number of tuple fields.  The idea is that
09956 // TuplePrefixPrinter<N>::PrintPrefixTo(t, os) prints the first N
09957 // fields in tuple t, and can be defined in terms of
09958 // TuplePrefixPrinter<N - 1>.
09959 
09960 // The inductive case.
09961 template <size_t N>
09962 struct TuplePrefixPrinter {
09963   // Prints the first N fields of a tuple.
09964   template <typename Tuple>
09965   static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
09966     TuplePrefixPrinter<N - 1>::PrintPrefixTo(t, os);
09967     *os << ", ";
09968     UniversalPrinter<typename ::std::tr1::tuple_element<N - 1, Tuple>::type>
09969         ::Print(::std::tr1::get<N - 1>(t), os);
09970   }
09971 
09972   // Tersely prints the first N fields of a tuple to a string vector,
09973   // one element for each field.
09974   template <typename Tuple>
09975   static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
09976     TuplePrefixPrinter<N - 1>::TersePrintPrefixToStrings(t, strings);
09977     ::std::stringstream ss;
09978     UniversalTersePrint(::std::tr1::get<N - 1>(t), &ss);
09979     strings->push_back(ss.str());
09980   }
09981 };
09982 
09983 // Base cases.
09984 template <>
09985 struct TuplePrefixPrinter<0> {
09986   template <typename Tuple>
09987   static void PrintPrefixTo(const Tuple&, ::std::ostream*) {}
09988 
09989   template <typename Tuple>
09990   static void TersePrintPrefixToStrings(const Tuple&, Strings*) {}
09991 };
09992 // We have to specialize the entire TuplePrefixPrinter<> class
09993 // template here, even though the definition of
09994 // TersePrintPrefixToStrings() is the same as the generic version, as
09995 // Embarcadero (formerly CodeGear, formerly Borland) C++ doesn't
09996 // support specializing a method template of a class template.
09997 template <>
09998 struct TuplePrefixPrinter<1> {
09999   template <typename Tuple>
10000   static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
10001     UniversalPrinter<typename ::std::tr1::tuple_element<0, Tuple>::type>::
10002         Print(::std::tr1::get<0>(t), os);
10003   }
10004 
10005   template <typename Tuple>
10006   static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
10007     ::std::stringstream ss;
10008     UniversalTersePrint(::std::tr1::get<0>(t), &ss);
10009     strings->push_back(ss.str());
10010   }
10011 };
10012 
10013 // Helper function for printing a tuple.  T must be instantiated with
10014 // a tuple type.
10015 template <typename T>
10016 void PrintTupleTo(const T& t, ::std::ostream* os) {
10017   *os << "(";
10018   TuplePrefixPrinter< ::std::tr1::tuple_size<T>::value>::
10019       PrintPrefixTo(t, os);
10020   *os << ")";
10021 }
10022 
10023 // Prints the fields of a tuple tersely to a string vector, one
10024 // element for each field.  See the comment before
10025 // UniversalTersePrint() for how we define "tersely".
10026 template <typename Tuple>
10027 Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
10028   Strings result;
10029   TuplePrefixPrinter< ::std::tr1::tuple_size<Tuple>::value>::
10030       TersePrintPrefixToStrings(value, &result);
10031   return result;
10032 }
10033 #endif  // GTEST_HAS_TR1_TUPLE
10034 
10035 }  // namespace internal
10036 
10037 template <typename T>
10038 ::std::string PrintToString(const T& value) {
10039   ::std::stringstream ss;
10040   internal::UniversalTersePrinter<T>::Print(value, &ss);
10041   return ss.str();
10042 }
10043 
10044 }  // namespace testing
10045 
10046 #endif  // GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
10047 
10048 #if GTEST_HAS_PARAM_TEST
10049 
10050 namespace testing {
10051 namespace internal {
10052 
10053 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
10054 //
10055 // Outputs a message explaining invalid registration of different
10056 // fixture class for the same test case. This may happen when
10057 // TEST_P macro is used to define two tests with the same name
10058 // but in different namespaces.
10059 GTEST_API_ void ReportInvalidTestCaseType(const char* test_case_name,
10060                                           const char* file, int line);
10061 
10062 template <typename> class ParamGeneratorInterface;
10063 template <typename> class ParamGenerator;
10064 
10065 // Interface for iterating over elements provided by an implementation
10066 // of ParamGeneratorInterface<T>.
10067 template <typename T>
10068 class ParamIteratorInterface {
10069  public:
10070   virtual ~ParamIteratorInterface() {}
10071   // A pointer to the base generator instance.
10072   // Used only for the purposes of iterator comparison
10073   // to make sure that two iterators belong to the same generator.
10074   virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0;
10075   // Advances iterator to point to the next element
10076   // provided by the generator. The caller is responsible
10077   // for not calling Advance() on an iterator equal to
10078   // BaseGenerator()->End().
10079   virtual void Advance() = 0;
10080   // Clones the iterator object. Used for implementing copy semantics
10081   // of ParamIterator<T>.
10082   virtual ParamIteratorInterface* Clone() const = 0;
10083   // Dereferences the current iterator and provides (read-only) access
10084   // to the pointed value. It is the caller's responsibility not to call
10085   // Current() on an iterator equal to BaseGenerator()->End().
10086   // Used for implementing ParamGenerator<T>::operator*().
10087   virtual const T* Current() const = 0;
10088   // Determines whether the given iterator and other point to the same
10089   // element in the sequence generated by the generator.
10090   // Used for implementing ParamGenerator<T>::operator==().
10091   virtual bool Equals(const ParamIteratorInterface& other) const = 0;
10092 };
10093 
10094 // Class iterating over elements provided by an implementation of
10095 // ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T>
10096 // and implements the const forward iterator concept.
10097 template <typename T>
10098 class ParamIterator {
10099  public:
10100   typedef T value_type;
10101   typedef const T& reference;
10102   typedef ptrdiff_t difference_type;
10103 
10104   // ParamIterator assumes ownership of the impl_ pointer.
10105   ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {}
10106   ParamIterator& operator=(const ParamIterator& other) {
10107     if (this != &other)
10108       impl_.reset(other.impl_->Clone());
10109     return *this;
10110   }
10111 
10112   const T& operator*() const { return *impl_->Current(); }
10113   const T* operator->() const { return impl_->Current(); }
10114   // Prefix version of operator++.
10115   ParamIterator& operator++() {
10116     impl_->Advance();
10117     return *this;
10118   }
10119   // Postfix version of operator++.
10120   ParamIterator operator++(int /*unused*/) {
10121     ParamIteratorInterface<T>* clone = impl_->Clone();
10122     impl_->Advance();
10123     return ParamIterator(clone);
10124   }
10125   bool operator==(const ParamIterator& other) const {
10126     return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_);
10127   }
10128   bool operator!=(const ParamIterator& other) const {
10129     return !(*this == other);
10130   }
10131 
10132  private:
10133   friend class ParamGenerator<T>;
10134   explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {}
10135   scoped_ptr<ParamIteratorInterface<T> > impl_;
10136 };
10137 
10138 // ParamGeneratorInterface<T> is the binary interface to access generators
10139 // defined in other translation units.
10140 template <typename T>
10141 class ParamGeneratorInterface {
10142  public:
10143   typedef T ParamType;
10144 
10145   virtual ~ParamGeneratorInterface() {}
10146 
10147   // Generator interface definition
10148   virtual ParamIteratorInterface<T>* Begin() const = 0;
10149   virtual ParamIteratorInterface<T>* End() const = 0;
10150 };
10151 
10152 // Wraps ParamGeneratorInterface<T> and provides general generator syntax
10153 // compatible with the STL Container concept.
10154 // This class implements copy initialization semantics and the contained
10155 // ParamGeneratorInterface<T> instance is shared among all copies
10156 // of the original object. This is possible because that instance is immutable.
10157 template<typename T>
10158 class ParamGenerator {
10159  public:
10160   typedef ParamIterator<T> iterator;
10161 
10162   explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {}
10163   ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {}
10164 
10165   ParamGenerator& operator=(const ParamGenerator& other) {
10166     impl_ = other.impl_;
10167     return *this;
10168   }
10169 
10170   iterator begin() const { return iterator(impl_->Begin()); }
10171   iterator end() const { return iterator(impl_->End()); }
10172 
10173  private:
10174   linked_ptr<const ParamGeneratorInterface<T> > impl_;
10175 };
10176 
10177 // Generates values from a range of two comparable values. Can be used to
10178 // generate sequences of user-defined types that implement operator+() and
10179 // operator<().
10180 // This class is used in the Range() function.
10181 template <typename T, typename IncrementT>
10182 class RangeGenerator : public ParamGeneratorInterface<T> {
10183  public:
10184   RangeGenerator(T begin, T end, IncrementT step)
10185       : begin_(begin), end_(end),
10186         step_(step), end_index_(CalculateEndIndex(begin, end, step)) {}
10187   virtual ~RangeGenerator() {}
10188 
10189   virtual ParamIteratorInterface<T>* Begin() const {
10190     return new Iterator(this, begin_, 0, step_);
10191   }
10192   virtual ParamIteratorInterface<T>* End() const {
10193     return new Iterator(this, end_, end_index_, step_);
10194   }
10195 
10196  private:
10197   class Iterator : public ParamIteratorInterface<T> {
10198    public:
10199     Iterator(const ParamGeneratorInterface<T>* base, T value, int index,
10200              IncrementT step)
10201         : base_(base), value_(value), index_(index), step_(step) {}
10202     virtual ~Iterator() {}
10203 
10204     virtual const ParamGeneratorInterface<T>* BaseGenerator() const {
10205       return base_;
10206     }
10207     virtual void Advance() {
10208       value_ = value_ + step_;
10209       index_++;
10210     }
10211     virtual ParamIteratorInterface<T>* Clone() const {
10212       return new Iterator(*this);
10213     }
10214     virtual const T* Current() const { return &value_; }
10215     virtual bool Equals(const ParamIteratorInterface<T>& other) const {
10216       // Having the same base generator guarantees that the other
10217       // iterator is of the same type and we can downcast.
10218       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
10219           << "The program attempted to compare iterators "
10220           << "from different generators." << std::endl;
10221       const int other_index =
10222           CheckedDowncastToActualType<const Iterator>(&other)->index_;
10223       return index_ == other_index;
10224     }
10225 
10226    private:
10227     Iterator(const Iterator& other)
10228         : ParamIteratorInterface<T>(),
10229           base_(other.base_), value_(other.value_), index_(other.index_),
10230           step_(other.step_) {}
10231 
10232     // No implementation - assignment is unsupported.
10233     void operator=(const Iterator& other);
10234 
10235     const ParamGeneratorInterface<T>* const base_;
10236     T value_;
10237     int index_;
10238     const IncrementT step_;
10239   };  // class RangeGenerator::Iterator
10240 
10241   static int CalculateEndIndex(const T& begin,
10242                                const T& end,
10243                                const IncrementT& step) {
10244     int end_index = 0;
10245     for (T i = begin; i < end; i = i + step)
10246       end_index++;
10247     return end_index;
10248   }
10249 
10250   // No implementation - assignment is unsupported.
10251   void operator=(const RangeGenerator& other);
10252 
10253   const T begin_;
10254   const T end_;
10255   const IncrementT step_;
10256   // The index for the end() iterator. All the elements in the generated
10257   // sequence are indexed (0-based) to aid iterator comparison.
10258   const int end_index_;
10259 };  // class RangeGenerator
10260 
10261 
10262 // Generates values from a pair of STL-style iterators. Used in the
10263 // ValuesIn() function. The elements are copied from the source range
10264 // since the source can be located on the stack, and the generator
10265 // is likely to persist beyond that stack frame.
10266 template <typename T>
10267 class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
10268  public:
10269   template <typename ForwardIterator>
10270   ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
10271       : container_(begin, end) {}
10272   virtual ~ValuesInIteratorRangeGenerator() {}
10273 
10274   virtual ParamIteratorInterface<T>* Begin() const {
10275     return new Iterator(this, container_.begin());
10276   }
10277   virtual ParamIteratorInterface<T>* End() const {
10278     return new Iterator(this, container_.end());
10279   }
10280 
10281  private:
10282   typedef typename ::std::vector<T> ContainerType;
10283 
10284   class Iterator : public ParamIteratorInterface<T> {
10285    public:
10286     Iterator(const ParamGeneratorInterface<T>* base,
10287              typename ContainerType::const_iterator iterator)
10288         : base_(base), iterator_(iterator) {}
10289     virtual ~Iterator() {}
10290 
10291     virtual const ParamGeneratorInterface<T>* BaseGenerator() const {
10292       return base_;
10293     }
10294     virtual void Advance() {
10295       ++iterator_;
10296       value_.reset();
10297     }
10298     virtual ParamIteratorInterface<T>* Clone() const {
10299       return new Iterator(*this);
10300     }
10301     // We need to use cached value referenced by iterator_ because *iterator_
10302     // can return a temporary object (and of type other then T), so just
10303     // having "return &*iterator_;" doesn't work.
10304     // value_ is updated here and not in Advance() because Advance()
10305     // can advance iterator_ beyond the end of the range, and we cannot
10306     // detect that fact. The client code, on the other hand, is
10307     // responsible for not calling Current() on an out-of-range iterator.
10308     virtual const T* Current() const {
10309       if (value_.get() == NULL)
10310         value_.reset(new T(*iterator_));
10311       return value_.get();
10312     }
10313     virtual bool Equals(const ParamIteratorInterface<T>& other) const {
10314       // Having the same base generator guarantees that the other
10315       // iterator is of the same type and we can downcast.
10316       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
10317           << "The program attempted to compare iterators "
10318           << "from different generators." << std::endl;
10319       return iterator_ ==
10320           CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
10321     }
10322 
10323    private:
10324     Iterator(const Iterator& other)
10325           // The explicit constructor call suppresses a false warning
10326           // emitted by gcc when supplied with the -Wextra option.
10327         : ParamIteratorInterface<T>(),
10328           base_(other.base_),
10329           iterator_(other.iterator_) {}
10330 
10331     const ParamGeneratorInterface<T>* const base_;
10332     typename ContainerType::const_iterator iterator_;
10333     // A cached value of *iterator_. We keep it here to allow access by
10334     // pointer in the wrapping iterator's operator->().
10335     // value_ needs to be mutable to be accessed in Current().
10336     // Use of scoped_ptr helps manage cached value's lifetime,
10337     // which is bound by the lifespan of the iterator itself.
10338     mutable scoped_ptr<const T> value_;
10339   };  // class ValuesInIteratorRangeGenerator::Iterator
10340 
10341   // No implementation - assignment is unsupported.
10342   void operator=(const ValuesInIteratorRangeGenerator& other);
10343 
10344   const ContainerType container_;
10345 };  // class ValuesInIteratorRangeGenerator
10346 
10347 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
10348 //
10349 // Stores a parameter value and later creates tests parameterized with that
10350 // value.
10351 template <class TestClass>
10352 class ParameterizedTestFactory : public TestFactoryBase {
10353  public:
10354   typedef typename TestClass::ParamType ParamType;
10355   explicit ParameterizedTestFactory(ParamType parameter) :
10356       parameter_(parameter) {}
10357   virtual Test* CreateTest() {
10358     TestClass::SetParam(&parameter_);
10359     return new TestClass();
10360   }
10361 
10362  private:
10363   const ParamType parameter_;
10364 
10365   GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory);
10366 };
10367 
10368 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
10369 //
10370 // TestMetaFactoryBase is a base class for meta-factories that create
10371 // test factories for passing into MakeAndRegisterTestInfo function.
10372 template <class ParamType>
10373 class TestMetaFactoryBase {
10374  public:
10375   virtual ~TestMetaFactoryBase() {}
10376 
10377   virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0;
10378 };
10379 
10380 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
10381 //
10382 // TestMetaFactory creates test factories for passing into
10383 // MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives
10384 // ownership of test factory pointer, same factory object cannot be passed
10385 // into that method twice. But ParameterizedTestCaseInfo is going to call
10386 // it for each Test/Parameter value combination. Thus it needs meta factory
10387 // creator class.
10388 template <class TestCase>
10389 class TestMetaFactory
10390     : public TestMetaFactoryBase<typename TestCase::ParamType> {
10391  public:
10392   typedef typename TestCase::ParamType ParamType;
10393 
10394   TestMetaFactory() {}
10395 
10396   virtual TestFactoryBase* CreateTestFactory(ParamType parameter) {
10397     return new ParameterizedTestFactory<TestCase>(parameter);
10398   }
10399 
10400  private:
10401   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory);
10402 };
10403 
10404 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
10405 //
10406 // ParameterizedTestCaseInfoBase is a generic interface
10407 // to ParameterizedTestCaseInfo classes. ParameterizedTestCaseInfoBase
10408 // accumulates test information provided by TEST_P macro invocations
10409 // and generators provided by INSTANTIATE_TEST_CASE_P macro invocations
10410 // and uses that information to register all resulting test instances
10411 // in RegisterTests method. The ParameterizeTestCaseRegistry class holds
10412 // a collection of pointers to the ParameterizedTestCaseInfo objects
10413 // and calls RegisterTests() on each of them when asked.
10414 class ParameterizedTestCaseInfoBase {
10415  public:
10416   virtual ~ParameterizedTestCaseInfoBase() {}
10417 
10418   // Base part of test case name for display purposes.
10419   virtual const string& GetTestCaseName() const = 0;
10420   // Test case id to verify identity.
10421   virtual TypeId GetTestCaseTypeId() const = 0;
10422   // UnitTest class invokes this method to register tests in this
10423   // test case right before running them in RUN_ALL_TESTS macro.
10424   // This method should not be called more then once on any single
10425   // instance of a ParameterizedTestCaseInfoBase derived class.
10426   virtual void RegisterTests() = 0;
10427 
10428  protected:
10429   ParameterizedTestCaseInfoBase() {}
10430 
10431  private:
10432   GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfoBase);
10433 };
10434 
10435 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
10436 //
10437 // ParameterizedTestCaseInfo accumulates tests obtained from TEST_P
10438 // macro invocations for a particular test case and generators
10439 // obtained from INSTANTIATE_TEST_CASE_P macro invocations for that
10440 // test case. It registers tests with all values generated by all
10441 // generators when asked.
10442 template <class TestCase>
10443 class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase {
10444  public:
10445   // ParamType and GeneratorCreationFunc are private types but are required
10446   // for declarations of public methods AddTestPattern() and
10447   // AddTestCaseInstantiation().
10448   typedef typename TestCase::ParamType ParamType;
10449   // A function that returns an instance of appropriate generator type.
10450   typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
10451 
10452   explicit ParameterizedTestCaseInfo(const char* name)
10453       : test_case_name_(name) {}
10454 
10455   // Test case base name for display purposes.
10456   virtual const string& GetTestCaseName() const { return test_case_name_; }
10457   // Test case id to verify identity.
10458   virtual TypeId GetTestCaseTypeId() const { return GetTypeId<TestCase>(); }
10459   // TEST_P macro uses AddTestPattern() to record information
10460   // about a single test in a LocalTestInfo structure.
10461   // test_case_name is the base name of the test case (without invocation
10462   // prefix). test_base_name is the name of an individual test without
10463   // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
10464   // test case base name and DoBar is test base name.
10465   void AddTestPattern(const char* test_case_name,
10466                       const char* test_base_name,
10467                       TestMetaFactoryBase<ParamType>* meta_factory) {
10468     tests_.push_back(linked_ptr<TestInfo>(new TestInfo(test_case_name,
10469                                                        test_base_name,
10470                                                        meta_factory)));
10471   }
10472   // INSTANTIATE_TEST_CASE_P macro uses AddGenerator() to record information
10473   // about a generator.
10474   int AddTestCaseInstantiation(const string& instantiation_name,
10475                                GeneratorCreationFunc* func,
10476                                const char* /* file */,
10477                                int /* line */) {
10478     instantiations_.push_back(::std::make_pair(instantiation_name, func));
10479     return 0;  // Return value used only to run this method in namespace scope.
10480   }
10481   // UnitTest class invokes this method to register tests in this test case
10482   // test cases right before running tests in RUN_ALL_TESTS macro.
10483   // This method should not be called more then once on any single
10484   // instance of a ParameterizedTestCaseInfoBase derived class.
10485   // UnitTest has a guard to prevent from calling this method more then once.
10486   virtual void RegisterTests() {
10487     for (typename TestInfoContainer::iterator test_it = tests_.begin();
10488          test_it != tests_.end(); ++test_it) {
10489       linked_ptr<TestInfo> test_info = *test_it;
10490       for (typename InstantiationContainer::iterator gen_it =
10491                instantiations_.begin(); gen_it != instantiations_.end();
10492                ++gen_it) {
10493         const string& instantiation_name = gen_it->first;
10494         ParamGenerator<ParamType> generator((*gen_it->second)());
10495 
10496         string test_case_name;
10497         if ( !instantiation_name.empty() )
10498           test_case_name = instantiation_name + "/";
10499         test_case_name += test_info->test_case_base_name;
10500 
10501         int i = 0;
10502         for (typename ParamGenerator<ParamType>::iterator param_it =
10503                  generator.begin();
10504              param_it != generator.end(); ++param_it, ++i) {
10505           Message test_name_stream;
10506           test_name_stream << test_info->test_base_name << "/" << i;
10507           MakeAndRegisterTestInfo(
10508               test_case_name.c_str(),
10509               test_name_stream.GetString().c_str(),
10510               NULL,  // No type parameter.
10511               PrintToString(*param_it).c_str(),
10512               GetTestCaseTypeId(),
10513               TestCase::SetUpTestCase,
10514               TestCase::TearDownTestCase,
10515               test_info->test_meta_factory->CreateTestFactory(*param_it));
10516         }  // for param_it
10517       }  // for gen_it
10518     }  // for test_it
10519   }  // RegisterTests
10520 
10521  private:
10522   // LocalTestInfo structure keeps information about a single test registered
10523   // with TEST_P macro.
10524   struct TestInfo {
10525     TestInfo(const char* a_test_case_base_name,
10526              const char* a_test_base_name,
10527              TestMetaFactoryBase<ParamType>* a_test_meta_factory) :
10528         test_case_base_name(a_test_case_base_name),
10529         test_base_name(a_test_base_name),
10530         test_meta_factory(a_test_meta_factory) {}
10531 
10532     const string test_case_base_name;
10533     const string test_base_name;
10534     const scoped_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory;
10535   };
10536   typedef ::std::vector<linked_ptr<TestInfo> > TestInfoContainer;
10537   // Keeps pairs of <Instantiation name, Sequence generator creation function>
10538   // received from INSTANTIATE_TEST_CASE_P macros.
10539   typedef ::std::vector<std::pair<string, GeneratorCreationFunc*> >
10540       InstantiationContainer;
10541 
10542   const string test_case_name_;
10543   TestInfoContainer tests_;
10544   InstantiationContainer instantiations_;
10545 
10546   GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfo);
10547 };  // class ParameterizedTestCaseInfo
10548 
10549 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
10550 //
10551 // ParameterizedTestCaseRegistry contains a map of ParameterizedTestCaseInfoBase
10552 // classes accessed by test case names. TEST_P and INSTANTIATE_TEST_CASE_P
10553 // macros use it to locate their corresponding ParameterizedTestCaseInfo
10554 // descriptors.
10555 class ParameterizedTestCaseRegistry {
10556  public:
10557   ParameterizedTestCaseRegistry() {}
10558   ~ParameterizedTestCaseRegistry() {
10559     for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
10560          it != test_case_infos_.end(); ++it) {
10561       delete *it;
10562     }
10563   }
10564 
10565   // Looks up or creates and returns a structure containing information about
10566   // tests and instantiations of a particular test case.
10567   template <class TestCase>
10568   ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
10569       const char* test_case_name,
10570       const char* file,
10571       int line) {
10572     ParameterizedTestCaseInfo<TestCase>* typed_test_info = NULL;
10573     for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
10574          it != test_case_infos_.end(); ++it) {
10575       if ((*it)->GetTestCaseName() == test_case_name) {
10576         if ((*it)->GetTestCaseTypeId() != GetTypeId<TestCase>()) {
10577           // Complain about incorrect usage of Google Test facilities
10578           // and terminate the program since we cannot guaranty correct
10579           // test case setup and tear-down in this case.
10580           ReportInvalidTestCaseType(test_case_name,  file, line);
10581           posix::Abort();
10582         } else {
10583           // At this point we are sure that the object we found is of the same
10584           // type we are looking for, so we downcast it to that type
10585           // without further checks.
10586           typed_test_info = CheckedDowncastToActualType<
10587               ParameterizedTestCaseInfo<TestCase> >(*it);
10588         }
10589         break;
10590       }
10591     }
10592     if (typed_test_info == NULL) {
10593       typed_test_info = new ParameterizedTestCaseInfo<TestCase>(test_case_name);
10594       test_case_infos_.push_back(typed_test_info);
10595     }
10596     return typed_test_info;
10597   }
10598   void RegisterTests() {
10599     for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
10600          it != test_case_infos_.end(); ++it) {
10601       (*it)->RegisterTests();
10602     }
10603   }
10604 
10605  private:
10606   typedef ::std::vector<ParameterizedTestCaseInfoBase*> TestCaseInfoContainer;
10607 
10608   TestCaseInfoContainer test_case_infos_;
10609 
10610   GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseRegistry);
10611 };
10612 
10613 }  // namespace internal
10614 }  // namespace testing
10615 
10616 #endif  //  GTEST_HAS_PARAM_TEST
10617 
10618 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
10619 // This file was GENERATED by command:
10620 //     pump.py gtest-param-util-generated.h.pump
10621 // DO NOT EDIT BY HAND!!!
10622 
10623 // Copyright 2008 Google Inc.
10624 // All Rights Reserved.
10625 //
10626 // Redistribution and use in source and binary forms, with or without
10627 // modification, are permitted provided that the following conditions are
10628 // met:
10629 //
10630 //     * Redistributions of source code must retain the above copyright
10631 // notice, this list of conditions and the following disclaimer.
10632 //     * Redistributions in binary form must reproduce the above
10633 // copyright notice, this list of conditions and the following disclaimer
10634 // in the documentation and/or other materials provided with the
10635 // distribution.
10636 //     * Neither the name of Google Inc. nor the names of its
10637 // contributors may be used to endorse or promote products derived from
10638 // this software without specific prior written permission.
10639 //
10640 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
10641 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
10642 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
10643 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
10644 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
10645 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
10646 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
10647 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
10648 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
10649 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
10650 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
10651 //
10652 // Author: vladl@google.com (Vlad Losev)
10653 
10654 // Type and function utilities for implementing parameterized tests.
10655 // This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
10656 //
10657 // Currently Google Test supports at most 50 arguments in Values,
10658 // and at most 10 arguments in Combine. Please contact
10659 // googletestframework@googlegroups.com if you need more.
10660 // Please note that the number of arguments to Combine is limited
10661 // by the maximum arity of the implementation of tr1::tuple which is
10662 // currently set at 10.
10663 
10664 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
10665 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
10666 
10667 // scripts/fuse_gtest.py depends on gtest's own header being #included
10668 // *unconditionally*.  Therefore these #includes cannot be moved
10669 // inside #if GTEST_HAS_PARAM_TEST.
10670 
10671 #if GTEST_HAS_PARAM_TEST
10672 
10673 namespace testing {
10674 
10675 // Forward declarations of ValuesIn(), which is implemented in
10676 // include/gtest/gtest-param-test.h.
10677 template <typename ForwardIterator>
10678 internal::ParamGenerator<
10679   typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
10680 ValuesIn(ForwardIterator begin, ForwardIterator end);
10681 
10682 template <typename T, size_t N>
10683 internal::ParamGenerator<T> ValuesIn(const T (&array)[N]);
10684 
10685 template <class Container>
10686 internal::ParamGenerator<typename Container::value_type> ValuesIn(
10687     const Container& container);
10688 
10689 namespace internal {
10690 
10691 // Used in the Values() function to provide polymorphic capabilities.
10692 template <typename T1>
10693 class ValueArray1 {
10694  public:
10695   explicit ValueArray1(T1 v1) : v1_(v1) {}
10696 
10697   template <typename T>
10698   operator ParamGenerator<T>() const { return ValuesIn(&v1_, &v1_ + 1); }
10699 
10700  private:
10701   // No implementation - assignment is unsupported.
10702   void operator=(const ValueArray1& other);
10703 
10704   const T1 v1_;
10705 };
10706 
10707 template <typename T1, typename T2>
10708 class ValueArray2 {
10709  public:
10710   ValueArray2(T1 v1, T2 v2) : v1_(v1), v2_(v2) {}
10711 
10712   template <typename T>
10713   operator ParamGenerator<T>() const {
10714     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_)};
10715     return ValuesIn(array);
10716   }
10717 
10718  private:
10719   // No implementation - assignment is unsupported.
10720   void operator=(const ValueArray2& other);
10721 
10722   const T1 v1_;
10723   const T2 v2_;
10724 };
10725 
10726 template <typename T1, typename T2, typename T3>
10727 class ValueArray3 {
10728  public:
10729   ValueArray3(T1 v1, T2 v2, T3 v3) : v1_(v1), v2_(v2), v3_(v3) {}
10730 
10731   template <typename T>
10732   operator ParamGenerator<T>() const {
10733     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
10734         static_cast<T>(v3_)};
10735     return ValuesIn(array);
10736   }
10737 
10738  private:
10739   // No implementation - assignment is unsupported.
10740   void operator=(const ValueArray3& other);
10741 
10742   const T1 v1_;
10743   const T2 v2_;
10744   const T3 v3_;
10745 };
10746 
10747 template <typename T1, typename T2, typename T3, typename T4>
10748 class ValueArray4 {
10749  public:
10750   ValueArray4(T1 v1, T2 v2, T3 v3, T4 v4) : v1_(v1), v2_(v2), v3_(v3),
10751       v4_(v4) {}
10752 
10753   template <typename T>
10754   operator ParamGenerator<T>() const {
10755     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
10756         static_cast<T>(v3_), static_cast<T>(v4_)};
10757     return ValuesIn(array);
10758   }
10759 
10760  private:
10761   // No implementation - assignment is unsupported.
10762   void operator=(const ValueArray4& other);
10763 
10764   const T1 v1_;
10765   const T2 v2_;
10766   const T3 v3_;
10767   const T4 v4_;
10768 };
10769 
10770 template <typename T1, typename T2, typename T3, typename T4, typename T5>
10771 class ValueArray5 {
10772  public:
10773   ValueArray5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) : v1_(v1), v2_(v2), v3_(v3),
10774       v4_(v4), v5_(v5) {}
10775 
10776   template <typename T>
10777   operator ParamGenerator<T>() const {
10778     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
10779         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_)};
10780     return ValuesIn(array);
10781   }
10782 
10783  private:
10784   // No implementation - assignment is unsupported.
10785   void operator=(const ValueArray5& other);
10786 
10787   const T1 v1_;
10788   const T2 v2_;
10789   const T3 v3_;
10790   const T4 v4_;
10791   const T5 v5_;
10792 };
10793 
10794 template <typename T1, typename T2, typename T3, typename T4, typename T5,
10795     typename T6>
10796 class ValueArray6 {
10797  public:
10798   ValueArray6(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) : v1_(v1), v2_(v2),
10799       v3_(v3), v4_(v4), v5_(v5), v6_(v6) {}
10800 
10801   template <typename T>
10802   operator ParamGenerator<T>() const {
10803     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
10804         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
10805         static_cast<T>(v6_)};
10806     return ValuesIn(array);
10807   }
10808 
10809  private:
10810   // No implementation - assignment is unsupported.
10811   void operator=(const ValueArray6& other);
10812 
10813   const T1 v1_;
10814   const T2 v2_;
10815   const T3 v3_;
10816   const T4 v4_;
10817   const T5 v5_;
10818   const T6 v6_;
10819 };
10820 
10821 template <typename T1, typename T2, typename T3, typename T4, typename T5,
10822     typename T6, typename T7>
10823 class ValueArray7 {
10824  public:
10825   ValueArray7(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) : v1_(v1),
10826       v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7) {}
10827 
10828   template <typename T>
10829   operator ParamGenerator<T>() const {
10830     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
10831         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
10832         static_cast<T>(v6_), static_cast<T>(v7_)};
10833     return ValuesIn(array);
10834   }
10835 
10836  private:
10837   // No implementation - assignment is unsupported.
10838   void operator=(const ValueArray7& other);
10839 
10840   const T1 v1_;
10841   const T2 v2_;
10842   const T3 v3_;
10843   const T4 v4_;
10844   const T5 v5_;
10845   const T6 v6_;
10846   const T7 v7_;
10847 };
10848 
10849 template <typename T1, typename T2, typename T3, typename T4, typename T5,
10850     typename T6, typename T7, typename T8>
10851 class ValueArray8 {
10852  public:
10853   ValueArray8(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
10854       T8 v8) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
10855       v8_(v8) {}
10856 
10857   template <typename T>
10858   operator ParamGenerator<T>() const {
10859     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
10860         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
10861         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_)};
10862     return ValuesIn(array);
10863   }
10864 
10865  private:
10866   // No implementation - assignment is unsupported.
10867   void operator=(const ValueArray8& other);
10868 
10869   const T1 v1_;
10870   const T2 v2_;
10871   const T3 v3_;
10872   const T4 v4_;
10873   const T5 v5_;
10874   const T6 v6_;
10875   const T7 v7_;
10876   const T8 v8_;
10877 };
10878 
10879 template <typename T1, typename T2, typename T3, typename T4, typename T5,
10880     typename T6, typename T7, typename T8, typename T9>
10881 class ValueArray9 {
10882  public:
10883   ValueArray9(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
10884       T9 v9) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
10885       v8_(v8), v9_(v9) {}
10886 
10887   template <typename T>
10888   operator ParamGenerator<T>() const {
10889     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
10890         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
10891         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
10892         static_cast<T>(v9_)};
10893     return ValuesIn(array);
10894   }
10895 
10896  private:
10897   // No implementation - assignment is unsupported.
10898   void operator=(const ValueArray9& other);
10899 
10900   const T1 v1_;
10901   const T2 v2_;
10902   const T3 v3_;
10903   const T4 v4_;
10904   const T5 v5_;
10905   const T6 v6_;
10906   const T7 v7_;
10907   const T8 v8_;
10908   const T9 v9_;
10909 };
10910 
10911 template <typename T1, typename T2, typename T3, typename T4, typename T5,
10912     typename T6, typename T7, typename T8, typename T9, typename T10>
10913 class ValueArray10 {
10914  public:
10915   ValueArray10(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
10916       T10 v10) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
10917       v8_(v8), v9_(v9), v10_(v10) {}
10918 
10919   template <typename T>
10920   operator ParamGenerator<T>() const {
10921     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
10922         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
10923         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
10924         static_cast<T>(v9_), static_cast<T>(v10_)};
10925     return ValuesIn(array);
10926   }
10927 
10928  private:
10929   // No implementation - assignment is unsupported.
10930   void operator=(const ValueArray10& other);
10931 
10932   const T1 v1_;
10933   const T2 v2_;
10934   const T3 v3_;
10935   const T4 v4_;
10936   const T5 v5_;
10937   const T6 v6_;
10938   const T7 v7_;
10939   const T8 v8_;
10940   const T9 v9_;
10941   const T10 v10_;
10942 };
10943 
10944 template <typename T1, typename T2, typename T3, typename T4, typename T5,
10945     typename T6, typename T7, typename T8, typename T9, typename T10,
10946     typename T11>
10947 class ValueArray11 {
10948  public:
10949   ValueArray11(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
10950       T10 v10, T11 v11) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
10951       v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11) {}
10952 
10953   template <typename T>
10954   operator ParamGenerator<T>() const {
10955     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
10956         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
10957         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
10958         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_)};
10959     return ValuesIn(array);
10960   }
10961 
10962  private:
10963   // No implementation - assignment is unsupported.
10964   void operator=(const ValueArray11& other);
10965 
10966   const T1 v1_;
10967   const T2 v2_;
10968   const T3 v3_;
10969   const T4 v4_;
10970   const T5 v5_;
10971   const T6 v6_;
10972   const T7 v7_;
10973   const T8 v8_;
10974   const T9 v9_;
10975   const T10 v10_;
10976   const T11 v11_;
10977 };
10978 
10979 template <typename T1, typename T2, typename T3, typename T4, typename T5,
10980     typename T6, typename T7, typename T8, typename T9, typename T10,
10981     typename T11, typename T12>
10982 class ValueArray12 {
10983  public:
10984   ValueArray12(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
10985       T10 v10, T11 v11, T12 v12) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
10986       v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12) {}
10987 
10988   template <typename T>
10989   operator ParamGenerator<T>() const {
10990     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
10991         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
10992         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
10993         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
10994         static_cast<T>(v12_)};
10995     return ValuesIn(array);
10996   }
10997 
10998  private:
10999   // No implementation - assignment is unsupported.
11000   void operator=(const ValueArray12& other);
11001 
11002   const T1 v1_;
11003   const T2 v2_;
11004   const T3 v3_;
11005   const T4 v4_;
11006   const T5 v5_;
11007   const T6 v6_;
11008   const T7 v7_;
11009   const T8 v8_;
11010   const T9 v9_;
11011   const T10 v10_;
11012   const T11 v11_;
11013   const T12 v12_;
11014 };
11015 
11016 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11017     typename T6, typename T7, typename T8, typename T9, typename T10,
11018     typename T11, typename T12, typename T13>
11019 class ValueArray13 {
11020  public:
11021   ValueArray13(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
11022       T10 v10, T11 v11, T12 v12, T13 v13) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
11023       v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
11024       v12_(v12), v13_(v13) {}
11025 
11026   template <typename T>
11027   operator ParamGenerator<T>() const {
11028     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
11029         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
11030         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
11031         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
11032         static_cast<T>(v12_), static_cast<T>(v13_)};
11033     return ValuesIn(array);
11034   }
11035 
11036  private:
11037   // No implementation - assignment is unsupported.
11038   void operator=(const ValueArray13& other);
11039 
11040   const T1 v1_;
11041   const T2 v2_;
11042   const T3 v3_;
11043   const T4 v4_;
11044   const T5 v5_;
11045   const T6 v6_;
11046   const T7 v7_;
11047   const T8 v8_;
11048   const T9 v9_;
11049   const T10 v10_;
11050   const T11 v11_;
11051   const T12 v12_;
11052   const T13 v13_;
11053 };
11054 
11055 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11056     typename T6, typename T7, typename T8, typename T9, typename T10,
11057     typename T11, typename T12, typename T13, typename T14>
11058 class ValueArray14 {
11059  public:
11060   ValueArray14(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
11061       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) : v1_(v1), v2_(v2), v3_(v3),
11062       v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
11063       v11_(v11), v12_(v12), v13_(v13), v14_(v14) {}
11064 
11065   template <typename T>
11066   operator ParamGenerator<T>() const {
11067     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
11068         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
11069         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
11070         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
11071         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_)};
11072     return ValuesIn(array);
11073   }
11074 
11075  private:
11076   // No implementation - assignment is unsupported.
11077   void operator=(const ValueArray14& other);
11078 
11079   const T1 v1_;
11080   const T2 v2_;
11081   const T3 v3_;
11082   const T4 v4_;
11083   const T5 v5_;
11084   const T6 v6_;
11085   const T7 v7_;
11086   const T8 v8_;
11087   const T9 v9_;
11088   const T10 v10_;
11089   const T11 v11_;
11090   const T12 v12_;
11091   const T13 v13_;
11092   const T14 v14_;
11093 };
11094 
11095 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11096     typename T6, typename T7, typename T8, typename T9, typename T10,
11097     typename T11, typename T12, typename T13, typename T14, typename T15>
11098 class ValueArray15 {
11099  public:
11100   ValueArray15(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
11101       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) : v1_(v1), v2_(v2),
11102       v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
11103       v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15) {}
11104 
11105   template <typename T>
11106   operator ParamGenerator<T>() const {
11107     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
11108         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
11109         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
11110         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
11111         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
11112         static_cast<T>(v15_)};
11113     return ValuesIn(array);
11114   }
11115 
11116  private:
11117   // No implementation - assignment is unsupported.
11118   void operator=(const ValueArray15& other);
11119 
11120   const T1 v1_;
11121   const T2 v2_;
11122   const T3 v3_;
11123   const T4 v4_;
11124   const T5 v5_;
11125   const T6 v6_;
11126   const T7 v7_;
11127   const T8 v8_;
11128   const T9 v9_;
11129   const T10 v10_;
11130   const T11 v11_;
11131   const T12 v12_;
11132   const T13 v13_;
11133   const T14 v14_;
11134   const T15 v15_;
11135 };
11136 
11137 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11138     typename T6, typename T7, typename T8, typename T9, typename T10,
11139     typename T11, typename T12, typename T13, typename T14, typename T15,
11140     typename T16>
11141 class ValueArray16 {
11142  public:
11143   ValueArray16(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
11144       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16) : v1_(v1),
11145       v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
11146       v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
11147       v16_(v16) {}
11148 
11149   template <typename T>
11150   operator ParamGenerator<T>() const {
11151     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
11152         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
11153         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
11154         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
11155         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
11156         static_cast<T>(v15_), static_cast<T>(v16_)};
11157     return ValuesIn(array);
11158   }
11159 
11160  private:
11161   // No implementation - assignment is unsupported.
11162   void operator=(const ValueArray16& other);
11163 
11164   const T1 v1_;
11165   const T2 v2_;
11166   const T3 v3_;
11167   const T4 v4_;
11168   const T5 v5_;
11169   const T6 v6_;
11170   const T7 v7_;
11171   const T8 v8_;
11172   const T9 v9_;
11173   const T10 v10_;
11174   const T11 v11_;
11175   const T12 v12_;
11176   const T13 v13_;
11177   const T14 v14_;
11178   const T15 v15_;
11179   const T16 v16_;
11180 };
11181 
11182 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11183     typename T6, typename T7, typename T8, typename T9, typename T10,
11184     typename T11, typename T12, typename T13, typename T14, typename T15,
11185     typename T16, typename T17>
11186 class ValueArray17 {
11187  public:
11188   ValueArray17(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
11189       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
11190       T17 v17) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
11191       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
11192       v15_(v15), v16_(v16), v17_(v17) {}
11193 
11194   template <typename T>
11195   operator ParamGenerator<T>() const {
11196     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
11197         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
11198         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
11199         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
11200         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
11201         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_)};
11202     return ValuesIn(array);
11203   }
11204 
11205  private:
11206   // No implementation - assignment is unsupported.
11207   void operator=(const ValueArray17& other);
11208 
11209   const T1 v1_;
11210   const T2 v2_;
11211   const T3 v3_;
11212   const T4 v4_;
11213   const T5 v5_;
11214   const T6 v6_;
11215   const T7 v7_;
11216   const T8 v8_;
11217   const T9 v9_;
11218   const T10 v10_;
11219   const T11 v11_;
11220   const T12 v12_;
11221   const T13 v13_;
11222   const T14 v14_;
11223   const T15 v15_;
11224   const T16 v16_;
11225   const T17 v17_;
11226 };
11227 
11228 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11229     typename T6, typename T7, typename T8, typename T9, typename T10,
11230     typename T11, typename T12, typename T13, typename T14, typename T15,
11231     typename T16, typename T17, typename T18>
11232 class ValueArray18 {
11233  public:
11234   ValueArray18(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
11235       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
11236       T18 v18) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
11237       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
11238       v15_(v15), v16_(v16), v17_(v17), v18_(v18) {}
11239 
11240   template <typename T>
11241   operator ParamGenerator<T>() const {
11242     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
11243         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
11244         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
11245         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
11246         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
11247         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
11248         static_cast<T>(v18_)};
11249     return ValuesIn(array);
11250   }
11251 
11252  private:
11253   // No implementation - assignment is unsupported.
11254   void operator=(const ValueArray18& other);
11255 
11256   const T1 v1_;
11257   const T2 v2_;
11258   const T3 v3_;
11259   const T4 v4_;
11260   const T5 v5_;
11261   const T6 v6_;
11262   const T7 v7_;
11263   const T8 v8_;
11264   const T9 v9_;
11265   const T10 v10_;
11266   const T11 v11_;
11267   const T12 v12_;
11268   const T13 v13_;
11269   const T14 v14_;
11270   const T15 v15_;
11271   const T16 v16_;
11272   const T17 v17_;
11273   const T18 v18_;
11274 };
11275 
11276 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11277     typename T6, typename T7, typename T8, typename T9, typename T10,
11278     typename T11, typename T12, typename T13, typename T14, typename T15,
11279     typename T16, typename T17, typename T18, typename T19>
11280 class ValueArray19 {
11281  public:
11282   ValueArray19(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
11283       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
11284       T18 v18, T19 v19) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
11285       v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
11286       v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19) {}
11287 
11288   template <typename T>
11289   operator ParamGenerator<T>() const {
11290     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
11291         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
11292         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
11293         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
11294         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
11295         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
11296         static_cast<T>(v18_), static_cast<T>(v19_)};
11297     return ValuesIn(array);
11298   }
11299 
11300  private:
11301   // No implementation - assignment is unsupported.
11302   void operator=(const ValueArray19& other);
11303 
11304   const T1 v1_;
11305   const T2 v2_;
11306   const T3 v3_;
11307   const T4 v4_;
11308   const T5 v5_;
11309   const T6 v6_;
11310   const T7 v7_;
11311   const T8 v8_;
11312   const T9 v9_;
11313   const T10 v10_;
11314   const T11 v11_;
11315   const T12 v12_;
11316   const T13 v13_;
11317   const T14 v14_;
11318   const T15 v15_;
11319   const T16 v16_;
11320   const T17 v17_;
11321   const T18 v18_;
11322   const T19 v19_;
11323 };
11324 
11325 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11326     typename T6, typename T7, typename T8, typename T9, typename T10,
11327     typename T11, typename T12, typename T13, typename T14, typename T15,
11328     typename T16, typename T17, typename T18, typename T19, typename T20>
11329 class ValueArray20 {
11330  public:
11331   ValueArray20(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
11332       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
11333       T18 v18, T19 v19, T20 v20) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
11334       v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
11335       v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
11336       v19_(v19), v20_(v20) {}
11337 
11338   template <typename T>
11339   operator ParamGenerator<T>() const {
11340     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
11341         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
11342         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
11343         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
11344         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
11345         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
11346         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_)};
11347     return ValuesIn(array);
11348   }
11349 
11350  private:
11351   // No implementation - assignment is unsupported.
11352   void operator=(const ValueArray20& other);
11353 
11354   const T1 v1_;
11355   const T2 v2_;
11356   const T3 v3_;
11357   const T4 v4_;
11358   const T5 v5_;
11359   const T6 v6_;
11360   const T7 v7_;
11361   const T8 v8_;
11362   const T9 v9_;
11363   const T10 v10_;
11364   const T11 v11_;
11365   const T12 v12_;
11366   const T13 v13_;
11367   const T14 v14_;
11368   const T15 v15_;
11369   const T16 v16_;
11370   const T17 v17_;
11371   const T18 v18_;
11372   const T19 v19_;
11373   const T20 v20_;
11374 };
11375 
11376 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11377     typename T6, typename T7, typename T8, typename T9, typename T10,
11378     typename T11, typename T12, typename T13, typename T14, typename T15,
11379     typename T16, typename T17, typename T18, typename T19, typename T20,
11380     typename T21>
11381 class ValueArray21 {
11382  public:
11383   ValueArray21(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
11384       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
11385       T18 v18, T19 v19, T20 v20, T21 v21) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
11386       v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
11387       v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
11388       v18_(v18), v19_(v19), v20_(v20), v21_(v21) {}
11389 
11390   template <typename T>
11391   operator ParamGenerator<T>() const {
11392     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
11393         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
11394         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
11395         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
11396         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
11397         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
11398         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
11399         static_cast<T>(v21_)};
11400     return ValuesIn(array);
11401   }
11402 
11403  private:
11404   // No implementation - assignment is unsupported.
11405   void operator=(const ValueArray21& other);
11406 
11407   const T1 v1_;
11408   const T2 v2_;
11409   const T3 v3_;
11410   const T4 v4_;
11411   const T5 v5_;
11412   const T6 v6_;
11413   const T7 v7_;
11414   const T8 v8_;
11415   const T9 v9_;
11416   const T10 v10_;
11417   const T11 v11_;
11418   const T12 v12_;
11419   const T13 v13_;
11420   const T14 v14_;
11421   const T15 v15_;
11422   const T16 v16_;
11423   const T17 v17_;
11424   const T18 v18_;
11425   const T19 v19_;
11426   const T20 v20_;
11427   const T21 v21_;
11428 };
11429 
11430 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11431     typename T6, typename T7, typename T8, typename T9, typename T10,
11432     typename T11, typename T12, typename T13, typename T14, typename T15,
11433     typename T16, typename T17, typename T18, typename T19, typename T20,
11434     typename T21, typename T22>
11435 class ValueArray22 {
11436  public:
11437   ValueArray22(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
11438       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
11439       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22) : v1_(v1), v2_(v2), v3_(v3),
11440       v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
11441       v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
11442       v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22) {}
11443 
11444   template <typename T>
11445   operator ParamGenerator<T>() const {
11446     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
11447         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
11448         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
11449         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
11450         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
11451         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
11452         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
11453         static_cast<T>(v21_), static_cast<T>(v22_)};
11454     return ValuesIn(array);
11455   }
11456 
11457  private:
11458   // No implementation - assignment is unsupported.
11459   void operator=(const ValueArray22& other);
11460 
11461   const T1 v1_;
11462   const T2 v2_;
11463   const T3 v3_;
11464   const T4 v4_;
11465   const T5 v5_;
11466   const T6 v6_;
11467   const T7 v7_;
11468   const T8 v8_;
11469   const T9 v9_;
11470   const T10 v10_;
11471   const T11 v11_;
11472   const T12 v12_;
11473   const T13 v13_;
11474   const T14 v14_;
11475   const T15 v15_;
11476   const T16 v16_;
11477   const T17 v17_;
11478   const T18 v18_;
11479   const T19 v19_;
11480   const T20 v20_;
11481   const T21 v21_;
11482   const T22 v22_;
11483 };
11484 
11485 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11486     typename T6, typename T7, typename T8, typename T9, typename T10,
11487     typename T11, typename T12, typename T13, typename T14, typename T15,
11488     typename T16, typename T17, typename T18, typename T19, typename T20,
11489     typename T21, typename T22, typename T23>
11490 class ValueArray23 {
11491  public:
11492   ValueArray23(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
11493       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
11494       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23) : v1_(v1), v2_(v2),
11495       v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
11496       v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
11497       v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
11498       v23_(v23) {}
11499 
11500   template <typename T>
11501   operator ParamGenerator<T>() const {
11502     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
11503         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
11504         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
11505         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
11506         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
11507         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
11508         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
11509         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_)};
11510     return ValuesIn(array);
11511   }
11512 
11513  private:
11514   // No implementation - assignment is unsupported.
11515   void operator=(const ValueArray23& other);
11516 
11517   const T1 v1_;
11518   const T2 v2_;
11519   const T3 v3_;
11520   const T4 v4_;
11521   const T5 v5_;
11522   const T6 v6_;
11523   const T7 v7_;
11524   const T8 v8_;
11525   const T9 v9_;
11526   const T10 v10_;
11527   const T11 v11_;
11528   const T12 v12_;
11529   const T13 v13_;
11530   const T14 v14_;
11531   const T15 v15_;
11532   const T16 v16_;
11533   const T17 v17_;
11534   const T18 v18_;
11535   const T19 v19_;
11536   const T20 v20_;
11537   const T21 v21_;
11538   const T22 v22_;
11539   const T23 v23_;
11540 };
11541 
11542 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11543     typename T6, typename T7, typename T8, typename T9, typename T10,
11544     typename T11, typename T12, typename T13, typename T14, typename T15,
11545     typename T16, typename T17, typename T18, typename T19, typename T20,
11546     typename T21, typename T22, typename T23, typename T24>
11547 class ValueArray24 {
11548  public:
11549   ValueArray24(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
11550       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
11551       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24) : v1_(v1),
11552       v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
11553       v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
11554       v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
11555       v22_(v22), v23_(v23), v24_(v24) {}
11556 
11557   template <typename T>
11558   operator ParamGenerator<T>() const {
11559     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
11560         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
11561         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
11562         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
11563         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
11564         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
11565         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
11566         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
11567         static_cast<T>(v24_)};
11568     return ValuesIn(array);
11569   }
11570 
11571  private:
11572   // No implementation - assignment is unsupported.
11573   void operator=(const ValueArray24& other);
11574 
11575   const T1 v1_;
11576   const T2 v2_;
11577   const T3 v3_;
11578   const T4 v4_;
11579   const T5 v5_;
11580   const T6 v6_;
11581   const T7 v7_;
11582   const T8 v8_;
11583   const T9 v9_;
11584   const T10 v10_;
11585   const T11 v11_;
11586   const T12 v12_;
11587   const T13 v13_;
11588   const T14 v14_;
11589   const T15 v15_;
11590   const T16 v16_;
11591   const T17 v17_;
11592   const T18 v18_;
11593   const T19 v19_;
11594   const T20 v20_;
11595   const T21 v21_;
11596   const T22 v22_;
11597   const T23 v23_;
11598   const T24 v24_;
11599 };
11600 
11601 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11602     typename T6, typename T7, typename T8, typename T9, typename T10,
11603     typename T11, typename T12, typename T13, typename T14, typename T15,
11604     typename T16, typename T17, typename T18, typename T19, typename T20,
11605     typename T21, typename T22, typename T23, typename T24, typename T25>
11606 class ValueArray25 {
11607  public:
11608   ValueArray25(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
11609       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
11610       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
11611       T25 v25) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
11612       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
11613       v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
11614       v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25) {}
11615 
11616   template <typename T>
11617   operator ParamGenerator<T>() const {
11618     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
11619         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
11620         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
11621         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
11622         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
11623         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
11624         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
11625         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
11626         static_cast<T>(v24_), static_cast<T>(v25_)};
11627     return ValuesIn(array);
11628   }
11629 
11630  private:
11631   // No implementation - assignment is unsupported.
11632   void operator=(const ValueArray25& other);
11633 
11634   const T1 v1_;
11635   const T2 v2_;
11636   const T3 v3_;
11637   const T4 v4_;
11638   const T5 v5_;
11639   const T6 v6_;
11640   const T7 v7_;
11641   const T8 v8_;
11642   const T9 v9_;
11643   const T10 v10_;
11644   const T11 v11_;
11645   const T12 v12_;
11646   const T13 v13_;
11647   const T14 v14_;
11648   const T15 v15_;
11649   const T16 v16_;
11650   const T17 v17_;
11651   const T18 v18_;
11652   const T19 v19_;
11653   const T20 v20_;
11654   const T21 v21_;
11655   const T22 v22_;
11656   const T23 v23_;
11657   const T24 v24_;
11658   const T25 v25_;
11659 };
11660 
11661 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11662     typename T6, typename T7, typename T8, typename T9, typename T10,
11663     typename T11, typename T12, typename T13, typename T14, typename T15,
11664     typename T16, typename T17, typename T18, typename T19, typename T20,
11665     typename T21, typename T22, typename T23, typename T24, typename T25,
11666     typename T26>
11667 class ValueArray26 {
11668  public:
11669   ValueArray26(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
11670       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
11671       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
11672       T26 v26) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
11673       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
11674       v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
11675       v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26) {}
11676 
11677   template <typename T>
11678   operator ParamGenerator<T>() const {
11679     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
11680         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
11681         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
11682         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
11683         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
11684         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
11685         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
11686         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
11687         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_)};
11688     return ValuesIn(array);
11689   }
11690 
11691  private:
11692   // No implementation - assignment is unsupported.
11693   void operator=(const ValueArray26& other);
11694 
11695   const T1 v1_;
11696   const T2 v2_;
11697   const T3 v3_;
11698   const T4 v4_;
11699   const T5 v5_;
11700   const T6 v6_;
11701   const T7 v7_;
11702   const T8 v8_;
11703   const T9 v9_;
11704   const T10 v10_;
11705   const T11 v11_;
11706   const T12 v12_;
11707   const T13 v13_;
11708   const T14 v14_;
11709   const T15 v15_;
11710   const T16 v16_;
11711   const T17 v17_;
11712   const T18 v18_;
11713   const T19 v19_;
11714   const T20 v20_;
11715   const T21 v21_;
11716   const T22 v22_;
11717   const T23 v23_;
11718   const T24 v24_;
11719   const T25 v25_;
11720   const T26 v26_;
11721 };
11722 
11723 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11724     typename T6, typename T7, typename T8, typename T9, typename T10,
11725     typename T11, typename T12, typename T13, typename T14, typename T15,
11726     typename T16, typename T17, typename T18, typename T19, typename T20,
11727     typename T21, typename T22, typename T23, typename T24, typename T25,
11728     typename T26, typename T27>
11729 class ValueArray27 {
11730  public:
11731   ValueArray27(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
11732       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
11733       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
11734       T26 v26, T27 v27) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
11735       v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
11736       v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
11737       v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
11738       v26_(v26), v27_(v27) {}
11739 
11740   template <typename T>
11741   operator ParamGenerator<T>() const {
11742     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
11743         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
11744         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
11745         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
11746         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
11747         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
11748         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
11749         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
11750         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
11751         static_cast<T>(v27_)};
11752     return ValuesIn(array);
11753   }
11754 
11755  private:
11756   // No implementation - assignment is unsupported.
11757   void operator=(const ValueArray27& other);
11758 
11759   const T1 v1_;
11760   const T2 v2_;
11761   const T3 v3_;
11762   const T4 v4_;
11763   const T5 v5_;
11764   const T6 v6_;
11765   const T7 v7_;
11766   const T8 v8_;
11767   const T9 v9_;
11768   const T10 v10_;
11769   const T11 v11_;
11770   const T12 v12_;
11771   const T13 v13_;
11772   const T14 v14_;
11773   const T15 v15_;
11774   const T16 v16_;
11775   const T17 v17_;
11776   const T18 v18_;
11777   const T19 v19_;
11778   const T20 v20_;
11779   const T21 v21_;
11780   const T22 v22_;
11781   const T23 v23_;
11782   const T24 v24_;
11783   const T25 v25_;
11784   const T26 v26_;
11785   const T27 v27_;
11786 };
11787 
11788 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11789     typename T6, typename T7, typename T8, typename T9, typename T10,
11790     typename T11, typename T12, typename T13, typename T14, typename T15,
11791     typename T16, typename T17, typename T18, typename T19, typename T20,
11792     typename T21, typename T22, typename T23, typename T24, typename T25,
11793     typename T26, typename T27, typename T28>
11794 class ValueArray28 {
11795  public:
11796   ValueArray28(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
11797       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
11798       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
11799       T26 v26, T27 v27, T28 v28) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
11800       v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
11801       v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
11802       v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
11803       v25_(v25), v26_(v26), v27_(v27), v28_(v28) {}
11804 
11805   template <typename T>
11806   operator ParamGenerator<T>() const {
11807     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
11808         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
11809         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
11810         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
11811         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
11812         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
11813         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
11814         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
11815         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
11816         static_cast<T>(v27_), static_cast<T>(v28_)};
11817     return ValuesIn(array);
11818   }
11819 
11820  private:
11821   // No implementation - assignment is unsupported.
11822   void operator=(const ValueArray28& other);
11823 
11824   const T1 v1_;
11825   const T2 v2_;
11826   const T3 v3_;
11827   const T4 v4_;
11828   const T5 v5_;
11829   const T6 v6_;
11830   const T7 v7_;
11831   const T8 v8_;
11832   const T9 v9_;
11833   const T10 v10_;
11834   const T11 v11_;
11835   const T12 v12_;
11836   const T13 v13_;
11837   const T14 v14_;
11838   const T15 v15_;
11839   const T16 v16_;
11840   const T17 v17_;
11841   const T18 v18_;
11842   const T19 v19_;
11843   const T20 v20_;
11844   const T21 v21_;
11845   const T22 v22_;
11846   const T23 v23_;
11847   const T24 v24_;
11848   const T25 v25_;
11849   const T26 v26_;
11850   const T27 v27_;
11851   const T28 v28_;
11852 };
11853 
11854 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11855     typename T6, typename T7, typename T8, typename T9, typename T10,
11856     typename T11, typename T12, typename T13, typename T14, typename T15,
11857     typename T16, typename T17, typename T18, typename T19, typename T20,
11858     typename T21, typename T22, typename T23, typename T24, typename T25,
11859     typename T26, typename T27, typename T28, typename T29>
11860 class ValueArray29 {
11861  public:
11862   ValueArray29(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
11863       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
11864       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
11865       T26 v26, T27 v27, T28 v28, T29 v29) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
11866       v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
11867       v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
11868       v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
11869       v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29) {}
11870 
11871   template <typename T>
11872   operator ParamGenerator<T>() const {
11873     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
11874         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
11875         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
11876         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
11877         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
11878         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
11879         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
11880         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
11881         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
11882         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_)};
11883     return ValuesIn(array);
11884   }
11885 
11886  private:
11887   // No implementation - assignment is unsupported.
11888   void operator=(const ValueArray29& other);
11889 
11890   const T1 v1_;
11891   const T2 v2_;
11892   const T3 v3_;
11893   const T4 v4_;
11894   const T5 v5_;
11895   const T6 v6_;
11896   const T7 v7_;
11897   const T8 v8_;
11898   const T9 v9_;
11899   const T10 v10_;
11900   const T11 v11_;
11901   const T12 v12_;
11902   const T13 v13_;
11903   const T14 v14_;
11904   const T15 v15_;
11905   const T16 v16_;
11906   const T17 v17_;
11907   const T18 v18_;
11908   const T19 v19_;
11909   const T20 v20_;
11910   const T21 v21_;
11911   const T22 v22_;
11912   const T23 v23_;
11913   const T24 v24_;
11914   const T25 v25_;
11915   const T26 v26_;
11916   const T27 v27_;
11917   const T28 v28_;
11918   const T29 v29_;
11919 };
11920 
11921 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11922     typename T6, typename T7, typename T8, typename T9, typename T10,
11923     typename T11, typename T12, typename T13, typename T14, typename T15,
11924     typename T16, typename T17, typename T18, typename T19, typename T20,
11925     typename T21, typename T22, typename T23, typename T24, typename T25,
11926     typename T26, typename T27, typename T28, typename T29, typename T30>
11927 class ValueArray30 {
11928  public:
11929   ValueArray30(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
11930       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
11931       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
11932       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) : v1_(v1), v2_(v2), v3_(v3),
11933       v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
11934       v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
11935       v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
11936       v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
11937       v29_(v29), v30_(v30) {}
11938 
11939   template <typename T>
11940   operator ParamGenerator<T>() const {
11941     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
11942         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
11943         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
11944         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
11945         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
11946         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
11947         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
11948         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
11949         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
11950         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
11951         static_cast<T>(v30_)};
11952     return ValuesIn(array);
11953   }
11954 
11955  private:
11956   // No implementation - assignment is unsupported.
11957   void operator=(const ValueArray30& other);
11958 
11959   const T1 v1_;
11960   const T2 v2_;
11961   const T3 v3_;
11962   const T4 v4_;
11963   const T5 v5_;
11964   const T6 v6_;
11965   const T7 v7_;
11966   const T8 v8_;
11967   const T9 v9_;
11968   const T10 v10_;
11969   const T11 v11_;
11970   const T12 v12_;
11971   const T13 v13_;
11972   const T14 v14_;
11973   const T15 v15_;
11974   const T16 v16_;
11975   const T17 v17_;
11976   const T18 v18_;
11977   const T19 v19_;
11978   const T20 v20_;
11979   const T21 v21_;
11980   const T22 v22_;
11981   const T23 v23_;
11982   const T24 v24_;
11983   const T25 v25_;
11984   const T26 v26_;
11985   const T27 v27_;
11986   const T28 v28_;
11987   const T29 v29_;
11988   const T30 v30_;
11989 };
11990 
11991 template <typename T1, typename T2, typename T3, typename T4, typename T5,
11992     typename T6, typename T7, typename T8, typename T9, typename T10,
11993     typename T11, typename T12, typename T13, typename T14, typename T15,
11994     typename T16, typename T17, typename T18, typename T19, typename T20,
11995     typename T21, typename T22, typename T23, typename T24, typename T25,
11996     typename T26, typename T27, typename T28, typename T29, typename T30,
11997     typename T31>
11998 class ValueArray31 {
11999  public:
12000   ValueArray31(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
12001       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
12002       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
12003       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) : v1_(v1), v2_(v2),
12004       v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
12005       v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
12006       v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
12007       v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
12008       v29_(v29), v30_(v30), v31_(v31) {}
12009 
12010   template <typename T>
12011   operator ParamGenerator<T>() const {
12012     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
12013         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
12014         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
12015         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
12016         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
12017         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
12018         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
12019         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
12020         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
12021         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
12022         static_cast<T>(v30_), static_cast<T>(v31_)};
12023     return ValuesIn(array);
12024   }
12025 
12026  private:
12027   // No implementation - assignment is unsupported.
12028   void operator=(const ValueArray31& other);
12029 
12030   const T1 v1_;
12031   const T2 v2_;
12032   const T3 v3_;
12033   const T4 v4_;
12034   const T5 v5_;
12035   const T6 v6_;
12036   const T7 v7_;
12037   const T8 v8_;
12038   const T9 v9_;
12039   const T10 v10_;
12040   const T11 v11_;
12041   const T12 v12_;
12042   const T13 v13_;
12043   const T14 v14_;
12044   const T15 v15_;
12045   const T16 v16_;
12046   const T17 v17_;
12047   const T18 v18_;
12048   const T19 v19_;
12049   const T20 v20_;
12050   const T21 v21_;
12051   const T22 v22_;
12052   const T23 v23_;
12053   const T24 v24_;
12054   const T25 v25_;
12055   const T26 v26_;
12056   const T27 v27_;
12057   const T28 v28_;
12058   const T29 v29_;
12059   const T30 v30_;
12060   const T31 v31_;
12061 };
12062 
12063 template <typename T1, typename T2, typename T3, typename T4, typename T5,
12064     typename T6, typename T7, typename T8, typename T9, typename T10,
12065     typename T11, typename T12, typename T13, typename T14, typename T15,
12066     typename T16, typename T17, typename T18, typename T19, typename T20,
12067     typename T21, typename T22, typename T23, typename T24, typename T25,
12068     typename T26, typename T27, typename T28, typename T29, typename T30,
12069     typename T31, typename T32>
12070 class ValueArray32 {
12071  public:
12072   ValueArray32(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
12073       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
12074       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
12075       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32) : v1_(v1),
12076       v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
12077       v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
12078       v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
12079       v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
12080       v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32) {}
12081 
12082   template <typename T>
12083   operator ParamGenerator<T>() const {
12084     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
12085         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
12086         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
12087         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
12088         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
12089         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
12090         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
12091         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
12092         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
12093         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
12094         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_)};
12095     return ValuesIn(array);
12096   }
12097 
12098  private:
12099   // No implementation - assignment is unsupported.
12100   void operator=(const ValueArray32& other);
12101 
12102   const T1 v1_;
12103   const T2 v2_;
12104   const T3 v3_;
12105   const T4 v4_;
12106   const T5 v5_;
12107   const T6 v6_;
12108   const T7 v7_;
12109   const T8 v8_;
12110   const T9 v9_;
12111   const T10 v10_;
12112   const T11 v11_;
12113   const T12 v12_;
12114   const T13 v13_;
12115   const T14 v14_;
12116   const T15 v15_;
12117   const T16 v16_;
12118   const T17 v17_;
12119   const T18 v18_;
12120   const T19 v19_;
12121   const T20 v20_;
12122   const T21 v21_;
12123   const T22 v22_;
12124   const T23 v23_;
12125   const T24 v24_;
12126   const T25 v25_;
12127   const T26 v26_;
12128   const T27 v27_;
12129   const T28 v28_;
12130   const T29 v29_;
12131   const T30 v30_;
12132   const T31 v31_;
12133   const T32 v32_;
12134 };
12135 
12136 template <typename T1, typename T2, typename T3, typename T4, typename T5,
12137     typename T6, typename T7, typename T8, typename T9, typename T10,
12138     typename T11, typename T12, typename T13, typename T14, typename T15,
12139     typename T16, typename T17, typename T18, typename T19, typename T20,
12140     typename T21, typename T22, typename T23, typename T24, typename T25,
12141     typename T26, typename T27, typename T28, typename T29, typename T30,
12142     typename T31, typename T32, typename T33>
12143 class ValueArray33 {
12144  public:
12145   ValueArray33(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
12146       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
12147       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
12148       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32,
12149       T33 v33) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
12150       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
12151       v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
12152       v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
12153       v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
12154       v33_(v33) {}
12155 
12156   template <typename T>
12157   operator ParamGenerator<T>() const {
12158     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
12159         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
12160         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
12161         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
12162         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
12163         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
12164         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
12165         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
12166         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
12167         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
12168         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
12169         static_cast<T>(v33_)};
12170     return ValuesIn(array);
12171   }
12172 
12173  private:
12174   // No implementation - assignment is unsupported.
12175   void operator=(const ValueArray33& other);
12176 
12177   const T1 v1_;
12178   const T2 v2_;
12179   const T3 v3_;
12180   const T4 v4_;
12181   const T5 v5_;
12182   const T6 v6_;
12183   const T7 v7_;
12184   const T8 v8_;
12185   const T9 v9_;
12186   const T10 v10_;
12187   const T11 v11_;
12188   const T12 v12_;
12189   const T13 v13_;
12190   const T14 v14_;
12191   const T15 v15_;
12192   const T16 v16_;
12193   const T17 v17_;
12194   const T18 v18_;
12195   const T19 v19_;
12196   const T20 v20_;
12197   const T21 v21_;
12198   const T22 v22_;
12199   const T23 v23_;
12200   const T24 v24_;
12201   const T25 v25_;
12202   const T26 v26_;
12203   const T27 v27_;
12204   const T28 v28_;
12205   const T29 v29_;
12206   const T30 v30_;
12207   const T31 v31_;
12208   const T32 v32_;
12209   const T33 v33_;
12210 };
12211 
12212 template <typename T1, typename T2, typename T3, typename T4, typename T5,
12213     typename T6, typename T7, typename T8, typename T9, typename T10,
12214     typename T11, typename T12, typename T13, typename T14, typename T15,
12215     typename T16, typename T17, typename T18, typename T19, typename T20,
12216     typename T21, typename T22, typename T23, typename T24, typename T25,
12217     typename T26, typename T27, typename T28, typename T29, typename T30,
12218     typename T31, typename T32, typename T33, typename T34>
12219 class ValueArray34 {
12220  public:
12221   ValueArray34(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
12222       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
12223       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
12224       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
12225       T34 v34) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
12226       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
12227       v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
12228       v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
12229       v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
12230       v33_(v33), v34_(v34) {}
12231 
12232   template <typename T>
12233   operator ParamGenerator<T>() const {
12234     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
12235         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
12236         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
12237         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
12238         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
12239         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
12240         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
12241         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
12242         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
12243         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
12244         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
12245         static_cast<T>(v33_), static_cast<T>(v34_)};
12246     return ValuesIn(array);
12247   }
12248 
12249  private:
12250   // No implementation - assignment is unsupported.
12251   void operator=(const ValueArray34& other);
12252 
12253   const T1 v1_;
12254   const T2 v2_;
12255   const T3 v3_;
12256   const T4 v4_;
12257   const T5 v5_;
12258   const T6 v6_;
12259   const T7 v7_;
12260   const T8 v8_;
12261   const T9 v9_;
12262   const T10 v10_;
12263   const T11 v11_;
12264   const T12 v12_;
12265   const T13 v13_;
12266   const T14 v14_;
12267   const T15 v15_;
12268   const T16 v16_;
12269   const T17 v17_;
12270   const T18 v18_;
12271   const T19 v19_;
12272   const T20 v20_;
12273   const T21 v21_;
12274   const T22 v22_;
12275   const T23 v23_;
12276   const T24 v24_;
12277   const T25 v25_;
12278   const T26 v26_;
12279   const T27 v27_;
12280   const T28 v28_;
12281   const T29 v29_;
12282   const T30 v30_;
12283   const T31 v31_;
12284   const T32 v32_;
12285   const T33 v33_;
12286   const T34 v34_;
12287 };
12288 
12289 template <typename T1, typename T2, typename T3, typename T4, typename T5,
12290     typename T6, typename T7, typename T8, typename T9, typename T10,
12291     typename T11, typename T12, typename T13, typename T14, typename T15,
12292     typename T16, typename T17, typename T18, typename T19, typename T20,
12293     typename T21, typename T22, typename T23, typename T24, typename T25,
12294     typename T26, typename T27, typename T28, typename T29, typename T30,
12295     typename T31, typename T32, typename T33, typename T34, typename T35>
12296 class ValueArray35 {
12297  public:
12298   ValueArray35(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
12299       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
12300       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
12301       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
12302       T34 v34, T35 v35) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
12303       v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
12304       v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
12305       v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
12306       v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31),
12307       v32_(v32), v33_(v33), v34_(v34), v35_(v35) {}
12308 
12309   template <typename T>
12310   operator ParamGenerator<T>() const {
12311     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
12312         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
12313         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
12314         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
12315         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
12316         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
12317         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
12318         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
12319         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
12320         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
12321         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
12322         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_)};
12323     return ValuesIn(array);
12324   }
12325 
12326  private:
12327   // No implementation - assignment is unsupported.
12328   void operator=(const ValueArray35& other);
12329 
12330   const T1 v1_;
12331   const T2 v2_;
12332   const T3 v3_;
12333   const T4 v4_;
12334   const T5 v5_;
12335   const T6 v6_;
12336   const T7 v7_;
12337   const T8 v8_;
12338   const T9 v9_;
12339   const T10 v10_;
12340   const T11 v11_;
12341   const T12 v12_;
12342   const T13 v13_;
12343   const T14 v14_;
12344   const T15 v15_;
12345   const T16 v16_;
12346   const T17 v17_;
12347   const T18 v18_;
12348   const T19 v19_;
12349   const T20 v20_;
12350   const T21 v21_;
12351   const T22 v22_;
12352   const T23 v23_;
12353   const T24 v24_;
12354   const T25 v25_;
12355   const T26 v26_;
12356   const T27 v27_;
12357   const T28 v28_;
12358   const T29 v29_;
12359   const T30 v30_;
12360   const T31 v31_;
12361   const T32 v32_;
12362   const T33 v33_;
12363   const T34 v34_;
12364   const T35 v35_;
12365 };
12366 
12367 template <typename T1, typename T2, typename T3, typename T4, typename T5,
12368     typename T6, typename T7, typename T8, typename T9, typename T10,
12369     typename T11, typename T12, typename T13, typename T14, typename T15,
12370     typename T16, typename T17, typename T18, typename T19, typename T20,
12371     typename T21, typename T22, typename T23, typename T24, typename T25,
12372     typename T26, typename T27, typename T28, typename T29, typename T30,
12373     typename T31, typename T32, typename T33, typename T34, typename T35,
12374     typename T36>
12375 class ValueArray36 {
12376  public:
12377   ValueArray36(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
12378       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
12379       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
12380       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
12381       T34 v34, T35 v35, T36 v36) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
12382       v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
12383       v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
12384       v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
12385       v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30),
12386       v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36) {}
12387 
12388   template <typename T>
12389   operator ParamGenerator<T>() const {
12390     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
12391         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
12392         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
12393         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
12394         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
12395         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
12396         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
12397         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
12398         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
12399         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
12400         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
12401         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
12402         static_cast<T>(v36_)};
12403     return ValuesIn(array);
12404   }
12405 
12406  private:
12407   // No implementation - assignment is unsupported.
12408   void operator=(const ValueArray36& other);
12409 
12410   const T1 v1_;
12411   const T2 v2_;
12412   const T3 v3_;
12413   const T4 v4_;
12414   const T5 v5_;
12415   const T6 v6_;
12416   const T7 v7_;
12417   const T8 v8_;
12418   const T9 v9_;
12419   const T10 v10_;
12420   const T11 v11_;
12421   const T12 v12_;
12422   const T13 v13_;
12423   const T14 v14_;
12424   const T15 v15_;
12425   const T16 v16_;
12426   const T17 v17_;
12427   const T18 v18_;
12428   const T19 v19_;
12429   const T20 v20_;
12430   const T21 v21_;
12431   const T22 v22_;
12432   const T23 v23_;
12433   const T24 v24_;
12434   const T25 v25_;
12435   const T26 v26_;
12436   const T27 v27_;
12437   const T28 v28_;
12438   const T29 v29_;
12439   const T30 v30_;
12440   const T31 v31_;
12441   const T32 v32_;
12442   const T33 v33_;
12443   const T34 v34_;
12444   const T35 v35_;
12445   const T36 v36_;
12446 };
12447 
12448 template <typename T1, typename T2, typename T3, typename T4, typename T5,
12449     typename T6, typename T7, typename T8, typename T9, typename T10,
12450     typename T11, typename T12, typename T13, typename T14, typename T15,
12451     typename T16, typename T17, typename T18, typename T19, typename T20,
12452     typename T21, typename T22, typename T23, typename T24, typename T25,
12453     typename T26, typename T27, typename T28, typename T29, typename T30,
12454     typename T31, typename T32, typename T33, typename T34, typename T35,
12455     typename T36, typename T37>
12456 class ValueArray37 {
12457  public:
12458   ValueArray37(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
12459       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
12460       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
12461       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
12462       T34 v34, T35 v35, T36 v36, T37 v37) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
12463       v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
12464       v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
12465       v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
12466       v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29),
12467       v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35),
12468       v36_(v36), v37_(v37) {}
12469 
12470   template <typename T>
12471   operator ParamGenerator<T>() const {
12472     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
12473         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
12474         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
12475         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
12476         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
12477         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
12478         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
12479         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
12480         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
12481         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
12482         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
12483         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
12484         static_cast<T>(v36_), static_cast<T>(v37_)};
12485     return ValuesIn(array);
12486   }
12487 
12488  private:
12489   // No implementation - assignment is unsupported.
12490   void operator=(const ValueArray37& other);
12491 
12492   const T1 v1_;
12493   const T2 v2_;
12494   const T3 v3_;
12495   const T4 v4_;
12496   const T5 v5_;
12497   const T6 v6_;
12498   const T7 v7_;
12499   const T8 v8_;
12500   const T9 v9_;
12501   const T10 v10_;
12502   const T11 v11_;
12503   const T12 v12_;
12504   const T13 v13_;
12505   const T14 v14_;
12506   const T15 v15_;
12507   const T16 v16_;
12508   const T17 v17_;
12509   const T18 v18_;
12510   const T19 v19_;
12511   const T20 v20_;
12512   const T21 v21_;
12513   const T22 v22_;
12514   const T23 v23_;
12515   const T24 v24_;
12516   const T25 v25_;
12517   const T26 v26_;
12518   const T27 v27_;
12519   const T28 v28_;
12520   const T29 v29_;
12521   const T30 v30_;
12522   const T31 v31_;
12523   const T32 v32_;
12524   const T33 v33_;
12525   const T34 v34_;
12526   const T35 v35_;
12527   const T36 v36_;
12528   const T37 v37_;
12529 };
12530 
12531 template <typename T1, typename T2, typename T3, typename T4, typename T5,
12532     typename T6, typename T7, typename T8, typename T9, typename T10,
12533     typename T11, typename T12, typename T13, typename T14, typename T15,
12534     typename T16, typename T17, typename T18, typename T19, typename T20,
12535     typename T21, typename T22, typename T23, typename T24, typename T25,
12536     typename T26, typename T27, typename T28, typename T29, typename T30,
12537     typename T31, typename T32, typename T33, typename T34, typename T35,
12538     typename T36, typename T37, typename T38>
12539 class ValueArray38 {
12540  public:
12541   ValueArray38(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
12542       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
12543       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
12544       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
12545       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38) : v1_(v1), v2_(v2), v3_(v3),
12546       v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
12547       v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
12548       v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
12549       v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
12550       v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
12551       v35_(v35), v36_(v36), v37_(v37), v38_(v38) {}
12552 
12553   template <typename T>
12554   operator ParamGenerator<T>() const {
12555     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
12556         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
12557         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
12558         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
12559         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
12560         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
12561         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
12562         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
12563         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
12564         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
12565         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
12566         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
12567         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_)};
12568     return ValuesIn(array);
12569   }
12570 
12571  private:
12572   // No implementation - assignment is unsupported.
12573   void operator=(const ValueArray38& other);
12574 
12575   const T1 v1_;
12576   const T2 v2_;
12577   const T3 v3_;
12578   const T4 v4_;
12579   const T5 v5_;
12580   const T6 v6_;
12581   const T7 v7_;
12582   const T8 v8_;
12583   const T9 v9_;
12584   const T10 v10_;
12585   const T11 v11_;
12586   const T12 v12_;
12587   const T13 v13_;
12588   const T14 v14_;
12589   const T15 v15_;
12590   const T16 v16_;
12591   const T17 v17_;
12592   const T18 v18_;
12593   const T19 v19_;
12594   const T20 v20_;
12595   const T21 v21_;
12596   const T22 v22_;
12597   const T23 v23_;
12598   const T24 v24_;
12599   const T25 v25_;
12600   const T26 v26_;
12601   const T27 v27_;
12602   const T28 v28_;
12603   const T29 v29_;
12604   const T30 v30_;
12605   const T31 v31_;
12606   const T32 v32_;
12607   const T33 v33_;
12608   const T34 v34_;
12609   const T35 v35_;
12610   const T36 v36_;
12611   const T37 v37_;
12612   const T38 v38_;
12613 };
12614 
12615 template <typename T1, typename T2, typename T3, typename T4, typename T5,
12616     typename T6, typename T7, typename T8, typename T9, typename T10,
12617     typename T11, typename T12, typename T13, typename T14, typename T15,
12618     typename T16, typename T17, typename T18, typename T19, typename T20,
12619     typename T21, typename T22, typename T23, typename T24, typename T25,
12620     typename T26, typename T27, typename T28, typename T29, typename T30,
12621     typename T31, typename T32, typename T33, typename T34, typename T35,
12622     typename T36, typename T37, typename T38, typename T39>
12623 class ValueArray39 {
12624  public:
12625   ValueArray39(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
12626       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
12627       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
12628       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
12629       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39) : v1_(v1), v2_(v2),
12630       v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
12631       v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
12632       v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
12633       v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
12634       v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
12635       v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39) {}
12636 
12637   template <typename T>
12638   operator ParamGenerator<T>() const {
12639     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
12640         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
12641         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
12642         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
12643         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
12644         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
12645         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
12646         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
12647         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
12648         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
12649         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
12650         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
12651         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
12652         static_cast<T>(v39_)};
12653     return ValuesIn(array);
12654   }
12655 
12656  private:
12657   // No implementation - assignment is unsupported.
12658   void operator=(const ValueArray39& other);
12659 
12660   const T1 v1_;
12661   const T2 v2_;
12662   const T3 v3_;
12663   const T4 v4_;
12664   const T5 v5_;
12665   const T6 v6_;
12666   const T7 v7_;
12667   const T8 v8_;
12668   const T9 v9_;
12669   const T10 v10_;
12670   const T11 v11_;
12671   const T12 v12_;
12672   const T13 v13_;
12673   const T14 v14_;
12674   const T15 v15_;
12675   const T16 v16_;
12676   const T17 v17_;
12677   const T18 v18_;
12678   const T19 v19_;
12679   const T20 v20_;
12680   const T21 v21_;
12681   const T22 v22_;
12682   const T23 v23_;
12683   const T24 v24_;
12684   const T25 v25_;
12685   const T26 v26_;
12686   const T27 v27_;
12687   const T28 v28_;
12688   const T29 v29_;
12689   const T30 v30_;
12690   const T31 v31_;
12691   const T32 v32_;
12692   const T33 v33_;
12693   const T34 v34_;
12694   const T35 v35_;
12695   const T36 v36_;
12696   const T37 v37_;
12697   const T38 v38_;
12698   const T39 v39_;
12699 };
12700 
12701 template <typename T1, typename T2, typename T3, typename T4, typename T5,
12702     typename T6, typename T7, typename T8, typename T9, typename T10,
12703     typename T11, typename T12, typename T13, typename T14, typename T15,
12704     typename T16, typename T17, typename T18, typename T19, typename T20,
12705     typename T21, typename T22, typename T23, typename T24, typename T25,
12706     typename T26, typename T27, typename T28, typename T29, typename T30,
12707     typename T31, typename T32, typename T33, typename T34, typename T35,
12708     typename T36, typename T37, typename T38, typename T39, typename T40>
12709 class ValueArray40 {
12710  public:
12711   ValueArray40(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
12712       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
12713       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
12714       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
12715       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) : v1_(v1),
12716       v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
12717       v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
12718       v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
12719       v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
12720       v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33),
12721       v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39),
12722       v40_(v40) {}
12723 
12724   template <typename T>
12725   operator ParamGenerator<T>() const {
12726     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
12727         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
12728         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
12729         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
12730         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
12731         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
12732         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
12733         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
12734         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
12735         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
12736         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
12737         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
12738         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
12739         static_cast<T>(v39_), static_cast<T>(v40_)};
12740     return ValuesIn(array);
12741   }
12742 
12743  private:
12744   // No implementation - assignment is unsupported.
12745   void operator=(const ValueArray40& other);
12746 
12747   const T1 v1_;
12748   const T2 v2_;
12749   const T3 v3_;
12750   const T4 v4_;
12751   const T5 v5_;
12752   const T6 v6_;
12753   const T7 v7_;
12754   const T8 v8_;
12755   const T9 v9_;
12756   const T10 v10_;
12757   const T11 v11_;
12758   const T12 v12_;
12759   const T13 v13_;
12760   const T14 v14_;
12761   const T15 v15_;
12762   const T16 v16_;
12763   const T17 v17_;
12764   const T18 v18_;
12765   const T19 v19_;
12766   const T20 v20_;
12767   const T21 v21_;
12768   const T22 v22_;
12769   const T23 v23_;
12770   const T24 v24_;
12771   const T25 v25_;
12772   const T26 v26_;
12773   const T27 v27_;
12774   const T28 v28_;
12775   const T29 v29_;
12776   const T30 v30_;
12777   const T31 v31_;
12778   const T32 v32_;
12779   const T33 v33_;
12780   const T34 v34_;
12781   const T35 v35_;
12782   const T36 v36_;
12783   const T37 v37_;
12784   const T38 v38_;
12785   const T39 v39_;
12786   const T40 v40_;
12787 };
12788 
12789 template <typename T1, typename T2, typename T3, typename T4, typename T5,
12790     typename T6, typename T7, typename T8, typename T9, typename T10,
12791     typename T11, typename T12, typename T13, typename T14, typename T15,
12792     typename T16, typename T17, typename T18, typename T19, typename T20,
12793     typename T21, typename T22, typename T23, typename T24, typename T25,
12794     typename T26, typename T27, typename T28, typename T29, typename T30,
12795     typename T31, typename T32, typename T33, typename T34, typename T35,
12796     typename T36, typename T37, typename T38, typename T39, typename T40,
12797     typename T41>
12798 class ValueArray41 {
12799  public:
12800   ValueArray41(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
12801       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
12802       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
12803       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
12804       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40,
12805       T41 v41) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
12806       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
12807       v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
12808       v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
12809       v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
12810       v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
12811       v39_(v39), v40_(v40), v41_(v41) {}
12812 
12813   template <typename T>
12814   operator ParamGenerator<T>() const {
12815     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
12816         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
12817         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
12818         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
12819         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
12820         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
12821         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
12822         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
12823         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
12824         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
12825         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
12826         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
12827         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
12828         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_)};
12829     return ValuesIn(array);
12830   }
12831 
12832  private:
12833   // No implementation - assignment is unsupported.
12834   void operator=(const ValueArray41& other);
12835 
12836   const T1 v1_;
12837   const T2 v2_;
12838   const T3 v3_;
12839   const T4 v4_;
12840   const T5 v5_;
12841   const T6 v6_;
12842   const T7 v7_;
12843   const T8 v8_;
12844   const T9 v9_;
12845   const T10 v10_;
12846   const T11 v11_;
12847   const T12 v12_;
12848   const T13 v13_;
12849   const T14 v14_;
12850   const T15 v15_;
12851   const T16 v16_;
12852   const T17 v17_;
12853   const T18 v18_;
12854   const T19 v19_;
12855   const T20 v20_;
12856   const T21 v21_;
12857   const T22 v22_;
12858   const T23 v23_;
12859   const T24 v24_;
12860   const T25 v25_;
12861   const T26 v26_;
12862   const T27 v27_;
12863   const T28 v28_;
12864   const T29 v29_;
12865   const T30 v30_;
12866   const T31 v31_;
12867   const T32 v32_;
12868   const T33 v33_;
12869   const T34 v34_;
12870   const T35 v35_;
12871   const T36 v36_;
12872   const T37 v37_;
12873   const T38 v38_;
12874   const T39 v39_;
12875   const T40 v40_;
12876   const T41 v41_;
12877 };
12878 
12879 template <typename T1, typename T2, typename T3, typename T4, typename T5,
12880     typename T6, typename T7, typename T8, typename T9, typename T10,
12881     typename T11, typename T12, typename T13, typename T14, typename T15,
12882     typename T16, typename T17, typename T18, typename T19, typename T20,
12883     typename T21, typename T22, typename T23, typename T24, typename T25,
12884     typename T26, typename T27, typename T28, typename T29, typename T30,
12885     typename T31, typename T32, typename T33, typename T34, typename T35,
12886     typename T36, typename T37, typename T38, typename T39, typename T40,
12887     typename T41, typename T42>
12888 class ValueArray42 {
12889  public:
12890   ValueArray42(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
12891       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
12892       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
12893       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
12894       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
12895       T42 v42) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
12896       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
12897       v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
12898       v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
12899       v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
12900       v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
12901       v39_(v39), v40_(v40), v41_(v41), v42_(v42) {}
12902 
12903   template <typename T>
12904   operator ParamGenerator<T>() const {
12905     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
12906         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
12907         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
12908         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
12909         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
12910         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
12911         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
12912         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
12913         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
12914         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
12915         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
12916         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
12917         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
12918         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
12919         static_cast<T>(v42_)};
12920     return ValuesIn(array);
12921   }
12922 
12923  private:
12924   // No implementation - assignment is unsupported.
12925   void operator=(const ValueArray42& other);
12926 
12927   const T1 v1_;
12928   const T2 v2_;
12929   const T3 v3_;
12930   const T4 v4_;
12931   const T5 v5_;
12932   const T6 v6_;
12933   const T7 v7_;
12934   const T8 v8_;
12935   const T9 v9_;
12936   const T10 v10_;
12937   const T11 v11_;
12938   const T12 v12_;
12939   const T13 v13_;
12940   const T14 v14_;
12941   const T15 v15_;
12942   const T16 v16_;
12943   const T17 v17_;
12944   const T18 v18_;
12945   const T19 v19_;
12946   const T20 v20_;
12947   const T21 v21_;
12948   const T22 v22_;
12949   const T23 v23_;
12950   const T24 v24_;
12951   const T25 v25_;
12952   const T26 v26_;
12953   const T27 v27_;
12954   const T28 v28_;
12955   const T29 v29_;
12956   const T30 v30_;
12957   const T31 v31_;
12958   const T32 v32_;
12959   const T33 v33_;
12960   const T34 v34_;
12961   const T35 v35_;
12962   const T36 v36_;
12963   const T37 v37_;
12964   const T38 v38_;
12965   const T39 v39_;
12966   const T40 v40_;
12967   const T41 v41_;
12968   const T42 v42_;
12969 };
12970 
12971 template <typename T1, typename T2, typename T3, typename T4, typename T5,
12972     typename T6, typename T7, typename T8, typename T9, typename T10,
12973     typename T11, typename T12, typename T13, typename T14, typename T15,
12974     typename T16, typename T17, typename T18, typename T19, typename T20,
12975     typename T21, typename T22, typename T23, typename T24, typename T25,
12976     typename T26, typename T27, typename T28, typename T29, typename T30,
12977     typename T31, typename T32, typename T33, typename T34, typename T35,
12978     typename T36, typename T37, typename T38, typename T39, typename T40,
12979     typename T41, typename T42, typename T43>
12980 class ValueArray43 {
12981  public:
12982   ValueArray43(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
12983       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
12984       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
12985       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
12986       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
12987       T42 v42, T43 v43) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6),
12988       v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13),
12989       v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19),
12990       v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25),
12991       v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31),
12992       v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37),
12993       v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43) {}
12994 
12995   template <typename T>
12996   operator ParamGenerator<T>() const {
12997     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
12998         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
12999         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
13000         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
13001         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
13002         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
13003         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
13004         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
13005         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
13006         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
13007         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
13008         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
13009         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
13010         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
13011         static_cast<T>(v42_), static_cast<T>(v43_)};
13012     return ValuesIn(array);
13013   }
13014 
13015  private:
13016   // No implementation - assignment is unsupported.
13017   void operator=(const ValueArray43& other);
13018 
13019   const T1 v1_;
13020   const T2 v2_;
13021   const T3 v3_;
13022   const T4 v4_;
13023   const T5 v5_;
13024   const T6 v6_;
13025   const T7 v7_;
13026   const T8 v8_;
13027   const T9 v9_;
13028   const T10 v10_;
13029   const T11 v11_;
13030   const T12 v12_;
13031   const T13 v13_;
13032   const T14 v14_;
13033   const T15 v15_;
13034   const T16 v16_;
13035   const T17 v17_;
13036   const T18 v18_;
13037   const T19 v19_;
13038   const T20 v20_;
13039   const T21 v21_;
13040   const T22 v22_;
13041   const T23 v23_;
13042   const T24 v24_;
13043   const T25 v25_;
13044   const T26 v26_;
13045   const T27 v27_;
13046   const T28 v28_;
13047   const T29 v29_;
13048   const T30 v30_;
13049   const T31 v31_;
13050   const T32 v32_;
13051   const T33 v33_;
13052   const T34 v34_;
13053   const T35 v35_;
13054   const T36 v36_;
13055   const T37 v37_;
13056   const T38 v38_;
13057   const T39 v39_;
13058   const T40 v40_;
13059   const T41 v41_;
13060   const T42 v42_;
13061   const T43 v43_;
13062 };
13063 
13064 template <typename T1, typename T2, typename T3, typename T4, typename T5,
13065     typename T6, typename T7, typename T8, typename T9, typename T10,
13066     typename T11, typename T12, typename T13, typename T14, typename T15,
13067     typename T16, typename T17, typename T18, typename T19, typename T20,
13068     typename T21, typename T22, typename T23, typename T24, typename T25,
13069     typename T26, typename T27, typename T28, typename T29, typename T30,
13070     typename T31, typename T32, typename T33, typename T34, typename T35,
13071     typename T36, typename T37, typename T38, typename T39, typename T40,
13072     typename T41, typename T42, typename T43, typename T44>
13073 class ValueArray44 {
13074  public:
13075   ValueArray44(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
13076       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
13077       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
13078       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
13079       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
13080       T42 v42, T43 v43, T44 v44) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5),
13081       v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12),
13082       v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18),
13083       v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24),
13084       v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30),
13085       v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36),
13086       v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42),
13087       v43_(v43), v44_(v44) {}
13088 
13089   template <typename T>
13090   operator ParamGenerator<T>() const {
13091     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
13092         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
13093         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
13094         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
13095         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
13096         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
13097         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
13098         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
13099         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
13100         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
13101         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
13102         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
13103         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
13104         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
13105         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_)};
13106     return ValuesIn(array);
13107   }
13108 
13109  private:
13110   // No implementation - assignment is unsupported.
13111   void operator=(const ValueArray44& other);
13112 
13113   const T1 v1_;
13114   const T2 v2_;
13115   const T3 v3_;
13116   const T4 v4_;
13117   const T5 v5_;
13118   const T6 v6_;
13119   const T7 v7_;
13120   const T8 v8_;
13121   const T9 v9_;
13122   const T10 v10_;
13123   const T11 v11_;
13124   const T12 v12_;
13125   const T13 v13_;
13126   const T14 v14_;
13127   const T15 v15_;
13128   const T16 v16_;
13129   const T17 v17_;
13130   const T18 v18_;
13131   const T19 v19_;
13132   const T20 v20_;
13133   const T21 v21_;
13134   const T22 v22_;
13135   const T23 v23_;
13136   const T24 v24_;
13137   const T25 v25_;
13138   const T26 v26_;
13139   const T27 v27_;
13140   const T28 v28_;
13141   const T29 v29_;
13142   const T30 v30_;
13143   const T31 v31_;
13144   const T32 v32_;
13145   const T33 v33_;
13146   const T34 v34_;
13147   const T35 v35_;
13148   const T36 v36_;
13149   const T37 v37_;
13150   const T38 v38_;
13151   const T39 v39_;
13152   const T40 v40_;
13153   const T41 v41_;
13154   const T42 v42_;
13155   const T43 v43_;
13156   const T44 v44_;
13157 };
13158 
13159 template <typename T1, typename T2, typename T3, typename T4, typename T5,
13160     typename T6, typename T7, typename T8, typename T9, typename T10,
13161     typename T11, typename T12, typename T13, typename T14, typename T15,
13162     typename T16, typename T17, typename T18, typename T19, typename T20,
13163     typename T21, typename T22, typename T23, typename T24, typename T25,
13164     typename T26, typename T27, typename T28, typename T29, typename T30,
13165     typename T31, typename T32, typename T33, typename T34, typename T35,
13166     typename T36, typename T37, typename T38, typename T39, typename T40,
13167     typename T41, typename T42, typename T43, typename T44, typename T45>
13168 class ValueArray45 {
13169  public:
13170   ValueArray45(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
13171       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
13172       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
13173       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
13174       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
13175       T42 v42, T43 v43, T44 v44, T45 v45) : v1_(v1), v2_(v2), v3_(v3), v4_(v4),
13176       v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11),
13177       v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17),
13178       v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23),
13179       v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29),
13180       v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35),
13181       v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41),
13182       v42_(v42), v43_(v43), v44_(v44), v45_(v45) {}
13183 
13184   template <typename T>
13185   operator ParamGenerator<T>() const {
13186     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
13187         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
13188         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
13189         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
13190         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
13191         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
13192         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
13193         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
13194         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
13195         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
13196         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
13197         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
13198         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
13199         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
13200         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
13201         static_cast<T>(v45_)};
13202     return ValuesIn(array);
13203   }
13204 
13205  private:
13206   // No implementation - assignment is unsupported.
13207   void operator=(const ValueArray45& other);
13208 
13209   const T1 v1_;
13210   const T2 v2_;
13211   const T3 v3_;
13212   const T4 v4_;
13213   const T5 v5_;
13214   const T6 v6_;
13215   const T7 v7_;
13216   const T8 v8_;
13217   const T9 v9_;
13218   const T10 v10_;
13219   const T11 v11_;
13220   const T12 v12_;
13221   const T13 v13_;
13222   const T14 v14_;
13223   const T15 v15_;
13224   const T16 v16_;
13225   const T17 v17_;
13226   const T18 v18_;
13227   const T19 v19_;
13228   const T20 v20_;
13229   const T21 v21_;
13230   const T22 v22_;
13231   const T23 v23_;
13232   const T24 v24_;
13233   const T25 v25_;
13234   const T26 v26_;
13235   const T27 v27_;
13236   const T28 v28_;
13237   const T29 v29_;
13238   const T30 v30_;
13239   const T31 v31_;
13240   const T32 v32_;
13241   const T33 v33_;
13242   const T34 v34_;
13243   const T35 v35_;
13244   const T36 v36_;
13245   const T37 v37_;
13246   const T38 v38_;
13247   const T39 v39_;
13248   const T40 v40_;
13249   const T41 v41_;
13250   const T42 v42_;
13251   const T43 v43_;
13252   const T44 v44_;
13253   const T45 v45_;
13254 };
13255 
13256 template <typename T1, typename T2, typename T3, typename T4, typename T5,
13257     typename T6, typename T7, typename T8, typename T9, typename T10,
13258     typename T11, typename T12, typename T13, typename T14, typename T15,
13259     typename T16, typename T17, typename T18, typename T19, typename T20,
13260     typename T21, typename T22, typename T23, typename T24, typename T25,
13261     typename T26, typename T27, typename T28, typename T29, typename T30,
13262     typename T31, typename T32, typename T33, typename T34, typename T35,
13263     typename T36, typename T37, typename T38, typename T39, typename T40,
13264     typename T41, typename T42, typename T43, typename T44, typename T45,
13265     typename T46>
13266 class ValueArray46 {
13267  public:
13268   ValueArray46(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
13269       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
13270       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
13271       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
13272       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
13273       T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) : v1_(v1), v2_(v2), v3_(v3),
13274       v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
13275       v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
13276       v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
13277       v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
13278       v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
13279       v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40),
13280       v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46) {}
13281 
13282   template <typename T>
13283   operator ParamGenerator<T>() const {
13284     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
13285         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
13286         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
13287         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
13288         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
13289         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
13290         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
13291         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
13292         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
13293         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
13294         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
13295         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
13296         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
13297         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
13298         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
13299         static_cast<T>(v45_), static_cast<T>(v46_)};
13300     return ValuesIn(array);
13301   }
13302 
13303  private:
13304   // No implementation - assignment is unsupported.
13305   void operator=(const ValueArray46& other);
13306 
13307   const T1 v1_;
13308   const T2 v2_;
13309   const T3 v3_;
13310   const T4 v4_;
13311   const T5 v5_;
13312   const T6 v6_;
13313   const T7 v7_;
13314   const T8 v8_;
13315   const T9 v9_;
13316   const T10 v10_;
13317   const T11 v11_;
13318   const T12 v12_;
13319   const T13 v13_;
13320   const T14 v14_;
13321   const T15 v15_;
13322   const T16 v16_;
13323   const T17 v17_;
13324   const T18 v18_;
13325   const T19 v19_;
13326   const T20 v20_;
13327   const T21 v21_;
13328   const T22 v22_;
13329   const T23 v23_;
13330   const T24 v24_;
13331   const T25 v25_;
13332   const T26 v26_;
13333   const T27 v27_;
13334   const T28 v28_;
13335   const T29 v29_;
13336   const T30 v30_;
13337   const T31 v31_;
13338   const T32 v32_;
13339   const T33 v33_;
13340   const T34 v34_;
13341   const T35 v35_;
13342   const T36 v36_;
13343   const T37 v37_;
13344   const T38 v38_;
13345   const T39 v39_;
13346   const T40 v40_;
13347   const T41 v41_;
13348   const T42 v42_;
13349   const T43 v43_;
13350   const T44 v44_;
13351   const T45 v45_;
13352   const T46 v46_;
13353 };
13354 
13355 template <typename T1, typename T2, typename T3, typename T4, typename T5,
13356     typename T6, typename T7, typename T8, typename T9, typename T10,
13357     typename T11, typename T12, typename T13, typename T14, typename T15,
13358     typename T16, typename T17, typename T18, typename T19, typename T20,
13359     typename T21, typename T22, typename T23, typename T24, typename T25,
13360     typename T26, typename T27, typename T28, typename T29, typename T30,
13361     typename T31, typename T32, typename T33, typename T34, typename T35,
13362     typename T36, typename T37, typename T38, typename T39, typename T40,
13363     typename T41, typename T42, typename T43, typename T44, typename T45,
13364     typename T46, typename T47>
13365 class ValueArray47 {
13366  public:
13367   ValueArray47(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
13368       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
13369       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
13370       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
13371       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
13372       T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) : v1_(v1), v2_(v2),
13373       v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10),
13374       v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16),
13375       v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22),
13376       v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28),
13377       v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34),
13378       v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40),
13379       v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46),
13380       v47_(v47) {}
13381 
13382   template <typename T>
13383   operator ParamGenerator<T>() const {
13384     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
13385         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
13386         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
13387         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
13388         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
13389         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
13390         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
13391         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
13392         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
13393         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
13394         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
13395         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
13396         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
13397         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
13398         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
13399         static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_)};
13400     return ValuesIn(array);
13401   }
13402 
13403  private:
13404   // No implementation - assignment is unsupported.
13405   void operator=(const ValueArray47& other);
13406 
13407   const T1 v1_;
13408   const T2 v2_;
13409   const T3 v3_;
13410   const T4 v4_;
13411   const T5 v5_;
13412   const T6 v6_;
13413   const T7 v7_;
13414   const T8 v8_;
13415   const T9 v9_;
13416   const T10 v10_;
13417   const T11 v11_;
13418   const T12 v12_;
13419   const T13 v13_;
13420   const T14 v14_;
13421   const T15 v15_;
13422   const T16 v16_;
13423   const T17 v17_;
13424   const T18 v18_;
13425   const T19 v19_;
13426   const T20 v20_;
13427   const T21 v21_;
13428   const T22 v22_;
13429   const T23 v23_;
13430   const T24 v24_;
13431   const T25 v25_;
13432   const T26 v26_;
13433   const T27 v27_;
13434   const T28 v28_;
13435   const T29 v29_;
13436   const T30 v30_;
13437   const T31 v31_;
13438   const T32 v32_;
13439   const T33 v33_;
13440   const T34 v34_;
13441   const T35 v35_;
13442   const T36 v36_;
13443   const T37 v37_;
13444   const T38 v38_;
13445   const T39 v39_;
13446   const T40 v40_;
13447   const T41 v41_;
13448   const T42 v42_;
13449   const T43 v43_;
13450   const T44 v44_;
13451   const T45 v45_;
13452   const T46 v46_;
13453   const T47 v47_;
13454 };
13455 
13456 template <typename T1, typename T2, typename T3, typename T4, typename T5,
13457     typename T6, typename T7, typename T8, typename T9, typename T10,
13458     typename T11, typename T12, typename T13, typename T14, typename T15,
13459     typename T16, typename T17, typename T18, typename T19, typename T20,
13460     typename T21, typename T22, typename T23, typename T24, typename T25,
13461     typename T26, typename T27, typename T28, typename T29, typename T30,
13462     typename T31, typename T32, typename T33, typename T34, typename T35,
13463     typename T36, typename T37, typename T38, typename T39, typename T40,
13464     typename T41, typename T42, typename T43, typename T44, typename T45,
13465     typename T46, typename T47, typename T48>
13466 class ValueArray48 {
13467  public:
13468   ValueArray48(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
13469       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
13470       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
13471       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
13472       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
13473       T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48) : v1_(v1),
13474       v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9),
13475       v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15),
13476       v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21),
13477       v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27),
13478       v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33),
13479       v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39),
13480       v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45),
13481       v46_(v46), v47_(v47), v48_(v48) {}
13482 
13483   template <typename T>
13484   operator ParamGenerator<T>() const {
13485     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
13486         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
13487         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
13488         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
13489         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
13490         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
13491         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
13492         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
13493         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
13494         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
13495         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
13496         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
13497         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
13498         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
13499         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
13500         static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
13501         static_cast<T>(v48_)};
13502     return ValuesIn(array);
13503   }
13504 
13505  private:
13506   // No implementation - assignment is unsupported.
13507   void operator=(const ValueArray48& other);
13508 
13509   const T1 v1_;
13510   const T2 v2_;
13511   const T3 v3_;
13512   const T4 v4_;
13513   const T5 v5_;
13514   const T6 v6_;
13515   const T7 v7_;
13516   const T8 v8_;
13517   const T9 v9_;
13518   const T10 v10_;
13519   const T11 v11_;
13520   const T12 v12_;
13521   const T13 v13_;
13522   const T14 v14_;
13523   const T15 v15_;
13524   const T16 v16_;
13525   const T17 v17_;
13526   const T18 v18_;
13527   const T19 v19_;
13528   const T20 v20_;
13529   const T21 v21_;
13530   const T22 v22_;
13531   const T23 v23_;
13532   const T24 v24_;
13533   const T25 v25_;
13534   const T26 v26_;
13535   const T27 v27_;
13536   const T28 v28_;
13537   const T29 v29_;
13538   const T30 v30_;
13539   const T31 v31_;
13540   const T32 v32_;
13541   const T33 v33_;
13542   const T34 v34_;
13543   const T35 v35_;
13544   const T36 v36_;
13545   const T37 v37_;
13546   const T38 v38_;
13547   const T39 v39_;
13548   const T40 v40_;
13549   const T41 v41_;
13550   const T42 v42_;
13551   const T43 v43_;
13552   const T44 v44_;
13553   const T45 v45_;
13554   const T46 v46_;
13555   const T47 v47_;
13556   const T48 v48_;
13557 };
13558 
13559 template <typename T1, typename T2, typename T3, typename T4, typename T5,
13560     typename T6, typename T7, typename T8, typename T9, typename T10,
13561     typename T11, typename T12, typename T13, typename T14, typename T15,
13562     typename T16, typename T17, typename T18, typename T19, typename T20,
13563     typename T21, typename T22, typename T23, typename T24, typename T25,
13564     typename T26, typename T27, typename T28, typename T29, typename T30,
13565     typename T31, typename T32, typename T33, typename T34, typename T35,
13566     typename T36, typename T37, typename T38, typename T39, typename T40,
13567     typename T41, typename T42, typename T43, typename T44, typename T45,
13568     typename T46, typename T47, typename T48, typename T49>
13569 class ValueArray49 {
13570  public:
13571   ValueArray49(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
13572       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
13573       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
13574       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
13575       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
13576       T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48,
13577       T49 v49) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
13578       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
13579       v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
13580       v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
13581       v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
13582       v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
13583       v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44),
13584       v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49) {}
13585 
13586   template <typename T>
13587   operator ParamGenerator<T>() const {
13588     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
13589         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
13590         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
13591         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
13592         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
13593         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
13594         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
13595         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
13596         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
13597         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
13598         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
13599         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
13600         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
13601         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
13602         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
13603         static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
13604         static_cast<T>(v48_), static_cast<T>(v49_)};
13605     return ValuesIn(array);
13606   }
13607 
13608  private:
13609   // No implementation - assignment is unsupported.
13610   void operator=(const ValueArray49& other);
13611 
13612   const T1 v1_;
13613   const T2 v2_;
13614   const T3 v3_;
13615   const T4 v4_;
13616   const T5 v5_;
13617   const T6 v6_;
13618   const T7 v7_;
13619   const T8 v8_;
13620   const T9 v9_;
13621   const T10 v10_;
13622   const T11 v11_;
13623   const T12 v12_;
13624   const T13 v13_;
13625   const T14 v14_;
13626   const T15 v15_;
13627   const T16 v16_;
13628   const T17 v17_;
13629   const T18 v18_;
13630   const T19 v19_;
13631   const T20 v20_;
13632   const T21 v21_;
13633   const T22 v22_;
13634   const T23 v23_;
13635   const T24 v24_;
13636   const T25 v25_;
13637   const T26 v26_;
13638   const T27 v27_;
13639   const T28 v28_;
13640   const T29 v29_;
13641   const T30 v30_;
13642   const T31 v31_;
13643   const T32 v32_;
13644   const T33 v33_;
13645   const T34 v34_;
13646   const T35 v35_;
13647   const T36 v36_;
13648   const T37 v37_;
13649   const T38 v38_;
13650   const T39 v39_;
13651   const T40 v40_;
13652   const T41 v41_;
13653   const T42 v42_;
13654   const T43 v43_;
13655   const T44 v44_;
13656   const T45 v45_;
13657   const T46 v46_;
13658   const T47 v47_;
13659   const T48 v48_;
13660   const T49 v49_;
13661 };
13662 
13663 template <typename T1, typename T2, typename T3, typename T4, typename T5,
13664     typename T6, typename T7, typename T8, typename T9, typename T10,
13665     typename T11, typename T12, typename T13, typename T14, typename T15,
13666     typename T16, typename T17, typename T18, typename T19, typename T20,
13667     typename T21, typename T22, typename T23, typename T24, typename T25,
13668     typename T26, typename T27, typename T28, typename T29, typename T30,
13669     typename T31, typename T32, typename T33, typename T34, typename T35,
13670     typename T36, typename T37, typename T38, typename T39, typename T40,
13671     typename T41, typename T42, typename T43, typename T44, typename T45,
13672     typename T46, typename T47, typename T48, typename T49, typename T50>
13673 class ValueArray50 {
13674  public:
13675   ValueArray50(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
13676       T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
13677       T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
13678       T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
13679       T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
13680       T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48, T49 v49,
13681       T50 v50) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7),
13682       v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14),
13683       v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20),
13684       v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26),
13685       v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32),
13686       v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38),
13687       v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44),
13688       v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49), v50_(v50) {}
13689 
13690   template <typename T>
13691   operator ParamGenerator<T>() const {
13692     const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
13693         static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
13694         static_cast<T>(v6_), static_cast<T>(v7_), static_cast<T>(v8_),
13695         static_cast<T>(v9_), static_cast<T>(v10_), static_cast<T>(v11_),
13696         static_cast<T>(v12_), static_cast<T>(v13_), static_cast<T>(v14_),
13697         static_cast<T>(v15_), static_cast<T>(v16_), static_cast<T>(v17_),
13698         static_cast<T>(v18_), static_cast<T>(v19_), static_cast<T>(v20_),
13699         static_cast<T>(v21_), static_cast<T>(v22_), static_cast<T>(v23_),
13700         static_cast<T>(v24_), static_cast<T>(v25_), static_cast<T>(v26_),
13701         static_cast<T>(v27_), static_cast<T>(v28_), static_cast<T>(v29_),
13702         static_cast<T>(v30_), static_cast<T>(v31_), static_cast<T>(v32_),
13703         static_cast<T>(v33_), static_cast<T>(v34_), static_cast<T>(v35_),
13704         static_cast<T>(v36_), static_cast<T>(v37_), static_cast<T>(v38_),
13705         static_cast<T>(v39_), static_cast<T>(v40_), static_cast<T>(v41_),
13706         static_cast<T>(v42_), static_cast<T>(v43_), static_cast<T>(v44_),
13707         static_cast<T>(v45_), static_cast<T>(v46_), static_cast<T>(v47_),
13708         static_cast<T>(v48_), static_cast<T>(v49_), static_cast<T>(v50_)};
13709     return ValuesIn(array);
13710   }
13711 
13712  private:
13713   // No implementation - assignment is unsupported.
13714   void operator=(const ValueArray50& other);
13715 
13716   const T1 v1_;
13717   const T2 v2_;
13718   const T3 v3_;
13719   const T4 v4_;
13720   const T5 v5_;
13721   const T6 v6_;
13722   const T7 v7_;
13723   const T8 v8_;
13724   const T9 v9_;
13725   const T10 v10_;
13726   const T11 v11_;
13727   const T12 v12_;
13728   const T13 v13_;
13729   const T14 v14_;
13730   const T15 v15_;
13731   const T16 v16_;
13732   const T17 v17_;
13733   const T18 v18_;
13734   const T19 v19_;
13735   const T20 v20_;
13736   const T21 v21_;
13737   const T22 v22_;
13738   const T23 v23_;
13739   const T24 v24_;
13740   const T25 v25_;
13741   const T26 v26_;
13742   const T27 v27_;
13743   const T28 v28_;
13744   const T29 v29_;
13745   const T30 v30_;
13746   const T31 v31_;
13747   const T32 v32_;
13748   const T33 v33_;
13749   const T34 v34_;
13750   const T35 v35_;
13751   const T36 v36_;
13752   const T37 v37_;
13753   const T38 v38_;
13754   const T39 v39_;
13755   const T40 v40_;
13756   const T41 v41_;
13757   const T42 v42_;
13758   const T43 v43_;
13759   const T44 v44_;
13760   const T45 v45_;
13761   const T46 v46_;
13762   const T47 v47_;
13763   const T48 v48_;
13764   const T49 v49_;
13765   const T50 v50_;
13766 };
13767 
13768 # if GTEST_HAS_COMBINE
13769 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
13770 //
13771 // Generates values from the Cartesian product of values produced
13772 // by the argument generators.
13773 //
13774 template <typename T1, typename T2>
13775 class CartesianProductGenerator2
13776     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2> > {
13777  public:
13778   typedef ::std::tr1::tuple<T1, T2> ParamType;
13779 
13780   CartesianProductGenerator2(const ParamGenerator<T1>& g1,
13781       const ParamGenerator<T2>& g2)
13782       : g1_(g1), g2_(g2) {}
13783   virtual ~CartesianProductGenerator2() {}
13784 
13785   virtual ParamIteratorInterface<ParamType>* Begin() const {
13786     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin());
13787   }
13788   virtual ParamIteratorInterface<ParamType>* End() const {
13789     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end());
13790   }
13791 
13792  private:
13793   class Iterator : public ParamIteratorInterface<ParamType> {
13794    public:
13795     Iterator(const ParamGeneratorInterface<ParamType>* base,
13796       const ParamGenerator<T1>& g1,
13797       const typename ParamGenerator<T1>::iterator& current1,
13798       const ParamGenerator<T2>& g2,
13799       const typename ParamGenerator<T2>::iterator& current2)
13800         : base_(base),
13801           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
13802           begin2_(g2.begin()), end2_(g2.end()), current2_(current2)    {
13803       ComputeCurrentValue();
13804     }
13805     virtual ~Iterator() {}
13806 
13807     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
13808       return base_;
13809     }
13810     // Advance should not be called on beyond-of-range iterators
13811     // so no component iterators must be beyond end of range, either.
13812     virtual void Advance() {
13813       assert(!AtEnd());
13814       ++current2_;
13815       if (current2_ == end2_) {
13816         current2_ = begin2_;
13817         ++current1_;
13818       }
13819       ComputeCurrentValue();
13820     }
13821     virtual ParamIteratorInterface<ParamType>* Clone() const {
13822       return new Iterator(*this);
13823     }
13824     virtual const ParamType* Current() const { return &current_value_; }
13825     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
13826       // Having the same base generator guarantees that the other
13827       // iterator is of the same type and we can downcast.
13828       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
13829           << "The program attempted to compare iterators "
13830           << "from different generators." << std::endl;
13831       const Iterator* typed_other =
13832           CheckedDowncastToActualType<const Iterator>(&other);
13833       // We must report iterators equal if they both point beyond their
13834       // respective ranges. That can happen in a variety of fashions,
13835       // so we have to consult AtEnd().
13836       return (AtEnd() && typed_other->AtEnd()) ||
13837          (
13838           current1_ == typed_other->current1_ &&
13839           current2_ == typed_other->current2_);
13840     }
13841 
13842    private:
13843     Iterator(const Iterator& other)
13844         : base_(other.base_),
13845         begin1_(other.begin1_),
13846         end1_(other.end1_),
13847         current1_(other.current1_),
13848         begin2_(other.begin2_),
13849         end2_(other.end2_),
13850         current2_(other.current2_) {
13851       ComputeCurrentValue();
13852     }
13853 
13854     void ComputeCurrentValue() {
13855       if (!AtEnd())
13856         current_value_ = ParamType(*current1_, *current2_);
13857     }
13858     bool AtEnd() const {
13859       // We must report iterator past the end of the range when either of the
13860       // component iterators has reached the end of its range.
13861       return
13862           current1_ == end1_ ||
13863           current2_ == end2_;
13864     }
13865 
13866     // No implementation - assignment is unsupported.
13867     void operator=(const Iterator& other);
13868 
13869     const ParamGeneratorInterface<ParamType>* const base_;
13870     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
13871     // current[i]_ is the actual traversing iterator.
13872     const typename ParamGenerator<T1>::iterator begin1_;
13873     const typename ParamGenerator<T1>::iterator end1_;
13874     typename ParamGenerator<T1>::iterator current1_;
13875     const typename ParamGenerator<T2>::iterator begin2_;
13876     const typename ParamGenerator<T2>::iterator end2_;
13877     typename ParamGenerator<T2>::iterator current2_;
13878     ParamType current_value_;
13879   };  // class CartesianProductGenerator2::Iterator
13880 
13881   // No implementation - assignment is unsupported.
13882   void operator=(const CartesianProductGenerator2& other);
13883 
13884   const ParamGenerator<T1> g1_;
13885   const ParamGenerator<T2> g2_;
13886 };  // class CartesianProductGenerator2
13887 
13888 
13889 template <typename T1, typename T2, typename T3>
13890 class CartesianProductGenerator3
13891     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3> > {
13892  public:
13893   typedef ::std::tr1::tuple<T1, T2, T3> ParamType;
13894 
13895   CartesianProductGenerator3(const ParamGenerator<T1>& g1,
13896       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3)
13897       : g1_(g1), g2_(g2), g3_(g3) {}
13898   virtual ~CartesianProductGenerator3() {}
13899 
13900   virtual ParamIteratorInterface<ParamType>* Begin() const {
13901     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
13902         g3_.begin());
13903   }
13904   virtual ParamIteratorInterface<ParamType>* End() const {
13905     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end());
13906   }
13907 
13908  private:
13909   class Iterator : public ParamIteratorInterface<ParamType> {
13910    public:
13911     Iterator(const ParamGeneratorInterface<ParamType>* base,
13912       const ParamGenerator<T1>& g1,
13913       const typename ParamGenerator<T1>::iterator& current1,
13914       const ParamGenerator<T2>& g2,
13915       const typename ParamGenerator<T2>::iterator& current2,
13916       const ParamGenerator<T3>& g3,
13917       const typename ParamGenerator<T3>::iterator& current3)
13918         : base_(base),
13919           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
13920           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
13921           begin3_(g3.begin()), end3_(g3.end()), current3_(current3)    {
13922       ComputeCurrentValue();
13923     }
13924     virtual ~Iterator() {}
13925 
13926     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
13927       return base_;
13928     }
13929     // Advance should not be called on beyond-of-range iterators
13930     // so no component iterators must be beyond end of range, either.
13931     virtual void Advance() {
13932       assert(!AtEnd());
13933       ++current3_;
13934       if (current3_ == end3_) {
13935         current3_ = begin3_;
13936         ++current2_;
13937       }
13938       if (current2_ == end2_) {
13939         current2_ = begin2_;
13940         ++current1_;
13941       }
13942       ComputeCurrentValue();
13943     }
13944     virtual ParamIteratorInterface<ParamType>* Clone() const {
13945       return new Iterator(*this);
13946     }
13947     virtual const ParamType* Current() const { return &current_value_; }
13948     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
13949       // Having the same base generator guarantees that the other
13950       // iterator is of the same type and we can downcast.
13951       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
13952           << "The program attempted to compare iterators "
13953           << "from different generators." << std::endl;
13954       const Iterator* typed_other =
13955           CheckedDowncastToActualType<const Iterator>(&other);
13956       // We must report iterators equal if they both point beyond their
13957       // respective ranges. That can happen in a variety of fashions,
13958       // so we have to consult AtEnd().
13959       return (AtEnd() && typed_other->AtEnd()) ||
13960          (
13961           current1_ == typed_other->current1_ &&
13962           current2_ == typed_other->current2_ &&
13963           current3_ == typed_other->current3_);
13964     }
13965 
13966    private:
13967     Iterator(const Iterator& other)
13968         : base_(other.base_),
13969         begin1_(other.begin1_),
13970         end1_(other.end1_),
13971         current1_(other.current1_),
13972         begin2_(other.begin2_),
13973         end2_(other.end2_),
13974         current2_(other.current2_),
13975         begin3_(other.begin3_),
13976         end3_(other.end3_),
13977         current3_(other.current3_) {
13978       ComputeCurrentValue();
13979     }
13980 
13981     void ComputeCurrentValue() {
13982       if (!AtEnd())
13983         current_value_ = ParamType(*current1_, *current2_, *current3_);
13984     }
13985     bool AtEnd() const {
13986       // We must report iterator past the end of the range when either of the
13987       // component iterators has reached the end of its range.
13988       return
13989           current1_ == end1_ ||
13990           current2_ == end2_ ||
13991           current3_ == end3_;
13992     }
13993 
13994     // No implementation - assignment is unsupported.
13995     void operator=(const Iterator& other);
13996 
13997     const ParamGeneratorInterface<ParamType>* const base_;
13998     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
13999     // current[i]_ is the actual traversing iterator.
14000     const typename ParamGenerator<T1>::iterator begin1_;
14001     const typename ParamGenerator<T1>::iterator end1_;
14002     typename ParamGenerator<T1>::iterator current1_;
14003     const typename ParamGenerator<T2>::iterator begin2_;
14004     const typename ParamGenerator<T2>::iterator end2_;
14005     typename ParamGenerator<T2>::iterator current2_;
14006     const typename ParamGenerator<T3>::iterator begin3_;
14007     const typename ParamGenerator<T3>::iterator end3_;
14008     typename ParamGenerator<T3>::iterator current3_;
14009     ParamType current_value_;
14010   };  // class CartesianProductGenerator3::Iterator
14011 
14012   // No implementation - assignment is unsupported.
14013   void operator=(const CartesianProductGenerator3& other);
14014 
14015   const ParamGenerator<T1> g1_;
14016   const ParamGenerator<T2> g2_;
14017   const ParamGenerator<T3> g3_;
14018 };  // class CartesianProductGenerator3
14019 
14020 
14021 template <typename T1, typename T2, typename T3, typename T4>
14022 class CartesianProductGenerator4
14023     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4> > {
14024  public:
14025   typedef ::std::tr1::tuple<T1, T2, T3, T4> ParamType;
14026 
14027   CartesianProductGenerator4(const ParamGenerator<T1>& g1,
14028       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
14029       const ParamGenerator<T4>& g4)
14030       : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {}
14031   virtual ~CartesianProductGenerator4() {}
14032 
14033   virtual ParamIteratorInterface<ParamType>* Begin() const {
14034     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
14035         g3_.begin(), g4_, g4_.begin());
14036   }
14037   virtual ParamIteratorInterface<ParamType>* End() const {
14038     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
14039         g4_, g4_.end());
14040   }
14041 
14042  private:
14043   class Iterator : public ParamIteratorInterface<ParamType> {
14044    public:
14045     Iterator(const ParamGeneratorInterface<ParamType>* base,
14046       const ParamGenerator<T1>& g1,
14047       const typename ParamGenerator<T1>::iterator& current1,
14048       const ParamGenerator<T2>& g2,
14049       const typename ParamGenerator<T2>::iterator& current2,
14050       const ParamGenerator<T3>& g3,
14051       const typename ParamGenerator<T3>::iterator& current3,
14052       const ParamGenerator<T4>& g4,
14053       const typename ParamGenerator<T4>::iterator& current4)
14054         : base_(base),
14055           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
14056           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
14057           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
14058           begin4_(g4.begin()), end4_(g4.end()), current4_(current4)    {
14059       ComputeCurrentValue();
14060     }
14061     virtual ~Iterator() {}
14062 
14063     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
14064       return base_;
14065     }
14066     // Advance should not be called on beyond-of-range iterators
14067     // so no component iterators must be beyond end of range, either.
14068     virtual void Advance() {
14069       assert(!AtEnd());
14070       ++current4_;
14071       if (current4_ == end4_) {
14072         current4_ = begin4_;
14073         ++current3_;
14074       }
14075       if (current3_ == end3_) {
14076         current3_ = begin3_;
14077         ++current2_;
14078       }
14079       if (current2_ == end2_) {
14080         current2_ = begin2_;
14081         ++current1_;
14082       }
14083       ComputeCurrentValue();
14084     }
14085     virtual ParamIteratorInterface<ParamType>* Clone() const {
14086       return new Iterator(*this);
14087     }
14088     virtual const ParamType* Current() const { return &current_value_; }
14089     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
14090       // Having the same base generator guarantees that the other
14091       // iterator is of the same type and we can downcast.
14092       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
14093           << "The program attempted to compare iterators "
14094           << "from different generators." << std::endl;
14095       const Iterator* typed_other =
14096           CheckedDowncastToActualType<const Iterator>(&other);
14097       // We must report iterators equal if they both point beyond their
14098       // respective ranges. That can happen in a variety of fashions,
14099       // so we have to consult AtEnd().
14100       return (AtEnd() && typed_other->AtEnd()) ||
14101          (
14102           current1_ == typed_other->current1_ &&
14103           current2_ == typed_other->current2_ &&
14104           current3_ == typed_other->current3_ &&
14105           current4_ == typed_other->current4_);
14106     }
14107 
14108    private:
14109     Iterator(const Iterator& other)
14110         : base_(other.base_),
14111         begin1_(other.begin1_),
14112         end1_(other.end1_),
14113         current1_(other.current1_),
14114         begin2_(other.begin2_),
14115         end2_(other.end2_),
14116         current2_(other.current2_),
14117         begin3_(other.begin3_),
14118         end3_(other.end3_),
14119         current3_(other.current3_),
14120         begin4_(other.begin4_),
14121         end4_(other.end4_),
14122         current4_(other.current4_) {
14123       ComputeCurrentValue();
14124     }
14125 
14126     void ComputeCurrentValue() {
14127       if (!AtEnd())
14128         current_value_ = ParamType(*current1_, *current2_, *current3_,
14129             *current4_);
14130     }
14131     bool AtEnd() const {
14132       // We must report iterator past the end of the range when either of the
14133       // component iterators has reached the end of its range.
14134       return
14135           current1_ == end1_ ||
14136           current2_ == end2_ ||
14137           current3_ == end3_ ||
14138           current4_ == end4_;
14139     }
14140 
14141     // No implementation - assignment is unsupported.
14142     void operator=(const Iterator& other);
14143 
14144     const ParamGeneratorInterface<ParamType>* const base_;
14145     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
14146     // current[i]_ is the actual traversing iterator.
14147     const typename ParamGenerator<T1>::iterator begin1_;
14148     const typename ParamGenerator<T1>::iterator end1_;
14149     typename ParamGenerator<T1>::iterator current1_;
14150     const typename ParamGenerator<T2>::iterator begin2_;
14151     const typename ParamGenerator<T2>::iterator end2_;
14152     typename ParamGenerator<T2>::iterator current2_;
14153     const typename ParamGenerator<T3>::iterator begin3_;
14154     const typename ParamGenerator<T3>::iterator end3_;
14155     typename ParamGenerator<T3>::iterator current3_;
14156     const typename ParamGenerator<T4>::iterator begin4_;
14157     const typename ParamGenerator<T4>::iterator end4_;
14158     typename ParamGenerator<T4>::iterator current4_;
14159     ParamType current_value_;
14160   };  // class CartesianProductGenerator4::Iterator
14161 
14162   // No implementation - assignment is unsupported.
14163   void operator=(const CartesianProductGenerator4& other);
14164 
14165   const ParamGenerator<T1> g1_;
14166   const ParamGenerator<T2> g2_;
14167   const ParamGenerator<T3> g3_;
14168   const ParamGenerator<T4> g4_;
14169 };  // class CartesianProductGenerator4
14170 
14171 
14172 template <typename T1, typename T2, typename T3, typename T4, typename T5>
14173 class CartesianProductGenerator5
14174     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5> > {
14175  public:
14176   typedef ::std::tr1::tuple<T1, T2, T3, T4, T5> ParamType;
14177 
14178   CartesianProductGenerator5(const ParamGenerator<T1>& g1,
14179       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
14180       const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5)
14181       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {}
14182   virtual ~CartesianProductGenerator5() {}
14183 
14184   virtual ParamIteratorInterface<ParamType>* Begin() const {
14185     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
14186         g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin());
14187   }
14188   virtual ParamIteratorInterface<ParamType>* End() const {
14189     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
14190         g4_, g4_.end(), g5_, g5_.end());
14191   }
14192 
14193  private:
14194   class Iterator : public ParamIteratorInterface<ParamType> {
14195    public:
14196     Iterator(const ParamGeneratorInterface<ParamType>* base,
14197       const ParamGenerator<T1>& g1,
14198       const typename ParamGenerator<T1>::iterator& current1,
14199       const ParamGenerator<T2>& g2,
14200       const typename ParamGenerator<T2>::iterator& current2,
14201       const ParamGenerator<T3>& g3,
14202       const typename ParamGenerator<T3>::iterator& current3,
14203       const ParamGenerator<T4>& g4,
14204       const typename ParamGenerator<T4>::iterator& current4,
14205       const ParamGenerator<T5>& g5,
14206       const typename ParamGenerator<T5>::iterator& current5)
14207         : base_(base),
14208           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
14209           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
14210           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
14211           begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
14212           begin5_(g5.begin()), end5_(g5.end()), current5_(current5)    {
14213       ComputeCurrentValue();
14214     }
14215     virtual ~Iterator() {}
14216 
14217     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
14218       return base_;
14219     }
14220     // Advance should not be called on beyond-of-range iterators
14221     // so no component iterators must be beyond end of range, either.
14222     virtual void Advance() {
14223       assert(!AtEnd());
14224       ++current5_;
14225       if (current5_ == end5_) {
14226         current5_ = begin5_;
14227         ++current4_;
14228       }
14229       if (current4_ == end4_) {
14230         current4_ = begin4_;
14231         ++current3_;
14232       }
14233       if (current3_ == end3_) {
14234         current3_ = begin3_;
14235         ++current2_;
14236       }
14237       if (current2_ == end2_) {
14238         current2_ = begin2_;
14239         ++current1_;
14240       }
14241       ComputeCurrentValue();
14242     }
14243     virtual ParamIteratorInterface<ParamType>* Clone() const {
14244       return new Iterator(*this);
14245     }
14246     virtual const ParamType* Current() const { return &current_value_; }
14247     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
14248       // Having the same base generator guarantees that the other
14249       // iterator is of the same type and we can downcast.
14250       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
14251           << "The program attempted to compare iterators "
14252           << "from different generators." << std::endl;
14253       const Iterator* typed_other =
14254           CheckedDowncastToActualType<const Iterator>(&other);
14255       // We must report iterators equal if they both point beyond their
14256       // respective ranges. That can happen in a variety of fashions,
14257       // so we have to consult AtEnd().
14258       return (AtEnd() && typed_other->AtEnd()) ||
14259          (
14260           current1_ == typed_other->current1_ &&
14261           current2_ == typed_other->current2_ &&
14262           current3_ == typed_other->current3_ &&
14263           current4_ == typed_other->current4_ &&
14264           current5_ == typed_other->current5_);
14265     }
14266 
14267    private:
14268     Iterator(const Iterator& other)
14269         : base_(other.base_),
14270         begin1_(other.begin1_),
14271         end1_(other.end1_),
14272         current1_(other.current1_),
14273         begin2_(other.begin2_),
14274         end2_(other.end2_),
14275         current2_(other.current2_),
14276         begin3_(other.begin3_),
14277         end3_(other.end3_),
14278         current3_(other.current3_),
14279         begin4_(other.begin4_),
14280         end4_(other.end4_),
14281         current4_(other.current4_),
14282         begin5_(other.begin5_),
14283         end5_(other.end5_),
14284         current5_(other.current5_) {
14285       ComputeCurrentValue();
14286     }
14287 
14288     void ComputeCurrentValue() {
14289       if (!AtEnd())
14290         current_value_ = ParamType(*current1_, *current2_, *current3_,
14291             *current4_, *current5_);
14292     }
14293     bool AtEnd() const {
14294       // We must report iterator past the end of the range when either of the
14295       // component iterators has reached the end of its range.
14296       return
14297           current1_ == end1_ ||
14298           current2_ == end2_ ||
14299           current3_ == end3_ ||
14300           current4_ == end4_ ||
14301           current5_ == end5_;
14302     }
14303 
14304     // No implementation - assignment is unsupported.
14305     void operator=(const Iterator& other);
14306 
14307     const ParamGeneratorInterface<ParamType>* const base_;
14308     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
14309     // current[i]_ is the actual traversing iterator.
14310     const typename ParamGenerator<T1>::iterator begin1_;
14311     const typename ParamGenerator<T1>::iterator end1_;
14312     typename ParamGenerator<T1>::iterator current1_;
14313     const typename ParamGenerator<T2>::iterator begin2_;
14314     const typename ParamGenerator<T2>::iterator end2_;
14315     typename ParamGenerator<T2>::iterator current2_;
14316     const typename ParamGenerator<T3>::iterator begin3_;
14317     const typename ParamGenerator<T3>::iterator end3_;
14318     typename ParamGenerator<T3>::iterator current3_;
14319     const typename ParamGenerator<T4>::iterator begin4_;
14320     const typename ParamGenerator<T4>::iterator end4_;
14321     typename ParamGenerator<T4>::iterator current4_;
14322     const typename ParamGenerator<T5>::iterator begin5_;
14323     const typename ParamGenerator<T5>::iterator end5_;
14324     typename ParamGenerator<T5>::iterator current5_;
14325     ParamType current_value_;
14326   };  // class CartesianProductGenerator5::Iterator
14327 
14328   // No implementation - assignment is unsupported.
14329   void operator=(const CartesianProductGenerator5& other);
14330 
14331   const ParamGenerator<T1> g1_;
14332   const ParamGenerator<T2> g2_;
14333   const ParamGenerator<T3> g3_;
14334   const ParamGenerator<T4> g4_;
14335   const ParamGenerator<T5> g5_;
14336 };  // class CartesianProductGenerator5
14337 
14338 
14339 template <typename T1, typename T2, typename T3, typename T4, typename T5,
14340     typename T6>
14341 class CartesianProductGenerator6
14342     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5,
14343         T6> > {
14344  public:
14345   typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6> ParamType;
14346 
14347   CartesianProductGenerator6(const ParamGenerator<T1>& g1,
14348       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
14349       const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
14350       const ParamGenerator<T6>& g6)
14351       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {}
14352   virtual ~CartesianProductGenerator6() {}
14353 
14354   virtual ParamIteratorInterface<ParamType>* Begin() const {
14355     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
14356         g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin());
14357   }
14358   virtual ParamIteratorInterface<ParamType>* End() const {
14359     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
14360         g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end());
14361   }
14362 
14363  private:
14364   class Iterator : public ParamIteratorInterface<ParamType> {
14365    public:
14366     Iterator(const ParamGeneratorInterface<ParamType>* base,
14367       const ParamGenerator<T1>& g1,
14368       const typename ParamGenerator<T1>::iterator& current1,
14369       const ParamGenerator<T2>& g2,
14370       const typename ParamGenerator<T2>::iterator& current2,
14371       const ParamGenerator<T3>& g3,
14372       const typename ParamGenerator<T3>::iterator& current3,
14373       const ParamGenerator<T4>& g4,
14374       const typename ParamGenerator<T4>::iterator& current4,
14375       const ParamGenerator<T5>& g5,
14376       const typename ParamGenerator<T5>::iterator& current5,
14377       const ParamGenerator<T6>& g6,
14378       const typename ParamGenerator<T6>::iterator& current6)
14379         : base_(base),
14380           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
14381           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
14382           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
14383           begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
14384           begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
14385           begin6_(g6.begin()), end6_(g6.end()), current6_(current6)    {
14386       ComputeCurrentValue();
14387     }
14388     virtual ~Iterator() {}
14389 
14390     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
14391       return base_;
14392     }
14393     // Advance should not be called on beyond-of-range iterators
14394     // so no component iterators must be beyond end of range, either.
14395     virtual void Advance() {
14396       assert(!AtEnd());
14397       ++current6_;
14398       if (current6_ == end6_) {
14399         current6_ = begin6_;
14400         ++current5_;
14401       }
14402       if (current5_ == end5_) {
14403         current5_ = begin5_;
14404         ++current4_;
14405       }
14406       if (current4_ == end4_) {
14407         current4_ = begin4_;
14408         ++current3_;
14409       }
14410       if (current3_ == end3_) {
14411         current3_ = begin3_;
14412         ++current2_;
14413       }
14414       if (current2_ == end2_) {
14415         current2_ = begin2_;
14416         ++current1_;
14417       }
14418       ComputeCurrentValue();
14419     }
14420     virtual ParamIteratorInterface<ParamType>* Clone() const {
14421       return new Iterator(*this);
14422     }
14423     virtual const ParamType* Current() const { return &current_value_; }
14424     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
14425       // Having the same base generator guarantees that the other
14426       // iterator is of the same type and we can downcast.
14427       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
14428           << "The program attempted to compare iterators "
14429           << "from different generators." << std::endl;
14430       const Iterator* typed_other =
14431           CheckedDowncastToActualType<const Iterator>(&other);
14432       // We must report iterators equal if they both point beyond their
14433       // respective ranges. That can happen in a variety of fashions,
14434       // so we have to consult AtEnd().
14435       return (AtEnd() && typed_other->AtEnd()) ||
14436          (
14437           current1_ == typed_other->current1_ &&
14438           current2_ == typed_other->current2_ &&
14439           current3_ == typed_other->current3_ &&
14440           current4_ == typed_other->current4_ &&
14441           current5_ == typed_other->current5_ &&
14442           current6_ == typed_other->current6_);
14443     }
14444 
14445    private:
14446     Iterator(const Iterator& other)
14447         : base_(other.base_),
14448         begin1_(other.begin1_),
14449         end1_(other.end1_),
14450         current1_(other.current1_),
14451         begin2_(other.begin2_),
14452         end2_(other.end2_),
14453         current2_(other.current2_),
14454         begin3_(other.begin3_),
14455         end3_(other.end3_),
14456         current3_(other.current3_),
14457         begin4_(other.begin4_),
14458         end4_(other.end4_),
14459         current4_(other.current4_),
14460         begin5_(other.begin5_),
14461         end5_(other.end5_),
14462         current5_(other.current5_),
14463         begin6_(other.begin6_),
14464         end6_(other.end6_),
14465         current6_(other.current6_) {
14466       ComputeCurrentValue();
14467     }
14468 
14469     void ComputeCurrentValue() {
14470       if (!AtEnd())
14471         current_value_ = ParamType(*current1_, *current2_, *current3_,
14472             *current4_, *current5_, *current6_);
14473     }
14474     bool AtEnd() const {
14475       // We must report iterator past the end of the range when either of the
14476       // component iterators has reached the end of its range.
14477       return
14478           current1_ == end1_ ||
14479           current2_ == end2_ ||
14480           current3_ == end3_ ||
14481           current4_ == end4_ ||
14482           current5_ == end5_ ||
14483           current6_ == end6_;
14484     }
14485 
14486     // No implementation - assignment is unsupported.
14487     void operator=(const Iterator& other);
14488 
14489     const ParamGeneratorInterface<ParamType>* const base_;
14490     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
14491     // current[i]_ is the actual traversing iterator.
14492     const typename ParamGenerator<T1>::iterator begin1_;
14493     const typename ParamGenerator<T1>::iterator end1_;
14494     typename ParamGenerator<T1>::iterator current1_;
14495     const typename ParamGenerator<T2>::iterator begin2_;
14496     const typename ParamGenerator<T2>::iterator end2_;
14497     typename ParamGenerator<T2>::iterator current2_;
14498     const typename ParamGenerator<T3>::iterator begin3_;
14499     const typename ParamGenerator<T3>::iterator end3_;
14500     typename ParamGenerator<T3>::iterator current3_;
14501     const typename ParamGenerator<T4>::iterator begin4_;
14502     const typename ParamGenerator<T4>::iterator end4_;
14503     typename ParamGenerator<T4>::iterator current4_;
14504     const typename ParamGenerator<T5>::iterator begin5_;
14505     const typename ParamGenerator<T5>::iterator end5_;
14506     typename ParamGenerator<T5>::iterator current5_;
14507     const typename ParamGenerator<T6>::iterator begin6_;
14508     const typename ParamGenerator<T6>::iterator end6_;
14509     typename ParamGenerator<T6>::iterator current6_;
14510     ParamType current_value_;
14511   };  // class CartesianProductGenerator6::Iterator
14512 
14513   // No implementation - assignment is unsupported.
14514   void operator=(const CartesianProductGenerator6& other);
14515 
14516   const ParamGenerator<T1> g1_;
14517   const ParamGenerator<T2> g2_;
14518   const ParamGenerator<T3> g3_;
14519   const ParamGenerator<T4> g4_;
14520   const ParamGenerator<T5> g5_;
14521   const ParamGenerator<T6> g6_;
14522 };  // class CartesianProductGenerator6
14523 
14524 
14525 template <typename T1, typename T2, typename T3, typename T4, typename T5,
14526     typename T6, typename T7>
14527 class CartesianProductGenerator7
14528     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
14529         T7> > {
14530  public:
14531   typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7> ParamType;
14532 
14533   CartesianProductGenerator7(const ParamGenerator<T1>& g1,
14534       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
14535       const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
14536       const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7)
14537       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {}
14538   virtual ~CartesianProductGenerator7() {}
14539 
14540   virtual ParamIteratorInterface<ParamType>* Begin() const {
14541     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
14542         g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
14543         g7_.begin());
14544   }
14545   virtual ParamIteratorInterface<ParamType>* End() const {
14546     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
14547         g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end());
14548   }
14549 
14550  private:
14551   class Iterator : public ParamIteratorInterface<ParamType> {
14552    public:
14553     Iterator(const ParamGeneratorInterface<ParamType>* base,
14554       const ParamGenerator<T1>& g1,
14555       const typename ParamGenerator<T1>::iterator& current1,
14556       const ParamGenerator<T2>& g2,
14557       const typename ParamGenerator<T2>::iterator& current2,
14558       const ParamGenerator<T3>& g3,
14559       const typename ParamGenerator<T3>::iterator& current3,
14560       const ParamGenerator<T4>& g4,
14561       const typename ParamGenerator<T4>::iterator& current4,
14562       const ParamGenerator<T5>& g5,
14563       const typename ParamGenerator<T5>::iterator& current5,
14564       const ParamGenerator<T6>& g6,
14565       const typename ParamGenerator<T6>::iterator& current6,
14566       const ParamGenerator<T7>& g7,
14567       const typename ParamGenerator<T7>::iterator& current7)
14568         : base_(base),
14569           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
14570           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
14571           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
14572           begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
14573           begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
14574           begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
14575           begin7_(g7.begin()), end7_(g7.end()), current7_(current7)    {
14576       ComputeCurrentValue();
14577     }
14578     virtual ~Iterator() {}
14579 
14580     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
14581       return base_;
14582     }
14583     // Advance should not be called on beyond-of-range iterators
14584     // so no component iterators must be beyond end of range, either.
14585     virtual void Advance() {
14586       assert(!AtEnd());
14587       ++current7_;
14588       if (current7_ == end7_) {
14589         current7_ = begin7_;
14590         ++current6_;
14591       }
14592       if (current6_ == end6_) {
14593         current6_ = begin6_;
14594         ++current5_;
14595       }
14596       if (current5_ == end5_) {
14597         current5_ = begin5_;
14598         ++current4_;
14599       }
14600       if (current4_ == end4_) {
14601         current4_ = begin4_;
14602         ++current3_;
14603       }
14604       if (current3_ == end3_) {
14605         current3_ = begin3_;
14606         ++current2_;
14607       }
14608       if (current2_ == end2_) {
14609         current2_ = begin2_;
14610         ++current1_;
14611       }
14612       ComputeCurrentValue();
14613     }
14614     virtual ParamIteratorInterface<ParamType>* Clone() const {
14615       return new Iterator(*this);
14616     }
14617     virtual const ParamType* Current() const { return &current_value_; }
14618     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
14619       // Having the same base generator guarantees that the other
14620       // iterator is of the same type and we can downcast.
14621       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
14622           << "The program attempted to compare iterators "
14623           << "from different generators." << std::endl;
14624       const Iterator* typed_other =
14625           CheckedDowncastToActualType<const Iterator>(&other);
14626       // We must report iterators equal if they both point beyond their
14627       // respective ranges. That can happen in a variety of fashions,
14628       // so we have to consult AtEnd().
14629       return (AtEnd() && typed_other->AtEnd()) ||
14630          (
14631           current1_ == typed_other->current1_ &&
14632           current2_ == typed_other->current2_ &&
14633           current3_ == typed_other->current3_ &&
14634           current4_ == typed_other->current4_ &&
14635           current5_ == typed_other->current5_ &&
14636           current6_ == typed_other->current6_ &&
14637           current7_ == typed_other->current7_);
14638     }
14639 
14640    private:
14641     Iterator(const Iterator& other)
14642         : base_(other.base_),
14643         begin1_(other.begin1_),
14644         end1_(other.end1_),
14645         current1_(other.current1_),
14646         begin2_(other.begin2_),
14647         end2_(other.end2_),
14648         current2_(other.current2_),
14649         begin3_(other.begin3_),
14650         end3_(other.end3_),
14651         current3_(other.current3_),
14652         begin4_(other.begin4_),
14653         end4_(other.end4_),
14654         current4_(other.current4_),
14655         begin5_(other.begin5_),
14656         end5_(other.end5_),
14657         current5_(other.current5_),
14658         begin6_(other.begin6_),
14659         end6_(other.end6_),
14660         current6_(other.current6_),
14661         begin7_(other.begin7_),
14662         end7_(other.end7_),
14663         current7_(other.current7_) {
14664       ComputeCurrentValue();
14665     }
14666 
14667     void ComputeCurrentValue() {
14668       if (!AtEnd())
14669         current_value_ = ParamType(*current1_, *current2_, *current3_,
14670             *current4_, *current5_, *current6_, *current7_);
14671     }
14672     bool AtEnd() const {
14673       // We must report iterator past the end of the range when either of the
14674       // component iterators has reached the end of its range.
14675       return
14676           current1_ == end1_ ||
14677           current2_ == end2_ ||
14678           current3_ == end3_ ||
14679           current4_ == end4_ ||
14680           current5_ == end5_ ||
14681           current6_ == end6_ ||
14682           current7_ == end7_;
14683     }
14684 
14685     // No implementation - assignment is unsupported.
14686     void operator=(const Iterator& other);
14687 
14688     const ParamGeneratorInterface<ParamType>* const base_;
14689     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
14690     // current[i]_ is the actual traversing iterator.
14691     const typename ParamGenerator<T1>::iterator begin1_;
14692     const typename ParamGenerator<T1>::iterator end1_;
14693     typename ParamGenerator<T1>::iterator current1_;
14694     const typename ParamGenerator<T2>::iterator begin2_;
14695     const typename ParamGenerator<T2>::iterator end2_;
14696     typename ParamGenerator<T2>::iterator current2_;
14697     const typename ParamGenerator<T3>::iterator begin3_;
14698     const typename ParamGenerator<T3>::iterator end3_;
14699     typename ParamGenerator<T3>::iterator current3_;
14700     const typename ParamGenerator<T4>::iterator begin4_;
14701     const typename ParamGenerator<T4>::iterator end4_;
14702     typename ParamGenerator<T4>::iterator current4_;
14703     const typename ParamGenerator<T5>::iterator begin5_;
14704     const typename ParamGenerator<T5>::iterator end5_;
14705     typename ParamGenerator<T5>::iterator current5_;
14706     const typename ParamGenerator<T6>::iterator begin6_;
14707     const typename ParamGenerator<T6>::iterator end6_;
14708     typename ParamGenerator<T6>::iterator current6_;
14709     const typename ParamGenerator<T7>::iterator begin7_;
14710     const typename ParamGenerator<T7>::iterator end7_;
14711     typename ParamGenerator<T7>::iterator current7_;
14712     ParamType current_value_;
14713   };  // class CartesianProductGenerator7::Iterator
14714 
14715   // No implementation - assignment is unsupported.
14716   void operator=(const CartesianProductGenerator7& other);
14717 
14718   const ParamGenerator<T1> g1_;
14719   const ParamGenerator<T2> g2_;
14720   const ParamGenerator<T3> g3_;
14721   const ParamGenerator<T4> g4_;
14722   const ParamGenerator<T5> g5_;
14723   const ParamGenerator<T6> g6_;
14724   const ParamGenerator<T7> g7_;
14725 };  // class CartesianProductGenerator7
14726 
14727 
14728 template <typename T1, typename T2, typename T3, typename T4, typename T5,
14729     typename T6, typename T7, typename T8>
14730 class CartesianProductGenerator8
14731     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
14732         T7, T8> > {
14733  public:
14734   typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8> ParamType;
14735 
14736   CartesianProductGenerator8(const ParamGenerator<T1>& g1,
14737       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
14738       const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
14739       const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
14740       const ParamGenerator<T8>& g8)
14741       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
14742           g8_(g8) {}
14743   virtual ~CartesianProductGenerator8() {}
14744 
14745   virtual ParamIteratorInterface<ParamType>* Begin() const {
14746     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
14747         g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
14748         g7_.begin(), g8_, g8_.begin());
14749   }
14750   virtual ParamIteratorInterface<ParamType>* End() const {
14751     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
14752         g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
14753         g8_.end());
14754   }
14755 
14756  private:
14757   class Iterator : public ParamIteratorInterface<ParamType> {
14758    public:
14759     Iterator(const ParamGeneratorInterface<ParamType>* base,
14760       const ParamGenerator<T1>& g1,
14761       const typename ParamGenerator<T1>::iterator& current1,
14762       const ParamGenerator<T2>& g2,
14763       const typename ParamGenerator<T2>::iterator& current2,
14764       const ParamGenerator<T3>& g3,
14765       const typename ParamGenerator<T3>::iterator& current3,
14766       const ParamGenerator<T4>& g4,
14767       const typename ParamGenerator<T4>::iterator& current4,
14768       const ParamGenerator<T5>& g5,
14769       const typename ParamGenerator<T5>::iterator& current5,
14770       const ParamGenerator<T6>& g6,
14771       const typename ParamGenerator<T6>::iterator& current6,
14772       const ParamGenerator<T7>& g7,
14773       const typename ParamGenerator<T7>::iterator& current7,
14774       const ParamGenerator<T8>& g8,
14775       const typename ParamGenerator<T8>::iterator& current8)
14776         : base_(base),
14777           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
14778           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
14779           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
14780           begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
14781           begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
14782           begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
14783           begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
14784           begin8_(g8.begin()), end8_(g8.end()), current8_(current8)    {
14785       ComputeCurrentValue();
14786     }
14787     virtual ~Iterator() {}
14788 
14789     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
14790       return base_;
14791     }
14792     // Advance should not be called on beyond-of-range iterators
14793     // so no component iterators must be beyond end of range, either.
14794     virtual void Advance() {
14795       assert(!AtEnd());
14796       ++current8_;
14797       if (current8_ == end8_) {
14798         current8_ = begin8_;
14799         ++current7_;
14800       }
14801       if (current7_ == end7_) {
14802         current7_ = begin7_;
14803         ++current6_;
14804       }
14805       if (current6_ == end6_) {
14806         current6_ = begin6_;
14807         ++current5_;
14808       }
14809       if (current5_ == end5_) {
14810         current5_ = begin5_;
14811         ++current4_;
14812       }
14813       if (current4_ == end4_) {
14814         current4_ = begin4_;
14815         ++current3_;
14816       }
14817       if (current3_ == end3_) {
14818         current3_ = begin3_;
14819         ++current2_;
14820       }
14821       if (current2_ == end2_) {
14822         current2_ = begin2_;
14823         ++current1_;
14824       }
14825       ComputeCurrentValue();
14826     }
14827     virtual ParamIteratorInterface<ParamType>* Clone() const {
14828       return new Iterator(*this);
14829     }
14830     virtual const ParamType* Current() const { return &current_value_; }
14831     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
14832       // Having the same base generator guarantees that the other
14833       // iterator is of the same type and we can downcast.
14834       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
14835           << "The program attempted to compare iterators "
14836           << "from different generators." << std::endl;
14837       const Iterator* typed_other =
14838           CheckedDowncastToActualType<const Iterator>(&other);
14839       // We must report iterators equal if they both point beyond their
14840       // respective ranges. That can happen in a variety of fashions,
14841       // so we have to consult AtEnd().
14842       return (AtEnd() && typed_other->AtEnd()) ||
14843          (
14844           current1_ == typed_other->current1_ &&
14845           current2_ == typed_other->current2_ &&
14846           current3_ == typed_other->current3_ &&
14847           current4_ == typed_other->current4_ &&
14848           current5_ == typed_other->current5_ &&
14849           current6_ == typed_other->current6_ &&
14850           current7_ == typed_other->current7_ &&
14851           current8_ == typed_other->current8_);
14852     }
14853 
14854    private:
14855     Iterator(const Iterator& other)
14856         : base_(other.base_),
14857         begin1_(other.begin1_),
14858         end1_(other.end1_),
14859         current1_(other.current1_),
14860         begin2_(other.begin2_),
14861         end2_(other.end2_),
14862         current2_(other.current2_),
14863         begin3_(other.begin3_),
14864         end3_(other.end3_),
14865         current3_(other.current3_),
14866         begin4_(other.begin4_),
14867         end4_(other.end4_),
14868         current4_(other.current4_),
14869         begin5_(other.begin5_),
14870         end5_(other.end5_),
14871         current5_(other.current5_),
14872         begin6_(other.begin6_),
14873         end6_(other.end6_),
14874         current6_(other.current6_),
14875         begin7_(other.begin7_),
14876         end7_(other.end7_),
14877         current7_(other.current7_),
14878         begin8_(other.begin8_),
14879         end8_(other.end8_),
14880         current8_(other.current8_) {
14881       ComputeCurrentValue();
14882     }
14883 
14884     void ComputeCurrentValue() {
14885       if (!AtEnd())
14886         current_value_ = ParamType(*current1_, *current2_, *current3_,
14887             *current4_, *current5_, *current6_, *current7_, *current8_);
14888     }
14889     bool AtEnd() const {
14890       // We must report iterator past the end of the range when either of the
14891       // component iterators has reached the end of its range.
14892       return
14893           current1_ == end1_ ||
14894           current2_ == end2_ ||
14895           current3_ == end3_ ||
14896           current4_ == end4_ ||
14897           current5_ == end5_ ||
14898           current6_ == end6_ ||
14899           current7_ == end7_ ||
14900           current8_ == end8_;
14901     }
14902 
14903     // No implementation - assignment is unsupported.
14904     void operator=(const Iterator& other);
14905 
14906     const ParamGeneratorInterface<ParamType>* const base_;
14907     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
14908     // current[i]_ is the actual traversing iterator.
14909     const typename ParamGenerator<T1>::iterator begin1_;
14910     const typename ParamGenerator<T1>::iterator end1_;
14911     typename ParamGenerator<T1>::iterator current1_;
14912     const typename ParamGenerator<T2>::iterator begin2_;
14913     const typename ParamGenerator<T2>::iterator end2_;
14914     typename ParamGenerator<T2>::iterator current2_;
14915     const typename ParamGenerator<T3>::iterator begin3_;
14916     const typename ParamGenerator<T3>::iterator end3_;
14917     typename ParamGenerator<T3>::iterator current3_;
14918     const typename ParamGenerator<T4>::iterator begin4_;
14919     const typename ParamGenerator<T4>::iterator end4_;
14920     typename ParamGenerator<T4>::iterator current4_;
14921     const typename ParamGenerator<T5>::iterator begin5_;
14922     const typename ParamGenerator<T5>::iterator end5_;
14923     typename ParamGenerator<T5>::iterator current5_;
14924     const typename ParamGenerator<T6>::iterator begin6_;
14925     const typename ParamGenerator<T6>::iterator end6_;
14926     typename ParamGenerator<T6>::iterator current6_;
14927     const typename ParamGenerator<T7>::iterator begin7_;
14928     const typename ParamGenerator<T7>::iterator end7_;
14929     typename ParamGenerator<T7>::iterator current7_;
14930     const typename ParamGenerator<T8>::iterator begin8_;
14931     const typename ParamGenerator<T8>::iterator end8_;
14932     typename ParamGenerator<T8>::iterator current8_;
14933     ParamType current_value_;
14934   };  // class CartesianProductGenerator8::Iterator
14935 
14936   // No implementation - assignment is unsupported.
14937   void operator=(const CartesianProductGenerator8& other);
14938 
14939   const ParamGenerator<T1> g1_;
14940   const ParamGenerator<T2> g2_;
14941   const ParamGenerator<T3> g3_;
14942   const ParamGenerator<T4> g4_;
14943   const ParamGenerator<T5> g5_;
14944   const ParamGenerator<T6> g6_;
14945   const ParamGenerator<T7> g7_;
14946   const ParamGenerator<T8> g8_;
14947 };  // class CartesianProductGenerator8
14948 
14949 
14950 template <typename T1, typename T2, typename T3, typename T4, typename T5,
14951     typename T6, typename T7, typename T8, typename T9>
14952 class CartesianProductGenerator9
14953     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
14954         T7, T8, T9> > {
14955  public:
14956   typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> ParamType;
14957 
14958   CartesianProductGenerator9(const ParamGenerator<T1>& g1,
14959       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
14960       const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
14961       const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
14962       const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9)
14963       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
14964           g9_(g9) {}
14965   virtual ~CartesianProductGenerator9() {}
14966 
14967   virtual ParamIteratorInterface<ParamType>* Begin() const {
14968     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
14969         g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
14970         g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin());
14971   }
14972   virtual ParamIteratorInterface<ParamType>* End() const {
14973     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
14974         g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
14975         g8_.end(), g9_, g9_.end());
14976   }
14977 
14978  private:
14979   class Iterator : public ParamIteratorInterface<ParamType> {
14980    public:
14981     Iterator(const ParamGeneratorInterface<ParamType>* base,
14982       const ParamGenerator<T1>& g1,
14983       const typename ParamGenerator<T1>::iterator& current1,
14984       const ParamGenerator<T2>& g2,
14985       const typename ParamGenerator<T2>::iterator& current2,
14986       const ParamGenerator<T3>& g3,
14987       const typename ParamGenerator<T3>::iterator& current3,
14988       const ParamGenerator<T4>& g4,
14989       const typename ParamGenerator<T4>::iterator& current4,
14990       const ParamGenerator<T5>& g5,
14991       const typename ParamGenerator<T5>::iterator& current5,
14992       const ParamGenerator<T6>& g6,
14993       const typename ParamGenerator<T6>::iterator& current6,
14994       const ParamGenerator<T7>& g7,
14995       const typename ParamGenerator<T7>::iterator& current7,
14996       const ParamGenerator<T8>& g8,
14997       const typename ParamGenerator<T8>::iterator& current8,
14998       const ParamGenerator<T9>& g9,
14999       const typename ParamGenerator<T9>::iterator& current9)
15000         : base_(base),
15001           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
15002           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
15003           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
15004           begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
15005           begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
15006           begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
15007           begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
15008           begin8_(g8.begin()), end8_(g8.end()), current8_(current8),
15009           begin9_(g9.begin()), end9_(g9.end()), current9_(current9)    {
15010       ComputeCurrentValue();
15011     }
15012     virtual ~Iterator() {}
15013 
15014     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
15015       return base_;
15016     }
15017     // Advance should not be called on beyond-of-range iterators
15018     // so no component iterators must be beyond end of range, either.
15019     virtual void Advance() {
15020       assert(!AtEnd());
15021       ++current9_;
15022       if (current9_ == end9_) {
15023         current9_ = begin9_;
15024         ++current8_;
15025       }
15026       if (current8_ == end8_) {
15027         current8_ = begin8_;
15028         ++current7_;
15029       }
15030       if (current7_ == end7_) {
15031         current7_ = begin7_;
15032         ++current6_;
15033       }
15034       if (current6_ == end6_) {
15035         current6_ = begin6_;
15036         ++current5_;
15037       }
15038       if (current5_ == end5_) {
15039         current5_ = begin5_;
15040         ++current4_;
15041       }
15042       if (current4_ == end4_) {
15043         current4_ = begin4_;
15044         ++current3_;
15045       }
15046       if (current3_ == end3_) {
15047         current3_ = begin3_;
15048         ++current2_;
15049       }
15050       if (current2_ == end2_) {
15051         current2_ = begin2_;
15052         ++current1_;
15053       }
15054       ComputeCurrentValue();
15055     }
15056     virtual ParamIteratorInterface<ParamType>* Clone() const {
15057       return new Iterator(*this);
15058     }
15059     virtual const ParamType* Current() const { return &current_value_; }
15060     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
15061       // Having the same base generator guarantees that the other
15062       // iterator is of the same type and we can downcast.
15063       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
15064           << "The program attempted to compare iterators "
15065           << "from different generators." << std::endl;
15066       const Iterator* typed_other =
15067           CheckedDowncastToActualType<const Iterator>(&other);
15068       // We must report iterators equal if they both point beyond their
15069       // respective ranges. That can happen in a variety of fashions,
15070       // so we have to consult AtEnd().
15071       return (AtEnd() && typed_other->AtEnd()) ||
15072          (
15073           current1_ == typed_other->current1_ &&
15074           current2_ == typed_other->current2_ &&
15075           current3_ == typed_other->current3_ &&
15076           current4_ == typed_other->current4_ &&
15077           current5_ == typed_other->current5_ &&
15078           current6_ == typed_other->current6_ &&
15079           current7_ == typed_other->current7_ &&
15080           current8_ == typed_other->current8_ &&
15081           current9_ == typed_other->current9_);
15082     }
15083 
15084    private:
15085     Iterator(const Iterator& other)
15086         : base_(other.base_),
15087         begin1_(other.begin1_),
15088         end1_(other.end1_),
15089         current1_(other.current1_),
15090         begin2_(other.begin2_),
15091         end2_(other.end2_),
15092         current2_(other.current2_),
15093         begin3_(other.begin3_),
15094         end3_(other.end3_),
15095         current3_(other.current3_),
15096         begin4_(other.begin4_),
15097         end4_(other.end4_),
15098         current4_(other.current4_),
15099         begin5_(other.begin5_),
15100         end5_(other.end5_),
15101         current5_(other.current5_),
15102         begin6_(other.begin6_),
15103         end6_(other.end6_),
15104         current6_(other.current6_),
15105         begin7_(other.begin7_),
15106         end7_(other.end7_),
15107         current7_(other.current7_),
15108         begin8_(other.begin8_),
15109         end8_(other.end8_),
15110         current8_(other.current8_),
15111         begin9_(other.begin9_),
15112         end9_(other.end9_),
15113         current9_(other.current9_) {
15114       ComputeCurrentValue();
15115     }
15116 
15117     void ComputeCurrentValue() {
15118       if (!AtEnd())
15119         current_value_ = ParamType(*current1_, *current2_, *current3_,
15120             *current4_, *current5_, *current6_, *current7_, *current8_,
15121             *current9_);
15122     }
15123     bool AtEnd() const {
15124       // We must report iterator past the end of the range when either of the
15125       // component iterators has reached the end of its range.
15126       return
15127           current1_ == end1_ ||
15128           current2_ == end2_ ||
15129           current3_ == end3_ ||
15130           current4_ == end4_ ||
15131           current5_ == end5_ ||
15132           current6_ == end6_ ||
15133           current7_ == end7_ ||
15134           current8_ == end8_ ||
15135           current9_ == end9_;
15136     }
15137 
15138     // No implementation - assignment is unsupported.
15139     void operator=(const Iterator& other);
15140 
15141     const ParamGeneratorInterface<ParamType>* const base_;
15142     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
15143     // current[i]_ is the actual traversing iterator.
15144     const typename ParamGenerator<T1>::iterator begin1_;
15145     const typename ParamGenerator<T1>::iterator end1_;
15146     typename ParamGenerator<T1>::iterator current1_;
15147     const typename ParamGenerator<T2>::iterator begin2_;
15148     const typename ParamGenerator<T2>::iterator end2_;
15149     typename ParamGenerator<T2>::iterator current2_;
15150     const typename ParamGenerator<T3>::iterator begin3_;
15151     const typename ParamGenerator<T3>::iterator end3_;
15152     typename ParamGenerator<T3>::iterator current3_;
15153     const typename ParamGenerator<T4>::iterator begin4_;
15154     const typename ParamGenerator<T4>::iterator end4_;
15155     typename ParamGenerator<T4>::iterator current4_;
15156     const typename ParamGenerator<T5>::iterator begin5_;
15157     const typename ParamGenerator<T5>::iterator end5_;
15158     typename ParamGenerator<T5>::iterator current5_;
15159     const typename ParamGenerator<T6>::iterator begin6_;
15160     const typename ParamGenerator<T6>::iterator end6_;
15161     typename ParamGenerator<T6>::iterator current6_;
15162     const typename ParamGenerator<T7>::iterator begin7_;
15163     const typename ParamGenerator<T7>::iterator end7_;
15164     typename ParamGenerator<T7>::iterator current7_;
15165     const typename ParamGenerator<T8>::iterator begin8_;
15166     const typename ParamGenerator<T8>::iterator end8_;
15167     typename ParamGenerator<T8>::iterator current8_;
15168     const typename ParamGenerator<T9>::iterator begin9_;
15169     const typename ParamGenerator<T9>::iterator end9_;
15170     typename ParamGenerator<T9>::iterator current9_;
15171     ParamType current_value_;
15172   };  // class CartesianProductGenerator9::Iterator
15173 
15174   // No implementation - assignment is unsupported.
15175   void operator=(const CartesianProductGenerator9& other);
15176 
15177   const ParamGenerator<T1> g1_;
15178   const ParamGenerator<T2> g2_;
15179   const ParamGenerator<T3> g3_;
15180   const ParamGenerator<T4> g4_;
15181   const ParamGenerator<T5> g5_;
15182   const ParamGenerator<T6> g6_;
15183   const ParamGenerator<T7> g7_;
15184   const ParamGenerator<T8> g8_;
15185   const ParamGenerator<T9> g9_;
15186 };  // class CartesianProductGenerator9
15187 
15188 
15189 template <typename T1, typename T2, typename T3, typename T4, typename T5,
15190     typename T6, typename T7, typename T8, typename T9, typename T10>
15191 class CartesianProductGenerator10
15192     : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
15193         T7, T8, T9, T10> > {
15194  public:
15195   typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ParamType;
15196 
15197   CartesianProductGenerator10(const ParamGenerator<T1>& g1,
15198       const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3,
15199       const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5,
15200       const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7,
15201       const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9,
15202       const ParamGenerator<T10>& g10)
15203       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
15204           g9_(g9), g10_(g10) {}
15205   virtual ~CartesianProductGenerator10() {}
15206 
15207   virtual ParamIteratorInterface<ParamType>* Begin() const {
15208     return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_,
15209         g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_,
15210         g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin(), g10_, g10_.begin());
15211   }
15212   virtual ParamIteratorInterface<ParamType>* End() const {
15213     return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(),
15214         g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_,
15215         g8_.end(), g9_, g9_.end(), g10_, g10_.end());
15216   }
15217 
15218  private:
15219   class Iterator : public ParamIteratorInterface<ParamType> {
15220    public:
15221     Iterator(const ParamGeneratorInterface<ParamType>* base,
15222       const ParamGenerator<T1>& g1,
15223       const typename ParamGenerator<T1>::iterator& current1,
15224       const ParamGenerator<T2>& g2,
15225       const typename ParamGenerator<T2>::iterator& current2,
15226       const ParamGenerator<T3>& g3,
15227       const typename ParamGenerator<T3>::iterator& current3,
15228       const ParamGenerator<T4>& g4,
15229       const typename ParamGenerator<T4>::iterator& current4,
15230       const ParamGenerator<T5>& g5,
15231       const typename ParamGenerator<T5>::iterator& current5,
15232       const ParamGenerator<T6>& g6,
15233       const typename ParamGenerator<T6>::iterator& current6,
15234       const ParamGenerator<T7>& g7,
15235       const typename ParamGenerator<T7>::iterator& current7,
15236       const ParamGenerator<T8>& g8,
15237       const typename ParamGenerator<T8>::iterator& current8,
15238       const ParamGenerator<T9>& g9,
15239       const typename ParamGenerator<T9>::iterator& current9,
15240       const ParamGenerator<T10>& g10,
15241       const typename ParamGenerator<T10>::iterator& current10)
15242         : base_(base),
15243           begin1_(g1.begin()), end1_(g1.end()), current1_(current1),
15244           begin2_(g2.begin()), end2_(g2.end()), current2_(current2),
15245           begin3_(g3.begin()), end3_(g3.end()), current3_(current3),
15246           begin4_(g4.begin()), end4_(g4.end()), current4_(current4),
15247           begin5_(g5.begin()), end5_(g5.end()), current5_(current5),
15248           begin6_(g6.begin()), end6_(g6.end()), current6_(current6),
15249           begin7_(g7.begin()), end7_(g7.end()), current7_(current7),
15250           begin8_(g8.begin()), end8_(g8.end()), current8_(current8),
15251           begin9_(g9.begin()), end9_(g9.end()), current9_(current9),
15252           begin10_(g10.begin()), end10_(g10.end()), current10_(current10)    {
15253       ComputeCurrentValue();
15254     }
15255     virtual ~Iterator() {}
15256 
15257     virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
15258       return base_;
15259     }
15260     // Advance should not be called on beyond-of-range iterators
15261     // so no component iterators must be beyond end of range, either.
15262     virtual void Advance() {
15263       assert(!AtEnd());
15264       ++current10_;
15265       if (current10_ == end10_) {
15266         current10_ = begin10_;
15267         ++current9_;
15268       }
15269       if (current9_ == end9_) {
15270         current9_ = begin9_;
15271         ++current8_;
15272       }
15273       if (current8_ == end8_) {
15274         current8_ = begin8_;
15275         ++current7_;
15276       }
15277       if (current7_ == end7_) {
15278         current7_ = begin7_;
15279         ++current6_;
15280       }
15281       if (current6_ == end6_) {
15282         current6_ = begin6_;
15283         ++current5_;
15284       }
15285       if (current5_ == end5_) {
15286         current5_ = begin5_;
15287         ++current4_;
15288       }
15289       if (current4_ == end4_) {
15290         current4_ = begin4_;
15291         ++current3_;
15292       }
15293       if (current3_ == end3_) {
15294         current3_ = begin3_;
15295         ++current2_;
15296       }
15297       if (current2_ == end2_) {
15298         current2_ = begin2_;
15299         ++current1_;
15300       }
15301       ComputeCurrentValue();
15302     }
15303     virtual ParamIteratorInterface<ParamType>* Clone() const {
15304       return new Iterator(*this);
15305     }
15306     virtual const ParamType* Current() const { return &current_value_; }
15307     virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
15308       // Having the same base generator guarantees that the other
15309       // iterator is of the same type and we can downcast.
15310       GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
15311           << "The program attempted to compare iterators "
15312           << "from different generators." << std::endl;
15313       const Iterator* typed_other =
15314           CheckedDowncastToActualType<const Iterator>(&other);
15315       // We must report iterators equal if they both point beyond their
15316       // respective ranges. That can happen in a variety of fashions,
15317       // so we have to consult AtEnd().
15318       return (AtEnd() && typed_other->AtEnd()) ||
15319          (
15320           current1_ == typed_other->current1_ &&
15321           current2_ == typed_other->current2_ &&
15322           current3_ == typed_other->current3_ &&
15323           current4_ == typed_other->current4_ &&
15324           current5_ == typed_other->current5_ &&
15325           current6_ == typed_other->current6_ &&
15326           current7_ == typed_other->current7_ &&
15327           current8_ == typed_other->current8_ &&
15328           current9_ == typed_other->current9_ &&
15329           current10_ == typed_other->current10_);
15330     }
15331 
15332    private:
15333     Iterator(const Iterator& other)
15334         : base_(other.base_),
15335         begin1_(other.begin1_),
15336         end1_(other.end1_),
15337         current1_(other.current1_),
15338         begin2_(other.begin2_),
15339         end2_(other.end2_),
15340         current2_(other.current2_),
15341         begin3_(other.begin3_),
15342         end3_(other.end3_),
15343         current3_(other.current3_),
15344         begin4_(other.begin4_),
15345         end4_(other.end4_),
15346         current4_(other.current4_),
15347         begin5_(other.begin5_),
15348         end5_(other.end5_),
15349         current5_(other.current5_),
15350         begin6_(other.begin6_),
15351         end6_(other.end6_),
15352         current6_(other.current6_),
15353         begin7_(other.begin7_),
15354         end7_(other.end7_),
15355         current7_(other.current7_),
15356         begin8_(other.begin8_),
15357         end8_(other.end8_),
15358         current8_(other.current8_),
15359         begin9_(other.begin9_),
15360         end9_(other.end9_),
15361         current9_(other.current9_),
15362         begin10_(other.begin10_),
15363         end10_(other.end10_),
15364         current10_(other.current10_) {
15365       ComputeCurrentValue();
15366     }
15367 
15368     void ComputeCurrentValue() {
15369       if (!AtEnd())
15370         current_value_ = ParamType(*current1_, *current2_, *current3_,
15371             *current4_, *current5_, *current6_, *current7_, *current8_,
15372             *current9_, *current10_);
15373     }
15374     bool AtEnd() const {
15375       // We must report iterator past the end of the range when either of the
15376       // component iterators has reached the end of its range.
15377       return
15378           current1_ == end1_ ||
15379           current2_ == end2_ ||
15380           current3_ == end3_ ||
15381           current4_ == end4_ ||
15382           current5_ == end5_ ||
15383           current6_ == end6_ ||
15384           current7_ == end7_ ||
15385           current8_ == end8_ ||
15386           current9_ == end9_ ||
15387           current10_ == end10_;
15388     }
15389 
15390     // No implementation - assignment is unsupported.
15391     void operator=(const Iterator& other);
15392 
15393     const ParamGeneratorInterface<ParamType>* const base_;
15394     // begin[i]_ and end[i]_ define the i-th range that Iterator traverses.
15395     // current[i]_ is the actual traversing iterator.
15396     const typename ParamGenerator<T1>::iterator begin1_;
15397     const typename ParamGenerator<T1>::iterator end1_;
15398     typename ParamGenerator<T1>::iterator current1_;
15399     const typename ParamGenerator<T2>::iterator begin2_;
15400     const typename ParamGenerator<T2>::iterator end2_;
15401     typename ParamGenerator<T2>::iterator current2_;
15402     const typename ParamGenerator<T3>::iterator begin3_;
15403     const typename ParamGenerator<T3>::iterator end3_;
15404     typename ParamGenerator<T3>::iterator current3_;
15405     const typename ParamGenerator<T4>::iterator begin4_;
15406     const typename ParamGenerator<T4>::iterator end4_;
15407     typename ParamGenerator<T4>::iterator current4_;
15408     const typename ParamGenerator<T5>::iterator begin5_;
15409     const typename ParamGenerator<T5>::iterator end5_;
15410     typename ParamGenerator<T5>::iterator current5_;
15411     const typename ParamGenerator<T6>::iterator begin6_;
15412     const typename ParamGenerator<T6>::iterator end6_;
15413     typename ParamGenerator<T6>::iterator current6_;
15414     const typename ParamGenerator<T7>::iterator begin7_;
15415     const typename ParamGenerator<T7>::iterator end7_;
15416     typename ParamGenerator<T7>::iterator current7_;
15417     const typename ParamGenerator<T8>::iterator begin8_;
15418     const typename ParamGenerator<T8>::iterator end8_;
15419     typename ParamGenerator<T8>::iterator current8_;
15420     const typename ParamGenerator<T9>::iterator begin9_;
15421     const typename ParamGenerator<T9>::iterator end9_;
15422     typename ParamGenerator<T9>::iterator current9_;
15423     const typename ParamGenerator<T10>::iterator begin10_;
15424     const typename ParamGenerator<T10>::iterator end10_;
15425     typename ParamGenerator<T10>::iterator current10_;
15426     ParamType current_value_;
15427   };  // class CartesianProductGenerator10::Iterator
15428 
15429   // No implementation - assignment is unsupported.
15430   void operator=(const CartesianProductGenerator10& other);
15431 
15432   const ParamGenerator<T1> g1_;
15433   const ParamGenerator<T2> g2_;
15434   const ParamGenerator<T3> g3_;
15435   const ParamGenerator<T4> g4_;
15436   const ParamGenerator<T5> g5_;
15437   const ParamGenerator<T6> g6_;
15438   const ParamGenerator<T7> g7_;
15439   const ParamGenerator<T8> g8_;
15440   const ParamGenerator<T9> g9_;
15441   const ParamGenerator<T10> g10_;
15442 };  // class CartesianProductGenerator10
15443 
15444 
15445 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
15446 //
15447 // Helper classes providing Combine() with polymorphic features. They allow
15448 // casting CartesianProductGeneratorN<T> to ParamGenerator<U> if T is
15449 // convertible to U.
15450 //
15451 template <class Generator1, class Generator2>
15452 class CartesianProductHolder2 {
15453  public:
15454 CartesianProductHolder2(const Generator1& g1, const Generator2& g2)
15455       : g1_(g1), g2_(g2) {}
15456   template <typename T1, typename T2>
15457   operator ParamGenerator< ::std::tr1::tuple<T1, T2> >() const {
15458     return ParamGenerator< ::std::tr1::tuple<T1, T2> >(
15459         new CartesianProductGenerator2<T1, T2>(
15460         static_cast<ParamGenerator<T1> >(g1_),
15461         static_cast<ParamGenerator<T2> >(g2_)));
15462   }
15463 
15464  private:
15465   // No implementation - assignment is unsupported.
15466   void operator=(const CartesianProductHolder2& other);
15467 
15468   const Generator1 g1_;
15469   const Generator2 g2_;
15470 };  // class CartesianProductHolder2
15471 
15472 template <class Generator1, class Generator2, class Generator3>
15473 class CartesianProductHolder3 {
15474  public:
15475 CartesianProductHolder3(const Generator1& g1, const Generator2& g2,
15476     const Generator3& g3)
15477       : g1_(g1), g2_(g2), g3_(g3) {}
15478   template <typename T1, typename T2, typename T3>
15479   operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3> >() const {
15480     return ParamGenerator< ::std::tr1::tuple<T1, T2, T3> >(
15481         new CartesianProductGenerator3<T1, T2, T3>(
15482         static_cast<ParamGenerator<T1> >(g1_),
15483         static_cast<ParamGenerator<T2> >(g2_),
15484         static_cast<ParamGenerator<T3> >(g3_)));
15485   }
15486 
15487  private:
15488   // No implementation - assignment is unsupported.
15489   void operator=(const CartesianProductHolder3& other);
15490 
15491   const Generator1 g1_;
15492   const Generator2 g2_;
15493   const Generator3 g3_;
15494 };  // class CartesianProductHolder3
15495 
15496 template <class Generator1, class Generator2, class Generator3,
15497     class Generator4>
15498 class CartesianProductHolder4 {
15499  public:
15500 CartesianProductHolder4(const Generator1& g1, const Generator2& g2,
15501     const Generator3& g3, const Generator4& g4)
15502       : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {}
15503   template <typename T1, typename T2, typename T3, typename T4>
15504   operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4> >() const {
15505     return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4> >(
15506         new CartesianProductGenerator4<T1, T2, T3, T4>(
15507         static_cast<ParamGenerator<T1> >(g1_),
15508         static_cast<ParamGenerator<T2> >(g2_),
15509         static_cast<ParamGenerator<T3> >(g3_),
15510         static_cast<ParamGenerator<T4> >(g4_)));
15511   }
15512 
15513  private:
15514   // No implementation - assignment is unsupported.
15515   void operator=(const CartesianProductHolder4& other);
15516 
15517   const Generator1 g1_;
15518   const Generator2 g2_;
15519   const Generator3 g3_;
15520   const Generator4 g4_;
15521 };  // class CartesianProductHolder4
15522 
15523 template <class Generator1, class Generator2, class Generator3,
15524     class Generator4, class Generator5>
15525 class CartesianProductHolder5 {
15526  public:
15527 CartesianProductHolder5(const Generator1& g1, const Generator2& g2,
15528     const Generator3& g3, const Generator4& g4, const Generator5& g5)
15529       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {}
15530   template <typename T1, typename T2, typename T3, typename T4, typename T5>
15531   operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5> >() const {
15532     return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5> >(
15533         new CartesianProductGenerator5<T1, T2, T3, T4, T5>(
15534         static_cast<ParamGenerator<T1> >(g1_),
15535         static_cast<ParamGenerator<T2> >(g2_),
15536         static_cast<ParamGenerator<T3> >(g3_),
15537         static_cast<ParamGenerator<T4> >(g4_),
15538         static_cast<ParamGenerator<T5> >(g5_)));
15539   }
15540 
15541  private:
15542   // No implementation - assignment is unsupported.
15543   void operator=(const CartesianProductHolder5& other);
15544 
15545   const Generator1 g1_;
15546   const Generator2 g2_;
15547   const Generator3 g3_;
15548   const Generator4 g4_;
15549   const Generator5 g5_;
15550 };  // class CartesianProductHolder5
15551 
15552 template <class Generator1, class Generator2, class Generator3,
15553     class Generator4, class Generator5, class Generator6>
15554 class CartesianProductHolder6 {
15555  public:
15556 CartesianProductHolder6(const Generator1& g1, const Generator2& g2,
15557     const Generator3& g3, const Generator4& g4, const Generator5& g5,
15558     const Generator6& g6)
15559       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {}
15560   template <typename T1, typename T2, typename T3, typename T4, typename T5,
15561       typename T6>
15562   operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6> >() const {
15563     return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6> >(
15564         new CartesianProductGenerator6<T1, T2, T3, T4, T5, T6>(
15565         static_cast<ParamGenerator<T1> >(g1_),
15566         static_cast<ParamGenerator<T2> >(g2_),
15567         static_cast<ParamGenerator<T3> >(g3_),
15568         static_cast<ParamGenerator<T4> >(g4_),
15569         static_cast<ParamGenerator<T5> >(g5_),
15570         static_cast<ParamGenerator<T6> >(g6_)));
15571   }
15572 
15573  private:
15574   // No implementation - assignment is unsupported.
15575   void operator=(const CartesianProductHolder6& other);
15576 
15577   const Generator1 g1_;
15578   const Generator2 g2_;
15579   const Generator3 g3_;
15580   const Generator4 g4_;
15581   const Generator5 g5_;
15582   const Generator6 g6_;
15583 };  // class CartesianProductHolder6
15584 
15585 template <class Generator1, class Generator2, class Generator3,
15586     class Generator4, class Generator5, class Generator6, class Generator7>
15587 class CartesianProductHolder7 {
15588  public:
15589 CartesianProductHolder7(const Generator1& g1, const Generator2& g2,
15590     const Generator3& g3, const Generator4& g4, const Generator5& g5,
15591     const Generator6& g6, const Generator7& g7)
15592       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {}
15593   template <typename T1, typename T2, typename T3, typename T4, typename T5,
15594       typename T6, typename T7>
15595   operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6,
15596       T7> >() const {
15597     return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7> >(
15598         new CartesianProductGenerator7<T1, T2, T3, T4, T5, T6, T7>(
15599         static_cast<ParamGenerator<T1> >(g1_),
15600         static_cast<ParamGenerator<T2> >(g2_),
15601         static_cast<ParamGenerator<T3> >(g3_),
15602         static_cast<ParamGenerator<T4> >(g4_),
15603         static_cast<ParamGenerator<T5> >(g5_),
15604         static_cast<ParamGenerator<T6> >(g6_),
15605         static_cast<ParamGenerator<T7> >(g7_)));
15606   }
15607 
15608  private:
15609   // No implementation - assignment is unsupported.
15610   void operator=(const CartesianProductHolder7& other);
15611 
15612   const Generator1 g1_;
15613   const Generator2 g2_;
15614   const Generator3 g3_;
15615   const Generator4 g4_;
15616   const Generator5 g5_;
15617   const Generator6 g6_;
15618   const Generator7 g7_;
15619 };  // class CartesianProductHolder7
15620 
15621 template <class Generator1, class Generator2, class Generator3,
15622     class Generator4, class Generator5, class Generator6, class Generator7,
15623     class Generator8>
15624 class CartesianProductHolder8 {
15625  public:
15626 CartesianProductHolder8(const Generator1& g1, const Generator2& g2,
15627     const Generator3& g3, const Generator4& g4, const Generator5& g5,
15628     const Generator6& g6, const Generator7& g7, const Generator8& g8)
15629       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7),
15630           g8_(g8) {}
15631   template <typename T1, typename T2, typename T3, typename T4, typename T5,
15632       typename T6, typename T7, typename T8>
15633   operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7,
15634       T8> >() const {
15635     return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8> >(
15636         new CartesianProductGenerator8<T1, T2, T3, T4, T5, T6, T7, T8>(
15637         static_cast<ParamGenerator<T1> >(g1_),
15638         static_cast<ParamGenerator<T2> >(g2_),
15639         static_cast<ParamGenerator<T3> >(g3_),
15640         static_cast<ParamGenerator<T4> >(g4_),
15641         static_cast<ParamGenerator<T5> >(g5_),
15642         static_cast<ParamGenerator<T6> >(g6_),
15643         static_cast<ParamGenerator<T7> >(g7_),
15644         static_cast<ParamGenerator<T8> >(g8_)));
15645   }
15646 
15647  private:
15648   // No implementation - assignment is unsupported.
15649   void operator=(const CartesianProductHolder8& other);
15650 
15651   const Generator1 g1_;
15652   const Generator2 g2_;
15653   const Generator3 g3_;
15654   const Generator4 g4_;
15655   const Generator5 g5_;
15656   const Generator6 g6_;
15657   const Generator7 g7_;
15658   const Generator8 g8_;
15659 };  // class CartesianProductHolder8
15660 
15661 template <class Generator1, class Generator2, class Generator3,
15662     class Generator4, class Generator5, class Generator6, class Generator7,
15663     class Generator8, class Generator9>
15664 class CartesianProductHolder9 {
15665  public:
15666 CartesianProductHolder9(const Generator1& g1, const Generator2& g2,
15667     const Generator3& g3, const Generator4& g4, const Generator5& g5,
15668     const Generator6& g6, const Generator7& g7, const Generator8& g8,
15669     const Generator9& g9)
15670       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
15671           g9_(g9) {}
15672   template <typename T1, typename T2, typename T3, typename T4, typename T5,
15673       typename T6, typename T7, typename T8, typename T9>
15674   operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
15675       T9> >() const {
15676     return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
15677         T9> >(
15678         new CartesianProductGenerator9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
15679         static_cast<ParamGenerator<T1> >(g1_),
15680         static_cast<ParamGenerator<T2> >(g2_),
15681         static_cast<ParamGenerator<T3> >(g3_),
15682         static_cast<ParamGenerator<T4> >(g4_),
15683         static_cast<ParamGenerator<T5> >(g5_),
15684         static_cast<ParamGenerator<T6> >(g6_),
15685         static_cast<ParamGenerator<T7> >(g7_),
15686         static_cast<ParamGenerator<T8> >(g8_),
15687         static_cast<ParamGenerator<T9> >(g9_)));
15688   }
15689 
15690  private:
15691   // No implementation - assignment is unsupported.
15692   void operator=(const CartesianProductHolder9& other);
15693 
15694   const Generator1 g1_;
15695   const Generator2 g2_;
15696   const Generator3 g3_;
15697   const Generator4 g4_;
15698   const Generator5 g5_;
15699   const Generator6 g6_;
15700   const Generator7 g7_;
15701   const Generator8 g8_;
15702   const Generator9 g9_;
15703 };  // class CartesianProductHolder9
15704 
15705 template <class Generator1, class Generator2, class Generator3,
15706     class Generator4, class Generator5, class Generator6, class Generator7,
15707     class Generator8, class Generator9, class Generator10>
15708 class CartesianProductHolder10 {
15709  public:
15710 CartesianProductHolder10(const Generator1& g1, const Generator2& g2,
15711     const Generator3& g3, const Generator4& g4, const Generator5& g5,
15712     const Generator6& g6, const Generator7& g7, const Generator8& g8,
15713     const Generator9& g9, const Generator10& g10)
15714       : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8),
15715           g9_(g9), g10_(g10) {}
15716   template <typename T1, typename T2, typename T3, typename T4, typename T5,
15717       typename T6, typename T7, typename T8, typename T9, typename T10>
15718   operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
15719       T9, T10> >() const {
15720     return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8,
15721         T9, T10> >(
15722         new CartesianProductGenerator10<T1, T2, T3, T4, T5, T6, T7, T8, T9,
15723             T10>(
15724         static_cast<ParamGenerator<T1> >(g1_),
15725         static_cast<ParamGenerator<T2> >(g2_),
15726         static_cast<ParamGenerator<T3> >(g3_),
15727         static_cast<ParamGenerator<T4> >(g4_),
15728         static_cast<ParamGenerator<T5> >(g5_),
15729         static_cast<ParamGenerator<T6> >(g6_),
15730         static_cast<ParamGenerator<T7> >(g7_),
15731         static_cast<ParamGenerator<T8> >(g8_),
15732         static_cast<ParamGenerator<T9> >(g9_),
15733         static_cast<ParamGenerator<T10> >(g10_)));
15734   }
15735 
15736  private:
15737   // No implementation - assignment is unsupported.
15738   void operator=(const CartesianProductHolder10& other);
15739 
15740   const Generator1 g1_;
15741   const Generator2 g2_;
15742   const Generator3 g3_;
15743   const Generator4 g4_;
15744   const Generator5 g5_;
15745   const Generator6 g6_;
15746   const Generator7 g7_;
15747   const Generator8 g8_;
15748   const Generator9 g9_;
15749   const Generator10 g10_;
15750 };  // class CartesianProductHolder10
15751 
15752 # endif  // GTEST_HAS_COMBINE
15753 
15754 }  // namespace internal
15755 }  // namespace testing
15756 
15757 #endif  //  GTEST_HAS_PARAM_TEST
15758 
15759 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
15760 
15761 #if GTEST_HAS_PARAM_TEST
15762 
15763 namespace testing {
15764 
15765 // Functions producing parameter generators.
15766 //
15767 // Google Test uses these generators to produce parameters for value-
15768 // parameterized tests. When a parameterized test case is instantiated
15769 // with a particular generator, Google Test creates and runs tests
15770 // for each element in the sequence produced by the generator.
15771 //
15772 // In the following sample, tests from test case FooTest are instantiated
15773 // each three times with parameter values 3, 5, and 8:
15774 //
15775 // class FooTest : public TestWithParam<int> { ... };
15776 //
15777 // TEST_P(FooTest, TestThis) {
15778 // }
15779 // TEST_P(FooTest, TestThat) {
15780 // }
15781 // INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8));
15782 //
15783 
15784 // Range() returns generators providing sequences of values in a range.
15785 //
15786 // Synopsis:
15787 // Range(start, end)
15788 //   - returns a generator producing a sequence of values {start, start+1,
15789 //     start+2, ..., }.
15790 // Range(start, end, step)
15791 //   - returns a generator producing a sequence of values {start, start+step,
15792 //     start+step+step, ..., }.
15793 // Notes:
15794 //   * The generated sequences never include end. For example, Range(1, 5)
15795 //     returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)
15796 //     returns a generator producing {1, 3, 5, 7}.
15797 //   * start and end must have the same type. That type may be any integral or
15798 //     floating-point type or a user defined type satisfying these conditions:
15799 //     * It must be assignable (have operator=() defined).
15800 //     * It must have operator+() (operator+(int-compatible type) for
15801 //       two-operand version).
15802 //     * It must have operator<() defined.
15803 //     Elements in the resulting sequences will also have that type.
15804 //   * Condition start < end must be satisfied in order for resulting sequences
15805 //     to contain any elements.
15806 //
15807 template <typename T, typename IncrementT>
15808 internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {
15809   return internal::ParamGenerator<T>(
15810       new internal::RangeGenerator<T, IncrementT>(start, end, step));
15811 }
15812 
15813 template <typename T>
15814 internal::ParamGenerator<T> Range(T start, T end) {
15815   return Range(start, end, 1);
15816 }
15817 
15818 // ValuesIn() function allows generation of tests with parameters coming from
15819 // a container.
15820 //
15821 // Synopsis:
15822 // ValuesIn(const T (&array)[N])
15823 //   - returns a generator producing sequences with elements from
15824 //     a C-style array.
15825 // ValuesIn(const Container& container)
15826 //   - returns a generator producing sequences with elements from
15827 //     an STL-style container.
15828 // ValuesIn(Iterator begin, Iterator end)
15829 //   - returns a generator producing sequences with elements from
15830 //     a range [begin, end) defined by a pair of STL-style iterators. These
15831 //     iterators can also be plain C pointers.
15832 //
15833 // Please note that ValuesIn copies the values from the containers
15834 // passed in and keeps them to generate tests in RUN_ALL_TESTS().
15835 //
15836 // Examples:
15837 //
15838 // This instantiates tests from test case StringTest
15839 // each with C-string values of "foo", "bar", and "baz":
15840 //
15841 // const char* strings[] = {"foo", "bar", "baz"};
15842 // INSTANTIATE_TEST_CASE_P(StringSequence, SrtingTest, ValuesIn(strings));
15843 //
15844 // This instantiates tests from test case StlStringTest
15845 // each with STL strings with values "a" and "b":
15846 //
15847 // ::std::vector< ::std::string> GetParameterStrings() {
15848 //   ::std::vector< ::std::string> v;
15849 //   v.push_back("a");
15850 //   v.push_back("b");
15851 //   return v;
15852 // }
15853 //
15854 // INSTANTIATE_TEST_CASE_P(CharSequence,
15855 //                         StlStringTest,
15856 //                         ValuesIn(GetParameterStrings()));
15857 //
15858 //
15859 // This will also instantiate tests from CharTest
15860 // each with parameter values 'a' and 'b':
15861 //
15862 // ::std::list<char> GetParameterChars() {
15863 //   ::std::list<char> list;
15864 //   list.push_back('a');
15865 //   list.push_back('b');
15866 //   return list;
15867 // }
15868 // ::std::list<char> l = GetParameterChars();
15869 // INSTANTIATE_TEST_CASE_P(CharSequence2,
15870 //                         CharTest,
15871 //                         ValuesIn(l.begin(), l.end()));
15872 //
15873 template <typename ForwardIterator>
15874 internal::ParamGenerator<
15875   typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>
15876 ValuesIn(ForwardIterator begin, ForwardIterator end) {
15877   typedef typename ::testing::internal::IteratorTraits<ForwardIterator>
15878       ::value_type ParamType;
15879   return internal::ParamGenerator<ParamType>(
15880       new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
15881 }
15882 
15883 template <typename T, size_t N>
15884 internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
15885   return ValuesIn(array, array + N);
15886 }
15887 
15888 template <class Container>
15889 internal::ParamGenerator<typename Container::value_type> ValuesIn(
15890     const Container& container) {
15891   return ValuesIn(container.begin(), container.end());
15892 }
15893 
15894 // Values() allows generating tests from explicitly specified list of
15895 // parameters.
15896 //
15897 // Synopsis:
15898 // Values(T v1, T v2, ..., T vN)
15899 //   - returns a generator producing sequences with elements v1, v2, ..., vN.
15900 //
15901 // For example, this instantiates tests from test case BarTest each
15902 // with values "one", "two", and "three":
15903 //
15904 // INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three"));
15905 //
15906 // This instantiates tests from test case BazTest each with values 1, 2, 3.5.
15907 // The exact type of values will depend on the type of parameter in BazTest.
15908 //
15909 // INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
15910 //
15911 // Currently, Values() supports from 1 to 50 parameters.
15912 //
15913 template <typename T1>
15914 internal::ValueArray1<T1> Values(T1 v1) {
15915   return internal::ValueArray1<T1>(v1);
15916 }
15917 
15918 template <typename T1, typename T2>
15919 internal::ValueArray2<T1, T2> Values(T1 v1, T2 v2) {
15920   return internal::ValueArray2<T1, T2>(v1, v2);
15921 }
15922 
15923 template <typename T1, typename T2, typename T3>
15924 internal::ValueArray3<T1, T2, T3> Values(T1 v1, T2 v2, T3 v3) {
15925   return internal::ValueArray3<T1, T2, T3>(v1, v2, v3);
15926 }
15927 
15928 template <typename T1, typename T2, typename T3, typename T4>
15929 internal::ValueArray4<T1, T2, T3, T4> Values(T1 v1, T2 v2, T3 v3, T4 v4) {
15930   return internal::ValueArray4<T1, T2, T3, T4>(v1, v2, v3, v4);
15931 }
15932 
15933 template <typename T1, typename T2, typename T3, typename T4, typename T5>
15934 internal::ValueArray5<T1, T2, T3, T4, T5> Values(T1 v1, T2 v2, T3 v3, T4 v4,
15935     T5 v5) {
15936   return internal::ValueArray5<T1, T2, T3, T4, T5>(v1, v2, v3, v4, v5);
15937 }
15938 
15939 template <typename T1, typename T2, typename T3, typename T4, typename T5,
15940     typename T6>
15941 internal::ValueArray6<T1, T2, T3, T4, T5, T6> Values(T1 v1, T2 v2, T3 v3,
15942     T4 v4, T5 v5, T6 v6) {
15943   return internal::ValueArray6<T1, T2, T3, T4, T5, T6>(v1, v2, v3, v4, v5, v6);
15944 }
15945 
15946 template <typename T1, typename T2, typename T3, typename T4, typename T5,
15947     typename T6, typename T7>
15948 internal::ValueArray7<T1, T2, T3, T4, T5, T6, T7> Values(T1 v1, T2 v2, T3 v3,
15949     T4 v4, T5 v5, T6 v6, T7 v7) {
15950   return internal::ValueArray7<T1, T2, T3, T4, T5, T6, T7>(v1, v2, v3, v4, v5,
15951       v6, v7);
15952 }
15953 
15954 template <typename T1, typename T2, typename T3, typename T4, typename T5,
15955     typename T6, typename T7, typename T8>
15956 internal::ValueArray8<T1, T2, T3, T4, T5, T6, T7, T8> Values(T1 v1, T2 v2,
15957     T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) {
15958   return internal::ValueArray8<T1, T2, T3, T4, T5, T6, T7, T8>(v1, v2, v3, v4,
15959       v5, v6, v7, v8);
15960 }
15961 
15962 template <typename T1, typename T2, typename T3, typename T4, typename T5,
15963     typename T6, typename T7, typename T8, typename T9>
15964 internal::ValueArray9<T1, T2, T3, T4, T5, T6, T7, T8, T9> Values(T1 v1, T2 v2,
15965     T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) {
15966   return internal::ValueArray9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(v1, v2, v3,
15967       v4, v5, v6, v7, v8, v9);
15968 }
15969 
15970 template <typename T1, typename T2, typename T3, typename T4, typename T5,
15971     typename T6, typename T7, typename T8, typename T9, typename T10>
15972 internal::ValueArray10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Values(T1 v1,
15973     T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) {
15974   return internal::ValueArray10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(v1,
15975       v2, v3, v4, v5, v6, v7, v8, v9, v10);
15976 }
15977 
15978 template <typename T1, typename T2, typename T3, typename T4, typename T5,
15979     typename T6, typename T7, typename T8, typename T9, typename T10,
15980     typename T11>
15981 internal::ValueArray11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
15982     T11> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
15983     T10 v10, T11 v11) {
15984   return internal::ValueArray11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
15985       T11>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
15986 }
15987 
15988 template <typename T1, typename T2, typename T3, typename T4, typename T5,
15989     typename T6, typename T7, typename T8, typename T9, typename T10,
15990     typename T11, typename T12>
15991 internal::ValueArray12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
15992     T12> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
15993     T10 v10, T11 v11, T12 v12) {
15994   return internal::ValueArray12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
15995       T12>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
15996 }
15997 
15998 template <typename T1, typename T2, typename T3, typename T4, typename T5,
15999     typename T6, typename T7, typename T8, typename T9, typename T10,
16000     typename T11, typename T12, typename T13>
16001 internal::ValueArray13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
16002     T13> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
16003     T10 v10, T11 v11, T12 v12, T13 v13) {
16004   return internal::ValueArray13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16005       T12, T13>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
16006 }
16007 
16008 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16009     typename T6, typename T7, typename T8, typename T9, typename T10,
16010     typename T11, typename T12, typename T13, typename T14>
16011 internal::ValueArray14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16012     T14> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
16013     T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) {
16014   return internal::ValueArray14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16015       T12, T13, T14>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
16016       v14);
16017 }
16018 
16019 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16020     typename T6, typename T7, typename T8, typename T9, typename T10,
16021     typename T11, typename T12, typename T13, typename T14, typename T15>
16022 internal::ValueArray15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16023     T14, T15> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
16024     T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) {
16025   return internal::ValueArray15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16026       T12, T13, T14, T15>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
16027       v13, v14, v15);
16028 }
16029 
16030 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16031     typename T6, typename T7, typename T8, typename T9, typename T10,
16032     typename T11, typename T12, typename T13, typename T14, typename T15,
16033     typename T16>
16034 internal::ValueArray16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16035     T14, T15, T16> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
16036     T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
16037     T16 v16) {
16038   return internal::ValueArray16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16039       T12, T13, T14, T15, T16>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
16040       v12, v13, v14, v15, v16);
16041 }
16042 
16043 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16044     typename T6, typename T7, typename T8, typename T9, typename T10,
16045     typename T11, typename T12, typename T13, typename T14, typename T15,
16046     typename T16, typename T17>
16047 internal::ValueArray17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16048     T14, T15, T16, T17> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
16049     T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
16050     T16 v16, T17 v17) {
16051   return internal::ValueArray17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16052       T12, T13, T14, T15, T16, T17>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
16053       v11, v12, v13, v14, v15, v16, v17);
16054 }
16055 
16056 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16057     typename T6, typename T7, typename T8, typename T9, typename T10,
16058     typename T11, typename T12, typename T13, typename T14, typename T15,
16059     typename T16, typename T17, typename T18>
16060 internal::ValueArray18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16061     T14, T15, T16, T17, T18> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
16062     T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
16063     T16 v16, T17 v17, T18 v18) {
16064   return internal::ValueArray18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16065       T12, T13, T14, T15, T16, T17, T18>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
16066       v10, v11, v12, v13, v14, v15, v16, v17, v18);
16067 }
16068 
16069 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16070     typename T6, typename T7, typename T8, typename T9, typename T10,
16071     typename T11, typename T12, typename T13, typename T14, typename T15,
16072     typename T16, typename T17, typename T18, typename T19>
16073 internal::ValueArray19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16074     T14, T15, T16, T17, T18, T19> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
16075     T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,
16076     T15 v15, T16 v16, T17 v17, T18 v18, T19 v19) {
16077   return internal::ValueArray19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16078       T12, T13, T14, T15, T16, T17, T18, T19>(v1, v2, v3, v4, v5, v6, v7, v8,
16079       v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19);
16080 }
16081 
16082 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16083     typename T6, typename T7, typename T8, typename T9, typename T10,
16084     typename T11, typename T12, typename T13, typename T14, typename T15,
16085     typename T16, typename T17, typename T18, typename T19, typename T20>
16086 internal::ValueArray20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16087     T14, T15, T16, T17, T18, T19, T20> Values(T1 v1, T2 v2, T3 v3, T4 v4,
16088     T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
16089     T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20) {
16090   return internal::ValueArray20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16091       T12, T13, T14, T15, T16, T17, T18, T19, T20>(v1, v2, v3, v4, v5, v6, v7,
16092       v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20);
16093 }
16094 
16095 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16096     typename T6, typename T7, typename T8, typename T9, typename T10,
16097     typename T11, typename T12, typename T13, typename T14, typename T15,
16098     typename T16, typename T17, typename T18, typename T19, typename T20,
16099     typename T21>
16100 internal::ValueArray21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16101     T14, T15, T16, T17, T18, T19, T20, T21> Values(T1 v1, T2 v2, T3 v3, T4 v4,
16102     T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
16103     T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21) {
16104   return internal::ValueArray21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16105       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(v1, v2, v3, v4, v5, v6,
16106       v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21);
16107 }
16108 
16109 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16110     typename T6, typename T7, typename T8, typename T9, typename T10,
16111     typename T11, typename T12, typename T13, typename T14, typename T15,
16112     typename T16, typename T17, typename T18, typename T19, typename T20,
16113     typename T21, typename T22>
16114 internal::ValueArray22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16115     T14, T15, T16, T17, T18, T19, T20, T21, T22> Values(T1 v1, T2 v2, T3 v3,
16116     T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
16117     T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
16118     T21 v21, T22 v22) {
16119   return internal::ValueArray22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16120       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>(v1, v2, v3, v4,
16121       v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
16122       v20, v21, v22);
16123 }
16124 
16125 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16126     typename T6, typename T7, typename T8, typename T9, typename T10,
16127     typename T11, typename T12, typename T13, typename T14, typename T15,
16128     typename T16, typename T17, typename T18, typename T19, typename T20,
16129     typename T21, typename T22, typename T23>
16130 internal::ValueArray23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16131     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Values(T1 v1, T2 v2,
16132     T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
16133     T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
16134     T21 v21, T22 v22, T23 v23) {
16135   return internal::ValueArray23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16136       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>(v1, v2, v3,
16137       v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
16138       v20, v21, v22, v23);
16139 }
16140 
16141 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16142     typename T6, typename T7, typename T8, typename T9, typename T10,
16143     typename T11, typename T12, typename T13, typename T14, typename T15,
16144     typename T16, typename T17, typename T18, typename T19, typename T20,
16145     typename T21, typename T22, typename T23, typename T24>
16146 internal::ValueArray24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16147     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Values(T1 v1, T2 v2,
16148     T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
16149     T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
16150     T21 v21, T22 v22, T23 v23, T24 v24) {
16151   return internal::ValueArray24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16152       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>(v1, v2,
16153       v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
16154       v19, v20, v21, v22, v23, v24);
16155 }
16156 
16157 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16158     typename T6, typename T7, typename T8, typename T9, typename T10,
16159     typename T11, typename T12, typename T13, typename T14, typename T15,
16160     typename T16, typename T17, typename T18, typename T19, typename T20,
16161     typename T21, typename T22, typename T23, typename T24, typename T25>
16162 internal::ValueArray25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16163     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Values(T1 v1,
16164     T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11,
16165     T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19,
16166     T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25) {
16167   return internal::ValueArray25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16168       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>(v1,
16169       v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17,
16170       v18, v19, v20, v21, v22, v23, v24, v25);
16171 }
16172 
16173 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16174     typename T6, typename T7, typename T8, typename T9, typename T10,
16175     typename T11, typename T12, typename T13, typename T14, typename T15,
16176     typename T16, typename T17, typename T18, typename T19, typename T20,
16177     typename T21, typename T22, typename T23, typename T24, typename T25,
16178     typename T26>
16179 internal::ValueArray26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16180     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16181     T26> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
16182     T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
16183     T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
16184     T26 v26) {
16185   return internal::ValueArray26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16186       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16187       T26>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
16188       v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26);
16189 }
16190 
16191 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16192     typename T6, typename T7, typename T8, typename T9, typename T10,
16193     typename T11, typename T12, typename T13, typename T14, typename T15,
16194     typename T16, typename T17, typename T18, typename T19, typename T20,
16195     typename T21, typename T22, typename T23, typename T24, typename T25,
16196     typename T26, typename T27>
16197 internal::ValueArray27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16198     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,
16199     T27> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
16200     T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
16201     T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
16202     T26 v26, T27 v27) {
16203   return internal::ValueArray27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16204       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16205       T26, T27>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14,
16206       v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27);
16207 }
16208 
16209 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16210     typename T6, typename T7, typename T8, typename T9, typename T10,
16211     typename T11, typename T12, typename T13, typename T14, typename T15,
16212     typename T16, typename T17, typename T18, typename T19, typename T20,
16213     typename T21, typename T22, typename T23, typename T24, typename T25,
16214     typename T26, typename T27, typename T28>
16215 internal::ValueArray28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16216     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,
16217     T28> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
16218     T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
16219     T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
16220     T26 v26, T27 v27, T28 v28) {
16221   return internal::ValueArray28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16222       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16223       T26, T27, T28>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
16224       v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27,
16225       v28);
16226 }
16227 
16228 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16229     typename T6, typename T7, typename T8, typename T9, typename T10,
16230     typename T11, typename T12, typename T13, typename T14, typename T15,
16231     typename T16, typename T17, typename T18, typename T19, typename T20,
16232     typename T21, typename T22, typename T23, typename T24, typename T25,
16233     typename T26, typename T27, typename T28, typename T29>
16234 internal::ValueArray29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16235     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16236     T29> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
16237     T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
16238     T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
16239     T26 v26, T27 v27, T28 v28, T29 v29) {
16240   return internal::ValueArray29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16241       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16242       T26, T27, T28, T29>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
16243       v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26,
16244       v27, v28, v29);
16245 }
16246 
16247 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16248     typename T6, typename T7, typename T8, typename T9, typename T10,
16249     typename T11, typename T12, typename T13, typename T14, typename T15,
16250     typename T16, typename T17, typename T18, typename T19, typename T20,
16251     typename T21, typename T22, typename T23, typename T24, typename T25,
16252     typename T26, typename T27, typename T28, typename T29, typename T30>
16253 internal::ValueArray30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16254     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16255     T29, T30> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
16256     T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
16257     T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
16258     T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) {
16259   return internal::ValueArray30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16260       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16261       T26, T27, T28, T29, T30>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
16262       v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25,
16263       v26, v27, v28, v29, v30);
16264 }
16265 
16266 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16267     typename T6, typename T7, typename T8, typename T9, typename T10,
16268     typename T11, typename T12, typename T13, typename T14, typename T15,
16269     typename T16, typename T17, typename T18, typename T19, typename T20,
16270     typename T21, typename T22, typename T23, typename T24, typename T25,
16271     typename T26, typename T27, typename T28, typename T29, typename T30,
16272     typename T31>
16273 internal::ValueArray31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16274     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16275     T29, T30, T31> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
16276     T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
16277     T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
16278     T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) {
16279   return internal::ValueArray31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16280       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16281       T26, T27, T28, T29, T30, T31>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
16282       v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24,
16283       v25, v26, v27, v28, v29, v30, v31);
16284 }
16285 
16286 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16287     typename T6, typename T7, typename T8, typename T9, typename T10,
16288     typename T11, typename T12, typename T13, typename T14, typename T15,
16289     typename T16, typename T17, typename T18, typename T19, typename T20,
16290     typename T21, typename T22, typename T23, typename T24, typename T25,
16291     typename T26, typename T27, typename T28, typename T29, typename T30,
16292     typename T31, typename T32>
16293 internal::ValueArray32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16294     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16295     T29, T30, T31, T32> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
16296     T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
16297     T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
16298     T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
16299     T32 v32) {
16300   return internal::ValueArray32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16301       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16302       T26, T27, T28, T29, T30, T31, T32>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
16303       v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
16304       v24, v25, v26, v27, v28, v29, v30, v31, v32);
16305 }
16306 
16307 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16308     typename T6, typename T7, typename T8, typename T9, typename T10,
16309     typename T11, typename T12, typename T13, typename T14, typename T15,
16310     typename T16, typename T17, typename T18, typename T19, typename T20,
16311     typename T21, typename T22, typename T23, typename T24, typename T25,
16312     typename T26, typename T27, typename T28, typename T29, typename T30,
16313     typename T31, typename T32, typename T33>
16314 internal::ValueArray33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16315     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16316     T29, T30, T31, T32, T33> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
16317     T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
16318     T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
16319     T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
16320     T32 v32, T33 v33) {
16321   return internal::ValueArray33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16322       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16323       T26, T27, T28, T29, T30, T31, T32, T33>(v1, v2, v3, v4, v5, v6, v7, v8,
16324       v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
16325       v24, v25, v26, v27, v28, v29, v30, v31, v32, v33);
16326 }
16327 
16328 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16329     typename T6, typename T7, typename T8, typename T9, typename T10,
16330     typename T11, typename T12, typename T13, typename T14, typename T15,
16331     typename T16, typename T17, typename T18, typename T19, typename T20,
16332     typename T21, typename T22, typename T23, typename T24, typename T25,
16333     typename T26, typename T27, typename T28, typename T29, typename T30,
16334     typename T31, typename T32, typename T33, typename T34>
16335 internal::ValueArray34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16336     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16337     T29, T30, T31, T32, T33, T34> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
16338     T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,
16339     T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22,
16340     T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30,
16341     T31 v31, T32 v32, T33 v33, T34 v34) {
16342   return internal::ValueArray34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16343       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16344       T26, T27, T28, T29, T30, T31, T32, T33, T34>(v1, v2, v3, v4, v5, v6, v7,
16345       v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22,
16346       v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34);
16347 }
16348 
16349 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16350     typename T6, typename T7, typename T8, typename T9, typename T10,
16351     typename T11, typename T12, typename T13, typename T14, typename T15,
16352     typename T16, typename T17, typename T18, typename T19, typename T20,
16353     typename T21, typename T22, typename T23, typename T24, typename T25,
16354     typename T26, typename T27, typename T28, typename T29, typename T30,
16355     typename T31, typename T32, typename T33, typename T34, typename T35>
16356 internal::ValueArray35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16357     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16358     T29, T30, T31, T32, T33, T34, T35> Values(T1 v1, T2 v2, T3 v3, T4 v4,
16359     T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
16360     T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,
16361     T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,
16362     T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35) {
16363   return internal::ValueArray35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16364       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16365       T26, T27, T28, T29, T30, T31, T32, T33, T34, T35>(v1, v2, v3, v4, v5, v6,
16366       v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
16367       v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35);
16368 }
16369 
16370 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16371     typename T6, typename T7, typename T8, typename T9, typename T10,
16372     typename T11, typename T12, typename T13, typename T14, typename T15,
16373     typename T16, typename T17, typename T18, typename T19, typename T20,
16374     typename T21, typename T22, typename T23, typename T24, typename T25,
16375     typename T26, typename T27, typename T28, typename T29, typename T30,
16376     typename T31, typename T32, typename T33, typename T34, typename T35,
16377     typename T36>
16378 internal::ValueArray36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16379     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16380     T29, T30, T31, T32, T33, T34, T35, T36> Values(T1 v1, T2 v2, T3 v3, T4 v4,
16381     T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
16382     T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,
16383     T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,
16384     T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36) {
16385   return internal::ValueArray36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16386       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16387       T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36>(v1, v2, v3, v4,
16388       v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
16389       v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,
16390       v34, v35, v36);
16391 }
16392 
16393 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16394     typename T6, typename T7, typename T8, typename T9, typename T10,
16395     typename T11, typename T12, typename T13, typename T14, typename T15,
16396     typename T16, typename T17, typename T18, typename T19, typename T20,
16397     typename T21, typename T22, typename T23, typename T24, typename T25,
16398     typename T26, typename T27, typename T28, typename T29, typename T30,
16399     typename T31, typename T32, typename T33, typename T34, typename T35,
16400     typename T36, typename T37>
16401 internal::ValueArray37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16402     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16403     T29, T30, T31, T32, T33, T34, T35, T36, T37> Values(T1 v1, T2 v2, T3 v3,
16404     T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
16405     T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
16406     T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,
16407     T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,
16408     T37 v37) {
16409   return internal::ValueArray37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16410       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16411       T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37>(v1, v2, v3,
16412       v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
16413       v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,
16414       v34, v35, v36, v37);
16415 }
16416 
16417 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16418     typename T6, typename T7, typename T8, typename T9, typename T10,
16419     typename T11, typename T12, typename T13, typename T14, typename T15,
16420     typename T16, typename T17, typename T18, typename T19, typename T20,
16421     typename T21, typename T22, typename T23, typename T24, typename T25,
16422     typename T26, typename T27, typename T28, typename T29, typename T30,
16423     typename T31, typename T32, typename T33, typename T34, typename T35,
16424     typename T36, typename T37, typename T38>
16425 internal::ValueArray38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16426     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16427     T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> Values(T1 v1, T2 v2,
16428     T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
16429     T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
16430     T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,
16431     T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,
16432     T37 v37, T38 v38) {
16433   return internal::ValueArray38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16434       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16435       T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38>(v1, v2,
16436       v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,
16437       v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32,
16438       v33, v34, v35, v36, v37, v38);
16439 }
16440 
16441 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16442     typename T6, typename T7, typename T8, typename T9, typename T10,
16443     typename T11, typename T12, typename T13, typename T14, typename T15,
16444     typename T16, typename T17, typename T18, typename T19, typename T20,
16445     typename T21, typename T22, typename T23, typename T24, typename T25,
16446     typename T26, typename T27, typename T28, typename T29, typename T30,
16447     typename T31, typename T32, typename T33, typename T34, typename T35,
16448     typename T36, typename T37, typename T38, typename T39>
16449 internal::ValueArray39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16450     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16451     T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Values(T1 v1, T2 v2,
16452     T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,
16453     T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,
16454     T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,
16455     T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,
16456     T37 v37, T38 v38, T39 v39) {
16457   return internal::ValueArray39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16458       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16459       T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39>(v1,
16460       v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17,
16461       v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
16462       v32, v33, v34, v35, v36, v37, v38, v39);
16463 }
16464 
16465 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16466     typename T6, typename T7, typename T8, typename T9, typename T10,
16467     typename T11, typename T12, typename T13, typename T14, typename T15,
16468     typename T16, typename T17, typename T18, typename T19, typename T20,
16469     typename T21, typename T22, typename T23, typename T24, typename T25,
16470     typename T26, typename T27, typename T28, typename T29, typename T30,
16471     typename T31, typename T32, typename T33, typename T34, typename T35,
16472     typename T36, typename T37, typename T38, typename T39, typename T40>
16473 internal::ValueArray40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16474     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16475     T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Values(T1 v1,
16476     T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11,
16477     T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19,
16478     T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27,
16479     T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35,
16480     T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) {
16481   return internal::ValueArray40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16482       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16483       T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
16484       T40>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
16485       v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29,
16486       v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40);
16487 }
16488 
16489 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16490     typename T6, typename T7, typename T8, typename T9, typename T10,
16491     typename T11, typename T12, typename T13, typename T14, typename T15,
16492     typename T16, typename T17, typename T18, typename T19, typename T20,
16493     typename T21, typename T22, typename T23, typename T24, typename T25,
16494     typename T26, typename T27, typename T28, typename T29, typename T30,
16495     typename T31, typename T32, typename T33, typename T34, typename T35,
16496     typename T36, typename T37, typename T38, typename T39, typename T40,
16497     typename T41>
16498 internal::ValueArray41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16499     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16500     T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40,
16501     T41> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
16502     T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
16503     T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
16504     T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
16505     T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41) {
16506   return internal::ValueArray41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16507       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16508       T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
16509       T40, T41>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14,
16510       v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28,
16511       v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41);
16512 }
16513 
16514 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16515     typename T6, typename T7, typename T8, typename T9, typename T10,
16516     typename T11, typename T12, typename T13, typename T14, typename T15,
16517     typename T16, typename T17, typename T18, typename T19, typename T20,
16518     typename T21, typename T22, typename T23, typename T24, typename T25,
16519     typename T26, typename T27, typename T28, typename T29, typename T30,
16520     typename T31, typename T32, typename T33, typename T34, typename T35,
16521     typename T36, typename T37, typename T38, typename T39, typename T40,
16522     typename T41, typename T42>
16523 internal::ValueArray42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16524     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16525     T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41,
16526     T42> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
16527     T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
16528     T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
16529     T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
16530     T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
16531     T42 v42) {
16532   return internal::ValueArray42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16533       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16534       T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
16535       T40, T41, T42>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,
16536       v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27,
16537       v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41,
16538       v42);
16539 }
16540 
16541 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16542     typename T6, typename T7, typename T8, typename T9, typename T10,
16543     typename T11, typename T12, typename T13, typename T14, typename T15,
16544     typename T16, typename T17, typename T18, typename T19, typename T20,
16545     typename T21, typename T22, typename T23, typename T24, typename T25,
16546     typename T26, typename T27, typename T28, typename T29, typename T30,
16547     typename T31, typename T32, typename T33, typename T34, typename T35,
16548     typename T36, typename T37, typename T38, typename T39, typename T40,
16549     typename T41, typename T42, typename T43>
16550 internal::ValueArray43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16551     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16552     T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42,
16553     T43> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
16554     T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
16555     T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
16556     T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
16557     T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
16558     T42 v42, T43 v43) {
16559   return internal::ValueArray43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16560       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16561       T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
16562       T40, T41, T42, T43>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,
16563       v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26,
16564       v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40,
16565       v41, v42, v43);
16566 }
16567 
16568 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16569     typename T6, typename T7, typename T8, typename T9, typename T10,
16570     typename T11, typename T12, typename T13, typename T14, typename T15,
16571     typename T16, typename T17, typename T18, typename T19, typename T20,
16572     typename T21, typename T22, typename T23, typename T24, typename T25,
16573     typename T26, typename T27, typename T28, typename T29, typename T30,
16574     typename T31, typename T32, typename T33, typename T34, typename T35,
16575     typename T36, typename T37, typename T38, typename T39, typename T40,
16576     typename T41, typename T42, typename T43, typename T44>
16577 internal::ValueArray44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16578     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16579     T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
16580     T44> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,
16581     T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,
16582     T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,
16583     T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33,
16584     T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41,
16585     T42 v42, T43 v43, T44 v44) {
16586   return internal::ValueArray44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16587       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16588       T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
16589       T40, T41, T42, T43, T44>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,
16590       v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25,
16591       v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39,
16592       v40, v41, v42, v43, v44);
16593 }
16594 
16595 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16596     typename T6, typename T7, typename T8, typename T9, typename T10,
16597     typename T11, typename T12, typename T13, typename T14, typename T15,
16598     typename T16, typename T17, typename T18, typename T19, typename T20,
16599     typename T21, typename T22, typename T23, typename T24, typename T25,
16600     typename T26, typename T27, typename T28, typename T29, typename T30,
16601     typename T31, typename T32, typename T33, typename T34, typename T35,
16602     typename T36, typename T37, typename T38, typename T39, typename T40,
16603     typename T41, typename T42, typename T43, typename T44, typename T45>
16604 internal::ValueArray45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16605     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16606     T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
16607     T44, T45> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,
16608     T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,
16609     T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,
16610     T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32,
16611     T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40,
16612     T41 v41, T42 v42, T43 v43, T44 v44, T45 v45) {
16613   return internal::ValueArray45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16614       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16615       T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
16616       T40, T41, T42, T43, T44, T45>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,
16617       v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24,
16618       v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38,
16619       v39, v40, v41, v42, v43, v44, v45);
16620 }
16621 
16622 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16623     typename T6, typename T7, typename T8, typename T9, typename T10,
16624     typename T11, typename T12, typename T13, typename T14, typename T15,
16625     typename T16, typename T17, typename T18, typename T19, typename T20,
16626     typename T21, typename T22, typename T23, typename T24, typename T25,
16627     typename T26, typename T27, typename T28, typename T29, typename T30,
16628     typename T31, typename T32, typename T33, typename T34, typename T35,
16629     typename T36, typename T37, typename T38, typename T39, typename T40,
16630     typename T41, typename T42, typename T43, typename T44, typename T45,
16631     typename T46>
16632 internal::ValueArray46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16633     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16634     T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
16635     T44, T45, T46> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
16636     T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
16637     T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
16638     T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
16639     T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39,
16640     T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) {
16641   return internal::ValueArray46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16642       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16643       T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
16644       T40, T41, T42, T43, T44, T45, T46>(v1, v2, v3, v4, v5, v6, v7, v8, v9,
16645       v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
16646       v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37,
16647       v38, v39, v40, v41, v42, v43, v44, v45, v46);
16648 }
16649 
16650 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16651     typename T6, typename T7, typename T8, typename T9, typename T10,
16652     typename T11, typename T12, typename T13, typename T14, typename T15,
16653     typename T16, typename T17, typename T18, typename T19, typename T20,
16654     typename T21, typename T22, typename T23, typename T24, typename T25,
16655     typename T26, typename T27, typename T28, typename T29, typename T30,
16656     typename T31, typename T32, typename T33, typename T34, typename T35,
16657     typename T36, typename T37, typename T38, typename T39, typename T40,
16658     typename T41, typename T42, typename T43, typename T44, typename T45,
16659     typename T46, typename T47>
16660 internal::ValueArray47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16661     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16662     T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
16663     T44, T45, T46, T47> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,
16664     T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
16665     T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
16666     T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
16667     T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39,
16668     T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) {
16669   return internal::ValueArray47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16670       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16671       T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
16672       T40, T41, T42, T43, T44, T45, T46, T47>(v1, v2, v3, v4, v5, v6, v7, v8,
16673       v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,
16674       v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37,
16675       v38, v39, v40, v41, v42, v43, v44, v45, v46, v47);
16676 }
16677 
16678 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16679     typename T6, typename T7, typename T8, typename T9, typename T10,
16680     typename T11, typename T12, typename T13, typename T14, typename T15,
16681     typename T16, typename T17, typename T18, typename T19, typename T20,
16682     typename T21, typename T22, typename T23, typename T24, typename T25,
16683     typename T26, typename T27, typename T28, typename T29, typename T30,
16684     typename T31, typename T32, typename T33, typename T34, typename T35,
16685     typename T36, typename T37, typename T38, typename T39, typename T40,
16686     typename T41, typename T42, typename T43, typename T44, typename T45,
16687     typename T46, typename T47, typename T48>
16688 internal::ValueArray48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16689     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16690     T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
16691     T44, T45, T46, T47, T48> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,
16692     T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,
16693     T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,
16694     T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,
16695     T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39,
16696     T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47,
16697     T48 v48) {
16698   return internal::ValueArray48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16699       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16700       T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
16701       T40, T41, T42, T43, T44, T45, T46, T47, T48>(v1, v2, v3, v4, v5, v6, v7,
16702       v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22,
16703       v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36,
16704       v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48);
16705 }
16706 
16707 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16708     typename T6, typename T7, typename T8, typename T9, typename T10,
16709     typename T11, typename T12, typename T13, typename T14, typename T15,
16710     typename T16, typename T17, typename T18, typename T19, typename T20,
16711     typename T21, typename T22, typename T23, typename T24, typename T25,
16712     typename T26, typename T27, typename T28, typename T29, typename T30,
16713     typename T31, typename T32, typename T33, typename T34, typename T35,
16714     typename T36, typename T37, typename T38, typename T39, typename T40,
16715     typename T41, typename T42, typename T43, typename T44, typename T45,
16716     typename T46, typename T47, typename T48, typename T49>
16717 internal::ValueArray49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16718     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16719     T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
16720     T44, T45, T46, T47, T48, T49> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,
16721     T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,
16722     T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22,
16723     T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30,
16724     T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38,
16725     T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46,
16726     T47 v47, T48 v48, T49 v49) {
16727   return internal::ValueArray49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16728       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16729       T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
16730       T40, T41, T42, T43, T44, T45, T46, T47, T48, T49>(v1, v2, v3, v4, v5, v6,
16731       v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,
16732       v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35,
16733       v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49);
16734 }
16735 
16736 template <typename T1, typename T2, typename T3, typename T4, typename T5,
16737     typename T6, typename T7, typename T8, typename T9, typename T10,
16738     typename T11, typename T12, typename T13, typename T14, typename T15,
16739     typename T16, typename T17, typename T18, typename T19, typename T20,
16740     typename T21, typename T22, typename T23, typename T24, typename T25,
16741     typename T26, typename T27, typename T28, typename T29, typename T30,
16742     typename T31, typename T32, typename T33, typename T34, typename T35,
16743     typename T36, typename T37, typename T38, typename T39, typename T40,
16744     typename T41, typename T42, typename T43, typename T44, typename T45,
16745     typename T46, typename T47, typename T48, typename T49, typename T50>
16746 internal::ValueArray50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
16747     T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,
16748     T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43,
16749     T44, T45, T46, T47, T48, T49, T50> Values(T1 v1, T2 v2, T3 v3, T4 v4,
16750     T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,
16751     T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,
16752     T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,
16753     T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37,
16754     T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45,
16755     T46 v46, T47 v47, T48 v48, T49 v49, T50 v50) {
16756   return internal::ValueArray50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
16757       T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,
16758       T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39,
16759       T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50>(v1, v2, v3, v4,
16760       v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
16761       v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,
16762       v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47,
16763       v48, v49, v50);
16764 }
16765 
16766 // Bool() allows generating tests with parameters in a set of (false, true).
16767 //
16768 // Synopsis:
16769 // Bool()
16770 //   - returns a generator producing sequences with elements {false, true}.
16771 //
16772 // It is useful when testing code that depends on Boolean flags. Combinations
16773 // of multiple flags can be tested when several Bool()'s are combined using
16774 // Combine() function.
16775 //
16776 // In the following example all tests in the test case FlagDependentTest
16777 // will be instantiated twice with parameters false and true.
16778 //
16779 // class FlagDependentTest : public testing::TestWithParam<bool> {
16780 //   virtual void SetUp() {
16781 //     external_flag = GetParam();
16782 //   }
16783 // }
16784 // INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool());
16785 //
16786 inline internal::ParamGenerator<bool> Bool() {
16787   return Values(false, true);
16788 }
16789 
16790 # if GTEST_HAS_COMBINE
16791 // Combine() allows the user to combine two or more sequences to produce
16792 // values of a Cartesian product of those sequences' elements.
16793 //
16794 // Synopsis:
16795 // Combine(gen1, gen2, ..., genN)
16796 //   - returns a generator producing sequences with elements coming from
16797 //     the Cartesian product of elements from the sequences generated by
16798 //     gen1, gen2, ..., genN. The sequence elements will have a type of
16799 //     tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
16800 //     of elements from sequences produces by gen1, gen2, ..., genN.
16801 //
16802 // Combine can have up to 10 arguments. This number is currently limited
16803 // by the maximum number of elements in the tuple implementation used by Google
16804 // Test.
16805 //
16806 // Example:
16807 //
16808 // This will instantiate tests in test case AnimalTest each one with
16809 // the parameter values tuple("cat", BLACK), tuple("cat", WHITE),
16810 // tuple("dog", BLACK), and tuple("dog", WHITE):
16811 //
16812 // enum Color { BLACK, GRAY, WHITE };
16813 // class AnimalTest
16814 //     : public testing::TestWithParam<tuple<const char*, Color> > {...};
16815 //
16816 // TEST_P(AnimalTest, AnimalLooksNice) {...}
16817 //
16818 // INSTANTIATE_TEST_CASE_P(AnimalVariations, AnimalTest,
16819 //                         Combine(Values("cat", "dog"),
16820 //                                 Values(BLACK, WHITE)));
16821 //
16822 // This will instantiate tests in FlagDependentTest with all variations of two
16823 // Boolean flags:
16824 //
16825 // class FlagDependentTest
16826 //     : public testing::TestWithParam<tuple<bool, bool> > {
16827 //   virtual void SetUp() {
16828 //     // Assigns external_flag_1 and external_flag_2 values from the tuple.
16829 //     tie(external_flag_1, external_flag_2) = GetParam();
16830 //   }
16831 // };
16832 //
16833 // TEST_P(FlagDependentTest, TestFeature1) {
16834 //   // Test your code using external_flag_1 and external_flag_2 here.
16835 // }
16836 // INSTANTIATE_TEST_CASE_P(TwoBoolSequence, FlagDependentTest,
16837 //                         Combine(Bool(), Bool()));
16838 //
16839 template <typename Generator1, typename Generator2>
16840 internal::CartesianProductHolder2<Generator1, Generator2> Combine(
16841     const Generator1& g1, const Generator2& g2) {
16842   return internal::CartesianProductHolder2<Generator1, Generator2>(
16843       g1, g2);
16844 }
16845 
16846 template <typename Generator1, typename Generator2, typename Generator3>
16847 internal::CartesianProductHolder3<Generator1, Generator2, Generator3> Combine(
16848     const Generator1& g1, const Generator2& g2, const Generator3& g3) {
16849   return internal::CartesianProductHolder3<Generator1, Generator2, Generator3>(
16850       g1, g2, g3);
16851 }
16852 
16853 template <typename Generator1, typename Generator2, typename Generator3,
16854     typename Generator4>
16855 internal::CartesianProductHolder4<Generator1, Generator2, Generator3,
16856     Generator4> Combine(
16857     const Generator1& g1, const Generator2& g2, const Generator3& g3,
16858         const Generator4& g4) {
16859   return internal::CartesianProductHolder4<Generator1, Generator2, Generator3,
16860       Generator4>(
16861       g1, g2, g3, g4);
16862 }
16863 
16864 template <typename Generator1, typename Generator2, typename Generator3,
16865     typename Generator4, typename Generator5>
16866 internal::CartesianProductHolder5<Generator1, Generator2, Generator3,
16867     Generator4, Generator5> Combine(
16868     const Generator1& g1, const Generator2& g2, const Generator3& g3,
16869         const Generator4& g4, const Generator5& g5) {
16870   return internal::CartesianProductHolder5<Generator1, Generator2, Generator3,
16871       Generator4, Generator5>(
16872       g1, g2, g3, g4, g5);
16873 }
16874 
16875 template <typename Generator1, typename Generator2, typename Generator3,
16876     typename Generator4, typename Generator5, typename Generator6>
16877 internal::CartesianProductHolder6<Generator1, Generator2, Generator3,
16878     Generator4, Generator5, Generator6> Combine(
16879     const Generator1& g1, const Generator2& g2, const Generator3& g3,
16880         const Generator4& g4, const Generator5& g5, const Generator6& g6) {
16881   return internal::CartesianProductHolder6<Generator1, Generator2, Generator3,
16882       Generator4, Generator5, Generator6>(
16883       g1, g2, g3, g4, g5, g6);
16884 }
16885 
16886 template <typename Generator1, typename Generator2, typename Generator3,
16887     typename Generator4, typename Generator5, typename Generator6,
16888     typename Generator7>
16889 internal::CartesianProductHolder7<Generator1, Generator2, Generator3,
16890     Generator4, Generator5, Generator6, Generator7> Combine(
16891     const Generator1& g1, const Generator2& g2, const Generator3& g3,
16892         const Generator4& g4, const Generator5& g5, const Generator6& g6,
16893         const Generator7& g7) {
16894   return internal::CartesianProductHolder7<Generator1, Generator2, Generator3,
16895       Generator4, Generator5, Generator6, Generator7>(
16896       g1, g2, g3, g4, g5, g6, g7);
16897 }
16898 
16899 template <typename Generator1, typename Generator2, typename Generator3,
16900     typename Generator4, typename Generator5, typename Generator6,
16901     typename Generator7, typename Generator8>
16902 internal::CartesianProductHolder8<Generator1, Generator2, Generator3,
16903     Generator4, Generator5, Generator6, Generator7, Generator8> Combine(
16904     const Generator1& g1, const Generator2& g2, const Generator3& g3,
16905         const Generator4& g4, const Generator5& g5, const Generator6& g6,
16906         const Generator7& g7, const Generator8& g8) {
16907   return internal::CartesianProductHolder8<Generator1, Generator2, Generator3,
16908       Generator4, Generator5, Generator6, Generator7, Generator8>(
16909       g1, g2, g3, g4, g5, g6, g7, g8);
16910 }
16911 
16912 template <typename Generator1, typename Generator2, typename Generator3,
16913     typename Generator4, typename Generator5, typename Generator6,
16914     typename Generator7, typename Generator8, typename Generator9>
16915 internal::CartesianProductHolder9<Generator1, Generator2, Generator3,
16916     Generator4, Generator5, Generator6, Generator7, Generator8,
16917     Generator9> Combine(
16918     const Generator1& g1, const Generator2& g2, const Generator3& g3,
16919         const Generator4& g4, const Generator5& g5, const Generator6& g6,
16920         const Generator7& g7, const Generator8& g8, const Generator9& g9) {
16921   return internal::CartesianProductHolder9<Generator1, Generator2, Generator3,
16922       Generator4, Generator5, Generator6, Generator7, Generator8, Generator9>(
16923       g1, g2, g3, g4, g5, g6, g7, g8, g9);
16924 }
16925 
16926 template <typename Generator1, typename Generator2, typename Generator3,
16927     typename Generator4, typename Generator5, typename Generator6,
16928     typename Generator7, typename Generator8, typename Generator9,
16929     typename Generator10>
16930 internal::CartesianProductHolder10<Generator1, Generator2, Generator3,
16931     Generator4, Generator5, Generator6, Generator7, Generator8, Generator9,
16932     Generator10> Combine(
16933     const Generator1& g1, const Generator2& g2, const Generator3& g3,
16934         const Generator4& g4, const Generator5& g5, const Generator6& g6,
16935         const Generator7& g7, const Generator8& g8, const Generator9& g9,
16936         const Generator10& g10) {
16937   return internal::CartesianProductHolder10<Generator1, Generator2, Generator3,
16938       Generator4, Generator5, Generator6, Generator7, Generator8, Generator9,
16939       Generator10>(
16940       g1, g2, g3, g4, g5, g6, g7, g8, g9, g10);
16941 }
16942 # endif  // GTEST_HAS_COMBINE
16943 
16944 
16945 
16946 # define TEST_P(test_case_name, test_name) \
16947   class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
16948       : public test_case_name { \
16949    public: \
16950     GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \
16951     virtual void TestBody(); \
16952    private: \
16953     static int AddToRegistry() { \
16954       ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
16955           GetTestCasePatternHolder<test_case_name>(\
16956               #test_case_name, __FILE__, __LINE__)->AddTestPattern(\
16957                   #test_case_name, \
16958                   #test_name, \
16959                   new ::testing::internal::TestMetaFactory< \
16960                       GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>()); \
16961       return 0; \
16962     } \
16963     static int gtest_registering_dummy_; \
16964     GTEST_DISALLOW_COPY_AND_ASSIGN_(\
16965         GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \
16966   }; \
16967   int GTEST_TEST_CLASS_NAME_(test_case_name, \
16968                              test_name)::gtest_registering_dummy_ = \
16969       GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \
16970   void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()
16971 
16972 # define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator) \
16973   ::testing::internal::ParamGenerator<test_case_name::ParamType> \
16974       gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \
16975   int gtest_##prefix##test_case_name##_dummy_ = \
16976       ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
16977           GetTestCasePatternHolder<test_case_name>(\
16978               #test_case_name, __FILE__, __LINE__)->AddTestCaseInstantiation(\
16979                   #prefix, \
16980                   &gtest_##prefix##test_case_name##_EvalGenerator_, \
16981                   __FILE__, __LINE__)
16982 
16983 }  // namespace testing
16984 
16985 #endif  // GTEST_HAS_PARAM_TEST
16986 
16987 #endif  // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
16988 // Copyright 2006, Google Inc.
16989 // All rights reserved.
16990 //
16991 // Redistribution and use in source and binary forms, with or without
16992 // modification, are permitted provided that the following conditions are
16993 // met:
16994 //
16995 //     * Redistributions of source code must retain the above copyright
16996 // notice, this list of conditions and the following disclaimer.
16997 //     * Redistributions in binary form must reproduce the above
16998 // copyright notice, this list of conditions and the following disclaimer
16999 // in the documentation and/or other materials provided with the
17000 // distribution.
17001 //     * Neither the name of Google Inc. nor the names of its
17002 // contributors may be used to endorse or promote products derived from
17003 // this software without specific prior written permission.
17004 //
17005 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17006 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17007 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
17008 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
17009 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
17010 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
17011 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
17012 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
17013 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
17014 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
17015 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
17016 //
17017 // Author: wan@google.com (Zhanyong Wan)
17018 //
17019 // Google C++ Testing Framework definitions useful in production code.
17020 
17021 #ifndef GTEST_INCLUDE_GTEST_GTEST_PROD_H_
17022 #define GTEST_INCLUDE_GTEST_GTEST_PROD_H_
17023 
17024 // When you need to test the private or protected members of a class,
17025 // use the FRIEND_TEST macro to declare your tests as friends of the
17026 // class.  For example:
17027 //
17028 // class MyClass {
17029 //  private:
17030 //   void MyMethod();
17031 //   FRIEND_TEST(MyClassTest, MyMethod);
17032 // };
17033 //
17034 // class MyClassTest : public testing::Test {
17035 //   // ...
17036 // };
17037 //
17038 // TEST_F(MyClassTest, MyMethod) {
17039 //   // Can call MyClass::MyMethod() here.
17040 // }
17041 
17042 #define FRIEND_TEST(test_case_name, test_name)\
17043 friend class test_case_name##_##test_name##_Test
17044 
17045 #endif  // GTEST_INCLUDE_GTEST_GTEST_PROD_H_
17046 // Copyright 2008, Google Inc.
17047 // All rights reserved.
17048 //
17049 // Redistribution and use in source and binary forms, with or without
17050 // modification, are permitted provided that the following conditions are
17051 // met:
17052 //
17053 //     * Redistributions of source code must retain the above copyright
17054 // notice, this list of conditions and the following disclaimer.
17055 //     * Redistributions in binary form must reproduce the above
17056 // copyright notice, this list of conditions and the following disclaimer
17057 // in the documentation and/or other materials provided with the
17058 // distribution.
17059 //     * Neither the name of Google Inc. nor the names of its
17060 // contributors may be used to endorse or promote products derived from
17061 // this software without specific prior written permission.
17062 //
17063 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17064 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17065 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
17066 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
17067 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
17068 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
17069 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
17070 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
17071 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
17072 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
17073 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
17074 //
17075 // Author: mheule@google.com (Markus Heule)
17076 //
17077 
17078 #ifndef GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
17079 #define GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
17080 
17081 #include <iosfwd>
17082 #include <vector>
17083 
17084 namespace testing {
17085 
17086 // A copyable object representing the result of a test part (i.e. an
17087 // assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()).
17088 //
17089 // Don't inherit from TestPartResult as its destructor is not virtual.
17090 class GTEST_API_ TestPartResult {
17091  public:
17092   // The possible outcomes of a test part (i.e. an assertion or an
17093   // explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
17094   enum Type {
17095     kSuccess,          // Succeeded.
17096     kNonFatalFailure,  // Failed but the test can continue.
17097     kFatalFailure      // Failed and the test should be terminated.
17098   };
17099 
17100   // C'tor.  TestPartResult does NOT have a default constructor.
17101   // Always use this constructor (with parameters) to create a
17102   // TestPartResult object.
17103   TestPartResult(Type a_type,
17104                  const char* a_file_name,
17105                  int a_line_number,
17106                  const char* a_message)
17107       : type_(a_type),
17108         file_name_(a_file_name == NULL ? "" : a_file_name),
17109         line_number_(a_line_number),
17110         summary_(ExtractSummary(a_message)),
17111         message_(a_message) {
17112   }
17113 
17114   // Gets the outcome of the test part.
17115   Type type() const { return type_; }
17116 
17117   // Gets the name of the source file where the test part took place, or
17118   // NULL if it's unknown.
17119   const char* file_name() const {
17120     return file_name_.empty() ? NULL : file_name_.c_str();
17121   }
17122 
17123   // Gets the line in the source file where the test part took place,
17124   // or -1 if it's unknown.
17125   int line_number() const { return line_number_; }
17126 
17127   // Gets the summary of the failure message.
17128   const char* summary() const { return summary_.c_str(); }
17129 
17130   // Gets the message associated with the test part.
17131   const char* message() const { return message_.c_str(); }
17132 
17133   // Returns true iff the test part passed.
17134   bool passed() const { return type_ == kSuccess; }
17135 
17136   // Returns true iff the test part failed.
17137   bool failed() const { return type_ != kSuccess; }
17138 
17139   // Returns true iff the test part non-fatally failed.
17140   bool nonfatally_failed() const { return type_ == kNonFatalFailure; }
17141 
17142   // Returns true iff the test part fatally failed.
17143   bool fatally_failed() const { return type_ == kFatalFailure; }
17144 
17145  private:
17146   Type type_;
17147 
17148   // Gets the summary of the failure message by omitting the stack
17149   // trace in it.
17150   static std::string ExtractSummary(const char* message);
17151 
17152   // The name of the source file where the test part took place, or
17153   // "" if the source file is unknown.
17154   std::string file_name_;
17155   // The line in the source file where the test part took place, or -1
17156   // if the line number is unknown.
17157   int line_number_;
17158   std::string summary_;  // The test failure summary.
17159   std::string message_;  // The test failure message.
17160 };
17161 
17162 // Prints a TestPartResult object.
17163 std::ostream& operator<<(std::ostream& os, const TestPartResult& result);
17164 
17165 // An array of TestPartResult objects.
17166 //
17167 // Don't inherit from TestPartResultArray as its destructor is not
17168 // virtual.
17169 class GTEST_API_ TestPartResultArray {
17170  public:
17171   TestPartResultArray() {}
17172 
17173   // Appends the given TestPartResult to the array.
17174   void Append(const TestPartResult& result);
17175 
17176   // Returns the TestPartResult at the given index (0-based).
17177   const TestPartResult& GetTestPartResult(int index) const;
17178 
17179   // Returns the number of TestPartResult objects in the array.
17180   int size() const;
17181 
17182  private:
17183   std::vector<TestPartResult> array_;
17184 
17185   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray);
17186 };
17187 
17188 // This interface knows how to report a test part result.
17189 class TestPartResultReporterInterface {
17190  public:
17191   virtual ~TestPartResultReporterInterface() {}
17192 
17193   virtual void ReportTestPartResult(const TestPartResult& result) = 0;
17194 };
17195 
17196 namespace internal {
17197 
17198 // This helper class is used by {ASSERT|EXPECT}_NO_FATAL_FAILURE to check if a
17199 // statement generates new fatal failures. To do so it registers itself as the
17200 // current test part result reporter. Besides checking if fatal failures were
17201 // reported, it only delegates the reporting to the former result reporter.
17202 // The original result reporter is restored in the destructor.
17203 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
17204 class GTEST_API_ HasNewFatalFailureHelper
17205     : public TestPartResultReporterInterface {
17206  public:
17207   HasNewFatalFailureHelper();
17208   virtual ~HasNewFatalFailureHelper();
17209   virtual void ReportTestPartResult(const TestPartResult& result);
17210   bool has_new_fatal_failure() const { return has_new_fatal_failure_; }
17211  private:
17212   bool has_new_fatal_failure_;
17213   TestPartResultReporterInterface* original_reporter_;
17214 
17215   GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper);
17216 };
17217 
17218 }  // namespace internal
17219 
17220 }  // namespace testing
17221 
17222 #endif  // GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
17223 // Copyright 2008 Google Inc.
17224 // All Rights Reserved.
17225 //
17226 // Redistribution and use in source and binary forms, with or without
17227 // modification, are permitted provided that the following conditions are
17228 // met:
17229 //
17230 //     * Redistributions of source code must retain the above copyright
17231 // notice, this list of conditions and the following disclaimer.
17232 //     * Redistributions in binary form must reproduce the above
17233 // copyright notice, this list of conditions and the following disclaimer
17234 // in the documentation and/or other materials provided with the
17235 // distribution.
17236 //     * Neither the name of Google Inc. nor the names of its
17237 // contributors may be used to endorse or promote products derived from
17238 // this software without specific prior written permission.
17239 //
17240 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17241 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17242 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
17243 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
17244 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
17245 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
17246 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
17247 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
17248 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
17249 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
17250 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
17251 //
17252 // Author: wan@google.com (Zhanyong Wan)
17253 
17254 #ifndef GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
17255 #define GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
17256 
17257 // This header implements typed tests and type-parameterized tests.
17258 
17259 // Typed (aka type-driven) tests repeat the same test for types in a
17260 // list.  You must know which types you want to test with when writing
17261 // typed tests. Here's how you do it:
17262 
17263 #if 0
17264 
17265 // First, define a fixture class template.  It should be parameterized
17266 // by a type.  Remember to derive it from testing::Test.
17267 template <typename T>
17268 class FooTest : public testing::Test {
17269  public:
17270   ...
17271   typedef std::list<T> List;
17272   static T shared_;
17273   T value_;
17274 };
17275 
17276 // Next, associate a list of types with the test case, which will be
17277 // repeated for each type in the list.  The typedef is necessary for
17278 // the macro to parse correctly.
17279 typedef testing::Types<char, int, unsigned int> MyTypes;
17280 TYPED_TEST_CASE(FooTest, MyTypes);
17281 
17282 // If the type list contains only one type, you can write that type
17283 // directly without Types<...>:
17284 //   TYPED_TEST_CASE(FooTest, int);
17285 
17286 // Then, use TYPED_TEST() instead of TEST_F() to define as many typed
17287 // tests for this test case as you want.
17288 TYPED_TEST(FooTest, DoesBlah) {
17289   // Inside a test, refer to TypeParam to get the type parameter.
17290   // Since we are inside a derived class template, C++ requires use to
17291   // visit the members of FooTest via 'this'.
17292   TypeParam n = this->value_;
17293 
17294   // To visit static members of the fixture, add the TestFixture::
17295   // prefix.
17296   n += TestFixture::shared_;
17297 
17298   // To refer to typedefs in the fixture, add the "typename
17299   // TestFixture::" prefix.
17300   typename TestFixture::List values;
17301   values.push_back(n);
17302   ...
17303 }
17304 
17305 TYPED_TEST(FooTest, HasPropertyA) { ... }
17306 
17307 #endif  // 0
17308 
17309 // Type-parameterized tests are abstract test patterns parameterized
17310 // by a type.  Compared with typed tests, type-parameterized tests
17311 // allow you to define the test pattern without knowing what the type
17312 // parameters are.  The defined pattern can be instantiated with
17313 // different types any number of times, in any number of translation
17314 // units.
17315 //
17316 // If you are designing an interface or concept, you can define a
17317 // suite of type-parameterized tests to verify properties that any
17318 // valid implementation of the interface/concept should have.  Then,
17319 // each implementation can easily instantiate the test suite to verify
17320 // that it conforms to the requirements, without having to write
17321 // similar tests repeatedly.  Here's an example:
17322 
17323 #if 0
17324 
17325 // First, define a fixture class template.  It should be parameterized
17326 // by a type.  Remember to derive it from testing::Test.
17327 template <typename T>
17328 class FooTest : public testing::Test {
17329   ...
17330 };
17331 
17332 // Next, declare that you will define a type-parameterized test case
17333 // (the _P suffix is for "parameterized" or "pattern", whichever you
17334 // prefer):
17335 TYPED_TEST_CASE_P(FooTest);
17336 
17337 // Then, use TYPED_TEST_P() to define as many type-parameterized tests
17338 // for this type-parameterized test case as you want.
17339 TYPED_TEST_P(FooTest, DoesBlah) {
17340   // Inside a test, refer to TypeParam to get the type parameter.
17341   TypeParam n = 0;
17342   ...
17343 }
17344 
17345 TYPED_TEST_P(FooTest, HasPropertyA) { ... }
17346 
17347 // Now the tricky part: you need to register all test patterns before
17348 // you can instantiate them.  The first argument of the macro is the
17349 // test case name; the rest are the names of the tests in this test
17350 // case.
17351 REGISTER_TYPED_TEST_CASE_P(FooTest,
17352                            DoesBlah, HasPropertyA);
17353 
17354 // Finally, you are free to instantiate the pattern with the types you
17355 // want.  If you put the above code in a header file, you can #include
17356 // it in multiple C++ source files and instantiate it multiple times.
17357 //
17358 // To distinguish different instances of the pattern, the first
17359 // argument to the INSTANTIATE_* macro is a prefix that will be added
17360 // to the actual test case name.  Remember to pick unique prefixes for
17361 // different instances.
17362 typedef testing::Types<char, int, unsigned int> MyTypes;
17363 INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes);
17364 
17365 // If the type list contains only one type, you can write that type
17366 // directly without Types<...>:
17367 //   INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
17368 
17369 #endif  // 0
17370 
17371 
17372 // Implements typed tests.
17373 
17374 #if GTEST_HAS_TYPED_TEST
17375 
17376 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
17377 //
17378 // Expands to the name of the typedef for the type parameters of the
17379 // given test case.
17380 # define GTEST_TYPE_PARAMS_(TestCaseName) gtest_type_params_##TestCaseName##_
17381 
17382 // The 'Types' template argument below must have spaces around it
17383 // since some compilers may choke on '>>' when passing a template
17384 // instance (e.g. Types<int>)
17385 # define TYPED_TEST_CASE(CaseName, Types) \
17386   typedef ::testing::internal::TypeList< Types >::type \
17387       GTEST_TYPE_PARAMS_(CaseName)
17388 
17389 # define TYPED_TEST(CaseName, TestName) \
17390   template <typename gtest_TypeParam_> \
17391   class GTEST_TEST_CLASS_NAME_(CaseName, TestName) \
17392       : public CaseName<gtest_TypeParam_> { \
17393    private: \
17394     typedef CaseName<gtest_TypeParam_> TestFixture; \
17395     typedef gtest_TypeParam_ TypeParam; \
17396     virtual void TestBody(); \
17397   }; \
17398   bool gtest_##CaseName##_##TestName##_registered_ GTEST_ATTRIBUTE_UNUSED_ = \
17399       ::testing::internal::TypeParameterizedTest< \
17400           CaseName, \
17401           ::testing::internal::TemplateSel< \
17402               GTEST_TEST_CLASS_NAME_(CaseName, TestName)>, \
17403           GTEST_TYPE_PARAMS_(CaseName)>::Register(\
17404               "", #CaseName, #TestName, 0); \
17405   template <typename gtest_TypeParam_> \
17406   void GTEST_TEST_CLASS_NAME_(CaseName, TestName)<gtest_TypeParam_>::TestBody()
17407 
17408 #endif  // GTEST_HAS_TYPED_TEST
17409 
17410 // Implements type-parameterized tests.
17411 
17412 #if GTEST_HAS_TYPED_TEST_P
17413 
17414 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
17415 //
17416 // Expands to the namespace name that the type-parameterized tests for
17417 // the given type-parameterized test case are defined in.  The exact
17418 // name of the namespace is subject to change without notice.
17419 # define GTEST_CASE_NAMESPACE_(TestCaseName) \
17420   gtest_case_##TestCaseName##_
17421 
17422 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
17423 //
17424 // Expands to the name of the variable used to remember the names of
17425 // the defined tests in the given test case.
17426 # define GTEST_TYPED_TEST_CASE_P_STATE_(TestCaseName) \
17427   gtest_typed_test_case_p_state_##TestCaseName##_
17428 
17429 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY.
17430 //
17431 // Expands to the name of the variable used to remember the names of
17432 // the registered tests in the given test case.
17433 # define GTEST_REGISTERED_TEST_NAMES_(TestCaseName) \
17434   gtest_registered_test_names_##TestCaseName##_
17435 
17436 // The variables defined in the type-parameterized test macros are
17437 // static as typically these macros are used in a .h file that can be
17438 // #included in multiple translation units linked together.
17439 # define TYPED_TEST_CASE_P(CaseName) \
17440   static ::testing::internal::TypedTestCasePState \
17441       GTEST_TYPED_TEST_CASE_P_STATE_(CaseName)
17442 
17443 # define TYPED_TEST_P(CaseName, TestName) \
17444   namespace GTEST_CASE_NAMESPACE_(CaseName) { \
17445   template <typename gtest_TypeParam_> \
17446   class TestName : public CaseName<gtest_TypeParam_> { \
17447    private: \
17448     typedef CaseName<gtest_TypeParam_> TestFixture; \
17449     typedef gtest_TypeParam_ TypeParam; \
17450     virtual void TestBody(); \
17451   }; \
17452   static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
17453       GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).AddTestName(\
17454           __FILE__, __LINE__, #CaseName, #TestName); \
17455   } \
17456   template <typename gtest_TypeParam_> \
17457   void GTEST_CASE_NAMESPACE_(CaseName)::TestName<gtest_TypeParam_>::TestBody()
17458 
17459 # define REGISTER_TYPED_TEST_CASE_P(CaseName, ...) \
17460   namespace GTEST_CASE_NAMESPACE_(CaseName) { \
17461   typedef ::testing::internal::Templates<__VA_ARGS__>::type gtest_AllTests_; \
17462   } \
17463   static const char* const GTEST_REGISTERED_TEST_NAMES_(CaseName) = \
17464       GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).VerifyRegisteredTestNames(\
17465           __FILE__, __LINE__, #__VA_ARGS__)
17466 
17467 // The 'Types' template argument below must have spaces around it
17468 // since some compilers may choke on '>>' when passing a template
17469 // instance (e.g. Types<int>)
17470 # define INSTANTIATE_TYPED_TEST_CASE_P(Prefix, CaseName, Types) \
17471   bool gtest_##Prefix##_##CaseName GTEST_ATTRIBUTE_UNUSED_ = \
17472       ::testing::internal::TypeParameterizedTestCase<CaseName, \
17473           GTEST_CASE_NAMESPACE_(CaseName)::gtest_AllTests_, \
17474           ::testing::internal::TypeList< Types >::type>::Register(\
17475               #Prefix, #CaseName, GTEST_REGISTERED_TEST_NAMES_(CaseName))
17476 
17477 #endif  // GTEST_HAS_TYPED_TEST_P
17478 
17479 #endif  // GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
17480 
17481 // Depending on the platform, different string classes are available.
17482 // On Linux, in addition to ::std::string, Google also makes use of
17483 // class ::string, which has the same interface as ::std::string, but
17484 // has a different implementation.
17485 //
17486 // The user can define GTEST_HAS_GLOBAL_STRING to 1 to indicate that
17487 // ::string is available AND is a distinct type to ::std::string, or
17488 // define it to 0 to indicate otherwise.
17489 //
17490 // If the user's ::std::string and ::string are the same class due to
17491 // aliasing, he should define GTEST_HAS_GLOBAL_STRING to 0.
17492 //
17493 // If the user doesn't define GTEST_HAS_GLOBAL_STRING, it is defined
17494 // heuristically.
17495 
17496 namespace testing {
17497 
17498 // Declares the flags.
17499 
17500 // This flag temporary enables the disabled tests.
17501 GTEST_DECLARE_bool_(also_run_disabled_tests);
17502 
17503 // This flag brings the debugger on an assertion failure.
17504 GTEST_DECLARE_bool_(break_on_failure);
17505 
17506 // This flag controls whether Google Test catches all test-thrown exceptions
17507 // and logs them as failures.
17508 GTEST_DECLARE_bool_(catch_exceptions);
17509 
17510 // This flag enables using colors in terminal output. Available values are
17511 // "yes" to enable colors, "no" (disable colors), or "auto" (the default)
17512 // to let Google Test decide.
17513 GTEST_DECLARE_string_(color);
17514 
17515 // This flag sets up the filter to select by name using a glob pattern
17516 // the tests to run. If the filter is not given all tests are executed.
17517 GTEST_DECLARE_string_(filter);
17518 
17519 // This flag causes the Google Test to list tests. None of the tests listed
17520 // are actually run if the flag is provided.
17521 GTEST_DECLARE_bool_(list_tests);
17522 
17523 // This flag controls whether Google Test emits a detailed XML report to a file
17524 // in addition to its normal textual output.
17525 GTEST_DECLARE_string_(output);
17526 
17527 // This flags control whether Google Test prints the elapsed time for each
17528 // test.
17529 GTEST_DECLARE_bool_(print_time);
17530 
17531 // This flag specifies the random number seed.
17532 GTEST_DECLARE_int32_(random_seed);
17533 
17534 // This flag sets how many times the tests are repeated. The default value
17535 // is 1. If the value is -1 the tests are repeating forever.
17536 GTEST_DECLARE_int32_(repeat);
17537 
17538 // This flag controls whether Google Test includes Google Test internal
17539 // stack frames in failure stack traces.
17540 GTEST_DECLARE_bool_(show_internal_stack_frames);
17541 
17542 // When this flag is specified, tests' order is randomized on every iteration.
17543 GTEST_DECLARE_bool_(shuffle);
17544 
17545 // This flag specifies the maximum number of stack frames to be
17546 // printed in a failure message.
17547 GTEST_DECLARE_int32_(stack_trace_depth);
17548 
17549 // When this flag is specified, a failed assertion will throw an
17550 // exception if exceptions are enabled, or exit the program with a
17551 // non-zero code otherwise.
17552 GTEST_DECLARE_bool_(throw_on_failure);
17553 
17554 // When this flag is set with a "host:port" string, on supported
17555 // platforms test results are streamed to the specified port on
17556 // the specified host machine.
17557 GTEST_DECLARE_string_(stream_result_to);
17558 
17559 // The upper limit for valid stack trace depths.
17560 const int kMaxStackTraceDepth = 100;
17561 
17562 namespace internal {
17563 
17564 class AssertHelper;
17565 class DefaultGlobalTestPartResultReporter;
17566 class ExecDeathTest;
17567 class NoExecDeathTest;
17568 class FinalSuccessChecker;
17569 class GTestFlagSaver;
17570 class StreamingListenerTest;
17571 class TestResultAccessor;
17572 class TestEventListenersAccessor;
17573 class TestEventRepeater;
17574 class UnitTestRecordPropertyTestHelper;
17575 class WindowsDeathTest;
17576 class UnitTestImpl* GetUnitTestImpl();
17577 void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
17578                                     const std::string& message);
17579 
17580 }  // namespace internal
17581 
17582 // The friend relationship of some of these classes is cyclic.
17583 // If we don't forward declare them the compiler might confuse the classes
17584 // in friendship clauses with same named classes on the scope.
17585 class Test;
17586 class TestCase;
17587 class TestInfo;
17588 class UnitTest;
17589 
17590 // A class for indicating whether an assertion was successful.  When
17591 // the assertion wasn't successful, the AssertionResult object
17592 // remembers a non-empty message that describes how it failed.
17593 //
17594 // To create an instance of this class, use one of the factory functions
17595 // (AssertionSuccess() and AssertionFailure()).
17596 //
17597 // This class is useful for two purposes:
17598 //   1. Defining predicate functions to be used with Boolean test assertions
17599 //      EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts
17600 //   2. Defining predicate-format functions to be
17601 //      used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
17602 //
17603 // For example, if you define IsEven predicate:
17604 //
17605 //   testing::AssertionResult IsEven(int n) {
17606 //     if ((n % 2) == 0)
17607 //       return testing::AssertionSuccess();
17608 //     else
17609 //       return testing::AssertionFailure() << n << " is odd";
17610 //   }
17611 //
17612 // Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))
17613 // will print the message
17614 //
17615 //   Value of: IsEven(Fib(5))
17616 //     Actual: false (5 is odd)
17617 //   Expected: true
17618 //
17619 // instead of a more opaque
17620 //
17621 //   Value of: IsEven(Fib(5))
17622 //     Actual: false
17623 //   Expected: true
17624 //
17625 // in case IsEven is a simple Boolean predicate.
17626 //
17627 // If you expect your predicate to be reused and want to support informative
17628 // messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up
17629 // about half as often as positive ones in our tests), supply messages for
17630 // both success and failure cases:
17631 //
17632 //   testing::AssertionResult IsEven(int n) {
17633 //     if ((n % 2) == 0)
17634 //       return testing::AssertionSuccess() << n << " is even";
17635 //     else
17636 //       return testing::AssertionFailure() << n << " is odd";
17637 //   }
17638 //
17639 // Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print
17640 //
17641 //   Value of: IsEven(Fib(6))
17642 //     Actual: true (8 is even)
17643 //   Expected: false
17644 //
17645 // NB: Predicates that support negative Boolean assertions have reduced
17646 // performance in positive ones so be careful not to use them in tests
17647 // that have lots (tens of thousands) of positive Boolean assertions.
17648 //
17649 // To use this class with EXPECT_PRED_FORMAT assertions such as:
17650 //
17651 //   // Verifies that Foo() returns an even number.
17652 //   EXPECT_PRED_FORMAT1(IsEven, Foo());
17653 //
17654 // you need to define:
17655 //
17656 //   testing::AssertionResult IsEven(const char* expr, int n) {
17657 //     if ((n % 2) == 0)
17658 //       return testing::AssertionSuccess();
17659 //     else
17660 //       return testing::AssertionFailure()
17661 //         << "Expected: " << expr << " is even\n  Actual: it's " << n;
17662 //   }
17663 //
17664 // If Foo() returns 5, you will see the following message:
17665 //
17666 //   Expected: Foo() is even
17667 //     Actual: it's 5
17668 //
17669 class GTEST_API_ AssertionResult {
17670  public:
17671   // Copy constructor.
17672   // Used in EXPECT_TRUE/FALSE(assertion_result).
17673   AssertionResult(const AssertionResult& other);
17674   // Used in the EXPECT_TRUE/FALSE(bool_expression).
17675   explicit AssertionResult(bool success) : success_(success) {}
17676 
17677   // Returns true iff the assertion succeeded.
17678   operator bool() const { return success_; }  // NOLINT
17679 
17680   // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
17681   AssertionResult operator!() const;
17682 
17683   // Returns the text streamed into this AssertionResult. Test assertions
17684   // use it when they fail (i.e., the predicate's outcome doesn't match the
17685   // assertion's expectation). When nothing has been streamed into the
17686   // object, returns an empty string.
17687   const char* message() const {
17688     return message_.get() != NULL ?  message_->c_str() : "";
17689   }
17690   // TODO(vladl@google.com): Remove this after making sure no clients use it.
17691   // Deprecated; please use message() instead.
17692   const char* failure_message() const { return message(); }
17693 
17694   // Streams a custom failure message into this object.
17695   template <typename T> AssertionResult& operator<<(const T& value) {
17696     AppendMessage(Message() << value);
17697     return *this;
17698   }
17699 
17700   // Allows streaming basic output manipulators such as endl or flush into
17701   // this object.
17702   AssertionResult& operator<<(
17703       ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
17704     AppendMessage(Message() << basic_manipulator);
17705     return *this;
17706   }
17707 
17708  private:
17709   // Appends the contents of message to message_.
17710   void AppendMessage(const Message& a_message) {
17711     if (message_.get() == NULL)
17712       message_.reset(new ::std::string);
17713     message_->append(a_message.GetString().c_str());
17714   }
17715 
17716   // Stores result of the assertion predicate.
17717   bool success_;
17718   // Stores the message describing the condition in case the expectation
17719   // construct is not satisfied with the predicate's outcome.
17720   // Referenced via a pointer to avoid taking too much stack frame space
17721   // with test assertions.
17722   internal::scoped_ptr< ::std::string> message_;
17723 
17724   GTEST_DISALLOW_ASSIGN_(AssertionResult);
17725 };
17726 
17727 // Makes a successful assertion result.
17728 GTEST_API_ AssertionResult AssertionSuccess();
17729 
17730 // Makes a failed assertion result.
17731 GTEST_API_ AssertionResult AssertionFailure();
17732 
17733 // Makes a failed assertion result with the given failure message.
17734 // Deprecated; use AssertionFailure() << msg.
17735 GTEST_API_ AssertionResult AssertionFailure(const Message& msg);
17736 
17737 // The abstract class that all tests inherit from.
17738 //
17739 // In Google Test, a unit test program contains one or many TestCases, and
17740 // each TestCase contains one or many Tests.
17741 //
17742 // When you define a test using the TEST macro, you don't need to
17743 // explicitly derive from Test - the TEST macro automatically does
17744 // this for you.
17745 //
17746 // The only time you derive from Test is when defining a test fixture
17747 // to be used a TEST_F.  For example:
17748 //
17749 //   class FooTest : public testing::Test {
17750 //    protected:
17751 //     virtual void SetUp() { ... }
17752 //     virtual void TearDown() { ... }
17753 //     ...
17754 //   };
17755 //
17756 //   TEST_F(FooTest, Bar) { ... }
17757 //   TEST_F(FooTest, Baz) { ... }
17758 //
17759 // Test is not copyable.
17760 class GTEST_API_ Test {
17761  public:
17762   friend class TestInfo;
17763 
17764   // Defines types for pointers to functions that set up and tear down
17765   // a test case.
17766   typedef internal::SetUpTestCaseFunc SetUpTestCaseFunc;
17767   typedef internal::TearDownTestCaseFunc TearDownTestCaseFunc;
17768 
17769   // The d'tor is virtual as we intend to inherit from Test.
17770   virtual ~Test();
17771 
17772   // Sets up the stuff shared by all tests in this test case.
17773   //
17774   // Google Test will call Foo::SetUpTestCase() before running the first
17775   // test in test case Foo.  Hence a sub-class can define its own
17776   // SetUpTestCase() method to shadow the one defined in the super
17777   // class.
17778   static void SetUpTestCase() {}
17779 
17780   // Tears down the stuff shared by all tests in this test case.
17781   //
17782   // Google Test will call Foo::TearDownTestCase() after running the last
17783   // test in test case Foo.  Hence a sub-class can define its own
17784   // TearDownTestCase() method to shadow the one defined in the super
17785   // class.
17786   static void TearDownTestCase() {}
17787 
17788   // Returns true iff the current test has a fatal failure.
17789   static bool HasFatalFailure();
17790 
17791   // Returns true iff the current test has a non-fatal failure.
17792   static bool HasNonfatalFailure();
17793 
17794   // Returns true iff the current test has a (either fatal or
17795   // non-fatal) failure.
17796   static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); }
17797 
17798   // Logs a property for the current test, test case, or for the entire
17799   // invocation of the test program when used outside of the context of a
17800   // test case.  Only the last value for a given key is remembered.  These
17801   // are public static so they can be called from utility functions that are
17802   // not members of the test fixture.  Calls to RecordProperty made during
17803   // lifespan of the test (from the moment its constructor starts to the
17804   // moment its destructor finishes) will be output in XML as attributes of
17805   // the <testcase> element.  Properties recorded from fixture's
17806   // SetUpTestCase or TearDownTestCase are logged as attributes of the
17807   // corresponding <testsuite> element.  Calls to RecordProperty made in the
17808   // global context (before or after invocation of RUN_ALL_TESTS and from
17809   // SetUp/TearDown method of Environment objects registered with Google
17810   // Test) will be output as attributes of the <testsuites> element.
17811   static void RecordProperty(const std::string& key, const std::string& value);
17812   static void RecordProperty(const std::string& key, int value);
17813 
17814  protected:
17815   // Creates a Test object.
17816   Test();
17817 
17818   // Sets up the test fixture.
17819   virtual void SetUp();
17820 
17821   // Tears down the test fixture.
17822   virtual void TearDown();
17823 
17824  private:
17825   // Returns true iff the current test has the same fixture class as
17826   // the first test in the current test case.
17827   static bool HasSameFixtureClass();
17828 
17829   // Runs the test after the test fixture has been set up.
17830   //
17831   // A sub-class must implement this to define the test logic.
17832   //
17833   // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM.
17834   // Instead, use the TEST or TEST_F macro.
17835   virtual void TestBody() = 0;
17836 
17837   // Sets up, executes, and tears down the test.
17838   void Run();
17839 
17840   // Deletes self.  We deliberately pick an unusual name for this
17841   // internal method to avoid clashing with names used in user TESTs.
17842   void DeleteSelf_() { delete this; }
17843 
17844   // Uses a GTestFlagSaver to save and restore all Google Test flags.
17845   const internal::GTestFlagSaver* const gtest_flag_saver_;
17846 
17847   // Often a user mis-spells SetUp() as Setup() and spends a long time
17848   // wondering why it is never called by Google Test.  The declaration of
17849   // the following method is solely for catching such an error at
17850   // compile time:
17851   //
17852   //   - The return type is deliberately chosen to be not void, so it
17853   //   will be a conflict if a user declares void Setup() in his test
17854   //   fixture.
17855   //
17856   //   - This method is private, so it will be another compiler error
17857   //   if a user calls it from his test fixture.
17858   //
17859   // DO NOT OVERRIDE THIS FUNCTION.
17860   //
17861   // If you see an error about overriding the following function or
17862   // about it being private, you have mis-spelled SetUp() as Setup().
17863   struct Setup_should_be_spelled_SetUp {};
17864   virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
17865 
17866   // We disallow copying Tests.
17867   GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
17868 };
17869 
17870 typedef internal::TimeInMillis TimeInMillis;
17871 
17872 // A copyable object representing a user specified test property which can be
17873 // output as a key/value string pair.
17874 //
17875 // Don't inherit from TestProperty as its destructor is not virtual.
17876 class TestProperty {
17877  public:
17878   // C'tor.  TestProperty does NOT have a default constructor.
17879   // Always use this constructor (with parameters) to create a
17880   // TestProperty object.
17881   TestProperty(const std::string& a_key, const std::string& a_value) :
17882     key_(a_key), value_(a_value) {
17883   }
17884 
17885   // Gets the user supplied key.
17886   const char* key() const {
17887     return key_.c_str();
17888   }
17889 
17890   // Gets the user supplied value.
17891   const char* value() const {
17892     return value_.c_str();
17893   }
17894 
17895   // Sets a new value, overriding the one supplied in the constructor.
17896   void SetValue(const std::string& new_value) {
17897     value_ = new_value;
17898   }
17899 
17900  private:
17901   // The key supplied by the user.
17902   std::string key_;
17903   // The value supplied by the user.
17904   std::string value_;
17905 };
17906 
17907 // The result of a single Test.  This includes a list of
17908 // TestPartResults, a list of TestProperties, a count of how many
17909 // death tests there are in the Test, and how much time it took to run
17910 // the Test.
17911 //
17912 // TestResult is not copyable.
17913 class GTEST_API_ TestResult {
17914  public:
17915   // Creates an empty TestResult.
17916   TestResult();
17917 
17918   // D'tor.  Do not inherit from TestResult.
17919   ~TestResult();
17920 
17921   // Gets the number of all test parts.  This is the sum of the number
17922   // of successful test parts and the number of failed test parts.
17923   int total_part_count() const;
17924 
17925   // Returns the number of the test properties.
17926   int test_property_count() const;
17927 
17928   // Returns true iff the test passed (i.e. no test part failed).
17929   bool Passed() const { return !Failed(); }
17930 
17931   // Returns true iff the test failed.
17932   bool Failed() const;
17933 
17934   // Returns true iff the test fatally failed.
17935   bool HasFatalFailure() const;
17936 
17937   // Returns true iff the test has a non-fatal failure.
17938   bool HasNonfatalFailure() const;
17939 
17940   // Returns the elapsed time, in milliseconds.
17941   TimeInMillis elapsed_time() const { return elapsed_time_; }
17942 
17943   // Returns the i-th test part result among all the results. i can range
17944   // from 0 to test_property_count() - 1. If i is not in that range, aborts
17945   // the program.
17946   const TestPartResult& GetTestPartResult(int i) const;
17947 
17948   // Returns the i-th test property. i can range from 0 to
17949   // test_property_count() - 1. If i is not in that range, aborts the
17950   // program.
17951   const TestProperty& GetTestProperty(int i) const;
17952 
17953  private:
17954   friend class TestInfo;
17955   friend class TestCase;
17956   friend class UnitTest;
17957   friend class internal::DefaultGlobalTestPartResultReporter;
17958   friend class internal::ExecDeathTest;
17959   friend class internal::TestResultAccessor;
17960   friend class internal::UnitTestImpl;
17961   friend class internal::WindowsDeathTest;
17962 
17963   // Gets the vector of TestPartResults.
17964   const std::vector<TestPartResult>& test_part_results() const {
17965     return test_part_results_;
17966   }
17967 
17968   // Gets the vector of TestProperties.
17969   const std::vector<TestProperty>& test_properties() const {
17970     return test_properties_;
17971   }
17972 
17973   // Sets the elapsed time.
17974   void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }
17975 
17976   // Adds a test property to the list. The property is validated and may add
17977   // a non-fatal failure if invalid (e.g., if it conflicts with reserved
17978   // key names). If a property is already recorded for the same key, the
17979   // value will be updated, rather than storing multiple values for the same
17980   // key.  xml_element specifies the element for which the property is being
17981   // recorded and is used for validation.
17982   void RecordProperty(const std::string& xml_element,
17983                       const TestProperty& test_property);
17984 
17985   // Adds a failure if the key is a reserved attribute of Google Test
17986   // testcase tags.  Returns true if the property is valid.
17987   // TODO(russr): Validate attribute names are legal and human readable.
17988   static bool ValidateTestProperty(const std::string& xml_element,
17989                                    const TestProperty& test_property);
17990 
17991   // Adds a test part result to the list.
17992   void AddTestPartResult(const TestPartResult& test_part_result);
17993 
17994   // Returns the death test count.
17995   int death_test_count() const { return death_test_count_; }
17996 
17997   // Increments the death test count, returning the new count.
17998   int increment_death_test_count() { return ++death_test_count_; }
17999 
18000   // Clears the test part results.
18001   void ClearTestPartResults();
18002 
18003   // Clears the object.
18004   void Clear();
18005 
18006   // Protects mutable state of the property vector and of owned
18007   // properties, whose values may be updated.
18008   internal::Mutex test_properites_mutex_;
18009 
18010   // The vector of TestPartResults
18011   std::vector<TestPartResult> test_part_results_;
18012   // The vector of TestProperties
18013   std::vector<TestProperty> test_properties_;
18014   // Running count of death tests.
18015   int death_test_count_;
18016   // The elapsed time, in milliseconds.
18017   TimeInMillis elapsed_time_;
18018 
18019   // We disallow copying TestResult.
18020   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult);
18021 };  // class TestResult
18022 
18023 // A TestInfo object stores the following information about a test:
18024 //
18025 //   Test case name
18026 //   Test name
18027 //   Whether the test should be run
18028 //   A function pointer that creates the test object when invoked
18029 //   Test result
18030 //
18031 // The constructor of TestInfo registers itself with the UnitTest
18032 // singleton such that the RUN_ALL_TESTS() macro knows which tests to
18033 // run.
18034 class GTEST_API_ TestInfo {
18035  public:
18036   // Destructs a TestInfo object.  This function is not virtual, so
18037   // don't inherit from TestInfo.
18038   ~TestInfo();
18039 
18040   // Returns the test case name.
18041   const char* test_case_name() const { return test_case_name_.c_str(); }
18042 
18043   // Returns the test name.
18044   const char* name() const { return name_.c_str(); }
18045 
18046   // Returns the name of the parameter type, or NULL if this is not a typed
18047   // or a type-parameterized test.
18048   const char* type_param() const {
18049     if (type_param_.get() != NULL)
18050       return type_param_->c_str();
18051     return NULL;
18052   }
18053 
18054   // Returns the text representation of the value parameter, or NULL if this
18055   // is not a value-parameterized test.
18056   const char* value_param() const {
18057     if (value_param_.get() != NULL)
18058       return value_param_->c_str();
18059     return NULL;
18060   }
18061 
18062   // Returns true if this test should run, that is if the test is not
18063   // disabled (or it is disabled but the also_run_disabled_tests flag has
18064   // been specified) and its full name matches the user-specified filter.
18065   //
18066   // Google Test allows the user to filter the tests by their full names.
18067   // The full name of a test Bar in test case Foo is defined as
18068   // "Foo.Bar".  Only the tests that match the filter will run.
18069   //
18070   // A filter is a colon-separated list of glob (not regex) patterns,
18071   // optionally followed by a '-' and a colon-separated list of
18072   // negative patterns (tests to exclude).  A test is run if it
18073   // matches one of the positive patterns and does not match any of
18074   // the negative patterns.
18075   //
18076   // For example, *A*:Foo.* is a filter that matches any string that
18077   // contains the character 'A' or starts with "Foo.".
18078   bool should_run() const { return should_run_; }
18079 
18080   // Returns true iff this test will appear in the XML report.
18081   bool is_reportable() const {
18082     // For now, the XML report includes all tests matching the filter.
18083     // In the future, we may trim tests that are excluded because of
18084     // sharding.
18085     return matches_filter_;
18086   }
18087 
18088   // Returns the result of the test.
18089   const TestResult* result() const { return &result_; }
18090 
18091  private:
18092 #if GTEST_HAS_DEATH_TEST
18093   friend class internal::DefaultDeathTestFactory;
18094 #endif  // GTEST_HAS_DEATH_TEST
18095   friend class Test;
18096   friend class TestCase;
18097   friend class internal::UnitTestImpl;
18098   friend class internal::StreamingListenerTest;
18099   friend TestInfo* internal::MakeAndRegisterTestInfo(
18100       const char* test_case_name,
18101       const char* name,
18102       const char* type_param,
18103       const char* value_param,
18104       internal::TypeId fixture_class_id,
18105       Test::SetUpTestCaseFunc set_up_tc,
18106       Test::TearDownTestCaseFunc tear_down_tc,
18107       internal::TestFactoryBase* factory);
18108 
18109   // Constructs a TestInfo object. The newly constructed instance assumes
18110   // ownership of the factory object.
18111   TestInfo(const std::string& test_case_name,
18112            const std::string& name,
18113            const char* a_type_param,   // NULL if not a type-parameterized test
18114            const char* a_value_param,  // NULL if not a value-parameterized test
18115            internal::TypeId fixture_class_id,
18116            internal::TestFactoryBase* factory);
18117 
18118   // Increments the number of death tests encountered in this test so
18119   // far.
18120   int increment_death_test_count() {
18121     return result_.increment_death_test_count();
18122   }
18123 
18124   // Creates the test object, runs it, records its result, and then
18125   // deletes it.
18126   void Run();
18127 
18128   static void ClearTestResult(TestInfo* test_info) {
18129     test_info->result_.Clear();
18130   }
18131 
18132   // These fields are immutable properties of the test.
18133   const std::string test_case_name_;     // Test case name
18134   const std::string name_;               // Test name
18135   // Name of the parameter type, or NULL if this is not a typed or a
18136   // type-parameterized test.
18137   const internal::scoped_ptr<const ::std::string> type_param_;
18138   // Text representation of the value parameter, or NULL if this is not a
18139   // value-parameterized test.
18140   const internal::scoped_ptr<const ::std::string> value_param_;
18141   const internal::TypeId fixture_class_id_;   // ID of the test fixture class
18142   bool should_run_;                 // True iff this test should run
18143   bool is_disabled_;                // True iff this test is disabled
18144   bool matches_filter_;             // True if this test matches the
18145                                     // user-specified filter.
18146   internal::TestFactoryBase* const factory_;  // The factory that creates
18147                                               // the test object
18148 
18149   // This field is mutable and needs to be reset before running the
18150   // test for the second time.
18151   TestResult result_;
18152 
18153   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
18154 };
18155 
18156 // A test case, which consists of a vector of TestInfos.
18157 //
18158 // TestCase is not copyable.
18159 class GTEST_API_ TestCase {
18160  public:
18161   // Creates a TestCase with the given name.
18162   //
18163   // TestCase does NOT have a default constructor.  Always use this
18164   // constructor to create a TestCase object.
18165   //
18166   // Arguments:
18167   //
18168   //   name:         name of the test case
18169   //   a_type_param: the name of the test's type parameter, or NULL if
18170   //                 this is not a type-parameterized test.
18171   //   set_up_tc:    pointer to the function that sets up the test case
18172   //   tear_down_tc: pointer to the function that tears down the test case
18173   TestCase(const char* name, const char* a_type_param,
18174            Test::SetUpTestCaseFunc set_up_tc,
18175            Test::TearDownTestCaseFunc tear_down_tc);
18176 
18177   // Destructor of TestCase.
18178   virtual ~TestCase();
18179 
18180   // Gets the name of the TestCase.
18181   const char* name() const { return name_.c_str(); }
18182 
18183   // Returns the name of the parameter type, or NULL if this is not a
18184   // type-parameterized test case.
18185   const char* type_param() const {
18186     if (type_param_.get() != NULL)
18187       return type_param_->c_str();
18188     return NULL;
18189   }
18190 
18191   // Returns true if any test in this test case should run.
18192   bool should_run() const { return should_run_; }
18193 
18194   // Gets the number of successful tests in this test case.
18195   int successful_test_count() const;
18196 
18197   // Gets the number of failed tests in this test case.
18198   int failed_test_count() const;
18199 
18200   // Gets the number of disabled tests that will be reported in the XML report.
18201   int reportable_disabled_test_count() const;
18202 
18203   // Gets the number of disabled tests in this test case.
18204   int disabled_test_count() const;
18205 
18206   // Gets the number of tests to be printed in the XML report.
18207   int reportable_test_count() const;
18208 
18209   // Get the number of tests in this test case that should run.
18210   int test_to_run_count() const;
18211 
18212   // Gets the number of all tests in this test case.
18213   int total_test_count() const;
18214 
18215   // Returns true iff the test case passed.
18216   bool Passed() const { return !Failed(); }
18217 
18218   // Returns true iff the test case failed.
18219   bool Failed() const { return failed_test_count() > 0; }
18220 
18221   // Returns the elapsed time, in milliseconds.
18222   TimeInMillis elapsed_time() const { return elapsed_time_; }
18223 
18224   // Returns the i-th test among all the tests. i can range from 0 to
18225   // total_test_count() - 1. If i is not in that range, returns NULL.
18226   const TestInfo* GetTestInfo(int i) const;
18227 
18228   // Returns the TestResult that holds test properties recorded during
18229   // execution of SetUpTestCase and TearDownTestCase.
18230   const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; }
18231 
18232  private:
18233   friend class Test;
18234   friend class internal::UnitTestImpl;
18235 
18236   // Gets the (mutable) vector of TestInfos in this TestCase.
18237   std::vector<TestInfo*>& test_info_list() { return test_info_list_; }
18238 
18239   // Gets the (immutable) vector of TestInfos in this TestCase.
18240   const std::vector<TestInfo*>& test_info_list() const {
18241     return test_info_list_;
18242   }
18243 
18244   // Returns the i-th test among all the tests. i can range from 0 to
18245   // total_test_count() - 1. If i is not in that range, returns NULL.
18246   TestInfo* GetMutableTestInfo(int i);
18247 
18248   // Sets the should_run member.
18249   void set_should_run(bool should) { should_run_ = should; }
18250 
18251   // Adds a TestInfo to this test case.  Will delete the TestInfo upon
18252   // destruction of the TestCase object.
18253   void AddTestInfo(TestInfo * test_info);
18254 
18255   // Clears the results of all tests in this test case.
18256   void ClearResult();
18257 
18258   // Clears the results of all tests in the given test case.
18259   static void ClearTestCaseResult(TestCase* test_case) {
18260     test_case->ClearResult();
18261   }
18262 
18263   // Runs every test in this TestCase.
18264   void Run();
18265 
18266   // Runs SetUpTestCase() for this TestCase.  This wrapper is needed
18267   // for catching exceptions thrown from SetUpTestCase().
18268   void RunSetUpTestCase() { (*set_up_tc_)(); }
18269 
18270   // Runs TearDownTestCase() for this TestCase.  This wrapper is
18271   // needed for catching exceptions thrown from TearDownTestCase().
18272   void RunTearDownTestCase() { (*tear_down_tc_)(); }
18273 
18274   // Returns true iff test passed.
18275   static bool TestPassed(const TestInfo* test_info) {
18276     return test_info->should_run() && test_info->result()->Passed();
18277   }
18278 
18279   // Returns true iff test failed.
18280   static bool TestFailed(const TestInfo* test_info) {
18281     return test_info->should_run() && test_info->result()->Failed();
18282   }
18283 
18284   // Returns true iff the test is disabled and will be reported in the XML
18285   // report.
18286   static bool TestReportableDisabled(const TestInfo* test_info) {
18287     return test_info->is_reportable() && test_info->is_disabled_;
18288   }
18289 
18290   // Returns true iff test is disabled.
18291   static bool TestDisabled(const TestInfo* test_info) {
18292     return test_info->is_disabled_;
18293   }
18294 
18295   // Returns true iff this test will appear in the XML report.
18296   static bool TestReportable(const TestInfo* test_info) {
18297     return test_info->is_reportable();
18298   }
18299 
18300   // Returns true if the given test should run.
18301   static bool ShouldRunTest(const TestInfo* test_info) {
18302     return test_info->should_run();
18303   }
18304 
18305   // Shuffles the tests in this test case.
18306   void ShuffleTests(internal::Random* random);
18307 
18308   // Restores the test order to before the first shuffle.
18309   void UnshuffleTests();
18310 
18311   // Name of the test case.
18312   std::string name_;
18313   // Name of the parameter type, or NULL if this is not a typed or a
18314   // type-parameterized test.
18315   const internal::scoped_ptr<const ::std::string> type_param_;
18316   // The vector of TestInfos in their original order.  It owns the
18317   // elements in the vector.
18318   std::vector<TestInfo*> test_info_list_;
18319   // Provides a level of indirection for the test list to allow easy
18320   // shuffling and restoring the test order.  The i-th element in this
18321   // vector is the index of the i-th test in the shuffled test list.
18322   std::vector<int> test_indices_;
18323   // Pointer to the function that sets up the test case.
18324   Test::SetUpTestCaseFunc set_up_tc_;
18325   // Pointer to the function that tears down the test case.
18326   Test::TearDownTestCaseFunc tear_down_tc_;
18327   // True iff any test in this test case should run.
18328   bool should_run_;
18329   // Elapsed time, in milliseconds.
18330   TimeInMillis elapsed_time_;
18331   // Holds test properties recorded during execution of SetUpTestCase and
18332   // TearDownTestCase.
18333   TestResult ad_hoc_test_result_;
18334 
18335   // We disallow copying TestCases.
18336   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestCase);
18337 };
18338 
18339 // An Environment object is capable of setting up and tearing down an
18340 // environment.  The user should subclass this to define his own
18341 // environment(s).
18342 //
18343 // An Environment object does the set-up and tear-down in virtual
18344 // methods SetUp() and TearDown() instead of the constructor and the
18345 // destructor, as:
18346 //
18347 //   1. You cannot safely throw from a destructor.  This is a problem
18348 //      as in some cases Google Test is used where exceptions are enabled, and
18349 //      we may want to implement ASSERT_* using exceptions where they are
18350 //      available.
18351 //   2. You cannot use ASSERT_* directly in a constructor or
18352 //      destructor.
18353 class Environment {
18354  public:
18355   // The d'tor is virtual as we need to subclass Environment.
18356   virtual ~Environment() {}
18357 
18358   // Override this to define how to set up the environment.
18359   virtual void SetUp() {}
18360 
18361   // Override this to define how to tear down the environment.
18362   virtual void TearDown() {}
18363  private:
18364   // If you see an error about overriding the following function or
18365   // about it being private, you have mis-spelled SetUp() as Setup().
18366   struct Setup_should_be_spelled_SetUp {};
18367   virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; }
18368 };
18369 
18370 // The interface for tracing execution of tests. The methods are organized in
18371 // the order the corresponding events are fired.
18372 class TestEventListener {
18373  public:
18374   virtual ~TestEventListener() {}
18375 
18376   // Fired before any test activity starts.
18377   virtual void OnTestProgramStart(const UnitTest& unit_test) = 0;
18378 
18379   // Fired before each iteration of tests starts.  There may be more than
18380   // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration
18381   // index, starting from 0.
18382   virtual void OnTestIterationStart(const UnitTest& unit_test,
18383                                     int iteration) = 0;
18384 
18385   // Fired before environment set-up for each iteration of tests starts.
18386   virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0;
18387 
18388   // Fired after environment set-up for each iteration of tests ends.
18389   virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0;
18390 
18391   // Fired before the test case starts.
18392   virtual void OnTestCaseStart(const TestCase& test_case) = 0;
18393 
18394   // Fired before the test starts.
18395   virtual void OnTestStart(const TestInfo& test_info) = 0;
18396 
18397   // Fired after a failed assertion or a SUCCEED() invocation.
18398   virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0;
18399 
18400   // Fired after the test ends.
18401   virtual void OnTestEnd(const TestInfo& test_info) = 0;
18402 
18403   // Fired after the test case ends.
18404   virtual void OnTestCaseEnd(const TestCase& test_case) = 0;
18405 
18406   // Fired before environment tear-down for each iteration of tests starts.
18407   virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0;
18408 
18409   // Fired after environment tear-down for each iteration of tests ends.
18410   virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0;
18411 
18412   // Fired after each iteration of tests finishes.
18413   virtual void OnTestIterationEnd(const UnitTest& unit_test,
18414                                   int iteration) = 0;
18415 
18416   // Fired after all test activities have ended.
18417   virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0;
18418 };
18419 
18420 // The convenience class for users who need to override just one or two
18421 // methods and are not concerned that a possible change to a signature of
18422 // the methods they override will not be caught during the build.  For
18423 // comments about each method please see the definition of TestEventListener
18424 // above.
18425 class EmptyTestEventListener : public TestEventListener {
18426  public:
18427   virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
18428   virtual void OnTestIterationStart(const UnitTest& /*unit_test*/,
18429                                     int /*iteration*/) {}
18430   virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {}
18431   virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
18432   virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
18433   virtual void OnTestStart(const TestInfo& /*test_info*/) {}
18434   virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {}
18435   virtual void OnTestEnd(const TestInfo& /*test_info*/) {}
18436   virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
18437   virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {}
18438   virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {}
18439   virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/,
18440                                   int /*iteration*/) {}
18441   virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
18442 };
18443 
18444 // TestEventListeners lets users add listeners to track events in Google Test.
18445 class GTEST_API_ TestEventListeners {
18446  public:
18447   TestEventListeners();
18448   ~TestEventListeners();
18449 
18450   // Appends an event listener to the end of the list. Google Test assumes
18451   // the ownership of the listener (i.e. it will delete the listener when
18452   // the test program finishes).
18453   void Append(TestEventListener* listener);
18454 
18455   // Removes the given event listener from the list and returns it.  It then
18456   // becomes the caller's responsibility to delete the listener. Returns
18457   // NULL if the listener is not found in the list.
18458   TestEventListener* Release(TestEventListener* listener);
18459 
18460   // Returns the standard listener responsible for the default console
18461   // output.  Can be removed from the listeners list to shut down default
18462   // console output.  Note that removing this object from the listener list
18463   // with Release transfers its ownership to the caller and makes this
18464   // function return NULL the next time.
18465   TestEventListener* default_result_printer() const {
18466     return default_result_printer_;
18467   }
18468 
18469   // Returns the standard listener responsible for the default XML output
18470   // controlled by the --gtest_output=xml flag.  Can be removed from the
18471   // listeners list by users who want to shut down the default XML output
18472   // controlled by this flag and substitute it with custom one.  Note that
18473   // removing this object from the listener list with Release transfers its
18474   // ownership to the caller and makes this function return NULL the next
18475   // time.
18476   TestEventListener* default_xml_generator() const {
18477     return default_xml_generator_;
18478   }
18479 
18480  private:
18481   friend class TestCase;
18482   friend class TestInfo;
18483   friend class internal::DefaultGlobalTestPartResultReporter;
18484   friend class internal::NoExecDeathTest;
18485   friend class internal::TestEventListenersAccessor;
18486   friend class internal::UnitTestImpl;
18487 
18488   // Returns repeater that broadcasts the TestEventListener events to all
18489   // subscribers.
18490   TestEventListener* repeater();
18491 
18492   // Sets the default_result_printer attribute to the provided listener.
18493   // The listener is also added to the listener list and previous
18494   // default_result_printer is removed from it and deleted. The listener can
18495   // also be NULL in which case it will not be added to the list. Does
18496   // nothing if the previous and the current listener objects are the same.
18497   void SetDefaultResultPrinter(TestEventListener* listener);
18498 
18499   // Sets the default_xml_generator attribute to the provided listener.  The
18500   // listener is also added to the listener list and previous
18501   // default_xml_generator is removed from it and deleted. The listener can
18502   // also be NULL in which case it will not be added to the list. Does
18503   // nothing if the previous and the current listener objects are the same.
18504   void SetDefaultXmlGenerator(TestEventListener* listener);
18505 
18506   // Controls whether events will be forwarded by the repeater to the
18507   // listeners in the list.
18508   bool EventForwardingEnabled() const;
18509   void SuppressEventForwarding();
18510 
18511   // The actual list of listeners.
18512   internal::TestEventRepeater* repeater_;
18513   // Listener responsible for the standard result output.
18514   TestEventListener* default_result_printer_;
18515   // Listener responsible for the creation of the XML output file.
18516   TestEventListener* default_xml_generator_;
18517 
18518   // We disallow copying TestEventListeners.
18519   GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
18520 };
18521 
18522 // A UnitTest consists of a vector of TestCases.
18523 //
18524 // This is a singleton class.  The only instance of UnitTest is
18525 // created when UnitTest::GetInstance() is first called.  This
18526 // instance is never deleted.
18527 //
18528 // UnitTest is not copyable.
18529 //
18530 // This class is thread-safe as long as the methods are called
18531 // according to their specification.
18532 class GTEST_API_ UnitTest {
18533  public:
18534   // Gets the singleton UnitTest object.  The first time this method
18535   // is called, a UnitTest object is constructed and returned.
18536   // Consecutive calls will return the same object.
18537   static UnitTest* GetInstance();
18538 
18539   // Runs all tests in this UnitTest object and prints the result.
18540   // Returns 0 if successful, or 1 otherwise.
18541   //
18542   // This method can only be called from the main thread.
18543   //
18544   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
18545   int Run() GTEST_MUST_USE_RESULT_;
18546 
18547   // Returns the working directory when the first TEST() or TEST_F()
18548   // was executed.  The UnitTest object owns the string.
18549   const char* original_working_dir() const;
18550 
18551   // Returns the TestCase object for the test that's currently running,
18552   // or NULL if no test is running.
18553   const TestCase* current_test_case() const
18554       GTEST_LOCK_EXCLUDED_(mutex_);
18555 
18556   // Returns the TestInfo object for the test that's currently running,
18557   // or NULL if no test is running.
18558   const TestInfo* current_test_info() const
18559       GTEST_LOCK_EXCLUDED_(mutex_);
18560 
18561   // Returns the random seed used at the start of the current test run.
18562   int random_seed() const;
18563 
18564 #if GTEST_HAS_PARAM_TEST
18565   // Returns the ParameterizedTestCaseRegistry object used to keep track of
18566   // value-parameterized tests and instantiate and register them.
18567   //
18568   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
18569   internal::ParameterizedTestCaseRegistry& parameterized_test_registry()
18570       GTEST_LOCK_EXCLUDED_(mutex_);
18571 #endif  // GTEST_HAS_PARAM_TEST
18572 
18573   // Gets the number of successful test cases.
18574   int successful_test_case_count() const;
18575 
18576   // Gets the number of failed test cases.
18577   int failed_test_case_count() const;
18578 
18579   // Gets the number of all test cases.
18580   int total_test_case_count() const;
18581 
18582   // Gets the number of all test cases that contain at least one test
18583   // that should run.
18584   int test_case_to_run_count() const;
18585 
18586   // Gets the number of successful tests.
18587   int successful_test_count() const;
18588 
18589   // Gets the number of failed tests.
18590   int failed_test_count() const;
18591 
18592   // Gets the number of disabled tests that will be reported in the XML report.
18593   int reportable_disabled_test_count() const;
18594 
18595   // Gets the number of disabled tests.
18596   int disabled_test_count() const;
18597 
18598   // Gets the number of tests to be printed in the XML report.
18599   int reportable_test_count() const;
18600 
18601   // Gets the number of all tests.
18602   int total_test_count() const;
18603 
18604   // Gets the number of tests that should run.
18605   int test_to_run_count() const;
18606 
18607   // Gets the time of the test program start, in ms from the start of the
18608   // UNIX epoch.
18609   TimeInMillis start_timestamp() const;
18610 
18611   // Gets the elapsed time, in milliseconds.
18612   TimeInMillis elapsed_time() const;
18613 
18614   // Returns true iff the unit test passed (i.e. all test cases passed).
18615   bool Passed() const;
18616 
18617   // Returns true iff the unit test failed (i.e. some test case failed
18618   // or something outside of all tests failed).
18619   bool Failed() const;
18620 
18621   // Gets the i-th test case among all the test cases. i can range from 0 to
18622   // total_test_case_count() - 1. If i is not in that range, returns NULL.
18623   const TestCase* GetTestCase(int i) const;
18624 
18625   // Returns the TestResult containing information on test failures and
18626   // properties logged outside of individual test cases.
18627   const TestResult& ad_hoc_test_result() const;
18628 
18629   // Returns the list of event listeners that can be used to track events
18630   // inside Google Test.
18631   TestEventListeners& listeners();
18632 
18633  private:
18634   // Registers and returns a global test environment.  When a test
18635   // program is run, all global test environments will be set-up in
18636   // the order they were registered.  After all tests in the program
18637   // have finished, all global test environments will be torn-down in
18638   // the *reverse* order they were registered.
18639   //
18640   // The UnitTest object takes ownership of the given environment.
18641   //
18642   // This method can only be called from the main thread.
18643   Environment* AddEnvironment(Environment* env);
18644 
18645   // Adds a TestPartResult to the current TestResult object.  All
18646   // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc)
18647   // eventually call this to report their results.  The user code
18648   // should use the assertion macros instead of calling this directly.
18649   void AddTestPartResult(TestPartResult::Type result_type,
18650                          const char* file_name,
18651                          int line_number,
18652                          const std::string& message,
18653                          const std::string& os_stack_trace)
18654       GTEST_LOCK_EXCLUDED_(mutex_);
18655 
18656   // Adds a TestProperty to the current TestResult object when invoked from
18657   // inside a test, to current TestCase's ad_hoc_test_result_ when invoked
18658   // from SetUpTestCase or TearDownTestCase, or to the global property set
18659   // when invoked elsewhere.  If the result already contains a property with
18660   // the same key, the value will be updated.
18661   void RecordProperty(const std::string& key, const std::string& value);
18662 
18663   // Gets the i-th test case among all the test cases. i can range from 0 to
18664   // total_test_case_count() - 1. If i is not in that range, returns NULL.
18665   TestCase* GetMutableTestCase(int i);
18666 
18667   // Accessors for the implementation object.
18668   internal::UnitTestImpl* impl() { return impl_; }
18669   const internal::UnitTestImpl* impl() const { return impl_; }
18670 
18671   // These classes and funcions are friends as they need to access private
18672   // members of UnitTest.
18673   friend class Test;
18674   friend class internal::AssertHelper;
18675   friend class internal::ScopedTrace;
18676   friend class internal::StreamingListenerTest;
18677   friend class internal::UnitTestRecordPropertyTestHelper;
18678   friend Environment* AddGlobalTestEnvironment(Environment* env);
18679   friend internal::UnitTestImpl* internal::GetUnitTestImpl();
18680   friend void internal::ReportFailureInUnknownLocation(
18681       TestPartResult::Type result_type,
18682       const std::string& message);
18683 
18684   // Creates an empty UnitTest.
18685   UnitTest();
18686 
18687   // D'tor
18688   virtual ~UnitTest();
18689 
18690   // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
18691   // Google Test trace stack.
18692   void PushGTestTrace(const internal::TraceInfo& trace)
18693       GTEST_LOCK_EXCLUDED_(mutex_);
18694 
18695   // Pops a trace from the per-thread Google Test trace stack.
18696   void PopGTestTrace()
18697       GTEST_LOCK_EXCLUDED_(mutex_);
18698 
18699   // Protects mutable state in *impl_.  This is mutable as some const
18700   // methods need to lock it too.
18701   mutable internal::Mutex mutex_;
18702 
18703   // Opaque implementation object.  This field is never changed once
18704   // the object is constructed.  We don't mark it as const here, as
18705   // doing so will cause a warning in the constructor of UnitTest.
18706   // Mutable state in *impl_ is protected by mutex_.
18707   internal::UnitTestImpl* impl_;
18708 
18709   // We disallow copying UnitTest.
18710   GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest);
18711 };
18712 
18713 // A convenient wrapper for adding an environment for the test
18714 // program.
18715 //
18716 // You should call this before RUN_ALL_TESTS() is called, probably in
18717 // main().  If you use gtest_main, you need to call this before main()
18718 // starts for it to take effect.  For example, you can define a global
18719 // variable like this:
18720 //
18721 //   testing::Environment* const foo_env =
18722 //       testing::AddGlobalTestEnvironment(new FooEnvironment);
18723 //
18724 // However, we strongly recommend you to write your own main() and
18725 // call AddGlobalTestEnvironment() there, as relying on initialization
18726 // of global variables makes the code harder to read and may cause
18727 // problems when you register multiple environments from different
18728 // translation units and the environments have dependencies among them
18729 // (remember that the compiler doesn't guarantee the order in which
18730 // global variables from different translation units are initialized).
18731 inline Environment* AddGlobalTestEnvironment(Environment* env) {
18732   return UnitTest::GetInstance()->AddEnvironment(env);
18733 }
18734 
18735 // Initializes Google Test.  This must be called before calling
18736 // RUN_ALL_TESTS().  In particular, it parses a command line for the
18737 // flags that Google Test recognizes.  Whenever a Google Test flag is
18738 // seen, it is removed from argv, and *argc is decremented.
18739 //
18740 // No value is returned.  Instead, the Google Test flag variables are
18741 // updated.
18742 //
18743 // Calling the function for the second time has no user-visible effect.
18744 GTEST_API_ void InitGoogleTest(int* argc, char** argv);
18745 
18746 // This overloaded version can be used in Windows programs compiled in
18747 // UNICODE mode.
18748 GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);
18749 
18750 namespace internal {
18751 
18752 // FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
18753 // value of type ToPrint that is an operand of a comparison assertion
18754 // (e.g. ASSERT_EQ).  OtherOperand is the type of the other operand in
18755 // the comparison, and is used to help determine the best way to
18756 // format the value.  In particular, when the value is a C string
18757 // (char pointer) and the other operand is an STL string object, we
18758 // want to format the C string as a string, since we know it is
18759 // compared by value with the string object.  If the value is a char
18760 // pointer but the other operand is not an STL string object, we don't
18761 // know whether the pointer is supposed to point to a NUL-terminated
18762 // string, and thus want to print it as a pointer to be safe.
18763 //
18764 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
18765 
18766 // The default case.
18767 template <typename ToPrint, typename OtherOperand>
18768 class FormatForComparison {
18769  public:
18770   static ::std::string Format(const ToPrint& value) {
18771     return ::testing::PrintToString(value);
18772   }
18773 };
18774 
18775 // Array.
18776 template <typename ToPrint, size_t N, typename OtherOperand>
18777 class FormatForComparison<ToPrint[N], OtherOperand> {
18778  public:
18779   static ::std::string Format(const ToPrint* value) {
18780     return FormatForComparison<const ToPrint*, OtherOperand>::Format(value);
18781   }
18782 };
18783 
18784 // By default, print C string as pointers to be safe, as we don't know
18785 // whether they actually point to a NUL-terminated string.
18786 
18787 #define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType)                \
18788   template <typename OtherOperand>                                      \
18789   class FormatForComparison<CharType*, OtherOperand> {                  \
18790    public:                                                              \
18791     static ::std::string Format(CharType* value) {                      \
18792       return ::testing::PrintToString(static_cast<const void*>(value)); \
18793     }                                                                   \
18794   }
18795 
18796 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
18797 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
18798 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
18799 GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
18800 
18801 #undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
18802 
18803 // If a C string is compared with an STL string object, we know it's meant
18804 // to point to a NUL-terminated string, and thus can print it as a string.
18805 
18806 #define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
18807   template <>                                                           \
18808   class FormatForComparison<CharType*, OtherStringType> {               \
18809    public:                                                              \
18810     static ::std::string Format(CharType* value) {                      \
18811       return ::testing::PrintToString(value);                           \
18812     }                                                                   \
18813   }
18814 
18815 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
18816 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
18817 
18818 #if GTEST_HAS_GLOBAL_STRING
18819 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::string);
18820 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::string);
18821 #endif
18822 
18823 #if GTEST_HAS_GLOBAL_WSTRING
18824 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::wstring);
18825 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::wstring);
18826 #endif
18827 
18828 #if GTEST_HAS_STD_WSTRING
18829 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
18830 GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring);
18831 #endif
18832 
18833 #undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_
18834 
18835 // Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
18836 // operand to be used in a failure message.  The type (but not value)
18837 // of the other operand may affect the format.  This allows us to
18838 // print a char* as a raw pointer when it is compared against another
18839 // char* or void*, and print it as a C string when it is compared
18840 // against an std::string object, for example.
18841 //
18842 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
18843 template <typename T1, typename T2>
18844 std::string FormatForComparisonFailureMessage(
18845     const T1& value, const T2& /* other_operand */) {
18846   return FormatForComparison<T1, T2>::Format(value);
18847 }
18848 
18849 // The helper function for {ASSERT|EXPECT}_EQ.
18850 template <typename T1, typename T2>
18851 AssertionResult CmpHelperEQ(const char* expected_expression,
18852                             const char* actual_expression,
18853                             const T1& expected,
18854                             const T2& actual) {
18855 #ifdef _MSC_VER
18856 # pragma warning(push)          // Saves the current warning state.
18857 # pragma warning(disable:4389)  // Temporarily disables warning on
18858                                 // signed/unsigned mismatch.
18859 #endif
18860 
18861   if (expected == actual) {
18862     return AssertionSuccess();
18863   }
18864 
18865 #ifdef _MSC_VER
18866 # pragma warning(pop)          // Restores the warning state.
18867 #endif
18868 
18869   return EqFailure(expected_expression,
18870                    actual_expression,
18871                    FormatForComparisonFailureMessage(expected, actual),
18872                    FormatForComparisonFailureMessage(actual, expected),
18873                    false);
18874 }
18875 
18876 // With this overloaded version, we allow anonymous enums to be used
18877 // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums
18878 // can be implicitly cast to BiggestInt.
18879 GTEST_API_ AssertionResult CmpHelperEQ(const char* expected_expression,
18880                                        const char* actual_expression,
18881                                        BiggestInt expected,
18882                                        BiggestInt actual);
18883 
18884 // The helper class for {ASSERT|EXPECT}_EQ.  The template argument
18885 // lhs_is_null_literal is true iff the first argument to ASSERT_EQ()
18886 // is a null pointer literal.  The following default implementation is
18887 // for lhs_is_null_literal being false.
18888 template <bool lhs_is_null_literal>
18889 class EqHelper {
18890  public:
18891   // This templatized version is for the general case.
18892   template <typename T1, typename T2>
18893   static AssertionResult Compare(const char* expected_expression,
18894                                  const char* actual_expression,
18895                                  const T1& expected,
18896                                  const T2& actual) {
18897     return CmpHelperEQ(expected_expression, actual_expression, expected,
18898                        actual);
18899   }
18900 
18901   // With this overloaded version, we allow anonymous enums to be used
18902   // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous
18903   // enums can be implicitly cast to BiggestInt.
18904   //
18905   // Even though its body looks the same as the above version, we
18906   // cannot merge the two, as it will make anonymous enums unhappy.
18907   static AssertionResult Compare(const char* expected_expression,
18908                                  const char* actual_expression,
18909                                  BiggestInt expected,
18910                                  BiggestInt actual) {
18911     return CmpHelperEQ(expected_expression, actual_expression, expected,
18912                        actual);
18913   }
18914 };
18915 
18916 // This specialization is used when the first argument to ASSERT_EQ()
18917 // is a null pointer literal, like NULL, false, or 0.
18918 template <>
18919 class EqHelper<true> {
18920  public:
18921   // We define two overloaded versions of Compare().  The first
18922   // version will be picked when the second argument to ASSERT_EQ() is
18923   // NOT a pointer, e.g. ASSERT_EQ(0, AnIntFunction()) or
18924   // EXPECT_EQ(false, a_bool).
18925   template <typename T1, typename T2>
18926   static AssertionResult Compare(
18927       const char* expected_expression,
18928       const char* actual_expression,
18929       const T1& expected,
18930       const T2& actual,
18931       // The following line prevents this overload from being considered if T2
18932       // is not a pointer type.  We need this because ASSERT_EQ(NULL, my_ptr)
18933       // expands to Compare("", "", NULL, my_ptr), which requires a conversion
18934       // to match the Secret* in the other overload, which would otherwise make
18935       // this template match better.
18936       typename EnableIf<!is_pointer<T2>::value>::type* = 0) {
18937     return CmpHelperEQ(expected_expression, actual_expression, expected,
18938                        actual);
18939   }
18940 
18941   // This version will be picked when the second argument to ASSERT_EQ() is a
18942   // pointer, e.g. ASSERT_EQ(NULL, a_pointer).
18943   template <typename T>
18944   static AssertionResult Compare(
18945       const char* expected_expression,
18946       const char* actual_expression,
18947       // We used to have a second template parameter instead of Secret*.  That
18948       // template parameter would deduce to 'long', making this a better match
18949       // than the first overload even without the first overload's EnableIf.
18950       // Unfortunately, gcc with -Wconversion-null warns when "passing NULL to
18951       // non-pointer argument" (even a deduced integral argument), so the old
18952       // implementation caused warnings in user code.
18953       Secret* /* expected (NULL) */,
18954       T* actual) {
18955     // We already know that 'expected' is a null pointer.
18956     return CmpHelperEQ(expected_expression, actual_expression,
18957                        static_cast<T*>(NULL), actual);
18958   }
18959 };
18960 
18961 // A macro for implementing the helper functions needed to implement
18962 // ASSERT_?? and EXPECT_??.  It is here just to avoid copy-and-paste
18963 // of similar code.
18964 //
18965 // For each templatized helper function, we also define an overloaded
18966 // version for BiggestInt in order to reduce code bloat and allow
18967 // anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled
18968 // with gcc 4.
18969 //
18970 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
18971 #define GTEST_IMPL_CMP_HELPER_(op_name, op)\
18972 template <typename T1, typename T2>\
18973 AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
18974                                    const T1& val1, const T2& val2) {\
18975   if (val1 op val2) {\
18976     return AssertionSuccess();\
18977   } else {\
18978     return AssertionFailure() \
18979         << "Expected: (" << expr1 << ") " #op " (" << expr2\
18980         << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\
18981         << " vs " << FormatForComparisonFailureMessage(val2, val1);\
18982   }\
18983 }\
18984 GTEST_API_ AssertionResult CmpHelper##op_name(\
18985     const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2)
18986 
18987 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
18988 
18989 // Implements the helper function for {ASSERT|EXPECT}_NE
18990 GTEST_IMPL_CMP_HELPER_(NE, !=);
18991 // Implements the helper function for {ASSERT|EXPECT}_LE
18992 GTEST_IMPL_CMP_HELPER_(LE, <=);
18993 // Implements the helper function for {ASSERT|EXPECT}_LT
18994 GTEST_IMPL_CMP_HELPER_(LT, <);
18995 // Implements the helper function for {ASSERT|EXPECT}_GE
18996 GTEST_IMPL_CMP_HELPER_(GE, >=);
18997 // Implements the helper function for {ASSERT|EXPECT}_GT
18998 GTEST_IMPL_CMP_HELPER_(GT, >);
18999 
19000 #undef GTEST_IMPL_CMP_HELPER_
19001 
19002 // The helper function for {ASSERT|EXPECT}_STREQ.
19003 //
19004 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
19005 GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression,
19006                                           const char* actual_expression,
19007                                           const char* expected,
19008                                           const char* actual);
19009 
19010 // The helper function for {ASSERT|EXPECT}_STRCASEEQ.
19011 //
19012 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
19013 GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression,
19014                                               const char* actual_expression,
19015                                               const char* expected,
19016                                               const char* actual);
19017 
19018 // The helper function for {ASSERT|EXPECT}_STRNE.
19019 //
19020 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
19021 GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
19022                                           const char* s2_expression,
19023                                           const char* s1,
19024                                           const char* s2);
19025 
19026 // The helper function for {ASSERT|EXPECT}_STRCASENE.
19027 //
19028 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
19029 GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
19030                                               const char* s2_expression,
19031                                               const char* s1,
19032                                               const char* s2);
19033 
19034 
19035 // Helper function for *_STREQ on wide strings.
19036 //
19037 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
19038 GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression,
19039                                           const char* actual_expression,
19040                                           const wchar_t* expected,
19041                                           const wchar_t* actual);
19042 
19043 // Helper function for *_STRNE on wide strings.
19044 //
19045 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
19046 GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
19047                                           const char* s2_expression,
19048                                           const wchar_t* s1,
19049                                           const wchar_t* s2);
19050 
19051 }  // namespace internal
19052 
19053 // IsSubstring() and IsNotSubstring() are intended to be used as the
19054 // first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by
19055 // themselves.  They check whether needle is a substring of haystack
19056 // (NULL is considered a substring of itself only), and return an
19057 // appropriate error message when they fail.
19058 //
19059 // The {needle,haystack}_expr arguments are the stringified
19060 // expressions that generated the two real arguments.
19061 GTEST_API_ AssertionResult IsSubstring(
19062     const char* needle_expr, const char* haystack_expr,
19063     const char* needle, const char* haystack);
19064 GTEST_API_ AssertionResult IsSubstring(
19065     const char* needle_expr, const char* haystack_expr,
19066     const wchar_t* needle, const wchar_t* haystack);
19067 GTEST_API_ AssertionResult IsNotSubstring(
19068     const char* needle_expr, const char* haystack_expr,
19069     const char* needle, const char* haystack);
19070 GTEST_API_ AssertionResult IsNotSubstring(
19071     const char* needle_expr, const char* haystack_expr,
19072     const wchar_t* needle, const wchar_t* haystack);
19073 GTEST_API_ AssertionResult IsSubstring(
19074     const char* needle_expr, const char* haystack_expr,
19075     const ::std::string& needle, const ::std::string& haystack);
19076 GTEST_API_ AssertionResult IsNotSubstring(
19077     const char* needle_expr, const char* haystack_expr,
19078     const ::std::string& needle, const ::std::string& haystack);
19079 
19080 #if GTEST_HAS_STD_WSTRING
19081 GTEST_API_ AssertionResult IsSubstring(
19082     const char* needle_expr, const char* haystack_expr,
19083     const ::std::wstring& needle, const ::std::wstring& haystack);
19084 GTEST_API_ AssertionResult IsNotSubstring(
19085     const char* needle_expr, const char* haystack_expr,
19086     const ::std::wstring& needle, const ::std::wstring& haystack);
19087 #endif  // GTEST_HAS_STD_WSTRING
19088 
19089 namespace internal {
19090 
19091 // Helper template function for comparing floating-points.
19092 //
19093 // Template parameter:
19094 //
19095 //   RawType: the raw floating-point type (either float or double)
19096 //
19097 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
19098 template <typename RawType>
19099 AssertionResult CmpHelperFloatingPointEQ(const char* expected_expression,
19100                                          const char* actual_expression,
19101                                          RawType expected,
19102                                          RawType actual) {
19103   const FloatingPoint<RawType> lhs(expected), rhs(actual);
19104 
19105   if (lhs.AlmostEquals(rhs)) {
19106     return AssertionSuccess();
19107   }
19108 
19109   ::std::stringstream expected_ss;
19110   expected_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
19111               << expected;
19112 
19113   ::std::stringstream actual_ss;
19114   actual_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
19115             << actual;
19116 
19117   return EqFailure(expected_expression,
19118                    actual_expression,
19119                    StringStreamToString(&expected_ss),
19120                    StringStreamToString(&actual_ss),
19121                    false);
19122 }
19123 
19124 // Helper function for implementing ASSERT_NEAR.
19125 //
19126 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
19127 GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
19128                                                 const char* expr2,
19129                                                 const char* abs_error_expr,
19130                                                 double val1,
19131                                                 double val2,
19132                                                 double abs_error);
19133 
19134 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
19135 // A class that enables one to stream messages to assertion macros
19136 class GTEST_API_ AssertHelper {
19137  public:
19138   // Constructor.
19139   AssertHelper(TestPartResult::Type type,
19140                const char* file,
19141                int line,
19142                const char* message);
19143   ~AssertHelper();
19144 
19145   // Message assignment is a semantic trick to enable assertion
19146   // streaming; see the GTEST_MESSAGE_ macro below.
19147   void operator=(const Message& message) const;
19148 
19149  private:
19150   // We put our data in a struct so that the size of the AssertHelper class can
19151   // be as small as possible.  This is important because gcc is incapable of
19152   // re-using stack space even for temporary variables, so every EXPECT_EQ
19153   // reserves stack space for another AssertHelper.
19154   struct AssertHelperData {
19155     AssertHelperData(TestPartResult::Type t,
19156                      const char* srcfile,
19157                      int line_num,
19158                      const char* msg)
19159         : type(t), file(srcfile), line(line_num), message(msg) { }
19160 
19161     TestPartResult::Type const type;
19162     const char* const file;
19163     int const line;
19164     std::string const message;
19165 
19166    private:
19167     GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
19168   };
19169 
19170   AssertHelperData* const data_;
19171 
19172   GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
19173 };
19174 
19175 }  // namespace internal
19176 
19177 #if GTEST_HAS_PARAM_TEST
19178 // The pure interface class that all value-parameterized tests inherit from.
19179 // A value-parameterized class must inherit from both ::testing::Test and
19180 // ::testing::WithParamInterface. In most cases that just means inheriting
19181 // from ::testing::TestWithParam, but more complicated test hierarchies
19182 // may need to inherit from Test and WithParamInterface at different levels.
19183 //
19184 // This interface has support for accessing the test parameter value via
19185 // the GetParam() method.
19186 //
19187 // Use it with one of the parameter generator defining functions, like Range(),
19188 // Values(), ValuesIn(), Bool(), and Combine().
19189 //
19190 // class FooTest : public ::testing::TestWithParam<int> {
19191 //  protected:
19192 //   FooTest() {
19193 //     // Can use GetParam() here.
19194 //   }
19195 //   virtual ~FooTest() {
19196 //     // Can use GetParam() here.
19197 //   }
19198 //   virtual void SetUp() {
19199 //     // Can use GetParam() here.
19200 //   }
19201 //   virtual void TearDown {
19202 //     // Can use GetParam() here.
19203 //   }
19204 // };
19205 // TEST_P(FooTest, DoesBar) {
19206 //   // Can use GetParam() method here.
19207 //   Foo foo;
19208 //   ASSERT_TRUE(foo.DoesBar(GetParam()));
19209 // }
19210 // INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));
19211 
19212 template <typename T>
19213 class WithParamInterface {
19214  public:
19215   typedef T ParamType;
19216   virtual ~WithParamInterface() {}
19217 
19218   // The current parameter value. Is also available in the test fixture's
19219   // constructor. This member function is non-static, even though it only
19220   // references static data, to reduce the opportunity for incorrect uses
19221   // like writing 'WithParamInterface<bool>::GetParam()' for a test that
19222   // uses a fixture whose parameter type is int.
19223   const ParamType& GetParam() const {
19224     GTEST_CHECK_(parameter_ != NULL)
19225         << "GetParam() can only be called inside a value-parameterized test "
19226         << "-- did you intend to write TEST_P instead of TEST_F?";
19227     return *parameter_;
19228   }
19229 
19230  private:
19231   // Sets parameter value. The caller is responsible for making sure the value
19232   // remains alive and unchanged throughout the current test.
19233   static void SetParam(const ParamType* parameter) {
19234     parameter_ = parameter;
19235   }
19236 
19237   // Static value used for accessing parameter during a test lifetime.
19238   static const ParamType* parameter_;
19239 
19240   // TestClass must be a subclass of WithParamInterface<T> and Test.
19241   template <class TestClass> friend class internal::ParameterizedTestFactory;
19242 };
19243 
19244 template <typename T>
19245 const T* WithParamInterface<T>::parameter_ = NULL;
19246 
19247 // Most value-parameterized classes can ignore the existence of
19248 // WithParamInterface, and can just inherit from ::testing::TestWithParam.
19249 
19250 template <typename T>
19251 class TestWithParam : public Test, public WithParamInterface<T> {
19252 };
19253 
19254 #endif  // GTEST_HAS_PARAM_TEST
19255 
19256 // Macros for indicating success/failure in test code.
19257 
19258 // ADD_FAILURE unconditionally adds a failure to the current test.
19259 // SUCCEED generates a success - it doesn't automatically make the
19260 // current test successful, as a test is only successful when it has
19261 // no failure.
19262 //
19263 // EXPECT_* verifies that a certain condition is satisfied.  If not,
19264 // it behaves like ADD_FAILURE.  In particular:
19265 //
19266 //   EXPECT_TRUE  verifies that a Boolean condition is true.
19267 //   EXPECT_FALSE verifies that a Boolean condition is false.
19268 //
19269 // FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except
19270 // that they will also abort the current function on failure.  People
19271 // usually want the fail-fast behavior of FAIL and ASSERT_*, but those
19272 // writing data-driven tests often find themselves using ADD_FAILURE
19273 // and EXPECT_* more.
19274 
19275 // Generates a nonfatal failure with a generic message.
19276 #define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
19277 
19278 // Generates a nonfatal failure at the given source file location with
19279 // a generic message.
19280 #define ADD_FAILURE_AT(file, line) \
19281   GTEST_MESSAGE_AT_(file, line, "Failed", \
19282                     ::testing::TestPartResult::kNonFatalFailure)
19283 
19284 // Generates a fatal failure with a generic message.
19285 #define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")
19286 
19287 // Define this macro to 1 to omit the definition of FAIL(), which is a
19288 // generic name and clashes with some other libraries.
19289 #if !GTEST_DONT_DEFINE_FAIL
19290 # define FAIL() GTEST_FAIL()
19291 #endif
19292 
19293 // Generates a success with a generic message.
19294 #define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded")
19295 
19296 // Define this macro to 1 to omit the definition of SUCCEED(), which
19297 // is a generic name and clashes with some other libraries.
19298 #if !GTEST_DONT_DEFINE_SUCCEED
19299 # define SUCCEED() GTEST_SUCCEED()
19300 #endif
19301 
19302 // Macros for testing exceptions.
19303 //
19304 //    * {ASSERT|EXPECT}_THROW(statement, expected_exception):
19305 //         Tests that the statement throws the expected exception.
19306 //    * {ASSERT|EXPECT}_NO_THROW(statement):
19307 //         Tests that the statement doesn't throw any exception.
19308 //    * {ASSERT|EXPECT}_ANY_THROW(statement):
19309 //         Tests that the statement throws an exception.
19310 
19311 #define EXPECT_THROW(statement, expected_exception) \
19312   GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
19313 #define EXPECT_NO_THROW(statement) \
19314   GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
19315 #define EXPECT_ANY_THROW(statement) \
19316   GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)
19317 #define ASSERT_THROW(statement, expected_exception) \
19318   GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
19319 #define ASSERT_NO_THROW(statement) \
19320   GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
19321 #define ASSERT_ANY_THROW(statement) \
19322   GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)
19323 
19324 // Boolean assertions. Condition can be either a Boolean expression or an
19325 // AssertionResult. For more information on how to use AssertionResult with
19326 // these macros see comments on that class.
19327 #define EXPECT_TRUE(condition) \
19328   GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
19329                       GTEST_NONFATAL_FAILURE_)
19330 #define EXPECT_FALSE(condition) \
19331   GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
19332                       GTEST_NONFATAL_FAILURE_)
19333 #define ASSERT_TRUE(condition) \
19334   GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
19335                       GTEST_FATAL_FAILURE_)
19336 #define ASSERT_FALSE(condition) \
19337   GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
19338                       GTEST_FATAL_FAILURE_)
19339 
19340 // Includes the auto-generated header that implements a family of
19341 // generic predicate assertion macros.
19342 // Copyright 2006, Google Inc.
19343 // All rights reserved.
19344 //
19345 // Redistribution and use in source and binary forms, with or without
19346 // modification, are permitted provided that the following conditions are
19347 // met:
19348 //
19349 //     * Redistributions of source code must retain the above copyright
19350 // notice, this list of conditions and the following disclaimer.
19351 //     * Redistributions in binary form must reproduce the above
19352 // copyright notice, this list of conditions and the following disclaimer
19353 // in the documentation and/or other materials provided with the
19354 // distribution.
19355 //     * Neither the name of Google Inc. nor the names of its
19356 // contributors may be used to endorse or promote products derived from
19357 // this software without specific prior written permission.
19358 //
19359 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19360 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19361 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19362 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
19363 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
19364 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
19365 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
19366 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
19367 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
19368 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
19369 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
19370 
19371 // This file is AUTOMATICALLY GENERATED on 10/31/2011 by command
19372 // 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
19373 //
19374 // Implements a family of generic predicate assertion macros.
19375 
19376 #ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
19377 #define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
19378 
19379 // Makes sure this header is not included before gtest.h.
19380 #ifndef GTEST_INCLUDE_GTEST_GTEST_H_
19381 # error Do not include gtest_pred_impl.h directly.  Include gtest.h instead.
19382 #endif  // GTEST_INCLUDE_GTEST_GTEST_H_
19383 
19384 // This header implements a family of generic predicate assertion
19385 // macros:
19386 //
19387 //   ASSERT_PRED_FORMAT1(pred_format, v1)
19388 //   ASSERT_PRED_FORMAT2(pred_format, v1, v2)
19389 //   ...
19390 //
19391 // where pred_format is a function or functor that takes n (in the
19392 // case of ASSERT_PRED_FORMATn) values and their source expression
19393 // text, and returns a testing::AssertionResult.  See the definition
19394 // of ASSERT_EQ in gtest.h for an example.
19395 //
19396 // If you don't care about formatting, you can use the more
19397 // restrictive version:
19398 //
19399 //   ASSERT_PRED1(pred, v1)
19400 //   ASSERT_PRED2(pred, v1, v2)
19401 //   ...
19402 //
19403 // where pred is an n-ary function or functor that returns bool,
19404 // and the values v1, v2, ..., must support the << operator for
19405 // streaming to std::ostream.
19406 //
19407 // We also define the EXPECT_* variations.
19408 //
19409 // For now we only support predicates whose arity is at most 5.
19410 // Please email googletestframework@googlegroups.com if you need
19411 // support for higher arities.
19412 
19413 // GTEST_ASSERT_ is the basic statement to which all of the assertions
19414 // in this file reduce.  Don't use this in your code.
19415 
19416 #define GTEST_ASSERT_(expression, on_failure) \
19417   GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
19418   if (const ::testing::AssertionResult gtest_ar = (expression)) \
19419     ; \
19420   else \
19421     on_failure(gtest_ar.failure_message())
19422 
19423 
19424 // Helper function for implementing {EXPECT|ASSERT}_PRED1.  Don't use
19425 // this in your code.
19426 template <typename Pred,
19427           typename T1>
19428 AssertionResult AssertPred1Helper(const char* pred_text,
19429                                   const char* e1,
19430                                   Pred pred,
19431                                   const T1& v1) {
19432   if (pred(v1)) return AssertionSuccess();
19433 
19434   return AssertionFailure() << pred_text << "("
19435                             << e1 << ") evaluates to false, where"
19436                             << "\n" << e1 << " evaluates to " << v1;
19437 }
19438 
19439 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
19440 // Don't use this in your code.
19441 #define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\
19442   GTEST_ASSERT_(pred_format(#v1, v1), \
19443                 on_failure)
19444 
19445 // Internal macro for implementing {EXPECT|ASSERT}_PRED1.  Don't use
19446 // this in your code.
19447 #define GTEST_PRED1_(pred, v1, on_failure)\
19448   GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \
19449                                              #v1, \
19450                                              pred, \
19451                                              v1), on_failure)
19452 
19453 // Unary predicate assertion macros.
19454 #define EXPECT_PRED_FORMAT1(pred_format, v1) \
19455   GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_)
19456 #define EXPECT_PRED1(pred, v1) \
19457   GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_)
19458 #define ASSERT_PRED_FORMAT1(pred_format, v1) \
19459   GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_)
19460 #define ASSERT_PRED1(pred, v1) \
19461   GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_)
19462 
19463 
19464 
19465 // Helper function for implementing {EXPECT|ASSERT}_PRED2.  Don't use
19466 // this in your code.
19467 template <typename Pred,
19468           typename T1,
19469           typename T2>
19470 AssertionResult AssertPred2Helper(const char* pred_text,
19471                                   const char* e1,
19472                                   const char* e2,
19473                                   Pred pred,
19474                                   const T1& v1,
19475                                   const T2& v2) {
19476   if (pred(v1, v2)) return AssertionSuccess();
19477 
19478   return AssertionFailure() << pred_text << "("
19479                             << e1 << ", "
19480                             << e2 << ") evaluates to false, where"
19481                             << "\n" << e1 << " evaluates to " << v1
19482                             << "\n" << e2 << " evaluates to " << v2;
19483 }
19484 
19485 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
19486 // Don't use this in your code.
19487 #define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\
19488   GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \
19489                 on_failure)
19490 
19491 // Internal macro for implementing {EXPECT|ASSERT}_PRED2.  Don't use
19492 // this in your code.
19493 #define GTEST_PRED2_(pred, v1, v2, on_failure)\
19494   GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \
19495                                              #v1, \
19496                                              #v2, \
19497                                              pred, \
19498                                              v1, \
19499                                              v2), on_failure)
19500 
19501 // Binary predicate assertion macros.
19502 #define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \
19503   GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_)
19504 #define EXPECT_PRED2(pred, v1, v2) \
19505   GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_)
19506 #define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \
19507   GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_)
19508 #define ASSERT_PRED2(pred, v1, v2) \
19509   GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_)
19510 
19511 
19512 
19513 // Helper function for implementing {EXPECT|ASSERT}_PRED3.  Don't use
19514 // this in your code.
19515 template <typename Pred,
19516           typename T1,
19517           typename T2,
19518           typename T3>
19519 AssertionResult AssertPred3Helper(const char* pred_text,
19520                                   const char* e1,
19521                                   const char* e2,
19522                                   const char* e3,
19523                                   Pred pred,
19524                                   const T1& v1,
19525                                   const T2& v2,
19526                                   const T3& v3) {
19527   if (pred(v1, v2, v3)) return AssertionSuccess();
19528 
19529   return AssertionFailure() << pred_text << "("
19530                             << e1 << ", "
19531                             << e2 << ", "
19532                             << e3 << ") evaluates to false, where"
19533                             << "\n" << e1 << " evaluates to " << v1
19534                             << "\n" << e2 << " evaluates to " << v2
19535                             << "\n" << e3 << " evaluates to " << v3;
19536 }
19537 
19538 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
19539 // Don't use this in your code.
19540 #define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\
19541   GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \
19542                 on_failure)
19543 
19544 // Internal macro for implementing {EXPECT|ASSERT}_PRED3.  Don't use
19545 // this in your code.
19546 #define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\
19547   GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \
19548                                              #v1, \
19549                                              #v2, \
19550                                              #v3, \
19551                                              pred, \
19552                                              v1, \
19553                                              v2, \
19554                                              v3), on_failure)
19555 
19556 // Ternary predicate assertion macros.
19557 #define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \
19558   GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
19559 #define EXPECT_PRED3(pred, v1, v2, v3) \
19560   GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
19561 #define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \
19562   GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_)
19563 #define ASSERT_PRED3(pred, v1, v2, v3) \
19564   GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_)
19565 
19566 
19567 
19568 // Helper function for implementing {EXPECT|ASSERT}_PRED4.  Don't use
19569 // this in your code.
19570 template <typename Pred,
19571           typename T1,
19572           typename T2,
19573           typename T3,
19574           typename T4>
19575 AssertionResult AssertPred4Helper(const char* pred_text,
19576                                   const char* e1,
19577                                   const char* e2,
19578                                   const char* e3,
19579                                   const char* e4,
19580                                   Pred pred,
19581                                   const T1& v1,
19582                                   const T2& v2,
19583                                   const T3& v3,
19584                                   const T4& v4) {
19585   if (pred(v1, v2, v3, v4)) return AssertionSuccess();
19586 
19587   return AssertionFailure() << pred_text << "("
19588                             << e1 << ", "
19589                             << e2 << ", "
19590                             << e3 << ", "
19591                             << e4 << ") evaluates to false, where"
19592                             << "\n" << e1 << " evaluates to " << v1
19593                             << "\n" << e2 << " evaluates to " << v2
19594                             << "\n" << e3 << " evaluates to " << v3
19595                             << "\n" << e4 << " evaluates to " << v4;
19596 }
19597 
19598 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
19599 // Don't use this in your code.
19600 #define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\
19601   GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \
19602                 on_failure)
19603 
19604 // Internal macro for implementing {EXPECT|ASSERT}_PRED4.  Don't use
19605 // this in your code.
19606 #define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\
19607   GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \
19608                                              #v1, \
19609                                              #v2, \
19610                                              #v3, \
19611                                              #v4, \
19612                                              pred, \
19613                                              v1, \
19614                                              v2, \
19615                                              v3, \
19616                                              v4), on_failure)
19617 
19618 // 4-ary predicate assertion macros.
19619 #define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
19620   GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
19621 #define EXPECT_PRED4(pred, v1, v2, v3, v4) \
19622   GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
19623 #define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
19624   GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
19625 #define ASSERT_PRED4(pred, v1, v2, v3, v4) \
19626   GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
19627 
19628 
19629 
19630 // Helper function for implementing {EXPECT|ASSERT}_PRED5.  Don't use
19631 // this in your code.
19632 template <typename Pred,
19633           typename T1,
19634           typename T2,
19635           typename T3,
19636           typename T4,
19637           typename T5>
19638 AssertionResult AssertPred5Helper(const char* pred_text,
19639                                   const char* e1,
19640                                   const char* e2,
19641                                   const char* e3,
19642                                   const char* e4,
19643                                   const char* e5,
19644                                   Pred pred,
19645                                   const T1& v1,
19646                                   const T2& v2,
19647                                   const T3& v3,
19648                                   const T4& v4,
19649                                   const T5& v5) {
19650   if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess();
19651 
19652   return AssertionFailure() << pred_text << "("
19653                             << e1 << ", "
19654                             << e2 << ", "
19655                             << e3 << ", "
19656                             << e4 << ", "
19657                             << e5 << ") evaluates to false, where"
19658                             << "\n" << e1 << " evaluates to " << v1
19659                             << "\n" << e2 << " evaluates to " << v2
19660                             << "\n" << e3 << " evaluates to " << v3
19661                             << "\n" << e4 << " evaluates to " << v4
19662                             << "\n" << e5 << " evaluates to " << v5;
19663 }
19664 
19665 // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
19666 // Don't use this in your code.
19667 #define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\
19668   GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \
19669                 on_failure)
19670 
19671 // Internal macro for implementing {EXPECT|ASSERT}_PRED5.  Don't use
19672 // this in your code.
19673 #define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\
19674   GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \
19675                                              #v1, \
19676                                              #v2, \
19677                                              #v3, \
19678                                              #v4, \
19679                                              #v5, \
19680                                              pred, \
19681                                              v1, \
19682                                              v2, \
19683                                              v3, \
19684                                              v4, \
19685                                              v5), on_failure)
19686 
19687 // 5-ary predicate assertion macros.
19688 #define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
19689   GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
19690 #define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \
19691   GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
19692 #define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
19693   GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
19694 #define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \
19695   GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
19696 
19697 
19698 
19699 #endif  // GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
19700 
19701 // Macros for testing equalities and inequalities.
19702 //
19703 //    * {ASSERT|EXPECT}_EQ(expected, actual): Tests that expected == actual
19704 //    * {ASSERT|EXPECT}_NE(v1, v2):           Tests that v1 != v2
19705 //    * {ASSERT|EXPECT}_LT(v1, v2):           Tests that v1 < v2
19706 //    * {ASSERT|EXPECT}_LE(v1, v2):           Tests that v1 <= v2
19707 //    * {ASSERT|EXPECT}_GT(v1, v2):           Tests that v1 > v2
19708 //    * {ASSERT|EXPECT}_GE(v1, v2):           Tests that v1 >= v2
19709 //
19710 // When they are not, Google Test prints both the tested expressions and
19711 // their actual values.  The values must be compatible built-in types,
19712 // or you will get a compiler error.  By "compatible" we mean that the
19713 // values can be compared by the respective operator.
19714 //
19715 // Note:
19716 //
19717 //   1. It is possible to make a user-defined type work with
19718 //   {ASSERT|EXPECT}_??(), but that requires overloading the
19719 //   comparison operators and is thus discouraged by the Google C++
19720 //   Usage Guide.  Therefore, you are advised to use the
19721 //   {ASSERT|EXPECT}_TRUE() macro to assert that two objects are
19722 //   equal.
19723 //
19724 //   2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on
19725 //   pointers (in particular, C strings).  Therefore, if you use it
19726 //   with two C strings, you are testing how their locations in memory
19727 //   are related, not how their content is related.  To compare two C
19728 //   strings by content, use {ASSERT|EXPECT}_STR*().
19729 //
19730 //   3. {ASSERT|EXPECT}_EQ(expected, actual) is preferred to
19731 //   {ASSERT|EXPECT}_TRUE(expected == actual), as the former tells you
19732 //   what the actual value is when it fails, and similarly for the
19733 //   other comparisons.
19734 //
19735 //   4. Do not depend on the order in which {ASSERT|EXPECT}_??()
19736 //   evaluate their arguments, which is undefined.
19737 //
19738 //   5. These macros evaluate their arguments exactly once.
19739 //
19740 // Examples:
19741 //
19742 //   EXPECT_NE(5, Foo());
19743 //   EXPECT_EQ(NULL, a_pointer);
19744 //   ASSERT_LT(i, array_size);
19745 //   ASSERT_GT(records.size(), 0) << "There is no record left.";
19746 
19747 #define EXPECT_EQ(expected, actual) \
19748   EXPECT_PRED_FORMAT2(::testing::internal:: \
19749                       EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \
19750                       expected, actual)
19751 #define EXPECT_NE(expected, actual) \
19752   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, expected, actual)
19753 #define EXPECT_LE(val1, val2) \
19754   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
19755 #define EXPECT_LT(val1, val2) \
19756   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
19757 #define EXPECT_GE(val1, val2) \
19758   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
19759 #define EXPECT_GT(val1, val2) \
19760   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
19761 
19762 #define GTEST_ASSERT_EQ(expected, actual) \
19763   ASSERT_PRED_FORMAT2(::testing::internal:: \
19764                       EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \
19765                       expected, actual)
19766 #define GTEST_ASSERT_NE(val1, val2) \
19767   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
19768 #define GTEST_ASSERT_LE(val1, val2) \
19769   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
19770 #define GTEST_ASSERT_LT(val1, val2) \
19771   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
19772 #define GTEST_ASSERT_GE(val1, val2) \
19773   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
19774 #define GTEST_ASSERT_GT(val1, val2) \
19775   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
19776 
19777 // Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of
19778 // ASSERT_XY(), which clashes with some users' own code.
19779 
19780 #if !GTEST_DONT_DEFINE_ASSERT_EQ
19781 # define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
19782 #endif
19783 
19784 #if !GTEST_DONT_DEFINE_ASSERT_NE
19785 # define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
19786 #endif
19787 
19788 #if !GTEST_DONT_DEFINE_ASSERT_LE
19789 # define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
19790 #endif
19791 
19792 #if !GTEST_DONT_DEFINE_ASSERT_LT
19793 # define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
19794 #endif
19795 
19796 #if !GTEST_DONT_DEFINE_ASSERT_GE
19797 # define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
19798 #endif
19799 
19800 #if !GTEST_DONT_DEFINE_ASSERT_GT
19801 # define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
19802 #endif
19803 
19804 // C-string Comparisons.  All tests treat NULL and any non-NULL string
19805 // as different.  Two NULLs are equal.
19806 //
19807 //    * {ASSERT|EXPECT}_STREQ(s1, s2):     Tests that s1 == s2
19808 //    * {ASSERT|EXPECT}_STRNE(s1, s2):     Tests that s1 != s2
19809 //    * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case
19810 //    * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case
19811 //
19812 // For wide or narrow string objects, you can use the
19813 // {ASSERT|EXPECT}_??() macros.
19814 //
19815 // Don't depend on the order in which the arguments are evaluated,
19816 // which is undefined.
19817 //
19818 // These macros evaluate their arguments exactly once.
19819 
19820 #define EXPECT_STREQ(expected, actual) \
19821   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual)
19822 #define EXPECT_STRNE(s1, s2) \
19823   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
19824 #define EXPECT_STRCASEEQ(expected, actual) \
19825   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual)
19826 #define EXPECT_STRCASENE(s1, s2)\
19827   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
19828 
19829 #define ASSERT_STREQ(expected, actual) \
19830   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual)
19831 #define ASSERT_STRNE(s1, s2) \
19832   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
19833 #define ASSERT_STRCASEEQ(expected, actual) \
19834   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual)
19835 #define ASSERT_STRCASENE(s1, s2)\
19836   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
19837 
19838 // Macros for comparing floating-point numbers.
19839 //
19840 //    * {ASSERT|EXPECT}_FLOAT_EQ(expected, actual):
19841 //         Tests that two float values are almost equal.
19842 //    * {ASSERT|EXPECT}_DOUBLE_EQ(expected, actual):
19843 //         Tests that two double values are almost equal.
19844 //    * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error):
19845 //         Tests that v1 and v2 are within the given distance to each other.
19846 //
19847 // Google Test uses ULP-based comparison to automatically pick a default
19848 // error bound that is appropriate for the operands.  See the
19849 // FloatingPoint template class in gtest-internal.h if you are
19850 // interested in the implementation details.
19851 
19852 #define EXPECT_FLOAT_EQ(expected, actual)\
19853   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
19854                       expected, actual)
19855 
19856 #define EXPECT_DOUBLE_EQ(expected, actual)\
19857   EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
19858                       expected, actual)
19859 
19860 #define ASSERT_FLOAT_EQ(expected, actual)\
19861   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
19862                       expected, actual)
19863 
19864 #define ASSERT_DOUBLE_EQ(expected, actual)\
19865   ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
19866                       expected, actual)
19867 
19868 #define EXPECT_NEAR(val1, val2, abs_error)\
19869   EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
19870                       val1, val2, abs_error)
19871 
19872 #define ASSERT_NEAR(val1, val2, abs_error)\
19873   ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
19874                       val1, val2, abs_error)
19875 
19876 // These predicate format functions work on floating-point values, and
19877 // can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g.
19878 //
19879 //   EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0);
19880 
19881 // Asserts that val1 is less than, or almost equal to, val2.  Fails
19882 // otherwise.  In particular, it fails if either val1 or val2 is NaN.
19883 GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2,
19884                                    float val1, float val2);
19885 GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
19886                                     double val1, double val2);
19887 
19888 
19889 #if GTEST_OS_WINDOWS
19890 
19891 // Macros that test for HRESULT failure and success, these are only useful
19892 // on Windows, and rely on Windows SDK macros and APIs to compile.
19893 //
19894 //    * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr)
19895 //
19896 // When expr unexpectedly fails or succeeds, Google Test prints the
19897 // expected result and the actual result with both a human-readable
19898 // string representation of the error, if available, as well as the
19899 // hex result code.
19900 # define EXPECT_HRESULT_SUCCEEDED(expr) \
19901     EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
19902 
19903 # define ASSERT_HRESULT_SUCCEEDED(expr) \
19904     ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
19905 
19906 # define EXPECT_HRESULT_FAILED(expr) \
19907     EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
19908 
19909 # define ASSERT_HRESULT_FAILED(expr) \
19910     ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
19911 
19912 #endif  // GTEST_OS_WINDOWS
19913 
19914 // Macros that execute statement and check that it doesn't generate new fatal
19915 // failures in the current thread.
19916 //
19917 //   * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement);
19918 //
19919 // Examples:
19920 //
19921 //   EXPECT_NO_FATAL_FAILURE(Process());
19922 //   ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed";
19923 //
19924 #define ASSERT_NO_FATAL_FAILURE(statement) \
19925     GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
19926 #define EXPECT_NO_FATAL_FAILURE(statement) \
19927     GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)
19928 
19929 // Causes a trace (including the source file path, the current line
19930 // number, and the given message) to be included in every test failure
19931 // message generated by code in the current scope.  The effect is
19932 // undone when the control leaves the current scope.
19933 //
19934 // The message argument can be anything streamable to std::ostream.
19935 //
19936 // In the implementation, we include the current line number as part
19937 // of the dummy variable name, thus allowing multiple SCOPED_TRACE()s
19938 // to appear in the same block - as long as they are on different
19939 // lines.
19940 #define SCOPED_TRACE(message) \
19941   ::testing::internal::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
19942     __FILE__, __LINE__, ::testing::Message() << (message))
19943 
19944 // Compile-time assertion for type equality.
19945 // StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are
19946 // the same type.  The value it returns is not interesting.
19947 //
19948 // Instead of making StaticAssertTypeEq a class template, we make it a
19949 // function template that invokes a helper class template.  This
19950 // prevents a user from misusing StaticAssertTypeEq<T1, T2> by
19951 // defining objects of that type.
19952 //
19953 // CAVEAT:
19954 //
19955 // When used inside a method of a class template,
19956 // StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is
19957 // instantiated.  For example, given:
19958 //
19959 //   template <typename T> class Foo {
19960 //    public:
19961 //     void Bar() { testing::StaticAssertTypeEq<int, T>(); }
19962 //   };
19963 //
19964 // the code:
19965 //
19966 //   void Test1() { Foo<bool> foo; }
19967 //
19968 // will NOT generate a compiler error, as Foo<bool>::Bar() is never
19969 // actually instantiated.  Instead, you need:
19970 //
19971 //   void Test2() { Foo<bool> foo; foo.Bar(); }
19972 //
19973 // to cause a compiler error.
19974 template <typename T1, typename T2>
19975 bool StaticAssertTypeEq() {
19976   (void)internal::StaticAssertTypeEqHelper<T1, T2>();
19977   return true;
19978 }
19979 
19980 // Defines a test.
19981 //
19982 // The first parameter is the name of the test case, and the second
19983 // parameter is the name of the test within the test case.
19984 //
19985 // The convention is to end the test case name with "Test".  For
19986 // example, a test case for the Foo class can be named FooTest.
19987 //
19988 // The user should put his test code between braces after using this
19989 // macro.  Example:
19990 //
19991 //   TEST(FooTest, InitializesCorrectly) {
19992 //     Foo foo;
19993 //     EXPECT_TRUE(foo.StatusIsOK());
19994 //   }
19995 
19996 // Note that we call GetTestTypeId() instead of GetTypeId<
19997 // ::testing::Test>() here to get the type ID of testing::Test.  This
19998 // is to work around a suspected linker bug when using Google Test as
19999 // a framework on Mac OS X.  The bug causes GetTypeId<
20000 // ::testing::Test>() to return different values depending on whether
20001 // the call is from the Google Test framework itself or from user test
20002 // code.  GetTestTypeId() is guaranteed to always return the same
20003 // value, as it always calls GetTypeId<>() from the Google Test
20004 // framework.
20005 #define GTEST_TEST(test_case_name, test_name)\
20006   GTEST_TEST_(test_case_name, test_name, \
20007               ::testing::Test, ::testing::internal::GetTestTypeId())
20008 
20009 // Define this macro to 1 to omit the definition of TEST(), which
20010 // is a generic name and clashes with some other libraries.
20011 #if !GTEST_DONT_DEFINE_TEST
20012 # define TEST(test_case_name, test_name) GTEST_TEST(test_case_name, test_name)
20013 #endif
20014 
20015 // Defines a test that uses a test fixture.
20016 //
20017 // The first parameter is the name of the test fixture class, which
20018 // also doubles as the test case name.  The second parameter is the
20019 // name of the test within the test case.
20020 //
20021 // A test fixture class must be declared earlier.  The user should put
20022 // his test code between braces after using this macro.  Example:
20023 //
20024 //   class FooTest : public testing::Test {
20025 //    protected:
20026 //     virtual void SetUp() { b_.AddElement(3); }
20027 //
20028 //     Foo a_;
20029 //     Foo b_;
20030 //   };
20031 //
20032 //   TEST_F(FooTest, InitializesCorrectly) {
20033 //     EXPECT_TRUE(a_.StatusIsOK());
20034 //   }
20035 //
20036 //   TEST_F(FooTest, ReturnsElementCountCorrectly) {
20037 //     EXPECT_EQ(0, a_.size());
20038 //     EXPECT_EQ(1, b_.size());
20039 //   }
20040 
20041 #define TEST_F(test_fixture, test_name)\
20042   GTEST_TEST_(test_fixture, test_name, test_fixture, \
20043               ::testing::internal::GetTypeId<test_fixture>())
20044 
20045 }  // namespace testing
20046 
20047 // Use this function in main() to run all tests.  It returns 0 if all
20048 // tests are successful, or 1 otherwise.
20049 //
20050 // RUN_ALL_TESTS() should be invoked after the command line has been
20051 // parsed by InitGoogleTest().
20052 //
20053 // This function was formerly a macro; thus, it is in the global
20054 // namespace and has an all-caps name.
20055 int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
20056 
20057 inline int RUN_ALL_TESTS() {
20058   return ::testing::UnitTest::GetInstance()->Run();
20059 }
20060 
20061 #endif  // GTEST_INCLUDE_GTEST_GTEST_H_