45#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
46#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
274#include <type_traits>
279#include <sys/types.h>
283#include <AvailabilityMacros.h>
284#include <TargetConditionals.h>
287#include "gtest/internal/custom/gtest-port.h"
288#include "gtest/internal/gtest-port-arch.h"
291#include "absl/flags/declare.h"
292#include "absl/flags/flag.h"
293#include "absl/flags/reflection.h"
296#if !defined(GTEST_DEV_EMAIL_)
297#define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
298#define GTEST_FLAG_PREFIX_ "gtest_"
299#define GTEST_FLAG_PREFIX_DASH_ "gtest-"
300#define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
301#define GTEST_NAME_ "Google Test"
302#define GTEST_PROJECT_URL_ "https://github.com/google/googletest/"
305#if !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
306#define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest"
312#define GTEST_GCC_VER_ \
313 (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
322#define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
323 __pragma(warning(push)) __pragma(warning(disable : warnings))
324#define GTEST_DISABLE_MSC_WARNINGS_POP_() __pragma(warning(pop))
327#define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
328#define GTEST_DISABLE_MSC_WARNINGS_POP_()
334#define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \
335 _Pragma("clang diagnostic push") \
336 _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") \
337 _Pragma("clang diagnostic ignored \"-Wdeprecated-implementations\"")
338#define GTEST_DISABLE_MSC_DEPRECATED_POP_() _Pragma("clang diagnostic pop")
340#define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \
341 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
342#define GTEST_DISABLE_MSC_DEPRECATED_POP_() GTEST_DISABLE_MSC_WARNINGS_POP_()
349#if !GTEST_OS_WINDOWS_MOBILE
354#if GTEST_OS_WINDOWS_MINGW && !defined(__MINGW64_VERSION_MAJOR)
357typedef struct _CRITICAL_SECTION GTEST_CRITICAL_SECTION;
362typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
376#if GTEST_OS_LINUX_ANDROID
378#include <android/api-level.h>
383#ifndef GTEST_HAS_POSIX_RE
384#if GTEST_OS_LINUX_ANDROID
386#define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
388#define GTEST_HAS_POSIX_RE \
389 !(GTEST_OS_WINDOWS || GTEST_OS_XTENSA || GTEST_OS_QURT)
396#include "absl/strings/string_view.h"
398#define GTEST_USES_RE2 1
399#elif GTEST_HAS_POSIX_RE
401#define GTEST_USES_POSIX_RE 1
404#define GTEST_USES_SIMPLE_RE 1
407#ifndef GTEST_HAS_EXCEPTIONS
410#if defined(_MSC_VER) && defined(_CPPUNWIND)
412#define GTEST_HAS_EXCEPTIONS 1
413#elif defined(__BORLANDC__)
417#ifndef _HAS_EXCEPTIONS
418#define _HAS_EXCEPTIONS 1
420#define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
421#elif defined(__clang__)
430#define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions))
431#elif defined(__GNUC__) && __EXCEPTIONS
433#define GTEST_HAS_EXCEPTIONS 1
434#elif defined(__SUNPRO_CC)
438#define GTEST_HAS_EXCEPTIONS 1
439#elif defined(__IBMCPP__) && __EXCEPTIONS
441#define GTEST_HAS_EXCEPTIONS 1
442#elif defined(__HP_aCC)
445#define GTEST_HAS_EXCEPTIONS 1
449#define GTEST_HAS_EXCEPTIONS 0
453#ifndef GTEST_HAS_STD_WSTRING
459#define GTEST_HAS_STD_WSTRING \
460 (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
461 GTEST_OS_HAIKU || GTEST_OS_ESP32 || GTEST_OS_ESP8266 || \
462 GTEST_OS_XTENSA || GTEST_OS_QURT))
467#ifndef GTEST_HAS_RTTI
474#define GTEST_HAS_RTTI 1
476#define GTEST_HAS_RTTI 0
481#elif defined(__GNUC__)
488#if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && !defined(__EXCEPTIONS)
489#define GTEST_HAS_RTTI 0
491#define GTEST_HAS_RTTI 1
494#define GTEST_HAS_RTTI 0
500#elif defined(__clang__)
502#define GTEST_HAS_RTTI __has_feature(cxx_rtti)
506#elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
509#define GTEST_HAS_RTTI 1
511#define GTEST_HAS_RTTI 0
517#define GTEST_HAS_RTTI 1
530#ifndef GTEST_HAS_PTHREAD
536#define GTEST_HAS_PTHREAD \
537 (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX || \
538 GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \
539 GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_OPENBSD || \
540 GTEST_OS_HAIKU || GTEST_OS_GNU_HURD)
556#ifndef GTEST_HAS_CLONE
559#if GTEST_OS_LINUX && !defined(__ia64__)
560#if GTEST_OS_LINUX_ANDROID
563#if defined(__LP64__) || (defined(__arm__) && __ANDROID_API__ >= 9) || \
564 (defined(__mips__) && __ANDROID_API__ >= 12) || \
565 (defined(__i386__) && __ANDROID_API__ >= 17)
566#define GTEST_HAS_CLONE 1
568#define GTEST_HAS_CLONE 0
571#define GTEST_HAS_CLONE 1
574#define GTEST_HAS_CLONE 0
581#ifndef GTEST_HAS_STREAM_REDIRECTION
584#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
585 GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA || \
587#define GTEST_HAS_STREAM_REDIRECTION 0
589#define GTEST_HAS_STREAM_REDIRECTION 1
595#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
596 (GTEST_OS_MAC && !GTEST_OS_IOS) || \
597 (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER) || GTEST_OS_WINDOWS_MINGW || \
598 GTEST_OS_AIX || GTEST_OS_HPUX || GTEST_OS_OPENBSD || GTEST_OS_QNX || \
599 GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \
600 GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_HAIKU || \
602#define GTEST_HAS_DEATH_TEST 1
609#if defined(__GNUC__) || defined(_MSC_VER) || defined(__SUNPRO_CC) || \
610 defined(__IBMCPP__) || defined(__HP_aCC)
611#define GTEST_HAS_TYPED_TEST 1
612#define GTEST_HAS_TYPED_TEST_P 1
616#define GTEST_WIDE_STRING_USES_UTF16_ \
617 (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_AIX || GTEST_OS_OS2)
620#if GTEST_OS_LINUX || GTEST_OS_GNU_KFREEBSD || GTEST_OS_DRAGONFLY || \
621 GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_OPENBSD || \
623#define GTEST_CAN_STREAM_RESULTS_ 1
636#ifdef __INTEL_COMPILER
637#define GTEST_AMBIGUOUS_ELSE_BLOCKER_
639#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
655#ifdef __has_attribute
656#define GTEST_HAVE_ATTRIBUTE_(x) __has_attribute(x)
658#define GTEST_HAVE_ATTRIBUTE_(x) 0
666#define GTEST_HAVE_FEATURE_(x) __has_feature(x)
668#define GTEST_HAVE_FEATURE_(x) 0
682#if GTEST_HAVE_ATTRIBUTE_(unused)
683#define GTEST_ATTRIBUTE_UNUSED_ __attribute__((unused))
685#define GTEST_ATTRIBUTE_UNUSED_
689#if GTEST_HAVE_ATTRIBUTE_(format) && defined(__MINGW_PRINTF_FORMAT)
693#define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
694 __attribute__((format(__MINGW_PRINTF_FORMAT, string_index, first_to_check)))
695#elif GTEST_HAVE_ATTRIBUTE_(format)
696#define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
697 __attribute__((format(printf, string_index, first_to_check)))
699#define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check)
707#if GTEST_HAVE_ATTRIBUTE_(warn_unused_result)
708#define GTEST_MUST_USE_RESULT_ __attribute__((warn_unused_result))
710#define GTEST_MUST_USE_RESULT_
721#define GTEST_INTENTIONAL_CONST_COND_PUSH_() \
722 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)
723#define GTEST_INTENTIONAL_CONST_COND_POP_() GTEST_DISABLE_MSC_WARNINGS_POP_()
731#if defined(_MSC_VER) || defined(__BORLANDC__)
733#define GTEST_HAS_SEH 1
736#define GTEST_HAS_SEH 0
741#ifndef GTEST_IS_THREADSAFE
743#define GTEST_IS_THREADSAFE \
744 (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ || \
745 (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) || \
750#if GTEST_IS_THREADSAFE
752#include <condition_variable>
762#if GTEST_LINKED_AS_SHARED_LIBRARY
763#define GTEST_API_ __declspec(dllimport)
764#elif GTEST_CREATE_SHARED_LIBRARY
765#define GTEST_API_ __declspec(dllexport)
767#elif GTEST_HAVE_ATTRIBUTE_(visibility)
768#define GTEST_API_ __attribute__((visibility("default")))
777#ifndef GTEST_DEFAULT_DEATH_TEST_STYLE
778#define GTEST_DEFAULT_DEATH_TEST_STYLE "fast"
781#if GTEST_HAVE_ATTRIBUTE_(noinline)
783#define GTEST_NO_INLINE_ __attribute__((noinline))
785#define GTEST_NO_INLINE_
788#if GTEST_HAVE_ATTRIBUTE_(disable_tail_calls)
791#define GTEST_NO_TAIL_CALL_ __attribute__((disable_tail_calls))
793#define GTEST_NO_TAIL_CALL_ \
794 __attribute__((optimize("no-optimize-sibling-calls")))
796#define GTEST_NO_TAIL_CALL_
800#if !defined(GTEST_HAS_CXXABI_H_)
801#if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER))
802#define GTEST_HAS_CXXABI_H_ 1
804#define GTEST_HAS_CXXABI_H_ 0
810#if GTEST_HAVE_ATTRIBUTE_(no_sanitize_memory)
811#define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ __attribute__((no_sanitize_memory))
813#define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
817#if GTEST_HAVE_ATTRIBUTE_(no_sanitize_address)
818#define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \
819 __attribute__((no_sanitize_address))
821#define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
825#if GTEST_HAVE_FEATURE_(hwaddress_sanitizer) && \
826 GTEST_HAVE_ATTRIBUTE_(no_sanitize)
827#define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ \
828 __attribute__((no_sanitize("hwaddress")))
830#define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
834#if GTEST_HAVE_ATTRIBUTE_(no_sanitize_thread)
835#define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ __attribute((no_sanitize_thread))
837#define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
847using std::make_tuple;
849using std::tuple_element;
850using std::tuple_size;
861GTEST_API_
bool IsTrue(
bool condition);
872 RE(absl::string_view regex) : regex_(regex) {}
873 RE(
const char* regex) : RE(absl::string_view(regex)) {}
874 RE(
const std::string& regex) : RE(absl::string_view(regex)) {}
875 RE(
const RE& other) : RE(other.pattern()) {}
877 const std::string& pattern()
const {
return regex_.pattern(); }
879 static bool FullMatch(absl::string_view str,
const RE& re) {
880 return RE2::FullMatch(str, re.regex_);
882 static bool PartialMatch(absl::string_view str,
const RE& re) {
883 return RE2::PartialMatch(str, re.regex_);
890#elif GTEST_USES_POSIX_RE || GTEST_USES_SIMPLE_RE
898 RE(
const RE& other) { Init(other.pattern()); }
901 RE(const ::std::string& regex) { Init(regex.c_str()); }
903 RE(
const char* regex) { Init(regex); }
907 const char* pattern()
const {
return pattern_; }
913 static bool FullMatch(const ::std::string& str,
const RE& re) {
914 return FullMatch(str.c_str(), re);
916 static bool PartialMatch(const ::std::string& str,
const RE& re) {
917 return PartialMatch(str.c_str(), re);
920 static bool FullMatch(
const char* str,
const RE& re);
921 static bool PartialMatch(
const char* str,
const RE& re);
924 void Init(
const char* regex);
925 const char* pattern_;
928#if GTEST_USES_POSIX_RE
931 regex_t partial_regex_;
935 const char* full_pattern_;
944GTEST_API_ ::std::string FormatFileLocation(
const char* file,
int line);
949GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
const char* file,
958enum GTestLogSeverity { GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL };
965 GTestLog(GTestLogSeverity severity,
const char* file,
int line);
970 ::std::ostream& GetStream() { return ::std::cerr; }
973 const GTestLogSeverity severity_;
979#if !defined(GTEST_LOG_)
981#define GTEST_LOG_(severity) \
982 ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
983 __FILE__, __LINE__) \
986inline void LogToStderr() {}
987inline void FlushInfoLog() { fflush(
nullptr); }
991#if !defined(GTEST_CHECK_)
1006#define GTEST_CHECK_(condition) \
1007 GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
1008 if (::testing::internal::IsTrue(condition)) \
1011 GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
1019#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
1020 if (const int gtest_error = (posix_call)) \
1021 GTEST_LOG_(FATAL) << #posix_call << "failed with error " << gtest_error
1034template <
typename T>
1036 typedef const T& type;
1038template <
typename T>
1044#define GTEST_REFERENCE_TO_CONST_(T) \
1045 typename ::testing::internal::ConstRef<T>::type
1067template <
typename To>
1068inline To ImplicitCast_(
To x) {
1093template <
typename To,
typename From>
1094inline To DownCast_(From* f) {
1099 GTEST_INTENTIONAL_CONST_COND_PUSH_()
1101 GTEST_INTENTIONAL_CONST_COND_POP_()
1102 const To to =
nullptr;
1103 ::testing::internal::ImplicitCast_<From*>(to);
1108 GTEST_CHECK_(f ==
nullptr ||
dynamic_cast<To
>(f) !=
nullptr);
1110 return static_cast<To
>(f);
1118template <
class Derived,
class Base>
1119Derived* CheckedDowncastToActualType(
Base* base) {
1121 GTEST_CHECK_(
typeid(*base) ==
typeid(Derived));
1124#if GTEST_HAS_DOWNCAST_
1125 return ::down_cast<Derived*>(base);
1127 return dynamic_cast<Derived*
>(base);
1129 return static_cast<Derived*
>(base);
1133#if GTEST_HAS_STREAM_REDIRECTION
1141GTEST_API_
void CaptureStdout();
1142GTEST_API_ std::string GetCapturedStdout();
1143GTEST_API_
void CaptureStderr();
1144GTEST_API_ std::string GetCapturedStderr();
1148GTEST_API_
size_t GetFileSize(FILE* file);
1151GTEST_API_ std::string ReadEntireFile(FILE* file);
1154GTEST_API_ std::vector<std::string> GetArgvs();
1156#if GTEST_HAS_DEATH_TEST
1158std::vector<std::string> GetInjectableArgvs();
1160void SetInjectableArgvs(
const std::vector<std::string>* new_argvs);
1161void SetInjectableArgvs(
const std::vector<std::string>& new_argvs);
1162void ClearInjectableArgvs();
1167#if GTEST_IS_THREADSAFE
1172class GTEST_API_ AutoHandle {
1179 typedef void* Handle;
1181 explicit AutoHandle(Handle handle);
1187 void Reset(Handle handle);
1192 bool IsCloseable()
const;
1196 AutoHandle(
const AutoHandle&) =
delete;
1197 AutoHandle& operator=(
const AutoHandle&) =
delete;
1201#if GTEST_HAS_NOTIFICATION_
1206GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
1216class GTEST_API_ Notification {
1218 Notification() : notified_(false) {}
1219 Notification(
const Notification&) =
delete;
1220 Notification& operator=(
const Notification&) =
delete;
1225 std::lock_guard<std::mutex> lock(mu_);
1232 void WaitForNotification() {
1233 std::unique_lock<std::mutex> lock(mu_);
1234 cv_.wait(lock, [
this]() {
return notified_; });
1239 std::condition_variable cv_;
1242GTEST_DISABLE_MSC_WARNINGS_POP_()
1248#if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW
1255class ThreadWithParamBase {
1257 virtual ~ThreadWithParamBase() {}
1258 virtual void Run() = 0;
1267extern "C" inline void* ThreadFuncWithCLinkage(
void* thread) {
1268 static_cast<ThreadWithParamBase*
>(thread)->Run();
1284template <
typename T>
1285class ThreadWithParam :
public ThreadWithParamBase {
1287 typedef void UserThreadFunc(T);
1289 ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
1292 thread_can_start_(thread_can_start),
1294 ThreadWithParamBase*
const base =
this;
1297 GTEST_CHECK_POSIX_SUCCESS_(
1298 pthread_create(&thread_,
nullptr, &ThreadFuncWithCLinkage, base));
1300 ~ThreadWithParam()
override { Join(); }
1304 GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_,
nullptr));
1309 void Run()
override {
1310 if (thread_can_start_ !=
nullptr) thread_can_start_->WaitForNotification();
1315 UserThreadFunc*
const func_;
1319 Notification*
const thread_can_start_;
1324 ThreadWithParam(
const ThreadWithParam&) =
delete;
1325 ThreadWithParam& operator=(
const ThreadWithParam&) =
delete;
1330#if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
1334#elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
1350class GTEST_API_ Mutex {
1352 enum MutexType { kStatic = 0, kDynamic = 1 };
1356 enum StaticConstructorSelector { kStaticMutex = 0 };
1361 explicit Mutex(StaticConstructorSelector ) {}
1376 void ThreadSafeLazyInit();
1380 unsigned int owner_thread_id_;
1385 long critical_section_init_phase_;
1386 GTEST_CRITICAL_SECTION* critical_section_;
1388 Mutex(
const Mutex&) =
delete;
1389 Mutex& operator=(
const Mutex&) =
delete;
1392#define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
1393 extern ::testing::internal::Mutex mutex
1395#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
1396 ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex)
1403class GTestMutexLock {
1405 explicit GTestMutexLock(Mutex* mutex) : mutex_(mutex) { mutex_->Lock(); }
1407 ~GTestMutexLock() { mutex_->Unlock(); }
1410 Mutex*
const mutex_;
1412 GTestMutexLock(
const GTestMutexLock&) =
delete;
1413 GTestMutexLock& operator=(
const GTestMutexLock&) =
delete;
1416typedef GTestMutexLock MutexLock;
1420class ThreadLocalValueHolderBase {
1422 virtual ~ThreadLocalValueHolderBase() {}
1427class ThreadLocalBase {
1433 virtual ThreadLocalValueHolderBase* NewValueForCurrentThread()
const = 0;
1436 ThreadLocalBase() {}
1437 virtual ~ThreadLocalBase() {}
1440 ThreadLocalBase(
const ThreadLocalBase&) =
delete;
1441 ThreadLocalBase& operator=(
const ThreadLocalBase&) =
delete;
1447class GTEST_API_ ThreadLocalRegistry {
1451 static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
1452 const ThreadLocalBase* thread_local_instance);
1455 static void OnThreadLocalDestroyed(
1456 const ThreadLocalBase* thread_local_instance);
1459class GTEST_API_ ThreadWithParamBase {
1466 virtual ~Runnable() {}
1467 virtual void Run() = 0;
1470 ThreadWithParamBase(Runnable* runnable, Notification* thread_can_start);
1471 virtual ~ThreadWithParamBase();
1478template <
typename T>
1479class ThreadWithParam :
public ThreadWithParamBase {
1481 typedef void UserThreadFunc(T);
1483 ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
1484 : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {}
1485 virtual ~ThreadWithParam() {}
1488 class RunnableImpl :
public Runnable {
1490 RunnableImpl(UserThreadFunc* func, T param) : func_(func), param_(param) {}
1491 virtual ~RunnableImpl() {}
1492 virtual void Run() { func_(param_); }
1495 UserThreadFunc*
const func_;
1498 RunnableImpl(
const RunnableImpl&) =
delete;
1499 RunnableImpl& operator=(
const RunnableImpl&) =
delete;
1502 ThreadWithParam(
const ThreadWithParam&) =
delete;
1503 ThreadWithParam& operator=(
const ThreadWithParam&) =
delete;
1533template <
typename T>
1534class ThreadLocal :
public ThreadLocalBase {
1536 ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {}
1537 explicit ThreadLocal(
const T& value)
1538 : default_factory_(new InstanceValueHolderFactory(value)) {}
1540 ~ThreadLocal()
override { ThreadLocalRegistry::OnThreadLocalDestroyed(
this); }
1542 T* pointer() {
return GetOrCreateValue(); }
1543 const T* pointer()
const {
return GetOrCreateValue(); }
1544 const T& get()
const {
return *pointer(); }
1545 void set(
const T& value) { *pointer() = value; }
1550 class ValueHolder :
public ThreadLocalValueHolderBase {
1552 ValueHolder() : value_() {}
1553 explicit ValueHolder(
const T& value) : value_(value) {}
1555 T* pointer() {
return &value_; }
1559 ValueHolder(
const ValueHolder&) =
delete;
1560 ValueHolder& operator=(
const ValueHolder&) =
delete;
1563 T* GetOrCreateValue()
const {
1564 return static_cast<ValueHolder*
>(
1565 ThreadLocalRegistry::GetValueOnCurrentThread(
this))
1569 ThreadLocalValueHolderBase* NewValueForCurrentThread()
const override {
1570 return default_factory_->MakeNewHolder();
1573 class ValueHolderFactory {
1575 ValueHolderFactory() {}
1576 virtual ~ValueHolderFactory() {}
1577 virtual ValueHolder* MakeNewHolder()
const = 0;
1580 ValueHolderFactory(
const ValueHolderFactory&) =
delete;
1581 ValueHolderFactory& operator=(
const ValueHolderFactory&) =
delete;
1584 class DefaultValueHolderFactory :
public ValueHolderFactory {
1586 DefaultValueHolderFactory() {}
1587 ValueHolder* MakeNewHolder()
const override {
return new ValueHolder(); }
1590 DefaultValueHolderFactory(
const DefaultValueHolderFactory&) =
delete;
1591 DefaultValueHolderFactory& operator=(
const DefaultValueHolderFactory&) =
1595 class InstanceValueHolderFactory :
public ValueHolderFactory {
1597 explicit InstanceValueHolderFactory(
const T& value) : value_(value) {}
1598 ValueHolder* MakeNewHolder()
const override {
1599 return new ValueHolder(value_);
1605 InstanceValueHolderFactory(
const InstanceValueHolderFactory&) =
delete;
1606 InstanceValueHolderFactory& operator=(
const InstanceValueHolderFactory&) =
1610 std::unique_ptr<ValueHolderFactory> default_factory_;
1612 ThreadLocal(
const ThreadLocal&) =
delete;
1613 ThreadLocal& operator=(
const ThreadLocal&) =
delete;
1616#elif GTEST_HAS_PTHREAD
1623 GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
1624 owner_ = pthread_self();
1635 GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
1640 void AssertHeld()
const {
1641 GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
1642 <<
"The current thread is not holding the mutex @" <<
this;
1651 pthread_mutex_t mutex_;
1663#define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
1664 extern ::testing::internal::MutexBase mutex
1672#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
1673 ::testing::internal::MutexBase mutex = {PTHREAD_MUTEX_INITIALIZER, false, 0}
1677class Mutex :
public MutexBase {
1680 GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_,
nullptr));
1683 ~Mutex() { GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_)); }
1686 Mutex(
const Mutex&) =
delete;
1687 Mutex& operator=(
const Mutex&) =
delete;
1695class GTestMutexLock {
1697 explicit GTestMutexLock(MutexBase* mutex) : mutex_(mutex) { mutex_->Lock(); }
1699 ~GTestMutexLock() { mutex_->Unlock(); }
1702 MutexBase*
const mutex_;
1704 GTestMutexLock(
const GTestMutexLock&) =
delete;
1705 GTestMutexLock& operator=(
const GTestMutexLock&) =
delete;
1708typedef GTestMutexLock MutexLock;
1716class GTEST_API_ ThreadLocalValueHolderBase {
1718 virtual ~ThreadLocalValueHolderBase() {}
1723extern "C" inline void DeleteThreadLocalValue(
void* value_holder) {
1724 delete static_cast<ThreadLocalValueHolderBase*
>(value_holder);
1728template <
typename T>
1729class GTEST_API_ ThreadLocal {
1732 : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
1733 explicit ThreadLocal(
const T& value)
1734 : key_(CreateKey()),
1735 default_factory_(new InstanceValueHolderFactory(value)) {}
1739 DeleteThreadLocalValue(pthread_getspecific(key_));
1743 GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
1746 T* pointer() {
return GetOrCreateValue(); }
1747 const T* pointer()
const {
return GetOrCreateValue(); }
1748 const T& get()
const {
return *pointer(); }
1749 void set(
const T& value) { *pointer() = value; }
1753 class ValueHolder :
public ThreadLocalValueHolderBase {
1755 ValueHolder() : value_() {}
1756 explicit ValueHolder(
const T& value) : value_(value) {}
1758 T* pointer() {
return &value_; }
1762 ValueHolder(
const ValueHolder&) =
delete;
1763 ValueHolder& operator=(
const ValueHolder&) =
delete;
1766 static pthread_key_t CreateKey() {
1770 GTEST_CHECK_POSIX_SUCCESS_(
1771 pthread_key_create(&key, &DeleteThreadLocalValue));
1775 T* GetOrCreateValue()
const {
1776 ThreadLocalValueHolderBase*
const holder =
1777 static_cast<ThreadLocalValueHolderBase*
>(pthread_getspecific(key_));
1778 if (holder !=
nullptr) {
1779 return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
1782 ValueHolder*
const new_holder = default_factory_->MakeNewHolder();
1783 ThreadLocalValueHolderBase*
const holder_base = new_holder;
1784 GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
1785 return new_holder->pointer();
1788 class ValueHolderFactory {
1790 ValueHolderFactory() {}
1791 virtual ~ValueHolderFactory() {}
1792 virtual ValueHolder* MakeNewHolder()
const = 0;
1795 ValueHolderFactory(
const ValueHolderFactory&) =
delete;
1796 ValueHolderFactory& operator=(
const ValueHolderFactory&) =
delete;
1799 class DefaultValueHolderFactory :
public ValueHolderFactory {
1801 DefaultValueHolderFactory() {}
1802 ValueHolder* MakeNewHolder()
const override {
return new ValueHolder(); }
1805 DefaultValueHolderFactory(
const DefaultValueHolderFactory&) =
delete;
1806 DefaultValueHolderFactory& operator=(
const DefaultValueHolderFactory&) =
1810 class InstanceValueHolderFactory :
public ValueHolderFactory {
1812 explicit InstanceValueHolderFactory(
const T& value) : value_(value) {}
1813 ValueHolder* MakeNewHolder()
const override {
1814 return new ValueHolder(value_);
1820 InstanceValueHolderFactory(
const InstanceValueHolderFactory&) =
delete;
1821 InstanceValueHolderFactory& operator=(
const InstanceValueHolderFactory&) =
1826 const pthread_key_t key_;
1827 std::unique_ptr<ValueHolderFactory> default_factory_;
1829 ThreadLocal(
const ThreadLocal&) =
delete;
1830 ThreadLocal& operator=(
const ThreadLocal&) =
delete;
1847 void AssertHeld()
const {}
1850#define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
1851 extern ::testing::internal::Mutex mutex
1853#define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
1867template <
typename T>
1871 explicit ThreadLocal(
const T& value) : value_(value) {}
1872 T* pointer() {
return &value_; }
1873 const T* pointer()
const {
return &value_; }
1874 const T& get()
const {
return value_; }
1875 void set(
const T& value) { value_ = value; }
1885GTEST_API_
size_t GetThreadCount();
1888#define GTEST_PATH_SEP_ "\\"
1889#define GTEST_HAS_ALT_PATH_SEP_ 1
1891#define GTEST_PATH_SEP_ "/"
1892#define GTEST_HAS_ALT_PATH_SEP_ 0
1902inline bool IsAlpha(
char ch) {
1903 return isalpha(
static_cast<unsigned char>(ch)) != 0;
1905inline bool IsAlNum(
char ch) {
1906 return isalnum(
static_cast<unsigned char>(ch)) != 0;
1908inline bool IsDigit(
char ch) {
1909 return isdigit(
static_cast<unsigned char>(ch)) != 0;
1911inline bool IsLower(
char ch) {
1912 return islower(
static_cast<unsigned char>(ch)) != 0;
1914inline bool IsSpace(
char ch) {
1915 return isspace(
static_cast<unsigned char>(ch)) != 0;
1917inline bool IsUpper(
char ch) {
1918 return isupper(
static_cast<unsigned char>(ch)) != 0;
1920inline bool IsXDigit(
char ch) {
1921 return isxdigit(
static_cast<unsigned char>(ch)) != 0;
1924inline bool IsXDigit(
char8_t ch) {
1925 return isxdigit(
static_cast<unsigned char>(ch)) != 0;
1928inline bool IsXDigit(
char16_t ch) {
1929 const unsigned char low_byte =
static_cast<unsigned char>(ch);
1930 return ch == low_byte && isxdigit(low_byte) != 0;
1932inline bool IsXDigit(
char32_t ch) {
1933 const unsigned char low_byte =
static_cast<unsigned char>(ch);
1934 return ch == low_byte && isxdigit(low_byte) != 0;
1936inline bool IsXDigit(
wchar_t ch) {
1937 const unsigned char low_byte =
static_cast<unsigned char>(ch);
1938 return ch == low_byte && isxdigit(low_byte) != 0;
1941inline char ToLower(
char ch) {
1942 return static_cast<char>(tolower(
static_cast<unsigned char>(ch)));
1944inline char ToUpper(
char ch) {
1945 return static_cast<char>(toupper(
static_cast<unsigned char>(ch)));
1948inline std::string StripTrailingSpaces(std::string str) {
1949 std::string::iterator it = str.end();
1950 while (it != str.begin() && IsSpace(*--it)) it = str.erase(it);
1966typedef struct _stat StatStruct;
1969inline int DoIsATTY(
int fd) {
return isatty(fd); }
1970inline int StrCaseCmp(
const char* s1,
const char* s2) {
1971 return stricmp(s1, s2);
1973inline char* StrDup(
const char* src) {
return strdup(src); }
1975#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \
1976 GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || defined(ESP_PLATFORM)
1977inline int DoIsATTY(
int ) {
return 0; }
1979inline int DoIsATTY(
int fd) {
return _isatty(fd); }
1981inline int StrCaseCmp(
const char* s1,
const char* s2) {
1982 return _stricmp(s1, s2);
1984inline char* StrDup(
const char* src) {
return _strdup(src); }
1987#if GTEST_OS_WINDOWS_MOBILE
1988inline int FileNo(FILE* file) {
return reinterpret_cast<int>(_fileno(file)); }
1992inline int FileNo(FILE* file) {
return _fileno(file); }
1993inline int Stat(
const char* path, StatStruct* buf) {
return _stat(path, buf); }
1994inline int RmDir(
const char* dir) {
return _rmdir(dir); }
1995inline bool IsDir(
const StatStruct& st) {
return (_S_IFDIR & st.st_mode) != 0; }
1998#elif GTEST_OS_ESP8266
1999typedef struct stat StatStruct;
2001inline int FileNo(FILE* file) {
return fileno(file); }
2002inline int DoIsATTY(
int fd) {
return isatty(fd); }
2003inline int Stat(
const char* path, StatStruct* buf) {
2007inline int StrCaseCmp(
const char* s1,
const char* s2) {
2008 return strcasecmp(s1, s2);
2010inline char* StrDup(
const char* src) {
return strdup(src); }
2011inline int RmDir(
const char* dir) {
return rmdir(dir); }
2012inline bool IsDir(
const StatStruct& st) {
return S_ISDIR(st.st_mode); }
2016typedef struct stat StatStruct;
2018inline int FileNo(FILE* file) {
return fileno(file); }
2019inline int DoIsATTY(
int fd) {
return isatty(fd); }
2020inline int Stat(
const char* path, StatStruct* buf) {
return stat(path, buf); }
2021inline int StrCaseCmp(
const char* s1,
const char* s2) {
2022 return strcasecmp(s1, s2);
2024inline char* StrDup(
const char* src) {
return strdup(src); }
2027inline int RmDir(
const char*) {
return 0; }
2029inline int RmDir(
const char* dir) {
return rmdir(dir); }
2031inline bool IsDir(
const StatStruct& st) {
return S_ISDIR(st.st_mode); }
2035inline int IsATTY(
int fd) {
2039 int savedErrno = errno;
2040 int isAttyValue = DoIsATTY(fd);
2048GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
2054#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && \
2055 !GTEST_OS_WINDOWS_RT && !GTEST_OS_ESP8266 && !GTEST_OS_XTENSA && \
2057inline int ChDir(
const char* dir) {
return chdir(dir); }
2059inline FILE* FOpen(
const char* path,
const char* mode) {
2060#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
2061 struct wchar_codecvt :
public std::codecvt<wchar_t, char, std::mbstate_t> {};
2062 std::wstring_convert<wchar_codecvt> converter;
2063 std::wstring wide_path = converter.from_bytes(path);
2064 std::wstring wide_mode = converter.from_bytes(mode);
2065 return _wfopen(wide_path.c_str(), wide_mode.c_str());
2067 return fopen(path, mode);
2070#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT
2071inline FILE* FReopen(
const char* path,
const char* mode, FILE* stream) {
2072 return freopen(path, mode, stream);
2074inline FILE* FDOpen(
int fd,
const char* mode) {
return fdopen(fd, mode); }
2076inline int FClose(FILE* fp) {
return fclose(fp); }
2077#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT
2078inline int Read(
int fd,
void* buf,
unsigned int count) {
2079 return static_cast<int>(read(fd, buf, count));
2081inline int Write(
int fd,
const void* buf,
unsigned int count) {
2082 return static_cast<int>(write(fd, buf, count));
2084inline int Close(
int fd) {
return close(fd); }
2085inline const char* StrError(
int errnum) {
return strerror(errnum); }
2087inline const char* GetEnv(
const char* name) {
2088#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
2089 GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA || \
2092 static_cast<void>(name);
2094#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
2097 const char*
const env = getenv(name);
2098 return (env !=
nullptr && env[0] !=
'\0') ? env :
nullptr;
2100 return getenv(name);
2104GTEST_DISABLE_MSC_DEPRECATED_POP_()
2106#if GTEST_OS_WINDOWS_MOBILE
2110[[noreturn]]
void Abort();
2112[[noreturn]]
inline void Abort() { abort(); }
2122#if _MSC_VER && !GTEST_OS_WINDOWS_MOBILE
2124#define GTEST_SNPRINTF_(buffer, size, format, ...) \
2125 _snprintf_s(buffer, size, size, format, __VA_ARGS__)
2126#elif defined(_MSC_VER)
2128#define GTEST_SNPRINTF_ _snprintf
2130#define GTEST_SNPRINTF_ snprintf
2136using BiggestInt =
long long;
2139constexpr BiggestInt kMaxBiggestInt = (std::numeric_limits<BiggestInt>::max)();
2159template <
size_t size>
2171 using Int = std::int32_t;
2172 using UInt = std::uint32_t;
2179 using Int = std::int64_t;
2180 using UInt = std::uint64_t;
2184using TimeInMillis = int64_t;
2189#if !defined(GTEST_FLAG)
2190#define GTEST_FLAG_NAME_(name) gtest_##name
2191#define GTEST_FLAG(name) FLAGS_gtest_##name
2198#define GTEST_DEFINE_bool_(name, default_val, doc) \
2199 ABSL_FLAG(bool, GTEST_FLAG_NAME_(name), default_val, doc)
2200#define GTEST_DEFINE_int32_(name, default_val, doc) \
2201 ABSL_FLAG(int32_t, GTEST_FLAG_NAME_(name), default_val, doc)
2202#define GTEST_DEFINE_string_(name, default_val, doc) \
2203 ABSL_FLAG(std::string, GTEST_FLAG_NAME_(name), default_val, doc)
2206#define GTEST_DECLARE_bool_(name) \
2207 ABSL_DECLARE_FLAG(bool, GTEST_FLAG_NAME_(name))
2208#define GTEST_DECLARE_int32_(name) \
2209 ABSL_DECLARE_FLAG(int32_t, GTEST_FLAG_NAME_(name))
2210#define GTEST_DECLARE_string_(name) \
2211 ABSL_DECLARE_FLAG(std::string, GTEST_FLAG_NAME_(name))
2213#define GTEST_FLAG_SAVER_ ::absl::FlagSaver
2215#define GTEST_FLAG_GET(name) ::absl::GetFlag(GTEST_FLAG(name))
2216#define GTEST_FLAG_SET(name, value) \
2217 (void)(::absl::SetFlag(>EST_FLAG(name), value))
2218#define GTEST_USE_OWN_FLAGFILE_FLAG_ 0
2223#define GTEST_DEFINE_bool_(name, default_val, doc) \
2224 namespace testing { \
2225 GTEST_API_ bool GTEST_FLAG(name) = (default_val); \
2227 static_assert(true, "no-op to require trailing semicolon")
2228#define GTEST_DEFINE_int32_(name, default_val, doc) \
2229 namespace testing { \
2230 GTEST_API_ std::int32_t GTEST_FLAG(name) = (default_val); \
2232 static_assert(true, "no-op to require trailing semicolon")
2233#define GTEST_DEFINE_string_(name, default_val, doc) \
2234 namespace testing { \
2235 GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val); \
2237 static_assert(true, "no-op to require trailing semicolon")
2240#define GTEST_DECLARE_bool_(name) \
2241 namespace testing { \
2242 GTEST_API_ extern bool GTEST_FLAG(name); \
2244 static_assert(true, "no-op to require trailing semicolon")
2245#define GTEST_DECLARE_int32_(name) \
2246 namespace testing { \
2247 GTEST_API_ extern std::int32_t GTEST_FLAG(name); \
2249 static_assert(true, "no-op to require trailing semicolon")
2250#define GTEST_DECLARE_string_(name) \
2251 namespace testing { \
2252 GTEST_API_ extern ::std::string GTEST_FLAG(name); \
2254 static_assert(true, "no-op to require trailing semicolon")
2256#define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
2258#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
2259#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
2260#define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
2265#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
2266#define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
2267#define GTEST_LOCK_EXCLUDED_(locks)
2273GTEST_API_
bool ParseInt32(
const Message& src_text,
const char* str,
2278bool BoolFromGTestEnv(
const char* flag,
bool default_val);
2279GTEST_API_ int32_t Int32FromGTestEnv(
const char* flag, int32_t default_val);
2280std::string OutputFlagAlsoCheckEnvVar();
2281const char* StringFromGTestEnv(
const char* flag,
const char* default_val);
2286#if !defined(GTEST_INTERNAL_DEPRECATED)
2296#if defined(_MSC_VER)
2297#define GTEST_INTERNAL_DEPRECATED(message) __declspec(deprecated(message))
2298#elif defined(__GNUC__)
2299#define GTEST_INTERNAL_DEPRECATED(message) __attribute__((deprecated(message)))
2301#define GTEST_INTERNAL_DEPRECATED(message)
2309#define GTEST_INTERNAL_HAS_ANY 1
2310#include "absl/types/any.h"
2313using Any = ::absl::any;
2318#if __has_include(<any>) && __cplusplus >= 201703L
2321#define GTEST_INTERNAL_HAS_ANY 1
2325using Any = ::std::any;
2337#define GTEST_INTERNAL_HAS_OPTIONAL 1
2338#include "absl/types/optional.h"
2341template <
typename T>
2342using Optional = ::absl::optional<T>;
2343inline ::absl::nullopt_t Nullopt() { return ::absl::nullopt; }
2348#if __has_include(<optional>) && __cplusplus >= 201703L
2351#define GTEST_INTERNAL_HAS_OPTIONAL 1
2355template <
typename T>
2356using Optional = ::std::optional<T>;
2357inline ::std::nullopt_t Nullopt() { return ::std::nullopt; }
2369#define GTEST_INTERNAL_HAS_STRING_VIEW 1
2370#include "absl/strings/string_view.h"
2373using StringView = ::absl::string_view;
2378#if __has_include(<string_view>) && __cplusplus >= 201703L
2381#define GTEST_INTERNAL_HAS_STRING_VIEW 1
2382#include <string_view>
2385using StringView = ::std::string_view;
2397#define GTEST_INTERNAL_HAS_VARIANT 1
2398#include "absl/types/variant.h"
2401template <
typename... T>
2402using Variant = ::absl::variant<T...>;
2407#if __has_include(<variant>) && __cplusplus >= 201703L
2410#define GTEST_INTERNAL_HAS_VARIANT 1
2414template <
typename... T>
2415using Variant = ::std::variant<T...>;
Definition gtest_unittest.cc:5101
Definition gtest-message.h:92
Definition gtest-port.h:963
Definition gtest-port.h:1860
Definition gtest-port.h:1842
Definition gtest-port.h:894
Definition gtest-port.h:1868
Definition googletest-port-test.cc:194
Definition gtest-port.h:2160
Definition gtest-port.h:1035