// Copyright 2005, Google Inc.

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

// Authors: wan@google.com (Zhanyong Wan)

//

// Low-level types and utilities for porting Google Test to various

// platforms.  All macros ending with _ and symbols defined in an

// internal namespace are subject to change without notice.  Code

// outside Google Test MUST NOT USE THEM DIRECTLY.  Macros that don't

// end with _ are part of Google Test's public API and can be used by

// code outside Google Test.

//

// This file is fundamental to Google Test.  All other Google Test source

// files are expected to #include this.  Therefore, it cannot #include

// any other Google Test header.

#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_

// Environment-describing macros

// -----------------------------

//

// Google Test can be used in many different environments.  Macros in

// this section tell Google Test what kind of environment it is being

// used in, such that Google Test can provide environment-specific

// features and implementations.

//

// Google Test tries to automatically detect the properties of its

// environment, so users usually don't need to worry about these

// macros.  However, the automatic detection is not perfect.

// Sometimes it's necessary for a user to define some of the following

// macros in the build script to override Google Test's decisions.

//

// If the user doesn't define a macro in the list, Google Test will

// provide a default definition.  After this header is #included, all

// macros in this list will be defined to either 1 or 0.

//

// Notes to maintainers:

//   - Each macro here is a user-tweakable knob; do not grow the list

//     lightly.

//   - Use #if to key off these macros.  Don't use #ifdef or "#if

//     defined(...)", which will not work as these macros are ALWAYS

//     defined.

//

//   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)

//                              is/isn't available.

//   GTEST_HAS_EXCEPTIONS     - Define it to 1/0 to indicate that exceptions

//                              are enabled.

//   GTEST_HAS_GLOBAL_STRING  - Define it to 1/0 to indicate that ::string

//                              is/isn't available (some systems define

//                              ::string, which is different to std::string).

//   GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string

//                              is/isn't available (some systems define

//                              ::wstring, which is different to std::wstring).

//   GTEST_HAS_POSIX_RE       - Define it to 1/0 to indicate that POSIX regular

//                              expressions are/aren't available.

//   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>

//                              is/isn't available.

//   GTEST_HAS_RTTI           - Define it to 1/0 to indicate that RTTI is/isn't

//                              enabled.

//   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that

//                              std::wstring does/doesn't work (Google Test can

//                              be used where std::wstring is unavailable).

//   GTEST_HAS_TR1_TUPLE      - Define it to 1/0 to indicate tr1::tuple

//                              is/isn't available.

//   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the

//                              compiler supports Microsoft's "Structured

//                              Exception Handling".

//   GTEST_HAS_STREAM_REDIRECTION

//                            - Define it to 1/0 to indicate whether the

//                              platform supports I/O stream redirection using

//                              dup() and dup2().

//   GTEST_USE_OWN_TR1_TUPLE  - Define it to 1/0 to indicate whether Google

//                              Test's own tr1 tuple implementation should be

//                              used.  Unused when the user sets

//                              GTEST_HAS_TR1_TUPLE to 0.

//   GTEST_LANG_CXX11         - Define it to 1/0 to indicate that Google Test

//                              is building in C++11/C++98 mode.

//   GTEST_LINKED_AS_SHARED_LIBRARY

//                            - Define to 1 when compiling tests that use

//                              Google Test as a shared library (known as

//                              DLL on Windows).

//   GTEST_CREATE_SHARED_LIBRARY

//                            - Define to 1 when compiling Google Test itself

//                              as a shared library.

// Platform-indicating macros

// --------------------------

//

// Macros indicating the platform on which Google Test is being used

// (a macro is defined to 1 if compiled on the given platform;

// otherwise UNDEFINED -- it's never defined to 0.).  Google Test

// defines these macros automatically.  Code outside Google Test MUST

// NOT define them.

//

//   GTEST_OS_AIX      - IBM AIX

//   GTEST_OS_CYGWIN   - Cygwin

//   GTEST_OS_FREEBSD  - FreeBSD

//   GTEST_OS_HAIKU    - Haiku

//   GTEST_OS_HPUX     - HP-UX

//   GTEST_OS_LINUX    - Linux

//     GTEST_OS_LINUX_ANDROID - Google Android

//   GTEST_OS_MAC      - Mac OS X

//     GTEST_OS_IOS    - iOS

//   GTEST_OS_MINIX    - Minix

//   GTEST_OS_NACL     - Google Native Client (NaCl)

//   GTEST_OS_OPENBSD  - OpenBSD

//   GTEST_OS_QNX      - QNX

//   GTEST_OS_SOLARIS  - Sun Solaris

//   GTEST_OS_SYMBIAN  - Symbian

//   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)

//     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop

//     GTEST_OS_WINDOWS_MINGW    - MinGW

//     GTEST_OS_WINDOWS_MOBILE   - Windows Mobile

//     GTEST_OS_WINDOWS_PHONE    - Windows Phone

//     GTEST_OS_WINDOWS_RT       - Windows Store App/WinRT

//   GTEST_OS_ZOS      - z/OS

//

// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the

// most stable support.  Since core members of the Google Test project

// don't have access to other platforms, support for them may be less

// stable.  If you notice any problems on your platform, please notify

// googletestframework@googlegroups.com (patches for fixing them are

// even more welcome!).

//

// It is possible that none of the GTEST_OS_* macros are defined.

// Feature-indicating macros

// -------------------------

//

// Macros indicating which Google Test features are available (a macro

// is defined to 1 if the corresponding feature is supported;

// otherwise UNDEFINED -- it's never defined to 0.).  Google Test

// defines these macros automatically.  Code outside Google Test MUST

// NOT define them.

//

// These macros are public so that portable tests can be written.

// Such tests typically surround code using a feature with an #if

// which controls that code.  For example:

//

// #if GTEST_HAS_DEATH_TEST

//   EXPECT_DEATH(DoSomethingDeadly());

// #endif

//

//   GTEST_HAS_COMBINE      - the Combine() function (for value-parameterized

//                            tests)

//   GTEST_HAS_DEATH_TEST   - death tests

//   GTEST_HAS_PARAM_TEST   - value-parameterized tests

//   GTEST_HAS_TYPED_TEST   - typed tests

//   GTEST_HAS_TYPED_TEST_P - type-parameterized tests

//   GTEST_IS_THREADSAFE    - Google Test is thread-safe.

//   GTEST_USES_POSIX_RE    - enhanced POSIX regex is used. Do not confuse with

//                            GTEST_HAS_POSIX_RE (see above) which users can

//                            define themselves.

//   GTEST_USES_SIMPLE_RE   - our own simple regex is used;

//                            the above two are mutually exclusive.

//   GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ().

// Misc public macros

// ------------------

//

//   GTEST_FLAG(flag_name)  - references the variable corresponding to

//                            the given Google Test flag.

// Internal utilities

// ------------------

//

// The following macros and utilities are for Google Test's INTERNAL

// use only.  Code outside Google Test MUST NOT USE THEM DIRECTLY.

//

// Macros for basic C++ coding:

//   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.

//   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a

//                              variable don't have to be used.

//   GTEST_DISALLOW_ASSIGN_   - disables operator=.

//   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.

//   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.

//   GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is

//                                        suppressed (constant conditional).

//   GTEST_INTENTIONAL_CONST_COND_POP_  - finish code section where MSVC C4127

//                                        is suppressed.

//

// C++11 feature wrappers:

//

//   testing::internal::move  - portability wrapper for std::move.

//

// Synchronization:

//   Mutex, MutexLock, ThreadLocal, GetThreadCount()

//                            - synchronization primitives.

//

// Template meta programming:

//   is_pointer     - as in TR1; needed on Symbian and IBM XL C/C++ only.

//   IteratorTraits - partial implementation of std::iterator_traits, which

//                    is not available in libCstd when compiled with Sun C++.

//

// Smart pointers:

//   scoped_ptr     - as in TR2.

//

// Regular expressions:

//   RE             - a simple regular expression class using the POSIX

//                    Extended Regular Expression syntax on UNIX-like

//                    platforms, or a reduced regular exception syntax on

//                    other platforms, including Windows.

//

// Logging:

//   GTEST_LOG_()   - logs messages at the specified severity level.

//   LogToStderr()  - directs all log messages to stderr.

//   FlushInfoLog() - flushes informational log messages.

//

// Stdout and stderr capturing:

//   CaptureStdout()     - starts capturing stdout.

//   GetCapturedStdout() - stops capturing stdout and returns the captured

//                         string.

//   CaptureStderr()     - starts capturing stderr.

//   GetCapturedStderr() - stops capturing stderr and returns the captured

//                         string.

//

// Integer types:

//   TypeWithSize   - maps an integer to a int type.

//   Int32, UInt32, Int64, UInt64, TimeInMillis

//                  - integers of known sizes.

//   BiggestInt     - the biggest signed integer type.

//

// Command-line utilities:

//   GTEST_DECLARE_*()  - declares a flag.

//   GTEST_DEFINE_*()   - defines a flag.

//   GetInjectableArgvs() - returns the command line as a vector of strings.

//

// Environment variable utilities:

//   GetEnv()             - gets the value of an environment variable.

//   BoolFromGTestEnv()   - parses a bool environment variable.

//   Int32FromGTestEnv()  - parses an Int32 environment variable.

//   StringFromGTestEnv() - parses a string environment variable.

#include <ctype.h>   // for isspace, etc

#include <stddef.h>  // for ptrdiff_t

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#ifndef _WIN32_WCE

# include <sys/types.h>

# include <sys/stat.h>

#endif  // !_WIN32_WCE

#if defined __APPLE__

# include <AvailabilityMacros.h>

# include <TargetConditionals.h>

#endif

#include <algorithm>  // NOLINT

#include <iostream>  // NOLINT

#include <sstream>  // NOLINT

#include <string>  // NOLINT

#include <utility>

#include <vector>  // NOLINT

#include "gtest/internal/gtest-port-arch.h"

#include "gtest/internal/custom/gtest-port.h"

#if !defined(GTEST_DEV_EMAIL_)

# define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"

# define GTEST_FLAG_PREFIX_ "gtest_"

# define GTEST_FLAG_PREFIX_DASH_ "gtest-"

# define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"

# define GTEST_NAME_ "Google Test"

# define GTEST_PROJECT_URL_ "https://github.com/google/googletest/"

#endif  // !defined(GTEST_DEV_EMAIL_)

#if !defined(GTEST_INIT_GOOGLE_TEST_NAME_)

# define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest"

#endif  // !defined(GTEST_INIT_GOOGLE_TEST_NAME_)

// Determines the version of gcc that is used to compile this.

#ifdef __GNUC__

// 40302 means version 4.3.2.

# define GTEST_GCC_VER_ \

    (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)

#endif  // __GNUC__

// Macros for disabling Microsoft Visual C++ warnings.

//

//   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385)

//   /* code that triggers warnings C4800 and C4385 */

//   GTEST_DISABLE_MSC_WARNINGS_POP_()

#if _MSC_VER >= 1500

# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \

    __pragma(warning(push))                        \

    __pragma(warning(disable: warnings))

# define GTEST_DISABLE_MSC_WARNINGS_POP_()          \

    __pragma(warning(pop))

#else

// Older versions of MSVC don't have __pragma.

# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)

# define GTEST_DISABLE_MSC_WARNINGS_POP_()

#endif

#ifndef GTEST_LANG_CXX11

// gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when

// -std={c,gnu}++{0x,11} is passed.  The C++11 standard specifies a

// value for __cplusplus, and recent versions of clang, gcc, and

// probably other compilers set that too in C++11 mode.

# if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L

// Compiling in at least C++11 mode.

#  define GTEST_LANG_CXX11 1

# else

#  define GTEST_LANG_CXX11 0

# endif

#endif

// Distinct from C++11 language support, some environments don't provide

// proper C++11 library support. Notably, it's possible to build in

// C++11 mode when targeting Mac OS X 10.6, which has an old libstdc++

// with no C++11 support.

//

// libstdc++ has sufficient C++11 support as of GCC 4.6.0, __GLIBCXX__

// 20110325, but maintenance releases in the 4.4 and 4.5 series followed

// this date, so check for those versions by their date stamps.

// https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html#abi.versioning

#if GTEST_LANG_CXX11 && \

    (!defined(__GLIBCXX__) || ( \

        __GLIBCXX__ >= 20110325ul &&  /* GCC >= 4.6.0 */ \

        /* Blacklist of patch releases of older branches: */ \

        __GLIBCXX__ != 20110416ul &&  /* GCC 4.4.6 */ \

        __GLIBCXX__ != 20120313ul &&  /* GCC 4.4.7 */ \

        __GLIBCXX__ != 20110428ul &&  /* GCC 4.5.3 */ \

        __GLIBCXX__ != 20120702ul))   /* GCC 4.5.4 */

# define GTEST_STDLIB_CXX11 1

#endif

// Only use C++11 library features if the library provides them.

#if GTEST_STDLIB_CXX11

# define GTEST_HAS_STD_BEGIN_AND_END_ 1

# define GTEST_HAS_STD_FORWARD_LIST_ 1

# define GTEST_HAS_STD_FUNCTION_ 1

# define GTEST_HAS_STD_INITIALIZER_LIST_ 1

# define GTEST_HAS_STD_MOVE_ 1

# define GTEST_HAS_STD_SHARED_PTR_ 1

# define GTEST_HAS_STD_TYPE_TRAITS_ 1

# define GTEST_HAS_STD_UNIQUE_PTR_ 1

#endif

// C++11 specifies that <tuple> provides std::tuple.

// Some platforms still might not have it, however.

#if GTEST_LANG_CXX11

# define GTEST_HAS_STD_TUPLE_ 1

# if defined(__clang__)

// Inspired by http://clang.llvm.org/docs/LanguageExtensions.html#__has_include

#  if defined(__has_include) && !__has_include(<tuple>)

#   undef GTEST_HAS_STD_TUPLE_

#  endif

# elif defined(_MSC_VER)

// Inspired by boost/config/stdlib/dinkumware.hpp

#  if defined(_CPPLIB_VER) && _CPPLIB_VER < 520

#   undef GTEST_HAS_STD_TUPLE_

#  endif

# elif defined(__GLIBCXX__)

// Inspired by boost/config/stdlib/libstdcpp3.hpp,

// http://gcc.gnu.org/gcc-4.2/changes.html and

// http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt01ch01.html#manual.intro.status.standard.200x

#  if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2)

#   undef GTEST_HAS_STD_TUPLE_

#  endif

# endif

#endif

// Brings in definitions for functions used in the testing::internal::posix

// namespace (read, write, close, chdir, isatty, stat). We do not currently

// use them on Windows Mobile.

#if GTEST_OS_WINDOWS

# if !GTEST_OS_WINDOWS_MOBILE

#  include <direct.h>

#  include <io.h>

# endif

// In order to avoid having to include <windows.h>, use forward declaration

// assuming CRITICAL_SECTION is a typedef of _RTL_CRITICAL_SECTION.

// This assumption is verified by

// WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION.

struct _RTL_CRITICAL_SECTION;

#else

// This assumes that non-Windows OSes provide unistd.h. For OSes where this

// is not the case, we need to include headers that provide the functions

// mentioned above.

# include <unistd.h>

# include <strings.h>

#endif  // GTEST_OS_WINDOWS

#if GTEST_OS_LINUX_ANDROID

// Used to define __ANDROID_API__ matching the target NDK API level.

#  include <android/api-level.h>  // NOLINT

#endif

// Defines this to true iff Google Test can use POSIX regular expressions.

#ifndef GTEST_HAS_POSIX_RE

# if GTEST_OS_LINUX_ANDROID

// On Android, <regex.h> is only available starting with Gingerbread.

#  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)

# else

#  define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS)

# endif

#endif

#if GTEST_USES_PCRE

// The appropriate headers have already been included.

#elif GTEST_HAS_POSIX_RE

// On some platforms, <regex.h> needs someone to define size_t, and

// won't compile otherwise.  We can #include it here as we already

// included <stdlib.h>, which is guaranteed to define size_t through

// <stddef.h>.

# include <regex.h>  // NOLINT

# define GTEST_USES_POSIX_RE 1

#elif GTEST_OS_WINDOWS

// <regex.h> is not available on Windows.  Use our own simple regex

// implementation instead.

# define GTEST_USES_SIMPLE_RE 1

#else

// <regex.h> may not be available on this platform.  Use our own

// simple regex implementation instead.

# define GTEST_USES_SIMPLE_RE 1

#endif  // GTEST_USES_PCRE

#ifndef GTEST_HAS_EXCEPTIONS

// The user didn't tell us whether exceptions are enabled, so we need

// to figure it out.

# if defined(_MSC_VER) || defined(__BORLANDC__)

// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS

// macro to enable exceptions, so we'll do the same.

// Assumes that exceptions are enabled by default.

#  ifndef _HAS_EXCEPTIONS

#   define _HAS_EXCEPTIONS 1

#  endif  // _HAS_EXCEPTIONS

#  define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS

# elif defined(__clang__)

// clang defines __EXCEPTIONS iff exceptions are enabled before clang 220714,

// but iff cleanups are enabled after that. In Obj-C++ files, there can be

// cleanups for ObjC exceptions which also need cleanups, even if C++ exceptions

// are disabled. clang has __has_feature(cxx_exceptions) which checks for C++

// exceptions starting at clang r206352, but which checked for cleanups prior to

// that. To reliably check for C++ exception availability with clang, check for

// __EXCEPTIONS && __has_feature(cxx_exceptions).

#  define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions))

# elif defined(__GNUC__) && __EXCEPTIONS

// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled.

#  define GTEST_HAS_EXCEPTIONS 1

# elif defined(__SUNPRO_CC)

// Sun Pro CC supports exceptions.  However, there is no compile-time way of

// detecting whether they are enabled or not.  Therefore, we assume that

// they are enabled unless the user tells us otherwise.

#  define GTEST_HAS_EXCEPTIONS 1

# elif defined(__IBMCPP__) && __EXCEPTIONS

// xlC defines __EXCEPTIONS to 1 iff exceptions are enabled.

#  define GTEST_HAS_EXCEPTIONS 1

# elif defined(__HP_aCC)

// Exception handling is in effect by default in HP aCC compiler. It has to

// be turned of by +noeh compiler option if desired.

#  define GTEST_HAS_EXCEPTIONS 1

# else

// For other compilers, we assume exceptions are disabled to be

// conservative.

#  define GTEST_HAS_EXCEPTIONS 0

# endif  // defined(_MSC_VER) || defined(__BORLANDC__)

#endif  // GTEST_HAS_EXCEPTIONS

#if !defined(GTEST_HAS_STD_STRING)

// Even though we don't use this macro any longer, we keep it in case

// some clients still depend on it.

# define GTEST_HAS_STD_STRING 1

#elif !GTEST_HAS_STD_STRING

// The user told us that ::std::string isn't available.

# error "Google Test cannot be used where ::std::string isn't available."

#endif  // !defined(GTEST_HAS_STD_STRING)

#ifndef GTEST_HAS_GLOBAL_STRING

// The user didn't tell us whether ::string is available, so we need

// to figure it out.

# define GTEST_HAS_GLOBAL_STRING 0

#endif  // GTEST_HAS_GLOBAL_STRING

#ifndef GTEST_HAS_STD_WSTRING

// The user didn't tell us whether ::std::wstring is available, so we need

// to figure it out.

// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring

//   is available.

// Cygwin 1.7 and below doesn't support ::std::wstring.

// Solaris' libc++ doesn't support it either.  Android has

// no support for it at least as recent as Froyo (2.2).

// Minix currently doesn't support it either.

# define GTEST_HAS_STD_WSTRING \

    (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || GTEST_OS_HAIKU || GTEST_OS_MINIX))

#endif  // GTEST_HAS_STD_WSTRING

#ifndef GTEST_HAS_GLOBAL_WSTRING

// The user didn't tell us whether ::wstring is available, so we need

// to figure it out.

# define GTEST_HAS_GLOBAL_WSTRING \

    (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING)

#endif  // GTEST_HAS_GLOBAL_WSTRING

// Determines whether RTTI is available.

#ifndef GTEST_HAS_RTTI

// The user didn't tell us whether RTTI is enabled, so we need to

// figure it out.

# ifdef _MSC_VER

#  ifdef _CPPRTTI  // MSVC defines this macro iff RTTI is enabled.

#   define GTEST_HAS_RTTI 1

#  else

#   define GTEST_HAS_RTTI 0

#  endif

// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled.

# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302)

#  ifdef __GXX_RTTI

// When building against STLport with the Android NDK and with

// -frtti -fno-exceptions, the build fails at link time with undefined

// references to __cxa_bad_typeid. Note sure if STL or toolchain bug,

// so disable RTTI when detected.

#   if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \

       !defined(__EXCEPTIONS)

#    define GTEST_HAS_RTTI 0

#   else

#    define GTEST_HAS_RTTI 1

#   endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS

#  else

#   define GTEST_HAS_RTTI 0

#  endif  // __GXX_RTTI

// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends

// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the

// first version with C++ support.

# elif defined(__clang__)

#  define GTEST_HAS_RTTI __has_feature(cxx_rtti)

// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if

// both the typeid and dynamic_cast features are present.

# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)

#  ifdef __RTTI_ALL__

#   define GTEST_HAS_RTTI 1

#  else

#   define GTEST_HAS_RTTI 0

#  endif

# else

// For all other compilers, we assume RTTI is enabled.

#  define GTEST_HAS_RTTI 1

# endif  // _MSC_VER

#endif  // GTEST_HAS_RTTI

// It's this header's responsibility to #include <typeinfo> when RTTI

// is enabled.

#if GTEST_HAS_RTTI

# include <typeinfo>

#endif

// Determines whether Google Test can use the pthreads library.

#ifndef GTEST_HAS_PTHREAD

// The user didn't tell us explicitly, so we make reasonable assumptions about

// which platforms have pthreads support.

//

// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0

// to your compiler flags.

# define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX \

    || GTEST_OS_QNX || GTEST_OS_FREEBSD || GTEST_OS_NACL)

#endif  // GTEST_HAS_PTHREAD

#if GTEST_HAS_PTHREAD

// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is

// true.

# include <pthread.h>  // NOLINT

// For timespec and nanosleep, used below.

# include <time.h>  // NOLINT

#endif

// Determines if hash_map/hash_set are available.

// Only used for testing against those containers.

#if !defined(GTEST_HAS_HASH_MAP_)

# if _MSC_VER

#  define GTEST_HAS_HASH_MAP_ 1  // Indicates that hash_map is available.

#  define GTEST_HAS_HASH_SET_ 1  // Indicates that hash_set is available.

# endif  // _MSC_VER

#endif  // !defined(GTEST_HAS_HASH_MAP_)

// Determines whether Google Test can use tr1/tuple.  You can define

// this macro to 0 to prevent Google Test from using tuple (any

// feature depending on tuple with be disabled in this mode).

#ifndef GTEST_HAS_TR1_TUPLE

# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR)

// STLport, provided with the Android NDK, has neither <tr1/tuple> or <tuple>.

#  define GTEST_HAS_TR1_TUPLE 0

# else

// The user didn't tell us not to do it, so we assume it's OK.

#  define GTEST_HAS_TR1_TUPLE 1

# endif

#endif  // GTEST_HAS_TR1_TUPLE

// Determines whether Google Test's own tr1 tuple implementation

// should be used.

#ifndef GTEST_USE_OWN_TR1_TUPLE

// The user didn't tell us, so we need to figure it out.

// We use our own TR1 tuple if we aren't sure the user has an

// implementation of it already.  At this time, libstdc++ 4.0.0+ and

// MSVC 2010 are the only mainstream standard libraries that come

// with a TR1 tuple implementation.  NVIDIA's CUDA NVCC compiler

// pretends to be GCC by defining __GNUC__ and friends, but cannot

// compile GCC's tuple implementation.  MSVC 2008 (9.0) provides TR1

// tuple in a 323 MB Feature Pack download, which we cannot assume the

// user has.  QNX's QCC compiler is a modified GCC but it doesn't

// support TR1 tuple.  libc++ only provides std::tuple, in C++11 mode,

// and it can be used with some compilers that define __GNUC__.

# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \

      && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) || _MSC_VER >= 1600

#  define GTEST_ENV_HAS_TR1_TUPLE_ 1

# endif

// C++11 specifies that <tuple> provides std::tuple. Use that if gtest is used

// in C++11 mode and libstdc++ isn't very old (binaries targeting OS X 10.6

// can build with clang but need to use gcc4.2's libstdc++).

# if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325)

#  define GTEST_ENV_HAS_STD_TUPLE_ 1

# endif

# if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_

#  define GTEST_USE_OWN_TR1_TUPLE 0

# else

#  define GTEST_USE_OWN_TR1_TUPLE 1

# endif

#endif  // GTEST_USE_OWN_TR1_TUPLE

// To avoid conditional compilation everywhere, we make it

// gtest-port.h's responsibility to #include the header implementing

// tuple.

#if GTEST_HAS_STD_TUPLE_

# include <tuple>  // IWYU pragma: export

# define GTEST_TUPLE_NAMESPACE_ ::std

#endif  // GTEST_HAS_STD_TUPLE_

// We include tr1::tuple even if std::tuple is available to define printers for

// them.

#if GTEST_HAS_TR1_TUPLE

# ifndef GTEST_TUPLE_NAMESPACE_

#  define GTEST_TUPLE_NAMESPACE_ ::std::tr1

# endif  // GTEST_TUPLE_NAMESPACE_

# if GTEST_USE_OWN_TR1_TUPLE

#  include "gtest/internal/gtest-tuple.h"  // IWYU pragma: export  // NOLINT

# elif GTEST_ENV_HAS_STD_TUPLE_

#  include <tuple>

// C++11 puts its tuple into the ::std namespace rather than

// ::std::tr1.  gtest expects tuple to live in ::std::tr1, so put it there.

// This causes undefined behavior, but supported compilers react in

// the way we intend.

namespace std {

namespace tr1 {

using ::std::get;

using ::std::make_tuple;

using ::std::tuple;

using ::std::tuple_element;

using ::std::tuple_size;

}

}

# elif GTEST_OS_SYMBIAN

// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to

// use STLport's tuple implementation, which unfortunately doesn't

// work as the copy of STLport distributed with Symbian is incomplete.

// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to

// use its own tuple implementation.

#  ifdef BOOST_HAS_TR1_TUPLE

#   undef BOOST_HAS_TR1_TUPLE

#  endif  // BOOST_HAS_TR1_TUPLE

// This prevents <boost/tr1/detail/config.hpp>, which defines

// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>.

#  define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED

#  include <tuple>  // IWYU pragma: export  // NOLINT

# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000)

// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header.  This does

// not conform to the TR1 spec, which requires the header to be <tuple>.

#  if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302

// Until version 4.3.2, gcc has a bug that causes <tr1/functional>,

// which is #included by <tr1/tuple>, to not compile when RTTI is

// disabled.  _TR1_FUNCTIONAL is the header guard for

// <tr1/functional>.  Hence the following #define is a hack to prevent

// <tr1/functional> from being included.

#   define _TR1_FUNCTIONAL 1

#   include <tr1/tuple>

#   undef _TR1_FUNCTIONAL  // Allows the user to #include

                        // <tr1/functional> if he chooses to.

#  else

#   include <tr1/tuple>  // NOLINT

#  endif  // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302

# else

// If the compiler is not GCC 4.0+, we assume the user is using a

// spec-conforming TR1 implementation.

#  include <tuple>  // IWYU pragma: export  // NOLINT

# endif  // GTEST_USE_OWN_TR1_TUPLE

#endif  // GTEST_HAS_TR1_TUPLE

// Determines whether clone(2) is supported.

// Usually it will only be available on Linux, excluding

// Linux on the Itanium architecture.

// Also see http://linux.die.net/man/2/clone.

#ifndef GTEST_HAS_CLONE

// The user didn't tell us, so we need to figure it out.

# if GTEST_OS_LINUX && !defined(__ia64__)

#  if GTEST_OS_LINUX_ANDROID

// On Android, clone() is only available on ARM starting with Gingerbread.

#    if defined(__arm__) && __ANDROID_API__ >= 9

#     define GTEST_HAS_CLONE 1

#    else

#     define GTEST_HAS_CLONE 0

#    endif

#  else

#   define GTEST_HAS_CLONE 1

#  endif

# else

#  define GTEST_HAS_CLONE 0

# endif  // GTEST_OS_LINUX && !defined(__ia64__)

#endif  // GTEST_HAS_CLONE

// Determines whether to support stream redirection. This is used to test

// output correctness and to implement death tests.

#ifndef GTEST_HAS_STREAM_REDIRECTION

// By default, we assume that stream redirection is supported on all

// platforms except known mobile ones.

# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || \

    GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT

#  define GTEST_HAS_STREAM_REDIRECTION 0

# else

#  define GTEST_HAS_STREAM_REDIRECTION 1

# endif  // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN

#endif  // GTEST_HAS_STREAM_REDIRECTION

// Determines whether to support death tests.

// Google Test does not support death tests for VC 7.1 and earlier as

// abort() in a VC 7.1 application compiled as GUI in debug config

// pops up a dialog window that cannot be suppressed programmatically.

#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \

     (GTEST_OS_MAC && !GTEST_OS_IOS) || \

     (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \

     GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \

     GTEST_OS_OPENBSD || GTEST_OS_QNX || GTEST_OS_FREEBSD || GTEST_OS_NETBSD)

# define GTEST_HAS_DEATH_TEST 1

#endif

// We don't support MSVC 7.1 with exceptions disabled now.  Therefore

// all the compilers we care about are adequate for supporting

// value-parameterized tests.

#define GTEST_HAS_PARAM_TEST 1

// Determines whether to support type-driven tests.

// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0,

// Sun Pro CC, IBM Visual Age, and HP aCC support.

#if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \

    defined(__IBMCPP__) || defined(__HP_aCC)

# define GTEST_HAS_TYPED_TEST 1

# define GTEST_HAS_TYPED_TEST_P 1

#endif

// Determines whether to support Combine(). This only makes sense when

// value-parameterized tests are enabled.  The implementation doesn't

// work on Sun Studio since it doesn't understand templated conversion

// operators.

#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC)

# define GTEST_HAS_COMBINE 1

#endif

// Determines whether the system compiler uses UTF-16 for encoding wide strings.

#define GTEST_WIDE_STRING_USES_UTF16_ \

    (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX)

// Determines whether test results can be streamed to a socket.

#if GTEST_OS_LINUX

# define GTEST_CAN_STREAM_RESULTS_ 1

#endif

// Defines some utility macros.

// The GNU compiler emits a warning if nested "if" statements are followed by

// an "else" statement and braces are not used to explicitly disambiguate the

// "else" binding.  This leads to problems with code like:

//

//   if (gate)

//     ASSERT_*(condition) << "Some message";

//

// The "switch (0) case 0:" idiom is used to suppress this.

#ifdef __INTEL_COMPILER

# define GTEST_AMBIGUOUS_ELSE_BLOCKER_

#else

# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:  // NOLINT

#endif

// Use this annotation at the end of a struct/class definition to

// prevent the compiler from optimizing away instances that are never

// used.  This is useful when all interesting logic happens inside the

// c'tor and / or d'tor.  Example:

//

//   struct Foo {

//     Foo() { ... }

//   } GTEST_ATTRIBUTE_UNUSED_;

//

// Also use it after a variable or parameter declaration to tell the

// compiler the variable/parameter does not have to be used.

#if defined(__GNUC__) && !defined(COMPILER_ICC)

# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))

#elif defined(__clang__)

# if __has_attribute(unused)

#  define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))

# endif

#endif

#ifndef GTEST_ATTRIBUTE_UNUSED_

# define GTEST_ATTRIBUTE_UNUSED_

#endif

// A macro to disallow operator=

// This should be used in the private: declarations for a class.

#define GTEST_DISALLOW_ASSIGN_(type)\

  void operator=(type const &) = delete

// A macro to disallow copy constructor and operator=

// This should be used in the private: declarations for a class.

#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\

  type(type const &) = delete;\

  GTEST_DISALLOW_ASSIGN_(type)

// Tell the compiler to warn about unused return values for functions declared

// with this macro.  The macro should be used on function declarations

// following the argument list:

//

//   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;

#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC)

# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))

#else

# define GTEST_MUST_USE_RESULT_

#endif  // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC

// MS C++ compiler emits warning when a conditional expression is compile time

// constant. In some contexts this warning is false positive and needs to be

// suppressed. Use the following two macros in such cases:

//

// GTEST_INTENTIONAL_CONST_COND_PUSH_()

// while (true) {

// GTEST_INTENTIONAL_CONST_COND_POP_()

// }

# define GTEST_INTENTIONAL_CONST_COND_PUSH_() \

    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)

# define GTEST_INTENTIONAL_CONST_COND_POP_() \

    GTEST_DISABLE_MSC_WARNINGS_POP_()

// Determine whether the compiler supports Microsoft's Structured Exception

// Handling.  This is supported by several Windows compilers but generally

// does not exist on any other system.

#ifndef GTEST_HAS_SEH

// The user didn't tell us, so we need to figure it out.

# if defined(_MSC_VER) || defined(__BORLANDC__)

// These two compilers are known to support SEH.

#  define GTEST_HAS_SEH 1

# else

// Assume no SEH.

#  define GTEST_HAS_SEH 0

# endif

#endif  // GTEST_HAS_SEH

#define GTEST_IS_THREADSAFE \

    (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ \

     || (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) \

     || GTEST_HAS_PTHREAD)

#ifdef _MSC_VER

# if GTEST_LINKED_AS_SHARED_LIBRARY

#  define GTEST_API_ __declspec(dllimport)

# elif GTEST_CREATE_SHARED_LIBRARY

#  define GTEST_API_ __declspec(dllexport)

# endif

#elif __GNUC__ >= 4 || defined(__clang__)

# define GTEST_API_ __attribute__((visibility ("default")))

#endif // _MSC_VER

#ifndef GTEST_API_

# define GTEST_API_

#endif

#ifdef __GNUC__

// Ask the compiler to never inline a given function.

# define GTEST_NO_INLINE_ __attribute__((noinline))

#else

# define GTEST_NO_INLINE_

#endif

// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.

#if defined(__has_include)

# if __has_include(<cxxabi.h>)

#  define GTEST_HAS_CXXABI_H_ 1

# else

#  define GTEST_HAS_CXXABI_H_ 0

# endif

#elif defined(__GLIBCXX__) || defined(_LIBCPP_VERSION)

# define GTEST_HAS_CXXABI_H_ 1

#else

# define GTEST_HAS_CXXABI_H_ 0

#endif

// A function level attribute to disable checking for use of uninitialized

// memory when built with MemorySanitizer.

#if defined(__clang__)

# if __has_feature(memory_sanitizer)

#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \

       __attribute__((no_sanitize_memory))

# else

#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_

# endif  // __has_feature(memory_sanitizer)

#else

# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_

#endif  // __clang__

// A function level attribute to disable AddressSanitizer instrumentation.

#if defined(__clang__)

# if __has_feature(address_sanitizer)

#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \

       __attribute__((no_sanitize_address))

# else

#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_

# endif  // __has_feature(address_sanitizer)

#else

# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_

#endif  // __clang__

// A function level attribute to disable ThreadSanitizer instrumentation.

#if defined(__clang__)

# if __has_feature(thread_sanitizer)

#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \

       __attribute__((no_sanitize_thread))

# else

#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_

# endif  // __has_feature(thread_sanitizer)

#else

# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_

#endif  // __clang__

namespace testing {

class Message;

#if defined(GTEST_TUPLE_NAMESPACE_)

// Import tuple and friends into the ::testing namespace.

// It is part of our interface, having them in ::testing allows us to change

// their types as needed.

using GTEST_TUPLE_NAMESPACE_::get;

using GTEST_TUPLE_NAMESPACE_::make_tuple;

using GTEST_TUPLE_NAMESPACE_::tuple;

using GTEST_TUPLE_NAMESPACE_::tuple_size;

using GTEST_TUPLE_NAMESPACE_::tuple_element;

#endif  // defined(GTEST_TUPLE_NAMESPACE_)

namespace internal {

// A secret type that Google Test users don't know about.  It has no

// definition on purpose.  Therefore it's impossible to create a

// Secret object, which is what we want.

class Secret;

// The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time

// expression is true. For example, you could use it to verify the

// size of a static array:

//

//   GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES,

//                         names_incorrect_size);

//

// or to make sure a struct is smaller than a certain size:

//

//   GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large);

//

// The second argument to the macro is the name of the variable. If

// the expression is false, most compilers will issue a warning/error

// containing the name of the variable.

#if GTEST_LANG_CXX11

# define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)

#else  // !GTEST_LANG_CXX11

template <bool>

  struct CompileAssert {

};

# define GTEST_COMPILE_ASSERT_(expr, msg) \

  typedef ::testing::internal::CompileAssert<(static_cast<bool>(expr))> \

      msg[static_cast<bool>(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_

#endif  // !GTEST_LANG_CXX11

// Implementation details of GTEST_COMPILE_ASSERT_:

//

// (In C++11, we simply use static_assert instead of the following)

//

// - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1

//   elements (and thus is invalid) when the expression is false.

//

// - The simpler definition

//

//    #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1]

//

//   does not work, as gcc supports variable-length arrays whose sizes

//   are determined at run-time (this is gcc's extension and not part

//   of the C++ standard).  As a result, gcc fails to reject the

//   following code with the simple definition:

//

//     int foo;

//     GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is

//                                      // not a compile-time constant.

//

// - By using the type CompileAssert<(bool(expr))>, we ensures that

//   expr is a compile-time constant.  (Template arguments must be

//   determined at compile-time.)

//

// - The outter parentheses in CompileAssert<(bool(expr))> are necessary

//   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written

//

//     CompileAssert<bool(expr)>

//

//   instead, these compilers will refuse to compile

//

//     GTEST_COMPILE_ASSERT_(5 > 0, some_message);

//

//   (They seem to think the ">" in "5 > 0" marks the end of the

//   template argument list.)

//

// - The array size is (bool(expr) ? 1 : -1), instead of simply

//

//     ((expr) ? 1 : -1).

//

//   This is to avoid running into a bug in MS VC 7.1, which

//   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.

// StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h.

//

// This template is declared, but intentionally undefined.

template <typename T1, typename T2>

struct StaticAssertTypeEqHelper;

template <typename T>

struct StaticAssertTypeEqHelper<T, T> {

  enum { value = true };

};

// Evaluates to the number of elements in 'array'.

#define GTEST_ARRAY_SIZE_(array) (sizeof(array) / sizeof(array[0]))

#if GTEST_HAS_GLOBAL_STRING

typedef ::string string;

#else

typedef ::std::string string;

#endif  // GTEST_HAS_GLOBAL_STRING

#if GTEST_HAS_GLOBAL_WSTRING

typedef ::wstring wstring;

#elif GTEST_HAS_STD_WSTRING

typedef ::std::wstring wstring;

#endif  // GTEST_HAS_GLOBAL_WSTRING

// A helper for suppressing warnings on constant condition.  It just

// returns 'condition'.

GTEST_API_ bool IsTrue(bool condition);

// Defines scoped_ptr.

// This implementation of scoped_ptr is PARTIAL - it only contains

// enough stuff to satisfy Google Test's need.

template <typename T>

class scoped_ptr {

 public:

  typedef T element_type;

  explicit scoped_ptr(T* p = NULL) : ptr_(p) {}

_ZN7testing8internal10scoped_ptrINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2EPS7_

Line

Count

Source

1128

326

  explicit scoped_ptr(T* p = NULL) : ptr_(p) {}

Unexecuted instantiation: _ZN7testing8internal10scoped_ptrINS0_17StreamingListener20AbstractSocketWriterEEC2EPS3_

_ZN7testing8internal10scoped_ptrINSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEEEC2EPS7_

Line

Count

Source

1128

98

  explicit scoped_ptr(T* p = NULL) : ptr_(p) {}

_ZN7testing8internal10scoped_ptrINS0_14GTestFlagSaverEEC2EPS2_

Line

Count

Source

1128

11

  explicit scoped_ptr(T* p = NULL) : ptr_(p) {}

_ZN7testing8internal10scoped_ptrIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2EPS8_

Line

Count

Source