43#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
44#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
268#include <type_traits>
271# include <sys/types.h>
272# include <sys/stat.h>
276# include <AvailabilityMacros.h>
277# include <TargetConditionals.h>
290#if !defined(GTEST_DEV_EMAIL_)
291# define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
292# define GTEST_FLAG_PREFIX_ "gtest_"
293# define GTEST_FLAG_PREFIX_DASH_ "gtest-"
294# define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
295# define GTEST_NAME_ "Google Test"
296# define GTEST_PROJECT_URL_ "https://github.com/google/googletest/"
299#if !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
300# define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest"
306# define GTEST_GCC_VER_ \
307 (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
316# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
317 __pragma(warning(push)) \
318 __pragma(warning(disable: warnings))
319# define GTEST_DISABLE_MSC_WARNINGS_POP_() \
320 __pragma(warning(pop))
323# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
324# define GTEST_DISABLE_MSC_WARNINGS_POP_()
330# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \
331 _Pragma("clang diagnostic push") \
332 _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") \
333 _Pragma("clang diagnostic ignored \"-Wdeprecated-implementations\"")
334#define GTEST_DISABLE_MSC_DEPRECATED_POP_() \
335 _Pragma("clang diagnostic pop")
337# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \
338 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
339# define GTEST_DISABLE_MSC_DEPRECATED_POP_() \
340 GTEST_DISABLE_MSC_WARNINGS_POP_()
347# if !GTEST_OS_WINDOWS_MOBILE
352#if GTEST_OS_WINDOWS_MINGW && !defined(__MINGW64_VERSION_MAJOR)
355typedef struct _CRITICAL_SECTION GTEST_CRITICAL_SECTION;
360typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
374#if GTEST_OS_LINUX_ANDROID
376# include <android/api-level.h>
381#ifndef GTEST_HAS_POSIX_RE
382# if GTEST_OS_LINUX_ANDROID
384# define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
386#define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS && !GTEST_OS_XTENSA)
393#elif GTEST_HAS_POSIX_RE
401# define GTEST_USES_POSIX_RE 1
403#elif GTEST_OS_WINDOWS
407# define GTEST_USES_SIMPLE_RE 1
413# define GTEST_USES_SIMPLE_RE 1
417#ifndef GTEST_HAS_EXCEPTIONS
420# if defined(_MSC_VER) && defined(_CPPUNWIND)
422# define GTEST_HAS_EXCEPTIONS 1
423# elif defined(__BORLANDC__)
427# ifndef _HAS_EXCEPTIONS
428# define _HAS_EXCEPTIONS 1
430# define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
431# elif defined(__clang__)
440# define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions))
441# elif defined(__GNUC__) && __EXCEPTIONS
443# define GTEST_HAS_EXCEPTIONS 1
444# elif defined(__SUNPRO_CC)
448# define GTEST_HAS_EXCEPTIONS 1
449# elif defined(__IBMCPP__) && __EXCEPTIONS
451# define GTEST_HAS_EXCEPTIONS 1
452# elif defined(__HP_aCC)
455# define GTEST_HAS_EXCEPTIONS 1
459# define GTEST_HAS_EXCEPTIONS 0
463#ifndef GTEST_HAS_STD_WSTRING
469#define GTEST_HAS_STD_WSTRING \
470 (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
471 GTEST_OS_HAIKU || GTEST_OS_ESP32 || GTEST_OS_ESP8266 || GTEST_OS_XTENSA))
476#ifndef GTEST_HAS_RTTI
483# define GTEST_HAS_RTTI 1
485# define GTEST_HAS_RTTI 0
490# elif defined(__GNUC__)
497# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
498 !defined(__EXCEPTIONS)
499# define GTEST_HAS_RTTI 0
501# define GTEST_HAS_RTTI 1
504# define GTEST_HAS_RTTI 0
510# elif defined(__clang__)
512# define GTEST_HAS_RTTI __has_feature(cxx_rtti)
516# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
519# define GTEST_HAS_RTTI 1
521# define GTEST_HAS_RTTI 0
527# define GTEST_HAS_RTTI 1
540#ifndef GTEST_HAS_PTHREAD
546#define GTEST_HAS_PTHREAD \
547 (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX || \
548 GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \
549 GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_OPENBSD || \
566#ifndef GTEST_HAS_CLONE
569# if GTEST_OS_LINUX && !defined(__ia64__)
570# if GTEST_OS_LINUX_ANDROID
573# if defined(__LP64__) || \
574 (defined(__arm__) && __ANDROID_API__ >= 9) || \
575 (defined(__mips__) && __ANDROID_API__ >= 12) || \
576 (defined(__i386__) && __ANDROID_API__ >= 17)
577# define GTEST_HAS_CLONE 1
579# define GTEST_HAS_CLONE 0
582# define GTEST_HAS_CLONE 1
585# define GTEST_HAS_CLONE 0
592#ifndef GTEST_HAS_STREAM_REDIRECTION
595#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
596 GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA
597# define GTEST_HAS_STREAM_REDIRECTION 0
599# define GTEST_HAS_STREAM_REDIRECTION 1
605#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
606 (GTEST_OS_MAC && !GTEST_OS_IOS) || \
607 (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER) || GTEST_OS_WINDOWS_MINGW || \
608 GTEST_OS_AIX || GTEST_OS_HPUX || GTEST_OS_OPENBSD || GTEST_OS_QNX || \
609 GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \
610 GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_HAIKU)
611# define GTEST_HAS_DEATH_TEST 1
618#if defined(__GNUC__) || defined(_MSC_VER) || defined(__SUNPRO_CC) || \
619 defined(__IBMCPP__) || defined(__HP_aCC)
620# define GTEST_HAS_TYPED_TEST 1
621# define GTEST_HAS_TYPED_TEST_P 1
625#define GTEST_WIDE_STRING_USES_UTF16_ \
626 (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_AIX || GTEST_OS_OS2)
629#if GTEST_OS_LINUX || GTEST_OS_GNU_KFREEBSD || GTEST_OS_DRAGONFLY || \
630 GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_OPENBSD
631# define GTEST_CAN_STREAM_RESULTS_ 1
644#ifdef __INTEL_COMPILER
645# define GTEST_AMBIGUOUS_ELSE_BLOCKER_
647# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:
661#if defined(__GNUC__) && !defined(COMPILER_ICC)
662# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
663#elif defined(__clang__)
664# if __has_attribute(unused)
665# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
668#ifndef GTEST_ATTRIBUTE_UNUSED_
669# define GTEST_ATTRIBUTE_UNUSED_
673#if (defined(__GNUC__) || defined(__clang__)) && !defined(COMPILER_ICC)
674# if defined(__MINGW_PRINTF_FORMAT)
678# define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
679 __attribute__((__format__(__MINGW_PRINTF_FORMAT, string_index, \
682# define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
683 __attribute__((__format__(__printf__, string_index, first_to_check)))
686# define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check)
692#define GTEST_DISALLOW_ASSIGN_(type) \
693 type& operator=(type const &) = delete
697#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type) \
698 type(type const&) = delete; \
699 type& operator=(type const&) = delete
703#define GTEST_DISALLOW_MOVE_ASSIGN_(type) \
704 type& operator=(type &&) noexcept = delete
708#define GTEST_DISALLOW_MOVE_AND_ASSIGN_(type) \
709 type(type&&) noexcept = delete; \
710 type& operator=(type&&) noexcept = delete
717#if defined(__GNUC__) && !defined(COMPILER_ICC)
718# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
720# define GTEST_MUST_USE_RESULT_
731# define GTEST_INTENTIONAL_CONST_COND_PUSH_() \
732 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)
733# define GTEST_INTENTIONAL_CONST_COND_POP_() \
734 GTEST_DISABLE_MSC_WARNINGS_POP_()
742# if defined(_MSC_VER) || defined(__BORLANDC__)
744# define GTEST_HAS_SEH 1
747# define GTEST_HAS_SEH 0
752#ifndef GTEST_IS_THREADSAFE
754#define GTEST_IS_THREADSAFE \
755 (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ || \
756 (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) || \
767# if GTEST_LINKED_AS_SHARED_LIBRARY
768# define GTEST_API_ __declspec(dllimport)
769# elif GTEST_CREATE_SHARED_LIBRARY
770# define GTEST_API_ __declspec(dllexport)
772#elif __GNUC__ >= 4 || defined(__clang__)
773# define GTEST_API_ __attribute__((visibility ("default")))
782#ifndef GTEST_DEFAULT_DEATH_TEST_STYLE
783# define GTEST_DEFAULT_DEATH_TEST_STYLE "fast"
788# define GTEST_NO_INLINE_ __attribute__((noinline))
790# define GTEST_NO_INLINE_
794#if !defined(GTEST_HAS_CXXABI_H_)
795# if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER))
796# define GTEST_HAS_CXXABI_H_ 1
798# define GTEST_HAS_CXXABI_H_ 0
804#if defined(__clang__)
805# if __has_feature(memory_sanitizer)
806# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \
807 __attribute__((no_sanitize_memory))
809# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
812# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
816#if defined(__clang__)
817# if __has_feature(address_sanitizer)
818# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \
819 __attribute__((no_sanitize_address))
821# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
824# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
828#if defined(__clang__)
829# if __has_feature(hwaddress_sanitizer)
830# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ \
831 __attribute__((no_sanitize("hwaddress")))
833# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
836# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
840#if defined(__clang__)
841# if __has_feature(thread_sanitizer)
842# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \
843 __attribute__((no_sanitize_thread))
845# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
848# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
858using std::make_tuple;
860using std::tuple_element;
861using std::tuple_size;
879#define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
889#elif GTEST_USES_POSIX_RE || GTEST_USES_SIMPLE_RE
900 RE(const ::std::string& regex) { Init(regex.c_str()); }
902 RE(
const char* regex) { Init(regex); }
906 const char*
pattern()
const {
return pattern_; }
913 return FullMatch(str.c_str(), re);
916 return PartialMatch(str.c_str(), re);
923 void Init(
const char* regex);
924 const char* pattern_;
927# if GTEST_USES_POSIX_RE
930 regex_t partial_regex_;
934 const char* full_pattern_;
982#if !defined(GTEST_LOG_)
984# define GTEST_LOG_(severity) \
985 ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
986 __FILE__, __LINE__).GetStream()
993#if !defined(GTEST_CHECK_)
1008# define GTEST_CHECK_(condition) \
1009 GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1010 if (::testing::internal::IsTrue(condition)) \
1013 GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
1021#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
1022 if (const int gtest_error = (posix_call)) \
1023 GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
1037template <
typename T>
1039template <
typename T>
1043#define GTEST_REFERENCE_TO_CONST_(T) \
1044 typename ::testing::internal::ConstRef<T>::type
1066template<
typename To>
1090template<
typename To,
typename From>
1099 const To to =
nullptr;
1100 ::testing::internal::ImplicitCast_<From*>(to);
1107 return static_cast<To>(f);
1115template <
class Derived,
class Base>
1121#if GTEST_HAS_DOWNCAST_
1122 return ::down_cast<Derived*>(base);
1124 return dynamic_cast<Derived*
>(base);
1126 return static_cast<Derived*
>(base);
1130#if GTEST_HAS_STREAM_REDIRECTION
1153#if GTEST_HAS_DEATH_TEST
1155std::vector<std::string> GetInjectableArgvs();
1157void SetInjectableArgvs(
const std::vector<std::string>* new_argvs);
1158void SetInjectableArgvs(
const std::vector<std::string>& new_argvs);
1159void ClearInjectableArgvs();
1164#if GTEST_IS_THREADSAFE
1165# if GTEST_HAS_PTHREAD
1169inline void SleepMilliseconds(
int n) {
1170 const timespec time = {
1174 nanosleep(&time,
nullptr);
1178# if GTEST_HAS_NOTIFICATION_
1182# elif GTEST_HAS_PTHREAD
1191 Notification() : notified_(false) {
1195 pthread_mutex_destroy(&mutex_);
1201 pthread_mutex_lock(&mutex_);
1203 pthread_mutex_unlock(&mutex_);
1208 void WaitForNotification() {
1210 pthread_mutex_lock(&mutex_);
1211 const bool notified = notified_;
1212 pthread_mutex_unlock(&mutex_);
1215 SleepMilliseconds(10);
1220 pthread_mutex_t mutex_;
1226# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
1239 typedef void* Handle;
1241 explicit AutoHandle(Handle handle);
1247 void Reset(Handle handle);
1252 bool IsCloseable()
const;
1269 void WaitForNotification();
1281# if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW
1288class ThreadWithParamBase {
1290 virtual ~ThreadWithParamBase() {}
1291 virtual void Run() = 0;
1300extern "C" inline void* ThreadFuncWithCLinkage(
void* thread) {
1301 static_cast<ThreadWithParamBase*
>(thread)->
Run();
1317template <
typename T>
1318class ThreadWithParam :
public ThreadWithParamBase {
1320 typedef void UserThreadFunc(T);
1322 ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
1325 thread_can_start_(thread_can_start),
1327 ThreadWithParamBase*
const base =
this;
1331 pthread_create(&thread_,
nullptr, &ThreadFuncWithCLinkage, base));
1333 ~ThreadWithParam()
override { Join(); }
1342 void Run()
override {
1343 if (thread_can_start_ !=
nullptr) thread_can_start_->WaitForNotification();
1348 UserThreadFunc*
const func_;
1352 Notification*
const thread_can_start_;
1362# if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
1366# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
1384 enum MutexType { kStatic = 0, kDynamic = 1 };
1388 enum StaticConstructorSelector { kStaticMutex = 0 };
1393 explicit Mutex(StaticConstructorSelector ) {}
1408 void ThreadSafeLazyInit();
1412 unsigned int owner_thread_id_;
1417 long critical_section_init_phase_;
1418 GTEST_CRITICAL_SECTION* critical_section_;
1423# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
1424 extern ::testing::internal::Mutex mutex
1426# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
1427 ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex)
1434class GTestMutexLock {
1437 : mutex_(mutex) { mutex_->Lock(); }
1439 ~GTestMutexLock() { mutex_->Unlock(); }
1442 Mutex*
const mutex_;
1451class ThreadLocalValueHolderBase {
1453 virtual ~ThreadLocalValueHolderBase() {}
1458class ThreadLocalBase {
1464 virtual ThreadLocalValueHolderBase* NewValueForCurrentThread()
const = 0;
1467 ThreadLocalBase() {}
1468 virtual ~ThreadLocalBase() {}
1481 static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
1482 const ThreadLocalBase* thread_local_instance);
1485 static void OnThreadLocalDestroyed(
1486 const ThreadLocalBase* thread_local_instance);
1496 virtual ~Runnable() {}
1497 virtual void Run() = 0;
1500 ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start);
1501 virtual ~ThreadWithParamBase();
1508template <
typename T>
1509class ThreadWithParam :
public ThreadWithParamBase {
1511 typedef void UserThreadFunc(T);
1513 ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
1514 : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {
1516 virtual ~ThreadWithParam() {}
1519 class RunnableImpl :
public Runnable {
1521 RunnableImpl(UserThreadFunc* func, T param)
1525 virtual ~RunnableImpl() {}
1526 virtual void Run() {
1531 UserThreadFunc*
const func_;
1567template <
typename T>
1568class ThreadLocal :
public ThreadLocalBase {
1570 ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {}
1572 : default_factory_(new InstanceValueHolderFactory(
value)) {}
1574 ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(
this); }
1576 T*
pointer() {
return GetOrCreateValue(); }
1577 const T*
pointer()
const {
return GetOrCreateValue(); }
1584 class ValueHolder :
public ThreadLocalValueHolderBase {
1586 ValueHolder() : value_() {}
1587 explicit ValueHolder(
const T&
value) : value_(
value) {}
1589 T*
pointer() {
return &value_; }
1597 T* GetOrCreateValue()
const {
1598 return static_cast<ValueHolder*
>(
1599 ThreadLocalRegistry::GetValueOnCurrentThread(
this))->
pointer();
1602 virtual ThreadLocalValueHolderBase* NewValueForCurrentThread()
const {
1603 return default_factory_->MakeNewHolder();
1606 class ValueHolderFactory {
1608 ValueHolderFactory() {}
1609 virtual ~ValueHolderFactory() {}
1610 virtual ValueHolder* MakeNewHolder()
const = 0;
1616 class DefaultValueHolderFactory :
public ValueHolderFactory {
1618 DefaultValueHolderFactory() {}
1619 ValueHolder* MakeNewHolder()
const override {
return new ValueHolder(); }
1625 class InstanceValueHolderFactory :
public ValueHolderFactory {
1627 explicit InstanceValueHolderFactory(
const T&
value) : value_(
value) {}
1628 ValueHolder* MakeNewHolder()
const override {
1629 return new ValueHolder(value_);
1638 std::unique_ptr<ValueHolderFactory> default_factory_;
1643# elif GTEST_HAS_PTHREAD
1651 owner_ = pthread_self();
1667 void AssertHeld()
const {
1668 GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
1669 <<
"The current thread is not holding the mutex @" <<
this;
1678 pthread_mutex_t mutex_;
1690# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
1691 extern ::testing::internal::MutexBase mutex
1699#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
1700 ::testing::internal::MutexBase mutex = {PTHREAD_MUTEX_INITIALIZER, false, 0}
1704class Mutex :
public MutexBase {
1723class GTestMutexLock {
1726 : mutex_(mutex) { mutex_->Lock(); }
1728 ~GTestMutexLock() { mutex_->Unlock(); }
1731 MutexBase*
const mutex_;
1744class ThreadLocalValueHolderBase {
1746 virtual ~ThreadLocalValueHolderBase() {}
1751extern "C" inline void DeleteThreadLocalValue(
void* value_holder) {
1752 delete static_cast<ThreadLocalValueHolderBase*
>(value_holder);
1756template <
typename T>
1760 : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
1761 explicit ThreadLocal(
const T&
value)
1762 : key_(CreateKey()),
1763 default_factory_(new InstanceValueHolderFactory(
value)) {}
1767 DeleteThreadLocalValue(pthread_getspecific(key_));
1774 T* pointer() {
return GetOrCreateValue(); }
1775 const T* pointer()
const {
return GetOrCreateValue(); }
1776 const T& get()
const {
return *pointer(); }
1781 class ValueHolder :
public ThreadLocalValueHolderBase {
1783 ValueHolder() : value_() {}
1784 explicit ValueHolder(
const T&
value) : value_(
value) {}
1786 T* pointer() {
return &value_; }
1793 static pthread_key_t CreateKey() {
1798 pthread_key_create(&key, &DeleteThreadLocalValue));
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();
1809 ValueHolder*
const new_holder = default_factory_->MakeNewHolder();
1810 ThreadLocalValueHolderBase*
const holder_base = new_holder;
1812 return new_holder->pointer();
1815 class ValueHolderFactory {
1817 ValueHolderFactory() {}
1818 virtual ~ValueHolderFactory() {}
1819 virtual ValueHolder* MakeNewHolder()
const = 0;
1825 class DefaultValueHolderFactory :
public ValueHolderFactory {
1827 DefaultValueHolderFactory() {}
1828 ValueHolder* MakeNewHolder()
const override {
return new ValueHolder(); }
1834 class InstanceValueHolderFactory :
public ValueHolderFactory {
1836 explicit InstanceValueHolderFactory(
const T&
value) : value_(
value) {}
1837 ValueHolder* MakeNewHolder()
const override {
1838 return new ValueHolder(value_);
1848 const pthread_key_t key_;
1849 std::unique_ptr<ValueHolderFactory> default_factory_;
1871# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
1872 extern ::testing::internal::Mutex mutex
1874# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
1888template <
typename T>
1895 const T&
get()
const {
return value_; }
1908# define GTEST_PATH_SEP_ "\\"
1909# define GTEST_HAS_ALT_PATH_SEP_ 1
1911# define GTEST_PATH_SEP_ "/"
1912# define GTEST_HAS_ALT_PATH_SEP_ 0
1923 return isalpha(
static_cast<unsigned char>(
ch)) != 0;
1926 return isalnum(
static_cast<unsigned char>(
ch)) != 0;
1929 return isdigit(
static_cast<unsigned char>(
ch)) != 0;
1932 return islower(
static_cast<unsigned char>(
ch)) != 0;
1935 return isspace(
static_cast<unsigned char>(
ch)) != 0;
1938 return isupper(
static_cast<unsigned char>(
ch)) != 0;
1941 return isxdigit(
static_cast<unsigned char>(
ch)) != 0;
1945 return isxdigit(
static_cast<unsigned char>(
ch)) != 0;
1949 const unsigned char low_byte =
static_cast<unsigned char>(
ch);
1950 return ch == low_byte && isxdigit(low_byte) != 0;
1953 const unsigned char low_byte =
static_cast<unsigned char>(
ch);
1954 return ch == low_byte && isxdigit(low_byte) != 0;
1957 const unsigned char low_byte =
static_cast<unsigned char>(
ch);
1958 return ch == low_byte && isxdigit(low_byte) != 0;
1962 return static_cast<char>(tolower(
static_cast<unsigned char>(
ch)));
1965 return static_cast<char>(toupper(
static_cast<unsigned char>(
ch)));
1969 std::string::iterator it = str.end();
1970 while (it != str.begin() &&
IsSpace(*--it))
1990inline int DoIsATTY(
int fd) {
return isatty(fd); }
1991inline int StrCaseCmp(
const char* s1,
const char* s2) {
1992 return stricmp(s1, s2);
1994inline char*
StrDup(
const char* src) {
return strdup(src); }
1996# if GTEST_OS_WINDOWS_MOBILE
1997inline int DoIsATTY(
int ) {
return 0; }
1999inline int DoIsATTY(
int fd) {
return _isatty(fd); }
2001inline int StrCaseCmp(
const char* s1,
const char* s2) {
2002 return _stricmp(s1, s2);
2004inline char*
StrDup(
const char* src) {
return _strdup(src); }
2007# if GTEST_OS_WINDOWS_MOBILE
2008inline int FileNo(FILE*
file) {
return reinterpret_cast<int>(_fileno(
file)); }
2013inline int Stat(
const char* path,
StatStruct* buf) {
return _stat(path, buf); }
2014inline int RmDir(
const char* dir) {
return _rmdir(dir); }
2016 return (_S_IFDIR & st.st_mode) != 0;
2020#elif GTEST_OS_ESP8266
2024inline int DoIsATTY(
int fd) {
return isatty(fd); }
2029inline int StrCaseCmp(
const char* s1,
const char* s2) {
2030 return strcasecmp(s1, s2);
2032inline char*
StrDup(
const char* src) {
return strdup(src); }
2033inline int RmDir(
const char* dir) {
return rmdir(dir); }
2034inline bool IsDir(
const StatStruct& st) {
return S_ISDIR(st.st_mode); }
2044 return strcasecmp(s1, s2);
2046inline char*
StrDup(
const char* src) {
return strdup(src); }
2047inline int RmDir(
const char* dir) {
return rmdir(dir); }
2056 int savedErrno = errno;
2071#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && \
2072 !GTEST_OS_WINDOWS_RT && !GTEST_OS_ESP8266 && !GTEST_OS_XTENSA
2073inline int ChDir(
const char* dir) {
return chdir(dir); }
2075inline FILE*
FOpen(
const char* path,
const char* mode) {
2076#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
2077 struct wchar_codecvt :
public std::codecvt<wchar_t, char, std::mbstate_t> {};
2078 std::wstring_convert<wchar_codecvt> converter;
2079 std::wstring wide_path = converter.from_bytes(path);
2080 std::wstring wide_mode = converter.from_bytes(mode);
2081 return _wfopen(wide_path.c_str(), wide_mode.c_str());
2083 return fopen(path, mode);
2086#if !GTEST_OS_WINDOWS_MOBILE
2087inline FILE *
FReopen(
const char* path,
const char* mode, FILE* stream) {
2088 return freopen(path, mode, stream);
2090inline FILE*
FDOpen(
int fd,
const char* mode) {
return fdopen(fd, mode); }
2092inline int FClose(FILE* fp) {
return fclose(fp); }
2093#if !GTEST_OS_WINDOWS_MOBILE
2095 return static_cast<int>(read(fd, buf,
count));
2098 return static_cast<int>(write(fd, buf,
count));
2100inline int Close(
int fd) {
return close(fd); }
2101inline const char*
StrError(
int errnum) {
return strerror(errnum); }
2104#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
2105 GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA
2107 static_cast<void>(name);
2109#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
2112 const char*
const env = getenv(name);
2113 return (env !=
nullptr && env[0] !=
'\0') ? env :
nullptr;
2115 return getenv(name);
2121#if GTEST_OS_WINDOWS_MOBILE
2125[[noreturn]]
void Abort();
2127[[noreturn]]
inline void Abort() { abort(); }
2137#if _MSC_VER && !GTEST_OS_WINDOWS_MOBILE
2139# define GTEST_SNPRINTF_(buffer, size, format, ...) \
2140 _snprintf_s(buffer, size, size, format, __VA_ARGS__)
2141#elif defined(_MSC_VER)
2143# define GTEST_SNPRINTF_ _snprintf
2145# define GTEST_SNPRINTF_ snprintf
2174template <
size_t size>
2204#if !defined(GTEST_FLAG)
2205# define GTEST_FLAG(name) FLAGS_gtest_##name
2208#if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
2209# define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
2212#if !defined(GTEST_DECLARE_bool_)
2213# define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
2216# define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
2217# define GTEST_DECLARE_int32_(name) \
2218 GTEST_API_ extern std::int32_t GTEST_FLAG(name)
2219# define GTEST_DECLARE_string_(name) \
2220 GTEST_API_ extern ::std::string GTEST_FLAG(name)
2223# define GTEST_DEFINE_bool_(name, default_val, doc) \
2224 GTEST_API_ bool GTEST_FLAG(name) = (default_val)
2225# define GTEST_DEFINE_int32_(name, default_val, doc) \
2226 GTEST_API_ std::int32_t GTEST_FLAG(name) = (default_val)
2227# define GTEST_DEFINE_string_(name, default_val, doc) \
2228 GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)
2233#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
2234# define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
2235# define GTEST_LOCK_EXCLUDED_(locks)
2254#if !defined(GTEST_INTERNAL_DEPRECATED)
2264#if defined(_MSC_VER)
2265#define GTEST_INTERNAL_DEPRECATED(message) __declspec(deprecated(message))
2266#elif defined(__GNUC__)
2267#define GTEST_INTERNAL_DEPRECATED(message) __attribute__((deprecated(message)))
2269#define GTEST_INTERNAL_DEPRECATED(message)
2277#define GTEST_INTERNAL_HAS_ANY 1
2278#include "absl/types/any.h"
2281using Any = ::absl::any;
2286#if __has_include(<any>) && __cplusplus >= 201703L
2289#define GTEST_INTERNAL_HAS_ANY 1
2293using Any = ::std::any;
2305#define GTEST_INTERNAL_HAS_OPTIONAL 1
2306#include "absl/types/optional.h"
2309template <
typename T>
2310using Optional = ::absl::optional<T>;
2315#if __has_include(<optional>) && __cplusplus >= 201703L
2318#define GTEST_INTERNAL_HAS_OPTIONAL 1
2322template <
typename T>
2323using Optional = ::std::optional<T>;
2335# define GTEST_INTERNAL_HAS_STRING_VIEW 1
2336#include "absl/strings/string_view.h"
2339using StringView = ::absl::string_view;
2343# ifdef __has_include
2344# if __has_include(<string_view>) && __cplusplus >= 201703L
2347# define GTEST_INTERNAL_HAS_STRING_VIEW 1
2348#include <string_view>
2351using StringView = ::std::string_view;
2363#define GTEST_INTERNAL_HAS_VARIANT 1
2364#include "absl/types/variant.h"
2367template <
typename... T>
2368using Variant = ::absl::variant<T...>;
2373#if __has_include(<variant>) && __cplusplus >= 201703L
2376#define GTEST_INTERNAL_HAS_VARIANT 1
2380template <
typename... T>
2381using Variant = ::std::variant<T...>;
#define GTEST_CHECK_POSIX_SUCCESS_(posix_call)
#define GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
#define GTEST_INTENTIONAL_CONST_COND_PUSH_()
#define GTEST_DISABLE_MSC_DEPRECATED_POP_()
#define GTEST_CHECK_(condition)
#define GTEST_INTENTIONAL_CONST_COND_POP_()
#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)
GTEST_API_ size_t GetFileSize(FILE *file)
std::string OutputFlagAlsoCheckEnvVar()
GTEST_API_::std::string FormatCompilerIndependentFileLocation(const char *file, int line)
GTEST_API_ std::string ReadEntireFile(FILE *file)
GTEST_API_::std::string FormatFileLocation(const char *file, int line)
GTEST_API_ std::string GetCapturedStderr()
GTEST_API_ size_t GetThreadCount()
GTEST_API_ bool ParseInt32(const Message &src_text, const char *str, int32_t *value)
GTEST_API_ bool IsTrue(bool condition)
bool BoolFromGTestEnv(const char *flag, bool default_val)
constexpr BiggestInt kMaxBiggestInt
const char * StringFromGTestEnv(const char *flag, const char *default_val)
GTEST_API_ void CaptureStderr()
GTEST_API_ std::vector< std::string > GetArgvs()
std::string StripTrailingSpaces(std::string str)
GTEST_API_ int32_t Int32FromGTestEnv(const char *flag, int32_t default_val)
GTEST_API_ void CaptureStdout()
GTEST_API_ std::string GetCapturedStdout()
Derived * CheckedDowncastToActualType(Base *base)
int ChDir(const char *dir)
int StrCaseCmp(const char *s1, const char *s2)
int Stat(const char *path, StatStruct *buf)
int Read(int fd, void *buf, unsigned int count)
char * StrDup(const char *src)
const char * StrError(int errnum)
FILE * FReopen(const char *path, const char *mode, FILE *stream)
FILE * FDOpen(int fd, const char *mode)
const char * GetEnv(const char *name)
int RmDir(const char *dir)
bool IsDir(const StatStruct &st)
int Write(int fd, const void *buf, unsigned int count)
FILE * FOpen(const char *path, const char *mode)
static bool PartialMatch(const ::std::string &str, const RE &re)
static bool FullMatch(const char *str, const RE &re)
const char * pattern() const
RE(const ::std::string ®ex)
static bool PartialMatch(const char *str, const RE &re)
static bool FullMatch(const ::std::string &str, const RE &re)
::std::ostream & GetStream()
ThreadLocal(const T &value)
const T * pointer() const