OpenCV 2.4.8 components for OpenCVgrabber.
[mmanager-3rdparty.git] / OpenCV2.4.8 / build / include / opencv2 / ts / ts_gtest.h
1 // Copyright 2005, Google Inc.
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
6 // met:
7 //
8 //     * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 //     * Redistributions in binary form must reproduce the above
11 // copyright notice, this list of conditions and the following disclaimer
12 // in the documentation and/or other materials provided with the
13 // distribution.
14 //     * Neither the name of Google Inc. nor the names of its
15 // contributors may be used to endorse or promote products derived from
16 // this software without specific prior written permission.
17 //
18 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 //
30 // Author: wan@google.com (Zhanyong Wan)
31 //
32 // The Google C++ Testing Framework (Google Test)
33 //
34 // This header file defines the public API for Google Test.  It should be
35 // included by any test program that uses Google Test.
36 //
37 // IMPORTANT NOTE: Due to limitation of the C++ language, we have to
38 // leave some internal implementation details in this header file.
39 // They are clearly marked by comments like this:
40 //
41 //   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
42 //
43 // Such code is NOT meant to be used by a user directly, and is subject
44 // to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
45 // program!
46 //
47 // Acknowledgment: Google Test borrowed the idea of automatic test
48 // registration from Barthelemy Dagenais' (barthelemy@prologique.com)
49 // easyUnit framework.
50
51 #ifndef GTEST_INCLUDE_GTEST_GTEST_H_
52 #define GTEST_INCLUDE_GTEST_GTEST_H_
53
54 #include <limits>
55 #include <ostream>
56 #include <vector>
57
58 // Copyright 2005, Google Inc.
59 // All rights reserved.
60 //
61 // Redistribution and use in source and binary forms, with or without
62 // modification, are permitted provided that the following conditions are
63 // met:
64 //
65 //     * Redistributions of source code must retain the above copyright
66 // notice, this list of conditions and the following disclaimer.
67 //     * Redistributions in binary form must reproduce the above
68 // copyright notice, this list of conditions and the following disclaimer
69 // in the documentation and/or other materials provided with the
70 // distribution.
71 //     * Neither the name of Google Inc. nor the names of its
72 // contributors may be used to endorse or promote products derived from
73 // this software without specific prior written permission.
74 //
75 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
76 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
77 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
78 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
79 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
80 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
81 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
82 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
83 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
84 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
85 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
86 //
87 // Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
88 //
89 // The Google C++ Testing Framework (Google Test)
90 //
91 // This header file declares functions and macros used internally by
92 // Google Test.  They are subject to change without notice.
93
94 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
95 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
96
97 // Copyright 2005, Google Inc.
98 // All rights reserved.
99 //
100 // Redistribution and use in source and binary forms, with or without
101 // modification, are permitted provided that the following conditions are
102 // met:
103 //
104 //     * Redistributions of source code must retain the above copyright
105 // notice, this list of conditions and the following disclaimer.
106 //     * Redistributions in binary form must reproduce the above
107 // copyright notice, this list of conditions and the following disclaimer
108 // in the documentation and/or other materials provided with the
109 // distribution.
110 //     * Neither the name of Google Inc. nor the names of its
111 // contributors may be used to endorse or promote products derived from
112 // this software without specific prior written permission.
113 //
114 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
115 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
116 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
117 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
118 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
119 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
120 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
121 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
122 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
123 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
124 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
125 //
126 // Authors: wan@google.com (Zhanyong Wan)
127 //
128 // Low-level types and utilities for porting Google Test to various
129 // platforms.  They are subject to change without notice.  DO NOT USE
130 // THEM IN USER CODE.
131 //
132 // This file is fundamental to Google Test.  All other Google Test source
133 // files are expected to #include this.  Therefore, it cannot #include
134 // any other Google Test header.
135
136 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
137 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
138
139 // The user can define the following macros in the build script to
140 // control Google Test's behavior.  If the user doesn't define a macro
141 // in this list, Google Test will define it.
142 //
143 //   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)
144 //                              is/isn't available.
145 //   GTEST_HAS_EXCEPTIONS     - Define it to 1/0 to indicate that exceptions
146 //                              are enabled.
147 //   GTEST_HAS_GLOBAL_STRING  - Define it to 1/0 to indicate that ::string
148 //                              is/isn't available (some systems define
149 //                              ::string, which is different to std::string).
150 //   GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string
151 //                              is/isn't available (some systems define
152 //                              ::wstring, which is different to std::wstring).
153 //   GTEST_HAS_POSIX_RE       - Define it to 1/0 to indicate that POSIX regular
154 //                              expressions are/aren't available.
155 //   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>
156 //                              is/isn't available.
157 //   GTEST_HAS_RTTI           - Define it to 1/0 to indicate that RTTI is/isn't
158 //                              enabled.
159 //   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that
160 //                              std::wstring does/doesn't work (Google Test can
161 //                              be used where std::wstring is unavailable).
162 //   GTEST_HAS_TR1_TUPLE      - Define it to 1/0 to indicate tr1::tuple
163 //                              is/isn't available.
164 //   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the
165 //                              compiler supports Microsoft's "Structured
166 //                              Exception Handling".
167 //   GTEST_HAS_STREAM_REDIRECTION
168 //                            - Define it to 1/0 to indicate whether the
169 //                              platform supports I/O stream redirection using
170 //                              dup() and dup2().
171 //   GTEST_USE_OWN_TR1_TUPLE  - Define it to 1/0 to indicate whether Google
172 //                              Test's own tr1 tuple implementation should be
173 //                              used.  Unused when the user sets
174 //                              GTEST_HAS_TR1_TUPLE to 0.
175 //   GTEST_LANG_CXX11         - Define it to 1/0 to indicate that Google Test
176 //                              is building in C++11/C++98 mode.
177 //   GTEST_LINKED_AS_SHARED_LIBRARY
178 //                            - Define to 1 when compiling tests that use
179 //                              Google Test as a shared library (known as
180 //                              DLL on Windows).
181 //   GTEST_CREATE_SHARED_LIBRARY
182 //                            - Define to 1 when compiling Google Test itself
183 //                              as a shared library.
184
185 // This header defines the following utilities:
186 //
187 // Macros indicating the current platform (defined to 1 if compiled on
188 // the given platform; otherwise undefined):
189 //   GTEST_OS_AIX      - IBM AIX
190 //   GTEST_OS_CYGWIN   - Cygwin
191 //   GTEST_OS_HPUX     - HP-UX
192 //   GTEST_OS_LINUX    - Linux
193 //     GTEST_OS_LINUX_ANDROID - Google Android
194 //   GTEST_OS_MAC      - Mac OS X
195 //     GTEST_OS_IOS    - iOS
196 //       GTEST_OS_IOS_SIMULATOR - iOS simulator
197 //   GTEST_OS_NACL     - Google Native Client (NaCl)
198 //   GTEST_OS_OPENBSD  - OpenBSD
199 //   GTEST_OS_QNX      - QNX
200 //   GTEST_OS_SOLARIS  - Sun Solaris
201 //   GTEST_OS_SYMBIAN  - Symbian
202 //   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
203 //     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop
204 //     GTEST_OS_WINDOWS_MINGW    - MinGW
205 //     GTEST_OS_WINDOWS_MOBILE   - Windows Mobile
206 //   GTEST_OS_ZOS      - z/OS
207 //
208 // Among the platforms, Cygwin, Linux, Max OS X, and Windows have the
209 // most stable support.  Since core members of the Google Test project
210 // don't have access to other platforms, support for them may be less
211 // stable.  If you notice any problems on your platform, please notify
212 // googletestframework@googlegroups.com (patches for fixing them are
213 // even more welcome!).
214 //
215 // Note that it is possible that none of the GTEST_OS_* macros are defined.
216 //
217 // Macros indicating available Google Test features (defined to 1 if
218 // the corresponding feature is supported; otherwise undefined):
219 //   GTEST_HAS_COMBINE      - the Combine() function (for value-parameterized
220 //                            tests)
221 //   GTEST_HAS_DEATH_TEST   - death tests
222 //   GTEST_HAS_PARAM_TEST   - value-parameterized tests
223 //   GTEST_HAS_TYPED_TEST   - typed tests
224 //   GTEST_HAS_TYPED_TEST_P - type-parameterized tests
225 //   GTEST_USES_POSIX_RE    - enhanced POSIX regex is used. Do not confuse with
226 //                            GTEST_HAS_POSIX_RE (see above) which users can
227 //                            define themselves.
228 //   GTEST_USES_SIMPLE_RE   - our own simple regex is used;
229 //                            the above two are mutually exclusive.
230 //   GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ().
231 //
232 // Macros for basic C++ coding:
233 //   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
234 //   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a
235 //                              variable don't have to be used.
236 //   GTEST_DISALLOW_ASSIGN_   - disables operator=.
237 //   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
238 //   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
239 //
240 // Synchronization:
241 //   Mutex, MutexLock, ThreadLocal, GetThreadCount()
242 //                  - synchronization primitives.
243 //   GTEST_IS_THREADSAFE - defined to 1 to indicate that the above
244 //                         synchronization primitives have real implementations
245 //                         and Google Test is thread-safe; or 0 otherwise.
246 //
247 // Template meta programming:
248 //   is_pointer     - as in TR1; needed on Symbian and IBM XL C/C++ only.
249 //   IteratorTraits - partial implementation of std::iterator_traits, which
250 //                    is not available in libCstd when compiled with Sun C++.
251 //
252 // Smart pointers:
253 //   scoped_ptr     - as in TR2.
254 //
255 // Regular expressions:
256 //   RE             - a simple regular expression class using the POSIX
257 //                    Extended Regular Expression syntax on UNIX-like
258 //                    platforms, or a reduced regular exception syntax on
259 //                    other platforms, including Windows.
260 //
261 // Logging:
262 //   GTEST_LOG_()   - logs messages at the specified severity level.
263 //   LogToStderr()  - directs all log messages to stderr.
264 //   FlushInfoLog() - flushes informational log messages.
265 //
266 // Stdout and stderr capturing:
267 //   CaptureStdout()     - starts capturing stdout.
268 //   GetCapturedStdout() - stops capturing stdout and returns the captured
269 //                         string.
270 //   CaptureStderr()     - starts capturing stderr.
271 //   GetCapturedStderr() - stops capturing stderr and returns the captured
272 //                         string.
273 //
274 // Integer types:
275 //   TypeWithSize   - maps an integer to a int type.
276 //   Int32, UInt32, Int64, UInt64, TimeInMillis
277 //                  - integers of known sizes.
278 //   BiggestInt     - the biggest signed integer type.
279 //
280 // Command-line utilities:
281 //   GTEST_FLAG()       - references a flag.
282 //   GTEST_DECLARE_*()  - declares a flag.
283 //   GTEST_DEFINE_*()   - defines a flag.
284 //   GetInjectableArgvs() - returns the command line as a vector of strings.
285 //
286 // Environment variable utilities:
287 //   GetEnv()             - gets the value of an environment variable.
288 //   BoolFromGTestEnv()   - parses a bool environment variable.
289 //   Int32FromGTestEnv()  - parses an Int32 environment variable.
290 //   StringFromGTestEnv() - parses a string environment variable.
291
292 #include <ctype.h>   // for isspace, etc
293 #include <stddef.h>  // for ptrdiff_t
294 #include <stdlib.h>
295 #include <stdio.h>
296 #include <string.h>
297 #ifndef _WIN32_WCE
298 # include <sys/types.h>
299 # include <sys/stat.h>
300 #endif  // !_WIN32_WCE
301
302 #if defined __APPLE__
303 # include <AvailabilityMacros.h>
304 # include <TargetConditionals.h>
305 #endif
306
307 #include <iostream>  // NOLINT
308 #include <sstream>  // NOLINT
309 #include <string>  // NOLINT
310
311 #define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
312 #define GTEST_FLAG_PREFIX_ "gtest_"
313 #define GTEST_FLAG_PREFIX_DASH_ "gtest-"
314 #define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
315 #define GTEST_NAME_ "Google Test"
316 #define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/"
317
318 // Determines the version of gcc that is used to compile this.
319 #ifdef __GNUC__
320 // 40302 means version 4.3.2.
321 # define GTEST_GCC_VER_ \
322     (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
323 #endif  // __GNUC__
324
325 // Determines the platform on which Google Test is compiled.
326 #define GTEST_OS_CYGWIN 0
327 #define GTEST_OS_SYMBIAN 0
328 #define GTEST_OS_WINDOWS 0
329 #define GTEST_OS_WINDOWS_MOBILE 0
330 #define GTEST_OS_WINDOWS_MINGW 0
331 #define GTEST_OS_WINDOWS_DESKTOP 0
332 #define GTEST_OS_MAC 0
333 #define GTEST_OS_LINUX 0
334 #define GTEST_OS_LINUX_ANDROID 0
335 #define GTEST_OS_ZOS 0
336 #define GTEST_OS_SOLARIS 0
337 #define GTEST_OS_AIX 0
338 #define GTEST_OS_HPUX 0
339 #define GTEST_OS_NACL 0
340 #define GTEST_OS_OPENBSD 0
341 #define GTEST_OS_QNX 0
342 #define GTEST_OS_IOS 0
343 #define GTEST_OS_IOS_SIMULATOR 0
344
345 #ifdef __CYGWIN__
346 # undef GTEST_OS_CYGWIN
347 # define GTEST_OS_CYGWIN 1
348 #elif defined __SYMBIAN32__
349 # undef GTEST_OS_SYMBIAN
350 # define GTEST_OS_SYMBIAN 1
351 #elif defined _WIN32
352 # undef GTEST_OS_WINDOWS
353 # define GTEST_OS_WINDOWS 1
354 # ifdef _WIN32_WCE
355 #  undef GTEST_OS_WINDOWS_MOBILE
356 #  define GTEST_OS_WINDOWS_MOBILE 1
357 # elif defined(__MINGW__) || defined(__MINGW32__)
358 #  undef GTEST_OS_WINDOWS_MINGW
359 #  define GTEST_OS_WINDOWS_MINGW 1
360 # else
361 #  undef GTEST_OS_WINDOWS_DESKTOP
362 #  define GTEST_OS_WINDOWS_DESKTOP 1
363 # endif  // _WIN32_WCE
364 #elif defined __APPLE__
365 # undef GTEST_OS_MAC
366 # define GTEST_OS_MAC 1
367 # if TARGET_OS_IPHONE
368 #  undef GTEST_OS_IOS
369 #  define GTEST_OS_IOS 1
370 #  if TARGET_IPHONE_SIMULATOR
371 #   undef GTEST_OS_IOS_SIMULATOR
372 #   define GTEST_OS_IOS_SIMULATOR 1
373 #  endif
374 # endif
375 #elif defined __linux__
376 # undef GTEST_OS_LINUX
377 # define GTEST_OS_LINUX 1
378 # if defined __ANDROID__
379 #  undef GTEST_OS_LINUX_ANDROID
380 #  define GTEST_OS_LINUX_ANDROID 1
381 # endif
382 #elif defined __MVS__
383 # undef GTEST_OS_ZOS
384 # define GTEST_OS_ZOS 1
385 #elif defined(__sun) && defined(__SVR4)
386 # undef GTEST_OS_SOLARIS
387 # define GTEST_OS_SOLARIS 1
388 #elif defined(_AIX)
389 # undef GTEST_OS_AIX
390 # define GTEST_OS_AIX 1
391 #elif defined(__hpux)
392 # undef GTEST_OS_HPUX
393 # define GTEST_OS_HPUX 1
394 #elif defined __native_client__
395 # undef GTEST_OS_NACL
396 # define GTEST_OS_NACL 1
397 #elif defined __OpenBSD__
398 # undef GTEST_OS_OPENBSD
399 # define GTEST_OS_OPENBSD 1
400 #elif defined __QNX__
401 # undef GTEST_OS_QNX
402 # define GTEST_OS_QNX 1
403 #endif  // __CYGWIN__
404
405 #ifndef GTEST_LANG_CXX11
406 // gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when
407 // -std={c,gnu}++{0x,11} is passed.  The C++11 standard specifies a
408 // value for __cplusplus, and recent versions of clang, gcc, and
409 // probably other compilers set that too in C++11 mode.
410 # if defined __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L
411 // Compiling in at least C++11 mode.
412 #  define GTEST_LANG_CXX11 1
413 # else
414 #  define GTEST_LANG_CXX11 0
415 # endif
416 #endif
417
418 // Brings in definitions for functions used in the testing::internal::posix
419 // namespace (read, write, close, chdir, isatty, stat). We do not currently
420 // use them on Windows Mobile.
421 #if !GTEST_OS_WINDOWS
422 // This assumes that non-Windows OSes provide unistd.h. For OSes where this
423 // is not the case, we need to include headers that provide the functions
424 // mentioned above.
425 # include <unistd.h>
426 # include <strings.h>
427 #elif !GTEST_OS_WINDOWS_MOBILE
428 # include <direct.h>
429 # include <io.h>
430 #endif
431
432 #if GTEST_OS_LINUX_ANDROID
433 // Used to define __ANDROID_API__ matching the target NDK API level.
434 #  include <android/api-level.h>  // NOLINT
435 #endif
436
437 // Defines this to true iff Google Test can use POSIX regular expressions.
438 #ifndef GTEST_HAS_POSIX_RE
439 # if GTEST_OS_LINUX_ANDROID
440 // On Android, <regex.h> is only available starting with Froyo.
441 #  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 8)
442 # else
443 # define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS)
444 #endif
445 #endif
446
447 #if GTEST_HAS_POSIX_RE
448
449 // On some platforms, <regex.h> needs someone to define size_t, and
450 // won't compile otherwise.  We can #include it here as we already
451 // included <stdlib.h>, which is guaranteed to define size_t through
452 // <stddef.h>.
453 # include <regex.h>  // NOLINT
454
455 # define GTEST_USES_POSIX_RE 1
456 # define GTEST_USES_SIMPLE_RE 0
457
458 #elif GTEST_OS_WINDOWS
459
460 // <regex.h> is not available on Windows.  Use our own simple regex
461 // implementation instead.
462 # define GTEST_USES_SIMPLE_RE 1
463 # define GTEST_USES_POSIX_RE  0
464
465 #else
466
467 // <regex.h> may not be available on this platform.  Use our own
468 // simple regex implementation instead.
469 # define GTEST_USES_SIMPLE_RE 1
470 # define GTEST_USES_POSIX_RE  0
471
472 #endif  // GTEST_HAS_POSIX_RE
473
474 #ifndef GTEST_HAS_EXCEPTIONS
475 // The user didn't tell us whether exceptions are enabled, so we need
476 // to figure it out.
477 # if defined(_MSC_VER) || defined(__BORLANDC__)
478 // MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS
479 // macro to enable exceptions, so we'll do the same.
480 // Assumes that exceptions are enabled by default.
481 #  ifndef _HAS_EXCEPTIONS
482 #   define _HAS_EXCEPTIONS 1
483 #  endif  // _HAS_EXCEPTIONS
484 #  define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
485 # elif defined(__GNUC__) && __EXCEPTIONS
486 // gcc defines __EXCEPTIONS to 1 iff exceptions are enabled.
487 #  define GTEST_HAS_EXCEPTIONS 1
488 # elif defined(__SUNPRO_CC)
489 // Sun Pro CC supports exceptions.  However, there is no compile-time way of
490 // detecting whether they are enabled or not.  Therefore, we assume that
491 // they are enabled unless the user tells us otherwise.
492 #  define GTEST_HAS_EXCEPTIONS 1
493 # elif defined(__IBMCPP__) && __EXCEPTIONS
494 // xlC defines __EXCEPTIONS to 1 iff exceptions are enabled.
495 #  define GTEST_HAS_EXCEPTIONS 1
496 # elif defined(__HP_aCC)
497 // Exception handling is in effect by default in HP aCC compiler. It has to
498 // be turned of by +noeh compiler option if desired.
499 #  define GTEST_HAS_EXCEPTIONS 1
500 # else
501 // For other compilers, we assume exceptions are disabled to be
502 // conservative.
503 #  define GTEST_HAS_EXCEPTIONS 0
504 # endif  // defined(_MSC_VER) || defined(__BORLANDC__)
505 #endif  // GTEST_HAS_EXCEPTIONS
506
507 #if !defined(GTEST_HAS_STD_STRING)
508 // Even though we don't use this macro any longer, we keep it in case
509 // some clients still depend on it.
510 # define GTEST_HAS_STD_STRING 1
511 #elif !GTEST_HAS_STD_STRING
512 // The user told us that ::std::string isn't available.
513 # error "Google Test cannot be used where ::std::string isn't available."
514 #endif  // !defined(GTEST_HAS_STD_STRING)
515
516 #ifndef GTEST_HAS_GLOBAL_STRING
517 // The user didn't tell us whether ::string is available, so we need
518 // to figure it out.
519
520 # define GTEST_HAS_GLOBAL_STRING 0
521
522 #endif  // GTEST_HAS_GLOBAL_STRING
523
524 #ifndef GTEST_HAS_STD_WSTRING
525 // The user didn't tell us whether ::std::wstring is available, so we need
526 // to figure it out.
527 // TODO(wan@google.com): uses autoconf to detect whether ::std::wstring
528 //   is available.
529
530 // Cygwin 1.7 and below doesn't support ::std::wstring.
531 // Solaris' libc++ doesn't support it either.  Android has
532 // no support for it at least as recent as Froyo (2.2).
533 # define GTEST_HAS_STD_WSTRING \
534     (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS))
535
536 #endif  // GTEST_HAS_STD_WSTRING
537
538 #ifndef GTEST_HAS_GLOBAL_WSTRING
539 // The user didn't tell us whether ::wstring is available, so we need
540 // to figure it out.
541 # define GTEST_HAS_GLOBAL_WSTRING \
542     (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
543 #endif  // GTEST_HAS_GLOBAL_WSTRING
544
545 // Determines whether RTTI is available.
546 #ifndef GTEST_HAS_RTTI
547 // The user didn't tell us whether RTTI is enabled, so we need to
548 // figure it out.
549
550 # ifdef _MSC_VER
551
552 #  ifdef _CPPRTTI  // MSVC defines this macro iff RTTI is enabled.
553 #   define GTEST_HAS_RTTI 1
554 #  else
555 #   define GTEST_HAS_RTTI 0
556 #  endif
557
558 // Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled.
559 # elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302)
560
561 #  ifdef __GXX_RTTI
562 // When building against STLport with the Android NDK and with
563 // -frtti -fno-exceptions, the build fails at link time with undefined
564 // references to __cxa_bad_typeid. Note sure if STL or toolchain bug,
565 // so disable RTTI when detected.
566 #   if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
567        !defined(__EXCEPTIONS)
568 #    define GTEST_HAS_RTTI 0
569 #   else
570 #   define GTEST_HAS_RTTI 1
571 #   endif  // GTEST_OS_LINUX_ANDROID && _STLPORT_MAJOR && !__EXCEPTIONS
572 #  else
573 #   define GTEST_HAS_RTTI 0
574 #  endif  // __GXX_RTTI
575
576 // Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends
577 // using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the
578 // first version with C++ support.
579 # elif defined(__clang__)
580
581 #  define GTEST_HAS_RTTI __has_feature(cxx_rtti)
582
583 // Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
584 // both the typeid and dynamic_cast features are present.
585 # elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
586
587 #  ifdef __RTTI_ALL__
588 #   define GTEST_HAS_RTTI 1
589 #  else
590 #   define GTEST_HAS_RTTI 0
591 #  endif
592
593 # else
594
595 // For all other compilers, we assume RTTI is enabled.
596 #  define GTEST_HAS_RTTI 1
597
598 # endif  // _MSC_VER
599
600 #endif  // GTEST_HAS_RTTI
601
602 // It's this header's responsibility to #include <typeinfo> when RTTI
603 // is enabled.
604 #if GTEST_HAS_RTTI
605 # include <typeinfo>
606 #endif
607
608 // Determines whether Google Test can use the pthreads library.
609 #ifndef GTEST_HAS_PTHREAD
610 // The user didn't tell us explicitly, so we assume pthreads support is
611 // available on Linux and Mac.
612 //
613 // To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
614 // to your compiler flags.
615 # define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX \
616     || GTEST_OS_QNX)
617 #endif  // GTEST_HAS_PTHREAD
618
619 #if GTEST_HAS_PTHREAD
620 // gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is
621 // true.
622 # include <pthread.h>  // NOLINT
623
624 // For timespec and nanosleep, used below.
625 # include <time.h>  // NOLINT
626 #endif
627
628 // Determines whether Google Test can use tr1/tuple.  You can define
629 // this macro to 0 to prevent Google Test from using tuple (any
630 // feature depending on tuple with be disabled in this mode).
631 #ifndef GTEST_HAS_TR1_TUPLE
632 # if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR)
633 // STLport, provided with the Android NDK, has neither <tr1/tuple> or <tuple>.
634 #  define GTEST_HAS_TR1_TUPLE 0
635 # else
636 // The user didn't tell us not to do it, so we assume it's OK.
637 # define GTEST_HAS_TR1_TUPLE 1
638 # endif
639 #endif  // GTEST_HAS_TR1_TUPLE
640
641 // Determines whether Google Test's own tr1 tuple implementation
642 // should be used.
643 #ifndef GTEST_USE_OWN_TR1_TUPLE
644 // The user didn't tell us, so we need to figure it out.
645
646 // We use our own TR1 tuple if we aren't sure the user has an
647 // implementation of it already.  At this time, libstdc++ 4.0.0+ and
648 // MSVC 2010 are the only mainstream standard libraries that come
649 // with a TR1 tuple implementation.  NVIDIA's CUDA NVCC compiler
650 // pretends to be GCC by defining __GNUC__ and friends, but cannot
651 // compile GCC's tuple implementation.  MSVC 2008 (9.0) provides TR1
652 // tuple in a 323 MB Feature Pack download, which we cannot assume the
653 // user has.  QNX's QCC compiler is a modified GCC but it doesn't
654 // support TR1 tuple.  libc++ only provides std::tuple, in C++11 mode,
655 // and it can be used with some compilers that define __GNUC__.
656 # if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \
657       && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) && !defined(_STLPORT_MAJOR) \
658       || (defined(_MSC_VER) && _MSC_VER >= 1600)
659 #  define GTEST_ENV_HAS_TR1_TUPLE_ 1
660 # else
661 #  define GTEST_ENV_HAS_TR1_TUPLE_ 0
662 # endif
663
664 // C++11 specifies that <tuple> provides std::tuple. Use that if gtest is used
665 // in C++11 mode and libstdc++ isn't very old (binaries targeting OS X 10.6
666 // can build with clang but need to use gcc4.2's libstdc++).
667 # if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325)
668 #  define GTEST_ENV_HAS_STD_TUPLE_ 1
669 # else
670 #  define GTEST_ENV_HAS_STD_TUPLE_ 0
671 # endif
672
673 # if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_
674 #  define GTEST_USE_OWN_TR1_TUPLE 0
675 # else
676 #  define GTEST_USE_OWN_TR1_TUPLE 1
677 #  undef  GTEST_HAS_TR1_TUPLE
678 #  define GTEST_HAS_TR1_TUPLE 1
679 # endif
680
681 #endif  // GTEST_USE_OWN_TR1_TUPLE
682
683 // To avoid conditional compilation everywhere, we make it
684 // gtest-port.h's responsibility to #include the header implementing
685 // tr1/tuple.
686 #if GTEST_HAS_TR1_TUPLE
687
688 # if GTEST_USE_OWN_TR1_TUPLE
689 // This file was GENERATED by command:
690 //     pump.py gtest-tuple.h.pump
691 // DO NOT EDIT BY HAND!!!
692
693 // Copyright 2009 Google Inc.
694 // All Rights Reserved.
695 //
696 // Redistribution and use in source and binary forms, with or without
697 // modification, are permitted provided that the following conditions are
698 // met:
699 //
700 //     * Redistributions of source code must retain the above copyright
701 // notice, this list of conditions and the following disclaimer.
702 //     * Redistributions in binary form must reproduce the above
703 // copyright notice, this list of conditions and the following disclaimer
704 // in the documentation and/or other materials provided with the
705 // distribution.
706 //     * Neither the name of Google Inc. nor the names of its
707 // contributors may be used to endorse or promote products derived from
708 // this software without specific prior written permission.
709 //
710 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
711 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
712 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
713 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
714 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
715 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
716 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
717 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
718 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
719 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
720 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
721 //
722 // Author: wan@google.com (Zhanyong Wan)
723
724 // Implements a subset of TR1 tuple needed by Google Test and Google Mock.
725
726 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
727 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
728
729 #include <utility>  // For ::std::pair.
730
731 // The compiler used in Symbian has a bug that prevents us from declaring the
732 // tuple template as a friend (it complains that tuple is redefined).  This
733 // hack bypasses the bug by declaring the members that should otherwise be
734 // private as public.
735 // Sun Studio versions < 12 also have the above bug.
736 #if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)
737 # define GTEST_DECLARE_TUPLE_AS_FRIEND_ public:
738 #else
739 # define GTEST_DECLARE_TUPLE_AS_FRIEND_ \
740     template <GTEST_10_TYPENAMES_(U)> friend class tuple; \
741    private:
742 #endif
743
744 // GTEST_n_TUPLE_(T) is the type of an n-tuple.
745 #define GTEST_0_TUPLE_(T) tuple<>
746 #define GTEST_1_TUPLE_(T) tuple<T##0, void, void, void, void, void, void, \
747     void, void, void>
748 #define GTEST_2_TUPLE_(T) tuple<T##0, T##1, void, void, void, void, void, \
749     void, void, void>
750 #define GTEST_3_TUPLE_(T) tuple<T##0, T##1, T##2, void, void, void, void, \
751     void, void, void>
752 #define GTEST_4_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, void, void, void, \
753     void, void, void>
754 #define GTEST_5_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, void, void, \
755     void, void, void>
756 #define GTEST_6_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, void, \
757     void, void, void>
758 #define GTEST_7_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
759     void, void, void>
760 #define GTEST_8_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
761     T##7, void, void>
762 #define GTEST_9_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
763     T##7, T##8, void>
764 #define GTEST_10_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
765     T##7, T##8, T##9>
766
767 // GTEST_n_TYPENAMES_(T) declares a list of n typenames.
768 #define GTEST_0_TYPENAMES_(T)
769 #define GTEST_1_TYPENAMES_(T) typename T##0
770 #define GTEST_2_TYPENAMES_(T) typename T##0, typename T##1
771 #define GTEST_3_TYPENAMES_(T) typename T##0, typename T##1, typename T##2
772 #define GTEST_4_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
773     typename T##3
774 #define GTEST_5_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
775     typename T##3, typename T##4
776 #define GTEST_6_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
777     typename T##3, typename T##4, typename T##5
778 #define GTEST_7_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
779     typename T##3, typename T##4, typename T##5, typename T##6
780 #define GTEST_8_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
781     typename T##3, typename T##4, typename T##5, typename T##6, typename T##7
782 #define GTEST_9_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
783     typename T##3, typename T##4, typename T##5, typename T##6, \
784     typename T##7, typename T##8
785 #define GTEST_10_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
786     typename T##3, typename T##4, typename T##5, typename T##6, \
787     typename T##7, typename T##8, typename T##9
788
789 // In theory, defining stuff in the ::std namespace is undefined
790 // behavior.  We can do this as we are playing the role of a standard
791 // library vendor.
792 namespace std {
793 namespace tr1 {
794
795 template <typename T0 = void, typename T1 = void, typename T2 = void,
796     typename T3 = void, typename T4 = void, typename T5 = void,
797     typename T6 = void, typename T7 = void, typename T8 = void,
798     typename T9 = void>
799 class tuple;
800
801 // Anything in namespace gtest_internal is Google Test's INTERNAL
802 // IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code.
803 namespace gtest_internal {
804
805 // ByRef<T>::type is T if T is a reference; otherwise it's const T&.
806 template <typename T>
807 struct ByRef { typedef const T& type; };  // NOLINT
808 template <typename T>
809 struct ByRef<T&> { typedef T& type; };  // NOLINT
810
811 // A handy wrapper for ByRef.
812 #define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type
813
814 // AddRef<T>::type is T if T is a reference; otherwise it's T&.  This
815 // is the same as tr1::add_reference<T>::type.
816 template <typename T>
817 struct AddRef { typedef T& type; };  // NOLINT
818 template <typename T>
819 struct AddRef<T&> { typedef T& type; };  // NOLINT
820
821 // A handy wrapper for AddRef.
822 #define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type
823
824 // A helper for implementing get<k>().
825 template <int k> class Get;
826
827 // A helper for implementing tuple_element<k, T>.  kIndexValid is true
828 // iff k < the number of fields in tuple type T.
829 template <bool kIndexValid, int kIndex, class Tuple>
830 struct TupleElement;
831
832 template <GTEST_10_TYPENAMES_(T)>
833 struct TupleElement<true, 0, GTEST_10_TUPLE_(T)> {
834   typedef T0 type;
835 };
836
837 template <GTEST_10_TYPENAMES_(T)>
838 struct TupleElement<true, 1, GTEST_10_TUPLE_(T)> {
839   typedef T1 type;
840 };
841
842 template <GTEST_10_TYPENAMES_(T)>
843 struct TupleElement<true, 2, GTEST_10_TUPLE_(T)> {
844   typedef T2 type;
845 };
846
847 template <GTEST_10_TYPENAMES_(T)>
848 struct TupleElement<true, 3, GTEST_10_TUPLE_(T)> {
849   typedef T3 type;
850 };
851
852 template <GTEST_10_TYPENAMES_(T)>
853 struct TupleElement<true, 4, GTEST_10_TUPLE_(T)> {
854   typedef T4 type;
855 };
856
857 template <GTEST_10_TYPENAMES_(T)>
858 struct TupleElement<true, 5, GTEST_10_TUPLE_(T)> {
859   typedef T5 type;
860 };
861
862 template <GTEST_10_TYPENAMES_(T)>
863 struct TupleElement<true, 6, GTEST_10_TUPLE_(T)> {
864   typedef T6 type;
865 };
866
867 template <GTEST_10_TYPENAMES_(T)>
868 struct TupleElement<true, 7, GTEST_10_TUPLE_(T)> {
869   typedef T7 type;
870 };
871
872 template <GTEST_10_TYPENAMES_(T)>
873 struct TupleElement<true, 8, GTEST_10_TUPLE_(T)> {
874   typedef T8 type;
875 };
876
877 template <GTEST_10_TYPENAMES_(T)>
878 struct TupleElement<true, 9, GTEST_10_TUPLE_(T)> {
879   typedef T9 type;
880 };
881
882 }  // namespace gtest_internal
883
884 template <>
885 class tuple<> {
886  public:
887   tuple() {}
888   tuple(const tuple& /* t */)  {}
889   tuple& operator=(const tuple& /* t */) { return *this; }
890 };
891
892 template <GTEST_1_TYPENAMES_(T)>
893 class GTEST_1_TUPLE_(T) {
894  public:
895   template <int k> friend class gtest_internal::Get;
896
897   tuple() : f0_() {}
898
899   explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {}
900
901   tuple(const tuple& t) : f0_(t.f0_) {}
902
903   template <GTEST_1_TYPENAMES_(U)>
904   tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {}
905
906   tuple& operator=(const tuple& t) { return CopyFrom(t); }
907
908   template <GTEST_1_TYPENAMES_(U)>
909   tuple& operator=(const GTEST_1_TUPLE_(U)& t) {
910     return CopyFrom(t);
911   }
912
913   GTEST_DECLARE_TUPLE_AS_FRIEND_
914
915   template <GTEST_1_TYPENAMES_(U)>
916   tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) {
917     f0_ = t.f0_;
918     return *this;
919   }
920
921   T0 f0_;
922 };
923
924 template <GTEST_2_TYPENAMES_(T)>
925 class GTEST_2_TUPLE_(T) {
926  public:
927   template <int k> friend class gtest_internal::Get;
928
929   tuple() : f0_(), f1_() {}
930
931   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0),
932       f1_(f1) {}
933
934   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {}
935
936   template <GTEST_2_TYPENAMES_(U)>
937   tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {}
938   template <typename U0, typename U1>
939   tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {}
940
941   tuple& operator=(const tuple& t) { return CopyFrom(t); }
942
943   template <GTEST_2_TYPENAMES_(U)>
944   tuple& operator=(const GTEST_2_TUPLE_(U)& t) {
945     return CopyFrom(t);
946   }
947   template <typename U0, typename U1>
948   tuple& operator=(const ::std::pair<U0, U1>& p) {
949     f0_ = p.first;
950     f1_ = p.second;
951     return *this;
952   }
953
954   GTEST_DECLARE_TUPLE_AS_FRIEND_
955
956   template <GTEST_2_TYPENAMES_(U)>
957   tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) {
958     f0_ = t.f0_;
959     f1_ = t.f1_;
960     return *this;
961   }
962
963   T0 f0_;
964   T1 f1_;
965 };
966
967 template <GTEST_3_TYPENAMES_(T)>
968 class GTEST_3_TUPLE_(T) {
969  public:
970   template <int k> friend class gtest_internal::Get;
971
972   tuple() : f0_(), f1_(), f2_() {}
973
974   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
975       GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {}
976
977   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
978
979   template <GTEST_3_TYPENAMES_(U)>
980   tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
981
982   tuple& operator=(const tuple& t) { return CopyFrom(t); }
983
984   template <GTEST_3_TYPENAMES_(U)>
985   tuple& operator=(const GTEST_3_TUPLE_(U)& t) {
986     return CopyFrom(t);
987   }
988
989   GTEST_DECLARE_TUPLE_AS_FRIEND_
990
991   template <GTEST_3_TYPENAMES_(U)>
992   tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) {
993     f0_ = t.f0_;
994     f1_ = t.f1_;
995     f2_ = t.f2_;
996     return *this;
997   }
998
999   T0 f0_;
1000   T1 f1_;
1001   T2 f2_;
1002 };
1003
1004 template <GTEST_4_TYPENAMES_(T)>
1005 class GTEST_4_TUPLE_(T) {
1006  public:
1007   template <int k> friend class gtest_internal::Get;
1008
1009   tuple() : f0_(), f1_(), f2_(), f3_() {}
1010
1011   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1012       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1), f2_(f2),
1013       f3_(f3) {}
1014
1015   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {}
1016
1017   template <GTEST_4_TYPENAMES_(U)>
1018   tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1019       f3_(t.f3_) {}
1020
1021   tuple& operator=(const tuple& t) { return CopyFrom(t); }
1022
1023   template <GTEST_4_TYPENAMES_(U)>
1024   tuple& operator=(const GTEST_4_TUPLE_(U)& t) {
1025     return CopyFrom(t);
1026   }
1027
1028   GTEST_DECLARE_TUPLE_AS_FRIEND_
1029
1030   template <GTEST_4_TYPENAMES_(U)>
1031   tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) {
1032     f0_ = t.f0_;
1033     f1_ = t.f1_;
1034     f2_ = t.f2_;
1035     f3_ = t.f3_;
1036     return *this;
1037   }
1038
1039   T0 f0_;
1040   T1 f1_;
1041   T2 f2_;
1042   T3 f3_;
1043 };
1044
1045 template <GTEST_5_TYPENAMES_(T)>
1046 class GTEST_5_TUPLE_(T) {
1047  public:
1048   template <int k> friend class gtest_internal::Get;
1049
1050   tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {}
1051
1052   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1053       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3,
1054       GTEST_BY_REF_(T4) f4) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4) {}
1055
1056   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1057       f4_(t.f4_) {}
1058
1059   template <GTEST_5_TYPENAMES_(U)>
1060   tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1061       f3_(t.f3_), f4_(t.f4_) {}
1062
1063   tuple& operator=(const tuple& t) { return CopyFrom(t); }
1064
1065   template <GTEST_5_TYPENAMES_(U)>
1066   tuple& operator=(const GTEST_5_TUPLE_(U)& t) {
1067     return CopyFrom(t);
1068   }
1069
1070   GTEST_DECLARE_TUPLE_AS_FRIEND_
1071
1072   template <GTEST_5_TYPENAMES_(U)>
1073   tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) {
1074     f0_ = t.f0_;
1075     f1_ = t.f1_;
1076     f2_ = t.f2_;
1077     f3_ = t.f3_;
1078     f4_ = t.f4_;
1079     return *this;
1080   }
1081
1082   T0 f0_;
1083   T1 f1_;
1084   T2 f2_;
1085   T3 f3_;
1086   T4 f4_;
1087 };
1088
1089 template <GTEST_6_TYPENAMES_(T)>
1090 class GTEST_6_TUPLE_(T) {
1091  public:
1092   template <int k> friend class gtest_internal::Get;
1093
1094   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {}
1095
1096   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1097       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
1098       GTEST_BY_REF_(T5) f5) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
1099       f5_(f5) {}
1100
1101   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1102       f4_(t.f4_), f5_(t.f5_) {}
1103
1104   template <GTEST_6_TYPENAMES_(U)>
1105   tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1106       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {}
1107
1108   tuple& operator=(const tuple& t) { return CopyFrom(t); }
1109
1110   template <GTEST_6_TYPENAMES_(U)>
1111   tuple& operator=(const GTEST_6_TUPLE_(U)& t) {
1112     return CopyFrom(t);
1113   }
1114
1115   GTEST_DECLARE_TUPLE_AS_FRIEND_
1116
1117   template <GTEST_6_TYPENAMES_(U)>
1118   tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) {
1119     f0_ = t.f0_;
1120     f1_ = t.f1_;
1121     f2_ = t.f2_;
1122     f3_ = t.f3_;
1123     f4_ = t.f4_;
1124     f5_ = t.f5_;
1125     return *this;
1126   }
1127
1128   T0 f0_;
1129   T1 f1_;
1130   T2 f2_;
1131   T3 f3_;
1132   T4 f4_;
1133   T5 f5_;
1134 };
1135
1136 template <GTEST_7_TYPENAMES_(T)>
1137 class GTEST_7_TUPLE_(T) {
1138  public:
1139   template <int k> friend class gtest_internal::Get;
1140
1141   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {}
1142
1143   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1144       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
1145       GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6) : f0_(f0), f1_(f1), f2_(f2),
1146       f3_(f3), f4_(f4), f5_(f5), f6_(f6) {}
1147
1148   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1149       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
1150
1151   template <GTEST_7_TYPENAMES_(U)>
1152   tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1153       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
1154
1155   tuple& operator=(const tuple& t) { return CopyFrom(t); }
1156
1157   template <GTEST_7_TYPENAMES_(U)>
1158   tuple& operator=(const GTEST_7_TUPLE_(U)& t) {
1159     return CopyFrom(t);
1160   }
1161
1162   GTEST_DECLARE_TUPLE_AS_FRIEND_
1163
1164   template <GTEST_7_TYPENAMES_(U)>
1165   tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) {
1166     f0_ = t.f0_;
1167     f1_ = t.f1_;
1168     f2_ = t.f2_;
1169     f3_ = t.f3_;
1170     f4_ = t.f4_;
1171     f5_ = t.f5_;
1172     f6_ = t.f6_;
1173     return *this;
1174   }
1175
1176   T0 f0_;
1177   T1 f1_;
1178   T2 f2_;
1179   T3 f3_;
1180   T4 f4_;
1181   T5 f5_;
1182   T6 f6_;
1183 };
1184
1185 template <GTEST_8_TYPENAMES_(T)>
1186 class GTEST_8_TUPLE_(T) {
1187  public:
1188   template <int k> friend class gtest_internal::Get;
1189
1190   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {}
1191
1192   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1193       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
1194       GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6,
1195       GTEST_BY_REF_(T7) f7) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
1196       f5_(f5), f6_(f6), f7_(f7) {}
1197
1198   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1199       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
1200
1201   template <GTEST_8_TYPENAMES_(U)>
1202   tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1203       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
1204
1205   tuple& operator=(const tuple& t) { return CopyFrom(t); }
1206
1207   template <GTEST_8_TYPENAMES_(U)>
1208   tuple& operator=(const GTEST_8_TUPLE_(U)& t) {
1209     return CopyFrom(t);
1210   }
1211
1212   GTEST_DECLARE_TUPLE_AS_FRIEND_
1213
1214   template <GTEST_8_TYPENAMES_(U)>
1215   tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) {
1216     f0_ = t.f0_;
1217     f1_ = t.f1_;
1218     f2_ = t.f2_;
1219     f3_ = t.f3_;
1220     f4_ = t.f4_;
1221     f5_ = t.f5_;
1222     f6_ = t.f6_;
1223     f7_ = t.f7_;
1224     return *this;
1225   }
1226
1227   T0 f0_;
1228   T1 f1_;
1229   T2 f2_;
1230   T3 f3_;
1231   T4 f4_;
1232   T5 f5_;
1233   T6 f6_;
1234   T7 f7_;
1235 };
1236
1237 template <GTEST_9_TYPENAMES_(T)>
1238 class GTEST_9_TUPLE_(T) {
1239  public:
1240   template <int k> friend class gtest_internal::Get;
1241
1242   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_() {}
1243
1244   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1245       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
1246       GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
1247       GTEST_BY_REF_(T8) f8) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
1248       f5_(f5), f6_(f6), f7_(f7), f8_(f8) {}
1249
1250   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1251       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
1252
1253   template <GTEST_9_TYPENAMES_(U)>
1254   tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1255       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
1256
1257   tuple& operator=(const tuple& t) { return CopyFrom(t); }
1258
1259   template <GTEST_9_TYPENAMES_(U)>
1260   tuple& operator=(const GTEST_9_TUPLE_(U)& t) {
1261     return CopyFrom(t);
1262   }
1263
1264   GTEST_DECLARE_TUPLE_AS_FRIEND_
1265
1266   template <GTEST_9_TYPENAMES_(U)>
1267   tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) {
1268     f0_ = t.f0_;
1269     f1_ = t.f1_;
1270     f2_ = t.f2_;
1271     f3_ = t.f3_;
1272     f4_ = t.f4_;
1273     f5_ = t.f5_;
1274     f6_ = t.f6_;
1275     f7_ = t.f7_;
1276     f8_ = t.f8_;
1277     return *this;
1278   }
1279
1280   T0 f0_;
1281   T1 f1_;
1282   T2 f2_;
1283   T3 f3_;
1284   T4 f4_;
1285   T5 f5_;
1286   T6 f6_;
1287   T7 f7_;
1288   T8 f8_;
1289 };
1290
1291 template <GTEST_10_TYPENAMES_(T)>
1292 class tuple {
1293  public:
1294   template <int k> friend class gtest_internal::Get;
1295
1296   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(),
1297       f9_() {}
1298
1299   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1300       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
1301       GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
1302       GTEST_BY_REF_(T8) f8, GTEST_BY_REF_(T9) f9) : f0_(f0), f1_(f1), f2_(f2),
1303       f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8), f9_(f9) {}
1304
1305   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1306       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {}
1307
1308   template <GTEST_10_TYPENAMES_(U)>
1309   tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1310       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_),
1311       f9_(t.f9_) {}
1312
1313   tuple& operator=(const tuple& t) { return CopyFrom(t); }
1314
1315   template <GTEST_10_TYPENAMES_(U)>
1316   tuple& operator=(const GTEST_10_TUPLE_(U)& t) {
1317     return CopyFrom(t);
1318   }
1319
1320   GTEST_DECLARE_TUPLE_AS_FRIEND_
1321
1322   template <GTEST_10_TYPENAMES_(U)>
1323   tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) {
1324     f0_ = t.f0_;
1325     f1_ = t.f1_;
1326     f2_ = t.f2_;
1327     f3_ = t.f3_;
1328     f4_ = t.f4_;
1329     f5_ = t.f5_;
1330     f6_ = t.f6_;
1331     f7_ = t.f7_;
1332     f8_ = t.f8_;
1333     f9_ = t.f9_;
1334     return *this;
1335   }
1336
1337   T0 f0_;
1338   T1 f1_;
1339   T2 f2_;
1340   T3 f3_;
1341   T4 f4_;
1342   T5 f5_;
1343   T6 f6_;
1344   T7 f7_;
1345   T8 f8_;
1346   T9 f9_;
1347 };
1348
1349 // 6.1.3.2 Tuple creation functions.
1350
1351 // Known limitations: we don't support passing an
1352 // std::tr1::reference_wrapper<T> to make_tuple().  And we don't
1353 // implement tie().
1354
1355 inline tuple<> make_tuple() { return tuple<>(); }
1356
1357 template <GTEST_1_TYPENAMES_(T)>
1358 inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) {
1359   return GTEST_1_TUPLE_(T)(f0);
1360 }
1361
1362 template <GTEST_2_TYPENAMES_(T)>
1363 inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) {
1364   return GTEST_2_TUPLE_(T)(f0, f1);
1365 }
1366
1367 template <GTEST_3_TYPENAMES_(T)>
1368 inline GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) {
1369   return GTEST_3_TUPLE_(T)(f0, f1, f2);
1370 }
1371
1372 template <GTEST_4_TYPENAMES_(T)>
1373 inline GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1374     const T3& f3) {
1375   return GTEST_4_TUPLE_(T)(f0, f1, f2, f3);
1376 }
1377
1378 template <GTEST_5_TYPENAMES_(T)>
1379 inline GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1380     const T3& f3, const T4& f4) {
1381   return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4);
1382 }
1383
1384 template <GTEST_6_TYPENAMES_(T)>
1385 inline GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1386     const T3& f3, const T4& f4, const T5& f5) {
1387   return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5);
1388 }
1389
1390 template <GTEST_7_TYPENAMES_(T)>
1391 inline GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1392     const T3& f3, const T4& f4, const T5& f5, const T6& f6) {
1393   return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6);
1394 }
1395
1396 template <GTEST_8_TYPENAMES_(T)>
1397 inline GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1398     const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7) {
1399   return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7);
1400 }
1401
1402 template <GTEST_9_TYPENAMES_(T)>
1403 inline GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1404     const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
1405     const T8& f8) {
1406   return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8);
1407 }
1408
1409 template <GTEST_10_TYPENAMES_(T)>
1410 inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1411     const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
1412     const T8& f8, const T9& f9) {
1413   return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9);
1414 }
1415
1416 // 6.1.3.3 Tuple helper classes.
1417
1418 template <typename Tuple> struct tuple_size;
1419
1420 template <GTEST_0_TYPENAMES_(T)>
1421 struct tuple_size<GTEST_0_TUPLE_(T)> {
1422   static const int value = 0;
1423 };
1424
1425 template <GTEST_1_TYPENAMES_(T)>
1426 struct tuple_size<GTEST_1_TUPLE_(T)> {
1427   static const int value = 1;
1428 };
1429
1430 template <GTEST_2_TYPENAMES_(T)>
1431 struct tuple_size<GTEST_2_TUPLE_(T)> {
1432   static const int value = 2;
1433 };
1434
1435 template <GTEST_3_TYPENAMES_(T)>
1436 struct tuple_size<GTEST_3_TUPLE_(T)> {
1437   static const int value = 3;
1438 };
1439
1440 template <GTEST_4_TYPENAMES_(T)>
1441 struct tuple_size<GTEST_4_TUPLE_(T)> {
1442   static const int value = 4;
1443 };
1444
1445 template <GTEST_5_TYPENAMES_(T)>
1446 struct tuple_size<GTEST_5_TUPLE_(T)> {
1447   static const int value = 5;
1448 };
1449
1450 template <GTEST_6_TYPENAMES_(T)>
1451 struct tuple_size<GTEST_6_TUPLE_(T)> {
1452   static const int value = 6;
1453 };
1454
1455 template <GTEST_7_TYPENAMES_(T)>
1456 struct tuple_size<GTEST_7_TUPLE_(T)> {
1457   static const int value = 7;
1458 };
1459
1460 template <GTEST_8_TYPENAMES_(T)>
1461 struct tuple_size<GTEST_8_TUPLE_(T)> {
1462   static const int value = 8;
1463 };
1464
1465 template <GTEST_9_TYPENAMES_(T)>
1466 struct tuple_size<GTEST_9_TUPLE_(T)> {
1467   static const int value = 9;
1468 };
1469
1470 template <GTEST_10_TYPENAMES_(T)>
1471 struct tuple_size<GTEST_10_TUPLE_(T)> {
1472   static const int value = 10;
1473 };
1474
1475 template <int k, class Tuple>
1476 struct tuple_element {
1477   typedef typename gtest_internal::TupleElement<
1478       k < (tuple_size<Tuple>::value), k, Tuple>::type type;
1479 };
1480
1481 #define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type
1482
1483 // 6.1.3.4 Element access.
1484
1485 namespace gtest_internal {
1486
1487 template <>
1488 class Get<0> {
1489  public:
1490   template <class Tuple>
1491   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
1492   Field(Tuple& t) { return t.f0_; }  // NOLINT
1493
1494   template <class Tuple>
1495   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
1496   ConstField(const Tuple& t) { return t.f0_; }
1497 };
1498
1499 template <>
1500 class Get<1> {
1501  public:
1502   template <class Tuple>
1503   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
1504   Field(Tuple& t) { return t.f1_; }  // NOLINT
1505
1506   template <class Tuple>
1507   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
1508   ConstField(const Tuple& t) { return t.f1_; }
1509 };
1510
1511 template <>
1512 class Get<2> {
1513  public:
1514   template <class Tuple>
1515   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
1516   Field(Tuple& t) { return t.f2_; }  // NOLINT
1517
1518   template <class Tuple>
1519   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
1520   ConstField(const Tuple& t) { return t.f2_; }
1521 };
1522
1523 template <>
1524 class Get<3> {
1525  public:
1526   template <class Tuple>
1527   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
1528   Field(Tuple& t) { return t.f3_; }  // NOLINT
1529
1530   template <class Tuple>
1531   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
1532   ConstField(const Tuple& t) { return t.f3_; }
1533 };
1534
1535 template <>
1536 class Get<4> {
1537  public:
1538   template <class Tuple>
1539   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
1540   Field(Tuple& t) { return t.f4_; }  // NOLINT
1541
1542   template <class Tuple>
1543   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
1544   ConstField(const Tuple& t) { return t.f4_; }
1545 };
1546
1547 template <>
1548 class Get<5> {
1549  public:
1550   template <class Tuple>
1551   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
1552   Field(Tuple& t) { return t.f5_; }  // NOLINT
1553
1554   template <class Tuple>
1555   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
1556   ConstField(const Tuple& t) { return t.f5_; }
1557 };
1558
1559 template <>
1560 class Get<6> {
1561  public:
1562   template <class Tuple>
1563   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
1564   Field(Tuple& t) { return t.f6_; }  // NOLINT
1565
1566   template <class Tuple>
1567   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
1568   ConstField(const Tuple& t) { return t.f6_; }
1569 };
1570
1571 template <>
1572 class Get<7> {
1573  public:
1574   template <class Tuple>
1575   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
1576   Field(Tuple& t) { return t.f7_; }  // NOLINT
1577
1578   template <class Tuple>
1579   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
1580   ConstField(const Tuple& t) { return t.f7_; }
1581 };
1582
1583 template <>
1584 class Get<8> {
1585  public:
1586   template <class Tuple>
1587   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
1588   Field(Tuple& t) { return t.f8_; }  // NOLINT
1589
1590   template <class Tuple>
1591   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
1592   ConstField(const Tuple& t) { return t.f8_; }
1593 };
1594
1595 template <>
1596 class Get<9> {
1597  public:
1598   template <class Tuple>
1599   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
1600   Field(Tuple& t) { return t.f9_; }  // NOLINT
1601
1602   template <class Tuple>
1603   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
1604   ConstField(const Tuple& t) { return t.f9_; }
1605 };
1606
1607 }  // namespace gtest_internal
1608
1609 template <int k, GTEST_10_TYPENAMES_(T)>
1610 GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T)))
1611 get(GTEST_10_TUPLE_(T)& t) {
1612   return gtest_internal::Get<k>::Field(t);
1613 }
1614
1615 template <int k, GTEST_10_TYPENAMES_(T)>
1616 GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k,  GTEST_10_TUPLE_(T)))
1617 get(const GTEST_10_TUPLE_(T)& t) {
1618   return gtest_internal::Get<k>::ConstField(t);
1619 }
1620
1621 // 6.1.3.5 Relational operators
1622
1623 // We only implement == and !=, as we don't have a need for the rest yet.
1624
1625 namespace gtest_internal {
1626
1627 // SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the
1628 // first k fields of t1 equals the first k fields of t2.
1629 // SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if
1630 // k1 != k2.
1631 template <int kSize1, int kSize2>
1632 struct SameSizeTuplePrefixComparator;
1633
1634 template <>
1635 struct SameSizeTuplePrefixComparator<0, 0> {
1636   template <class Tuple1, class Tuple2>
1637   static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) {
1638     return true;
1639   }
1640 };
1641
1642 template <int k>
1643 struct SameSizeTuplePrefixComparator<k, k> {
1644   template <class Tuple1, class Tuple2>
1645   static bool Eq(const Tuple1& t1, const Tuple2& t2) {
1646     return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) &&
1647         ::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2);
1648   }
1649 };
1650
1651 }  // namespace gtest_internal
1652
1653 template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
1654 inline bool operator==(const GTEST_10_TUPLE_(T)& t,
1655                        const GTEST_10_TUPLE_(U)& u) {
1656   return gtest_internal::SameSizeTuplePrefixComparator<
1657       tuple_size<GTEST_10_TUPLE_(T)>::value,
1658       tuple_size<GTEST_10_TUPLE_(U)>::value>::Eq(t, u);
1659 }
1660
1661 template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
1662 inline bool operator!=(const GTEST_10_TUPLE_(T)& t,
1663                        const GTEST_10_TUPLE_(U)& u) { return !(t == u); }
1664
1665 // 6.1.4 Pairs.
1666 // Unimplemented.
1667
1668 }  // namespace tr1
1669 }  // namespace std
1670
1671 #undef GTEST_0_TUPLE_
1672 #undef GTEST_1_TUPLE_
1673 #undef GTEST_2_TUPLE_
1674 #undef GTEST_3_TUPLE_
1675 #undef GTEST_4_TUPLE_
1676 #undef GTEST_5_TUPLE_
1677 #undef GTEST_6_TUPLE_
1678 #undef GTEST_7_TUPLE_
1679 #undef GTEST_8_TUPLE_
1680 #undef GTEST_9_TUPLE_
1681 #undef GTEST_10_TUPLE_
1682
1683 #undef GTEST_0_TYPENAMES_
1684 #undef GTEST_1_TYPENAMES_
1685 #undef GTEST_2_TYPENAMES_
1686 #undef GTEST_3_TYPENAMES_
1687 #undef GTEST_4_TYPENAMES_
1688 #undef GTEST_5_TYPENAMES_
1689 #undef GTEST_6_TYPENAMES_
1690 #undef GTEST_7_TYPENAMES_
1691 #undef GTEST_8_TYPENAMES_
1692 #undef GTEST_9_TYPENAMES_
1693 #undef GTEST_10_TYPENAMES_
1694
1695 #undef GTEST_DECLARE_TUPLE_AS_FRIEND_
1696 #undef GTEST_BY_REF_
1697 #undef GTEST_ADD_REF_
1698 #undef GTEST_TUPLE_ELEMENT_
1699
1700 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
1701 # elif GTEST_ENV_HAS_STD_TUPLE_
1702 #  include <tuple>
1703 // C++11 puts its tuple into the ::std namespace rather than
1704 // ::std::tr1.  gtest expects tuple to live in ::std::tr1, so put it there.
1705 // This causes undefined behavior, but supported compilers react in
1706 // the way we intend.
1707 namespace std {
1708 namespace tr1 {
1709 using ::std::get;
1710 using ::std::make_tuple;
1711 using ::std::tuple;
1712 using ::std::tuple_element;
1713 using ::std::tuple_size;
1714 }
1715 }
1716
1717 # elif GTEST_OS_SYMBIAN
1718
1719 // On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to
1720 // use STLport's tuple implementation, which unfortunately doesn't
1721 // work as the copy of STLport distributed with Symbian is incomplete.
1722 // By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to
1723 // use its own tuple implementation.
1724 #  ifdef BOOST_HAS_TR1_TUPLE
1725 #   undef BOOST_HAS_TR1_TUPLE
1726 #  endif  // BOOST_HAS_TR1_TUPLE
1727
1728 // This prevents <boost/tr1/detail/config.hpp>, which defines
1729 // BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>.
1730 #  define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED
1731 #  include <tuple>
1732
1733 # elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
1734 // GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header.  This does
1735 // not conform to the TR1 spec, which requires the header to be <tuple>.
1736
1737 #  if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
1738 // Until version 4.3.2, gcc has a bug that causes <tr1/functional>,
1739 // which is #included by <tr1/tuple>, to not compile when RTTI is
1740 // disabled.  _TR1_FUNCTIONAL is the header guard for
1741 // <tr1/functional>.  Hence the following #define is a hack to prevent
1742 // <tr1/functional> from being included.
1743 #   define _TR1_FUNCTIONAL 1
1744 #   include <tr1/tuple>
1745 #   undef _TR1_FUNCTIONAL  // Allows the user to #include
1746                         // <tr1/functional> if he chooses to.
1747 #  else
1748 #   include <tr1/tuple>  // NOLINT
1749 #  endif  // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
1750
1751 # else
1752 // If the compiler is not GCC 4.0+, we assume the user is using a
1753 // spec-conforming TR1 implementation.
1754 #  include <tuple>  // NOLINT
1755 # endif  // GTEST_USE_OWN_TR1_TUPLE
1756
1757 #endif  // GTEST_HAS_TR1_TUPLE
1758
1759 // Determines whether clone(2) is supported.
1760 // Usually it will only be available on Linux, excluding
1761 // Linux on the Itanium architecture.
1762 // Also see http://linux.die.net/man/2/clone.
1763 #ifndef GTEST_HAS_CLONE
1764 // The user didn't tell us, so we need to figure it out.
1765
1766 # if GTEST_OS_LINUX && !defined(__ia64__)
1767 #  if GTEST_OS_LINUX_ANDROID
1768 // On Android, clone() is only available on ARM starting with Gingerbread.
1769 #    if (defined(__arm__) || defined(__mips__)) && __ANDROID_API__ >= 9
1770 #     define GTEST_HAS_CLONE 1
1771 #    else
1772 #     define GTEST_HAS_CLONE 0
1773 #    endif
1774 #  else
1775 #  define GTEST_HAS_CLONE 1
1776 #  endif
1777 # else
1778 #  define GTEST_HAS_CLONE 0
1779 # endif  // GTEST_OS_LINUX && !defined(__ia64__)
1780
1781 #endif  // GTEST_HAS_CLONE
1782
1783 // Determines whether to support stream redirection. This is used to test
1784 // output correctness and to implement death tests.
1785 #ifndef GTEST_HAS_STREAM_REDIRECTION
1786 // By default, we assume that stream redirection is supported on all
1787 // platforms except known mobile ones.
1788 # if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN
1789 #  define GTEST_HAS_STREAM_REDIRECTION 0
1790 # else
1791 #  define GTEST_HAS_STREAM_REDIRECTION 1
1792 # endif  // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN
1793 #endif  // GTEST_HAS_STREAM_REDIRECTION
1794
1795 // Determines whether to support death tests.
1796 // Google Test does not support death tests for VC 7.1 and earlier as
1797 // abort() in a VC 7.1 application compiled as GUI in debug config
1798 // pops up a dialog window that cannot be suppressed programmatically.
1799 #if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
1800      (GTEST_OS_MAC && !GTEST_OS_IOS) || GTEST_OS_IOS_SIMULATOR || \
1801      (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \
1802      GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \
1803      GTEST_OS_OPENBSD || GTEST_OS_QNX)
1804 # define GTEST_HAS_DEATH_TEST 1
1805 # include <vector>  // NOLINT
1806 #else
1807 # define GTEST_HAS_DEATH_TEST 0
1808 #endif
1809
1810 // We don't support MSVC 7.1 with exceptions disabled now.  Therefore
1811 // all the compilers we care about are adequate for supporting
1812 // value-parameterized tests.
1813 #define GTEST_HAS_PARAM_TEST 1
1814
1815 // Determines whether to support type-driven tests.
1816
1817 // Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0,
1818 // Sun Pro CC, IBM Visual Age, and HP aCC support.
1819 #if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \
1820     defined(__IBMCPP__) || defined(__HP_aCC)
1821 # define GTEST_HAS_TYPED_TEST 1
1822 # define GTEST_HAS_TYPED_TEST_P 1
1823 #endif
1824
1825 // Determines whether to support Combine(). This only makes sense when
1826 // value-parameterized tests are enabled.  The implementation doesn't
1827 // work on Sun Studio since it doesn't understand templated conversion
1828 // operators.
1829 #if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC)
1830 # define GTEST_HAS_COMBINE 1
1831 #endif
1832
1833 // Determines whether the system compiler uses UTF-16 for encoding wide strings.
1834 #define GTEST_WIDE_STRING_USES_UTF16_ \
1835     (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX)
1836
1837 // Determines whether test results can be streamed to a socket.
1838 #if GTEST_OS_LINUX
1839 # define GTEST_CAN_STREAM_RESULTS_ 1
1840 #else
1841 # define GTEST_CAN_STREAM_RESULTS_ 0
1842 #endif
1843
1844 // Defines some utility macros.
1845
1846 // The GNU compiler emits a warning if nested "if" statements are followed by
1847 // an "else" statement and braces are not used to explicitly disambiguate the
1848 // "else" binding.  This leads to problems with code like:
1849 //
1850 //   if (gate)
1851 //     ASSERT_*(condition) << "Some message";
1852 //
1853 // The "switch (0) case 0:" idiom is used to suppress this.
1854 #ifdef __INTEL_COMPILER
1855 # define GTEST_AMBIGUOUS_ELSE_BLOCKER_
1856 #else
1857 # define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:  // NOLINT
1858 #endif
1859
1860 // Use this annotation at the end of a struct/class definition to
1861 // prevent the compiler from optimizing away instances that are never
1862 // used.  This is useful when all interesting logic happens inside the
1863 // c'tor and / or d'tor.  Example:
1864 //
1865 //   struct Foo {
1866 //     Foo() { ... }
1867 //   } GTEST_ATTRIBUTE_UNUSED_;
1868 //
1869 // Also use it after a variable or parameter declaration to tell the
1870 // compiler the variable/parameter does not have to be used.
1871 #if defined(__GNUC__) && !defined(COMPILER_ICC)
1872 # define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
1873 #else
1874 # define GTEST_ATTRIBUTE_UNUSED_
1875 #endif
1876
1877 // A macro to disallow operator=
1878 // This should be used in the private: declarations for a class.
1879 #define GTEST_DISALLOW_ASSIGN_(type)\
1880   void operator=(type const &)
1881
1882 // A macro to disallow copy constructor and operator=
1883 // This should be used in the private: declarations for a class.
1884 #define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\
1885   type(type const &);\
1886   GTEST_DISALLOW_ASSIGN_(type)
1887
1888 // Tell the compiler to warn about unused return values for functions declared
1889 // with this macro.  The macro should be used on function declarations
1890 // following the argument list:
1891 //
1892 //   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
1893 #if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)
1894 # define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
1895 #else
1896 # define GTEST_MUST_USE_RESULT_
1897 #endif  // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC
1898
1899 // Determine whether the compiler supports Microsoft's Structured Exception
1900 // Handling.  This is supported by several Windows compilers but generally
1901 // does not exist on any other system.
1902 #ifndef GTEST_HAS_SEH
1903 // The user didn't tell us, so we need to figure it out.
1904
1905 # if defined(_MSC_VER) || defined(__BORLANDC__)
1906 // These two compilers are known to support SEH.
1907 #  define GTEST_HAS_SEH 1
1908 # else
1909 // Assume no SEH.
1910 #  define GTEST_HAS_SEH 0
1911 # endif
1912
1913 #endif  // GTEST_HAS_SEH
1914
1915 #ifdef _MSC_VER
1916
1917 # if GTEST_LINKED_AS_SHARED_LIBRARY
1918 #  define GTEST_API_ __declspec(dllimport)
1919 # elif GTEST_CREATE_SHARED_LIBRARY
1920 #  define GTEST_API_ __declspec(dllexport)
1921 # endif
1922
1923 #endif  // _MSC_VER
1924
1925 #ifndef GTEST_API_
1926 # define GTEST_API_
1927 #endif
1928
1929 #ifdef __GNUC__
1930 // Ask the compiler to never inline a given function.
1931 # define GTEST_NO_INLINE_ __attribute__((noinline))
1932 #else
1933 # define GTEST_NO_INLINE_
1934 #endif
1935
1936 // _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
1937 #if defined(__GLIBCXX__) || defined(_LIBCPP_VERSION)
1938 # define GTEST_HAS_CXXABI_H_ 1
1939 #else
1940 # define GTEST_HAS_CXXABI_H_ 0
1941 #endif
1942
1943 namespace testing {
1944
1945 class Message;
1946
1947 namespace internal {
1948
1949 // A secret type that Google Test users don't know about.  It has no
1950 // definition on purpose.  Therefore it's impossible to create a
1951 // Secret object, which is what we want.
1952 class Secret;
1953
1954 // The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time
1955 // expression is true. For example, you could use it to verify the
1956 // size of a static array:
1957 //
1958 //   GTEST_COMPILE_ASSERT_(ARRAYSIZE(content_type_names) == CONTENT_NUM_TYPES,
1959 //                         content_type_names_incorrect_size);
1960 //
1961 // or to make sure a struct is smaller than a certain size:
1962 //
1963 //   GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large);
1964 //
1965 // The second argument to the macro is the name of the variable. If
1966 // the expression is false, most compilers will issue a warning/error
1967 // containing the name of the variable.
1968
1969 template <bool>
1970 struct CompileAssert {
1971 };
1972
1973 #define GTEST_COMPILE_ASSERT_(expr, msg) \
1974   typedef ::testing::internal::CompileAssert<(static_cast<bool>(expr))> \
1975       msg[static_cast<bool>(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_
1976
1977 // Implementation details of GTEST_COMPILE_ASSERT_:
1978 //
1979 // - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1
1980 //   elements (and thus is invalid) when the expression is false.
1981 //
1982 // - The simpler definition
1983 //
1984 //    #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1]
1985 //
1986 //   does not work, as gcc supports variable-length arrays whose sizes
1987 //   are determined at run-time (this is gcc's extension and not part
1988 //   of the C++ standard).  As a result, gcc fails to reject the
1989 //   following code with the simple definition:
1990 //
1991 //     int foo;
1992 //     GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is
1993 //                                      // not a compile-time constant.
1994 //
1995 // - By using the type CompileAssert<(bool(expr))>, we ensures that
1996 //   expr is a compile-time constant.  (Template arguments must be
1997 //   determined at compile-time.)
1998 //
1999 // - The outter parentheses in CompileAssert<(bool(expr))> are necessary
2000 //   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
2001 //
2002 //     CompileAssert<bool(expr)>
2003 //
2004 //   instead, these compilers will refuse to compile
2005 //
2006 //     GTEST_COMPILE_ASSERT_(5 > 0, some_message);
2007 //
2008 //   (They seem to think the ">" in "5 > 0" marks the end of the
2009 //   template argument list.)
2010 //
2011 // - The array size is (bool(expr) ? 1 : -1), instead of simply
2012 //
2013 //     ((expr) ? 1 : -1).
2014 //
2015 //   This is to avoid running into a bug in MS VC 7.1, which
2016 //   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
2017
2018 // StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h.
2019 //
2020 // This template is declared, but intentionally undefined.
2021 template <typename T1, typename T2>
2022 struct StaticAssertTypeEqHelper;
2023
2024 template <typename T>
2025 struct StaticAssertTypeEqHelper<T, T> {};
2026
2027 #if GTEST_HAS_GLOBAL_STRING
2028 typedef ::string string;
2029 #else
2030 typedef ::std::string string;
2031 #endif  // GTEST_HAS_GLOBAL_STRING
2032
2033 #if GTEST_HAS_GLOBAL_WSTRING
2034 typedef ::wstring wstring;
2035 #elif GTEST_HAS_STD_WSTRING
2036 typedef ::std::wstring wstring;
2037 #endif  // GTEST_HAS_GLOBAL_WSTRING
2038
2039 // A helper for suppressing warnings on constant condition.  It just
2040 // returns 'condition'.
2041 GTEST_API_ bool IsTrue(bool condition);
2042
2043 // Defines scoped_ptr.
2044
2045 // This implementation of scoped_ptr is PARTIAL - it only contains
2046 // enough stuff to satisfy Google Test's need.
2047 template <typename T>
2048 class scoped_ptr {
2049  public:
2050   typedef T element_type;
2051
2052   explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
2053   ~scoped_ptr() { reset(); }
2054
2055   T& operator*() const { return *ptr_; }
2056   T* operator->() const { return ptr_; }
2057   T* get() const { return ptr_; }
2058
2059   T* release() {
2060     T* const ptr = ptr_;
2061     ptr_ = NULL;
2062     return ptr;
2063   }
2064
2065   void reset(T* p = NULL) {
2066     if (p != ptr_) {
2067       if (IsTrue(sizeof(T) > 0)) {  // Makes sure T is a complete type.
2068         delete ptr_;
2069       }
2070       ptr_ = p;
2071     }
2072   }
2073
2074  private:
2075   T* ptr_;
2076
2077   GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
2078 };
2079
2080 // Defines RE.
2081
2082 // A simple C++ wrapper for <regex.h>.  It uses the POSIX Extended
2083 // Regular Expression syntax.
2084 class GTEST_API_ RE {
2085  public:
2086   // A copy constructor is required by the Standard to initialize object
2087   // references from r-values.
2088   RE(const RE& other) { Init(other.pattern()); }
2089
2090   // Constructs an RE from a string.
2091   RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT
2092
2093 #if GTEST_HAS_GLOBAL_STRING
2094
2095   RE(const ::string& regex) { Init(regex.c_str()); }  // NOLINT
2096
2097 #endif  // GTEST_HAS_GLOBAL_STRING
2098
2099   RE(const char* regex) { Init(regex); }  // NOLINT
2100   ~RE();
2101
2102   // Returns the string representation of the regex.
2103   const char* pattern() const { return pattern_; }
2104
2105   // FullMatch(str, re) returns true iff regular expression re matches
2106   // the entire str.
2107   // PartialMatch(str, re) returns true iff regular expression re
2108   // matches a substring of str (including str itself).
2109   //
2110   // TODO(wan@google.com): make FullMatch() and PartialMatch() work
2111   // when str contains NUL characters.
2112   static bool FullMatch(const ::std::string& str, const RE& re) {
2113     return FullMatch(str.c_str(), re);
2114   }
2115   static bool PartialMatch(const ::std::string& str, const RE& re) {
2116     return PartialMatch(str.c_str(), re);
2117   }
2118
2119 #if GTEST_HAS_GLOBAL_STRING
2120
2121   static bool FullMatch(const ::string& str, const RE& re) {
2122     return FullMatch(str.c_str(), re);
2123   }
2124   static bool PartialMatch(const ::string& str, const RE& re) {
2125     return PartialMatch(str.c_str(), re);
2126   }
2127
2128 #endif  // GTEST_HAS_GLOBAL_STRING
2129
2130   static bool FullMatch(const char* str, const RE& re);
2131   static bool PartialMatch(const char* str, const RE& re);
2132
2133  private:
2134   void Init(const char* regex);
2135
2136   // We use a const char* instead of an std::string, as Google Test used to be
2137   // used where std::string is not available.  TODO(wan@google.com): change to
2138   // std::string.
2139   const char* pattern_;
2140   bool is_valid_;
2141
2142 #if GTEST_USES_POSIX_RE
2143
2144   regex_t full_regex_;     // For FullMatch().
2145   regex_t partial_regex_;  // For PartialMatch().
2146
2147 #else  // GTEST_USES_SIMPLE_RE
2148
2149   const char* full_pattern_;  // For FullMatch();
2150
2151 #endif
2152
2153   GTEST_DISALLOW_ASSIGN_(RE);
2154 };
2155
2156 // Formats a source file path and a line number as they would appear
2157 // in an error message from the compiler used to compile this code.
2158 GTEST_API_ ::std::string FormatFileLocation(const char* file, int line);
2159
2160 // Formats a file location for compiler-independent XML output.
2161 // Although this function is not platform dependent, we put it next to
2162 // FormatFileLocation in order to contrast the two functions.
2163 GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
2164                                                                int line);
2165
2166 // Defines logging utilities:
2167 //   GTEST_LOG_(severity) - logs messages at the specified severity level. The
2168 //                          message itself is streamed into the macro.
2169 //   LogToStderr()  - directs all log messages to stderr.
2170 //   FlushInfoLog() - flushes informational log messages.
2171
2172 enum GTestLogSeverity {
2173   GTEST_INFO,
2174   GTEST_WARNING,
2175   GTEST_ERROR,
2176   GTEST_FATAL
2177 };
2178
2179 // Formats log entry severity, provides a stream object for streaming the
2180 // log message, and terminates the message with a newline when going out of
2181 // scope.
2182 class GTEST_API_ GTestLog {
2183  public:
2184   GTestLog(GTestLogSeverity severity, const char* file, int line);
2185
2186   // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
2187   ~GTestLog();
2188
2189   ::std::ostream& GetStream() { return ::std::cerr; }
2190
2191  private:
2192   const GTestLogSeverity severity_;
2193
2194   GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
2195 };
2196
2197 #define GTEST_LOG_(severity) \
2198     ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
2199                                   __FILE__, __LINE__).GetStream()
2200
2201 inline void LogToStderr() {}
2202 inline void FlushInfoLog() { fflush(NULL); }
2203
2204 // INTERNAL IMPLEMENTATION - DO NOT USE.
2205 //
2206 // GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
2207 // is not satisfied.
2208 //  Synopsys:
2209 //    GTEST_CHECK_(boolean_condition);
2210 //     or
2211 //    GTEST_CHECK_(boolean_condition) << "Additional message";
2212 //
2213 //    This checks the condition and if the condition is not satisfied
2214 //    it prints message about the condition violation, including the
2215 //    condition itself, plus additional message streamed into it, if any,
2216 //    and then it aborts the program. It aborts the program irrespective of
2217 //    whether it is built in the debug mode or not.
2218 #define GTEST_CHECK_(condition) \
2219     GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
2220     if (::testing::internal::IsTrue(condition)) \
2221       ; \
2222     else \
2223       GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
2224
2225 // An all-mode assert to verify that the given POSIX-style function
2226 // call returns 0 (indicating success).  Known limitation: this
2227 // doesn't expand to a balanced 'if' statement, so enclose the macro
2228 // in {} if you need to use it as the only statement in an 'if'
2229 // branch.
2230 #define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
2231   if (const int gtest_error = (posix_call)) \
2232     GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
2233                       << gtest_error
2234
2235 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
2236 //
2237 // Use ImplicitCast_ as a safe version of static_cast for upcasting in
2238 // the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a
2239 // const Foo*).  When you use ImplicitCast_, the compiler checks that
2240 // the cast is safe.  Such explicit ImplicitCast_s are necessary in
2241 // surprisingly many situations where C++ demands an exact type match
2242 // instead of an argument type convertable to a target type.
2243 //
2244 // The syntax for using ImplicitCast_ is the same as for static_cast:
2245 //
2246 //   ImplicitCast_<ToType>(expr)
2247 //
2248 // ImplicitCast_ would have been part of the C++ standard library,
2249 // but the proposal was submitted too late.  It will probably make
2250 // its way into the language in the future.
2251 //
2252 // This relatively ugly name is intentional. It prevents clashes with
2253 // similar functions users may have (e.g., implicit_cast). The internal
2254 // namespace alone is not enough because the function can be found by ADL.
2255 template<typename To>
2256 inline To ImplicitCast_(To x) { return x; }
2257
2258 // When you upcast (that is, cast a pointer from type Foo to type
2259 // SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts
2260 // always succeed.  When you downcast (that is, cast a pointer from
2261 // type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
2262 // how do you know the pointer is really of type SubclassOfFoo?  It
2263 // could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
2264 // when you downcast, you should use this macro.  In debug mode, we
2265 // use dynamic_cast<> to double-check the downcast is legal (we die
2266 // if it's not).  In normal mode, we do the efficient static_cast<>
2267 // instead.  Thus, it's important to test in debug mode to make sure
2268 // the cast is legal!
2269 //    This is the only place in the code we should use dynamic_cast<>.
2270 // In particular, you SHOULDN'T be using dynamic_cast<> in order to
2271 // do RTTI (eg code like this:
2272 //    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
2273 //    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
2274 // You should design the code some other way not to need this.
2275 //
2276 // This relatively ugly name is intentional. It prevents clashes with
2277 // similar functions users may have (e.g., down_cast). The internal
2278 // namespace alone is not enough because the function can be found by ADL.
2279 template<typename To, typename From>  // use like this: DownCast_<T*>(foo);
2280 inline To DownCast_(From* f) {  // so we only accept pointers
2281   // Ensures that To is a sub-type of From *.  This test is here only
2282   // for compile-time type checking, and has no overhead in an
2283   // optimized build at run-time, as it will be optimized away
2284   // completely.
2285   if (false) {
2286     const To to = NULL;
2287     ::testing::internal::ImplicitCast_<From*>(to);
2288   }
2289
2290 #if GTEST_HAS_RTTI
2291   // RTTI: debug mode only!
2292   GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL);
2293 #endif
2294   return static_cast<To>(f);
2295 }
2296
2297 // Downcasts the pointer of type Base to Derived.
2298 // Derived must be a subclass of Base. The parameter MUST
2299 // point to a class of type Derived, not any subclass of it.
2300 // When RTTI is available, the function performs a runtime
2301 // check to enforce this.
2302 template <class Derived, class Base>
2303 Derived* CheckedDowncastToActualType(Base* base) {
2304 #if GTEST_HAS_RTTI
2305   GTEST_CHECK_(typeid(*base) == typeid(Derived));
2306   return dynamic_cast<Derived*>(base);  // NOLINT
2307 #else
2308   return static_cast<Derived*>(base);  // Poor man's downcast.
2309 #endif
2310 }
2311
2312 #if GTEST_HAS_STREAM_REDIRECTION
2313
2314 // Defines the stderr capturer:
2315 //   CaptureStdout     - starts capturing stdout.
2316 //   GetCapturedStdout - stops capturing stdout and returns the captured string.
2317 //   CaptureStderr     - starts capturing stderr.
2318 //   GetCapturedStderr - stops capturing stderr and returns the captured string.
2319 //
2320 GTEST_API_ void CaptureStdout();
2321 GTEST_API_ std::string GetCapturedStdout();
2322 GTEST_API_ void CaptureStderr();
2323 GTEST_API_ std::string GetCapturedStderr();
2324
2325 #endif  // GTEST_HAS_STREAM_REDIRECTION
2326
2327
2328 #if GTEST_HAS_DEATH_TEST
2329
2330 const ::std::vector<testing::internal::string>& GetInjectableArgvs();
2331 void SetInjectableArgvs(const ::std::vector<testing::internal::string>*
2332                              new_argvs);
2333
2334 // A copy of all command line arguments.  Set by InitGoogleTest().
2335 extern ::std::vector<testing::internal::string> g_argvs;
2336
2337 #endif  // GTEST_HAS_DEATH_TEST
2338
2339 // Defines synchronization primitives.
2340
2341 #if GTEST_HAS_PTHREAD
2342
2343 // Sleeps for (roughly) n milli-seconds.  This function is only for
2344 // testing Google Test's own constructs.  Don't use it in user tests,
2345 // either directly or indirectly.
2346 inline void SleepMilliseconds(int n) {
2347   const timespec time = {
2348     0,                  // 0 seconds.
2349     n * 1000L * 1000L,  // And n ms.
2350   };
2351   nanosleep(&time, NULL);
2352 }
2353
2354 // Allows a controller thread to pause execution of newly created
2355 // threads until notified.  Instances of this class must be created
2356 // and destroyed in the controller thread.
2357 //
2358 // This class is only for testing Google Test's own constructs. Do not
2359 // use it in user tests, either directly or indirectly.
2360 class Notification {
2361  public:
2362   Notification() : notified_(false) {
2363     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
2364   }
2365   ~Notification() {
2366     pthread_mutex_destroy(&mutex_);
2367   }
2368
2369   // Notifies all threads created with this notification to start. Must
2370   // be called from the controller thread.
2371   void Notify() {
2372     pthread_mutex_lock(&mutex_);
2373     notified_ = true;
2374     pthread_mutex_unlock(&mutex_);
2375   }
2376
2377   // Blocks until the controller thread notifies. Must be called from a test
2378   // thread.
2379   void WaitForNotification() {
2380     for (;;) {
2381       pthread_mutex_lock(&mutex_);
2382       const bool notified = notified_;
2383       pthread_mutex_unlock(&mutex_);
2384       if (notified)
2385         break;
2386       SleepMilliseconds(10);
2387     }
2388   }
2389
2390  private:
2391   pthread_mutex_t mutex_;
2392   bool notified_;
2393
2394   GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
2395 };
2396
2397 // As a C-function, ThreadFuncWithCLinkage cannot be templated itself.
2398 // Consequently, it cannot select a correct instantiation of ThreadWithParam
2399 // in order to call its Run(). Introducing ThreadWithParamBase as a
2400 // non-templated base class for ThreadWithParam allows us to bypass this
2401 // problem.
2402 class ThreadWithParamBase {
2403  public:
2404   virtual ~ThreadWithParamBase() {}
2405   virtual void Run() = 0;
2406 };
2407
2408 // pthread_create() accepts a pointer to a function type with the C linkage.
2409 // According to the Standard (7.5/1), function types with different linkages
2410 // are different even if they are otherwise identical.  Some compilers (for
2411 // example, SunStudio) treat them as different types.  Since class methods
2412 // cannot be defined with C-linkage we need to define a free C-function to
2413 // pass into pthread_create().
2414 extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
2415   static_cast<ThreadWithParamBase*>(thread)->Run();
2416   return NULL;
2417 }
2418
2419 // Helper class for testing Google Test's multi-threading constructs.
2420 // To use it, write:
2421 //
2422 //   void ThreadFunc(int param) { /* Do things with param */ }
2423 //   Notification thread_can_start;
2424 //   ...
2425 //   // The thread_can_start parameter is optional; you can supply NULL.
2426 //   ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start);
2427 //   thread_can_start.Notify();
2428 //
2429 // These classes are only for testing Google Test's own constructs. Do
2430 // not use them in user tests, either directly or indirectly.
2431 template <typename T>
2432 class ThreadWithParam : public ThreadWithParamBase {
2433  public:
2434   typedef void (*UserThreadFunc)(T);
2435
2436   ThreadWithParam(
2437       UserThreadFunc func, T param, Notification* thread_can_start)
2438       : func_(func),
2439         param_(param),
2440         thread_can_start_(thread_can_start),
2441         finished_(false) {
2442     ThreadWithParamBase* const base = this;
2443     // The thread can be created only after all fields except thread_
2444     // have been initialized.
2445     GTEST_CHECK_POSIX_SUCCESS_(
2446         pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base));
2447   }
2448   ~ThreadWithParam() { Join(); }
2449
2450   void Join() {
2451     if (!finished_) {
2452       GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0));
2453       finished_ = true;
2454     }
2455   }
2456
2457   virtual void Run() {
2458     if (thread_can_start_ != NULL)
2459       thread_can_start_->WaitForNotification();
2460     func_(param_);
2461   }
2462
2463  private:
2464   const UserThreadFunc func_;  // User-supplied thread function.
2465   const T param_;  // User-supplied parameter to the thread function.
2466   // When non-NULL, used to block execution until the controller thread
2467   // notifies.
2468   Notification* const thread_can_start_;
2469   bool finished_;  // true iff we know that the thread function has finished.
2470   pthread_t thread_;  // The native thread object.
2471
2472   GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
2473 };
2474
2475 // MutexBase and Mutex implement mutex on pthreads-based platforms. They
2476 // are used in conjunction with class MutexLock:
2477 //
2478 //   Mutex mutex;
2479 //   ...
2480 //   MutexLock lock(&mutex);  // Acquires the mutex and releases it at the end
2481 //                            // of the current scope.
2482 //
2483 // MutexBase implements behavior for both statically and dynamically
2484 // allocated mutexes.  Do not use MutexBase directly.  Instead, write
2485 // the following to define a static mutex:
2486 //
2487 //   GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);
2488 //
2489 // You can forward declare a static mutex like this:
2490 //
2491 //   GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);
2492 //
2493 // To create a dynamic mutex, just define an object of type Mutex.
2494 class MutexBase {
2495  public:
2496   // Acquires this mutex.
2497   void Lock() {
2498     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
2499     owner_ = pthread_self();
2500     has_owner_ = true;
2501   }
2502
2503   // Releases this mutex.
2504   void Unlock() {
2505     // Since the lock is being released the owner_ field should no longer be
2506     // considered valid. We don't protect writing to has_owner_ here, as it's
2507     // the caller's responsibility to ensure that the current thread holds the
2508     // mutex when this is called.
2509     has_owner_ = false;
2510     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
2511   }
2512
2513   // Does nothing if the current thread holds the mutex. Otherwise, crashes
2514   // with high probability.
2515   void AssertHeld() const {
2516     GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
2517         << "The current thread is not holding the mutex @" << this;
2518   }
2519
2520   // A static mutex may be used before main() is entered.  It may even
2521   // be used before the dynamic initialization stage.  Therefore we
2522   // must be able to initialize a static mutex object at link time.
2523   // This means MutexBase has to be a POD and its member variables
2524   // have to be public.
2525  public:
2526   pthread_mutex_t mutex_;  // The underlying pthread mutex.
2527   // has_owner_ indicates whether the owner_ field below contains a valid thread
2528   // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All
2529   // accesses to the owner_ field should be protected by a check of this field.
2530   // An alternative might be to memset() owner_ to all zeros, but there's no
2531   // guarantee that a zero'd pthread_t is necessarily invalid or even different
2532   // from pthread_self().
2533   bool has_owner_;
2534   pthread_t owner_;  // The thread holding the mutex.
2535 };
2536
2537 // Forward-declares a static mutex.
2538 # define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
2539     extern ::testing::internal::MutexBase mutex
2540
2541 // Defines and statically (i.e. at link time) initializes a static mutex.
2542 // The initialization list here does not explicitly initialize each field,
2543 // instead relying on default initialization for the unspecified fields. In
2544 // particular, the owner_ field (a pthread_t) is not explicitly initialized.
2545 // This allows initialization to work whether pthread_t is a scalar or struct.
2546 // The flag -Wmissing-field-initializers must not be specified for this to work.
2547 # define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
2548     ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, false }
2549
2550 // The Mutex class can only be used for mutexes created at runtime. It
2551 // shares its API with MutexBase otherwise.
2552 class Mutex : public MutexBase {
2553  public:
2554   Mutex() {
2555     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
2556     has_owner_ = false;
2557   }
2558   ~Mutex() {
2559     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
2560   }
2561
2562  private:
2563   GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
2564 };
2565
2566 // We cannot name this class MutexLock as the ctor declaration would
2567 // conflict with a macro named MutexLock, which is defined on some
2568 // platforms.  Hence the typedef trick below.
2569 class GTestMutexLock {
2570  public:
2571   explicit GTestMutexLock(MutexBase* mutex)
2572       : mutex_(mutex) { mutex_->Lock(); }
2573
2574   ~GTestMutexLock() { mutex_->Unlock(); }
2575
2576  private:
2577   MutexBase* const mutex_;
2578
2579   GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
2580 };
2581
2582 typedef GTestMutexLock MutexLock;
2583
2584 // Helpers for ThreadLocal.
2585
2586 // pthread_key_create() requires DeleteThreadLocalValue() to have
2587 // C-linkage.  Therefore it cannot be templatized to access
2588 // ThreadLocal<T>.  Hence the need for class
2589 // ThreadLocalValueHolderBase.
2590 class ThreadLocalValueHolderBase {
2591  public:
2592   virtual ~ThreadLocalValueHolderBase() {}
2593 };
2594
2595 // Called by pthread to delete thread-local data stored by
2596 // pthread_setspecific().
2597 extern "C" inline void DeleteThreadLocalValue(void* value_holder) {
2598   delete static_cast<ThreadLocalValueHolderBase*>(value_holder);
2599 }
2600
2601 // Implements thread-local storage on pthreads-based systems.
2602 //
2603 //   // Thread 1
2604 //   ThreadLocal<int> tl(100);  // 100 is the default value for each thread.
2605 //
2606 //   // Thread 2
2607 //   tl.set(150);  // Changes the value for thread 2 only.
2608 //   EXPECT_EQ(150, tl.get());
2609 //
2610 //   // Thread 1
2611 //   EXPECT_EQ(100, tl.get());  // In thread 1, tl has the original value.
2612 //   tl.set(200);
2613 //   EXPECT_EQ(200, tl.get());
2614 //
2615 // The template type argument T must have a public copy constructor.
2616 // In addition, the default ThreadLocal constructor requires T to have
2617 // a public default constructor.
2618 //
2619 // An object managed for a thread by a ThreadLocal instance is deleted
2620 // when the thread exits.  Or, if the ThreadLocal instance dies in
2621 // that thread, when the ThreadLocal dies.  It's the user's
2622 // responsibility to ensure that all other threads using a ThreadLocal
2623 // have exited when it dies, or the per-thread objects for those
2624 // threads will not be deleted.
2625 //
2626 // Google Test only uses global ThreadLocal objects.  That means they
2627 // will die after main() has returned.  Therefore, no per-thread
2628 // object managed by Google Test will be leaked as long as all threads
2629 // using Google Test have exited when main() returns.
2630 template <typename T>
2631 class ThreadLocal {
2632  public:
2633   ThreadLocal() : key_(CreateKey()),
2634                   default_() {}
2635   explicit ThreadLocal(const T& value) : key_(CreateKey()),
2636                                          default_(value) {}
2637
2638   ~ThreadLocal() {
2639     // Destroys the managed object for the current thread, if any.
2640     DeleteThreadLocalValue(pthread_getspecific(key_));
2641
2642     // Releases resources associated with the key.  This will *not*
2643     // delete managed objects for other threads.
2644     GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
2645   }
2646
2647   T* pointer() { return GetOrCreateValue(); }
2648   const T* pointer() const { return GetOrCreateValue(); }
2649   const T& get() const { return *pointer(); }
2650   void set(const T& value) { *pointer() = value; }
2651
2652  private:
2653   // Holds a value of type T.
2654   class ValueHolder : public ThreadLocalValueHolderBase {
2655    public:
2656     explicit ValueHolder(const T& value) : value_(value) {}
2657
2658     T* pointer() { return &value_; }
2659
2660    private:
2661     T value_;
2662     GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
2663   };
2664
2665   static pthread_key_t CreateKey() {
2666     pthread_key_t key;
2667     // When a thread exits, DeleteThreadLocalValue() will be called on
2668     // the object managed for that thread.
2669     GTEST_CHECK_POSIX_SUCCESS_(
2670         pthread_key_create(&key, &DeleteThreadLocalValue));
2671     return key;
2672   }
2673
2674   T* GetOrCreateValue() const {
2675     ThreadLocalValueHolderBase* const holder =
2676         static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
2677     if (holder != NULL) {
2678       return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
2679     }
2680
2681     ValueHolder* const new_holder = new ValueHolder(default_);
2682     ThreadLocalValueHolderBase* const holder_base = new_holder;
2683     GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
2684     return new_holder->pointer();
2685   }
2686
2687   // A key pthreads uses for looking up per-thread values.
2688   const pthread_key_t key_;
2689   const T default_;  // The default value for each thread.
2690
2691   GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
2692 };
2693
2694 # define GTEST_IS_THREADSAFE 1
2695
2696 #else  // GTEST_HAS_PTHREAD
2697
2698 // A dummy implementation of synchronization primitives (mutex, lock,
2699 // and thread-local variable).  Necessary for compiling Google Test where
2700 // mutex is not supported - using Google Test in multiple threads is not
2701 // supported on such platforms.
2702
2703 class Mutex {
2704  public:
2705   Mutex() {}
2706   void Lock() {}
2707   void Unlock() {}
2708   void AssertHeld() const {}
2709 };
2710
2711 # define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
2712   extern ::testing::internal::Mutex mutex
2713
2714 # define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
2715
2716 class GTestMutexLock {
2717  public:
2718   explicit GTestMutexLock(Mutex*) {}  // NOLINT
2719 };
2720
2721 typedef GTestMutexLock MutexLock;
2722
2723 template <typename T>
2724 class ThreadLocal {
2725  public:
2726   ThreadLocal() : value_() {}
2727   explicit ThreadLocal(const T& value) : value_(value) {}
2728   T* pointer() { return &value_; }
2729   const T* pointer() const { return &value_; }
2730   const T& get() const { return value_; }
2731   void set(const T& value) { value_ = value; }
2732  private:
2733   T value_;
2734 };
2735
2736 // The above synchronization primitives have dummy implementations.
2737 // Therefore Google Test is not thread-safe.
2738 # define GTEST_IS_THREADSAFE 0
2739
2740 #endif  // GTEST_HAS_PTHREAD
2741
2742 // Returns the number of threads running in the process, or 0 to indicate that
2743 // we cannot detect it.
2744 GTEST_API_ size_t GetThreadCount();
2745
2746 // Passing non-POD classes through ellipsis (...) crashes the ARM
2747 // compiler and generates a warning in Sun Studio.  The Nokia Symbian
2748 // and the IBM XL C/C++ compiler try to instantiate a copy constructor
2749 // for objects passed through ellipsis (...), failing for uncopyable
2750 // objects.  We define this to ensure that only POD is passed through
2751 // ellipsis on these systems.
2752 #if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC)
2753 // We lose support for NULL detection where the compiler doesn't like
2754 // passing non-POD classes through ellipsis (...).
2755 # define GTEST_ELLIPSIS_NEEDS_POD_ 1
2756 #else
2757 # define GTEST_CAN_COMPARE_NULL 1
2758 #endif
2759
2760 // The Nokia Symbian and IBM XL C/C++ compilers cannot decide between
2761 // const T& and const T* in a function template.  These compilers
2762 // _can_ decide between class template specializations for T and T*,
2763 // so a tr1::type_traits-like is_pointer works.
2764 #if defined(__SYMBIAN32__) || defined(__IBMCPP__)
2765 # define GTEST_NEEDS_IS_POINTER_ 1
2766 #endif
2767
2768 template <bool bool_value>
2769 struct bool_constant {
2770   typedef bool_constant<bool_value> type;
2771   static const bool value = bool_value;
2772 };
2773 template <bool bool_value> const bool bool_constant<bool_value>::value;
2774
2775 typedef bool_constant<false> false_type;
2776 typedef bool_constant<true> true_type;
2777
2778 template <typename T>
2779 struct is_pointer : public false_type {};
2780
2781 template <typename T>
2782 struct is_pointer<T*> : public true_type {};
2783
2784 template <typename Iterator>
2785 struct IteratorTraits {
2786   typedef typename Iterator::value_type value_type;
2787 };
2788
2789 template <typename T>
2790 struct IteratorTraits<T*> {
2791   typedef T value_type;
2792 };
2793
2794 template <typename T>
2795 struct IteratorTraits<const T*> {
2796   typedef T value_type;
2797 };
2798
2799 #if GTEST_OS_WINDOWS
2800 # define GTEST_PATH_SEP_ "\\"
2801 # define GTEST_HAS_ALT_PATH_SEP_ 1
2802 // The biggest signed integer type the compiler supports.
2803 typedef __int64 BiggestInt;
2804 #else
2805 # define GTEST_PATH_SEP_ "/"
2806 # define GTEST_HAS_ALT_PATH_SEP_ 0
2807 typedef long long BiggestInt;  // NOLINT
2808 #endif  // GTEST_OS_WINDOWS
2809
2810 // Utilities for char.
2811
2812 // isspace(int ch) and friends accept an unsigned char or EOF.  char
2813 // may be signed, depending on the compiler (or compiler flags).
2814 // Therefore we need to cast a char to unsigned char before calling
2815 // isspace(), etc.
2816
2817 inline bool IsAlpha(char ch) {
2818   return isalpha(static_cast<unsigned char>(ch)) != 0;
2819 }
2820 inline bool IsAlNum(char ch) {
2821   return isalnum(static_cast<unsigned char>(ch)) != 0;
2822 }
2823 inline bool IsDigit(char ch) {
2824   return isdigit(static_cast<unsigned char>(ch)) != 0;
2825 }
2826 inline bool IsLower(char ch) {
2827   return islower(static_cast<unsigned char>(ch)) != 0;
2828 }
2829 inline bool IsSpace(char ch) {
2830   return isspace(static_cast<unsigned char>(ch)) != 0;
2831 }
2832 inline bool IsUpper(char ch) {
2833   return isupper(static_cast<unsigned char>(ch)) != 0;
2834 }
2835 inline bool IsXDigit(char ch) {
2836   return isxdigit(static_cast<unsigned char>(ch)) != 0;
2837 }
2838 inline bool IsXDigit(wchar_t ch) {
2839   const unsigned char low_byte = static_cast<unsigned char>(ch);
2840   return ch == low_byte && isxdigit(low_byte) != 0;
2841 }
2842
2843 inline char ToLower(char ch) {
2844   return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
2845 }
2846 inline char ToUpper(char ch) {
2847   return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
2848 }
2849
2850 // The testing::internal::posix namespace holds wrappers for common
2851 // POSIX functions.  These wrappers hide the differences between
2852 // Windows/MSVC and POSIX systems.  Since some compilers define these
2853 // standard functions as macros, the wrapper cannot have the same name
2854 // as the wrapped function.
2855
2856 namespace posix {
2857
2858 // Functions with a different name on Windows.
2859
2860 #if GTEST_OS_WINDOWS
2861
2862 typedef struct _stat StatStruct;
2863
2864 # ifdef __BORLANDC__
2865 inline int IsATTY(int fd) { return isatty(fd); }
2866 inline int StrCaseCmp(const char* s1, const char* s2) {
2867   return stricmp(s1, s2);
2868 }
2869 inline char* StrDup(const char* src) { return strdup(src); }
2870 # else  // !__BORLANDC__
2871 #  if GTEST_OS_WINDOWS_MOBILE
2872 inline int IsATTY(int /* fd */) { return 0; }
2873 #  else
2874 inline int IsATTY(int fd) { return _isatty(fd); }
2875 #  endif  // GTEST_OS_WINDOWS_MOBILE
2876 inline int StrCaseCmp(const char* s1, const char* s2) {
2877   return _stricmp(s1, s2);
2878 }
2879 inline char* StrDup(const char* src) { return _strdup(src); }
2880 # endif  // __BORLANDC__
2881
2882 # if GTEST_OS_WINDOWS_MOBILE
2883 inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
2884 // Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
2885 // time and thus not defined there.
2886 # else
2887 inline int FileNo(FILE* file) { return _fileno(file); }
2888 inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
2889 inline int RmDir(const char* dir) { return _rmdir(dir); }
2890 inline bool IsDir(const StatStruct& st) {
2891   return (_S_IFDIR & st.st_mode) != 0;
2892 }
2893 # endif  // GTEST_OS_WINDOWS_MOBILE
2894
2895 #else
2896
2897 typedef struct stat StatStruct;
2898
2899 inline int FileNo(FILE* file) { return fileno(file); }
2900 inline int IsATTY(int fd) { return isatty(fd); }
2901 inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
2902 inline int StrCaseCmp(const char* s1, const char* s2) {
2903   return strcasecmp(s1, s2);
2904 }
2905 inline char* StrDup(const char* src) { return strdup(src); }
2906 inline int RmDir(const char* dir) { return rmdir(dir); }
2907 inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
2908
2909 #endif  // GTEST_OS_WINDOWS
2910
2911 // Functions deprecated by MSVC 8.0.
2912
2913 #ifdef _MSC_VER
2914 // Temporarily disable warning 4996 (deprecated function).
2915 # pragma warning(push)
2916 # pragma warning(disable:4996)
2917 #endif
2918
2919 inline const char* StrNCpy(char* dest, const char* src, size_t n) {
2920   return strncpy(dest, src, n);
2921 }
2922
2923 // ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and
2924 // StrError() aren't needed on Windows CE at this time and thus not
2925 // defined there.
2926
2927 #if !GTEST_OS_WINDOWS_MOBILE
2928 inline int ChDir(const char* dir) { return chdir(dir); }
2929 #endif
2930 inline FILE* FOpen(const char* path, const char* mode) {
2931   return fopen(path, mode);
2932 }
2933 #if !GTEST_OS_WINDOWS_MOBILE
2934 inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
2935   return freopen(path, mode, stream);
2936 }
2937 inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
2938 #endif
2939 inline int FClose(FILE* fp) { return fclose(fp); }
2940 #if !GTEST_OS_WINDOWS_MOBILE
2941 inline int Read(int fd, void* buf, unsigned int count) {
2942   return static_cast<int>(read(fd, buf, count));
2943 }
2944 inline int Write(int fd, const void* buf, unsigned int count) {
2945   return static_cast<int>(write(fd, buf, count));
2946 }
2947 inline int Close(int fd) { return close(fd); }
2948 inline const char* StrError(int errnum) { return strerror(errnum); }
2949 #endif
2950 inline const char* GetEnv(const char* name) {
2951 #if GTEST_OS_WINDOWS_MOBILE
2952   // We are on Windows CE, which has no environment variables.
2953   return NULL;
2954 #elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
2955   // Environment variables which we programmatically clear will be set to the
2956   // empty string rather than unset (NULL).  Handle that case.
2957   const char* const env = getenv(name);
2958   return (env != NULL && env[0] != '\0') ? env : NULL;
2959 #else
2960   return getenv(name);
2961 #endif
2962 }
2963
2964 #ifdef _MSC_VER
2965 # pragma warning(pop)  // Restores the warning state.
2966 #endif
2967
2968 #if GTEST_OS_WINDOWS_MOBILE
2969 // Windows CE has no C library. The abort() function is used in
2970 // several places in Google Test. This implementation provides a reasonable
2971 // imitation of standard behaviour.
2972 void Abort();
2973 #else
2974 inline void Abort() { abort(); }
2975 #endif  // GTEST_OS_WINDOWS_MOBILE
2976
2977 }  // namespace posix
2978
2979 // MSVC "deprecates" snprintf and issues warnings wherever it is used.  In
2980 // order to avoid these warnings, we need to use _snprintf or _snprintf_s on
2981 // MSVC-based platforms.  We map the GTEST_SNPRINTF_ macro to the appropriate
2982 // function in order to achieve that.  We use macro definition here because
2983 // snprintf is a variadic function.
2984 #if defined(_MSC_VER) && _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE
2985 // MSVC 2005 and above support variadic macros.
2986 # define GTEST_SNPRINTF_(buffer, size, format, ...) \
2987      _snprintf_s(buffer, size, size, format, __VA_ARGS__)
2988 #elif defined(_MSC_VER)
2989 // Windows CE does not define _snprintf_s and MSVC prior to 2005 doesn't
2990 // complain about _snprintf.
2991 # define GTEST_SNPRINTF_ _snprintf
2992 #else
2993 # define GTEST_SNPRINTF_ snprintf
2994 #endif
2995
2996 // The maximum number a BiggestInt can represent.  This definition
2997 // works no matter BiggestInt is represented in one's complement or
2998 // two's complement.
2999 //
3000 // We cannot rely on numeric_limits in STL, as __int64 and long long
3001 // are not part of standard C++ and numeric_limits doesn't need to be
3002 // defined for them.
3003 const BiggestInt kMaxBiggestInt =
3004     ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1));
3005
3006 // This template class serves as a compile-time function from size to
3007 // type.  It maps a size in bytes to a primitive type with that
3008 // size. e.g.
3009 //
3010 //   TypeWithSize<4>::UInt
3011 //
3012 // is typedef-ed to be unsigned int (unsigned integer made up of 4
3013 // bytes).
3014 //
3015 // Such functionality should belong to STL, but I cannot find it
3016 // there.
3017 //
3018 // Google Test uses this class in the implementation of floating-point
3019 // comparison.
3020 //
3021 // For now it only handles UInt (unsigned int) as that's all Google Test
3022 // needs.  Other types can be easily added in the future if need
3023 // arises.
3024 template <size_t size>
3025 class TypeWithSize {
3026  public:
3027   // This prevents the user from using TypeWithSize<N> with incorrect
3028   // values of N.
3029   typedef void UInt;
3030 };
3031
3032 // The specialization for size 4.
3033 template <>
3034 class TypeWithSize<4> {
3035  public:
3036   // unsigned int has size 4 in both gcc and MSVC.
3037   //
3038   // As base/basictypes.h doesn't compile on Windows, we cannot use
3039   // uint32, uint64, and etc here.
3040   typedef int Int;
3041   typedef unsigned int UInt;
3042 };
3043
3044 // The specialization for size 8.
3045 template <>
3046 class TypeWithSize<8> {
3047  public:
3048 #if GTEST_OS_WINDOWS
3049   typedef __int64 Int;
3050   typedef unsigned __int64 UInt;
3051 #else
3052   typedef long long Int;  // NOLINT
3053   typedef unsigned long long UInt;  // NOLINT
3054 #endif  // GTEST_OS_WINDOWS
3055 };
3056
3057 // Integer types of known sizes.
3058 typedef TypeWithSize<4>::Int Int32;
3059 typedef TypeWithSize<4>::UInt UInt32;
3060 typedef TypeWithSize<8>::Int Int64;
3061 typedef TypeWithSize<8>::UInt UInt64;
3062 typedef TypeWithSize<8>::Int TimeInMillis;  // Represents time in milliseconds.
3063
3064 // Utilities for command line flags and environment variables.
3065
3066 // Macro for referencing flags.
3067 #define GTEST_FLAG(name) FLAGS_gtest_##name
3068
3069 // Macros for declaring flags.
3070 #define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
3071 #define GTEST_DECLARE_int32_(name) \
3072     GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name)
3073 #define GTEST_DECLARE_string_(name) \
3074     GTEST_API_ extern ::std::string GTEST_FLAG(name)
3075
3076 // Macros for defining flags.
3077 #define GTEST_DEFINE_bool_(name, default_val, doc) \
3078     GTEST_API_ bool GTEST_FLAG(name) = (default_val)
3079 #define GTEST_DEFINE_int32_(name, default_val, doc) \
3080     GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
3081 #define GTEST_DEFINE_string_(name, default_val, doc) \
3082     GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)
3083
3084 // Thread annotations
3085 #define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
3086 #define GTEST_LOCK_EXCLUDED_(locks)
3087
3088 // Parses 'str' for a 32-bit signed integer.  If successful, writes the result
3089 // to *value and returns true; otherwise leaves *value unchanged and returns
3090 // false.
3091 // TODO(chandlerc): Find a better way to refactor flag and environment parsing
3092 // out of both gtest-port.cc and gtest.cc to avoid exporting this utility
3093 // function.
3094 bool ParseInt32(const Message& src_text, const char* str, Int32* value);
3095
3096 // Parses a bool/Int32/string from the environment variable
3097 // corresponding to the given Google Test flag.
3098 bool BoolFromGTestEnv(const char* flag, bool default_val);
3099 GTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val);
3100 const char* StringFromGTestEnv(const char* flag, const char* default_val);
3101
3102 }  // namespace internal
3103 }  // namespace testing
3104
3105 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
3106
3107 #if GTEST_OS_LINUX
3108 # include <stdlib.h>
3109 # include <sys/types.h>
3110 # include <sys/wait.h>
3111 # include <unistd.h>
3112 #endif  // GTEST_OS_LINUX
3113
3114 #if GTEST_HAS_EXCEPTIONS
3115 # include <stdexcept>
3116 #endif
3117
3118 #include <ctype.h>
3119 #include <float.h>
3120 #include <string.h>
3121 #include <iomanip>
3122 #include <limits>
3123 #include <set>
3124
3125 // Copyright 2005, Google Inc.
3126 // All rights reserved.
3127 //
3128 // Redistribution and use in source and binary forms, with or without
3129 // modification, are permitted provided that the following conditions are
3130 // met:
3131 //
3132 //     * Redistributions of source code must retain the above copyright
3133 // notice, this list of conditions and the following disclaimer.
3134 //     * Redistributions in binary form must reproduce the above
3135 // copyright notice, this list of conditions and the following disclaimer
3136 // in the documentation and/or other materials provided with the
3137 // distribution.
3138 //     * Neither the name of Google Inc. nor the names of its
3139 // contributors may be used to endorse or promote products derived from
3140 // this software without specific prior written permission.
3141 //
3142 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
3143 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
3144 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
3145 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
3146 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
3147 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
3148 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
3149 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
3150 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
3151 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
3152 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
3153 //
3154 // Author: wan@google.com (Zhanyong Wan)
3155 //
3156 // The Google C++ Testing Framework (Google Test)
3157 //
3158 // This header file defines the Message class.
3159 //
3160 // IMPORTANT NOTE: Due to limitation of the C++ language, we have to
3161 // leave some internal implementation details in this header file.
3162 // They are clearly marked by comments like this:
3163 //
3164 //   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
3165 //
3166 // Such code is NOT meant to be used by a user directly, and is subject
3167 // to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
3168 // program!
3169
3170 #ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
3171 #define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
3172
3173 #include <limits>
3174
3175
3176 // Ensures that there is at least one operator<< in the global namespace.
3177 // See Message& operator<<(...) below for why.
3178 void operator<<(const testing::internal::Secret&, int);
3179
3180 namespace testing {
3181
3182 // The Message class works like an ostream repeater.
3183 //
3184 // Typical usage:
3185 //
3186 //   1. You stream a bunch of values to a Message object.
3187 //      It will remember the text in a stringstream.
3188 //   2. Then you stream the Message object to an ostream.
3189 //      This causes the text in the Message to be streamed
3190 //      to the ostream.
3191 //
3192 // For example;
3193 //
3194 //   testing::Message foo;
3195 //   foo << 1 << " != " << 2;
3196 //   std::cout << foo;
3197 //
3198 // will print "1 != 2".
3199 //
3200 // Message is not intended to be inherited from.  In particular, its
3201 // destructor is not virtual.
3202 //
3203 // Note that stringstream behaves differently in gcc and in MSVC.  You
3204 // can stream a NULL char pointer to it in the former, but not in the
3205 // latter (it causes an access violation if you do).  The Message
3206 // class hides this difference by treating a NULL char pointer as
3207 // "(null)".
3208 class GTEST_API_ Message {
3209  private:
3210   // The type of basic IO manipulators (endl, ends, and flush) for
3211   // narrow streams.
3212   typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
3213
3214  public:
3215   // Constructs an empty Message.
3216   Message();
3217
3218   // Copy constructor.
3219   Message(const Message& msg) : ss_(new ::std::stringstream) {  // NOLINT
3220     *ss_ << msg.GetString();
3221   }
3222
3223   // Constructs a Message from a C-string.
3224   explicit Message(const char* str) : ss_(new ::std::stringstream) {
3225     *ss_ << str;
3226   }
3227
3228 #if GTEST_OS_SYMBIAN
3229   // Streams a value (either a pointer or not) to this object.
3230   template <typename T>
3231   inline Message& operator <<(const T& value) {
3232     StreamHelper(typename internal::is_pointer<T>::type(), value);
3233     return *this;
3234   }
3235 #else
3236   // Streams a non-pointer value to this object.
3237   template <typename T>
3238   inline Message& operator <<(const T& val) {
3239     // Some libraries overload << for STL containers.  These
3240     // overloads are defined in the global namespace instead of ::std.
3241     //
3242     // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
3243     // overloads are visible in either the std namespace or the global
3244     // namespace, but not other namespaces, including the testing
3245     // namespace which Google Test's Message class is in.
3246     //
3247     // To allow STL containers (and other types that has a << operator
3248     // defined in the global namespace) to be used in Google Test
3249     // assertions, testing::Message must access the custom << operator
3250     // from the global namespace.  With this using declaration,
3251     // overloads of << defined in the global namespace and those
3252     // visible via Koenig lookup are both exposed in this function.
3253     using ::operator <<;
3254     *ss_ << val;
3255     return *this;
3256   }
3257
3258   // Streams a pointer value to this object.
3259   //
3260   // This function is an overload of the previous one.  When you
3261   // stream a pointer to a Message, this definition will be used as it
3262   // is more specialized.  (The C++ Standard, section
3263   // [temp.func.order].)  If you stream a non-pointer, then the
3264   // previous definition will be used.
3265   //
3266   // The reason for this overload is that streaming a NULL pointer to
3267   // ostream is undefined behavior.  Depending on the compiler, you
3268   // may get "0", "(nil)", "(null)", or an access violation.  To
3269   // ensure consistent result across compilers, we always treat NULL
3270   // as "(null)".
3271   template <typename T>
3272   inline Message& operator <<(T* const& pointer) {  // NOLINT
3273     if (pointer == NULL) {
3274       *ss_ << "(null)";
3275     } else {
3276       *ss_ << pointer;
3277     }
3278     return *this;
3279   }
3280 #endif  // GTEST_OS_SYMBIAN
3281
3282   // Since the basic IO manipulators are overloaded for both narrow
3283   // and wide streams, we have to provide this specialized definition
3284   // of operator <<, even though its body is the same as the
3285   // templatized version above.  Without this definition, streaming
3286   // endl or other basic IO manipulators to Message will confuse the
3287   // compiler.
3288   Message& operator <<(BasicNarrowIoManip val) {
3289     *ss_ << val;
3290     return *this;
3291   }
3292
3293   // Instead of 1/0, we want to see true/false for bool values.
3294   Message& operator <<(bool b) {
3295     return *this << (b ? "true" : "false");
3296   }
3297
3298   // These two overloads allow streaming a wide C string to a Message
3299   // using the UTF-8 encoding.
3300   Message& operator <<(const wchar_t* wide_c_str);
3301   Message& operator <<(wchar_t* wide_c_str);
3302
3303 #if GTEST_HAS_STD_WSTRING
3304   // Converts the given wide string to a narrow string using the UTF-8
3305   // encoding, and streams the result to this Message object.
3306   Message& operator <<(const ::std::wstring& wstr);
3307 #endif  // GTEST_HAS_STD_WSTRING
3308
3309 #if GTEST_HAS_GLOBAL_WSTRING
3310   // Converts the given wide string to a narrow string using the UTF-8
3311   // encoding, and streams the result to this Message object.
3312   Message& operator <<(const ::wstring& wstr);
3313 #endif  // GTEST_HAS_GLOBAL_WSTRING
3314
3315   // Gets the text streamed to this object so far as an std::string.
3316   // Each '\0' character in the buffer is replaced with "\\0".
3317   //
3318   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
3319   std::string GetString() const;
3320
3321  private:
3322
3323 #if GTEST_OS_SYMBIAN
3324   // These are needed as the Nokia Symbian Compiler cannot decide between
3325   // const T& and const T* in a function template. The Nokia compiler _can_
3326   // decide between class template specializations for T and T*, so a
3327   // tr1::type_traits-like is_pointer works, and we can overload on that.
3328   template <typename T>
3329   inline void StreamHelper(internal::true_type /*is_pointer*/, T* pointer) {
3330     if (pointer == NULL) {
3331       *ss_ << "(null)";
3332     } else {
3333       *ss_ << pointer;
3334     }
3335   }
3336   template <typename T>
3337   inline void StreamHelper(internal::false_type /*is_pointer*/,
3338                            const T& value) {
3339     // See the comments in Message& operator <<(const T&) above for why
3340     // we need this using statement.
3341     using ::operator <<;
3342     *ss_ << value;
3343   }
3344 #endif  // GTEST_OS_SYMBIAN
3345
3346   // We'll hold the text streamed to this object here.
3347   const internal::scoped_ptr< ::std::stringstream> ss_;
3348
3349   // We declare (but don't implement) this to prevent the compiler
3350   // from implementing the assignment operator.
3351   void operator=(const Message&);
3352 };
3353
3354 // Streams a Message to an ostream.
3355 inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
3356   return os << sb.GetString();
3357 }
3358
3359 namespace internal {
3360
3361 // Converts a streamable value to an std::string.  A NULL pointer is
3362 // converted to "(null)".  When the input value is a ::string,
3363 // ::std::string, ::wstring, or ::std::wstring object, each NUL
3364 // character in it is replaced with "\\0".
3365 template <typename T>
3366 std::string StreamableToString(const T& streamable) {
3367   return (Message() << streamable).GetString();
3368 }
3369
3370 }  // namespace internal
3371 }  // namespace testing
3372
3373 #endif  // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
3374 // Copyright 2005, Google Inc.
3375 // All rights reserved.
3376 //
3377 // Redistribution and use in source and binary forms, with or without
3378 // modification, are permitted provided that the following conditions are
3379 // met:
3380 //
3381 //     * Redistributions of source code must retain the above copyright
3382 // notice, this list of conditions and the following disclaimer.
3383 //     * Redistributions in binary form must reproduce the above
3384 // copyright notice, this list of conditions and the following disclaimer
3385 // in the documentation and/or other materials provided with the
3386 // distribution.
3387 //     * Neither the name of Google Inc. nor the names of its
3388 // contributors may be used to endorse or promote products derived from
3389 // this software without specific prior written permission.
3390 //
3391 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
3392 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
3393 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
3394 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
3395 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
3396 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
3397 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
3398 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
3399 // THEOR