deps: update googletest to 50b8600 · nodejs/node@05e560d

Mutex();

~Mutex();

void Lock();

void lock();

void Unlock();

void unlock();

// Does nothing if the current thread holds the mutex. Otherwise, crashes

// with high probability.

// "MutexLock l(&mu)". Hence the typedef trick below.

class GTestMutexLock {

public:

explicit GTestMutexLock(Mutex* mutex) : mutex_(mutex) { mutex_->Lock(); }

explicit GTestMutexLock(Mutex* mutex) : mutex_(mutex) { mutex_->lock(); }

~GTestMutexLock() { mutex_->Unlock(); }

~GTestMutexLock() { mutex_->unlock(); }

private:

Mutex* const mutex_;

class MutexBase {

public:

// Acquires this mutex.

void Lock() {

void lock() {

GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));

owner_ = pthread_self();

has_owner_ = true;

}

// Releases this mutex.

void Unlock() {

void unlock() {

// Since the lock is being released the owner_ field should no longer be

// considered valid. We don't protect writing to has_owner_ here, as it's

// the caller's responsibility to ensure that the current thread holds the

// "MutexLock l(&mu)". Hence the typedef trick below.

class GTestMutexLock {

public:

explicit GTestMutexLock(MutexBase* mutex) : mutex_(mutex) { mutex_->Lock(); }

explicit GTestMutexLock(MutexBase* mutex) : mutex_(mutex) { mutex_->lock(); }

~GTestMutexLock() { mutex_->Unlock(); }

~GTestMutexLock() { mutex_->unlock(); }

private:

MutexBase* const mutex_;

class Mutex {

public:

Mutex() {}

void Lock() {}

void Unlock() {}

void lock() {}

void unlock() {}

void AssertHeld() const {}

};

} // namespace internal

} // namespace testing

#if GTEST_INTERNAL_HAVE_CPP_ATTRIBUTE(clang::annotate)

#define GTEST_INTERNAL_DEPRECATE_AND_INLINE(msg) \

[[deprecated(msg), clang::annotate("inline-me")]]

#else

#define GTEST_INTERNAL_DEPRECATE_AND_INLINE(msg) [[deprecated(msg)]]

#endif

#if defined(__cpp_lib_span) || (GTEST_INTERNAL_HAS_INCLUDE(<span>) && \

GTEST_INTERNAL_CPLUSPLUS_LANG >= 202002L)

#define GTEST_INTERNAL_HAS_STD_SPAN 1