a bunch of updates. to be checked on durian. does not build.
[jacinto-ai/caffe-jacinto.git] / src / gtest / 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.
51 #ifndef GTEST_INCLUDE_GTEST_GTEST_H_
52 #define GTEST_INCLUDE_GTEST_GTEST_H_
54 #include <limits>
55 #include <vector>
57 // Copyright 2005, Google Inc.
58 // All rights reserved.
59 //
60 // Redistribution and use in source and binary forms, with or without
61 // modification, are permitted provided that the following conditions are
62 // met:
63 //
64 //     * Redistributions of source code must retain the above copyright
65 // notice, this list of conditions and the following disclaimer.
66 //     * Redistributions in binary form must reproduce the above
67 // copyright notice, this list of conditions and the following disclaimer
68 // in the documentation and/or other materials provided with the
69 // distribution.
70 //     * Neither the name of Google Inc. nor the names of its
71 // contributors may be used to endorse or promote products derived from
72 // this software without specific prior written permission.
73 //
74 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
75 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
76 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
77 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
78 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
79 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
80 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
81 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
82 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
83 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
84 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
85 //
86 // Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
87 //
88 // The Google C++ Testing Framework (Google Test)
89 //
90 // This header file declares functions and macros used internally by
91 // Google Test.  They are subject to change without notice.
93 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
94 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
96 // Copyright 2005, Google Inc.
97 // All rights reserved.
98 //
99 // Redistribution and use in source and binary forms, with or without
100 // modification, are permitted provided that the following conditions are
101 // met:
102 //
103 //     * Redistributions of source code must retain the above copyright
104 // notice, this list of conditions and the following disclaimer.
105 //     * Redistributions in binary form must reproduce the above
106 // copyright notice, this list of conditions and the following disclaimer
107 // in the documentation and/or other materials provided with the
108 // distribution.
109 //     * Neither the name of Google Inc. nor the names of its
110 // contributors may be used to endorse or promote products derived from
111 // this software without specific prior written permission.
112 //
113 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
114 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
115 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
116 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
117 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
118 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
119 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
120 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
121 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
122 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
123 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
124 //
125 // Authors: wan@google.com (Zhanyong Wan)
126 //
127 // Low-level types and utilities for porting Google Test to various
128 // platforms.  They are subject to change without notice.  DO NOT USE
129 // THEM IN USER CODE.
131 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
132 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
134 // The user can define the following macros in the build script to
135 // control Google Test's behavior.  If the user doesn't define a macro
136 // in this list, Google Test will define it.
137 //
138 //   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)
139 //                              is/isn't available.
140 //   GTEST_HAS_EXCEPTIONS     - Define it to 1/0 to indicate that exceptions
141 //                              are enabled.
142 //   GTEST_HAS_GLOBAL_STRING  - Define it to 1/0 to indicate that ::string
143 //                              is/isn't available (some systems define
144 //                              ::string, which is different to std::string).
145 //   GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string
146 //                              is/isn't available (some systems define
147 //                              ::wstring, which is different to std::wstring).
148 //   GTEST_HAS_POSIX_RE       - Define it to 1/0 to indicate that POSIX regular
149 //                              expressions are/aren't available.
150 //   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>
151 //                              is/isn't available.
152 //   GTEST_HAS_RTTI           - Define it to 1/0 to indicate that RTTI is/isn't
153 //                              enabled.
154 //   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that
155 //                              std::wstring does/doesn't work (Google Test can
156 //                              be used where std::wstring is unavailable).
157 //   GTEST_HAS_TR1_TUPLE      - Define it to 1/0 to indicate tr1::tuple
158 //                              is/isn't available.
159 //   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the
160 //                              compiler supports Microsoft's "Structured
161 //                              Exception Handling".
162 //   GTEST_HAS_STREAM_REDIRECTION
163 //                            - Define it to 1/0 to indicate whether the
164 //                              platform supports I/O stream redirection using
165 //                              dup() and dup2().
166 //   GTEST_USE_OWN_TR1_TUPLE  - Define it to 1/0 to indicate whether Google
167 //                              Test's own tr1 tuple implementation should be
168 //                              used.  Unused when the user sets
169 //                              GTEST_HAS_TR1_TUPLE to 0.
170 //   GTEST_LINKED_AS_SHARED_LIBRARY
171 //                            - Define to 1 when compiling tests that use
172 //                              Google Test as a shared library (known as
173 //                              DLL on Windows).
174 //   GTEST_CREATE_SHARED_LIBRARY
175 //                            - Define to 1 when compiling Google Test itself
176 //                              as a shared library.
178 // This header defines the following utilities:
179 //
180 // Macros indicating the current platform (defined to 1 if compiled on
181 // the given platform; otherwise undefined):
182 //   GTEST_OS_AIX      - IBM AIX
183 //   GTEST_OS_CYGWIN   - Cygwin
184 //   GTEST_OS_HPUX     - HP-UX
185 //   GTEST_OS_LINUX    - Linux
186 //     GTEST_OS_LINUX_ANDROID - Google Android
187 //   GTEST_OS_MAC      - Mac OS X
188 //   GTEST_OS_NACL     - Google Native Client (NaCl)
189 //   GTEST_OS_SOLARIS  - Sun Solaris
190 //   GTEST_OS_SYMBIAN  - Symbian
191 //   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
192 //     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop
193 //     GTEST_OS_WINDOWS_MINGW    - MinGW
194 //     GTEST_OS_WINDOWS_MOBILE   - Windows Mobile
195 //   GTEST_OS_ZOS      - z/OS
196 //
197 // Among the platforms, Cygwin, Linux, Max OS X, and Windows have the
198 // most stable support.  Since core members of the Google Test project
199 // don't have access to other platforms, support for them may be less
200 // stable.  If you notice any problems on your platform, please notify
201 // googletestframework@googlegroups.com (patches for fixing them are
202 // even more welcome!).
203 //
204 // Note that it is possible that none of the GTEST_OS_* macros are defined.
205 //
206 // Macros indicating available Google Test features (defined to 1 if
207 // the corresponding feature is supported; otherwise undefined):
208 //   GTEST_HAS_COMBINE      - the Combine() function (for value-parameterized
209 //                            tests)
210 //   GTEST_HAS_DEATH_TEST   - death tests
211 //   GTEST_HAS_PARAM_TEST   - value-parameterized tests
212 //   GTEST_HAS_TYPED_TEST   - typed tests
213 //   GTEST_HAS_TYPED_TEST_P - type-parameterized tests
214 //   GTEST_USES_POSIX_RE    - enhanced POSIX regex is used. Do not confuse with
215 //                            GTEST_HAS_POSIX_RE (see above) which users can
216 //                            define themselves.
217 //   GTEST_USES_SIMPLE_RE   - our own simple regex is used;
218 //                            the above two are mutually exclusive.
219 //   GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ().
220 //
221 // Macros for basic C++ coding:
222 //   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
223 //   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a
224 //                              variable don't have to be used.
225 //   GTEST_DISALLOW_ASSIGN_   - disables operator=.
226 //   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
227 //   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
228 //
229 // Synchronization:
230 //   Mutex, MutexLock, ThreadLocal, GetThreadCount()
231 //                  - synchronization primitives.
232 //   GTEST_IS_THREADSAFE - defined to 1 to indicate that the above
233 //                         synchronization primitives have real implementations
234 //                         and Google Test is thread-safe; or 0 otherwise.
235 //
236 // Template meta programming:
237 //   is_pointer     - as in TR1; needed on Symbian and IBM XL C/C++ only.
238 //   IteratorTraits - partial implementation of std::iterator_traits, which
239 //                    is not available in libCstd when compiled with Sun C++.
240 //
241 // Smart pointers:
242 //   scoped_ptr     - as in TR2.
243 //
244 // Regular expressions:
245 //   RE             - a simple regular expression class using the POSIX
246 //                    Extended Regular Expression syntax on UNIX-like
247 //                    platforms, or a reduced regular exception syntax on
248 //                    other platforms, including Windows.
249 //
250 // Logging:
251 //   GTEST_LOG_()   - logs messages at the specified severity level.
252 //   LogToStderr()  - directs all log messages to stderr.
253 //   FlushInfoLog() - flushes informational log messages.
254 //
255 // Stdout and stderr capturing:
256 //   CaptureStdout()     - starts capturing stdout.
257 //   GetCapturedStdout() - stops capturing stdout and returns the captured
258 //                         string.
259 //   CaptureStderr()     - starts capturing stderr.
260 //   GetCapturedStderr() - stops capturing stderr and returns the captured
261 //                         string.
262 //
263 // Integer types:
264 //   TypeWithSize   - maps an integer to a int type.
265 //   Int32, UInt32, Int64, UInt64, TimeInMillis
266 //                  - integers of known sizes.
267 //   BiggestInt     - the biggest signed integer type.
268 //
269 // Command-line utilities:
270 //   GTEST_FLAG()       - references a flag.
271 //   GTEST_DECLARE_*()  - declares a flag.
272 //   GTEST_DEFINE_*()   - defines a flag.
273 //   GetArgvs()         - returns the command line as a vector of strings.
274 //
275 // Environment variable utilities:
276 //   GetEnv()             - gets the value of an environment variable.
277 //   BoolFromGTestEnv()   - parses a bool environment variable.
278 //   Int32FromGTestEnv()  - parses an Int32 environment variable.
279 //   StringFromGTestEnv() - parses a string environment variable.
281 #include <ctype.h>   // for isspace, etc
282 #include <stddef.h>  // for ptrdiff_t
283 #include <stdlib.h>
284 #include <stdio.h>
285 #include <string.h>
286 #ifndef _WIN32_WCE
287 # include <sys/types.h>
288 # include <sys/stat.h>
289 #endif  // !_WIN32_WCE
291 #include <iostream>  // NOLINT
292 #include <sstream>  // NOLINT
293 #include <string>  // NOLINT
295 #define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
296 #define GTEST_FLAG_PREFIX_ "gtest_"
297 #define GTEST_FLAG_PREFIX_DASH_ "gtest-"
298 #define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
299 #define GTEST_NAME_ "Google Test"
300 #define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/"
302 // Determines the version of gcc that is used to compile this.
303 #ifdef __GNUC__
304 // 40302 means version 4.3.2.
305 # define GTEST_GCC_VER_ \
306     (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
307 #endif  // __GNUC__
309 // Determines the platform on which Google Test is compiled.
310 #ifdef __CYGWIN__
311 # define GTEST_OS_CYGWIN 1
312 #elif defined __SYMBIAN32__
313 # define GTEST_OS_SYMBIAN 1
314 #elif defined _WIN32
315 # define GTEST_OS_WINDOWS 1
316 # ifdef _WIN32_WCE
317 #  define GTEST_OS_WINDOWS_MOBILE 1
318 # elif defined(__MINGW__) || defined(__MINGW32__)
319 #  define GTEST_OS_WINDOWS_MINGW 1
320 # else
321 #  define GTEST_OS_WINDOWS_DESKTOP 1
322 # endif  // _WIN32_WCE
323 #elif defined __APPLE__
324 # define GTEST_OS_MAC 1
325 #elif defined __linux__
326 # define GTEST_OS_LINUX 1
327 # ifdef ANDROID
328 #  define GTEST_OS_LINUX_ANDROID 1
329 # endif  // ANDROID
330 #elif defined __MVS__
331 # define GTEST_OS_ZOS 1
332 #elif defined(__sun) && defined(__SVR4)
333 # define GTEST_OS_SOLARIS 1
334 #elif defined(_AIX)
335 # define GTEST_OS_AIX 1
336 #elif defined(__hpux)
337 # define GTEST_OS_HPUX 1
338 #elif defined __native_client__
339 # define GTEST_OS_NACL 1
340 #endif  // __CYGWIN__
342 // Brings in definitions for functions used in the testing::internal::posix
343 // namespace (read, write, close, chdir, isatty, stat). We do not currently
344 // use them on Windows Mobile.
345 #if !GTEST_OS_WINDOWS
346 // This assumes that non-Windows OSes provide unistd.h. For OSes where this
347 // is not the case, we need to include headers that provide the functions
348 // mentioned above.
349 # include <unistd.h>
350 # if !GTEST_OS_NACL
351 // TODO(vladl@google.com): Remove this condition when Native Client SDK adds
352 // strings.h (tracked in
353 // http://code.google.com/p/nativeclient/issues/detail?id=1175).
354 #  include <strings.h>  // Native Client doesn't provide strings.h.
355 # endif
356 #elif !GTEST_OS_WINDOWS_MOBILE
357 # include <direct.h>
358 # include <io.h>
359 #endif
361 // Defines this to true iff Google Test can use POSIX regular expressions.
362 #ifndef GTEST_HAS_POSIX_RE
363 # define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS)
364 #endif
366 #if GTEST_HAS_POSIX_RE
368 // On some platforms, <regex.h> needs someone to define size_t, and
369 // won't compile otherwise.  We can #include it here as we already
370 // included <stdlib.h>, which is guaranteed to define size_t through
371 // <stddef.h>.
372 # include <regex.h>  // NOLINT
374 # define GTEST_USES_POSIX_RE 1
376 #elif GTEST_OS_WINDOWS
378 // <regex.h> is not available on Windows.  Use our own simple regex
379 // implementation instead.
380 # define GTEST_USES_SIMPLE_RE 1
382 #else
384 // <regex.h> may not be available on this platform.  Use our own
385 // simple regex implementation instead.
386 # define GTEST_USES_SIMPLE_RE 1
388 #endif  // GTEST_HAS_POSIX_RE
390 #ifndef GTEST_HAS_EXCEPTIONS
391 // The user didn't tell us whether exceptions are enabled, so we need
392 // to figure it out.
393 # if defined(_MSC_VER) || defined(__BORLANDC__)
394 // MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS
395 // macro to enable exceptions, so we'll do the same.
396 // Assumes that exceptions are enabled by default.
397 #  ifndef _HAS_EXCEPTIONS
398 #   define _HAS_EXCEPTIONS 1
399 #  endif  // _HAS_EXCEPTIONS
400 #  define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
401 # elif defined(__GNUC__) && __EXCEPTIONS
402 // gcc defines __EXCEPTIONS to 1 iff exceptions are enabled.
403 #  define GTEST_HAS_EXCEPTIONS 1
404 # elif defined(__SUNPRO_CC)
405 // Sun Pro CC supports exceptions.  However, there is no compile-time way of
406 // detecting whether they are enabled or not.  Therefore, we assume that
407 // they are enabled unless the user tells us otherwise.
408 #  define GTEST_HAS_EXCEPTIONS 1
409 # elif defined(__IBMCPP__) && __EXCEPTIONS
410 // xlC defines __EXCEPTIONS to 1 iff exceptions are enabled.
411 #  define GTEST_HAS_EXCEPTIONS 1
412 # elif defined(__HP_aCC)
413 // Exception handling is in effect by default in HP aCC compiler. It has to
414 // be turned of by +noeh compiler option if desired.
415 #  define GTEST_HAS_EXCEPTIONS 1
416 # else
417 // For other compilers, we assume exceptions are disabled to be
418 // conservative.
419 #  define GTEST_HAS_EXCEPTIONS 0
420 # endif  // defined(_MSC_VER) || defined(__BORLANDC__)
421 #endif  // GTEST_HAS_EXCEPTIONS
423 #if !defined(GTEST_HAS_STD_STRING)
424 // Even though we don't use this macro any longer, we keep it in case
425 // some clients still depend on it.
426 # define GTEST_HAS_STD_STRING 1
427 #elif !GTEST_HAS_STD_STRING
428 // The user told us that ::std::string isn't available.
429 # error "Google Test cannot be used where ::std::string isn't available."
430 #endif  // !defined(GTEST_HAS_STD_STRING)
432 #ifndef GTEST_HAS_GLOBAL_STRING
433 // The user didn't tell us whether ::string is available, so we need
434 // to figure it out.
436 # define GTEST_HAS_GLOBAL_STRING 0
438 #endif  // GTEST_HAS_GLOBAL_STRING
440 #ifndef GTEST_HAS_STD_WSTRING
441 // The user didn't tell us whether ::std::wstring is available, so we need
442 // to figure it out.
443 // TODO(wan@google.com): uses autoconf to detect whether ::std::wstring
444 //   is available.
446 // Cygwin 1.7 and below doesn't support ::std::wstring.
447 // Solaris' libc++ doesn't support it either.  Android has
448 // no support for it at least as recent as Froyo (2.2).
449 # define GTEST_HAS_STD_WSTRING \
450     (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS))
452 #endif  // GTEST_HAS_STD_WSTRING
454 #ifndef GTEST_HAS_GLOBAL_WSTRING
455 // The user didn't tell us whether ::wstring is available, so we need
456 // to figure it out.
457 # define GTEST_HAS_GLOBAL_WSTRING \
458     (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
459 #endif  // GTEST_HAS_GLOBAL_WSTRING
461 // Determines whether RTTI is available.
462 #ifndef GTEST_HAS_RTTI
463 // The user didn't tell us whether RTTI is enabled, so we need to
464 // figure it out.
466 # ifdef _MSC_VER
468 #  ifdef _CPPRTTI  // MSVC defines this macro iff RTTI is enabled.
469 #   define GTEST_HAS_RTTI 1
470 #  else
471 #   define GTEST_HAS_RTTI 0
472 #  endif
474 // Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled.
475 # elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302)
477 #  ifdef __GXX_RTTI
478 #   define GTEST_HAS_RTTI 1
479 #  else
480 #   define GTEST_HAS_RTTI 0
481 #  endif  // __GXX_RTTI
483 // Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
484 // both the typeid and dynamic_cast features are present.
485 # elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
487 #  ifdef __RTTI_ALL__
488 #   define GTEST_HAS_RTTI 1
489 #  else
490 #   define GTEST_HAS_RTTI 0
491 #  endif
493 # else
495 // For all other compilers, we assume RTTI is enabled.
496 #  define GTEST_HAS_RTTI 1
498 # endif  // _MSC_VER
500 #endif  // GTEST_HAS_RTTI
502 // It's this header's responsibility to #include <typeinfo> when RTTI
503 // is enabled.
504 #if GTEST_HAS_RTTI
505 # include <typeinfo>
506 #endif
508 // Determines whether Google Test can use the pthreads library.
509 #ifndef GTEST_HAS_PTHREAD
510 // The user didn't tell us explicitly, so we assume pthreads support is
511 // available on Linux and Mac.
512 //
513 // To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
514 // to your compiler flags.
515 # define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX)
516 #endif  // GTEST_HAS_PTHREAD
518 #if GTEST_HAS_PTHREAD
519 // gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is
520 // true.
521 # include <pthread.h>  // NOLINT
523 // For timespec and nanosleep, used below.
524 # include <time.h>  // NOLINT
525 #endif
527 // Determines whether Google Test can use tr1/tuple.  You can define
528 // this macro to 0 to prevent Google Test from using tuple (any
529 // feature depending on tuple with be disabled in this mode).
530 #ifndef GTEST_HAS_TR1_TUPLE
531 // The user didn't tell us not to do it, so we assume it's OK.
532 # define GTEST_HAS_TR1_TUPLE 1
533 #endif  // GTEST_HAS_TR1_TUPLE
535 // Determines whether Google Test's own tr1 tuple implementation
536 // should be used.
537 #ifndef GTEST_USE_OWN_TR1_TUPLE
538 // The user didn't tell us, so we need to figure it out.
540 // We use our own TR1 tuple if we aren't sure the user has an
541 // implementation of it already.  At this time, GCC 4.0.0+ and MSVC
542 // 2010 are the only mainstream compilers that come with a TR1 tuple
543 // implementation.  NVIDIA's CUDA NVCC compiler pretends to be GCC by
544 // defining __GNUC__ and friends, but cannot compile GCC's tuple
545 // implementation.  MSVC 2008 (9.0) provides TR1 tuple in a 323 MB
546 // Feature Pack download, which we cannot assume the user has.
547 # if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000)) \
548     || _MSC_VER >= 1600
549 #  define GTEST_USE_OWN_TR1_TUPLE 0
550 # else
551 #  define GTEST_USE_OWN_TR1_TUPLE 1
552 # endif
554 #endif  // GTEST_USE_OWN_TR1_TUPLE
556 // To avoid conditional compilation everywhere, we make it
557 // gtest-port.h's responsibility to #include the header implementing
558 // tr1/tuple.
559 #if GTEST_HAS_TR1_TUPLE
561 # if GTEST_USE_OWN_TR1_TUPLE
562 // This file was GENERATED by a script.  DO NOT EDIT BY HAND!!!
564 // Copyright 2009 Google Inc.
565 // All Rights Reserved.
566 //
567 // Redistribution and use in source and binary forms, with or without
568 // modification, are permitted provided that the following conditions are
569 // met:
570 //
571 //     * Redistributions of source code must retain the above copyright
572 // notice, this list of conditions and the following disclaimer.
573 //     * Redistributions in binary form must reproduce the above
574 // copyright notice, this list of conditions and the following disclaimer
575 // in the documentation and/or other materials provided with the
576 // distribution.
577 //     * Neither the name of Google Inc. nor the names of its
578 // contributors may be used to endorse or promote products derived from
579 // this software without specific prior written permission.
580 //
581 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
582 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
583 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
584 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
585 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
586 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
587 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
588 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
589 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
590 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
591 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
592 //
593 // Author: wan@google.com (Zhanyong Wan)
595 // Implements a subset of TR1 tuple needed by Google Test and Google Mock.
597 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
598 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
600 #include <utility>  // For ::std::pair.
602 // The compiler used in Symbian has a bug that prevents us from declaring the
603 // tuple template as a friend (it complains that tuple is redefined).  This
604 // hack bypasses the bug by declaring the members that should otherwise be
605 // private as public.
606 // Sun Studio versions < 12 also have the above bug.
607 #if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)
608 # define GTEST_DECLARE_TUPLE_AS_FRIEND_ public:
609 #else
610 # define GTEST_DECLARE_TUPLE_AS_FRIEND_ \
611     template <GTEST_10_TYPENAMES_(U)> friend class tuple; \
612    private:
613 #endif
615 // GTEST_n_TUPLE_(T) is the type of an n-tuple.
616 #define GTEST_0_TUPLE_(T) tuple<>
617 #define GTEST_1_TUPLE_(T) tuple<T##0, void, void, void, void, void, void, \
618     void, void, void>
619 #define GTEST_2_TUPLE_(T) tuple<T##0, T##1, void, void, void, void, void, \
620     void, void, void>
621 #define GTEST_3_TUPLE_(T) tuple<T##0, T##1, T##2, void, void, void, void, \
622     void, void, void>
623 #define GTEST_4_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, void, void, void, \
624     void, void, void>
625 #define GTEST_5_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, void, void, \
626     void, void, void>
627 #define GTEST_6_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, void, \
628     void, void, void>
629 #define GTEST_7_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
630     void, void, void>
631 #define GTEST_8_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
632     T##7, void, void>
633 #define GTEST_9_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
634     T##7, T##8, void>
635 #define GTEST_10_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
636     T##7, T##8, T##9>
638 // GTEST_n_TYPENAMES_(T) declares a list of n typenames.
639 #define GTEST_0_TYPENAMES_(T)
640 #define GTEST_1_TYPENAMES_(T) typename T##0
641 #define GTEST_2_TYPENAMES_(T) typename T##0, typename T##1
642 #define GTEST_3_TYPENAMES_(T) typename T##0, typename T##1, typename T##2
643 #define GTEST_4_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
644     typename T##3
645 #define GTEST_5_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
646     typename T##3, typename T##4
647 #define GTEST_6_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
648     typename T##3, typename T##4, typename T##5
649 #define GTEST_7_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
650     typename T##3, typename T##4, typename T##5, typename T##6
651 #define GTEST_8_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
652     typename T##3, typename T##4, typename T##5, typename T##6, typename T##7
653 #define GTEST_9_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
654     typename T##3, typename T##4, typename T##5, typename T##6, \
655     typename T##7, typename T##8
656 #define GTEST_10_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
657     typename T##3, typename T##4, typename T##5, typename T##6, \
658     typename T##7, typename T##8, typename T##9
660 // In theory, defining stuff in the ::std namespace is undefined
661 // behavior.  We can do this as we are playing the role of a standard
662 // library vendor.
663 namespace std {
664 namespace tr1 {
666 template <typename T0 = void, typename T1 = void, typename T2 = void,
667     typename T3 = void, typename T4 = void, typename T5 = void,
668     typename T6 = void, typename T7 = void, typename T8 = void,
669     typename T9 = void>
670 class tuple;
672 // Anything in namespace gtest_internal is Google Test's INTERNAL
673 // IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code.
674 namespace gtest_internal {
676 // ByRef<T>::type is T if T is a reference; otherwise it's const T&.
677 template <typename T>
678 struct ByRef { typedef const T& type; };  // NOLINT
679 template <typename T>
680 struct ByRef<T&> { typedef T& type; };  // NOLINT
682 // A handy wrapper for ByRef.
683 #define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type
685 // AddRef<T>::type is T if T is a reference; otherwise it's T&.  This
686 // is the same as tr1::add_reference<T>::type.
687 template <typename T>
688 struct AddRef { typedef T& type; };  // NOLINT
689 template <typename T>
690 struct AddRef<T&> { typedef T& type; };  // NOLINT
692 // A handy wrapper for AddRef.
693 #define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type
695 // A helper for implementing get<k>().
696 template <int k> class Get;
698 // A helper for implementing tuple_element<k, T>.  kIndexValid is true
699 // iff k < the number of fields in tuple type T.
700 template <bool kIndexValid, int kIndex, class Tuple>
701 struct TupleElement;
703 template <GTEST_10_TYPENAMES_(T)>
704 struct TupleElement<true, 0, GTEST_10_TUPLE_(T)> { typedef T0 type; };
706 template <GTEST_10_TYPENAMES_(T)>
707 struct TupleElement<true, 1, GTEST_10_TUPLE_(T)> { typedef T1 type; };
709 template <GTEST_10_TYPENAMES_(T)>
710 struct TupleElement<true, 2, GTEST_10_TUPLE_(T)> { typedef T2 type; };
712 template <GTEST_10_TYPENAMES_(T)>
713 struct TupleElement<true, 3, GTEST_10_TUPLE_(T)> { typedef T3 type; };
715 template <GTEST_10_TYPENAMES_(T)>
716 struct TupleElement<true, 4, GTEST_10_TUPLE_(T)> { typedef T4 type; };
718 template <GTEST_10_TYPENAMES_(T)>
719 struct TupleElement<true, 5, GTEST_10_TUPLE_(T)> { typedef T5 type; };
721 template <GTEST_10_TYPENAMES_(T)>
722 struct TupleElement<true, 6, GTEST_10_TUPLE_(T)> { typedef T6 type; };
724 template <GTEST_10_TYPENAMES_(T)>
725 struct TupleElement<true, 7, GTEST_10_TUPLE_(T)> { typedef T7 type; };
727 template <GTEST_10_TYPENAMES_(T)>
728 struct TupleElement<true, 8, GTEST_10_TUPLE_(T)> { typedef T8 type; };
730 template <GTEST_10_TYPENAMES_(T)>
731 struct TupleElement<true, 9, GTEST_10_TUPLE_(T)> { typedef T9 type; };
733 }  // namespace gtest_internal
735 template <>
736 class tuple<> {
737  public:
738   tuple() {}
739   tuple(const tuple& /* t */)  {}
740   tuple& operator=(const tuple& /* t */) { return *this; }
741 };
743 template <GTEST_1_TYPENAMES_(T)>
744 class GTEST_1_TUPLE_(T) {
745  public:
746   template <int k> friend class gtest_internal::Get;
748   tuple() : f0_() {}
750   explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {}
752   tuple(const tuple& t) : f0_(t.f0_) {}
754   template <GTEST_1_TYPENAMES_(U)>
755   tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {}
757   tuple& operator=(const tuple& t) { return CopyFrom(t); }
759   template <GTEST_1_TYPENAMES_(U)>
760   tuple& operator=(const GTEST_1_TUPLE_(U)& t) {
761     return CopyFrom(t);
762   }
764   GTEST_DECLARE_TUPLE_AS_FRIEND_
766   template <GTEST_1_TYPENAMES_(U)>
767   tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) {
768     f0_ = t.f0_;
769     return *this;
770   }
772   T0 f0_;
773 };
775 template <GTEST_2_TYPENAMES_(T)>
776 class GTEST_2_TUPLE_(T) {
777  public:
778   template <int k> friend class gtest_internal::Get;
780   tuple() : f0_(), f1_() {}
782   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0),
783       f1_(f1) {}
785   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {}
787   template <GTEST_2_TYPENAMES_(U)>
788   tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {}
789   template <typename U0, typename U1>
790   tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {}
792   tuple& operator=(const tuple& t) { return CopyFrom(t); }
794   template <GTEST_2_TYPENAMES_(U)>
795   tuple& operator=(const GTEST_2_TUPLE_(U)& t) {
796     return CopyFrom(t);
797   }
798   template <typename U0, typename U1>
799   tuple& operator=(const ::std::pair<U0, U1>& p) {
800     f0_ = p.first;
801     f1_ = p.second;
802     return *this;
803   }
805   GTEST_DECLARE_TUPLE_AS_FRIEND_
807   template <GTEST_2_TYPENAMES_(U)>
808   tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) {
809     f0_ = t.f0_;
810     f1_ = t.f1_;
811     return *this;
812   }
814   T0 f0_;
815   T1 f1_;
816 };
818 template <GTEST_3_TYPENAMES_(T)>
819 class GTEST_3_TUPLE_(T) {
820  public:
821   template <int k> friend class gtest_internal::Get;
823   tuple() : f0_(), f1_(), f2_() {}
825   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
826       GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {}
828   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
830   template <GTEST_3_TYPENAMES_(U)>
831   tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
833   tuple& operator=(const tuple& t) { return CopyFrom(t); }
835   template <GTEST_3_TYPENAMES_(U)>
836   tuple& operator=(const GTEST_3_TUPLE_(U)& t) {
837     return CopyFrom(t);
838   }
840   GTEST_DECLARE_TUPLE_AS_FRIEND_
842   template <GTEST_3_TYPENAMES_(U)>
843   tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) {
844     f0_ = t.f0_;
845     f1_ = t.f1_;
846     f2_ = t.f2_;
847     return *this;
848   }
850   T0 f0_;
851   T1 f1_;
852   T2 f2_;
853 };
855 template <GTEST_4_TYPENAMES_(T)>
856 class GTEST_4_TUPLE_(T) {
857  public:
858   template <int k> friend class gtest_internal::Get;
860   tuple() : f0_(), f1_(), f2_(), f3_() {}
862   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
863       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1), f2_(f2),
864       f3_(f3) {}
866   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {}
868   template <GTEST_4_TYPENAMES_(U)>
869   tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
870       f3_(t.f3_) {}
872   tuple& operator=(const tuple& t) { return CopyFrom(t); }
874   template <GTEST_4_TYPENAMES_(U)>
875   tuple& operator=(const GTEST_4_TUPLE_(U)& t) {
876     return CopyFrom(t);
877   }
879   GTEST_DECLARE_TUPLE_AS_FRIEND_
881   template <GTEST_4_TYPENAMES_(U)>
882   tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) {
883     f0_ = t.f0_;
884     f1_ = t.f1_;
885     f2_ = t.f2_;
886     f3_ = t.f3_;
887     return *this;
888   }
890   T0 f0_;
891   T1 f1_;
892   T2 f2_;
893   T3 f3_;
894 };
896 template <GTEST_5_TYPENAMES_(T)>
897 class GTEST_5_TUPLE_(T) {
898  public:
899   template <int k> friend class gtest_internal::Get;
901   tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {}
903   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
904       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3,
905       GTEST_BY_REF_(T4) f4) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4) {}
907   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
908       f4_(t.f4_) {}
910   template <GTEST_5_TYPENAMES_(U)>
911   tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
912       f3_(t.f3_), f4_(t.f4_) {}
914   tuple& operator=(const tuple& t) { return CopyFrom(t); }
916   template <GTEST_5_TYPENAMES_(U)>
917   tuple& operator=(const GTEST_5_TUPLE_(U)& t) {
918     return CopyFrom(t);
919   }
921   GTEST_DECLARE_TUPLE_AS_FRIEND_
923   template <GTEST_5_TYPENAMES_(U)>
924   tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) {
925     f0_ = t.f0_;
926     f1_ = t.f1_;
927     f2_ = t.f2_;
928     f3_ = t.f3_;
929     f4_ = t.f4_;
930     return *this;
931   }
933   T0 f0_;
934   T1 f1_;
935   T2 f2_;
936   T3 f3_;
937   T4 f4_;
938 };
940 template <GTEST_6_TYPENAMES_(T)>
941 class GTEST_6_TUPLE_(T) {
942  public:
943   template <int k> friend class gtest_internal::Get;
945   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {}
947   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
948       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
949       GTEST_BY_REF_(T5) f5) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
950       f5_(f5) {}
952   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
953       f4_(t.f4_), f5_(t.f5_) {}
955   template <GTEST_6_TYPENAMES_(U)>
956   tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
957       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {}
959   tuple& operator=(const tuple& t) { return CopyFrom(t); }
961   template <GTEST_6_TYPENAMES_(U)>
962   tuple& operator=(const GTEST_6_TUPLE_(U)& t) {
963     return CopyFrom(t);
964   }
966   GTEST_DECLARE_TUPLE_AS_FRIEND_
968   template <GTEST_6_TYPENAMES_(U)>
969   tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) {
970     f0_ = t.f0_;
971     f1_ = t.f1_;
972     f2_ = t.f2_;
973     f3_ = t.f3_;
974     f4_ = t.f4_;
975     f5_ = t.f5_;
976     return *this;
977   }
979   T0 f0_;
980   T1 f1_;
981   T2 f2_;
982   T3 f3_;
983   T4 f4_;
984   T5 f5_;
985 };
987 template <GTEST_7_TYPENAMES_(T)>
988 class GTEST_7_TUPLE_(T) {
989  public:
990   template <int k> friend class gtest_internal::Get;
992   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {}
994   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
995       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
996       GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6) : f0_(f0), f1_(f1), f2_(f2),
997       f3_(f3), f4_(f4), f5_(f5), f6_(f6) {}
999   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1000       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
1002   template <GTEST_7_TYPENAMES_(U)>
1003   tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1004       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
1006   tuple& operator=(const tuple& t) { return CopyFrom(t); }
1008   template <GTEST_7_TYPENAMES_(U)>
1009   tuple& operator=(const GTEST_7_TUPLE_(U)& t) {
1010     return CopyFrom(t);
1011   }
1013   GTEST_DECLARE_TUPLE_AS_FRIEND_
1015   template <GTEST_7_TYPENAMES_(U)>
1016   tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) {
1017     f0_ = t.f0_;
1018     f1_ = t.f1_;
1019     f2_ = t.f2_;
1020     f3_ = t.f3_;
1021     f4_ = t.f4_;
1022     f5_ = t.f5_;
1023     f6_ = t.f6_;
1024     return *this;
1025   }
1027   T0 f0_;
1028   T1 f1_;
1029   T2 f2_;
1030   T3 f3_;
1031   T4 f4_;
1032   T5 f5_;
1033   T6 f6_;
1034 };
1036 template <GTEST_8_TYPENAMES_(T)>
1037 class GTEST_8_TUPLE_(T) {
1038  public:
1039   template <int k> friend class gtest_internal::Get;
1041   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {}
1043   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1044       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
1045       GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6,
1046       GTEST_BY_REF_(T7) f7) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
1047       f5_(f5), f6_(f6), f7_(f7) {}
1049   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1050       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
1052   template <GTEST_8_TYPENAMES_(U)>
1053   tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1054       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
1056   tuple& operator=(const tuple& t) { return CopyFrom(t); }
1058   template <GTEST_8_TYPENAMES_(U)>
1059   tuple& operator=(const GTEST_8_TUPLE_(U)& t) {
1060     return CopyFrom(t);
1061   }
1063   GTEST_DECLARE_TUPLE_AS_FRIEND_
1065   template <GTEST_8_TYPENAMES_(U)>
1066   tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) {
1067     f0_ = t.f0_;
1068     f1_ = t.f1_;
1069     f2_ = t.f2_;
1070     f3_ = t.f3_;
1071     f4_ = t.f4_;
1072     f5_ = t.f5_;
1073     f6_ = t.f6_;
1074     f7_ = t.f7_;
1075     return *this;
1076   }
1078   T0 f0_;
1079   T1 f1_;
1080   T2 f2_;
1081   T3 f3_;
1082   T4 f4_;
1083   T5 f5_;
1084   T6 f6_;
1085   T7 f7_;
1086 };
1088 template <GTEST_9_TYPENAMES_(T)>
1089 class GTEST_9_TUPLE_(T) {
1090  public:
1091   template <int k> friend class gtest_internal::Get;
1093   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_() {}
1095   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1096       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
1097       GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
1098       GTEST_BY_REF_(T8) f8) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
1099       f5_(f5), f6_(f6), f7_(f7), f8_(f8) {}
1101   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1102       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
1104   template <GTEST_9_TYPENAMES_(U)>
1105   tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1106       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
1108   tuple& operator=(const tuple& t) { return CopyFrom(t); }
1110   template <GTEST_9_TYPENAMES_(U)>
1111   tuple& operator=(const GTEST_9_TUPLE_(U)& t) {
1112     return CopyFrom(t);
1113   }
1115   GTEST_DECLARE_TUPLE_AS_FRIEND_
1117   template <GTEST_9_TYPENAMES_(U)>
1118   tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) {
1119     f0_ = t.f0_;
1120     f1_ = t.f1_;
1121     f2_ = t.f2_;
1122     f3_ = t.f3_;
1123     f4_ = t.f4_;
1124     f5_ = t.f5_;
1125     f6_ = t.f6_;
1126     f7_ = t.f7_;
1127     f8_ = t.f8_;
1128     return *this;
1129   }
1131   T0 f0_;
1132   T1 f1_;
1133   T2 f2_;
1134   T3 f3_;
1135   T4 f4_;
1136   T5 f5_;
1137   T6 f6_;
1138   T7 f7_;
1139   T8 f8_;
1140 };
1142 template <GTEST_10_TYPENAMES_(T)>
1143 class tuple {
1144  public:
1145   template <int k> friend class gtest_internal::Get;
1147   tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(),
1148       f9_() {}
1150   explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
1151       GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
1152       GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
1153       GTEST_BY_REF_(T8) f8, GTEST_BY_REF_(T9) f9) : f0_(f0), f1_(f1), f2_(f2),
1154       f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8), f9_(f9) {}
1156   tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
1157       f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {}
1159   template <GTEST_10_TYPENAMES_(U)>
1160   tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
1161       f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_),
1162       f9_(t.f9_) {}
1164   tuple& operator=(const tuple& t) { return CopyFrom(t); }
1166   template <GTEST_10_TYPENAMES_(U)>
1167   tuple& operator=(const GTEST_10_TUPLE_(U)& t) {
1168     return CopyFrom(t);
1169   }
1171   GTEST_DECLARE_TUPLE_AS_FRIEND_
1173   template <GTEST_10_TYPENAMES_(U)>
1174   tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) {
1175     f0_ = t.f0_;
1176     f1_ = t.f1_;
1177     f2_ = t.f2_;
1178     f3_ = t.f3_;
1179     f4_ = t.f4_;
1180     f5_ = t.f5_;
1181     f6_ = t.f6_;
1182     f7_ = t.f7_;
1183     f8_ = t.f8_;
1184     f9_ = t.f9_;
1185     return *this;
1186   }
1188   T0 f0_;
1189   T1 f1_;
1190   T2 f2_;
1191   T3 f3_;
1192   T4 f4_;
1193   T5 f5_;
1194   T6 f6_;
1195   T7 f7_;
1196   T8 f8_;
1197   T9 f9_;
1198 };
1200 // 6.1.3.2 Tuple creation functions.
1202 // Known limitations: we don't support passing an
1203 // std::tr1::reference_wrapper<T> to make_tuple().  And we don't
1204 // implement tie().
1206 inline tuple<> make_tuple() { return tuple<>(); }
1208 template <GTEST_1_TYPENAMES_(T)>
1209 inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) {
1210   return GTEST_1_TUPLE_(T)(f0);
1213 template <GTEST_2_TYPENAMES_(T)>
1214 inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) {
1215   return GTEST_2_TUPLE_(T)(f0, f1);
1218 template <GTEST_3_TYPENAMES_(T)>
1219 inline GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) {
1220   return GTEST_3_TUPLE_(T)(f0, f1, f2);
1223 template <GTEST_4_TYPENAMES_(T)>
1224 inline GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1225     const T3& f3) {
1226   return GTEST_4_TUPLE_(T)(f0, f1, f2, f3);
1229 template <GTEST_5_TYPENAMES_(T)>
1230 inline GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1231     const T3& f3, const T4& f4) {
1232   return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4);
1235 template <GTEST_6_TYPENAMES_(T)>
1236 inline GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1237     const T3& f3, const T4& f4, const T5& f5) {
1238   return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5);
1241 template <GTEST_7_TYPENAMES_(T)>
1242 inline GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1243     const T3& f3, const T4& f4, const T5& f5, const T6& f6) {
1244   return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6);
1247 template <GTEST_8_TYPENAMES_(T)>
1248 inline GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1249     const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7) {
1250   return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7);
1253 template <GTEST_9_TYPENAMES_(T)>
1254 inline GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1255     const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
1256     const T8& f8) {
1257   return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8);
1260 template <GTEST_10_TYPENAMES_(T)>
1261 inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
1262     const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
1263     const T8& f8, const T9& f9) {
1264   return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9);
1267 // 6.1.3.3 Tuple helper classes.
1269 template <typename Tuple> struct tuple_size;
1271 template <GTEST_0_TYPENAMES_(T)>
1272 struct tuple_size<GTEST_0_TUPLE_(T)> { static const int value = 0; };
1274 template <GTEST_1_TYPENAMES_(T)>
1275 struct tuple_size<GTEST_1_TUPLE_(T)> { static const int value = 1; };
1277 template <GTEST_2_TYPENAMES_(T)>
1278 struct tuple_size<GTEST_2_TUPLE_(T)> { static const int value = 2; };
1280 template <GTEST_3_TYPENAMES_(T)>
1281 struct tuple_size<GTEST_3_TUPLE_(T)> { static const int value = 3; };
1283 template <GTEST_4_TYPENAMES_(T)>
1284 struct tuple_size<GTEST_4_TUPLE_(T)> { static const int value = 4; };
1286 template <GTEST_5_TYPENAMES_(T)>
1287 struct tuple_size<GTEST_5_TUPLE_(T)> { static const int value = 5; };
1289 template <GTEST_6_TYPENAMES_(T)>
1290 struct tuple_size<GTEST_6_TUPLE_(T)> { static const int value = 6; };
1292 template <GTEST_7_TYPENAMES_(T)>
1293 struct tuple_size<GTEST_7_TUPLE_(T)> { static const int value = 7; };
1295 template <GTEST_8_TYPENAMES_(T)>
1296 struct tuple_size<GTEST_8_TUPLE_(T)> { static const int value = 8; };
1298 template <GTEST_9_TYPENAMES_(T)>
1299 struct tuple_size<GTEST_9_TUPLE_(T)> { static const int value = 9; };
1301 template <GTEST_10_TYPENAMES_(T)>
1302 struct tuple_size<GTEST_10_TUPLE_(T)> { static const int value = 10; };
1304 template <int k, class Tuple>
1305 struct tuple_element {
1306   typedef typename gtest_internal::TupleElement<
1307       k < (tuple_size<Tuple>::value), k, Tuple>::type type;
1308 };
1310 #define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type
1312 // 6.1.3.4 Element access.
1314 namespace gtest_internal {
1316 template <>
1317 class Get<0> {
1318  public:
1319   template <class Tuple>
1320   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
1321   Field(Tuple& t) { return t.f0_; }  // NOLINT
1323   template <class Tuple>
1324   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
1325   ConstField(const Tuple& t) { return t.f0_; }
1326 };
1328 template <>
1329 class Get<1> {
1330  public:
1331   template <class Tuple>
1332   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
1333   Field(Tuple& t) { return t.f1_; }  // NOLINT
1335   template <class Tuple>
1336   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
1337   ConstField(const Tuple& t) { return t.f1_; }
1338 };
1340 template <>
1341 class Get<2> {
1342  public:
1343   template <class Tuple>
1344   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
1345   Field(Tuple& t) { return t.f2_; }  // NOLINT
1347   template <class Tuple>
1348   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
1349   ConstField(const Tuple& t) { return t.f2_; }
1350 };
1352 template <>
1353 class Get<3> {
1354  public:
1355   template <class Tuple>
1356   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
1357   Field(Tuple& t) { return t.f3_; }  // NOLINT
1359   template <class Tuple>
1360   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
1361   ConstField(const Tuple& t) { return t.f3_; }
1362 };
1364 template <>
1365 class Get<4> {
1366  public:
1367   template <class Tuple>
1368   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
1369   Field(Tuple& t) { return t.f4_; }  // NOLINT
1371   template <class Tuple>
1372   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
1373   ConstField(const Tuple& t) { return t.f4_; }
1374 };
1376 template <>
1377 class Get<5> {
1378  public:
1379   template <class Tuple>
1380   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
1381   Field(Tuple& t) { return t.f5_; }  // NOLINT
1383   template <class Tuple>
1384   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
1385   ConstField(const Tuple& t) { return t.f5_; }
1386 };
1388 template <>
1389 class Get<6> {
1390  public:
1391   template <class Tuple>
1392   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
1393   Field(Tuple& t) { return t.f6_; }  // NOLINT
1395   template <class Tuple>
1396   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
1397   ConstField(const Tuple& t) { return t.f6_; }
1398 };
1400 template <>
1401 class Get<7> {
1402  public:
1403   template <class Tuple>
1404   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
1405   Field(Tuple& t) { return t.f7_; }  // NOLINT
1407   template <class Tuple>
1408   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
1409   ConstField(const Tuple& t) { return t.f7_; }
1410 };
1412 template <>
1413 class Get<8> {
1414  public:
1415   template <class Tuple>
1416   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
1417   Field(Tuple& t) { return t.f8_; }  // NOLINT
1419   template <class Tuple>
1420   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
1421   ConstField(const Tuple& t) { return t.f8_; }
1422 };
1424 template <>
1425 class Get<9> {
1426  public:
1427   template <class Tuple>
1428   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
1429   Field(Tuple& t) { return t.f9_; }  // NOLINT
1431   template <class Tuple>
1432   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
1433   ConstField(const Tuple& t) { return t.f9_; }
1434 };
1436 }  // namespace gtest_internal
1438 template <int k, GTEST_10_TYPENAMES_(T)>
1439 GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T)))
1440 get(GTEST_10_TUPLE_(T)& t) {
1441   return gtest_internal::Get<k>::Field(t);
1444 template <int k, GTEST_10_TYPENAMES_(T)>
1445 GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k,  GTEST_10_TUPLE_(T)))
1446 get(const GTEST_10_TUPLE_(T)& t) {
1447   return gtest_internal::Get<k>::ConstField(t);
1450 // 6.1.3.5 Relational operators
1452 // We only implement == and !=, as we don't have a need for the rest yet.
1454 namespace gtest_internal {
1456 // SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the
1457 // first k fields of t1 equals the first k fields of t2.
1458 // SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if
1459 // k1 != k2.
1460 template <int kSize1, int kSize2>
1461 struct SameSizeTuplePrefixComparator;
1463 template <>
1464 struct SameSizeTuplePrefixComparator<0, 0> {
1465   template <class Tuple1, class Tuple2>
1466   static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) {
1467     return true;
1468   }
1469 };
1471 template <int k>
1472 struct SameSizeTuplePrefixComparator<k, k> {
1473   template <class Tuple1, class Tuple2>
1474   static bool Eq(const Tuple1& t1, const Tuple2& t2) {
1475     return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) &&
1476         ::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2);
1477   }
1478 };
1480 }  // namespace gtest_internal
1482 template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
1483 inline bool operator==(const GTEST_10_TUPLE_(T)& t,
1484                        const GTEST_10_TUPLE_(U)& u) {
1485   return gtest_internal::SameSizeTuplePrefixComparator<
1486       tuple_size<GTEST_10_TUPLE_(T)>::value,
1487       tuple_size<GTEST_10_TUPLE_(U)>::value>::Eq(t, u);
1490 template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
1491 inline bool operator!=(const GTEST_10_TUPLE_(T)& t,
1492                        const GTEST_10_TUPLE_(U)& u) { return !(t == u); }
1494 // 6.1.4 Pairs.
1495 // Unimplemented.
1497 }  // namespace tr1
1498 }  // namespace std
1500 #undef GTEST_0_TUPLE_
1501 #undef GTEST_1_TUPLE_
1502 #undef GTEST_2_TUPLE_
1503 #undef GTEST_3_TUPLE_
1504 #undef GTEST_4_TUPLE_
1505 #undef GTEST_5_TUPLE_
1506 #undef GTEST_6_TUPLE_
1507 #undef GTEST_7_TUPLE_
1508 #undef GTEST_8_TUPLE_
1509 #undef GTEST_9_TUPLE_
1510 #undef GTEST_10_TUPLE_
1512 #undef GTEST_0_TYPENAMES_
1513 #undef GTEST_1_TYPENAMES_
1514 #undef GTEST_2_TYPENAMES_
1515 #undef GTEST_3_TYPENAMES_
1516 #undef GTEST_4_TYPENAMES_
1517 #undef GTEST_5_TYPENAMES_
1518 #undef GTEST_6_TYPENAMES_
1519 #undef GTEST_7_TYPENAMES_
1520 #undef GTEST_8_TYPENAMES_
1521 #undef GTEST_9_TYPENAMES_
1522 #undef GTEST_10_TYPENAMES_
1524 #undef GTEST_DECLARE_TUPLE_AS_FRIEND_
1525 #undef GTEST_BY_REF_
1526 #undef GTEST_ADD_REF_
1527 #undef GTEST_TUPLE_ELEMENT_
1529 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
1530 # elif GTEST_OS_SYMBIAN
1532 // On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to
1533 // use STLport's tuple implementation, which unfortunately doesn't
1534 // work as the copy of STLport distributed with Symbian is incomplete.
1535 // By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to
1536 // use its own tuple implementation.
1537 #  ifdef BOOST_HAS_TR1_TUPLE
1538 #   undef BOOST_HAS_TR1_TUPLE
1539 #  endif  // BOOST_HAS_TR1_TUPLE
1541 // This prevents <boost/tr1/detail/config.hpp>, which defines
1542 // BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>.
1543 #  define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED
1544 #  include <tuple>
1546 # elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
1547 // GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header.  This does
1548 // not conform to the TR1 spec, which requires the header to be <tuple>.
1550 #  if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
1551 // Until version 4.3.2, gcc has a bug that causes <tr1/functional>,
1552 // which is #included by <tr1/tuple>, to not compile when RTTI is
1553 // disabled.  _TR1_FUNCTIONAL is the header guard for
1554 // <tr1/functional>.  Hence the following #define is a hack to prevent
1555 // <tr1/functional> from being included.
1556 #   define _TR1_FUNCTIONAL 1
1557 #   include <tr1/tuple>
1558 #   undef _TR1_FUNCTIONAL  // Allows the user to #include
1559                         // <tr1/functional> if he chooses to.
1560 #  else
1561 #   include <tr1/tuple>  // NOLINT
1562 #  endif  // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
1564 # else
1565 // If the compiler is not GCC 4.0+, we assume the user is using a
1566 // spec-conforming TR1 implementation.
1567 #  include <tuple>  // NOLINT
1568 # endif  // GTEST_USE_OWN_TR1_TUPLE
1570 #endif  // GTEST_HAS_TR1_TUPLE
1572 // Determines whether clone(2) is supported.
1573 // Usually it will only be available on Linux, excluding
1574 // Linux on the Itanium architecture.
1575 // Also see http://linux.die.net/man/2/clone.
1576 #ifndef GTEST_HAS_CLONE
1577 // The user didn't tell us, so we need to figure it out.
1579 # if GTEST_OS_LINUX && !defined(__ia64__)
1580 #  define GTEST_HAS_CLONE 1
1581 # else
1582 #  define GTEST_HAS_CLONE 0
1583 # endif  // GTEST_OS_LINUX && !defined(__ia64__)
1585 #endif  // GTEST_HAS_CLONE
1587 // Determines whether to support stream redirection. This is used to test
1588 // output correctness and to implement death tests.
1589 #ifndef GTEST_HAS_STREAM_REDIRECTION
1590 // By default, we assume that stream redirection is supported on all
1591 // platforms except known mobile ones.
1592 # if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN
1593 #  define GTEST_HAS_STREAM_REDIRECTION 0
1594 # else
1595 #  define GTEST_HAS_STREAM_REDIRECTION 1
1596 # endif  // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN
1597 #endif  // GTEST_HAS_STREAM_REDIRECTION
1599 // Determines whether to support death tests.
1600 // Google Test does not support death tests for VC 7.1 and earlier as
1601 // abort() in a VC 7.1 application compiled as GUI in debug config
1602 // pops up a dialog window that cannot be suppressed programmatically.
1603 #if (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
1604      (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \
1605      GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX)
1606 # define GTEST_HAS_DEATH_TEST 1
1607 # include <vector>  // NOLINT
1608 #endif
1610 // We don't support MSVC 7.1 with exceptions disabled now.  Therefore
1611 // all the compilers we care about are adequate for supporting
1612 // value-parameterized tests.
1613 #define GTEST_HAS_PARAM_TEST 1
1615 // Determines whether to support type-driven tests.
1617 // Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0,
1618 // Sun Pro CC, IBM Visual Age, and HP aCC support.
1619 #if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \
1620     defined(__IBMCPP__) || defined(__HP_aCC)
1621 # define GTEST_HAS_TYPED_TEST 1
1622 # define GTEST_HAS_TYPED_TEST_P 1
1623 #endif
1625 // Determines whether to support Combine(). This only makes sense when
1626 // value-parameterized tests are enabled.  The implementation doesn't
1627 // work on Sun Studio since it doesn't understand templated conversion
1628 // operators.
1629 #if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC)
1630 # define GTEST_HAS_COMBINE 1
1631 #endif
1633 // Determines whether the system compiler uses UTF-16 for encoding wide strings.
1634 #define GTEST_WIDE_STRING_USES_UTF16_ \
1635     (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX)
1637 // Determines whether test results can be streamed to a socket.
1638 #if GTEST_OS_LINUX
1639 # define GTEST_CAN_STREAM_RESULTS_ 1
1640 #endif
1642 // Defines some utility macros.
1644 // The GNU compiler emits a warning if nested "if" statements are followed by
1645 // an "else" statement and braces are not used to explicitly disambiguate the
1646 // "else" binding.  This leads to problems with code like:
1647 //
1648 //   if (gate)
1649 //     ASSERT_*(condition) << "Some message";
1650 //
1651 // The "switch (0) case 0:" idiom is used to suppress this.
1652 #ifdef __INTEL_COMPILER
1653 # define GTEST_AMBIGUOUS_ELSE_BLOCKER_
1654 #else
1655 # define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:  // NOLINT
1656 #endif
1658 // Use this annotation at the end of a struct/class definition to
1659 // prevent the compiler from optimizing away instances that are never
1660 // used.  This is useful when all interesting logic happens inside the
1661 // c'tor and / or d'tor.  Example:
1662 //
1663 //   struct Foo {
1664 //     Foo() { ... }
1665 //   } GTEST_ATTRIBUTE_UNUSED_;
1666 //
1667 // Also use it after a variable or parameter declaration to tell the
1668 // compiler the variable/parameter does not have to be used.
1669 #if defined(__GNUC__) && !defined(COMPILER_ICC)
1670 # define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
1671 #else
1672 # define GTEST_ATTRIBUTE_UNUSED_
1673 #endif
1675 // A macro to disallow operator=
1676 // This should be used in the private: declarations for a class.
1677 #define GTEST_DISALLOW_ASSIGN_(type)\
1678   void operator=(type const &)
1680 // A macro to disallow copy constructor and operator=
1681 // This should be used in the private: declarations for a class.
1682 #define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\
1683   type(type const &);\
1684   GTEST_DISALLOW_ASSIGN_(type)
1686 // Tell the compiler to warn about unused return values for functions declared
1687 // with this macro.  The macro should be used on function declarations
1688 // following the argument list:
1689 //
1690 //   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
1691 #if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)
1692 # define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
1693 #else
1694 # define GTEST_MUST_USE_RESULT_
1695 #endif  // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC
1697 // Determine whether the compiler supports Microsoft's Structured Exception
1698 // Handling.  This is supported by several Windows compilers but generally
1699 // does not exist on any other system.
1700 #ifndef GTEST_HAS_SEH
1701 // The user didn't tell us, so we need to figure it out.
1703 # if defined(_MSC_VER) || defined(__BORLANDC__)
1704 // These two compilers are known to support SEH.
1705 #  define GTEST_HAS_SEH 1
1706 # else
1707 // Assume no SEH.
1708 #  define GTEST_HAS_SEH 0
1709 # endif
1711 #endif  // GTEST_HAS_SEH
1713 #ifdef _MSC_VER
1715 # if GTEST_LINKED_AS_SHARED_LIBRARY
1716 #  define GTEST_API_ __declspec(dllimport)
1717 # elif GTEST_CREATE_SHARED_LIBRARY
1718 #  define GTEST_API_ __declspec(dllexport)
1719 # endif
1721 #endif  // _MSC_VER
1723 #ifndef GTEST_API_
1724 # define GTEST_API_
1725 #endif
1727 #ifdef __GNUC__
1728 // Ask the compiler to never inline a given function.
1729 # define GTEST_NO_INLINE_ __attribute__((noinline))
1730 #else
1731 # define GTEST_NO_INLINE_
1732 #endif
1734 namespace testing {
1736 class Message;
1738 namespace internal {
1740 class String;
1742 // The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time
1743 // expression is true. For example, you could use it to verify the
1744 // size of a static array:
1745 //
1746 //   GTEST_COMPILE_ASSERT_(ARRAYSIZE(content_type_names) == CONTENT_NUM_TYPES,
1747 //                         content_type_names_incorrect_size);
1748 //
1749 // or to make sure a struct is smaller than a certain size:
1750 //
1751 //   GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large);
1752 //
1753 // The second argument to the macro is the name of the variable. If
1754 // the expression is false, most compilers will issue a warning/error
1755 // containing the name of the variable.
1757 template <bool>
1758 struct CompileAssert {
1759 };
1761 #define GTEST_COMPILE_ASSERT_(expr, msg) \
1762   typedef ::testing::internal::CompileAssert<(bool(expr))> \
1763       msg[bool(expr) ? 1 : -1]
1765 // Implementation details of GTEST_COMPILE_ASSERT_:
1766 //
1767 // - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1
1768 //   elements (and thus is invalid) when the expression is false.
1769 //
1770 // - The simpler definition
1771 //
1772 //    #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1]
1773 //
1774 //   does not work, as gcc supports variable-length arrays whose sizes
1775 //   are determined at run-time (this is gcc's extension and not part
1776 //   of the C++ standard).  As a result, gcc fails to reject the
1777 //   following code with the simple definition:
1778 //
1779 //     int foo;
1780 //     GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is
1781 //                                      // not a compile-time constant.
1782 //
1783 // - By using the type CompileAssert<(bool(expr))>, we ensures that
1784 //   expr is a compile-time constant.  (Template arguments must be
1785 //   determined at compile-time.)
1786 //
1787 // - The outter parentheses in CompileAssert<(bool(expr))> are necessary
1788 //   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
1789 //
1790 //     CompileAssert<bool(expr)>
1791 //
1792 //   instead, these compilers will refuse to compile
1793 //
1794 //     GTEST_COMPILE_ASSERT_(5 > 0, some_message);
1795 //
1796 //   (They seem to think the ">" in "5 > 0" marks the end of the
1797 //   template argument list.)
1798 //
1799 // - The array size is (bool(expr) ? 1 : -1), instead of simply
1800 //
1801 //     ((expr) ? 1 : -1).
1802 //
1803 //   This is to avoid running into a bug in MS VC 7.1, which
1804 //   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
1806 // StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h.
1807 //
1808 // This template is declared, but intentionally undefined.
1809 template <typename T1, typename T2>
1810 struct StaticAssertTypeEqHelper;
1812 template <typename T>
1813 struct StaticAssertTypeEqHelper<T, T> {};
1815 #if GTEST_HAS_GLOBAL_STRING
1816 typedef ::string string;
1817 #else
1818 typedef ::std::string string;
1819 #endif  // GTEST_HAS_GLOBAL_STRING
1821 #if GTEST_HAS_GLOBAL_WSTRING
1822 typedef ::wstring wstring;
1823 #elif GTEST_HAS_STD_WSTRING
1824 typedef ::std::wstring wstring;
1825 #endif  // GTEST_HAS_GLOBAL_WSTRING
1827 // A helper for suppressing warnings on constant condition.  It just
1828 // returns 'condition'.
1829 GTEST_API_ bool IsTrue(bool condition);
1831 // Defines scoped_ptr.
1833 // This implementation of scoped_ptr is PARTIAL - it only contains
1834 // enough stuff to satisfy Google Test's need.
1835 template <typename T>
1836 class scoped_ptr {
1837  public:
1838   typedef T element_type;
1840   explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
1841   ~scoped_ptr() { reset(); }
1843   T& operator*() const { return *ptr_; }
1844   T* operator->() const { return ptr_; }
1845   T* get() const { return ptr_; }
1847   T* release() {
1848     T* const ptr = ptr_;
1849     ptr_ = NULL;
1850     return ptr;
1851   }
1853   void reset(T* p = NULL) {
1854     if (p != ptr_) {
1855       if (IsTrue(sizeof(T) > 0)) {  // Makes sure T is a complete type.
1856         delete ptr_;
1857       }
1858       ptr_ = p;
1859     }
1860   }
1861  private:
1862   T* ptr_;
1864   GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
1865 };
1867 // Defines RE.
1869 // A simple C++ wrapper for <regex.h>.  It uses the POSIX Extended
1870 // Regular Expression syntax.
1871 class GTEST_API_ RE {
1872  public:
1873   // A copy constructor is required by the Standard to initialize object
1874   // references from r-values.
1875   RE(const RE& other) { Init(other.pattern()); }
1877   // Constructs an RE from a string.
1878   RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT
1880 #if GTEST_HAS_GLOBAL_STRING
1882   RE(const ::string& regex) { Init(regex.c_str()); }  // NOLINT
1884 #endif  // GTEST_HAS_GLOBAL_STRING
1886   RE(const char* regex) { Init(regex); }  // NOLINT
1887   ~RE();
1889   // Returns the string representation of the regex.
1890   const char* pattern() const { return pattern_; }
1892   // FullMatch(str, re) returns true iff regular expression re matches
1893   // the entire str.
1894   // PartialMatch(str, re) returns true iff regular expression re
1895   // matches a substring of str (including str itself).
1896   //
1897   // TODO(wan@google.com): make FullMatch() and PartialMatch() work
1898   // when str contains NUL characters.
1899   static bool FullMatch(const ::std::string& str, const RE& re) {
1900     return FullMatch(str.c_str(), re);
1901   }
1902   static bool PartialMatch(const ::std::string& str, const RE& re) {
1903     return PartialMatch(str.c_str(), re);
1904   }
1906 #if GTEST_HAS_GLOBAL_STRING
1908   static bool FullMatch(const ::string& str, const RE& re) {
1909     return FullMatch(str.c_str(), re);
1910   }
1911   static bool PartialMatch(const ::string& str, const RE& re) {
1912     return PartialMatch(str.c_str(), re);
1913   }
1915 #endif  // GTEST_HAS_GLOBAL_STRING
1917   static bool FullMatch(const char* str, const RE& re);
1918   static bool PartialMatch(const char* str, const RE& re);
1920  private:
1921   void Init(const char* regex);
1923   // We use a const char* instead of a string, as Google Test may be used
1924   // where string is not available.  We also do not use Google Test's own
1925   // String type here, in order to simplify dependencies between the
1926   // files.
1927   const char* pattern_;
1928   bool is_valid_;
1930 #if GTEST_USES_POSIX_RE
1932   regex_t full_regex_;     // For FullMatch().
1933   regex_t partial_regex_;  // For PartialMatch().
1935 #else  // GTEST_USES_SIMPLE_RE
1937   const char* full_pattern_;  // For FullMatch();
1939 #endif
1941   GTEST_DISALLOW_ASSIGN_(RE);
1942 };
1944 // Formats a source file path and a line number as they would appear
1945 // in an error message from the compiler used to compile this code.
1946 GTEST_API_ ::std::string FormatFileLocation(const char* file, int line);
1948 // Formats a file location for compiler-independent XML output.
1949 // Although this function is not platform dependent, we put it next to
1950 // FormatFileLocation in order to contrast the two functions.
1951 GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
1952                                                                int line);
1954 // Defines logging utilities:
1955 //   GTEST_LOG_(severity) - logs messages at the specified severity level. The
1956 //                          message itself is streamed into the macro.
1957 //   LogToStderr()  - directs all log messages to stderr.
1958 //   FlushInfoLog() - flushes informational log messages.
1960 enum GTestLogSeverity {
1961   GTEST_INFO,
1962   GTEST_WARNING,
1963   GTEST_ERROR,
1964   GTEST_FATAL
1965 };
1967 // Formats log entry severity, provides a stream object for streaming the
1968 // log message, and terminates the message with a newline when going out of
1969 // scope.
1970 class GTEST_API_ GTestLog {
1971  public:
1972   GTestLog(GTestLogSeverity severity, const char* file, int line);
1974   // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
1975   ~GTestLog();
1977   ::std::ostream& GetStream() { return ::std::cerr; }
1979  private:
1980   const GTestLogSeverity severity_;
1982   GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
1983 };
1985 #define GTEST_LOG_(severity) \
1986     ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
1987                                   __FILE__, __LINE__).GetStream()
1989 inline void LogToStderr() {}
1990 inline void FlushInfoLog() { fflush(NULL); }
1992 // INTERNAL IMPLEMENTATION - DO NOT USE.
1993 //
1994 // GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
1995 // is not satisfied.
1996 //  Synopsys:
1997 //    GTEST_CHECK_(boolean_condition);
1998 //     or
1999 //    GTEST_CHECK_(boolean_condition) << "Additional message";
2000 //
2001 //    This checks the condition and if the condition is not satisfied
2002 //    it prints message about the condition violation, including the
2003 //    condition itself, plus additional message streamed into it, if any,
2004 //    and then it aborts the program. It aborts the program irrespective of
2005 //    whether it is built in the debug mode or not.
2006 #define GTEST_CHECK_(condition) \
2007     GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
2008     if (::testing::internal::IsTrue(condition)) \
2009       ; \
2010     else \
2011       GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
2013 // An all-mode assert to verify that the given POSIX-style function
2014 // call returns 0 (indicating success).  Known limitation: this
2015 // doesn't expand to a balanced 'if' statement, so enclose the macro
2016 // in {} if you need to use it as the only statement in an 'if'
2017 // branch.
2018 #define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
2019   if (const int gtest_error = (posix_call)) \
2020     GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
2021                       << gtest_error
2023 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
2024 //
2025 // Use ImplicitCast_ as a safe version of static_cast for upcasting in
2026 // the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a
2027 // const Foo*).  When you use ImplicitCast_, the compiler checks that
2028 // the cast is safe.  Such explicit ImplicitCast_s are necessary in
2029 // surprisingly many situations where C++ demands an exact type match
2030 // instead of an argument type convertable to a target type.
2031 //
2032 // The syntax for using ImplicitCast_ is the same as for static_cast:
2033 //
2034 //   ImplicitCast_<ToType>(expr)
2035 //
2036 // ImplicitCast_ would have been part of the C++ standard library,
2037 // but the proposal was submitted too late.  It will probably make
2038 // its way into the language in the future.
2039 //
2040 // This relatively ugly name is intentional. It prevents clashes with
2041 // similar functions users may have (e.g., implicit_cast). The internal
2042 // namespace alone is not enough because the function can be found by ADL.
2043 template<typename To>
2044 inline To ImplicitCast_(To x) { return x; }
2046 // When you upcast (that is, cast a pointer from type Foo to type
2047 // SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts
2048 // always succeed.  When you downcast (that is, cast a pointer from
2049 // type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
2050 // how do you know the pointer is really of type SubclassOfFoo?  It
2051 // could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
2052 // when you downcast, you should use this macro.  In debug mode, we
2053 // use dynamic_cast<> to double-check the downcast is legal (we die
2054 // if it's not).  In normal mode, we do the efficient static_cast<>
2055 // instead.  Thus, it's important to test in debug mode to make sure
2056 // the cast is legal!
2057 //    This is the only place in the code we should use dynamic_cast<>.
2058 // In particular, you SHOULDN'T be using dynamic_cast<> in order to
2059 // do RTTI (eg code like this:
2060 //    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
2061 //    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
2062 // You should design the code some other way not to need this.
2063 //
2064 // This relatively ugly name is intentional. It prevents clashes with
2065 // similar functions users may have (e.g., down_cast). The internal
2066 // namespace alone is not enough because the function can be found by ADL.
2067 template<typename To, typename From>  // use like this: DownCast_<T*>(foo);
2068 inline To DownCast_(From* f) {  // so we only accept pointers
2069   // Ensures that To is a sub-type of From *.  This test is here only
2070   // for compile-time type checking, and has no overhead in an
2071   // optimized build at run-time, as it will be optimized away
2072   // completely.
2073   if (false) {
2074     const To to = NULL;
2075     ::testing::internal::ImplicitCast_<From*>(to);
2076   }
2078 #if GTEST_HAS_RTTI
2079   // RTTI: debug mode only!
2080   GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL);
2081 #endif
2082   return static_cast<To>(f);
2085 // Downcasts the pointer of type Base to Derived.
2086 // Derived must be a subclass of Base. The parameter MUST
2087 // point to a class of type Derived, not any subclass of it.
2088 // When RTTI is available, the function performs a runtime
2089 // check to enforce this.
2090 template <class Derived, class Base>
2091 Derived* CheckedDowncastToActualType(Base* base) {
2092 #if GTEST_HAS_RTTI
2093   GTEST_CHECK_(typeid(*base) == typeid(Derived));
2094   return dynamic_cast<Derived*>(base);  // NOLINT
2095 #else
2096   return static_cast<Derived*>(base);  // Poor man's downcast.
2097 #endif
2100 #if GTEST_HAS_STREAM_REDIRECTION
2102 // Defines the stderr capturer:
2103 //   CaptureStdout     - starts capturing stdout.
2104 //   GetCapturedStdout - stops capturing stdout and returns the captured string.
2105 //   CaptureStderr     - starts capturing stderr.
2106 //   GetCapturedStderr - stops capturing stderr and returns the captured string.
2107 //
2108 GTEST_API_ void CaptureStdout();
2109 GTEST_API_ String GetCapturedStdout();
2110 GTEST_API_ void CaptureStderr();
2111 GTEST_API_ String GetCapturedStderr();
2113 #endif  // GTEST_HAS_STREAM_REDIRECTION
2116 #if GTEST_HAS_DEATH_TEST
2118 // A copy of all command line arguments.  Set by InitGoogleTest().
2119 extern ::std::vector<String> g_argvs;
2121 // GTEST_HAS_DEATH_TEST implies we have ::std::string.
2122 const ::std::vector<String>& GetArgvs();
2124 #endif  // GTEST_HAS_DEATH_TEST
2126 // Defines synchronization primitives.
2128 #if GTEST_HAS_PTHREAD
2130 // Sleeps for (roughly) n milli-seconds.  This function is only for
2131 // testing Google Test's own constructs.  Don't use it in user tests,
2132 // either directly or indirectly.
2133 inline void SleepMilliseconds(int n) {
2134   const timespec time = {
2135     0,                  // 0 seconds.
2136     n * 1000L * 1000L,  // And n ms.
2137   };
2138   nanosleep(&time, NULL);
2141 // Allows a controller thread to pause execution of newly created
2142 // threads until notified.  Instances of this class must be created
2143 // and destroyed in the controller thread.
2144 //
2145 // This class is only for testing Google Test's own constructs. Do not
2146 // use it in user tests, either directly or indirectly.
2147 class Notification {
2148  public:
2149   Notification() : notified_(false) {}
2151   // Notifies all threads created with this notification to start. Must
2152   // be called from the controller thread.
2153   void Notify() { notified_ = true; }
2155   // Blocks until the controller thread notifies. Must be called from a test
2156   // thread.
2157   void WaitForNotification() {
2158     while(!notified_) {
2159       SleepMilliseconds(10);
2160     }
2161   }
2163  private:
2164   volatile bool notified_;
2166   GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
2167 };
2169 // As a C-function, ThreadFuncWithCLinkage cannot be templated itself.
2170 // Consequently, it cannot select a correct instantiation of ThreadWithParam
2171 // in order to call its Run(). Introducing ThreadWithParamBase as a
2172 // non-templated base class for ThreadWithParam allows us to bypass this
2173 // problem.
2174 class ThreadWithParamBase {
2175  public:
2176   virtual ~ThreadWithParamBase() {}
2177   virtual void Run() = 0;
2178 };
2180 // pthread_create() accepts a pointer to a function type with the C linkage.
2181 // According to the Standard (7.5/1), function types with different linkages
2182 // are different even if they are otherwise identical.  Some compilers (for
2183 // example, SunStudio) treat them as different types.  Since class methods
2184 // cannot be defined with C-linkage we need to define a free C-function to
2185 // pass into pthread_create().
2186 extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
2187   static_cast<ThreadWithParamBase*>(thread)->Run();
2188   return NULL;
2191 // Helper class for testing Google Test's multi-threading constructs.
2192 // To use it, write:
2193 //
2194 //   void ThreadFunc(int param) { /* Do things with param */ }
2195 //   Notification thread_can_start;
2196 //   ...
2197 //   // The thread_can_start parameter is optional; you can supply NULL.
2198 //   ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start);
2199 //   thread_can_start.Notify();
2200 //
2201 // These classes are only for testing Google Test's own constructs. Do
2202 // not use them in user tests, either directly or indirectly.
2203 template <typename T>
2204 class ThreadWithParam : public ThreadWithParamBase {
2205  public:
2206   typedef void (*UserThreadFunc)(T);
2208   ThreadWithParam(
2209       UserThreadFunc func, T param, Notification* thread_can_start)
2210       : func_(func),
2211         param_(param),
2212         thread_can_start_(thread_can_start),
2213         finished_(false) {
2214     ThreadWithParamBase* const base = this;
2215     // The thread can be created only after all fields except thread_
2216     // have been initialized.
2217     GTEST_CHECK_POSIX_SUCCESS_(
2218         pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base));
2219   }
2220   ~ThreadWithParam() { Join(); }
2222   void Join() {
2223     if (!finished_) {
2224       GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0));
2225       finished_ = true;
2226     }
2227   }
2229   virtual void Run() {
2230     if (thread_can_start_ != NULL)
2231       thread_can_start_->WaitForNotification();
2232     func_(param_);
2233   }
2235  private:
2236   const UserThreadFunc func_;  // User-supplied thread function.
2237   const T param_;  // User-supplied parameter to the thread function.
2238   // When non-NULL, used to block execution until the controller thread
2239   // notifies.
2240   Notification* const thread_can_start_;
2241   bool finished_;  // true iff we know that the thread function has finished.
2242   pthread_t thread_;  // The native thread object.
2244   GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
2245 };
2247 // MutexBase and Mutex implement mutex on pthreads-based platforms. They
2248 // are used in conjunction with class MutexLock:
2249 //
2250 //   Mutex mutex;
2251 //   ...
2252 //   MutexLock lock(&mutex);  // Acquires the mutex and releases it at the end
2253 //                            // of the current scope.
2254 //
2255 // MutexBase implements behavior for both statically and dynamically
2256 // allocated mutexes.  Do not use MutexBase directly.  Instead, write
2257 // the following to define a static mutex:
2258 //
2259 //   GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);
2260 //
2261 // You can forward declare a static mutex like this:
2262 //
2263 //   GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);
2264 //
2265 // To create a dynamic mutex, just define an object of type Mutex.
2266 class MutexBase {
2267  public:
2268   // Acquires this mutex.
2269   void Lock() {
2270     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
2271     owner_ = pthread_self();
2272   }
2274   // Releases this mutex.
2275   void Unlock() {
2276     // We don't protect writing to owner_ here, as it's the caller's
2277     // responsibility to ensure that the current thread holds the
2278     // mutex when this is called.
2279     owner_ = 0;
2280     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
2281   }
2283   // Does nothing if the current thread holds the mutex. Otherwise, crashes
2284   // with high probability.
2285   void AssertHeld() const {
2286     GTEST_CHECK_(owner_ == pthread_self())
2287         << "The current thread is not holding the mutex @" << this;
2288   }
2290   // A static mutex may be used before main() is entered.  It may even
2291   // be used before the dynamic initialization stage.  Therefore we
2292   // must be able to initialize a static mutex object at link time.
2293   // This means MutexBase has to be a POD and its member variables
2294   // have to be public.
2295  public:
2296   pthread_mutex_t mutex_;  // The underlying pthread mutex.
2297   pthread_t owner_;  // The thread holding the mutex; 0 means no one holds it.
2298 };
2300 // Forward-declares a static mutex.
2301 # define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
2302     extern ::testing::internal::MutexBase mutex
2304 // Defines and statically (i.e. at link time) initializes a static mutex.
2305 # define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
2306     ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, 0 }
2308 // The Mutex class can only be used for mutexes created at runtime. It
2309 // shares its API with MutexBase otherwise.
2310 class Mutex : public MutexBase {
2311  public:
2312   Mutex() {
2313     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
2314     owner_ = 0;
2315   }
2316   ~Mutex() {
2317     GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
2318   }
2320  private:
2321   GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
2322 };
2324 // We cannot name this class MutexLock as the ctor declaration would
2325 // conflict with a macro named MutexLock, which is defined on some
2326 // platforms.  Hence the typedef trick below.
2327 class GTestMutexLock {
2328  public:
2329   explicit GTestMutexLock(MutexBase* mutex)
2330       : mutex_(mutex) { mutex_->Lock(); }
2332   ~GTestMutexLock() { mutex_->Unlock(); }
2334  private:
2335   MutexBase* const mutex_;
2337   GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
2338 };
2340 typedef GTestMutexLock MutexLock;
2342 // Helpers for ThreadLocal.
2344 // pthread_key_create() requires DeleteThreadLocalValue() to have
2345 // C-linkage.  Therefore it cannot be templatized to access
2346 // ThreadLocal<T>.  Hence the need for class
2347 // ThreadLocalValueHolderBase.
2348 class ThreadLocalValueHolderBase {
2349  public:
2350   virtual ~ThreadLocalValueHolderBase() {}
2351 };
2353 // Called by pthread to delete thread-local data stored by
2354 // pthread_setspecific().
2355 extern "C" inline void DeleteThreadLocalValue(void* value_holder) {
2356   delete static_cast<ThreadLocalValueHolderBase*>(value_holder);
2359 // Implements thread-local storage on pthreads-based systems.
2360 //
2361 //   // Thread 1
2362 //   ThreadLocal<int> tl(100);  // 100 is the default value for each thread.
2363 //
2364 //   // Thread 2
2365 //   tl.set(150);  // Changes the value for thread 2 only.
2366 //   EXPECT_EQ(150, tl.get());
2367 //
2368 //   // Thread 1
2369 //   EXPECT_EQ(100, tl.get());  // In thread 1, tl has the original value.
2370 //   tl.set(200);
2371 //   EXPECT_EQ(200, tl.get());
2372 //
2373 // The template type argument T must have a public copy constructor.
2374 // In addition, the default ThreadLocal constructor requires T to have
2375 // a public default constructor.
2376 //
2377 // An object managed for a thread by a ThreadLocal instance is deleted
2378 // when the thread exits.  Or, if the ThreadLocal instance dies in
2379 // that thread, when the ThreadLocal dies.  It's the user's
2380 // responsibility to ensure that all other threads using a ThreadLocal
2381 // have exited when it dies, or the per-thread objects for those
2382 // threads will not be deleted.
2383 //
2384 // Google Test only uses global ThreadLocal objects.  That means they
2385 // will die after main() has returned.  Therefore, no per-thread
2386 // object managed by Google Test will be leaked as long as all threads
2387 // using Google Test have exited when main() returns.
2388 template <typename T>
2389 class ThreadLocal {
2390  public:
2391   ThreadLocal() : key_(CreateKey()),
2392                   default_() {}
2393   explicit ThreadLocal(const T& value) : key_(CreateKey()),
2394                                          default_(value) {}
2396   ~ThreadLocal() {
2397     // Destroys the managed object for the current thread, if any.
2398     DeleteThreadLocalValue(pthread_getspecific(key_));
2400     // Releases resources associated with the key.  This will *not*
2401     // delete managed objects for other threads.
2402     GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
2403   }
2405   T* pointer() { return GetOrCreateValue(); }
2406   const T* pointer() const { return GetOrCreateValue(); }
2407   const T& get() const { return *pointer(); }
2408   void set(const T& value) { *pointer() = value; }
2410  private:
2411   // Holds a value of type T.
2412   class ValueHolder : public ThreadLocalValueHolderBase {
2413    public:
2414     explicit ValueHolder(const T& value) : value_(value) {}
2416     T* pointer() { return &value_; }
2418    private:
2419     T value_;
2420     GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
2421   };
2423   static pthread_key_t CreateKey() {
2424     pthread_key_t key;
2425     // When a thread exits, DeleteThreadLocalValue() will be called on
2426     // the object managed for that thread.
2427     GTEST_CHECK_POSIX_SUCCESS_(
2428         pthread_key_create(&key, &DeleteThreadLocalValue));
2429     return key;
2430   }
2432   T* GetOrCreateValue() const {
2433     ThreadLocalValueHolderBase* const holder =
2434         static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
2435     if (holder != NULL) {
2436       return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
2437     }
2439     ValueHolder* const new_holder = new ValueHolder(default_);
2440     ThreadLocalValueHolderBase* const holder_base = new_holder;
2441     GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
2442     return new_holder->pointer();
2443   }
2445   // A key pthreads uses for looking up per-thread values.
2446   const pthread_key_t key_;
2447   const T default_;  // The default value for each thread.
2449   GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
2450 };
2452 # define GTEST_IS_THREADSAFE 1
2454 #else  // GTEST_HAS_PTHREAD
2456 // A dummy implementation of synchronization primitives (mutex, lock,
2457 // and thread-local variable).  Necessary for compiling Google Test where
2458 // mutex is not supported - using Google Test in multiple threads is not
2459 // supported on such platforms.
2461 class Mutex {
2462  public:
2463   Mutex() {}
2464   void AssertHeld() const {}
2465 };
2467 # define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
2468   extern ::testing::internal::Mutex mutex
2470 # define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
2472 class GTestMutexLock {
2473  public:
2474   explicit GTestMutexLock(Mutex*) {}  // NOLINT
2475 };
2477 typedef GTestMutexLock MutexLock;
2479 template <typename T>
2480 class ThreadLocal {
2481  public:
2482   ThreadLocal() : value_() {}
2483   explicit ThreadLocal(const T& value) : value_(value) {}
2484   T* pointer() { return &value_; }
2485   const T* pointer() const { return &value_; }
2486   const T& get() const { return value_; }
2487   void set(const T& value) { value_ = value; }
2488  private:
2489   T value_;
2490 };
2492 // The above synchronization primitives have dummy implementations.
2493 // Therefore Google Test is not thread-safe.
2494 # define GTEST_IS_THREADSAFE 0
2496 #endif  // GTEST_HAS_PTHREAD
2498 // Returns the number of threads running in the process, or 0 to indicate that
2499 // we cannot detect it.
2500 GTEST_API_ size_t GetThreadCount();
2502 // Passing non-POD classes through ellipsis (...) crashes the ARM
2503 // compiler and generates a warning in Sun Studio.  The Nokia Symbian
2504 // and the IBM XL C/C++ compiler try to instantiate a copy constructor
2505 // for objects passed through ellipsis (...), failing for uncopyable
2506 // objects.  We define this to ensure that only POD is passed through
2507 // ellipsis on these systems.
2508 #if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC)
2509 // We lose support for NULL detection where the compiler doesn't like
2510 // passing non-POD classes through ellipsis (...).
2511 # define GTEST_ELLIPSIS_NEEDS_POD_ 1
2512 #else
2513 # define GTEST_CAN_COMPARE_NULL 1
2514 #endif
2516 // The Nokia Symbian and IBM XL C/C++ compilers cannot decide between
2517 // const T& and const T* in a function template.  These compilers
2518 // _can_ decide between class template specializations for T and T*,
2519 // so a tr1::type_traits-like is_pointer works.
2520 #if defined(__SYMBIAN32__) || defined(__IBMCPP__)
2521 # define GTEST_NEEDS_IS_POINTER_ 1
2522 #endif
2524 template <bool bool_value>
2525 struct bool_constant {
2526   typedef bool_constant<bool_value> type;
2527   static const bool value = bool_value;
2528 };
2529 template <bool bool_value> const bool bool_constant<bool_value>::value;
2531 typedef bool_constant<false> false_type;
2532 typedef bool_constant<true> true_type;
2534 template <typename T>
2535 struct is_pointer : public false_type {};
2537 template <typename T>
2538 struct is_pointer<T*> : public true_type {};
2540 template <typename Iterator>
2541 struct IteratorTraits {
2542   typedef typename Iterator::value_type value_type;
2543 };
2545 template <typename T>
2546 struct IteratorTraits<T*> {
2547   typedef T value_type;
2548 };
2550 template <typename T>
2551 struct IteratorTraits<const T*> {
2552   typedef T value_type;
2553 };
2555 #if GTEST_OS_WINDOWS
2556 # define GTEST_PATH_SEP_ "\\"
2557 # define GTEST_HAS_ALT_PATH_SEP_ 1
2558 // The biggest signed integer type the compiler supports.
2559 typedef __int64 BiggestInt;
2560 #else
2561 # define GTEST_PATH_SEP_ "/"
2562 # define GTEST_HAS_ALT_PATH_SEP_ 0
2563 typedef long long BiggestInt;  // NOLINT
2564 #endif  // GTEST_OS_WINDOWS
2566 // Utilities for char.
2568 // isspace(int ch) and friends accept an unsigned char or EOF.  char
2569 // may be signed, depending on the compiler (or compiler flags).
2570 // Therefore we need to cast a char to unsigned char before calling
2571 // isspace(), etc.
2573 inline bool IsAlpha(char ch) {
2574   return isalpha(static_cast<unsigned char>(ch)) != 0;
2576 inline bool IsAlNum(char ch) {
2577   return isalnum(static_cast<unsigned char>(ch)) != 0;
2579 inline bool IsDigit(char ch) {
2580   return isdigit(static_cast<unsigned char>(ch)) != 0;
2582 inline bool IsLower(char ch) {
2583   return islower(static_cast<unsigned char>(ch)) != 0;
2585 inline bool IsSpace(char ch) {
2586   return isspace(static_cast<unsigned char>(ch)) != 0;
2588 inline bool IsUpper(char ch) {
2589   return isupper(static_cast<unsigned char>(ch)) != 0;
2591 inline bool IsXDigit(char ch) {
2592   return isxdigit(static_cast<unsigned char>(ch)) != 0;
2595 inline char ToLower(char ch) {
2596   return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
2598 inline char ToUpper(char ch) {
2599   return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
2602 // The testing::internal::posix namespace holds wrappers for common
2603 // POSIX functions.  These wrappers hide the differences between
2604 // Windows/MSVC and POSIX systems.  Since some compilers define these
2605 // standard functions as macros, the wrapper cannot have the same name
2606 // as the wrapped function.
2608 namespace posix {
2610 // Functions with a different name on Windows.
2612 #if GTEST_OS_WINDOWS
2614 typedef struct _stat StatStruct;
2616 # ifdef __BORLANDC__
2617 inline int IsATTY(int fd) { return isatty(fd); }
2618 inline int StrCaseCmp(const char* s1, const char* s2) {
2619   return stricmp(s1, s2);
2621 inline char* StrDup(const char* src) { return strdup(src); }
2622 # else  // !__BORLANDC__
2623 #  if GTEST_OS_WINDOWS_MOBILE
2624 inline int IsATTY(int /* fd */) { return 0; }
2625 #  else
2626 inline int IsATTY(int fd) { return _isatty(fd); }
2627 #  endif  // GTEST_OS_WINDOWS_MOBILE
2628 inline int StrCaseCmp(const char* s1, const char* s2) {
2629   return _stricmp(s1, s2);
2631 inline char* StrDup(const char* src) { return _strdup(src); }
2632 # endif  // __BORLANDC__
2634 # if GTEST_OS_WINDOWS_MOBILE
2635 inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
2636 // Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
2637 // time and thus not defined there.
2638 # else
2639 inline int FileNo(FILE* file) { return _fileno(file); }
2640 inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
2641 inline int RmDir(const char* dir) { return _rmdir(dir); }
2642 inline bool IsDir(const StatStruct& st) {
2643   return (_S_IFDIR & st.st_mode) != 0;
2645 # endif  // GTEST_OS_WINDOWS_MOBILE
2647 #else
2649 typedef struct stat StatStruct;
2651 inline int FileNo(FILE* file) { return fileno(file); }
2652 inline int IsATTY(int fd) { return isatty(fd); }
2653 inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
2654 inline int StrCaseCmp(const char* s1, const char* s2) {
2655   return strcasecmp(s1, s2);
2657 inline char* StrDup(const char* src) { return strdup(src); }
2658 inline int RmDir(const char* dir) { return rmdir(dir); }
2659 inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
2661 #endif  // GTEST_OS_WINDOWS
2663 // Functions deprecated by MSVC 8.0.
2665 #ifdef _MSC_VER
2666 // Temporarily disable warning 4996 (deprecated function).
2667 # pragma warning(push)
2668 # pragma warning(disable:4996)
2669 #endif
2671 inline const char* StrNCpy(char* dest, const char* src, size_t n) {
2672   return strncpy(dest, src, n);
2675 // ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and
2676 // StrError() aren't needed on Windows CE at this time and thus not
2677 // defined there.
2679 #if !GTEST_OS_WINDOWS_MOBILE
2680 inline int ChDir(const char* dir) { return chdir(dir); }
2681 #endif
2682 inline FILE* FOpen(const char* path, const char* mode) {
2683   return fopen(path, mode);
2685 #if !GTEST_OS_WINDOWS_MOBILE
2686 inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
2687   return freopen(path, mode, stream);
2689 inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
2690 #endif
2691 inline int FClose(FILE* fp) { return fclose(fp); }
2692 #if !GTEST_OS_WINDOWS_MOBILE
2693 inline int Read(int fd, void* buf, unsigned int count) {
2694   return static_cast<int>(read(fd, buf, count));
2696 inline int Write(int fd, const void* buf, unsigned int count) {
2697   return static_cast<int>(write(fd, buf, count));
2699 inline int Close(int fd) { return close(fd); }
2700 inline const char* StrError(int errnum) { return strerror(errnum); }
2701 #endif
2702 inline const char* GetEnv(const char* name) {
2703 #if GTEST_OS_WINDOWS_MOBILE
2704   // We are on Windows CE, which has no environment variables.
2705   return NULL;
2706 #elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
2707   // Environment variables which we programmatically clear will be set to the
2708   // empty string rather than unset (NULL).  Handle that case.
2709   const char* const env = getenv(name);
2710   return (env != NULL && env[0] != '\0') ? env : NULL;
2711 #else
2712   return getenv(name);
2713 #endif
2716 #ifdef _MSC_VER
2717 # pragma warning(pop)  // Restores the warning state.
2718 #endif
2720 #if GTEST_OS_WINDOWS_MOBILE
2721 // Windows CE has no C library. The abort() function is used in
2722 // several places in Google Test. This implementation provides a reasonable
2723 // imitation of standard behaviour.
2724 void Abort();
2725 #else
2726 inline void Abort() { abort(); }
2727 #endif  // GTEST_OS_WINDOWS_MOBILE
2729 }  // namespace posix
2731 // The maximum number a BiggestInt can represent.  This definition
2732 // works no matter BiggestInt is represented in one's complement or
2733 // two's complement.
2734 //
2735 // We cannot rely on numeric_limits in STL, as __int64 and long long
2736 // are not part of standard C++ and numeric_limits doesn't need to be
2737 // defined for them.
2738 const BiggestInt kMaxBiggestInt =
2739     ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1));
2741 // This template class serves as a compile-time function from size to
2742 // type.  It maps a size in bytes to a primitive type with that
2743 // size. e.g.
2744 //
2745 //   TypeWithSize<4>::UInt
2746 //
2747 // is typedef-ed to be unsigned int (unsigned integer made up of 4
2748 // bytes).
2749 //
2750 // Such functionality should belong to STL, but I cannot find it
2751 // there.
2752 //
2753 // Google Test uses this class in the implementation of floating-point
2754 // comparison.
2755 //
2756 // For now it only handles UInt (unsigned int) as that's all Google Test
2757 // needs.  Other types can be easily added in the future if need
2758 // arises.
2759 template <size_t size>
2760 class TypeWithSize {
2761  public:
2762   // This prevents the user from using TypeWithSize<N> with incorrect
2763   // values of N.
2764   typedef void UInt;
2765 };
2767 // The specialization for size 4.
2768 template <>
2769 class TypeWithSize<4> {
2770  public:
2771   // unsigned int has size 4 in both gcc and MSVC.
2772   //
2773   // As base/basictypes.h doesn't compile on Windows, we cannot use
2774   // uint32, uint64, and etc here.
2775   typedef int Int;
2776   typedef unsigned int UInt;
2777 };
2779 // The specialization for size 8.
2780 template <>
2781 class TypeWithSize<8> {
2782  public:
2784 #if GTEST_OS_WINDOWS
2785   typedef __int64 Int;
2786   typedef unsigned __int64 UInt;
2787 #else
2788   typedef long long Int;  // NOLINT
2789   typedef unsigned long long UInt;  // NOLINT
2790 #endif  // GTEST_OS_WINDOWS
2791 };
2793 // Integer types of known sizes.
2794 typedef TypeWithSize<4>::Int Int32;
2795 typedef TypeWithSize<4>::UInt UInt32;
2796 typedef TypeWithSize<8>::Int Int64;
2797 typedef TypeWithSize<8>::UInt UInt64;
2798 typedef TypeWithSize<8>::Int TimeInMillis;  // Represents time in milliseconds.
2800 // Utilities for command line flags and environment variables.
2802 // Macro for referencing flags.
2803 #define GTEST_FLAG(name) FLAGS_gtest_##name
2805 // Macros for declaring flags.
2806 #define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
2807 #define GTEST_DECLARE_int32_(name) \
2808     GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name)
2809 #define GTEST_DECLARE_string_(name) \
2810     GTEST_API_ extern ::testing::internal::String GTEST_FLAG(name)
2812 // Macros for defining flags.
2813 #define GTEST_DEFINE_bool_(name, default_val, doc) \
2814     GTEST_API_ bool GTEST_FLAG(name) = (default_val)
2815 #define GTEST_DEFINE_int32_(name, default_val, doc) \
2816     GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
2817 #define GTEST_DEFINE_string_(name, default_val, doc) \
2818     GTEST_API_ ::testing::internal::String GTEST_FLAG(name) = (default_val)
2820 // Parses 'str' for a 32-bit signed integer.  If successful, writes the result
2821 // to *value and returns true; otherwise leaves *value unchanged and returns
2822 // false.
2823 // TODO(chandlerc): Find a better way to refactor flag and environment parsing
2824 // out of both gtest-port.cc and gtest.cc to avoid exporting this utility
2825 // function.
2826 bool ParseInt32(const Message& src_text, const char* str, Int32* value);
2828 // Parses a bool/Int32/string from the environment variable
2829 // corresponding to the given Google Test flag.
2830 bool BoolFromGTestEnv(const char* flag, bool default_val);
2831 GTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val);
2832 const char* StringFromGTestEnv(const char* flag, const char* default_val);
2834 }  // namespace internal
2835 }  // namespace testing
2837 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
2839 #if GTEST_OS_LINUX
2840 # include <stdlib.h>
2841 # include <sys/types.h>
2842 # include <sys/wait.h>
2843 # include <unistd.h>
2844 #endif  // GTEST_OS_LINUX
2846 #include <ctype.h>
2847 #include <string.h>
2848 #include <iomanip>
2849 #include <limits>
2850 #include <set>
2852 // Copyright 2005, Google Inc.
2853 // All rights reserved.
2854 //
2855 // Redistribution and use in source and binary forms, with or without
2856 // modification, are permitted provided that the following conditions are
2857 // met:
2858 //
2859 //     * Redistributions of source code must retain the above copyright
2860 // notice, this list of conditions and the following disclaimer.
2861 //     * Redistributions in binary form must reproduce the above
2862 // copyright notice, this list of conditions and the following disclaimer
2863 // in the documentation and/or other materials provided with the
2864 // distribution.
2865 //     * Neither the name of Google Inc. nor the names of its
2866 // contributors may be used to endorse or promote products derived from
2867 // this software without specific prior written permission.
2868 //
2869 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
2870 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
2871 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
2872 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
2873 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
2874 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
2875 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
2876 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
2877 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
2878 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
2879 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2880 //
2881 // Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee)
2882 //
2883 // The Google C++ Testing Framework (Google Test)
2884 //
2885 // This header file declares the String class and functions used internally by
2886 // Google Test.  They are subject to change without notice. They should not used
2887 // by code external to Google Test.
2888 //
2889 // This header file is #included by <gtest/internal/gtest-internal.h>.
2890 // It should not be #included by other files.
2892 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
2893 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
2895 #ifdef __BORLANDC__
2896 // string.h is not guaranteed to provide strcpy on C++ Builder.
2897 # include <mem.h>
2898 #endif
2900 #include <string.h>
2902 #include <string>
2904 namespace testing {
2905 namespace internal {
2907 // String - a UTF-8 string class.
2908 //
2909 // For historic reasons, we don't use std::string.
2910 //
2911 // TODO(wan@google.com): replace this class with std::string or
2912 // implement it in terms of the latter.
2913 //
2914 // Note that String can represent both NULL and the empty string,
2915 // while std::string cannot represent NULL.
2916 //
2917 // NULL and the empty string are considered different.  NULL is less
2918 // than anything (including the empty string) except itself.
2919 //
2920 // This class only provides minimum functionality necessary for
2921 // implementing Google Test.  We do not intend to implement a full-fledged
2922 // string class here.
2923 //
2924 // Since the purpose of this class is to provide a substitute for
2925 // std::string on platforms where it cannot be used, we define a copy
2926 // constructor and assignment operators such that we don't need
2927 // conditional compilation in a lot of places.
2928 //
2929 // In order to make the representation efficient, the d'tor of String
2930 // is not virtual.  Therefore DO NOT INHERIT FROM String.
2931 class GTEST_API_ String {
2932  public:
2933   // Static utility methods
2935   // Returns the input enclosed in double quotes if it's not NULL;
2936   // otherwise returns "(null)".  For example, "\"Hello\"" is returned
2937   // for input "Hello".
2938   //
2939   // This is useful for printing a C string in the syntax of a literal.
2940   //
2941   // Known issue: escape sequences are not handled yet.
2942   static String ShowCStringQuoted(const char* c_str);
2944   // Clones a 0-terminated C string, allocating memory using new.  The
2945   // caller is responsible for deleting the return value using
2946   // delete[].  Returns the cloned string, or NULL if the input is
2947   // NULL.
2948   //
2949   // This is different from strdup() in string.h, which allocates
2950   // memory using malloc().
2951   static const char* CloneCString(const char* c_str);
2953 #if GTEST_OS_WINDOWS_MOBILE
2954   // Windows CE does not have the 'ANSI' versions of Win32 APIs. To be
2955   // able to pass strings to Win32 APIs on CE we need to convert them
2956   // to 'Unicode', UTF-16.
2958   // Creates a UTF-16 wide string from the given ANSI string, allocating
2959   // memory using new. The caller is responsible for deleting the return
2960   // value using delete[]. Returns the wide string, or NULL if the
2961   // input is NULL.
2962   //
2963   // The wide string is created using the ANSI codepage (CP_ACP) to
2964   // match the behaviour of the ANSI versions of Win32 calls and the
2965   // C runtime.
2966   static LPCWSTR AnsiToUtf16(const char* c_str);
2968   // Creates an ANSI string from the given wide string, allocating
2969   // memory using new. The caller is responsible for deleting the return
2970   // value using delete[]. Returns the ANSI string, or NULL if the
2971   // input is NULL.
2972   //
2973   // The returned string is created using the ANSI codepage (CP_ACP) to
2974   // match the behaviour of the ANSI versions of Win32 calls and the
2975   // C runtime.
2976   static const char* Utf16ToAnsi(LPCWSTR utf16_str);
2977 #endif
2979   // Compares two C strings.  Returns true iff they have the same content.
2980   //
2981   // Unlike strcmp(), this function can handle NULL argument(s).  A
2982   // NULL C string is considered different to any non-NULL C string,
2983   // including the empty string.
2984   static bool CStringEquals(const char* lhs, const char* rhs);
2986   // Converts a wide C string to a String using the UTF-8 encoding.
2987   // NULL will be converted to "(null)".  If an error occurred during
2988   // the conversion, "(failed to convert from wide string)" is
2989   // returned.
2990   static String ShowWideCString(const wchar_t* wide_c_str);
2992   // Similar to ShowWideCString(), except that this function encloses
2993   // the converted string in double quotes.
2994   static String ShowWideCStringQuoted(const wchar_t* wide_c_str);
2996   // Compares two wide C strings.  Returns true iff they have the same
2997   // content.
2998   //
2999   // Unlike wcscmp(), this function can handle NULL argument(s).  A
3000   // NULL C string is considered different to any non-NULL C string,
3001   // including the empty string.
3002   static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs);
3004   // Compares two C strings, ignoring case.  Returns true iff they
3005   // have the same content.
3006   //
3007   // Unlike strcasecmp(), this function can handle NULL argument(s).
3008   // A NULL C string is considered different to any non-NULL C string,
3009   // including the empty string.
3010   static bool CaseInsensitiveCStringEquals(const char* lhs,
3011                                            const char* rhs);
3013   // Compares two wide C strings, ignoring case.  Returns true iff they
3014   // have the same content.
3015   //
3016   // Unlike wcscasecmp(), this function can handle NULL argument(s).
3017   // A NULL C string is considered different to any non-NULL wide C string,
3018   // including the empty string.
3019   // NB: The implementations on different platforms slightly differ.
3020   // On windows, this method uses _wcsicmp which compares according to LC_CTYPE
3021   // environment variable. On GNU platform this method uses wcscasecmp
3022   // which compares according to LC_CTYPE category of the current locale.
3023   // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
3024   // current locale.
3025   static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
3026                                                const wchar_t* rhs);
3028   // Formats a list of arguments to a String, using the same format
3029   // spec string as for printf.
3030   //
3031   // We do not use the StringPrintf class as it is not universally
3032   // available.
3033   //
3034   // The result is limited to 4096 characters (including the tailing
3035   // 0).  If 4096 characters are not enough to format the input,
3036   // "<buffer exceeded>" is returned.
3037   static String Format(const char* format, ...);
3039   // C'tors
3041   // The default c'tor constructs a NULL string.
3042   String() : c_str_(NULL), length_(0) {}
3044   // Constructs a String by cloning a 0-terminated C string.
3045   String(const char* a_c_str) {  // NOLINT
3046     if (a_c_str == NULL) {
3047       c_str_ = NULL;
3048       length_ = 0;
3049     } else {
3050       ConstructNonNull(a_c_str, strlen(a_c_str));
3051     }
3052   }
3054   // Constructs a String by copying a given number of chars from a
3055   // buffer.  E.g. String("hello", 3) creates the string "hel",
3056   // String("a\0bcd", 4) creates "a\0bc", String(NULL, 0) creates "",
3057   // and String(NULL, 1) results in access violation.
3058   String(const char* buffer, size_t a_length) {
3059     ConstructNonNull(buffer, a_length);
3060   }
3062   // The copy c'tor creates a new copy of the string.  The two
3063   // String objects do not share content.
3064   String(const String& str) : c_str_(NULL), length_(0) { *this = str; }
3066   // D'tor.  String is intended to be a final class, so the d'tor
3067   // doesn't need to be virtual.
3068   ~String() { delete[] c_str_; }
3070   // Allows a String to be implicitly converted to an ::std::string or
3071   // ::string, and vice versa.  Converting a String containing a NULL
3072   // pointer to ::std::string or ::string is undefined behavior.
3073   // Converting a ::std::string or ::string containing an embedded NUL
3074   // character to a String will result in the prefix up to the first
3075   // NUL character.
3076   String(const ::std::string& str) {
3077     ConstructNonNull(str.c_str(), str.length());
3078   }
3080   operator ::std::string() const { return ::std::string(c_str(), length()); }
3082 #if GTEST_HAS_GLOBAL_STRING
3083   String(const ::string& str) {
3084     ConstructNonNull(str.c_str(), str.length());
3085   }
3087   operator ::string() const { return ::string(c_str(), length()); }
3088 #endif  // GTEST_HAS_GLOBAL_STRING
3090   // Returns true iff this is an empty string (i.e. "").
3091   bool empty() const { return (c_str() != NULL) && (length() == 0); }
3093   // Compares this with another String.
3094   // Returns < 0 if this is less than rhs, 0 if this is equal to rhs, or > 0
3095   // if this is greater than rhs.
3096   int Compare(const String& rhs) const;
3098   // Returns true iff this String equals the given C string.  A NULL
3099   // string and a non-NULL string are considered not equal.
3100   bool operator==(const char* a_c_str) const { return Compare(a_c_str) == 0; }
3102   // Returns true iff this String is less than the given String.  A
3103   // NULL string is considered less than "".
3104   bool operator<(const String& rhs) const { return Compare(rhs) < 0; }
3106   // Returns true iff this String doesn't equal the given C string.  A NULL
3107   // string and a non-NULL string are considered not equal.
3108   bool operator!=(const char* a_c_str) const { return !(*this == a_c_str); }
3110   // Returns true iff this String ends with the given suffix.  *Any*
3111   // String is considered to end with a NULL or empty suffix.
3112   bool EndsWith(const char* suffix) const;
3114   // Returns true iff this String ends with the given suffix, not considering
3115   // case. Any String is considered to end with a NULL or empty suffix.
3116   bool EndsWithCaseInsensitive(const char* suffix) const;
3118   // Returns the length of the encapsulated string, or 0 if the
3119   // string is NULL.
3120   size_t length() const { return length_; }
3122   // Gets the 0-terminated C string this String object represents.
3123   // The String object still owns the string.  Therefore the caller
3124   // should NOT delete the return value.
3125   const char* c_str() const { return c_str_; }
3127   // Assigns a C string to this object.  Self-assignment works.
3128   const String& operator=(const char* a_c_str) {
3129     return *this = String(a_c_str);
3130   }
3132   // Assigns a String object to this object.  Self-assignment works.
3133   const String& operator=(const String& rhs) {
3134     if (this != &rhs) {
3135       delete[] c_str_;
3136       if (rhs.c_str() == NULL) {
3137         c_str_ = NULL;
3138         length_ = 0;
3139       } else {
3140         ConstructNonNull(rhs.c_str(), rhs.length());
3141       }
3142     }
3144     return *this;
3145   }
3147  private:
3148   // Constructs a non-NULL String from the given content.  This
3149   // function can only be called when c_str_ has not been allocated.
3150   // ConstructNonNull(NULL, 0) results in an empty string ("").
3151   // ConstructNonNull(NULL, non_zero) is undefined behavior.
3152   void ConstructNonNull(const char* buffer, size_t a_length) {
3153     char* const str = new char[a_length + 1];
3154     memcpy(str, buffer, a_length);
3155     str[a_length] = '\0';
3156     c_str_ = str;
3157     length_ = a_length;
3158   }
3160   const char* c_str_;
3161   size_t length_;
3162 };  // class String
3164 // Streams a String to an ostream.  Each '\0' character in the String
3165 // is replaced with "\\0".
3166 inline ::std::ostream& operator<<(::std::ostream& os, const String& str) {
3167   if (str.c_str() == NULL) {
3168     os << "(null)";
3169   } else {
3170     const char* const c_str = str.c_str();
3171     for (size_t i = 0; i != str.length(); i++) {
3172       if (c_str[i] == '\0') {
3173         os << "\\0";
3174       } else {
3175         os << c_str[i];
3176       }
3177     }
3178   }
3179   return os;
3182 // Gets the content of the stringstream's buffer as a String.  Each '\0'
3183 // character in the buffer is replaced with "\\0".
3184 GTEST_API_ String StringStreamToString(::std::stringstream* stream);
3186 // Converts a streamable value to a String.  A NULL pointer is
3187 // converted to "(null)".  When the input value is a ::string,
3188 // ::std::string, ::wstring, or ::std::wstring object, each NUL
3189 // character in it is replaced with "\\0".
3191 // Declared here but defined in gtest.h, so that it has access
3192 // to the definition of the Message class, required by the ARM
3193 // compiler.
3194 template <typename T>
3195 String StreamableToString(const T& streamable);
3197 }  // namespace internal
3198 }  // namespace testing
3200 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
3201 // Copyright 2008, Google Inc.
3202 // All rights reserved.
3203 //
3204 // Redistribution and use in source and binary forms, with or without
3205 // modification, are permitted provided that the following conditions are
3206 // met:
3207 //
3208 //     * Redistributions of source code must retain the above copyright
3209 // notice, this list of conditions and the following disclaimer.
3210 //     * Redistributions in binary form must reproduce the above
3211 // copyright notice, this list of conditions and the following disclaimer
3212 // in the documentation and/or other materials provided with the
3213 // distribution.
3214 //     * Neither the name of Google Inc. nor the names of its
3215 // contributors may be used to endorse or promote products derived from
3216 // this software without specific prior written permission.
3217 //
3218 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
3219 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
3220 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
3221 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
3222 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
3223 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
3224 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
3225 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
3226 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
3227 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
3228 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
3229 //
3230 // Author: keith.ray@gmail.com (Keith Ray)
3231 //
3232 // Google Test filepath utilities
3233 //
3234 // This header file declares classes and functions used internally by
3235 // Google Test.  They are subject to change without notice.
3236 //
3237 // This file is #included in <gtest/internal/gtest-internal.h>.
3238 // Do not include this header file separately!
3240 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
3241 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
3244 namespace testing {
3245 namespace internal {
3247 // FilePath - a class for file and directory pathname manipulation which
3248 // handles platform-specific conventions (like the pathname separator).
3249 // Used for helper functions for naming files in a directory for xml output.
3250 // Except for Set methods, all methods are const or static, which provides an
3251 // "immutable value object" -- useful for peace of mind.
3252 // A FilePath with a value ending in a path separator ("like/this/") represents
3253 // a directory, otherwise it is assumed to represent a file. In either case,
3254 // it may or may not represent an actual file or directory in the file system.
3255 // Names are NOT checked for syntax correctness -- no checking for illegal
3256 // characters, malformed paths, etc.
3258 class GTEST_API_ FilePath {
3259  public:
3260   FilePath() : pathname_("") { }
3261   FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
3263   explicit FilePath(const char* pathname) : pathname_(pathname) {
3264     Normalize();
3265   }
3267   explicit FilePath(const String& pathname) : pathname_(pathname) {
3268     Normalize();
3269   }
3271   FilePath& operator=(const FilePath& rhs) {
3272     Set(rhs);
3273     return *this;
3274   }
3276   void Set(const FilePath& rhs) {
3277     pathname_ = rhs.pathname_;
3278   }
3280   String ToString() const { return pathname_; }
3281   const char* c_str() const { return pathname_.c_str(); }
3283   // Returns the current working directory, or "" if unsuccessful.
3284   static FilePath GetCurrentDir();
3286   // Given directory = "dir", base_name = "test", number = 0,
3287   // extension = "xml", returns "dir/test.xml". If number is greater
3288   // than zero (e.g., 12), returns "dir/test_12.xml".
3289   // On Windows platform, uses \ as the separator rather than /.
3290   static FilePath MakeFileName(const FilePath& directory,
3291                                const FilePath& base_name,
3292                                int number,
3293                                const char* extension);
3295   // Given directory = "dir", relative_path = "test.xml",
3296   // returns "dir/test.xml".
3297   // On Windows, uses \ as the separator rather than /.
3298   static FilePath ConcatPaths(const FilePath& directory,
3299                               const FilePath& relative_path);
3301   // Returns a pathname for a file that does not currently exist. The pathname
3302   // will be directory/base_name.extension or
3303   // directory/base_name_<number>.extension if directory/base_name.extension
3304   // already exists. The number will be incremented until a pathname is found
3305   // that does not already exist.
3306   // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
3307   // There could be a race condition if two or more processes are calling this
3308   // function at the same time -- they could both pick the same filename.
3309   static FilePath GenerateUniqueFileName(const FilePath& directory,
3310                                          const FilePath& base_name,
3311                                          const char* extension);
3313   // Returns true iff the path is NULL or "".
3314   bool IsEmpty() const { return c_str() == NULL || *c_str() == '\0'; }
3316   // If input name has a trailing separator character, removes it and returns
3317   // the name, otherwise return the name string unmodified.
3318   // On Windows platform, uses \ as the separator, other platforms use /.
3319   FilePath RemoveTrailingPathSeparator() const;
3321   // Returns a copy of the FilePath with the directory part removed.
3322   // Example: FilePath("path/to/file").RemoveDirectoryName() returns
3323   // FilePath("file"). If there is no directory part ("just_a_file"), it returns
3324   // the FilePath unmodified. If there is no file part ("just_a_dir/") it
3325   // returns an empty FilePath ("").
3326   // On Windows platform, '\' is the path separator, otherwise it is '/'.
3327   FilePath RemoveDirectoryName() const;
3329   // RemoveFileName returns the directory path with the filename removed.
3330   // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
3331   // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
3332   // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
3333   // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
3334   // On Windows platform, '\' is the path separator, otherwise it is '/'.
3335   FilePath RemoveFileName() const;
3337   // Returns a copy of the FilePath with the case-insensitive extension removed.
3338   // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
3339   // FilePath("dir/file"). If a case-insensitive extension is not
3340   // found, returns a copy of the original FilePath.
3341   FilePath RemoveExtension(const char* extension) const;
3343   // Creates directories so that path exists. Returns true if successful or if
3344   // the directories already exist; returns false if unable to create
3345   // directories for any reason. Will also return false if the FilePath does
3346   // not represent a directory (that is, it doesn't end with a path separator).
3347   bool CreateDirectoriesRecursively() const;
3349   // Create the directory so that path exists. Returns true if successful or
3350   // if the directory already exists; returns false if unable to create the
3351   // directory for any reason, including if the parent directory does not
3352   // exist. Not named "CreateDirectory" because that's a macro on Windows.
3353   bool CreateFolder() const;
3355   // Returns true if FilePath describes something in the file-system,
3356   // either a file, directory, or whatever, and that something exists.
3357   bool FileOrDirectoryExists() const;
3359   // Returns true if pathname describes a directory in the file-system
3360   // that exists.
3361   bool DirectoryExists() const;
3363   // Returns true if FilePath ends with a path separator, which indicates that
3364   // it is intended to represent a directory. Returns false otherwise.
3365   // This does NOT check that a directory (or file) actually exists.
3366   bool IsDirectory() const;
3368   // Returns true if pathname describes a root directory. (Windows has one
3369   // root directory per disk drive.)
3370   bool IsRootDirectory() const;
3372   // Returns true if pathname describes an absolute path.
3373   bool IsAbsolutePath() const;
3375  private:
3376   // Replaces multiple consecutive separators with a single separator.
3377   // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
3378   // redundancies that might be in a pathname involving "." or "..".
3379   //
3380   // A pathname with multiple consecutive separators may occur either through
3381   // user error or as a result of some scripts or APIs that generate a pathname
3382   // with a trailing separator. On other platforms the same API or script
3383   // may NOT generate a pathname with a trailing "/". Then elsewhere that
3384   // pathname may have another "/" and pathname components added to it,
3385   // without checking for the separator already being there.
3386   // The script language and operating system may allow paths like "foo//bar"
3387   // but some of the functions in FilePath will not handle that correctly. In
3388   // particular, RemoveTrailingPathSeparator() only removes one separator, and
3389   // it is called in CreateDirectoriesRecursively() assuming that it will change
3390   // a pathname from directory syntax (trailing separator) to filename syntax.
3391   //
3392   // On Windows this method also replaces the alternate path separator '/' with
3393   // the primary path separator '\\', so that for example "bar\\/\\foo" becomes
3394   // "bar\\foo".
3396   void Normalize();
3398   // Returns a pointer to the last occurence of a valid path separator in
3399   // the FilePath. On Windows, for example, both '/' and '\' are valid path
3400   // separators. Returns NULL if no path separator was found.
3401   const char* FindLastPathSeparator() const;
3403   String pathname_;
3404 };  // class FilePath
3406 }  // namespace internal
3407 }  // namespace testing
3409 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
3410 // This file was GENERATED by command:
3411 //     pump.py gtest-type-util.h.pump
3412 // DO NOT EDIT BY HAND!!!
3414 // Copyright 2008 Google Inc.
3415 // All Rights Reserved.
3416 //
3417 // Redistribution and use in source and binary forms, with or without
3418 // modification, are permitted provided that the following conditions are
3419 // met:
3420 //
3421 //     * Redistributions of source code must retain the above copyright
3422 // notice, this list of conditions and the following disclaimer.
3423 //     * Redistributions in binary form must reproduce the above
3424 // copyright notice, this list of conditions and the following disclaimer
3425 // in the documentation and/or other materials provided with the
3426 // distribution.
3427 //     * Neither the name of Google Inc. nor the names of its
3428 // contributors may be used to endorse or promote products derived from
3429 // this software without specific prior written permission.
3430 //
3431 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
3432 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
3433 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
3434 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
3435 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
3436 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
3437 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
3438 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
3439 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
3440 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
3441 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
3442 //
3443 // Author: wan@google.com (Zhanyong Wan)
3445 // Type utilities needed for implementing typed and type-parameterized
3446 // tests.  This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!
3447 //
3448 // Currently we support at most 50 types in a list, and at most 50
3449 // type-parameterized tests in one type-parameterized test case.
3450 // Please contact googletestframework@googlegroups.com if you need
3451 // more.
3453 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
3454 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
3457 // #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
3458 // libstdc++ (which is where cxxabi.h comes from).
3459 # ifdef __GLIBCXX__
3460 #  include <cxxabi.h>
3461 # elif defined(__HP_aCC)
3462 #  include <acxx_demangle.h>
3463 # endif  // __GLIBCXX__
3465 namespace testing {
3466 namespace internal {
3468 // GetTypeName<T>() returns a human-readable name of type T.
3469 // NB: This function is also used in Google Mock, so don't move it inside of
3470 // the typed-test-only section below.
3471 template <typename T>
3472 String GetTypeName() {
3473 # if GTEST_HAS_RTTI
3475   const char* const name = typeid(T).name();
3476 #  if defined(__GLIBCXX__) || defined(__HP_aCC)
3477   int status = 0;
3478   // gcc's implementation of typeid(T).name() mangles the type name,
3479   // so we have to demangle it.
3480 #   ifdef __GLIBCXX__
3481   using abi::__cxa_demangle;
3482 #   endif // __GLIBCXX__
3483   char* const readable_name = __cxa_demangle(name, 0, 0, &status);
3484   const String name_str(status == 0 ? readable_name : name);
3485   free(readable_name);
3486   return name_str;
3487 #  else
3488   return name;
3489 #  endif  // __GLIBCXX__ || __HP_aCC
3491 # else
3493   return "<type>";
3495 # endif  // GTEST_HAS_RTTI
3498 #if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
3500 // AssertyTypeEq<T1, T2>::type is defined iff T1 and T2 are the same
3501 // type.  This can be used as a compile-time assertion to ensure that
3502 // two types are equal.
3504 template <typename T1, typename T2>
3505 struct AssertTypeEq;
3507 template <typename T>
3508 struct AssertTypeEq<T, T> {
3509   typedef bool type;
3510 };
3512 // A unique type used as the default value for the arguments of class
3513 // template Types.  This allows us to simulate variadic templates
3514 // (e.g. Types<int>, Type<int, double>, and etc), which C++ doesn't
3515 // support directly.
3516 struct None {};
3518 // The following family of struct and struct templates are used to
3519 // represent type lists.  In particular, TypesN<T1, T2, ..., TN>
3520 // represents a type list with N types (T1, T2, ..., and TN) in it.
3521 // Except for Types0, every struct in the family has two member types:
3522 // Head for the first type in the list, and Tail for the rest of the
3523 // list.
3525 // The empty type list.
3526 struct Types0 {};
3528 // Type lists of length 1, 2, 3, and so on.
3530 template <typename T1>
3531 struct Types1 {
3532   typedef T1 Head;
3533   typedef Types0 Tail;
3534 };
3535 template <typename T1, typename T2>
3536 struct Types2 {
3537   typedef T1 Head;
3538   typedef Types1<T2> Tail;
3539 };
3541 template <typename T1, typename T2, typename T3>
3542 struct Types3 {
3543   typedef T1 Head;
3544   typedef Types2<T2, T3> Tail;
3545 };
3547 template <typename T1, typename T2, typename T3, typename T4>
3548 struct Types4 {
3549   typedef T1 Head;
3550   typedef Types3<T2, T3, T4> Tail;
3551 };
3553 template <typename T1, typename T2, typename T3, typename T4, typename T5>
3554 struct Types5 {
3555   typedef T1 Head;
3556   typedef Types4<T2, T3, T4, T5> Tail;
3557 };
3559 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3560     typename T6>
3561 struct Types6 {
3562   typedef T1 Head;
3563   typedef Types5<T2, T3, T4, T5, T6> Tail;
3564 };
3566 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3567     typename T6, typename T7>
3568 struct Types7 {
3569   typedef T1 Head;
3570   typedef Types6<T2, T3, T4, T5, T6, T7> Tail;
3571 };
3573 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3574     typename T6, typename T7, typename T8>
3575 struct Types8 {
3576   typedef T1 Head;
3577   typedef Types7<T2, T3, T4, T5, T6, T7, T8> Tail;
3578 };
3580 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3581     typename T6, typename T7, typename T8, typename T9>
3582 struct Types9 {
3583   typedef T1 Head;
3584   typedef Types8<T2, T3, T4, T5, T6, T7, T8, T9> Tail;
3585 };
3587 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3588     typename T6, typename T7, typename T8, typename T9, typename T10>
3589 struct Types10 {
3590   typedef T1 Head;
3591   typedef Types9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail;
3592 };
3594 template <typename T1, typename T2, typename T3, typename T4, typename T5,
3595     typename T6, typename T7, typename T8, typename T9, typename T10,
3596     typename T11>
3597 struct Types11 {
3598   typedef T1 Head;
3599   typedef Types10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail;
3600 };