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>
287#include "gtest/internal/custom/gtest-port.h"
288#include "gtest/internal/gtest-port-arch.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;
370#if GTEST_OS_LINUX_ANDROID
372# include <android/api-level.h>
377#ifndef GTEST_HAS_POSIX_RE
378# if GTEST_OS_LINUX_ANDROID
380# define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
382# define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS)
389#elif GTEST_HAS_POSIX_RE
397# define GTEST_USES_POSIX_RE 1
399#elif GTEST_OS_WINDOWS
403# define GTEST_USES_SIMPLE_RE 1
409# define GTEST_USES_SIMPLE_RE 1
413#ifndef GTEST_HAS_EXCEPTIONS
416# if defined(_MSC_VER) && defined(_CPPUNWIND)
418# define GTEST_HAS_EXCEPTIONS 1
419# elif defined(__BORLANDC__)
423# ifndef _HAS_EXCEPTIONS
424# define _HAS_EXCEPTIONS 1
426# define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
427# elif defined(__clang__)
436# define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions))
437# elif defined(__GNUC__) && __EXCEPTIONS
439# define GTEST_HAS_EXCEPTIONS 1
440# elif defined(__SUNPRO_CC)
444# define GTEST_HAS_EXCEPTIONS 1
445# elif defined(__IBMCPP__) && __EXCEPTIONS
447# define GTEST_HAS_EXCEPTIONS 1
448# elif defined(__HP_aCC)
451# define GTEST_HAS_EXCEPTIONS 1
455# define GTEST_HAS_EXCEPTIONS 0
459#ifndef GTEST_HAS_STD_WSTRING
465#define GTEST_HAS_STD_WSTRING \
466 (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
467 GTEST_OS_HAIKU || GTEST_OS_ESP32 || GTEST_OS_ESP8266))
472#ifndef GTEST_HAS_RTTI
479# define GTEST_HAS_RTTI 1
481# define GTEST_HAS_RTTI 0
486# elif defined(__GNUC__)
493# if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
494 !defined(__EXCEPTIONS)
495# define GTEST_HAS_RTTI 0
497# define GTEST_HAS_RTTI 1
500# define GTEST_HAS_RTTI 0
506# elif defined(__clang__)
508# define GTEST_HAS_RTTI __has_feature(cxx_rtti)
512# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
515# define GTEST_HAS_RTTI 1
517# define GTEST_HAS_RTTI 0
523# define GTEST_HAS_RTTI 1
536#ifndef GTEST_HAS_PTHREAD
542#define GTEST_HAS_PTHREAD \
543 (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX || \
544 GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \
545 GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_OPENBSD || \
562#ifndef GTEST_HAS_CLONE
565# if GTEST_OS_LINUX && !defined(__ia64__)
566# if GTEST_OS_LINUX_ANDROID
569# if defined(__LP64__) || \
570 (defined(__arm__) && __ANDROID_API__ >= 9) || \
571 (defined(__mips__) && __ANDROID_API__ >= 12) || \
572 (defined(__i386__) && __ANDROID_API__ >= 17)
573# define GTEST_HAS_CLONE 1
575# define GTEST_HAS_CLONE 0
578# define GTEST_HAS_CLONE 1
581# define GTEST_HAS_CLONE 0
588#ifndef GTEST_HAS_STREAM_REDIRECTION
591#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
592 GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266
593# define GTEST_HAS_STREAM_REDIRECTION 0
595# define GTEST_HAS_STREAM_REDIRECTION 1
601#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
602 (GTEST_OS_MAC && !GTEST_OS_IOS) || \
603 (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER) || GTEST_OS_WINDOWS_MINGW || \
604 GTEST_OS_AIX || GTEST_OS_HPUX || GTEST_OS_OPENBSD || GTEST_OS_QNX || \
605 GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \
606 GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_HAIKU)
607# define GTEST_HAS_DEATH_TEST 1
614#if defined(__GNUC__) || defined(_MSC_VER) || defined(__SUNPRO_CC) || \
615 defined(__IBMCPP__) || defined(__HP_aCC)
616# define GTEST_HAS_TYPED_TEST 1
617# define GTEST_HAS_TYPED_TEST_P 1
621#define GTEST_WIDE_STRING_USES_UTF16_ \
622 (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_AIX || GTEST_OS_OS2)
625#if GTEST_OS_LINUX || GTEST_OS_GNU_KFREEBSD || GTEST_OS_DRAGONFLY || \
626 GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_OPENBSD
627# define GTEST_CAN_STREAM_RESULTS_ 1
640#ifdef __INTEL_COMPILER
641# define GTEST_AMBIGUOUS_ELSE_BLOCKER_
643# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:
657#if defined(__GNUC__) && !defined(COMPILER_ICC)
658# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
659#elif defined(__clang__)
660# if __has_attribute(unused)
661# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
664#ifndef GTEST_ATTRIBUTE_UNUSED_
665# define GTEST_ATTRIBUTE_UNUSED_
669#if (defined(__GNUC__) || defined(__clang__)) && !defined(COMPILER_ICC)
670# if defined(__MINGW_PRINTF_FORMAT)
674# define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
675 __attribute__((__format__(__MINGW_PRINTF_FORMAT, string_index, \
678# define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
679 __attribute__((__format__(__printf__, string_index, first_to_check)))
682# define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check)
688#define GTEST_DISALLOW_ASSIGN_(type) \
689 type& operator=(type const &) = delete
693#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type) \
694 type(type const&) = delete; \
695 type& operator=(type const&) = delete
699#define GTEST_DISALLOW_MOVE_ASSIGN_(type) \
700 type& operator=(type &&) noexcept = delete
704#define GTEST_DISALLOW_MOVE_AND_ASSIGN_(type) \
705 type(type&&) noexcept = delete; \
706 type& operator=(type&&) noexcept = delete
713#if defined(__GNUC__) && !defined(COMPILER_ICC)
714# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
716# define GTEST_MUST_USE_RESULT_
727# define GTEST_INTENTIONAL_CONST_COND_PUSH_() \
728 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)
729# define GTEST_INTENTIONAL_CONST_COND_POP_() \
730 GTEST_DISABLE_MSC_WARNINGS_POP_()
738# if defined(_MSC_VER) || defined(__BORLANDC__)
740# define GTEST_HAS_SEH 1
743# define GTEST_HAS_SEH 0
748#ifndef GTEST_IS_THREADSAFE
750#define GTEST_IS_THREADSAFE \
751 (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ || \
752 (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) || \
763# if GTEST_LINKED_AS_SHARED_LIBRARY
764# define GTEST_API_ __declspec(dllimport)
765# elif GTEST_CREATE_SHARED_LIBRARY
766# define GTEST_API_ __declspec(dllexport)
768#elif __GNUC__ >= 4 || defined(__clang__)
769# define GTEST_API_ __attribute__((visibility ("default")))
778#ifndef GTEST_DEFAULT_DEATH_TEST_STYLE
779# define GTEST_DEFAULT_DEATH_TEST_STYLE "fast"
784# define GTEST_NO_INLINE_ __attribute__((noinline))
786# define GTEST_NO_INLINE_
790#if !defined(GTEST_HAS_CXXABI_H_)
791# if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER))
792# define GTEST_HAS_CXXABI_H_ 1
794# define GTEST_HAS_CXXABI_H_ 0
800#if defined(__clang__)
801# if __has_feature(memory_sanitizer)
802# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \
803 __attribute__((no_sanitize_memory))
805# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
808# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
812#if defined(__clang__)
813# if __has_feature(address_sanitizer)
814# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \
815 __attribute__((no_sanitize_address))
817# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
820# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
824#if defined(__clang__)
825# if __has_feature(hwaddress_sanitizer)
826# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ \
827 __attribute__((no_sanitize("hwaddress")))
829# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
832# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
836#if defined(__clang__)
837# if __has_feature(thread_sanitizer)
838# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \
839 __attribute__((no_sanitize_thread))
841# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
844# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
854using std::make_tuple;
856using std::tuple_element;
857using std::tuple_size;
875#define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
879GTEST_API_
bool IsTrue(
bool condition);
885#elif GTEST_USES_POSIX_RE || GTEST_USES_SIMPLE_RE
893 RE(
const RE& other) { Init(other.pattern()); }
896 RE(const ::std::string& regex) { Init(regex.c_str()); }
898 RE(
const char* regex) { Init(regex); }
902 const char* pattern()
const {
return pattern_; }
908 static bool FullMatch(const ::std::string& str,
const RE& re) {
909 return FullMatch(str.c_str(), re);
911 static bool PartialMatch(const ::std::string& str,
const RE& re) {
912 return PartialMatch(str.c_str(), re);
915 static bool FullMatch(
const char* str,
const RE& re);
916 static bool PartialMatch(
const char* str,
const RE& re);
919 void Init(
const char* regex);
920 const char* pattern_;
923# if GTEST_USES_POSIX_RE
926 regex_t partial_regex_;
930 const char* full_pattern_;
939GTEST_API_ ::std::string FormatFileLocation(
const char* file,
int line);
944GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
const char* file,
953enum GTestLogSeverity {
965 GTestLog(GTestLogSeverity severity,
const char* file,
int line);
970 ::std::ostream& GetStream() { return ::std::cerr; }
973 const GTestLogSeverity severity_;
975 GTEST_DISALLOW_COPY_AND_ASSIGN_(
GTestLog);
978#if !defined(GTEST_LOG_)
980# define GTEST_LOG_(severity) \
981 ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
982 __FILE__, __LINE__).GetStream()
984inline void LogToStderr() {}
985inline void FlushInfoLog() { fflush(
nullptr); }
989#if !defined(GTEST_CHECK_)
1004# define GTEST_CHECK_(condition) \
1005 GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1006 if (::testing::internal::IsTrue(condition)) \
1009 GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
1017#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
1018 if (const int gtest_error = (posix_call)) \
1019 GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
1033template <
typename T>
1035template <
typename T>
1039#define GTEST_REFERENCE_TO_CONST_(T) \
1040 typename ::testing::internal::ConstRef<T>::type
1062template<
typename To>
1063inline To ImplicitCast_(
To x) {
return x; }
1086template<
typename To,
typename From>
1087inline To DownCast_(From* f) {
1092 GTEST_INTENTIONAL_CONST_COND_PUSH_()
1094 GTEST_INTENTIONAL_CONST_COND_POP_()
1095 const To to =
nullptr;
1096 ::testing::internal::ImplicitCast_<From*>(to);
1101 GTEST_CHECK_(f ==
nullptr ||
dynamic_cast<To
>(f) !=
nullptr);
1103 return static_cast<To
>(f);
1111template <
class Derived,
class Base>
1112Derived* CheckedDowncastToActualType(Base* base) {
1114 GTEST_CHECK_(
typeid(*base) ==
typeid(Derived));
1117#if GTEST_HAS_DOWNCAST_
1118 return ::down_cast<Derived*>(base);
1120 return dynamic_cast<Derived*
>(base);
1122 return static_cast<Derived*
>(base);
1126#if GTEST_HAS_STREAM_REDIRECTION
1134GTEST_API_
void CaptureStdout();
1135GTEST_API_ std::string GetCapturedStdout();
1136GTEST_API_
void CaptureStderr();
1137GTEST_API_ std::string GetCapturedStderr();
1141GTEST_API_
size_t GetFileSize(FILE* file);
1144GTEST_API_ std::string ReadEntireFile(FILE* file);
1147GTEST_API_ std::vector<std::string> GetArgvs();
1149#if GTEST_HAS_DEATH_TEST
1151std::vector<std::string> GetInjectableArgvs();
1153void SetInjectableArgvs(
const std::vector<std::string>* new_argvs);
1154void SetInjectableArgvs(
const std::vector<std::string>& new_argvs);
1155void ClearInjectableArgvs();
1160#if GTEST_IS_THREADSAFE
1161# if GTEST_HAS_PTHREAD
1165inline void SleepMilliseconds(
int n) {
1166 const timespec time = {
1170 nanosleep(&time,
nullptr);
1174# if GTEST_HAS_NOTIFICATION_
1178# elif GTEST_HAS_PTHREAD
1187 Notification() : notified_(false) {
1188 GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_,
nullptr));
1191 pthread_mutex_destroy(&mutex_);
1197 pthread_mutex_lock(&mutex_);
1199 pthread_mutex_unlock(&mutex_);
1204 void WaitForNotification() {
1206 pthread_mutex_lock(&mutex_);
1207 const bool notified = notified_;
1208 pthread_mutex_unlock(&mutex_);
1211 SleepMilliseconds(10);
1216 pthread_mutex_t mutex_;
1219 GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
1222# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
1224GTEST_API_
void SleepMilliseconds(
int n);
1228class GTEST_API_ AutoHandle {
1235 typedef void* Handle;
1237 explicit AutoHandle(Handle handle);
1243 void Reset(Handle handle);
1248 bool IsCloseable()
const;
1252 GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);
1261class GTEST_API_ Notification {
1265 void WaitForNotification();
1270 GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
1277# if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW
1284class ThreadWithParamBase {
1286 virtual ~ThreadWithParamBase() {}
1287 virtual void Run() = 0;
1296extern "C" inline void* ThreadFuncWithCLinkage(
void* thread) {
1297 static_cast<ThreadWithParamBase*
>(thread)->Run();
1313template <
typename T>
1314class ThreadWithParam :
public ThreadWithParamBase {
1316 typedef void UserThreadFunc(T);
1318 ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
1321 thread_can_start_(thread_can_start),
1323 ThreadWithParamBase*
const base =
this;
1326 GTEST_CHECK_POSIX_SUCCESS_(
1327 pthread_create(&thread_,
nullptr, &ThreadFuncWithCLinkage, base));
1329 ~ThreadWithParam()
override { Join(); }
1333 GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_,
nullptr));
1338 void Run()
override {
1339 if (thread_can_start_ !=
nullptr) thread_can_start_->WaitForNotification();
1344 UserThreadFunc*
const func_;
1348 Notification*
const thread_can_start_;
1353 GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
1358# if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
1362# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
1378class GTEST_API_ Mutex {
1380 enum MutexType { kStatic = 0, kDynamic = 1 };
1384 enum StaticConstructorSelector { kStaticMutex = 0 };
1389 explicit Mutex(StaticConstructorSelector ) {}
1404 void ThreadSafeLazyInit();
1408 unsigned int owner_thread_id_;
1413 long critical_section_init_phase_;
1414 GTEST_CRITICAL_SECTION* critical_section_;
1416 GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
1419# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
1420 extern ::testing::internal::Mutex mutex
1422# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
1423 ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex)
1430class GTestMutexLock {
1432 explicit GTestMutexLock(Mutex* mutex)
1433 : mutex_(mutex) { mutex_->Lock(); }
1435 ~GTestMutexLock() { mutex_->Unlock(); }
1438 Mutex*
const mutex_;
1440 GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
1443typedef GTestMutexLock MutexLock;
1447class ThreadLocalValueHolderBase {
1449 virtual ~ThreadLocalValueHolderBase() {}
1454class ThreadLocalBase {
1460 virtual ThreadLocalValueHolderBase* NewValueForCurrentThread()
const = 0;
1463 ThreadLocalBase() {}
1464 virtual ~ThreadLocalBase() {}
1467 GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase);
1473class GTEST_API_ ThreadLocalRegistry {
1477 static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
1478 const ThreadLocalBase* thread_local_instance);
1481 static void OnThreadLocalDestroyed(
1482 const ThreadLocalBase* thread_local_instance);
1485class GTEST_API_ ThreadWithParamBase {
1492 virtual ~Runnable() {}
1493 virtual void Run() = 0;
1496 ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start);
1497 virtual ~ThreadWithParamBase();
1504template <
typename T>
1505class ThreadWithParam :
public ThreadWithParamBase {
1507 typedef void UserThreadFunc(T);
1509 ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
1510 : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {
1512 virtual ~ThreadWithParam() {}
1515 class RunnableImpl :
public Runnable {
1517 RunnableImpl(UserThreadFunc* func, T param)
1521 virtual ~RunnableImpl() {}
1522 virtual void Run() {
1527 UserThreadFunc*
const func_;
1530 GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl);
1533 GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
1563template <
typename T>
1564class ThreadLocal :
public ThreadLocalBase {
1566 ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {}
1567 explicit ThreadLocal(
const T& value)
1568 : default_factory_(new InstanceValueHolderFactory(value)) {}
1570 ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(
this); }
1572 T* pointer() {
return GetOrCreateValue(); }
1573 const T* pointer()
const {
return GetOrCreateValue(); }
1574 const T& get()
const {
return *pointer(); }
1575 void set(
const T& value) { *pointer() = value; }
1580 class ValueHolder :
public ThreadLocalValueHolderBase {
1582 ValueHolder() : value_() {}
1583 explicit ValueHolder(
const T& value) : value_(value) {}
1585 T* pointer() {
return &value_; }
1589 GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
1593 T* GetOrCreateValue()
const {
1594 return static_cast<ValueHolder*
>(
1595 ThreadLocalRegistry::GetValueOnCurrentThread(
this))->pointer();
1598 virtual ThreadLocalValueHolderBase* NewValueForCurrentThread()
const {
1599 return default_factory_->MakeNewHolder();
1602 class ValueHolderFactory {
1604 ValueHolderFactory() {}
1605 virtual ~ValueHolderFactory() {}
1606 virtual ValueHolder* MakeNewHolder()
const = 0;
1609 GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
1612 class DefaultValueHolderFactory :
public ValueHolderFactory {
1614 DefaultValueHolderFactory() {}
1615 ValueHolder* MakeNewHolder()
const override {
return new ValueHolder(); }
1618 GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
1621 class InstanceValueHolderFactory :
public ValueHolderFactory {
1623 explicit InstanceValueHolderFactory(
const T& value) : value_(value) {}
1624 ValueHolder* MakeNewHolder()
const override {
1625 return new ValueHolder(value_);
1631 GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
1634 std::unique_ptr<ValueHolderFactory> default_factory_;
1636 GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
1639# elif GTEST_HAS_PTHREAD
1646 GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
1647 owner_ = pthread_self();
1658 GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
1663 void AssertHeld()
const {
1664 GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
1665 <<
"The current thread is not holding the mutex @" <<
this;
1674 pthread_mutex_t mutex_;
1686# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
1687 extern ::testing::internal::MutexBase mutex
1695#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
1696 ::testing::internal::MutexBase mutex = {PTHREAD_MUTEX_INITIALIZER, false, 0}
1700class Mutex :
public MutexBase {
1703 GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_,
nullptr));
1707 GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
1711 GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
1719class GTestMutexLock {
1721 explicit GTestMutexLock(MutexBase* mutex)
1722 : mutex_(mutex) { mutex_->Lock(); }
1724 ~GTestMutexLock() { mutex_->Unlock(); }
1727 MutexBase*
const mutex_;
1729 GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
1732typedef GTestMutexLock MutexLock;
1740class ThreadLocalValueHolderBase {
1742 virtual ~ThreadLocalValueHolderBase() {}
1747extern "C" inline void DeleteThreadLocalValue(
void* value_holder) {
1748 delete static_cast<ThreadLocalValueHolderBase*
>(value_holder);
1752template <
typename T>
1753class GTEST_API_ ThreadLocal {
1756 : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
1757 explicit ThreadLocal(
const T& value)
1758 : key_(CreateKey()),
1759 default_factory_(new InstanceValueHolderFactory(value)) {}
1763 DeleteThreadLocalValue(pthread_getspecific(key_));
1767 GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
1770 T* pointer() {
return GetOrCreateValue(); }
1771 const T* pointer()
const {
return GetOrCreateValue(); }
1772 const T& get()
const {
return *pointer(); }
1773 void set(
const T& value) { *pointer() = value; }
1777 class ValueHolder :
public ThreadLocalValueHolderBase {
1779 ValueHolder() : value_() {}
1780 explicit ValueHolder(
const T& value) : value_(value) {}
1782 T* pointer() {
return &value_; }
1786 GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
1789 static pthread_key_t CreateKey() {
1793 GTEST_CHECK_POSIX_SUCCESS_(
1794 pthread_key_create(&key, &DeleteThreadLocalValue));
1798 T* GetOrCreateValue()
const {
1799 ThreadLocalValueHolderBase*
const holder =
1800 static_cast<ThreadLocalValueHolderBase*
>(pthread_getspecific(key_));
1801 if (holder !=
nullptr) {
1802 return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
1805 ValueHolder*
const new_holder = default_factory_->MakeNewHolder();
1806 ThreadLocalValueHolderBase*
const holder_base = new_holder;
1807 GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
1808 return new_holder->pointer();
1811 class ValueHolderFactory {
1813 ValueHolderFactory() {}
1814 virtual ~ValueHolderFactory() {}
1815 virtual ValueHolder* MakeNewHolder()
const = 0;
1818 GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
1821 class DefaultValueHolderFactory :
public ValueHolderFactory {
1823 DefaultValueHolderFactory() {}
1824 ValueHolder* MakeNewHolder()
const override {
return new ValueHolder(); }
1827 GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
1830 class InstanceValueHolderFactory :
public ValueHolderFactory {
1832 explicit InstanceValueHolderFactory(
const T& value) : value_(value) {}
1833 ValueHolder* MakeNewHolder()
const override {
1834 return new ValueHolder(value_);
1840 GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
1844 const pthread_key_t key_;
1845 std::unique_ptr<ValueHolderFactory> default_factory_;
1847 GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
1864 void AssertHeld()
const {}
1867# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
1868 extern ::testing::internal::Mutex mutex
1870# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
1884template <
typename T>
1888 explicit ThreadLocal(
const T& value) : value_(value) {}
1889 T* pointer() {
return &value_; }
1890 const T* pointer()
const {
return &value_; }
1891 const T& get()
const {
return value_; }
1892 void set(
const T& value) { value_ = value; }
1901GTEST_API_
size_t GetThreadCount();
1904# define GTEST_PATH_SEP_ "\\"
1905# define GTEST_HAS_ALT_PATH_SEP_ 1
1907# define GTEST_PATH_SEP_ "/"
1908# define GTEST_HAS_ALT_PATH_SEP_ 0
1918inline bool IsAlpha(
char ch) {
1919 return isalpha(
static_cast<unsigned char>(ch)) != 0;
1921inline bool IsAlNum(
char ch) {
1922 return isalnum(
static_cast<unsigned char>(ch)) != 0;
1924inline bool IsDigit(
char ch) {
1925 return isdigit(
static_cast<unsigned char>(ch)) != 0;
1927inline bool IsLower(
char ch) {
1928 return islower(
static_cast<unsigned char>(ch)) != 0;
1930inline bool IsSpace(
char ch) {
1931 return isspace(
static_cast<unsigned char>(ch)) != 0;
1933inline bool IsUpper(
char ch) {
1934 return isupper(
static_cast<unsigned char>(ch)) != 0;
1936inline bool IsXDigit(
char ch) {
1937 return isxdigit(
static_cast<unsigned char>(ch)) != 0;
1940inline bool IsXDigit(
char8_t ch) {
1941 return isxdigit(
static_cast<unsigned char>(ch)) != 0;
1944inline bool IsXDigit(
char16_t ch) {
1945 const unsigned char low_byte =
static_cast<unsigned char>(ch);
1946 return ch == low_byte && isxdigit(low_byte) != 0;
1948inline bool IsXDigit(
char32_t ch) {
1949 const unsigned char low_byte =
static_cast<unsigned char>(ch);
1950 return ch == low_byte && isxdigit(low_byte) != 0;
1952inline bool IsXDigit(
wchar_t ch) {
1953 const unsigned char low_byte =
static_cast<unsigned char>(ch);
1954 return ch == low_byte && isxdigit(low_byte) != 0;
1957inline char ToLower(
char ch) {
1958 return static_cast<char>(tolower(
static_cast<unsigned char>(ch)));
1960inline char ToUpper(
char ch) {
1961 return static_cast<char>(toupper(
static_cast<unsigned char>(ch)));
1964inline std::string StripTrailingSpaces(std::string str) {
1965 std::string::iterator it = str.end();
1966 while (it != str.begin() && IsSpace(*--it))
1983typedef struct _stat StatStruct;
1986inline int DoIsATTY(
int fd) {
return isatty(fd); }
1987inline int StrCaseCmp(
const char* s1,
const char* s2) {
1988 return stricmp(s1, s2);
1990inline char* StrDup(
const char* src) {
return strdup(src); }
1992# if GTEST_OS_WINDOWS_MOBILE
1993inline int DoIsATTY(
int ) {
return 0; }
1995inline int DoIsATTY(
int fd) {
return _isatty(fd); }
1997inline int StrCaseCmp(
const char* s1,
const char* s2) {
1998 return _stricmp(s1, s2);
2000inline char* StrDup(
const char* src) {
return _strdup(src); }
2003# if GTEST_OS_WINDOWS_MOBILE
2004inline int FileNo(FILE* file) {
return reinterpret_cast<int>(_fileno(file)); }
2008inline int FileNo(FILE* file) {
return _fileno(file); }
2009inline int Stat(
const char* path, StatStruct* buf) {
return _stat(path, buf); }
2010inline int RmDir(
const char* dir) {
return _rmdir(dir); }
2011inline bool IsDir(
const StatStruct& st) {
2012 return (_S_IFDIR & st.st_mode) != 0;
2016#elif GTEST_OS_ESP8266
2017typedef struct stat StatStruct;
2019inline int FileNo(FILE* file) {
return fileno(file); }
2020inline int DoIsATTY(
int fd) {
return isatty(fd); }
2021inline int Stat(
const char* path, StatStruct* buf) {
2025inline int StrCaseCmp(
const char* s1,
const char* s2) {
2026 return strcasecmp(s1, s2);
2028inline char* StrDup(
const char* src) {
return strdup(src); }
2029inline int RmDir(
const char* dir) {
return rmdir(dir); }
2030inline bool IsDir(
const StatStruct& st) {
return S_ISDIR(st.st_mode); }
2034typedef struct stat StatStruct;
2036inline int FileNo(FILE* file) {
return fileno(file); }
2037inline int DoIsATTY(
int fd) {
return isatty(fd); }
2038inline int Stat(
const char* path, StatStruct* buf) {
return stat(path, buf); }
2039inline int StrCaseCmp(
const char* s1,
const char* s2) {
2040 return strcasecmp(s1, s2);
2042inline char* StrDup(
const char* src) {
return strdup(src); }
2043inline int RmDir(
const char* dir) {
return rmdir(dir); }
2044inline bool IsDir(
const StatStruct& st) {
return S_ISDIR(st.st_mode); }
2048inline int IsATTY(
int fd) {
2052 int savedErrno = errno;
2053 int isAttyValue = DoIsATTY(fd);
2061GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
2067#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
2068inline int ChDir(
const char* dir) {
return chdir(dir); }
2070inline FILE* FOpen(
const char* path,
const char* mode) {
2071#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
2072 struct wchar_codecvt :
public std::codecvt<wchar_t, char, std::mbstate_t> {};
2073 std::wstring_convert<wchar_codecvt> converter;
2074 std::wstring wide_path = converter.from_bytes(path);
2075 std::wstring wide_mode = converter.from_bytes(mode);
2076 return _wfopen(wide_path.c_str(), wide_mode.c_str());
2078 return fopen(path, mode);
2081#if !GTEST_OS_WINDOWS_MOBILE
2082inline FILE *FReopen(
const char* path,
const char* mode, FILE* stream) {
2083 return freopen(path, mode, stream);
2085inline FILE* FDOpen(
int fd,
const char* mode) {
return fdopen(fd, mode); }
2087inline int FClose(FILE* fp) {
return fclose(fp); }
2088#if !GTEST_OS_WINDOWS_MOBILE
2089inline int Read(
int fd,
void* buf,
unsigned int count) {
2090 return static_cast<int>(read(fd, buf, count));
2092inline int Write(
int fd,
const void* buf,
unsigned int count) {
2093 return static_cast<int>(write(fd, buf, count));
2095inline int Close(
int fd) {
return close(fd); }
2096inline const char* StrError(
int errnum) {
return strerror(errnum); }
2098inline const char* GetEnv(
const char* name) {
2099#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
2100 GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266
2102 static_cast<void>(name);
2104#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
2107 const char*
const env = getenv(name);
2108 return (env !=
nullptr && env[0] !=
'\0') ? env :
nullptr;
2110 return getenv(name);
2114GTEST_DISABLE_MSC_DEPRECATED_POP_()
2116#if GTEST_OS_WINDOWS_MOBILE
2120[[noreturn]]
void Abort();
2122[[noreturn]]
inline void Abort() { abort(); }
2132#if _MSC_VER && !GTEST_OS_WINDOWS_MOBILE
2134# define GTEST_SNPRINTF_(buffer, size, format, ...) \
2135 _snprintf_s(buffer, size, size, format, __VA_ARGS__)
2136#elif defined(_MSC_VER)
2138# define GTEST_SNPRINTF_ _snprintf
2140# define GTEST_SNPRINTF_ snprintf
2146using BiggestInt =
long long;
2149constexpr BiggestInt kMaxBiggestInt = (std::numeric_limits<BiggestInt>::max)();
2169template <
size_t size>
2181 using Int = std::int32_t;
2182 using UInt = std::uint32_t;
2189 using Int = std::int64_t;
2190 using UInt = std::uint64_t;
2194using TimeInMillis = int64_t;
2199#if !defined(GTEST_FLAG)
2200# define GTEST_FLAG(name) FLAGS_gtest_##name
2203#if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
2204# define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
2207#if !defined(GTEST_DECLARE_bool_)
2208# define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
2211# define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
2212# define GTEST_DECLARE_int32_(name) \
2213 GTEST_API_ extern std::int32_t GTEST_FLAG(name)
2214# define GTEST_DECLARE_string_(name) \
2215 GTEST_API_ extern ::std::string GTEST_FLAG(name)
2218# define GTEST_DEFINE_bool_(name, default_val, doc) \
2219 GTEST_API_ bool GTEST_FLAG(name) = (default_val)
2220# define GTEST_DEFINE_int32_(name, default_val, doc) \
2221 GTEST_API_ std::int32_t GTEST_FLAG(name) = (default_val)
2222# define GTEST_DEFINE_string_(name, default_val, doc) \
2223 GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)
2228#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
2229# define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
2230# define GTEST_LOCK_EXCLUDED_(locks)
2236GTEST_API_
bool ParseInt32(
const Message& src_text,
const char* str,
2241bool BoolFromGTestEnv(
const char* flag,
bool default_val);
2242GTEST_API_ int32_t Int32FromGTestEnv(
const char* flag, int32_t default_val);
2243std::string OutputFlagAlsoCheckEnvVar();
2244const char* StringFromGTestEnv(
const char* flag,
const char* default_val);
2249#if !defined(GTEST_INTERNAL_DEPRECATED)
2259#if defined(_MSC_VER)
2260#define GTEST_INTERNAL_DEPRECATED(message) __declspec(deprecated(message))
2261#elif defined(__GNUC__)
2262#define GTEST_INTERNAL_DEPRECATED(message) __attribute__((deprecated(message)))
2264#define GTEST_INTERNAL_DEPRECATED(message)
2272#define GTEST_INTERNAL_HAS_ANY 1
2273#include "absl/types/any.h"
2276using Any = ::absl::any;
2281#if __has_include(<any>) && __cplusplus >= 201703L
2284#define GTEST_INTERNAL_HAS_ANY 1
2288using Any = ::std::any;
2300#define GTEST_INTERNAL_HAS_OPTIONAL 1
2301#include "absl/types/optional.h"
2304template <
typename T>
2305using Optional = ::absl::optional<T>;
2310#if __has_include(<optional>) && __cplusplus >= 201703L
2313#define GTEST_INTERNAL_HAS_OPTIONAL 1
2317template <
typename T>
2318using Optional = ::std::optional<T>;
2330# define GTEST_INTERNAL_HAS_STRING_VIEW 1
2331#include "absl/strings/string_view.h"
2334using StringView = ::absl::string_view;
2338# ifdef __has_include
2339# if __has_include(<string_view>) && __cplusplus >= 201703L
2342# define GTEST_INTERNAL_HAS_STRING_VIEW 1
2343#include <string_view>
2346using StringView = ::std::string_view;
2358#define GTEST_INTERNAL_HAS_VARIANT 1
2359#include "absl/types/variant.h"
2362template <
typename... T>
2363using Variant = ::absl::variant<T...>;
2368#if __has_include(<variant>) && __cplusplus >= 201703L
2371#define GTEST_INTERNAL_HAS_VARIANT 1
2375template <
typename... T>
2376using Variant = ::std::variant<T...>;
Definition gtest-message.h:91
Definition gtest-port.h:963
Definition gtest-port.h:1877
Definition gtest-port.h:1859
Definition gtest-port.h:889
Definition gtest-port.h:1885
Definition googletest-port-test.cc:192
Definition gtest-port.h:2170
Definition gtest-port.h:1034