is Google's (unit) testing and mocking framework for C++ tests.
| gtest-port.h (googletest-release-1.11.0) | : | gtest-port.h (googletest-release-1.12.0) |
|---|
| | |
| skipping to change at line 29 | | skipping to change at line 29 |
|---|
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
| // | | |
| // Low-level types and utilities for porting Google Test to various | | // Low-level types and utilities for porting Google Test to various |
| // platforms. All macros ending with _ and symbols defined in an | | // platforms. All macros ending with _ and symbols defined in an |
| // internal namespace are subject to change without notice. Code | | // internal namespace are subject to change without notice. Code |
| // outside Google Test MUST NOT USE THEM DIRECTLY. Macros that don't | | // outside Google Test MUST NOT USE THEM DIRECTLY. Macros that don't |
| // end with _ are part of Google Test's public API and can be used by | | // end with _ are part of Google Test's public API and can be used by |
| // code outside Google Test. | | // code outside Google Test. |
| // | | // |
| // This file is fundamental to Google Test. All other Google Test source | | // This file is fundamental to Google Test. All other Google Test source |
| // files are expected to #include this. Therefore, it cannot #include | | // files are expected to #include this. Therefore, it cannot #include |
| // any other Google Test header. | | // any other Google Test header. |
| | |
|
| // GOOGLETEST_CM0001 DO NOT DELETE | | // IWYU pragma: private, include "gtest/gtest.h" |
| | // IWYU pragma: friend gtest/.* |
| | // IWYU pragma: friend gmock/.* |
| | |
| #ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ | | #ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ |
| #define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ | | #define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ |
| | |
| // Environment-describing macros | | // Environment-describing macros |
| // ----------------------------- | | // ----------------------------- |
| // | | // |
| // Google Test can be used in many different environments. Macros in | | // Google Test can be used in many different environments. Macros in |
| // this section tell Google Test what kind of environment it is being | | // this section tell Google Test what kind of environment it is being |
| // used in, such that Google Test can provide environment-specific | | // used in, such that Google Test can provide environment-specific |
| | |
| skipping to change at line 119 | | skipping to change at line 121 |
|---|
| // (a macro is defined to 1 if compiled on the given platform; | | // (a macro is defined to 1 if compiled on the given platform; |
| // otherwise UNDEFINED -- it's never defined to 0.). Google Test | | // otherwise UNDEFINED -- it's never defined to 0.). Google Test |
| // defines these macros automatically. Code outside Google Test MUST | | // defines these macros automatically. Code outside Google Test MUST |
| // NOT define them. | | // NOT define them. |
| // | | // |
| // GTEST_OS_AIX - IBM AIX | | // GTEST_OS_AIX - IBM AIX |
| // GTEST_OS_CYGWIN - Cygwin | | // GTEST_OS_CYGWIN - Cygwin |
| // GTEST_OS_DRAGONFLY - DragonFlyBSD | | // GTEST_OS_DRAGONFLY - DragonFlyBSD |
| // GTEST_OS_FREEBSD - FreeBSD | | // GTEST_OS_FREEBSD - FreeBSD |
| // GTEST_OS_FUCHSIA - Fuchsia | | // GTEST_OS_FUCHSIA - Fuchsia |
|
| | // GTEST_OS_GNU_HURD - GNU/Hurd |
| // GTEST_OS_GNU_KFREEBSD - GNU/kFreeBSD | | // GTEST_OS_GNU_KFREEBSD - GNU/kFreeBSD |
| // GTEST_OS_HAIKU - Haiku | | // GTEST_OS_HAIKU - Haiku |
| // GTEST_OS_HPUX - HP-UX | | // GTEST_OS_HPUX - HP-UX |
| // GTEST_OS_LINUX - Linux | | // GTEST_OS_LINUX - Linux |
| // GTEST_OS_LINUX_ANDROID - Google Android | | // GTEST_OS_LINUX_ANDROID - Google Android |
| // GTEST_OS_MAC - Mac OS X | | // GTEST_OS_MAC - Mac OS X |
| // GTEST_OS_IOS - iOS | | // GTEST_OS_IOS - iOS |
| // GTEST_OS_NACL - Google Native Client (NaCl) | | // GTEST_OS_NACL - Google Native Client (NaCl) |
| // GTEST_OS_NETBSD - NetBSD | | // GTEST_OS_NETBSD - NetBSD |
| // GTEST_OS_OPENBSD - OpenBSD | | // GTEST_OS_OPENBSD - OpenBSD |
| | |
| skipping to change at line 170 | | skipping to change at line 173 |
|---|
| // which controls that code. For example: | | // which controls that code. For example: |
| // | | // |
| // #if GTEST_HAS_DEATH_TEST | | // #if GTEST_HAS_DEATH_TEST |
| // EXPECT_DEATH(DoSomethingDeadly()); | | // EXPECT_DEATH(DoSomethingDeadly()); |
| // #endif | | // #endif |
| // | | // |
| // GTEST_HAS_DEATH_TEST - death tests | | // GTEST_HAS_DEATH_TEST - death tests |
| // GTEST_HAS_TYPED_TEST - typed tests | | // GTEST_HAS_TYPED_TEST - typed tests |
| // GTEST_HAS_TYPED_TEST_P - type-parameterized tests | | // GTEST_HAS_TYPED_TEST_P - type-parameterized tests |
| // GTEST_IS_THREADSAFE - Google Test is thread-safe. | | // GTEST_IS_THREADSAFE - Google Test is thread-safe. |
|
| // GOOGLETEST_CM0007 DO NOT DELETE | | // GTEST_USES_RE2 - the RE2 regular expression library is used |
| // GTEST_USES_POSIX_RE - enhanced POSIX regex is used. Do not confuse with | | // GTEST_USES_POSIX_RE - enhanced POSIX regex is used. Do not confuse with |
| // GTEST_HAS_POSIX_RE (see above) which users can | | // GTEST_HAS_POSIX_RE (see above) which users can |
| // define themselves. | | // define themselves. |
| // GTEST_USES_SIMPLE_RE - our own simple regex is used; | | // GTEST_USES_SIMPLE_RE - our own simple regex is used; |
| // the above RE\b(s) are mutually exclusive. | | // the above RE\b(s) are mutually exclusive. |
| | |
| // Misc public macros | | // Misc public macros |
| // ------------------ | | // ------------------ |
| // | | // |
| // GTEST_FLAG(flag_name) - references the variable corresponding to | | // GTEST_FLAG(flag_name) - references the variable corresponding to |
| | |
| skipping to change at line 193 | | skipping to change at line 196 |
|---|
| // Internal utilities | | // Internal utilities |
| // ------------------ | | // ------------------ |
| // | | // |
| // The following macros and utilities are for Google Test's INTERNAL | | // The following macros and utilities are for Google Test's INTERNAL |
| // use only. Code outside Google Test MUST NOT USE THEM DIRECTLY. | | // use only. Code outside Google Test MUST NOT USE THEM DIRECTLY. |
| // | | // |
| // Macros for basic C++ coding: | | // Macros for basic C++ coding: |
| // GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning. | | // GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning. |
| // GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a | | // GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a |
| // variable don't have to be used. | | // variable don't have to be used. |
|
| // GTEST_DISALLOW_ASSIGN_ - disables copy operator=. | | |
| // GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=. | | |
| // GTEST_DISALLOW_MOVE_ASSIGN_ - disables move operator=. | | |
| // GTEST_DISALLOW_MOVE_AND_ASSIGN_ - disables move ctor and operator=. | | |
| // GTEST_MUST_USE_RESULT_ - declares that a function's result must be used. | | // GTEST_MUST_USE_RESULT_ - declares that a function's result must be used. |
| // GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is | | // GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is |
| // suppressed (constant conditional). | | // suppressed (constant conditional). |
| // GTEST_INTENTIONAL_CONST_COND_POP_ - finish code section where MSVC C4127 | | // GTEST_INTENTIONAL_CONST_COND_POP_ - finish code section where MSVC C4127 |
| // is suppressed. | | // is suppressed. |
| // GTEST_INTERNAL_HAS_ANY - for enabling UniversalPrinter<std::any> or | | // GTEST_INTERNAL_HAS_ANY - for enabling UniversalPrinter<std::any> or |
| // UniversalPrinter<absl::any> specializations. | | // UniversalPrinter<absl::any> specializations. |
| // GTEST_INTERNAL_HAS_OPTIONAL - for enabling UniversalPrinter<std::optional> | | // GTEST_INTERNAL_HAS_OPTIONAL - for enabling UniversalPrinter<std::optional> |
| // or | | // or |
| // UniversalPrinter<absl::optional> | | // UniversalPrinter<absl::optional> |
| | |
| skipping to change at line 220 | | skipping to change at line 219 |
|---|
| // specializations. | | // specializations. |
| // GTEST_INTERNAL_HAS_VARIANT - for enabling UniversalPrinter<std::variant> or | | // GTEST_INTERNAL_HAS_VARIANT - for enabling UniversalPrinter<std::variant> or |
| // UniversalPrinter<absl::variant> | | // UniversalPrinter<absl::variant> |
| // specializations. | | // specializations. |
| // | | // |
| // Synchronization: | | // Synchronization: |
| // Mutex, MutexLock, ThreadLocal, GetThreadCount() | | // Mutex, MutexLock, ThreadLocal, GetThreadCount() |
| // - synchronization primitives. | | // - synchronization primitives. |
| // | | // |
| // Regular expressions: | | // Regular expressions: |
|
| // RE - a simple regular expression class using the POSIX | | // RE - a simple regular expression class using |
| // Extended Regular Expression syntax on UNIX-like platforms | | // 1) the RE2 syntax on all platforms when built with RE2 |
| // GOOGLETEST_CM0008 DO NOT DELETE | | // and Abseil as dependencies |
| // or a reduced regular exception syntax on other | | // 2) the POSIX Extended Regular Expression syntax on |
| // platforms, including Windows. | | // UNIX-like platforms, |
| | // 3) A reduced regular exception syntax on other platforms, |
| | // including Windows. |
| // Logging: | | // Logging: |
| // GTEST_LOG_() - logs messages at the specified severity level. | | // GTEST_LOG_() - logs messages at the specified severity level. |
| // LogToStderr() - directs all log messages to stderr. | | // LogToStderr() - directs all log messages to stderr. |
| // FlushInfoLog() - flushes informational log messages. | | // FlushInfoLog() - flushes informational log messages. |
| // | | // |
| // Stdout and stderr capturing: | | // Stdout and stderr capturing: |
| // CaptureStdout() - starts capturing stdout. | | // CaptureStdout() - starts capturing stdout. |
| // GetCapturedStdout() - stops capturing stdout and returns the captured | | // GetCapturedStdout() - stops capturing stdout and returns the captured |
| // string. | | // string. |
| // CaptureStderr() - starts capturing stderr. | | // CaptureStderr() - starts capturing stderr. |
| // GetCapturedStderr() - stops capturing stderr and returns the captured | | // GetCapturedStderr() - stops capturing stderr and returns the captured |
| // string. | | // string. |
| // | | // |
| // Integer types: | | // Integer types: |
| // TypeWithSize - maps an integer to a int type. | | // TypeWithSize - maps an integer to a int type. |
| // TimeInMillis - integers of known sizes. | | // TimeInMillis - integers of known sizes. |
| // BiggestInt - the biggest signed integer type. | | // BiggestInt - the biggest signed integer type. |
| // | | // |
| // Command-line utilities: | | // Command-line utilities: |
|
| // GTEST_DECLARE_*() - declares a flag. | | |
| // GTEST_DEFINE_*() - defines a flag. | | |
| // GetInjectableArgvs() - returns the command line as a vector of strings. | | // GetInjectableArgvs() - returns the command line as a vector of strings. |
| // | | // |
| // Environment variable utilities: | | // Environment variable utilities: |
| // GetEnv() - gets the value of an environment variable. | | // GetEnv() - gets the value of an environment variable. |
| // BoolFromGTestEnv() - parses a bool environment variable. | | // BoolFromGTestEnv() - parses a bool environment variable. |
| // Int32FromGTestEnv() - parses an int32_t environment variable. | | // Int32FromGTestEnv() - parses an int32_t environment variable. |
| // StringFromGTestEnv() - parses a string environment variable. | | // StringFromGTestEnv() - parses a string environment variable. |
| // | | // |
| // Deprecation warnings: | | // Deprecation warnings: |
| // GTEST_INTERNAL_DEPRECATED(message) - attribute marking a function as | | // GTEST_INTERNAL_DEPRECATED(message) - attribute marking a function as |
| // deprecated; calling a marked function | | // deprecated; calling a marked function |
| // should generate a compiler warning | | // should generate a compiler warning |
| | |
| #include <ctype.h> // for isspace, etc | | #include <ctype.h> // for isspace, etc |
| #include <stddef.h> // for ptrdiff_t | | #include <stddef.h> // for ptrdiff_t |
| #include <stdio.h> | | #include <stdio.h> |
| #include <stdlib.h> | | #include <stdlib.h> |
| #include <string.h> | | #include <string.h> |
| | |
| #include <cerrno> | | #include <cerrno> |
|
| | // #include <condition_variable> // Guarded by GTEST_IS_THREADSAFE below |
| #include <cstdint> | | #include <cstdint> |
|
| | #include <iostream> |
| #include <limits> | | #include <limits> |
|
| | #include <locale> |
| | #include <memory> |
| | #include <string> |
| | // #include <mutex> // Guarded by GTEST_IS_THREADSAFE below |
| | #include <tuple> |
| #include <type_traits> | | #include <type_traits> |
|
| | #include <vector> |
| | |
| #ifndef _WIN32_WCE | | #ifndef _WIN32_WCE |
|
| # include <sys/types.h> | | #include <sys/stat.h> |
| # include <sys/stat.h> | | #include <sys/types.h> |
| #endif // !_WIN32_WCE | | #endif // !_WIN32_WCE |
| | |
| #if defined __APPLE__ | | #if defined __APPLE__ |
|
| # include <AvailabilityMacros.h> | | #include <AvailabilityMacros.h> |
| # include <TargetConditionals.h> | | #include <TargetConditionals.h> |
| #endif | | #endif |
| | |
|
| #include <iostream> // NOLINT | | |
| #include <locale> | | |
| #include <memory> | | |
| #include <string> // NOLINT | | |
| #include <tuple> | | |
| #include <vector> // NOLINT | | |
| | | |
| #include "gtest/internal/custom/gtest-port.h" | | #include "gtest/internal/custom/gtest-port.h" |
| #include "gtest/internal/gtest-port-arch.h" | | #include "gtest/internal/gtest-port-arch.h" |
| | |
|
| | #if GTEST_HAS_ABSL |
| | #include "absl/flags/declare.h" |
| | #include "absl/flags/flag.h" |
| | #include "absl/flags/reflection.h" |
| | #endif |
| | |
| #if !defined(GTEST_DEV_EMAIL_) | | #if !defined(GTEST_DEV_EMAIL_) |
|
| # define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com" | | #define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com" |
| # define GTEST_FLAG_PREFIX_ "gtest_" | | #define GTEST_FLAG_PREFIX_ "gtest_" |
| # define GTEST_FLAG_PREFIX_DASH_ "gtest-" | | #define GTEST_FLAG_PREFIX_DASH_ "gtest-" |
| # define GTEST_FLAG_PREFIX_UPPER_ "GTEST_" | | #define GTEST_FLAG_PREFIX_UPPER_ "GTEST_" |
| # define GTEST_NAME_ "Google Test" | | #define GTEST_NAME_ "Google Test" |
| # define GTEST_PROJECT_URL_ "https://github.com/google/googletest/" | | #define GTEST_PROJECT_URL_ "https://github.com/google/googletest/" |
| #endif // !defined(GTEST_DEV_EMAIL_) | | #endif // !defined(GTEST_DEV_EMAIL_) |
| | |
| #if !defined(GTEST_INIT_GOOGLE_TEST_NAME_) | | #if !defined(GTEST_INIT_GOOGLE_TEST_NAME_) |
|
| # define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest" | | #define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest" |
| #endif // !defined(GTEST_INIT_GOOGLE_TEST_NAME_) | | #endif // !defined(GTEST_INIT_GOOGLE_TEST_NAME_) |
| | |
| // Determines the version of gcc that is used to compile this. | | // Determines the version of gcc that is used to compile this. |
| #ifdef __GNUC__ | | #ifdef __GNUC__ |
| // 40302 means version 4.3.2. | | // 40302 means version 4.3.2. |
|
| # define GTEST_GCC_VER_ \ | | #define GTEST_GCC_VER_ \ |
| (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__) | | (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) |
| #endif // __GNUC__ | | #endif // __GNUC__ |
| | |
| // Macros for disabling Microsoft Visual C++ warnings. | | // Macros for disabling Microsoft Visual C++ warnings. |
| // | | // |
| // GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385) | | // GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385) |
| // /* code that triggers warnings C4800 and C4385 */ | | // /* code that triggers warnings C4800 and C4385 */ |
| // GTEST_DISABLE_MSC_WARNINGS_POP_() | | // GTEST_DISABLE_MSC_WARNINGS_POP_() |
| #if defined(_MSC_VER) | | #if defined(_MSC_VER) |
|
| # define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \ | | #define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \ |
| __pragma(warning(push)) \ | | __pragma(warning(push)) __pragma(warning(disable : warnings)) |
| __pragma(warning(disable: warnings)) | | #define GTEST_DISABLE_MSC_WARNINGS_POP_() __pragma(warning(pop)) |
| # define GTEST_DISABLE_MSC_WARNINGS_POP_() \ | | |
| __pragma(warning(pop)) | | |
| #else | | #else |
| // Not all compilers are MSVC | | // Not all compilers are MSVC |
|
| # define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) | | #define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) |
| # define GTEST_DISABLE_MSC_WARNINGS_POP_() | | #define GTEST_DISABLE_MSC_WARNINGS_POP_() |
| #endif | | #endif |
| | |
| // Clang on Windows does not understand MSVC's pragma warning. | | // Clang on Windows does not understand MSVC's pragma warning. |
| // We need clang-specific way to disable function deprecation warning. | | // We need clang-specific way to disable function deprecation warning. |
| #ifdef __clang__ | | #ifdef __clang__ |
|
| # define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \ | | #define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \ |
| _Pragma("clang diagnostic push") \ | | _Pragma("clang diagnostic push") \ |
| _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") \ | | _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") \ |
| _Pragma("clang diagnostic ignored \"-Wdeprecated-implementations\"") | | _Pragma("clang diagnostic ignored \"-Wdeprecated-implementations\"") |
| #define GTEST_DISABLE_MSC_DEPRECATED_POP_() \ | | #define GTEST_DISABLE_MSC_DEPRECATED_POP_() _Pragma("clang diagnostic pop") |
| _Pragma("clang diagnostic pop") | | #else |
| #else | | #define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \ |
| # define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \ | | GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996) |
| GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996) | | #define GTEST_DISABLE_MSC_DEPRECATED_POP_() GTEST_DISABLE_MSC_WARNINGS_POP_() |
| # define GTEST_DISABLE_MSC_DEPRECATED_POP_() \ | | |
| GTEST_DISABLE_MSC_WARNINGS_POP_() | | |
| #endif | | #endif |
| | |
| // Brings in definitions for functions used in the testing::internal::posix | | // Brings in definitions for functions used in the testing::internal::posix |
| // namespace (read, write, close, chdir, isatty, stat). We do not currently | | // namespace (read, write, close, chdir, isatty, stat). We do not currently |
| // use them on Windows Mobile. | | // use them on Windows Mobile. |
| #if GTEST_OS_WINDOWS | | #if GTEST_OS_WINDOWS |
|
| # if !GTEST_OS_WINDOWS_MOBILE | | #if !GTEST_OS_WINDOWS_MOBILE |
| # include <direct.h> | | #include <direct.h> |
| # include <io.h> | | #include <io.h> |
| # endif | | #endif |
| // In order to avoid having to include <windows.h>, use forward declaration | | // In order to avoid having to include <windows.h>, use forward declaration |
| #if GTEST_OS_WINDOWS_MINGW && !defined(__MINGW64_VERSION_MAJOR) | | #if GTEST_OS_WINDOWS_MINGW && !defined(__MINGW64_VERSION_MAJOR) |
| // MinGW defined _CRITICAL_SECTION and _RTL_CRITICAL_SECTION as two | | // MinGW defined _CRITICAL_SECTION and _RTL_CRITICAL_SECTION as two |
| // separate (equivalent) structs, instead of using typedef | | // separate (equivalent) structs, instead of using typedef |
| typedef struct _CRITICAL_SECTION GTEST_CRITICAL_SECTION; | | typedef struct _CRITICAL_SECTION GTEST_CRITICAL_SECTION; |
| #else | | #else |
| // Assume CRITICAL_SECTION is a typedef of _RTL_CRITICAL_SECTION. | | // Assume CRITICAL_SECTION is a typedef of _RTL_CRITICAL_SECTION. |
| // This assumption is verified by | | // This assumption is verified by |
| // WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION. | | // WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION. |
| typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION; | | typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION; |
| #endif | | #endif |
| #elif GTEST_OS_XTENSA | | #elif GTEST_OS_XTENSA |
| #include <unistd.h> | | #include <unistd.h> |
| // Xtensa toolchains define strcasecmp in the string.h header instead of | | // Xtensa toolchains define strcasecmp in the string.h header instead of |
| // strings.h. string.h is already included. | | // strings.h. string.h is already included. |
| #else | | #else |
| // This assumes that non-Windows OSes provide unistd.h. For OSes where this | | // This assumes that non-Windows OSes provide unistd.h. For OSes where this |
| // is not the case, we need to include headers that provide the functions | | // is not the case, we need to include headers that provide the functions |
| // mentioned above. | | // mentioned above. |
|
| # include <unistd.h> | | #include <strings.h> |
| # include <strings.h> | | #include <unistd.h> |
| #endif // GTEST_OS_WINDOWS | | #endif // GTEST_OS_WINDOWS |
| | |
| #if GTEST_OS_LINUX_ANDROID | | #if GTEST_OS_LINUX_ANDROID |
| // Used to define __ANDROID_API__ matching the target NDK API level. | | // Used to define __ANDROID_API__ matching the target NDK API level. |
|
| # include <android/api-level.h> // NOLINT | | #include <android/api-level.h> // NOLINT |
| #endif | | #endif |
| | |
| // Defines this to true if and only if Google Test can use POSIX regular | | // Defines this to true if and only if Google Test can use POSIX regular |
| // expressions. | | // expressions. |
| #ifndef GTEST_HAS_POSIX_RE | | #ifndef GTEST_HAS_POSIX_RE |
|
| # if GTEST_OS_LINUX_ANDROID | | #if GTEST_OS_LINUX_ANDROID |
| // On Android, <regex.h> is only available starting with Gingerbread. | | // On Android, <regex.h> is only available starting with Gingerbread. |
|
| # define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9) | | #define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9) |
| # else | | #else |
| #define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS && !GTEST_OS_XTENSA) | | #define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS && !GTEST_OS_XTENSA) |
|
| # endif | | #endif |
| #endif | | #endif |
| | |
|
| #if GTEST_USES_PCRE | | // Select the regular expression implementation. |
| // The appropriate headers have already been included. | | #if GTEST_HAS_ABSL |
| | | // When using Abseil, RE2 is required. |
| | #include "absl/strings/string_view.h" |
| | #include "re2/re2.h" |
| | #define GTEST_USES_RE2 1 |
| #elif GTEST_HAS_POSIX_RE | | #elif GTEST_HAS_POSIX_RE |
|
| | | #include <regex.h> // NOLINT |
| // On some platforms, <regex.h> needs someone to define size_t, and | | #define GTEST_USES_POSIX_RE 1 |
| // won't compile otherwise. We can #include it here as we already | | |
| // included <stdlib.h>, which is guaranteed to define size_t through | | |
| // <stddef.h>. | | |
| # include <regex.h> // NOLINT | | |
| | | |
| # define GTEST_USES_POSIX_RE 1 | | |
| | |
| #elif GTEST_OS_WINDOWS | | |
| | |
| // <regex.h> is not available on Windows. Use our own simple regex | | |
| // implementation instead. | | |
| # define GTEST_USES_SIMPLE_RE 1 | | |
| | | |
| #else | | #else |
|
| | | // Use our own simple regex implementation. |
| // <regex.h> may not be available on this platform. Use our own | | #define GTEST_USES_SIMPLE_RE 1 |
| // simple regex implementation instead. | | #endif |
| # define GTEST_USES_SIMPLE_RE 1 | | |
| | | |
| #endif // GTEST_USES_PCRE | | |
| | |
| #ifndef GTEST_HAS_EXCEPTIONS | | #ifndef GTEST_HAS_EXCEPTIONS |
| // The user didn't tell us whether exceptions are enabled, so we need | | // The user didn't tell us whether exceptions are enabled, so we need |
| // to figure it out. | | // to figure it out. |
|
| # if defined(_MSC_VER) && defined(_CPPUNWIND) | | #if defined(_MSC_VER) && defined(_CPPUNWIND) |
| // MSVC defines _CPPUNWIND to 1 if and only if exceptions are enabled. | | // MSVC defines _CPPUNWIND to 1 if and only if exceptions are enabled. |
|
| # define GTEST_HAS_EXCEPTIONS 1 | | #define GTEST_HAS_EXCEPTIONS 1 |
| # elif defined(__BORLANDC__) | | #elif defined(__BORLANDC__) |
| // C++Builder's implementation of the STL uses the _HAS_EXCEPTIONS | | // C++Builder's implementation of the STL uses the _HAS_EXCEPTIONS |
| // macro to enable exceptions, so we'll do the same. | | // macro to enable exceptions, so we'll do the same. |
| // Assumes that exceptions are enabled by default. | | // Assumes that exceptions are enabled by default. |
|
| # ifndef _HAS_EXCEPTIONS | | #ifndef _HAS_EXCEPTIONS |
| # define _HAS_EXCEPTIONS 1 | | #define _HAS_EXCEPTIONS 1 |
| # endif // _HAS_EXCEPTIONS | | #endif // _HAS_EXCEPTIONS |
| # define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS | | #define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS |
| # elif defined(__clang__) | | #elif defined(__clang__) |
| // clang defines __EXCEPTIONS if and only if exceptions are enabled before clang | | // clang defines __EXCEPTIONS if and only if exceptions are enabled before clang |
| // 220714, but if and only if cleanups are enabled after that. In Obj-C++ files, | | // 220714, but if and only if cleanups are enabled after that. In Obj-C++ files, |
| // there can be cleanups for ObjC exceptions which also need cleanups, even if | | // there can be cleanups for ObjC exceptions which also need cleanups, even if |
| // C++ exceptions are disabled. clang has __has_feature(cxx_exceptions) which | | // C++ exceptions are disabled. clang has __has_feature(cxx_exceptions) which |
| // checks for C++ exceptions starting at clang r206352, but which checked for | | // checks for C++ exceptions starting at clang r206352, but which checked for |
| // cleanups prior to that. To reliably check for C++ exception availability with | | // cleanups prior to that. To reliably check for C++ exception availability with |
| // clang, check for | | // clang, check for |
| // __EXCEPTIONS && __has_feature(cxx_exceptions). | | // __EXCEPTIONS && __has_feature(cxx_exceptions). |
|
| # define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions)) | | #define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions)) |
| # elif defined(__GNUC__) && __EXCEPTIONS | | #elif defined(__GNUC__) && __EXCEPTIONS |
| // gcc defines __EXCEPTIONS to 1 if and only if exceptions are enabled. | | // gcc defines __EXCEPTIONS to 1 if and only if exceptions are enabled. |
|
| # define GTEST_HAS_EXCEPTIONS 1 | | #define GTEST_HAS_EXCEPTIONS 1 |
| # elif defined(__SUNPRO_CC) | | #elif defined(__SUNPRO_CC) |
| // Sun Pro CC supports exceptions. However, there is no compile-time way of | | // Sun Pro CC supports exceptions. However, there is no compile-time way of |
| // detecting whether they are enabled or not. Therefore, we assume that | | // detecting whether they are enabled or not. Therefore, we assume that |
| // they are enabled unless the user tells us otherwise. | | // they are enabled unless the user tells us otherwise. |
|
| # define GTEST_HAS_EXCEPTIONS 1 | | #define GTEST_HAS_EXCEPTIONS 1 |
| # elif defined(__IBMCPP__) && __EXCEPTIONS | | #elif defined(__IBMCPP__) && __EXCEPTIONS |
| // xlC defines __EXCEPTIONS to 1 if and only if exceptions are enabled. | | // xlC defines __EXCEPTIONS to 1 if and only if exceptions are enabled. |
|
| # define GTEST_HAS_EXCEPTIONS 1 | | #define GTEST_HAS_EXCEPTIONS 1 |
| # elif defined(__HP_aCC) | | #elif defined(__HP_aCC) |
| // Exception handling is in effect by default in HP aCC compiler. It has to | | // Exception handling is in effect by default in HP aCC compiler. It has to |
| // be turned of by +noeh compiler option if desired. | | // be turned of by +noeh compiler option if desired. |
|
| # define GTEST_HAS_EXCEPTIONS 1 | | #define GTEST_HAS_EXCEPTIONS 1 |
| # else | | #else |
| // For other compilers, we assume exceptions are disabled to be | | // For other compilers, we assume exceptions are disabled to be |
| // conservative. | | // conservative. |
|
| # define GTEST_HAS_EXCEPTIONS 0 | | #define GTEST_HAS_EXCEPTIONS 0 |
| # endif // defined(_MSC_VER) || defined(__BORLANDC__) | | #endif // defined(_MSC_VER) || defined(__BORLANDC__) |
| #endif // GTEST_HAS_EXCEPTIONS | | #endif // GTEST_HAS_EXCEPTIONS |
| | |
| #ifndef GTEST_HAS_STD_WSTRING | | #ifndef GTEST_HAS_STD_WSTRING |
| // The user didn't tell us whether ::std::wstring is available, so we need | | // The user didn't tell us whether ::std::wstring is available, so we need |
| // to figure it out. | | // to figure it out. |
| // Cygwin 1.7 and below doesn't support ::std::wstring. | | // Cygwin 1.7 and below doesn't support ::std::wstring. |
| // Solaris' libc++ doesn't support it either. Android has | | // Solaris' libc++ doesn't support it either. Android has |
| // no support for it at least as recent as Froyo (2.2). | | // no support for it at least as recent as Froyo (2.2). |
| #define GTEST_HAS_STD_WSTRING \ | | #define GTEST_HAS_STD_WSTRING \ |
| (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ | | (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ |
| GTEST_OS_HAIKU || GTEST_OS_ESP32 || GTEST_OS_ESP8266 || GTEST_OS_XTENSA)) | | GTEST_OS_HAIKU || GTEST_OS_ESP32 || GTEST_OS_ESP8266 || GTEST_OS_XTENSA)) |
| | |
| #endif // GTEST_HAS_STD_WSTRING | | #endif // GTEST_HAS_STD_WSTRING |
| | |
| // Determines whether RTTI is available. | | // Determines whether RTTI is available. |
| #ifndef GTEST_HAS_RTTI | | #ifndef GTEST_HAS_RTTI |
| // The user didn't tell us whether RTTI is enabled, so we need to | | // The user didn't tell us whether RTTI is enabled, so we need to |
| // figure it out. | | // figure it out. |
| | |
|
| # ifdef _MSC_VER | | #ifdef _MSC_VER |
| | |
| #ifdef _CPPRTTI // MSVC defines this macro if and only if RTTI is enabled. | | #ifdef _CPPRTTI // MSVC defines this macro if and only if RTTI is enabled. |
|
| # define GTEST_HAS_RTTI 1 | | #define GTEST_HAS_RTTI 1 |
| # else | | #else |
| # define GTEST_HAS_RTTI 0 | | #define GTEST_HAS_RTTI 0 |
| # endif | | #endif |
| | |
| // Starting with version 4.3.2, gcc defines __GXX_RTTI if and only if RTTI is | | // Starting with version 4.3.2, gcc defines __GXX_RTTI if and only if RTTI is |
| // enabled. | | // enabled. |
|
| # elif defined(__GNUC__) | | #elif defined(__GNUC__) |
| | |
|
| # ifdef __GXX_RTTI | | #ifdef __GXX_RTTI |
| // When building against STLport with the Android NDK and with | | // When building against STLport with the Android NDK and with |
| // -frtti -fno-exceptions, the build fails at link time with undefined | | // -frtti -fno-exceptions, the build fails at link time with undefined |
| // references to __cxa_bad_typeid. Note sure if STL or toolchain bug, | | // references to __cxa_bad_typeid. Note sure if STL or toolchain bug, |
| // so disable RTTI when detected. | | // so disable RTTI when detected. |
|
| # if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \ | | #if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && !defined(__EXCEPTIONS) |
| !defined(__EXCEPTIONS) | | #define GTEST_HAS_RTTI 0 |
| # define GTEST_HAS_RTTI 0 | | #else |
| # else | | #define GTEST_HAS_RTTI 1 |
| # define GTEST_HAS_RTTI 1 | | #endif // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS |
| # endif // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS | | #else |
| # else | | #define GTEST_HAS_RTTI 0 |
| # define GTEST_HAS_RTTI 0 | | #endif // __GXX_RTTI |
| # endif // __GXX_RTTI | | |
| | |
| // Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends | | // Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends |
| // using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the | | // using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the |
| // first version with C++ support. | | // first version with C++ support. |
|
| # elif defined(__clang__) | | #elif defined(__clang__) |
| | |
|
| # define GTEST_HAS_RTTI __has_feature(cxx_rtti) | | #define GTEST_HAS_RTTI __has_feature(cxx_rtti) |
| | |
| // Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if | | // Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if |
| // both the typeid and dynamic_cast features are present. | | // both the typeid and dynamic_cast features are present. |
|
| # elif defined(__IBMCPP__) && (__IBMCPP__ >= 900) | | #elif defined(__IBMCPP__) && (__IBMCPP__ >= 900) |
| | |
|
| # ifdef __RTTI_ALL__ | | #ifdef __RTTI_ALL__ |
| # define GTEST_HAS_RTTI 1 | | #define GTEST_HAS_RTTI 1 |
| # else | | #else |
| # define GTEST_HAS_RTTI 0 | | #define GTEST_HAS_RTTI 0 |
| # endif | | #endif |
| | |
|
| # else | | #else |
| | |
| // For all other compilers, we assume RTTI is enabled. | | // For all other compilers, we assume RTTI is enabled. |
|
| # define GTEST_HAS_RTTI 1 | | #define GTEST_HAS_RTTI 1 |
| | |
|
| # endif // _MSC_VER | | #endif // _MSC_VER |
| | |
| #endif // GTEST_HAS_RTTI | | #endif // GTEST_HAS_RTTI |
| | |
| // It's this header's responsibility to #include <typeinfo> when RTTI | | // It's this header's responsibility to #include <typeinfo> when RTTI |
| // is enabled. | | // is enabled. |
| #if GTEST_HAS_RTTI | | #if GTEST_HAS_RTTI |
|
| # include <typeinfo> | | #include <typeinfo> |
| #endif | | #endif |
| | |
| // Determines whether Google Test can use the pthreads library. | | // Determines whether Google Test can use the pthreads library. |
| #ifndef GTEST_HAS_PTHREAD | | #ifndef GTEST_HAS_PTHREAD |
| // The user didn't tell us explicitly, so we make reasonable assumptions about | | // The user didn't tell us explicitly, so we make reasonable assumptions about |
| // which platforms have pthreads support. | | // which platforms have pthreads support. |
| // | | // |
| // To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0 | | // To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0 |
| // to your compiler flags. | | // to your compiler flags. |
| #define GTEST_HAS_PTHREAD \ | | #define GTEST_HAS_PTHREAD \ |
| (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX || \ | | (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX || \ |
| GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \ | | GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \ |
| GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_OPENBSD || \ | | GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_OPENBSD || \ |
|
| GTEST_OS_HAIKU) | | GTEST_OS_HAIKU || GTEST_OS_GNU_HURD) |
| #endif // GTEST_HAS_PTHREAD | | #endif // GTEST_HAS_PTHREAD |
| | |
| #if GTEST_HAS_PTHREAD | | #if GTEST_HAS_PTHREAD |
| // gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is | | // gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is |
| // true. | | // true. |
|
| # include <pthread.h> // NOLINT | | #include <pthread.h> // NOLINT |
| | |
| // For timespec and nanosleep, used below. | | // For timespec and nanosleep, used below. |
|
| # include <time.h> // NOLINT | | #include <time.h> // NOLINT |
| #endif | | #endif |
| | |
| // Determines whether clone(2) is supported. | | // Determines whether clone(2) is supported. |
| // Usually it will only be available on Linux, excluding | | // Usually it will only be available on Linux, excluding |
| // Linux on the Itanium architecture. | | // Linux on the Itanium architecture. |
| // Also see http://linux.die.net/man/2/clone. | | // Also see http://linux.die.net/man/2/clone. |
| #ifndef GTEST_HAS_CLONE | | #ifndef GTEST_HAS_CLONE |
| // The user didn't tell us, so we need to figure it out. | | // The user didn't tell us, so we need to figure it out. |
| | |
|
| # if GTEST_OS_LINUX && !defined(__ia64__) | | #if GTEST_OS_LINUX && !defined(__ia64__) |
| # if GTEST_OS_LINUX_ANDROID | | #if GTEST_OS_LINUX_ANDROID |
| // On Android, clone() became available at different API levels for each 32-bit | | // On Android, clone() became available at different API levels for each 32-bit |
| // architecture. | | // architecture. |
|
| # if defined(__LP64__) || \ | | #if defined(__LP64__) || (defined(__arm__) && __ANDROID_API__ >= 9) || \ |
| (defined(__arm__) && __ANDROID_API__ >= 9) || \ | | (defined(__mips__) && __ANDROID_API__ >= 12) || \ |
| (defined(__mips__) && __ANDROID_API__ >= 12) || \ | | (defined(__i386__) && __ANDROID_API__ >= 17) |
| (defined(__i386__) && __ANDROID_API__ >= 17) | | #define GTEST_HAS_CLONE 1 |
| # define GTEST_HAS_CLONE 1 | | #else |
| # else | | #define GTEST_HAS_CLONE 0 |
| # define GTEST_HAS_CLONE 0 | | #endif |
| # endif | | #else |
| # else | | #define GTEST_HAS_CLONE 1 |
| # define GTEST_HAS_CLONE 1 | | #endif |
| # endif | | #else |
| # else | | #define GTEST_HAS_CLONE 0 |
| # define GTEST_HAS_CLONE 0 | | #endif // GTEST_OS_LINUX && !defined(__ia64__) |
| # endif // GTEST_OS_LINUX && !defined(__ia64__) | | |
| | |
| #endif // GTEST_HAS_CLONE | | #endif // GTEST_HAS_CLONE |
| | |
| // Determines whether to support stream redirection. This is used to test | | // Determines whether to support stream redirection. This is used to test |
| // output correctness and to implement death tests. | | // output correctness and to implement death tests. |
| #ifndef GTEST_HAS_STREAM_REDIRECTION | | #ifndef GTEST_HAS_STREAM_REDIRECTION |
| // By default, we assume that stream redirection is supported on all | | // By default, we assume that stream redirection is supported on all |
| // platforms except known mobile ones. | | // platforms except known mobile ones. |
| #if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \ | | #if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \ |
| GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA | | GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA |
|
| # define GTEST_HAS_STREAM_REDIRECTION 0 | | #define GTEST_HAS_STREAM_REDIRECTION 0 |
| # else | | #else |
| # define GTEST_HAS_STREAM_REDIRECTION 1 | | #define GTEST_HAS_STREAM_REDIRECTION 1 |
| # endif // !GTEST_OS_WINDOWS_MOBILE | | #endif // !GTEST_OS_WINDOWS_MOBILE |
| #endif // GTEST_HAS_STREAM_REDIRECTION | | #endif // GTEST_HAS_STREAM_REDIRECTION |
| | |
| // Determines whether to support death tests. | | // Determines whether to support death tests. |
| // pops up a dialog window that cannot be suppressed programmatically. | | // pops up a dialog window that cannot be suppressed programmatically. |
| #if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ | | #if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ |
| (GTEST_OS_MAC && !GTEST_OS_IOS) || \ | | (GTEST_OS_MAC && !GTEST_OS_IOS) || \ |
| (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER) || GTEST_OS_WINDOWS_MINGW || \ | | (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER) || GTEST_OS_WINDOWS_MINGW || \ |
| GTEST_OS_AIX || GTEST_OS_HPUX || GTEST_OS_OPENBSD || GTEST_OS_QNX || \ | | GTEST_OS_AIX || GTEST_OS_HPUX || GTEST_OS_OPENBSD || GTEST_OS_QNX || \ |
| GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \ | | GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \ |
|
| GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_HAIKU) | | GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_HAIKU || \ |
| # define GTEST_HAS_DEATH_TEST 1 | | GTEST_OS_GNU_HURD) |
| | #define GTEST_HAS_DEATH_TEST 1 |
| #endif | | #endif |
| | |
| // Determines whether to support type-driven tests. | | // Determines whether to support type-driven tests. |
| | |
| // Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0, | | // Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0, |
| // Sun Pro CC, IBM Visual Age, and HP aCC support. | | // Sun Pro CC, IBM Visual Age, and HP aCC support. |
| #if defined(__GNUC__) || defined(_MSC_VER) || defined(__SUNPRO_CC) || \ | | #if defined(__GNUC__) || defined(_MSC_VER) || defined(__SUNPRO_CC) || \ |
| defined(__IBMCPP__) || defined(__HP_aCC) | | defined(__IBMCPP__) || defined(__HP_aCC) |
|
| # define GTEST_HAS_TYPED_TEST 1 | | #define GTEST_HAS_TYPED_TEST 1 |
| # define GTEST_HAS_TYPED_TEST_P 1 | | #define GTEST_HAS_TYPED_TEST_P 1 |
| #endif | | #endif |
| | |
| // Determines whether the system compiler uses UTF-16 for encoding wide strings. | | // Determines whether the system compiler uses UTF-16 for encoding wide strings. |
| #define GTEST_WIDE_STRING_USES_UTF16_ \ | | #define GTEST_WIDE_STRING_USES_UTF16_ \ |
| (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_AIX || GTEST_OS_OS2) | | (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_AIX || GTEST_OS_OS2) |
| | |
| // Determines whether test results can be streamed to a socket. | | // Determines whether test results can be streamed to a socket. |
| #if GTEST_OS_LINUX || GTEST_OS_GNU_KFREEBSD || GTEST_OS_DRAGONFLY || \ | | #if GTEST_OS_LINUX || GTEST_OS_GNU_KFREEBSD || GTEST_OS_DRAGONFLY || \ |
|
| GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_OPENBSD | | GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_OPENBSD || \ |
| # define GTEST_CAN_STREAM_RESULTS_ 1 | | GTEST_OS_GNU_HURD |
| | #define GTEST_CAN_STREAM_RESULTS_ 1 |
| #endif | | #endif |
| | |
| // Defines some utility macros. | | // Defines some utility macros. |
| | |
| // The GNU compiler emits a warning if nested "if" statements are followed by | | // The GNU compiler emits a warning if nested "if" statements are followed by |
| // an "else" statement and braces are not used to explicitly disambiguate the | | // an "else" statement and braces are not used to explicitly disambiguate the |
| // "else" binding. This leads to problems with code like: | | // "else" binding. This leads to problems with code like: |
| // | | // |
| // if (gate) | | // if (gate) |
| // ASSERT_*(condition) << "Some message"; | | // ASSERT_*(condition) << "Some message"; |
| // | | // |
| // The "switch (0) case 0:" idiom is used to suppress this. | | // The "switch (0) case 0:" idiom is used to suppress this. |
| #ifdef __INTEL_COMPILER | | #ifdef __INTEL_COMPILER |
|
| # define GTEST_AMBIGUOUS_ELSE_BLOCKER_ | | #define GTEST_AMBIGUOUS_ELSE_BLOCKER_ |
| #else | | #else |
|
| # define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default: // NOLINT | | #define GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ |
| | switch (0) \ |
| | case 0: \ |
| | default: // NOLINT |
| #endif | | #endif |
| | |
| // Use this annotation at the end of a struct/class definition to | | // Use this annotation at the end of a struct/class definition to |
| // prevent the compiler from optimizing away instances that are never | | // prevent the compiler from optimizing away instances that are never |
| // used. This is useful when all interesting logic happens inside the | | // used. This is useful when all interesting logic happens inside the |
| // c'tor and / or d'tor. Example: | | // c'tor and / or d'tor. Example: |
| // | | // |
| // struct Foo { | | // struct Foo { |
| // Foo() { ... } | | // Foo() { ... } |
| // } GTEST_ATTRIBUTE_UNUSED_; | | // } GTEST_ATTRIBUTE_UNUSED_; |
| // | | // |
| // Also use it after a variable or parameter declaration to tell the | | // Also use it after a variable or parameter declaration to tell the |
| // compiler the variable/parameter does not have to be used. | | // compiler the variable/parameter does not have to be used. |
| #if defined(__GNUC__) && !defined(COMPILER_ICC) | | #if defined(__GNUC__) && !defined(COMPILER_ICC) |
|
| # define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) | | #define GTEST_ATTRIBUTE_UNUSED_ __attribute__((unused)) |
| #elif defined(__clang__) | | #elif defined(__clang__) |
|
| # if __has_attribute(unused) | | #if __has_attribute(unused) |
| # define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) | | #define GTEST_ATTRIBUTE_UNUSED_ __attribute__((unused)) |
| # endif | | #endif |
| #endif | | #endif |
| #ifndef GTEST_ATTRIBUTE_UNUSED_ | | #ifndef GTEST_ATTRIBUTE_UNUSED_ |
|
| # define GTEST_ATTRIBUTE_UNUSED_ | | #define GTEST_ATTRIBUTE_UNUSED_ |
| #endif | | #endif |
| | |
| // Use this annotation before a function that takes a printf format string. | | // Use this annotation before a function that takes a printf format string. |
| #if (defined(__GNUC__) || defined(__clang__)) && !defined(COMPILER_ICC) | | #if (defined(__GNUC__) || defined(__clang__)) && !defined(COMPILER_ICC) |
|
| # if defined(__MINGW_PRINTF_FORMAT) | | #if defined(__MINGW_PRINTF_FORMAT) |
| // MinGW has two different printf implementations. Ensure the format macro | | // MinGW has two different printf implementations. Ensure the format macro |
| // matches the selected implementation. See | | // matches the selected implementation. See |
| // https://sourceforge.net/p/mingw-w64/wiki2/gnu%20printf/. | | // https://sourceforge.net/p/mingw-w64/wiki2/gnu%20printf/. |
|
| # define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \ | | #define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \ |
| __attribute__((__format__(__MINGW_PRINTF_FORMAT, string_index, \ | | __attribute__(( \ |
| first_to_check))) | | __format__(__MINGW_PRINTF_FORMAT, string_index, first_to_check))) |
| # else | | #else |
| # define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \ | | #define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \ |
| __attribute__((__format__(__printf__, string_index, first_to_check))) | | __attribute__((__format__(__printf__, string_index, first_to_check))) |
| # endif | | #endif |
| #else | | #else |
| # define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) | | #define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) |
| #endif | | #endif |
| | | |
| // A macro to disallow copy operator= | | |
| // This should be used in the private: declarations for a class. | | |
| #define GTEST_DISALLOW_ASSIGN_(type) \ | | |
| type& operator=(type const &) = delete | | |
| | |
| // A macro to disallow copy constructor and operator= | | |
| // This should be used in the private: declarations for a class. | | |
| #define GTEST_DISALLOW_COPY_AND_ASSIGN_(type) \ | | |
| type(type const&) = delete; \ | | |
| type& operator=(type const&) = delete | | |
| | |
| // A macro to disallow move operator= | | |
| // This should be used in the private: declarations for a class. | | |
| #define GTEST_DISALLOW_MOVE_ASSIGN_(type) \ | | |
| type& operator=(type &&) noexcept = delete | | |
| | |
| // A macro to disallow move constructor and operator= | | |
| // This should be used in the private: declarations for a class. | | |
| #define GTEST_DISALLOW_MOVE_AND_ASSIGN_(type) \ | | |
| type(type&&) noexcept = delete; \ | | |
| type& operator=(type&&) noexcept = delete | | |
| | |
| // Tell the compiler to warn about unused return values for functions declared | | // Tell the compiler to warn about unused return values for functions declared |
| // with this macro. The macro should be used on function declarations | | // with this macro. The macro should be used on function declarations |
| // following the argument list: | | // following the argument list: |
| // | | // |
| // Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_; | | // Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_; |
| #if defined(__GNUC__) && !defined(COMPILER_ICC) | | #if defined(__GNUC__) && !defined(COMPILER_ICC) |
|
| # define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result)) | | #define GTEST_MUST_USE_RESULT_ __attribute__((warn_unused_result)) |
| #else | | #else |
|
| # define GTEST_MUST_USE_RESULT_ | | #define GTEST_MUST_USE_RESULT_ |
| #endif // __GNUC__ && !COMPILER_ICC | | #endif // __GNUC__ && !COMPILER_ICC |
| | |
| // MS C++ compiler emits warning when a conditional expression is compile time | | // MS C++ compiler emits warning when a conditional expression is compile time |
| // constant. In some contexts this warning is false positive and needs to be | | // constant. In some contexts this warning is false positive and needs to be |
| // suppressed. Use the following two macros in such cases: | | // suppressed. Use the following two macros in such cases: |
| // | | // |
| // GTEST_INTENTIONAL_CONST_COND_PUSH_() | | // GTEST_INTENTIONAL_CONST_COND_PUSH_() |
| // while (true) { | | // while (true) { |
| // GTEST_INTENTIONAL_CONST_COND_POP_() | | // GTEST_INTENTIONAL_CONST_COND_POP_() |
| // } | | // } |
|
| # define GTEST_INTENTIONAL_CONST_COND_PUSH_() \ | | #define GTEST_INTENTIONAL_CONST_COND_PUSH_() \ |
| GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127) | | GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127) |
| # define GTEST_INTENTIONAL_CONST_COND_POP_() \ | | #define GTEST_INTENTIONAL_CONST_COND_POP_() GTEST_DISABLE_MSC_WARNINGS_POP_() |
| GTEST_DISABLE_MSC_WARNINGS_POP_() | | |
| | |
| // Determine whether the compiler supports Microsoft's Structured Exception | | // Determine whether the compiler supports Microsoft's Structured Exception |
| // Handling. This is supported by several Windows compilers but generally | | // Handling. This is supported by several Windows compilers but generally |
| // does not exist on any other system. | | // does not exist on any other system. |
| #ifndef GTEST_HAS_SEH | | #ifndef GTEST_HAS_SEH |
| // The user didn't tell us, so we need to figure it out. | | // The user didn't tell us, so we need to figure it out. |
| | |
|
| # if defined(_MSC_VER) || defined(__BORLANDC__) | | #if defined(_MSC_VER) || defined(__BORLANDC__) |
| // These two compilers are known to support SEH. | | // These two compilers are known to support SEH. |
|
| # define GTEST_HAS_SEH 1 | | #define GTEST_HAS_SEH 1 |
| # else | | #else |
| // Assume no SEH. | | // Assume no SEH. |
|
| # define GTEST_HAS_SEH 0 | | #define GTEST_HAS_SEH 0 |
| # endif | | #endif |
| | |
| #endif // GTEST_HAS_SEH | | #endif // GTEST_HAS_SEH |
| | |
| #ifndef GTEST_IS_THREADSAFE | | #ifndef GTEST_IS_THREADSAFE |
| | |
| #define GTEST_IS_THREADSAFE \ | | #define GTEST_IS_THREADSAFE \ |
| (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ || \ | | (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ || \ |
| (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) || \ | | (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) || \ |
| GTEST_HAS_PTHREAD) | | GTEST_HAS_PTHREAD) |
| | |
| #endif // GTEST_IS_THREADSAFE | | #endif // GTEST_IS_THREADSAFE |
| | |
|
| | #if GTEST_IS_THREADSAFE |
| | // Some platforms don't support including these threading related headers. |
| | #include <condition_variable> // NOLINT |
| | #include <mutex> // NOLINT |
| | #endif // GTEST_IS_THREADSAFE |
| | |
| // GTEST_API_ qualifies all symbols that must be exported. The definitions below | | // GTEST_API_ qualifies all symbols that must be exported. The definitions below |
| // are guarded by #ifndef to give embedders a chance to define GTEST_API_ in | | // are guarded by #ifndef to give embedders a chance to define GTEST_API_ in |
| // gtest/internal/custom/gtest-port.h | | // gtest/internal/custom/gtest-port.h |
| #ifndef GTEST_API_ | | #ifndef GTEST_API_ |
| | |
| #ifdef _MSC_VER | | #ifdef _MSC_VER |
|
| # if GTEST_LINKED_AS_SHARED_LIBRARY | | #if GTEST_LINKED_AS_SHARED_LIBRARY |
| # define GTEST_API_ __declspec(dllimport) | | #define GTEST_API_ __declspec(dllimport) |
| # elif GTEST_CREATE_SHARED_LIBRARY | | #elif GTEST_CREATE_SHARED_LIBRARY |
| # define GTEST_API_ __declspec(dllexport) | | #define GTEST_API_ __declspec(dllexport) |
| # endif | | #endif |
| #elif __GNUC__ >= 4 || defined(__clang__) | | #elif __GNUC__ >= 4 || defined(__clang__) |
|
| # define GTEST_API_ __attribute__((visibility ("default"))) | | #define GTEST_API_ __attribute__((visibility("default"))) |
| #endif // _MSC_VER | | #endif // _MSC_VER |
| | |
| #endif // GTEST_API_ | | #endif // GTEST_API_ |
| | |
| #ifndef GTEST_API_ | | #ifndef GTEST_API_ |
|
| # define GTEST_API_ | | #define GTEST_API_ |
| #endif // GTEST_API_ | | #endif // GTEST_API_ |
| | |
| #ifndef GTEST_DEFAULT_DEATH_TEST_STYLE | | #ifndef GTEST_DEFAULT_DEATH_TEST_STYLE |
|
| # define GTEST_DEFAULT_DEATH_TEST_STYLE "fast" | | #define GTEST_DEFAULT_DEATH_TEST_STYLE "fast" |
| #endif // GTEST_DEFAULT_DEATH_TEST_STYLE | | #endif // GTEST_DEFAULT_DEATH_TEST_STYLE |
| | |
| #ifdef __GNUC__ | | #ifdef __GNUC__ |
| // Ask the compiler to never inline a given function. | | // Ask the compiler to never inline a given function. |
|
| # define GTEST_NO_INLINE_ __attribute__((noinline)) | | #define GTEST_NO_INLINE_ __attribute__((noinline)) |
| | #else |
| | #define GTEST_NO_INLINE_ |
| | #endif |
| | |
| | #if defined(__clang__) |
| | // Nested ifs to avoid triggering MSVC warning. |
| | #if __has_attribute(disable_tail_calls) |
| | // Ask the compiler not to perform tail call optimization inside |
| | // the marked function. |
| | #define GTEST_NO_TAIL_CALL_ __attribute__((disable_tail_calls)) |
| | #endif |
| | #elif __GNUC__ |
| | #define GTEST_NO_TAIL_CALL_ \ |
| | __attribute__((optimize("no-optimize-sibling-calls"))) |
| #else | | #else |
|
| # define GTEST_NO_INLINE_ | | #define GTEST_NO_TAIL_CALL_ |
| #endif | | #endif |
| | |
| // _LIBCPP_VERSION is defined by the libc++ library from the LLVM project. | | // _LIBCPP_VERSION is defined by the libc++ library from the LLVM project. |
| #if !defined(GTEST_HAS_CXXABI_H_) | | #if !defined(GTEST_HAS_CXXABI_H_) |
|
| # if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER)) | | #if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER)) |
| # define GTEST_HAS_CXXABI_H_ 1 | | #define GTEST_HAS_CXXABI_H_ 1 |
| # else | | #else |
| # define GTEST_HAS_CXXABI_H_ 0 | | #define GTEST_HAS_CXXABI_H_ 0 |
| # endif | | #endif |
| #endif | | #endif |
| | |
| // A function level attribute to disable checking for use of uninitialized | | // A function level attribute to disable checking for use of uninitialized |
| // memory when built with MemorySanitizer. | | // memory when built with MemorySanitizer. |
| #if defined(__clang__) | | #if defined(__clang__) |
|
| # if __has_feature(memory_sanitizer) | | #if __has_feature(memory_sanitizer) |
| # define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \ | | #define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ __attribute__((no_sanitize_memory)) |
| __attribute__((no_sanitize_memory)) | | #else |
| # else | | #define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ |
| # define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ | | #endif // __has_feature(memory_sanitizer) |
| # endif // __has_feature(memory_sanitizer) | | |
| #else | | #else |
|
| # define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ | | #define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ |
| #endif // __clang__ | | #endif // __clang__ |
| | |
| // A function level attribute to disable AddressSanitizer instrumentation. | | // A function level attribute to disable AddressSanitizer instrumentation. |
| #if defined(__clang__) | | #if defined(__clang__) |
|
| # if __has_feature(address_sanitizer) | | #if __has_feature(address_sanitizer) |
| # define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \ | | #define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \ |
| __attribute__((no_sanitize_address)) | | __attribute__((no_sanitize_address)) |
| # else | | |
| # define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ | | |
| # endif // __has_feature(address_sanitizer) | | |
| #else | | #else |
|
| # define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ | | #define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ |
| | #endif // __has_feature(address_sanitizer) |
| | #else |
| | #define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ |
| #endif // __clang__ | | #endif // __clang__ |
| | |
| // A function level attribute to disable HWAddressSanitizer instrumentation. | | // A function level attribute to disable HWAddressSanitizer instrumentation. |
| #if defined(__clang__) | | #if defined(__clang__) |
|
| # if __has_feature(hwaddress_sanitizer) | | #if __has_feature(hwaddress_sanitizer) |
| # define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ \ | | #define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ \ |
| __attribute__((no_sanitize("hwaddress"))) | | __attribute__((no_sanitize("hwaddress"))) |
| # else | | #else |
| # define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ | | #define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ |
| # endif // __has_feature(hwaddress_sanitizer) | | #endif // __has_feature(hwaddress_sanitizer) |
| #else | | #else |
|
| # define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ | | #define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ |
| #endif // __clang__ | | #endif // __clang__ |
| | |
| // A function level attribute to disable ThreadSanitizer instrumentation. | | // A function level attribute to disable ThreadSanitizer instrumentation. |
| #if defined(__clang__) | | #if defined(__clang__) |
|
| # if __has_feature(thread_sanitizer) | | #if __has_feature(thread_sanitizer) |
| # define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \ | | #define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ __attribute__((no_sanitize_thread)) |
| __attribute__((no_sanitize_thread)) | | #else |
| # else | | #define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ |
| # define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ | | #endif // __has_feature(thread_sanitizer) |
| # endif // __has_feature(thread_sanitizer) | | |
| #else | | #else |
|
| # define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ | | #define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ |
| #endif // __clang__ | | #endif // __clang__ |
| | |
| namespace testing { | | namespace testing { |
| | |
| class Message; | | class Message; |
| | |
| // Legacy imports for backwards compatibility. | | // Legacy imports for backwards compatibility. |
| // New code should use std:: names directly. | | // New code should use std:: names directly. |
| using std::get; | | using std::get; |
| using std::make_tuple; | | using std::make_tuple; |
| | |
| skipping to change at line 869 | | skipping to change at line 856 |
|---|
| using std::tuple_element; | | using std::tuple_element; |
| using std::tuple_size; | | using std::tuple_size; |
| | |
| namespace internal { | | namespace internal { |
| | |
| // A secret type that Google Test users don't know about. It has no | | // A secret type that Google Test users don't know about. It has no |
| // definition on purpose. Therefore it's impossible to create a | | // definition on purpose. Therefore it's impossible to create a |
| // Secret object, which is what we want. | | // Secret object, which is what we want. |
| class Secret; | | class Secret; |
| | |
|
| // The GTEST_COMPILE_ASSERT_ is a legacy macro used to verify that a compile | | |
| // time expression is true (in new code, use static_assert instead). For | | |
| // example, you could use it to verify the size of a static array: | | |
| // | | |
| // GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES, | | |
| // names_incorrect_size); | | |
| // | | |
| // The second argument to the macro must be a valid C++ identifier. If the | | |
| // expression is false, compiler will issue an error containing this identifier. | | |
| #define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg) | | |
| | | |
| // A helper for suppressing warnings on constant condition. It just | | // A helper for suppressing warnings on constant condition. It just |
| // returns 'condition'. | | // returns 'condition'. |
| GTEST_API_ bool IsTrue(bool condition); | | GTEST_API_ bool IsTrue(bool condition); |
| | |
| // Defines RE. | | // Defines RE. |
| | |
|
| #if GTEST_USES_PCRE | | #if GTEST_USES_RE2 |
| // if used, PCRE is injected by custom/gtest-port.h | | |
| | // This is almost `using RE = ::RE2`, except it is copy-constructible, and it |
| | // needs to disambiguate the `std::string`, `absl::string_view`, and `const |
| | // char*` constructors. |
| | class GTEST_API_ RE { |
| | public: |
| | RE(absl::string_view regex) : regex_(regex) {} // NOLINT |
| | RE(const char* regex) : RE(absl::string_view(regex)) {} // NOLINT |
| | RE(const std::string& regex) : RE(absl::string_view(regex)) {} // NOLINT |
| | RE(const RE& other) : RE(other.pattern()) {} |
| | |
| | const std::string& pattern() const { return regex_.pattern(); } |
| | |
| | static bool FullMatch(absl::string_view str, const RE& re) { |
| | return RE2::FullMatch(str, re.regex_); |
| | } |
| | static bool PartialMatch(absl::string_view str, const RE& re) { |
| | return RE2::PartialMatch(str, re.regex_); |
| | } |
| | |
| | private: |
| | RE2 regex_; |
| | }; |
| | |
| #elif GTEST_USES_POSIX_RE || GTEST_USES_SIMPLE_RE | | #elif GTEST_USES_POSIX_RE || GTEST_USES_SIMPLE_RE |
| | |
| // A simple C++ wrapper for <regex.h>. It uses the POSIX Extended | | // A simple C++ wrapper for <regex.h>. It uses the POSIX Extended |
| // Regular Expression syntax. | | // Regular Expression syntax. |
| class GTEST_API_ RE { | | class GTEST_API_ RE { |
| public: | | public: |
| // A copy constructor is required by the Standard to initialize object | | // A copy constructor is required by the Standard to initialize object |
| // references from r-values. | | // references from r-values. |
| RE(const RE& other) { Init(other.pattern()); } | | RE(const RE& other) { Init(other.pattern()); } |
| | |
| | |
| skipping to change at line 926 | | skipping to change at line 925 |
|---|
| } | | } |
| | |
| static bool FullMatch(const char* str, const RE& re); | | static bool FullMatch(const char* str, const RE& re); |
| static bool PartialMatch(const char* str, const RE& re); | | static bool PartialMatch(const char* str, const RE& re); |
| | |
| private: | | private: |
| void Init(const char* regex); | | void Init(const char* regex); |
| const char* pattern_; | | const char* pattern_; |
| bool is_valid_; | | bool is_valid_; |
| | |
|
| # if GTEST_USES_POSIX_RE | | #if GTEST_USES_POSIX_RE |
| | |
| regex_t full_regex_; // For FullMatch(). | | regex_t full_regex_; // For FullMatch(). |
| regex_t partial_regex_; // For PartialMatch(). | | regex_t partial_regex_; // For PartialMatch(). |
| | |
|
| # else // GTEST_USES_SIMPLE_RE | | #else // GTEST_USES_SIMPLE_RE |
| | |
| const char* full_pattern_; // For FullMatch(); | | const char* full_pattern_; // For FullMatch(); |
| | |
|
| # endif | | #endif |
| }; | | }; |
| | |
|
| #endif // GTEST_USES_PCRE | | #endif // ::testing::internal::RE implementation |
| | |
| // Formats a source file path and a line number as they would appear | | // Formats a source file path and a line number as they would appear |
| // in an error message from the compiler used to compile this code. | | // in an error message from the compiler used to compile this code. |
| GTEST_API_ ::std::string FormatFileLocation(const char* file, int line); | | GTEST_API_ ::std::string FormatFileLocation(const char* file, int line); |
| | |
| // Formats a file location for compiler-independent XML output. | | // Formats a file location for compiler-independent XML output. |
| // Although this function is not platform dependent, we put it next to | | // Although this function is not platform dependent, we put it next to |
| // FormatFileLocation in order to contrast the two functions. | | // FormatFileLocation in order to contrast the two functions. |
| GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file, | | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file, |
| int line); | | int line); |
| | |
| // Defines logging utilities: | | // Defines logging utilities: |
| // GTEST_LOG_(severity) - logs messages at the specified severity level. The | | // GTEST_LOG_(severity) - logs messages at the specified severity level. The |
| // message itself is streamed into the macro. | | // message itself is streamed into the macro. |
| // LogToStderr() - directs all log messages to stderr. | | // LogToStderr() - directs all log messages to stderr. |
| // FlushInfoLog() - flushes informational log messages. | | // FlushInfoLog() - flushes informational log messages. |
| | |
|
| enum GTestLogSeverity { | | enum GTestLogSeverity { GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL }; |
| GTEST_INFO, | | |
| GTEST_WARNING, | | |
| GTEST_ERROR, | | |
| GTEST_FATAL | | |
| }; | | |
| | |
| // Formats log entry severity, provides a stream object for streaming the | | // Formats log entry severity, provides a stream object for streaming the |
| // log message, and terminates the message with a newline when going out of | | // log message, and terminates the message with a newline when going out of |
| // scope. | | // scope. |
| class GTEST_API_ GTestLog { | | class GTEST_API_ GTestLog { |
| public: | | public: |
| GTestLog(GTestLogSeverity severity, const char* file, int line); | | GTestLog(GTestLogSeverity severity, const char* file, int line); |
| | |
| // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program. | | // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program. |
| ~GTestLog(); | | ~GTestLog(); |
| | |
| ::std::ostream& GetStream() { return ::std::cerr; } | | ::std::ostream& GetStream() { return ::std::cerr; } |
| | |
| private: | | private: |
| const GTestLogSeverity severity_; | | const GTestLogSeverity severity_; |
| | |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog); | | GTestLog(const GTestLog&) = delete; |
| | GTestLog& operator=(const GTestLog&) = delete; |
| }; | | }; |
| | |
| #if !defined(GTEST_LOG_) | | #if !defined(GTEST_LOG_) |
| | |
|
| # define GTEST_LOG_(severity) \ | | #define GTEST_LOG_(severity) \ |
| ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ | | ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ |
| __FILE__, __LINE__).GetStream() | | __FILE__, __LINE__) \ |
| | .GetStream() |
| | |
| inline void LogToStderr() {} | | inline void LogToStderr() {} |
| inline void FlushInfoLog() { fflush(nullptr); } | | inline void FlushInfoLog() { fflush(nullptr); } |
| | |
| #endif // !defined(GTEST_LOG_) | | #endif // !defined(GTEST_LOG_) |
| | |
| #if !defined(GTEST_CHECK_) | | #if !defined(GTEST_CHECK_) |
| // INTERNAL IMPLEMENTATION - DO NOT USE. | | // INTERNAL IMPLEMENTATION - DO NOT USE. |
| // | | // |
| // GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition | | // GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition |
| // is not satisfied. | | // is not satisfied. |
|
| // Synopsys: | | // Synopsis: |
| // GTEST_CHECK_(boolean_condition); | | // GTEST_CHECK_(boolean_condition); |
| // or | | // or |
| // GTEST_CHECK_(boolean_condition) << "Additional message"; | | // GTEST_CHECK_(boolean_condition) << "Additional message"; |
| // | | // |
| // This checks the condition and if the condition is not satisfied | | // This checks the condition and if the condition is not satisfied |
| // it prints message about the condition violation, including the | | // it prints message about the condition violation, including the |
| // condition itself, plus additional message streamed into it, if any, | | // condition itself, plus additional message streamed into it, if any, |
| // and then it aborts the program. It aborts the program irrespective of | | // and then it aborts the program. It aborts the program irrespective of |
| // whether it is built in the debug mode or not. | | // whether it is built in the debug mode or not. |
|
| # define GTEST_CHECK_(condition) \ | | #define GTEST_CHECK_(condition) \ |
| GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ | | GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ |
| if (::testing::internal::IsTrue(condition)) \ | | if (::testing::internal::IsTrue(condition)) \ |
| ; \ | | ; \ |
| else \ | | else \ |
| GTEST_LOG_(FATAL) << "Condition " #condition " failed. " | | GTEST_LOG_(FATAL) << "Condition " #condition " failed. " |
| #endif // !defined(GTEST_CHECK_) | | #endif // !defined(GTEST_CHECK_) |
| | |
| // An all-mode assert to verify that the given POSIX-style function | | // An all-mode assert to verify that the given POSIX-style function |
| // call returns 0 (indicating success). Known limitation: this | | // call returns 0 (indicating success). Known limitation: this |
| // doesn't expand to a balanced 'if' statement, so enclose the macro | | // doesn't expand to a balanced 'if' statement, so enclose the macro |
| // in {} if you need to use it as the only statement in an 'if' | | // in {} if you need to use it as the only statement in an 'if' |
| // branch. | | // branch. |
| #define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \ | | #define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \ |
|
| if (const int gtest_error = (posix_call)) \ | | if (const int gtest_error = (posix_call)) \ |
| GTEST_LOG_(FATAL) << #posix_call << "failed with error " \ | | GTEST_LOG_(FATAL) << #posix_call << "failed with error " << gtest_error |
| << gtest_error | | |
| | |
| // Transforms "T" into "const T&" according to standard reference collapsing | | // Transforms "T" into "const T&" according to standard reference collapsing |
| // rules (this is only needed as a backport for C++98 compilers that do not | | // rules (this is only needed as a backport for C++98 compilers that do not |
| // support reference collapsing). Specifically, it transforms: | | // support reference collapsing). Specifically, it transforms: |
| // | | // |
| // char ==> const char& | | // char ==> const char& |
| // const char ==> const char& | | // const char ==> const char& |
| // char& ==> char& | | // char& ==> char& |
| // const char& ==> const char& | | // const char& ==> const char& |
| // | | // |
| // Note that the non-const reference will not have "const" added. This is | | // Note that the non-const reference will not have "const" added. This is |
| // standard, and necessary so that "T" can always bind to "const T&". | | // standard, and necessary so that "T" can always bind to "const T&". |
| template <typename T> | | template <typename T> |
|
| struct ConstRef { typedef const T& type; }; | | struct ConstRef { |
| | typedef const T& type; |
| | }; |
| template <typename T> | | template <typename T> |
|
| struct ConstRef<T&> { typedef T& type; }; | | struct ConstRef<T&> { |
| | typedef T& type; |
| | }; |
| | |
| // The argument T must depend on some template parameters. | | // The argument T must depend on some template parameters. |
| #define GTEST_REFERENCE_TO_CONST_(T) \ | | #define GTEST_REFERENCE_TO_CONST_(T) \ |
| typename ::testing::internal::ConstRef<T>::type | | typename ::testing::internal::ConstRef<T>::type |
| | |
| // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. | | // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. |
| // | | // |
| // Use ImplicitCast_ as a safe version of static_cast for upcasting in | | // Use ImplicitCast_ as a safe version of static_cast for upcasting in |
| // the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a | | // the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a |
| // const Foo*). When you use ImplicitCast_, the compiler checks that | | // const Foo*). When you use ImplicitCast_, the compiler checks that |
| // the cast is safe. Such explicit ImplicitCast_s are necessary in | | // the cast is safe. Such explicit ImplicitCast_s are necessary in |
| // surprisingly many situations where C++ demands an exact type match | | // surprisingly many situations where C++ demands an exact type match |
|
| // instead of an argument type convertable to a target type. | | // instead of an argument type convertible to a target type. |
| // | | // |
| // The syntax for using ImplicitCast_ is the same as for static_cast: | | // The syntax for using ImplicitCast_ is the same as for static_cast: |
| // | | // |
| // ImplicitCast_<ToType>(expr) | | // ImplicitCast_<ToType>(expr) |
| // | | // |
| // ImplicitCast_ would have been part of the C++ standard library, | | // ImplicitCast_ would have been part of the C++ standard library, |
| // but the proposal was submitted too late. It will probably make | | // but the proposal was submitted too late. It will probably make |
| // its way into the language in the future. | | // its way into the language in the future. |
| // | | // |
| // This relatively ugly name is intentional. It prevents clashes with | | // This relatively ugly name is intentional. It prevents clashes with |
| // similar functions users may have (e.g., implicit_cast). The internal | | // similar functions users may have (e.g., implicit_cast). The internal |
| // namespace alone is not enough because the function can be found by ADL. | | // namespace alone is not enough because the function can be found by ADL. |
|
| template<typename To> | | template <typename To> |
| inline To ImplicitCast_(To x) { return x; } | | inline To ImplicitCast_(To x) { |
| | return x; |
| | } |
| | |
| // When you upcast (that is, cast a pointer from type Foo to type | | // When you upcast (that is, cast a pointer from type Foo to type |
| // SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts | | // SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts |
| // always succeed. When you downcast (that is, cast a pointer from | | // always succeed. When you downcast (that is, cast a pointer from |
| // type Foo to type SubclassOfFoo), static_cast<> isn't safe, because | | // type Foo to type SubclassOfFoo), static_cast<> isn't safe, because |
| // how do you know the pointer is really of type SubclassOfFoo? It | | // how do you know the pointer is really of type SubclassOfFoo? It |
| // could be a bare Foo, or of type DifferentSubclassOfFoo. Thus, | | // could be a bare Foo, or of type DifferentSubclassOfFoo. Thus, |
| // when you downcast, you should use this macro. In debug mode, we | | // when you downcast, you should use this macro. In debug mode, we |
| // use dynamic_cast<> to double-check the downcast is legal (we die | | // use dynamic_cast<> to double-check the downcast is legal (we die |
| // if it's not). In normal mode, we do the efficient static_cast<> | | // if it's not). In normal mode, we do the efficient static_cast<> |
| | |
| skipping to change at line 1089 | | skipping to change at line 1090 |
|---|
| // This is the only place in the code we should use dynamic_cast<>. | | // This is the only place in the code we should use dynamic_cast<>. |
| // In particular, you SHOULDN'T be using dynamic_cast<> in order to | | // In particular, you SHOULDN'T be using dynamic_cast<> in order to |
| // do RTTI (eg code like this: | | // do RTTI (eg code like this: |
| // if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo); | | // if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo); |
| // if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo); | | // if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo); |
| // You should design the code some other way not to need this. | | // You should design the code some other way not to need this. |
| // | | // |
| // This relatively ugly name is intentional. It prevents clashes with | | // This relatively ugly name is intentional. It prevents clashes with |
| // similar functions users may have (e.g., down_cast). The internal | | // similar functions users may have (e.g., down_cast). The internal |
| // namespace alone is not enough because the function can be found by ADL. | | // namespace alone is not enough because the function can be found by ADL. |
|
| template<typename To, typename From> // use like this: DownCast_<T*>(foo); | | template <typename To, typename From> // use like this: DownCast_<T*>(foo); |
| inline To DownCast_(From* f) { // so we only accept pointers | | inline To DownCast_(From* f) { // so we only accept pointers |
| // Ensures that To is a sub-type of From *. This test is here only | | // Ensures that To is a sub-type of From *. This test is here only |
| // for compile-time type checking, and has no overhead in an | | // for compile-time type checking, and has no overhead in an |
| // optimized build at run-time, as it will be optimized away | | // optimized build at run-time, as it will be optimized away |
| // completely. | | // completely. |
| GTEST_INTENTIONAL_CONST_COND_PUSH_() | | GTEST_INTENTIONAL_CONST_COND_PUSH_() |
| if (false) { | | if (false) { |
|
| GTEST_INTENTIONAL_CONST_COND_POP_() | | GTEST_INTENTIONAL_CONST_COND_POP_() |
| const To to = nullptr; | | const To to = nullptr; |
| ::testing::internal::ImplicitCast_<From*>(to); | | ::testing::internal::ImplicitCast_<From*>(to); |
| } | | } |
| | |
| #if GTEST_HAS_RTTI | | #if GTEST_HAS_RTTI |
| // RTTI: debug mode only! | | // RTTI: debug mode only! |
| GTEST_CHECK_(f == nullptr || dynamic_cast<To>(f) != nullptr); | | GTEST_CHECK_(f == nullptr || dynamic_cast<To>(f) != nullptr); |
| #endif | | #endif |
| return static_cast<To>(f); | | return static_cast<To>(f); |
| } | | } |
| | |
| // Downcasts the pointer of type Base to Derived. | | // Downcasts the pointer of type Base to Derived. |
| | |
| skipping to change at line 1164 | | skipping to change at line 1165 |
|---|
| std::vector<std::string> GetInjectableArgvs(); | | std::vector<std::string> GetInjectableArgvs(); |
| // Deprecated: pass the args vector by value instead. | | // Deprecated: pass the args vector by value instead. |
| void SetInjectableArgvs(const std::vector<std::string>* new_argvs); | | void SetInjectableArgvs(const std::vector<std::string>* new_argvs); |
| void SetInjectableArgvs(const std::vector<std::string>& new_argvs); | | void SetInjectableArgvs(const std::vector<std::string>& new_argvs); |
| void ClearInjectableArgvs(); | | void ClearInjectableArgvs(); |
| | |
| #endif // GTEST_HAS_DEATH_TEST | | #endif // GTEST_HAS_DEATH_TEST |
| | |
| // Defines synchronization primitives. | | // Defines synchronization primitives. |
| #if GTEST_IS_THREADSAFE | | #if GTEST_IS_THREADSAFE |
|
| # if GTEST_HAS_PTHREAD | | |
| // Sleeps for (roughly) n milliseconds. This function is only for testing | | |
| // Google Test's own constructs. Don't use it in user tests, either | | |
| // directly or indirectly. | | |
| inline void SleepMilliseconds(int n) { | | |
| const timespec time = { | | |
| 0, // 0 seconds. | | |
| n * 1000L * 1000L, // And n ms. | | |
| }; | | |
| nanosleep(&time, nullptr); | | |
| } | | |
| # endif // GTEST_HAS_PTHREAD | | |
| | |
| # if GTEST_HAS_NOTIFICATION_ | | |
| // Notification has already been imported into the namespace. | | |
| // Nothing to do here. | | |
| | |
| # elif GTEST_HAS_PTHREAD | | |
| // Allows a controller thread to pause execution of newly created | | |
| // threads until notified. Instances of this class must be created | | |
| // and destroyed in the controller thread. | | |
| // | | |
| // This class is only for testing Google Test's own constructs. Do not | | |
| // use it in user tests, either directly or indirectly. | | |
| class Notification { | | |
| public: | | |
| Notification() : notified_(false) { | | |
| GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr)); | | |
| } | | |
| ~Notification() { | | |
| pthread_mutex_destroy(&mutex_); | | |
| } | | |
| | |
| // Notifies all threads created with this notification to start. Must | | |
| // be called from the controller thread. | | |
| void Notify() { | | |
| pthread_mutex_lock(&mutex_); | | |
| notified_ = true; | | |
| pthread_mutex_unlock(&mutex_); | | |
| } | | |
| | |
| // Blocks until the controller thread notifies. Must be called from a test | | |
| // thread. | | |
| void WaitForNotification() { | | |
| for (;;) { | | |
| pthread_mutex_lock(&mutex_); | | |
| const bool notified = notified_; | | |
| pthread_mutex_unlock(&mutex_); | | |
| if (notified) | | |
| break; | | |
| SleepMilliseconds(10); | | |
| } | | |
| } | | |
| | |
| private: | | |
| pthread_mutex_t mutex_; | | |
| bool notified_; | | |
| | |
| GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification); | | |
| }; | | |
| | |
| # elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT | | |
| | |
| GTEST_API_ void SleepMilliseconds(int n); | | |
| | |
|
| | #if GTEST_OS_WINDOWS |
| // Provides leak-safe Windows kernel handle ownership. | | // Provides leak-safe Windows kernel handle ownership. |
| // Used in death tests and in threading support. | | // Used in death tests and in threading support. |
| class GTEST_API_ AutoHandle { | | class GTEST_API_ AutoHandle { |
| public: | | public: |
| // Assume that Win32 HANDLE type is equivalent to void*. Doing so allows us to | | // Assume that Win32 HANDLE type is equivalent to void*. Doing so allows us to |
| // avoid including <windows.h> in this header file. Including <windows.h> is | | // avoid including <windows.h> in this header file. Including <windows.h> is |
| // undesirable because it defines a lot of symbols and macros that tend to | | // undesirable because it defines a lot of symbols and macros that tend to |
| // conflict with client code. This assumption is verified by | | // conflict with client code. This assumption is verified by |
| // WindowsTypesTest.HANDLEIsVoidStar. | | // WindowsTypesTest.HANDLEIsVoidStar. |
| typedef void* Handle; | | typedef void* Handle; |
| | |
| skipping to change at line 1255 | | skipping to change at line 1193 |
|---|
| void Reset(); | | void Reset(); |
| void Reset(Handle handle); | | void Reset(Handle handle); |
| | |
| private: | | private: |
| // Returns true if and only if the handle is a valid handle object that can be | | // Returns true if and only if the handle is a valid handle object that can be |
| // closed. | | // closed. |
| bool IsCloseable() const; | | bool IsCloseable() const; |
| | |
| Handle handle_; | | Handle handle_; |
| | |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle); | | AutoHandle(const AutoHandle&) = delete; |
| | AutoHandle& operator=(const AutoHandle&) = delete; |
| }; | | }; |
|
| | #endif |
| | |
| | #if GTEST_HAS_NOTIFICATION_ |
| | // Notification has already been imported into the namespace. |
| | // Nothing to do here. |
| | |
| | #else |
| | GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ |
| | /* class A needs to have dll-interface to be used by clients of class B */) |
| | |
| // Allows a controller thread to pause execution of newly created | | // Allows a controller thread to pause execution of newly created |
| // threads until notified. Instances of this class must be created | | // threads until notified. Instances of this class must be created |
| // and destroyed in the controller thread. | | // and destroyed in the controller thread. |
| // | | // |
| // This class is only for testing Google Test's own constructs. Do not | | // This class is only for testing Google Test's own constructs. Do not |
| // use it in user tests, either directly or indirectly. | | // use it in user tests, either directly or indirectly. |
|
| | // TODO(b/203539622): Replace unconditionally with absl::Notification. |
| class GTEST_API_ Notification { | | class GTEST_API_ Notification { |
| public: | | public: |
|
| Notification(); | | Notification() : notified_(false) {} |
| void Notify(); | | Notification(const Notification&) = delete; |
| void WaitForNotification(); | | Notification& operator=(const Notification&) = delete; |
| | |
|
| private: | | // Notifies all threads created with this notification to start. Must |
| AutoHandle event_; | | // be called from the controller thread. |
| | void Notify() { |
| | std::lock_guard<std::mutex> lock(mu_); |
| | notified_ = true; |
| | cv_.notify_all(); |
| | } |
| | |
| | // Blocks until the controller thread notifies. Must be called from a test |
| | // thread. |
| | void WaitForNotification() { |
| | std::unique_lock<std::mutex> lock(mu_); |
| | cv_.wait(lock, [this]() { return notified_; }); |
| | } |
| | |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification); | | private: |
| | std::mutex mu_; |
| | std::condition_variable cv_; |
| | bool notified_; |
| }; | | }; |
|
| # endif // GTEST_HAS_NOTIFICATION_ | | GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 |
| | #endif // GTEST_HAS_NOTIFICATION_ |
| | |
| // On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD | | // On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD |
| // defined, but we don't want to use MinGW's pthreads implementation, which | | // defined, but we don't want to use MinGW's pthreads implementation, which |
| // has conformance problems with some versions of the POSIX standard. | | // has conformance problems with some versions of the POSIX standard. |
|
| # if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW | | #if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW |
| | |
| // As a C-function, ThreadFuncWithCLinkage cannot be templated itself. | | // As a C-function, ThreadFuncWithCLinkage cannot be templated itself. |
| // Consequently, it cannot select a correct instantiation of ThreadWithParam | | // Consequently, it cannot select a correct instantiation of ThreadWithParam |
| // in order to call its Run(). Introducing ThreadWithParamBase as a | | // in order to call its Run(). Introducing ThreadWithParamBase as a |
| // non-templated base class for ThreadWithParam allows us to bypass this | | // non-templated base class for ThreadWithParam allows us to bypass this |
| // problem. | | // problem. |
| class ThreadWithParamBase { | | class ThreadWithParamBase { |
| public: | | public: |
| virtual ~ThreadWithParamBase() {} | | virtual ~ThreadWithParamBase() {} |
| virtual void Run() = 0; | | virtual void Run() = 0; |
| | |
| skipping to change at line 1356 | | skipping to change at line 1321 |
|---|
| private: | | private: |
| UserThreadFunc* const func_; // User-supplied thread function. | | UserThreadFunc* const func_; // User-supplied thread function. |
| const T param_; // User-supplied parameter to the thread function. | | const T param_; // User-supplied parameter to the thread function. |
| // When non-NULL, used to block execution until the controller thread | | // When non-NULL, used to block execution until the controller thread |
| // notifies. | | // notifies. |
| Notification* const thread_can_start_; | | Notification* const thread_can_start_; |
| bool finished_; // true if and only if we know that the thread function has | | bool finished_; // true if and only if we know that the thread function has |
| // finished. | | // finished. |
| pthread_t thread_; // The native thread object. | | pthread_t thread_; // The native thread object. |
| | |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam); | | ThreadWithParam(const ThreadWithParam&) = delete; |
| | ThreadWithParam& operator=(const ThreadWithParam&) = delete; |
| }; | | }; |
|
| # endif // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD || | | #endif // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD || |
| // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ | | // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ |
| | |
|
| # if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ | | #if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ |
| // Mutex and ThreadLocal have already been imported into the namespace. | | // Mutex and ThreadLocal have already been imported into the namespace. |
| // Nothing to do here. | | // Nothing to do here. |
| | |
|
| # elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT | | #elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT |
| | |
| // Mutex implements mutex on Windows platforms. It is used in conjunction | | // Mutex implements mutex on Windows platforms. It is used in conjunction |
| // with class MutexLock: | | // with class MutexLock: |
| // | | // |
| // Mutex mutex; | | // Mutex mutex; |
| // ... | | // ... |
| // MutexLock lock(&mutex); // Acquires the mutex and releases it at the | | // MutexLock lock(&mutex); // Acquires the mutex and releases it at the |
| // // end of the current scope. | | // // end of the current scope. |
| // | | // |
| // A static Mutex *must* be defined or declared using one of the following | | // A static Mutex *must* be defined or declared using one of the following |
| | |
| skipping to change at line 1419 | | skipping to change at line 1385 |
|---|
| // Per https://blogs.msdn.microsoft.com/oldnewthing/20040223-00/?p=40503, | | // Per https://blogs.msdn.microsoft.com/oldnewthing/20040223-00/?p=40503, |
| // we assume that 0 is an invalid value for thread IDs. | | // we assume that 0 is an invalid value for thread IDs. |
| unsigned int owner_thread_id_; | | unsigned int owner_thread_id_; |
| | |
| // For static mutexes, we rely on these members being initialized to zeros | | // For static mutexes, we rely on these members being initialized to zeros |
| // by the linker. | | // by the linker. |
| MutexType type_; | | MutexType type_; |
| long critical_section_init_phase_; // NOLINT | | long critical_section_init_phase_; // NOLINT |
| GTEST_CRITICAL_SECTION* critical_section_; | | GTEST_CRITICAL_SECTION* critical_section_; |
| | |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex); | | Mutex(const Mutex&) = delete; |
| | Mutex& operator=(const Mutex&) = delete; |
| }; | | }; |
| | |
|
| # define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ | | #define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ |
| extern ::testing::internal::Mutex mutex | | extern ::testing::internal::Mutex mutex |
| | |
|
| # define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ | | #define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ |
| ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex) | | ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex) |
| | |
| // We cannot name this class MutexLock because the ctor declaration would | | // We cannot name this class MutexLock because the ctor declaration would |
| // conflict with a macro named MutexLock, which is defined on some | | // conflict with a macro named MutexLock, which is defined on some |
| // platforms. That macro is used as a defensive measure to prevent against | | // platforms. That macro is used as a defensive measure to prevent against |
| // inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than | | // inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than |
| // "MutexLock l(&mu)". Hence the typedef trick below. | | // "MutexLock l(&mu)". Hence the typedef trick below. |
| class GTestMutexLock { | | class GTestMutexLock { |
| public: | | public: |
|
| explicit GTestMutexLock(Mutex* mutex) | | explicit GTestMutexLock(Mutex* mutex) : mutex_(mutex) { mutex_->Lock(); } |
| : mutex_(mutex) { mutex_->Lock(); } | | |
| | |
| ~GTestMutexLock() { mutex_->Unlock(); } | | ~GTestMutexLock() { mutex_->Unlock(); } |
| | |
| private: | | private: |
| Mutex* const mutex_; | | Mutex* const mutex_; |
| | |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock); | | GTestMutexLock(const GTestMutexLock&) = delete; |
| | GTestMutexLock& operator=(const GTestMutexLock&) = delete; |
| }; | | }; |
| | |
| typedef GTestMutexLock MutexLock; | | typedef GTestMutexLock MutexLock; |
| | |
| // Base class for ValueHolder<T>. Allows a caller to hold and delete a value | | // Base class for ValueHolder<T>. Allows a caller to hold and delete a value |
| // without knowing its type. | | // without knowing its type. |
| class ThreadLocalValueHolderBase { | | class ThreadLocalValueHolderBase { |
| public: | | public: |
| virtual ~ThreadLocalValueHolderBase() {} | | virtual ~ThreadLocalValueHolderBase() {} |
| }; | | }; |
| | |
| skipping to change at line 1470 | | skipping to change at line 1437 |
|---|
| // this ThreadLocal<T>'s constructor and returns it. It is the caller's | | // this ThreadLocal<T>'s constructor and returns it. It is the caller's |
| // responsibility not to call this when the ThreadLocal<T> instance already | | // responsibility not to call this when the ThreadLocal<T> instance already |
| // has a value on the current thread. | | // has a value on the current thread. |
| virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const = 0; | | virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const = 0; |
| | |
| protected: | | protected: |
| ThreadLocalBase() {} | | ThreadLocalBase() {} |
| virtual ~ThreadLocalBase() {} | | virtual ~ThreadLocalBase() {} |
| | |
| private: | | private: |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase); | | ThreadLocalBase(const ThreadLocalBase&) = delete; |
| | ThreadLocalBase& operator=(const ThreadLocalBase&) = delete; |
| }; | | }; |
| | |
| // Maps a thread to a set of ThreadLocals that have values instantiated on that | | // Maps a thread to a set of ThreadLocals that have values instantiated on that |
| // thread and notifies them when the thread exits. A ThreadLocal instance is | | // thread and notifies them when the thread exits. A ThreadLocal instance is |
| // expected to persist until all threads it has values on have terminated. | | // expected to persist until all threads it has values on have terminated. |
| class GTEST_API_ ThreadLocalRegistry { | | class GTEST_API_ ThreadLocalRegistry { |
| public: | | public: |
| // Registers thread_local_instance as having value on the current thread. | | // Registers thread_local_instance as having value on the current thread. |
| // Returns a value that can be used to identify the thread from other threads. | | // Returns a value that can be used to identify the thread from other threads. |
| static ThreadLocalValueHolderBase* GetValueOnCurrentThread( | | static ThreadLocalValueHolderBase* GetValueOnCurrentThread( |
| | |
| skipping to change at line 1499 | | skipping to change at line 1467 |
|---|
| public: | | public: |
| void Join(); | | void Join(); |
| | |
| protected: | | protected: |
| class Runnable { | | class Runnable { |
| public: | | public: |
| virtual ~Runnable() {} | | virtual ~Runnable() {} |
| virtual void Run() = 0; | | virtual void Run() = 0; |
| }; | | }; |
| | |
|
| ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start); | | ThreadWithParamBase(Runnable* runnable, Notification* thread_can_start); |
| virtual ~ThreadWithParamBase(); | | virtual ~ThreadWithParamBase(); |
| | |
| private: | | private: |
| AutoHandle thread_; | | AutoHandle thread_; |
| }; | | }; |
| | |
| // Helper class for testing Google Test's multi-threading constructs. | | // Helper class for testing Google Test's multi-threading constructs. |
| template <typename T> | | template <typename T> |
| class ThreadWithParam : public ThreadWithParamBase { | | class ThreadWithParam : public ThreadWithParamBase { |
| public: | | public: |
| typedef void UserThreadFunc(T); | | typedef void UserThreadFunc(T); |
| | |
| ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start) | | ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start) |
|
| : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) { | | : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {} |
| } | | |
| virtual ~ThreadWithParam() {} | | virtual ~ThreadWithParam() {} |
| | |
| private: | | private: |
| class RunnableImpl : public Runnable { | | class RunnableImpl : public Runnable { |
| public: | | public: |
|
| RunnableImpl(UserThreadFunc* func, T param) | | RunnableImpl(UserThreadFunc* func, T param) : func_(func), param_(param) {} |
| : func_(func), | | |
| param_(param) { | | |
| } | | |
| virtual ~RunnableImpl() {} | | virtual ~RunnableImpl() {} |
|
| virtual void Run() { | | virtual void Run() { func_(param_); } |
| func_(param_); | | |
| } | | |
| | |
| private: | | private: |
| UserThreadFunc* const func_; | | UserThreadFunc* const func_; |
| const T param_; | | const T param_; |
| | |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl); | | RunnableImpl(const RunnableImpl&) = delete; |
| | RunnableImpl& operator=(const RunnableImpl&) = delete; |
| }; | | }; |
| | |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam); | | ThreadWithParam(const ThreadWithParam&) = delete; |
| | ThreadWithParam& operator=(const ThreadWithParam&) = delete; |
| }; | | }; |
| | |
| // Implements thread-local storage on Windows systems. | | // Implements thread-local storage on Windows systems. |
| // | | // |
| // // Thread 1 | | // // Thread 1 |
| // ThreadLocal<int> tl(100); // 100 is the default value for each thread. | | // ThreadLocal<int> tl(100); // 100 is the default value for each thread. |
| // | | // |
| // // Thread 2 | | // // Thread 2 |
| // tl.set(150); // Changes the value for thread 2 only. | | // tl.set(150); // Changes the value for thread 2 only. |
| // EXPECT_EQ(150, tl.get()); | | // EXPECT_EQ(150, tl.get()); |
| | |
| skipping to change at line 1573 | | skipping to change at line 1537 |
|---|
| // will die after main() has returned. Therefore, no per-thread | | // will die after main() has returned. Therefore, no per-thread |
| // object managed by Google Test will be leaked as long as all threads | | // object managed by Google Test will be leaked as long as all threads |
| // using Google Test have exited when main() returns. | | // using Google Test have exited when main() returns. |
| template <typename T> | | template <typename T> |
| class ThreadLocal : public ThreadLocalBase { | | class ThreadLocal : public ThreadLocalBase { |
| public: | | public: |
| ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {} | | ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {} |
| explicit ThreadLocal(const T& value) | | explicit ThreadLocal(const T& value) |
| : default_factory_(new InstanceValueHolderFactory(value)) {} | | : default_factory_(new InstanceValueHolderFactory(value)) {} |
| | |
|
| ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(this); } | | ~ThreadLocal() override { ThreadLocalRegistry::OnThreadLocalDestroyed(this); } |
| | |
| T* pointer() { return GetOrCreateValue(); } | | T* pointer() { return GetOrCreateValue(); } |
| const T* pointer() const { return GetOrCreateValue(); } | | const T* pointer() const { return GetOrCreateValue(); } |
| const T& get() const { return *pointer(); } | | const T& get() const { return *pointer(); } |
| void set(const T& value) { *pointer() = value; } | | void set(const T& value) { *pointer() = value; } |
| | |
| private: | | private: |
| // Holds a value of T. Can be deleted via its base class without the caller | | // Holds a value of T. Can be deleted via its base class without the caller |
| // knowing the type of T. | | // knowing the type of T. |
| class ValueHolder : public ThreadLocalValueHolderBase { | | class ValueHolder : public ThreadLocalValueHolderBase { |
| public: | | public: |
| ValueHolder() : value_() {} | | ValueHolder() : value_() {} |
| explicit ValueHolder(const T& value) : value_(value) {} | | explicit ValueHolder(const T& value) : value_(value) {} |
| | |
| T* pointer() { return &value_; } | | T* pointer() { return &value_; } |
| | |
| private: | | private: |
| T value_; | | T value_; |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder); | | ValueHolder(const ValueHolder&) = delete; |
| | ValueHolder& operator=(const ValueHolder&) = delete; |
| }; | | }; |
| | |
| T* GetOrCreateValue() const { | | T* GetOrCreateValue() const { |
| return static_cast<ValueHolder*>( | | return static_cast<ValueHolder*>( |
|
| ThreadLocalRegistry::GetValueOnCurrentThread(this))->pointer(); | | ThreadLocalRegistry::GetValueOnCurrentThread(this)) |
| | ->pointer(); |
| } | | } |
| | |
|
| virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const { | | ThreadLocalValueHolderBase* NewValueForCurrentThread() const override { |
| return default_factory_->MakeNewHolder(); | | return default_factory_->MakeNewHolder(); |
| } | | } |
| | |
| class ValueHolderFactory { | | class ValueHolderFactory { |
| public: | | public: |
| ValueHolderFactory() {} | | ValueHolderFactory() {} |
| virtual ~ValueHolderFactory() {} | | virtual ~ValueHolderFactory() {} |
| virtual ValueHolder* MakeNewHolder() const = 0; | | virtual ValueHolder* MakeNewHolder() const = 0; |
| | |
| private: | | private: |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory); | | ValueHolderFactory(const ValueHolderFactory&) = delete; |
| | ValueHolderFactory& operator=(const ValueHolderFactory&) = delete; |
| }; | | }; |
| | |
| class DefaultValueHolderFactory : public ValueHolderFactory { | | class DefaultValueHolderFactory : public ValueHolderFactory { |
| public: | | public: |
| DefaultValueHolderFactory() {} | | DefaultValueHolderFactory() {} |
| ValueHolder* MakeNewHolder() const override { return new ValueHolder(); } | | ValueHolder* MakeNewHolder() const override { return new ValueHolder(); } |
| | |
| private: | | private: |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory); | | DefaultValueHolderFactory(const DefaultValueHolderFactory&) = delete; |
| | DefaultValueHolderFactory& operator=(const DefaultValueHolderFactory&) = |
| | delete; |
| }; | | }; |
| | |
| class InstanceValueHolderFactory : public ValueHolderFactory { | | class InstanceValueHolderFactory : public ValueHolderFactory { |
| public: | | public: |
| explicit InstanceValueHolderFactory(const T& value) : value_(value) {} | | explicit InstanceValueHolderFactory(const T& value) : value_(value) {} |
| ValueHolder* MakeNewHolder() const override { | | ValueHolder* MakeNewHolder() const override { |
| return new ValueHolder(value_); | | return new ValueHolder(value_); |
| } | | } |
| | |
| private: | | private: |
| const T value_; // The value for each thread. | | const T value_; // The value for each thread. |
| | |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory); | | InstanceValueHolderFactory(const InstanceValueHolderFactory&) = delete; |
| | InstanceValueHolderFactory& operator=(const InstanceValueHolderFactory&) = |
| | delete; |
| }; | | }; |
| | |
| std::unique_ptr<ValueHolderFactory> default_factory_; | | std::unique_ptr<ValueHolderFactory> default_factory_; |
| | |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal); | | ThreadLocal(const ThreadLocal&) = delete; |
| | ThreadLocal& operator=(const ThreadLocal&) = delete; |
| }; | | }; |
| | |
|
| # elif GTEST_HAS_PTHREAD | | #elif GTEST_HAS_PTHREAD |
| | |
| // MutexBase and Mutex implement mutex on pthreads-based platforms. | | // MutexBase and Mutex implement mutex on pthreads-based platforms. |
| class MutexBase { | | class MutexBase { |
| public: | | public: |
| // Acquires this mutex. | | // Acquires this mutex. |
| void Lock() { | | void Lock() { |
| GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_)); | | GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_)); |
| owner_ = pthread_self(); | | owner_ = pthread_self(); |
| has_owner_ = true; | | has_owner_ = true; |
| } | | } |
| | |
| skipping to change at line 1688 | | skipping to change at line 1660 |
|---|
| // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All | | // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All |
| // accesses to the owner_ field should be protected by a check of this field. | | // accesses to the owner_ field should be protected by a check of this field. |
| // An alternative might be to memset() owner_ to all zeros, but there's no | | // An alternative might be to memset() owner_ to all zeros, but there's no |
| // guarantee that a zero'd pthread_t is necessarily invalid or even different | | // guarantee that a zero'd pthread_t is necessarily invalid or even different |
| // from pthread_self(). | | // from pthread_self(). |
| bool has_owner_; | | bool has_owner_; |
| pthread_t owner_; // The thread holding the mutex. | | pthread_t owner_; // The thread holding the mutex. |
| }; | | }; |
| | |
| // Forward-declares a static mutex. | | // Forward-declares a static mutex. |
|
| # define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ | | #define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ |
| extern ::testing::internal::MutexBase mutex | | extern ::testing::internal::MutexBase mutex |
| | |
| // Defines and statically (i.e. at link time) initializes a static mutex. | | // Defines and statically (i.e. at link time) initializes a static mutex. |
| // The initialization list here does not explicitly initialize each field, | | // The initialization list here does not explicitly initialize each field, |
| // instead relying on default initialization for the unspecified fields. In | | // instead relying on default initialization for the unspecified fields. In |
| // particular, the owner_ field (a pthread_t) is not explicitly initialized. | | // particular, the owner_ field (a pthread_t) is not explicitly initialized. |
| // This allows initialization to work whether pthread_t is a scalar or struct. | | // This allows initialization to work whether pthread_t is a scalar or struct. |
| // The flag -Wmissing-field-initializers must not be specified for this to work. | | // The flag -Wmissing-field-initializers must not be specified for this to work. |
| #define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ | | #define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ |
| ::testing::internal::MutexBase mutex = {PTHREAD_MUTEX_INITIALIZER, false, 0} | | ::testing::internal::MutexBase mutex = {PTHREAD_MUTEX_INITIALIZER, false, 0} |
| | |
| // The Mutex class can only be used for mutexes created at runtime. It | | // The Mutex class can only be used for mutexes created at runtime. It |
| // shares its API with MutexBase otherwise. | | // shares its API with MutexBase otherwise. |
| class Mutex : public MutexBase { | | class Mutex : public MutexBase { |
| public: | | public: |
| Mutex() { | | Mutex() { |
| GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr)); | | GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr)); |
| has_owner_ = false; | | has_owner_ = false; |
| } | | } |
|
| ~Mutex() { | | ~Mutex() { GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_)); } |
| GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_)); | | |
| } | | |
| | |
| private: | | private: |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex); | | Mutex(const Mutex&) = delete; |
| | Mutex& operator=(const Mutex&) = delete; |
| }; | | }; |
| | |
| // We cannot name this class MutexLock because the ctor declaration would | | // We cannot name this class MutexLock because the ctor declaration would |
| // conflict with a macro named MutexLock, which is defined on some | | // conflict with a macro named MutexLock, which is defined on some |
| // platforms. That macro is used as a defensive measure to prevent against | | // platforms. That macro is used as a defensive measure to prevent against |
| // inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than | | // inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than |
| // "MutexLock l(&mu)". Hence the typedef trick below. | | // "MutexLock l(&mu)". Hence the typedef trick below. |
| class GTestMutexLock { | | class GTestMutexLock { |
| public: | | public: |
|
| explicit GTestMutexLock(MutexBase* mutex) | | explicit GTestMutexLock(MutexBase* mutex) : mutex_(mutex) { mutex_->Lock(); } |
| : mutex_(mutex) { mutex_->Lock(); } | | |
| | |
| ~GTestMutexLock() { mutex_->Unlock(); } | | ~GTestMutexLock() { mutex_->Unlock(); } |
| | |
| private: | | private: |
| MutexBase* const mutex_; | | MutexBase* const mutex_; |
| | |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock); | | GTestMutexLock(const GTestMutexLock&) = delete; |
| | GTestMutexLock& operator=(const GTestMutexLock&) = delete; |
| }; | | }; |
| | |
| typedef GTestMutexLock MutexLock; | | typedef GTestMutexLock MutexLock; |
| | |
| // Helpers for ThreadLocal. | | // Helpers for ThreadLocal. |
| | |
| // pthread_key_create() requires DeleteThreadLocalValue() to have | | // pthread_key_create() requires DeleteThreadLocalValue() to have |
| // C-linkage. Therefore it cannot be templatized to access | | // C-linkage. Therefore it cannot be templatized to access |
| // ThreadLocal<T>. Hence the need for class | | // ThreadLocal<T>. Hence the need for class |
| // ThreadLocalValueHolderBase. | | // ThreadLocalValueHolderBase. |
| | |
| skipping to change at line 1788 | | skipping to change at line 1759 |
|---|
| // Holds a value of type T. | | // Holds a value of type T. |
| class ValueHolder : public ThreadLocalValueHolderBase { | | class ValueHolder : public ThreadLocalValueHolderBase { |
| public: | | public: |
| ValueHolder() : value_() {} | | ValueHolder() : value_() {} |
| explicit ValueHolder(const T& value) : value_(value) {} | | explicit ValueHolder(const T& value) : value_(value) {} |
| | |
| T* pointer() { return &value_; } | | T* pointer() { return &value_; } |
| | |
| private: | | private: |
| T value_; | | T value_; |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder); | | ValueHolder(const ValueHolder&) = delete; |
| | ValueHolder& operator=(const ValueHolder&) = delete; |
| }; | | }; |
| | |
| static pthread_key_t CreateKey() { | | static pthread_key_t CreateKey() { |
| pthread_key_t key; | | pthread_key_t key; |
| // When a thread exits, DeleteThreadLocalValue() will be called on | | // When a thread exits, DeleteThreadLocalValue() will be called on |
| // the object managed for that thread. | | // the object managed for that thread. |
| GTEST_CHECK_POSIX_SUCCESS_( | | GTEST_CHECK_POSIX_SUCCESS_( |
| pthread_key_create(&key, &DeleteThreadLocalValue)); | | pthread_key_create(&key, &DeleteThreadLocalValue)); |
| return key; | | return key; |
| } | | } |
| | |
| skipping to change at line 1820 | | skipping to change at line 1792 |
|---|
| return new_holder->pointer(); | | return new_holder->pointer(); |
| } | | } |
| | |
| class ValueHolderFactory { | | class ValueHolderFactory { |
| public: | | public: |
| ValueHolderFactory() {} | | ValueHolderFactory() {} |
| virtual ~ValueHolderFactory() {} | | virtual ~ValueHolderFactory() {} |
| virtual ValueHolder* MakeNewHolder() const = 0; | | virtual ValueHolder* MakeNewHolder() const = 0; |
| | |
| private: | | private: |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory); | | ValueHolderFactory(const ValueHolderFactory&) = delete; |
| | ValueHolderFactory& operator=(const ValueHolderFactory&) = delete; |
| }; | | }; |
| | |
| class DefaultValueHolderFactory : public ValueHolderFactory { | | class DefaultValueHolderFactory : public ValueHolderFactory { |
| public: | | public: |
| DefaultValueHolderFactory() {} | | DefaultValueHolderFactory() {} |
| ValueHolder* MakeNewHolder() const override { return new ValueHolder(); } | | ValueHolder* MakeNewHolder() const override { return new ValueHolder(); } |
| | |
| private: | | private: |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory); | | DefaultValueHolderFactory(const DefaultValueHolderFactory&) = delete; |
| | DefaultValueHolderFactory& operator=(const DefaultValueHolderFactory&) = |
| | delete; |
| }; | | }; |
| | |
| class InstanceValueHolderFactory : public ValueHolderFactory { | | class InstanceValueHolderFactory : public ValueHolderFactory { |
| public: | | public: |
| explicit InstanceValueHolderFactory(const T& value) : value_(value) {} | | explicit InstanceValueHolderFactory(const T& value) : value_(value) {} |
| ValueHolder* MakeNewHolder() const override { | | ValueHolder* MakeNewHolder() const override { |
| return new ValueHolder(value_); | | return new ValueHolder(value_); |
| } | | } |
| | |
| private: | | private: |
| const T value_; // The value for each thread. | | const T value_; // The value for each thread. |
| | |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory); | | InstanceValueHolderFactory(const InstanceValueHolderFactory&) = delete; |
| | InstanceValueHolderFactory& operator=(const InstanceValueHolderFactory&) = |
| | delete; |
| }; | | }; |
| | |
| // A key pthreads uses for looking up per-thread values. | | // A key pthreads uses for looking up per-thread values. |
| const pthread_key_t key_; | | const pthread_key_t key_; |
| std::unique_ptr<ValueHolderFactory> default_factory_; | | std::unique_ptr<ValueHolderFactory> default_factory_; |
| | |
|
| GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal); | | ThreadLocal(const ThreadLocal&) = delete; |
| | ThreadLocal& operator=(const ThreadLocal&) = delete; |
| }; | | }; |
| | |
|
| # endif // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ | | #endif // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ |
| | |
| #else // GTEST_IS_THREADSAFE | | #else // GTEST_IS_THREADSAFE |
| | |
| // A dummy implementation of synchronization primitives (mutex, lock, | | // A dummy implementation of synchronization primitives (mutex, lock, |
| // and thread-local variable). Necessary for compiling Google Test where | | // and thread-local variable). Necessary for compiling Google Test where |
| // mutex is not supported - using Google Test in multiple threads is not | | // mutex is not supported - using Google Test in multiple threads is not |
| // supported on such platforms. | | // supported on such platforms. |
| | |
| class Mutex { | | class Mutex { |
| public: | | public: |
| Mutex() {} | | Mutex() {} |
| void Lock() {} | | void Lock() {} |
| void Unlock() {} | | void Unlock() {} |
| void AssertHeld() const {} | | void AssertHeld() const {} |
| }; | | }; |
| | |
|
| # define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ | | #define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ |
| extern ::testing::internal::Mutex mutex | | extern ::testing::internal::Mutex mutex |
| | |
|
| # define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex | | #define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex |
| | |
| // We cannot name this class MutexLock because the ctor declaration would | | // We cannot name this class MutexLock because the ctor declaration would |
| // conflict with a macro named MutexLock, which is defined on some | | // conflict with a macro named MutexLock, which is defined on some |
| // platforms. That macro is used as a defensive measure to prevent against | | // platforms. That macro is used as a defensive measure to prevent against |
| // inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than | | // inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than |
| // "MutexLock l(&mu)". Hence the typedef trick below. | | // "MutexLock l(&mu)". Hence the typedef trick below. |
| class GTestMutexLock { | | class GTestMutexLock { |
| public: | | public: |
| explicit GTestMutexLock(Mutex*) {} // NOLINT | | explicit GTestMutexLock(Mutex*) {} // NOLINT |
| }; | | }; |
| | |
| skipping to change at line 1895 | | skipping to change at line 1873 |
|---|
| | |
| template <typename T> | | template <typename T> |
| class GTEST_API_ ThreadLocal { | | class GTEST_API_ ThreadLocal { |
| public: | | public: |
| ThreadLocal() : value_() {} | | ThreadLocal() : value_() {} |
| explicit ThreadLocal(const T& value) : value_(value) {} | | explicit ThreadLocal(const T& value) : value_(value) {} |
| T* pointer() { return &value_; } | | T* pointer() { return &value_; } |
| const T* pointer() const { return &value_; } | | const T* pointer() const { return &value_; } |
| const T& get() const { return value_; } | | const T& get() const { return value_; } |
| void set(const T& value) { value_ = value; } | | void set(const T& value) { value_ = value; } |
|
| | |
| private: | | private: |
| T value_; | | T value_; |
| }; | | }; |
| | |
| #endif // GTEST_IS_THREADSAFE | | #endif // GTEST_IS_THREADSAFE |
| | |
| // Returns the number of threads running in the process, or 0 to indicate that | | // Returns the number of threads running in the process, or 0 to indicate that |
| // we cannot detect it. | | // we cannot detect it. |
| GTEST_API_ size_t GetThreadCount(); | | GTEST_API_ size_t GetThreadCount(); |
| | |
| #if GTEST_OS_WINDOWS | | #if GTEST_OS_WINDOWS |
|
| # define GTEST_PATH_SEP_ "\\" | | #define GTEST_PATH_SEP_ "\\" |
| # define GTEST_HAS_ALT_PATH_SEP_ 1 | | #define GTEST_HAS_ALT_PATH_SEP_ 1 |
| #else | | #else |
|
| # define GTEST_PATH_SEP_ "/" | | #define GTEST_PATH_SEP_ "/" |
| # define GTEST_HAS_ALT_PATH_SEP_ 0 | | #define GTEST_HAS_ALT_PATH_SEP_ 0 |
| #endif // GTEST_OS_WINDOWS | | #endif // GTEST_OS_WINDOWS |
| | |
| // Utilities for char. | | // Utilities for char. |
| | |
| // isspace(int ch) and friends accept an unsigned char or EOF. char | | // isspace(int ch) and friends accept an unsigned char or EOF. char |
| // may be signed, depending on the compiler (or compiler flags). | | // may be signed, depending on the compiler (or compiler flags). |
| // Therefore we need to cast a char to unsigned char before calling | | // Therefore we need to cast a char to unsigned char before calling |
| // isspace(), etc. | | // isspace(), etc. |
| | |
| inline bool IsAlpha(char ch) { | | inline bool IsAlpha(char ch) { |
| | |
| skipping to change at line 1968 | | skipping to change at line 1947 |
|---|
| | |
| inline char ToLower(char ch) { | | inline char ToLower(char ch) { |
| return static_cast<char>(tolower(static_cast<unsigned char>(ch))); | | return static_cast<char>(tolower(static_cast<unsigned char>(ch))); |
| } | | } |
| inline char ToUpper(char ch) { | | inline char ToUpper(char ch) { |
| return static_cast<char>(toupper(static_cast<unsigned char>(ch))); | | return static_cast<char>(toupper(static_cast<unsigned char>(ch))); |
| } | | } |
| | |
| inline std::string StripTrailingSpaces(std::string str) { | | inline std::string StripTrailingSpaces(std::string str) { |
| std::string::iterator it = str.end(); | | std::string::iterator it = str.end(); |
|
| while (it != str.begin() && IsSpace(*--it)) | | while (it != str.begin() && IsSpace(*--it)) it = str.erase(it); |
| it = str.erase(it); | | |
| return str; | | return str; |
| } | | } |
| | |
| // The testing::internal::posix namespace holds wrappers for common | | // The testing::internal::posix namespace holds wrappers for common |
| // POSIX functions. These wrappers hide the differences between | | // POSIX functions. These wrappers hide the differences between |
| // Windows/MSVC and POSIX systems. Since some compilers define these | | // Windows/MSVC and POSIX systems. Since some compilers define these |
| // standard functions as macros, the wrapper cannot have the same name | | // standard functions as macros, the wrapper cannot have the same name |
| // as the wrapped function. | | // as the wrapped function. |
| | |
| namespace posix { | | namespace posix { |
| | |
| // Functions with a different name on Windows. | | // Functions with a different name on Windows. |
| | |
| #if GTEST_OS_WINDOWS | | #if GTEST_OS_WINDOWS |
| | |
| typedef struct _stat StatStruct; | | typedef struct _stat StatStruct; |
| | |
|
| # ifdef __BORLANDC__ | | #ifdef __BORLANDC__ |
| inline int DoIsATTY(int fd) { return isatty(fd); } | | inline int DoIsATTY(int fd) { return isatty(fd); } |
| inline int StrCaseCmp(const char* s1, const char* s2) { | | inline int StrCaseCmp(const char* s1, const char* s2) { |
| return stricmp(s1, s2); | | return stricmp(s1, s2); |
| } | | } |
| inline char* StrDup(const char* src) { return strdup(src); } | | inline char* StrDup(const char* src) { return strdup(src); } |
|
| # else // !__BORLANDC__ | | #else // !__BORLANDC__ |
| # if GTEST_OS_WINDOWS_MOBILE | | #if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \ |
| | GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || defined(ESP_PLATFORM) |
| inline int DoIsATTY(int /* fd */) { return 0; } | | inline int DoIsATTY(int /* fd */) { return 0; } |
|
| # else | | #else |
| inline int DoIsATTY(int fd) { return _isatty(fd); } | | inline int DoIsATTY(int fd) { return _isatty(fd); } |
|
| # endif // GTEST_OS_WINDOWS_MOBILE | | #endif // GTEST_OS_WINDOWS_MOBILE |
| inline int StrCaseCmp(const char* s1, const char* s2) { | | inline int StrCaseCmp(const char* s1, const char* s2) { |
| return _stricmp(s1, s2); | | return _stricmp(s1, s2); |
| } | | } |
| inline char* StrDup(const char* src) { return _strdup(src); } | | inline char* StrDup(const char* src) { return _strdup(src); } |
|
| # endif // __BORLANDC__ | | #endif // __BORLANDC__ |
| | |
|
| # if GTEST_OS_WINDOWS_MOBILE | | #if GTEST_OS_WINDOWS_MOBILE |
| inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); } | | inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); } |
| // Stat(), RmDir(), and IsDir() are not needed on Windows CE at this | | // Stat(), RmDir(), and IsDir() are not needed on Windows CE at this |
| // time and thus not defined there. | | // time and thus not defined there. |
|
| # else | | #else |
| inline int FileNo(FILE* file) { return _fileno(file); } | | inline int FileNo(FILE* file) { return _fileno(file); } |
| inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); } | | inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); } |
| inline int RmDir(const char* dir) { return _rmdir(dir); } | | inline int RmDir(const char* dir) { return _rmdir(dir); } |
|
| inline bool IsDir(const StatStruct& st) { | | inline bool IsDir(const StatStruct& st) { return (_S_IFDIR & st.st_mode) != 0; } |
| return (_S_IFDIR & st.st_mode) != 0; | | #endif // GTEST_OS_WINDOWS_MOBILE |
| } | | |
| # endif // GTEST_OS_WINDOWS_MOBILE | | |
| | |
| #elif GTEST_OS_ESP8266 | | #elif GTEST_OS_ESP8266 |
| typedef struct stat StatStruct; | | typedef struct stat StatStruct; |
| | |
| inline int FileNo(FILE* file) { return fileno(file); } | | inline int FileNo(FILE* file) { return fileno(file); } |
| inline int DoIsATTY(int fd) { return isatty(fd); } | | inline int DoIsATTY(int fd) { return isatty(fd); } |
| inline int Stat(const char* path, StatStruct* buf) { | | inline int Stat(const char* path, StatStruct* buf) { |
| // stat function not implemented on ESP8266 | | // stat function not implemented on ESP8266 |
| return 0; | | return 0; |
| } | | } |
| | |
| skipping to change at line 2080 | | skipping to change at line 2057 |
|---|
| !GTEST_OS_WINDOWS_RT && !GTEST_OS_ESP8266 && !GTEST_OS_XTENSA | | !GTEST_OS_WINDOWS_RT && !GTEST_OS_ESP8266 && !GTEST_OS_XTENSA |
| inline int ChDir(const char* dir) { return chdir(dir); } | | inline int ChDir(const char* dir) { return chdir(dir); } |
| #endif | | #endif |
| inline FILE* FOpen(const char* path, const char* mode) { | | inline FILE* FOpen(const char* path, const char* mode) { |
| #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW | | #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW |
| struct wchar_codecvt : public std::codecvt<wchar_t, char, std::mbstate_t> {}; | | struct wchar_codecvt : public std::codecvt<wchar_t, char, std::mbstate_t> {}; |
| std::wstring_convert<wchar_codecvt> converter; | | std::wstring_convert<wchar_codecvt> converter; |
| std::wstring wide_path = converter.from_bytes(path); | | std::wstring wide_path = converter.from_bytes(path); |
| std::wstring wide_mode = converter.from_bytes(mode); | | std::wstring wide_mode = converter.from_bytes(mode); |
| return _wfopen(wide_path.c_str(), wide_mode.c_str()); | | return _wfopen(wide_path.c_str(), wide_mode.c_str()); |
|
| #else // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW | | #else // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW |
| return fopen(path, mode); | | return fopen(path, mode); |
| #endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW | | #endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW |
| } | | } |
| #if !GTEST_OS_WINDOWS_MOBILE | | #if !GTEST_OS_WINDOWS_MOBILE |
|
| inline FILE *FReopen(const char* path, const char* mode, FILE* stream) { | | inline FILE* FReopen(const char* path, const char* mode, FILE* stream) { |
| return freopen(path, mode, stream); | | return freopen(path, mode, stream); |
| } | | } |
| inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); } | | inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); } |
| #endif | | #endif |
| inline int FClose(FILE* fp) { return fclose(fp); } | | inline int FClose(FILE* fp) { return fclose(fp); } |
| #if !GTEST_OS_WINDOWS_MOBILE | | #if !GTEST_OS_WINDOWS_MOBILE |
| inline int Read(int fd, void* buf, unsigned int count) { | | inline int Read(int fd, void* buf, unsigned int count) { |
| return static_cast<int>(read(fd, buf, count)); | | return static_cast<int>(read(fd, buf, count)); |
| } | | } |
| inline int Write(int fd, const void* buf, unsigned int count) { | | inline int Write(int fd, const void* buf, unsigned int count) { |
| | |
| skipping to change at line 2137 | | skipping to change at line 2114 |
|---|
| | |
| } // namespace posix | | } // namespace posix |
| | |
| // MSVC "deprecates" snprintf and issues warnings wherever it is used. In | | // MSVC "deprecates" snprintf and issues warnings wherever it is used. In |
| // order to avoid these warnings, we need to use _snprintf or _snprintf_s on | | // order to avoid these warnings, we need to use _snprintf or _snprintf_s on |
| // MSVC-based platforms. We map the GTEST_SNPRINTF_ macro to the appropriate | | // MSVC-based platforms. We map the GTEST_SNPRINTF_ macro to the appropriate |
| // function in order to achieve that. We use macro definition here because | | // function in order to achieve that. We use macro definition here because |
| // snprintf is a variadic function. | | // snprintf is a variadic function. |
| #if _MSC_VER && !GTEST_OS_WINDOWS_MOBILE | | #if _MSC_VER && !GTEST_OS_WINDOWS_MOBILE |
| // MSVC 2005 and above support variadic macros. | | // MSVC 2005 and above support variadic macros. |
|
| # define GTEST_SNPRINTF_(buffer, size, format, ...) \ | | #define GTEST_SNPRINTF_(buffer, size, format, ...) \ |
| _snprintf_s(buffer, size, size, format, __VA_ARGS__) | | _snprintf_s(buffer, size, size, format, __VA_ARGS__) |
| #elif defined(_MSC_VER) | | #elif defined(_MSC_VER) |
| // Windows CE does not define _snprintf_s | | // Windows CE does not define _snprintf_s |
|
| # define GTEST_SNPRINTF_ _snprintf | | #define GTEST_SNPRINTF_ _snprintf |
| #else | | #else |
|
| # define GTEST_SNPRINTF_ snprintf | | #define GTEST_SNPRINTF_ snprintf |
| #endif | | #endif |
| | |
| // The biggest signed integer type the compiler supports. | | // The biggest signed integer type the compiler supports. |
| // | | // |
| // long long is guaranteed to be at least 64-bits in C++11. | | // long long is guaranteed to be at least 64-bits in C++11. |
| using BiggestInt = long long; // NOLINT | | using BiggestInt = long long; // NOLINT |
| | |
| // The maximum number a BiggestInt can represent. | | // The maximum number a BiggestInt can represent. |
| constexpr BiggestInt kMaxBiggestInt = (std::numeric_limits<BiggestInt>::max)(); | | constexpr BiggestInt kMaxBiggestInt = (std::numeric_limits<BiggestInt>::max)(); |
| | |
| | |
| skipping to change at line 2203 | | skipping to change at line 2180 |
|---|
| using UInt = std::uint64_t; | | using UInt = std::uint64_t; |
| }; | | }; |
| | |
| // Integer types of known sizes. | | // Integer types of known sizes. |
| using TimeInMillis = int64_t; // Represents time in milliseconds. | | using TimeInMillis = int64_t; // Represents time in milliseconds. |
| | |
| // Utilities for command line flags and environment variables. | | // Utilities for command line flags and environment variables. |
| | |
| // Macro for referencing flags. | | // Macro for referencing flags. |
| #if !defined(GTEST_FLAG) | | #if !defined(GTEST_FLAG) |
|
| # define GTEST_FLAG(name) FLAGS_gtest_##name | | #define GTEST_FLAG_NAME_(name) gtest_##name |
| | #define GTEST_FLAG(name) FLAGS_gtest_##name |
| #endif // !defined(GTEST_FLAG) | | #endif // !defined(GTEST_FLAG) |
| | |
|
| #if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_) | | // Pick a command line flags implementation. |
| # define GTEST_USE_OWN_FLAGFILE_FLAG_ 1 | | #if GTEST_HAS_ABSL |
| #endif // !defined(GTEST_USE_OWN_FLAGFILE_FLAG_) | | |
| | |
|
| #if !defined(GTEST_DECLARE_bool_) | | // Macros for defining flags. |
| # define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver | | #define GTEST_DEFINE_bool_(name, default_val, doc) \ |
| | ABSL_FLAG(bool, GTEST_FLAG_NAME_(name), default_val, doc) |
| | #define GTEST_DEFINE_int32_(name, default_val, doc) \ |
| | ABSL_FLAG(int32_t, GTEST_FLAG_NAME_(name), default_val, doc) |
| | #define GTEST_DEFINE_string_(name, default_val, doc) \ |
| | ABSL_FLAG(std::string, GTEST_FLAG_NAME_(name), default_val, doc) |
| | |
| // Macros for declaring flags. | | // Macros for declaring flags. |
|
| # define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name) | | #define GTEST_DECLARE_bool_(name) \ |
| # define GTEST_DECLARE_int32_(name) \ | | ABSL_DECLARE_FLAG(bool, GTEST_FLAG_NAME_(name)) |
| GTEST_API_ extern std::int32_t GTEST_FLAG(name) | | #define GTEST_DECLARE_int32_(name) \ |
| # define GTEST_DECLARE_string_(name) \ | | ABSL_DECLARE_FLAG(int32_t, GTEST_FLAG_NAME_(name)) |
| GTEST_API_ extern ::std::string GTEST_FLAG(name) | | #define GTEST_DECLARE_string_(name) \ |
| | ABSL_DECLARE_FLAG(std::string, GTEST_FLAG_NAME_(name)) |
| | |
| | #define GTEST_FLAG_SAVER_ ::absl::FlagSaver |
| | |
| | #define GTEST_FLAG_GET(name) ::absl::GetFlag(GTEST_FLAG(name)) |
| | #define GTEST_FLAG_SET(name, value) \ |
| | (void)(::absl::SetFlag(>EST_FLAG(name), value)) |
| | #define GTEST_USE_OWN_FLAGFILE_FLAG_ 0 |
| | |
| | #else // GTEST_HAS_ABSL |
| | |
| // Macros for defining flags. | | // Macros for defining flags. |
|
| # define GTEST_DEFINE_bool_(name, default_val, doc) \ | | #define GTEST_DEFINE_bool_(name, default_val, doc) \ |
| GTEST_API_ bool GTEST_FLAG(name) = (default_val) | | namespace testing { \ |
| # define GTEST_DEFINE_int32_(name, default_val, doc) \ | | GTEST_API_ bool GTEST_FLAG(name) = (default_val); \ |
| GTEST_API_ std::int32_t GTEST_FLAG(name) = (default_val) | | } \ |
| # define GTEST_DEFINE_string_(name, default_val, doc) \ | | static_assert(true, "no-op to require trailing semicolon") |
| GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val) | | #define GTEST_DEFINE_int32_(name, default_val, doc) \ |
| | namespace testing { \ |
| | GTEST_API_ std::int32_t GTEST_FLAG(name) = (default_val); \ |
| | } \ |
| | static_assert(true, "no-op to require trailing semicolon") |
| | #define GTEST_DEFINE_string_(name, default_val, doc) \ |
| | namespace testing { \ |
| | GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val); \ |
| | } \ |
| | static_assert(true, "no-op to require trailing semicolon") |
| | |
|
| #endif // !defined(GTEST_DECLARE_bool_) | | // Macros for declaring flags. |
| | #define GTEST_DECLARE_bool_(name) \ |
| | namespace testing { \ |
| | GTEST_API_ extern bool GTEST_FLAG(name); \ |
| | } \ |
| | static_assert(true, "no-op to require trailing semicolon") |
| | #define GTEST_DECLARE_int32_(name) \ |
| | namespace testing { \ |
| | GTEST_API_ extern std::int32_t GTEST_FLAG(name); \ |
| | } \ |
| | static_assert(true, "no-op to require trailing semicolon") |
| | #define GTEST_DECLARE_string_(name) \ |
| | namespace testing { \ |
| | GTEST_API_ extern ::std::string GTEST_FLAG(name); \ |
| | } \ |
| | static_assert(true, "no-op to require trailing semicolon") |
| | |
| | #define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver |
| | |
| | #define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name) |
| | #define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value) |
| | #define GTEST_USE_OWN_FLAGFILE_FLAG_ 1 |
| | |
| | #endif // GTEST_HAS_ABSL |
| | |
| // Thread annotations | | // Thread annotations |
| #if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_) | | #if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_) |
|
| # define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks) | | #define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks) |
| # define GTEST_LOCK_EXCLUDED_(locks) | | #define GTEST_LOCK_EXCLUDED_(locks) |
| #endif // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_) | | #endif // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_) |
| | |
| // Parses 'str' for a 32-bit signed integer. If successful, writes the result | | // Parses 'str' for a 32-bit signed integer. If successful, writes the result |
| // to *value and returns true; otherwise leaves *value unchanged and returns | | // to *value and returns true; otherwise leaves *value unchanged and returns |
| // false. | | // false. |
| GTEST_API_ bool ParseInt32(const Message& src_text, const char* str, | | GTEST_API_ bool ParseInt32(const Message& src_text, const char* str, |
| int32_t* value); | | int32_t* value); |
| | |
| // Parses a bool/int32_t/string from the environment variable | | // Parses a bool/int32_t/string from the environment variable |
| // corresponding to the given Google Test flag. | | // corresponding to the given Google Test flag. |
| | |
| skipping to change at line 2309 | | skipping to change at line 2333 |
|---|
| | |
| #if GTEST_HAS_ABSL | | #if GTEST_HAS_ABSL |
| // Always use absl::optional for UniversalPrinter<> specializations if | | // Always use absl::optional for UniversalPrinter<> specializations if |
| // googletest is built with absl support. | | // googletest is built with absl support. |
| #define GTEST_INTERNAL_HAS_OPTIONAL 1 | | #define GTEST_INTERNAL_HAS_OPTIONAL 1 |
| #include "absl/types/optional.h" | | #include "absl/types/optional.h" |
| namespace testing { | | namespace testing { |
| namespace internal { | | namespace internal { |
| template <typename T> | | template <typename T> |
| using Optional = ::absl::optional<T>; | | using Optional = ::absl::optional<T>; |
|
| | inline ::absl::nullopt_t Nullopt() { return ::absl::nullopt; } |
| } // namespace internal | | } // namespace internal |
| } // namespace testing | | } // namespace testing |
| #else | | #else |
| #ifdef __has_include | | #ifdef __has_include |
| #if __has_include(<optional>) && __cplusplus >= 201703L | | #if __has_include(<optional>) && __cplusplus >= 201703L |
| // Otherwise for C++17 and higher use std::optional for UniversalPrinter<> | | // Otherwise for C++17 and higher use std::optional for UniversalPrinter<> |
| // specializations. | | // specializations. |
| #define GTEST_INTERNAL_HAS_OPTIONAL 1 | | #define GTEST_INTERNAL_HAS_OPTIONAL 1 |
| #include <optional> | | #include <optional> |
| namespace testing { | | namespace testing { |
| namespace internal { | | namespace internal { |
| template <typename T> | | template <typename T> |
| using Optional = ::std::optional<T>; | | using Optional = ::std::optional<T>; |
|
| | inline ::std::nullopt_t Nullopt() { return ::std::nullopt; } |
| } // namespace internal | | } // namespace internal |
| } // namespace testing | | } // namespace testing |
| // The case where absl is configured NOT to alias std::optional is not | | // The case where absl is configured NOT to alias std::optional is not |
| // supported. | | // supported. |
| #endif // __has_include(<optional>) && __cplusplus >= 201703L | | #endif // __has_include(<optional>) && __cplusplus >= 201703L |
| #endif // __has_include | | #endif // __has_include |
| #endif // GTEST_HAS_ABSL | | #endif // GTEST_HAS_ABSL |
| | |
| #if GTEST_HAS_ABSL | | #if GTEST_HAS_ABSL |
| // Always use absl::string_view for Matcher<> specializations if googletest | | // Always use absl::string_view for Matcher<> specializations if googletest |
| // is built with absl support. | | // is built with absl support. |
|
| # define GTEST_INTERNAL_HAS_STRING_VIEW 1 | | #define GTEST_INTERNAL_HAS_STRING_VIEW 1 |
| #include "absl/strings/string_view.h" | | #include "absl/strings/string_view.h" |
| namespace testing { | | namespace testing { |
| namespace internal { | | namespace internal { |
| using StringView = ::absl::string_view; | | using StringView = ::absl::string_view; |
| } // namespace internal | | } // namespace internal |
| } // namespace testing | | } // namespace testing |
| #else | | #else |
|
| # ifdef __has_include | | #ifdef __has_include |
| # if __has_include(<string_view>) && __cplusplus >= 201703L | | #if __has_include(<string_view>) && __cplusplus >= 201703L |
| // Otherwise for C++17 and higher use std::string_view for Matcher<> | | // Otherwise for C++17 and higher use std::string_view for Matcher<> |
| // specializations. | | // specializations. |
|
| # define GTEST_INTERNAL_HAS_STRING_VIEW 1 | | #define GTEST_INTERNAL_HAS_STRING_VIEW 1 |
| #include <string_view> | | #include <string_view> |
| namespace testing { | | namespace testing { |
| namespace internal { | | namespace internal { |
| using StringView = ::std::string_view; | | using StringView = ::std::string_view; |
| } // namespace internal | | } // namespace internal |
| } // namespace testing | | } // namespace testing |
| // The case where absl is configured NOT to alias std::string_view is not | | // The case where absl is configured NOT to alias std::string_view is not |
| // supported. | | // supported. |
|
| # endif // __has_include(<string_view>) && __cplusplus >= 201703L | | #endif // __has_include(<string_view>) && __cplusplus >= 201703L |
| # endif // __has_include | | #endif // __has_include |
| #endif // GTEST_HAS_ABSL | | #endif // GTEST_HAS_ABSL |
| | |
| #if GTEST_HAS_ABSL | | #if GTEST_HAS_ABSL |
| // Always use absl::variant for UniversalPrinter<> specializations if googletest | | // Always use absl::variant for UniversalPrinter<> specializations if googletest |
| // is built with absl support. | | // is built with absl support. |
| #define GTEST_INTERNAL_HAS_VARIANT 1 | | #define GTEST_INTERNAL_HAS_VARIANT 1 |
| #include "absl/types/variant.h" | | #include "absl/types/variant.h" |
| namespace testing { | | namespace testing { |
| namespace internal { | | namespace internal { |
| template <typename... T> | | template <typename... T> |
| | | |
| End of changes. 186 change blocks. |
|---|
| 480 lines changed or deleted | | 506 lines changed or added |
|---|
"Fossies" - the Fresh Open Source Software Archive 