43 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 44 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ 265 # include <sys/types.h> 266 # include <sys/stat.h> 267 #endif // !_WIN32_WCE 269 #if defined __APPLE__ 270 # include <AvailabilityMacros.h> 271 # include <TargetConditionals.h> 281 #include "gtest/internal/gtest-port-arch.h" 282 #include "gtest/internal/custom/gtest-port.h" 284 #if !defined(GTEST_DEV_EMAIL_) 285 # define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com" 286 # define GTEST_FLAG_PREFIX_ "gtest_" 287 # define GTEST_FLAG_PREFIX_DASH_ "gtest-" 288 # define GTEST_FLAG_PREFIX_UPPER_ "GTEST_" 289 # define GTEST_NAME_ "Google Test" 290 # define GTEST_PROJECT_URL_ "https://github.com/google/googletest/" 291 #endif // !defined(GTEST_DEV_EMAIL_) 293 #if !defined(GTEST_INIT_GOOGLE_TEST_NAME_) 294 # define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest" 295 #endif // !defined(GTEST_INIT_GOOGLE_TEST_NAME_) 300 # define GTEST_GCC_VER_ \ 301 (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__) 310 # define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \ 311 __pragma(warning(push)) \ 312 __pragma(warning(disable: warnings)) 313 # define GTEST_DISABLE_MSC_WARNINGS_POP_() \ 314 __pragma(warning(pop)) 317 # define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) 318 # define GTEST_DISABLE_MSC_WARNINGS_POP_() 321 #ifndef GTEST_LANG_CXX11 326 # if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L 328 # define GTEST_LANG_CXX11 1 330 # define GTEST_LANG_CXX11 0 343 #if GTEST_LANG_CXX11 && \ 344 (!defined(__GLIBCXX__) || ( \ 345 __GLIBCXX__ >= 20110325ul && \ 347 __GLIBCXX__ != 20110416ul && \ 348 __GLIBCXX__ != 20120313ul && \ 349 __GLIBCXX__ != 20110428ul && \ 350 __GLIBCXX__ != 20120702ul)) 351 # define GTEST_STDLIB_CXX11 1 355 #if GTEST_STDLIB_CXX11 356 # define GTEST_HAS_STD_BEGIN_AND_END_ 1 357 # define GTEST_HAS_STD_FORWARD_LIST_ 1 358 # define GTEST_HAS_STD_FUNCTION_ 1 359 # define GTEST_HAS_STD_INITIALIZER_LIST_ 1 360 # define GTEST_HAS_STD_MOVE_ 1 361 # define GTEST_HAS_STD_SHARED_PTR_ 1 362 # define GTEST_HAS_STD_TYPE_TRAITS_ 1 363 # define GTEST_HAS_STD_UNIQUE_PTR_ 1 369 # define GTEST_HAS_STD_TUPLE_ 1 370 # if defined(__clang__) 372 # if defined(__has_include) && !__has_include(<tuple>) 373 # undef GTEST_HAS_STD_TUPLE_ 375 # elif defined(_MSC_VER) 377 # if defined(_CPPLIB_VER) && _CPPLIB_VER < 520 378 # undef GTEST_HAS_STD_TUPLE_ 380 # elif defined(__GLIBCXX__) 384 # if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2) 385 # undef GTEST_HAS_STD_TUPLE_ 394 # if !GTEST_OS_WINDOWS_MOBILE 402 struct _RTL_CRITICAL_SECTION;
408 # include <strings.h> 409 #endif // GTEST_OS_WINDOWS 411 #if GTEST_OS_LINUX_ANDROID 413 # include <android/api-level.h> 417 #ifndef GTEST_HAS_POSIX_RE 418 # if GTEST_OS_LINUX_ANDROID 420 # define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9) 422 # define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS) 429 #elif GTEST_HAS_POSIX_RE 437 # define GTEST_USES_POSIX_RE 1 439 #elif GTEST_OS_WINDOWS 443 # define GTEST_USES_SIMPLE_RE 1 449 # define GTEST_USES_SIMPLE_RE 1 451 #endif // GTEST_USES_PCRE 453 #ifndef GTEST_HAS_EXCEPTIONS 456 # if defined(_MSC_VER) || defined(__BORLANDC__) 460 # ifndef _HAS_EXCEPTIONS 461 # define _HAS_EXCEPTIONS 1 462 # endif // _HAS_EXCEPTIONS 463 # define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS 464 # elif defined(__clang__) 472 # define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions)) 473 # elif defined(__GNUC__) && __EXCEPTIONS 475 # define GTEST_HAS_EXCEPTIONS 1 476 # elif defined(__SUNPRO_CC) 480 # define GTEST_HAS_EXCEPTIONS 1 481 # elif defined(__IBMCPP__) && __EXCEPTIONS 483 # define GTEST_HAS_EXCEPTIONS 1 484 # elif defined(__HP_aCC) 487 # define GTEST_HAS_EXCEPTIONS 1 491 # define GTEST_HAS_EXCEPTIONS 0 492 # endif // defined(_MSC_VER) || defined(__BORLANDC__) 493 #endif // GTEST_HAS_EXCEPTIONS 495 #if !defined(GTEST_HAS_STD_STRING) 498 # define GTEST_HAS_STD_STRING 1 499 #elif !GTEST_HAS_STD_STRING 501 # error "Google Test cannot be used where ::std::string isn't available." 502 #endif // !defined(GTEST_HAS_STD_STRING) 504 #ifndef GTEST_HAS_GLOBAL_STRING 508 # define GTEST_HAS_GLOBAL_STRING 0 510 #endif // GTEST_HAS_GLOBAL_STRING 512 #ifndef GTEST_HAS_STD_WSTRING 521 # define GTEST_HAS_STD_WSTRING \ 522 (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS)) 524 #endif // GTEST_HAS_STD_WSTRING 526 #ifndef GTEST_HAS_GLOBAL_WSTRING 529 # define GTEST_HAS_GLOBAL_WSTRING \ 530 (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING) 531 #endif // GTEST_HAS_GLOBAL_WSTRING 534 #ifndef GTEST_HAS_RTTI 540 # ifdef _CPPRTTI // MSVC defines this macro iff RTTI is enabled. 541 # define GTEST_HAS_RTTI 1 543 # define GTEST_HAS_RTTI 0 547 # elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302) 554 # if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \ 555 !defined(__EXCEPTIONS) 556 # define GTEST_HAS_RTTI 0 558 # define GTEST_HAS_RTTI 1 559 # endif // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS 561 # define GTEST_HAS_RTTI 0 562 # endif // __GXX_RTTI 567 # elif defined(__clang__) 569 # define GTEST_HAS_RTTI __has_feature(cxx_rtti) 573 # elif defined(__IBMCPP__) && (__IBMCPP__ >= 900) 576 # define GTEST_HAS_RTTI 1 578 # define GTEST_HAS_RTTI 0 584 # define GTEST_HAS_RTTI 1 588 #endif // GTEST_HAS_RTTI 597 #ifndef GTEST_HAS_PTHREAD 603 # define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX \ 604 || GTEST_OS_QNX || GTEST_OS_FREEBSD || GTEST_OS_NACL) 605 #endif // GTEST_HAS_PTHREAD 607 #if GTEST_HAS_PTHREAD 610 # include <pthread.h> 618 #if !defined(GTEST_HAS_HASH_MAP_) 620 # define GTEST_HAS_HASH_MAP_ 1 // Indicates that hash_map is available. 621 # define GTEST_HAS_HASH_SET_ 1 // Indicates that hash_set is available. 623 #endif // !defined(GTEST_HAS_HASH_MAP_) 628 #ifndef GTEST_HAS_TR1_TUPLE 629 # if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) 631 # define GTEST_HAS_TR1_TUPLE 0 634 # define GTEST_HAS_TR1_TUPLE 1 636 #endif // GTEST_HAS_TR1_TUPLE 640 #ifndef GTEST_USE_OWN_TR1_TUPLE 653 # if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \ 654 && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) || _MSC_VER >= 1600 655 # define GTEST_ENV_HAS_TR1_TUPLE_ 1 661 # if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325) 662 # define GTEST_ENV_HAS_STD_TUPLE_ 1 665 # if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_ 666 # define GTEST_USE_OWN_TR1_TUPLE 0 668 # define GTEST_USE_OWN_TR1_TUPLE 1 671 #endif // GTEST_USE_OWN_TR1_TUPLE 676 #if GTEST_HAS_STD_TUPLE_ 678 # define GTEST_TUPLE_NAMESPACE_ ::std 679 #endif // GTEST_HAS_STD_TUPLE_ 683 #if GTEST_HAS_TR1_TUPLE 684 # ifndef GTEST_TUPLE_NAMESPACE_ 685 # define GTEST_TUPLE_NAMESPACE_ ::std::tr1 686 # endif // GTEST_TUPLE_NAMESPACE_ 688 # if GTEST_USE_OWN_TR1_TUPLE 689 # include "gtest/internal/gtest-tuple.h" 690 # elif GTEST_ENV_HAS_STD_TUPLE_ 701 using ::std::tuple_element;
702 using ::std::tuple_size;
706 # elif GTEST_OS_SYMBIAN 713 # ifdef BOOST_HAS_TR1_TUPLE 714 # undef BOOST_HAS_TR1_TUPLE 715 # endif // BOOST_HAS_TR1_TUPLE 719 # define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED 722 # elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000) 726 # if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 732 # define _TR1_FUNCTIONAL 1 733 # include <tr1/tuple> 734 # undef _TR1_FUNCTIONAL // Allows the user to #include 737 # include <tr1/tuple> 738 # endif // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 744 # endif // GTEST_USE_OWN_TR1_TUPLE 746 #endif // GTEST_HAS_TR1_TUPLE 752 #ifndef GTEST_HAS_CLONE 755 # if GTEST_OS_LINUX && !defined(__ia64__) 756 # if GTEST_OS_LINUX_ANDROID 758 # if defined(__arm__) && __ANDROID_API__ >= 9 759 # define GTEST_HAS_CLONE 1 761 # define GTEST_HAS_CLONE 0 764 # define GTEST_HAS_CLONE 1 767 # define GTEST_HAS_CLONE 0 768 # endif // GTEST_OS_LINUX && !defined(__ia64__) 770 #endif // GTEST_HAS_CLONE 774 #ifndef GTEST_HAS_STREAM_REDIRECTION 777 # if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || \ 778 GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT 779 # define GTEST_HAS_STREAM_REDIRECTION 0 781 # define GTEST_HAS_STREAM_REDIRECTION 1 782 # endif // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN 783 #endif // GTEST_HAS_STREAM_REDIRECTION 789 #if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ 790 (GTEST_OS_MAC && !GTEST_OS_IOS) || \ 791 (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \ 792 GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \ 793 GTEST_OS_OPENBSD || GTEST_OS_QNX || GTEST_OS_FREEBSD || \ 795 # define GTEST_HAS_DEATH_TEST 1 801 #define GTEST_HAS_PARAM_TEST 1 807 #if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \ 808 defined(__IBMCPP__) || defined(__HP_aCC) 809 # define GTEST_HAS_TYPED_TEST 1 810 # define GTEST_HAS_TYPED_TEST_P 1 817 #if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC) 818 # define GTEST_HAS_COMBINE 1 822 #define GTEST_WIDE_STRING_USES_UTF16_ \ 823 (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX) 827 # define GTEST_CAN_STREAM_RESULTS_ 1 840 #ifdef __INTEL_COMPILER 841 # define GTEST_AMBIGUOUS_ELSE_BLOCKER_ 843 # define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default: // NOLINT 857 #if defined(__GNUC__) && !defined(COMPILER_ICC) 858 # define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) 859 #elif defined(__clang__) 860 # if __has_attribute(unused) 861 # define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) 864 #ifndef GTEST_ATTRIBUTE_UNUSED_ 865 # define GTEST_ATTRIBUTE_UNUSED_ 870 #define GTEST_DISALLOW_ASSIGN_(type)\ 871 void operator=(type const &) 875 #define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\ 877 GTEST_DISALLOW_ASSIGN_(type) 884 #if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC) 885 # define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result)) 887 # define GTEST_MUST_USE_RESULT_ 888 #endif // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC 898 # define GTEST_INTENTIONAL_CONST_COND_PUSH_() \ 899 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127) 900 # define GTEST_INTENTIONAL_CONST_COND_POP_() \ 901 GTEST_DISABLE_MSC_WARNINGS_POP_() 906 #ifndef GTEST_HAS_SEH 909 # if defined(_MSC_VER) || defined(__BORLANDC__) 911 # define GTEST_HAS_SEH 1 914 # define GTEST_HAS_SEH 0 917 #define GTEST_IS_THREADSAFE \ 918 (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ \ 919 || (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) \ 920 || GTEST_HAS_PTHREAD) 922 #endif // GTEST_HAS_SEH 925 # if GTEST_LINKED_AS_SHARED_LIBRARY 926 # define GTEST_API_ __declspec(dllimport) 927 # elif GTEST_CREATE_SHARED_LIBRARY 928 # define GTEST_API_ __declspec(dllexport) 930 #elif __GNUC__ >= 4 || defined(__clang__) 931 # define GTEST_API_ __attribute__((visibility ("default"))) 940 # define GTEST_NO_INLINE_ __attribute__((noinline)) 942 # define GTEST_NO_INLINE_ 946 #if defined(__GLIBCXX__) || defined(_LIBCPP_VERSION) 947 # define GTEST_HAS_CXXABI_H_ 1 949 # define GTEST_HAS_CXXABI_H_ 0 954 #if defined(__clang__) 955 # if __has_feature(memory_sanitizer) 956 # define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \ 957 __attribute__((no_sanitize_memory)) 959 # define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ 960 # endif // __has_feature(memory_sanitizer) 962 # define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ 966 #if defined(__clang__) 967 # if __has_feature(address_sanitizer) 968 # define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \ 969 __attribute__((no_sanitize_address)) 971 # define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ 972 # endif // __has_feature(address_sanitizer) 974 # define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ 978 #if defined(__clang__) 979 # if __has_feature(thread_sanitizer) 980 # define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \ 981 __attribute__((no_sanitize_thread)) 983 # define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ 984 # endif // __has_feature(thread_sanitizer) 986 # define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ 993 #if defined(GTEST_TUPLE_NAMESPACE_) 999 using GTEST_TUPLE_NAMESPACE_::tuple;
1000 using GTEST_TUPLE_NAMESPACE_::tuple_size;
1001 using GTEST_TUPLE_NAMESPACE_::tuple_element;
1002 #endif // defined(GTEST_TUPLE_NAMESPACE_) 1026 #if GTEST_LANG_CXX11 1027 # define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg) 1028 #else // !GTEST_LANG_CXX11 1030 struct CompileAssert {
1033 # define GTEST_COMPILE_ASSERT_(expr, msg) \ 1034 typedef ::testing::internal::CompileAssert<(static_cast<bool>(expr))> \ 1035 msg[static_cast<bool>(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_ 1036 #endif // !GTEST_LANG_CXX11 1084 template <
typename T1,
typename T2>
1085 struct StaticAssertTypeEqHelper;
1087 template <
typename T>
1088 struct StaticAssertTypeEqHelper<
T,
T> {
1089 enum {
value =
true };
1093 #define GTEST_ARRAY_SIZE_(array) (sizeof(array) / sizeof(array[0])) 1095 #if GTEST_HAS_GLOBAL_STRING 1099 #endif // GTEST_HAS_GLOBAL_STRING 1101 #if GTEST_HAS_GLOBAL_WSTRING 1103 #elif GTEST_HAS_STD_WSTRING 1105 #endif // GTEST_HAS_GLOBAL_WSTRING 1115 template <
typename T>
1125 T*
get()
const {
return ptr_; }
1128 T*
const ptr = ptr_;
1144 swap(
a.ptr_, b.ptr_);
1166 #if GTEST_HAS_GLOBAL_STRING 1170 #endif // GTEST_HAS_GLOBAL_STRING 1172 RE(
const char* regex) { Init(regex); }
1186 return FullMatch(str.c_str(), re);
1189 return PartialMatch(str.c_str(), re);
1192 #if GTEST_HAS_GLOBAL_STRING 1195 return FullMatch(str.c_str(), re);
1198 return PartialMatch(str.c_str(), re);
1201 #endif // GTEST_HAS_GLOBAL_STRING 1203 static bool FullMatch(
const char* str,
const RE& re);
1204 static bool PartialMatch(
const char* str,
const RE& re);
1207 void Init(
const char* regex);
1212 const char* pattern_;
1215 #if GTEST_USES_POSIX_RE 1217 regex_t full_regex_;
1218 regex_t partial_regex_;
1220 #else // GTEST_USES_SIMPLE_RE 1222 const char* full_pattern_;
1270 #if !defined(GTEST_LOG_) 1272 # define GTEST_LOG_(severity) \ 1273 ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ 1274 __FILE__, __LINE__).GetStream() 1279 #endif // !defined(GTEST_LOG_) 1281 #if !defined(GTEST_CHECK_) 1296 # define GTEST_CHECK_(condition) \ 1297 GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ 1298 if (::testing::internal::IsTrue(condition)) \ 1301 GTEST_LOG_(FATAL) << "Condition " #condition " failed. " 1302 #endif // !defined(GTEST_CHECK_) 1309 #define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \ 1310 if (const int gtest_error = (posix_call)) \ 1311 GTEST_LOG_(FATAL) << #posix_call << "failed with error " \ 1314 #if GTEST_HAS_STD_MOVE_ 1316 #else // GTEST_HAS_STD_MOVE_ 1317 template <
typename T>
1318 const T&
move(
const T& t) {
1321 #endif // GTEST_HAS_STD_MOVE_ 1343 template<
typename To>
1367 template<
typename To,
typename From>
1382 GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL);
1384 return static_cast<To
>(f);
1392 template <
class Derived,
class Base>
1398 #if GTEST_HAS_DOWNCAST_ 1399 return ::down_cast<Derived*>(base);
1400 #elif GTEST_HAS_RTTI 1401 return dynamic_cast<Derived*
>(base);
1403 return static_cast<Derived*
>(base);
1407 #if GTEST_HAS_STREAM_REDIRECTION 1420 #endif // GTEST_HAS_STREAM_REDIRECTION 1434 #if GTEST_HAS_DEATH_TEST 1436 const ::std::vector<testing::internal::string>& GetInjectableArgvs();
1437 void SetInjectableArgvs(const ::std::vector<testing::internal::string>*
1441 #endif // GTEST_HAS_DEATH_TEST 1444 #if GTEST_IS_THREADSAFE 1445 # if GTEST_HAS_PTHREAD 1449 inline void SleepMilliseconds(
int n) {
1450 const timespec
time = {
1454 nanosleep(&
time, NULL);
1456 # endif // GTEST_HAS_PTHREAD 1458 # if GTEST_HAS_NOTIFICATION_ 1462 # elif GTEST_HAS_PTHREAD 1469 class Notification {
1471 Notification() : notified_(
false) {
1475 pthread_mutex_destroy(&mutex_);
1481 pthread_mutex_lock(&mutex_);
1483 pthread_mutex_unlock(&mutex_);
1488 void WaitForNotification() {
1490 pthread_mutex_lock(&mutex_);
1491 const bool notified = notified_;
1492 pthread_mutex_unlock(&mutex_);
1495 SleepMilliseconds(10);
1500 pthread_mutex_t mutex_;
1506 # elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT 1519 typedef void* Handle;
1521 explicit AutoHandle(Handle handle);
1527 void Reset(Handle handle);
1531 bool IsCloseable()
const;
1548 void WaitForNotification();
1555 # endif // GTEST_HAS_NOTIFICATION_ 1557 # if GTEST_HAS_PTHREAD 1564 class ThreadWithParamBase {
1566 virtual ~ThreadWithParamBase() {}
1567 virtual void Run() = 0;
1576 extern "C" inline void* ThreadFuncWithCLinkage(
void* thread) {
1577 static_cast<ThreadWithParamBase*
>(thread)->Run();
1593 template <
typename T>
1594 class ThreadWithParam :
public ThreadWithParamBase {
1596 typedef void UserThreadFunc(
T);
1598 ThreadWithParam(UserThreadFunc* func,
T param, Notification* thread_can_start)
1601 thread_can_start_(thread_can_start),
1603 ThreadWithParamBase*
const base =
this;
1607 pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base));
1609 ~ThreadWithParam() { Join(); }
1618 virtual void Run() {
1619 if (thread_can_start_ != NULL)
1620 thread_can_start_->WaitForNotification();
1625 UserThreadFunc*
const func_;
1629 Notification*
const thread_can_start_;
1635 # endif // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD || 1638 # if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ 1642 # elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT 1660 enum MutexType { kStatic = 0, kDynamic = 1 };
1664 enum StaticConstructorSelector { kStaticMutex = 0 };
1669 explicit Mutex(StaticConstructorSelector ) {}
1684 void ThreadSafeLazyInit();
1688 unsigned int owner_thread_id_;
1693 long critical_section_init_phase_;
1694 _RTL_CRITICAL_SECTION* critical_section_;
1699 # define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ 1700 extern ::testing::internal::Mutex mutex 1702 # define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ 1703 ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex) 1710 class GTestMutexLock {
1713 : mutex_(mutex) { mutex_->Lock(); }
1718 Mutex*
const mutex_;
1727 class ThreadLocalValueHolderBase {
1729 virtual ~ThreadLocalValueHolderBase() {}
1734 class ThreadLocalBase {
1740 virtual ThreadLocalValueHolderBase* NewValueForCurrentThread()
const = 0;
1743 ThreadLocalBase() {}
1744 virtual ~ThreadLocalBase() {}
1757 static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
1758 const ThreadLocalBase* thread_local_instance);
1761 static void OnThreadLocalDestroyed(
1762 const ThreadLocalBase* thread_local_instance);
1772 virtual ~Runnable() {}
1773 virtual void Run() = 0;
1776 ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start);
1777 virtual ~ThreadWithParamBase();
1784 template <
typename T>
1785 class ThreadWithParam :
public ThreadWithParamBase {
1787 typedef void UserThreadFunc(
T);
1789 ThreadWithParam(UserThreadFunc* func,
T param, Notification* thread_can_start)
1790 : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {
1792 virtual ~ThreadWithParam() {}
1795 class RunnableImpl :
public Runnable {
1797 RunnableImpl(UserThreadFunc* func,
T param)
1801 virtual ~RunnableImpl() {}
1802 virtual void Run() {
1807 UserThreadFunc*
const func_;
1843 template <
typename T>
1844 class ThreadLocal :
public ThreadLocalBase {
1846 ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {}
1848 : default_factory_(new InstanceValueHolderFactory(
value)) {}
1850 ~
ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(
this); }
1852 T*
pointer() {
return GetOrCreateValue(); }
1853 const T*
pointer()
const {
return GetOrCreateValue(); }
1854 const T&
get()
const {
return *
pointer(); }
1860 class ValueHolder :
public ThreadLocalValueHolderBase {
1862 ValueHolder() : value_() {}
1863 explicit ValueHolder(
const T&
value) : value_(
value) {}
1873 T* GetOrCreateValue()
const {
1874 return static_cast<ValueHolder*
>(
1875 ThreadLocalRegistry::GetValueOnCurrentThread(
this))->
pointer();
1878 virtual ThreadLocalValueHolderBase* NewValueForCurrentThread()
const {
1879 return default_factory_->MakeNewHolder();
1882 class ValueHolderFactory {
1884 ValueHolderFactory() {}
1885 virtual ~ValueHolderFactory() {}
1886 virtual ValueHolder* MakeNewHolder()
const = 0;
1892 class DefaultValueHolderFactory :
public ValueHolderFactory {
1894 DefaultValueHolderFactory() {}
1895 virtual ValueHolder* MakeNewHolder()
const {
return new ValueHolder(); }
1901 class InstanceValueHolderFactory :
public ValueHolderFactory {
1903 explicit InstanceValueHolderFactory(
const T&
value) : value_(
value) {}
1904 virtual ValueHolder* MakeNewHolder()
const {
1905 return new ValueHolder(value_);
1914 scoped_ptr<ValueHolderFactory> default_factory_;
1919 # elif GTEST_HAS_PTHREAD 1927 owner_ = pthread_self();
1943 void AssertHeld()
const {
1944 GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
1945 <<
"The current thread is not holding the mutex @" <<
this;
1954 pthread_mutex_t mutex_;
1966 # define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ 1967 extern ::testing::internal::MutexBase mutex 1970 # define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ 1971 ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, false, pthread_t() } 1975 class Mutex :
public MutexBase {
1994 class GTestMutexLock {
1997 : mutex_(mutex) { mutex_->Lock(); }
2002 MutexBase*
const mutex_;
2015 class ThreadLocalValueHolderBase {
2017 virtual ~ThreadLocalValueHolderBase() {}
2022 extern "C" inline void DeleteThreadLocalValue(
void* value_holder) {
2023 delete static_cast<ThreadLocalValueHolderBase*
>(value_holder);
2027 template <
typename T>
2031 : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
2033 : key_(CreateKey()),
2034 default_factory_(new InstanceValueHolderFactory(
value)) {}
2038 DeleteThreadLocalValue(pthread_getspecific(key_));
2045 T*
pointer() {
return GetOrCreateValue(); }
2046 const T*
pointer()
const {
return GetOrCreateValue(); }
2047 const T&
get()
const {
return *
pointer(); }
2052 class ValueHolder :
public ThreadLocalValueHolderBase {
2054 ValueHolder() : value_() {}
2055 explicit ValueHolder(
const T&
value) : value_(
value) {}
2064 static pthread_key_t CreateKey() {
2069 pthread_key_create(&
key, &DeleteThreadLocalValue));
2073 T* GetOrCreateValue()
const {
2074 ThreadLocalValueHolderBase*
const holder =
2075 static_cast<ThreadLocalValueHolderBase*
>(pthread_getspecific(key_));
2076 if (holder != NULL) {
2077 return CheckedDowncastToActualType<ValueHolder>(holder)->
pointer();
2080 ValueHolder*
const new_holder = default_factory_->MakeNewHolder();
2081 ThreadLocalValueHolderBase*
const holder_base = new_holder;
2083 return new_holder->pointer();
2086 class ValueHolderFactory {
2088 ValueHolderFactory() {}
2089 virtual ~ValueHolderFactory() {}
2090 virtual ValueHolder* MakeNewHolder()
const = 0;
2096 class DefaultValueHolderFactory :
public ValueHolderFactory {
2098 DefaultValueHolderFactory() {}
2099 virtual ValueHolder* MakeNewHolder()
const {
return new ValueHolder(); }
2105 class InstanceValueHolderFactory :
public ValueHolderFactory {
2107 explicit InstanceValueHolderFactory(
const T&
value) : value_(
value) {}
2108 virtual ValueHolder* MakeNewHolder()
const {
2109 return new ValueHolder(value_);
2119 const pthread_key_t key_;
2120 scoped_ptr<ValueHolderFactory> default_factory_;
2125 # endif // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ 2127 #else // GTEST_IS_THREADSAFE 2142 # define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ 2143 extern ::testing::internal::Mutex mutex 2145 # define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex 2152 class GTestMutexLock {
2159 template <
typename T>
2166 const T&
get()
const {
return value_; }
2172 #endif // GTEST_IS_THREADSAFE 2184 #if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC) 2187 # define GTEST_ELLIPSIS_NEEDS_POD_ 1 2189 # define GTEST_CAN_COMPARE_NULL 1 2196 #if defined(__SYMBIAN32__) || defined(__IBMCPP__) 2197 # define GTEST_NEEDS_IS_POINTER_ 1 2200 template <
bool bool_value>
2201 struct bool_constant {
2203 static const bool value = bool_value;
2210 template <
typename T>
2213 template <
typename T>
2216 template <
typename Iterator>
2217 struct IteratorTraits {
2221 template <
typename T>
2226 template <
typename T>
2231 #if GTEST_OS_WINDOWS 2232 # define GTEST_PATH_SEP_ "\\" 2233 # define GTEST_HAS_ALT_PATH_SEP_ 1 2237 # define GTEST_PATH_SEP_ "/" 2238 # define GTEST_HAS_ALT_PATH_SEP_ 0 2240 #endif // GTEST_OS_WINDOWS 2249 inline bool IsAlpha(
char ch) {
2250 return isalpha(static_cast<unsigned char>(ch)) != 0;
2252 inline bool IsAlNum(
char ch) {
2253 return isalnum(static_cast<unsigned char>(ch)) != 0;
2255 inline bool IsDigit(
char ch) {
2256 return isdigit(static_cast<unsigned char>(ch)) != 0;
2258 inline bool IsLower(
char ch) {
2259 return islower(static_cast<unsigned char>(ch)) != 0;
2261 inline bool IsSpace(
char ch) {
2262 return isspace(static_cast<unsigned char>(ch)) != 0;
2264 inline bool IsUpper(
char ch) {
2265 return isupper(static_cast<unsigned char>(ch)) != 0;
2268 return isxdigit(static_cast<unsigned char>(ch)) != 0;
2271 const unsigned char low_byte =
static_cast<unsigned char>(ch);
2272 return ch == low_byte && isxdigit(low_byte) != 0;
2275 inline char ToLower(
char ch) {
2276 return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
2278 inline char ToUpper(
char ch) {
2279 return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
2283 std::string::iterator it = str.end();
2284 while (it != str.begin() &&
IsSpace(*--it))
2299 #if GTEST_OS_WINDOWS 2303 # ifdef __BORLANDC__ 2304 inline int IsATTY(
int fd) {
return isatty(fd); }
2305 inline int StrCaseCmp(
const char* s1,
const char* s2) {
2306 return stricmp(s1, s2);
2308 inline char*
StrDup(
const char* src) {
return strdup(src); }
2309 # else // !__BORLANDC__ 2310 # if GTEST_OS_WINDOWS_MOBILE 2311 inline int IsATTY(
int ) {
return 0; }
2313 inline int IsATTY(
int fd) {
return _isatty(fd); }
2314 # endif // GTEST_OS_WINDOWS_MOBILE 2315 inline int StrCaseCmp(
const char* s1,
const char* s2) {
2316 return _stricmp(s1, s2);
2318 inline char*
StrDup(
const char* src) {
return _strdup(src); }
2319 # endif // __BORLANDC__ 2321 # if GTEST_OS_WINDOWS_MOBILE 2322 inline int FileNo(FILE* file) {
return reinterpret_cast<int>(_fileno(file)); }
2326 inline int FileNo(FILE* file) {
return _fileno(file); }
2328 inline int RmDir(
const char* dir) {
return _rmdir(dir); }
2330 return (_S_IFDIR & st.st_mode) != 0;
2332 # endif // GTEST_OS_WINDOWS_MOBILE 2338 inline int FileNo(FILE* file) {
return fileno(file); }
2339 inline int IsATTY(
int fd) {
return isatty(fd); }
2341 inline int StrCaseCmp(
const char* s1,
const char* s2) {
2342 return strcasecmp(s1, s2);
2344 inline char*
StrDup(
const char* src) {
return strdup(src); }
2345 inline int RmDir(
const char* dir) {
return rmdir(dir); }
2346 inline bool IsDir(
const StatStruct& st) {
return S_ISDIR(st.st_mode); }
2348 #endif // GTEST_OS_WINDOWS 2355 return strncpy(
dest, src, n);
2362 #if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT 2363 inline int ChDir(
const char* dir) {
return chdir(dir); }
2365 inline FILE*
FOpen(
const char* path,
const char* mode) {
2366 return fopen(path, mode);
2368 #if !GTEST_OS_WINDOWS_MOBILE 2369 inline FILE *
FReopen(
const char* path,
const char* mode, FILE* stream) {
2370 return freopen(path, mode, stream);
2372 inline FILE*
FDOpen(
int fd,
const char* mode) {
return fdopen(fd, mode); }
2374 inline int FClose(FILE* fp) {
return fclose(fp); }
2375 #if !GTEST_OS_WINDOWS_MOBILE 2376 inline int Read(
int fd,
void*
buf,
unsigned int count) {
2377 return static_cast<int>(read(fd,
buf,
count));
2379 inline int Write(
int fd,
const void*
buf,
unsigned int count) {
2380 return static_cast<int>(write(fd,
buf,
count));
2382 inline int Close(
int fd) {
return close(fd); }
2383 inline const char*
StrError(
int errnum) {
return strerror(errnum); }
2385 inline const char*
GetEnv(
const char*
name) {
2386 #if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE | GTEST_OS_WINDOWS_RT 2388 static_cast<void>(
name);
2390 #elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9) 2393 const char*
const env = getenv(
name);
2394 return (env != NULL && env[0] !=
'\0') ? env : NULL;
2396 return getenv(
name);
2402 #if GTEST_OS_WINDOWS_MOBILE 2408 inline void Abort() { abort(); }
2409 #endif // GTEST_OS_WINDOWS_MOBILE 2418 #if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE 2420 # define GTEST_SNPRINTF_(buffer, size, format, ...) \ 2421 _snprintf_s(buffer, size, size, format, __VA_ARGS__) 2422 #elif defined(_MSC_VER) 2425 # define GTEST_SNPRINTF_ _snprintf 2427 # define GTEST_SNPRINTF_ snprintf 2458 template <
size_t size>
2459 class TypeWithSize {
2482 #if GTEST_OS_WINDOWS 2483 typedef __int64 Int;
2484 typedef unsigned __int64
UInt;
2488 #endif // GTEST_OS_WINDOWS 2501 #if !defined(GTEST_FLAG) 2502 # define GTEST_FLAG(name) FLAGS_gtest_##name 2503 #endif // !defined(GTEST_FLAG) 2505 #if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_) 2506 # define GTEST_USE_OWN_FLAGFILE_FLAG_ 1 2507 #endif // !defined(GTEST_USE_OWN_FLAGFILE_FLAG_) 2509 #if !defined(GTEST_DECLARE_bool_) 2510 # define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver 2513 # define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name) 2514 # define GTEST_DECLARE_int32_(name) \ 2515 GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name) 2516 #define GTEST_DECLARE_string_(name) \ 2517 GTEST_API_ extern ::std::string GTEST_FLAG(name) 2520 #define GTEST_DEFINE_bool_(name, default_val, doc) \ 2521 GTEST_API_ bool GTEST_FLAG(name) = (default_val) 2522 #define GTEST_DEFINE_int32_(name, default_val, doc) \ 2523 GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val) 2524 #define GTEST_DEFINE_string_(name, default_val, doc) \ 2525 GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val) 2527 #endif // !defined(GTEST_DECLARE_bool_) 2530 #if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_) 2531 # define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks) 2532 # define GTEST_LOCK_EXCLUDED_(locks) 2533 #endif // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_) 2552 #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
const T * pointer() const
TypeWithSize< 8 >::Int Int64
#define GTEST_DISABLE_MSC_WARNINGS_POP_()
GTEST_API_ std::string GetCapturedStdout()
GTEST_API_ std::string GetCapturedStderr()
#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)
GTEST_API_ std::string TempDir()
char * StrDup(const char *src)
GTEST_API_ size_t GetThreadCount()
const char * pattern() const
#define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
static bool PartialMatch(const ::std::string &str, const RE &re)
GTEST_API_ bool IsTrue(bool condition)
CXA_THROW_INFO_T void(* dest)(void *))
TypeWithSize< 4 >::Int Int32
GTEST_API_ std::string ReadEntireFile(FILE *file)
FILE * FOpen(const char *path, const char *mode)
Derived * CheckedDowncastToActualType(Base *base)
std::string StringFromGTestEnv(const char *flag, const char *default_val)
GTEST_API_ ::std::string FormatFileLocation(const char *file, int line)
TypeWithSize< 4 >::UInt UInt32
bool_constant< bool_value > type
bool ParseInt32(const Message &src_text, const char *str, Int32 *value)
FILE * FReopen(const char *path, const char *mode, FILE *stream)
int Stat(const char *path, StatStruct *buf)
base::threading::internal::Mutex Mutex
int ChDir(const char *dir)
TypeWithSize< 8 >::UInt UInt64
GTEST_API_ void CaptureStdout()
ThreadLocal(const T &value)
GTEST_API_ size_t GetFileSize(FILE *file)
bool_constant< true > true_type
int Write(int fd, const void *buf, unsigned int count)
mdb_size_t count(MDB_cursor *cur)
::std::ostream & GetStream()
int RmDir(const char *dir)
static bool FullMatch(const ::std::string &str, const RE &re)
friend void swap(scoped_ptr &a, scoped_ptr &b)
int Read(int fd, void *buf, unsigned int count)
int StrCaseCmp(const char *s1, const char *s2)
const char * StrNCpy(char *dest, const char *src, size_t n)
bool IsDir(const StatStruct &st)
#define GTEST_INTENTIONAL_CONST_COND_PUSH_()
const GenericPointer< typename T::ValueType > T2 T::AllocatorType & a
GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char *file, int line)
FILE * FDOpen(int fd, const char *mode)
bool BoolFromGTestEnv(const char *flag, bool default_val)
const T & move(const T &t)
#define GTEST_CHECK_(condition)
const GenericPointer< typename T::ValueType > T2 value
const char * StrError(int errnum)
GTEST_API_ void CaptureStderr()
bool_constant< false > false_type
GTEST_API_ Int32 Int32FromGTestEnv(const char *flag, Int32 default_val)
RE(const ::std::string ®ex)
#define GTEST_INTENTIONAL_CONST_COND_POP_()
#define GTEST_DISALLOW_ASSIGN_(type)
TypeWithSize< 8 >::Int TimeInMillis
Iterator::value_type value_type
void get(std::istream &input, bool &res)
const char * GetEnv(const char *name)
#define GTEST_CHECK_POSIX_SUCCESS_(posix_call)
const BiggestInt kMaxBiggestInt
std::string StripTrailingSpaces(std::string str)
GTEST_API_ const ::std::vector< testing::internal::string > & GetArgvs()