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// Authors: wan@google.com (Zhanyong Wan)
31//
32// Low-level types and utilities for porting Google Test to various
33// platforms.  All macros ending with _ and symbols defined in an
34// internal namespace are subject to change without notice.  Code
35// outside Google Test MUST NOT USE THEM DIRECTLY.  Macros that don't
36// end with _ are part of Google Test's public API and can be used by
37// code outside Google Test.
38//
39// This file is fundamental to Google Test.  All other Google Test source
40// files are expected to #include this.  Therefore, it cannot #include
41// any other Google Test header.
42
43#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
44#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
45
46// Environment-describing macros
47// -----------------------------
48//
49// Google Test can be used in many different environments.  Macros in
50// this section tell Google Test what kind of environment it is being
51// used in, such that Google Test can provide environment-specific
52// features and implementations.
53//
54// Google Test tries to automatically detect the properties of its
55// environment, so users usually don't need to worry about these
56// macros.  However, the automatic detection is not perfect.
57// Sometimes it's necessary for a user to define some of the following
58// macros in the build script to override Google Test's decisions.
59//
60// If the user doesn't define a macro in the list, Google Test will
61// provide a default definition.  After this header is #included, all
62// macros in this list will be defined to either 1 or 0.
63//
64// Notes to maintainers:
65//   - Each macro here is a user-tweakable knob; do not grow the list
66//     lightly.
67//   - Use #if to key off these macros.  Don't use #ifdef or "#if
68//     defined(...)", which will not work as these macros are ALWAYS
69//     defined.
70//
71//   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)
72//                              is/isn't available.
73//   GTEST_HAS_EXCEPTIONS     - Define it to 1/0 to indicate that exceptions
74//                              are enabled.
75//   GTEST_HAS_GLOBAL_STRING  - Define it to 1/0 to indicate that ::string
76//                              is/isn't available (some systems define
77//                              ::string, which is different to std::string).
78//   GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string
79//                              is/isn't available (some systems define
80//                              ::wstring, which is different to std::wstring).
81//   GTEST_HAS_POSIX_RE       - Define it to 1/0 to indicate that POSIX regular
82//                              expressions are/aren't available.
83//   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>
84//                              is/isn't available.
85//   GTEST_HAS_RTTI           - Define it to 1/0 to indicate that RTTI is/isn't
86//                              enabled.
87//   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that
88//                              std::wstring does/doesn't work (Google Test can
89//                              be used where std::wstring is unavailable).
90//   GTEST_HAS_TR1_TUPLE      - Define it to 1/0 to indicate tr1::tuple
91//                              is/isn't available.
92//   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the
93//                              compiler supports Microsoft's "Structured
94//                              Exception Handling".
95//   GTEST_HAS_STREAM_REDIRECTION
96//                            - Define it to 1/0 to indicate whether the
97//                              platform supports I/O stream redirection using
98//                              dup() and dup2().
99//   GTEST_USE_OWN_TR1_TUPLE  - Define it to 1/0 to indicate whether Google
100//                              Test's own tr1 tuple implementation should be
101//                              used.  Unused when the user sets
102//                              GTEST_HAS_TR1_TUPLE to 0.
103//   GTEST_LANG_CXX11         - Define it to 1/0 to indicate that Google Test
104//                              is building in C++11/C++98 mode.
105//   GTEST_LINKED_AS_SHARED_LIBRARY
106//                            - Define to 1 when compiling tests that use
107//                              Google Test as a shared library (known as
108//                              DLL on Windows).
109//   GTEST_CREATE_SHARED_LIBRARY
110//                            - Define to 1 when compiling Google Test itself
111//                              as a shared library.
112
113// Platform-indicating macros
114// --------------------------
115//
116// Macros indicating the platform on which Google Test is being used
117// (a macro is defined to 1 if compiled on the given platform;
118// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
119// defines these macros automatically.  Code outside Google Test MUST
120// NOT define them.
121//
122//   GTEST_OS_AIX      - IBM AIX
123//   GTEST_OS_CYGWIN   - Cygwin
124//   GTEST_OS_FREEBSD  - FreeBSD
125//   GTEST_OS_HPUX     - HP-UX
126//   GTEST_OS_LINUX    - Linux
127//     GTEST_OS_LINUX_ANDROID - Google Android
128//   GTEST_OS_MAC      - Mac OS X
129//     GTEST_OS_IOS    - iOS
130//   GTEST_OS_NACL     - Google Native Client (NaCl)
131//   GTEST_OS_OPENBSD  - OpenBSD
132//   GTEST_OS_QNX      - QNX
133//   GTEST_OS_SOLARIS  - Sun Solaris
134//   GTEST_OS_SYMBIAN  - Symbian
135//   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
136//     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop
137//     GTEST_OS_WINDOWS_MINGW    - MinGW
138//     GTEST_OS_WINDOWS_MOBILE   - Windows Mobile
139//     GTEST_OS_WINDOWS_PHONE    - Windows Phone
140//     GTEST_OS_WINDOWS_RT       - Windows Store App/WinRT
141//   GTEST_OS_ZOS      - z/OS
142//
143// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the
144// most stable support.  Since core members of the Google Test project
145// don't have access to other platforms, support for them may be less
146// stable.  If you notice any problems on your platform, please notify
147// googletestframework@googlegroups.com (patches for fixing them are
148// even more welcome!).
149//
150// It is possible that none of the GTEST_OS_* macros are defined.
151
152// Feature-indicating macros
153// -------------------------
154//
155// Macros indicating which Google Test features are available (a macro
156// is defined to 1 if the corresponding feature is supported;
157// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
158// defines these macros automatically.  Code outside Google Test MUST
159// NOT define them.
160//
161// These macros are public so that portable tests can be written.
162// Such tests typically surround code using a feature with an #if
163// which controls that code.  For example:
164//
165// #if GTEST_HAS_DEATH_TEST
166//   EXPECT_DEATH(DoSomethingDeadly());
167// #endif
168//
169//   GTEST_HAS_COMBINE      - the Combine() function (for value-parameterized
170//                            tests)
171//   GTEST_HAS_DEATH_TEST   - death tests
172//   GTEST_HAS_PARAM_TEST   - value-parameterized tests
173//   GTEST_HAS_TYPED_TEST   - typed tests
174//   GTEST_HAS_TYPED_TEST_P - type-parameterized tests
175//   GTEST_IS_THREADSAFE    - Google Test is thread-safe.
176//   GTEST_USES_POSIX_RE    - enhanced POSIX regex is used. Do not confuse with
177//                            GTEST_HAS_POSIX_RE (see above) which users can
178//                            define themselves.
179//   GTEST_USES_SIMPLE_RE   - our own simple regex is used;
180//                            the above two are mutually exclusive.
181//   GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ().
182
183// Misc public macros
184// ------------------
185//
186//   GTEST_FLAG(flag_name)  - references the variable corresponding to
187//                            the given Google Test flag.
188
189// Internal utilities
190// ------------------
191//
192// The following macros and utilities are for Google Test's INTERNAL
193// use only.  Code outside Google Test MUST NOT USE THEM DIRECTLY.
194//
195// Macros for basic C++ coding:
196//   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
197//   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a
198//                              variable don't have to be used.
199//   GTEST_DISALLOW_ASSIGN_   - disables operator=.
200//   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
201//   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
202//   GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is
203//                                        suppressed (constant conditional).
204//   GTEST_INTENTIONAL_CONST_COND_POP_  - finish code section where MSVC C4127
205//                                        is suppressed.
206//
207// C++11 feature wrappers:
208//
209//   testing::internal::move  - portability wrapper for std::move.
210//
211// Synchronization:
212//   Mutex, MutexLock, ThreadLocal, GetThreadCount()
213//                            - synchronization primitives.
214//
215// Template meta programming:
216//   is_pointer     - as in TR1; needed on Symbian and IBM XL C/C++ only.
217//   IteratorTraits - partial implementation of std::iterator_traits, which
218//                    is not available in libCstd when compiled with Sun C++.
219//
220// Smart pointers:
221//   scoped_ptr     - as in TR2.
222//
223// Regular expressions:
224//   RE             - a simple regular expression class using the POSIX
225//                    Extended Regular Expression syntax on UNIX-like
226//                    platforms, or a reduced regular exception syntax on
227//                    other platforms, including Windows.
228//
229// Logging:
230//   GTEST_LOG_()   - logs messages at the specified severity level.
231//   LogToStderr()  - directs all log messages to stderr.
232//   FlushInfoLog() - flushes informational log messages.
233//
234// Stdout and stderr capturing:
235//   CaptureStdout()     - starts capturing stdout.
236//   GetCapturedStdout() - stops capturing stdout and returns the captured
237//                         string.
238//   CaptureStderr()     - starts capturing stderr.
239//   GetCapturedStderr() - stops capturing stderr and returns the captured
240//                         string.
241//
242// Integer types:
243//   TypeWithSize   - maps an integer to a int type.
244//   Int32, UInt32, Int64, UInt64, TimeInMillis
245//                  - integers of known sizes.
246//   BiggestInt     - the biggest signed integer type.
247//
248// Command-line utilities:
249//   GTEST_DECLARE_*()  - declares a flag.
250//   GTEST_DEFINE_*()   - defines a flag.
251//   GetInjectableArgvs() - returns the command line as a vector of strings.
252//
253// Environment variable utilities:
254//   GetEnv()             - gets the value of an environment variable.
255//   BoolFromGTestEnv()   - parses a bool environment variable.
256//   Int32FromGTestEnv()  - parses an Int32 environment variable.
257//   StringFromGTestEnv() - parses a string environment variable.
258
259#include <ctype.h>   // for isspace, etc
260#include <stddef.h>  // for ptrdiff_t
261#include <stdlib.h>
262#include <stdio.h>
263#include <string.h>
264#ifndef _WIN32_WCE
265# include <sys/types.h>
266# include <sys/stat.h>
267#endif  // !_WIN32_WCE
268
269#if defined __APPLE__
270# include <AvailabilityMacros.h>
271# include <TargetConditionals.h>
272#endif
273
274#include <algorithm>  // NOLINT
275#include <iostream>  // NOLINT
276#include <sstream>  // NOLINT
277#include <string>  // NOLINT
278#include <utility>
279#include <vector>  // NOLINT
280
281#include "gtest/internal/gtest-port-arch.h"
282#include "gtest/internal/custom/gtest-port.h"
283
284#if !defined(GTEST_DEV_EMAIL_)
285# define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
286# define GTEST_FLAG_PREFIX_ "gtest_"
287# define GTEST_FLAG_PREFIX_DASH_ "gtest-"
288# define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
289# define GTEST_NAME_ "Google Test"
290# define GTEST_PROJECT_URL_ "https://github.com/google/googletest/"
291#endif  // !defined(GTEST_DEV_EMAIL_)
292
293#if !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
294# define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest"
295#endif  // !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
296
297// Determines the version of gcc that is used to compile this.
298#ifdef __GNUC__
299// 40302 means version 4.3.2.
300# define GTEST_GCC_VER_ \
301    (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
302#endif  // __GNUC__
303
304// Macros for disabling Microsoft Visual C++ warnings.
305//
306//   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385)
307//   /* code that triggers warnings C4800 and C4385 */
308//   GTEST_DISABLE_MSC_WARNINGS_POP_()
309#if _MSC_VER >= 1500
310# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
311    __pragma(warning(push))                        \
312    __pragma(warning(disable: warnings))
313# define GTEST_DISABLE_MSC_WARNINGS_POP_()          \
314    __pragma(warning(pop))
315#else
316// Older versions of MSVC don't have __pragma.
317# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
318# define GTEST_DISABLE_MSC_WARNINGS_POP_()
319#endif
320
321#ifndef GTEST_LANG_CXX11
322// gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when
323// -std={c,gnu}++{0x,11} is passed.  The C++11 standard specifies a
324// value for __cplusplus, and recent versions of clang, gcc, and
325// probably other compilers set that too in C++11 mode.
326# if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L
327// Compiling in at least C++11 mode.
328#  define GTEST_LANG_CXX11 1
329# else
330#  define GTEST_LANG_CXX11 0
331# endif
332#endif
333
334// Distinct from C++11 language support, some environments don't provide
335// proper C++11 library support. Notably, it's possible to build in
336// C++11 mode when targeting Mac OS X 10.6, which has an old libstdc++
337// with no C++11 support.
338//
339// libstdc++ has sufficient C++11 support as of GCC 4.6.0, __GLIBCXX__
340// 20110325, but maintenance releases in the 4.4 and 4.5 series followed
341// this date, so check for those versions by their date stamps.
342// https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html#abi.versioning
343#if GTEST_LANG_CXX11 && \
344    (!defined(__GLIBCXX__) || ( \
345        __GLIBCXX__ >= 20110325ul &&  /* GCC >= 4.6.0 */ \
346        /* Blacklist of patch releases of older branches: */ \
347        __GLIBCXX__ != 20110416ul &&  /* GCC 4.4.6 */ \
348        __GLIBCXX__ != 20120313ul &&  /* GCC 4.4.7 */ \
349        __GLIBCXX__ != 20110428ul &&  /* GCC 4.5.3 */ \
350        __GLIBCXX__ != 20120702ul))   /* GCC 4.5.4 */
351# define GTEST_STDLIB_CXX11 1
352#endif
353
354// Only use C++11 library features if the library provides them.
355#if GTEST_STDLIB_CXX11
356# define GTEST_HAS_STD_BEGIN_AND_END_ 1
357# define GTEST_HAS_STD_FORWARD_LIST_ 1
358# define GTEST_HAS_STD_FUNCTION_ 1
359# define GTEST_HAS_STD_INITIALIZER_LIST_ 1
360# define GTEST_HAS_STD_MOVE_ 1
361# define GTEST_HAS_STD_SHARED_PTR_ 1
362# define GTEST_HAS_STD_TYPE_TRAITS_ 1
363# define GTEST_HAS_STD_UNIQUE_PTR_ 1
364#endif
365
366// C++11 specifies that <tuple> provides std::tuple.
367// Some platforms still might not have it, however.
368#if GTEST_LANG_CXX11
369# define GTEST_HAS_STD_TUPLE_ 1
370# if defined(__clang__)
371// Inspired by http://clang.llvm.org/docs/LanguageExtensions.html#__has_include
372#  if defined(__has_include) && !__has_include(<tuple>)
373#   undef GTEST_HAS_STD_TUPLE_
374#  endif
375# elif defined(_MSC_VER)
376// Inspired by boost/config/stdlib/dinkumware.hpp
377#  if defined(_CPPLIB_VER) && _CPPLIB_VER < 520
378#   undef GTEST_HAS_STD_TUPLE_
379#  endif
380# elif defined(__GLIBCXX__)
381// Inspired by boost/config/stdlib/libstdcpp3.hpp,
382// http://gcc.gnu.org/gcc-4.2/changes.html and
383// http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt01ch01.html#manual.intro.status.standard.200x
384#  if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2)
385#   undef GTEST_HAS_STD_TUPLE_
386#  endif
387# endif
388#endif
389
390// Brings in definitions for functions used in the testing::internal::posix
391// namespace (read, write, close, chdir, isatty, stat). We do not currently
392// use them on Windows Mobile.
393#if GTEST_OS_WINDOWS
394# if !GTEST_OS_WINDOWS_MOBILE
395#  include <direct.h>
396#  include <io.h>
397# endif
398// In order to avoid having to include <windows.h>, use forward declaration
399// assuming CRITICAL_SECTION is a typedef of _RTL_CRITICAL_SECTION.
400// This assumption is verified by
401// WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION.
402struct _RTL_CRITICAL_SECTION;
403#else
404// This assumes that non-Windows OSes provide unistd.h. For OSes where this
405// is not the case, we need to include headers that provide the functions
406// mentioned above.
407# include <unistd.h>
408# include <strings.h>
409#endif  // GTEST_OS_WINDOWS
410
411#if GTEST_OS_LINUX_ANDROID
412// Used to define __ANDROID_API__ matching the target NDK API level.
413#  include <android/api-level.h>  // NOLINT
414#endif
415
416// Defines this to true iff Google Test can use POSIX regular expressions.
417#ifndef GTEST_HAS_POSIX_RE
418# if GTEST_OS_LINUX_ANDROID
419// On Android, <regex.h> is only available starting with Gingerbread.
420#  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
421# else
422#  define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS)
423# endif
424#endif
425
426#if GTEST_USES_PCRE
427// The appropriate headers have already been included.
428
429#elif GTEST_HAS_POSIX_RE
430
431// On some platforms, <regex.h> needs someone to define size_t, and
432// won't compile otherwise.  We can #include it here as we already
433// included <stdlib.h>, which is guaranteed to define size_t through
434// <stddef.h>.
435# include <regex.h>  // NOLINT
436
437# define GTEST_USES_POSIX_RE 1
438
439#elif GTEST_OS_WINDOWS
440
441// <regex.h> is not available on Windows.  Use our own simple regex
442// implementation instead.
443# define GTEST_USES_SIMPLE_RE 1
444
445#else
446
447// <regex.h> may not be available on this platform.  Use our own
448// simple regex implementation instead.
449# define GTEST_USES_SIMPLE_RE 1
450
451#endif  // GTEST_USES_PCRE
452
453#ifndef GTEST_HAS_EXCEPTIONS
454// The user didn't tell us whether exceptions are enabled, so we need
455// to figure it out.
456# if defined(_MSC_VER) || defined(__BORLANDC__)
457// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS
458// macro to enable exceptions, so we'll do the same.
459// Assumes that exceptions are enabled by default.
460#  ifndef _HAS_EXCEPTIONS
461#   define _HAS_EXCEPTIONS 1
462#  endif  // _HAS_EXCEPTIONS
463#  define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
464# elif defined(__clang__)
465// clang defines __EXCEPTIONS iff exceptions are enabled before clang 220714,
466// but iff cleanups are enabled after that. In Obj-C++ files, there can be
467// cleanups for ObjC exceptions which also need cleanups, even if C++ exceptions
468// are disabled. clang has __has_feature(cxx_exceptions) which checks for C++
469// exceptions starting at clang r206352, but which checked for cleanups prior to
470// that. To reliably check for C++ exception availability with clang, check for
471// __EXCEPTIONS && __has_feature(cxx_exceptions).
472#  define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions))
473# elif defined(__GNUC__) && __EXCEPTIONS
474// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled.
475#  define GTEST_HAS_EXCEPTIONS 1
476# elif defined(__SUNPRO_CC)
477// Sun Pro CC supports exceptions.  However, there is no compile-time way of
478// detecting whether they are enabled or not.  Therefore, we assume that
479// they are enabled unless the user tells us otherwise.
480#  define GTEST_HAS_EXCEPTIONS 1
481# elif defined(__IBMCPP__) && __EXCEPTIONS
482// xlC defines __EXCEPTIONS to 1 iff exceptions are enabled.
483#  define GTEST_HAS_EXCEPTIONS 1
484# elif defined(__HP_aCC)
485// Exception handling is in effect by default in HP aCC compiler. It has to
486// be turned of by +noeh compiler option if desired.
487#  define GTEST_HAS_EXCEPTIONS 1
488# else
489// For other compilers, we assume exceptions are disabled to be
490// conservative.
491#  define GTEST_HAS_EXCEPTIONS 0
492# endif  // defined(_MSC_VER) || defined(__BORLANDC__)
493#endif  // GTEST_HAS_EXCEPTIONS
494
495#if !defined(GTEST_HAS_STD_STRING)
496// Even though we don't use this macro any longer, we keep it in case
497// some clients still depend on it.
498# define GTEST_HAS_STD_STRING 1
499#elif !GTEST_HAS_STD_STRING
500// The user told us that ::std::string isn't available.
501# error "Google Test cannot be used where ::std::string isn't available."
502#endif  // !defined(GTEST_HAS_STD_STRING)
503
504#ifndef GTEST_HAS_GLOBAL_STRING
505// The user didn't tell us whether ::string is available, so we need
506// to figure it out.
507
508# define GTEST_HAS_GLOBAL_STRING 0
509
510#endif  // GTEST_HAS_GLOBAL_STRING
511
512#ifndef GTEST_HAS_STD_WSTRING
513// The user didn't tell us whether ::std::wstring is available, so we need
514// to figure it out.
515// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring
516//   is available.
517
518// Cygwin 1.7 and below doesn't support ::std::wstring.
519// Solaris' libc++ doesn't support it either.  Android has
520// no support for it at least as recent as Froyo (2.2).
521# define GTEST_HAS_STD_WSTRING \
522    (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS))
523
524#endif  // GTEST_HAS_STD_WSTRING
525
526#ifndef GTEST_HAS_GLOBAL_WSTRING
527// The user didn't tell us whether ::wstring is available, so we need
528// to figure it out.
529# define GTEST_HAS_GLOBAL_WSTRING \
530    (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
531#endif  // GTEST_HAS_GLOBAL_WSTRING
532
533// Determines whether RTTI is available.
534#ifndef GTEST_HAS_RTTI
535// The user didn't tell us whether RTTI is enabled, so we need to
536// figure it out.
537
538# ifdef _MSC_VER
539
540#  ifdef _CPPRTTI  // MSVC defines this macro iff RTTI is enabled.
541#   define GTEST_HAS_RTTI 1
542#  else
543#   define GTEST_HAS_RTTI 0
544#  endif
545
546// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled.
547# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302)
548
549#  ifdef __GXX_RTTI
550// When building against STLport with the Android NDK and with
551// -frtti -fno-exceptions, the build fails at link time with undefined
552// references to __cxa_bad_typeid. Note sure if STL or toolchain bug,
553// so disable RTTI when detected.
554#   if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
555       !defined(__EXCEPTIONS)
556#    define GTEST_HAS_RTTI 0
557#   else
558#    define GTEST_HAS_RTTI 1
559#   endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS
560#  else
561#   define GTEST_HAS_RTTI 0
562#  endif  // __GXX_RTTI
563
564// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends
565// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the
566// first version with C++ support.
567# elif defined(__clang__)
568
569#  define GTEST_HAS_RTTI __has_feature(cxx_rtti)
570
571// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
572// both the typeid and dynamic_cast features are present.
573# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
574
575#  ifdef __RTTI_ALL__
576#   define GTEST_HAS_RTTI 1
577#  else
578#   define GTEST_HAS_RTTI 0
579#  endif
580
581# else
582
583// For all other compilers, we assume RTTI is enabled.
584#  define GTEST_HAS_RTTI 1
585
586# endif  // _MSC_VER
587
588#endif  // GTEST_HAS_RTTI
589
590// It's this header's responsibility to #include <typeinfo> when RTTI
591// is enabled.
592#if GTEST_HAS_RTTI
593# include <typeinfo>
594#endif
595
596// Determines whether Google Test can use the pthreads library.
597#ifndef GTEST_HAS_PTHREAD
598// The user didn't tell us explicitly, so we make reasonable assumptions about
599// which platforms have pthreads support.
600//
601// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
602// to your compiler flags.
603# define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX \
604    || GTEST_OS_QNX || GTEST_OS_FREEBSD || GTEST_OS_NACL)
605#endif  // GTEST_HAS_PTHREAD
606
607#if GTEST_HAS_PTHREAD
608// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is
609// true.
610# include <pthread.h>  // NOLINT
611
612// For timespec and nanosleep, used below.
613# include <time.h>  // NOLINT
614#endif
615
616// Determines if hash_map/hash_set are available.
617// Only used for testing against those containers.
618#if !defined(GTEST_HAS_HASH_MAP_)
619# if _MSC_VER
620#  define GTEST_HAS_HASH_MAP_ 1  // Indicates that hash_map is available.
621#  define GTEST_HAS_HASH_SET_ 1  // Indicates that hash_set is available.
622# endif  // _MSC_VER
623#endif  // !defined(GTEST_HAS_HASH_MAP_)
624
625// Determines whether Google Test can use tr1/tuple.  You can define
626// this macro to 0 to prevent Google Test from using tuple (any
627// feature depending on tuple with be disabled in this mode).
628#ifndef GTEST_HAS_TR1_TUPLE
629# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR)
630// STLport, provided with the Android NDK, has neither <tr1/tuple> or <tuple>.
631#  define GTEST_HAS_TR1_TUPLE 0
632# else
633// The user didn't tell us not to do it, so we assume it's OK.
634#  define GTEST_HAS_TR1_TUPLE 1
635# endif
636#endif  // GTEST_HAS_TR1_TUPLE
637
638// Determines whether Google Test's own tr1 tuple implementation
639// should be used.
640#ifndef GTEST_USE_OWN_TR1_TUPLE
641// The user didn't tell us, so we need to figure it out.
642
643// We use our own TR1 tuple if we aren't sure the user has an
644// implementation of it already.  At this time, libstdc++ 4.0.0+ and
645// MSVC 2010 are the only mainstream standard libraries that come
646// with a TR1 tuple implementation.  NVIDIA's CUDA NVCC compiler
647// pretends to be GCC by defining __GNUC__ and friends, but cannot
648// compile GCC's tuple implementation.  MSVC 2008 (9.0) provides TR1
649// tuple in a 323 MB Feature Pack download, which we cannot assume the
650// user has.  QNX's QCC compiler is a modified GCC but it doesn't
651// support TR1 tuple.  libc++ only provides std::tuple, in C++11 mode,
652// and it can be used with some compilers that define __GNUC__.
653# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \
654      && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) || _MSC_VER >= 1600
655#  define GTEST_ENV_HAS_TR1_TUPLE_ 1
656# endif
657
658// C++11 specifies that <tuple> provides std::tuple. Use that if gtest is used
659// in C++11 mode and libstdc++ isn't very old (binaries targeting OS X 10.6
660// can build with clang but need to use gcc4.2's libstdc++).
661# if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325)
662#  define GTEST_ENV_HAS_STD_TUPLE_ 1
663# endif
664
665# if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_
666#  define GTEST_USE_OWN_TR1_TUPLE 0
667# else
668#  define GTEST_USE_OWN_TR1_TUPLE 1
669# endif
670
671#endif  // GTEST_USE_OWN_TR1_TUPLE
672
673// To avoid conditional compilation everywhere, we make it
674// gtest-port.h's responsibility to #include the header implementing
675// tuple.
676#if GTEST_HAS_STD_TUPLE_
677# include <tuple>  // IWYU pragma: export
678# define GTEST_TUPLE_NAMESPACE_ ::std
679#endif  // GTEST_HAS_STD_TUPLE_
680
681// We include tr1::tuple even if std::tuple is available to define printers for
682// them.
683#if GTEST_HAS_TR1_TUPLE
684# ifndef GTEST_TUPLE_NAMESPACE_
685#  define GTEST_TUPLE_NAMESPACE_ ::std::tr1
686# endif  // GTEST_TUPLE_NAMESPACE_
687
688# if GTEST_USE_OWN_TR1_TUPLE
689#  include "gtest/internal/gtest-tuple.h"  // IWYU pragma: export  // NOLINT
690# elif GTEST_ENV_HAS_STD_TUPLE_
691#  include <tuple>
692// C++11 puts its tuple into the ::std namespace rather than
693// ::std::tr1.  gtest expects tuple to live in ::std::tr1, so put it there.
694// This causes undefined behavior, but supported compilers react in
695// the way we intend.
696namespace std {
697namespace tr1 {
698using ::std::get;
699using ::std::make_tuple;
700using ::std::tuple;
701using ::std::tuple_element;
702using ::std::tuple_size;
703}
704}
705
706# elif GTEST_OS_SYMBIAN
707
708// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to
709// use STLport's tuple implementation, which unfortunately doesn't
710// work as the copy of STLport distributed with Symbian is incomplete.
711// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to
712// use its own tuple implementation.
713#  ifdef BOOST_HAS_TR1_TUPLE
714#   undef BOOST_HAS_TR1_TUPLE
715#  endif  // BOOST_HAS_TR1_TUPLE
716
717// This prevents <boost/tr1/detail/config.hpp>, which defines
718// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>.
719#  define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED
720#  include <tuple>  // IWYU pragma: export  // NOLINT
721
722# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
723// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header.  This does
724// not conform to the TR1 spec, which requires the header to be <tuple>.
725
726#  if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
727// Until version 4.3.2, gcc has a bug that causes <tr1/functional>,
728// which is #included by <tr1/tuple>, to not compile when RTTI is
729// disabled.  _TR1_FUNCTIONAL is the header guard for
730// <tr1/functional>.  Hence the following #define is a hack to prevent
731// <tr1/functional> from being included.
732#   define _TR1_FUNCTIONAL 1
733#   include <tr1/tuple>
734#   undef _TR1_FUNCTIONAL  // Allows the user to #include
735                        // <tr1/functional> if he chooses to.
736#  else
737#   include <tr1/tuple>  // NOLINT
738#  endif  // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
739
740# else
741// If the compiler is not GCC 4.0+, we assume the user is using a
742// spec-conforming TR1 implementation.
743#  include <tuple>  // IWYU pragma: export  // NOLINT
744# endif  // GTEST_USE_OWN_TR1_TUPLE
745
746#endif  // GTEST_HAS_TR1_TUPLE
747
748// Determines whether clone(2) is supported.
749// Usually it will only be available on Linux, excluding
750// Linux on the Itanium architecture.
751// Also see http://linux.die.net/man/2/clone.
752#ifndef GTEST_HAS_CLONE
753// The user didn't tell us, so we need to figure it out.
754
755# if GTEST_OS_LINUX && !defined(__ia64__)
756#  if GTEST_OS_LINUX_ANDROID
757// On Android, clone() is only available on ARM starting with Gingerbread.
758#    if defined(__arm__) && __ANDROID_API__ >= 9
759#     define GTEST_HAS_CLONE 1
760#    else
761#     define GTEST_HAS_CLONE 0
762#    endif
763#  else
764#   define GTEST_HAS_CLONE 1
765#  endif
766# else
767#  define GTEST_HAS_CLONE 0
768# endif  // GTEST_OS_LINUX && !defined(__ia64__)
769
770#endif  // GTEST_HAS_CLONE
771
772// Determines whether to support stream redirection. This is used to test
773// output correctness and to implement death tests.
774#ifndef GTEST_HAS_STREAM_REDIRECTION
775// By default, we assume that stream redirection is supported on all
776// platforms except known mobile ones.
777# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || \
778    GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
779#  define GTEST_HAS_STREAM_REDIRECTION 0
780# else
781#  define GTEST_HAS_STREAM_REDIRECTION 1
782# endif  // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN
783#endif  // GTEST_HAS_STREAM_REDIRECTION
784
785// Determines whether to support death tests.
786// Google Test does not support death tests for VC 7.1 and earlier as
787// abort() in a VC 7.1 application compiled as GUI in debug config
788// pops up a dialog window that cannot be suppressed programmatically.
789#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
790     (GTEST_OS_MAC && !GTEST_OS_IOS) || \
791     (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \
792     GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \
793     GTEST_OS_OPENBSD || GTEST_OS_QNX || GTEST_OS_FREEBSD)
794# define GTEST_HAS_DEATH_TEST 1
795#endif
796
797// We don't support MSVC 7.1 with exceptions disabled now.  Therefore
798// all the compilers we care about are adequate for supporting
799// value-parameterized tests.
800#define GTEST_HAS_PARAM_TEST 1
801
802// Determines whether to support type-driven tests.
803
804// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0,
805// Sun Pro CC, IBM Visual Age, and HP aCC support.
806#if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \
807    defined(__IBMCPP__) || defined(__HP_aCC)
808# define GTEST_HAS_TYPED_TEST 1
809# define GTEST_HAS_TYPED_TEST_P 1
810#endif
811
812// Determines whether to support Combine(). This only makes sense when
813// value-parameterized tests are enabled.  The implementation doesn't
814// work on Sun Studio since it doesn't understand templated conversion
815// operators.
816#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC)
817# define GTEST_HAS_COMBINE 1
818#endif
819
820// Determines whether the system compiler uses UTF-16 for encoding wide strings.
821#define GTEST_WIDE_STRING_USES_UTF16_ \
822    (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX)
823
824// Determines whether test results can be streamed to a socket.
825#if GTEST_OS_LINUX
826# define GTEST_CAN_STREAM_RESULTS_ 1
827#endif
828
829// Defines some utility macros.
830
831// The GNU compiler emits a warning if nested "if" statements are followed by
832// an "else" statement and braces are not used to explicitly disambiguate the
833// "else" binding.  This leads to problems with code like:
834//
835//   if (gate)
836//     ASSERT_*(condition) << "Some message";
837//
838// The "switch (0) case 0:" idiom is used to suppress this.
839#ifdef __INTEL_COMPILER
840# define GTEST_AMBIGUOUS_ELSE_BLOCKER_
841#else
842# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:  // NOLINT
843#endif
844
845// Use this annotation at the end of a struct/class definition to
846// prevent the compiler from optimizing away instances that are never
847// used.  This is useful when all interesting logic happens inside the
848// c'tor and / or d'tor.  Example:
849//
850//   struct Foo {
851//     Foo() { ... }
852//   } GTEST_ATTRIBUTE_UNUSED_;
853//
854// Also use it after a variable or parameter declaration to tell the
855// compiler the variable/parameter does not have to be used.
856#if defined(__GNUC__) && !defined(COMPILER_ICC)
857# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
858#elif defined(__clang__)
859# if __has_attribute(unused)
860#  define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
861# endif
862#endif
863#ifndef GTEST_ATTRIBUTE_UNUSED_
864# define GTEST_ATTRIBUTE_UNUSED_
865#endif
866
867// A macro to disallow operator=
868// This should be used in the private: declarations for a class.
869#define GTEST_DISALLOW_ASSIGN_(type)\
870  void operator=(type const &)
871
872// A macro to disallow copy constructor and operator=
873// This should be used in the private: declarations for a class.
874#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\
875  type(type const &);\
876  GTEST_DISALLOW_ASSIGN_(type)
877
878// Tell the compiler to warn about unused return values for functions declared
879// with this macro.  The macro should be used on function declarations
880// following the argument list:
881//
882//   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
883#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)
884# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
885#else
886# define GTEST_MUST_USE_RESULT_
887#endif  // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC
888
889// MS C++ compiler emits warning when a conditional expression is compile time
890// constant. In some contexts this warning is false positive and needs to be
891// suppressed. Use the following two macros in such cases:
892//
893// GTEST_INTENTIONAL_CONST_COND_PUSH_()
894// while (true) {
895// GTEST_INTENTIONAL_CONST_COND_POP_()
896// }
897# define GTEST_INTENTIONAL_CONST_COND_PUSH_() \
898    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)
899# define GTEST_INTENTIONAL_CONST_COND_POP_() \
900    GTEST_DISABLE_MSC_WARNINGS_POP_()
901
902// Determine whether the compiler supports Microsoft's Structured Exception
903// Handling.  This is supported by several Windows compilers but generally
904// does not exist on any other system.
905#ifndef GTEST_HAS_SEH
906// The user didn't tell us, so we need to figure it out.
907
908# if defined(_MSC_VER) || defined(__BORLANDC__)
909// These two compilers are known to support SEH.
910#  define GTEST_HAS_SEH 1
911# else
912// Assume no SEH.
913#  define GTEST_HAS_SEH 0
914# endif
915
916#define GTEST_IS_THREADSAFE \
917    (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ \
918     || (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) \
919     || GTEST_HAS_PTHREAD)
920
921#endif  // GTEST_HAS_SEH
922
923#ifdef _MSC_VER
924# if GTEST_LINKED_AS_SHARED_LIBRARY
925#  define GTEST_API_ __declspec(dllimport)
926# elif GTEST_CREATE_SHARED_LIBRARY
927#  define GTEST_API_ __declspec(dllexport)
928# endif
929#elif __GNUC__ >= 4 || defined(__clang__)
930# define GTEST_API_ __attribute__((visibility ("default")))
931#endif // _MSC_VER
932
933#ifndef GTEST_API_
934# define GTEST_API_
935#endif
936
937#ifdef __GNUC__
938// Ask the compiler to never inline a given function.
939# define GTEST_NO_INLINE_ __attribute__((noinline))
940#else
941# define GTEST_NO_INLINE_
942#endif
943
944// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
945#if defined(__GLIBCXX__) || defined(_LIBCPP_VERSION)
946# define GTEST_HAS_CXXABI_H_ 1
947#else
948# define GTEST_HAS_CXXABI_H_ 0
949#endif
950
951// A function level attribute to disable checking for use of uninitialized
952// memory when built with MemorySanitizer.
953#if defined(__clang__)
954# if __has_feature(memory_sanitizer)
955#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \
956       __attribute__((no_sanitize_memory))
957# else
958#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
959# endif  // __has_feature(memory_sanitizer)
960#else
961# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
962#endif  // __clang__
963
964// A function level attribute to disable AddressSanitizer instrumentation.
965#if defined(__clang__)
966# if __has_feature(address_sanitizer)
967#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \
968       __attribute__((no_sanitize_address))
969# else
970#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
971# endif  // __has_feature(address_sanitizer)
972#else
973# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
974#endif  // __clang__
975
976// A function level attribute to disable ThreadSanitizer instrumentation.
977#if defined(__clang__)
978# if __has_feature(thread_sanitizer)
979#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \
980       __attribute__((no_sanitize_thread))
981# else
982#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
983# endif  // __has_feature(thread_sanitizer)
984#else
985# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
986#endif  // __clang__
987
988namespace testing {
989
990class Message;
991
992#if defined(GTEST_TUPLE_NAMESPACE_)
993// Import tuple and friends into the ::testing namespace.
994// It is part of our interface, having them in ::testing allows us to change
995// their types as needed.
996using GTEST_TUPLE_NAMESPACE_::get;
997using GTEST_TUPLE_NAMESPACE_::make_tuple;
998using GTEST_TUPLE_NAMESPACE_::tuple;
999using GTEST_TUPLE_NAMESPACE_::tuple_size;
1000using GTEST_TUPLE_NAMESPACE_::tuple_element;
1001#endif  // defined(GTEST_TUPLE_NAMESPACE_)
1002
1003namespace internal {
1004
1005// A secret type that Google Test users don't know about.  It has no
1006// definition on purpose.  Therefore it's impossible to create a
1007// Secret object, which is what we want.
1008class Secret;
1009
1010// The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time
1011// expression is true. For example, you could use it to verify the
1012// size of a static array:
1013//
1014//   GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES,
1015//                         names_incorrect_size);
1016//
1017// or to make sure a struct is smaller than a certain size:
1018//
1019//   GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large);
1020//
1021// The second argument to the macro is the name of the variable. If
1022// the expression is false, most compilers will issue a warning/error
1023// containing the name of the variable.
1024
1025#if GTEST_LANG_CXX11
1026# define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
1027#else  // !GTEST_LANG_CXX11
1028template <bool>
1029  struct CompileAssert {
1030};
1031
1032# define GTEST_COMPILE_ASSERT_(expr, msg) \
1033  typedef ::testing::internal::CompileAssert<(static_cast<bool>(expr))> \
1034      msg[static_cast<bool>(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_
1035#endif  // !GTEST_LANG_CXX11
1036
1037// Implementation details of GTEST_COMPILE_ASSERT_:
1038//
1039// (In C++11, we simply use static_assert instead of the following)
1040//
1041// - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1
1042//   elements (and thus is invalid) when the expression is false.
1043//
1044// - The simpler definition
1045//
1046//    #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1]
1047//
1048//   does not work, as gcc supports variable-length arrays whose sizes
1049//   are determined at run-time (this is gcc's extension and not part
1050//   of the C++ standard).  As a result, gcc fails to reject the
1051//   following code with the simple definition:
1052//
1053//     int foo;
1054//     GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is
1055//                                      // not a compile-time constant.
1056//
1057// - By using the type CompileAssert<(bool(expr))>, we ensures that
1058//   expr is a compile-time constant.  (Template arguments must be
1059//   determined at compile-time.)
1060//
1061// - The outter parentheses in CompileAssert<(bool(expr))> are necessary
1062//   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
1063//
1064//     CompileAssert<bool(expr)>
1065//
1066//   instead, these compilers will refuse to compile
1067//
1068//     GTEST_COMPILE_ASSERT_(5 > 0, some_message);
1069//
1070//   (They seem to think the ">" in "5 > 0" marks the end of the
1071//   template argument list.)
1072//
1073// - The array size is (bool(expr) ? 1 : -1), instead of simply
1074//
1075//     ((expr) ? 1 : -1).
1076//
1077//   This is to avoid running into a bug in MS VC 7.1, which
1078//   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
1079
1080// StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h.
1081//
1082// This template is declared, but intentionally undefined.
1083template <typename T1, typename T2>
1084struct StaticAssertTypeEqHelper;
1085
1086template <typename T>
1087struct StaticAssertTypeEqHelper<T, T> {
1088  enum { value = true };
1089};
1090
1091// Evaluates to the number of elements in 'array'.
1092#define GTEST_ARRAY_SIZE_(array) (sizeof(array) / sizeof(array[0]))
1093
1094#if GTEST_HAS_GLOBAL_STRING
1095typedef ::string string;
1096#else
1097typedef ::std::string string;
1098#endif  // GTEST_HAS_GLOBAL_STRING
1099
1100#if GTEST_HAS_GLOBAL_WSTRING
1101typedef ::wstring wstring;
1102#elif GTEST_HAS_STD_WSTRING
1103typedef ::std::wstring wstring;
1104#endif  // GTEST_HAS_GLOBAL_WSTRING
1105
1106// A helper for suppressing warnings on constant condition.  It just
1107// returns 'condition'.
1108GTEST_API_ bool IsTrue(bool condition);
1109
1110// Defines scoped_ptr.
1111
1112// This implementation of scoped_ptr is PARTIAL - it only contains
1113// enough stuff to satisfy Google Test's need.
1114template <typename T>
1115class scoped_ptr {
1116 public:
1117  typedef T element_type;
1118
1119  explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
1120  ~scoped_ptr() { reset(); }
1121
1122  T& operator*() const { return *ptr_; }
1123  T* operator->() const { return ptr_; }
1124  T* get() const { return ptr_; }
1125
1126  T* release() {
1127    T* const ptr = ptr_;
1128    ptr_ = NULL;
1129    return ptr;
1130  }
1131
1132  void reset(T* p = NULL) {
1133    if (p != ptr_) {
1134      if (IsTrue(sizeof(T) > 0)) {  // Makes sure T is a complete type.
1135        delete ptr_;
1136      }
1137      ptr_ = p;
1138    }
1139  }
1140
1141  friend void swap(scoped_ptr& a, scoped_ptr& b) {
1142    using std::swap;
1143    swap(a.ptr_, b.ptr_);
1144  }
1145
1146 private:
1147  T* ptr_;
1148
1149  GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
1150};
1151
1152// Defines RE.
1153
1154// A simple C++ wrapper for <regex.h>.  It uses the POSIX Extended
1155// Regular Expression syntax.
1156class GTEST_API_ RE {
1157 public:
1158  // A copy constructor is required by the Standard to initialize object
1159  // references from r-values.
1160  RE(const RE& other) { Init(other.pattern()); }
1161
1162  // Constructs an RE from a string.
1163  RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT
1164
1165#if GTEST_HAS_GLOBAL_STRING
1166
1167  RE(const ::string& regex) { Init(regex.c_str()); }  // NOLINT
1168
1169#endif  // GTEST_HAS_GLOBAL_STRING
1170
1171  RE(const char* regex) { Init(regex); }  // NOLINT
1172  ~RE();
1173
1174  // Returns the string representation of the regex.
1175  const char* pattern() const { return pattern_; }
1176
1177  // FullMatch(str, re) returns true iff regular expression re matches
1178  // the entire str.
1179  // PartialMatch(str, re) returns true iff regular expression re
1180  // matches a substring of str (including str itself).
1181  //
1182  // TODO(wan@google.com): make FullMatch() and PartialMatch() work
1183  // when str contains NUL characters.
1184  static bool FullMatch(const ::std::string& str, const RE& re) {
1185    return FullMatch(str.c_str(), re);
1186  }
1187  static bool PartialMatch(const ::std::string& str, const RE& re) {
1188    return PartialMatch(str.c_str(), re);
1189  }
1190
1191#if GTEST_HAS_GLOBAL_STRING
1192
1193  static bool FullMatch(const ::string& str, const RE& re) {
1194    return FullMatch(str.c_str(), re);
1195  }
1196  static bool PartialMatch(const ::string& str, const RE& re) {
1197    return PartialMatch(str.c_str(), re);
1198  }
1199
1200#endif  // GTEST_HAS_GLOBAL_STRING
1201
1202  static bool FullMatch(const char* str, const RE& re);
1203  static bool PartialMatch(const char* str, const RE& re);
1204
1205 private:
1206  void Init(const char* regex);
1207
1208  // We use a const char* instead of an std::string, as Google Test used to be
1209  // used where std::string is not available.  TODO(wan@google.com): change to
1210  // std::string.
1211  const char* pattern_;
1212  bool is_valid_;
1213
1214#if GTEST_USES_POSIX_RE
1215
1216  regex_t full_regex_;     // For FullMatch().
1217  regex_t partial_regex_;  // For PartialMatch().
1218
1219#else  // GTEST_USES_SIMPLE_RE
1220
1221  const char* full_pattern_;  // For FullMatch();
1222
1223#endif
1224
1225  GTEST_DISALLOW_ASSIGN_(RE);
1226};
1227
1228// Formats a source file path and a line number as they would appear
1229// in an error message from the compiler used to compile this code.
1230GTEST_API_ ::std::string FormatFileLocation(const char* file, int line);
1231
1232// Formats a file location for compiler-independent XML output.
1233// Although this function is not platform dependent, we put it next to
1234// FormatFileLocation in order to contrast the two functions.
1235GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
1236                                                               int line);
1237
1238// Defines logging utilities:
1239//   GTEST_LOG_(severity) - logs messages at the specified severity level. The
1240//                          message itself is streamed into the macro.
1241//   LogToStderr()  - directs all log messages to stderr.
1242//   FlushInfoLog() - flushes informational log messages.
1243
1244enum GTestLogSeverity {
1245  GTEST_INFO,
1246  GTEST_WARNING,
1247  GTEST_ERROR,
1248  GTEST_FATAL
1249};
1250
1251// Formats log entry severity, provides a stream object for streaming the
1252// log message, and terminates the message with a newline when going out of
1253// scope.
1254class GTEST_API_ GTestLog {
1255 public:
1256  GTestLog(GTestLogSeverity severity, const char* file, int line);
1257
1258  // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
1259  ~GTestLog();
1260
1261  ::std::ostream& GetStream() { return ::std::cerr; }
1262
1263 private:
1264  const GTestLogSeverity severity_;
1265
1266  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
1267};
1268
1269#if !defined(GTEST_LOG_)
1270
1271# define GTEST_LOG_(severity) \
1272    ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
1273                                  __FILE__, __LINE__).GetStream()
1274
1275inline void LogToStderr() {}
1276inline void FlushInfoLog() { fflush(NULL); }
1277
1278#endif  // !defined(GTEST_LOG_)
1279
1280#if !defined(GTEST_CHECK_)
1281// INTERNAL IMPLEMENTATION - DO NOT USE.
1282//
1283// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
1284// is not satisfied.
1285//  Synopsys:
1286//    GTEST_CHECK_(boolean_condition);
1287//     or
1288//    GTEST_CHECK_(boolean_condition) << "Additional message";
1289//
1290//    This checks the condition and if the condition is not satisfied
1291//    it prints message about the condition violation, including the
1292//    condition itself, plus additional message streamed into it, if any,
1293//    and then it aborts the program. It aborts the program irrespective of
1294//    whether it is built in the debug mode or not.
1295# define GTEST_CHECK_(condition) \
1296    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1297    if (::testing::internal::IsTrue(condition)) \
1298      ; \
1299    else \
1300      GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
1301#endif  // !defined(GTEST_CHECK_)
1302
1303// An all-mode assert to verify that the given POSIX-style function
1304// call returns 0 (indicating success).  Known limitation: this
1305// doesn't expand to a balanced 'if' statement, so enclose the macro
1306// in {} if you need to use it as the only statement in an 'if'
1307// branch.
1308#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
1309  if (const int gtest_error = (posix_call)) \
1310    GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
1311                      << gtest_error
1312
1313#if GTEST_HAS_STD_MOVE_
1314using std::move;
1315#else  // GTEST_HAS_STD_MOVE_
1316template <typename T>
1317const T& move(const T& t) {
1318  return t;
1319}
1320#endif  // GTEST_HAS_STD_MOVE_
1321
1322// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
1323//
1324// Use ImplicitCast_ as a safe version of static_cast for upcasting in
1325// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a
1326// const Foo*).  When you use ImplicitCast_, the compiler checks that
1327// the cast is safe.  Such explicit ImplicitCast_s are necessary in
1328// surprisingly many situations where C++ demands an exact type match
1329// instead of an argument type convertable to a target type.
1330//
1331// The syntax for using ImplicitCast_ is the same as for static_cast:
1332//
1333//   ImplicitCast_<ToType>(expr)
1334//
1335// ImplicitCast_ would have been part of the C++ standard library,
1336// but the proposal was submitted too late.  It will probably make
1337// its way into the language in the future.
1338//
1339// This relatively ugly name is intentional. It prevents clashes with
1340// similar functions users may have (e.g., implicit_cast). The internal
1341// namespace alone is not enough because the function can be found by ADL.
1342template<typename To>
1343inline To ImplicitCast_(To x) { return x; }
1344
1345// When you upcast (that is, cast a pointer from type Foo to type
1346// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts
1347// always succeed.  When you downcast (that is, cast a pointer from
1348// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
1349// how do you know the pointer is really of type SubclassOfFoo?  It
1350// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
1351// when you downcast, you should use this macro.  In debug mode, we
1352// use dynamic_cast<> to double-check the downcast is legal (we die
1353// if it's not).  In normal mode, we do the efficient static_cast<>
1354// instead.  Thus, it's important to test in debug mode to make sure
1355// the cast is legal!
1356//    This is the only place in the code we should use dynamic_cast<>.
1357// In particular, you SHOULDN'T be using dynamic_cast<> in order to
1358// do RTTI (eg code like this:
1359//    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
1360//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
1361// You should design the code some other way not to need this.
1362//
1363// This relatively ugly name is intentional. It prevents clashes with
1364// similar functions users may have (e.g., down_cast). The internal
1365// namespace alone is not enough because the function can be found by ADL.
1366template<typename To, typename From>  // use like this: DownCast_<T*>(foo);
1367inline To DownCast_(From* f) {  // so we only accept pointers
1368  // Ensures that To is a sub-type of From *.  This test is here only
1369  // for compile-time type checking, and has no overhead in an
1370  // optimized build at run-time, as it will be optimized away
1371  // completely.
1372  GTEST_INTENTIONAL_CONST_COND_PUSH_()
1373  if (false) {
1374  GTEST_INTENTIONAL_CONST_COND_POP_()
1375    const To to = NULL;
1376    ::testing::internal::ImplicitCast_<From*>(to);
1377  }
1378
1379#if GTEST_HAS_RTTI
1380  // RTTI: debug mode only!
1381  GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL);
1382#endif
1383  return static_cast<To>(f);
1384}
1385
1386// Downcasts the pointer of type Base to Derived.
1387// Derived must be a subclass of Base. The parameter MUST
1388// point to a class of type Derived, not any subclass of it.
1389// When RTTI is available, the function performs a runtime
1390// check to enforce this.
1391template <class Derived, class Base>
1392Derived* CheckedDowncastToActualType(Base* base) {
1393#if GTEST_HAS_RTTI
1394  GTEST_CHECK_(typeid(*base) == typeid(Derived));
1395#endif
1396
1397#if GTEST_HAS_DOWNCAST_
1398  return ::down_cast<Derived*>(base);
1399#elif GTEST_HAS_RTTI
1400  return dynamic_cast<Derived*>(base);  // NOLINT
1401#else
1402  return static_cast<Derived*>(base);  // Poor man's downcast.
1403#endif
1404}
1405
1406#if GTEST_HAS_STREAM_REDIRECTION
1407
1408// Defines the stderr capturer:
1409//   CaptureStdout     - starts capturing stdout.
1410//   GetCapturedStdout - stops capturing stdout and returns the captured string.
1411//   CaptureStderr     - starts capturing stderr.
1412//   GetCapturedStderr - stops capturing stderr and returns the captured string.
1413//
1414GTEST_API_ void CaptureStdout();
1415GTEST_API_ std::string GetCapturedStdout();
1416GTEST_API_ void CaptureStderr();
1417GTEST_API_ std::string GetCapturedStderr();
1418
1419#endif  // GTEST_HAS_STREAM_REDIRECTION
1420
1421// Returns a path to temporary directory.
1422GTEST_API_ std::string TempDir();
1423
1424// Returns the size (in bytes) of a file.
1425GTEST_API_ size_t GetFileSize(FILE* file);
1426
1427// Reads the entire content of a file as a string.
1428GTEST_API_ std::string ReadEntireFile(FILE* file);
1429
1430// All command line arguments.
1431GTEST_API_ const ::std::vector<testing::internal::string>& GetArgvs();
1432
1433#if GTEST_HAS_DEATH_TEST
1434
1435const ::std::vector<testing::internal::string>& GetInjectableArgvs();
1436void SetInjectableArgvs(const ::std::vector<testing::internal::string>*
1437                             new_argvs);
1438
1439
1440#endif  // GTEST_HAS_DEATH_TEST
1441
1442// Defines synchronization primitives.
1443#if GTEST_IS_THREADSAFE
1444# if GTEST_HAS_PTHREAD
1445// Sleeps for (roughly) n milliseconds.  This function is only for testing
1446// Google Test's own constructs.  Don't use it in user tests, either
1447// directly or indirectly.
1448inline void SleepMilliseconds(int n) {
1449  const timespec time = {
1450    0,                  // 0 seconds.
1451    n * 1000L * 1000L,  // And n ms.
1452  };
1453  nanosleep(&time, NULL);
1454}
1455# endif  // GTEST_HAS_PTHREAD
1456
1457# if GTEST_HAS_NOTIFICATION_
1458// Notification has already been imported into the namespace.
1459// Nothing to do here.
1460
1461# elif GTEST_HAS_PTHREAD
1462// Allows a controller thread to pause execution of newly created
1463// threads until notified.  Instances of this class must be created
1464// and destroyed in the controller thread.
1465//
1466// This class is only for testing Google Test's own constructs. Do not
1467// use it in user tests, either directly or indirectly.
1468class Notification {
1469 public:
1470  Notification() : notified_(false) {
1471    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
1472  }
1473  ~Notification() {
1474    pthread_mutex_destroy(&mutex_);
1475  }
1476
1477  // Notifies all threads created with this notification to start. Must
1478  // be called from the controller thread.
1479  void Notify() {
1480    pthread_mutex_lock(&mutex_);
1481    notified_ = true;
1482    pthread_mutex_unlock(&mutex_);
1483  }
1484
1485  // Blocks until the controller thread notifies. Must be called from a test
1486  // thread.
1487  void WaitForNotification() {
1488    for (;;) {
1489      pthread_mutex_lock(&mutex_);
1490      const bool notified = notified_;
1491      pthread_mutex_unlock(&mutex_);
1492      if (notified)
1493        break;
1494      SleepMilliseconds(10);
1495    }
1496  }
1497
1498 private:
1499  pthread_mutex_t mutex_;
1500  bool notified_;
1501
1502  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
1503};
1504
1505# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
1506
1507GTEST_API_ void SleepMilliseconds(int n);
1508
1509// Provides leak-safe Windows kernel handle ownership.
1510// Used in death tests and in threading support.
1511class GTEST_API_ AutoHandle {
1512 public:
1513  // Assume that Win32 HANDLE type is equivalent to void*. Doing so allows us to
1514  // avoid including <windows.h> in this header file. Including <windows.h> is
1515  // undesirable because it defines a lot of symbols and macros that tend to
1516  // conflict with client code. This assumption is verified by
1517  // WindowsTypesTest.HANDLEIsVoidStar.
1518  typedef void* Handle;
1519  AutoHandle();
1520  explicit AutoHandle(Handle handle);
1521
1522  ~AutoHandle();
1523
1524  Handle Get() const;
1525  void Reset();
1526  void Reset(Handle handle);
1527
1528 private:
1529  // Returns true iff the handle is a valid handle object that can be closed.
1530  bool IsCloseable() const;
1531
1532  Handle handle_;
1533
1534  GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);
1535};
1536
1537// Allows a controller thread to pause execution of newly created
1538// threads until notified.  Instances of this class must be created
1539// and destroyed in the controller thread.
1540//
1541// This class is only for testing Google Test's own constructs. Do not
1542// use it in user tests, either directly or indirectly.
1543class GTEST_API_ Notification {
1544 public:
1545  Notification();
1546  void Notify();
1547  void WaitForNotification();
1548
1549 private:
1550  AutoHandle event_;
1551
1552  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
1553};
1554# endif  // GTEST_HAS_NOTIFICATION_
1555
1556// On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD
1557// defined, but we don't want to use MinGW's pthreads implementation, which
1558// has conformance problems with some versions of the POSIX standard.
1559# if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW
1560
1561// As a C-function, ThreadFuncWithCLinkage cannot be templated itself.
1562// Consequently, it cannot select a correct instantiation of ThreadWithParam
1563// in order to call its Run(). Introducing ThreadWithParamBase as a
1564// non-templated base class for ThreadWithParam allows us to bypass this
1565// problem.
1566class ThreadWithParamBase {
1567 public:
1568  virtual ~ThreadWithParamBase() {}
1569  virtual void Run() = 0;
1570};
1571
1572// pthread_create() accepts a pointer to a function type with the C linkage.
1573// According to the Standard (7.5/1), function types with different linkages
1574// are different even if they are otherwise identical.  Some compilers (for
1575// example, SunStudio) treat them as different types.  Since class methods
1576// cannot be defined with C-linkage we need to define a free C-function to
1577// pass into pthread_create().
1578extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
1579  static_cast<ThreadWithParamBase*>(thread)->Run();
1580  return NULL;
1581}
1582
1583// Helper class for testing Google Test's multi-threading constructs.
1584// To use it, write:
1585//
1586//   void ThreadFunc(int param) { /* Do things with param */ }
1587//   Notification thread_can_start;
1588//   ...
1589//   // The thread_can_start parameter is optional; you can supply NULL.
1590//   ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start);
1591//   thread_can_start.Notify();
1592//
1593// These classes are only for testing Google Test's own constructs. Do
1594// not use them in user tests, either directly or indirectly.
1595template <typename T>
1596class ThreadWithParam : public ThreadWithParamBase {
1597 public:
1598  typedef void UserThreadFunc(T);
1599
1600  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
1601      : func_(func),
1602        param_(param),
1603        thread_can_start_(thread_can_start),
1604        finished_(false) {
1605    ThreadWithParamBase* const base = this;
1606    // The thread can be created only after all fields except thread_
1607    // have been initialized.
1608    GTEST_CHECK_POSIX_SUCCESS_(
1609        pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base));
1610  }
1611  ~ThreadWithParam() { Join(); }
1612
1613  void Join() {
1614    if (!finished_) {
1615      GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0));
1616      finished_ = true;
1617    }
1618  }
1619
1620  virtual void Run() {
1621    if (thread_can_start_ != NULL)
1622      thread_can_start_->WaitForNotification();
1623    func_(param_);
1624  }
1625
1626 private:
1627  UserThreadFunc* const func_;  // User-supplied thread function.
1628  const T param_;  // User-supplied parameter to the thread function.
1629  // When non-NULL, used to block execution until the controller thread
1630  // notifies.
1631  Notification* const thread_can_start_;
1632  bool finished_;  // true iff we know that the thread function has finished.
1633  pthread_t thread_;  // The native thread object.
1634
1635  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
1636};
1637# endif  // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD ||
1638         // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
1639
1640# if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
1641// Mutex and ThreadLocal have already been imported into the namespace.
1642// Nothing to do here.
1643
1644# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
1645
1646// Mutex implements mutex on Windows platforms.  It is used in conjunction
1647// with class MutexLock:
1648//
1649//   Mutex mutex;
1650//   ...
1651//   MutexLock lock(&mutex);  // Acquires the mutex and releases it at the
1652//                            // end of the current scope.
1653//
1654// A static Mutex *must* be defined or declared using one of the following
1655// macros:
1656//   GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);
1657//   GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);
1658//
1659// (A non-static Mutex is defined/declared in the usual way).
1660class GTEST_API_ Mutex {
1661 public:
1662  enum MutexType { kStatic = 0, kDynamic = 1 };
1663  // We rely on kStaticMutex being 0 as it is to what the linker initializes
1664  // type_ in static mutexes.  critical_section_ will be initialized lazily
1665  // in ThreadSafeLazyInit().
1666  enum StaticConstructorSelector { kStaticMutex = 0 };
1667
1668  // This constructor intentionally does nothing.  It relies on type_ being
1669  // statically initialized to 0 (effectively setting it to kStatic) and on
1670  // ThreadSafeLazyInit() to lazily initialize the rest of the members.
1671  explicit Mutex(StaticConstructorSelector /*dummy*/) {}
1672
1673  Mutex();
1674  ~Mutex();
1675
1676  void Lock();
1677
1678  void Unlock();
1679
1680  // Does nothing if the current thread holds the mutex. Otherwise, crashes
1681  // with high probability.
1682  void AssertHeld();
1683
1684 private:
1685  // Initializes owner_thread_id_ and critical_section_ in static mutexes.
1686  void ThreadSafeLazyInit();
1687
1688  // Per http://blogs.msdn.com/b/oldnewthing/archive/2004/02/23/78395.aspx,
1689  // we assume that 0 is an invalid value for thread IDs.
1690  unsigned int owner_thread_id_;
1691
1692  // For static mutexes, we rely on these members being initialized to zeros
1693  // by the linker.
1694  MutexType type_;
1695  long critical_section_init_phase_;  // NOLINT
1696  _RTL_CRITICAL_SECTION* critical_section_;
1697
1698  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
1699};
1700
1701# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
1702    extern ::testing::internal::Mutex mutex
1703
1704# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
1705    ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex)
1706
1707// We cannot name this class MutexLock because the ctor declaration would
1708// conflict with a macro named MutexLock, which is defined on some
1709// platforms. That macro is used as a defensive measure to prevent against
1710// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
1711// "MutexLock l(&mu)".  Hence the typedef trick below.
1712class GTestMutexLock {
1713 public:
1714  explicit GTestMutexLock(Mutex* mutex)
1715      : mutex_(mutex) { mutex_->Lock(); }
1716
1717  ~GTestMutexLock() { mutex_->Unlock(); }
1718
1719 private:
1720  Mutex* const mutex_;
1721
1722  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
1723};
1724
1725typedef GTestMutexLock MutexLock;
1726
1727// Base class for ValueHolder<T>.  Allows a caller to hold and delete a value
1728// without knowing its type.
1729class ThreadLocalValueHolderBase {
1730 public:
1731  virtual ~ThreadLocalValueHolderBase() {}
1732};
1733
1734// Provides a way for a thread to send notifications to a ThreadLocal
1735// regardless of its parameter type.
1736class ThreadLocalBase {
1737 public:
1738  // Creates a new ValueHolder<T> object holding a default value passed to
1739  // this ThreadLocal<T>'s constructor and returns it.  It is the caller's
1740  // responsibility not to call this when the ThreadLocal<T> instance already
1741  // has a value on the current thread.
1742  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const = 0;
1743
1744 protected:
1745  ThreadLocalBase() {}
1746  virtual ~ThreadLocalBase() {}
1747
1748 private:
1749  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase);
1750};
1751
1752// Maps a thread to a set of ThreadLocals that have values instantiated on that
1753// thread and notifies them when the thread exits.  A ThreadLocal instance is
1754// expected to persist until all threads it has values on have terminated.
1755class GTEST_API_ ThreadLocalRegistry {
1756 public:
1757  // Registers thread_local_instance as having value on the current thread.
1758  // Returns a value that can be used to identify the thread from other threads.
1759  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
1760      const ThreadLocalBase* thread_local_instance);
1761
1762  // Invoked when a ThreadLocal instance is destroyed.
1763  static void OnThreadLocalDestroyed(
1764      const ThreadLocalBase* thread_local_instance);
1765};
1766
1767class GTEST_API_ ThreadWithParamBase {
1768 public:
1769  void Join();
1770
1771 protected:
1772  class Runnable {
1773   public:
1774    virtual ~Runnable() {}
1775    virtual void Run() = 0;
1776  };
1777
1778  ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start);
1779  virtual ~ThreadWithParamBase();
1780
1781 private:
1782  AutoHandle thread_;
1783};
1784
1785// Helper class for testing Google Test's multi-threading constructs.
1786template <typename T>
1787class ThreadWithParam : public ThreadWithParamBase {
1788 public:
1789  typedef void UserThreadFunc(T);
1790
1791  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
1792      : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {
1793  }
1794  virtual ~ThreadWithParam() {}
1795
1796 private:
1797  class RunnableImpl : public Runnable {
1798   public:
1799    RunnableImpl(UserThreadFunc* func, T param)
1800        : func_(func),
1801          param_(param) {
1802    }
1803    virtual ~RunnableImpl() {}
1804    virtual void Run() {
1805      func_(param_);
1806    }
1807
1808   private:
1809    UserThreadFunc* const func_;
1810    const T param_;
1811
1812    GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl);
1813  };
1814
1815  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
1816};
1817
1818// Implements thread-local storage on Windows systems.
1819//
1820//   // Thread 1
1821//   ThreadLocal<int> tl(100);  // 100 is the default value for each thread.
1822//
1823//   // Thread 2
1824//   tl.set(150);  // Changes the value for thread 2 only.
1825//   EXPECT_EQ(150, tl.get());
1826//
1827//   // Thread 1
1828//   EXPECT_EQ(100, tl.get());  // In thread 1, tl has the original value.
1829//   tl.set(200);
1830//   EXPECT_EQ(200, tl.get());
1831//
1832// The template type argument T must have a public copy constructor.
1833// In addition, the default ThreadLocal constructor requires T to have
1834// a public default constructor.
1835//
1836// The users of a TheadLocal instance have to make sure that all but one
1837// threads (including the main one) using that instance have exited before
1838// destroying it. Otherwise, the per-thread objects managed for them by the
1839// ThreadLocal instance are not guaranteed to be destroyed on all platforms.
1840//
1841// Google Test only uses global ThreadLocal objects.  That means they
1842// will die after main() has returned.  Therefore, no per-thread
1843// object managed by Google Test will be leaked as long as all threads
1844// using Google Test have exited when main() returns.
1845template <typename T>
1846class ThreadLocal : public ThreadLocalBase {
1847 public:
1848  ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {}
1849  explicit ThreadLocal(const T& value)
1850      : default_factory_(new InstanceValueHolderFactory(value)) {}
1851
1852  ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(this); }
1853
1854  T* pointer() { return GetOrCreateValue(); }
1855  const T* pointer() const { return GetOrCreateValue(); }
1856  const T& get() const { return *pointer(); }
1857  void set(const T& value) { *pointer() = value; }
1858
1859 private:
1860  // Holds a value of T.  Can be deleted via its base class without the caller
1861  // knowing the type of T.
1862  class ValueHolder : public ThreadLocalValueHolderBase {
1863   public:
1864    ValueHolder() : value_() {}
1865    explicit ValueHolder(const T& value) : value_(value) {}
1866
1867    T* pointer() { return &value_; }
1868
1869   private:
1870    T value_;
1871    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
1872  };
1873
1874
1875  T* GetOrCreateValue() const {
1876    return static_cast<ValueHolder*>(
1877        ThreadLocalRegistry::GetValueOnCurrentThread(this))->pointer();
1878  }
1879
1880  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const {
1881    return default_factory_->MakeNewHolder();
1882  }
1883
1884  class ValueHolderFactory {
1885   public:
1886    ValueHolderFactory() {}
1887    virtual ~ValueHolderFactory() {}
1888    virtual ValueHolder* MakeNewHolder() const = 0;
1889
1890   private:
1891    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
1892  };
1893
1894  class DefaultValueHolderFactory : public ValueHolderFactory {
1895   public:
1896    DefaultValueHolderFactory() {}
1897    virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); }
1898
1899   private:
1900    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
1901  };
1902
1903  class InstanceValueHolderFactory : public ValueHolderFactory {
1904   public:
1905    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
1906    virtual ValueHolder* MakeNewHolder() const {
1907      return new ValueHolder(value_);
1908    }
1909
1910   private:
1911    const T value_;  // The value for each thread.
1912
1913    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
1914  };
1915
1916  scoped_ptr<ValueHolderFactory> default_factory_;
1917
1918  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
1919};
1920
1921# elif GTEST_HAS_PTHREAD
1922
1923// MutexBase and Mutex implement mutex on pthreads-based platforms.
1924class MutexBase {
1925 public:
1926  // Acquires this mutex.
1927  void Lock() {
1928    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
1929    owner_ = pthread_self();
1930    has_owner_ = true;
1931  }
1932
1933  // Releases this mutex.
1934  void Unlock() {
1935    // Since the lock is being released the owner_ field should no longer be
1936    // considered valid. We don't protect writing to has_owner_ here, as it's
1937    // the caller's responsibility to ensure that the current thread holds the
1938    // mutex when this is called.
1939    has_owner_ = false;
1940    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
1941  }
1942
1943  // Does nothing if the current thread holds the mutex. Otherwise, crashes
1944  // with high probability.
1945  void AssertHeld() const {
1946    GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
1947        << "The current thread is not holding the mutex @" << this;
1948  }
1949
1950  // A static mutex may be used before main() is entered.  It may even
1951  // be used before the dynamic initialization stage.  Therefore we
1952  // must be able to initialize a static mutex object at link time.
1953  // This means MutexBase has to be a POD and its member variables
1954  // have to be public.
1955 public:
1956  pthread_mutex_t mutex_;  // The underlying pthread mutex.
1957  // has_owner_ indicates whether the owner_ field below contains a valid thread
1958  // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All
1959  // accesses to the owner_ field should be protected by a check of this field.
1960  // An alternative might be to memset() owner_ to all zeros, but there's no
1961  // guarantee that a zero'd pthread_t is necessarily invalid or even different
1962  // from pthread_self().
1963  bool has_owner_;
1964  pthread_t owner_;  // The thread holding the mutex.
1965};
1966
1967// Forward-declares a static mutex.
1968#  define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
1969     extern ::testing::internal::MutexBase mutex
1970
1971// Defines and statically (i.e. at link time) initializes a static mutex.
1972#  define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
1973     ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, false, pthread_t() }
1974
1975// The Mutex class can only be used for mutexes created at runtime. It
1976// shares its API with MutexBase otherwise.
1977class Mutex : public MutexBase {
1978 public:
1979  Mutex() {
1980    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
1981    has_owner_ = false;
1982  }
1983  ~Mutex() {
1984    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
1985  }
1986
1987 private:
1988  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
1989};
1990
1991// We cannot name this class MutexLock because the ctor declaration would
1992// conflict with a macro named MutexLock, which is defined on some
1993// platforms. That macro is used as a defensive measure to prevent against
1994// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
1995// "MutexLock l(&mu)".  Hence the typedef trick below.
1996class GTestMutexLock {
1997 public:
1998  explicit GTestMutexLock(MutexBase* mutex)
1999      : mutex_(mutex) { mutex_->Lock(); }
2000
2001  ~GTestMutexLock() { mutex_->Unlock(); }
2002
2003 private:
2004  MutexBase* const mutex_;
2005
2006  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
2007};
2008
2009typedef GTestMutexLock MutexLock;
2010
2011// Helpers for ThreadLocal.
2012
2013// pthread_key_create() requires DeleteThreadLocalValue() to have
2014// C-linkage.  Therefore it cannot be templatized to access
2015// ThreadLocal<T>.  Hence the need for class
2016// ThreadLocalValueHolderBase.
2017class ThreadLocalValueHolderBase {
2018 public:
2019  virtual ~ThreadLocalValueHolderBase() {}
2020};
2021
2022// Called by pthread to delete thread-local data stored by
2023// pthread_setspecific().
2024extern "C" inline void DeleteThreadLocalValue(void* value_holder) {
2025  delete static_cast<ThreadLocalValueHolderBase*>(value_holder);
2026}
2027
2028// Implements thread-local storage on pthreads-based systems.
2029template <typename T>
2030class ThreadLocal {
2031 public:
2032  ThreadLocal()
2033      : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
2034  explicit ThreadLocal(const T& value)
2035      : key_(CreateKey()),
2036        default_factory_(new InstanceValueHolderFactory(value)) {}
2037
2038  ~ThreadLocal() {
2039    // Destroys the managed object for the current thread, if any.
2040    DeleteThreadLocalValue(pthread_getspecific(key_));
2041
2042    // Releases resources associated with the key.  This will *not*
2043    // delete managed objects for other threads.
2044    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
2045  }
2046
2047  T* pointer() { return GetOrCreateValue(); }
2048  const T* pointer() const { return GetOrCreateValue(); }
2049  const T& get() const { return *pointer(); }
2050  void set(const T& value) { *pointer() = value; }
2051
2052 private:
2053  // Holds a value of type T.
2054  class ValueHolder : public ThreadLocalValueHolderBase {
2055   public:
2056    ValueHolder() : value_() {}
2057    explicit ValueHolder(const T& value) : value_(value) {}
2058
2059    T* pointer() { return &value_; }
2060
2061   private:
2062    T value_;
2063    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
2064  };
2065
2066  static pthread_key_t CreateKey() {
2067    pthread_key_t key;
2068    // When a thread exits, DeleteThreadLocalValue() will be called on
2069    // the object managed for that thread.
2070    GTEST_CHECK_POSIX_SUCCESS_(
2071        pthread_key_create(&key, &DeleteThreadLocalValue));
2072    return key;
2073  }
2074
2075  T* GetOrCreateValue() const {
2076    ThreadLocalValueHolderBase* const holder =
2077        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
2078    if (holder != NULL) {
2079      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
2080    }
2081
2082    ValueHolder* const new_holder = default_factory_->MakeNewHolder();
2083    ThreadLocalValueHolderBase* const holder_base = new_holder;
2084    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
2085    return new_holder->pointer();
2086  }
2087
2088  class ValueHolderFactory {
2089   public:
2090    ValueHolderFactory() {}
2091    virtual ~ValueHolderFactory() {}
2092    virtual ValueHolder* MakeNewHolder() const = 0;
2093
2094   private:
2095    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
2096  };
2097
2098  class DefaultValueHolderFactory : public ValueHolderFactory {
2099   public:
2100    DefaultValueHolderFactory() {}
2101    virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); }
2102
2103   private:
2104    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
2105  };
2106
2107  class InstanceValueHolderFactory : public ValueHolderFactory {
2108   public:
2109    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
2110    virtual ValueHolder* MakeNewHolder() const {
2111      return new ValueHolder(value_);
2112    }
2113
2114   private:
2115    const T value_;  // The value for each thread.
2116
2117    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
2118  };
2119
2120  // A key pthreads uses for looking up per-thread values.
2121  const pthread_key_t key_;
2122  scoped_ptr<ValueHolderFactory> default_factory_;
2123
2124  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
2125};
2126
2127# endif  // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
2128
2129#else  // GTEST_IS_THREADSAFE
2130
2131// A dummy implementation of synchronization primitives (mutex, lock,
2132// and thread-local variable).  Necessary for compiling Google Test where
2133// mutex is not supported - using Google Test in multiple threads is not
2134// supported on such platforms.
2135
2136class Mutex {
2137 public:
2138  Mutex() {}
2139  void Lock() {}
2140  void Unlock() {}
2141  void AssertHeld() const {}
2142};
2143
2144# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
2145  extern ::testing::internal::Mutex mutex
2146
2147# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
2148
2149// We cannot name this class MutexLock because the ctor declaration would
2150// conflict with a macro named MutexLock, which is defined on some
2151// platforms. That macro is used as a defensive measure to prevent against
2152// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
2153// "MutexLock l(&mu)".  Hence the typedef trick below.
2154class GTestMutexLock {
2155 public:
2156  explicit GTestMutexLock(Mutex*) {}  // NOLINT
2157};
2158
2159typedef GTestMutexLock MutexLock;
2160
2161template <typename T>
2162class ThreadLocal {
2163 public:
2164  ThreadLocal() : value_() {}
2165  explicit ThreadLocal(const T& value) : value_(value) {}
2166  T* pointer() { return &value_; }
2167  const T* pointer() const { return &value_; }
2168  const T& get() const { return value_; }
2169  void set(const T& value) { value_ = value; }
2170 private:
2171  T value_;
2172};
2173
2174#endif  // GTEST_IS_THREADSAFE
2175
2176// Returns the number of threads running in the process, or 0 to indicate that
2177// we cannot detect it.
2178GTEST_API_ size_t GetThreadCount();
2179
2180// Passing non-POD classes through ellipsis (...) crashes the ARM
2181// compiler and generates a warning in Sun Studio.  The Nokia Symbian
2182// and the IBM XL C/C++ compiler try to instantiate a copy constructor
2183// for objects passed through ellipsis (...), failing for uncopyable
2184// objects.  We define this to ensure that only POD is passed through
2185// ellipsis on these systems.
2186#if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC)
2187// We lose support for NULL detection where the compiler doesn't like
2188// passing non-POD classes through ellipsis (...).
2189# define GTEST_ELLIPSIS_NEEDS_POD_ 1
2190#else
2191# define GTEST_CAN_COMPARE_NULL 1
2192#endif
2193
2194// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between
2195// const T& and const T* in a function template.  These compilers
2196// _can_ decide between class template specializations for T and T*,
2197// so a tr1::type_traits-like is_pointer works.
2198#if defined(__SYMBIAN32__) || defined(__IBMCPP__)
2199# define GTEST_NEEDS_IS_POINTER_ 1
2200#endif
2201
2202template <bool bool_value>
2203struct bool_constant {
2204  typedef bool_constant<bool_value> type;
2205  static const bool value = bool_value;
2206};
2207template <bool bool_value> const bool bool_constant<bool_value>::value;
2208
2209typedef bool_constant<false> false_type;
2210typedef bool_constant<true> true_type;
2211
2212template <typename T>
2213struct is_pointer : public false_type {};
2214
2215template <typename T>
2216struct is_pointer<T*> : public true_type {};
2217
2218template <typename Iterator>
2219struct IteratorTraits {
2220  typedef typename Iterator::value_type value_type;
2221};
2222
2223template <typename T>
2224struct IteratorTraits<T*> {
2225  typedef T value_type;
2226};
2227
2228template <typename T>
2229struct IteratorTraits<const T*> {
2230  typedef T value_type;
2231};
2232
2233#if GTEST_OS_WINDOWS
2234# define GTEST_PATH_SEP_ "\\"
2235# define GTEST_HAS_ALT_PATH_SEP_ 1
2236// The biggest signed integer type the compiler supports.
2237typedef __int64 BiggestInt;
2238#else
2239# define GTEST_PATH_SEP_ "/"
2240# define GTEST_HAS_ALT_PATH_SEP_ 0
2241typedef long long BiggestInt;  // NOLINT
2242#endif  // GTEST_OS_WINDOWS
2243
2244// Utilities for char.
2245
2246// isspace(int ch) and friends accept an unsigned char or EOF.  char
2247// may be signed, depending on the compiler (or compiler flags).
2248// Therefore we need to cast a char to unsigned char before calling
2249// isspace(), etc.
2250
2251inline bool IsAlpha(char ch) {
2252  return isalpha(static_cast<unsigned char>(ch)) != 0;
2253}
2254inline bool IsAlNum(char ch) {
2255  return isalnum(static_cast<unsigned char>(ch)) != 0;
2256}
2257inline bool IsDigit(char ch) {
2258  return isdigit(static_cast<unsigned char>(ch)) != 0;
2259}
2260inline bool IsLower(char ch) {
2261  return islower(static_cast<unsigned char>(ch)) != 0;
2262}
2263inline bool IsSpace(char ch) {
2264  return isspace(static_cast<unsigned char>(ch)) != 0;
2265}
2266inline bool IsUpper(char ch) {
2267  return isupper(static_cast<unsigned char>(ch)) != 0;
2268}
2269inline bool IsXDigit(char ch) {
2270  return isxdigit(static_cast<unsigned char>(ch)) != 0;
2271}
2272inline bool IsXDigit(wchar_t ch) {
2273  const unsigned char low_byte = static_cast<unsigned char>(ch);
2274  return ch == low_byte && isxdigit(low_byte) != 0;
2275}
2276
2277inline char ToLower(char ch) {
2278  return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
2279}
2280inline char ToUpper(char ch) {
2281  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
2282}
2283
2284inline std::string StripTrailingSpaces(std::string str) {
2285  std::string::iterator it = str.end();
2286  while (it != str.begin() && IsSpace(*--it))
2287    it = str.erase(it);
2288  return str;
2289}
2290
2291// The testing::internal::posix namespace holds wrappers for common
2292// POSIX functions.  These wrappers hide the differences between
2293// Windows/MSVC and POSIX systems.  Since some compilers define these
2294// standard functions as macros, the wrapper cannot have the same name
2295// as the wrapped function.
2296
2297namespace posix {
2298
2299// Functions with a different name on Windows.
2300
2301#if GTEST_OS_WINDOWS
2302
2303typedef struct _stat StatStruct;
2304
2305# ifdef __BORLANDC__
2306inline int IsATTY(int fd) { return isatty(fd); }
2307inline int StrCaseCmp(const char* s1, const char* s2) {
2308  return stricmp(s1, s2);
2309}
2310inline char* StrDup(const char* src) { return strdup(src); }
2311# else  // !__BORLANDC__
2312#  if GTEST_OS_WINDOWS_MOBILE
2313inline int IsATTY(int /* fd */) { return 0; }
2314#  else
2315inline int IsATTY(int fd) { return _isatty(fd); }
2316#  endif  // GTEST_OS_WINDOWS_MOBILE
2317inline int StrCaseCmp(const char* s1, const char* s2) {
2318  return _stricmp(s1, s2);
2319}
2320inline char* StrDup(const char* src) { return _strdup(src); }
2321# endif  // __BORLANDC__
2322
2323# if GTEST_OS_WINDOWS_MOBILE
2324inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
2325// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
2326// time and thus not defined there.
2327# else
2328inline int FileNo(FILE* file) { return _fileno(file); }
2329inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
2330inline int RmDir(const char* dir) { return _rmdir(dir); }
2331inline bool IsDir(const StatStruct& st) {
2332  return (_S_IFDIR & st.st_mode) != 0;
2333}
2334# endif  // GTEST_OS_WINDOWS_MOBILE
2335
2336#else
2337
2338typedef struct stat StatStruct;
2339
2340inline int FileNo(FILE* file) { return fileno(file); }
2341inline int IsATTY(int fd) { return isatty(fd); }
2342inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
2343inline int StrCaseCmp(const char* s1, const char* s2) {
2344  return strcasecmp(s1, s2);
2345}
2346inline char* StrDup(const char* src) { return strdup(src); }
2347inline int RmDir(const char* dir) { return rmdir(dir); }
2348inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
2349
2350#endif  // GTEST_OS_WINDOWS
2351
2352// Functions deprecated by MSVC 8.0.
2353
2354GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996 /* deprecated function */)
2355
2356inline const char* StrNCpy(char* dest, const char* src, size_t n) {
2357  return strncpy(dest, src, n);
2358}
2359
2360// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and
2361// StrError() aren't needed on Windows CE at this time and thus not
2362// defined there.
2363
2364#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
2365inline int ChDir(const char* dir) { return chdir(dir); }
2366#endif
2367inline FILE* FOpen(const char* path, const char* mode) {
2368  return fopen(path, mode);
2369}
2370#if !GTEST_OS_WINDOWS_MOBILE
2371inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
2372  return freopen(path, mode, stream);
2373}
2374inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
2375#endif
2376inline int FClose(FILE* fp) { return fclose(fp); }
2377#if !GTEST_OS_WINDOWS_MOBILE
2378inline int Read(int fd, void* buf, unsigned int count) {
2379  return static_cast<int>(read(fd, buf, count));
2380}
2381inline int Write(int fd, const void* buf, unsigned int count) {
2382  return static_cast<int>(write(fd, buf, count));
2383}
2384inline int Close(int fd) { return close(fd); }
2385inline const char* StrError(int errnum) { return strerror(errnum); }
2386#endif
2387inline const char* GetEnv(const char* name) {
2388#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE | GTEST_OS_WINDOWS_RT
2389  // We are on Windows CE, which has no environment variables.
2390  static_cast<void>(name);  // To prevent 'unused argument' warning.
2391  return NULL;
2392#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
2393  // Environment variables which we programmatically clear will be set to the
2394  // empty string rather than unset (NULL).  Handle that case.
2395  const char* const env = getenv(name);
2396  return (env != NULL && env[0] != '\0') ? env : NULL;
2397#else
2398  return getenv(name);
2399#endif
2400}
2401
2402GTEST_DISABLE_MSC_WARNINGS_POP_()
2403
2404#if GTEST_OS_WINDOWS_MOBILE
2405// Windows CE has no C library. The abort() function is used in
2406// several places in Google Test. This implementation provides a reasonable
2407// imitation of standard behaviour.
2408void Abort();
2409#else
2410inline void Abort() { abort(); }
2411#endif  // GTEST_OS_WINDOWS_MOBILE
2412
2413}  // namespace posix
2414
2415// MSVC "deprecates" snprintf and issues warnings wherever it is used.  In
2416// order to avoid these warnings, we need to use _snprintf or _snprintf_s on
2417// MSVC-based platforms.  We map the GTEST_SNPRINTF_ macro to the appropriate
2418// function in order to achieve that.  We use macro definition here because
2419// snprintf is a variadic function.
2420#if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE
2421// MSVC 2005 and above support variadic macros.
2422# define GTEST_SNPRINTF_(buffer, size, format, ...) \
2423     _snprintf_s(buffer, size, size, format, __VA_ARGS__)
2424#elif defined(_MSC_VER)
2425// Windows CE does not define _snprintf_s and MSVC prior to 2005 doesn't
2426// complain about _snprintf.
2427# define GTEST_SNPRINTF_ _snprintf
2428#else
2429# define GTEST_SNPRINTF_ snprintf
2430#endif
2431
2432// The maximum number a BiggestInt can represent.  This definition
2433// works no matter BiggestInt is represented in one's complement or
2434// two's complement.
2435//
2436// We cannot rely on numeric_limits in STL, as __int64 and long long
2437// are not part of standard C++ and numeric_limits doesn't need to be
2438// defined for them.
2439const BiggestInt kMaxBiggestInt =
2440    ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1));
2441
2442// This template class serves as a compile-time function from size to
2443// type.  It maps a size in bytes to a primitive type with that
2444// size. e.g.
2445//
2446//   TypeWithSize<4>::UInt
2447//
2448// is typedef-ed to be unsigned int (unsigned integer made up of 4
2449// bytes).
2450//
2451// Such functionality should belong to STL, but I cannot find it
2452// there.
2453//
2454// Google Test uses this class in the implementation of floating-point
2455// comparison.
2456//
2457// For now it only handles UInt (unsigned int) as that's all Google Test
2458// needs.  Other types can be easily added in the future if need
2459// arises.
2460template <size_t size>
2461class TypeWithSize {
2462 public:
2463  // This prevents the user from using TypeWithSize<N> with incorrect
2464  // values of N.
2465  typedef void UInt;
2466};
2467
2468// The specialization for size 4.
2469template <>
2470class TypeWithSize<4> {
2471 public:
2472  // unsigned int has size 4 in both gcc and MSVC.
2473  //
2474  // As base/basictypes.h doesn't compile on Windows, we cannot use
2475  // uint32, uint64, and etc here.
2476  typedef int Int;
2477  typedef unsigned int UInt;
2478};
2479
2480// The specialization for size 8.
2481template <>
2482class TypeWithSize<8> {
2483 public:
2484#if GTEST_OS_WINDOWS
2485  typedef __int64 Int;
2486  typedef unsigned __int64 UInt;
2487#else
2488  typedef long long Int;  // NOLINT
2489  typedef unsigned long long UInt;  // NOLINT
2490#endif  // GTEST_OS_WINDOWS
2491};
2492
2493// Integer types of known sizes.
2494typedef TypeWithSize<4>::Int Int32;
2495typedef TypeWithSize<4>::UInt UInt32;
2496typedef TypeWithSize<8>::Int Int64;
2497typedef TypeWithSize<8>::UInt UInt64;
2498typedef TypeWithSize<8>::Int TimeInMillis;  // Represents time in milliseconds.
2499
2500// Utilities for command line flags and environment variables.
2501
2502// Macro for referencing flags.
2503#if !defined(GTEST_FLAG)
2504# define GTEST_FLAG(name) FLAGS_gtest_##name
2505#endif  // !defined(GTEST_FLAG)
2506
2507#if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
2508# define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
2509#endif  // !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
2510
2511#if !defined(GTEST_DECLARE_bool_)
2512# define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
2513
2514// Macros for declaring flags.
2515# define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
2516# define GTEST_DECLARE_int32_(name) \
2517    GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name)
2518#define GTEST_DECLARE_string_(name) \
2519    GTEST_API_ extern ::std::string GTEST_FLAG(name)
2520
2521// Macros for defining flags.
2522#define GTEST_DEFINE_bool_(name, default_val, doc) \
2523    GTEST_API_ bool GTEST_FLAG(name) = (default_val)
2524#define GTEST_DEFINE_int32_(name, default_val, doc) \
2525    GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
2526#define GTEST_DEFINE_string_(name, default_val, doc) \
2527    GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)
2528
2529#endif  // !defined(GTEST_DECLARE_bool_)
2530
2531// Thread annotations
2532#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
2533# define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
2534# define GTEST_LOCK_EXCLUDED_(locks)
2535#endif  // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
2536
2537// Parses 'str' for a 32-bit signed integer.  If successful, writes the result
2538// to *value and returns true; otherwise leaves *value unchanged and returns
2539// false.
2540// TODO(chandlerc): Find a better way to refactor flag and environment parsing
2541// out of both gtest-port.cc and gtest.cc to avoid exporting this utility
2542// function.
2543bool ParseInt32(const Message& src_text, const char* str, Int32* value);
2544
2545// Parses a bool/Int32/string from the environment variable
2546// corresponding to the given Google Test flag.
2547bool BoolFromGTestEnv(const char* flag, bool default_val);
2548GTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val);
2549std::string StringFromGTestEnv(const char* flag, const char* default_val);
2550
2551}  // namespace internal
2552}  // namespace testing
2553
2554#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
2555