brintos / llvm-project-archived public Read only

1// Copyright 2005, Google Inc.2// All rights reserved.3//4// Redistribution and use in source and binary forms, with or without5// modification, are permitted provided that the following conditions are6// met:7//8//     * Redistributions of source code must retain the above copyright9// notice, this list of conditions and the following disclaimer.10//     * Redistributions in binary form must reproduce the above11// copyright notice, this list of conditions and the following disclaimer12// in the documentation and/or other materials provided with the13// distribution.14//     * Neither the name of Google Inc. nor the names of its15// contributors may be used to endorse or promote products derived from16// this software without specific prior written permission.17//18// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS19// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT20// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR21// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT22// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,23// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT24// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,25// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY26// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT27// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE28// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.29 30// Low-level types and utilities for porting Google Test to various31// platforms.  All macros ending with _ and symbols defined in an32// internal namespace are subject to change without notice.  Code33// outside Google Test MUST NOT USE THEM DIRECTLY.  Macros that don't34// end with _ are part of Google Test's public API and can be used by35// code outside Google Test.36//37// This file is fundamental to Google Test.  All other Google Test source38// files are expected to #include this.  Therefore, it cannot #include39// any other Google Test header.40 41// IWYU pragma: private, include "gtest/gtest.h"42// IWYU pragma: friend gtest/.*43// IWYU pragma: friend gmock/.*44 45#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_46#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_47 48// Environment-describing macros49// -----------------------------50//51// Google Test can be used in many different environments.  Macros in52// this section tell Google Test what kind of environment it is being53// used in, such that Google Test can provide environment-specific54// features and implementations.55//56// Google Test tries to automatically detect the properties of its57// environment, so users usually don't need to worry about these58// macros.  However, the automatic detection is not perfect.59// Sometimes it's necessary for a user to define some of the following60// macros in the build script to override Google Test's decisions.61//62// If the user doesn't define a macro in the list, Google Test will63// provide a default definition.  After this header is #included, all64// macros in this list will be defined to either 1 or 0.65//66// Notes to maintainers:67//   - Each macro here is a user-tweakable knob; do not grow the list68//     lightly.69//   - Use #if to key off these macros.  Don't use #ifdef or "#if70//     defined(...)", which will not work as these macros are ALWAYS71//     defined.72//73//   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)74//                              is/isn't available.75//   GTEST_HAS_EXCEPTIONS     - Define it to 1/0 to indicate that exceptions76//                              are enabled.77//   GTEST_HAS_POSIX_RE       - Define it to 1/0 to indicate that POSIX regular78//                              expressions are/aren't available.79//   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>80//                              is/isn't available.81//   GTEST_HAS_RTTI           - Define it to 1/0 to indicate that RTTI is/isn't82//                              enabled.83//   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that84//                              std::wstring does/doesn't work (Google Test can85//                              be used where std::wstring is unavailable).86//   GTEST_HAS_FILE_SYSTEM    - Define it to 1/0 to indicate whether or not a87//                              file system is/isn't available.88//   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the89//                              compiler supports Microsoft's "Structured90//                              Exception Handling".91//   GTEST_HAS_STREAM_REDIRECTION92//                            - Define it to 1/0 to indicate whether the93//                              platform supports I/O stream redirection using94//                              dup() and dup2().95//   GTEST_LINKED_AS_SHARED_LIBRARY96//                            - Define to 1 when compiling tests that use97//                              Google Test as a shared library (known as98//                              DLL on Windows).99//   GTEST_CREATE_SHARED_LIBRARY100//                            - Define to 1 when compiling Google Test itself101//                              as a shared library.102//   GTEST_DEFAULT_DEATH_TEST_STYLE103//                            - The default value of --gtest_death_test_style.104//                              The legacy default has been "fast" in the open105//                              source version since 2008. The recommended value106//                              is "threadsafe", and can be set in107//                              custom/gtest-port.h.108 109// Platform-indicating macros110// --------------------------111//112// Macros indicating the platform on which Google Test is being used113// (a macro is defined to 1 if compiled on the given platform;114// otherwise UNDEFINED -- it's never defined to 0.).  Google Test115// defines these macros automatically.  Code outside Google Test MUST116// NOT define them.117//118//   GTEST_OS_AIX      - IBM AIX119//   GTEST_OS_CYGWIN   - Cygwin120//   GTEST_OS_DRAGONFLY - DragonFlyBSD121//   GTEST_OS_FREEBSD  - FreeBSD122//   GTEST_OS_FUCHSIA  - Fuchsia123//   GTEST_OS_GNU_HURD - GNU/Hurd124//   GTEST_OS_GNU_KFREEBSD - GNU/kFreeBSD125//   GTEST_OS_HAIKU    - Haiku126//   GTEST_OS_HPUX     - HP-UX127//   GTEST_OS_LINUX    - Linux128//     GTEST_OS_LINUX_ANDROID - Google Android129//   GTEST_OS_MAC      - Mac OS X130//     GTEST_OS_IOS    - iOS131//   GTEST_OS_NACL     - Google Native Client (NaCl)132//   GTEST_OS_NETBSD   - NetBSD133//   GTEST_OS_OPENBSD  - OpenBSD134//   GTEST_OS_OS2      - OS/2135//   GTEST_OS_QNX      - QNX136//   GTEST_OS_SOLARIS  - Sun Solaris137//   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)138//     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop139//     GTEST_OS_WINDOWS_MINGW    - MinGW140//     GTEST_OS_WINDOWS_MOBILE   - Windows Mobile141//     GTEST_OS_WINDOWS_PHONE    - Windows Phone142//     GTEST_OS_WINDOWS_RT       - Windows Store App/WinRT143//   GTEST_OS_ZOS      - z/OS144//145// Among the platforms, Cygwin, Linux, Mac OS X, and Windows have the146// most stable support.  Since core members of the Google Test project147// don't have access to other platforms, support for them may be less148// stable.  If you notice any problems on your platform, please notify149// googletestframework@googlegroups.com (patches for fixing them are150// even more welcome!).151//152// It is possible that none of the GTEST_OS_* macros are defined.153 154// Feature-indicating macros155// -------------------------156//157// Macros indicating which Google Test features are available (a macro158// is defined to 1 if the corresponding feature is supported;159// otherwise UNDEFINED -- it's never defined to 0.).  Google Test160// defines these macros automatically.  Code outside Google Test MUST161// NOT define them.162//163// These macros are public so that portable tests can be written.164// Such tests typically surround code using a feature with an #ifdef165// which controls that code.  For example:166//167// #ifdef GTEST_HAS_DEATH_TEST168//   EXPECT_DEATH(DoSomethingDeadly());169// #endif170//171//   GTEST_HAS_DEATH_TEST   - death tests172//   GTEST_HAS_TYPED_TEST   - typed tests173//   GTEST_HAS_TYPED_TEST_P - type-parameterized tests174//   GTEST_IS_THREADSAFE    - Google Test is thread-safe.175//   GTEST_USES_RE2         - the RE2 regular expression library is used176//   GTEST_USES_POSIX_RE    - enhanced POSIX regex is used. Do not confuse with177//                            GTEST_HAS_POSIX_RE (see above) which users can178//                            define themselves.179//   GTEST_USES_SIMPLE_RE   - our own simple regex is used;180//                            the above RE\b(s) are mutually exclusive.181//   GTEST_HAS_ABSL         - Google Test is compiled with Abseil.182 183// Misc public macros184// ------------------185//186//   GTEST_FLAG(flag_name)  - references the variable corresponding to187//                            the given Google Test flag.188 189// Internal utilities190// ------------------191//192// The following macros and utilities are for Google Test's INTERNAL193// use only.  Code outside Google Test MUST NOT USE THEM DIRECTLY.194//195// Macros for basic C++ coding:196//   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.197//   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a198//                              variable don't have to be used.199//   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.200//   GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is201//                                        suppressed (constant conditional).202//   GTEST_INTENTIONAL_CONST_COND_POP_  - finish code section where MSVC C4127203//                                        is suppressed.204//   GTEST_INTERNAL_HAS_ANY - for enabling UniversalPrinter<std::any> or205//                            UniversalPrinter<absl::any> specializations.206//                            Always defined to 0 or 1.207//   GTEST_INTERNAL_HAS_OPTIONAL - for enabling UniversalPrinter<std::optional>208//   or209//                                 UniversalPrinter<absl::optional>210//                                 specializations. Always defined to 0 or 1.211//   GTEST_INTERNAL_HAS_STRING_VIEW - for enabling Matcher<std::string_view> or212//                                    Matcher<absl::string_view>213//                                    specializations. Always defined to 0 or 1.214//   GTEST_INTERNAL_HAS_VARIANT - for enabling UniversalPrinter<std::variant> or215//                                UniversalPrinter<absl::variant>216//                                specializations. Always defined to 0 or 1.217//   GTEST_USE_OWN_FLAGFILE_FLAG_ - Always defined to 0 or 1.218//   GTEST_HAS_CXXABI_H_ - Always defined to 0 or 1.219//   GTEST_CAN_STREAM_RESULTS_ - Always defined to 0 or 1.220//   GTEST_HAS_ALT_PATH_SEP_ - Always defined to 0 or 1.221//   GTEST_WIDE_STRING_USES_UTF16_ - Always defined to 0 or 1.222//   GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ - Always defined to 0 or 1.223//   GTEST_HAS_NOTIFICATION_- Always defined to 0 or 1.224//225// Synchronization:226//   Mutex, MutexLock, ThreadLocal, GetThreadCount()227//                            - synchronization primitives.228//229// Regular expressions:230//   RE             - a simple regular expression class using231//                     1) the RE2 syntax on all platforms when built with RE2232//                        and Abseil as dependencies233//                     2) the POSIX Extended Regular Expression syntax on234//                        UNIX-like platforms,235//                     3) A reduced regular exception syntax on other platforms,236//                        including Windows.237// Logging:238//   GTEST_LOG_()   - logs messages at the specified severity level.239//   LogToStderr()  - directs all log messages to stderr.240//   FlushInfoLog() - flushes informational log messages.241//242// Stdout and stderr capturing:243//   CaptureStdout()     - starts capturing stdout.244//   GetCapturedStdout() - stops capturing stdout and returns the captured245//                         string.246//   CaptureStderr()     - starts capturing stderr.247//   GetCapturedStderr() - stops capturing stderr and returns the captured248//                         string.249//250// Integer types:251//   TypeWithSize   - maps an integer to a int type.252//   TimeInMillis   - integers of known sizes.253//   BiggestInt     - the biggest signed integer type.254//255// Command-line utilities:256//   GetInjectableArgvs() - returns the command line as a vector of strings.257//258// Environment variable utilities:259//   GetEnv()             - gets the value of an environment variable.260//   BoolFromGTestEnv()   - parses a bool environment variable.261//   Int32FromGTestEnv()  - parses an int32_t environment variable.262//   StringFromGTestEnv() - parses a string environment variable.263//264// Deprecation warnings:265//   GTEST_INTERNAL_DEPRECATED(message) - attribute marking a function as266//                                        deprecated; calling a marked function267//                                        should generate a compiler warning268 269// The definition of GTEST_INTERNAL_CPLUSPLUS_LANG comes first because it can270// potentially be used as an #include guard.271#if defined(_MSVC_LANG)272#define GTEST_INTERNAL_CPLUSPLUS_LANG _MSVC_LANG273#elif defined(__cplusplus)274#define GTEST_INTERNAL_CPLUSPLUS_LANG __cplusplus275#endif276 277#if !defined(GTEST_INTERNAL_CPLUSPLUS_LANG) || \278    GTEST_INTERNAL_CPLUSPLUS_LANG < 201402L279#error C++ versions less than C++14 are not supported.280#endif281 282#include <ctype.h>   // for isspace, etc283#include <stddef.h>  // for ptrdiff_t284#include <stdio.h>285#include <stdlib.h>286#include <string.h>287 288#include <cerrno>289// #include <condition_variable>  // Guarded by GTEST_IS_THREADSAFE below290#include <cstdint>291#include <iostream>292#include <limits>293#include <locale>294#include <memory>295#include <ostream>296#include <string>297// #include <mutex>  // Guarded by GTEST_IS_THREADSAFE below298#include <tuple>299#include <type_traits>300#include <vector>301 302#ifndef _WIN32_WCE303#include <sys/stat.h>304#include <sys/types.h>305#endif  // !_WIN32_WCE306 307#if defined __APPLE__308#include <AvailabilityMacros.h>309#include <TargetConditionals.h>310#endif311 312#include "gtest/internal/custom/gtest-port.h"313#include "gtest/internal/gtest-port-arch.h"314 315#ifndef GTEST_HAS_MUTEX_AND_THREAD_LOCAL_316#define GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ 0317#endif318 319#ifndef GTEST_HAS_NOTIFICATION_320#define GTEST_HAS_NOTIFICATION_ 0321#endif322 323#ifdef GTEST_HAS_ABSL324#include "absl/flags/declare.h"325#include "absl/flags/flag.h"326#include "absl/flags/reflection.h"327#endif328 329#if !defined(GTEST_DEV_EMAIL_)330#define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"331#define GTEST_FLAG_PREFIX_ "gtest_"332#define GTEST_FLAG_PREFIX_DASH_ "gtest-"333#define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"334#define GTEST_NAME_ "Google Test"335#define GTEST_PROJECT_URL_ "https://github.com/google/googletest/"336#endif  // !defined(GTEST_DEV_EMAIL_)337 338#if !defined(GTEST_INIT_GOOGLE_TEST_NAME_)339#define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest"340#endif  // !defined(GTEST_INIT_GOOGLE_TEST_NAME_)341 342// Determines the version of gcc that is used to compile this.343#ifdef __GNUC__344// 40302 means version 4.3.2.345#define GTEST_GCC_VER_ \346  (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)347#endif  // __GNUC__348 349// Macros for disabling Microsoft Visual C++ warnings.350//351//   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385)352//   /* code that triggers warnings C4800 and C4385 */353//   GTEST_DISABLE_MSC_WARNINGS_POP_()354#if defined(_MSC_VER)355#define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \356  __pragma(warning(push)) __pragma(warning(disable : warnings))357#define GTEST_DISABLE_MSC_WARNINGS_POP_() __pragma(warning(pop))358#else359// Not all compilers are MSVC360#define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)361#define GTEST_DISABLE_MSC_WARNINGS_POP_()362#endif363 364// Clang on Windows does not understand MSVC's pragma warning.365// We need clang-specific way to disable function deprecation warning.366#ifdef __clang__367#define GTEST_DISABLE_MSC_DEPRECATED_PUSH_()                            \368  _Pragma("clang diagnostic push")                                      \369      _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") \370          _Pragma("clang diagnostic ignored \"-Wdeprecated-implementations\"")371#define GTEST_DISABLE_MSC_DEPRECATED_POP_() _Pragma("clang diagnostic pop")372#else373#define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \374  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)375#define GTEST_DISABLE_MSC_DEPRECATED_POP_() GTEST_DISABLE_MSC_WARNINGS_POP_()376#endif377 378// Brings in definitions for functions used in the testing::internal::posix379// namespace (read, write, close, chdir, isatty, stat). We do not currently380// use them on Windows Mobile.381#ifdef GTEST_OS_WINDOWS382#ifndef GTEST_OS_WINDOWS_MOBILE383#include <direct.h>384#include <io.h>385#endif386// In order to avoid having to include <windows.h>, use forward declaration387#if defined(GTEST_OS_WINDOWS_MINGW) && !defined(__MINGW64_VERSION_MAJOR)388// MinGW defined _CRITICAL_SECTION and _RTL_CRITICAL_SECTION as two389// separate (equivalent) structs, instead of using typedef390typedef struct _CRITICAL_SECTION GTEST_CRITICAL_SECTION;391#else392// Assume CRITICAL_SECTION is a typedef of _RTL_CRITICAL_SECTION.393// This assumption is verified by394// WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION.395typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;396#endif397#elif defined(GTEST_OS_XTENSA)398#include <unistd.h>399// Xtensa toolchains define strcasecmp in the string.h header instead of400// strings.h. string.h is already included.401#else402// This assumes that non-Windows OSes provide unistd.h. For OSes where this403// is not the case, we need to include headers that provide the functions404// mentioned above.405#include <strings.h>406#include <unistd.h>407#endif  // GTEST_OS_WINDOWS408 409#ifdef GTEST_OS_LINUX_ANDROID410// Used to define __ANDROID_API__ matching the target NDK API level.411#include <android/api-level.h>  // NOLINT412#endif413 414// Defines this to true if and only if Google Test can use POSIX regular415// expressions.416#ifndef GTEST_HAS_POSIX_RE417#ifdef GTEST_OS_LINUX_ANDROID418// On Android, <regex.h> is only available starting with Gingerbread.419#define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)420#else421#if !(defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_XTENSA) || \422      defined(GTEST_OS_QURT))423#define GTEST_HAS_POSIX_RE 1424#else425#define GTEST_HAS_POSIX_RE 0426#endif427#endif  // GTEST_OS_LINUX_ANDROID428#endif429 430// Select the regular expression implementation.431#ifdef GTEST_HAS_ABSL432// When using Abseil, RE2 is required.433#include "absl/strings/string_view.h"434#include "re2/re2.h"435#define GTEST_USES_RE2 1436#elif GTEST_HAS_POSIX_RE437#include <regex.h>  // NOLINT438#define GTEST_USES_POSIX_RE 1439#else440// Use our own simple regex implementation.441#define GTEST_USES_SIMPLE_RE 1442#endif443 444#ifndef GTEST_HAS_EXCEPTIONS445// The user didn't tell us whether exceptions are enabled, so we need446// to figure it out.447#if defined(_MSC_VER) && defined(_CPPUNWIND)448// MSVC defines _CPPUNWIND to 1 if and only if exceptions are enabled.449#define GTEST_HAS_EXCEPTIONS 1450#elif defined(__BORLANDC__)451// C++Builder's implementation of the STL uses the _HAS_EXCEPTIONS452// macro to enable exceptions, so we'll do the same.453// Assumes that exceptions are enabled by default.454#ifndef _HAS_EXCEPTIONS455#define _HAS_EXCEPTIONS 1456#endif  // _HAS_EXCEPTIONS457#define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS458#elif defined(__clang__)459// clang defines __EXCEPTIONS if and only if exceptions are enabled before clang460// 220714, but if and only if cleanups are enabled after that. In Obj-C++ files,461// there can be cleanups for ObjC exceptions which also need cleanups, even if462// C++ exceptions are disabled. clang has __has_feature(cxx_exceptions) which463// checks for C++ exceptions starting at clang r206352, but which checked for464// cleanups prior to that. To reliably check for C++ exception availability with465// clang, check for466// __EXCEPTIONS && __has_feature(cxx_exceptions).467#if defined(__EXCEPTIONS) && __EXCEPTIONS && __has_feature(cxx_exceptions)468#define GTEST_HAS_EXCEPTIONS 1469#else470#define GTEST_HAS_EXCEPTIONS 0471#endif472#elif defined(__GNUC__) && defined(__EXCEPTIONS) && __EXCEPTIONS473// gcc defines __EXCEPTIONS to 1 if and only if exceptions are enabled.474#define GTEST_HAS_EXCEPTIONS 1475#elif defined(__SUNPRO_CC)476// Sun Pro CC supports exceptions.  However, there is no compile-time way of477// detecting whether they are enabled or not.  Therefore, we assume that478// they are enabled unless the user tells us otherwise.479#define GTEST_HAS_EXCEPTIONS 1480#elif defined(__IBMCPP__) && defined(__EXCEPTIONS) && __EXCEPTIONS481// xlC defines __EXCEPTIONS to 1 if and only if exceptions are enabled.482#define GTEST_HAS_EXCEPTIONS 1483#elif defined(__HP_aCC)484// Exception handling is in effect by default in HP aCC compiler. It has to485// be turned of by +noeh compiler option if desired.486#define GTEST_HAS_EXCEPTIONS 1487#else488// For other compilers, we assume exceptions are disabled to be489// conservative.490#define GTEST_HAS_EXCEPTIONS 0491#endif  // defined(_MSC_VER) || defined(__BORLANDC__)492#endif  // GTEST_HAS_EXCEPTIONS493 494#ifndef GTEST_HAS_STD_WSTRING495// The user didn't tell us whether ::std::wstring is available, so we need496// to figure it out.497// Cygwin 1.7 and below doesn't support ::std::wstring.498// Solaris' libc++ doesn't support it either.  Android has499// no support for it at least as recent as Froyo (2.2).500#if (!(defined(GTEST_OS_LINUX_ANDROID) || defined(GTEST_OS_CYGWIN) || \501       defined(GTEST_OS_SOLARIS) || defined(GTEST_OS_HAIKU) ||        \502       defined(GTEST_OS_ESP32) || defined(GTEST_OS_ESP8266) ||        \503       defined(GTEST_OS_XTENSA) || defined(GTEST_OS_QURT) ||          \504       defined(GTEST_OS_NXP_QN9090) || defined(GTEST_OS_NRF52)))505#define GTEST_HAS_STD_WSTRING 1506#else507#define GTEST_HAS_STD_WSTRING 0508#endif509#endif  // GTEST_HAS_STD_WSTRING510 511#ifndef GTEST_HAS_FILE_SYSTEM512// Most platforms support a file system.513#define GTEST_HAS_FILE_SYSTEM 1514#endif  // GTEST_HAS_FILE_SYSTEM515 516// Determines whether RTTI is available.517#ifndef GTEST_HAS_RTTI518// The user didn't tell us whether RTTI is enabled, so we need to519// figure it out.520 521#ifdef _MSC_VER522 523#ifdef _CPPRTTI  // MSVC defines this macro if and only if RTTI is enabled.524#define GTEST_HAS_RTTI 1525#else526#define GTEST_HAS_RTTI 0527#endif528 529// Starting with version 4.3.2, gcc defines __GXX_RTTI if and only if RTTI is530// enabled.531#elif defined(__GNUC__)532 533#ifdef __GXX_RTTI534// When building against STLport with the Android NDK and with535// -frtti -fno-exceptions, the build fails at link time with undefined536// references to __cxa_bad_typeid. Note sure if STL or toolchain bug,537// so disable RTTI when detected.538#if defined(GTEST_OS_LINUX_ANDROID) && defined(_STLPORT_MAJOR) && \539    !defined(__EXCEPTIONS)540#define GTEST_HAS_RTTI 0541#else542#define GTEST_HAS_RTTI 1543#endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS544#else545#define GTEST_HAS_RTTI 0546#endif  // __GXX_RTTI547 548// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends549// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the550// first version with C++ support.551#elif defined(__clang__)552 553#define GTEST_HAS_RTTI __has_feature(cxx_rtti)554 555// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if556// both the typeid and dynamic_cast features are present.557#elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)558 559#ifdef __RTTI_ALL__560#define GTEST_HAS_RTTI 1561#else562#define GTEST_HAS_RTTI 0563#endif564 565#else566 567// For all other compilers, we assume RTTI is enabled.568#define GTEST_HAS_RTTI 1569 570#endif  // _MSC_VER571 572#endif  // GTEST_HAS_RTTI573 574// It's this header's responsibility to #include <typeinfo> when RTTI575// is enabled.576#if GTEST_HAS_RTTI577#include <typeinfo>578#endif579 580// Determines whether Google Test can use the pthreads library.581#ifndef GTEST_HAS_PTHREAD582// The user didn't tell us explicitly, so we make reasonable assumptions about583// which platforms have pthreads support.584//585// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0586// to your compiler flags.587#if (defined(GTEST_OS_LINUX) || defined(GTEST_OS_MAC) ||              \588     defined(GTEST_OS_HPUX) || defined(GTEST_OS_QNX) ||               \589     defined(GTEST_OS_FREEBSD) || defined(GTEST_OS_NACL) ||           \590     defined(GTEST_OS_NETBSD) || defined(GTEST_OS_FUCHSIA) ||         \591     defined(GTEST_OS_DRAGONFLY) || defined(GTEST_OS_GNU_KFREEBSD) || \592     defined(GTEST_OS_OPENBSD) || defined(GTEST_OS_HAIKU) ||          \593     defined(GTEST_OS_GNU_HURD))594#define GTEST_HAS_PTHREAD 1595#else596#define GTEST_HAS_PTHREAD 0597#endif598#endif  // GTEST_HAS_PTHREAD599 600#if GTEST_HAS_PTHREAD601// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is602// true.603#include <pthread.h>  // NOLINT604 605// For timespec and nanosleep, used below.606#include <time.h>  // NOLINT607#endif608 609// Determines whether clone(2) is supported.610// Usually it will only be available on Linux, excluding611// Linux on the Itanium architecture.612// Also see http://linux.die.net/man/2/clone.613#ifndef GTEST_HAS_CLONE614// The user didn't tell us, so we need to figure it out.615 616#if defined(GTEST_OS_LINUX) && !defined(__ia64__)617#if defined(GTEST_OS_LINUX_ANDROID)618// On Android, clone() became available at different API levels for each 32-bit619// architecture.620#if defined(__LP64__) || (defined(__arm__) && __ANDROID_API__ >= 9) || \621    (defined(__mips__) && __ANDROID_API__ >= 12) ||                    \622    (defined(__i386__) && __ANDROID_API__ >= 17)623#define GTEST_HAS_CLONE 1624#else625#define GTEST_HAS_CLONE 0626#endif627#else628#define GTEST_HAS_CLONE 1629#endif630#else631#define GTEST_HAS_CLONE 0632#endif  // GTEST_OS_LINUX && !defined(__ia64__)633 634#endif  // GTEST_HAS_CLONE635 636// Determines whether to support stream redirection. This is used to test637// output correctness and to implement death tests.638#ifndef GTEST_HAS_STREAM_REDIRECTION639// By default, we assume that stream redirection is supported on all640// platforms except known mobile / embedded ones. Also, if the port doesn't have641// a file system, stream redirection is not supported.642#if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_WINDOWS_PHONE) || \643    defined(GTEST_OS_WINDOWS_RT) || defined(GTEST_OS_ESP8266) ||           \644    defined(GTEST_OS_XTENSA) || defined(GTEST_OS_QURT) ||                  \645    !GTEST_HAS_FILE_SYSTEM646#define GTEST_HAS_STREAM_REDIRECTION 0647#else648#define GTEST_HAS_STREAM_REDIRECTION 1649#endif  // !GTEST_OS_WINDOWS_MOBILE650#endif  // GTEST_HAS_STREAM_REDIRECTION651 652// Determines whether to support death tests.653// pops up a dialog window that cannot be suppressed programmatically.654#if (defined(GTEST_OS_LINUX) || defined(GTEST_OS_CYGWIN) ||           \655     defined(GTEST_OS_SOLARIS) || defined(GTEST_OS_ZOS) ||            \656     (defined(GTEST_OS_MAC) && !defined(GTEST_OS_IOS)) ||             \657     (defined(GTEST_OS_WINDOWS_DESKTOP) && _MSC_VER) ||               \658     defined(GTEST_OS_WINDOWS_MINGW) || defined(GTEST_OS_AIX) ||      \659     defined(GTEST_OS_HPUX) || defined(GTEST_OS_OPENBSD) ||           \660     defined(GTEST_OS_QNX) || defined(GTEST_OS_FREEBSD) ||            \661     defined(GTEST_OS_NETBSD) || defined(GTEST_OS_FUCHSIA) ||         \662     defined(GTEST_OS_DRAGONFLY) || defined(GTEST_OS_GNU_KFREEBSD) || \663     defined(GTEST_OS_HAIKU) || defined(GTEST_OS_GNU_HURD))664// Death tests require a file system to work properly.665#if GTEST_HAS_FILE_SYSTEM666#define GTEST_HAS_DEATH_TEST 1667#endif  // GTEST_HAS_FILE_SYSTEM668#endif669 670// Determines whether to support type-driven tests.671 672// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0,673// Sun Pro CC, IBM Visual Age, and HP aCC support.674#if defined(__GNUC__) || defined(_MSC_VER) || defined(__SUNPRO_CC) || \675    defined(__IBMCPP__) || defined(__HP_aCC)676#define GTEST_HAS_TYPED_TEST 1677#define GTEST_HAS_TYPED_TEST_P 1678#endif679 680// Determines whether the system compiler uses UTF-16 for encoding wide strings.681#if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_CYGWIN) || \682    defined(GTEST_OS_AIX) || defined(GTEST_OS_OS2)683#define GTEST_WIDE_STRING_USES_UTF16_ 1684#else685#define GTEST_WIDE_STRING_USES_UTF16_ 0686#endif687 688// Determines whether test results can be streamed to a socket.689#if defined(GTEST_OS_LINUX) || defined(GTEST_OS_GNU_KFREEBSD) || \690    defined(GTEST_OS_DRAGONFLY) || defined(GTEST_OS_FREEBSD) ||  \691    defined(GTEST_OS_NETBSD) || defined(GTEST_OS_OPENBSD) ||     \692    defined(GTEST_OS_GNU_HURD) || defined(GTEST_OS_MAC)693#define GTEST_CAN_STREAM_RESULTS_ 1694#else695#define GTEST_CAN_STREAM_RESULTS_ 0696#endif697 698// Defines some utility macros.699 700// The GNU compiler emits a warning if nested "if" statements are followed by701// an "else" statement and braces are not used to explicitly disambiguate the702// "else" binding.  This leads to problems with code like:703//704//   if (gate)705//     ASSERT_*(condition) << "Some message";706//707// The "switch (0) case 0:" idiom is used to suppress this.708#ifdef __INTEL_COMPILER709#define GTEST_AMBIGUOUS_ELSE_BLOCKER_710#else711#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ \712  switch (0)                          \713  case 0:                             \714  default:  // NOLINT715#endif716 717// GTEST_HAVE_ATTRIBUTE_718//719// A function-like feature checking macro that is a wrapper around720// `__has_attribute`, which is defined by GCC 5+ and Clang and evaluates to a721// nonzero constant integer if the attribute is supported or 0 if not.722//723// It evaluates to zero if `__has_attribute` is not defined by the compiler.724//725// GCC: https://gcc.gnu.org/gcc-5/changes.html726// Clang: https://clang.llvm.org/docs/LanguageExtensions.html727#ifdef __has_attribute728#define GTEST_HAVE_ATTRIBUTE_(x) __has_attribute(x)729#else730#define GTEST_HAVE_ATTRIBUTE_(x) 0731#endif732 733// GTEST_HAVE_FEATURE_734//735// A function-like feature checking macro that is a wrapper around736// `__has_feature`.737#ifdef __has_feature738#define GTEST_HAVE_FEATURE_(x) __has_feature(x)739#else740#define GTEST_HAVE_FEATURE_(x) 0741#endif742 743// Use this annotation after a variable or parameter declaration to tell the744// compiler the variable/parameter does not have to be used.745// Example:746//747//   GTEST_ATTRIBUTE_UNUSED_ int foo = bar();748#if GTEST_HAVE_ATTRIBUTE_(unused)749#define GTEST_ATTRIBUTE_UNUSED_ __attribute__((unused))750#else751#define GTEST_ATTRIBUTE_UNUSED_752#endif753 754// Use this annotation before a function that takes a printf format string.755#if GTEST_HAVE_ATTRIBUTE_(format) && defined(__MINGW_PRINTF_FORMAT)756// MinGW has two different printf implementations. Ensure the format macro757// matches the selected implementation. See758// https://sourceforge.net/p/mingw-w64/wiki2/gnu%20printf/.759#define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \760  __attribute__((format(__MINGW_PRINTF_FORMAT, string_index, first_to_check)))761#elif GTEST_HAVE_ATTRIBUTE_(format)762#define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \763  __attribute__((format(printf, string_index, first_to_check)))764#else765#define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check)766#endif767 768// Tell the compiler to warn about unused return values for functions declared769// with this macro.  The macro should be used on function declarations770// following the argument list:771//772//   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;773#if GTEST_HAVE_ATTRIBUTE_(warn_unused_result)774#define GTEST_MUST_USE_RESULT_ __attribute__((warn_unused_result))775#else776#define GTEST_MUST_USE_RESULT_777#endif778 779// MS C++ compiler emits warning when a conditional expression is compile time780// constant. In some contexts this warning is false positive and needs to be781// suppressed. Use the following two macros in such cases:782//783// GTEST_INTENTIONAL_CONST_COND_PUSH_()784// while (true) {785// GTEST_INTENTIONAL_CONST_COND_POP_()786// }787#define GTEST_INTENTIONAL_CONST_COND_PUSH_() \788  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)789#define GTEST_INTENTIONAL_CONST_COND_POP_() GTEST_DISABLE_MSC_WARNINGS_POP_()790 791// Determine whether the compiler supports Microsoft's Structured Exception792// Handling.  This is supported by several Windows compilers but generally793// does not exist on any other system.794#ifndef GTEST_HAS_SEH795// The user didn't tell us, so we need to figure it out.796 797#if defined(_MSC_VER) || defined(__BORLANDC__)798// These two compilers are known to support SEH.799#define GTEST_HAS_SEH 1800#else801// Assume no SEH.802#define GTEST_HAS_SEH 0803#endif804 805#endif  // GTEST_HAS_SEH806 807#ifndef GTEST_IS_THREADSAFE808 809#if (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ ||                              \810     (defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_PHONE) && \811      !defined(GTEST_OS_WINDOWS_RT)) ||                                \812     GTEST_HAS_PTHREAD)813#define GTEST_IS_THREADSAFE 1814#endif815 816#endif  // GTEST_IS_THREADSAFE817 818#ifdef GTEST_IS_THREADSAFE819// Some platforms don't support including these threading related headers.820#include <condition_variable>  // NOLINT821#include <mutex>               // NOLINT822#endif                         // GTEST_IS_THREADSAFE823 824// GTEST_API_ qualifies all symbols that must be exported. The definitions below825// are guarded by #ifndef to give embedders a chance to define GTEST_API_ in826// gtest/internal/custom/gtest-port.h827#ifndef GTEST_API_828 829#ifdef _MSC_VER830#if GTEST_LINKED_AS_SHARED_LIBRARY831#define GTEST_API_ __declspec(dllimport)832#elif GTEST_CREATE_SHARED_LIBRARY833#define GTEST_API_ __declspec(dllexport)834#endif835#elif GTEST_HAVE_ATTRIBUTE_(visibility)836#define GTEST_API_ __attribute__((visibility("default")))837#endif  // _MSC_VER838 839#endif  // GTEST_API_840 841#ifndef GTEST_API_842#define GTEST_API_843#endif  // GTEST_API_844 845#ifndef GTEST_DEFAULT_DEATH_TEST_STYLE846#define GTEST_DEFAULT_DEATH_TEST_STYLE "fast"847#endif  // GTEST_DEFAULT_DEATH_TEST_STYLE848 849#if GTEST_HAVE_ATTRIBUTE_(noinline)850// Ask the compiler to never inline a given function.851#define GTEST_NO_INLINE_ __attribute__((noinline))852#else853#define GTEST_NO_INLINE_854#endif855 856#if GTEST_HAVE_ATTRIBUTE_(disable_tail_calls)857// Ask the compiler not to perform tail call optimization inside858// the marked function.859#define GTEST_NO_TAIL_CALL_ __attribute__((disable_tail_calls))860#elif defined(__GNUC__) && !defined(__NVCOMPILER)861#define GTEST_NO_TAIL_CALL_ \862  __attribute__((optimize("no-optimize-sibling-calls")))863#else864#define GTEST_NO_TAIL_CALL_865#endif866 867// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.868#if !defined(GTEST_HAS_CXXABI_H_)869#if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER))870#define GTEST_HAS_CXXABI_H_ 1871#else872#define GTEST_HAS_CXXABI_H_ 0873#endif874#endif875 876// A function level attribute to disable checking for use of uninitialized877// memory when built with MemorySanitizer.878#if GTEST_HAVE_ATTRIBUTE_(no_sanitize_memory)879#define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ __attribute__((no_sanitize_memory))880#else881#define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_882#endif883 884// A function level attribute to disable AddressSanitizer instrumentation.885#if GTEST_HAVE_ATTRIBUTE_(no_sanitize_address)886#define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \887  __attribute__((no_sanitize_address))888#else889#define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_890#endif891 892// A function level attribute to disable HWAddressSanitizer instrumentation.893#if GTEST_HAVE_FEATURE_(hwaddress_sanitizer) && \894    GTEST_HAVE_ATTRIBUTE_(no_sanitize)895#define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ \896  __attribute__((no_sanitize("hwaddress")))897#else898#define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_899#endif900 901// A function level attribute to disable ThreadSanitizer instrumentation.902#if GTEST_HAVE_ATTRIBUTE_(no_sanitize_thread)903#define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ __attribute((no_sanitize_thread))904#else905#define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_906#endif907 908namespace testing {909 910class Message;911 912// Legacy imports for backwards compatibility.913// New code should use std:: names directly.914using std::get;915using std::make_tuple;916using std::tuple;917using std::tuple_element;918using std::tuple_size;919 920namespace internal {921 922// A secret type that Google Test users don't know about.  It has no923// accessible constructors on purpose.  Therefore it's impossible to create a924// Secret object, which is what we want.925class Secret {926  Secret(const Secret&) = delete;927};928 929// A helper for suppressing warnings on constant condition.  It just930// returns 'condition'.931GTEST_API_ bool IsTrue(bool condition);932 933// Defines RE.934 935#ifdef GTEST_USES_RE2936 937// This is almost `using RE = ::RE2`, except it is copy-constructible, and it938// needs to disambiguate the `std::string`, `absl::string_view`, and `const939// char*` constructors.940class GTEST_API_ RE {941 public:942  RE(absl::string_view regex) : regex_(regex) {}                  // NOLINT943  RE(const char* regex) : RE(absl::string_view(regex)) {}         // NOLINT944  RE(const std::string& regex) : RE(absl::string_view(regex)) {}  // NOLINT945  RE(const RE& other) : RE(other.pattern()) {}946 947  const std::string& pattern() const { return regex_.pattern(); }948 949  static bool FullMatch(absl::string_view str, const RE& re) {950    return RE2::FullMatch(str, re.regex_);951  }952  static bool PartialMatch(absl::string_view str, const RE& re) {953    return RE2::PartialMatch(str, re.regex_);954  }955 956 private:957  RE2 regex_;958};959 960#elif defined(GTEST_USES_POSIX_RE) || defined(GTEST_USES_SIMPLE_RE)961GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \962/* class A needs to have dll-interface to be used by clients of class B */)963 964// A simple C++ wrapper for <regex.h>.  It uses the POSIX Extended965// Regular Expression syntax.966class GTEST_API_ RE {967 public:968  // A copy constructor is required by the Standard to initialize object969  // references from r-values.970  RE(const RE& other) { Init(other.pattern()); }971 972  // Constructs an RE from a string.973  RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT974 975  RE(const char* regex) { Init(regex); }  // NOLINT976  ~RE();977 978  // Returns the string representation of the regex.979  const char* pattern() const { return pattern_.c_str(); }980 981  // FullMatch(str, re) returns true if and only if regular expression re982  // matches the entire str.983  // PartialMatch(str, re) returns true if and only if regular expression re984  // matches a substring of str (including str itself).985  static bool FullMatch(const ::std::string& str, const RE& re) {986    return FullMatch(str.c_str(), re);987  }988  static bool PartialMatch(const ::std::string& str, const RE& re) {989    return PartialMatch(str.c_str(), re);990  }991 992  static bool FullMatch(const char* str, const RE& re);993  static bool PartialMatch(const char* str, const RE& re);994 995 private:996  void Init(const char* regex);997  std::string pattern_;998  bool is_valid_;999 1000#ifdef GTEST_USES_POSIX_RE1001 1002  regex_t full_regex_;     // For FullMatch().1003  regex_t partial_regex_;  // For PartialMatch().1004 1005#else  // GTEST_USES_SIMPLE_RE1006 1007  std::string full_pattern_;  // For FullMatch();1008 1009#endif1010};1011GTEST_DISABLE_MSC_WARNINGS_POP_()  // 42511012#endif  // ::testing::internal::RE implementation1013 1014// Formats a source file path and a line number as they would appear1015// in an error message from the compiler used to compile this code.1016GTEST_API_ ::std::string FormatFileLocation(const char* file, int line);1017 1018// Formats a file location for compiler-independent XML output.1019// Although this function is not platform dependent, we put it next to1020// FormatFileLocation in order to contrast the two functions.1021GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,1022                                                               int line);1023 1024// Defines logging utilities:1025//   GTEST_LOG_(severity) - logs messages at the specified severity level. The1026//                          message itself is streamed into the macro.1027//   LogToStderr()  - directs all log messages to stderr.1028//   FlushInfoLog() - flushes informational log messages.1029 1030enum GTestLogSeverity { GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL };1031 1032// Formats log entry severity, provides a stream object for streaming the1033// log message, and terminates the message with a newline when going out of1034// scope.1035class GTEST_API_ GTestLog {1036 public:1037  GTestLog(GTestLogSeverity severity, const char* file, int line);1038 1039  // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.1040  ~GTestLog();1041 1042  ::std::ostream& GetStream() { return ::std::cerr; }1043 1044 private:1045  const GTestLogSeverity severity_;1046 1047  GTestLog(const GTestLog&) = delete;1048  GTestLog& operator=(const GTestLog&) = delete;1049};1050 1051#if !defined(GTEST_LOG_)1052 1053#define GTEST_LOG_(severity)                                           \1054  ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \1055                                __FILE__, __LINE__)                    \1056      .GetStream()1057 1058inline void LogToStderr() {}1059inline void FlushInfoLog() { fflush(nullptr); }1060 1061#endif  // !defined(GTEST_LOG_)1062 1063#if !defined(GTEST_CHECK_)1064// INTERNAL IMPLEMENTATION - DO NOT USE.1065//1066// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition1067// is not satisfied.1068//  Synopsis:1069//    GTEST_CHECK_(boolean_condition);1070//     or1071//    GTEST_CHECK_(boolean_condition) << "Additional message";1072//1073//    This checks the condition and if the condition is not satisfied1074//    it prints message about the condition violation, including the1075//    condition itself, plus additional message streamed into it, if any,1076//    and then it aborts the program. It aborts the program irrespective of1077//    whether it is built in the debug mode or not.1078#define GTEST_CHECK_(condition)               \1079  GTEST_AMBIGUOUS_ELSE_BLOCKER_               \1080  if (::testing::internal::IsTrue(condition)) \1081    ;                                         \1082  else                                        \1083    GTEST_LOG_(FATAL) << "Condition " #condition " failed. "1084#endif  // !defined(GTEST_CHECK_)1085 1086// An all-mode assert to verify that the given POSIX-style function1087// call returns 0 (indicating success).  Known limitation: this1088// doesn't expand to a balanced 'if' statement, so enclose the macro1089// in {} if you need to use it as the only statement in an 'if'1090// branch.1091#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \1092  if (const int gtest_error = (posix_call))    \1093  GTEST_LOG_(FATAL) << #posix_call << "failed with error " << gtest_error1094 1095// Transforms "T" into "const T&" according to standard reference collapsing1096// rules (this is only needed as a backport for C++98 compilers that do not1097// support reference collapsing). Specifically, it transforms:1098//1099//   char         ==> const char&1100//   const char   ==> const char&1101//   char&        ==> char&1102//   const char&  ==> const char&1103//1104// Note that the non-const reference will not have "const" added. This is1105// standard, and necessary so that "T" can always bind to "const T&".1106template <typename T>1107struct ConstRef {1108  typedef const T& type;1109};1110template <typename T>1111struct ConstRef<T&> {1112  typedef T& type;1113};1114 1115// The argument T must depend on some template parameters.1116#define GTEST_REFERENCE_TO_CONST_(T) \1117  typename ::testing::internal::ConstRef<T>::type1118 1119// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.1120//1121// Use ImplicitCast_ as a safe version of static_cast for upcasting in1122// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a1123// const Foo*).  When you use ImplicitCast_, the compiler checks that1124// the cast is safe.  Such explicit ImplicitCast_s are necessary in1125// surprisingly many situations where C++ demands an exact type match1126// instead of an argument type convertible to a target type.1127//1128// The syntax for using ImplicitCast_ is the same as for static_cast:1129//1130//   ImplicitCast_<ToType>(expr)1131//1132// ImplicitCast_ would have been part of the C++ standard library,1133// but the proposal was submitted too late.  It will probably make1134// its way into the language in the future.1135//1136// This relatively ugly name is intentional. It prevents clashes with1137// similar functions users may have (e.g., implicit_cast). The internal1138// namespace alone is not enough because the function can be found by ADL.1139template <typename To>1140inline To ImplicitCast_(To x) {1141  return x;1142}1143 1144// Downcasts the pointer of type Base to Derived.1145// Derived must be a subclass of Base. The parameter MUST1146// point to a class of type Derived, not any subclass of it.1147// When RTTI is available, the function performs a runtime1148// check to enforce this.1149template <class Derived, class Base>1150Derived* CheckedDowncastToActualType(Base* base) {1151  static_assert(std::is_base_of<Base, Derived>::value,1152                "target type not derived from source type");1153#if GTEST_HAS_RTTI1154  GTEST_CHECK_(base == nullptr || dynamic_cast<Derived*>(base) != nullptr);1155#endif1156  return static_cast<Derived*>(base);1157}1158 1159#if GTEST_HAS_STREAM_REDIRECTION1160 1161// Defines the stderr capturer:1162//   CaptureStdout     - starts capturing stdout.1163//   GetCapturedStdout - stops capturing stdout and returns the captured string.1164//   CaptureStderr     - starts capturing stderr.1165//   GetCapturedStderr - stops capturing stderr and returns the captured string.1166//1167GTEST_API_ void CaptureStdout();1168GTEST_API_ std::string GetCapturedStdout();1169GTEST_API_ void CaptureStderr();1170GTEST_API_ std::string GetCapturedStderr();1171 1172#endif  // GTEST_HAS_STREAM_REDIRECTION1173// Returns the size (in bytes) of a file.1174GTEST_API_ size_t GetFileSize(FILE* file);1175 1176// Reads the entire content of a file as a string.1177GTEST_API_ std::string ReadEntireFile(FILE* file);1178 1179// All command line arguments.1180GTEST_API_ std::vector<std::string> GetArgvs();1181 1182#ifdef GTEST_HAS_DEATH_TEST1183 1184std::vector<std::string> GetInjectableArgvs();1185// Deprecated: pass the args vector by value instead.1186void SetInjectableArgvs(const std::vector<std::string>* new_argvs);1187void SetInjectableArgvs(const std::vector<std::string>& new_argvs);1188void ClearInjectableArgvs();1189 1190#endif  // GTEST_HAS_DEATH_TEST1191 1192// Defines synchronization primitives.1193#ifdef GTEST_IS_THREADSAFE1194 1195#ifdef GTEST_OS_WINDOWS1196// Provides leak-safe Windows kernel handle ownership.1197// Used in death tests and in threading support.1198class GTEST_API_ AutoHandle {1199 public:1200  // Assume that Win32 HANDLE type is equivalent to void*. Doing so allows us to1201  // avoid including <windows.h> in this header file. Including <windows.h> is1202  // undesirable because it defines a lot of symbols and macros that tend to1203  // conflict with client code. This assumption is verified by1204  // WindowsTypesTest.HANDLEIsVoidStar.1205  typedef void* Handle;1206  AutoHandle();1207  explicit AutoHandle(Handle handle);1208 1209  ~AutoHandle();1210 1211  Handle Get() const;1212  void Reset();1213  void Reset(Handle handle);1214 1215 private:1216  // Returns true if and only if the handle is a valid handle object that can be1217  // closed.1218  bool IsCloseable() const;1219 1220  Handle handle_;1221 1222  AutoHandle(const AutoHandle&) = delete;1223  AutoHandle& operator=(const AutoHandle&) = delete;1224};1225#endif1226 1227#if GTEST_HAS_NOTIFICATION_1228// Notification has already been imported into the namespace.1229// Nothing to do here.1230 1231#else1232GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \1233/* class A needs to have dll-interface to be used by clients of class B */)1234 1235// Allows a controller thread to pause execution of newly created1236// threads until notified.  Instances of this class must be created1237// and destroyed in the controller thread.1238//1239// This class is only for testing Google Test's own constructs. Do not1240// use it in user tests, either directly or indirectly.1241// TODO(b/203539622): Replace unconditionally with absl::Notification.1242class GTEST_API_ Notification {1243 public:1244  Notification() : notified_(false) {}1245  Notification(const Notification&) = delete;1246  Notification& operator=(const Notification&) = delete;1247 1248  // Notifies all threads created with this notification to start. Must1249  // be called from the controller thread.1250  void Notify() {1251    std::lock_guard<std::mutex> lock(mu_);1252    notified_ = true;1253    cv_.notify_all();1254  }1255 1256  // Blocks until the controller thread notifies. Must be called from a test1257  // thread.1258  void WaitForNotification() {1259    std::unique_lock<std::mutex> lock(mu_);1260    cv_.wait(lock, [this]() { return notified_; });1261  }1262 1263 private:1264  std::mutex mu_;1265  std::condition_variable cv_;1266  bool notified_;1267};1268GTEST_DISABLE_MSC_WARNINGS_POP_()  // 42511269#endif  // GTEST_HAS_NOTIFICATION_1270 1271// On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD1272// defined, but we don't want to use MinGW's pthreads implementation, which1273// has conformance problems with some versions of the POSIX standard.1274#if GTEST_HAS_PTHREAD && !defined(GTEST_OS_WINDOWS_MINGW)1275 1276// As a C-function, ThreadFuncWithCLinkage cannot be templated itself.1277// Consequently, it cannot select a correct instantiation of ThreadWithParam1278// in order to call its Run(). Introducing ThreadWithParamBase as a1279// non-templated base class for ThreadWithParam allows us to bypass this1280// problem.1281class ThreadWithParamBase {1282 public:1283  virtual ~ThreadWithParamBase() = default;1284  virtual void Run() = 0;1285};1286 1287// pthread_create() accepts a pointer to a function type with the C linkage.1288// According to the Standard (7.5/1), function types with different linkages1289// are different even if they are otherwise identical.  Some compilers (for1290// example, SunStudio) treat them as different types.  Since class methods1291// cannot be defined with C-linkage we need to define a free C-function to1292// pass into pthread_create().1293extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {1294  static_cast<ThreadWithParamBase*>(thread)->Run();1295  return nullptr;1296}1297 1298// Helper class for testing Google Test's multi-threading constructs.1299// To use it, write:1300//1301//   void ThreadFunc(int param) { /* Do things with param */ }1302//   Notification thread_can_start;1303//   ...1304//   // The thread_can_start parameter is optional; you can supply NULL.1305//   ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start);1306//   thread_can_start.Notify();1307//1308// These classes are only for testing Google Test's own constructs. Do1309// not use them in user tests, either directly or indirectly.1310template <typename T>1311class ThreadWithParam : public ThreadWithParamBase {1312 public:1313  typedef void UserThreadFunc(T);1314 1315  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)1316      : func_(func),1317        param_(param),1318        thread_can_start_(thread_can_start),1319        finished_(false) {1320    ThreadWithParamBase* const base = this;1321    // The thread can be created only after all fields except thread_1322    // have been initialized.1323    GTEST_CHECK_POSIX_SUCCESS_(1324        pthread_create(&thread_, nullptr, &ThreadFuncWithCLinkage, base));1325  }1326  ~ThreadWithParam() override { Join(); }1327 1328  void Join() {1329    if (!finished_) {1330      GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, nullptr));1331      finished_ = true;1332    }1333  }1334 1335  void Run() override {1336    if (thread_can_start_ != nullptr) thread_can_start_->WaitForNotification();1337    func_(param_);1338  }1339 1340 private:1341  UserThreadFunc* const func_;  // User-supplied thread function.1342  const T param_;  // User-supplied parameter to the thread function.1343  // When non-NULL, used to block execution until the controller thread1344  // notifies.1345  Notification* const thread_can_start_;1346  bool finished_;  // true if and only if we know that the thread function has1347                   // finished.1348  pthread_t thread_;  // The native thread object.1349 1350  ThreadWithParam(const ThreadWithParam&) = delete;1351  ThreadWithParam& operator=(const ThreadWithParam&) = delete;1352};1353#endif  // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD ||1354        // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_1355 1356#if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_1357// Mutex and ThreadLocal have already been imported into the namespace.1358// Nothing to do here.1359 1360#elif defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_PHONE) && \1361    !defined(GTEST_OS_WINDOWS_RT)1362 1363// Mutex implements mutex on Windows platforms.  It is used in conjunction1364// with class MutexLock:1365//1366//   Mutex mutex;1367//   ...1368//   MutexLock lock(&mutex);  // Acquires the mutex and releases it at the1369//                            // end of the current scope.1370//1371// A static Mutex *must* be defined or declared using one of the following1372// macros:1373//   GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);1374//   GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);1375//1376// (A non-static Mutex is defined/declared in the usual way).1377class GTEST_API_ Mutex {1378 public:1379  enum MutexType { kStatic = 0, kDynamic = 1 };1380  // We rely on kStaticMutex being 0 as it is to what the linker initializes1381  // type_ in static mutexes.  critical_section_ will be initialized lazily1382  // in ThreadSafeLazyInit().1383  enum StaticConstructorSelector { kStaticMutex = 0 };1384 1385  // This constructor intentionally does nothing.  It relies on type_ being1386  // statically initialized to 0 (effectively setting it to kStatic) and on1387  // ThreadSafeLazyInit() to lazily initialize the rest of the members.1388  explicit Mutex(StaticConstructorSelector /*dummy*/) {}1389 1390  Mutex();1391  ~Mutex();1392 1393  void Lock();1394 1395  void Unlock();1396 1397  // Does nothing if the current thread holds the mutex. Otherwise, crashes1398  // with high probability.1399  void AssertHeld();1400 1401 private:1402  // Initializes owner_thread_id_ and critical_section_ in static mutexes.1403  void ThreadSafeLazyInit();1404 1405  // Per https://blogs.msdn.microsoft.com/oldnewthing/20040223-00/?p=40503,1406  // we assume that 0 is an invalid value for thread IDs.1407  unsigned int owner_thread_id_;1408 1409  // For static mutexes, we rely on these members being initialized to zeros1410  // by the linker.1411  MutexType type_;1412  long critical_section_init_phase_;  // NOLINT1413  GTEST_CRITICAL_SECTION* critical_section_;1414 1415  Mutex(const Mutex&) = delete;1416  Mutex& operator=(const Mutex&) = delete;1417};1418 1419#define GTEST_DECLARE_STATIC_MUTEX_(mutex) \1420  extern ::testing::internal::Mutex mutex1421 1422#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \1423  ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex)1424 1425// We cannot name this class MutexLock because the ctor declaration would1426// conflict with a macro named MutexLock, which is defined on some1427// platforms. That macro is used as a defensive measure to prevent against1428// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than1429// "MutexLock l(&mu)".  Hence the typedef trick below.1430class GTestMutexLock {1431 public:1432  explicit GTestMutexLock(Mutex* mutex) : mutex_(mutex) { mutex_->Lock(); }1433 1434  ~GTestMutexLock() { mutex_->Unlock(); }1435 1436 private:1437  Mutex* const mutex_;1438 1439  GTestMutexLock(const GTestMutexLock&) = delete;1440  GTestMutexLock& operator=(const GTestMutexLock&) = delete;1441};1442 1443typedef GTestMutexLock MutexLock;1444 1445// Base class for ValueHolder<T>.  Allows a caller to hold and delete a value1446// without knowing its type.1447class ThreadLocalValueHolderBase {1448 public:1449  virtual ~ThreadLocalValueHolderBase() {}1450};1451 1452// Provides a way for a thread to send notifications to a ThreadLocal1453// regardless of its parameter type.1454class ThreadLocalBase {1455 public:1456  // Creates a new ValueHolder<T> object holding a default value passed to1457  // this ThreadLocal<T>'s constructor and returns it.  It is the caller's1458  // responsibility not to call this when the ThreadLocal<T> instance already1459  // has a value on the current thread.1460  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const = 0;1461 1462 protected:1463  ThreadLocalBase() {}1464  virtual ~ThreadLocalBase() {}1465 1466 private:1467  ThreadLocalBase(const ThreadLocalBase&) = delete;1468  ThreadLocalBase& operator=(const ThreadLocalBase&) = delete;1469};1470 1471// Maps a thread to a set of ThreadLocals that have values instantiated on that1472// thread and notifies them when the thread exits.  A ThreadLocal instance is1473// expected to persist until all threads it has values on have terminated.1474class GTEST_API_ ThreadLocalRegistry {1475 public:1476  // Registers thread_local_instance as having value on the current thread.1477  // Returns a value that can be used to identify the thread from other threads.1478  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(1479      const ThreadLocalBase* thread_local_instance);1480 1481  // Invoked when a ThreadLocal instance is destroyed.1482  static void OnThreadLocalDestroyed(1483      const ThreadLocalBase* thread_local_instance);1484};1485 1486class GTEST_API_ ThreadWithParamBase {1487 public:1488  void Join();1489 1490 protected:1491  class Runnable {1492   public:1493    virtual ~Runnable() {}1494    virtual void Run() = 0;1495  };1496 1497  ThreadWithParamBase(Runnable* runnable, Notification* thread_can_start);1498  virtual ~ThreadWithParamBase();1499 1500 private:1501  AutoHandle thread_;1502};1503 1504// Helper class for testing Google Test's multi-threading constructs.1505template <typename T>1506class ThreadWithParam : public ThreadWithParamBase {1507 public:1508  typedef void UserThreadFunc(T);1509 1510  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)1511      : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {}1512  virtual ~ThreadWithParam() {}1513 1514 private:1515  class RunnableImpl : public Runnable {1516   public:1517    RunnableImpl(UserThreadFunc* func, T param) : func_(func), param_(param) {}1518    virtual ~RunnableImpl() {}1519    virtual void Run() { func_(param_); }1520 1521   private:1522    UserThreadFunc* const func_;1523    const T param_;1524 1525    RunnableImpl(const RunnableImpl&) = delete;1526    RunnableImpl& operator=(const RunnableImpl&) = delete;1527  };1528 1529  ThreadWithParam(const ThreadWithParam&) = delete;1530  ThreadWithParam& operator=(const ThreadWithParam&) = delete;1531};1532 1533// Implements thread-local storage on Windows systems.1534//1535//   // Thread 11536//   ThreadLocal<int> tl(100);  // 100 is the default value for each thread.1537//1538//   // Thread 21539//   tl.set(150);  // Changes the value for thread 2 only.1540//   EXPECT_EQ(150, tl.get());1541//1542//   // Thread 11543//   EXPECT_EQ(100, tl.get());  // In thread 1, tl has the original value.1544//   tl.set(200);1545//   EXPECT_EQ(200, tl.get());1546//1547// The template type argument T must have a public copy constructor.1548// In addition, the default ThreadLocal constructor requires T to have1549// a public default constructor.1550//1551// The users of a TheadLocal instance have to make sure that all but one1552// threads (including the main one) using that instance have exited before1553// destroying it. Otherwise, the per-thread objects managed for them by the1554// ThreadLocal instance are not guaranteed to be destroyed on all platforms.1555//1556// Google Test only uses global ThreadLocal objects.  That means they1557// will die after main() has returned.  Therefore, no per-thread1558// object managed by Google Test will be leaked as long as all threads1559// using Google Test have exited when main() returns.1560template <typename T>1561class ThreadLocal : public ThreadLocalBase {1562 public:1563  ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {}1564  explicit ThreadLocal(const T& value)1565      : default_factory_(new InstanceValueHolderFactory(value)) {}1566 1567  ~ThreadLocal() override { ThreadLocalRegistry::OnThreadLocalDestroyed(this); }1568 1569  T* pointer() { return GetOrCreateValue(); }1570  const T* pointer() const { return GetOrCreateValue(); }1571  const T& get() const { return *pointer(); }1572  void set(const T& value) { *pointer() = value; }1573 1574 private:1575  // Holds a value of T.  Can be deleted via its base class without the caller1576  // knowing the type of T.1577  class ValueHolder : public ThreadLocalValueHolderBase {1578   public:1579    ValueHolder() : value_() {}1580    explicit ValueHolder(const T& value) : value_(value) {}1581 1582    T* pointer() { return &value_; }1583 1584   private:1585    T value_;1586    ValueHolder(const ValueHolder&) = delete;1587    ValueHolder& operator=(const ValueHolder&) = delete;1588  };1589 1590  T* GetOrCreateValue() const {1591    return static_cast<ValueHolder*>(1592               ThreadLocalRegistry::GetValueOnCurrentThread(this))1593        ->pointer();1594  }1595 1596  ThreadLocalValueHolderBase* NewValueForCurrentThread() const override {1597    return default_factory_->MakeNewHolder();1598  }1599 1600  class ValueHolderFactory {1601   public:1602    ValueHolderFactory() {}1603    virtual ~ValueHolderFactory() {}1604    virtual ValueHolder* MakeNewHolder() const = 0;1605 1606   private:1607    ValueHolderFactory(const ValueHolderFactory&) = delete;1608    ValueHolderFactory& operator=(const ValueHolderFactory&) = delete;1609  };1610 1611  class DefaultValueHolderFactory : public ValueHolderFactory {1612   public:1613    DefaultValueHolderFactory() {}1614    ValueHolder* MakeNewHolder() const override { return new ValueHolder(); }1615 1616   private:1617    DefaultValueHolderFactory(const DefaultValueHolderFactory&) = delete;1618    DefaultValueHolderFactory& operator=(const DefaultValueHolderFactory&) =1619        delete;1620  };1621 1622  class InstanceValueHolderFactory : public ValueHolderFactory {1623   public:1624    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}1625    ValueHolder* MakeNewHolder() const override {1626      return new ValueHolder(value_);1627    }1628 1629   private:1630    const T value_;  // The value for each thread.1631 1632    InstanceValueHolderFactory(const InstanceValueHolderFactory&) = delete;1633    InstanceValueHolderFactory& operator=(const InstanceValueHolderFactory&) =1634        delete;1635  };1636 1637  std::unique_ptr<ValueHolderFactory> default_factory_;1638 1639  ThreadLocal(const ThreadLocal&) = delete;1640  ThreadLocal& operator=(const ThreadLocal&) = delete;1641};1642 1643#elif GTEST_HAS_PTHREAD1644 1645// MutexBase and Mutex implement mutex on pthreads-based platforms.1646class MutexBase {1647 public:1648  // Acquires this mutex.1649  void Lock() {1650    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));1651    owner_ = pthread_self();1652    has_owner_ = true;1653  }1654 1655  // Releases this mutex.1656  void Unlock() {1657    // Since the lock is being released the owner_ field should no longer be1658    // considered valid. We don't protect writing to has_owner_ here, as it's1659    // the caller's responsibility to ensure that the current thread holds the1660    // mutex when this is called.1661    has_owner_ = false;1662    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));1663  }1664 1665  // Does nothing if the current thread holds the mutex. Otherwise, crashes1666  // with high probability.1667  void AssertHeld() const {1668    GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))1669        << "The current thread is not holding the mutex @" << this;1670  }1671 1672  // A static mutex may be used before main() is entered.  It may even1673  // be used before the dynamic initialization stage.  Therefore we1674  // must be able to initialize a static mutex object at link time.1675  // This means MutexBase has to be a POD and its member variables1676  // have to be public.1677 public:1678  pthread_mutex_t mutex_;  // The underlying pthread mutex.1679  // has_owner_ indicates whether the owner_ field below contains a valid thread1680  // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All1681  // accesses to the owner_ field should be protected by a check of this field.1682  // An alternative might be to memset() owner_ to all zeros, but there's no1683  // guarantee that a zero'd pthread_t is necessarily invalid or even different1684  // from pthread_self().1685  bool has_owner_;1686  pthread_t owner_;  // The thread holding the mutex.1687};1688 1689// Forward-declares a static mutex.1690#define GTEST_DECLARE_STATIC_MUTEX_(mutex) \1691  extern ::testing::internal::MutexBase mutex1692 1693// Defines and statically (i.e. at link time) initializes a static mutex.1694// The initialization list here does not explicitly initialize each field,1695// instead relying on default initialization for the unspecified fields. In1696// particular, the owner_ field (a pthread_t) is not explicitly initialized.1697// This allows initialization to work whether pthread_t is a scalar or struct.1698// The flag -Wmissing-field-initializers must not be specified for this to work.1699#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \1700  ::testing::internal::MutexBase mutex = {PTHREAD_MUTEX_INITIALIZER, false, 0}1701 1702// The Mutex class can only be used for mutexes created at runtime. It1703// shares its API with MutexBase otherwise.1704class Mutex : public MutexBase {1705 public:1706  Mutex() {1707    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));1708    has_owner_ = false;1709  }1710  ~Mutex() { GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_)); }1711 1712 private:1713  Mutex(const Mutex&) = delete;1714  Mutex& operator=(const Mutex&) = delete;1715};1716 1717// We cannot name this class MutexLock because the ctor declaration would1718// conflict with a macro named MutexLock, which is defined on some1719// platforms. That macro is used as a defensive measure to prevent against1720// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than1721// "MutexLock l(&mu)".  Hence the typedef trick below.1722class GTestMutexLock {1723 public:1724  explicit GTestMutexLock(MutexBase* mutex) : mutex_(mutex) { mutex_->Lock(); }1725 1726  ~GTestMutexLock() { mutex_->Unlock(); }1727 1728 private:1729  MutexBase* const mutex_;1730 1731  GTestMutexLock(const GTestMutexLock&) = delete;1732  GTestMutexLock& operator=(const GTestMutexLock&) = delete;1733};1734 1735typedef GTestMutexLock MutexLock;1736 1737// Helpers for ThreadLocal.1738 1739// pthread_key_create() requires DeleteThreadLocalValue() to have1740// C-linkage.  Therefore it cannot be templatized to access1741// ThreadLocal<T>.  Hence the need for class1742// ThreadLocalValueHolderBase.1743class GTEST_API_ ThreadLocalValueHolderBase {1744 public:1745  virtual ~ThreadLocalValueHolderBase() = default;1746};1747 1748// Called by pthread to delete thread-local data stored by1749// pthread_setspecific().1750extern "C" inline void DeleteThreadLocalValue(void* value_holder) {1751  delete static_cast<ThreadLocalValueHolderBase*>(value_holder);1752}1753 1754// Implements thread-local storage on pthreads-based systems.1755template <typename T>1756class GTEST_API_ ThreadLocal {1757 public:1758  ThreadLocal()1759      : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}1760  explicit ThreadLocal(const T& value)1761      : key_(CreateKey()),1762        default_factory_(new InstanceValueHolderFactory(value)) {}1763 1764  ~ThreadLocal() {1765    // Destroys the managed object for the current thread, if any.1766    DeleteThreadLocalValue(pthread_getspecific(key_));1767 1768    // Releases resources associated with the key.  This will *not*1769    // delete managed objects for other threads.1770    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));1771  }1772 1773  T* pointer() { return GetOrCreateValue(); }1774  const T* pointer() const { return GetOrCreateValue(); }1775  const T& get() const { return *pointer(); }1776  void set(const T& value) { *pointer() = value; }1777 1778 private:1779  // Holds a value of type T.1780  class ValueHolder : public ThreadLocalValueHolderBase {1781   public:1782    ValueHolder() : value_() {}1783    explicit ValueHolder(const T& value) : value_(value) {}1784 1785    T* pointer() { return &value_; }1786 1787   private:1788    T value_;1789    ValueHolder(const ValueHolder&) = delete;1790    ValueHolder& operator=(const ValueHolder&) = delete;1791  };1792 1793  static pthread_key_t CreateKey() {1794    pthread_key_t key;1795    // When a thread exits, DeleteThreadLocalValue() will be called on1796    // the object managed for that thread.1797    GTEST_CHECK_POSIX_SUCCESS_(1798        pthread_key_create(&key, &DeleteThreadLocalValue));1799    return key;1800  }1801 1802  T* GetOrCreateValue() const {1803    ThreadLocalValueHolderBase* const holder =1804        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));1805    if (holder != nullptr) {1806      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();1807    }1808 1809    ValueHolder* const new_holder = default_factory_->MakeNewHolder();1810    ThreadLocalValueHolderBase* const holder_base = new_holder;1811    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));1812    return new_holder->pointer();1813  }1814 1815  class ValueHolderFactory {1816   public:1817    ValueHolderFactory() = default;1818    virtual ~ValueHolderFactory() = default;1819    virtual ValueHolder* MakeNewHolder() const = 0;1820 1821   private:1822    ValueHolderFactory(const ValueHolderFactory&) = delete;1823    ValueHolderFactory& operator=(const ValueHolderFactory&) = delete;1824  };1825 1826  class DefaultValueHolderFactory : public ValueHolderFactory {1827   public:1828    DefaultValueHolderFactory() = default;1829    ValueHolder* MakeNewHolder() const override { return new ValueHolder(); }1830 1831   private:1832    DefaultValueHolderFactory(const DefaultValueHolderFactory&) = delete;1833    DefaultValueHolderFactory& operator=(const DefaultValueHolderFactory&) =1834        delete;1835  };1836 1837  class InstanceValueHolderFactory : public ValueHolderFactory {1838   public:1839    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}1840    ValueHolder* MakeNewHolder() const override {1841      return new ValueHolder(value_);1842    }1843 1844   private:1845    const T value_;  // The value for each thread.1846 1847    InstanceValueHolderFactory(const InstanceValueHolderFactory&) = delete;1848    InstanceValueHolderFactory& operator=(const InstanceValueHolderFactory&) =1849        delete;1850  };1851 1852  // A key pthreads uses for looking up per-thread values.1853  const pthread_key_t key_;1854  std::unique_ptr<ValueHolderFactory> default_factory_;1855 1856  ThreadLocal(const ThreadLocal&) = delete;1857  ThreadLocal& operator=(const ThreadLocal&) = delete;1858};1859 1860#endif  // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_1861 1862#else  // GTEST_IS_THREADSAFE1863 1864// A dummy implementation of synchronization primitives (mutex, lock,1865// and thread-local variable).  Necessary for compiling Google Test where1866// mutex is not supported - using Google Test in multiple threads is not1867// supported on such platforms.1868 1869class Mutex {1870 public:1871  Mutex() {}1872  void Lock() {}1873  void Unlock() {}1874  void AssertHeld() const {}1875};1876 1877#define GTEST_DECLARE_STATIC_MUTEX_(mutex) \1878  extern ::testing::internal::Mutex mutex1879 1880#define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex1881 1882// We cannot name this class MutexLock because the ctor declaration would1883// conflict with a macro named MutexLock, which is defined on some1884// platforms. That macro is used as a defensive measure to prevent against1885// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than1886// "MutexLock l(&mu)".  Hence the typedef trick below.1887class GTestMutexLock {1888 public:1889  explicit GTestMutexLock(Mutex*) {}  // NOLINT1890};1891 1892typedef GTestMutexLock MutexLock;1893 1894template <typename T>1895class GTEST_API_ ThreadLocal {1896 public:1897  ThreadLocal() : value_() {}1898  explicit ThreadLocal(const T& value) : value_(value) {}1899  T* pointer() { return &value_; }1900  const T* pointer() const { return &value_; }1901  const T& get() const { return value_; }1902  void set(const T& value) { value_ = value; }1903 1904 private:1905  T value_;1906};1907 1908#endif  // GTEST_IS_THREADSAFE1909 1910// Returns the number of threads running in the process, or 0 to indicate that1911// we cannot detect it.1912GTEST_API_ size_t GetThreadCount();1913 1914#ifdef GTEST_OS_WINDOWS1915#define GTEST_PATH_SEP_ "\\"1916#define GTEST_HAS_ALT_PATH_SEP_ 11917#else1918#define GTEST_PATH_SEP_ "/"1919#define GTEST_HAS_ALT_PATH_SEP_ 01920#endif  // GTEST_OS_WINDOWS1921 1922// Utilities for char.1923 1924// isspace(int ch) and friends accept an unsigned char or EOF.  char1925// may be signed, depending on the compiler (or compiler flags).1926// Therefore we need to cast a char to unsigned char before calling1927// isspace(), etc.1928 1929inline bool IsAlpha(char ch) {1930  return isalpha(static_cast<unsigned char>(ch)) != 0;1931}1932inline bool IsAlNum(char ch) {1933  return isalnum(static_cast<unsigned char>(ch)) != 0;1934}1935inline bool IsDigit(char ch) {1936  return isdigit(static_cast<unsigned char>(ch)) != 0;1937}1938inline bool IsLower(char ch) {1939  return islower(static_cast<unsigned char>(ch)) != 0;1940}1941inline bool IsSpace(char ch) {1942  return isspace(static_cast<unsigned char>(ch)) != 0;1943}1944inline bool IsUpper(char ch) {1945  return isupper(static_cast<unsigned char>(ch)) != 0;1946}1947inline bool IsXDigit(char ch) {1948  return isxdigit(static_cast<unsigned char>(ch)) != 0;1949}1950#ifdef __cpp_lib_char8_t1951inline bool IsXDigit(char8_t ch) {1952  return isxdigit(static_cast<unsigned char>(ch)) != 0;1953}1954#endif1955inline bool IsXDigit(char16_t ch) {1956  const unsigned char low_byte = static_cast<unsigned char>(ch);1957  return ch == low_byte && isxdigit(low_byte) != 0;1958}1959inline bool IsXDigit(char32_t ch) {1960  const unsigned char low_byte = static_cast<unsigned char>(ch);1961  return ch == low_byte && isxdigit(low_byte) != 0;1962}1963inline bool IsXDigit(wchar_t ch) {1964  const unsigned char low_byte = static_cast<unsigned char>(ch);1965  return ch == low_byte && isxdigit(low_byte) != 0;1966}1967 1968inline char ToLower(char ch) {1969  return static_cast<char>(tolower(static_cast<unsigned char>(ch)));1970}1971inline char ToUpper(char ch) {1972  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));1973}1974 1975inline std::string StripTrailingSpaces(std::string str) {1976  std::string::iterator it = str.end();1977  while (it != str.begin() && IsSpace(*--it)) it = str.erase(it);1978  return str;1979}1980 1981// The testing::internal::posix namespace holds wrappers for common1982// POSIX functions.  These wrappers hide the differences between1983// Windows/MSVC and POSIX systems.  Since some compilers define these1984// standard functions as macros, the wrapper cannot have the same name1985// as the wrapped function.1986 1987namespace posix {1988 1989// File system porting.1990#if GTEST_HAS_FILE_SYSTEM1991#ifdef GTEST_OS_WINDOWS1992 1993typedef struct _stat StatStruct;1994 1995#ifdef GTEST_OS_WINDOWS_MOBILE1996inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }1997// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this1998// time and thus not defined there.1999#else2000inline int FileNo(FILE* file) { return _fileno(file); }2001inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }2002inline int RmDir(const char* dir) { return _rmdir(dir); }2003inline bool IsDir(const StatStruct& st) { return (_S_IFDIR & st.st_mode) != 0; }2004#endif  // GTEST_OS_WINDOWS_MOBILE2005 2006#elif defined(GTEST_OS_ESP8266)2007typedef struct stat StatStruct;2008 2009inline int FileNo(FILE* file) { return fileno(file); }2010inline int Stat(const char* path, StatStruct* buf) {2011  // stat function not implemented on ESP82662012  return 0;2013}2014inline int RmDir(const char* dir) { return rmdir(dir); }2015inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }2016 2017#else2018 2019typedef struct stat StatStruct;2020 2021inline int FileNo(FILE* file) { return fileno(file); }2022inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }2023#ifdef GTEST_OS_QURT2024// QuRT doesn't support any directory functions, including rmdir2025inline int RmDir(const char*) { return 0; }2026#else2027inline int RmDir(const char* dir) { return rmdir(dir); }2028#endif2029inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }2030 2031#endif  // GTEST_OS_WINDOWS2032#endif  // GTEST_HAS_FILE_SYSTEM2033 2034// Other functions with a different name on Windows.2035 2036#ifdef GTEST_OS_WINDOWS2037 2038#ifdef __BORLANDC__2039inline int DoIsATTY(int fd) { return isatty(fd); }2040inline int StrCaseCmp(const char* s1, const char* s2) {2041  return stricmp(s1, s2);2042}2043#else  // !__BORLANDC__2044#if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_ZOS) || \2045    defined(GTEST_OS_IOS) || defined(GTEST_OS_WINDOWS_PHONE) ||  \2046    defined(GTEST_OS_WINDOWS_RT) || defined(ESP_PLATFORM)2047inline int DoIsATTY(int /* fd */) { return 0; }2048#else2049inline int DoIsATTY(int fd) { return _isatty(fd); }2050#endif  // GTEST_OS_WINDOWS_MOBILE2051inline int StrCaseCmp(const char* s1, const char* s2) {2052  return _stricmp(s1, s2);2053}2054#endif  // __BORLANDC__2055 2056#else2057 2058inline int DoIsATTY(int fd) { return isatty(fd); }2059inline int StrCaseCmp(const char* s1, const char* s2) {2060  return strcasecmp(s1, s2);2061}2062 2063#endif  // GTEST_OS_WINDOWS2064 2065inline int IsATTY(int fd) {2066  // DoIsATTY might change errno (for example ENOTTY in case you redirect stdout2067  // to a file on Linux), which is unexpected, so save the previous value, and2068  // restore it after the call.2069  int savedErrno = errno;2070  int isAttyValue = DoIsATTY(fd);2071  errno = savedErrno;2072 2073  return isAttyValue;2074}2075 2076// Functions deprecated by MSVC 8.0.2077 2078GTEST_DISABLE_MSC_DEPRECATED_PUSH_()2079 2080// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and2081// StrError() aren't needed on Windows CE at this time and thus not2082// defined there.2083#if GTEST_HAS_FILE_SYSTEM2084#if !defined(GTEST_OS_WINDOWS_MOBILE) && !defined(GTEST_OS_WINDOWS_PHONE) && \2085    !defined(GTEST_OS_WINDOWS_RT) && !defined(GTEST_OS_ESP8266) &&           \2086    !defined(GTEST_OS_XTENSA) && !defined(GTEST_OS_QURT)2087inline int ChDir(const char* dir) { return chdir(dir); }2088#endif2089inline FILE* FOpen(const char* path, const char* mode) {2090// FIXME: This doesn't work when building with rpmalloc, see2091// https://github.com/llvm/llvm-project/pull/65823#issuecomment-17398205342092// so hacking it out for now.2093#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MINGW) && 02094  struct wchar_codecvt : public std::codecvt<wchar_t, char, std::mbstate_t> {};2095  std::wstring_convert<wchar_codecvt> converter;2096  std::wstring wide_path = converter.from_bytes(path);2097  std::wstring wide_mode = converter.from_bytes(mode);2098  return _wfopen(wide_path.c_str(), wide_mode.c_str());2099#else   // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW2100  return fopen(path, mode);2101#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW2102}2103#if !defined(GTEST_OS_WINDOWS_MOBILE) && !defined(GTEST_OS_QURT)2104inline FILE* FReopen(const char* path, const char* mode, FILE* stream) {2105  return freopen(path, mode, stream);2106}2107inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }2108#endif  // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT2109inline int FClose(FILE* fp) { return fclose(fp); }2110#if !defined(GTEST_OS_WINDOWS_MOBILE) && !defined(GTEST_OS_QURT)2111inline int Read(int fd, void* buf, unsigned int count) {2112  return static_cast<int>(read(fd, buf, count));2113}2114inline int Write(int fd, const void* buf, unsigned int count) {2115  return static_cast<int>(write(fd, buf, count));2116}2117inline int Close(int fd) { return close(fd); }2118#endif  // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT2119#endif  // GTEST_HAS_FILE_SYSTEM2120 2121#if !defined(GTEST_OS_WINDOWS_MOBILE) && !defined(GTEST_OS_QURT)2122inline const char* StrError(int errnum) { return strerror(errnum); }2123#endif  // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT2124 2125inline const char* GetEnv(const char* name) {2126#if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_WINDOWS_PHONE) || \2127    defined(GTEST_OS_ESP8266) || defined(GTEST_OS_XTENSA) ||               \2128    defined(GTEST_OS_QURT)2129  // We are on an embedded platform, which has no environment variables.2130  static_cast<void>(name);  // To prevent 'unused argument' warning.2131  return nullptr;2132#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)2133  // Environment variables which we programmatically clear will be set to the2134  // empty string rather than unset (NULL).  Handle that case.2135  const char* const env = getenv(name);2136  return (env != nullptr && env[0] != '\0') ? env : nullptr;2137#else2138  return getenv(name);2139#endif2140}2141 2142GTEST_DISABLE_MSC_DEPRECATED_POP_()2143 2144#ifdef GTEST_OS_WINDOWS_MOBILE2145// Windows CE has no C library. The abort() function is used in2146// several places in Google Test. This implementation provides a reasonable2147// imitation of standard behaviour.2148[[noreturn]] void Abort();2149#else2150[[noreturn]] inline void Abort() { abort(); }2151#endif  // GTEST_OS_WINDOWS_MOBILE2152 2153}  // namespace posix2154 2155// MSVC "deprecates" snprintf and issues warnings wherever it is used.  In2156// order to avoid these warnings, we need to use _snprintf or _snprintf_s on2157// MSVC-based platforms.  We map the GTEST_SNPRINTF_ macro to the appropriate2158// function in order to achieve that.  We use macro definition here because2159// snprintf is a variadic function.2160#if defined(_MSC_VER) && !defined(GTEST_OS_WINDOWS_MOBILE)2161// MSVC 2005 and above support variadic macros.2162#define GTEST_SNPRINTF_(buffer, size, format, ...) \2163  _snprintf_s(buffer, size, size, format, __VA_ARGS__)2164#elif defined(_MSC_VER)2165// Windows CE does not define _snprintf_s2166#define GTEST_SNPRINTF_ _snprintf2167#else2168#define GTEST_SNPRINTF_ snprintf2169#endif2170 2171// The biggest signed integer type the compiler supports.2172//2173// long long is guaranteed to be at least 64-bits in C++11.2174using BiggestInt = long long;  // NOLINT2175 2176// The maximum number a BiggestInt can represent.2177constexpr BiggestInt kMaxBiggestInt = (std::numeric_limits<BiggestInt>::max)();2178 2179// This template class serves as a compile-time function from size to2180// type.  It maps a size in bytes to a primitive type with that2181// size. e.g.2182//2183//   TypeWithSize<4>::UInt2184//2185// is typedef-ed to be unsigned int (unsigned integer made up of 42186// bytes).2187//2188// Such functionality should belong to STL, but I cannot find it2189// there.2190//2191// Google Test uses this class in the implementation of floating-point2192// comparison.2193//2194// For now it only handles UInt (unsigned int) as that's all Google Test2195// needs.  Other types can be easily added in the future if need2196// arises.2197template <size_t size>2198class TypeWithSize {2199 public:2200  // This prevents the user from using TypeWithSize<N> with incorrect2201  // values of N.2202  using UInt = void;2203};2204 2205// The specialization for size 4.2206template <>2207class TypeWithSize<4> {2208 public:2209  using Int = std::int32_t;2210  using UInt = std::uint32_t;2211};2212 2213// The specialization for size 8.2214template <>2215class TypeWithSize<8> {2216 public:2217  using Int = std::int64_t;2218  using UInt = std::uint64_t;2219};2220 2221// Integer types of known sizes.2222using TimeInMillis = int64_t;  // Represents time in milliseconds.2223 2224// Utilities for command line flags and environment variables.2225 2226// Macro for referencing flags.2227#if !defined(GTEST_FLAG)2228#define GTEST_FLAG_NAME_(name) gtest_##name2229#define GTEST_FLAG(name) FLAGS_gtest_##name2230#endif  // !defined(GTEST_FLAG)2231 2232// Pick a command line flags implementation.2233#ifdef GTEST_HAS_ABSL2234 2235// Macros for defining flags.2236#define GTEST_DEFINE_bool_(name, default_val, doc) \2237  ABSL_FLAG(bool, GTEST_FLAG_NAME_(name), default_val, doc)2238#define GTEST_DEFINE_int32_(name, default_val, doc) \2239  ABSL_FLAG(int32_t, GTEST_FLAG_NAME_(name), default_val, doc)2240#define GTEST_DEFINE_string_(name, default_val, doc) \2241  ABSL_FLAG(std::string, GTEST_FLAG_NAME_(name), default_val, doc)2242 2243// Macros for declaring flags.2244#define GTEST_DECLARE_bool_(name) \2245  ABSL_DECLARE_FLAG(bool, GTEST_FLAG_NAME_(name))2246#define GTEST_DECLARE_int32_(name) \2247  ABSL_DECLARE_FLAG(int32_t, GTEST_FLAG_NAME_(name))2248#define GTEST_DECLARE_string_(name) \2249  ABSL_DECLARE_FLAG(std::string, GTEST_FLAG_NAME_(name))2250 2251#define GTEST_FLAG_SAVER_ ::absl::FlagSaver2252 2253#define GTEST_FLAG_GET(name) ::absl::GetFlag(GTEST_FLAG(name))2254#define GTEST_FLAG_SET(name, value) \2255  (void)(::absl::SetFlag(&GTEST_FLAG(name), value))2256#define GTEST_USE_OWN_FLAGFILE_FLAG_ 02257 2258#else  // GTEST_HAS_ABSL2259 2260// Macros for defining flags.2261#define GTEST_DEFINE_bool_(name, default_val, doc)  \2262  namespace testing {                               \2263  GTEST_API_ bool GTEST_FLAG(name) = (default_val); \2264  }                                                 \2265  static_assert(true, "no-op to require trailing semicolon")2266#define GTEST_DEFINE_int32_(name, default_val, doc)         \2267  namespace testing {                                       \2268  GTEST_API_ std::int32_t GTEST_FLAG(name) = (default_val); \2269  }                                                         \2270  static_assert(true, "no-op to require trailing semicolon")2271#define GTEST_DEFINE_string_(name, default_val, doc)         \2272  namespace testing {                                        \2273  GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val); \2274  }                                                          \2275  static_assert(true, "no-op to require trailing semicolon")2276 2277// Macros for declaring flags.2278#define GTEST_DECLARE_bool_(name)          \2279  namespace testing {                      \2280  GTEST_API_ extern bool GTEST_FLAG(name); \2281  }                                        \2282  static_assert(true, "no-op to require trailing semicolon")2283#define GTEST_DECLARE_int32_(name)                 \2284  namespace testing {                              \2285  GTEST_API_ extern std::int32_t GTEST_FLAG(name); \2286  }                                                \2287  static_assert(true, "no-op to require trailing semicolon")2288#define GTEST_DECLARE_string_(name)                 \2289  namespace testing {                               \2290  GTEST_API_ extern ::std::string GTEST_FLAG(name); \2291  }                                                 \2292  static_assert(true, "no-op to require trailing semicolon")2293 2294#define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver2295 2296#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)2297#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)2298#define GTEST_USE_OWN_FLAGFILE_FLAG_ 12299 2300#endif  // GTEST_HAS_ABSL2301 2302// Thread annotations2303#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)2304#define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)2305#define GTEST_LOCK_EXCLUDED_(locks)2306#endif  // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)2307 2308// Parses 'str' for a 32-bit signed integer.  If successful, writes the result2309// to *value and returns true; otherwise leaves *value unchanged and returns2310// false.2311GTEST_API_ bool ParseInt32(const Message& src_text, const char* str,2312                           int32_t* value);2313 2314// Parses a bool/int32_t/string from the environment variable2315// corresponding to the given Google Test flag.2316bool BoolFromGTestEnv(const char* flag, bool default_val);2317GTEST_API_ int32_t Int32FromGTestEnv(const char* flag, int32_t default_val);2318std::string OutputFlagAlsoCheckEnvVar();2319const char* StringFromGTestEnv(const char* flag, const char* default_val);2320 2321}  // namespace internal2322}  // namespace testing2323 2324#if !defined(GTEST_INTERNAL_DEPRECATED)2325 2326// Internal Macro to mark an API deprecated, for googletest usage only2327// Usage: class GTEST_INTERNAL_DEPRECATED(message) MyClass or2328// GTEST_INTERNAL_DEPRECATED(message) <return_type> myFunction(); Every usage of2329// a deprecated entity will trigger a warning when compiled with2330// `-Wdeprecated-declarations` option (clang, gcc, any __GNUC__ compiler).2331// For msvc /W3 option will need to be used2332// Note that for 'other' compilers this macro evaluates to nothing to prevent2333// compilations errors.2334#if defined(_MSC_VER)2335#define GTEST_INTERNAL_DEPRECATED(message) __declspec(deprecated(message))2336#elif defined(__GNUC__)2337#define GTEST_INTERNAL_DEPRECATED(message) __attribute__((deprecated(message)))2338#else2339#define GTEST_INTERNAL_DEPRECATED(message)2340#endif2341 2342#endif  // !defined(GTEST_INTERNAL_DEPRECATED)2343 2344#ifdef GTEST_HAS_ABSL2345// Always use absl::any for UniversalPrinter<> specializations if googletest2346// is built with absl support.2347#define GTEST_INTERNAL_HAS_ANY 12348#include "absl/types/any.h"2349namespace testing {2350namespace internal {2351using Any = ::absl::any;2352}  // namespace internal2353}  // namespace testing2354#else2355#ifdef __has_include2356#if __has_include(<any>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L && \2357    (!defined(_MSC_VER) || GTEST_HAS_RTTI)2358// Otherwise for C++17 and higher use std::any for UniversalPrinter<>2359// specializations.2360#define GTEST_INTERNAL_HAS_ANY 12361#include <any>2362namespace testing {2363namespace internal {2364using Any = ::std::any;2365}  // namespace internal2366}  // namespace testing2367// The case where absl is configured NOT to alias std::any is not2368// supported.2369#endif  // __has_include(<any>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L2370#endif  // __has_include2371#endif  // GTEST_HAS_ABSL2372 2373#ifndef GTEST_INTERNAL_HAS_ANY2374#define GTEST_INTERNAL_HAS_ANY 02375#endif2376 2377#ifdef GTEST_HAS_ABSL2378// Always use absl::optional for UniversalPrinter<> specializations if2379// googletest is built with absl support.2380#define GTEST_INTERNAL_HAS_OPTIONAL 12381#include "absl/types/optional.h"2382namespace testing {2383namespace internal {2384template <typename T>2385using Optional = ::absl::optional<T>;2386inline ::absl::nullopt_t Nullopt() { return ::absl::nullopt; }2387}  // namespace internal2388}  // namespace testing2389#else2390#ifdef __has_include2391#if __has_include(<optional>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L2392// Otherwise for C++17 and higher use std::optional for UniversalPrinter<>2393// specializations.2394#define GTEST_INTERNAL_HAS_OPTIONAL 12395#include <optional>2396namespace testing {2397namespace internal {2398template <typename T>2399using Optional = ::std::optional<T>;2400inline ::std::nullopt_t Nullopt() { return ::std::nullopt; }2401}  // namespace internal2402}  // namespace testing2403// The case where absl is configured NOT to alias std::optional is not2404// supported.2405#endif  // __has_include(<optional>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L2406#endif  // __has_include2407#endif  // GTEST_HAS_ABSL2408 2409#ifndef GTEST_INTERNAL_HAS_OPTIONAL2410#define GTEST_INTERNAL_HAS_OPTIONAL 02411#endif2412 2413#ifdef GTEST_HAS_ABSL2414// Always use absl::string_view for Matcher<> specializations if googletest2415// is built with absl support.2416#define GTEST_INTERNAL_HAS_STRING_VIEW 12417#include "absl/strings/string_view.h"2418namespace testing {2419namespace internal {2420using StringView = ::absl::string_view;2421}  // namespace internal2422}  // namespace testing2423#else2424#ifdef __has_include2425#if __has_include(<string_view>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L2426// Otherwise for C++17 and higher use std::string_view for Matcher<>2427// specializations.2428#define GTEST_INTERNAL_HAS_STRING_VIEW 12429#include <string_view>2430namespace testing {2431namespace internal {2432using StringView = ::std::string_view;2433}  // namespace internal2434}  // namespace testing2435// The case where absl is configured NOT to alias std::string_view is not2436// supported.2437#endif  // __has_include(<string_view>) && GTEST_INTERNAL_CPLUSPLUS_LANG >=2438        // 201703L2439#endif  // __has_include2440#endif  // GTEST_HAS_ABSL2441 2442#ifndef GTEST_INTERNAL_HAS_STRING_VIEW2443#define GTEST_INTERNAL_HAS_STRING_VIEW 02444#endif2445 2446#ifdef GTEST_HAS_ABSL2447// Always use absl::variant for UniversalPrinter<> specializations if googletest2448// is built with absl support.2449#define GTEST_INTERNAL_HAS_VARIANT 12450#include "absl/types/variant.h"2451namespace testing {2452namespace internal {2453template <typename... T>2454using Variant = ::absl::variant<T...>;2455}  // namespace internal2456}  // namespace testing2457#else2458#ifdef __has_include2459#if __has_include(<variant>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L2460// Otherwise for C++17 and higher use std::variant for UniversalPrinter<>2461// specializations.2462#define GTEST_INTERNAL_HAS_VARIANT 12463#include <variant>2464namespace testing {2465namespace internal {2466template <typename... T>2467using Variant = ::std::variant<T...>;2468}  // namespace internal2469}  // namespace testing2470// The case where absl is configured NOT to alias std::variant is not supported.2471#endif  // __has_include(<variant>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L2472#endif  // __has_include2473#endif  // GTEST_HAS_ABSL2474 2475#ifndef GTEST_INTERNAL_HAS_VARIANT2476#define GTEST_INTERNAL_HAS_VARIANT 02477#endif2478 2479#if defined(GTEST_INTERNAL_CPLUSPLUS_LANG) && \2480    GTEST_INTERNAL_CPLUSPLUS_LANG < 201703L2481#define GTEST_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL 12482#endif2483 2484#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_2485