113481Sgiacomo.travaglini@arm.com// Copyright 2005, Google Inc.
213481Sgiacomo.travaglini@arm.com// All rights reserved.
313481Sgiacomo.travaglini@arm.com//
413481Sgiacomo.travaglini@arm.com// Redistribution and use in source and binary forms, with or without
513481Sgiacomo.travaglini@arm.com// modification, are permitted provided that the following conditions are
613481Sgiacomo.travaglini@arm.com// met:
713481Sgiacomo.travaglini@arm.com//
813481Sgiacomo.travaglini@arm.com//     * Redistributions of source code must retain the above copyright
913481Sgiacomo.travaglini@arm.com// notice, this list of conditions and the following disclaimer.
1013481Sgiacomo.travaglini@arm.com//     * Redistributions in binary form must reproduce the above
1113481Sgiacomo.travaglini@arm.com// copyright notice, this list of conditions and the following disclaimer
1213481Sgiacomo.travaglini@arm.com// in the documentation and/or other materials provided with the
1313481Sgiacomo.travaglini@arm.com// distribution.
1413481Sgiacomo.travaglini@arm.com//     * Neither the name of Google Inc. nor the names of its
1513481Sgiacomo.travaglini@arm.com// contributors may be used to endorse or promote products derived from
1613481Sgiacomo.travaglini@arm.com// this software without specific prior written permission.
1713481Sgiacomo.travaglini@arm.com//
1813481Sgiacomo.travaglini@arm.com// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
1913481Sgiacomo.travaglini@arm.com// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
2013481Sgiacomo.travaglini@arm.com// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
2113481Sgiacomo.travaglini@arm.com// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
2213481Sgiacomo.travaglini@arm.com// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
2313481Sgiacomo.travaglini@arm.com// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
2413481Sgiacomo.travaglini@arm.com// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
2513481Sgiacomo.travaglini@arm.com// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
2613481Sgiacomo.travaglini@arm.com// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
2713481Sgiacomo.travaglini@arm.com// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
2813481Sgiacomo.travaglini@arm.com// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2913481Sgiacomo.travaglini@arm.com//
3013481Sgiacomo.travaglini@arm.com// Authors: wan@google.com (Zhanyong Wan)
3113481Sgiacomo.travaglini@arm.com//
3213481Sgiacomo.travaglini@arm.com// Low-level types and utilities for porting Google Test to various
3313481Sgiacomo.travaglini@arm.com// platforms.  All macros ending with _ and symbols defined in an
3413481Sgiacomo.travaglini@arm.com// internal namespace are subject to change without notice.  Code
3513481Sgiacomo.travaglini@arm.com// outside Google Test MUST NOT USE THEM DIRECTLY.  Macros that don't
3613481Sgiacomo.travaglini@arm.com// end with _ are part of Google Test's public API and can be used by
3713481Sgiacomo.travaglini@arm.com// code outside Google Test.
3813481Sgiacomo.travaglini@arm.com//
3913481Sgiacomo.travaglini@arm.com// This file is fundamental to Google Test.  All other Google Test source
4013481Sgiacomo.travaglini@arm.com// files are expected to #include this.  Therefore, it cannot #include
4113481Sgiacomo.travaglini@arm.com// any other Google Test header.
4213481Sgiacomo.travaglini@arm.com
4313481Sgiacomo.travaglini@arm.com#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
4413481Sgiacomo.travaglini@arm.com#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
4513481Sgiacomo.travaglini@arm.com
4613481Sgiacomo.travaglini@arm.com// Environment-describing macros
4713481Sgiacomo.travaglini@arm.com// -----------------------------
4813481Sgiacomo.travaglini@arm.com//
4913481Sgiacomo.travaglini@arm.com// Google Test can be used in many different environments.  Macros in
5013481Sgiacomo.travaglini@arm.com// this section tell Google Test what kind of environment it is being
5113481Sgiacomo.travaglini@arm.com// used in, such that Google Test can provide environment-specific
5213481Sgiacomo.travaglini@arm.com// features and implementations.
5313481Sgiacomo.travaglini@arm.com//
5413481Sgiacomo.travaglini@arm.com// Google Test tries to automatically detect the properties of its
5513481Sgiacomo.travaglini@arm.com// environment, so users usually don't need to worry about these
5613481Sgiacomo.travaglini@arm.com// macros.  However, the automatic detection is not perfect.
5713481Sgiacomo.travaglini@arm.com// Sometimes it's necessary for a user to define some of the following
5813481Sgiacomo.travaglini@arm.com// macros in the build script to override Google Test's decisions.
5913481Sgiacomo.travaglini@arm.com//
6013481Sgiacomo.travaglini@arm.com// If the user doesn't define a macro in the list, Google Test will
6113481Sgiacomo.travaglini@arm.com// provide a default definition.  After this header is #included, all
6213481Sgiacomo.travaglini@arm.com// macros in this list will be defined to either 1 or 0.
6313481Sgiacomo.travaglini@arm.com//
6413481Sgiacomo.travaglini@arm.com// Notes to maintainers:
6513481Sgiacomo.travaglini@arm.com//   - Each macro here is a user-tweakable knob; do not grow the list
6613481Sgiacomo.travaglini@arm.com//     lightly.
6713481Sgiacomo.travaglini@arm.com//   - Use #if to key off these macros.  Don't use #ifdef or "#if
6813481Sgiacomo.travaglini@arm.com//     defined(...)", which will not work as these macros are ALWAYS
6913481Sgiacomo.travaglini@arm.com//     defined.
7013481Sgiacomo.travaglini@arm.com//
7113481Sgiacomo.travaglini@arm.com//   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)
7213481Sgiacomo.travaglini@arm.com//                              is/isn't available.
7313481Sgiacomo.travaglini@arm.com//   GTEST_HAS_EXCEPTIONS     - Define it to 1/0 to indicate that exceptions
7413481Sgiacomo.travaglini@arm.com//                              are enabled.
7513481Sgiacomo.travaglini@arm.com//   GTEST_HAS_GLOBAL_STRING  - Define it to 1/0 to indicate that ::string
7613481Sgiacomo.travaglini@arm.com//                              is/isn't available (some systems define
7713481Sgiacomo.travaglini@arm.com//                              ::string, which is different to std::string).
7813481Sgiacomo.travaglini@arm.com//   GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string
7913481Sgiacomo.travaglini@arm.com//                              is/isn't available (some systems define
8013481Sgiacomo.travaglini@arm.com//                              ::wstring, which is different to std::wstring).
8113481Sgiacomo.travaglini@arm.com//   GTEST_HAS_POSIX_RE       - Define it to 1/0 to indicate that POSIX regular
8213481Sgiacomo.travaglini@arm.com//                              expressions are/aren't available.
8313481Sgiacomo.travaglini@arm.com//   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>
8413481Sgiacomo.travaglini@arm.com//                              is/isn't available.
8513481Sgiacomo.travaglini@arm.com//   GTEST_HAS_RTTI           - Define it to 1/0 to indicate that RTTI is/isn't
8613481Sgiacomo.travaglini@arm.com//                              enabled.
8713481Sgiacomo.travaglini@arm.com//   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that
8813481Sgiacomo.travaglini@arm.com//                              std::wstring does/doesn't work (Google Test can
8913481Sgiacomo.travaglini@arm.com//                              be used where std::wstring is unavailable).
9013481Sgiacomo.travaglini@arm.com//   GTEST_HAS_TR1_TUPLE      - Define it to 1/0 to indicate tr1::tuple
9113481Sgiacomo.travaglini@arm.com//                              is/isn't available.
9213481Sgiacomo.travaglini@arm.com//   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the
9313481Sgiacomo.travaglini@arm.com//                              compiler supports Microsoft's "Structured
9413481Sgiacomo.travaglini@arm.com//                              Exception Handling".
9513481Sgiacomo.travaglini@arm.com//   GTEST_HAS_STREAM_REDIRECTION
9613481Sgiacomo.travaglini@arm.com//                            - Define it to 1/0 to indicate whether the
9713481Sgiacomo.travaglini@arm.com//                              platform supports I/O stream redirection using
9813481Sgiacomo.travaglini@arm.com//                              dup() and dup2().
9913481Sgiacomo.travaglini@arm.com//   GTEST_USE_OWN_TR1_TUPLE  - Define it to 1/0 to indicate whether Google
10013481Sgiacomo.travaglini@arm.com//                              Test's own tr1 tuple implementation should be
10113481Sgiacomo.travaglini@arm.com//                              used.  Unused when the user sets
10213481Sgiacomo.travaglini@arm.com//                              GTEST_HAS_TR1_TUPLE to 0.
10313481Sgiacomo.travaglini@arm.com//   GTEST_LANG_CXX11         - Define it to 1/0 to indicate that Google Test
10413481Sgiacomo.travaglini@arm.com//                              is building in C++11/C++98 mode.
10513481Sgiacomo.travaglini@arm.com//   GTEST_LINKED_AS_SHARED_LIBRARY
10613481Sgiacomo.travaglini@arm.com//                            - Define to 1 when compiling tests that use
10713481Sgiacomo.travaglini@arm.com//                              Google Test as a shared library (known as
10813481Sgiacomo.travaglini@arm.com//                              DLL on Windows).
10913481Sgiacomo.travaglini@arm.com//   GTEST_CREATE_SHARED_LIBRARY
11013481Sgiacomo.travaglini@arm.com//                            - Define to 1 when compiling Google Test itself
11113481Sgiacomo.travaglini@arm.com//                              as a shared library.
11213481Sgiacomo.travaglini@arm.com
11313481Sgiacomo.travaglini@arm.com// Platform-indicating macros
11413481Sgiacomo.travaglini@arm.com// --------------------------
11513481Sgiacomo.travaglini@arm.com//
11613481Sgiacomo.travaglini@arm.com// Macros indicating the platform on which Google Test is being used
11713481Sgiacomo.travaglini@arm.com// (a macro is defined to 1 if compiled on the given platform;
11813481Sgiacomo.travaglini@arm.com// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
11913481Sgiacomo.travaglini@arm.com// defines these macros automatically.  Code outside Google Test MUST
12013481Sgiacomo.travaglini@arm.com// NOT define them.
12113481Sgiacomo.travaglini@arm.com//
12213481Sgiacomo.travaglini@arm.com//   GTEST_OS_AIX      - IBM AIX
12313481Sgiacomo.travaglini@arm.com//   GTEST_OS_CYGWIN   - Cygwin
12413481Sgiacomo.travaglini@arm.com//   GTEST_OS_FREEBSD  - FreeBSD
12513481Sgiacomo.travaglini@arm.com//   GTEST_OS_HPUX     - HP-UX
12613481Sgiacomo.travaglini@arm.com//   GTEST_OS_LINUX    - Linux
12713481Sgiacomo.travaglini@arm.com//     GTEST_OS_LINUX_ANDROID - Google Android
12813481Sgiacomo.travaglini@arm.com//   GTEST_OS_MAC      - Mac OS X
12913481Sgiacomo.travaglini@arm.com//     GTEST_OS_IOS    - iOS
13013481Sgiacomo.travaglini@arm.com//   GTEST_OS_NACL     - Google Native Client (NaCl)
13113481Sgiacomo.travaglini@arm.com//   GTEST_OS_OPENBSD  - OpenBSD
13213481Sgiacomo.travaglini@arm.com//   GTEST_OS_QNX      - QNX
13313481Sgiacomo.travaglini@arm.com//   GTEST_OS_SOLARIS  - Sun Solaris
13413481Sgiacomo.travaglini@arm.com//   GTEST_OS_SYMBIAN  - Symbian
13513481Sgiacomo.travaglini@arm.com//   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
13613481Sgiacomo.travaglini@arm.com//     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop
13713481Sgiacomo.travaglini@arm.com//     GTEST_OS_WINDOWS_MINGW    - MinGW
13813481Sgiacomo.travaglini@arm.com//     GTEST_OS_WINDOWS_MOBILE   - Windows Mobile
13913481Sgiacomo.travaglini@arm.com//     GTEST_OS_WINDOWS_PHONE    - Windows Phone
14013481Sgiacomo.travaglini@arm.com//     GTEST_OS_WINDOWS_RT       - Windows Store App/WinRT
14113481Sgiacomo.travaglini@arm.com//   GTEST_OS_ZOS      - z/OS
14213481Sgiacomo.travaglini@arm.com//
14313481Sgiacomo.travaglini@arm.com// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the
14413481Sgiacomo.travaglini@arm.com// most stable support.  Since core members of the Google Test project
14513481Sgiacomo.travaglini@arm.com// don't have access to other platforms, support for them may be less
14613481Sgiacomo.travaglini@arm.com// stable.  If you notice any problems on your platform, please notify
14713481Sgiacomo.travaglini@arm.com// googletestframework@googlegroups.com (patches for fixing them are
14813481Sgiacomo.travaglini@arm.com// even more welcome!).
14913481Sgiacomo.travaglini@arm.com//
15013481Sgiacomo.travaglini@arm.com// It is possible that none of the GTEST_OS_* macros are defined.
15113481Sgiacomo.travaglini@arm.com
15213481Sgiacomo.travaglini@arm.com// Feature-indicating macros
15313481Sgiacomo.travaglini@arm.com// -------------------------
15413481Sgiacomo.travaglini@arm.com//
15513481Sgiacomo.travaglini@arm.com// Macros indicating which Google Test features are available (a macro
15613481Sgiacomo.travaglini@arm.com// is defined to 1 if the corresponding feature is supported;
15713481Sgiacomo.travaglini@arm.com// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
15813481Sgiacomo.travaglini@arm.com// defines these macros automatically.  Code outside Google Test MUST
15913481Sgiacomo.travaglini@arm.com// NOT define them.
16013481Sgiacomo.travaglini@arm.com//
16113481Sgiacomo.travaglini@arm.com// These macros are public so that portable tests can be written.
16213481Sgiacomo.travaglini@arm.com// Such tests typically surround code using a feature with an #if
16313481Sgiacomo.travaglini@arm.com// which controls that code.  For example:
16413481Sgiacomo.travaglini@arm.com//
16513481Sgiacomo.travaglini@arm.com// #if GTEST_HAS_DEATH_TEST
16613481Sgiacomo.travaglini@arm.com//   EXPECT_DEATH(DoSomethingDeadly());
16713481Sgiacomo.travaglini@arm.com// #endif
16813481Sgiacomo.travaglini@arm.com//
16913481Sgiacomo.travaglini@arm.com//   GTEST_HAS_COMBINE      - the Combine() function (for value-parameterized
17013481Sgiacomo.travaglini@arm.com//                            tests)
17113481Sgiacomo.travaglini@arm.com//   GTEST_HAS_DEATH_TEST   - death tests
17213481Sgiacomo.travaglini@arm.com//   GTEST_HAS_PARAM_TEST   - value-parameterized tests
17313481Sgiacomo.travaglini@arm.com//   GTEST_HAS_TYPED_TEST   - typed tests
17413481Sgiacomo.travaglini@arm.com//   GTEST_HAS_TYPED_TEST_P - type-parameterized tests
17513481Sgiacomo.travaglini@arm.com//   GTEST_IS_THREADSAFE    - Google Test is thread-safe.
17613481Sgiacomo.travaglini@arm.com//   GTEST_USES_POSIX_RE    - enhanced POSIX regex is used. Do not confuse with
17713481Sgiacomo.travaglini@arm.com//                            GTEST_HAS_POSIX_RE (see above) which users can
17813481Sgiacomo.travaglini@arm.com//                            define themselves.
17913481Sgiacomo.travaglini@arm.com//   GTEST_USES_SIMPLE_RE   - our own simple regex is used;
18013481Sgiacomo.travaglini@arm.com//                            the above two are mutually exclusive.
18113481Sgiacomo.travaglini@arm.com//   GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ().
18213481Sgiacomo.travaglini@arm.com
18313481Sgiacomo.travaglini@arm.com// Misc public macros
18413481Sgiacomo.travaglini@arm.com// ------------------
18513481Sgiacomo.travaglini@arm.com//
18613481Sgiacomo.travaglini@arm.com//   GTEST_FLAG(flag_name)  - references the variable corresponding to
18713481Sgiacomo.travaglini@arm.com//                            the given Google Test flag.
18813481Sgiacomo.travaglini@arm.com
18913481Sgiacomo.travaglini@arm.com// Internal utilities
19013481Sgiacomo.travaglini@arm.com// ------------------
19113481Sgiacomo.travaglini@arm.com//
19213481Sgiacomo.travaglini@arm.com// The following macros and utilities are for Google Test's INTERNAL
19313481Sgiacomo.travaglini@arm.com// use only.  Code outside Google Test MUST NOT USE THEM DIRECTLY.
19413481Sgiacomo.travaglini@arm.com//
19513481Sgiacomo.travaglini@arm.com// Macros for basic C++ coding:
19613481Sgiacomo.travaglini@arm.com//   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
19713481Sgiacomo.travaglini@arm.com//   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a
19813481Sgiacomo.travaglini@arm.com//                              variable don't have to be used.
19913481Sgiacomo.travaglini@arm.com//   GTEST_DISALLOW_ASSIGN_   - disables operator=.
20013481Sgiacomo.travaglini@arm.com//   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
20113481Sgiacomo.travaglini@arm.com//   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
20213481Sgiacomo.travaglini@arm.com//   GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is
20313481Sgiacomo.travaglini@arm.com//                                        suppressed (constant conditional).
20413481Sgiacomo.travaglini@arm.com//   GTEST_INTENTIONAL_CONST_COND_POP_  - finish code section where MSVC C4127
20513481Sgiacomo.travaglini@arm.com//                                        is suppressed.
20613481Sgiacomo.travaglini@arm.com//
20713481Sgiacomo.travaglini@arm.com// C++11 feature wrappers:
20813481Sgiacomo.travaglini@arm.com//
20913481Sgiacomo.travaglini@arm.com//   testing::internal::move  - portability wrapper for std::move.
21013481Sgiacomo.travaglini@arm.com//
21113481Sgiacomo.travaglini@arm.com// Synchronization:
21213481Sgiacomo.travaglini@arm.com//   Mutex, MutexLock, ThreadLocal, GetThreadCount()
21313481Sgiacomo.travaglini@arm.com//                            - synchronization primitives.
21413481Sgiacomo.travaglini@arm.com//
21513481Sgiacomo.travaglini@arm.com// Template meta programming:
21613481Sgiacomo.travaglini@arm.com//   is_pointer     - as in TR1; needed on Symbian and IBM XL C/C++ only.
21713481Sgiacomo.travaglini@arm.com//   IteratorTraits - partial implementation of std::iterator_traits, which
21813481Sgiacomo.travaglini@arm.com//                    is not available in libCstd when compiled with Sun C++.
21913481Sgiacomo.travaglini@arm.com//
22013481Sgiacomo.travaglini@arm.com// Smart pointers:
22113481Sgiacomo.travaglini@arm.com//   scoped_ptr     - as in TR2.
22213481Sgiacomo.travaglini@arm.com//
22313481Sgiacomo.travaglini@arm.com// Regular expressions:
22413481Sgiacomo.travaglini@arm.com//   RE             - a simple regular expression class using the POSIX
22513481Sgiacomo.travaglini@arm.com//                    Extended Regular Expression syntax on UNIX-like
22613481Sgiacomo.travaglini@arm.com//                    platforms, or a reduced regular exception syntax on
22713481Sgiacomo.travaglini@arm.com//                    other platforms, including Windows.
22813481Sgiacomo.travaglini@arm.com//
22913481Sgiacomo.travaglini@arm.com// Logging:
23013481Sgiacomo.travaglini@arm.com//   GTEST_LOG_()   - logs messages at the specified severity level.
23113481Sgiacomo.travaglini@arm.com//   LogToStderr()  - directs all log messages to stderr.
23213481Sgiacomo.travaglini@arm.com//   FlushInfoLog() - flushes informational log messages.
23313481Sgiacomo.travaglini@arm.com//
23413481Sgiacomo.travaglini@arm.com// Stdout and stderr capturing:
23513481Sgiacomo.travaglini@arm.com//   CaptureStdout()     - starts capturing stdout.
23613481Sgiacomo.travaglini@arm.com//   GetCapturedStdout() - stops capturing stdout and returns the captured
23713481Sgiacomo.travaglini@arm.com//                         string.
23813481Sgiacomo.travaglini@arm.com//   CaptureStderr()     - starts capturing stderr.
23913481Sgiacomo.travaglini@arm.com//   GetCapturedStderr() - stops capturing stderr and returns the captured
24013481Sgiacomo.travaglini@arm.com//                         string.
24113481Sgiacomo.travaglini@arm.com//
24213481Sgiacomo.travaglini@arm.com// Integer types:
24313481Sgiacomo.travaglini@arm.com//   TypeWithSize   - maps an integer to a int type.
24413481Sgiacomo.travaglini@arm.com//   Int32, UInt32, Int64, UInt64, TimeInMillis
24513481Sgiacomo.travaglini@arm.com//                  - integers of known sizes.
24613481Sgiacomo.travaglini@arm.com//   BiggestInt     - the biggest signed integer type.
24713481Sgiacomo.travaglini@arm.com//
24813481Sgiacomo.travaglini@arm.com// Command-line utilities:
24913481Sgiacomo.travaglini@arm.com//   GTEST_DECLARE_*()  - declares a flag.
25013481Sgiacomo.travaglini@arm.com//   GTEST_DEFINE_*()   - defines a flag.
25113481Sgiacomo.travaglini@arm.com//   GetInjectableArgvs() - returns the command line as a vector of strings.
25213481Sgiacomo.travaglini@arm.com//
25313481Sgiacomo.travaglini@arm.com// Environment variable utilities:
25413481Sgiacomo.travaglini@arm.com//   GetEnv()             - gets the value of an environment variable.
25513481Sgiacomo.travaglini@arm.com//   BoolFromGTestEnv()   - parses a bool environment variable.
25613481Sgiacomo.travaglini@arm.com//   Int32FromGTestEnv()  - parses an Int32 environment variable.
25713481Sgiacomo.travaglini@arm.com//   StringFromGTestEnv() - parses a string environment variable.
25813481Sgiacomo.travaglini@arm.com
25913481Sgiacomo.travaglini@arm.com#include <ctype.h>   // for isspace, etc
26013481Sgiacomo.travaglini@arm.com#include <stddef.h>  // for ptrdiff_t
26113481Sgiacomo.travaglini@arm.com#include <stdlib.h>
26213481Sgiacomo.travaglini@arm.com#include <stdio.h>
26313481Sgiacomo.travaglini@arm.com#include <string.h>
26413481Sgiacomo.travaglini@arm.com#ifndef _WIN32_WCE
26513481Sgiacomo.travaglini@arm.com# include <sys/types.h>
26613481Sgiacomo.travaglini@arm.com# include <sys/stat.h>
26713481Sgiacomo.travaglini@arm.com#endif  // !_WIN32_WCE
26813481Sgiacomo.travaglini@arm.com
26913481Sgiacomo.travaglini@arm.com#if defined __APPLE__
27013481Sgiacomo.travaglini@arm.com# include <AvailabilityMacros.h>
27113481Sgiacomo.travaglini@arm.com# include <TargetConditionals.h>
27213481Sgiacomo.travaglini@arm.com#endif
27313481Sgiacomo.travaglini@arm.com
27413481Sgiacomo.travaglini@arm.com#include <algorithm>  // NOLINT
27513481Sgiacomo.travaglini@arm.com#include <iostream>  // NOLINT
27613481Sgiacomo.travaglini@arm.com#include <sstream>  // NOLINT
27713481Sgiacomo.travaglini@arm.com#include <string>  // NOLINT
27813481Sgiacomo.travaglini@arm.com#include <utility>
27913481Sgiacomo.travaglini@arm.com#include <vector>  // NOLINT
28013481Sgiacomo.travaglini@arm.com
28113481Sgiacomo.travaglini@arm.com#include "gtest/internal/gtest-port-arch.h"
28213481Sgiacomo.travaglini@arm.com#include "gtest/internal/custom/gtest-port.h"
28313481Sgiacomo.travaglini@arm.com
28413481Sgiacomo.travaglini@arm.com#if !defined(GTEST_DEV_EMAIL_)
28513481Sgiacomo.travaglini@arm.com# define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
28613481Sgiacomo.travaglini@arm.com# define GTEST_FLAG_PREFIX_ "gtest_"
28713481Sgiacomo.travaglini@arm.com# define GTEST_FLAG_PREFIX_DASH_ "gtest-"
28813481Sgiacomo.travaglini@arm.com# define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
28913481Sgiacomo.travaglini@arm.com# define GTEST_NAME_ "Google Test"
29013481Sgiacomo.travaglini@arm.com# define GTEST_PROJECT_URL_ "https://github.com/google/googletest/"
29113481Sgiacomo.travaglini@arm.com#endif  // !defined(GTEST_DEV_EMAIL_)
29213481Sgiacomo.travaglini@arm.com
29313481Sgiacomo.travaglini@arm.com#if !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
29413481Sgiacomo.travaglini@arm.com# define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest"
29513481Sgiacomo.travaglini@arm.com#endif  // !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
29613481Sgiacomo.travaglini@arm.com
29713481Sgiacomo.travaglini@arm.com// Determines the version of gcc that is used to compile this.
29813481Sgiacomo.travaglini@arm.com#ifdef __GNUC__
29913481Sgiacomo.travaglini@arm.com// 40302 means version 4.3.2.
30013481Sgiacomo.travaglini@arm.com# define GTEST_GCC_VER_ \
30113481Sgiacomo.travaglini@arm.com    (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
30213481Sgiacomo.travaglini@arm.com#endif  // __GNUC__
30313481Sgiacomo.travaglini@arm.com
30413481Sgiacomo.travaglini@arm.com// Macros for disabling Microsoft Visual C++ warnings.
30513481Sgiacomo.travaglini@arm.com//
30613481Sgiacomo.travaglini@arm.com//   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385)
30713481Sgiacomo.travaglini@arm.com//   /* code that triggers warnings C4800 and C4385 */
30813481Sgiacomo.travaglini@arm.com//   GTEST_DISABLE_MSC_WARNINGS_POP_()
30913481Sgiacomo.travaglini@arm.com#if _MSC_VER >= 1500
31013481Sgiacomo.travaglini@arm.com# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
31113481Sgiacomo.travaglini@arm.com    __pragma(warning(push))                        \
31213481Sgiacomo.travaglini@arm.com    __pragma(warning(disable: warnings))
31313481Sgiacomo.travaglini@arm.com# define GTEST_DISABLE_MSC_WARNINGS_POP_()          \
31413481Sgiacomo.travaglini@arm.com    __pragma(warning(pop))
31513481Sgiacomo.travaglini@arm.com#else
31613481Sgiacomo.travaglini@arm.com// Older versions of MSVC don't have __pragma.
31713481Sgiacomo.travaglini@arm.com# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
31813481Sgiacomo.travaglini@arm.com# define GTEST_DISABLE_MSC_WARNINGS_POP_()
31913481Sgiacomo.travaglini@arm.com#endif
32013481Sgiacomo.travaglini@arm.com
32113481Sgiacomo.travaglini@arm.com#ifndef GTEST_LANG_CXX11
32213481Sgiacomo.travaglini@arm.com// gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when
32313481Sgiacomo.travaglini@arm.com// -std={c,gnu}++{0x,11} is passed.  The C++11 standard specifies a
32413481Sgiacomo.travaglini@arm.com// value for __cplusplus, and recent versions of clang, gcc, and
32513481Sgiacomo.travaglini@arm.com// probably other compilers set that too in C++11 mode.
32613481Sgiacomo.travaglini@arm.com# if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L
32713481Sgiacomo.travaglini@arm.com// Compiling in at least C++11 mode.
32813481Sgiacomo.travaglini@arm.com#  define GTEST_LANG_CXX11 1
32913481Sgiacomo.travaglini@arm.com# else
33013481Sgiacomo.travaglini@arm.com#  define GTEST_LANG_CXX11 0
33113481Sgiacomo.travaglini@arm.com# endif
33213481Sgiacomo.travaglini@arm.com#endif
33313481Sgiacomo.travaglini@arm.com
33413481Sgiacomo.travaglini@arm.com// Distinct from C++11 language support, some environments don't provide
33513481Sgiacomo.travaglini@arm.com// proper C++11 library support. Notably, it's possible to build in
33613481Sgiacomo.travaglini@arm.com// C++11 mode when targeting Mac OS X 10.6, which has an old libstdc++
33713481Sgiacomo.travaglini@arm.com// with no C++11 support.
33813481Sgiacomo.travaglini@arm.com//
33913481Sgiacomo.travaglini@arm.com// libstdc++ has sufficient C++11 support as of GCC 4.6.0, __GLIBCXX__
34013481Sgiacomo.travaglini@arm.com// 20110325, but maintenance releases in the 4.4 and 4.5 series followed
34113481Sgiacomo.travaglini@arm.com// this date, so check for those versions by their date stamps.
34213481Sgiacomo.travaglini@arm.com// https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html#abi.versioning
34313481Sgiacomo.travaglini@arm.com#if GTEST_LANG_CXX11 && \
34413481Sgiacomo.travaglini@arm.com    (!defined(__GLIBCXX__) || ( \
34513481Sgiacomo.travaglini@arm.com        __GLIBCXX__ >= 20110325ul &&  /* GCC >= 4.6.0 */ \
34613481Sgiacomo.travaglini@arm.com        /* Blacklist of patch releases of older branches: */ \
34713481Sgiacomo.travaglini@arm.com        __GLIBCXX__ != 20110416ul &&  /* GCC 4.4.6 */ \
34813481Sgiacomo.travaglini@arm.com        __GLIBCXX__ != 20120313ul &&  /* GCC 4.4.7 */ \
34913481Sgiacomo.travaglini@arm.com        __GLIBCXX__ != 20110428ul &&  /* GCC 4.5.3 */ \
35013481Sgiacomo.travaglini@arm.com        __GLIBCXX__ != 20120702ul))   /* GCC 4.5.4 */
35113481Sgiacomo.travaglini@arm.com# define GTEST_STDLIB_CXX11 1
35213481Sgiacomo.travaglini@arm.com#endif
35313481Sgiacomo.travaglini@arm.com
35413481Sgiacomo.travaglini@arm.com// Only use C++11 library features if the library provides them.
35513481Sgiacomo.travaglini@arm.com#if GTEST_STDLIB_CXX11
35613481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_BEGIN_AND_END_ 1
35713481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_FORWARD_LIST_ 1
35813481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_FUNCTION_ 1
35913481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_INITIALIZER_LIST_ 1
36013481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_MOVE_ 1
36113481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_SHARED_PTR_ 1
36213481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_TYPE_TRAITS_ 1
36313481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_UNIQUE_PTR_ 1
36413481Sgiacomo.travaglini@arm.com#endif
36513481Sgiacomo.travaglini@arm.com
36613481Sgiacomo.travaglini@arm.com// C++11 specifies that <tuple> provides std::tuple.
36713481Sgiacomo.travaglini@arm.com// Some platforms still might not have it, however.
36813481Sgiacomo.travaglini@arm.com#if GTEST_LANG_CXX11
36913481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_TUPLE_ 1
37013481Sgiacomo.travaglini@arm.com# if defined(__clang__)
37113481Sgiacomo.travaglini@arm.com// Inspired by http://clang.llvm.org/docs/LanguageExtensions.html#__has_include
37213481Sgiacomo.travaglini@arm.com#  if defined(__has_include) && !__has_include(<tuple>)
37313481Sgiacomo.travaglini@arm.com#   undef GTEST_HAS_STD_TUPLE_
37413481Sgiacomo.travaglini@arm.com#  endif
37513481Sgiacomo.travaglini@arm.com# elif defined(_MSC_VER)
37613481Sgiacomo.travaglini@arm.com// Inspired by boost/config/stdlib/dinkumware.hpp
37713481Sgiacomo.travaglini@arm.com#  if defined(_CPPLIB_VER) && _CPPLIB_VER < 520
37813481Sgiacomo.travaglini@arm.com#   undef GTEST_HAS_STD_TUPLE_
37913481Sgiacomo.travaglini@arm.com#  endif
38013481Sgiacomo.travaglini@arm.com# elif defined(__GLIBCXX__)
38113481Sgiacomo.travaglini@arm.com// Inspired by boost/config/stdlib/libstdcpp3.hpp,
38213481Sgiacomo.travaglini@arm.com// http://gcc.gnu.org/gcc-4.2/changes.html and
38313481Sgiacomo.travaglini@arm.com// http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt01ch01.html#manual.intro.status.standard.200x
38413481Sgiacomo.travaglini@arm.com#  if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2)
38513481Sgiacomo.travaglini@arm.com#   undef GTEST_HAS_STD_TUPLE_
38613481Sgiacomo.travaglini@arm.com#  endif
38713481Sgiacomo.travaglini@arm.com# endif
38813481Sgiacomo.travaglini@arm.com#endif
38913481Sgiacomo.travaglini@arm.com
39013481Sgiacomo.travaglini@arm.com// Brings in definitions for functions used in the testing::internal::posix
39113481Sgiacomo.travaglini@arm.com// namespace (read, write, close, chdir, isatty, stat). We do not currently
39213481Sgiacomo.travaglini@arm.com// use them on Windows Mobile.
39313481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS
39413481Sgiacomo.travaglini@arm.com# if !GTEST_OS_WINDOWS_MOBILE
39513481Sgiacomo.travaglini@arm.com#  include <direct.h>
39613481Sgiacomo.travaglini@arm.com#  include <io.h>
39713481Sgiacomo.travaglini@arm.com# endif
39813481Sgiacomo.travaglini@arm.com// In order to avoid having to include <windows.h>, use forward declaration
39913481Sgiacomo.travaglini@arm.com// assuming CRITICAL_SECTION is a typedef of _RTL_CRITICAL_SECTION.
40013481Sgiacomo.travaglini@arm.com// This assumption is verified by
40113481Sgiacomo.travaglini@arm.com// WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION.
40213481Sgiacomo.travaglini@arm.comstruct _RTL_CRITICAL_SECTION;
40313481Sgiacomo.travaglini@arm.com#else
40413481Sgiacomo.travaglini@arm.com// This assumes that non-Windows OSes provide unistd.h. For OSes where this
40513481Sgiacomo.travaglini@arm.com// is not the case, we need to include headers that provide the functions
40613481Sgiacomo.travaglini@arm.com// mentioned above.
40713481Sgiacomo.travaglini@arm.com# include <unistd.h>
40813481Sgiacomo.travaglini@arm.com# include <strings.h>
40913481Sgiacomo.travaglini@arm.com#endif  // GTEST_OS_WINDOWS
41013481Sgiacomo.travaglini@arm.com
41113481Sgiacomo.travaglini@arm.com#if GTEST_OS_LINUX_ANDROID
41213481Sgiacomo.travaglini@arm.com// Used to define __ANDROID_API__ matching the target NDK API level.
41313481Sgiacomo.travaglini@arm.com#  include <android/api-level.h>  // NOLINT
41413481Sgiacomo.travaglini@arm.com#endif
41513481Sgiacomo.travaglini@arm.com
41613481Sgiacomo.travaglini@arm.com// Defines this to true iff Google Test can use POSIX regular expressions.
41713481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_POSIX_RE
41813481Sgiacomo.travaglini@arm.com# if GTEST_OS_LINUX_ANDROID
41913481Sgiacomo.travaglini@arm.com// On Android, <regex.h> is only available starting with Gingerbread.
42013481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
42113481Sgiacomo.travaglini@arm.com# else
42213481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS)
42313481Sgiacomo.travaglini@arm.com# endif
42413481Sgiacomo.travaglini@arm.com#endif
42513481Sgiacomo.travaglini@arm.com
42613481Sgiacomo.travaglini@arm.com#if GTEST_USES_PCRE
42713481Sgiacomo.travaglini@arm.com// The appropriate headers have already been included.
42813481Sgiacomo.travaglini@arm.com
42913481Sgiacomo.travaglini@arm.com#elif GTEST_HAS_POSIX_RE
43013481Sgiacomo.travaglini@arm.com
43113481Sgiacomo.travaglini@arm.com// On some platforms, <regex.h> needs someone to define size_t, and
43213481Sgiacomo.travaglini@arm.com// won't compile otherwise.  We can #include it here as we already
43313481Sgiacomo.travaglini@arm.com// included <stdlib.h>, which is guaranteed to define size_t through
43413481Sgiacomo.travaglini@arm.com// <stddef.h>.
43513481Sgiacomo.travaglini@arm.com# include <regex.h>  // NOLINT
43613481Sgiacomo.travaglini@arm.com
43713481Sgiacomo.travaglini@arm.com# define GTEST_USES_POSIX_RE 1
43813481Sgiacomo.travaglini@arm.com
43913481Sgiacomo.travaglini@arm.com#elif GTEST_OS_WINDOWS
44013481Sgiacomo.travaglini@arm.com
44113481Sgiacomo.travaglini@arm.com// <regex.h> is not available on Windows.  Use our own simple regex
44213481Sgiacomo.travaglini@arm.com// implementation instead.
44313481Sgiacomo.travaglini@arm.com# define GTEST_USES_SIMPLE_RE 1
44413481Sgiacomo.travaglini@arm.com
44513481Sgiacomo.travaglini@arm.com#else
44613481Sgiacomo.travaglini@arm.com
44713481Sgiacomo.travaglini@arm.com// <regex.h> may not be available on this platform.  Use our own
44813481Sgiacomo.travaglini@arm.com// simple regex implementation instead.
44913481Sgiacomo.travaglini@arm.com# define GTEST_USES_SIMPLE_RE 1
45013481Sgiacomo.travaglini@arm.com
45113481Sgiacomo.travaglini@arm.com#endif  // GTEST_USES_PCRE
45213481Sgiacomo.travaglini@arm.com
45313481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_EXCEPTIONS
45413481Sgiacomo.travaglini@arm.com// The user didn't tell us whether exceptions are enabled, so we need
45513481Sgiacomo.travaglini@arm.com// to figure it out.
45613481Sgiacomo.travaglini@arm.com# if defined(_MSC_VER) || defined(__BORLANDC__)
45713481Sgiacomo.travaglini@arm.com// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS
45813481Sgiacomo.travaglini@arm.com// macro to enable exceptions, so we'll do the same.
45913481Sgiacomo.travaglini@arm.com// Assumes that exceptions are enabled by default.
46013481Sgiacomo.travaglini@arm.com#  ifndef _HAS_EXCEPTIONS
46113481Sgiacomo.travaglini@arm.com#   define _HAS_EXCEPTIONS 1
46213481Sgiacomo.travaglini@arm.com#  endif  // _HAS_EXCEPTIONS
46313481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
46413481Sgiacomo.travaglini@arm.com# elif defined(__clang__)
46513481Sgiacomo.travaglini@arm.com// clang defines __EXCEPTIONS iff exceptions are enabled before clang 220714,
46613481Sgiacomo.travaglini@arm.com// but iff cleanups are enabled after that. In Obj-C++ files, there can be
46713481Sgiacomo.travaglini@arm.com// cleanups for ObjC exceptions which also need cleanups, even if C++ exceptions
46813481Sgiacomo.travaglini@arm.com// are disabled. clang has __has_feature(cxx_exceptions) which checks for C++
46913481Sgiacomo.travaglini@arm.com// exceptions starting at clang r206352, but which checked for cleanups prior to
47013481Sgiacomo.travaglini@arm.com// that. To reliably check for C++ exception availability with clang, check for
47113481Sgiacomo.travaglini@arm.com// __EXCEPTIONS && __has_feature(cxx_exceptions).
47213481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions))
47313481Sgiacomo.travaglini@arm.com# elif defined(__GNUC__) && __EXCEPTIONS
47413481Sgiacomo.travaglini@arm.com// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled.
47513481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_EXCEPTIONS 1
47613481Sgiacomo.travaglini@arm.com# elif defined(__SUNPRO_CC)
47713481Sgiacomo.travaglini@arm.com// Sun Pro CC supports exceptions.  However, there is no compile-time way of
47813481Sgiacomo.travaglini@arm.com// detecting whether they are enabled or not.  Therefore, we assume that
47913481Sgiacomo.travaglini@arm.com// they are enabled unless the user tells us otherwise.
48013481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_EXCEPTIONS 1
48113481Sgiacomo.travaglini@arm.com# elif defined(__IBMCPP__) && __EXCEPTIONS
48213481Sgiacomo.travaglini@arm.com// xlC defines __EXCEPTIONS to 1 iff exceptions are enabled.
48313481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_EXCEPTIONS 1
48413481Sgiacomo.travaglini@arm.com# elif defined(__HP_aCC)
48513481Sgiacomo.travaglini@arm.com// Exception handling is in effect by default in HP aCC compiler. It has to
48613481Sgiacomo.travaglini@arm.com// be turned of by +noeh compiler option if desired.
48713481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_EXCEPTIONS 1
48813481Sgiacomo.travaglini@arm.com# else
48913481Sgiacomo.travaglini@arm.com// For other compilers, we assume exceptions are disabled to be
49013481Sgiacomo.travaglini@arm.com// conservative.
49113481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_EXCEPTIONS 0
49213481Sgiacomo.travaglini@arm.com# endif  // defined(_MSC_VER) || defined(__BORLANDC__)
49313481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_EXCEPTIONS
49413481Sgiacomo.travaglini@arm.com
49513481Sgiacomo.travaglini@arm.com#if !defined(GTEST_HAS_STD_STRING)
49613481Sgiacomo.travaglini@arm.com// Even though we don't use this macro any longer, we keep it in case
49713481Sgiacomo.travaglini@arm.com// some clients still depend on it.
49813481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_STRING 1
49913481Sgiacomo.travaglini@arm.com#elif !GTEST_HAS_STD_STRING
50013481Sgiacomo.travaglini@arm.com// The user told us that ::std::string isn't available.
50113481Sgiacomo.travaglini@arm.com# error "Google Test cannot be used where ::std::string isn't available."
50213481Sgiacomo.travaglini@arm.com#endif  // !defined(GTEST_HAS_STD_STRING)
50313481Sgiacomo.travaglini@arm.com
50413481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_GLOBAL_STRING
50513481Sgiacomo.travaglini@arm.com// The user didn't tell us whether ::string is available, so we need
50613481Sgiacomo.travaglini@arm.com// to figure it out.
50713481Sgiacomo.travaglini@arm.com
50813481Sgiacomo.travaglini@arm.com# define GTEST_HAS_GLOBAL_STRING 0
50913481Sgiacomo.travaglini@arm.com
51013481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_GLOBAL_STRING
51113481Sgiacomo.travaglini@arm.com
51213481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_STD_WSTRING
51313481Sgiacomo.travaglini@arm.com// The user didn't tell us whether ::std::wstring is available, so we need
51413481Sgiacomo.travaglini@arm.com// to figure it out.
51513481Sgiacomo.travaglini@arm.com// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring
51613481Sgiacomo.travaglini@arm.com//   is available.
51713481Sgiacomo.travaglini@arm.com
51813481Sgiacomo.travaglini@arm.com// Cygwin 1.7 and below doesn't support ::std::wstring.
51913481Sgiacomo.travaglini@arm.com// Solaris' libc++ doesn't support it either.  Android has
52013481Sgiacomo.travaglini@arm.com// no support for it at least as recent as Froyo (2.2).
52113481Sgiacomo.travaglini@arm.com# define GTEST_HAS_STD_WSTRING \
52213481Sgiacomo.travaglini@arm.com    (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS))
52313481Sgiacomo.travaglini@arm.com
52413481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_STD_WSTRING
52513481Sgiacomo.travaglini@arm.com
52613481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_GLOBAL_WSTRING
52713481Sgiacomo.travaglini@arm.com// The user didn't tell us whether ::wstring is available, so we need
52813481Sgiacomo.travaglini@arm.com// to figure it out.
52913481Sgiacomo.travaglini@arm.com# define GTEST_HAS_GLOBAL_WSTRING \
53013481Sgiacomo.travaglini@arm.com    (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)
53113481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_GLOBAL_WSTRING
53213481Sgiacomo.travaglini@arm.com
53313481Sgiacomo.travaglini@arm.com// Determines whether RTTI is available.
53413481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_RTTI
53513481Sgiacomo.travaglini@arm.com// The user didn't tell us whether RTTI is enabled, so we need to
53613481Sgiacomo.travaglini@arm.com// figure it out.
53713481Sgiacomo.travaglini@arm.com
53813481Sgiacomo.travaglini@arm.com# ifdef _MSC_VER
53913481Sgiacomo.travaglini@arm.com
54013481Sgiacomo.travaglini@arm.com#  ifdef _CPPRTTI  // MSVC defines this macro iff RTTI is enabled.
54113481Sgiacomo.travaglini@arm.com#   define GTEST_HAS_RTTI 1
54213481Sgiacomo.travaglini@arm.com#  else
54313481Sgiacomo.travaglini@arm.com#   define GTEST_HAS_RTTI 0
54413481Sgiacomo.travaglini@arm.com#  endif
54513481Sgiacomo.travaglini@arm.com
54613481Sgiacomo.travaglini@arm.com// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled.
54713481Sgiacomo.travaglini@arm.com# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302)
54813481Sgiacomo.travaglini@arm.com
54913481Sgiacomo.travaglini@arm.com#  ifdef __GXX_RTTI
55013481Sgiacomo.travaglini@arm.com// When building against STLport with the Android NDK and with
55113481Sgiacomo.travaglini@arm.com// -frtti -fno-exceptions, the build fails at link time with undefined
55213481Sgiacomo.travaglini@arm.com// references to __cxa_bad_typeid. Note sure if STL or toolchain bug,
55313481Sgiacomo.travaglini@arm.com// so disable RTTI when detected.
55413481Sgiacomo.travaglini@arm.com#   if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
55513481Sgiacomo.travaglini@arm.com       !defined(__EXCEPTIONS)
55613481Sgiacomo.travaglini@arm.com#    define GTEST_HAS_RTTI 0
55713481Sgiacomo.travaglini@arm.com#   else
55813481Sgiacomo.travaglini@arm.com#    define GTEST_HAS_RTTI 1
55913481Sgiacomo.travaglini@arm.com#   endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS
56013481Sgiacomo.travaglini@arm.com#  else
56113481Sgiacomo.travaglini@arm.com#   define GTEST_HAS_RTTI 0
56213481Sgiacomo.travaglini@arm.com#  endif  // __GXX_RTTI
56313481Sgiacomo.travaglini@arm.com
56413481Sgiacomo.travaglini@arm.com// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends
56513481Sgiacomo.travaglini@arm.com// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the
56613481Sgiacomo.travaglini@arm.com// first version with C++ support.
56713481Sgiacomo.travaglini@arm.com# elif defined(__clang__)
56813481Sgiacomo.travaglini@arm.com
56913481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_RTTI __has_feature(cxx_rtti)
57013481Sgiacomo.travaglini@arm.com
57113481Sgiacomo.travaglini@arm.com// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
57213481Sgiacomo.travaglini@arm.com// both the typeid and dynamic_cast features are present.
57313481Sgiacomo.travaglini@arm.com# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
57413481Sgiacomo.travaglini@arm.com
57513481Sgiacomo.travaglini@arm.com#  ifdef __RTTI_ALL__
57613481Sgiacomo.travaglini@arm.com#   define GTEST_HAS_RTTI 1
57713481Sgiacomo.travaglini@arm.com#  else
57813481Sgiacomo.travaglini@arm.com#   define GTEST_HAS_RTTI 0
57913481Sgiacomo.travaglini@arm.com#  endif
58013481Sgiacomo.travaglini@arm.com
58113481Sgiacomo.travaglini@arm.com# else
58213481Sgiacomo.travaglini@arm.com
58313481Sgiacomo.travaglini@arm.com// For all other compilers, we assume RTTI is enabled.
58413481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_RTTI 1
58513481Sgiacomo.travaglini@arm.com
58613481Sgiacomo.travaglini@arm.com# endif  // _MSC_VER
58713481Sgiacomo.travaglini@arm.com
58813481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_RTTI
58913481Sgiacomo.travaglini@arm.com
59013481Sgiacomo.travaglini@arm.com// It's this header's responsibility to #include <typeinfo> when RTTI
59113481Sgiacomo.travaglini@arm.com// is enabled.
59213481Sgiacomo.travaglini@arm.com#if GTEST_HAS_RTTI
59313481Sgiacomo.travaglini@arm.com# include <typeinfo>
59413481Sgiacomo.travaglini@arm.com#endif
59513481Sgiacomo.travaglini@arm.com
59613481Sgiacomo.travaglini@arm.com// Determines whether Google Test can use the pthreads library.
59713481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_PTHREAD
59813481Sgiacomo.travaglini@arm.com// The user didn't tell us explicitly, so we make reasonable assumptions about
59913481Sgiacomo.travaglini@arm.com// which platforms have pthreads support.
60013481Sgiacomo.travaglini@arm.com//
60113481Sgiacomo.travaglini@arm.com// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
60213481Sgiacomo.travaglini@arm.com// to your compiler flags.
60313481Sgiacomo.travaglini@arm.com# define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX \
60413481Sgiacomo.travaglini@arm.com    || GTEST_OS_QNX || GTEST_OS_FREEBSD || GTEST_OS_NACL)
60513481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_PTHREAD
60613481Sgiacomo.travaglini@arm.com
60713481Sgiacomo.travaglini@arm.com#if GTEST_HAS_PTHREAD
60813481Sgiacomo.travaglini@arm.com// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is
60913481Sgiacomo.travaglini@arm.com// true.
61013481Sgiacomo.travaglini@arm.com# include <pthread.h>  // NOLINT
61113481Sgiacomo.travaglini@arm.com
61213481Sgiacomo.travaglini@arm.com// For timespec and nanosleep, used below.
61313481Sgiacomo.travaglini@arm.com# include <time.h>  // NOLINT
61413481Sgiacomo.travaglini@arm.com#endif
61513481Sgiacomo.travaglini@arm.com
61613481Sgiacomo.travaglini@arm.com// Determines if hash_map/hash_set are available.
61713481Sgiacomo.travaglini@arm.com// Only used for testing against those containers.
61813481Sgiacomo.travaglini@arm.com#if !defined(GTEST_HAS_HASH_MAP_)
61913481Sgiacomo.travaglini@arm.com# if _MSC_VER
62013481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_HASH_MAP_ 1  // Indicates that hash_map is available.
62113481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_HASH_SET_ 1  // Indicates that hash_set is available.
62213481Sgiacomo.travaglini@arm.com# endif  // _MSC_VER
62313481Sgiacomo.travaglini@arm.com#endif  // !defined(GTEST_HAS_HASH_MAP_)
62413481Sgiacomo.travaglini@arm.com
62513481Sgiacomo.travaglini@arm.com// Determines whether Google Test can use tr1/tuple.  You can define
62613481Sgiacomo.travaglini@arm.com// this macro to 0 to prevent Google Test from using tuple (any
62713481Sgiacomo.travaglini@arm.com// feature depending on tuple with be disabled in this mode).
62813481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_TR1_TUPLE
62913481Sgiacomo.travaglini@arm.com# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR)
63013481Sgiacomo.travaglini@arm.com// STLport, provided with the Android NDK, has neither <tr1/tuple> or <tuple>.
63113481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_TR1_TUPLE 0
63213481Sgiacomo.travaglini@arm.com# else
63313481Sgiacomo.travaglini@arm.com// The user didn't tell us not to do it, so we assume it's OK.
63413481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_TR1_TUPLE 1
63513481Sgiacomo.travaglini@arm.com# endif
63613481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_TR1_TUPLE
63713481Sgiacomo.travaglini@arm.com
63813481Sgiacomo.travaglini@arm.com// Determines whether Google Test's own tr1 tuple implementation
63913481Sgiacomo.travaglini@arm.com// should be used.
64013481Sgiacomo.travaglini@arm.com#ifndef GTEST_USE_OWN_TR1_TUPLE
64113481Sgiacomo.travaglini@arm.com// The user didn't tell us, so we need to figure it out.
64213481Sgiacomo.travaglini@arm.com
64313481Sgiacomo.travaglini@arm.com// We use our own TR1 tuple if we aren't sure the user has an
64413481Sgiacomo.travaglini@arm.com// implementation of it already.  At this time, libstdc++ 4.0.0+ and
64513481Sgiacomo.travaglini@arm.com// MSVC 2010 are the only mainstream standard libraries that come
64613481Sgiacomo.travaglini@arm.com// with a TR1 tuple implementation.  NVIDIA's CUDA NVCC compiler
64713481Sgiacomo.travaglini@arm.com// pretends to be GCC by defining __GNUC__ and friends, but cannot
64813481Sgiacomo.travaglini@arm.com// compile GCC's tuple implementation.  MSVC 2008 (9.0) provides TR1
64913481Sgiacomo.travaglini@arm.com// tuple in a 323 MB Feature Pack download, which we cannot assume the
65013481Sgiacomo.travaglini@arm.com// user has.  QNX's QCC compiler is a modified GCC but it doesn't
65113481Sgiacomo.travaglini@arm.com// support TR1 tuple.  libc++ only provides std::tuple, in C++11 mode,
65213481Sgiacomo.travaglini@arm.com// and it can be used with some compilers that define __GNUC__.
65313481Sgiacomo.travaglini@arm.com# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \
65413481Sgiacomo.travaglini@arm.com      && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) || _MSC_VER >= 1600
65513481Sgiacomo.travaglini@arm.com#  define GTEST_ENV_HAS_TR1_TUPLE_ 1
65613481Sgiacomo.travaglini@arm.com# endif
65713481Sgiacomo.travaglini@arm.com
65813481Sgiacomo.travaglini@arm.com// C++11 specifies that <tuple> provides std::tuple. Use that if gtest is used
65913481Sgiacomo.travaglini@arm.com// in C++11 mode and libstdc++ isn't very old (binaries targeting OS X 10.6
66013481Sgiacomo.travaglini@arm.com// can build with clang but need to use gcc4.2's libstdc++).
66113481Sgiacomo.travaglini@arm.com# if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325)
66213481Sgiacomo.travaglini@arm.com#  define GTEST_ENV_HAS_STD_TUPLE_ 1
66313481Sgiacomo.travaglini@arm.com# endif
66413481Sgiacomo.travaglini@arm.com
66513481Sgiacomo.travaglini@arm.com# if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_
66613481Sgiacomo.travaglini@arm.com#  define GTEST_USE_OWN_TR1_TUPLE 0
66713481Sgiacomo.travaglini@arm.com# else
66813481Sgiacomo.travaglini@arm.com#  define GTEST_USE_OWN_TR1_TUPLE 1
66913481Sgiacomo.travaglini@arm.com# endif
67013481Sgiacomo.travaglini@arm.com
67113481Sgiacomo.travaglini@arm.com#endif  // GTEST_USE_OWN_TR1_TUPLE
67213481Sgiacomo.travaglini@arm.com
67313481Sgiacomo.travaglini@arm.com// To avoid conditional compilation everywhere, we make it
67413481Sgiacomo.travaglini@arm.com// gtest-port.h's responsibility to #include the header implementing
67513481Sgiacomo.travaglini@arm.com// tuple.
67613481Sgiacomo.travaglini@arm.com#if GTEST_HAS_STD_TUPLE_
67713481Sgiacomo.travaglini@arm.com# include <tuple>  // IWYU pragma: export
67813481Sgiacomo.travaglini@arm.com# define GTEST_TUPLE_NAMESPACE_ ::std
67913481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_STD_TUPLE_
68013481Sgiacomo.travaglini@arm.com
68113481Sgiacomo.travaglini@arm.com// We include tr1::tuple even if std::tuple is available to define printers for
68213481Sgiacomo.travaglini@arm.com// them.
68313481Sgiacomo.travaglini@arm.com#if GTEST_HAS_TR1_TUPLE
68413481Sgiacomo.travaglini@arm.com# ifndef GTEST_TUPLE_NAMESPACE_
68513481Sgiacomo.travaglini@arm.com#  define GTEST_TUPLE_NAMESPACE_ ::std::tr1
68613481Sgiacomo.travaglini@arm.com# endif  // GTEST_TUPLE_NAMESPACE_
68713481Sgiacomo.travaglini@arm.com
68813481Sgiacomo.travaglini@arm.com# if GTEST_USE_OWN_TR1_TUPLE
68913481Sgiacomo.travaglini@arm.com#  include "gtest/internal/gtest-tuple.h"  // IWYU pragma: export  // NOLINT
69013481Sgiacomo.travaglini@arm.com# elif GTEST_ENV_HAS_STD_TUPLE_
69113481Sgiacomo.travaglini@arm.com#  include <tuple>
69213481Sgiacomo.travaglini@arm.com// C++11 puts its tuple into the ::std namespace rather than
69313481Sgiacomo.travaglini@arm.com// ::std::tr1.  gtest expects tuple to live in ::std::tr1, so put it there.
69413481Sgiacomo.travaglini@arm.com// This causes undefined behavior, but supported compilers react in
69513481Sgiacomo.travaglini@arm.com// the way we intend.
69613481Sgiacomo.travaglini@arm.comnamespace std {
69713481Sgiacomo.travaglini@arm.comnamespace tr1 {
69813481Sgiacomo.travaglini@arm.comusing ::std::get;
69913481Sgiacomo.travaglini@arm.comusing ::std::make_tuple;
70013481Sgiacomo.travaglini@arm.comusing ::std::tuple;
70113481Sgiacomo.travaglini@arm.comusing ::std::tuple_element;
70213481Sgiacomo.travaglini@arm.comusing ::std::tuple_size;
70313481Sgiacomo.travaglini@arm.com}
70413481Sgiacomo.travaglini@arm.com}
70513481Sgiacomo.travaglini@arm.com
70613481Sgiacomo.travaglini@arm.com# elif GTEST_OS_SYMBIAN
70713481Sgiacomo.travaglini@arm.com
70813481Sgiacomo.travaglini@arm.com// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to
70913481Sgiacomo.travaglini@arm.com// use STLport's tuple implementation, which unfortunately doesn't
71013481Sgiacomo.travaglini@arm.com// work as the copy of STLport distributed with Symbian is incomplete.
71113481Sgiacomo.travaglini@arm.com// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to
71213481Sgiacomo.travaglini@arm.com// use its own tuple implementation.
71313481Sgiacomo.travaglini@arm.com#  ifdef BOOST_HAS_TR1_TUPLE
71413481Sgiacomo.travaglini@arm.com#   undef BOOST_HAS_TR1_TUPLE
71513481Sgiacomo.travaglini@arm.com#  endif  // BOOST_HAS_TR1_TUPLE
71613481Sgiacomo.travaglini@arm.com
71713481Sgiacomo.travaglini@arm.com// This prevents <boost/tr1/detail/config.hpp>, which defines
71813481Sgiacomo.travaglini@arm.com// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>.
71913481Sgiacomo.travaglini@arm.com#  define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED
72013481Sgiacomo.travaglini@arm.com#  include <tuple>  // IWYU pragma: export  // NOLINT
72113481Sgiacomo.travaglini@arm.com
72213481Sgiacomo.travaglini@arm.com# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)
72313481Sgiacomo.travaglini@arm.com// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header.  This does
72413481Sgiacomo.travaglini@arm.com// not conform to the TR1 spec, which requires the header to be <tuple>.
72513481Sgiacomo.travaglini@arm.com
72613481Sgiacomo.travaglini@arm.com#  if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
72713481Sgiacomo.travaglini@arm.com// Until version 4.3.2, gcc has a bug that causes <tr1/functional>,
72813481Sgiacomo.travaglini@arm.com// which is #included by <tr1/tuple>, to not compile when RTTI is
72913481Sgiacomo.travaglini@arm.com// disabled.  _TR1_FUNCTIONAL is the header guard for
73013481Sgiacomo.travaglini@arm.com// <tr1/functional>.  Hence the following #define is a hack to prevent
73113481Sgiacomo.travaglini@arm.com// <tr1/functional> from being included.
73213481Sgiacomo.travaglini@arm.com#   define _TR1_FUNCTIONAL 1
73313481Sgiacomo.travaglini@arm.com#   include <tr1/tuple>
73413481Sgiacomo.travaglini@arm.com#   undef _TR1_FUNCTIONAL  // Allows the user to #include
73513481Sgiacomo.travaglini@arm.com                        // <tr1/functional> if he chooses to.
73613481Sgiacomo.travaglini@arm.com#  else
73713481Sgiacomo.travaglini@arm.com#   include <tr1/tuple>  // NOLINT
73813481Sgiacomo.travaglini@arm.com#  endif  // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
73913481Sgiacomo.travaglini@arm.com
74013481Sgiacomo.travaglini@arm.com# else
74113481Sgiacomo.travaglini@arm.com// If the compiler is not GCC 4.0+, we assume the user is using a
74213481Sgiacomo.travaglini@arm.com// spec-conforming TR1 implementation.
74313481Sgiacomo.travaglini@arm.com#  include <tuple>  // IWYU pragma: export  // NOLINT
74413481Sgiacomo.travaglini@arm.com# endif  // GTEST_USE_OWN_TR1_TUPLE
74513481Sgiacomo.travaglini@arm.com
74613481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_TR1_TUPLE
74713481Sgiacomo.travaglini@arm.com
74813481Sgiacomo.travaglini@arm.com// Determines whether clone(2) is supported.
74913481Sgiacomo.travaglini@arm.com// Usually it will only be available on Linux, excluding
75013481Sgiacomo.travaglini@arm.com// Linux on the Itanium architecture.
75113481Sgiacomo.travaglini@arm.com// Also see http://linux.die.net/man/2/clone.
75213481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_CLONE
75313481Sgiacomo.travaglini@arm.com// The user didn't tell us, so we need to figure it out.
75413481Sgiacomo.travaglini@arm.com
75513481Sgiacomo.travaglini@arm.com# if GTEST_OS_LINUX && !defined(__ia64__)
75613481Sgiacomo.travaglini@arm.com#  if GTEST_OS_LINUX_ANDROID
75713481Sgiacomo.travaglini@arm.com// On Android, clone() is only available on ARM starting with Gingerbread.
75813481Sgiacomo.travaglini@arm.com#    if defined(__arm__) && __ANDROID_API__ >= 9
75913481Sgiacomo.travaglini@arm.com#     define GTEST_HAS_CLONE 1
76013481Sgiacomo.travaglini@arm.com#    else
76113481Sgiacomo.travaglini@arm.com#     define GTEST_HAS_CLONE 0
76213481Sgiacomo.travaglini@arm.com#    endif
76313481Sgiacomo.travaglini@arm.com#  else
76413481Sgiacomo.travaglini@arm.com#   define GTEST_HAS_CLONE 1
76513481Sgiacomo.travaglini@arm.com#  endif
76613481Sgiacomo.travaglini@arm.com# else
76713481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_CLONE 0
76813481Sgiacomo.travaglini@arm.com# endif  // GTEST_OS_LINUX && !defined(__ia64__)
76913481Sgiacomo.travaglini@arm.com
77013481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_CLONE
77113481Sgiacomo.travaglini@arm.com
77213481Sgiacomo.travaglini@arm.com// Determines whether to support stream redirection. This is used to test
77313481Sgiacomo.travaglini@arm.com// output correctness and to implement death tests.
77413481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_STREAM_REDIRECTION
77513481Sgiacomo.travaglini@arm.com// By default, we assume that stream redirection is supported on all
77613481Sgiacomo.travaglini@arm.com// platforms except known mobile ones.
77713481Sgiacomo.travaglini@arm.com# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || \
77813481Sgiacomo.travaglini@arm.com    GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
77913481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_STREAM_REDIRECTION 0
78013481Sgiacomo.travaglini@arm.com# else
78113481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_STREAM_REDIRECTION 1
78213481Sgiacomo.travaglini@arm.com# endif  // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN
78313481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_STREAM_REDIRECTION
78413481Sgiacomo.travaglini@arm.com
78513481Sgiacomo.travaglini@arm.com// Determines whether to support death tests.
78613481Sgiacomo.travaglini@arm.com// Google Test does not support death tests for VC 7.1 and earlier as
78713481Sgiacomo.travaglini@arm.com// abort() in a VC 7.1 application compiled as GUI in debug config
78813481Sgiacomo.travaglini@arm.com// pops up a dialog window that cannot be suppressed programmatically.
78913481Sgiacomo.travaglini@arm.com#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
79013481Sgiacomo.travaglini@arm.com     (GTEST_OS_MAC && !GTEST_OS_IOS) || \
79113481Sgiacomo.travaglini@arm.com     (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \
79213481Sgiacomo.travaglini@arm.com     GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \
79313481Sgiacomo.travaglini@arm.com     GTEST_OS_OPENBSD || GTEST_OS_QNX || GTEST_OS_FREEBSD)
79413481Sgiacomo.travaglini@arm.com# define GTEST_HAS_DEATH_TEST 1
79513481Sgiacomo.travaglini@arm.com#endif
79613481Sgiacomo.travaglini@arm.com
79713481Sgiacomo.travaglini@arm.com// We don't support MSVC 7.1 with exceptions disabled now.  Therefore
79813481Sgiacomo.travaglini@arm.com// all the compilers we care about are adequate for supporting
79913481Sgiacomo.travaglini@arm.com// value-parameterized tests.
80013481Sgiacomo.travaglini@arm.com#define GTEST_HAS_PARAM_TEST 1
80113481Sgiacomo.travaglini@arm.com
80213481Sgiacomo.travaglini@arm.com// Determines whether to support type-driven tests.
80313481Sgiacomo.travaglini@arm.com
80413481Sgiacomo.travaglini@arm.com// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0,
80513481Sgiacomo.travaglini@arm.com// Sun Pro CC, IBM Visual Age, and HP aCC support.
80613481Sgiacomo.travaglini@arm.com#if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \
80713481Sgiacomo.travaglini@arm.com    defined(__IBMCPP__) || defined(__HP_aCC)
80813481Sgiacomo.travaglini@arm.com# define GTEST_HAS_TYPED_TEST 1
80913481Sgiacomo.travaglini@arm.com# define GTEST_HAS_TYPED_TEST_P 1
81013481Sgiacomo.travaglini@arm.com#endif
81113481Sgiacomo.travaglini@arm.com
81213481Sgiacomo.travaglini@arm.com// Determines whether to support Combine(). This only makes sense when
81313481Sgiacomo.travaglini@arm.com// value-parameterized tests are enabled.  The implementation doesn't
81413481Sgiacomo.travaglini@arm.com// work on Sun Studio since it doesn't understand templated conversion
81513481Sgiacomo.travaglini@arm.com// operators.
81613481Sgiacomo.travaglini@arm.com#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC)
81713481Sgiacomo.travaglini@arm.com# define GTEST_HAS_COMBINE 1
81813481Sgiacomo.travaglini@arm.com#endif
81913481Sgiacomo.travaglini@arm.com
82013481Sgiacomo.travaglini@arm.com// Determines whether the system compiler uses UTF-16 for encoding wide strings.
82113481Sgiacomo.travaglini@arm.com#define GTEST_WIDE_STRING_USES_UTF16_ \
82213481Sgiacomo.travaglini@arm.com    (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX)
82313481Sgiacomo.travaglini@arm.com
82413481Sgiacomo.travaglini@arm.com// Determines whether test results can be streamed to a socket.
82513481Sgiacomo.travaglini@arm.com#if GTEST_OS_LINUX
82613481Sgiacomo.travaglini@arm.com# define GTEST_CAN_STREAM_RESULTS_ 1
82713481Sgiacomo.travaglini@arm.com#endif
82813481Sgiacomo.travaglini@arm.com
82913481Sgiacomo.travaglini@arm.com// Defines some utility macros.
83013481Sgiacomo.travaglini@arm.com
83113481Sgiacomo.travaglini@arm.com// The GNU compiler emits a warning if nested "if" statements are followed by
83213481Sgiacomo.travaglini@arm.com// an "else" statement and braces are not used to explicitly disambiguate the
83313481Sgiacomo.travaglini@arm.com// "else" binding.  This leads to problems with code like:
83413481Sgiacomo.travaglini@arm.com//
83513481Sgiacomo.travaglini@arm.com//   if (gate)
83613481Sgiacomo.travaglini@arm.com//     ASSERT_*(condition) << "Some message";
83713481Sgiacomo.travaglini@arm.com//
83813481Sgiacomo.travaglini@arm.com// The "switch (0) case 0:" idiom is used to suppress this.
83913481Sgiacomo.travaglini@arm.com#ifdef __INTEL_COMPILER
84013481Sgiacomo.travaglini@arm.com# define GTEST_AMBIGUOUS_ELSE_BLOCKER_
84113481Sgiacomo.travaglini@arm.com#else
84213481Sgiacomo.travaglini@arm.com# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:  // NOLINT
84313481Sgiacomo.travaglini@arm.com#endif
84413481Sgiacomo.travaglini@arm.com
84513481Sgiacomo.travaglini@arm.com// Use this annotation at the end of a struct/class definition to
84613481Sgiacomo.travaglini@arm.com// prevent the compiler from optimizing away instances that are never
84713481Sgiacomo.travaglini@arm.com// used.  This is useful when all interesting logic happens inside the
84813481Sgiacomo.travaglini@arm.com// c'tor and / or d'tor.  Example:
84913481Sgiacomo.travaglini@arm.com//
85013481Sgiacomo.travaglini@arm.com//   struct Foo {
85113481Sgiacomo.travaglini@arm.com//     Foo() { ... }
85213481Sgiacomo.travaglini@arm.com//   } GTEST_ATTRIBUTE_UNUSED_;
85313481Sgiacomo.travaglini@arm.com//
85413481Sgiacomo.travaglini@arm.com// Also use it after a variable or parameter declaration to tell the
85513481Sgiacomo.travaglini@arm.com// compiler the variable/parameter does not have to be used.
85613481Sgiacomo.travaglini@arm.com#if defined(__GNUC__) && !defined(COMPILER_ICC)
85713481Sgiacomo.travaglini@arm.com# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
85813481Sgiacomo.travaglini@arm.com#elif defined(__clang__)
85913481Sgiacomo.travaglini@arm.com# if __has_attribute(unused)
86013481Sgiacomo.travaglini@arm.com#  define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
86113481Sgiacomo.travaglini@arm.com# endif
86213481Sgiacomo.travaglini@arm.com#endif
86313481Sgiacomo.travaglini@arm.com#ifndef GTEST_ATTRIBUTE_UNUSED_
86413481Sgiacomo.travaglini@arm.com# define GTEST_ATTRIBUTE_UNUSED_
86513481Sgiacomo.travaglini@arm.com#endif
86613481Sgiacomo.travaglini@arm.com
86713481Sgiacomo.travaglini@arm.com// A macro to disallow operator=
86813481Sgiacomo.travaglini@arm.com// This should be used in the private: declarations for a class.
86913481Sgiacomo.travaglini@arm.com#define GTEST_DISALLOW_ASSIGN_(type)\
87013481Sgiacomo.travaglini@arm.com  void operator=(type const &)
87113481Sgiacomo.travaglini@arm.com
87213481Sgiacomo.travaglini@arm.com// A macro to disallow copy constructor and operator=
87313481Sgiacomo.travaglini@arm.com// This should be used in the private: declarations for a class.
87413481Sgiacomo.travaglini@arm.com#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\
87513481Sgiacomo.travaglini@arm.com  type(type const &);\
87613481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_ASSIGN_(type)
87713481Sgiacomo.travaglini@arm.com
87813481Sgiacomo.travaglini@arm.com// Tell the compiler to warn about unused return values for functions declared
87913481Sgiacomo.travaglini@arm.com// with this macro.  The macro should be used on function declarations
88013481Sgiacomo.travaglini@arm.com// following the argument list:
88113481Sgiacomo.travaglini@arm.com//
88213481Sgiacomo.travaglini@arm.com//   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
88313481Sgiacomo.travaglini@arm.com#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)
88413481Sgiacomo.travaglini@arm.com# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
88513481Sgiacomo.travaglini@arm.com#else
88613481Sgiacomo.travaglini@arm.com# define GTEST_MUST_USE_RESULT_
88713481Sgiacomo.travaglini@arm.com#endif  // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC
88813481Sgiacomo.travaglini@arm.com
88913481Sgiacomo.travaglini@arm.com// MS C++ compiler emits warning when a conditional expression is compile time
89013481Sgiacomo.travaglini@arm.com// constant. In some contexts this warning is false positive and needs to be
89113481Sgiacomo.travaglini@arm.com// suppressed. Use the following two macros in such cases:
89213481Sgiacomo.travaglini@arm.com//
89313481Sgiacomo.travaglini@arm.com// GTEST_INTENTIONAL_CONST_COND_PUSH_()
89413481Sgiacomo.travaglini@arm.com// while (true) {
89513481Sgiacomo.travaglini@arm.com// GTEST_INTENTIONAL_CONST_COND_POP_()
89613481Sgiacomo.travaglini@arm.com// }
89713481Sgiacomo.travaglini@arm.com# define GTEST_INTENTIONAL_CONST_COND_PUSH_() \
89813481Sgiacomo.travaglini@arm.com    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)
89913481Sgiacomo.travaglini@arm.com# define GTEST_INTENTIONAL_CONST_COND_POP_() \
90013481Sgiacomo.travaglini@arm.com    GTEST_DISABLE_MSC_WARNINGS_POP_()
90113481Sgiacomo.travaglini@arm.com
90213481Sgiacomo.travaglini@arm.com// Determine whether the compiler supports Microsoft's Structured Exception
90313481Sgiacomo.travaglini@arm.com// Handling.  This is supported by several Windows compilers but generally
90413481Sgiacomo.travaglini@arm.com// does not exist on any other system.
90513481Sgiacomo.travaglini@arm.com#ifndef GTEST_HAS_SEH
90613481Sgiacomo.travaglini@arm.com// The user didn't tell us, so we need to figure it out.
90713481Sgiacomo.travaglini@arm.com
90813481Sgiacomo.travaglini@arm.com# if defined(_MSC_VER) || defined(__BORLANDC__)
90913481Sgiacomo.travaglini@arm.com// These two compilers are known to support SEH.
91013481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_SEH 1
91113481Sgiacomo.travaglini@arm.com# else
91213481Sgiacomo.travaglini@arm.com// Assume no SEH.
91313481Sgiacomo.travaglini@arm.com#  define GTEST_HAS_SEH 0
91413481Sgiacomo.travaglini@arm.com# endif
91513481Sgiacomo.travaglini@arm.com
91613481Sgiacomo.travaglini@arm.com#define GTEST_IS_THREADSAFE \
91713481Sgiacomo.travaglini@arm.com    (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ \
91813481Sgiacomo.travaglini@arm.com     || (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) \
91913481Sgiacomo.travaglini@arm.com     || GTEST_HAS_PTHREAD)
92013481Sgiacomo.travaglini@arm.com
92113481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_SEH
92213481Sgiacomo.travaglini@arm.com
92313481Sgiacomo.travaglini@arm.com#ifdef _MSC_VER
92413481Sgiacomo.travaglini@arm.com# if GTEST_LINKED_AS_SHARED_LIBRARY
92513481Sgiacomo.travaglini@arm.com#  define GTEST_API_ __declspec(dllimport)
92613481Sgiacomo.travaglini@arm.com# elif GTEST_CREATE_SHARED_LIBRARY
92713481Sgiacomo.travaglini@arm.com#  define GTEST_API_ __declspec(dllexport)
92813481Sgiacomo.travaglini@arm.com# endif
92913481Sgiacomo.travaglini@arm.com#elif __GNUC__ >= 4 || defined(__clang__)
93013481Sgiacomo.travaglini@arm.com# define GTEST_API_ __attribute__((visibility ("default")))
93113481Sgiacomo.travaglini@arm.com#endif // _MSC_VER
93213481Sgiacomo.travaglini@arm.com
93313481Sgiacomo.travaglini@arm.com#ifndef GTEST_API_
93413481Sgiacomo.travaglini@arm.com# define GTEST_API_
93513481Sgiacomo.travaglini@arm.com#endif
93613481Sgiacomo.travaglini@arm.com
93713481Sgiacomo.travaglini@arm.com#ifdef __GNUC__
93813481Sgiacomo.travaglini@arm.com// Ask the compiler to never inline a given function.
93913481Sgiacomo.travaglini@arm.com# define GTEST_NO_INLINE_ __attribute__((noinline))
94013481Sgiacomo.travaglini@arm.com#else
94113481Sgiacomo.travaglini@arm.com# define GTEST_NO_INLINE_
94213481Sgiacomo.travaglini@arm.com#endif
94313481Sgiacomo.travaglini@arm.com
94413481Sgiacomo.travaglini@arm.com// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
94513481Sgiacomo.travaglini@arm.com#if defined(__GLIBCXX__) || defined(_LIBCPP_VERSION)
94613481Sgiacomo.travaglini@arm.com# define GTEST_HAS_CXXABI_H_ 1
94713481Sgiacomo.travaglini@arm.com#else
94813481Sgiacomo.travaglini@arm.com# define GTEST_HAS_CXXABI_H_ 0
94913481Sgiacomo.travaglini@arm.com#endif
95013481Sgiacomo.travaglini@arm.com
95113481Sgiacomo.travaglini@arm.com// A function level attribute to disable checking for use of uninitialized
95213481Sgiacomo.travaglini@arm.com// memory when built with MemorySanitizer.
95313481Sgiacomo.travaglini@arm.com#if defined(__clang__)
95413481Sgiacomo.travaglini@arm.com# if __has_feature(memory_sanitizer)
95513481Sgiacomo.travaglini@arm.com#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \
95613481Sgiacomo.travaglini@arm.com       __attribute__((no_sanitize_memory))
95713481Sgiacomo.travaglini@arm.com# else
95813481Sgiacomo.travaglini@arm.com#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
95913481Sgiacomo.travaglini@arm.com# endif  // __has_feature(memory_sanitizer)
96013481Sgiacomo.travaglini@arm.com#else
96113481Sgiacomo.travaglini@arm.com# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
96213481Sgiacomo.travaglini@arm.com#endif  // __clang__
96313481Sgiacomo.travaglini@arm.com
96413481Sgiacomo.travaglini@arm.com// A function level attribute to disable AddressSanitizer instrumentation.
96513481Sgiacomo.travaglini@arm.com#if defined(__clang__)
96613481Sgiacomo.travaglini@arm.com# if __has_feature(address_sanitizer)
96713481Sgiacomo.travaglini@arm.com#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \
96813481Sgiacomo.travaglini@arm.com       __attribute__((no_sanitize_address))
96913481Sgiacomo.travaglini@arm.com# else
97013481Sgiacomo.travaglini@arm.com#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
97113481Sgiacomo.travaglini@arm.com# endif  // __has_feature(address_sanitizer)
97213481Sgiacomo.travaglini@arm.com#else
97313481Sgiacomo.travaglini@arm.com# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
97413481Sgiacomo.travaglini@arm.com#endif  // __clang__
97513481Sgiacomo.travaglini@arm.com
97613481Sgiacomo.travaglini@arm.com// A function level attribute to disable ThreadSanitizer instrumentation.
97713481Sgiacomo.travaglini@arm.com#if defined(__clang__)
97813481Sgiacomo.travaglini@arm.com# if __has_feature(thread_sanitizer)
97913481Sgiacomo.travaglini@arm.com#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \
98013481Sgiacomo.travaglini@arm.com       __attribute__((no_sanitize_thread))
98113481Sgiacomo.travaglini@arm.com# else
98213481Sgiacomo.travaglini@arm.com#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
98313481Sgiacomo.travaglini@arm.com# endif  // __has_feature(thread_sanitizer)
98413481Sgiacomo.travaglini@arm.com#else
98513481Sgiacomo.travaglini@arm.com# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
98613481Sgiacomo.travaglini@arm.com#endif  // __clang__
98713481Sgiacomo.travaglini@arm.com
98813481Sgiacomo.travaglini@arm.comnamespace testing {
98913481Sgiacomo.travaglini@arm.com
99013481Sgiacomo.travaglini@arm.comclass Message;
99113481Sgiacomo.travaglini@arm.com
99213481Sgiacomo.travaglini@arm.com#if defined(GTEST_TUPLE_NAMESPACE_)
99313481Sgiacomo.travaglini@arm.com// Import tuple and friends into the ::testing namespace.
99413481Sgiacomo.travaglini@arm.com// It is part of our interface, having them in ::testing allows us to change
99513481Sgiacomo.travaglini@arm.com// their types as needed.
99613481Sgiacomo.travaglini@arm.comusing GTEST_TUPLE_NAMESPACE_::get;
99713481Sgiacomo.travaglini@arm.comusing GTEST_TUPLE_NAMESPACE_::make_tuple;
99813481Sgiacomo.travaglini@arm.comusing GTEST_TUPLE_NAMESPACE_::tuple;
99913481Sgiacomo.travaglini@arm.comusing GTEST_TUPLE_NAMESPACE_::tuple_size;
100013481Sgiacomo.travaglini@arm.comusing GTEST_TUPLE_NAMESPACE_::tuple_element;
100113481Sgiacomo.travaglini@arm.com#endif  // defined(GTEST_TUPLE_NAMESPACE_)
100213481Sgiacomo.travaglini@arm.com
100313481Sgiacomo.travaglini@arm.comnamespace internal {
100413481Sgiacomo.travaglini@arm.com
100513481Sgiacomo.travaglini@arm.com// A secret type that Google Test users don't know about.  It has no
100613481Sgiacomo.travaglini@arm.com// definition on purpose.  Therefore it's impossible to create a
100713481Sgiacomo.travaglini@arm.com// Secret object, which is what we want.
100813481Sgiacomo.travaglini@arm.comclass Secret;
100913481Sgiacomo.travaglini@arm.com
101013481Sgiacomo.travaglini@arm.com// The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time
101113481Sgiacomo.travaglini@arm.com// expression is true. For example, you could use it to verify the
101213481Sgiacomo.travaglini@arm.com// size of a static array:
101313481Sgiacomo.travaglini@arm.com//
101413481Sgiacomo.travaglini@arm.com//   GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES,
101513481Sgiacomo.travaglini@arm.com//                         names_incorrect_size);
101613481Sgiacomo.travaglini@arm.com//
101713481Sgiacomo.travaglini@arm.com// or to make sure a struct is smaller than a certain size:
101813481Sgiacomo.travaglini@arm.com//
101913481Sgiacomo.travaglini@arm.com//   GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large);
102013481Sgiacomo.travaglini@arm.com//
102113481Sgiacomo.travaglini@arm.com// The second argument to the macro is the name of the variable. If
102213481Sgiacomo.travaglini@arm.com// the expression is false, most compilers will issue a warning/error
102313481Sgiacomo.travaglini@arm.com// containing the name of the variable.
102413481Sgiacomo.travaglini@arm.com
102513481Sgiacomo.travaglini@arm.com#if GTEST_LANG_CXX11
102613481Sgiacomo.travaglini@arm.com# define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
102713481Sgiacomo.travaglini@arm.com#else  // !GTEST_LANG_CXX11
102813481Sgiacomo.travaglini@arm.comtemplate <bool>
102913481Sgiacomo.travaglini@arm.com  struct CompileAssert {
103013481Sgiacomo.travaglini@arm.com};
103113481Sgiacomo.travaglini@arm.com
103213481Sgiacomo.travaglini@arm.com# define GTEST_COMPILE_ASSERT_(expr, msg) \
103313481Sgiacomo.travaglini@arm.com  typedef ::testing::internal::CompileAssert<(static_cast<bool>(expr))> \
103413481Sgiacomo.travaglini@arm.com      msg[static_cast<bool>(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_
103513481Sgiacomo.travaglini@arm.com#endif  // !GTEST_LANG_CXX11
103613481Sgiacomo.travaglini@arm.com
103713481Sgiacomo.travaglini@arm.com// Implementation details of GTEST_COMPILE_ASSERT_:
103813481Sgiacomo.travaglini@arm.com//
103913481Sgiacomo.travaglini@arm.com// (In C++11, we simply use static_assert instead of the following)
104013481Sgiacomo.travaglini@arm.com//
104113481Sgiacomo.travaglini@arm.com// - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1
104213481Sgiacomo.travaglini@arm.com//   elements (and thus is invalid) when the expression is false.
104313481Sgiacomo.travaglini@arm.com//
104413481Sgiacomo.travaglini@arm.com// - The simpler definition
104513481Sgiacomo.travaglini@arm.com//
104613481Sgiacomo.travaglini@arm.com//    #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1]
104713481Sgiacomo.travaglini@arm.com//
104813481Sgiacomo.travaglini@arm.com//   does not work, as gcc supports variable-length arrays whose sizes
104913481Sgiacomo.travaglini@arm.com//   are determined at run-time (this is gcc's extension and not part
105013481Sgiacomo.travaglini@arm.com//   of the C++ standard).  As a result, gcc fails to reject the
105113481Sgiacomo.travaglini@arm.com//   following code with the simple definition:
105213481Sgiacomo.travaglini@arm.com//
105313481Sgiacomo.travaglini@arm.com//     int foo;
105413481Sgiacomo.travaglini@arm.com//     GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is
105513481Sgiacomo.travaglini@arm.com//                                      // not a compile-time constant.
105613481Sgiacomo.travaglini@arm.com//
105713481Sgiacomo.travaglini@arm.com// - By using the type CompileAssert<(bool(expr))>, we ensures that
105813481Sgiacomo.travaglini@arm.com//   expr is a compile-time constant.  (Template arguments must be
105913481Sgiacomo.travaglini@arm.com//   determined at compile-time.)
106013481Sgiacomo.travaglini@arm.com//
106113481Sgiacomo.travaglini@arm.com// - The outter parentheses in CompileAssert<(bool(expr))> are necessary
106213481Sgiacomo.travaglini@arm.com//   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
106313481Sgiacomo.travaglini@arm.com//
106413481Sgiacomo.travaglini@arm.com//     CompileAssert<bool(expr)>
106513481Sgiacomo.travaglini@arm.com//
106613481Sgiacomo.travaglini@arm.com//   instead, these compilers will refuse to compile
106713481Sgiacomo.travaglini@arm.com//
106813481Sgiacomo.travaglini@arm.com//     GTEST_COMPILE_ASSERT_(5 > 0, some_message);
106913481Sgiacomo.travaglini@arm.com//
107013481Sgiacomo.travaglini@arm.com//   (They seem to think the ">" in "5 > 0" marks the end of the
107113481Sgiacomo.travaglini@arm.com//   template argument list.)
107213481Sgiacomo.travaglini@arm.com//
107313481Sgiacomo.travaglini@arm.com// - The array size is (bool(expr) ? 1 : -1), instead of simply
107413481Sgiacomo.travaglini@arm.com//
107513481Sgiacomo.travaglini@arm.com//     ((expr) ? 1 : -1).
107613481Sgiacomo.travaglini@arm.com//
107713481Sgiacomo.travaglini@arm.com//   This is to avoid running into a bug in MS VC 7.1, which
107813481Sgiacomo.travaglini@arm.com//   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
107913481Sgiacomo.travaglini@arm.com
108013481Sgiacomo.travaglini@arm.com// StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h.
108113481Sgiacomo.travaglini@arm.com//
108213481Sgiacomo.travaglini@arm.com// This template is declared, but intentionally undefined.
108313481Sgiacomo.travaglini@arm.comtemplate <typename T1, typename T2>
108413481Sgiacomo.travaglini@arm.comstruct StaticAssertTypeEqHelper;
108513481Sgiacomo.travaglini@arm.com
108613481Sgiacomo.travaglini@arm.comtemplate <typename T>
108713481Sgiacomo.travaglini@arm.comstruct StaticAssertTypeEqHelper<T, T> {
108813481Sgiacomo.travaglini@arm.com  enum { value = true };
108913481Sgiacomo.travaglini@arm.com};
109013481Sgiacomo.travaglini@arm.com
109113481Sgiacomo.travaglini@arm.com// Evaluates to the number of elements in 'array'.
109213481Sgiacomo.travaglini@arm.com#define GTEST_ARRAY_SIZE_(array) (sizeof(array) / sizeof(array[0]))
109313481Sgiacomo.travaglini@arm.com
109413481Sgiacomo.travaglini@arm.com#if GTEST_HAS_GLOBAL_STRING
109513481Sgiacomo.travaglini@arm.comtypedef ::string string;
109613481Sgiacomo.travaglini@arm.com#else
109713481Sgiacomo.travaglini@arm.comtypedef ::std::string string;
109813481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_GLOBAL_STRING
109913481Sgiacomo.travaglini@arm.com
110013481Sgiacomo.travaglini@arm.com#if GTEST_HAS_GLOBAL_WSTRING
110113481Sgiacomo.travaglini@arm.comtypedef ::wstring wstring;
110213481Sgiacomo.travaglini@arm.com#elif GTEST_HAS_STD_WSTRING
110313481Sgiacomo.travaglini@arm.comtypedef ::std::wstring wstring;
110413481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_GLOBAL_WSTRING
110513481Sgiacomo.travaglini@arm.com
110613481Sgiacomo.travaglini@arm.com// A helper for suppressing warnings on constant condition.  It just
110713481Sgiacomo.travaglini@arm.com// returns 'condition'.
110813481Sgiacomo.travaglini@arm.comGTEST_API_ bool IsTrue(bool condition);
110913481Sgiacomo.travaglini@arm.com
111013481Sgiacomo.travaglini@arm.com// Defines scoped_ptr.
111113481Sgiacomo.travaglini@arm.com
111213481Sgiacomo.travaglini@arm.com// This implementation of scoped_ptr is PARTIAL - it only contains
111313481Sgiacomo.travaglini@arm.com// enough stuff to satisfy Google Test's need.
111413481Sgiacomo.travaglini@arm.comtemplate <typename T>
111513481Sgiacomo.travaglini@arm.comclass scoped_ptr {
111613481Sgiacomo.travaglini@arm.com public:
111713481Sgiacomo.travaglini@arm.com  typedef T element_type;
111813481Sgiacomo.travaglini@arm.com
111913481Sgiacomo.travaglini@arm.com  explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
112013481Sgiacomo.travaglini@arm.com  ~scoped_ptr() { reset(); }
112113481Sgiacomo.travaglini@arm.com
112213481Sgiacomo.travaglini@arm.com  T& operator*() const { return *ptr_; }
112313481Sgiacomo.travaglini@arm.com  T* operator->() const { return ptr_; }
112413481Sgiacomo.travaglini@arm.com  T* get() const { return ptr_; }
112513481Sgiacomo.travaglini@arm.com
112613481Sgiacomo.travaglini@arm.com  T* release() {
112713481Sgiacomo.travaglini@arm.com    T* const ptr = ptr_;
112813481Sgiacomo.travaglini@arm.com    ptr_ = NULL;
112913481Sgiacomo.travaglini@arm.com    return ptr;
113013481Sgiacomo.travaglini@arm.com  }
113113481Sgiacomo.travaglini@arm.com
113213481Sgiacomo.travaglini@arm.com  void reset(T* p = NULL) {
113313481Sgiacomo.travaglini@arm.com    if (p != ptr_) {
113413481Sgiacomo.travaglini@arm.com      if (IsTrue(sizeof(T) > 0)) {  // Makes sure T is a complete type.
113513481Sgiacomo.travaglini@arm.com        delete ptr_;
113613481Sgiacomo.travaglini@arm.com      }
113713481Sgiacomo.travaglini@arm.com      ptr_ = p;
113813481Sgiacomo.travaglini@arm.com    }
113913481Sgiacomo.travaglini@arm.com  }
114013481Sgiacomo.travaglini@arm.com
114113481Sgiacomo.travaglini@arm.com  friend void swap(scoped_ptr& a, scoped_ptr& b) {
114213481Sgiacomo.travaglini@arm.com    using std::swap;
114313481Sgiacomo.travaglini@arm.com    swap(a.ptr_, b.ptr_);
114413481Sgiacomo.travaglini@arm.com  }
114513481Sgiacomo.travaglini@arm.com
114613481Sgiacomo.travaglini@arm.com private:
114713481Sgiacomo.travaglini@arm.com  T* ptr_;
114813481Sgiacomo.travaglini@arm.com
114913481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr);
115013481Sgiacomo.travaglini@arm.com};
115113481Sgiacomo.travaglini@arm.com
115213481Sgiacomo.travaglini@arm.com// Defines RE.
115313481Sgiacomo.travaglini@arm.com
115413481Sgiacomo.travaglini@arm.com// A simple C++ wrapper for <regex.h>.  It uses the POSIX Extended
115513481Sgiacomo.travaglini@arm.com// Regular Expression syntax.
115613481Sgiacomo.travaglini@arm.comclass GTEST_API_ RE {
115713481Sgiacomo.travaglini@arm.com public:
115813481Sgiacomo.travaglini@arm.com  // A copy constructor is required by the Standard to initialize object
115913481Sgiacomo.travaglini@arm.com  // references from r-values.
116013481Sgiacomo.travaglini@arm.com  RE(const RE& other) { Init(other.pattern()); }
116113481Sgiacomo.travaglini@arm.com
116213481Sgiacomo.travaglini@arm.com  // Constructs an RE from a string.
116313481Sgiacomo.travaglini@arm.com  RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT
116413481Sgiacomo.travaglini@arm.com
116513481Sgiacomo.travaglini@arm.com#if GTEST_HAS_GLOBAL_STRING
116613481Sgiacomo.travaglini@arm.com
116713481Sgiacomo.travaglini@arm.com  RE(const ::string& regex) { Init(regex.c_str()); }  // NOLINT
116813481Sgiacomo.travaglini@arm.com
116913481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_GLOBAL_STRING
117013481Sgiacomo.travaglini@arm.com
117113481Sgiacomo.travaglini@arm.com  RE(const char* regex) { Init(regex); }  // NOLINT
117213481Sgiacomo.travaglini@arm.com  ~RE();
117313481Sgiacomo.travaglini@arm.com
117413481Sgiacomo.travaglini@arm.com  // Returns the string representation of the regex.
117513481Sgiacomo.travaglini@arm.com  const char* pattern() const { return pattern_; }
117613481Sgiacomo.travaglini@arm.com
117713481Sgiacomo.travaglini@arm.com  // FullMatch(str, re) returns true iff regular expression re matches
117813481Sgiacomo.travaglini@arm.com  // the entire str.
117913481Sgiacomo.travaglini@arm.com  // PartialMatch(str, re) returns true iff regular expression re
118013481Sgiacomo.travaglini@arm.com  // matches a substring of str (including str itself).
118113481Sgiacomo.travaglini@arm.com  //
118213481Sgiacomo.travaglini@arm.com  // TODO(wan@google.com): make FullMatch() and PartialMatch() work
118313481Sgiacomo.travaglini@arm.com  // when str contains NUL characters.
118413481Sgiacomo.travaglini@arm.com  static bool FullMatch(const ::std::string& str, const RE& re) {
118513481Sgiacomo.travaglini@arm.com    return FullMatch(str.c_str(), re);
118613481Sgiacomo.travaglini@arm.com  }
118713481Sgiacomo.travaglini@arm.com  static bool PartialMatch(const ::std::string& str, const RE& re) {
118813481Sgiacomo.travaglini@arm.com    return PartialMatch(str.c_str(), re);
118913481Sgiacomo.travaglini@arm.com  }
119013481Sgiacomo.travaglini@arm.com
119113481Sgiacomo.travaglini@arm.com#if GTEST_HAS_GLOBAL_STRING
119213481Sgiacomo.travaglini@arm.com
119313481Sgiacomo.travaglini@arm.com  static bool FullMatch(const ::string& str, const RE& re) {
119413481Sgiacomo.travaglini@arm.com    return FullMatch(str.c_str(), re);
119513481Sgiacomo.travaglini@arm.com  }
119613481Sgiacomo.travaglini@arm.com  static bool PartialMatch(const ::string& str, const RE& re) {
119713481Sgiacomo.travaglini@arm.com    return PartialMatch(str.c_str(), re);
119813481Sgiacomo.travaglini@arm.com  }
119913481Sgiacomo.travaglini@arm.com
120013481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_GLOBAL_STRING
120113481Sgiacomo.travaglini@arm.com
120213481Sgiacomo.travaglini@arm.com  static bool FullMatch(const char* str, const RE& re);
120313481Sgiacomo.travaglini@arm.com  static bool PartialMatch(const char* str, const RE& re);
120413481Sgiacomo.travaglini@arm.com
120513481Sgiacomo.travaglini@arm.com private:
120613481Sgiacomo.travaglini@arm.com  void Init(const char* regex);
120713481Sgiacomo.travaglini@arm.com
120813481Sgiacomo.travaglini@arm.com  // We use a const char* instead of an std::string, as Google Test used to be
120913481Sgiacomo.travaglini@arm.com  // used where std::string is not available.  TODO(wan@google.com): change to
121013481Sgiacomo.travaglini@arm.com  // std::string.
121113481Sgiacomo.travaglini@arm.com  const char* pattern_;
121213481Sgiacomo.travaglini@arm.com  bool is_valid_;
121313481Sgiacomo.travaglini@arm.com
121413481Sgiacomo.travaglini@arm.com#if GTEST_USES_POSIX_RE
121513481Sgiacomo.travaglini@arm.com
121613481Sgiacomo.travaglini@arm.com  regex_t full_regex_;     // For FullMatch().
121713481Sgiacomo.travaglini@arm.com  regex_t partial_regex_;  // For PartialMatch().
121813481Sgiacomo.travaglini@arm.com
121913481Sgiacomo.travaglini@arm.com#else  // GTEST_USES_SIMPLE_RE
122013481Sgiacomo.travaglini@arm.com
122113481Sgiacomo.travaglini@arm.com  const char* full_pattern_;  // For FullMatch();
122213481Sgiacomo.travaglini@arm.com
122313481Sgiacomo.travaglini@arm.com#endif
122413481Sgiacomo.travaglini@arm.com
122513481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_ASSIGN_(RE);
122613481Sgiacomo.travaglini@arm.com};
122713481Sgiacomo.travaglini@arm.com
122813481Sgiacomo.travaglini@arm.com// Formats a source file path and a line number as they would appear
122913481Sgiacomo.travaglini@arm.com// in an error message from the compiler used to compile this code.
123013481Sgiacomo.travaglini@arm.comGTEST_API_ ::std::string FormatFileLocation(const char* file, int line);
123113481Sgiacomo.travaglini@arm.com
123213481Sgiacomo.travaglini@arm.com// Formats a file location for compiler-independent XML output.
123313481Sgiacomo.travaglini@arm.com// Although this function is not platform dependent, we put it next to
123413481Sgiacomo.travaglini@arm.com// FormatFileLocation in order to contrast the two functions.
123513481Sgiacomo.travaglini@arm.comGTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
123613481Sgiacomo.travaglini@arm.com                                                               int line);
123713481Sgiacomo.travaglini@arm.com
123813481Sgiacomo.travaglini@arm.com// Defines logging utilities:
123913481Sgiacomo.travaglini@arm.com//   GTEST_LOG_(severity) - logs messages at the specified severity level. The
124013481Sgiacomo.travaglini@arm.com//                          message itself is streamed into the macro.
124113481Sgiacomo.travaglini@arm.com//   LogToStderr()  - directs all log messages to stderr.
124213481Sgiacomo.travaglini@arm.com//   FlushInfoLog() - flushes informational log messages.
124313481Sgiacomo.travaglini@arm.com
124413481Sgiacomo.travaglini@arm.comenum GTestLogSeverity {
124513481Sgiacomo.travaglini@arm.com  GTEST_INFO,
124613481Sgiacomo.travaglini@arm.com  GTEST_WARNING,
124713481Sgiacomo.travaglini@arm.com  GTEST_ERROR,
124813481Sgiacomo.travaglini@arm.com  GTEST_FATAL
124913481Sgiacomo.travaglini@arm.com};
125013481Sgiacomo.travaglini@arm.com
125113481Sgiacomo.travaglini@arm.com// Formats log entry severity, provides a stream object for streaming the
125213481Sgiacomo.travaglini@arm.com// log message, and terminates the message with a newline when going out of
125313481Sgiacomo.travaglini@arm.com// scope.
125413481Sgiacomo.travaglini@arm.comclass GTEST_API_ GTestLog {
125513481Sgiacomo.travaglini@arm.com public:
125613481Sgiacomo.travaglini@arm.com  GTestLog(GTestLogSeverity severity, const char* file, int line);
125713481Sgiacomo.travaglini@arm.com
125813481Sgiacomo.travaglini@arm.com  // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
125913481Sgiacomo.travaglini@arm.com  ~GTestLog();
126013481Sgiacomo.travaglini@arm.com
126113481Sgiacomo.travaglini@arm.com  ::std::ostream& GetStream() { return ::std::cerr; }
126213481Sgiacomo.travaglini@arm.com
126313481Sgiacomo.travaglini@arm.com private:
126413481Sgiacomo.travaglini@arm.com  const GTestLogSeverity severity_;
126513481Sgiacomo.travaglini@arm.com
126613481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
126713481Sgiacomo.travaglini@arm.com};
126813481Sgiacomo.travaglini@arm.com
126913481Sgiacomo.travaglini@arm.com#if !defined(GTEST_LOG_)
127013481Sgiacomo.travaglini@arm.com
127113481Sgiacomo.travaglini@arm.com# define GTEST_LOG_(severity) \
127213481Sgiacomo.travaglini@arm.com    ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
127313481Sgiacomo.travaglini@arm.com                                  __FILE__, __LINE__).GetStream()
127413481Sgiacomo.travaglini@arm.com
127513481Sgiacomo.travaglini@arm.cominline void LogToStderr() {}
127613481Sgiacomo.travaglini@arm.cominline void FlushInfoLog() { fflush(NULL); }
127713481Sgiacomo.travaglini@arm.com
127813481Sgiacomo.travaglini@arm.com#endif  // !defined(GTEST_LOG_)
127913481Sgiacomo.travaglini@arm.com
128013481Sgiacomo.travaglini@arm.com#if !defined(GTEST_CHECK_)
128113481Sgiacomo.travaglini@arm.com// INTERNAL IMPLEMENTATION - DO NOT USE.
128213481Sgiacomo.travaglini@arm.com//
128313481Sgiacomo.travaglini@arm.com// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
128413481Sgiacomo.travaglini@arm.com// is not satisfied.
128513481Sgiacomo.travaglini@arm.com//  Synopsys:
128613481Sgiacomo.travaglini@arm.com//    GTEST_CHECK_(boolean_condition);
128713481Sgiacomo.travaglini@arm.com//     or
128813481Sgiacomo.travaglini@arm.com//    GTEST_CHECK_(boolean_condition) << "Additional message";
128913481Sgiacomo.travaglini@arm.com//
129013481Sgiacomo.travaglini@arm.com//    This checks the condition and if the condition is not satisfied
129113481Sgiacomo.travaglini@arm.com//    it prints message about the condition violation, including the
129213481Sgiacomo.travaglini@arm.com//    condition itself, plus additional message streamed into it, if any,
129313481Sgiacomo.travaglini@arm.com//    and then it aborts the program. It aborts the program irrespective of
129413481Sgiacomo.travaglini@arm.com//    whether it is built in the debug mode or not.
129513481Sgiacomo.travaglini@arm.com# define GTEST_CHECK_(condition) \
129613481Sgiacomo.travaglini@arm.com    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
129713481Sgiacomo.travaglini@arm.com    if (::testing::internal::IsTrue(condition)) \
129813481Sgiacomo.travaglini@arm.com      ; \
129913481Sgiacomo.travaglini@arm.com    else \
130013481Sgiacomo.travaglini@arm.com      GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
130113481Sgiacomo.travaglini@arm.com#endif  // !defined(GTEST_CHECK_)
130213481Sgiacomo.travaglini@arm.com
130313481Sgiacomo.travaglini@arm.com// An all-mode assert to verify that the given POSIX-style function
130413481Sgiacomo.travaglini@arm.com// call returns 0 (indicating success).  Known limitation: this
130513481Sgiacomo.travaglini@arm.com// doesn't expand to a balanced 'if' statement, so enclose the macro
130613481Sgiacomo.travaglini@arm.com// in {} if you need to use it as the only statement in an 'if'
130713481Sgiacomo.travaglini@arm.com// branch.
130813481Sgiacomo.travaglini@arm.com#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
130913481Sgiacomo.travaglini@arm.com  if (const int gtest_error = (posix_call)) \
131013481Sgiacomo.travaglini@arm.com    GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
131113481Sgiacomo.travaglini@arm.com                      << gtest_error
131213481Sgiacomo.travaglini@arm.com
131313481Sgiacomo.travaglini@arm.com#if GTEST_HAS_STD_MOVE_
131413481Sgiacomo.travaglini@arm.comusing std::move;
131513481Sgiacomo.travaglini@arm.com#else  // GTEST_HAS_STD_MOVE_
131613481Sgiacomo.travaglini@arm.comtemplate <typename T>
131713481Sgiacomo.travaglini@arm.comconst T& move(const T& t) {
131813481Sgiacomo.travaglini@arm.com  return t;
131913481Sgiacomo.travaglini@arm.com}
132013481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_STD_MOVE_
132113481Sgiacomo.travaglini@arm.com
132213481Sgiacomo.travaglini@arm.com// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
132313481Sgiacomo.travaglini@arm.com//
132413481Sgiacomo.travaglini@arm.com// Use ImplicitCast_ as a safe version of static_cast for upcasting in
132513481Sgiacomo.travaglini@arm.com// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a
132613481Sgiacomo.travaglini@arm.com// const Foo*).  When you use ImplicitCast_, the compiler checks that
132713481Sgiacomo.travaglini@arm.com// the cast is safe.  Such explicit ImplicitCast_s are necessary in
132813481Sgiacomo.travaglini@arm.com// surprisingly many situations where C++ demands an exact type match
132913481Sgiacomo.travaglini@arm.com// instead of an argument type convertable to a target type.
133013481Sgiacomo.travaglini@arm.com//
133113481Sgiacomo.travaglini@arm.com// The syntax for using ImplicitCast_ is the same as for static_cast:
133213481Sgiacomo.travaglini@arm.com//
133313481Sgiacomo.travaglini@arm.com//   ImplicitCast_<ToType>(expr)
133413481Sgiacomo.travaglini@arm.com//
133513481Sgiacomo.travaglini@arm.com// ImplicitCast_ would have been part of the C++ standard library,
133613481Sgiacomo.travaglini@arm.com// but the proposal was submitted too late.  It will probably make
133713481Sgiacomo.travaglini@arm.com// its way into the language in the future.
133813481Sgiacomo.travaglini@arm.com//
133913481Sgiacomo.travaglini@arm.com// This relatively ugly name is intentional. It prevents clashes with
134013481Sgiacomo.travaglini@arm.com// similar functions users may have (e.g., implicit_cast). The internal
134113481Sgiacomo.travaglini@arm.com// namespace alone is not enough because the function can be found by ADL.
134213481Sgiacomo.travaglini@arm.comtemplate<typename To>
134313481Sgiacomo.travaglini@arm.cominline To ImplicitCast_(To x) { return x; }
134413481Sgiacomo.travaglini@arm.com
134513481Sgiacomo.travaglini@arm.com// When you upcast (that is, cast a pointer from type Foo to type
134613481Sgiacomo.travaglini@arm.com// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts
134713481Sgiacomo.travaglini@arm.com// always succeed.  When you downcast (that is, cast a pointer from
134813481Sgiacomo.travaglini@arm.com// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
134913481Sgiacomo.travaglini@arm.com// how do you know the pointer is really of type SubclassOfFoo?  It
135013481Sgiacomo.travaglini@arm.com// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
135113481Sgiacomo.travaglini@arm.com// when you downcast, you should use this macro.  In debug mode, we
135213481Sgiacomo.travaglini@arm.com// use dynamic_cast<> to double-check the downcast is legal (we die
135313481Sgiacomo.travaglini@arm.com// if it's not).  In normal mode, we do the efficient static_cast<>
135413481Sgiacomo.travaglini@arm.com// instead.  Thus, it's important to test in debug mode to make sure
135513481Sgiacomo.travaglini@arm.com// the cast is legal!
135613481Sgiacomo.travaglini@arm.com//    This is the only place in the code we should use dynamic_cast<>.
135713481Sgiacomo.travaglini@arm.com// In particular, you SHOULDN'T be using dynamic_cast<> in order to
135813481Sgiacomo.travaglini@arm.com// do RTTI (eg code like this:
135913481Sgiacomo.travaglini@arm.com//    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
136013481Sgiacomo.travaglini@arm.com//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
136113481Sgiacomo.travaglini@arm.com// You should design the code some other way not to need this.
136213481Sgiacomo.travaglini@arm.com//
136313481Sgiacomo.travaglini@arm.com// This relatively ugly name is intentional. It prevents clashes with
136413481Sgiacomo.travaglini@arm.com// similar functions users may have (e.g., down_cast). The internal
136513481Sgiacomo.travaglini@arm.com// namespace alone is not enough because the function can be found by ADL.
136613481Sgiacomo.travaglini@arm.comtemplate<typename To, typename From>  // use like this: DownCast_<T*>(foo);
136713481Sgiacomo.travaglini@arm.cominline To DownCast_(From* f) {  // so we only accept pointers
136813481Sgiacomo.travaglini@arm.com  // Ensures that To is a sub-type of From *.  This test is here only
136913481Sgiacomo.travaglini@arm.com  // for compile-time type checking, and has no overhead in an
137013481Sgiacomo.travaglini@arm.com  // optimized build at run-time, as it will be optimized away
137113481Sgiacomo.travaglini@arm.com  // completely.
137213481Sgiacomo.travaglini@arm.com  GTEST_INTENTIONAL_CONST_COND_PUSH_()
137313481Sgiacomo.travaglini@arm.com  if (false) {
137413481Sgiacomo.travaglini@arm.com  GTEST_INTENTIONAL_CONST_COND_POP_()
137513481Sgiacomo.travaglini@arm.com    const To to = NULL;
137613481Sgiacomo.travaglini@arm.com    ::testing::internal::ImplicitCast_<From*>(to);
137713481Sgiacomo.travaglini@arm.com  }
137813481Sgiacomo.travaglini@arm.com
137913481Sgiacomo.travaglini@arm.com#if GTEST_HAS_RTTI
138013481Sgiacomo.travaglini@arm.com  // RTTI: debug mode only!
138113481Sgiacomo.travaglini@arm.com  GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL);
138213481Sgiacomo.travaglini@arm.com#endif
138313481Sgiacomo.travaglini@arm.com  return static_cast<To>(f);
138413481Sgiacomo.travaglini@arm.com}
138513481Sgiacomo.travaglini@arm.com
138613481Sgiacomo.travaglini@arm.com// Downcasts the pointer of type Base to Derived.
138713481Sgiacomo.travaglini@arm.com// Derived must be a subclass of Base. The parameter MUST
138813481Sgiacomo.travaglini@arm.com// point to a class of type Derived, not any subclass of it.
138913481Sgiacomo.travaglini@arm.com// When RTTI is available, the function performs a runtime
139013481Sgiacomo.travaglini@arm.com// check to enforce this.
139113481Sgiacomo.travaglini@arm.comtemplate <class Derived, class Base>
139213481Sgiacomo.travaglini@arm.comDerived* CheckedDowncastToActualType(Base* base) {
139313481Sgiacomo.travaglini@arm.com#if GTEST_HAS_RTTI
139413481Sgiacomo.travaglini@arm.com  GTEST_CHECK_(typeid(*base) == typeid(Derived));
139513481Sgiacomo.travaglini@arm.com#endif
139613481Sgiacomo.travaglini@arm.com
139713481Sgiacomo.travaglini@arm.com#if GTEST_HAS_DOWNCAST_
139813481Sgiacomo.travaglini@arm.com  return ::down_cast<Derived*>(base);
139913481Sgiacomo.travaglini@arm.com#elif GTEST_HAS_RTTI
140013481Sgiacomo.travaglini@arm.com  return dynamic_cast<Derived*>(base);  // NOLINT
140113481Sgiacomo.travaglini@arm.com#else
140213481Sgiacomo.travaglini@arm.com  return static_cast<Derived*>(base);  // Poor man's downcast.
140313481Sgiacomo.travaglini@arm.com#endif
140413481Sgiacomo.travaglini@arm.com}
140513481Sgiacomo.travaglini@arm.com
140613481Sgiacomo.travaglini@arm.com#if GTEST_HAS_STREAM_REDIRECTION
140713481Sgiacomo.travaglini@arm.com
140813481Sgiacomo.travaglini@arm.com// Defines the stderr capturer:
140913481Sgiacomo.travaglini@arm.com//   CaptureStdout     - starts capturing stdout.
141013481Sgiacomo.travaglini@arm.com//   GetCapturedStdout - stops capturing stdout and returns the captured string.
141113481Sgiacomo.travaglini@arm.com//   CaptureStderr     - starts capturing stderr.
141213481Sgiacomo.travaglini@arm.com//   GetCapturedStderr - stops capturing stderr and returns the captured string.
141313481Sgiacomo.travaglini@arm.com//
141413481Sgiacomo.travaglini@arm.comGTEST_API_ void CaptureStdout();
141513481Sgiacomo.travaglini@arm.comGTEST_API_ std::string GetCapturedStdout();
141613481Sgiacomo.travaglini@arm.comGTEST_API_ void CaptureStderr();
141713481Sgiacomo.travaglini@arm.comGTEST_API_ std::string GetCapturedStderr();
141813481Sgiacomo.travaglini@arm.com
141913481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_STREAM_REDIRECTION
142013481Sgiacomo.travaglini@arm.com
142113481Sgiacomo.travaglini@arm.com// Returns a path to temporary directory.
142213481Sgiacomo.travaglini@arm.comGTEST_API_ std::string TempDir();
142313481Sgiacomo.travaglini@arm.com
142413481Sgiacomo.travaglini@arm.com// Returns the size (in bytes) of a file.
142513481Sgiacomo.travaglini@arm.comGTEST_API_ size_t GetFileSize(FILE* file);
142613481Sgiacomo.travaglini@arm.com
142713481Sgiacomo.travaglini@arm.com// Reads the entire content of a file as a string.
142813481Sgiacomo.travaglini@arm.comGTEST_API_ std::string ReadEntireFile(FILE* file);
142913481Sgiacomo.travaglini@arm.com
143013481Sgiacomo.travaglini@arm.com// All command line arguments.
143113481Sgiacomo.travaglini@arm.comGTEST_API_ const ::std::vector<testing::internal::string>& GetArgvs();
143213481Sgiacomo.travaglini@arm.com
143313481Sgiacomo.travaglini@arm.com#if GTEST_HAS_DEATH_TEST
143413481Sgiacomo.travaglini@arm.com
143513481Sgiacomo.travaglini@arm.comconst ::std::vector<testing::internal::string>& GetInjectableArgvs();
143613481Sgiacomo.travaglini@arm.comvoid SetInjectableArgvs(const ::std::vector<testing::internal::string>*
143713481Sgiacomo.travaglini@arm.com                             new_argvs);
143813481Sgiacomo.travaglini@arm.com
143913481Sgiacomo.travaglini@arm.com
144013481Sgiacomo.travaglini@arm.com#endif  // GTEST_HAS_DEATH_TEST
144113481Sgiacomo.travaglini@arm.com
144213481Sgiacomo.travaglini@arm.com// Defines synchronization primitives.
144313481Sgiacomo.travaglini@arm.com#if GTEST_IS_THREADSAFE
144413481Sgiacomo.travaglini@arm.com# if GTEST_HAS_PTHREAD
144513481Sgiacomo.travaglini@arm.com// Sleeps for (roughly) n milliseconds.  This function is only for testing
144613481Sgiacomo.travaglini@arm.com// Google Test's own constructs.  Don't use it in user tests, either
144713481Sgiacomo.travaglini@arm.com// directly or indirectly.
144813481Sgiacomo.travaglini@arm.cominline void SleepMilliseconds(int n) {
144913481Sgiacomo.travaglini@arm.com  const timespec time = {
145013481Sgiacomo.travaglini@arm.com    0,                  // 0 seconds.
145113481Sgiacomo.travaglini@arm.com    n * 1000L * 1000L,  // And n ms.
145213481Sgiacomo.travaglini@arm.com  };
145313481Sgiacomo.travaglini@arm.com  nanosleep(&time, NULL);
145413481Sgiacomo.travaglini@arm.com}
145513481Sgiacomo.travaglini@arm.com# endif  // GTEST_HAS_PTHREAD
145613481Sgiacomo.travaglini@arm.com
145713481Sgiacomo.travaglini@arm.com# if GTEST_HAS_NOTIFICATION_
145813481Sgiacomo.travaglini@arm.com// Notification has already been imported into the namespace.
145913481Sgiacomo.travaglini@arm.com// Nothing to do here.
146013481Sgiacomo.travaglini@arm.com
146113481Sgiacomo.travaglini@arm.com# elif GTEST_HAS_PTHREAD
146213481Sgiacomo.travaglini@arm.com// Allows a controller thread to pause execution of newly created
146313481Sgiacomo.travaglini@arm.com// threads until notified.  Instances of this class must be created
146413481Sgiacomo.travaglini@arm.com// and destroyed in the controller thread.
146513481Sgiacomo.travaglini@arm.com//
146613481Sgiacomo.travaglini@arm.com// This class is only for testing Google Test's own constructs. Do not
146713481Sgiacomo.travaglini@arm.com// use it in user tests, either directly or indirectly.
146813481Sgiacomo.travaglini@arm.comclass Notification {
146913481Sgiacomo.travaglini@arm.com public:
147013481Sgiacomo.travaglini@arm.com  Notification() : notified_(false) {
147113481Sgiacomo.travaglini@arm.com    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
147213481Sgiacomo.travaglini@arm.com  }
147313481Sgiacomo.travaglini@arm.com  ~Notification() {
147413481Sgiacomo.travaglini@arm.com    pthread_mutex_destroy(&mutex_);
147513481Sgiacomo.travaglini@arm.com  }
147613481Sgiacomo.travaglini@arm.com
147713481Sgiacomo.travaglini@arm.com  // Notifies all threads created with this notification to start. Must
147813481Sgiacomo.travaglini@arm.com  // be called from the controller thread.
147913481Sgiacomo.travaglini@arm.com  void Notify() {
148013481Sgiacomo.travaglini@arm.com    pthread_mutex_lock(&mutex_);
148113481Sgiacomo.travaglini@arm.com    notified_ = true;
148213481Sgiacomo.travaglini@arm.com    pthread_mutex_unlock(&mutex_);
148313481Sgiacomo.travaglini@arm.com  }
148413481Sgiacomo.travaglini@arm.com
148513481Sgiacomo.travaglini@arm.com  // Blocks until the controller thread notifies. Must be called from a test
148613481Sgiacomo.travaglini@arm.com  // thread.
148713481Sgiacomo.travaglini@arm.com  void WaitForNotification() {
148813481Sgiacomo.travaglini@arm.com    for (;;) {
148913481Sgiacomo.travaglini@arm.com      pthread_mutex_lock(&mutex_);
149013481Sgiacomo.travaglini@arm.com      const bool notified = notified_;
149113481Sgiacomo.travaglini@arm.com      pthread_mutex_unlock(&mutex_);
149213481Sgiacomo.travaglini@arm.com      if (notified)
149313481Sgiacomo.travaglini@arm.com        break;
149413481Sgiacomo.travaglini@arm.com      SleepMilliseconds(10);
149513481Sgiacomo.travaglini@arm.com    }
149613481Sgiacomo.travaglini@arm.com  }
149713481Sgiacomo.travaglini@arm.com
149813481Sgiacomo.travaglini@arm.com private:
149913481Sgiacomo.travaglini@arm.com  pthread_mutex_t mutex_;
150013481Sgiacomo.travaglini@arm.com  bool notified_;
150113481Sgiacomo.travaglini@arm.com
150213481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
150313481Sgiacomo.travaglini@arm.com};
150413481Sgiacomo.travaglini@arm.com
150513481Sgiacomo.travaglini@arm.com# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
150613481Sgiacomo.travaglini@arm.com
150713481Sgiacomo.travaglini@arm.comGTEST_API_ void SleepMilliseconds(int n);
150813481Sgiacomo.travaglini@arm.com
150913481Sgiacomo.travaglini@arm.com// Provides leak-safe Windows kernel handle ownership.
151013481Sgiacomo.travaglini@arm.com// Used in death tests and in threading support.
151113481Sgiacomo.travaglini@arm.comclass GTEST_API_ AutoHandle {
151213481Sgiacomo.travaglini@arm.com public:
151313481Sgiacomo.travaglini@arm.com  // Assume that Win32 HANDLE type is equivalent to void*. Doing so allows us to
151413481Sgiacomo.travaglini@arm.com  // avoid including <windows.h> in this header file. Including <windows.h> is
151513481Sgiacomo.travaglini@arm.com  // undesirable because it defines a lot of symbols and macros that tend to
151613481Sgiacomo.travaglini@arm.com  // conflict with client code. This assumption is verified by
151713481Sgiacomo.travaglini@arm.com  // WindowsTypesTest.HANDLEIsVoidStar.
151813481Sgiacomo.travaglini@arm.com  typedef void* Handle;
151913481Sgiacomo.travaglini@arm.com  AutoHandle();
152013481Sgiacomo.travaglini@arm.com  explicit AutoHandle(Handle handle);
152113481Sgiacomo.travaglini@arm.com
152213481Sgiacomo.travaglini@arm.com  ~AutoHandle();
152313481Sgiacomo.travaglini@arm.com
152413481Sgiacomo.travaglini@arm.com  Handle Get() const;
152513481Sgiacomo.travaglini@arm.com  void Reset();
152613481Sgiacomo.travaglini@arm.com  void Reset(Handle handle);
152713481Sgiacomo.travaglini@arm.com
152813481Sgiacomo.travaglini@arm.com private:
152913481Sgiacomo.travaglini@arm.com  // Returns true iff the handle is a valid handle object that can be closed.
153013481Sgiacomo.travaglini@arm.com  bool IsCloseable() const;
153113481Sgiacomo.travaglini@arm.com
153213481Sgiacomo.travaglini@arm.com  Handle handle_;
153313481Sgiacomo.travaglini@arm.com
153413481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);
153513481Sgiacomo.travaglini@arm.com};
153613481Sgiacomo.travaglini@arm.com
153713481Sgiacomo.travaglini@arm.com// Allows a controller thread to pause execution of newly created
153813481Sgiacomo.travaglini@arm.com// threads until notified.  Instances of this class must be created
153913481Sgiacomo.travaglini@arm.com// and destroyed in the controller thread.
154013481Sgiacomo.travaglini@arm.com//
154113481Sgiacomo.travaglini@arm.com// This class is only for testing Google Test's own constructs. Do not
154213481Sgiacomo.travaglini@arm.com// use it in user tests, either directly or indirectly.
154313481Sgiacomo.travaglini@arm.comclass GTEST_API_ Notification {
154413481Sgiacomo.travaglini@arm.com public:
154513481Sgiacomo.travaglini@arm.com  Notification();
154613481Sgiacomo.travaglini@arm.com  void Notify();
154713481Sgiacomo.travaglini@arm.com  void WaitForNotification();
154813481Sgiacomo.travaglini@arm.com
154913481Sgiacomo.travaglini@arm.com private:
155013481Sgiacomo.travaglini@arm.com  AutoHandle event_;
155113481Sgiacomo.travaglini@arm.com
155213481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
155313481Sgiacomo.travaglini@arm.com};
155413481Sgiacomo.travaglini@arm.com# endif  // GTEST_HAS_NOTIFICATION_
155513481Sgiacomo.travaglini@arm.com
155613481Sgiacomo.travaglini@arm.com// On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD
155713481Sgiacomo.travaglini@arm.com// defined, but we don't want to use MinGW's pthreads implementation, which
155813481Sgiacomo.travaglini@arm.com// has conformance problems with some versions of the POSIX standard.
155913481Sgiacomo.travaglini@arm.com# if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW
156013481Sgiacomo.travaglini@arm.com
156113481Sgiacomo.travaglini@arm.com// As a C-function, ThreadFuncWithCLinkage cannot be templated itself.
156213481Sgiacomo.travaglini@arm.com// Consequently, it cannot select a correct instantiation of ThreadWithParam
156313481Sgiacomo.travaglini@arm.com// in order to call its Run(). Introducing ThreadWithParamBase as a
156413481Sgiacomo.travaglini@arm.com// non-templated base class for ThreadWithParam allows us to bypass this
156513481Sgiacomo.travaglini@arm.com// problem.
156613481Sgiacomo.travaglini@arm.comclass ThreadWithParamBase {
156713481Sgiacomo.travaglini@arm.com public:
156813481Sgiacomo.travaglini@arm.com  virtual ~ThreadWithParamBase() {}
156913481Sgiacomo.travaglini@arm.com  virtual void Run() = 0;
157013481Sgiacomo.travaglini@arm.com};
157113481Sgiacomo.travaglini@arm.com
157213481Sgiacomo.travaglini@arm.com// pthread_create() accepts a pointer to a function type with the C linkage.
157313481Sgiacomo.travaglini@arm.com// According to the Standard (7.5/1), function types with different linkages
157413481Sgiacomo.travaglini@arm.com// are different even if they are otherwise identical.  Some compilers (for
157513481Sgiacomo.travaglini@arm.com// example, SunStudio) treat them as different types.  Since class methods
157613481Sgiacomo.travaglini@arm.com// cannot be defined with C-linkage we need to define a free C-function to
157713481Sgiacomo.travaglini@arm.com// pass into pthread_create().
157813481Sgiacomo.travaglini@arm.comextern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
157913481Sgiacomo.travaglini@arm.com  static_cast<ThreadWithParamBase*>(thread)->Run();
158013481Sgiacomo.travaglini@arm.com  return NULL;
158113481Sgiacomo.travaglini@arm.com}
158213481Sgiacomo.travaglini@arm.com
158313481Sgiacomo.travaglini@arm.com// Helper class for testing Google Test's multi-threading constructs.
158413481Sgiacomo.travaglini@arm.com// To use it, write:
158513481Sgiacomo.travaglini@arm.com//
158613481Sgiacomo.travaglini@arm.com//   void ThreadFunc(int param) { /* Do things with param */ }
158713481Sgiacomo.travaglini@arm.com//   Notification thread_can_start;
158813481Sgiacomo.travaglini@arm.com//   ...
158913481Sgiacomo.travaglini@arm.com//   // The thread_can_start parameter is optional; you can supply NULL.
159013481Sgiacomo.travaglini@arm.com//   ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start);
159113481Sgiacomo.travaglini@arm.com//   thread_can_start.Notify();
159213481Sgiacomo.travaglini@arm.com//
159313481Sgiacomo.travaglini@arm.com// These classes are only for testing Google Test's own constructs. Do
159413481Sgiacomo.travaglini@arm.com// not use them in user tests, either directly or indirectly.
159513481Sgiacomo.travaglini@arm.comtemplate <typename T>
159613481Sgiacomo.travaglini@arm.comclass ThreadWithParam : public ThreadWithParamBase {
159713481Sgiacomo.travaglini@arm.com public:
159813481Sgiacomo.travaglini@arm.com  typedef void UserThreadFunc(T);
159913481Sgiacomo.travaglini@arm.com
160013481Sgiacomo.travaglini@arm.com  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
160113481Sgiacomo.travaglini@arm.com      : func_(func),
160213481Sgiacomo.travaglini@arm.com        param_(param),
160313481Sgiacomo.travaglini@arm.com        thread_can_start_(thread_can_start),
160413481Sgiacomo.travaglini@arm.com        finished_(false) {
160513481Sgiacomo.travaglini@arm.com    ThreadWithParamBase* const base = this;
160613481Sgiacomo.travaglini@arm.com    // The thread can be created only after all fields except thread_
160713481Sgiacomo.travaglini@arm.com    // have been initialized.
160813481Sgiacomo.travaglini@arm.com    GTEST_CHECK_POSIX_SUCCESS_(
160913481Sgiacomo.travaglini@arm.com        pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base));
161013481Sgiacomo.travaglini@arm.com  }
161113481Sgiacomo.travaglini@arm.com  ~ThreadWithParam() { Join(); }
161213481Sgiacomo.travaglini@arm.com
161313481Sgiacomo.travaglini@arm.com  void Join() {
161413481Sgiacomo.travaglini@arm.com    if (!finished_) {
161513481Sgiacomo.travaglini@arm.com      GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0));
161613481Sgiacomo.travaglini@arm.com      finished_ = true;
161713481Sgiacomo.travaglini@arm.com    }
161813481Sgiacomo.travaglini@arm.com  }
161913481Sgiacomo.travaglini@arm.com
162013481Sgiacomo.travaglini@arm.com  virtual void Run() {
162113481Sgiacomo.travaglini@arm.com    if (thread_can_start_ != NULL)
162213481Sgiacomo.travaglini@arm.com      thread_can_start_->WaitForNotification();
162313481Sgiacomo.travaglini@arm.com    func_(param_);
162413481Sgiacomo.travaglini@arm.com  }
162513481Sgiacomo.travaglini@arm.com
162613481Sgiacomo.travaglini@arm.com private:
162713481Sgiacomo.travaglini@arm.com  UserThreadFunc* const func_;  // User-supplied thread function.
162813481Sgiacomo.travaglini@arm.com  const T param_;  // User-supplied parameter to the thread function.
162913481Sgiacomo.travaglini@arm.com  // When non-NULL, used to block execution until the controller thread
163013481Sgiacomo.travaglini@arm.com  // notifies.
163113481Sgiacomo.travaglini@arm.com  Notification* const thread_can_start_;
163213481Sgiacomo.travaglini@arm.com  bool finished_;  // true iff we know that the thread function has finished.
163313481Sgiacomo.travaglini@arm.com  pthread_t thread_;  // The native thread object.
163413481Sgiacomo.travaglini@arm.com
163513481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
163613481Sgiacomo.travaglini@arm.com};
163713481Sgiacomo.travaglini@arm.com# endif  // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD ||
163813481Sgiacomo.travaglini@arm.com         // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
163913481Sgiacomo.travaglini@arm.com
164013481Sgiacomo.travaglini@arm.com# if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
164113481Sgiacomo.travaglini@arm.com// Mutex and ThreadLocal have already been imported into the namespace.
164213481Sgiacomo.travaglini@arm.com// Nothing to do here.
164313481Sgiacomo.travaglini@arm.com
164413481Sgiacomo.travaglini@arm.com# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
164513481Sgiacomo.travaglini@arm.com
164613481Sgiacomo.travaglini@arm.com// Mutex implements mutex on Windows platforms.  It is used in conjunction
164713481Sgiacomo.travaglini@arm.com// with class MutexLock:
164813481Sgiacomo.travaglini@arm.com//
164913481Sgiacomo.travaglini@arm.com//   Mutex mutex;
165013481Sgiacomo.travaglini@arm.com//   ...
165113481Sgiacomo.travaglini@arm.com//   MutexLock lock(&mutex);  // Acquires the mutex and releases it at the
165213481Sgiacomo.travaglini@arm.com//                            // end of the current scope.
165313481Sgiacomo.travaglini@arm.com//
165413481Sgiacomo.travaglini@arm.com// A static Mutex *must* be defined or declared using one of the following
165513481Sgiacomo.travaglini@arm.com// macros:
165613481Sgiacomo.travaglini@arm.com//   GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);
165713481Sgiacomo.travaglini@arm.com//   GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);
165813481Sgiacomo.travaglini@arm.com//
165913481Sgiacomo.travaglini@arm.com// (A non-static Mutex is defined/declared in the usual way).
166013481Sgiacomo.travaglini@arm.comclass GTEST_API_ Mutex {
166113481Sgiacomo.travaglini@arm.com public:
166213481Sgiacomo.travaglini@arm.com  enum MutexType { kStatic = 0, kDynamic = 1 };
166313481Sgiacomo.travaglini@arm.com  // We rely on kStaticMutex being 0 as it is to what the linker initializes
166413481Sgiacomo.travaglini@arm.com  // type_ in static mutexes.  critical_section_ will be initialized lazily
166513481Sgiacomo.travaglini@arm.com  // in ThreadSafeLazyInit().
166613481Sgiacomo.travaglini@arm.com  enum StaticConstructorSelector { kStaticMutex = 0 };
166713481Sgiacomo.travaglini@arm.com
166813481Sgiacomo.travaglini@arm.com  // This constructor intentionally does nothing.  It relies on type_ being
166913481Sgiacomo.travaglini@arm.com  // statically initialized to 0 (effectively setting it to kStatic) and on
167013481Sgiacomo.travaglini@arm.com  // ThreadSafeLazyInit() to lazily initialize the rest of the members.
167113481Sgiacomo.travaglini@arm.com  explicit Mutex(StaticConstructorSelector /*dummy*/) {}
167213481Sgiacomo.travaglini@arm.com
167313481Sgiacomo.travaglini@arm.com  Mutex();
167413481Sgiacomo.travaglini@arm.com  ~Mutex();
167513481Sgiacomo.travaglini@arm.com
167613481Sgiacomo.travaglini@arm.com  void Lock();
167713481Sgiacomo.travaglini@arm.com
167813481Sgiacomo.travaglini@arm.com  void Unlock();
167913481Sgiacomo.travaglini@arm.com
168013481Sgiacomo.travaglini@arm.com  // Does nothing if the current thread holds the mutex. Otherwise, crashes
168113481Sgiacomo.travaglini@arm.com  // with high probability.
168213481Sgiacomo.travaglini@arm.com  void AssertHeld();
168313481Sgiacomo.travaglini@arm.com
168413481Sgiacomo.travaglini@arm.com private:
168513481Sgiacomo.travaglini@arm.com  // Initializes owner_thread_id_ and critical_section_ in static mutexes.
168613481Sgiacomo.travaglini@arm.com  void ThreadSafeLazyInit();
168713481Sgiacomo.travaglini@arm.com
168813481Sgiacomo.travaglini@arm.com  // Per http://blogs.msdn.com/b/oldnewthing/archive/2004/02/23/78395.aspx,
168913481Sgiacomo.travaglini@arm.com  // we assume that 0 is an invalid value for thread IDs.
169013481Sgiacomo.travaglini@arm.com  unsigned int owner_thread_id_;
169113481Sgiacomo.travaglini@arm.com
169213481Sgiacomo.travaglini@arm.com  // For static mutexes, we rely on these members being initialized to zeros
169313481Sgiacomo.travaglini@arm.com  // by the linker.
169413481Sgiacomo.travaglini@arm.com  MutexType type_;
169513481Sgiacomo.travaglini@arm.com  long critical_section_init_phase_;  // NOLINT
169613481Sgiacomo.travaglini@arm.com  _RTL_CRITICAL_SECTION* critical_section_;
169713481Sgiacomo.travaglini@arm.com
169813481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
169913481Sgiacomo.travaglini@arm.com};
170013481Sgiacomo.travaglini@arm.com
170113481Sgiacomo.travaglini@arm.com# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
170213481Sgiacomo.travaglini@arm.com    extern ::testing::internal::Mutex mutex
170313481Sgiacomo.travaglini@arm.com
170413481Sgiacomo.travaglini@arm.com# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
170513481Sgiacomo.travaglini@arm.com    ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex)
170613481Sgiacomo.travaglini@arm.com
170713481Sgiacomo.travaglini@arm.com// We cannot name this class MutexLock because the ctor declaration would
170813481Sgiacomo.travaglini@arm.com// conflict with a macro named MutexLock, which is defined on some
170913481Sgiacomo.travaglini@arm.com// platforms. That macro is used as a defensive measure to prevent against
171013481Sgiacomo.travaglini@arm.com// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
171113481Sgiacomo.travaglini@arm.com// "MutexLock l(&mu)".  Hence the typedef trick below.
171213481Sgiacomo.travaglini@arm.comclass GTestMutexLock {
171313481Sgiacomo.travaglini@arm.com public:
171413481Sgiacomo.travaglini@arm.com  explicit GTestMutexLock(Mutex* mutex)
171513481Sgiacomo.travaglini@arm.com      : mutex_(mutex) { mutex_->Lock(); }
171613481Sgiacomo.travaglini@arm.com
171713481Sgiacomo.travaglini@arm.com  ~GTestMutexLock() { mutex_->Unlock(); }
171813481Sgiacomo.travaglini@arm.com
171913481Sgiacomo.travaglini@arm.com private:
172013481Sgiacomo.travaglini@arm.com  Mutex* const mutex_;
172113481Sgiacomo.travaglini@arm.com
172213481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
172313481Sgiacomo.travaglini@arm.com};
172413481Sgiacomo.travaglini@arm.com
172513481Sgiacomo.travaglini@arm.comtypedef GTestMutexLock MutexLock;
172613481Sgiacomo.travaglini@arm.com
172713481Sgiacomo.travaglini@arm.com// Base class for ValueHolder<T>.  Allows a caller to hold and delete a value
172813481Sgiacomo.travaglini@arm.com// without knowing its type.
172913481Sgiacomo.travaglini@arm.comclass ThreadLocalValueHolderBase {
173013481Sgiacomo.travaglini@arm.com public:
173113481Sgiacomo.travaglini@arm.com  virtual ~ThreadLocalValueHolderBase() {}
173213481Sgiacomo.travaglini@arm.com};
173313481Sgiacomo.travaglini@arm.com
173413481Sgiacomo.travaglini@arm.com// Provides a way for a thread to send notifications to a ThreadLocal
173513481Sgiacomo.travaglini@arm.com// regardless of its parameter type.
173613481Sgiacomo.travaglini@arm.comclass ThreadLocalBase {
173713481Sgiacomo.travaglini@arm.com public:
173813481Sgiacomo.travaglini@arm.com  // Creates a new ValueHolder<T> object holding a default value passed to
173913481Sgiacomo.travaglini@arm.com  // this ThreadLocal<T>'s constructor and returns it.  It is the caller's
174013481Sgiacomo.travaglini@arm.com  // responsibility not to call this when the ThreadLocal<T> instance already
174113481Sgiacomo.travaglini@arm.com  // has a value on the current thread.
174213481Sgiacomo.travaglini@arm.com  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const = 0;
174313481Sgiacomo.travaglini@arm.com
174413481Sgiacomo.travaglini@arm.com protected:
174513481Sgiacomo.travaglini@arm.com  ThreadLocalBase() {}
174613481Sgiacomo.travaglini@arm.com  virtual ~ThreadLocalBase() {}
174713481Sgiacomo.travaglini@arm.com
174813481Sgiacomo.travaglini@arm.com private:
174913481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase);
175013481Sgiacomo.travaglini@arm.com};
175113481Sgiacomo.travaglini@arm.com
175213481Sgiacomo.travaglini@arm.com// Maps a thread to a set of ThreadLocals that have values instantiated on that
175313481Sgiacomo.travaglini@arm.com// thread and notifies them when the thread exits.  A ThreadLocal instance is
175413481Sgiacomo.travaglini@arm.com// expected to persist until all threads it has values on have terminated.
175513481Sgiacomo.travaglini@arm.comclass GTEST_API_ ThreadLocalRegistry {
175613481Sgiacomo.travaglini@arm.com public:
175713481Sgiacomo.travaglini@arm.com  // Registers thread_local_instance as having value on the current thread.
175813481Sgiacomo.travaglini@arm.com  // Returns a value that can be used to identify the thread from other threads.
175913481Sgiacomo.travaglini@arm.com  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
176013481Sgiacomo.travaglini@arm.com      const ThreadLocalBase* thread_local_instance);
176113481Sgiacomo.travaglini@arm.com
176213481Sgiacomo.travaglini@arm.com  // Invoked when a ThreadLocal instance is destroyed.
176313481Sgiacomo.travaglini@arm.com  static void OnThreadLocalDestroyed(
176413481Sgiacomo.travaglini@arm.com      const ThreadLocalBase* thread_local_instance);
176513481Sgiacomo.travaglini@arm.com};
176613481Sgiacomo.travaglini@arm.com
176713481Sgiacomo.travaglini@arm.comclass GTEST_API_ ThreadWithParamBase {
176813481Sgiacomo.travaglini@arm.com public:
176913481Sgiacomo.travaglini@arm.com  void Join();
177013481Sgiacomo.travaglini@arm.com
177113481Sgiacomo.travaglini@arm.com protected:
177213481Sgiacomo.travaglini@arm.com  class Runnable {
177313481Sgiacomo.travaglini@arm.com   public:
177413481Sgiacomo.travaglini@arm.com    virtual ~Runnable() {}
177513481Sgiacomo.travaglini@arm.com    virtual void Run() = 0;
177613481Sgiacomo.travaglini@arm.com  };
177713481Sgiacomo.travaglini@arm.com
177813481Sgiacomo.travaglini@arm.com  ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start);
177913481Sgiacomo.travaglini@arm.com  virtual ~ThreadWithParamBase();
178013481Sgiacomo.travaglini@arm.com
178113481Sgiacomo.travaglini@arm.com private:
178213481Sgiacomo.travaglini@arm.com  AutoHandle thread_;
178313481Sgiacomo.travaglini@arm.com};
178413481Sgiacomo.travaglini@arm.com
178513481Sgiacomo.travaglini@arm.com// Helper class for testing Google Test's multi-threading constructs.
178613481Sgiacomo.travaglini@arm.comtemplate <typename T>
178713481Sgiacomo.travaglini@arm.comclass ThreadWithParam : public ThreadWithParamBase {
178813481Sgiacomo.travaglini@arm.com public:
178913481Sgiacomo.travaglini@arm.com  typedef void UserThreadFunc(T);
179013481Sgiacomo.travaglini@arm.com
179113481Sgiacomo.travaglini@arm.com  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
179213481Sgiacomo.travaglini@arm.com      : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {
179313481Sgiacomo.travaglini@arm.com  }
179413481Sgiacomo.travaglini@arm.com  virtual ~ThreadWithParam() {}
179513481Sgiacomo.travaglini@arm.com
179613481Sgiacomo.travaglini@arm.com private:
179713481Sgiacomo.travaglini@arm.com  class RunnableImpl : public Runnable {
179813481Sgiacomo.travaglini@arm.com   public:
179913481Sgiacomo.travaglini@arm.com    RunnableImpl(UserThreadFunc* func, T param)
180013481Sgiacomo.travaglini@arm.com        : func_(func),
180113481Sgiacomo.travaglini@arm.com          param_(param) {
180213481Sgiacomo.travaglini@arm.com    }
180313481Sgiacomo.travaglini@arm.com    virtual ~RunnableImpl() {}
180413481Sgiacomo.travaglini@arm.com    virtual void Run() {
180513481Sgiacomo.travaglini@arm.com      func_(param_);
180613481Sgiacomo.travaglini@arm.com    }
180713481Sgiacomo.travaglini@arm.com
180813481Sgiacomo.travaglini@arm.com   private:
180913481Sgiacomo.travaglini@arm.com    UserThreadFunc* const func_;
181013481Sgiacomo.travaglini@arm.com    const T param_;
181113481Sgiacomo.travaglini@arm.com
181213481Sgiacomo.travaglini@arm.com    GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl);
181313481Sgiacomo.travaglini@arm.com  };
181413481Sgiacomo.travaglini@arm.com
181513481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
181613481Sgiacomo.travaglini@arm.com};
181713481Sgiacomo.travaglini@arm.com
181813481Sgiacomo.travaglini@arm.com// Implements thread-local storage on Windows systems.
181913481Sgiacomo.travaglini@arm.com//
182013481Sgiacomo.travaglini@arm.com//   // Thread 1
182113481Sgiacomo.travaglini@arm.com//   ThreadLocal<int> tl(100);  // 100 is the default value for each thread.
182213481Sgiacomo.travaglini@arm.com//
182313481Sgiacomo.travaglini@arm.com//   // Thread 2
182413481Sgiacomo.travaglini@arm.com//   tl.set(150);  // Changes the value for thread 2 only.
182513481Sgiacomo.travaglini@arm.com//   EXPECT_EQ(150, tl.get());
182613481Sgiacomo.travaglini@arm.com//
182713481Sgiacomo.travaglini@arm.com//   // Thread 1
182813481Sgiacomo.travaglini@arm.com//   EXPECT_EQ(100, tl.get());  // In thread 1, tl has the original value.
182913481Sgiacomo.travaglini@arm.com//   tl.set(200);
183013481Sgiacomo.travaglini@arm.com//   EXPECT_EQ(200, tl.get());
183113481Sgiacomo.travaglini@arm.com//
183213481Sgiacomo.travaglini@arm.com// The template type argument T must have a public copy constructor.
183313481Sgiacomo.travaglini@arm.com// In addition, the default ThreadLocal constructor requires T to have
183413481Sgiacomo.travaglini@arm.com// a public default constructor.
183513481Sgiacomo.travaglini@arm.com//
183613481Sgiacomo.travaglini@arm.com// The users of a TheadLocal instance have to make sure that all but one
183713481Sgiacomo.travaglini@arm.com// threads (including the main one) using that instance have exited before
183813481Sgiacomo.travaglini@arm.com// destroying it. Otherwise, the per-thread objects managed for them by the
183913481Sgiacomo.travaglini@arm.com// ThreadLocal instance are not guaranteed to be destroyed on all platforms.
184013481Sgiacomo.travaglini@arm.com//
184113481Sgiacomo.travaglini@arm.com// Google Test only uses global ThreadLocal objects.  That means they
184213481Sgiacomo.travaglini@arm.com// will die after main() has returned.  Therefore, no per-thread
184313481Sgiacomo.travaglini@arm.com// object managed by Google Test will be leaked as long as all threads
184413481Sgiacomo.travaglini@arm.com// using Google Test have exited when main() returns.
184513481Sgiacomo.travaglini@arm.comtemplate <typename T>
184613481Sgiacomo.travaglini@arm.comclass ThreadLocal : public ThreadLocalBase {
184713481Sgiacomo.travaglini@arm.com public:
184813481Sgiacomo.travaglini@arm.com  ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {}
184913481Sgiacomo.travaglini@arm.com  explicit ThreadLocal(const T& value)
185013481Sgiacomo.travaglini@arm.com      : default_factory_(new InstanceValueHolderFactory(value)) {}
185113481Sgiacomo.travaglini@arm.com
185213481Sgiacomo.travaglini@arm.com  ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(this); }
185313481Sgiacomo.travaglini@arm.com
185413481Sgiacomo.travaglini@arm.com  T* pointer() { return GetOrCreateValue(); }
185513481Sgiacomo.travaglini@arm.com  const T* pointer() const { return GetOrCreateValue(); }
185613481Sgiacomo.travaglini@arm.com  const T& get() const { return *pointer(); }
185713481Sgiacomo.travaglini@arm.com  void set(const T& value) { *pointer() = value; }
185813481Sgiacomo.travaglini@arm.com
185913481Sgiacomo.travaglini@arm.com private:
186013481Sgiacomo.travaglini@arm.com  // Holds a value of T.  Can be deleted via its base class without the caller
186113481Sgiacomo.travaglini@arm.com  // knowing the type of T.
186213481Sgiacomo.travaglini@arm.com  class ValueHolder : public ThreadLocalValueHolderBase {
186313481Sgiacomo.travaglini@arm.com   public:
186413481Sgiacomo.travaglini@arm.com    ValueHolder() : value_() {}
186513481Sgiacomo.travaglini@arm.com    explicit ValueHolder(const T& value) : value_(value) {}
186613481Sgiacomo.travaglini@arm.com
186713481Sgiacomo.travaglini@arm.com    T* pointer() { return &value_; }
186813481Sgiacomo.travaglini@arm.com
186913481Sgiacomo.travaglini@arm.com   private:
187013481Sgiacomo.travaglini@arm.com    T value_;
187113481Sgiacomo.travaglini@arm.com    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
187213481Sgiacomo.travaglini@arm.com  };
187313481Sgiacomo.travaglini@arm.com
187413481Sgiacomo.travaglini@arm.com
187513481Sgiacomo.travaglini@arm.com  T* GetOrCreateValue() const {
187613481Sgiacomo.travaglini@arm.com    return static_cast<ValueHolder*>(
187713481Sgiacomo.travaglini@arm.com        ThreadLocalRegistry::GetValueOnCurrentThread(this))->pointer();
187813481Sgiacomo.travaglini@arm.com  }
187913481Sgiacomo.travaglini@arm.com
188013481Sgiacomo.travaglini@arm.com  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const {
188113481Sgiacomo.travaglini@arm.com    return default_factory_->MakeNewHolder();
188213481Sgiacomo.travaglini@arm.com  }
188313481Sgiacomo.travaglini@arm.com
188413481Sgiacomo.travaglini@arm.com  class ValueHolderFactory {
188513481Sgiacomo.travaglini@arm.com   public:
188613481Sgiacomo.travaglini@arm.com    ValueHolderFactory() {}
188713481Sgiacomo.travaglini@arm.com    virtual ~ValueHolderFactory() {}
188813481Sgiacomo.travaglini@arm.com    virtual ValueHolder* MakeNewHolder() const = 0;
188913481Sgiacomo.travaglini@arm.com
189013481Sgiacomo.travaglini@arm.com   private:
189113481Sgiacomo.travaglini@arm.com    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
189213481Sgiacomo.travaglini@arm.com  };
189313481Sgiacomo.travaglini@arm.com
189413481Sgiacomo.travaglini@arm.com  class DefaultValueHolderFactory : public ValueHolderFactory {
189513481Sgiacomo.travaglini@arm.com   public:
189613481Sgiacomo.travaglini@arm.com    DefaultValueHolderFactory() {}
189713481Sgiacomo.travaglini@arm.com    virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); }
189813481Sgiacomo.travaglini@arm.com
189913481Sgiacomo.travaglini@arm.com   private:
190013481Sgiacomo.travaglini@arm.com    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
190113481Sgiacomo.travaglini@arm.com  };
190213481Sgiacomo.travaglini@arm.com
190313481Sgiacomo.travaglini@arm.com  class InstanceValueHolderFactory : public ValueHolderFactory {
190413481Sgiacomo.travaglini@arm.com   public:
190513481Sgiacomo.travaglini@arm.com    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
190613481Sgiacomo.travaglini@arm.com    virtual ValueHolder* MakeNewHolder() const {
190713481Sgiacomo.travaglini@arm.com      return new ValueHolder(value_);
190813481Sgiacomo.travaglini@arm.com    }
190913481Sgiacomo.travaglini@arm.com
191013481Sgiacomo.travaglini@arm.com   private:
191113481Sgiacomo.travaglini@arm.com    const T value_;  // The value for each thread.
191213481Sgiacomo.travaglini@arm.com
191313481Sgiacomo.travaglini@arm.com    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
191413481Sgiacomo.travaglini@arm.com  };
191513481Sgiacomo.travaglini@arm.com
191613481Sgiacomo.travaglini@arm.com  scoped_ptr<ValueHolderFactory> default_factory_;
191713481Sgiacomo.travaglini@arm.com
191813481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
191913481Sgiacomo.travaglini@arm.com};
192013481Sgiacomo.travaglini@arm.com
192113481Sgiacomo.travaglini@arm.com# elif GTEST_HAS_PTHREAD
192213481Sgiacomo.travaglini@arm.com
192313481Sgiacomo.travaglini@arm.com// MutexBase and Mutex implement mutex on pthreads-based platforms.
192413481Sgiacomo.travaglini@arm.comclass MutexBase {
192513481Sgiacomo.travaglini@arm.com public:
192613481Sgiacomo.travaglini@arm.com  // Acquires this mutex.
192713481Sgiacomo.travaglini@arm.com  void Lock() {
192813481Sgiacomo.travaglini@arm.com    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
192913481Sgiacomo.travaglini@arm.com    owner_ = pthread_self();
193013481Sgiacomo.travaglini@arm.com    has_owner_ = true;
193113481Sgiacomo.travaglini@arm.com  }
193213481Sgiacomo.travaglini@arm.com
193313481Sgiacomo.travaglini@arm.com  // Releases this mutex.
193413481Sgiacomo.travaglini@arm.com  void Unlock() {
193513481Sgiacomo.travaglini@arm.com    // Since the lock is being released the owner_ field should no longer be
193613481Sgiacomo.travaglini@arm.com    // considered valid. We don't protect writing to has_owner_ here, as it's
193713481Sgiacomo.travaglini@arm.com    // the caller's responsibility to ensure that the current thread holds the
193813481Sgiacomo.travaglini@arm.com    // mutex when this is called.
193913481Sgiacomo.travaglini@arm.com    has_owner_ = false;
194013481Sgiacomo.travaglini@arm.com    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
194113481Sgiacomo.travaglini@arm.com  }
194213481Sgiacomo.travaglini@arm.com
194313481Sgiacomo.travaglini@arm.com  // Does nothing if the current thread holds the mutex. Otherwise, crashes
194413481Sgiacomo.travaglini@arm.com  // with high probability.
194513481Sgiacomo.travaglini@arm.com  void AssertHeld() const {
194613481Sgiacomo.travaglini@arm.com    GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
194713481Sgiacomo.travaglini@arm.com        << "The current thread is not holding the mutex @" << this;
194813481Sgiacomo.travaglini@arm.com  }
194913481Sgiacomo.travaglini@arm.com
195013481Sgiacomo.travaglini@arm.com  // A static mutex may be used before main() is entered.  It may even
195113481Sgiacomo.travaglini@arm.com  // be used before the dynamic initialization stage.  Therefore we
195213481Sgiacomo.travaglini@arm.com  // must be able to initialize a static mutex object at link time.
195313481Sgiacomo.travaglini@arm.com  // This means MutexBase has to be a POD and its member variables
195413481Sgiacomo.travaglini@arm.com  // have to be public.
195513481Sgiacomo.travaglini@arm.com public:
195613481Sgiacomo.travaglini@arm.com  pthread_mutex_t mutex_;  // The underlying pthread mutex.
195713481Sgiacomo.travaglini@arm.com  // has_owner_ indicates whether the owner_ field below contains a valid thread
195813481Sgiacomo.travaglini@arm.com  // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All
195913481Sgiacomo.travaglini@arm.com  // accesses to the owner_ field should be protected by a check of this field.
196013481Sgiacomo.travaglini@arm.com  // An alternative might be to memset() owner_ to all zeros, but there's no
196113481Sgiacomo.travaglini@arm.com  // guarantee that a zero'd pthread_t is necessarily invalid or even different
196213481Sgiacomo.travaglini@arm.com  // from pthread_self().
196313481Sgiacomo.travaglini@arm.com  bool has_owner_;
196413481Sgiacomo.travaglini@arm.com  pthread_t owner_;  // The thread holding the mutex.
196513481Sgiacomo.travaglini@arm.com};
196613481Sgiacomo.travaglini@arm.com
196713481Sgiacomo.travaglini@arm.com// Forward-declares a static mutex.
196813481Sgiacomo.travaglini@arm.com#  define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
196913481Sgiacomo.travaglini@arm.com     extern ::testing::internal::MutexBase mutex
197013481Sgiacomo.travaglini@arm.com
197113481Sgiacomo.travaglini@arm.com// Defines and statically (i.e. at link time) initializes a static mutex.
197213481Sgiacomo.travaglini@arm.com#  define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
197313481Sgiacomo.travaglini@arm.com     ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, false, pthread_t() }
197413481Sgiacomo.travaglini@arm.com
197513481Sgiacomo.travaglini@arm.com// The Mutex class can only be used for mutexes created at runtime. It
197613481Sgiacomo.travaglini@arm.com// shares its API with MutexBase otherwise.
197713481Sgiacomo.travaglini@arm.comclass Mutex : public MutexBase {
197813481Sgiacomo.travaglini@arm.com public:
197913481Sgiacomo.travaglini@arm.com  Mutex() {
198013481Sgiacomo.travaglini@arm.com    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
198113481Sgiacomo.travaglini@arm.com    has_owner_ = false;
198213481Sgiacomo.travaglini@arm.com  }
198313481Sgiacomo.travaglini@arm.com  ~Mutex() {
198413481Sgiacomo.travaglini@arm.com    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
198513481Sgiacomo.travaglini@arm.com  }
198613481Sgiacomo.travaglini@arm.com
198713481Sgiacomo.travaglini@arm.com private:
198813481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
198913481Sgiacomo.travaglini@arm.com};
199013481Sgiacomo.travaglini@arm.com
199113481Sgiacomo.travaglini@arm.com// We cannot name this class MutexLock because the ctor declaration would
199213481Sgiacomo.travaglini@arm.com// conflict with a macro named MutexLock, which is defined on some
199313481Sgiacomo.travaglini@arm.com// platforms. That macro is used as a defensive measure to prevent against
199413481Sgiacomo.travaglini@arm.com// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
199513481Sgiacomo.travaglini@arm.com// "MutexLock l(&mu)".  Hence the typedef trick below.
199613481Sgiacomo.travaglini@arm.comclass GTestMutexLock {
199713481Sgiacomo.travaglini@arm.com public:
199813481Sgiacomo.travaglini@arm.com  explicit GTestMutexLock(MutexBase* mutex)
199913481Sgiacomo.travaglini@arm.com      : mutex_(mutex) { mutex_->Lock(); }
200013481Sgiacomo.travaglini@arm.com
200113481Sgiacomo.travaglini@arm.com  ~GTestMutexLock() { mutex_->Unlock(); }
200213481Sgiacomo.travaglini@arm.com
200313481Sgiacomo.travaglini@arm.com private:
200413481Sgiacomo.travaglini@arm.com  MutexBase* const mutex_;
200513481Sgiacomo.travaglini@arm.com
200613481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
200713481Sgiacomo.travaglini@arm.com};
200813481Sgiacomo.travaglini@arm.com
200913481Sgiacomo.travaglini@arm.comtypedef GTestMutexLock MutexLock;
201013481Sgiacomo.travaglini@arm.com
201113481Sgiacomo.travaglini@arm.com// Helpers for ThreadLocal.
201213481Sgiacomo.travaglini@arm.com
201313481Sgiacomo.travaglini@arm.com// pthread_key_create() requires DeleteThreadLocalValue() to have
201413481Sgiacomo.travaglini@arm.com// C-linkage.  Therefore it cannot be templatized to access
201513481Sgiacomo.travaglini@arm.com// ThreadLocal<T>.  Hence the need for class
201613481Sgiacomo.travaglini@arm.com// ThreadLocalValueHolderBase.
201713481Sgiacomo.travaglini@arm.comclass ThreadLocalValueHolderBase {
201813481Sgiacomo.travaglini@arm.com public:
201913481Sgiacomo.travaglini@arm.com  virtual ~ThreadLocalValueHolderBase() {}
202013481Sgiacomo.travaglini@arm.com};
202113481Sgiacomo.travaglini@arm.com
202213481Sgiacomo.travaglini@arm.com// Called by pthread to delete thread-local data stored by
202313481Sgiacomo.travaglini@arm.com// pthread_setspecific().
202413481Sgiacomo.travaglini@arm.comextern "C" inline void DeleteThreadLocalValue(void* value_holder) {
202513481Sgiacomo.travaglini@arm.com  delete static_cast<ThreadLocalValueHolderBase*>(value_holder);
202613481Sgiacomo.travaglini@arm.com}
202713481Sgiacomo.travaglini@arm.com
202813481Sgiacomo.travaglini@arm.com// Implements thread-local storage on pthreads-based systems.
202913481Sgiacomo.travaglini@arm.comtemplate <typename T>
203013481Sgiacomo.travaglini@arm.comclass ThreadLocal {
203113481Sgiacomo.travaglini@arm.com public:
203213481Sgiacomo.travaglini@arm.com  ThreadLocal()
203313481Sgiacomo.travaglini@arm.com      : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
203413481Sgiacomo.travaglini@arm.com  explicit ThreadLocal(const T& value)
203513481Sgiacomo.travaglini@arm.com      : key_(CreateKey()),
203613481Sgiacomo.travaglini@arm.com        default_factory_(new InstanceValueHolderFactory(value)) {}
203713481Sgiacomo.travaglini@arm.com
203813481Sgiacomo.travaglini@arm.com  ~ThreadLocal() {
203913481Sgiacomo.travaglini@arm.com    // Destroys the managed object for the current thread, if any.
204013481Sgiacomo.travaglini@arm.com    DeleteThreadLocalValue(pthread_getspecific(key_));
204113481Sgiacomo.travaglini@arm.com
204213481Sgiacomo.travaglini@arm.com    // Releases resources associated with the key.  This will *not*
204313481Sgiacomo.travaglini@arm.com    // delete managed objects for other threads.
204413481Sgiacomo.travaglini@arm.com    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
204513481Sgiacomo.travaglini@arm.com  }
204613481Sgiacomo.travaglini@arm.com
204713481Sgiacomo.travaglini@arm.com  T* pointer() { return GetOrCreateValue(); }
204813481Sgiacomo.travaglini@arm.com  const T* pointer() const { return GetOrCreateValue(); }
204913481Sgiacomo.travaglini@arm.com  const T& get() const { return *pointer(); }
205013481Sgiacomo.travaglini@arm.com  void set(const T& value) { *pointer() = value; }
205113481Sgiacomo.travaglini@arm.com
205213481Sgiacomo.travaglini@arm.com private:
205313481Sgiacomo.travaglini@arm.com  // Holds a value of type T.
205413481Sgiacomo.travaglini@arm.com  class ValueHolder : public ThreadLocalValueHolderBase {
205513481Sgiacomo.travaglini@arm.com   public:
205613481Sgiacomo.travaglini@arm.com    ValueHolder() : value_() {}
205713481Sgiacomo.travaglini@arm.com    explicit ValueHolder(const T& value) : value_(value) {}
205813481Sgiacomo.travaglini@arm.com
205913481Sgiacomo.travaglini@arm.com    T* pointer() { return &value_; }
206013481Sgiacomo.travaglini@arm.com
206113481Sgiacomo.travaglini@arm.com   private:
206213481Sgiacomo.travaglini@arm.com    T value_;
206313481Sgiacomo.travaglini@arm.com    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
206413481Sgiacomo.travaglini@arm.com  };
206513481Sgiacomo.travaglini@arm.com
206613481Sgiacomo.travaglini@arm.com  static pthread_key_t CreateKey() {
206713481Sgiacomo.travaglini@arm.com    pthread_key_t key;
206813481Sgiacomo.travaglini@arm.com    // When a thread exits, DeleteThreadLocalValue() will be called on
206913481Sgiacomo.travaglini@arm.com    // the object managed for that thread.
207013481Sgiacomo.travaglini@arm.com    GTEST_CHECK_POSIX_SUCCESS_(
207113481Sgiacomo.travaglini@arm.com        pthread_key_create(&key, &DeleteThreadLocalValue));
207213481Sgiacomo.travaglini@arm.com    return key;
207313481Sgiacomo.travaglini@arm.com  }
207413481Sgiacomo.travaglini@arm.com
207513481Sgiacomo.travaglini@arm.com  T* GetOrCreateValue() const {
207613481Sgiacomo.travaglini@arm.com    ThreadLocalValueHolderBase* const holder =
207713481Sgiacomo.travaglini@arm.com        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
207813481Sgiacomo.travaglini@arm.com    if (holder != NULL) {
207913481Sgiacomo.travaglini@arm.com      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
208013481Sgiacomo.travaglini@arm.com    }
208113481Sgiacomo.travaglini@arm.com
208213481Sgiacomo.travaglini@arm.com    ValueHolder* const new_holder = default_factory_->MakeNewHolder();
208313481Sgiacomo.travaglini@arm.com    ThreadLocalValueHolderBase* const holder_base = new_holder;
208413481Sgiacomo.travaglini@arm.com    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
208513481Sgiacomo.travaglini@arm.com    return new_holder->pointer();
208613481Sgiacomo.travaglini@arm.com  }
208713481Sgiacomo.travaglini@arm.com
208813481Sgiacomo.travaglini@arm.com  class ValueHolderFactory {
208913481Sgiacomo.travaglini@arm.com   public:
209013481Sgiacomo.travaglini@arm.com    ValueHolderFactory() {}
209113481Sgiacomo.travaglini@arm.com    virtual ~ValueHolderFactory() {}
209213481Sgiacomo.travaglini@arm.com    virtual ValueHolder* MakeNewHolder() const = 0;
209313481Sgiacomo.travaglini@arm.com
209413481Sgiacomo.travaglini@arm.com   private:
209513481Sgiacomo.travaglini@arm.com    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
209613481Sgiacomo.travaglini@arm.com  };
209713481Sgiacomo.travaglini@arm.com
209813481Sgiacomo.travaglini@arm.com  class DefaultValueHolderFactory : public ValueHolderFactory {
209913481Sgiacomo.travaglini@arm.com   public:
210013481Sgiacomo.travaglini@arm.com    DefaultValueHolderFactory() {}
210113481Sgiacomo.travaglini@arm.com    virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); }
210213481Sgiacomo.travaglini@arm.com
210313481Sgiacomo.travaglini@arm.com   private:
210413481Sgiacomo.travaglini@arm.com    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
210513481Sgiacomo.travaglini@arm.com  };
210613481Sgiacomo.travaglini@arm.com
210713481Sgiacomo.travaglini@arm.com  class InstanceValueHolderFactory : public ValueHolderFactory {
210813481Sgiacomo.travaglini@arm.com   public:
210913481Sgiacomo.travaglini@arm.com    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
211013481Sgiacomo.travaglini@arm.com    virtual ValueHolder* MakeNewHolder() const {
211113481Sgiacomo.travaglini@arm.com      return new ValueHolder(value_);
211213481Sgiacomo.travaglini@arm.com    }
211313481Sgiacomo.travaglini@arm.com
211413481Sgiacomo.travaglini@arm.com   private:
211513481Sgiacomo.travaglini@arm.com    const T value_;  // The value for each thread.
211613481Sgiacomo.travaglini@arm.com
211713481Sgiacomo.travaglini@arm.com    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
211813481Sgiacomo.travaglini@arm.com  };
211913481Sgiacomo.travaglini@arm.com
212013481Sgiacomo.travaglini@arm.com  // A key pthreads uses for looking up per-thread values.
212113481Sgiacomo.travaglini@arm.com  const pthread_key_t key_;
212213481Sgiacomo.travaglini@arm.com  scoped_ptr<ValueHolderFactory> default_factory_;
212313481Sgiacomo.travaglini@arm.com
212413481Sgiacomo.travaglini@arm.com  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
212513481Sgiacomo.travaglini@arm.com};
212613481Sgiacomo.travaglini@arm.com
212713481Sgiacomo.travaglini@arm.com# endif  // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
212813481Sgiacomo.travaglini@arm.com
212913481Sgiacomo.travaglini@arm.com#else  // GTEST_IS_THREADSAFE
213013481Sgiacomo.travaglini@arm.com
213113481Sgiacomo.travaglini@arm.com// A dummy implementation of synchronization primitives (mutex, lock,
213213481Sgiacomo.travaglini@arm.com// and thread-local variable).  Necessary for compiling Google Test where
213313481Sgiacomo.travaglini@arm.com// mutex is not supported - using Google Test in multiple threads is not
213413481Sgiacomo.travaglini@arm.com// supported on such platforms.
213513481Sgiacomo.travaglini@arm.com
213613481Sgiacomo.travaglini@arm.comclass Mutex {
213713481Sgiacomo.travaglini@arm.com public:
213813481Sgiacomo.travaglini@arm.com  Mutex() {}
213913481Sgiacomo.travaglini@arm.com  void Lock() {}
214013481Sgiacomo.travaglini@arm.com  void Unlock() {}
214113481Sgiacomo.travaglini@arm.com  void AssertHeld() const {}
214213481Sgiacomo.travaglini@arm.com};
214313481Sgiacomo.travaglini@arm.com
214413481Sgiacomo.travaglini@arm.com# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
214513481Sgiacomo.travaglini@arm.com  extern ::testing::internal::Mutex mutex
214613481Sgiacomo.travaglini@arm.com
214713481Sgiacomo.travaglini@arm.com# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
214813481Sgiacomo.travaglini@arm.com
214913481Sgiacomo.travaglini@arm.com// We cannot name this class MutexLock because the ctor declaration would
215013481Sgiacomo.travaglini@arm.com// conflict with a macro named MutexLock, which is defined on some
215113481Sgiacomo.travaglini@arm.com// platforms. That macro is used as a defensive measure to prevent against
215213481Sgiacomo.travaglini@arm.com// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
215313481Sgiacomo.travaglini@arm.com// "MutexLock l(&mu)".  Hence the typedef trick below.
215413481Sgiacomo.travaglini@arm.comclass GTestMutexLock {
215513481Sgiacomo.travaglini@arm.com public:
215613481Sgiacomo.travaglini@arm.com  explicit GTestMutexLock(Mutex*) {}  // NOLINT
215713481Sgiacomo.travaglini@arm.com};
215813481Sgiacomo.travaglini@arm.com
215913481Sgiacomo.travaglini@arm.comtypedef GTestMutexLock MutexLock;
216013481Sgiacomo.travaglini@arm.com
216113481Sgiacomo.travaglini@arm.comtemplate <typename T>
216213481Sgiacomo.travaglini@arm.comclass ThreadLocal {
216313481Sgiacomo.travaglini@arm.com public:
216413481Sgiacomo.travaglini@arm.com  ThreadLocal() : value_() {}
216513481Sgiacomo.travaglini@arm.com  explicit ThreadLocal(const T& value) : value_(value) {}
216613481Sgiacomo.travaglini@arm.com  T* pointer() { return &value_; }
216713481Sgiacomo.travaglini@arm.com  const T* pointer() const { return &value_; }
216813481Sgiacomo.travaglini@arm.com  const T& get() const { return value_; }
216913481Sgiacomo.travaglini@arm.com  void set(const T& value) { value_ = value; }
217013481Sgiacomo.travaglini@arm.com private:
217113481Sgiacomo.travaglini@arm.com  T value_;
217213481Sgiacomo.travaglini@arm.com};
217313481Sgiacomo.travaglini@arm.com
217413481Sgiacomo.travaglini@arm.com#endif  // GTEST_IS_THREADSAFE
217513481Sgiacomo.travaglini@arm.com
217613481Sgiacomo.travaglini@arm.com// Returns the number of threads running in the process, or 0 to indicate that
217713481Sgiacomo.travaglini@arm.com// we cannot detect it.
217813481Sgiacomo.travaglini@arm.comGTEST_API_ size_t GetThreadCount();
217913481Sgiacomo.travaglini@arm.com
218013481Sgiacomo.travaglini@arm.com// Passing non-POD classes through ellipsis (...) crashes the ARM
218113481Sgiacomo.travaglini@arm.com// compiler and generates a warning in Sun Studio.  The Nokia Symbian
218213481Sgiacomo.travaglini@arm.com// and the IBM XL C/C++ compiler try to instantiate a copy constructor
218313481Sgiacomo.travaglini@arm.com// for objects passed through ellipsis (...), failing for uncopyable
218413481Sgiacomo.travaglini@arm.com// objects.  We define this to ensure that only POD is passed through
218513481Sgiacomo.travaglini@arm.com// ellipsis on these systems.
218613481Sgiacomo.travaglini@arm.com#if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC)
218713481Sgiacomo.travaglini@arm.com// We lose support for NULL detection where the compiler doesn't like
218813481Sgiacomo.travaglini@arm.com// passing non-POD classes through ellipsis (...).
218913481Sgiacomo.travaglini@arm.com# define GTEST_ELLIPSIS_NEEDS_POD_ 1
219013481Sgiacomo.travaglini@arm.com#else
219113481Sgiacomo.travaglini@arm.com# define GTEST_CAN_COMPARE_NULL 1
219213481Sgiacomo.travaglini@arm.com#endif
219313481Sgiacomo.travaglini@arm.com
219413481Sgiacomo.travaglini@arm.com// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between
219513481Sgiacomo.travaglini@arm.com// const T& and const T* in a function template.  These compilers
219613481Sgiacomo.travaglini@arm.com// _can_ decide between class template specializations for T and T*,
219713481Sgiacomo.travaglini@arm.com// so a tr1::type_traits-like is_pointer works.
219813481Sgiacomo.travaglini@arm.com#if defined(__SYMBIAN32__) || defined(__IBMCPP__)
219913481Sgiacomo.travaglini@arm.com# define GTEST_NEEDS_IS_POINTER_ 1
220013481Sgiacomo.travaglini@arm.com#endif
220113481Sgiacomo.travaglini@arm.com
220213481Sgiacomo.travaglini@arm.comtemplate <bool bool_value>
220313481Sgiacomo.travaglini@arm.comstruct bool_constant {
220413481Sgiacomo.travaglini@arm.com  typedef bool_constant<bool_value> type;
220513481Sgiacomo.travaglini@arm.com  static const bool value = bool_value;
220613481Sgiacomo.travaglini@arm.com};
220713481Sgiacomo.travaglini@arm.comtemplate <bool bool_value> const bool bool_constant<bool_value>::value;
220813481Sgiacomo.travaglini@arm.com
220913481Sgiacomo.travaglini@arm.comtypedef bool_constant<false> false_type;
221013481Sgiacomo.travaglini@arm.comtypedef bool_constant<true> true_type;
221113481Sgiacomo.travaglini@arm.com
221213481Sgiacomo.travaglini@arm.comtemplate <typename T>
221313481Sgiacomo.travaglini@arm.comstruct is_pointer : public false_type {};
221413481Sgiacomo.travaglini@arm.com
221513481Sgiacomo.travaglini@arm.comtemplate <typename T>
221613481Sgiacomo.travaglini@arm.comstruct is_pointer<T*> : public true_type {};
221713481Sgiacomo.travaglini@arm.com
221813481Sgiacomo.travaglini@arm.comtemplate <typename Iterator>
221913481Sgiacomo.travaglini@arm.comstruct IteratorTraits {
222013481Sgiacomo.travaglini@arm.com  typedef typename Iterator::value_type value_type;
222113481Sgiacomo.travaglini@arm.com};
222213481Sgiacomo.travaglini@arm.com
222313481Sgiacomo.travaglini@arm.comtemplate <typename T>
222413481Sgiacomo.travaglini@arm.comstruct IteratorTraits<T*> {
222513481Sgiacomo.travaglini@arm.com  typedef T value_type;
222613481Sgiacomo.travaglini@arm.com};
222713481Sgiacomo.travaglini@arm.com
222813481Sgiacomo.travaglini@arm.comtemplate <typename T>
222913481Sgiacomo.travaglini@arm.comstruct IteratorTraits<const T*> {
223013481Sgiacomo.travaglini@arm.com  typedef T value_type;
223113481Sgiacomo.travaglini@arm.com};
223213481Sgiacomo.travaglini@arm.com
223313481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS
223413481Sgiacomo.travaglini@arm.com# define GTEST_PATH_SEP_ "\\"
223513481Sgiacomo.travaglini@arm.com# define GTEST_HAS_ALT_PATH_SEP_ 1
223613481Sgiacomo.travaglini@arm.com// The biggest signed integer type the compiler supports.
223713481Sgiacomo.travaglini@arm.comtypedef __int64 BiggestInt;
223813481Sgiacomo.travaglini@arm.com#else
223913481Sgiacomo.travaglini@arm.com# define GTEST_PATH_SEP_ "/"
224013481Sgiacomo.travaglini@arm.com# define GTEST_HAS_ALT_PATH_SEP_ 0
224113481Sgiacomo.travaglini@arm.comtypedef long long BiggestInt;  // NOLINT
224213481Sgiacomo.travaglini@arm.com#endif  // GTEST_OS_WINDOWS
224313481Sgiacomo.travaglini@arm.com
224413481Sgiacomo.travaglini@arm.com// Utilities for char.
224513481Sgiacomo.travaglini@arm.com
224613481Sgiacomo.travaglini@arm.com// isspace(int ch) and friends accept an unsigned char or EOF.  char
224713481Sgiacomo.travaglini@arm.com// may be signed, depending on the compiler (or compiler flags).
224813481Sgiacomo.travaglini@arm.com// Therefore we need to cast a char to unsigned char before calling
224913481Sgiacomo.travaglini@arm.com// isspace(), etc.
225013481Sgiacomo.travaglini@arm.com
225113481Sgiacomo.travaglini@arm.cominline bool IsAlpha(char ch) {
225213481Sgiacomo.travaglini@arm.com  return isalpha(static_cast<unsigned char>(ch)) != 0;
225313481Sgiacomo.travaglini@arm.com}
225413481Sgiacomo.travaglini@arm.cominline bool IsAlNum(char ch) {
225513481Sgiacomo.travaglini@arm.com  return isalnum(static_cast<unsigned char>(ch)) != 0;
225613481Sgiacomo.travaglini@arm.com}
225713481Sgiacomo.travaglini@arm.cominline bool IsDigit(char ch) {
225813481Sgiacomo.travaglini@arm.com  return isdigit(static_cast<unsigned char>(ch)) != 0;
225913481Sgiacomo.travaglini@arm.com}
226013481Sgiacomo.travaglini@arm.cominline bool IsLower(char ch) {
226113481Sgiacomo.travaglini@arm.com  return islower(static_cast<unsigned char>(ch)) != 0;
226213481Sgiacomo.travaglini@arm.com}
226313481Sgiacomo.travaglini@arm.cominline bool IsSpace(char ch) {
226413481Sgiacomo.travaglini@arm.com  return isspace(static_cast<unsigned char>(ch)) != 0;
226513481Sgiacomo.travaglini@arm.com}
226613481Sgiacomo.travaglini@arm.cominline bool IsUpper(char ch) {
226713481Sgiacomo.travaglini@arm.com  return isupper(static_cast<unsigned char>(ch)) != 0;
226813481Sgiacomo.travaglini@arm.com}
226913481Sgiacomo.travaglini@arm.cominline bool IsXDigit(char ch) {
227013481Sgiacomo.travaglini@arm.com  return isxdigit(static_cast<unsigned char>(ch)) != 0;
227113481Sgiacomo.travaglini@arm.com}
227213481Sgiacomo.travaglini@arm.cominline bool IsXDigit(wchar_t ch) {
227313481Sgiacomo.travaglini@arm.com  const unsigned char low_byte = static_cast<unsigned char>(ch);
227413481Sgiacomo.travaglini@arm.com  return ch == low_byte && isxdigit(low_byte) != 0;
227513481Sgiacomo.travaglini@arm.com}
227613481Sgiacomo.travaglini@arm.com
227713481Sgiacomo.travaglini@arm.cominline char ToLower(char ch) {
227813481Sgiacomo.travaglini@arm.com  return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
227913481Sgiacomo.travaglini@arm.com}
228013481Sgiacomo.travaglini@arm.cominline char ToUpper(char ch) {
228113481Sgiacomo.travaglini@arm.com  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
228213481Sgiacomo.travaglini@arm.com}
228313481Sgiacomo.travaglini@arm.com
228413481Sgiacomo.travaglini@arm.cominline std::string StripTrailingSpaces(std::string str) {
228513481Sgiacomo.travaglini@arm.com  std::string::iterator it = str.end();
228613481Sgiacomo.travaglini@arm.com  while (it != str.begin() && IsSpace(*--it))
228713481Sgiacomo.travaglini@arm.com    it = str.erase(it);
228813481Sgiacomo.travaglini@arm.com  return str;
228913481Sgiacomo.travaglini@arm.com}
229013481Sgiacomo.travaglini@arm.com
229113481Sgiacomo.travaglini@arm.com// The testing::internal::posix namespace holds wrappers for common
229213481Sgiacomo.travaglini@arm.com// POSIX functions.  These wrappers hide the differences between
229313481Sgiacomo.travaglini@arm.com// Windows/MSVC and POSIX systems.  Since some compilers define these
229413481Sgiacomo.travaglini@arm.com// standard functions as macros, the wrapper cannot have the same name
229513481Sgiacomo.travaglini@arm.com// as the wrapped function.
229613481Sgiacomo.travaglini@arm.com
229713481Sgiacomo.travaglini@arm.comnamespace posix {
229813481Sgiacomo.travaglini@arm.com
229913481Sgiacomo.travaglini@arm.com// Functions with a different name on Windows.
230013481Sgiacomo.travaglini@arm.com
230113481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS
230213481Sgiacomo.travaglini@arm.com
230313481Sgiacomo.travaglini@arm.comtypedef struct _stat StatStruct;
230413481Sgiacomo.travaglini@arm.com
230513481Sgiacomo.travaglini@arm.com# ifdef __BORLANDC__
230613481Sgiacomo.travaglini@arm.cominline int IsATTY(int fd) { return isatty(fd); }
230713481Sgiacomo.travaglini@arm.cominline int StrCaseCmp(const char* s1, const char* s2) {
230813481Sgiacomo.travaglini@arm.com  return stricmp(s1, s2);
230913481Sgiacomo.travaglini@arm.com}
231013481Sgiacomo.travaglini@arm.cominline char* StrDup(const char* src) { return strdup(src); }
231113481Sgiacomo.travaglini@arm.com# else  // !__BORLANDC__
231213481Sgiacomo.travaglini@arm.com#  if GTEST_OS_WINDOWS_MOBILE
231313481Sgiacomo.travaglini@arm.cominline int IsATTY(int /* fd */) { return 0; }
231413481Sgiacomo.travaglini@arm.com#  else
231513481Sgiacomo.travaglini@arm.cominline int IsATTY(int fd) { return _isatty(fd); }
231613481Sgiacomo.travaglini@arm.com#  endif  // GTEST_OS_WINDOWS_MOBILE
231713481Sgiacomo.travaglini@arm.cominline int StrCaseCmp(const char* s1, const char* s2) {
231813481Sgiacomo.travaglini@arm.com  return _stricmp(s1, s2);
231913481Sgiacomo.travaglini@arm.com}
232013481Sgiacomo.travaglini@arm.cominline char* StrDup(const char* src) { return _strdup(src); }
232113481Sgiacomo.travaglini@arm.com# endif  // __BORLANDC__
232213481Sgiacomo.travaglini@arm.com
232313481Sgiacomo.travaglini@arm.com# if GTEST_OS_WINDOWS_MOBILE
232413481Sgiacomo.travaglini@arm.cominline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
232513481Sgiacomo.travaglini@arm.com// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
232613481Sgiacomo.travaglini@arm.com// time and thus not defined there.
232713481Sgiacomo.travaglini@arm.com# else
232813481Sgiacomo.travaglini@arm.cominline int FileNo(FILE* file) { return _fileno(file); }
232913481Sgiacomo.travaglini@arm.cominline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
233013481Sgiacomo.travaglini@arm.cominline int RmDir(const char* dir) { return _rmdir(dir); }
233113481Sgiacomo.travaglini@arm.cominline bool IsDir(const StatStruct& st) {
233213481Sgiacomo.travaglini@arm.com  return (_S_IFDIR & st.st_mode) != 0;
233313481Sgiacomo.travaglini@arm.com}
233413481Sgiacomo.travaglini@arm.com# endif  // GTEST_OS_WINDOWS_MOBILE
233513481Sgiacomo.travaglini@arm.com
233613481Sgiacomo.travaglini@arm.com#else
233713481Sgiacomo.travaglini@arm.com
233813481Sgiacomo.travaglini@arm.comtypedef struct stat StatStruct;
233913481Sgiacomo.travaglini@arm.com
234013481Sgiacomo.travaglini@arm.cominline int FileNo(FILE* file) { return fileno(file); }
234113481Sgiacomo.travaglini@arm.cominline int IsATTY(int fd) { return isatty(fd); }
234213481Sgiacomo.travaglini@arm.cominline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
234313481Sgiacomo.travaglini@arm.cominline int StrCaseCmp(const char* s1, const char* s2) {
234413481Sgiacomo.travaglini@arm.com  return strcasecmp(s1, s2);
234513481Sgiacomo.travaglini@arm.com}
234613481Sgiacomo.travaglini@arm.cominline char* StrDup(const char* src) { return strdup(src); }
234713481Sgiacomo.travaglini@arm.cominline int RmDir(const char* dir) { return rmdir(dir); }
234813481Sgiacomo.travaglini@arm.cominline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
234913481Sgiacomo.travaglini@arm.com
235013481Sgiacomo.travaglini@arm.com#endif  // GTEST_OS_WINDOWS
235113481Sgiacomo.travaglini@arm.com
235213481Sgiacomo.travaglini@arm.com// Functions deprecated by MSVC 8.0.
235313481Sgiacomo.travaglini@arm.com
235413481Sgiacomo.travaglini@arm.comGTEST_DISABLE_MSC_WARNINGS_PUSH_(4996 /* deprecated function */)
235513481Sgiacomo.travaglini@arm.com
235613481Sgiacomo.travaglini@arm.cominline const char* StrNCpy(char* dest, const char* src, size_t n) {
235713481Sgiacomo.travaglini@arm.com  return strncpy(dest, src, n);
235813481Sgiacomo.travaglini@arm.com}
235913481Sgiacomo.travaglini@arm.com
236013481Sgiacomo.travaglini@arm.com// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and
236113481Sgiacomo.travaglini@arm.com// StrError() aren't needed on Windows CE at this time and thus not
236213481Sgiacomo.travaglini@arm.com// defined there.
236313481Sgiacomo.travaglini@arm.com
236413481Sgiacomo.travaglini@arm.com#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
236513481Sgiacomo.travaglini@arm.cominline int ChDir(const char* dir) { return chdir(dir); }
236613481Sgiacomo.travaglini@arm.com#endif
236713481Sgiacomo.travaglini@arm.cominline FILE* FOpen(const char* path, const char* mode) {
236813481Sgiacomo.travaglini@arm.com  return fopen(path, mode);
236913481Sgiacomo.travaglini@arm.com}
237013481Sgiacomo.travaglini@arm.com#if !GTEST_OS_WINDOWS_MOBILE
237113481Sgiacomo.travaglini@arm.cominline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
237213481Sgiacomo.travaglini@arm.com  return freopen(path, mode, stream);
237313481Sgiacomo.travaglini@arm.com}
237413481Sgiacomo.travaglini@arm.cominline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
237513481Sgiacomo.travaglini@arm.com#endif
237613481Sgiacomo.travaglini@arm.cominline int FClose(FILE* fp) { return fclose(fp); }
237713481Sgiacomo.travaglini@arm.com#if !GTEST_OS_WINDOWS_MOBILE
237813481Sgiacomo.travaglini@arm.cominline int Read(int fd, void* buf, unsigned int count) {
237913481Sgiacomo.travaglini@arm.com  return static_cast<int>(read(fd, buf, count));
238013481Sgiacomo.travaglini@arm.com}
238113481Sgiacomo.travaglini@arm.cominline int Write(int fd, const void* buf, unsigned int count) {
238213481Sgiacomo.travaglini@arm.com  return static_cast<int>(write(fd, buf, count));
238313481Sgiacomo.travaglini@arm.com}
238413481Sgiacomo.travaglini@arm.cominline int Close(int fd) { return close(fd); }
238513481Sgiacomo.travaglini@arm.cominline const char* StrError(int errnum) { return strerror(errnum); }
238613481Sgiacomo.travaglini@arm.com#endif
238713481Sgiacomo.travaglini@arm.cominline const char* GetEnv(const char* name) {
238813481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE | GTEST_OS_WINDOWS_RT
238913481Sgiacomo.travaglini@arm.com  // We are on Windows CE, which has no environment variables.
239013481Sgiacomo.travaglini@arm.com  static_cast<void>(name);  // To prevent 'unused argument' warning.
239113481Sgiacomo.travaglini@arm.com  return NULL;
239213481Sgiacomo.travaglini@arm.com#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
239313481Sgiacomo.travaglini@arm.com  // Environment variables which we programmatically clear will be set to the
239413481Sgiacomo.travaglini@arm.com  // empty string rather than unset (NULL).  Handle that case.
239513481Sgiacomo.travaglini@arm.com  const char* const env = getenv(name);
239613481Sgiacomo.travaglini@arm.com  return (env != NULL && env[0] != '\0') ? env : NULL;
239713481Sgiacomo.travaglini@arm.com#else
239813481Sgiacomo.travaglini@arm.com  return getenv(name);
239913481Sgiacomo.travaglini@arm.com#endif
240013481Sgiacomo.travaglini@arm.com}
240113481Sgiacomo.travaglini@arm.com
240213481Sgiacomo.travaglini@arm.comGTEST_DISABLE_MSC_WARNINGS_POP_()
240313481Sgiacomo.travaglini@arm.com
240413481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS_MOBILE
240513481Sgiacomo.travaglini@arm.com// Windows CE has no C library. The abort() function is used in
240613481Sgiacomo.travaglini@arm.com// several places in Google Test. This implementation provides a reasonable
240713481Sgiacomo.travaglini@arm.com// imitation of standard behaviour.
240813481Sgiacomo.travaglini@arm.comvoid Abort();
240913481Sgiacomo.travaglini@arm.com#else
241013481Sgiacomo.travaglini@arm.cominline void Abort() { abort(); }
241113481Sgiacomo.travaglini@arm.com#endif  // GTEST_OS_WINDOWS_MOBILE
241213481Sgiacomo.travaglini@arm.com
241313481Sgiacomo.travaglini@arm.com}  // namespace posix
241413481Sgiacomo.travaglini@arm.com
241513481Sgiacomo.travaglini@arm.com// MSVC "deprecates" snprintf and issues warnings wherever it is used.  In
241613481Sgiacomo.travaglini@arm.com// order to avoid these warnings, we need to use _snprintf or _snprintf_s on
241713481Sgiacomo.travaglini@arm.com// MSVC-based platforms.  We map the GTEST_SNPRINTF_ macro to the appropriate
241813481Sgiacomo.travaglini@arm.com// function in order to achieve that.  We use macro definition here because
241913481Sgiacomo.travaglini@arm.com// snprintf is a variadic function.
242013481Sgiacomo.travaglini@arm.com#if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE
242113481Sgiacomo.travaglini@arm.com// MSVC 2005 and above support variadic macros.
242213481Sgiacomo.travaglini@arm.com# define GTEST_SNPRINTF_(buffer, size, format, ...) \
242313481Sgiacomo.travaglini@arm.com     _snprintf_s(buffer, size, size, format, __VA_ARGS__)
242413481Sgiacomo.travaglini@arm.com#elif defined(_MSC_VER)
242513481Sgiacomo.travaglini@arm.com// Windows CE does not define _snprintf_s and MSVC prior to 2005 doesn't
242613481Sgiacomo.travaglini@arm.com// complain about _snprintf.
242713481Sgiacomo.travaglini@arm.com# define GTEST_SNPRINTF_ _snprintf
242813481Sgiacomo.travaglini@arm.com#else
242913481Sgiacomo.travaglini@arm.com# define GTEST_SNPRINTF_ snprintf
243013481Sgiacomo.travaglini@arm.com#endif
243113481Sgiacomo.travaglini@arm.com
243213481Sgiacomo.travaglini@arm.com// The maximum number a BiggestInt can represent.  This definition
243313481Sgiacomo.travaglini@arm.com// works no matter BiggestInt is represented in one's complement or
243413481Sgiacomo.travaglini@arm.com// two's complement.
243513481Sgiacomo.travaglini@arm.com//
243613481Sgiacomo.travaglini@arm.com// We cannot rely on numeric_limits in STL, as __int64 and long long
243713481Sgiacomo.travaglini@arm.com// are not part of standard C++ and numeric_limits doesn't need to be
243813481Sgiacomo.travaglini@arm.com// defined for them.
243913481Sgiacomo.travaglini@arm.comconst BiggestInt kMaxBiggestInt =
244013481Sgiacomo.travaglini@arm.com    ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1));
244113481Sgiacomo.travaglini@arm.com
244213481Sgiacomo.travaglini@arm.com// This template class serves as a compile-time function from size to
244313481Sgiacomo.travaglini@arm.com// type.  It maps a size in bytes to a primitive type with that
244413481Sgiacomo.travaglini@arm.com// size. e.g.
244513481Sgiacomo.travaglini@arm.com//
244613481Sgiacomo.travaglini@arm.com//   TypeWithSize<4>::UInt
244713481Sgiacomo.travaglini@arm.com//
244813481Sgiacomo.travaglini@arm.com// is typedef-ed to be unsigned int (unsigned integer made up of 4
244913481Sgiacomo.travaglini@arm.com// bytes).
245013481Sgiacomo.travaglini@arm.com//
245113481Sgiacomo.travaglini@arm.com// Such functionality should belong to STL, but I cannot find it
245213481Sgiacomo.travaglini@arm.com// there.
245313481Sgiacomo.travaglini@arm.com//
245413481Sgiacomo.travaglini@arm.com// Google Test uses this class in the implementation of floating-point
245513481Sgiacomo.travaglini@arm.com// comparison.
245613481Sgiacomo.travaglini@arm.com//
245713481Sgiacomo.travaglini@arm.com// For now it only handles UInt (unsigned int) as that's all Google Test
245813481Sgiacomo.travaglini@arm.com// needs.  Other types can be easily added in the future if need
245913481Sgiacomo.travaglini@arm.com// arises.
246013481Sgiacomo.travaglini@arm.comtemplate <size_t size>
246113481Sgiacomo.travaglini@arm.comclass TypeWithSize {
246213481Sgiacomo.travaglini@arm.com public:
246313481Sgiacomo.travaglini@arm.com  // This prevents the user from using TypeWithSize<N> with incorrect
246413481Sgiacomo.travaglini@arm.com  // values of N.
246513481Sgiacomo.travaglini@arm.com  typedef void UInt;
246613481Sgiacomo.travaglini@arm.com};
246713481Sgiacomo.travaglini@arm.com
246813481Sgiacomo.travaglini@arm.com// The specialization for size 4.
246913481Sgiacomo.travaglini@arm.comtemplate <>
247013481Sgiacomo.travaglini@arm.comclass TypeWithSize<4> {
247113481Sgiacomo.travaglini@arm.com public:
247213481Sgiacomo.travaglini@arm.com  // unsigned int has size 4 in both gcc and MSVC.
247313481Sgiacomo.travaglini@arm.com  //
247413481Sgiacomo.travaglini@arm.com  // As base/basictypes.h doesn't compile on Windows, we cannot use
247513481Sgiacomo.travaglini@arm.com  // uint32, uint64, and etc here.
247613481Sgiacomo.travaglini@arm.com  typedef int Int;
247713481Sgiacomo.travaglini@arm.com  typedef unsigned int UInt;
247813481Sgiacomo.travaglini@arm.com};
247913481Sgiacomo.travaglini@arm.com
248013481Sgiacomo.travaglini@arm.com// The specialization for size 8.
248113481Sgiacomo.travaglini@arm.comtemplate <>
248213481Sgiacomo.travaglini@arm.comclass TypeWithSize<8> {
248313481Sgiacomo.travaglini@arm.com public:
248413481Sgiacomo.travaglini@arm.com#if GTEST_OS_WINDOWS
248513481Sgiacomo.travaglini@arm.com  typedef __int64 Int;
248613481Sgiacomo.travaglini@arm.com  typedef unsigned __int64 UInt;
248713481Sgiacomo.travaglini@arm.com#else
248813481Sgiacomo.travaglini@arm.com  typedef long long Int;  // NOLINT
248913481Sgiacomo.travaglini@arm.com  typedef unsigned long long UInt;  // NOLINT
249013481Sgiacomo.travaglini@arm.com#endif  // GTEST_OS_WINDOWS
249113481Sgiacomo.travaglini@arm.com};
249213481Sgiacomo.travaglini@arm.com
249313481Sgiacomo.travaglini@arm.com// Integer types of known sizes.
249413481Sgiacomo.travaglini@arm.comtypedef TypeWithSize<4>::Int Int32;
249513481Sgiacomo.travaglini@arm.comtypedef TypeWithSize<4>::UInt UInt32;
249613481Sgiacomo.travaglini@arm.comtypedef TypeWithSize<8>::Int Int64;
249713481Sgiacomo.travaglini@arm.comtypedef TypeWithSize<8>::UInt UInt64;
249813481Sgiacomo.travaglini@arm.comtypedef TypeWithSize<8>::Int TimeInMillis;  // Represents time in milliseconds.
249913481Sgiacomo.travaglini@arm.com
250013481Sgiacomo.travaglini@arm.com// Utilities for command line flags and environment variables.
250113481Sgiacomo.travaglini@arm.com
250213481Sgiacomo.travaglini@arm.com// Macro for referencing flags.
250313481Sgiacomo.travaglini@arm.com#if !defined(GTEST_FLAG)
250413481Sgiacomo.travaglini@arm.com# define GTEST_FLAG(name) FLAGS_gtest_##name
250513481Sgiacomo.travaglini@arm.com#endif  // !defined(GTEST_FLAG)
250613481Sgiacomo.travaglini@arm.com
250713481Sgiacomo.travaglini@arm.com#if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
250813481Sgiacomo.travaglini@arm.com# define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
250913481Sgiacomo.travaglini@arm.com#endif  // !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
251013481Sgiacomo.travaglini@arm.com
251113481Sgiacomo.travaglini@arm.com#if !defined(GTEST_DECLARE_bool_)
251213481Sgiacomo.travaglini@arm.com# define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
251313481Sgiacomo.travaglini@arm.com
251413481Sgiacomo.travaglini@arm.com// Macros for declaring flags.
251513481Sgiacomo.travaglini@arm.com# define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
251613481Sgiacomo.travaglini@arm.com# define GTEST_DECLARE_int32_(name) \
251713481Sgiacomo.travaglini@arm.com    GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name)
251813481Sgiacomo.travaglini@arm.com#define GTEST_DECLARE_string_(name) \
251913481Sgiacomo.travaglini@arm.com    GTEST_API_ extern ::std::string GTEST_FLAG(name)
252013481Sgiacomo.travaglini@arm.com
252113481Sgiacomo.travaglini@arm.com// Macros for defining flags.
252213481Sgiacomo.travaglini@arm.com#define GTEST_DEFINE_bool_(name, default_val, doc) \
252313481Sgiacomo.travaglini@arm.com    GTEST_API_ bool GTEST_FLAG(name) = (default_val)
252413481Sgiacomo.travaglini@arm.com#define GTEST_DEFINE_int32_(name, default_val, doc) \
252513481Sgiacomo.travaglini@arm.com    GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val)
252613481Sgiacomo.travaglini@arm.com#define GTEST_DEFINE_string_(name, default_val, doc) \
252713481Sgiacomo.travaglini@arm.com    GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)
252813481Sgiacomo.travaglini@arm.com
252913481Sgiacomo.travaglini@arm.com#endif  // !defined(GTEST_DECLARE_bool_)
253013481Sgiacomo.travaglini@arm.com
253113481Sgiacomo.travaglini@arm.com// Thread annotations
253213481Sgiacomo.travaglini@arm.com#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
253313481Sgiacomo.travaglini@arm.com# define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
253413481Sgiacomo.travaglini@arm.com# define GTEST_LOCK_EXCLUDED_(locks)
253513481Sgiacomo.travaglini@arm.com#endif  // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
253613481Sgiacomo.travaglini@arm.com
253713481Sgiacomo.travaglini@arm.com// Parses 'str' for a 32-bit signed integer.  If successful, writes the result
253813481Sgiacomo.travaglini@arm.com// to *value and returns true; otherwise leaves *value unchanged and returns
253913481Sgiacomo.travaglini@arm.com// false.
254013481Sgiacomo.travaglini@arm.com// TODO(chandlerc): Find a better way to refactor flag and environment parsing
254113481Sgiacomo.travaglini@arm.com// out of both gtest-port.cc and gtest.cc to avoid exporting this utility
254213481Sgiacomo.travaglini@arm.com// function.
254313481Sgiacomo.travaglini@arm.combool ParseInt32(const Message& src_text, const char* str, Int32* value);
254413481Sgiacomo.travaglini@arm.com
254513481Sgiacomo.travaglini@arm.com// Parses a bool/Int32/string from the environment variable
254613481Sgiacomo.travaglini@arm.com// corresponding to the given Google Test flag.
254713481Sgiacomo.travaglini@arm.combool BoolFromGTestEnv(const char* flag, bool default_val);
254813481Sgiacomo.travaglini@arm.comGTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val);
254913481Sgiacomo.travaglini@arm.comstd::string StringFromGTestEnv(const char* flag, const char* default_val);
255013481Sgiacomo.travaglini@arm.com
255113481Sgiacomo.travaglini@arm.com}  // namespace internal
255213481Sgiacomo.travaglini@arm.com}  // namespace testing
255313481Sgiacomo.travaglini@arm.com
255413481Sgiacomo.travaglini@arm.com#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
2555