GitHub-Proxy/googletest
1
0
Fork 0
mirror of https://git.mirrors.martin98.com/https://github.com/google/googletest.git synced 2025-07-29 01:02:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into fixes_std_pair_diff

Browse Source
This commit is contained in:
Andy Soffer 2023-05-01 14:27:38 -04:00 committed by GitHub
commit 76bce79a34
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
92 changed files with 1324 additions and 1079 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.github/ISSUE_TEMPLATE/10-feature_request.yml vendored
View File

@ -10,21 +10,21 @@ body:
description: We recommend using the latest commit from GitHub in your projects. description: We recommend using the latest commit from GitHub in your projects.
validations: validations:
required: true required: true
- type: textarea - type: textarea
id: why id: why
attributes: attributes:
label: Why do we need this feature? label: Why do we need this feature?
description: Ideally, explain why a combination of existing features cannot be used instead. description: Ideally, explain why a combination of existing features cannot be used instead.
validations: validations:
required: true required: true
- type: textarea - type: textarea
id: proposal id: proposal
attributes: attributes:
label: Describe the proposal. label: Describe the proposal.
description: Include a detailed description of the feature, with usage examples. description: Include a detailed description of the feature, with usage examples.
validations: validations:
required: true required: true
- type: textarea - type: textarea
id: platform id: platform
attributes: attributes:
label: Is the feature specific to an operating system, compiler, or build system version? label: Is the feature specific to an operating system, compiler, or build system version?

19
WORKSPACE
View File

@ -1,23 +1,10 @@
workspace(name = "com_google_googletest") workspace(name = "com_google_googletest")
load("//:googletest_deps.bzl", "googletest_deps")
googletest_deps()
load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive") load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
http_archive(
name = "com_google_absl", # 2023-01-10T21:08:25Z
sha256 = "f9a4e749f42c386a32a90fddf0e2913ed408d10c42f7f33ccf4c59ac4f0d1d05",
strip_prefix = "abseil-cpp-52835439ca90d86b27bf8cd1708296e95604d724",
urls = ["https://github.com/abseil/abseil-cpp/archive/52835439ca90d86b27bf8cd1708296e95604d724.zip"],
)
# Note this must use a commit from the `abseil` branch of the RE2 project.
# https://github.com/google/re2/tree/abseil
http_archive(
name = "com_googlesource_code_re2", # 2022-12-21T14:29:10Z
sha256 = "b9ce3a51beebb38534d11d40f8928d40509b9e18a735f6a4a97ad3d014c87cb5",
strip_prefix = "re2-d0b1f8f2ecc2ea74956c7608b6f915175314ff0e",
urls = ["https://github.com/google/re2/archive/d0b1f8f2ecc2ea74956c7608b6f915175314ff0e.zip"],
)
http_archive( http_archive(
name = "rules_python", # 2023-01-10T22:00:51Z name = "rules_python", # 2023-01-10T22:00:51Z
sha256 = "5de54486a60ad8948dabe49605bb1c08053e04001a431ab3e96745b4d97a4419", sha256 = "5de54486a60ad8948dabe49605bb1c08053e04001a431ab3e96745b4d97a4419",

7
ci/linux-presubmit.sh
View File

@ -31,8 +31,8 @@
set -euox pipefail set -euox pipefail
readonly LINUX_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest:20220217" readonly LINUX_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest:20230217"
readonly LINUX_GCC_FLOOR_CONTAINER="gcr.io/google.com/absl-177019/linux_gcc-floor:20220621" readonly LINUX_GCC_FLOOR_CONTAINER="gcr.io/google.com/absl-177019/linux_gcc-floor:20230120"
if [[ -z ${GTEST_ROOT:-} ]]; then if [[ -z ${GTEST_ROOT:-} ]]; then
GTEST_ROOT="$(realpath $(dirname ${0})/..)" GTEST_ROOT="$(realpath $(dirname ${0})/..)"
@ -78,6 +78,7 @@ time docker run \
--copt="-Wall" \ --copt="-Wall" \
--copt="-Werror" \ --copt="-Werror" \
--copt="-Wuninitialized" \ --copt="-Wuninitialized" \
--copt="-Wundef" \
--copt="-Wno-error=pragmas" \ --copt="-Wno-error=pragmas" \
--distdir="/bazel-distdir" \ --distdir="/bazel-distdir" \
--features=external_include_paths \ --features=external_include_paths \
@ -99,6 +100,7 @@ for std in ${STD}; do
--copt="-Wall" \ --copt="-Wall" \
--copt="-Werror" \ --copt="-Werror" \
--copt="-Wuninitialized" \ --copt="-Wuninitialized" \
--copt="-Wundef" \
--define="absl=${absl}" \ --define="absl=${absl}" \
--distdir="/bazel-distdir" \ --distdir="/bazel-distdir" \
--features=external_include_paths \ --features=external_include_paths \
@ -123,6 +125,7 @@ for std in ${STD}; do
--copt="-Wall" \ --copt="-Wall" \
--copt="-Werror" \ --copt="-Werror" \
--copt="-Wuninitialized" \ --copt="-Wuninitialized" \
--copt="-Wundef" \
--define="absl=${absl}" \ --define="absl=${absl}" \
--distdir="/bazel-distdir" \ --distdir="/bazel-distdir" \
--features=external_include_paths \ --features=external_include_paths \

1
ci/macos-presubmit.sh
View File

@ -66,6 +66,7 @@ for absl in 0 1; do
${BAZEL_BIN} test ... \ ${BAZEL_BIN} test ... \
--copt="-Wall" \ --copt="-Wall" \
--copt="-Werror" \ --copt="-Werror" \
--copt="-Wundef" \
--cxxopt="-std=c++14" \ --cxxopt="-std=c++14" \
--define="absl=${absl}" \ --define="absl=${absl}" \
--features=external_include_paths \ --features=external_include_paths \

24
ci/windows-presubmit.bat
View File

@ -2,12 +2,14 @@ SETLOCAL ENABLEDELAYEDEXPANSION
SET BAZEL_EXE=%KOKORO_GFILE_DIR%\bazel-5.1.1-windows-x86_64.exe SET BAZEL_EXE=%KOKORO_GFILE_DIR%\bazel-5.1.1-windows-x86_64.exe
SET PATH=C:\Python37;%PATH% SET PATH=C:\Python34;%PATH%
SET BAZEL_PYTHON=C:\python37\python.exe SET BAZEL_PYTHON=C:\python34\python.exe
SET BAZEL_SH=C:\tools\msys64\usr\bin\bash.exe SET BAZEL_SH=C:\tools\msys64\usr\bin\bash.exe
SET CMAKE_BIN="C:\Program Files\CMake\bin\cmake.exe" SET CMAKE_BIN="cmake.exe"
SET CTEST_BIN="C:\Program Files\CMake\bin\ctest.exe" SET CTEST_BIN="ctest.exe"
SET CTEST_OUTPUT_ON_FAILURE=1 SET CTEST_OUTPUT_ON_FAILURE=1
SET CMAKE_BUILD_PARALLEL_LEVEL=16
SET CTEST_PARALLEL_LEVEL=16
IF EXIST git\googletest ( IF EXIST git\googletest (
CD git\googletest CD git\googletest
@ -18,12 +20,12 @@ IF EXIST git\googletest (
IF %errorlevel% neq 0 EXIT /B 1 IF %errorlevel% neq 0 EXIT /B 1
:: ---------------------------------------------------------------------------- :: ----------------------------------------------------------------------------
:: CMake Visual Studio 15 2017 Win64 :: CMake
MKDIR cmake_msvc2017 MKDIR cmake_msvc2022
CD cmake_msvc2017 CD cmake_msvc2022
%CMAKE_BIN% .. ^ %CMAKE_BIN% .. ^
-G "Visual Studio 15 2017 Win64" ^ -G "Visual Studio 17 2022" ^
-DPYTHON_EXECUTABLE:FILEPATH=c:\python37\python.exe ^ -DPYTHON_EXECUTABLE:FILEPATH=c:\python37\python.exe ^
-DPYTHON_INCLUDE_DIR:PATH=c:\python37\include ^ -DPYTHON_INCLUDE_DIR:PATH=c:\python37\include ^
-DPYTHON_LIBRARY:FILEPATH=c:\python37\lib\site-packages\pip ^ -DPYTHON_LIBRARY:FILEPATH=c:\python37\lib\site-packages\pip ^
@ -39,12 +41,12 @@ IF %errorlevel% neq 0 EXIT /B 1
IF %errorlevel% neq 0 EXIT /B 1 IF %errorlevel% neq 0 EXIT /B 1
CD .. CD ..
RMDIR /S /Q cmake_msvc2017 RMDIR /S /Q cmake_msvc2022
:: ---------------------------------------------------------------------------- :: ----------------------------------------------------------------------------
:: Bazel Visual Studio 15 2017 Win64 :: Bazel
SET BAZEL_VC=C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC SET BAZEL_VS=C:\Program Files\Microsoft Visual Studio\2022\Community
%BAZEL_EXE% test ... ^ %BAZEL_EXE% test ... ^
--compilation_mode=dbg ^ --compilation_mode=dbg ^
--copt=/std:c++14 ^ --copt=/std:c++14 ^

209
docs/advanced.md
View File

@ -1,9 +1,9 @@
# Advanced googletest Topics # Advanced GoogleTest Topics
## Introduction ## Introduction
Now that you have read the [googletest Primer](primer.md) and learned how to Now that you have read the [GoogleTest Primer](primer.md) and learned how to
write tests using googletest, it's time to learn some new tricks. This document write tests using GoogleTest, it's time to learn some new tricks. This document
will show you more assertions as well as how to construct complex failure will show you more assertions as well as how to construct complex failure
messages, propagate fatal failures, reuse and speed up your test fixtures, and messages, propagate fatal failures, reuse and speed up your test fixtures, and
use various flags with your tests. use various flags with your tests.
@ -25,7 +25,7 @@ Reference.
### Predicate Assertions for Better Error Messages ### Predicate Assertions for Better Error Messages
Even though googletest has a rich set of assertions, they can never be complete, Even though GoogleTest has a rich set of assertions, they can never be complete,
as it's impossible (nor a good idea) to anticipate all scenarios a user might as it's impossible (nor a good idea) to anticipate all scenarios a user might
run into. Therefore, sometimes a user has to use `EXPECT_TRUE()` to check a run into. Therefore, sometimes a user has to use `EXPECT_TRUE()` to check a
complex expression, for lack of a better macro. This has the problem of not complex expression, for lack of a better macro. This has the problem of not
@ -35,7 +35,7 @@ failure message by themselves, streaming it into `EXPECT_TRUE()`. However, this
is awkward especially when the expression has side-effects or is expensive to is awkward especially when the expression has side-effects or is expensive to
evaluate. evaluate.
googletest gives you three different options to solve this problem: GoogleTest gives you three different options to solve this problem:
#### Using an Existing Boolean Function #### Using an Existing Boolean Function
@ -304,9 +304,9 @@ TEST_F(SkipFixture, SkipsOneTest) {
As with assertion macros, you can stream a custom message into `GTEST_SKIP()`. As with assertion macros, you can stream a custom message into `GTEST_SKIP()`.
## Teaching googletest How to Print Your Values ## Teaching GoogleTest How to Print Your Values
When a test assertion such as `EXPECT_EQ` fails, googletest prints the argument When a test assertion such as `EXPECT_EQ` fails, GoogleTest prints the argument
values to help you debug. It does this using a user-extensible value printer. values to help you debug. It does this using a user-extensible value printer.
This printer knows how to print built-in C++ types, native arrays, STL This printer knows how to print built-in C++ types, native arrays, STL
@ -315,73 +315,96 @@ prints the raw bytes in the value and hopes that you the user can figure it out.
As mentioned earlier, the printer is *extensible*. That means you can teach it As mentioned earlier, the printer is *extensible*. That means you can teach it
to do a better job at printing your particular type than to dump the bytes. To to do a better job at printing your particular type than to dump the bytes. To
do that, define `<<` for your type: do that, define an `AbslStringify()` overload as a `friend` function template
for your type:
```c++
#include <ostream>
```cpp
namespace foo { namespace foo {
class Bar { // We want googletest to be able to print instances of this. class Point { // We want GoogleTest to be able to print instances of this.
... ...
// Create a free inline friend function. // Provide a friend overload.
friend std::ostream& operator<<(std::ostream& os, const Bar& bar) { template <typename Sink>
return os << bar.DebugString(); // whatever needed to print bar to os friend void AbslStringify(Sink& sink, const Point& point) {
absl::Format(&sink, "(%d, %d)", point.x, point.y);
} }
int x;
int y;
}; };
// If you can't declare the function in the class it's important that the // If you can't declare the function in the class it's important that the
// << operator is defined in the SAME namespace that defines Bar. C++'s look-up // AbslStringify overload is defined in the SAME namespace that defines Point.
// rules rely on that. // C++'s look-up rules rely on that.
std::ostream& operator<<(std::ostream& os, const Bar& bar) { enum class EnumWithStringify { kMany = 0, kChoices = 1 };
return os << bar.DebugString(); // whatever needed to print bar to os
template <typename Sink>
void AbslStringify(Sink& sink, EnumWithStringify e) {
absl::Format(&sink, "%s", e == EnumWithStringify::kMany ? "Many" : "Choices");
} }
} // namespace foo } // namespace foo
``` ```
Sometimes, this might not be an option: your team may consider it bad style to {: .callout .note}
have a `<<` operator for `Bar`, or `Bar` may already have a `<<` operator that Note: `AbslStringify()` utilizes a generic "sink" buffer to construct its
doesn't do what you want (and you cannot change it). If so, you can instead string. For more information about supported operations on `AbslStringify()`'s
define a `PrintTo()` function like this: sink, see go/abslstringify.
`AbslStringify()` can also use `absl::StrFormat`'s catch-all `%v` type specifier
within its own format strings to perform type deduction. `Point` above could be
formatted as `"(%v, %v)"` for example, and deduce the `int` values as `%d`.
Sometimes, `AbslStringify()` might not be an option: your team may wish to print
types with extra debugging information for testing purposes only. If so, you can
instead define a `PrintTo()` function like this:
```c++ ```c++
#include <ostream> #include <ostream>
namespace foo { namespace foo {
class Bar { class Point {
... ...
friend void PrintTo(const Bar& bar, std::ostream* os) { friend void PrintTo(const Point& point, std::ostream* os) {
*os << bar.DebugString(); // whatever needed to print bar to os *os << "(" << point.x << "," << point.y << ")";
} }
int x;
int y;
}; };
// If you can't declare the function in the class it's important that PrintTo() // If you can't declare the function in the class it's important that PrintTo()
// is defined in the SAME namespace that defines Bar. C++'s look-up rules rely // is defined in the SAME namespace that defines Point. C++'s look-up rules
// on that. // rely on that.
void PrintTo(const Bar& bar, std::ostream* os) { void PrintTo(const Point& point, std::ostream* os) {
*os << bar.DebugString(); // whatever needed to print bar to os *os << "(" << point.x << "," << point.y << ")";
} }
} // namespace foo } // namespace foo
``` ```
If you have defined both `<<` and `PrintTo()`, the latter will be used when If you have defined both `AbslStringify()` and `PrintTo()`, the latter will be
googletest is concerned. This allows you to customize how the value appears in used by GoogleTest. This allows you to customize how the value appears in
googletest's output without affecting code that relies on the behavior of its GoogleTest's output without affecting code that relies on the behavior of
`<<` operator. `AbslStringify()`.
If you want to print a value `x` using googletest's value printer yourself, just If you have an existing `<<` operator and would like to define an
`AbslStringify()`, the latter will be used for GoogleTest printing.
If you want to print a value `x` using GoogleTest's value printer yourself, just
call `::testing::PrintToString(x)`, which returns an `std::string`: call `::testing::PrintToString(x)`, which returns an `std::string`:
```c++ ```c++
vector<pair<Bar, int> > bar_ints = GetBarIntVector(); vector<pair<Point, int> > point_ints = GetPointIntVector();
EXPECT_TRUE(IsCorrectBarIntVector(bar_ints)) EXPECT_TRUE(IsCorrectPointIntVector(point_ints))
<< "bar_ints = " << testing::PrintToString(bar_ints); << "point_ints = " << testing::PrintToString(point_ints);
``` ```
For more details regarding `AbslStringify()` and its integration with other
libraries, see go/abslstringify.
## Death Tests ## Death Tests
In many applications, there are assertions that can cause application failure if In many applications, there are assertions that can cause application failure if
@ -451,7 +474,7 @@ Note that a death test only cares about three things:
3. does the stderr output match `matcher`? 3. does the stderr output match `matcher`?
In particular, if `statement` generates an `ASSERT_*` or `EXPECT_*` failure, it In particular, if `statement` generates an `ASSERT_*` or `EXPECT_*` failure, it
will **not** cause the death test to fail, as googletest assertions don't abort will **not** cause the death test to fail, as GoogleTest assertions don't abort
the process. the process.
### Death Test Naming ### Death Test Naming
@ -482,14 +505,14 @@ TEST_F(FooDeathTest, DoesThat) {
### Regular Expression Syntax ### Regular Expression Syntax
When built with Bazel and using Abseil, googletest uses the When built with Bazel and using Abseil, GoogleTest uses the
[RE2](https://github.com/google/re2/wiki/Syntax) syntax. Otherwise, for POSIX [RE2](https://github.com/google/re2/wiki/Syntax) syntax. Otherwise, for POSIX
systems (Linux, Cygwin, Mac), googletest uses the systems (Linux, Cygwin, Mac), GoogleTest uses the
[POSIX extended regular expression](http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html#tag_09_04) [POSIX extended regular expression](http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html#tag_09_04)
syntax. To learn about POSIX syntax, you may want to read this syntax. To learn about POSIX syntax, you may want to read this
[Wikipedia entry](http://en.wikipedia.org/wiki/Regular_expression#POSIX_extended). [Wikipedia entry](http://en.wikipedia.org/wiki/Regular_expression#POSIX_extended).
On Windows, googletest uses its own simple regular expression implementation. It On Windows, GoogleTest uses its own simple regular expression implementation. It
lacks many features. For example, we don't support union (`"x|y"`), grouping lacks many features. For example, we don't support union (`"x|y"`), grouping
(`"(xy)"`), brackets (`"[xy]"`), and repetition count (`"x{5,7}"`), among (`"(xy)"`), brackets (`"[xy]"`), and repetition count (`"x{5,7}"`), among
others. Below is what we do support (`A` denotes a literal character, period others. Below is what we do support (`A` denotes a literal character, period
@ -519,7 +542,7 @@ Expression | Meaning
`$` | matches the end of a string (not that of each line) `$` | matches the end of a string (not that of each line)
`xy` | matches `x` followed by `y` `xy` | matches `x` followed by `y`
To help you determine which capability is available on your system, googletest To help you determine which capability is available on your system, GoogleTest
defines macros to govern which regular expression it is using. The macros are: defines macros to govern which regular expression it is using. The macros are:
`GTEST_USES_SIMPLE_RE=1` or `GTEST_USES_POSIX_RE=1`. If you want your death `GTEST_USES_SIMPLE_RE=1` or `GTEST_USES_POSIX_RE=1`. If you want your death
tests to work in all cases, you can either `#if` on these macros or use the more tests to work in all cases, you can either `#if` on these macros or use the more
@ -539,7 +562,7 @@ arrange that kind of environment. For example, statically-initialized modules
may start threads before main is ever reached. Once threads have been created, may start threads before main is ever reached. Once threads have been created,
it may be difficult or impossible to clean them up. it may be difficult or impossible to clean them up.
googletest has three features intended to raise awareness of threading issues. GoogleTest has three features intended to raise awareness of threading issues.
1. A warning is emitted if multiple threads are running when a death test is 1. A warning is emitted if multiple threads are running when a death test is
encountered. encountered.
@ -562,7 +585,7 @@ The automated testing framework does not set the style flag. You can choose a
particular style of death tests by setting the flag programmatically: particular style of death tests by setting the flag programmatically:
```c++ ```c++
GTEST_FLAG_SET(death_test_style, "threadsafe") GTEST_FLAG_SET(death_test_style, "threadsafe");
``` ```
You can do this in `main()` to set the style for all death tests in the binary, You can do this in `main()` to set the style for all death tests in the binary,
@ -592,7 +615,7 @@ TEST(MyDeathTest, TestTwo) {
The `statement` argument of `ASSERT_EXIT()` can be any valid C++ statement. If The `statement` argument of `ASSERT_EXIT()` can be any valid C++ statement. If
it leaves the current function via a `return` statement or by throwing an it leaves the current function via a `return` statement or by throwing an
exception, the death test is considered to have failed. Some googletest macros exception, the death test is considered to have failed. Some GoogleTest macros
may return from the current function (e.g. `ASSERT_TRUE()`), so be sure to avoid may return from the current function (e.g. `ASSERT_TRUE()`), so be sure to avoid
them in `statement`. them in `statement`.
@ -726,7 +749,7 @@ TEST(FooTest, Bar) {
} }
``` ```
To alleviate this, googletest provides three different solutions. You could use To alleviate this, GoogleTest provides three different solutions. You could use
either exceptions, the `(ASSERT|EXPECT)_NO_FATAL_FAILURE` assertions or the either exceptions, the `(ASSERT|EXPECT)_NO_FATAL_FAILURE` assertions or the
`HasFatalFailure()` function. They are described in the following two `HasFatalFailure()` function. They are described in the following two
subsections. subsections.
@ -760,7 +783,7 @@ in it, the test will continue after the subroutine returns. This may not be what
you want. you want.
Often people want fatal failures to propagate like exceptions. For that Often people want fatal failures to propagate like exceptions. For that
googletest offers the following macros: GoogleTest offers the following macros:
Fatal assertion | Nonfatal assertion | Verifies Fatal assertion | Nonfatal assertion | Verifies
------------------------------------- | ------------------------------------- | -------- ------------------------------------- | ------------------------------------- | --------
@ -852,7 +875,7 @@ will output XML like this:
> needs to be prefixed with `::testing::Test::` if used outside of the > needs to be prefixed with `::testing::Test::` if used outside of the
> `TEST` body and the test fixture class. > `TEST` body and the test fixture class.
> * *`key`* must be a valid XML attribute name, and cannot conflict with the > * *`key`* must be a valid XML attribute name, and cannot conflict with the
> ones already used by googletest (`name`, `status`, `time`, `classname`, > ones already used by GoogleTest (`name`, `status`, `time`, `classname`,
> `type_param`, and `value_param`). > `type_param`, and `value_param`).
> * Calling `RecordProperty()` outside of the lifespan of a test is allowed. > * Calling `RecordProperty()` outside of the lifespan of a test is allowed.
> If it's called outside of a test but between a test suite's > If it's called outside of a test but between a test suite's
@ -863,13 +886,13 @@ will output XML like this:
## Sharing Resources Between Tests in the Same Test Suite ## Sharing Resources Between Tests in the Same Test Suite
googletest creates a new test fixture object for each test in order to make GoogleTest creates a new test fixture object for each test in order to make
tests independent and easier to debug. However, sometimes tests use resources tests independent and easier to debug. However, sometimes tests use resources
that are expensive to set up, making the one-copy-per-test model prohibitively that are expensive to set up, making the one-copy-per-test model prohibitively
expensive. expensive.
If the tests don't change the resource, there's no harm in their sharing a If the tests don't change the resource, there's no harm in their sharing a
single resource copy. So, in addition to per-test set-up/tear-down, googletest single resource copy. So, in addition to per-test set-up/tear-down, GoogleTest
also supports per-test-suite set-up/tear-down. To use it: also supports per-test-suite set-up/tear-down. To use it:
1. In your test fixture class (say `FooTest` ), declare as `static` some member 1. In your test fixture class (say `FooTest` ), declare as `static` some member
@ -881,7 +904,7 @@ also supports per-test-suite set-up/tear-down. To use it:
`u`!) to set up the shared resources and a `static void TearDownTestSuite()` `u`!) to set up the shared resources and a `static void TearDownTestSuite()`
function to tear them down. function to tear them down.
That's it! googletest automatically calls `SetUpTestSuite()` before running the That's it! GoogleTest automatically calls `SetUpTestSuite()` before running the
*first test* in the `FooTest` test suite (i.e. before creating the first *first test* in the `FooTest` test suite (i.e. before creating the first
`FooTest` object), and calls `TearDownTestSuite()` after running the *last test* `FooTest` object), and calls `TearDownTestSuite()` after running the *last test*
in it (i.e. after deleting the last `FooTest` object). In between, the tests can in it (i.e. after deleting the last `FooTest` object). In between, the tests can
@ -974,7 +997,7 @@ class Environment : public ::testing::Environment {
}; };
``` ```
Then, you register an instance of your environment class with googletest by Then, you register an instance of your environment class with GoogleTest by
calling the `::testing::AddGlobalTestEnvironment()` function: calling the `::testing::AddGlobalTestEnvironment()` function:
```c++ ```c++
@ -991,7 +1014,7 @@ It's OK to register multiple environment objects. In this suite, their `SetUp()`
will be called in the order they are registered, and their `TearDown()` will be will be called in the order they are registered, and their `TearDown()` will be
called in the reverse order. called in the reverse order.
Note that googletest takes ownership of the registered environment objects. Note that GoogleTest takes ownership of the registered environment objects.
Therefore **do not delete them** by yourself. Therefore **do not delete them** by yourself.
You should call `AddGlobalTestEnvironment()` before `RUN_ALL_TESTS()` is called, You should call `AddGlobalTestEnvironment()` before `RUN_ALL_TESTS()` is called,
@ -1043,7 +1066,7 @@ they must be declared **public** rather than **protected** in order to use
```c++ ```c++
class FooTest : class FooTest :
public testing::TestWithParam<const char*> { public testing::TestWithParam<absl::string_view> {
// You can implement all the usual fixture class members here. // You can implement all the usual fixture class members here.
// To access the test parameter, call GetParam() from class // To access the test parameter, call GetParam() from class
// TestWithParam<T>. // TestWithParam<T>.
@ -1054,7 +1077,7 @@ class BaseTest : public testing::Test {
... ...
}; };
class BarTest : public BaseTest, class BarTest : public BaseTest,
public testing::WithParamInterface<const char*> { public testing::WithParamInterface<absl::string_view> {
... ...
}; };
``` ```
@ -1125,8 +1148,8 @@ with parameter values `"cat"` and `"dog"` using the
[`ValuesIn`](reference/testing.md#param-generators) parameter generator: [`ValuesIn`](reference/testing.md#param-generators) parameter generator:
```c++ ```c++
const char* pets[] = {"cat", "dog"}; constexpr absl::string_view kPets[] = {"cat", "dog"};
INSTANTIATE_TEST_SUITE_P(Pets, FooTest, testing::ValuesIn(pets)); INSTANTIATE_TEST_SUITE_P(Pets, FooTest, testing::ValuesIn(kPets));
``` ```
The tests from the instantiation above will have these names: The tests from the instantiation above will have these names:
@ -1501,12 +1524,12 @@ To test them, we use the following special techniques:
## "Catching" Failures ## "Catching" Failures
If you are building a testing utility on top of googletest, you'll want to test If you are building a testing utility on top of GoogleTest, you'll want to test
your utility. What framework would you use to test it? googletest, of course. your utility. What framework would you use to test it? GoogleTest, of course.
The challenge is to verify that your testing utility reports failures correctly. The challenge is to verify that your testing utility reports failures correctly.
In frameworks that report a failure by throwing an exception, you could catch In frameworks that report a failure by throwing an exception, you could catch
the exception and assert on it. But googletest doesn't use exceptions, so how do the exception and assert on it. But GoogleTest doesn't use exceptions, so how do
we test that a piece of code generates an expected failure? we test that a piece of code generates an expected failure?
`"gtest/gtest-spi.h"` contains some constructs to do this. `"gtest/gtest-spi.h"` contains some constructs to do this.
@ -1649,9 +1672,9 @@ particular, you cannot find the test suite name in `SetUpTestSuite()`,
`TearDownTestSuite()` (where you know the test suite name implicitly), or `TearDownTestSuite()` (where you know the test suite name implicitly), or
functions called from them. functions called from them.
## Extending googletest by Handling Test Events ## Extending GoogleTest by Handling Test Events
googletest provides an **event listener API** to let you receive notifications GoogleTest provides an **event listener API** to let you receive notifications
about the progress of a test program and test failures. The events you can about the progress of a test program and test failures. The events you can
listen to include the start and end of the test program, a test suite, or a test listen to include the start and end of the test program, a test suite, or a test
method, among others. You may use this API to augment or replace the standard method, among others. You may use this API to augment or replace the standard
@ -1712,7 +1735,7 @@ Here's an example:
### Using Event Listeners ### Using Event Listeners
To use the event listener you have defined, add an instance of it to the To use the event listener you have defined, add an instance of it to the
googletest event listener list (represented by class GoogleTest event listener list (represented by class
[`TestEventListeners`](reference/testing.md#TestEventListeners) - note the "s" [`TestEventListeners`](reference/testing.md#TestEventListeners) - note the "s"
at the end of the name) in your `main()` function, before calling at the end of the name) in your `main()` function, before calling
`RUN_ALL_TESTS()`: `RUN_ALL_TESTS()`:
@ -1723,7 +1746,7 @@ int main(int argc, char** argv) {
// Gets hold of the event listener list. // Gets hold of the event listener list.
testing::TestEventListeners& listeners = testing::TestEventListeners& listeners =
testing::UnitTest::GetInstance()->listeners(); testing::UnitTest::GetInstance()->listeners();
// Adds a listener to the end. googletest takes the ownership. // Adds a listener to the end. GoogleTest takes the ownership.
listeners.Append(new MinimalistPrinter); listeners.Append(new MinimalistPrinter);
return RUN_ALL_TESTS(); return RUN_ALL_TESTS();
} }
@ -1775,7 +1798,7 @@ See [sample10_unittest.cc] for an example of a failure-raising listener.
## Running Test Programs: Advanced Options ## Running Test Programs: Advanced Options
googletest test programs are ordinary executables. Once built, you can run them GoogleTest test programs are ordinary executables. Once built, you can run them
directly and affect their behavior via the following environment variables directly and affect their behavior via the following environment variables
and/or command line flags. For the flags to work, your programs must call and/or command line flags. For the flags to work, your programs must call
`::testing::InitGoogleTest()` before calling `RUN_ALL_TESTS()`. `::testing::InitGoogleTest()` before calling `RUN_ALL_TESTS()`.
@ -1808,10 +1831,10 @@ corresponding environment variable for this flag.
#### Running a Subset of the Tests #### Running a Subset of the Tests
By default, a googletest program runs all tests the user has defined. Sometimes, By default, a GoogleTest program runs all tests the user has defined. Sometimes,
you want to run only a subset of the tests (e.g. for debugging or quickly you want to run only a subset of the tests (e.g. for debugging or quickly
verifying a change). If you set the `GTEST_FILTER` environment variable or the verifying a change). If you set the `GTEST_FILTER` environment variable or the
`--gtest_filter` flag to a filter string, googletest will only run the tests `--gtest_filter` flag to a filter string, GoogleTest will only run the tests
whose full names (in the form of `TestSuiteName.TestName`) match the filter. whose full names (in the form of `TestSuiteName.TestName`) match the filter.
The format of a filter is a '`:`'-separated list of wildcard patterns (called The format of a filter is a '`:`'-separated list of wildcard patterns (called
@ -1842,7 +1865,7 @@ For example:
#### Stop test execution upon first failure #### Stop test execution upon first failure
By default, a googletest program runs all tests the user has defined. In some By default, a GoogleTest program runs all tests the user has defined. In some
cases (e.g. iterative test development & execution) it may be desirable stop cases (e.g. iterative test development & execution) it may be desirable stop
test execution upon first failure (trading improved latency for completeness). test execution upon first failure (trading improved latency for completeness).
If `GTEST_FAIL_FAST` environment variable or `--gtest_fail_fast` flag is set, If `GTEST_FAIL_FAST` environment variable or `--gtest_fail_fast` flag is set,
@ -1859,7 +1882,7 @@ If you need to disable all tests in a test suite, you can either add `DISABLED_`
to the front of the name of each test, or alternatively add it to the front of to the front of the name of each test, or alternatively add it to the front of
the test suite name. the test suite name.
For example, the following tests won't be run by googletest, even though they For example, the following tests won't be run by GoogleTest, even though they
will still be compiled: will still be compiled:
```c++ ```c++
@ -1874,7 +1897,7 @@ TEST_F(DISABLED_BarTest, DoesXyz) { ... }
{: .callout .note} {: .callout .note}
NOTE: This feature should only be used for temporary pain-relief. You still have NOTE: This feature should only be used for temporary pain-relief. You still have
to fix the disabled tests at a later date. As a reminder, googletest will print to fix the disabled tests at a later date. As a reminder, GoogleTest will print
a banner warning you if a test program contains any disabled tests. a banner warning you if a test program contains any disabled tests.
{: .callout .tip} {: .callout .tip}
@ -1932,16 +1955,16 @@ You can specify the `--gtest_shuffle` flag (or set the `GTEST_SHUFFLE`
environment variable to `1`) to run the tests in a program in a random order. environment variable to `1`) to run the tests in a program in a random order.
This helps to reveal bad dependencies between tests. This helps to reveal bad dependencies between tests.
By default, googletest uses a random seed calculated from the current time. By default, GoogleTest uses a random seed calculated from the current time.
Therefore you'll get a different order every time. The console output includes Therefore you'll get a different order every time. The console output includes
the random seed value, such that you can reproduce an order-related test failure the random seed value, such that you can reproduce an order-related test failure
later. To specify the random seed explicitly, use the `--gtest_random_seed=SEED` later. To specify the random seed explicitly, use the `--gtest_random_seed=SEED`
flag (or set the `GTEST_RANDOM_SEED` environment variable), where `SEED` is an flag (or set the `GTEST_RANDOM_SEED` environment variable), where `SEED` is an
integer in the range [0, 99999]. The seed value 0 is special: it tells integer in the range [0, 99999]. The seed value 0 is special: it tells
googletest to do the default behavior of calculating the seed from the current GoogleTest to do the default behavior of calculating the seed from the current
time. time.
If you combine this with `--gtest_repeat=N`, googletest will pick a different If you combine this with `--gtest_repeat=N`, GoogleTest will pick a different
random seed and re-shuffle the tests in each iteration. random seed and re-shuffle the tests in each iteration.
### Distributing Test Functions to Multiple Machines ### Distributing Test Functions to Multiple Machines
@ -2000,7 +2023,7 @@ shards, but here's one possible scenario:
#### Colored Terminal Output #### Colored Terminal Output
googletest can use colors in its terminal output to make it easier to spot the GoogleTest can use colors in its terminal output to make it easier to spot the
important information: important information:
<pre>... <pre>...
@ -2025,25 +2048,25 @@ important information:
You can set the `GTEST_COLOR` environment variable or the `--gtest_color` You can set the `GTEST_COLOR` environment variable or the `--gtest_color`
command line flag to `yes`, `no`, or `auto` (the default) to enable colors, command line flag to `yes`, `no`, or `auto` (the default) to enable colors,
disable colors, or let googletest decide. When the value is `auto`, googletest disable colors, or let GoogleTest decide. When the value is `auto`, GoogleTest
will use colors if and only if the output goes to a terminal and (on non-Windows will use colors if and only if the output goes to a terminal and (on non-Windows
platforms) the `TERM` environment variable is set to `xterm` or `xterm-color`. platforms) the `TERM` environment variable is set to `xterm` or `xterm-color`.
#### Suppressing test passes #### Suppressing test passes
By default, googletest prints 1 line of output for each test, indicating if it By default, GoogleTest prints 1 line of output for each test, indicating if it
passed or failed. To show only test failures, run the test program with passed or failed. To show only test failures, run the test program with
`--gtest_brief=1`, or set the GTEST_BRIEF environment variable to `1`. `--gtest_brief=1`, or set the GTEST_BRIEF environment variable to `1`.
#### Suppressing the Elapsed Time #### Suppressing the Elapsed Time
By default, googletest prints the time it takes to run each test. To disable By default, GoogleTest prints the time it takes to run each test. To disable
that, run the test program with the `--gtest_print_time=0` command line flag, or that, run the test program with the `--gtest_print_time=0` command line flag, or
set the GTEST_PRINT_TIME environment variable to `0`. set the GTEST_PRINT_TIME environment variable to `0`.
#### Suppressing UTF-8 Text Output #### Suppressing UTF-8 Text Output
In case of assertion failures, googletest prints expected and actual values of In case of assertion failures, GoogleTest prints expected and actual values of
type `string` both as hex-encoded strings as well as in readable UTF-8 text if type `string` both as hex-encoded strings as well as in readable UTF-8 text if
they contain valid non-ASCII UTF-8 characters. If you want to suppress the UTF-8 they contain valid non-ASCII UTF-8 characters. If you want to suppress the UTF-8
text because, for example, you don't have an UTF-8 compatible output medium, run text because, for example, you don't have an UTF-8 compatible output medium, run
@ -2052,7 +2075,7 @@ environment variable to `0`.
#### Generating an XML Report #### Generating an XML Report
googletest can emit a detailed XML report to a file in addition to its normal GoogleTest can emit a detailed XML report to a file in addition to its normal
textual output. The report contains the duration of each test, and thus can help textual output. The report contains the duration of each test, and thus can help
you identify slow tests. you identify slow tests.
@ -2063,15 +2086,15 @@ in which case the output can be found in the `test_detail.xml` file in the
current directory. current directory.
If you specify a directory (for example, `"xml:output/directory/"` on Linux or If you specify a directory (for example, `"xml:output/directory/"` on Linux or
`"xml:output\directory\"` on Windows), googletest will create the XML file in `"xml:output\directory\"` on Windows), GoogleTest will create the XML file in
that directory, named after the test executable (e.g. `foo_test.xml` for test that directory, named after the test executable (e.g. `foo_test.xml` for test
program `foo_test` or `foo_test.exe`). If the file already exists (perhaps left program `foo_test` or `foo_test.exe`). If the file already exists (perhaps left
over from a previous run), googletest will pick a different name (e.g. over from a previous run), GoogleTest will pick a different name (e.g.
`foo_test_1.xml`) to avoid overwriting it. `foo_test_1.xml`) to avoid overwriting it.
The report is based on the `junitreport` Ant task. Since that format was The report is based on the `junitreport` Ant task. Since that format was
originally intended for Java, a little interpretation is required to make it originally intended for Java, a little interpretation is required to make it
apply to googletest tests, as shown here: apply to GoogleTest tests, as shown here:
```xml ```xml
<testsuites name="AllTests" ...> <testsuites name="AllTests" ...>
@ -2086,8 +2109,8 @@ apply to googletest tests, as shown here:
``` ```
* The root `<testsuites>` element corresponds to the entire test program. * The root `<testsuites>` element corresponds to the entire test program.
* `<testsuite>` elements correspond to googletest test suites. * `<testsuite>` elements correspond to GoogleTest test suites.
* `<testcase>` elements correspond to googletest test functions. * `<testcase>` elements correspond to GoogleTest test functions.
For instance, the following program For instance, the following program
@ -2120,7 +2143,7 @@ could generate this report:
Things to note: Things to note:
* The `tests` attribute of a `<testsuites>` or `<testsuite>` element tells how * The `tests` attribute of a `<testsuites>` or `<testsuite>` element tells how
many test functions the googletest program or test suite contains, while the many test functions the GoogleTest program or test suite contains, while the
`failures` attribute tells how many of them failed. `failures` attribute tells how many of them failed.
* The `time` attribute expresses the duration of the test, test suite, or * The `time` attribute expresses the duration of the test, test suite, or
@ -2132,12 +2155,12 @@ Things to note:
* The `file` and `line` attributes record the source file location, where the * The `file` and `line` attributes record the source file location, where the
test was defined. test was defined.
* Each `<failure>` element corresponds to a single failed googletest * Each `<failure>` element corresponds to a single failed GoogleTest
assertion. assertion.
#### Generating a JSON Report #### Generating a JSON Report
googletest can also emit a JSON report as an alternative format to XML. To GoogleTest can also emit a JSON report as an alternative format to XML. To
generate the JSON report, set the `GTEST_OUTPUT` environment variable or the generate the JSON report, set the `GTEST_OUTPUT` environment variable or the
`--gtest_output` flag to the string `"json:path_to_output_file"`, which will `--gtest_output` flag to the string `"json:path_to_output_file"`, which will
create the file at the given location. You can also just use the string create the file at the given location. You can also just use the string
@ -2362,7 +2385,7 @@ variable has been set.
When running test programs under a debugger, it's very convenient if the When running test programs under a debugger, it's very convenient if the
debugger can catch an assertion failure and automatically drop into interactive debugger can catch an assertion failure and automatically drop into interactive
mode. googletest's *break-on-failure* mode supports this behavior. mode. GoogleTest's *break-on-failure* mode supports this behavior.
To enable it, set the `GTEST_BREAK_ON_FAILURE` environment variable to a value To enable it, set the `GTEST_BREAK_ON_FAILURE` environment variable to a value
other than `0`. Alternatively, you can use the `--gtest_break_on_failure` other than `0`. Alternatively, you can use the `--gtest_break_on_failure`
@ -2370,9 +2393,9 @@ command line flag.
#### Disabling Catching Test-Thrown Exceptions #### Disabling Catching Test-Thrown Exceptions
googletest can be used either with or without exceptions enabled. If a test GoogleTest can be used either with or without exceptions enabled. If a test
throws a C++ exception or (on Windows) a structured exception (SEH), by default throws a C++ exception or (on Windows) a structured exception (SEH), by default
googletest catches it, reports it as a test failure, and continues with the next GoogleTest catches it, reports it as a test failure, and continues with the next
test method. This maximizes the coverage of a test run. Also, on Windows an test method. This maximizes the coverage of a test run. Also, on Windows an
uncaught exception will cause a pop-up window, so catching the exceptions allows uncaught exception will cause a pop-up window, so catching the exceptions allows
you to run the tests automatically. you to run the tests automatically.
@ -2410,4 +2433,4 @@ void __tsan_on_report() {
``` ```
After compiling your project with one of the sanitizers enabled, if a particular After compiling your project with one of the sanitizers enabled, if a particular
test triggers a sanitizer error, googletest will report that it failed. test triggers a sanitizer error, GoogleTest will report that it failed.

31
docs/gmock_cook_book.md
View File

@ -2781,26 +2781,21 @@ action:
If you are not happy with the default action, you can tweak it as usual; see If you are not happy with the default action, you can tweak it as usual; see
[Setting Default Actions](#OnCall). [Setting Default Actions](#OnCall).
If you just need to return a pre-defined move-only value, you can use the If you just need to return a move-only value, you can use it in combination with
`Return(ByMove(...))` action: `WillOnce`. For example:
```cpp ```cpp
// When this fires, the unique_ptr<> specified by ByMove(...) will EXPECT_CALL(mock_buzzer_, MakeBuzz("hello"))
// be returned. .WillOnce(Return(std::make_unique<Buzz>(AccessLevel::kInternal)));
EXPECT_CALL(mock_buzzer_, MakeBuzz("world")) EXPECT_NE(nullptr, mock_buzzer_.MakeBuzz("hello"));
.WillOnce(Return(ByMove(std::make_unique<Buzz>(AccessLevel::kInternal))));
EXPECT_NE(nullptr, mock_buzzer_.MakeBuzz("world"));
``` ```
Note that `ByMove()` is essential here - if you drop it, the code won’t compile. Quiz time! What do you think will happen if a `Return` action is performed more
than once (e.g. you write `... .WillRepeatedly(Return(std::move(...)));`)? Come
Quiz time! What do you think will happen if a `Return(ByMove(...))` action is think of it, after the first time the action runs, the source value will be
performed more than once (e.g. you write `... consumed (since it’s a move-only value), so the next time around, there’s no
.WillRepeatedly(Return(ByMove(...)));`)? Come think of it, after the first time value to move from -- you’ll get a run-time error that `Return(std::move(...))`
the action runs, the source value will be consumed (since it’s a move-only can only be run once.
value), so the next time around, there’s no value to move from -- you’ll get a
run-time error that `Return(ByMove(...))` can only be run once.
If you need your mock method to do more than just moving a pre-defined value, If you need your mock method to do more than just moving a pre-defined value,
remember that you can always use a lambda or a callable object, which can do remember that you can always use a lambda or a callable object, which can do
@ -2817,7 +2812,7 @@ pretty much anything you want:
``` ```
Every time this `EXPECT_CALL` fires, a new `unique_ptr<Buzz>` will be created Every time this `EXPECT_CALL` fires, a new `unique_ptr<Buzz>` will be created
and returned. You cannot do this with `Return(ByMove(...))`. and returned. You cannot do this with `Return(std::make_unique<...>(...))`.
That covers returning move-only values; but how do we work with methods That covers returning move-only values; but how do we work with methods
accepting move-only arguments? The answer is that they work normally, although accepting move-only arguments? The answer is that they work normally, although
@ -4298,7 +4293,7 @@ particular type than to dump the bytes.
### Mock std::function {#MockFunction} ### Mock std::function {#MockFunction}
`std::function` is a general function type introduced in C++11. It is a `std::function` is a general function type introduced in C++11. It is a
preferred way of passing callbacks to new interfaces. Functions are copiable, preferred way of passing callbacks to new interfaces. Functions are copyable,
and are not usually passed around by pointer, which makes them tricky to mock. and are not usually passed around by pointer, which makes them tricky to mock.
But fear not - `MockFunction` can help you with that. But fear not - `MockFunction` can help you with that.

92
docs/primer.md
View File

@ -1,74 +1,74 @@
# Googletest Primer # GoogleTest Primer
## Introduction: Why googletest? ## Introduction: Why GoogleTest?
*googletest* helps you write better C++ tests. *GoogleTest* helps you write better C++ tests.
googletest is a testing framework developed by the Testing Technology team with GoogleTest is a testing framework developed by the Testing Technology team with
Google's specific requirements and constraints in mind. Whether you work on Google's specific requirements and constraints in mind. Whether you work on
Linux, Windows, or a Mac, if you write C++ code, googletest can help you. And it Linux, Windows, or a Mac, if you write C++ code, GoogleTest can help you. And it
supports *any* kind of tests, not just unit tests. supports *any* kind of tests, not just unit tests.
So what makes a good test, and how does googletest fit in? We believe: So what makes a good test, and how does GoogleTest fit in? We believe:
1. Tests should be *independent* and *repeatable*. It's a pain to debug a test 1. Tests should be *independent* and *repeatable*. It's a pain to debug a test
that succeeds or fails as a result of other tests. googletest isolates the that succeeds or fails as a result of other tests. GoogleTest isolates the
tests by running each of them on a different object. When a test fails, tests by running each of them on a different object. When a test fails,
googletest allows you to run it in isolation for quick debugging. GoogleTest allows you to run it in isolation for quick debugging.
2. Tests should be well *organized* and reflect the structure of the tested 2. Tests should be well *organized* and reflect the structure of the tested
code. googletest groups related tests into test suites that can share data code. GoogleTest groups related tests into test suites that can share data
and subroutines. This common pattern is easy to recognize and makes tests and subroutines. This common pattern is easy to recognize and makes tests
easy to maintain. Such consistency is especially helpful when people switch easy to maintain. Such consistency is especially helpful when people switch
projects and start to work on a new code base. projects and start to work on a new code base.
3. Tests should be *portable* and *reusable*. Google has a lot of code that is 3. Tests should be *portable* and *reusable*. Google has a lot of code that is
platform-neutral; its tests should also be platform-neutral. googletest platform-neutral; its tests should also be platform-neutral. GoogleTest
works on different OSes, with different compilers, with or without works on different OSes, with different compilers, with or without
exceptions, so googletest tests can work with a variety of configurations. exceptions, so GoogleTest tests can work with a variety of configurations.
4. When tests fail, they should provide as much *information* about the problem 4. When tests fail, they should provide as much *information* about the problem
as possible. googletest doesn't stop at the first test failure. Instead, it as possible. GoogleTest doesn't stop at the first test failure. Instead, it
only stops the current test and continues with the next. You can also set up only stops the current test and continues with the next. You can also set up
tests that report non-fatal failures after which the current test continues. tests that report non-fatal failures after which the current test continues.
Thus, you can detect and fix multiple bugs in a single run-edit-compile Thus, you can detect and fix multiple bugs in a single run-edit-compile
cycle. cycle.
5. The testing framework should liberate test writers from housekeeping chores 5. The testing framework should liberate test writers from housekeeping chores
and let them focus on the test *content*. googletest automatically keeps and let them focus on the test *content*. GoogleTest automatically keeps
track of all tests defined, and doesn't require the user to enumerate them track of all tests defined, and doesn't require the user to enumerate them
in order to run them. in order to run them.
6. Tests should be *fast*. With googletest, you can reuse shared resources 6. Tests should be *fast*. With GoogleTest, you can reuse shared resources
across tests and pay for the set-up/tear-down only once, without making across tests and pay for the set-up/tear-down only once, without making
tests depend on each other. tests depend on each other.
Since googletest is based on the popular xUnit architecture, you'll feel right Since GoogleTest is based on the popular xUnit architecture, you'll feel right
at home if you've used JUnit or PyUnit before. If not, it will take you about 10 at home if you've used JUnit or PyUnit before. If not, it will take you about 10
minutes to learn the basics and get started. So let's go! minutes to learn the basics and get started. So let's go!
## Beware of the nomenclature ## Beware of the nomenclature
{: .callout .note} {: .callout .note}
_Note:_ There might be some confusion arising from different definitions of the *Note:* There might be some confusion arising from different definitions of the
terms _Test_, _Test Case_ and _Test Suite_, so beware of misunderstanding these. terms *Test*, *Test Case* and *Test Suite*, so beware of misunderstanding these.
Historically, googletest started to use the term _Test Case_ for grouping Historically, GoogleTest started to use the term *Test Case* for grouping
related tests, whereas current publications, including International Software related tests, whereas current publications, including International Software
Testing Qualifications Board ([ISTQB](http://www.istqb.org/)) materials and Testing Qualifications Board ([ISTQB](http://www.istqb.org/)) materials and
various textbooks on software quality, use the term various textbooks on software quality, use the term
_[Test Suite][istqb test suite]_ for this. *[Test Suite][istqb test suite]* for this.
The related term _Test_, as it is used in googletest, corresponds to the term The related term *Test*, as it is used in GoogleTest, corresponds to the term
_[Test Case][istqb test case]_ of ISTQB and others. *[Test Case][istqb test case]* of ISTQB and others.
The term _Test_ is commonly of broad enough sense, including ISTQB's definition The term *Test* is commonly of broad enough sense, including ISTQB's definition
of _Test Case_, so it's not much of a problem here. But the term _Test Case_ as of *Test Case*, so it's not much of a problem here. But the term *Test Case* as
was used in Google Test is of contradictory sense and thus confusing. was used in Google Test is of contradictory sense and thus confusing.
googletest recently started replacing the term _Test Case_ with _Test Suite_. GoogleTest recently started replacing the term *Test Case* with *Test Suite*.
The preferred API is *TestSuite*. The older TestCase API is being slowly The preferred API is *TestSuite*. The older TestCase API is being slowly
deprecated and refactored away. deprecated and refactored away.
So please be aware of the different definitions of the terms: So please be aware of the different definitions of the terms:
Meaning | googletest Term | [ISTQB](http://www.istqb.org/) Term Meaning | GoogleTest Term | [ISTQB](http://www.istqb.org/) Term
:----------------------------------------------------------------------------------- | :---------------------- | :---------------------------------- :----------------------------------------------------------------------------------- | :---------------------- | :----------------------------------
Exercise a particular program path with specific input values and verify the results | [TEST()](#simple-tests) | [Test Case][istqb test case] Exercise a particular program path with specific input values and verify the results | [TEST()](#simple-tests) | [Test Case][istqb test case]
@ -78,7 +78,7 @@ Exercise a particular program path with specific input values and verify the res
## Basic Concepts ## Basic Concepts
When using googletest, you start by writing *assertions*, which are statements When using GoogleTest, you start by writing *assertions*, which are statements
that check whether a condition is true. An assertion's result can be *success*, that check whether a condition is true. An assertion's result can be *success*,
*nonfatal failure*, or *fatal failure*. If a fatal failure occurs, it aborts the *nonfatal failure*, or *fatal failure*. If a fatal failure occurs, it aborts the
current function; otherwise the program continues normally. current function; otherwise the program continues normally.
@ -98,11 +98,11 @@ assertion level and building up to tests and test suites.
## Assertions ## Assertions
googletest assertions are macros that resemble function calls. You test a class GoogleTest assertions are macros that resemble function calls. You test a class
or function by making assertions about its behavior. When an assertion fails, or function by making assertions about its behavior. When an assertion fails,
googletest prints the assertion's source file and line number location, along GoogleTest prints the assertion's source file and line number location, along
with a failure message. You may also supply a custom failure message which will with a failure message. You may also supply a custom failure message which will
be appended to googletest's message. be appended to GoogleTest's message.
The assertions come in pairs that test the same thing but have different effects The assertions come in pairs that test the same thing but have different effects
on the current function. `ASSERT_*` versions generate fatal failures when they on the current function. `ASSERT_*` versions generate fatal failures when they
@ -149,7 +149,7 @@ To create a test:
1. Use the `TEST()` macro to define and name a test function. These are 1. Use the `TEST()` macro to define and name a test function. These are
ordinary C++ functions that don't return a value. ordinary C++ functions that don't return a value.
2. In this function, along with any valid C++ statements you want to include, 2. In this function, along with any valid C++ statements you want to include,
use the various googletest assertions to check values. use the various GoogleTest assertions to check values.
3. The test's result is determined by the assertions; if any assertion in the 3. The test's result is determined by the assertions; if any assertion in the
test fails (either fatally or non-fatally), or if the test crashes, the test fails (either fatally or non-fatally), or if the test crashes, the
entire test fails. Otherwise, it succeeds. entire test fails. Otherwise, it succeeds.
@ -190,7 +190,7 @@ TEST(FactorialTest, HandlesPositiveInput) {
} }
``` ```
googletest groups the test results by test suites, so logically related tests GoogleTest groups the test results by test suites, so logically related tests
should be in the same test suite; in other words, the first argument to their should be in the same test suite; in other words, the first argument to their
`TEST()` should be the same. In the above example, we have two tests, `TEST()` should be the same. In the above example, we have two tests,
`HandlesZeroInput` and `HandlesPositiveInput`, that belong to the same test `HandlesZeroInput` and `HandlesPositiveInput`, that belong to the same test
@ -227,14 +227,14 @@ When using a fixture, use `TEST_F()` instead of `TEST()` as it allows you to
access objects and subroutines in the test fixture: access objects and subroutines in the test fixture:
```c++ ```c++
TEST_F(TestFixtureName, TestName) { TEST_F(TestFixtureClassName, TestName) {
... test body ... ... test body ...
} }
``` ```
Like `TEST()`, the first argument is the test suite name, but for `TEST_F()` Unlike `TEST()`, in `TEST_F()` the first argument must be the name of the test
this must be the name of the test fixture class. You've probably guessed: `_F` fixture class. (`_F` stands for "Fixture"). No test suite name is specified for
is for fixture. this macro.
Unfortunately, the C++ macro system does not allow us to create a single macro Unfortunately, the C++ macro system does not allow us to create a single macro
that can handle both types of tests. Using the wrong macro causes a compiler that can handle both types of tests. Using the wrong macro causes a compiler
@ -244,12 +244,12 @@ Also, you must first define a test fixture class before using it in a
`TEST_F()`, or you'll get the compiler error "`virtual outside class `TEST_F()`, or you'll get the compiler error "`virtual outside class
declaration`". declaration`".
For each test defined with `TEST_F()`, googletest will create a *fresh* test For each test defined with `TEST_F()`, GoogleTest will create a *fresh* test
fixture at runtime, immediately initialize it via `SetUp()`, run the test, clean fixture at runtime, immediately initialize it via `SetUp()`, run the test, clean
up by calling `TearDown()`, and then delete the test fixture. Note that up by calling `TearDown()`, and then delete the test fixture. Note that
different tests in the same test suite have different test fixture objects, and different tests in the same test suite have different test fixture objects, and
googletest always deletes a test fixture before it creates the next one. GoogleTest always deletes a test fixture before it creates the next one.
googletest does **not** reuse the same test fixture for multiple tests. Any GoogleTest does **not** reuse the same test fixture for multiple tests. Any
changes one test makes to the fixture do not affect other tests. changes one test makes to the fixture do not affect other tests.
As an example, let's write tests for a FIFO queue class named `Queue`, which has As an example, let's write tests for a FIFO queue class named `Queue`, which has
@ -325,7 +325,7 @@ would lead to a segfault when `n` is `NULL`.
When these tests run, the following happens: When these tests run, the following happens:
1. googletest constructs a `QueueTest` object (let's call it `t1`). 1. GoogleTest constructs a `QueueTest` object (let's call it `t1`).
2. `t1.SetUp()` initializes `t1`. 2. `t1.SetUp()` initializes `t1`.
3. The first test (`IsEmptyInitially`) runs on `t1`. 3. The first test (`IsEmptyInitially`) runs on `t1`.
4. `t1.TearDown()` cleans up after the test finishes. 4. `t1.TearDown()` cleans up after the test finishes.
@ -337,7 +337,7 @@ When these tests run, the following happens:
## Invoking the Tests ## Invoking the Tests
`TEST()` and `TEST_F()` implicitly register their tests with googletest. So, `TEST()` and `TEST_F()` implicitly register their tests with GoogleTest. So,
unlike with many other C++ testing frameworks, you don't have to re-list all unlike with many other C++ testing frameworks, you don't have to re-list all
your defined tests in order to run them. your defined tests in order to run them.
@ -348,7 +348,7 @@ test suites, or even different source files.
When invoked, the `RUN_ALL_TESTS()` macro: When invoked, the `RUN_ALL_TESTS()` macro:
* Saves the state of all googletest flags. * Saves the state of all GoogleTest flags.
* Creates a test fixture object for the first test. * Creates a test fixture object for the first test.
@ -360,7 +360,7 @@ When invoked, the `RUN_ALL_TESTS()` macro:
* Deletes the fixture. * Deletes the fixture.
* Restores the state of all googletest flags. * Restores the state of all GoogleTest flags.
* Repeats the above steps for the next test, until all tests have run. * Repeats the above steps for the next test, until all tests have run.
@ -374,14 +374,14 @@ If a fatal failure happens the subsequent steps will be skipped.
> return the value of `RUN_ALL_TESTS()`. > return the value of `RUN_ALL_TESTS()`.
> >
> Also, you should call `RUN_ALL_TESTS()` only **once**. Calling it more than > Also, you should call `RUN_ALL_TESTS()` only **once**. Calling it more than
> once conflicts with some advanced googletest features (e.g., thread-safe > once conflicts with some advanced GoogleTest features (e.g., thread-safe
> [death tests](advanced.md#death-tests)) and thus is not supported. > [death tests](advanced.md#death-tests)) and thus is not supported.
**Availability**: Linux, Windows, Mac. **Availability**: Linux, Windows, Mac.
## Writing the main() Function ## Writing the main() Function
Most users should _not_ need to write their own `main` function and instead link Most users should *not* need to write their own `main` function and instead link
with `gtest_main` (as opposed to with `gtest`), which defines a suitable entry with `gtest_main` (as opposed to with `gtest`), which defines a suitable entry
point. See the end of this section for details. The remainder of this section point. See the end of this section for details. The remainder of this section
should only apply when you need to do something custom before the tests run that should only apply when you need to do something custom before the tests run that
@ -456,7 +456,7 @@ int main(int argc, char **argv) {
``` ```
The `::testing::InitGoogleTest()` function parses the command line for The `::testing::InitGoogleTest()` function parses the command line for
googletest flags, and removes all recognized flags. This allows the user to GoogleTest flags, and removes all recognized flags. This allows the user to
control a test program's behavior via various flags, which we'll cover in the control a test program's behavior via various flags, which we'll cover in the
[AdvancedGuide](advanced.md). You **must** call this function before calling [AdvancedGuide](advanced.md). You **must** call this function before calling
`RUN_ALL_TESTS()`, or the flags won't be properly initialized. `RUN_ALL_TESTS()`, or the flags won't be properly initialized.
@ -476,7 +476,7 @@ NOTE: `ParseGUnitFlags()` is deprecated in favor of `InitGoogleTest()`.
* Google Test is designed to be thread-safe. The implementation is thread-safe * Google Test is designed to be thread-safe. The implementation is thread-safe
on systems where the `pthreads` library is available. It is currently on systems where the `pthreads` library is available. It is currently
_unsafe_ to use Google Test assertions from two threads concurrently on *unsafe* to use Google Test assertions from two threads concurrently on
other systems (e.g. Windows). In most tests this is not an issue as usually other systems (e.g. Windows). In most tests this is not an issue as usually
the assertions are done in the main thread. If you want to help, you can the assertions are done in the main thread. If you want to help, you can
volunteer to implement the necessary synchronization primitives in volunteer to implement the necessary synchronization primitives in

2
docs/reference/assertions.md
View File

@ -515,7 +515,7 @@ Verifies that *`expression`* is a success `HRESULT`.
### EXPECT_HRESULT_FAILED {#EXPECT_HRESULT_FAILED} ### EXPECT_HRESULT_FAILED {#EXPECT_HRESULT_FAILED}
`EXPECT_HRESULT_FAILED(`*`expression`*`)` \ `EXPECT_HRESULT_FAILED(`*`expression`*`)` \
`EXPECT_HRESULT_FAILED(`*`expression`*`)` `ASSERT_HRESULT_FAILED(`*`expression`*`)`
Verifies that *`expression`* is a failure `HRESULT`. Verifies that *`expression`* is a failure `HRESULT`.

1
docs/reference/testing.md
View File

@ -110,6 +110,7 @@ namespace:
| `Bool()` | Yields sequence `{false, true}`. | | `Bool()` | Yields sequence `{false, true}`. |
| `Combine(g1, g2, ..., gN)` | Yields as `std::tuple` *n*-tuples all combinations (Cartesian product) of the values generated by the given *n* generators `g1`, `g2`, ..., `gN`. | | `Combine(g1, g2, ..., gN)` | Yields as `std::tuple` *n*-tuples all combinations (Cartesian product) of the values generated by the given *n* generators `g1`, `g2`, ..., `gN`. |
| `ConvertGenerator<T>(g)` | Yields values generated by generator `g`, `static_cast` to `T`. | | `ConvertGenerator<T>(g)` | Yields values generated by generator `g`, `static_cast` to `T`. |
The optional last argument *`name_generator`* is a function or functor that The optional last argument *`name_generator`* is a function or functor that
generates custom test name suffixes based on the test parameters. The function generates custom test name suffixes based on the test parameters. The function
must accept an argument of type must accept an argument of type

12
googlemock/include/gmock/gmock-actions.h
View File

@ -611,7 +611,7 @@ class DefaultValue {
private: private:
class ValueProducer { class ValueProducer {
public: public:
virtual ~ValueProducer() {} virtual ~ValueProducer() = default;
virtual T Produce() = 0; virtual T Produce() = 0;
}; };
@ -699,8 +699,8 @@ class ActionInterface {
typedef typename internal::Function<F>::Result Result; typedef typename internal::Function<F>::Result Result;
typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple; typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
ActionInterface() {} ActionInterface() = default;
virtual ~ActionInterface() {} virtual ~ActionInterface() = default;
// Performs the action. This method is not const, as in general an // Performs the action. This method is not const, as in general an
// action can have side effects and be stateful. For example, a // action can have side effects and be stateful. For example, a
@ -749,7 +749,7 @@ class Action<R(Args...)> {
// Constructs a null Action. Needed for storing Action objects in // Constructs a null Action. Needed for storing Action objects in
// STL containers. // STL containers.
Action() {} Action() = default;
// Construct an Action from a specified callable. // Construct an Action from a specified callable.
// This cannot take std::function directly, because then Action would not be // This cannot take std::function directly, because then Action would not be
@ -1273,7 +1273,7 @@ class AssignAction {
const T2 value_; const T2 value_;
}; };
#if !GTEST_OS_WINDOWS_MOBILE #ifndef GTEST_OS_WINDOWS_MOBILE
// Implements the SetErrnoAndReturn action to simulate return from // Implements the SetErrnoAndReturn action to simulate return from
// various system calls and libc functions. // various system calls and libc functions.
@ -1926,7 +1926,7 @@ PolymorphicAction<internal::AssignAction<T1, T2>> Assign(T1* ptr, T2 val) {
return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val)); return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val));
} }
#if !GTEST_OS_WINDOWS_MOBILE #ifndef GTEST_OS_WINDOWS_MOBILE
// Creates an action that sets errno and returns the appropriate error. // Creates an action that sets errno and returns the appropriate error.
template <typename T> template <typename T>

4
googlemock/include/gmock/gmock-cardinalities.h
View File

@ -65,7 +65,7 @@ namespace testing {
// The implementation of a cardinality. // The implementation of a cardinality.
class CardinalityInterface { class CardinalityInterface {
public: public:
virtual ~CardinalityInterface() {} virtual ~CardinalityInterface() = default;
// Conservative estimate on the lower/upper bound of the number of // Conservative estimate on the lower/upper bound of the number of
// calls allowed. // calls allowed.
@ -92,7 +92,7 @@ class GTEST_API_ Cardinality {
public: public:
// Constructs a null cardinality. Needed for storing Cardinality // Constructs a null cardinality. Needed for storing Cardinality
// objects in STL containers. // objects in STL containers.
Cardinality() {} Cardinality() = default;
// Constructs a Cardinality from its implementation. // Constructs a Cardinality from its implementation.
explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {} explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {}

28
googlemock/include/gmock/gmock-matchers.h
View File

@ -257,6 +257,8 @@
#include <algorithm> #include <algorithm>
#include <cmath> #include <cmath>
#include <exception>
#include <functional>
#include <initializer_list> #include <initializer_list>
#include <ios> #include <ios>
#include <iterator> #include <iterator>
@ -562,7 +564,7 @@ namespace internal {
// If the explanation is not empty, prints it to the ostream. // If the explanation is not empty, prints it to the ostream.
inline void PrintIfNotEmpty(const std::string& explanation, inline void PrintIfNotEmpty(const std::string& explanation,
::std::ostream* os) { ::std::ostream* os) {
if (explanation != "" && os != nullptr) { if (!explanation.empty() && os != nullptr) {
*os << ", " << explanation; *os << ", " << explanation;
} }
} }
@ -1199,27 +1201,27 @@ class PairMatchBase {
}; };
}; };
class Eq2Matcher : public PairMatchBase<Eq2Matcher, AnyEq> { class Eq2Matcher : public PairMatchBase<Eq2Matcher, std::equal_to<>> {
public: public:
static const char* Desc() { return "an equal pair"; } static const char* Desc() { return "an equal pair"; }
}; };
class Ne2Matcher : public PairMatchBase<Ne2Matcher, AnyNe> { class Ne2Matcher : public PairMatchBase<Ne2Matcher, std::not_equal_to<>> {
public: public:
static const char* Desc() { return "an unequal pair"; } static const char* Desc() { return "an unequal pair"; }
}; };
class Lt2Matcher : public PairMatchBase<Lt2Matcher, AnyLt> { class Lt2Matcher : public PairMatchBase<Lt2Matcher, std::less<>> {
public: public:
static const char* Desc() { return "a pair where the first < the second"; } static const char* Desc() { return "a pair where the first < the second"; }
}; };
class Gt2Matcher : public PairMatchBase<Gt2Matcher, AnyGt> { class Gt2Matcher : public PairMatchBase<Gt2Matcher, std::greater<>> {
public: public:
static const char* Desc() { return "a pair where the first > the second"; } static const char* Desc() { return "a pair where the first > the second"; }
}; };
class Le2Matcher : public PairMatchBase<Le2Matcher, AnyLe> { class Le2Matcher : public PairMatchBase<Le2Matcher, std::less_equal<>> {
public: public:
static const char* Desc() { return "a pair where the first <= the second"; } static const char* Desc() { return "a pair where the first <= the second"; }
}; };
class Ge2Matcher : public PairMatchBase<Ge2Matcher, AnyGe> { class Ge2Matcher : public PairMatchBase<Ge2Matcher, std::greater_equal<>> {
public: public:
static const char* Desc() { return "a pair where the first >= the second"; } static const char* Desc() { return "a pair where the first >= the second"; }
}; };
@ -1473,6 +1475,7 @@ class SomeOfArrayMatcher {
operator Matcher<U>() const { // NOLINT operator Matcher<U>() const { // NOLINT
using RawU = typename std::decay<U>::type; using RawU = typename std::decay<U>::type;
std::vector<Matcher<RawU>> matchers; std::vector<Matcher<RawU>> matchers;
matchers.reserve(matchers_.size());
for (const auto& matcher : matchers_) { for (const auto& matcher : matchers_) {
matchers.push_back(MatcherCast<RawU>(matcher)); matchers.push_back(MatcherCast<RawU>(matcher));
} }
@ -2964,7 +2967,7 @@ class KeyMatcherImpl : public MatcherInterface<PairType> {
const bool match = inner_matcher_.MatchAndExplain( const bool match = inner_matcher_.MatchAndExplain(
pair_getters::First(key_value, Rank0()), &inner_listener); pair_getters::First(key_value, Rank0()), &inner_listener);
const std::string explanation = inner_listener.str(); const std::string explanation = inner_listener.str();
if (explanation != "") { if (!explanation.empty()) {
*listener << "whose first field is a value " << explanation; *listener << "whose first field is a value " << explanation;
} }
return match; return match;
@ -3111,12 +3114,12 @@ class PairMatcherImpl : public MatcherInterface<PairType> {
const std::string& second_explanation, const std::string& second_explanation,
MatchResultListener* listener) const { MatchResultListener* listener) const {
*listener << "whose both fields match"; *listener << "whose both fields match";
if (first_explanation != "") { if (!first_explanation.empty()) {
*listener << ", where the first field is a value " << first_explanation; *listener << ", where the first field is a value " << first_explanation;
} }
if (second_explanation != "") { if (!second_explanation.empty()) {
*listener << ", "; *listener << ", ";
if (first_explanation != "") { if (!first_explanation.empty()) {
*listener << "and "; *listener << "and ";
} else { } else {
*listener << "where "; *listener << "where ";
@ -5542,7 +5545,8 @@ PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> ThrowsMessage(
\ \
private: \ private: \
::std::string FormatDescription(bool negation) const { \ ::std::string FormatDescription(bool negation) const { \
::std::string gmock_description = (description); \ ::std::string gmock_description; \
gmock_description = (description); \
if (!gmock_description.empty()) { \ if (!gmock_description.empty()) { \
return gmock_description; \ return gmock_description; \
} \ } \

2
googlemock/include/gmock/gmock-nice-strict.h
View File

@ -98,7 +98,7 @@ constexpr bool HasStrictnessModifier() {
// deregistration. This guarantees that MockClass's constructor and destructor // deregistration. This guarantees that MockClass's constructor and destructor
// run with the same level of strictness as its instance methods. // run with the same level of strictness as its instance methods.
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW && \ #if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MINGW) && \
(defined(_MSC_VER) || defined(__clang__)) (defined(_MSC_VER) || defined(__clang__))
// We need to mark these classes with this declspec to ensure that // We need to mark these classes with this declspec to ensure that
// the empty base class optimization is performed. // the empty base class optimization is performed.

77
googlemock/include/gmock/gmock-spec-builders.h
View File

@ -204,6 +204,9 @@ class GTEST_API_ UntypedFunctionMockerBase {
using UntypedExpectations = std::vector<std::shared_ptr<ExpectationBase>>; using UntypedExpectations = std::vector<std::shared_ptr<ExpectationBase>>;
struct UninterestingCallCleanupHandler;
struct FailureCleanupHandler;
// Returns an Expectation object that references and co-owns exp, // Returns an Expectation object that references and co-owns exp,
// which must be an expectation on this mock function. // which must be an expectation on this mock function.
Expectation GetHandleOf(ExpectationBase* exp); Expectation GetHandleOf(ExpectationBase* exp);
@ -563,7 +566,7 @@ class ExpectationSet {
typedef Expectation::Set::value_type value_type; typedef Expectation::Set::value_type value_type;
// Constructs an empty set. // Constructs an empty set.
ExpectationSet() {} ExpectationSet() = default;
// This single-argument ctor must not be explicit, in order to support the // This single-argument ctor must not be explicit, in order to support the
// ExpectationSet es = EXPECT_CALL(...); // ExpectationSet es = EXPECT_CALL(...);
@ -1396,6 +1399,41 @@ class Cleanup final {
std::function<void()> f_; std::function<void()> f_;
}; };
struct UntypedFunctionMockerBase::UninterestingCallCleanupHandler {
CallReaction reaction;
std::stringstream& ss;
~UninterestingCallCleanupHandler() {
ReportUninterestingCall(reaction, ss.str());
}
};
struct UntypedFunctionMockerBase::FailureCleanupHandler {
std::stringstream& ss;
std::stringstream& why;
std::stringstream& loc;
const ExpectationBase* untyped_expectation;
bool found;
bool is_excessive;
~FailureCleanupHandler() {
ss << "\n" << why.str();
if (!found) {
// No expectation matches this call - reports a failure.
Expect(false, nullptr, -1, ss.str());
} else if (is_excessive) {
// We had an upper-bound violation and the failure message is in ss.
Expect(false, untyped_expectation->file(), untyped_expectation->line(),
ss.str());
} else {
// We had an expected call and the matching expectation is
// described in ss.
Log(kInfo, loc.str() + ss.str(), 2);
}
}
};
template <typename F> template <typename F>
class FunctionMocker; class FunctionMocker;
@ -1408,7 +1446,7 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
using ArgumentTuple = std::tuple<Args...>; using ArgumentTuple = std::tuple<Args...>;
using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>; using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>;
FunctionMocker() {} FunctionMocker() = default;
// There is no generally useful and implementable semantics of // There is no generally useful and implementable semantics of
// copying a mock object, so copying a mock is usually a user error. // copying a mock object, so copying a mock is usually a user error.
@ -1794,8 +1832,15 @@ R FunctionMocker<R(Args...)>::InvokeWith(ArgumentTuple&& args)
// //
// We use RAII to do the latter in case R is void or a non-moveable type. In // We use RAII to do the latter in case R is void or a non-moveable type. In
// either case we can't assign it to a local variable. // either case we can't assign it to a local variable.
const Cleanup report_uninteresting_call( //
[&] { ReportUninterestingCall(reaction, ss.str()); }); // Note that std::bind() is essential here.
// We *don't* use any local callback types (like lambdas).
// Doing so slows down compilation dramatically because the *constructor* of
// std::function<T> is re-instantiated with different template
// parameters each time.
const UninterestingCallCleanupHandler report_uninteresting_call = {
reaction, ss
};
return PerformActionAndPrintResult(nullptr, std::move(args), ss.str(), ss); return PerformActionAndPrintResult(nullptr, std::move(args), ss.str(), ss);
} }
@ -1839,22 +1884,14 @@ R FunctionMocker<R(Args...)>::InvokeWith(ArgumentTuple&& args)
// //
// We use RAII to do the latter in case R is void or a non-moveable type. In // We use RAII to do the latter in case R is void or a non-moveable type. In
// either case we can't assign it to a local variable. // either case we can't assign it to a local variable.
const Cleanup handle_failures([&] { //
ss << "\n" << why.str(); // Note that we *don't* use any local callback types (like lambdas) here.
// Doing so slows down compilation dramatically because the *constructor* of
if (!found) { // std::function<T> is re-instantiated with different template
// No expectation matches this call - reports a failure. // parameters each time.
Expect(false, nullptr, -1, ss.str()); const FailureCleanupHandler handle_failures = {
} else if (is_excessive) { ss, why, loc, untyped_expectation, found, is_excessive
// We had an upper-bound violation and the failure message is in ss. };
Expect(false, untyped_expectation->file(), untyped_expectation->line(),
ss.str());
} else {
// We had an expected call and the matching expectation is
// described in ss.
Log(kInfo, loc.str() + ss.str(), 2);
}
});
return PerformActionAndPrintResult(untyped_action, std::move(args), ss.str(), return PerformActionAndPrintResult(untyped_action, std::move(args), ss.str(),
ss); ss);

7
googlemock/include/gmock/internal/gmock-internal-utils.h
View File

@ -224,7 +224,7 @@ class FailureReporterInterface {
// The type of a failure (either non-fatal or fatal). // The type of a failure (either non-fatal or fatal).
enum FailureType { kNonfatal, kFatal }; enum FailureType { kNonfatal, kFatal };
virtual ~FailureReporterInterface() {} virtual ~FailureReporterInterface() = default;
// Reports a failure that occurred at the given source file location. // Reports a failure that occurred at the given source file location.
virtual void ReportFailure(FailureType type, const char* file, int line, virtual void ReportFailure(FailureType type, const char* file, int line,
@ -311,7 +311,8 @@ GTEST_API_ WithoutMatchers GetWithoutMatchers();
// crashes). // crashes).
template <typename T> template <typename T>
inline T Invalid() { inline T Invalid() {
Assert(false, "", -1, "Internal error: attempt to return invalid value"); Assert(/*condition=*/false, /*file=*/"", /*line=*/-1,
"Internal error: attempt to return invalid value");
#if defined(__GNUC__) || defined(__clang__) #if defined(__GNUC__) || defined(__clang__)
__builtin_unreachable(); __builtin_unreachable();
#elif defined(_MSC_VER) #elif defined(_MSC_VER)
@ -464,8 +465,10 @@ struct Function<R(Args...)> {
using MakeResultIgnoredValue = IgnoredValue(Args...); using MakeResultIgnoredValue = IgnoredValue(Args...);
}; };
#ifdef GTEST_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
template <typename R, typename... Args> template <typename R, typename... Args>
constexpr size_t Function<R(Args...)>::ArgumentCount; constexpr size_t Function<R(Args...)>::ArgumentCount;
#endif
// Workaround for MSVC error C2039: 'type': is not a member of 'std' // Workaround for MSVC error C2039: 'type': is not a member of 'std'
// when std::tuple_element is used. // when std::tuple_element is used.

3
googlemock/src/gmock-internal-utils.cc
View File

@ -41,6 +41,7 @@
#include <cctype> #include <cctype>
#include <cstdint> #include <cstdint>
#include <cstring> #include <cstring>
#include <iostream>
#include <ostream> // NOLINT #include <ostream> // NOLINT
#include <string> #include <string>
#include <vector> #include <vector>
@ -87,7 +88,7 @@ GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name) {
(!IsDigit(prev_char) && IsDigit(*p)); (!IsDigit(prev_char) && IsDigit(*p));
if (IsAlNum(*p)) { if (IsAlNum(*p)) {
if (starts_new_word && result != "") result += ' '; if (starts_new_word && !result.empty()) result += ' ';
result += ToLower(*p); result += ToLower(*p);
} }
} }

2
googlemock/src/gmock-matchers.cc
View File

@ -53,7 +53,7 @@ GTEST_API_ std::string FormatMatcherDescription(
bool negation, const char* matcher_name, bool negation, const char* matcher_name,
const std::vector<const char*>& param_names, const Strings& param_values) { const std::vector<const char*>& param_names, const Strings& param_values) {
std::string result = ConvertIdentifierNameToWords(matcher_name); std::string result = ConvertIdentifierNameToWords(matcher_name);
if (param_values.size() >= 1) { if (!param_values.empty()) {
result += " " + JoinAsKeyValueTuple(param_names, param_values); result += " " + JoinAsKeyValueTuple(param_names, param_values);
} }
return negation ? "not (" + result + ")" : result; return negation ? "not (" + result + ")" : result;

19
googlemock/src/gmock-spec-builders.cc
View File

@ -40,6 +40,7 @@
#include <map> #include <map>
#include <memory> #include <memory>
#include <set> #include <set>
#include <sstream>
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
@ -48,10 +49,10 @@
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "gtest/internal/gtest-port.h" #include "gtest/internal/gtest-port.h"
#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC #if defined(GTEST_OS_CYGWIN) || defined(GTEST_OS_LINUX) || defined(GTEST_OS_MAC)
#include <unistd.h> // NOLINT #include <unistd.h> // NOLINT
#endif #endif
#if GTEST_OS_QURT #ifdef GTEST_OS_QURT
#include <qurt_event.h> #include <qurt_event.h>
#endif #endif
@ -95,7 +96,7 @@ ExpectationBase::ExpectationBase(const char* a_file, int a_line,
action_count_checked_(false) {} action_count_checked_(false) {}
// Destructs an ExpectationBase object. // Destructs an ExpectationBase object.
ExpectationBase::~ExpectationBase() {} ExpectationBase::~ExpectationBase() = default;
// Explicitly specifies the cardinality of this expectation. Used by // Explicitly specifies the cardinality of this expectation. Used by
// the subclasses to implement the .Times() clause. // the subclasses to implement the .Times() clause.
@ -297,7 +298,7 @@ void ReportUninterestingCall(CallReaction reaction, const std::string& msg) {
"See " "See "
"https://github.com/google/googletest/blob/main/docs/" "https://github.com/google/googletest/blob/main/docs/"
"gmock_cook_book.md#" "gmock_cook_book.md#"
"knowing-when-to-expect for details.\n", "knowing-when-to-expect-useoncall for details.\n",
stack_frames_to_skip); stack_frames_to_skip);
break; break;
default: // FAIL default: // FAIL
@ -308,7 +309,7 @@ void ReportUninterestingCall(CallReaction reaction, const std::string& msg) {
UntypedFunctionMockerBase::UntypedFunctionMockerBase() UntypedFunctionMockerBase::UntypedFunctionMockerBase()
: mock_obj_(nullptr), name_("") {} : mock_obj_(nullptr), name_("") {}
UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {} UntypedFunctionMockerBase::~UntypedFunctionMockerBase() = default;
// Sets the mock object this mock method belongs to, and registers // Sets the mock object this mock method belongs to, and registers
// this information in the global mock registry. Will be called // this information in the global mock registry. Will be called
@ -503,7 +504,7 @@ class MockObjectRegistry {
std::cout << internal::FormatFileLocation(state.first_used_file, std::cout << internal::FormatFileLocation(state.first_used_file,
state.first_used_line); state.first_used_line);
std::cout << " ERROR: this mock object"; std::cout << " ERROR: this mock object";
if (state.first_used_test != "") { if (!state.first_used_test.empty()) {
std::cout << " (used in test " << state.first_used_test_suite << "." std::cout << " (used in test " << state.first_used_test_suite << "."
<< state.first_used_test << ")"; << state.first_used_test << ")";
} }
@ -526,7 +527,7 @@ class MockObjectRegistry {
// RUN_ALL_TESTS() has already returned when this destructor is // RUN_ALL_TESTS() has already returned when this destructor is
// called. Therefore we cannot use the normal Google Test // called. Therefore we cannot use the normal Google Test
// failure reporting mechanism. // failure reporting mechanism.
#if GTEST_OS_QURT #ifdef GTEST_OS_QURT
qurt_exception_raise_fatal(); qurt_exception_raise_fatal();
#else #else
_exit(1); // We cannot call exit() as it is not reentrant and _exit(1); // We cannot call exit() as it is not reentrant and
@ -745,13 +746,13 @@ void Mock::ClearDefaultActionsLocked(void* mock_obj)
// needed by VerifyAndClearExpectationsLocked(). // needed by VerifyAndClearExpectationsLocked().
} }
Expectation::Expectation() {} Expectation::Expectation() = default;
Expectation::Expectation( Expectation::Expectation(
const std::shared_ptr<internal::ExpectationBase>& an_expectation_base) const std::shared_ptr<internal::ExpectationBase>& an_expectation_base)
: expectation_base_(an_expectation_base) {} : expectation_base_(an_expectation_base) {}
Expectation::~Expectation() {} Expectation::~Expectation() = default;
// Adds an expectation to a sequence. // Adds an expectation to a sequence.
void Sequence::AddExpectation(const Expectation& expectation) const { void Sequence::AddExpectation(const Expectation& expectation) const {

2
googlemock/src/gmock.cc
View File

@ -29,6 +29,8 @@
#include "gmock/gmock.h" #include "gmock/gmock.h"
#include <string>
#include "gmock/internal/gmock-port.h" #include "gmock/internal/gmock-port.h"
GMOCK_DEFINE_bool_(catch_leaked_mocks, true, GMOCK_DEFINE_bool_(catch_leaked_mocks, true,

8
googlemock/src/gmock_main.cc
View File

@ -32,8 +32,8 @@
#include "gmock/gmock.h" #include "gmock/gmock.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#if GTEST_OS_ESP8266 || GTEST_OS_ESP32 #if defined(GTEST_OS_ESP8266) || defined(GTEST_OS_ESP32)
#if GTEST_OS_ESP8266 #ifdef GTEST_OS_ESP8266
extern "C" { extern "C" {
#endif #endif
void setup() { void setup() {
@ -43,7 +43,7 @@ void setup() {
testing::InitGoogleMock(); testing::InitGoogleMock();
} }
void loop() { RUN_ALL_TESTS(); } void loop() { RUN_ALL_TESTS(); }
#if GTEST_OS_ESP8266 #ifdef GTEST_OS_ESP8266
} }
#endif #endif
@ -55,7 +55,7 @@ void loop() { RUN_ALL_TESTS(); }
// Windows. See the following link to track the current status of this bug: // Windows. See the following link to track the current status of this bug:
// https://web.archive.org/web/20170912203238/connect.microsoft.com/VisualStudio/feedback/details/394464/wmain-link-error-in-the-static-library // https://web.archive.org/web/20170912203238/connect.microsoft.com/VisualStudio/feedback/details/394464/wmain-link-error-in-the-static-library
// // NOLINT // // NOLINT
#if GTEST_OS_WINDOWS_MOBILE #ifdef GTEST_OS_WINDOWS_MOBILE
#include <tchar.h> // NOLINT #include <tchar.h> // NOLINT
GTEST_API_ int _tmain(int argc, TCHAR** argv) { GTEST_API_ int _tmain(int argc, TCHAR** argv) {

25
googlemock/test/gmock-actions_test.cc
View File

@ -37,14 +37,18 @@
#include <functional> #include <functional>
#include <iterator> #include <iterator>
#include <memory> #include <memory>
#include <sstream>
#include <string> #include <string>
#include <tuple>
#include <type_traits> #include <type_traits>
#include <utility>
#include <vector> #include <vector>
#include "gmock/gmock.h" #include "gmock/gmock.h"
#include "gmock/internal/gmock-port.h" #include "gmock/internal/gmock-port.h"
#include "gtest/gtest-spi.h" #include "gtest/gtest-spi.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "gtest/internal/gtest-port.h"
// Silence C4100 (unreferenced formal parameter) and C4503 (decorated name // Silence C4100 (unreferenced formal parameter) and C4503 (decorated name
// length exceeded) for MSVC. // length exceeded) for MSVC.
@ -218,7 +222,8 @@ TEST(TypeTraits, IsInvocableRV) {
// In C++17 and above, where it's guaranteed that functions can return // In C++17 and above, where it's guaranteed that functions can return
// non-moveable objects, everything should work fine for non-moveable rsult // non-moveable objects, everything should work fine for non-moveable rsult
// types too. // types too.
#if defined(__cplusplus) && __cplusplus >= 201703L #if defined(GTEST_INTERNAL_CPLUSPLUS_LANG) && \
GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
{ {
struct NonMoveable { struct NonMoveable {
NonMoveable() = default; NonMoveable() = default;
@ -444,7 +449,7 @@ TEST(DefaultValueTest, GetWorksForMoveOnlyIfSet) {
EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists()); EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Get() == nullptr); EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Get() == nullptr);
DefaultValue<std::unique_ptr<int>>::SetFactory( DefaultValue<std::unique_ptr<int>>::SetFactory(
[] { return std::unique_ptr<int>(new int(42)); }); [] { return std::make_unique<int>(42); });
EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists()); EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
std::unique_ptr<int> i = DefaultValue<std::unique_ptr<int>>::Get(); std::unique_ptr<int> i = DefaultValue<std::unique_ptr<int>>::Get();
EXPECT_EQ(42, *i); EXPECT_EQ(42, *i);
@ -982,7 +987,7 @@ TEST(ReturnRoundRobinTest, WorksForVector) {
class MockClass { class MockClass {
public: public:
MockClass() {} MockClass() = default;
MOCK_METHOD1(IntFunc, int(bool flag)); // NOLINT MOCK_METHOD1(IntFunc, int(bool flag)); // NOLINT
MOCK_METHOD0(Foo, MyNonDefaultConstructible()); MOCK_METHOD0(Foo, MyNonDefaultConstructible());
@ -1592,7 +1597,7 @@ TEST(WithArgsTest, RefQualifiedInnerAction) {
EXPECT_EQ(19, mock.AsStdFunction()(0, 17)); EXPECT_EQ(19, mock.AsStdFunction()(0, 17));
} }
#if !GTEST_OS_WINDOWS_MOBILE #ifndef GTEST_OS_WINDOWS_MOBILE
class SetErrnoAndReturnTest : public testing::Test { class SetErrnoAndReturnTest : public testing::Test {
protected: protected:
@ -1751,9 +1756,7 @@ TEST(ReturnNewTest, ConstructorThatTakes10Arguments) {
delete c; delete c;
} }
std::unique_ptr<int> UniquePtrSource() { std::unique_ptr<int> UniquePtrSource() { return std::make_unique<int>(19); }
return std::unique_ptr<int>(new int(19));
}
std::vector<std::unique_ptr<int>> VectorUniquePtrSource() { std::vector<std::unique_ptr<int>> VectorUniquePtrSource() {
std::vector<std::unique_ptr<int>> out; std::vector<std::unique_ptr<int>> out;
@ -1802,7 +1805,7 @@ TEST(MockMethodTest, CanReturnMoveOnlyValue_Invoke) {
// Check default value // Check default value
DefaultValue<std::unique_ptr<int>>::SetFactory( DefaultValue<std::unique_ptr<int>>::SetFactory(
[] { return std::unique_ptr<int>(new int(42)); }); [] { return std::make_unique<int>(42); });
EXPECT_EQ(42, *mock.MakeUnique()); EXPECT_EQ(42, *mock.MakeUnique());
EXPECT_CALL(mock, MakeUnique()).WillRepeatedly(Invoke(UniquePtrSource)); EXPECT_CALL(mock, MakeUnique()).WillRepeatedly(Invoke(UniquePtrSource));
@ -1822,7 +1825,7 @@ TEST(MockMethodTest, CanReturnMoveOnlyValue_Invoke) {
TEST(MockMethodTest, CanTakeMoveOnlyValue) { TEST(MockMethodTest, CanTakeMoveOnlyValue) {
MockClass mock; MockClass mock;
auto make = [](int i) { return std::unique_ptr<int>(new int(i)); }; auto make = [](int i) { return std::make_unique<int>(i); };
EXPECT_CALL(mock, TakeUnique(_)).WillRepeatedly([](std::unique_ptr<int> i) { EXPECT_CALL(mock, TakeUnique(_)).WillRepeatedly([](std::unique_ptr<int> i) {
return *i; return *i;
@ -2053,9 +2056,7 @@ struct Double {
} }
}; };
std::unique_ptr<int> UniqueInt(int i) { std::unique_ptr<int> UniqueInt(int i) { return std::make_unique<int>(i); }
return std::unique_ptr<int>(new int(i));
}
TEST(FunctorActionTest, ActionFromFunction) { TEST(FunctorActionTest, ActionFromFunction) {
Action<int(int, int&, int*)> a = &Add; Action<int(int, int&, int*)> a = &Add;

4
googlemock/test/gmock-cardinalities_test.cc
View File

@ -31,6 +31,8 @@
// //
// This file tests the built-in cardinalities. // This file tests the built-in cardinalities.
#include <ostream>
#include "gmock/gmock.h" #include "gmock/gmock.h"
#include "gtest/gtest-spi.h" #include "gtest/gtest-spi.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
@ -50,7 +52,7 @@ using testing::MakeCardinality;
class MockFoo { class MockFoo {
public: public:
MockFoo() {} MockFoo() = default;
MOCK_METHOD0(Bar, int()); // NOLINT MOCK_METHOD0(Bar, int()); // NOLINT
private: private:

36
googlemock/test/gmock-function-mocker_test.cc
View File

@ -35,7 +35,7 @@
// Silence C4503 (decorated name length exceeded) for MSVC. // Silence C4503 (decorated name length exceeded) for MSVC.
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4503) GTEST_DISABLE_MSC_WARNINGS_PUSH_(4503)
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
// MSDN says the header file to be included for STDMETHOD is BaseTyps.h but // MSDN says the header file to be included for STDMETHOD is BaseTyps.h but
// we are getting compiler errors if we use basetyps.h, hence including // we are getting compiler errors if we use basetyps.h, hence including
// objbase.h for definition of STDMETHOD. // objbase.h for definition of STDMETHOD.
@ -70,7 +70,7 @@ using testing::TypedEq;
template <typename T> template <typename T>
class TemplatedCopyable { class TemplatedCopyable {
public: public:
TemplatedCopyable() {} TemplatedCopyable() = default;
template <typename U> template <typename U>
TemplatedCopyable(const U& other) {} // NOLINT TemplatedCopyable(const U& other) {} // NOLINT
@ -78,7 +78,7 @@ class TemplatedCopyable {
class FooInterface { class FooInterface {
public: public:
virtual ~FooInterface() {} virtual ~FooInterface() = default;
virtual void VoidReturning(int x) = 0; virtual void VoidReturning(int x) = 0;
@ -120,7 +120,7 @@ class FooInterface {
virtual int RefQualifiedOverloaded() & = 0; virtual int RefQualifiedOverloaded() & = 0;
virtual int RefQualifiedOverloaded() && = 0; virtual int RefQualifiedOverloaded() && = 0;
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
STDMETHOD_(int, CTNullary)() = 0; STDMETHOD_(int, CTNullary)() = 0;
STDMETHOD_(bool, CTUnary)(int x) = 0; STDMETHOD_(bool, CTUnary)(int x) = 0;
STDMETHOD_(int, CTDecimal) STDMETHOD_(int, CTDecimal)
@ -137,7 +137,7 @@ class FooInterface {
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4373) GTEST_DISABLE_MSC_WARNINGS_PUSH_(4373)
class MockFoo : public FooInterface { class MockFoo : public FooInterface {
public: public:
MockFoo() {} MockFoo() = default;
// Makes sure that a mock function parameter can be named. // Makes sure that a mock function parameter can be named.
MOCK_METHOD(void, VoidReturning, (int n)); // NOLINT MOCK_METHOD(void, VoidReturning, (int n)); // NOLINT
@ -178,7 +178,7 @@ class MockFoo : public FooInterface {
MOCK_METHOD(int (*)(bool), ReturnsFunctionPointer1, (int), ()); MOCK_METHOD(int (*)(bool), ReturnsFunctionPointer1, (int), ());
MOCK_METHOD(fn_ptr, ReturnsFunctionPointer2, (int), ()); MOCK_METHOD(fn_ptr, ReturnsFunctionPointer2, (int), ());
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
MOCK_METHOD(int, CTNullary, (), (Calltype(STDMETHODCALLTYPE))); MOCK_METHOD(int, CTNullary, (), (Calltype(STDMETHODCALLTYPE)));
MOCK_METHOD(bool, CTUnary, (int), (Calltype(STDMETHODCALLTYPE))); MOCK_METHOD(bool, CTUnary, (int), (Calltype(STDMETHODCALLTYPE)));
MOCK_METHOD(int, CTDecimal, MOCK_METHOD(int, CTDecimal,
@ -208,7 +208,7 @@ class MockFoo : public FooInterface {
class LegacyMockFoo : public FooInterface { class LegacyMockFoo : public FooInterface {
public: public:
LegacyMockFoo() {} LegacyMockFoo() = default;
// Makes sure that a mock function parameter can be named. // Makes sure that a mock function parameter can be named.
MOCK_METHOD1(VoidReturning, void(int n)); // NOLINT MOCK_METHOD1(VoidReturning, void(int n)); // NOLINT
@ -248,7 +248,7 @@ class LegacyMockFoo : public FooInterface {
MOCK_METHOD1(ReturnsFunctionPointer1, int (*(int))(bool)); MOCK_METHOD1(ReturnsFunctionPointer1, int (*(int))(bool));
MOCK_METHOD1(ReturnsFunctionPointer2, fn_ptr(int)); MOCK_METHOD1(ReturnsFunctionPointer2, fn_ptr(int));
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, CTNullary, int()); MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, CTNullary, int());
MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, CTUnary, bool(int)); // NOLINT MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, CTUnary, bool(int)); // NOLINT
MOCK_METHOD10_WITH_CALLTYPE(STDMETHODCALLTYPE, CTDecimal, MOCK_METHOD10_WITH_CALLTYPE(STDMETHODCALLTYPE, CTDecimal,
@ -404,7 +404,7 @@ TYPED_TEST(FunctionMockerTest, MocksTypeWithTemplatedCopyCtor) {
EXPECT_TRUE(this->foo_->TypeWithTemplatedCopyCtor(TemplatedCopyable<int>())); EXPECT_TRUE(this->foo_->TypeWithTemplatedCopyCtor(TemplatedCopyable<int>()));
} }
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
// Tests mocking a nullary function with calltype. // Tests mocking a nullary function with calltype.
TYPED_TEST(FunctionMockerTest, MocksNullaryFunctionWithCallType) { TYPED_TEST(FunctionMockerTest, MocksNullaryFunctionWithCallType) {
EXPECT_CALL(this->mock_foo_, CTNullary()) EXPECT_CALL(this->mock_foo_, CTNullary())
@ -487,7 +487,7 @@ TEST(FunctionMockerTest, RefQualified) {
class MockB { class MockB {
public: public:
MockB() {} MockB() = default;
MOCK_METHOD(void, DoB, ()); MOCK_METHOD(void, DoB, ());
@ -498,7 +498,7 @@ class MockB {
class LegacyMockB { class LegacyMockB {
public: public:
LegacyMockB() {} LegacyMockB() = default;
MOCK_METHOD0(DoB, void()); MOCK_METHOD0(DoB, void());
@ -534,7 +534,7 @@ TYPED_TEST(ExpectCallTest, UnmentionedFunctionCanBeCalledAnyNumberOfTimes) {
template <typename T> template <typename T>
class StackInterface { class StackInterface {
public: public:
virtual ~StackInterface() {} virtual ~StackInterface() = default;
// Template parameter appears in function parameter. // Template parameter appears in function parameter.
virtual void Push(const T& value) = 0; virtual void Push(const T& value) = 0;
@ -547,7 +547,7 @@ class StackInterface {
template <typename T> template <typename T>
class MockStack : public StackInterface<T> { class MockStack : public StackInterface<T> {
public: public:
MockStack() {} MockStack() = default;
MOCK_METHOD(void, Push, (const T& elem), ()); MOCK_METHOD(void, Push, (const T& elem), ());
MOCK_METHOD(void, Pop, (), (final)); MOCK_METHOD(void, Pop, (), (final));
@ -566,7 +566,7 @@ class MockStack : public StackInterface<T> {
template <typename T> template <typename T>
class LegacyMockStack : public StackInterface<T> { class LegacyMockStack : public StackInterface<T> {
public: public:
LegacyMockStack() {} LegacyMockStack() = default;
MOCK_METHOD1_T(Push, void(const T& elem)); MOCK_METHOD1_T(Push, void(const T& elem));
MOCK_METHOD0_T(Pop, void()); MOCK_METHOD0_T(Pop, void());
@ -620,7 +620,7 @@ TYPED_TEST(TemplateMockTest, MethodWithCommaInReturnTypeWorks) {
EXPECT_EQ(a_map, mock.ReturnTypeWithComma(1)); EXPECT_EQ(a_map, mock.ReturnTypeWithComma(1));
} }
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
// Tests mocking template interfaces with calltype. // Tests mocking template interfaces with calltype.
template <typename T> template <typename T>
@ -711,7 +711,7 @@ TYPED_TEST(TemplateMockTestWithCallType, Works) {
class MockOverloadedOnArgNumber { class MockOverloadedOnArgNumber {
public: public:
MockOverloadedOnArgNumber() {} MockOverloadedOnArgNumber() = default;
MY_MOCK_METHODS1_; MY_MOCK_METHODS1_;
@ -723,7 +723,7 @@ class MockOverloadedOnArgNumber {
class LegacyMockOverloadedOnArgNumber { class LegacyMockOverloadedOnArgNumber {
public: public:
LegacyMockOverloadedOnArgNumber() {} LegacyMockOverloadedOnArgNumber() = default;
LEGACY_MY_MOCK_METHODS1_; LEGACY_MY_MOCK_METHODS1_;
@ -758,7 +758,7 @@ TYPED_TEST(OverloadedMockMethodTest, CanOverloadOnArgNumberInMacroBody) {
class MockOverloadedOnConstness { class MockOverloadedOnConstness {
public: public:
MockOverloadedOnConstness() {} MockOverloadedOnConstness() = default;
MY_MOCK_METHODS2_; MY_MOCK_METHODS2_;

5
googlemock/test/gmock-internal-utils_test.cc
View File

@ -40,6 +40,7 @@
#include <memory> #include <memory>
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <tuple>
#include <vector> #include <vector>
#include "gmock/gmock.h" #include "gmock/gmock.h"
@ -56,7 +57,7 @@
#include "src/gtest-internal-inl.h" #include "src/gtest-internal-inl.h"
#undef GTEST_IMPLEMENTATION_ #undef GTEST_IMPLEMENTATION_
#if GTEST_OS_CYGWIN #ifdef GTEST_OS_CYGWIN
#include <sys/types.h> // For ssize_t. NOLINT #include <sys/types.h> // For ssize_t. NOLINT
#endif #endif
@ -167,7 +168,7 @@ TEST(KindOfTest, Integer) {
EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned long long)); // NOLINT EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned long long)); // NOLINT
EXPECT_EQ(kInteger, GMOCK_KIND_OF_(wchar_t)); // NOLINT EXPECT_EQ(kInteger, GMOCK_KIND_OF_(wchar_t)); // NOLINT
EXPECT_EQ(kInteger, GMOCK_KIND_OF_(size_t)); // NOLINT EXPECT_EQ(kInteger, GMOCK_KIND_OF_(size_t)); // NOLINT
#if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN #if defined(GTEST_OS_LINUX) || defined(GTEST_OS_MAC) || defined(GTEST_OS_CYGWIN)
// ssize_t is not defined on Windows and possibly some other OSes. // ssize_t is not defined on Windows and possibly some other OSes.
EXPECT_EQ(kInteger, GMOCK_KIND_OF_(ssize_t)); // NOLINT EXPECT_EQ(kInteger, GMOCK_KIND_OF_(ssize_t)); // NOLINT
#endif #endif

7
googlemock/test/gmock-matchers-arithmetic_test.cc
View File

@ -31,7 +31,10 @@
// //
// This file tests some commonly used argument matchers. // This file tests some commonly used argument matchers.
#include <cmath>
#include <limits> #include <limits>
#include <memory>
#include <string>
#include "test/gmock-matchers_test.h" #include "test/gmock-matchers_test.h"
@ -952,7 +955,7 @@ TEST(AllArgsTest, WorksForNonTuple) {
class AllArgsHelper { class AllArgsHelper {
public: public:
AllArgsHelper() {} AllArgsHelper() = default;
MOCK_METHOD2(Helper, int(char x, int y)); MOCK_METHOD2(Helper, int(char x, int y));
@ -973,7 +976,7 @@ TEST(AllArgsTest, WorksInWithClause) {
class OptionalMatchersHelper { class OptionalMatchersHelper {
public: public:
OptionalMatchersHelper() {} OptionalMatchersHelper() = default;
MOCK_METHOD0(NoArgs, int()); MOCK_METHOD0(NoArgs, int());

10
googlemock/test/gmock-matchers-comparisons_test.cc
View File

@ -31,6 +31,10 @@
// //
// This file tests some commonly used argument matchers. // This file tests some commonly used argument matchers.
#include <functional>
#include <memory>
#include <string>
#include <tuple>
#include <vector> #include <vector>
#include "test/gmock-matchers_test.h" #include "test/gmock-matchers_test.h"
@ -585,8 +589,8 @@ TEST(MatcherCastTest, ValueIsNotCopied) {
class Base { class Base {
public: public:
virtual ~Base() {} virtual ~Base() = default;
Base() {} Base() = default;
private: private:
Base(const Base&) = delete; Base(const Base&) = delete;
@ -1542,7 +1546,7 @@ TEST(PairTest, MatchesCorrectly) {
TEST(PairTest, WorksWithMoveOnly) { TEST(PairTest, WorksWithMoveOnly) {
pair<std::unique_ptr<int>, std::unique_ptr<int>> p; pair<std::unique_ptr<int>, std::unique_ptr<int>> p;
p.second.reset(new int(7)); p.second = std::make_unique<int>(7);
EXPECT_THAT(p, Pair(Eq(nullptr), Ne(nullptr))); EXPECT_THAT(p, Pair(Eq(nullptr), Ne(nullptr)));
} }

18
googlemock/test/gmock-matchers-containers_test.cc
View File

@ -31,6 +31,18 @@
// //
// This file tests some commonly used argument matchers. // This file tests some commonly used argument matchers.
#include <algorithm>
#include <array>
#include <deque>
#include <forward_list>
#include <iterator>
#include <list>
#include <memory>
#include <ostream>
#include <string>
#include <tuple>
#include <vector>
#include "gtest/gtest.h" #include "gtest/gtest.h"
// Silence warning C4244: 'initializing': conversion from 'int' to 'short', // Silence warning C4244: 'initializing': conversion from 'int' to 'short',
@ -1824,8 +1836,8 @@ TEST(UnorderedElementsAreArrayTest, SucceedsWhenExpected) {
} }
TEST(UnorderedElementsAreArrayTest, VectorBool) { TEST(UnorderedElementsAreArrayTest, VectorBool) {
const bool a[] = {0, 1, 0, 1, 1}; const bool a[] = {false, true, false, true, true};
const bool b[] = {1, 0, 1, 1, 0}; const bool b[] = {true, false, true, true, false};
std::vector<bool> expected(std::begin(a), std::end(a)); std::vector<bool> expected(std::begin(a), std::end(a));
std::vector<bool> actual(std::begin(b), std::end(b)); std::vector<bool> actual(std::begin(b), std::end(b));
StringMatchResultListener listener; StringMatchResultListener listener;
@ -2776,7 +2788,7 @@ TEST(ElementsAreTest, WorksWithNativeArrayPassedByReference) {
class NativeArrayPassedAsPointerAndSize { class NativeArrayPassedAsPointerAndSize {
public: public:
NativeArrayPassedAsPointerAndSize() {} NativeArrayPassedAsPointerAndSize() = default;
MOCK_METHOD(void, Helper, (int* array, int size)); MOCK_METHOD(void, Helper, (int* array, int size));

10
googlemock/test/gmock-matchers-misc_test.cc
View File

@ -31,6 +31,14 @@
// //
// This file tests some commonly used argument matchers. // This file tests some commonly used argument matchers.
#include <array>
#include <memory>
#include <ostream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#include "gtest/gtest.h" #include "gtest/gtest.h"
// Silence warning C4244: 'initializing': conversion from 'int' to 'short', // Silence warning C4244: 'initializing': conversion from 'int' to 'short',
@ -200,7 +208,7 @@ TEST(IsTrueTest, IsTrueIsFalse) {
EXPECT_THAT(nonnull_unique, Not(IsFalse())); EXPECT_THAT(nonnull_unique, Not(IsFalse()));
} }
#if GTEST_HAS_TYPED_TEST #ifdef GTEST_HAS_TYPED_TEST
// Tests ContainerEq with different container types, and // Tests ContainerEq with different container types, and
// different element types. // different element types.

6
googlemock/test/gmock-more-actions_test.cc
View File

@ -33,10 +33,14 @@
#include "gmock/gmock-more-actions.h" #include "gmock/gmock-more-actions.h"
#include <algorithm>
#include <functional> #include <functional>
#include <iterator>
#include <memory> #include <memory>
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <tuple>
#include <vector>
#include "gmock/gmock.h" #include "gmock/gmock.h"
#include "gtest/gtest-spi.h" #include "gtest/gtest-spi.h"
@ -673,7 +677,7 @@ TEST(SetArrayArgumentTest, SetsTheNthArrayWithIteratorArgument) {
Action<MyFunction> a = SetArrayArgument<1>(letters.begin(), letters.end()); Action<MyFunction> a = SetArrayArgument<1>(letters.begin(), letters.end());
std::string s; std::string s;
a.Perform(std::make_tuple(true, back_inserter(s))); a.Perform(std::make_tuple(true, std::back_inserter(s)));
EXPECT_EQ(letters, s); EXPECT_EQ(letters, s);
} }

8
googlemock/test/gmock-nice-strict_test.cc
View File

@ -40,7 +40,7 @@
// clash with ::testing::Mock. // clash with ::testing::Mock.
class Mock { class Mock {
public: public:
Mock() {} Mock() = default;
MOCK_METHOD0(DoThis, void()); MOCK_METHOD0(DoThis, void());
@ -78,7 +78,7 @@ class CallsMockMethodInDestructor {
class Foo { class Foo {
public: public:
virtual ~Foo() {} virtual ~Foo() = default;
virtual void DoThis() = 0; virtual void DoThis() = 0;
virtual int DoThat(bool flag) = 0; virtual int DoThat(bool flag) = 0;
@ -86,7 +86,7 @@ class Foo {
class MockFoo : public Foo { class MockFoo : public Foo {
public: public:
MockFoo() {} MockFoo() = default;
void Delete() { delete this; } void Delete() { delete this; }
MOCK_METHOD0(DoThis, void()); MOCK_METHOD0(DoThis, void());
@ -109,7 +109,7 @@ class MockBar {
(a10 ? 'T' : 'F'); (a10 ? 'T' : 'F');
} }
virtual ~MockBar() {} virtual ~MockBar() = default;
const std::string& str() const { return str_; } const std::string& str() const { return str_; }

47
googlemock/test/gmock-spec-builders_test.cc
View File

@ -98,7 +98,7 @@ class NonDefaultConstructible {
class MockA { class MockA {
public: public:
MockA() {} MockA() = default;
MOCK_METHOD1(DoA, void(int n)); MOCK_METHOD1(DoA, void(int n));
MOCK_METHOD1(ReturnResult, Result(int n)); MOCK_METHOD1(ReturnResult, Result(int n));
@ -113,7 +113,7 @@ class MockA {
class MockB { class MockB {
public: public:
MockB() {} MockB() = default;
MOCK_CONST_METHOD0(DoB, int()); // NOLINT MOCK_CONST_METHOD0(DoB, int()); // NOLINT
MOCK_METHOD1(DoB, int(int n)); // NOLINT MOCK_METHOD1(DoB, int(int n)); // NOLINT
@ -125,7 +125,7 @@ class MockB {
class ReferenceHoldingMock { class ReferenceHoldingMock {
public: public:
ReferenceHoldingMock() {} ReferenceHoldingMock() = default;
MOCK_METHOD1(AcceptReference, void(std::shared_ptr<MockA>*)); MOCK_METHOD1(AcceptReference, void(std::shared_ptr<MockA>*));
@ -143,12 +143,12 @@ class ReferenceHoldingMock {
class CC { class CC {
public: public:
virtual ~CC() {} virtual ~CC() = default;
virtual int Method() = 0; virtual int Method() = 0;
}; };
class MockCC : public CC { class MockCC : public CC {
public: public:
MockCC() {} MockCC() = default;
MOCK_METHOD0(Method, int()); MOCK_METHOD0(Method, int());
@ -804,39 +804,40 @@ TEST(ExpectCallTest, InfersCardinality1WhenThereIsWillRepeatedly) {
"to be called at least once"); "to be called at least once");
} }
#if defined(__cplusplus) && __cplusplus >= 201703L #if defined(GTEST_INTERNAL_CPLUSPLUS_LANG) && \
GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
// It should be possible to return a non-moveable type from a mock action in // It should be possible to return a non-moveable type from a mock action in
// C++17 and above, where it's guaranteed that such a type can be initialized // C++17 and above, where it's guaranteed that such a type can be initialized
// from a prvalue returned from a function. // from a prvalue returned from a function.
TEST(ExpectCallTest, NonMoveableType) { TEST(ExpectCallTest, NonMoveableType) {
// Define a non-moveable result type. // Define a non-moveable result type.
struct Result { struct NonMoveableStruct {
explicit Result(int x_in) : x(x_in) {} explicit NonMoveableStruct(int x_in) : x(x_in) {}
Result(Result&&) = delete; NonMoveableStruct(NonMoveableStruct&&) = delete;
int x; int x;
}; };
static_assert(!std::is_move_constructible_v<Result>); static_assert(!std::is_move_constructible_v<NonMoveableStruct>);
static_assert(!std::is_copy_constructible_v<Result>); static_assert(!std::is_copy_constructible_v<NonMoveableStruct>);
static_assert(!std::is_move_assignable_v<Result>); static_assert(!std::is_move_assignable_v<NonMoveableStruct>);
static_assert(!std::is_copy_assignable_v<Result>); static_assert(!std::is_copy_assignable_v<NonMoveableStruct>);
// We should be able to use a callable that returns that result as both a // We should be able to use a callable that returns that result as both a
// OnceAction and an Action, whether the callable ignores arguments or not. // OnceAction and an Action, whether the callable ignores arguments or not.
const auto return_17 = [] { return Result(17); }; const auto return_17 = [] { return NonMoveableStruct(17); };
static_cast<void>(OnceAction<Result()>{return_17}); static_cast<void>(OnceAction<NonMoveableStruct()>{return_17});
static_cast<void>(Action<Result()>{return_17}); static_cast<void>(Action<NonMoveableStruct()>{return_17});
static_cast<void>(OnceAction<Result(int)>{return_17}); static_cast<void>(OnceAction<NonMoveableStruct(int)>{return_17});
static_cast<void>(Action<Result(int)>{return_17}); static_cast<void>(Action<NonMoveableStruct(int)>{return_17});
// It should be possible to return the result end to end through an // It should be possible to return the result end to end through an
// EXPECT_CALL statement, with both WillOnce and WillRepeatedly. // EXPECT_CALL statement, with both WillOnce and WillRepeatedly.
MockFunction<Result()> mock; MockFunction<NonMoveableStruct()> mock;
EXPECT_CALL(mock, Call) // EXPECT_CALL(mock, Call) //
.WillOnce(return_17) // .WillOnce(return_17) //
.WillRepeatedly(return_17); .WillRepeatedly(return_17);
@ -1088,7 +1089,7 @@ TEST(UnexpectedCallTest, UnsatisfiedPrerequisites) {
// Verifies that the failure message contains the two unsatisfied // Verifies that the failure message contains the two unsatisfied
// pre-requisites but not the satisfied one. // pre-requisites but not the satisfied one.
#if GTEST_USES_POSIX_RE #ifdef GTEST_USES_POSIX_RE
EXPECT_THAT(r.message(), EXPECT_THAT(r.message(),
ContainsRegex( ContainsRegex(
// POSIX RE doesn't understand the (?s) prefix, but has no // POSIX RE doesn't understand the (?s) prefix, but has no
@ -1881,7 +1882,7 @@ struct Unprintable {
class MockC { class MockC {
public: public:
MockC() {} MockC() = default;
MOCK_METHOD6(VoidMethod, void(bool cond, int n, std::string s, void* p, MOCK_METHOD6(VoidMethod, void(bool cond, int n, std::string s, void* p,
const Printable& x, Unprintable y)); const Printable& x, Unprintable y));
@ -2050,7 +2051,7 @@ class GMockVerboseFlagTest : public VerboseFlagPreservingFixture {
"See " "See "
"https://github.com/google/googletest/blob/main/docs/" "https://github.com/google/googletest/blob/main/docs/"
"gmock_cook_book.md#" "gmock_cook_book.md#"
"knowing-when-to-expect for details."; "knowing-when-to-expect-useoncall for details.";
// A void-returning function. // A void-returning function.
CaptureStdout(); CaptureStdout();
@ -2121,7 +2122,7 @@ void PrintTo(PrintMeNot /* dummy */, ::std::ostream* /* os */) {
class LogTestHelper { class LogTestHelper {
public: public:
LogTestHelper() {} LogTestHelper() = default;
MOCK_METHOD1(Foo, PrintMeNot(PrintMeNot)); MOCK_METHOD1(Foo, PrintMeNot(PrintMeNot));

2
googlemock/test/gmock_ex_test.cc
View File

@ -29,6 +29,8 @@
// Tests Google Mock's functionality that depends on exceptions. // Tests Google Mock's functionality that depends on exceptions.
#include <exception>
#include "gmock/gmock.h" #include "gmock/gmock.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"

4
googlemock/test/gmock_leak_test_.cc
View File

@ -40,13 +40,13 @@ using ::testing::Return;
class FooInterface { class FooInterface {
public: public:
virtual ~FooInterface() {} virtual ~FooInterface() = default;
virtual void DoThis() = 0; virtual void DoThis() = 0;
}; };
class MockFoo : public FooInterface { class MockFoo : public FooInterface {
public: public:
MockFoo() {} MockFoo() = default;
MOCK_METHOD0(DoThis, void()); MOCK_METHOD0(DoThis, void());

10
googlemock/test/gmock_link_test.h
View File

@ -116,7 +116,7 @@
#include "gmock/gmock.h" #include "gmock/gmock.h"
#if !GTEST_OS_WINDOWS_MOBILE #ifndef GTEST_OS_WINDOWS_MOBILE
#include <errno.h> #include <errno.h>
#endif #endif
@ -181,7 +181,7 @@ using testing::WithArg;
using testing::WithArgs; using testing::WithArgs;
using testing::WithoutArgs; using testing::WithoutArgs;
#if !GTEST_OS_WINDOWS_MOBILE #ifndef GTEST_OS_WINDOWS_MOBILE
using testing::SetErrnoAndReturn; using testing::SetErrnoAndReturn;
#endif #endif
@ -194,7 +194,7 @@ using testing::MatchesRegex;
class Interface { class Interface {
public: public:
virtual ~Interface() {} virtual ~Interface() = default;
virtual void VoidFromString(char* str) = 0; virtual void VoidFromString(char* str) = 0;
virtual char* StringFromString(char* str) = 0; virtual char* StringFromString(char* str) = 0;
virtual int IntFromString(char* str) = 0; virtual int IntFromString(char* str) = 0;
@ -208,7 +208,7 @@ class Interface {
class Mock : public Interface { class Mock : public Interface {
public: public:
Mock() {} Mock() = default;
MOCK_METHOD1(VoidFromString, void(char* str)); MOCK_METHOD1(VoidFromString, void(char* str));
MOCK_METHOD1(StringFromString, char*(char* str)); MOCK_METHOD1(StringFromString, char*(char* str));
@ -306,7 +306,7 @@ TEST(LinkTest, TestSetArrayArgument) {
mock.VoidFromString(&ch); mock.VoidFromString(&ch);
} }
#if !GTEST_OS_WINDOWS_MOBILE #ifndef GTEST_OS_WINDOWS_MOBILE
// Tests the linkage of the SetErrnoAndReturn action. // Tests the linkage of the SetErrnoAndReturn action.
TEST(LinkTest, TestSetErrnoAndReturn) { TEST(LinkTest, TestSetErrnoAndReturn) {

2
googlemock/test/gmock_output_test_.cc
View File

@ -52,7 +52,7 @@ using testing::Value;
class MockFoo { class MockFoo {
public: public:
MockFoo() {} MockFoo() = default;
MOCK_METHOD3(Bar, char(const std::string& s, int i, double x)); MOCK_METHOD3(Bar, char(const std::string& s, int i, double x));
MOCK_METHOD2(Bar2, bool(int x, int y)); MOCK_METHOD2(Bar2, bool(int x, int y));

25
googlemock/test/gmock_output_test_golden.txt
View File

@ -40,6 +40,7 @@ FILE:#: EXPECT_CALL(foo_, Bar2(0, _))...
Actual: 1 Actual: 1
Expected: to be called once Expected: to be called once
Actual: never called - unsatisfied and active Actual: never called - unsatisfied and active
[ FAILED ] GMockOutputTest.UnexpectedCall [ FAILED ] GMockOutputTest.UnexpectedCall
[ RUN ] GMockOutputTest.UnexpectedCallToVoidFunction [ RUN ] GMockOutputTest.UnexpectedCallToVoidFunction
unknown file: Failure unknown file: Failure
@ -53,6 +54,7 @@ FILE:#: EXPECT_CALL(foo_, Bar3(0, _))...
Actual: 1 Actual: 1
Expected: to be called once Expected: to be called once
Actual: never called - unsatisfied and active Actual: never called - unsatisfied and active
[ FAILED ] GMockOutputTest.UnexpectedCallToVoidFunction [ FAILED ] GMockOutputTest.UnexpectedCallToVoidFunction
[ RUN ] GMockOutputTest.ExcessiveCall [ RUN ] GMockOutputTest.ExcessiveCall
FILE:#: Failure FILE:#: Failure
@ -61,6 +63,7 @@ Mock function called more times than expected - returning default value.
Returns: false Returns: false
Expected: to be called once Expected: to be called once
Actual: called twice - over-saturated and active Actual: called twice - over-saturated and active
[ FAILED ] GMockOutputTest.ExcessiveCall [ FAILED ] GMockOutputTest.ExcessiveCall
[ RUN ] GMockOutputTest.ExcessiveCallToVoidFunction [ RUN ] GMockOutputTest.ExcessiveCallToVoidFunction
FILE:#: Failure FILE:#: Failure
@ -68,6 +71,7 @@ Mock function called more times than expected - returning directly.
Function call: Bar3(0, 1) Function call: Bar3(0, 1)
Expected: to be called once Expected: to be called once
Actual: called twice - over-saturated and active Actual: called twice - over-saturated and active
[ FAILED ] GMockOutputTest.ExcessiveCallToVoidFunction [ FAILED ] GMockOutputTest.ExcessiveCallToVoidFunction
[ RUN ] GMockOutputTest.UninterestingCall [ RUN ] GMockOutputTest.UninterestingCall
@ -75,14 +79,14 @@ GMOCK WARNING:
Uninteresting mock function call - returning default value. Uninteresting mock function call - returning default value.
Function call: Bar2(0, 1) Function call: Bar2(0, 1)
Returns: false Returns: false
NOTE: You can safely ignore the above warning unless this call should not happen. Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call. See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect for details. NOTE: You can safely ignore the above warning unless this call should not happen. Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call. See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect-useoncall for details.
[ OK ] GMockOutputTest.UninterestingCall [ OK ] GMockOutputTest.UninterestingCall
[ RUN ] GMockOutputTest.UninterestingCallToVoidFunction [ RUN ] GMockOutputTest.UninterestingCallToVoidFunction
GMOCK WARNING: GMOCK WARNING:
Uninteresting mock function call - returning directly. Uninteresting mock function call - returning directly.
Function call: Bar3(0, 1) Function call: Bar3(0, 1)
NOTE: You can safely ignore the above warning unless this call should not happen. Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call. See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect for details. NOTE: You can safely ignore the above warning unless this call should not happen. Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call. See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect-useoncall for details.
[ OK ] GMockOutputTest.UninterestingCallToVoidFunction [ OK ] GMockOutputTest.UninterestingCallToVoidFunction
[ RUN ] GMockOutputTest.RetiredExpectation [ RUN ] GMockOutputTest.RetiredExpectation
unknown file: Failure unknown file: Failure
@ -104,6 +108,7 @@ FILE:#: tried expectation #1: EXPECT_CALL(foo_, Bar2(0, 0))...
Actual: 1 Actual: 1
Expected: to be called once Expected: to be called once
Actual: never called - unsatisfied and active Actual: never called - unsatisfied and active
[ FAILED ] GMockOutputTest.RetiredExpectation [ FAILED ] GMockOutputTest.RetiredExpectation
[ RUN ] GMockOutputTest.UnsatisfiedPrerequisite [ RUN ] GMockOutputTest.UnsatisfiedPrerequisite
unknown file: Failure unknown file: Failure
@ -125,6 +130,7 @@ FILE:#: pre-requisite #0
(end of pre-requisites) (end of pre-requisites)
Expected: to be called once Expected: to be called once
Actual: never called - unsatisfied and active Actual: never called - unsatisfied and active
[ FAILED ] GMockOutputTest.UnsatisfiedPrerequisite [ FAILED ] GMockOutputTest.UnsatisfiedPrerequisite
[ RUN ] GMockOutputTest.UnsatisfiedPrerequisites [ RUN ] GMockOutputTest.UnsatisfiedPrerequisites
unknown file: Failure unknown file: Failure
@ -147,6 +153,7 @@ FILE:#: pre-requisite #1
(end of pre-requisites) (end of pre-requisites)
Expected: to be called once Expected: to be called once
Actual: never called - unsatisfied and active Actual: never called - unsatisfied and active
[ FAILED ] GMockOutputTest.UnsatisfiedPrerequisites [ FAILED ] GMockOutputTest.UnsatisfiedPrerequisites
[ RUN ] GMockOutputTest.UnsatisfiedWith [ RUN ] GMockOutputTest.UnsatisfiedWith
FILE:#: Failure FILE:#: Failure
@ -154,16 +161,19 @@ Actual function call count doesn't match EXPECT_CALL(foo_, Bar2(_, _))...
Expected args: are a pair where the first >= the second Expected args: are a pair where the first >= the second
Expected: to be called once Expected: to be called once
Actual: never called - unsatisfied and active Actual: never called - unsatisfied and active
[ FAILED ] GMockOutputTest.UnsatisfiedWith [ FAILED ] GMockOutputTest.UnsatisfiedWith
[ RUN ] GMockOutputTest.UnsatisfiedExpectation [ RUN ] GMockOutputTest.UnsatisfiedExpectation
FILE:#: Failure FILE:#: Failure
Actual function call count doesn't match EXPECT_CALL(foo_, Bar2(0, _))... Actual function call count doesn't match EXPECT_CALL(foo_, Bar2(0, _))...
Expected: to be called twice Expected: to be called twice
Actual: called once - unsatisfied and active Actual: called once - unsatisfied and active
FILE:#: Failure FILE:#: Failure
Actual function call count doesn't match EXPECT_CALL(foo_, Bar(_, _, _))... Actual function call count doesn't match EXPECT_CALL(foo_, Bar(_, _, _))...
Expected: to be called once Expected: to be called once
Actual: never called - unsatisfied and active Actual: never called - unsatisfied and active
[ FAILED ] GMockOutputTest.UnsatisfiedExpectation [ FAILED ] GMockOutputTest.UnsatisfiedExpectation
[ RUN ] GMockOutputTest.MismatchArguments [ RUN ] GMockOutputTest.MismatchArguments
unknown file: Failure unknown file: Failure
@ -180,6 +190,7 @@ FILE:#: EXPECT_CALL(foo_, Bar(Ref(s), _, Ge(0)))...
Actual: -0.1 Actual: -0.1
Expected: to be called once Expected: to be called once
Actual: never called - unsatisfied and active Actual: never called - unsatisfied and active
[ FAILED ] GMockOutputTest.MismatchArguments [ FAILED ] GMockOutputTest.MismatchArguments
[ RUN ] GMockOutputTest.MismatchWith [ RUN ] GMockOutputTest.MismatchWith
unknown file: Failure unknown file: Failure
@ -194,6 +205,7 @@ FILE:#: EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))...
Actual: don't match Actual: don't match
Expected: to be called once Expected: to be called once
Actual: never called - unsatisfied and active Actual: never called - unsatisfied and active
[ FAILED ] GMockOutputTest.MismatchWith [ FAILED ] GMockOutputTest.MismatchWith
[ RUN ] GMockOutputTest.MismatchArgumentsAndWith [ RUN ] GMockOutputTest.MismatchArgumentsAndWith
unknown file: Failure unknown file: Failure
@ -210,6 +222,7 @@ FILE:#: EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))...
Actual: don't match Actual: don't match
Expected: to be called once Expected: to be called once
Actual: never called - unsatisfied and active Actual: never called - unsatisfied and active
[ FAILED ] GMockOutputTest.MismatchArgumentsAndWith [ FAILED ] GMockOutputTest.MismatchArgumentsAndWith
[ RUN ] GMockOutputTest.UnexpectedCallWithDefaultAction [ RUN ] GMockOutputTest.UnexpectedCallWithDefaultAction
unknown file: Failure unknown file: Failure
@ -227,6 +240,7 @@ FILE:#: EXPECT_CALL(foo_, Bar2(2, 2))...
Actual: 0 Actual: 0
Expected: to be called once Expected: to be called once
Actual: never called - unsatisfied and active Actual: never called - unsatisfied and active
unknown file: Failure unknown file: Failure
Unexpected mock function call - taking default action specified at: Unexpected mock function call - taking default action specified at:
@ -242,6 +256,7 @@ FILE:#: EXPECT_CALL(foo_, Bar2(2, 2))...
Actual: 0 Actual: 0
Expected: to be called once Expected: to be called once
Actual: never called - unsatisfied and active Actual: never called - unsatisfied and active
[ FAILED ] GMockOutputTest.UnexpectedCallWithDefaultAction [ FAILED ] GMockOutputTest.UnexpectedCallWithDefaultAction
[ RUN ] GMockOutputTest.ExcessiveCallWithDefaultAction [ RUN ] GMockOutputTest.ExcessiveCallWithDefaultAction
FILE:#: Failure FILE:#: Failure
@ -251,6 +266,7 @@ FILE:#:
Returns: true Returns: true
Expected: to be called once Expected: to be called once
Actual: called twice - over-saturated and active Actual: called twice - over-saturated and active
FILE:#: Failure FILE:#: Failure
Mock function called more times than expected - taking default action specified at: Mock function called more times than expected - taking default action specified at:
FILE:#: FILE:#:
@ -258,6 +274,7 @@ FILE:#:
Returns: false Returns: false
Expected: to be called once Expected: to be called once
Actual: called twice - over-saturated and active Actual: called twice - over-saturated and active
[ FAILED ] GMockOutputTest.ExcessiveCallWithDefaultAction [ FAILED ] GMockOutputTest.ExcessiveCallWithDefaultAction
[ RUN ] GMockOutputTest.UninterestingCallWithDefaultAction [ RUN ] GMockOutputTest.UninterestingCallWithDefaultAction
@ -266,14 +283,14 @@ Uninteresting mock function call - taking default action specified at:
FILE:#: FILE:#:
Function call: Bar2(2, 2) Function call: Bar2(2, 2)
Returns: true Returns: true
NOTE: You can safely ignore the above warning unless this call should not happen. Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call. See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect for details. NOTE: You can safely ignore the above warning unless this call should not happen. Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call. See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect-useoncall for details.
GMOCK WARNING: GMOCK WARNING:
Uninteresting mock function call - taking default action specified at: Uninteresting mock function call - taking default action specified at:
FILE:#: FILE:#:
Function call: Bar2(1, 1) Function call: Bar2(1, 1)
Returns: false Returns: false
NOTE: You can safely ignore the above warning unless this call should not happen. Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call. See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect for details. NOTE: You can safely ignore the above warning unless this call should not happen. Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call. See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect-useoncall for details.
[ OK ] GMockOutputTest.UninterestingCallWithDefaultAction [ OK ] GMockOutputTest.UninterestingCallWithDefaultAction
[ RUN ] GMockOutputTest.ExplicitActionsRunOutWithDefaultAction [ RUN ] GMockOutputTest.ExplicitActionsRunOutWithDefaultAction

2
googlemock/test/gmock_test.cc
View File

@ -174,6 +174,6 @@ TEST(WideInitGoogleMockTest, ParsesGoogleMockFlagAndUnrecognizedFlag) {
// Makes sure Google Mock flags can be accessed in code. // Makes sure Google Mock flags can be accessed in code.
TEST(FlagTest, IsAccessibleInCode) { TEST(FlagTest, IsAccessibleInCode) {
bool dummy = bool dummy =
GMOCK_FLAG_GET(catch_leaked_mocks) && GMOCK_FLAG_GET(verbose) == ""; GMOCK_FLAG_GET(catch_leaked_mocks) && GMOCK_FLAG_GET(verbose).empty();
(void)dummy; // Avoids the "unused local variable" warning. (void)dummy; // Avoids the "unused local variable" warning.
} }

8
googletest/cmake/internal_utils.cmake
View File

@ -16,6 +16,10 @@ if (POLICY CMP0054)
cmake_policy(SET CMP0054 NEW) cmake_policy(SET CMP0054 NEW)
endif (POLICY CMP0054) endif (POLICY CMP0054)
if (POLICY CMP0069)
cmake_policy(SET CMP0069 NEW)
endif (POLICY CMP0069)
# Tweaks CMake's default compiler/linker settings to suit Google Test's needs. # Tweaks CMake's default compiler/linker settings to suit Google Test's needs.
# #
# This must be a macro(), as inside a function string() can only # This must be a macro(), as inside a function string() can only
@ -91,13 +95,13 @@ macro(config_compiler_and_linker)
set(cxx_base_flags "${cxx_base_flags} -utf-8") set(cxx_base_flags "${cxx_base_flags} -utf-8")
endif() endif()
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Clang") elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
set(cxx_base_flags "-Wall -Wshadow -Wconversion") set(cxx_base_flags "-Wall -Wshadow -Wconversion -Wundef")
set(cxx_exception_flags "-fexceptions") set(cxx_exception_flags "-fexceptions")
set(cxx_no_exception_flags "-fno-exceptions") set(cxx_no_exception_flags "-fno-exceptions")
set(cxx_strict_flags "-W -Wpointer-arith -Wreturn-type -Wcast-qual -Wwrite-strings -Wswitch -Wunused-parameter -Wcast-align -Wchar-subscripts -Winline -Wredundant-decls") set(cxx_strict_flags "-W -Wpointer-arith -Wreturn-type -Wcast-qual -Wwrite-strings -Wswitch -Wunused-parameter -Wcast-align -Wchar-subscripts -Winline -Wredundant-decls")
set(cxx_no_rtti_flags "-fno-rtti") set(cxx_no_rtti_flags "-fno-rtti")
elseif (CMAKE_COMPILER_IS_GNUCXX) elseif (CMAKE_COMPILER_IS_GNUCXX)
set(cxx_base_flags "-Wall -Wshadow") set(cxx_base_flags "-Wall -Wshadow -Wundef")
if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0.0) if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0.0)
set(cxx_base_flags "${cxx_base_flags} -Wno-error=dangling-else") set(cxx_base_flags "${cxx_base_flags} -Wno-error=dangling-else")
endif() endif()

4
googletest/include/gtest/gtest-assertion-result.h
View File

@ -181,7 +181,7 @@ class GTEST_API_ AssertionResult {
// assertion's expectation). When nothing has been streamed into the // assertion's expectation). When nothing has been streamed into the
// object, returns an empty string. // object, returns an empty string.
const char* message() const { const char* message() const {
return message_.get() != nullptr ? message_->c_str() : ""; return message_ != nullptr ? message_->c_str() : "";
} }
// Deprecated; please use message() instead. // Deprecated; please use message() instead.
const char* failure_message() const { return message(); } const char* failure_message() const { return message(); }
@ -204,7 +204,7 @@ class GTEST_API_ AssertionResult {
private: private:
// Appends the contents of message to message_. // Appends the contents of message to message_.
void AppendMessage(const Message& a_message) { void AppendMessage(const Message& a_message) {
if (message_.get() == nullptr) message_.reset(new ::std::string); if (message_ == nullptr) message_ = ::std::make_unique<::std::string>();
message_->append(a_message.GetString().c_str()); message_->append(a_message.GetString().c_str());
} }

6
googletest/include/gtest/gtest-death-test.h
View File

@ -51,7 +51,7 @@ GTEST_DECLARE_string_(death_test_style);
namespace testing { namespace testing {
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
namespace internal { namespace internal {
@ -203,7 +203,7 @@ class GTEST_API_ ExitedWithCode {
const int exit_code_; const int exit_code_;
}; };
#if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA #if !defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_FUCHSIA)
// Tests that an exit code describes an exit due to termination by a // Tests that an exit code describes an exit due to termination by a
// given signal. // given signal.
class GTEST_API_ KilledBySignal { class GTEST_API_ KilledBySignal {
@ -328,7 +328,7 @@ class GTEST_API_ KilledBySignal {
// death tests are supported; otherwise they just issue a warning. This is // death tests are supported; otherwise they just issue a warning. This is
// useful when you are combining death test assertions with normal test // useful when you are combining death test assertions with normal test
// assertions in one test. // assertions in one test.
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
#define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \ #define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
EXPECT_DEATH(statement, regex) EXPECT_DEATH(statement, regex)
#define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \ #define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \

77
googletest/include/gtest/gtest-matchers.h
View File

@ -40,6 +40,7 @@
#define GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_ #define GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
#include <atomic> #include <atomic>
#include <functional>
#include <memory> #include <memory>
#include <ostream> #include <ostream>
#include <string> #include <string>
@ -106,13 +107,13 @@ class MatchResultListener {
MatchResultListener& operator=(const MatchResultListener&) = delete; MatchResultListener& operator=(const MatchResultListener&) = delete;
}; };
inline MatchResultListener::~MatchResultListener() {} inline MatchResultListener::~MatchResultListener() = default;
// An instance of a subclass of this knows how to describe itself as a // An instance of a subclass of this knows how to describe itself as a
// matcher. // matcher.
class GTEST_API_ MatcherDescriberInterface { class GTEST_API_ MatcherDescriberInterface {
public: public:
virtual ~MatcherDescriberInterface() {} virtual ~MatcherDescriberInterface() = default;
// Describes this matcher to an ostream. The function should print // Describes this matcher to an ostream. The function should print
// a verb phrase that describes the property a value matching this // a verb phrase that describes the property a value matching this
@ -178,43 +179,6 @@ class MatcherInterface : public MatcherDescriberInterface {
namespace internal { namespace internal {
struct AnyEq {
template <typename A, typename B>
bool operator()(const A& a, const B& b) const {
return a == b;
}
};
struct AnyNe {
template <typename A, typename B>
bool operator()(const A& a, const B& b) const {
return a != b;
}
};
struct AnyLt {
template <typename A, typename B>
bool operator()(const A& a, const B& b) const {
return a < b;
}
};
struct AnyGt {
template <typename A, typename B>
bool operator()(const A& a, const B& b) const {
return a > b;
}
};
struct AnyLe {
template <typename A, typename B>
bool operator()(const A& a, const B& b) const {
return a <= b;
}
};
struct AnyGe {
template <typename A, typename B>
bool operator()(const A& a, const B& b) const {
return a >= b;
}
};
// A match result listener that ignores the explanation. // A match result listener that ignores the explanation.
class DummyMatchResultListener : public MatchResultListener { class DummyMatchResultListener : public MatchResultListener {
public: public:
@ -530,7 +494,7 @@ template <>
class GTEST_API_ Matcher<const std::string&> class GTEST_API_ Matcher<const std::string&>
: public internal::MatcherBase<const std::string&> { : public internal::MatcherBase<const std::string&> {
public: public:
Matcher() {} Matcher() = default;
explicit Matcher(const MatcherInterface<const std::string&>* impl) explicit Matcher(const MatcherInterface<const std::string&>* impl)
: internal::MatcherBase<const std::string&>(impl) {} : internal::MatcherBase<const std::string&>(impl) {}
@ -552,7 +516,7 @@ template <>
class GTEST_API_ Matcher<std::string> class GTEST_API_ Matcher<std::string>
: public internal::MatcherBase<std::string> { : public internal::MatcherBase<std::string> {
public: public:
Matcher() {} Matcher() = default;
explicit Matcher(const MatcherInterface<const std::string&>* impl) explicit Matcher(const MatcherInterface<const std::string&>* impl)
: internal::MatcherBase<std::string>(impl) {} : internal::MatcherBase<std::string>(impl) {}
@ -580,7 +544,7 @@ template <>
class GTEST_API_ Matcher<const internal::StringView&> class GTEST_API_ Matcher<const internal::StringView&>
: public internal::MatcherBase<const internal::StringView&> { : public internal::MatcherBase<const internal::StringView&> {
public: public:
Matcher() {} Matcher() = default;
explicit Matcher(const MatcherInterface<const internal::StringView&>* impl) explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
: internal::MatcherBase<const internal::StringView&>(impl) {} : internal::MatcherBase<const internal::StringView&>(impl) {}
@ -606,7 +570,7 @@ template <>
class GTEST_API_ Matcher<internal::StringView> class GTEST_API_ Matcher<internal::StringView>
: public internal::MatcherBase<internal::StringView> { : public internal::MatcherBase<internal::StringView> {
public: public:
Matcher() {} Matcher() = default;
explicit Matcher(const MatcherInterface<const internal::StringView&>* impl) explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
: internal::MatcherBase<internal::StringView>(impl) {} : internal::MatcherBase<internal::StringView>(impl) {}
@ -758,50 +722,53 @@ class ComparisonBase {
}; };
template <typename Rhs> template <typename Rhs>
class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> { class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, std::equal_to<>> {
public: public:
explicit EqMatcher(const Rhs& rhs) explicit EqMatcher(const Rhs& rhs)
: ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) {} : ComparisonBase<EqMatcher<Rhs>, Rhs, std::equal_to<>>(rhs) {}
static const char* Desc() { return "is equal to"; } static const char* Desc() { return "is equal to"; }
static const char* NegatedDesc() { return "isn't equal to"; } static const char* NegatedDesc() { return "isn't equal to"; }
}; };
template <typename Rhs> template <typename Rhs>
class NeMatcher : public ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe> { class NeMatcher
: public ComparisonBase<NeMatcher<Rhs>, Rhs, std::not_equal_to<>> {
public: public:
explicit NeMatcher(const Rhs& rhs) explicit NeMatcher(const Rhs& rhs)
: ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) {} : ComparisonBase<NeMatcher<Rhs>, Rhs, std::not_equal_to<>>(rhs) {}
static const char* Desc() { return "isn't equal to"; } static const char* Desc() { return "isn't equal to"; }
static const char* NegatedDesc() { return "is equal to"; } static const char* NegatedDesc() { return "is equal to"; }
}; };
template <typename Rhs> template <typename Rhs>
class LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt> { class LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, std::less<>> {
public: public:
explicit LtMatcher(const Rhs& rhs) explicit LtMatcher(const Rhs& rhs)
: ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) {} : ComparisonBase<LtMatcher<Rhs>, Rhs, std::less<>>(rhs) {}
static const char* Desc() { return "is <"; } static const char* Desc() { return "is <"; }
static const char* NegatedDesc() { return "isn't <"; } static const char* NegatedDesc() { return "isn't <"; }
}; };
template <typename Rhs> template <typename Rhs>
class GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt> { class GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, std::greater<>> {
public: public:
explicit GtMatcher(const Rhs& rhs) explicit GtMatcher(const Rhs& rhs)
: ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) {} : ComparisonBase<GtMatcher<Rhs>, Rhs, std::greater<>>(rhs) {}
static const char* Desc() { return "is >"; } static const char* Desc() { return "is >"; }
static const char* NegatedDesc() { return "isn't >"; } static const char* NegatedDesc() { return "isn't >"; }
}; };
template <typename Rhs> template <typename Rhs>
class LeMatcher : public ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe> { class LeMatcher
: public ComparisonBase<LeMatcher<Rhs>, Rhs, std::less_equal<>> {
public: public:
explicit LeMatcher(const Rhs& rhs) explicit LeMatcher(const Rhs& rhs)
: ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) {} : ComparisonBase<LeMatcher<Rhs>, Rhs, std::less_equal<>>(rhs) {}
static const char* Desc() { return "is <="; } static const char* Desc() { return "is <="; }
static const char* NegatedDesc() { return "isn't <="; } static const char* NegatedDesc() { return "isn't <="; }
}; };
template <typename Rhs> template <typename Rhs>
class GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> { class GeMatcher
: public ComparisonBase<GeMatcher<Rhs>, Rhs, std::greater_equal<>> {
public: public:
explicit GeMatcher(const Rhs& rhs) explicit GeMatcher(const Rhs& rhs)
: ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) {} : ComparisonBase<GeMatcher<Rhs>, Rhs, std::greater_equal<>>(rhs) {}
static const char* Desc() { return "is >="; } static const char* Desc() { return "is >="; }
static const char* NegatedDesc() { return "isn't >="; } static const char* NegatedDesc() { return "isn't >="; }
}; };

22
googletest/include/gtest/gtest-printers.h
View File

@ -206,12 +206,13 @@ struct StreamPrinter {
// Don't accept member pointers here. We'd print them via implicit // Don't accept member pointers here. We'd print them via implicit
// conversion to bool, which isn't useful. // conversion to bool, which isn't useful.
typename = typename std::enable_if< typename = typename std::enable_if<
!std::is_member_pointer<T>::value>::type, !std::is_member_pointer<T>::value>::type>
// Only accept types for which we can find a streaming operator via // Only accept types for which we can find a streaming operator via
// ADL (possibly involving implicit conversions). // ADL (possibly involving implicit conversions).
typename = decltype(std::declval<std::ostream&>() // (Use SFINAE via return type, because it seems GCC < 12 doesn't handle name
<< std::declval<const T&>())> // lookup properly when we do it in the template parameter list.)
static void PrintValue(const T& value, ::std::ostream* os) { static auto PrintValue(const T& value, ::std::ostream* os)
-> decltype((void)(*os << value)) {
// Call streaming operator found by ADL, possibly with implicit conversions // Call streaming operator found by ADL, possibly with implicit conversions
// of the arguments. // of the arguments.
*os << value; *os << value;
@ -306,9 +307,10 @@ template <typename T>
void PrintWithFallback(const T& value, ::std::ostream* os) { void PrintWithFallback(const T& value, ::std::ostream* os) {
using Printer = typename FindFirstPrinter< using Printer = typename FindFirstPrinter<
T, void, ContainerPrinter, FunctionPointerPrinter, PointerPrinter, T, void, ContainerPrinter, FunctionPointerPrinter, PointerPrinter,
ProtobufPrinter,
internal_stream_operator_without_lexical_name_lookup::StreamPrinter, internal_stream_operator_without_lexical_name_lookup::StreamPrinter,
ProtobufPrinter, ConvertibleToIntegerPrinter, ConvertibleToIntegerPrinter, ConvertibleToStringViewPrinter,
ConvertibleToStringViewPrinter, RawBytesPrinter, FallbackPrinter>::type; RawBytesPrinter, FallbackPrinter>::type;
Printer::PrintValue(value, os); Printer::PrintValue(value, os);
} }
@ -856,7 +858,7 @@ class UniversalPrinter<Variant<T...>> {
public: public:
static void Print(const Variant<T...>& value, ::std::ostream* os) { static void Print(const Variant<T...>& value, ::std::ostream* os) {
*os << '('; *os << '(';
#if GTEST_HAS_ABSL #ifdef GTEST_HAS_ABSL
absl::visit(Visitor{os, value.index()}, value); absl::visit(Visitor{os, value.index()}, value);
#else #else
std::visit(Visitor{os, value.index()}, value); std::visit(Visitor{os, value.index()}, value);
@ -1002,7 +1004,7 @@ template <>
class UniversalTersePrinter<char*> : public UniversalTersePrinter<const char*> { class UniversalTersePrinter<char*> : public UniversalTersePrinter<const char*> {
}; };
#ifdef __cpp_char8_t #ifdef __cpp_lib_char8_t
template <> template <>
class UniversalTersePrinter<const char8_t*> { class UniversalTersePrinter<const char8_t*> {
public: public:

4
googletest/include/gtest/gtest-test-part.h
View File

@ -133,7 +133,7 @@ std::ostream& operator<<(std::ostream& os, const TestPartResult& result);
// virtual. // virtual.
class GTEST_API_ TestPartResultArray { class GTEST_API_ TestPartResultArray {
public: public:
TestPartResultArray() {} TestPartResultArray() = default;
// Appends the given TestPartResult to the array. // Appends the given TestPartResult to the array.
void Append(const TestPartResult& result); void Append(const TestPartResult& result);
@ -154,7 +154,7 @@ class GTEST_API_ TestPartResultArray {
// This interface knows how to report a test part result. // This interface knows how to report a test part result.
class GTEST_API_ TestPartResultReporterInterface { class GTEST_API_ TestPartResultReporterInterface {
public: public:
virtual ~TestPartResultReporterInterface() {} virtual ~TestPartResultReporterInterface() = default;
virtual void ReportTestPartResult(const TestPartResult& result) = 0; virtual void ReportTestPartResult(const TestPartResult& result) = 0;
}; };

46
googletest/include/gtest/gtest.h
View File

@ -302,7 +302,7 @@ class GTEST_API_ Test {
template <typename T, std::enable_if_t<std::is_convertible<T, int64_t>::value, template <typename T, std::enable_if_t<std::is_convertible<T, int64_t>::value,
bool> = true> bool> = true>
static void RecordProperty(const std::string& key, const T& value) { static void RecordProperty(const std::string& key, const T& value) {
RecordProperty(key, (Message() << static_cast<int64_t>(value)).GetString()); RecordProperty(key, (Message() << value).GetString());
} }
protected: protected:
@ -551,14 +551,14 @@ class GTEST_API_ TestInfo {
// Returns the name of the parameter type, or NULL if this is not a typed // Returns the name of the parameter type, or NULL if this is not a typed
// or a type-parameterized test. // or a type-parameterized test.
const char* type_param() const { const char* type_param() const {
if (type_param_.get() != nullptr) return type_param_->c_str(); if (type_param_ != nullptr) return type_param_->c_str();
return nullptr; return nullptr;
} }
// Returns the text representation of the value parameter, or NULL if this // Returns the text representation of the value parameter, or NULL if this
// is not a value-parameterized test. // is not a value-parameterized test.
const char* value_param() const { const char* value_param() const {
if (value_param_.get() != nullptr) return value_param_->c_str(); if (value_param_ != nullptr) return value_param_->c_str();
return nullptr; return nullptr;
} }
@ -600,7 +600,7 @@ class GTEST_API_ TestInfo {
const TestResult* result() const { return &result_; } const TestResult* result() const { return &result_; }
private: private:
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
friend class internal::DefaultDeathTestFactory; friend class internal::DefaultDeathTestFactory;
#endif // GTEST_HAS_DEATH_TEST #endif // GTEST_HAS_DEATH_TEST
friend class Test; friend class Test;
@ -697,7 +697,7 @@ class GTEST_API_ TestSuite {
// Returns the name of the parameter type, or NULL if this is not a // Returns the name of the parameter type, or NULL if this is not a
// type-parameterized test suite. // type-parameterized test suite.
const char* type_param() const { const char* type_param() const {
if (type_param_.get() != nullptr) return type_param_->c_str(); if (type_param_ != nullptr) return type_param_->c_str();
return nullptr; return nullptr;
} }
@ -894,7 +894,7 @@ class GTEST_API_ TestSuite {
class Environment { class Environment {
public: public:
// The d'tor is virtual as we need to subclass Environment. // The d'tor is virtual as we need to subclass Environment.
virtual ~Environment() {} virtual ~Environment() = default;
// Override this to define how to set up the environment. // Override this to define how to set up the environment.
virtual void SetUp() {} virtual void SetUp() {}
@ -925,7 +925,7 @@ class GTEST_API_ AssertionException
// the order the corresponding events are fired. // the order the corresponding events are fired.
class TestEventListener { class TestEventListener {
public: public:
virtual ~TestEventListener() {} virtual ~TestEventListener() = default;
// Fired before any test activity starts. // Fired before any test activity starts.
virtual void OnTestProgramStart(const UnitTest& unit_test) = 0; virtual void OnTestProgramStart(const UnitTest& unit_test) = 0;
@ -1671,7 +1671,7 @@ template <typename T>
class WithParamInterface { class WithParamInterface {
public: public:
typedef T ParamType; typedef T ParamType;
virtual ~WithParamInterface() {} virtual ~WithParamInterface() = default;
// The current parameter value. Is also available in the test fixture's // The current parameter value. Is also available in the test fixture's
// constructor. // constructor.
@ -1747,7 +1747,7 @@ class TestWithParam : public Test, public WithParamInterface<T> {};
// Define this macro to 1 to omit the definition of FAIL(), which is a // Define this macro to 1 to omit the definition of FAIL(), which is a
// generic name and clashes with some other libraries. // generic name and clashes with some other libraries.
#if !GTEST_DONT_DEFINE_FAIL #if !(defined(GTEST_DONT_DEFINE_FAIL) && GTEST_DONT_DEFINE_FAIL)
#define FAIL() GTEST_FAIL() #define FAIL() GTEST_FAIL()
#endif #endif
@ -1756,7 +1756,7 @@ class TestWithParam : public Test, public WithParamInterface<T> {};
// Define this macro to 1 to omit the definition of SUCCEED(), which // Define this macro to 1 to omit the definition of SUCCEED(), which
// is a generic name and clashes with some other libraries. // is a generic name and clashes with some other libraries.
#if !GTEST_DONT_DEFINE_SUCCEED #if !(defined(GTEST_DONT_DEFINE_SUCCEED) && GTEST_DONT_DEFINE_SUCCEED)
#define SUCCEED() GTEST_SUCCEED() #define SUCCEED() GTEST_SUCCEED()
#endif #endif
@ -1800,19 +1800,19 @@ class TestWithParam : public Test, public WithParamInterface<T> {};
// Define these macros to 1 to omit the definition of the corresponding // Define these macros to 1 to omit the definition of the corresponding
// EXPECT or ASSERT, which clashes with some users' own code. // EXPECT or ASSERT, which clashes with some users' own code.
#if !GTEST_DONT_DEFINE_EXPECT_TRUE #if !(defined(GTEST_DONT_DEFINE_EXPECT_TRUE) && GTEST_DONT_DEFINE_EXPECT_TRUE)
#define EXPECT_TRUE(condition) GTEST_EXPECT_TRUE(condition) #define EXPECT_TRUE(condition) GTEST_EXPECT_TRUE(condition)
#endif #endif
#if !GTEST_DONT_DEFINE_EXPECT_FALSE #if !(defined(GTEST_DONT_DEFINE_EXPECT_FALSE) && GTEST_DONT_DEFINE_EXPECT_FALSE)
#define EXPECT_FALSE(condition) GTEST_EXPECT_FALSE(condition) #define EXPECT_FALSE(condition) GTEST_EXPECT_FALSE(condition)
#endif #endif
#if !GTEST_DONT_DEFINE_ASSERT_TRUE #if !(defined(GTEST_DONT_DEFINE_ASSERT_TRUE) && GTEST_DONT_DEFINE_ASSERT_TRUE)
#define ASSERT_TRUE(condition) GTEST_ASSERT_TRUE(condition) #define ASSERT_TRUE(condition) GTEST_ASSERT_TRUE(condition)
#endif #endif
#if !GTEST_DONT_DEFINE_ASSERT_FALSE #if !(defined(GTEST_DONT_DEFINE_ASSERT_FALSE) && GTEST_DONT_DEFINE_ASSERT_FALSE)
#define ASSERT_FALSE(condition) GTEST_ASSERT_FALSE(condition) #define ASSERT_FALSE(condition) GTEST_ASSERT_FALSE(condition)
#endif #endif
@ -1891,27 +1891,27 @@ class TestWithParam : public Test, public WithParamInterface<T> {};
// Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of // Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of
// ASSERT_XY(), which clashes with some users' own code. // ASSERT_XY(), which clashes with some users' own code.
#if !GTEST_DONT_DEFINE_ASSERT_EQ #if !(defined(GTEST_DONT_DEFINE_ASSERT_EQ) && GTEST_DONT_DEFINE_ASSERT_EQ)
#define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2) #define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
#endif #endif
#if !GTEST_DONT_DEFINE_ASSERT_NE #if !(defined(GTEST_DONT_DEFINE_ASSERT_NE) && GTEST_DONT_DEFINE_ASSERT_NE)
#define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2) #define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
#endif #endif
#if !GTEST_DONT_DEFINE_ASSERT_LE #if !(defined(GTEST_DONT_DEFINE_ASSERT_LE) && GTEST_DONT_DEFINE_ASSERT_LE)
#define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2) #define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
#endif #endif
#if !GTEST_DONT_DEFINE_ASSERT_LT #if !(defined(GTEST_DONT_DEFINE_ASSERT_LT) && GTEST_DONT_DEFINE_ASSERT_LT)
#define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2) #define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
#endif #endif
#if !GTEST_DONT_DEFINE_ASSERT_GE #if !(defined(GTEST_DONT_DEFINE_ASSERT_GE) && GTEST_DONT_DEFINE_ASSERT_GE)
#define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2) #define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
#endif #endif
#if !GTEST_DONT_DEFINE_ASSERT_GT #if !(defined(GTEST_DONT_DEFINE_ASSERT_GT) && GTEST_DONT_DEFINE_ASSERT_GT)
#define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2) #define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
#endif #endif
@ -1999,7 +1999,7 @@ GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2,
GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2, GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
double val1, double val2); double val1, double val2);
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
// Macros that test for HRESULT failure and success, these are only useful // Macros that test for HRESULT failure and success, these are only useful
// on Windows, and rely on Windows SDK macros and APIs to compile. // on Windows, and rely on Windows SDK macros and APIs to compile.
@ -2169,7 +2169,7 @@ constexpr bool StaticAssertTypeEq() noexcept {
// Define this macro to 1 to omit the definition of TEST(), which // Define this macro to 1 to omit the definition of TEST(), which
// is a generic name and clashes with some other libraries. // is a generic name and clashes with some other libraries.
#if !GTEST_DONT_DEFINE_TEST #if !(defined(GTEST_DONT_DEFINE_TEST) && GTEST_DONT_DEFINE_TEST)
#define TEST(test_suite_name, test_name) GTEST_TEST(test_suite_name, test_name) #define TEST(test_suite_name, test_name) GTEST_TEST(test_suite_name, test_name)
#endif #endif
@ -2201,7 +2201,7 @@ constexpr bool StaticAssertTypeEq() noexcept {
#define GTEST_TEST_F(test_fixture, test_name) \ #define GTEST_TEST_F(test_fixture, test_name) \
GTEST_TEST_(test_fixture, test_name, test_fixture, \ GTEST_TEST_(test_fixture, test_name, test_fixture, \
::testing::internal::GetTypeId<test_fixture>()) ::testing::internal::GetTypeId<test_fixture>())
#if !GTEST_DONT_DEFINE_TEST_F #if !(defined(GTEST_DONT_DEFINE_TEST_F) && GTEST_DONT_DEFINE_TEST_F)
#define TEST_F(test_fixture, test_name) GTEST_TEST_F(test_fixture, test_name) #define TEST_F(test_fixture, test_name) GTEST_TEST_F(test_fixture, test_name)
#endif #endif

8
googletest/include/gtest/internal/gtest-death-test-internal.h
View File

@ -57,7 +57,7 @@ const char kDeathTestStyleFlag[] = "death_test_style";
const char kDeathTestUseFork[] = "death_test_use_fork"; const char kDeathTestUseFork[] = "death_test_use_fork";
const char kInternalRunDeathTestFlag[] = "internal_run_death_test"; const char kInternalRunDeathTestFlag[] = "internal_run_death_test";
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
/* class A needs to have dll-interface to be used by clients of class B */) /* class A needs to have dll-interface to be used by clients of class B */)
@ -88,7 +88,7 @@ class GTEST_API_ DeathTest {
static bool Create(const char* statement, Matcher<const std::string&> matcher, static bool Create(const char* statement, Matcher<const std::string&> matcher,
const char* file, int line, DeathTest** test); const char* file, int line, DeathTest** test);
DeathTest(); DeathTest();
virtual ~DeathTest() {} virtual ~DeathTest() = default;
// A helper class that aborts a death test when it's deleted. // A helper class that aborts a death test when it's deleted.
class ReturnSentinel { class ReturnSentinel {
@ -153,7 +153,7 @@ GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
// Factory interface for death tests. May be mocked out for testing. // Factory interface for death tests. May be mocked out for testing.
class DeathTestFactory { class DeathTestFactory {
public: public:
virtual ~DeathTestFactory() {} virtual ~DeathTestFactory() = default;
virtual bool Create(const char* statement, virtual bool Create(const char* statement,
Matcher<const std::string&> matcher, const char* file, Matcher<const std::string&> matcher, const char* file,
int line, DeathTest** test) = 0; int line, DeathTest** test) = 0;
@ -238,7 +238,7 @@ inline Matcher<const ::std::string&> MakeDeathTestMatcher(
} \ } \
break; \ break; \
case ::testing::internal::DeathTest::EXECUTE_TEST: { \ case ::testing::internal::DeathTest::EXECUTE_TEST: { \
::testing::internal::DeathTest::ReturnSentinel gtest_sentinel( \ const ::testing::internal::DeathTest::ReturnSentinel gtest_sentinel( \
gtest_dt); \ gtest_dt); \
GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt); \ GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt); \
gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE); \ gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE); \

8
googletest/include/gtest/internal/gtest-internal.h
View File

@ -41,7 +41,7 @@
#include "gtest/internal/gtest-port.h" #include "gtest/internal/gtest-port.h"
#if GTEST_OS_LINUX #ifdef GTEST_OS_LINUX
#include <stdlib.h> #include <stdlib.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/wait.h> #include <sys/wait.h>
@ -435,7 +435,7 @@ GTEST_API_ TypeId GetTestTypeId();
// of a Test object. // of a Test object.
class TestFactoryBase { class TestFactoryBase {
public: public:
virtual ~TestFactoryBase() {} virtual ~TestFactoryBase() = default;
// Creates a test instance to run. The instance is both created and destroyed // Creates a test instance to run. The instance is both created and destroyed
// within TestInfoImpl::Run() // within TestInfoImpl::Run()
@ -457,7 +457,7 @@ class TestFactoryImpl : public TestFactoryBase {
Test* CreateTest() override { return new TestClass; } Test* CreateTest() override { return new TestClass; }
}; };
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
// Predicate-formatters for implementing the HRESULT checking macros // Predicate-formatters for implementing the HRESULT checking macros
// {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED} // {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}
@ -900,8 +900,10 @@ class HasDebugStringAndShortDebugString {
HasDebugStringType::value && HasShortDebugStringType::value; HasDebugStringType::value && HasShortDebugStringType::value;
}; };
#ifdef GTEST_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
template <typename T> template <typename T>
constexpr bool HasDebugStringAndShortDebugString<T>::value; constexpr bool HasDebugStringAndShortDebugString<T>::value;
#endif
// When the compiler sees expression IsContainerTest<C>(0), if C is an // When the compiler sees expression IsContainerTest<C>(0), if C is an
// STL-style container class, the first overload of IsContainerTest // STL-style container class, the first overload of IsContainerTest

26
googletest/include/gtest/internal/gtest-param-util.h
View File

@ -97,7 +97,7 @@ class ParamGenerator;
template <typename T> template <typename T>
class ParamIteratorInterface { class ParamIteratorInterface {
public: public:
virtual ~ParamIteratorInterface() {} virtual ~ParamIteratorInterface() = default;
// A pointer to the base generator instance. // A pointer to the base generator instance.
// Used only for the purposes of iterator comparison // Used only for the purposes of iterator comparison
// to make sure that two iterators belong to the same generator. // to make sure that two iterators belong to the same generator.
@ -171,7 +171,7 @@ class ParamGeneratorInterface {
public: public:
typedef T ParamType; typedef T ParamType;
virtual ~ParamGeneratorInterface() {} virtual ~ParamGeneratorInterface() = default;
// Generator interface definition // Generator interface definition
virtual ParamIteratorInterface<T>* Begin() const = 0; virtual ParamIteratorInterface<T>* Begin() const = 0;
@ -215,7 +215,7 @@ class RangeGenerator : public ParamGeneratorInterface<T> {
end_(end), end_(end),
step_(step), step_(step),
end_index_(CalculateEndIndex(begin, end, step)) {} end_index_(CalculateEndIndex(begin, end, step)) {}
~RangeGenerator() override {} ~RangeGenerator() override = default;
ParamIteratorInterface<T>* Begin() const override { ParamIteratorInterface<T>* Begin() const override {
return new Iterator(this, begin_, 0, step_); return new Iterator(this, begin_, 0, step_);
@ -230,7 +230,7 @@ class RangeGenerator : public ParamGeneratorInterface<T> {
Iterator(const ParamGeneratorInterface<T>* base, T value, int index, Iterator(const ParamGeneratorInterface<T>* base, T value, int index,
IncrementT step) IncrementT step)
: base_(base), value_(value), index_(index), step_(step) {} : base_(base), value_(value), index_(index), step_(step) {}
~Iterator() override {} ~Iterator() override = default;
const ParamGeneratorInterface<T>* BaseGenerator() const override { const ParamGeneratorInterface<T>* BaseGenerator() const override {
return base_; return base_;
@ -299,7 +299,7 @@ class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
template <typename ForwardIterator> template <typename ForwardIterator>
ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end) ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
: container_(begin, end) {} : container_(begin, end) {}
~ValuesInIteratorRangeGenerator() override {} ~ValuesInIteratorRangeGenerator() override = default;
ParamIteratorInterface<T>* Begin() const override { ParamIteratorInterface<T>* Begin() const override {
return new Iterator(this, container_.begin()); return new Iterator(this, container_.begin());
@ -316,7 +316,7 @@ class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
Iterator(const ParamGeneratorInterface<T>* base, Iterator(const ParamGeneratorInterface<T>* base,
typename ContainerType::const_iterator iterator) typename ContainerType::const_iterator iterator)
: base_(base), iterator_(iterator) {} : base_(base), iterator_(iterator) {}
~Iterator() override {} ~Iterator() override = default;
const ParamGeneratorInterface<T>* BaseGenerator() const override { const ParamGeneratorInterface<T>* BaseGenerator() const override {
return base_; return base_;
@ -420,7 +420,7 @@ class ParameterizedTestFactory : public TestFactoryBase {
template <class ParamType> template <class ParamType>
class TestMetaFactoryBase { class TestMetaFactoryBase {
public: public:
virtual ~TestMetaFactoryBase() {} virtual ~TestMetaFactoryBase() = default;
virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0; virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0;
}; };
@ -439,7 +439,7 @@ class TestMetaFactory
public: public:
using ParamType = typename TestSuite::ParamType; using ParamType = typename TestSuite::ParamType;
TestMetaFactory() {} TestMetaFactory() = default;
TestFactoryBase* CreateTestFactory(ParamType parameter) override { TestFactoryBase* CreateTestFactory(ParamType parameter) override {
return new ParameterizedTestFactory<TestSuite>(parameter); return new ParameterizedTestFactory<TestSuite>(parameter);
@ -462,7 +462,7 @@ class TestMetaFactory
// and calls RegisterTests() on each of them when asked. // and calls RegisterTests() on each of them when asked.
class ParameterizedTestSuiteInfoBase { class ParameterizedTestSuiteInfoBase {
public: public:
virtual ~ParameterizedTestSuiteInfoBase() {} virtual ~ParameterizedTestSuiteInfoBase() = default;
// Base part of test suite name for display purposes. // Base part of test suite name for display purposes.
virtual const std::string& GetTestSuiteName() const = 0; virtual const std::string& GetTestSuiteName() const = 0;
@ -691,7 +691,7 @@ using ParameterizedTestCaseInfo = ParameterizedTestSuiteInfo<TestCase>;
// ParameterizedTestSuiteInfo descriptors. // ParameterizedTestSuiteInfo descriptors.
class ParameterizedTestSuiteRegistry { class ParameterizedTestSuiteRegistry {
public: public:
ParameterizedTestSuiteRegistry() {} ParameterizedTestSuiteRegistry() = default;
~ParameterizedTestSuiteRegistry() { ~ParameterizedTestSuiteRegistry() {
for (auto& test_suite_info : test_suite_infos_) { for (auto& test_suite_info : test_suite_infos_) {
delete test_suite_info; delete test_suite_info;
@ -825,7 +825,7 @@ class CartesianProductGenerator
CartesianProductGenerator(const std::tuple<ParamGenerator<T>...>& g) CartesianProductGenerator(const std::tuple<ParamGenerator<T>...>& g)
: generators_(g) {} : generators_(g) {}
~CartesianProductGenerator() override {} ~CartesianProductGenerator() override = default;
ParamIteratorInterface<ParamType>* Begin() const override { ParamIteratorInterface<ParamType>* Begin() const override {
return new Iterator(this, generators_, false); return new Iterator(this, generators_, false);
@ -850,7 +850,7 @@ class CartesianProductGenerator
current_(is_end ? end_ : begin_) { current_(is_end ? end_ : begin_) {
ComputeCurrentValue(); ComputeCurrentValue();
} }
~IteratorImpl() override {} ~IteratorImpl() override = default;
const ParamGeneratorInterface<ParamType>* BaseGenerator() const override { const ParamGeneratorInterface<ParamType>* BaseGenerator() const override {
return base_; return base_;
@ -969,7 +969,7 @@ class ParamGeneratorConverter : public ParamGeneratorInterface<To> {
: base_(base), it_(it), end_(end) { : base_(base), it_(it), end_(end) {
if (it_ != end_) value_ = std::make_shared<To>(static_cast<To>(*it_)); if (it_ != end_) value_ = std::make_shared<To>(static_cast<To>(*it_));
} }
~Iterator() override {} ~Iterator() override = default;
const ParamGeneratorInterface<To>* BaseGenerator() const override { const ParamGeneratorInterface<To>* BaseGenerator() const override {
return base_; return base_;

295
googletest/include/gtest/internal/gtest-port.h
View File

@ -161,10 +161,10 @@
// NOT define them. // NOT define them.
// //
// These macros are public so that portable tests can be written. // These macros are public so that portable tests can be written.
// Such tests typically surround code using a feature with an #if // Such tests typically surround code using a feature with an #ifdef
// which controls that code. For example: // which controls that code. For example:
// //
// #if GTEST_HAS_DEATH_TEST // #ifdef GTEST_HAS_DEATH_TEST
// EXPECT_DEATH(DoSomethingDeadly()); // EXPECT_DEATH(DoSomethingDeadly());
// #endif // #endif
// //
@ -178,6 +178,7 @@
// 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.
// GTEST_HAS_ABSL - Google Test is compiled with Abseil.
// Misc public macros // Misc public macros
// ------------------ // ------------------
@ -202,16 +203,25 @@
// 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.
// Always defined to 0 or 1.
// 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>
// specializations. // specializations. Always defined to 0 or 1.
// GTEST_INTERNAL_HAS_STRING_VIEW - for enabling Matcher<std::string_view> or // GTEST_INTERNAL_HAS_STRING_VIEW - for enabling Matcher<std::string_view> or
// Matcher<absl::string_view> // Matcher<absl::string_view>
// specializations. // specializations. Always defined to 0 or 1.
// 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. Always defined to 0 or 1.
// GTEST_USE_OWN_FLAGFILE_FLAG_ - Always defined to 0 or 1.
// GTEST_HAS_CXXABI_H_ - Always defined to 0 or 1.
// GTEST_CAN_STREAM_RESULTS_ - Always defined to 0 or 1.
// GTEST_HAS_ALT_PATH_SEP_ - Always defined to 0 or 1.
// GTEST_WIDE_STRING_USES_UTF16_ - Always defined to 0 or 1.
// GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ - Always defined to 0 or 1.
// GTEST_HAS_DOWNCAST_ - Always defined to 0 or 1.
// GTEST_HAS_NOTIFICATION_- Always defined to 0 or 1.
// //
// Synchronization: // Synchronization:
// Mutex, MutexLock, ThreadLocal, GetThreadCount() // Mutex, MutexLock, ThreadLocal, GetThreadCount()
@ -303,7 +313,19 @@
#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 #ifndef GTEST_HAS_DOWNCAST_
#define GTEST_HAS_DOWNCAST_ 0
#endif
#ifndef GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
#define GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ 0
#endif
#ifndef GTEST_HAS_NOTIFICATION_
#define GTEST_HAS_NOTIFICATION_ 0
#endif
#ifdef GTEST_HAS_ABSL
#include "absl/flags/declare.h" #include "absl/flags/declare.h"
#include "absl/flags/flag.h" #include "absl/flags/flag.h"
#include "absl/flags/reflection.h" #include "absl/flags/reflection.h"
@ -361,13 +383,13 @@
// 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 #ifdef GTEST_OS_WINDOWS
#if !GTEST_OS_WINDOWS_MOBILE #ifndef 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 defined(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;
@ -377,7 +399,7 @@ typedef struct _CRITICAL_SECTION GTEST_CRITICAL_SECTION;
// 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 defined(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.
@ -389,7 +411,7 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
#include <unistd.h> #include <unistd.h>
#endif // GTEST_OS_WINDOWS #endif // GTEST_OS_WINDOWS
#if GTEST_OS_LINUX_ANDROID #ifdef 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
@ -397,17 +419,21 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
// 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 #ifdef 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 \ #if !(defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_XTENSA) || \
!(GTEST_OS_WINDOWS || GTEST_OS_XTENSA || GTEST_OS_QURT) defined(GTEST_OS_QURT))
#define GTEST_HAS_POSIX_RE 1
#else
#define GTEST_HAS_POSIX_RE 0
#endif #endif
#endif // GTEST_OS_LINUX_ANDROID
#endif #endif
// Select the regular expression implementation. // Select the regular expression implementation.
#if GTEST_HAS_ABSL #ifdef GTEST_HAS_ABSL
// When using Abseil, RE2 is required. // When using Abseil, RE2 is required.
#include "absl/strings/string_view.h" #include "absl/strings/string_view.h"
#include "re2/re2.h" #include "re2/re2.h"
@ -443,8 +469,12 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
// 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)) #if defined(__EXCEPTIONS) && __EXCEPTIONS && __has_feature(cxx_exceptions)
#elif defined(__GNUC__) && __EXCEPTIONS #define GTEST_HAS_EXCEPTIONS 1
#else
#define GTEST_HAS_EXCEPTIONS 0
#endif
#elif defined(__GNUC__) && defined(__EXCEPTIONS) && __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)
@ -452,7 +482,7 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
// 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__) && defined(__EXCEPTIONS) && __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)
@ -472,11 +502,14 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
// 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 \ #if (!(defined(GTEST_OS_LINUX_ANDROID) || defined(GTEST_OS_CYGWIN) || \
(!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ defined(GTEST_OS_SOLARIS) || defined(GTEST_OS_HAIKU) || \
GTEST_OS_HAIKU || GTEST_OS_ESP32 || GTEST_OS_ESP8266 || \ defined(GTEST_OS_ESP32) || defined(GTEST_OS_ESP8266) || \
GTEST_OS_XTENSA || GTEST_OS_QURT)) defined(GTEST_OS_XTENSA) || defined(GTEST_OS_QURT)))
#define GTEST_HAS_STD_WSTRING 1
#else
#define GTEST_HAS_STD_WSTRING 0
#endif
#endif // GTEST_HAS_STD_WSTRING #endif // GTEST_HAS_STD_WSTRING
#ifndef GTEST_HAS_FILE_SYSTEM #ifndef GTEST_HAS_FILE_SYSTEM
@ -506,7 +539,8 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
// -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) && !defined(__EXCEPTIONS) #if defined(GTEST_OS_LINUX_ANDROID) && defined(_STLPORT_MAJOR) && \
!defined(__EXCEPTIONS)
#define GTEST_HAS_RTTI 0 #define GTEST_HAS_RTTI 0
#else #else
#define GTEST_HAS_RTTI 1 #define GTEST_HAS_RTTI 1
@ -554,11 +588,17 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
// //
// 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 \ #if (defined(GTEST_OS_LINUX) || defined(GTEST_OS_MAC) || \
(GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX || \ defined(GTEST_OS_HPUX) || defined(GTEST_OS_QNX) || \
GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \ defined(GTEST_OS_FREEBSD) || defined(GTEST_OS_NACL) || \
GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_OPENBSD || \ defined(GTEST_OS_NETBSD) || defined(GTEST_OS_FUCHSIA) || \
GTEST_OS_HAIKU || GTEST_OS_GNU_HURD) defined(GTEST_OS_DRAGONFLY) || defined(GTEST_OS_GNU_KFREEBSD) || \
defined(GTEST_OS_OPENBSD) || defined(GTEST_OS_HAIKU) || \
defined(GTEST_OS_GNU_HURD))
#define GTEST_HAS_PTHREAD 1
#else
#define GTEST_HAS_PTHREAD 0
#endif
#endif // GTEST_HAS_PTHREAD #endif // GTEST_HAS_PTHREAD
#if GTEST_HAS_PTHREAD #if GTEST_HAS_PTHREAD
@ -577,8 +617,8 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
#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 defined(GTEST_OS_LINUX) && !defined(__ia64__)
#if GTEST_OS_LINUX_ANDROID #if defined(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__) || (defined(__arm__) && __ANDROID_API__ >= 9) || \ #if defined(__LP64__) || (defined(__arm__) && __ANDROID_API__ >= 9) || \
@ -603,9 +643,10 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
// 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 / embedded ones. Also, if the port doesn't have // platforms except known mobile / embedded ones. Also, if the port doesn't have
// a file system, stream redirection is not supported. // a file system, stream redirection is not supported.
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \ #if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_WINDOWS_PHONE) || \
GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA || \ defined(GTEST_OS_WINDOWS_RT) || defined(GTEST_OS_ESP8266) || \
GTEST_OS_QURT || !GTEST_HAS_FILE_SYSTEM defined(GTEST_OS_XTENSA) || defined(GTEST_OS_QURT) || \
!GTEST_HAS_FILE_SYSTEM
#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
@ -614,13 +655,16 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
// 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 (defined(GTEST_OS_LINUX) || defined(GTEST_OS_CYGWIN) || \
(GTEST_OS_MAC && !GTEST_OS_IOS) || \ defined(GTEST_OS_SOLARIS) || \
(GTEST_OS_WINDOWS_DESKTOP && _MSC_VER) || GTEST_OS_WINDOWS_MINGW || \ (defined(GTEST_OS_MAC) && !defined(GTEST_OS_IOS)) || \
GTEST_OS_AIX || GTEST_OS_HPUX || GTEST_OS_OPENBSD || GTEST_OS_QNX || \ (defined(GTEST_OS_WINDOWS_DESKTOP) && _MSC_VER) || \
GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \ defined(GTEST_OS_WINDOWS_MINGW) || defined(GTEST_OS_AIX) || \
GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_HAIKU || \ defined(GTEST_OS_HPUX) || defined(GTEST_OS_OPENBSD) || \
GTEST_OS_GNU_HURD) defined(GTEST_OS_QNX) || defined(GTEST_OS_FREEBSD) || \
defined(GTEST_OS_NETBSD) || defined(GTEST_OS_FUCHSIA) || \
defined(GTEST_OS_DRAGONFLY) || defined(GTEST_OS_GNU_KFREEBSD) || \
defined(GTEST_OS_HAIKU) || defined(GTEST_OS_GNU_HURD))
// Death tests require a file system to work properly. // Death tests require a file system to work properly.
#if GTEST_HAS_FILE_SYSTEM #if GTEST_HAS_FILE_SYSTEM
#define GTEST_HAS_DEATH_TEST 1 #define GTEST_HAS_DEATH_TEST 1
@ -638,14 +682,21 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
#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_ \ #if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_CYGWIN) || \
(GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_AIX || GTEST_OS_OS2) defined(GTEST_OS_AIX) || defined(GTEST_OS_OS2)
#define GTEST_WIDE_STRING_USES_UTF16_ 1
#else
#define GTEST_WIDE_STRING_USES_UTF16_ 0
#endif
// 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 defined(GTEST_OS_LINUX) || defined(GTEST_OS_GNU_KFREEBSD) || \
GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_OPENBSD || \ defined(GTEST_OS_DRAGONFLY) || defined(GTEST_OS_FREEBSD) || \
GTEST_OS_GNU_HURD defined(GTEST_OS_NETBSD) || defined(GTEST_OS_OPENBSD) || \
defined(GTEST_OS_GNU_HURD) || defined(GTEST_OS_MAC)
#define GTEST_CAN_STREAM_RESULTS_ 1 #define GTEST_CAN_STREAM_RESULTS_ 1
#else
#define GTEST_CAN_STREAM_RESULTS_ 0
#endif #endif
// Defines some utility macros. // Defines some utility macros.
@ -759,14 +810,16 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
#ifndef GTEST_IS_THREADSAFE #ifndef GTEST_IS_THREADSAFE
#define GTEST_IS_THREADSAFE \ #if (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ || \
(GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ || \ (defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_PHONE) && \
(GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) || \ !defined(GTEST_OS_WINDOWS_RT)) || \
GTEST_HAS_PTHREAD) GTEST_HAS_PTHREAD)
#define GTEST_IS_THREADSAFE 1
#endif
#endif // GTEST_IS_THREADSAFE #endif // GTEST_IS_THREADSAFE
#if GTEST_IS_THREADSAFE #ifdef GTEST_IS_THREADSAFE
// Some platforms don't support including these threading related headers. // Some platforms don't support including these threading related headers.
#include <condition_variable> // NOLINT #include <condition_variable> // NOLINT
#include <mutex> // NOLINT #include <mutex> // NOLINT
@ -808,7 +861,7 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
// Ask the compiler not to perform tail call optimization inside // Ask the compiler not to perform tail call optimization inside
// the marked function. // the marked function.
#define GTEST_NO_TAIL_CALL_ __attribute__((disable_tail_calls)) #define GTEST_NO_TAIL_CALL_ __attribute__((disable_tail_calls))
#elif __GNUC__ #elif defined(__GNUC__) && !defined(__NVCOMPILER)
#define GTEST_NO_TAIL_CALL_ \ #define GTEST_NO_TAIL_CALL_ \
__attribute__((optimize("no-optimize-sibling-calls"))) __attribute__((optimize("no-optimize-sibling-calls")))
#else #else
@ -881,7 +934,7 @@ GTEST_API_ bool IsTrue(bool condition);
// Defines RE. // Defines RE.
#if GTEST_USES_RE2 #ifdef GTEST_USES_RE2
// This is almost `using RE = ::RE2`, except it is copy-constructible, and it // This is almost `using RE = ::RE2`, except it is copy-constructible, and it
// needs to disambiguate the `std::string`, `absl::string_view`, and `const // needs to disambiguate the `std::string`, `absl::string_view`, and `const
@ -906,7 +959,9 @@ class GTEST_API_ RE {
RE2 regex_; RE2 regex_;
}; };
#elif GTEST_USES_POSIX_RE || GTEST_USES_SIMPLE_RE #elif defined(GTEST_USES_POSIX_RE) || defined(GTEST_USES_SIMPLE_RE)
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
/* class A needs to have dll-interface to be used by clients of class B */)
// 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.
@ -923,7 +978,7 @@ class GTEST_API_ RE {
~RE(); ~RE();
// Returns the string representation of the regex. // Returns the string representation of the regex.
const char* pattern() const { return pattern_; } const char* pattern() const { return pattern_.c_str(); }
// FullMatch(str, re) returns true if and only if regular expression re // FullMatch(str, re) returns true if and only if regular expression re
// matches the entire str. // matches the entire str.
@ -941,21 +996,21 @@ class GTEST_API_ RE {
private: private:
void Init(const char* regex); void Init(const char* regex);
const char* pattern_; std::string pattern_;
bool is_valid_; bool is_valid_;
#if GTEST_USES_POSIX_RE #ifdef 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(); std::string full_pattern_; // For FullMatch();
#endif #endif
}; };
GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
#endif // ::testing::internal::RE implementation #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
@ -1172,7 +1227,7 @@ GTEST_API_ std::string ReadEntireFile(FILE* file);
// All command line arguments. // All command line arguments.
GTEST_API_ std::vector<std::string> GetArgvs(); GTEST_API_ std::vector<std::string> GetArgvs();
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
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.
@ -1183,9 +1238,9 @@ void ClearInjectableArgvs();
#endif // GTEST_HAS_DEATH_TEST #endif // GTEST_HAS_DEATH_TEST
// Defines synchronization primitives. // Defines synchronization primitives.
#if GTEST_IS_THREADSAFE #ifdef GTEST_IS_THREADSAFE
#if GTEST_OS_WINDOWS #ifdef 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 {
@ -1264,7 +1319,7 @@ GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
// 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 && !defined(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
@ -1273,7 +1328,7 @@ GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
// problem. // problem.
class ThreadWithParamBase { class ThreadWithParamBase {
public: public:
virtual ~ThreadWithParamBase() {} virtual ~ThreadWithParamBase() = default;
virtual void Run() = 0; virtual void Run() = 0;
}; };
@ -1350,7 +1405,8 @@ class ThreadWithParam : public ThreadWithParamBase {
// 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 defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_PHONE) && \
!defined(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:
@ -1734,7 +1790,7 @@ typedef GTestMutexLock MutexLock;
// ThreadLocalValueHolderBase. // ThreadLocalValueHolderBase.
class GTEST_API_ ThreadLocalValueHolderBase { class GTEST_API_ ThreadLocalValueHolderBase {
public: public:
virtual ~ThreadLocalValueHolderBase() {} virtual ~ThreadLocalValueHolderBase() = default;
}; };
// Called by pthread to delete thread-local data stored by // Called by pthread to delete thread-local data stored by
@ -1806,8 +1862,8 @@ class GTEST_API_ ThreadLocal {
class ValueHolderFactory { class ValueHolderFactory {
public: public:
ValueHolderFactory() {} ValueHolderFactory() = default;
virtual ~ValueHolderFactory() {} virtual ~ValueHolderFactory() = default;
virtual ValueHolder* MakeNewHolder() const = 0; virtual ValueHolder* MakeNewHolder() const = 0;
private: private:
@ -1817,7 +1873,7 @@ class GTEST_API_ ThreadLocal {
class DefaultValueHolderFactory : public ValueHolderFactory { class DefaultValueHolderFactory : public ValueHolderFactory {
public: public:
DefaultValueHolderFactory() {} DefaultValueHolderFactory() = default;
ValueHolder* MakeNewHolder() const override { return new ValueHolder(); } ValueHolder* MakeNewHolder() const override { return new ValueHolder(); }
private: private:
@ -1903,7 +1959,7 @@ class GTEST_API_ ThreadLocal {
// we cannot detect it. // we cannot detect it.
GTEST_API_ size_t GetThreadCount(); GTEST_API_ size_t GetThreadCount();
#if GTEST_OS_WINDOWS #ifdef 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
@ -1980,11 +2036,11 @@ namespace posix {
// File system porting. // File system porting.
#if GTEST_HAS_FILE_SYSTEM #if GTEST_HAS_FILE_SYSTEM
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
typedef struct _stat StatStruct; typedef struct _stat StatStruct;
#if GTEST_OS_WINDOWS_MOBILE #ifdef 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.
@ -1995,7 +2051,7 @@ inline int RmDir(const char* dir) { return _rmdir(dir); }
inline bool IsDir(const StatStruct& st) { return (_S_IFDIR & st.st_mode) != 0; } inline bool IsDir(const StatStruct& st) { return (_S_IFDIR & st.st_mode) != 0; }
#endif // GTEST_OS_WINDOWS_MOBILE #endif // GTEST_OS_WINDOWS_MOBILE
#elif GTEST_OS_ESP8266 #elif defined(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); }
@ -2012,7 +2068,7 @@ typedef struct stat StatStruct;
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); }
#if GTEST_OS_QURT #ifdef GTEST_OS_QURT
// QuRT doesn't support any directory functions, including rmdir // QuRT doesn't support any directory functions, including rmdir
inline int RmDir(const char*) { return 0; } inline int RmDir(const char*) { return 0; }
#else #else
@ -2025,17 +2081,17 @@ inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
// Other functions with a different name on Windows. // Other functions with a different name on Windows.
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
#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); }
#else // !__BORLANDC__ #else // !__BORLANDC__
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \ #if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_ZOS) || \
GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || defined(ESP_PLATFORM) defined(GTEST_OS_IOS) || defined(GTEST_OS_WINDOWS_PHONE) || \
defined(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); }
@ -2043,24 +2099,14 @@ 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); }
#endif // __BORLANDC__ #endif // __BORLANDC__
#elif GTEST_OS_ESP8266
inline int DoIsATTY(int fd) { return isatty(fd); }
inline int StrCaseCmp(const char* s1, const char* s2) {
return strcasecmp(s1, s2);
}
inline char* StrDup(const char* src) { return strdup(src); }
#else #else
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 strcasecmp(s1, s2); return strcasecmp(s1, s2);
} }
inline char* StrDup(const char* src) { return strdup(src); }
#endif // GTEST_OS_WINDOWS #endif // GTEST_OS_WINDOWS
@ -2083,13 +2129,13 @@ GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
// StrError() aren't needed on Windows CE at this time and thus not // StrError() aren't needed on Windows CE at this time and thus not
// defined there. // defined there.
#if GTEST_HAS_FILE_SYSTEM #if GTEST_HAS_FILE_SYSTEM
#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && \ #if !defined(GTEST_OS_WINDOWS_MOBILE) && !defined(GTEST_OS_WINDOWS_PHONE) && \
!GTEST_OS_WINDOWS_RT && !GTEST_OS_ESP8266 && !GTEST_OS_XTENSA && \ !defined(GTEST_OS_WINDOWS_RT) && !defined(GTEST_OS_ESP8266) && \
!GTEST_OS_QURT !defined(GTEST_OS_XTENSA) && !defined(GTEST_OS_QURT)
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 defined(GTEST_OS_WINDOWS) && !defined(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);
@ -2099,14 +2145,14 @@ inline FILE* FOpen(const char* path, const char* mode) {
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 && !GTEST_OS_QURT #if !defined(GTEST_OS_WINDOWS_MOBILE) && !defined(GTEST_OS_QURT)
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 // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT #endif // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT
inline int FClose(FILE* fp) { return fclose(fp); } inline int FClose(FILE* fp) { return fclose(fp); }
#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT #if !defined(GTEST_OS_WINDOWS_MOBILE) && !defined(GTEST_OS_QURT)
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));
} }
@ -2117,14 +2163,14 @@ inline int Close(int fd) { return close(fd); }
#endif // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT #endif // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT
#endif // GTEST_HAS_FILE_SYSTEM #endif // GTEST_HAS_FILE_SYSTEM
#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT #if !defined(GTEST_OS_WINDOWS_MOBILE) && !defined(GTEST_OS_QURT)
inline const char* StrError(int errnum) { return strerror(errnum); } inline const char* StrError(int errnum) { return strerror(errnum); }
#endif // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT #endif // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_QURT
inline const char* GetEnv(const char* name) { inline const char* GetEnv(const char* name) {
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \ #if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_WINDOWS_PHONE) || \
GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA || \ defined(GTEST_OS_ESP8266) || defined(GTEST_OS_XTENSA) || \
GTEST_OS_QURT defined(GTEST_OS_QURT)
// We are on an embedded platform, which has no environment variables. // We are on an embedded platform, which has no environment variables.
static_cast<void>(name); // To prevent 'unused argument' warning. static_cast<void>(name); // To prevent 'unused argument' warning.
return nullptr; return nullptr;
@ -2140,7 +2186,7 @@ inline const char* GetEnv(const char* name) {
GTEST_DISABLE_MSC_DEPRECATED_POP_() GTEST_DISABLE_MSC_DEPRECATED_POP_()
#if GTEST_OS_WINDOWS_MOBILE #ifdef GTEST_OS_WINDOWS_MOBILE
// Windows CE has no C library. The abort() function is used in // Windows CE has no C library. The abort() function is used in
// several places in Google Test. This implementation provides a reasonable // several places in Google Test. This implementation provides a reasonable
// imitation of standard behaviour. // imitation of standard behaviour.
@ -2156,7 +2202,7 @@ GTEST_DISABLE_MSC_DEPRECATED_POP_()
// 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 defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE #if defined(_MSC_VER) && !defined(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__)
@ -2229,7 +2275,7 @@ using TimeInMillis = int64_t; // Represents time in milliseconds.
#endif // !defined(GTEST_FLAG) #endif // !defined(GTEST_FLAG)
// Pick a command line flags implementation. // Pick a command line flags implementation.
#if GTEST_HAS_ABSL #ifdef 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) \
@ -2340,7 +2386,7 @@ const char* StringFromGTestEnv(const char* flag, const char* default_val);
#endif // !defined(GTEST_INTERNAL_DEPRECATED) #endif // !defined(GTEST_INTERNAL_DEPRECATED)
#if GTEST_HAS_ABSL #ifdef GTEST_HAS_ABSL
// Always use absl::any for UniversalPrinter<> specializations if googletest // Always use absl::any for UniversalPrinter<> specializations if googletest
// is built with absl support. // is built with absl support.
#define GTEST_INTERNAL_HAS_ANY 1 #define GTEST_INTERNAL_HAS_ANY 1
@ -2352,7 +2398,8 @@ using Any = ::absl::any;
} // namespace testing } // namespace testing
#else #else
#ifdef __has_include #ifdef __has_include
#if __has_include(<any>) && __cplusplus >= 201703L #if __has_include(<any>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L && \
(!defined(_MSC_VER) || GTEST_HAS_RTTI)
// Otherwise for C++17 and higher use std::any for UniversalPrinter<> // Otherwise for C++17 and higher use std::any for UniversalPrinter<>
// specializations. // specializations.
#define GTEST_INTERNAL_HAS_ANY 1 #define GTEST_INTERNAL_HAS_ANY 1
@ -2364,11 +2411,15 @@ using Any = ::std::any;
} // namespace testing } // namespace testing
// The case where absl is configured NOT to alias std::any is not // The case where absl is configured NOT to alias std::any is not
// supported. // supported.
#endif // __has_include(<any>) && __cplusplus >= 201703L #endif // __has_include(<any>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
#endif // __has_include #endif // __has_include
#endif // GTEST_HAS_ABSL #endif // GTEST_HAS_ABSL
#if GTEST_HAS_ABSL #ifndef GTEST_INTERNAL_HAS_ANY
#define GTEST_INTERNAL_HAS_ANY 0
#endif
#ifdef 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
@ -2382,7 +2433,7 @@ inline ::absl::nullopt_t Nullopt() { return ::absl::nullopt; }
} // namespace testing } // namespace testing
#else #else
#ifdef __has_include #ifdef __has_include
#if __has_include(<optional>) && __cplusplus >= 201703L #if __has_include(<optional>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 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
@ -2396,11 +2447,15 @@ inline ::std::nullopt_t Nullopt() { return ::std::nullopt; }
} // 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>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
#endif // __has_include #endif // __has_include
#endif // GTEST_HAS_ABSL #endif // GTEST_HAS_ABSL
#if GTEST_HAS_ABSL #ifndef GTEST_INTERNAL_HAS_OPTIONAL
#define GTEST_INTERNAL_HAS_OPTIONAL 0
#endif
#ifdef 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
@ -2412,7 +2467,7 @@ using StringView = ::absl::string_view;
} // namespace testing } // namespace testing
#else #else
#ifdef __has_include #ifdef __has_include
#if __has_include(<string_view>) && __cplusplus >= 201703L #if __has_include(<string_view>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 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
@ -2424,11 +2479,16 @@ using StringView = ::std::string_view;
} // 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>) && GTEST_INTERNAL_CPLUSPLUS_LANG >=
// 201703L
#endif // __has_include #endif // __has_include
#endif // GTEST_HAS_ABSL #endif // GTEST_HAS_ABSL
#if GTEST_HAS_ABSL #ifndef GTEST_INTERNAL_HAS_STRING_VIEW
#define GTEST_INTERNAL_HAS_STRING_VIEW 0
#endif
#ifdef 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
@ -2441,7 +2501,7 @@ using Variant = ::absl::variant<T...>;
} // namespace testing } // namespace testing
#else #else
#ifdef __has_include #ifdef __has_include
#if __has_include(<variant>) && __cplusplus >= 201703L #if __has_include(<variant>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
// Otherwise for C++17 and higher use std::variant for UniversalPrinter<> // Otherwise for C++17 and higher use std::variant for UniversalPrinter<>
// specializations. // specializations.
#define GTEST_INTERNAL_HAS_VARIANT 1 #define GTEST_INTERNAL_HAS_VARIANT 1
@ -2453,8 +2513,17 @@ using Variant = ::std::variant<T...>;
} // namespace internal } // namespace internal
} // namespace testing } // namespace testing
// The case where absl is configured NOT to alias std::variant is not supported. // The case where absl is configured NOT to alias std::variant is not supported.
#endif // __has_include(<variant>) && __cplusplus >= 201703L #endif // __has_include(<variant>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
#endif // __has_include #endif // __has_include
#endif // GTEST_HAS_ABSL #endif // GTEST_HAS_ABSL
#ifndef GTEST_INTERNAL_HAS_VARIANT
#define GTEST_INTERNAL_HAS_VARIANT 0
#endif
#if defined(GTEST_INTERNAL_CPLUSPLUS_LANG) && \
GTEST_INTERNAL_CPLUSPLUS_LANG < 201703L
#define GTEST_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL 1
#endif
#endif // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ #endif // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_

2
googletest/include/gtest/internal/gtest-string.h
View File

@ -73,7 +73,7 @@ class GTEST_API_ String {
// memory using malloc(). // memory using malloc().
static const char* CloneCString(const char* c_str); static const char* CloneCString(const char* c_str);
#if GTEST_OS_WINDOWS_MOBILE #ifdef GTEST_OS_WINDOWS_MOBILE
// Windows CE does not have the 'ANSI' versions of Win32 APIs. To be // Windows CE does not have the 'ANSI' versions of Win32 APIs. To be
// able to pass strings to Win32 APIs on CE we need to convert them // able to pass strings to Win32 APIs on CE we need to convert them
// to 'Unicode', UTF-16. // to 'Unicode', UTF-16.

2
googletest/samples/prime_tables.h
View File

@ -39,7 +39,7 @@
// The prime table interface. // The prime table interface.
class PrimeTable { class PrimeTable {
public: public:
virtual ~PrimeTable() {} virtual ~PrimeTable() = default;
// Returns true if and only if n is a prime number. // Returns true if and only if n is a prime number.
virtual bool IsPrime(int n) const = 0; virtual bool IsPrime(int n) const = 0;

1
googletest/samples/sample10_unittest.cc
View File

@ -38,7 +38,6 @@ using ::testing::InitGoogleTest;
using ::testing::Test; using ::testing::Test;
using ::testing::TestEventListeners; using ::testing::TestEventListeners;
using ::testing::TestInfo; using ::testing::TestInfo;
using ::testing::TestPartResult;
using ::testing::UnitTest; using ::testing::UnitTest;
namespace { namespace {

2
googletest/samples/sample8_unittest.cc
View File

@ -32,6 +32,8 @@
// and each test is given one combination as a parameter. // and each test is given one combination as a parameter.
// Use class definitions to test from this header. // Use class definitions to test from this header.
#include <tuple>
#include "prime_tables.h" #include "prime_tables.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
namespace { namespace {

1
googletest/samples/sample9_unittest.cc
View File

@ -40,7 +40,6 @@ using ::testing::Test;
using ::testing::TestEventListeners; using ::testing::TestEventListeners;
using ::testing::TestInfo; using ::testing::TestInfo;
using ::testing::TestPartResult; using ::testing::TestPartResult;
using ::testing::TestSuite;
using ::testing::UnitTest; using ::testing::UnitTest;
namespace { namespace {
// Provides alternative output mode which produces minimal amount of // Provides alternative output mode which produces minimal amount of

4
googletest/src/gtest-assertion-result.cc
View File

@ -44,7 +44,7 @@ namespace testing {
// Used in EXPECT_TRUE/FALSE(assertion_result). // Used in EXPECT_TRUE/FALSE(assertion_result).
AssertionResult::AssertionResult(const AssertionResult& other) AssertionResult::AssertionResult(const AssertionResult& other)
: success_(other.success_), : success_(other.success_),
message_(other.message_.get() != nullptr message_(other.message_ != nullptr
? new ::std::string(*other.message_) ? new ::std::string(*other.message_)
: static_cast< ::std::string*>(nullptr)) {} : static_cast< ::std::string*>(nullptr)) {}
@ -58,7 +58,7 @@ void AssertionResult::swap(AssertionResult& other) {
// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE. // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
AssertionResult AssertionResult::operator!() const { AssertionResult AssertionResult::operator!() const {
AssertionResult negation(!success_); AssertionResult negation(!success_);
if (message_.get() != nullptr) negation << *message_; if (message_ != nullptr) negation << *message_;
return negation; return negation;
} }

156
googletest/src/gtest-death-test.cc
View File

@ -33,14 +33,18 @@
#include "gtest/gtest-death-test.h" #include "gtest/gtest-death-test.h"
#include <functional> #include <functional>
#include <memory>
#include <sstream>
#include <string>
#include <utility> #include <utility>
#include <vector>
#include "gtest/internal/custom/gtest.h" #include "gtest/internal/custom/gtest.h"
#include "gtest/internal/gtest-port.h" #include "gtest/internal/gtest-port.h"
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
#if GTEST_OS_MAC #ifdef GTEST_OS_MAC
#include <crt_externs.h> #include <crt_externs.h>
#endif // GTEST_OS_MAC #endif // GTEST_OS_MAC
@ -48,24 +52,24 @@
#include <fcntl.h> #include <fcntl.h>
#include <limits.h> #include <limits.h>
#if GTEST_OS_LINUX #ifdef GTEST_OS_LINUX
#include <signal.h> #include <signal.h>
#endif // GTEST_OS_LINUX #endif // GTEST_OS_LINUX
#include <stdarg.h> #include <stdarg.h>
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
#include <windows.h> #include <windows.h>
#else #else
#include <sys/mman.h> #include <sys/mman.h>
#include <sys/wait.h> #include <sys/wait.h>
#endif // GTEST_OS_WINDOWS #endif // GTEST_OS_WINDOWS
#if GTEST_OS_QNX #ifdef GTEST_OS_QNX
#include <spawn.h> #include <spawn.h>
#endif // GTEST_OS_QNX #endif // GTEST_OS_QNX
#if GTEST_OS_FUCHSIA #ifdef GTEST_OS_FUCHSIA
#include <lib/fdio/fd.h> #include <lib/fdio/fd.h>
#include <lib/fdio/io.h> #include <lib/fdio/io.h>
#include <lib/fdio/spawn.h> #include <lib/fdio/spawn.h>
@ -131,13 +135,13 @@ GTEST_DEFINE_string_(
namespace testing { namespace testing {
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
namespace internal { namespace internal {
// Valid only for fast death tests. Indicates the code is running in the // Valid only for fast death tests. Indicates the code is running in the
// child process of a fast style death test. // child process of a fast style death test.
#if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA #if !defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_FUCHSIA)
static bool g_in_fast_death_test_child = false; static bool g_in_fast_death_test_child = false;
#endif #endif
@ -147,7 +151,7 @@ static bool g_in_fast_death_test_child = false;
// tests. IMPORTANT: This is an internal utility. Using it may break the // tests. IMPORTANT: This is an internal utility. Using it may break the
// implementation of death tests. User code MUST NOT use it. // implementation of death tests. User code MUST NOT use it.
bool InDeathTestChild() { bool InDeathTestChild() {
#if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA #if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_FUCHSIA)
// On Windows and Fuchsia, death tests are thread-safe regardless of the value // On Windows and Fuchsia, death tests are thread-safe regardless of the value
// of the death_test_style flag. // of the death_test_style flag.
@ -169,7 +173,7 @@ ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) {}
// ExitedWithCode function-call operator. // ExitedWithCode function-call operator.
bool ExitedWithCode::operator()(int exit_status) const { bool ExitedWithCode::operator()(int exit_status) const {
#if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA #if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_FUCHSIA)
return exit_status == exit_code_; return exit_status == exit_code_;
@ -180,7 +184,7 @@ bool ExitedWithCode::operator()(int exit_status) const {
#endif // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA #endif // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
} }
#if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA #if !defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_FUCHSIA)
// KilledBySignal constructor. // KilledBySignal constructor.
KilledBySignal::KilledBySignal(int signum) : signum_(signum) {} KilledBySignal::KilledBySignal(int signum) : signum_(signum) {}
@ -207,7 +211,7 @@ namespace internal {
static std::string ExitSummary(int exit_code) { static std::string ExitSummary(int exit_code) {
Message m; Message m;
#if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA #if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_FUCHSIA)
m << "Exited with exit status " << exit_code; m << "Exited with exit status " << exit_code;
@ -234,7 +238,7 @@ bool ExitedUnsuccessfully(int exit_status) {
return !ExitedWithCode(0)(exit_status); return !ExitedWithCode(0)(exit_status);
} }
#if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA #if !defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_FUCHSIA)
// Generates a textual failure message when a death test finds more than // Generates a textual failure message when a death test finds more than
// one thread running, or cannot determine the number of threads, prior // one thread running, or cannot determine the number of threads, prior
// to executing the given statement. It is the responsibility of the // to executing the given statement. It is the responsibility of the
@ -263,7 +267,7 @@ static const char kDeathTestReturned = 'R';
static const char kDeathTestThrew = 'T'; static const char kDeathTestThrew = 'T';
static const char kDeathTestInternalError = 'I'; static const char kDeathTestInternalError = 'I';
#if GTEST_OS_FUCHSIA #ifdef GTEST_OS_FUCHSIA
// File descriptor used for the pipe in the child process. // File descriptor used for the pipe in the child process.
static const int kFuchsiaReadPipeFd = 3; static const int kFuchsiaReadPipeFd = 3;
@ -621,7 +625,18 @@ bool DeathTestImpl::Passed(bool status_ok) {
return success; return success;
} }
#if GTEST_OS_WINDOWS // Note: The return value points into args, so the return value's lifetime is
// bound to that of args.
std::unique_ptr<char*[]> CreateArgvFromArgs(std::vector<std::string>& args) {
auto result = std::make_unique<char*[]>(args.size() + 1);
for (size_t i = 0; i < args.size(); ++i) {
result[i] = &args[i][0];
}
result[args.size()] = nullptr; // extra null terminator
return result;
}
#ifdef GTEST_OS_WINDOWS
// WindowsDeathTest implements death tests on Windows. Due to the // WindowsDeathTest implements death tests on Windows. Due to the
// specifics of starting new processes on Windows, death tests there are // specifics of starting new processes on Windows, death tests there are
// always threadsafe, and Google Test considers the // always threadsafe, and Google Test considers the
@ -808,7 +823,7 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
return OVERSEE_TEST; return OVERSEE_TEST;
} }
#elif GTEST_OS_FUCHSIA #elif defined(GTEST_OS_FUCHSIA)
class FuchsiaDeathTest : public DeathTestImpl { class FuchsiaDeathTest : public DeathTestImpl {
public: public:
@ -836,36 +851,6 @@ class FuchsiaDeathTest : public DeathTestImpl {
zx::socket stderr_socket_; zx::socket stderr_socket_;
}; };
// Utility class for accumulating command-line arguments.
class Arguments {
public:
Arguments() { args_.push_back(nullptr); }
~Arguments() {
for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
++i) {
free(*i);
}
}
void AddArgument(const char* argument) {
args_.insert(args_.end() - 1, posix::StrDup(argument));
}
template <typename Str>
void AddArguments(const ::std::vector<Str>& arguments) {
for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
i != arguments.end(); ++i) {
args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
}
}
char* const* Argv() { return &args_[0]; }
int size() { return static_cast<int>(args_.size()) - 1; }
private:
std::vector<char*> args_;
};
// Waits for the child in a death test to exit, returning its exit // Waits for the child in a death test to exit, returning its exit
// status, or 0 if no child process exists. As a side effect, sets the // status, or 0 if no child process exists. As a side effect, sets the
// outcome data member. // outcome data member.
@ -986,10 +971,10 @@ DeathTest::TestRole FuchsiaDeathTest::AssumeRole() {
kInternalRunDeathTestFlag + "=" + file_ + kInternalRunDeathTestFlag + "=" + file_ +
"|" + StreamableToString(line_) + "|" + "|" + StreamableToString(line_) + "|" +
StreamableToString(death_test_index); StreamableToString(death_test_index);
Arguments args;
args.AddArguments(GetInjectableArgvs()); std::vector<std::string> args = GetInjectableArgvs();
args.AddArgument(filter_flag.c_str()); args.push_back(filter_flag);
args.AddArgument(internal_flag.c_str()); args.push_back(internal_flag);
// Build the pipe for communication with the child. // Build the pipe for communication with the child.
zx_status_t status; zx_status_t status;
@ -1041,8 +1026,14 @@ DeathTest::TestRole FuchsiaDeathTest::AssumeRole() {
GTEST_DEATH_TEST_CHECK_(status == ZX_OK); GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
// Spawn the child process. // Spawn the child process.
status = fdio_spawn_etc(child_job, FDIO_SPAWN_CLONE_ALL, args.Argv()[0], // Note: The test component must have `fuchsia.process.Launcher` declared
args.Argv(), nullptr, 2, spawn_actions, // in its manifest. (Fuchsia integration tests require creating a
// "Fuchsia Test Component" which contains a "Fuchsia Component Manifest")
// Launching processes is a privileged operation in Fuchsia, and the
// declaration indicates that the ability is required for the component.
std::unique_ptr<char*[]> argv = CreateArgvFromArgs(args);
status = fdio_spawn_etc(child_job, FDIO_SPAWN_CLONE_ALL, argv[0], argv.get(),
nullptr, 2, spawn_actions,
child_process_.reset_and_get_address(), nullptr); child_process_.reset_and_get_address(), nullptr);
GTEST_DEATH_TEST_CHECK_(status == ZX_OK); GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
@ -1173,34 +1164,6 @@ class ExecDeathTest : public ForkingDeathTest {
const int line_; const int line_;
}; };
// Utility class for accumulating command-line arguments.
class Arguments {
public:
Arguments() { args_.push_back(nullptr); }
~Arguments() {
for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
++i) {
free(*i);
}
}
void AddArgument(const char* argument) {
args_.insert(args_.end() - 1, posix::StrDup(argument));
}
template <typename Str>
void AddArguments(const ::std::vector<Str>& arguments) {
for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
i != arguments.end(); ++i) {
args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
}
}
char* const* Argv() { return &args_[0]; }
private:
std::vector<char*> args_;
};
// A struct that encompasses the arguments to the child process of a // A struct that encompasses the arguments to the child process of a
// threadsafe-style death test process. // threadsafe-style death test process.
struct ExecDeathTestArgs { struct ExecDeathTestArgs {
@ -1208,7 +1171,7 @@ struct ExecDeathTestArgs {
int close_fd; // File descriptor to close; the read end of a pipe int close_fd; // File descriptor to close; the read end of a pipe
}; };
#if GTEST_OS_QNX #ifdef GTEST_OS_QNX
extern "C" char** environ; extern "C" char** environ;
#else // GTEST_OS_QNX #else // GTEST_OS_QNX
// The main function for a threadsafe-style death test child process. // The main function for a threadsafe-style death test child process.
@ -1289,7 +1252,7 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
ExecDeathTestArgs args = {argv, close_fd}; ExecDeathTestArgs args = {argv, close_fd};
pid_t child_pid = -1; pid_t child_pid = -1;
#if GTEST_OS_QNX #ifdef GTEST_OS_QNX
// Obtains the current directory and sets it to be closed in the child // Obtains the current directory and sets it to be closed in the child
// process. // process.
const int cwd_fd = open(".", O_RDONLY); const int cwd_fd = open(".", O_RDONLY);
@ -1320,7 +1283,7 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd)); GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd));
#else // GTEST_OS_QNX #else // GTEST_OS_QNX
#if GTEST_OS_LINUX #ifdef GTEST_OS_LINUX
// When a SIGPROF signal is received while fork() or clone() are executing, // When a SIGPROF signal is received while fork() or clone() are executing,
// the process may hang. To avoid this, we ignore SIGPROF here and re-enable // the process may hang. To avoid this, we ignore SIGPROF here and re-enable
// it after the call to fork()/clone() is complete. // it after the call to fork()/clone() is complete.
@ -1367,11 +1330,10 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
#endif // GTEST_HAS_CLONE #endif // GTEST_HAS_CLONE
if (use_fork && (child_pid = fork()) == 0) { if (use_fork && (child_pid = fork()) == 0) {
ExecDeathTestChildMain(&args); _exit(ExecDeathTestChildMain(&args));
_exit(0);
} }
#endif // GTEST_OS_QNX #endif // GTEST_OS_QNX
#if GTEST_OS_LINUX #ifdef GTEST_OS_LINUX
GTEST_DEATH_TEST_CHECK_SYSCALL_( GTEST_DEATH_TEST_CHECK_SYSCALL_(
sigaction(SIGPROF, &saved_sigprof_action, nullptr)); sigaction(SIGPROF, &saved_sigprof_action, nullptr));
#endif // GTEST_OS_LINUX #endif // GTEST_OS_LINUX
@ -1410,10 +1372,9 @@ DeathTest::TestRole ExecDeathTest::AssumeRole() {
StreamableToString(line_) + "|" + StreamableToString(line_) + "|" +
StreamableToString(death_test_index) + "|" + StreamableToString(death_test_index) + "|" +
StreamableToString(pipe_fd[1]); StreamableToString(pipe_fd[1]);
Arguments args; std::vector<std::string> args = GetArgvsForDeathTestChildProcess();
args.AddArguments(GetArgvsForDeathTestChildProcess()); args.push_back(filter_flag);
args.AddArgument(filter_flag.c_str()); args.push_back(internal_flag);
args.AddArgument(internal_flag.c_str());
DeathTest::set_last_death_test_message(""); DeathTest::set_last_death_test_message("");
@ -1422,7 +1383,8 @@ DeathTest::TestRole ExecDeathTest::AssumeRole() {
// is necessary. // is necessary.
FlushInfoLog(); FlushInfoLog();
const pid_t child_pid = ExecDeathTestSpawnChild(args.Argv(), pipe_fd[0]); std::unique_ptr<char*[]> argv = CreateArgvFromArgs(args);
const pid_t child_pid = ExecDeathTestSpawnChild(argv.get(), pipe_fd[0]);
GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1])); GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
set_child_pid(child_pid); set_child_pid(child_pid);
set_read_fd(pipe_fd[0]); set_read_fd(pipe_fd[0]);
@ -1463,14 +1425,14 @@ bool DefaultDeathTestFactory::Create(const char* statement,
} }
} }
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
if (GTEST_FLAG_GET(death_test_style) == "threadsafe" || if (GTEST_FLAG_GET(death_test_style) == "threadsafe" ||
GTEST_FLAG_GET(death_test_style) == "fast") { GTEST_FLAG_GET(death_test_style) == "fast") {
*test = new WindowsDeathTest(statement, std::move(matcher), file, line); *test = new WindowsDeathTest(statement, std::move(matcher), file, line);
} }
#elif GTEST_OS_FUCHSIA #elif defined(GTEST_OS_FUCHSIA)
if (GTEST_FLAG_GET(death_test_style) == "threadsafe" || if (GTEST_FLAG_GET(death_test_style) == "threadsafe" ||
GTEST_FLAG_GET(death_test_style) == "fast") { GTEST_FLAG_GET(death_test_style) == "fast") {
@ -1497,7 +1459,7 @@ bool DefaultDeathTestFactory::Create(const char* statement,
return true; return true;
} }
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
// Recreates the pipe and event handles from the provided parameters, // Recreates the pipe and event handles from the provided parameters,
// signals the event, and returns a file descriptor wrapped around the pipe // signals the event, and returns a file descriptor wrapped around the pipe
// handle. This function is called in the child process only. // handle. This function is called in the child process only.
@ -1564,7 +1526,7 @@ static int GetStatusFileDescriptor(unsigned int parent_process_id,
// initialized from the GTEST_FLAG(internal_run_death_test) flag if // initialized from the GTEST_FLAG(internal_run_death_test) flag if
// the flag is specified; otherwise returns NULL. // the flag is specified; otherwise returns NULL.
InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() { InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
if (GTEST_FLAG_GET(internal_run_death_test) == "") return nullptr; if (GTEST_FLAG_GET(internal_run_death_test).empty()) return nullptr;
// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
// can use it here. // can use it here.
@ -1574,7 +1536,7 @@ InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
SplitString(GTEST_FLAG_GET(internal_run_death_test), '|', &fields); SplitString(GTEST_FLAG_GET(internal_run_death_test), '|', &fields);
int write_fd = -1; int write_fd = -1;
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
unsigned int parent_process_id = 0; unsigned int parent_process_id = 0;
size_t write_handle_as_size_t = 0; size_t write_handle_as_size_t = 0;
@ -1591,7 +1553,7 @@ InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
write_fd = GetStatusFileDescriptor(parent_process_id, write_handle_as_size_t, write_fd = GetStatusFileDescriptor(parent_process_id, write_handle_as_size_t,
event_handle_as_size_t); event_handle_as_size_t);
#elif GTEST_OS_FUCHSIA #elif defined(GTEST_OS_FUCHSIA)
if (fields.size() != 3 || !ParseNaturalNumber(fields[1], &line) || if (fields.size() != 3 || !ParseNaturalNumber(fields[1], &line) ||
!ParseNaturalNumber(fields[2], &index)) { !ParseNaturalNumber(fields[2], &index)) {

41
googletest/src/gtest-filepath.cc
View File

@ -31,12 +31,15 @@
#include <stdlib.h> #include <stdlib.h>
#include <iterator>
#include <string>
#include "gtest/gtest-message.h" #include "gtest/gtest-message.h"
#include "gtest/internal/gtest-port.h" #include "gtest/internal/gtest-port.h"
#if GTEST_OS_WINDOWS_MOBILE #ifdef GTEST_OS_WINDOWS_MOBILE
#include <windows.h> #include <windows.h>
#elif GTEST_OS_WINDOWS #elif defined(GTEST_OS_WINDOWS)
#include <direct.h> #include <direct.h>
#include <io.h> #include <io.h>
#else #else
@ -47,7 +50,7 @@
#include "gtest/internal/gtest-string.h" #include "gtest/internal/gtest-string.h"
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
#define GTEST_PATH_MAX_ _MAX_PATH #define GTEST_PATH_MAX_ _MAX_PATH
#elif defined(PATH_MAX) #elif defined(PATH_MAX)
#define GTEST_PATH_MAX_ PATH_MAX #define GTEST_PATH_MAX_ PATH_MAX
@ -62,7 +65,7 @@
namespace testing { namespace testing {
namespace internal { namespace internal {
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
// On Windows, '\\' is the standard path separator, but many tools and the // On Windows, '\\' is the standard path separator, but many tools and the
// Windows API also accept '/' as an alternate path separator. Unless otherwise // Windows API also accept '/' as an alternate path separator. Unless otherwise
// noted, a file path can contain either kind of path separators, or a mixture // noted, a file path can contain either kind of path separators, or a mixture
@ -70,7 +73,7 @@ namespace internal {
const char kPathSeparator = '\\'; const char kPathSeparator = '\\';
const char kAlternatePathSeparator = '/'; const char kAlternatePathSeparator = '/';
const char kAlternatePathSeparatorString[] = "/"; const char kAlternatePathSeparatorString[] = "/";
#if GTEST_OS_WINDOWS_MOBILE #ifdef GTEST_OS_WINDOWS_MOBILE
// Windows CE doesn't have a current directory. You should not use // Windows CE doesn't have a current directory. You should not use
// the current directory in tests on Windows CE, but this at least // the current directory in tests on Windows CE, but this at least
// provides a reasonable fallback. // provides a reasonable fallback.
@ -96,19 +99,20 @@ static bool IsPathSeparator(char c) {
// Returns the current working directory, or "" if unsuccessful. // Returns the current working directory, or "" if unsuccessful.
FilePath FilePath::GetCurrentDir() { FilePath FilePath::GetCurrentDir() {
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \ #if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_WINDOWS_PHONE) || \
GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_ESP32 || \ defined(GTEST_OS_WINDOWS_RT) || defined(GTEST_OS_ESP8266) || \
GTEST_OS_XTENSA || GTEST_OS_QURT defined(GTEST_OS_ESP32) || defined(GTEST_OS_XTENSA) || \
defined(GTEST_OS_QURT)
// These platforms do not have a current directory, so we just return // These platforms do not have a current directory, so we just return
// something reasonable. // something reasonable.
return FilePath(kCurrentDirectoryString); return FilePath(kCurrentDirectoryString);
#elif GTEST_OS_WINDOWS #elif defined(GTEST_OS_WINDOWS)
char cwd[GTEST_PATH_MAX_ + 1] = {'\0'}; char cwd[GTEST_PATH_MAX_ + 1] = {'\0'};
return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? "" : cwd); return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? "" : cwd);
#else #else
char cwd[GTEST_PATH_MAX_ + 1] = {'\0'}; char cwd[GTEST_PATH_MAX_ + 1] = {'\0'};
char* result = getcwd(cwd, sizeof(cwd)); char* result = getcwd(cwd, sizeof(cwd));
#if GTEST_OS_NACL #ifdef GTEST_OS_NACL
// getcwd will likely fail in NaCl due to the sandbox, so return something // getcwd will likely fail in NaCl due to the sandbox, so return something
// reasonable. The user may have provided a shim implementation for getcwd, // reasonable. The user may have provided a shim implementation for getcwd,
// however, so fallback only when failure is detected. // however, so fallback only when failure is detected.
@ -151,7 +155,7 @@ size_t FilePath::CalculateRootLength() const {
const auto& path = pathname_; const auto& path = pathname_;
auto s = path.begin(); auto s = path.begin();
auto end = path.end(); auto end = path.end();
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
if (end - s >= 2 && s[1] == ':' && (end - s == 2 || IsPathSeparator(s[2])) && if (end - s >= 2 && s[1] == ':' && (end - s == 2 || IsPathSeparator(s[2])) &&
(('A' <= s[0] && s[0] <= 'Z') || ('a' <= s[0] && s[0] <= 'z'))) { (('A' <= s[0] && s[0] <= 'Z') || ('a' <= s[0] && s[0] <= 'z'))) {
// A typical absolute path like "C:\Windows" or "D:" // A typical absolute path like "C:\Windows" or "D:"
@ -244,7 +248,7 @@ FilePath FilePath::ConcatPaths(const FilePath& directory,
// Returns true if pathname describes something findable in the file-system, // Returns true if pathname describes something findable in the file-system,
// either a file, directory, or whatever. // either a file, directory, or whatever.
bool FilePath::FileOrDirectoryExists() const { bool FilePath::FileOrDirectoryExists() const {
#if GTEST_OS_WINDOWS_MOBILE #ifdef GTEST_OS_WINDOWS_MOBILE
LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str()); LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
const DWORD attributes = GetFileAttributes(unicode); const DWORD attributes = GetFileAttributes(unicode);
delete[] unicode; delete[] unicode;
@ -259,7 +263,7 @@ bool FilePath::FileOrDirectoryExists() const {
// that exists. // that exists.
bool FilePath::DirectoryExists() const { bool FilePath::DirectoryExists() const {
bool result = false; bool result = false;
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
// Don't strip off trailing separator if path is a root directory on // Don't strip off trailing separator if path is a root directory on
// Windows (like "C:\\"). // Windows (like "C:\\").
const FilePath& path(IsRootDirectory() ? *this const FilePath& path(IsRootDirectory() ? *this
@ -268,7 +272,7 @@ bool FilePath::DirectoryExists() const {
const FilePath& path(*this); const FilePath& path(*this);
#endif #endif
#if GTEST_OS_WINDOWS_MOBILE #ifdef GTEST_OS_WINDOWS_MOBILE
LPCWSTR unicode = String::AnsiToUtf16(path.c_str()); LPCWSTR unicode = String::AnsiToUtf16(path.c_str());
const DWORD attributes = GetFileAttributes(unicode); const DWORD attributes = GetFileAttributes(unicode);
delete[] unicode; delete[] unicode;
@ -344,14 +348,15 @@ bool FilePath::CreateDirectoriesRecursively() const {
// directory for any reason, including if the parent directory does not // directory for any reason, including if the parent directory does not
// exist. Not named "CreateDirectory" because that's a macro on Windows. // exist. Not named "CreateDirectory" because that's a macro on Windows.
bool FilePath::CreateFolder() const { bool FilePath::CreateFolder() const {
#if GTEST_OS_WINDOWS_MOBILE #ifdef GTEST_OS_WINDOWS_MOBILE
FilePath removed_sep(this->RemoveTrailingPathSeparator()); FilePath removed_sep(this->RemoveTrailingPathSeparator());
LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str()); LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
int result = CreateDirectory(unicode, nullptr) ? 0 : -1; int result = CreateDirectory(unicode, nullptr) ? 0 : -1;
delete[] unicode; delete[] unicode;
#elif GTEST_OS_WINDOWS #elif defined(GTEST_OS_WINDOWS)
int result = _mkdir(pathname_.c_str()); int result = _mkdir(pathname_.c_str());
#elif GTEST_OS_ESP8266 || GTEST_OS_XTENSA || GTEST_OS_QURT #elif defined(GTEST_OS_ESP8266) || defined(GTEST_OS_XTENSA) || \
defined(GTEST_OS_QURT)
// do nothing // do nothing
int result = 0; int result = 0;
#else #else
@ -380,7 +385,7 @@ void FilePath::Normalize() {
auto out = pathname_.begin(); auto out = pathname_.begin();
auto i = pathname_.cbegin(); auto i = pathname_.cbegin();
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
// UNC paths are treated specially // UNC paths are treated specially
if (pathname_.end() - i >= 3 && IsPathSeparator(*i) && if (pathname_.end() - i >= 3 && IsPathSeparator(*i) &&
IsPathSeparator(*(i + 1)) && !IsPathSeparator(*(i + 2))) { IsPathSeparator(*(i + 1)) && !IsPathSeparator(*(i + 2))) {

26
googletest/src/gtest-internal-inl.h
View File

@ -55,7 +55,7 @@
#include <netdb.h> // NOLINT #include <netdb.h> // NOLINT
#endif #endif
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
#include <windows.h> // NOLINT #include <windows.h> // NOLINT
#endif // GTEST_OS_WINDOWS #endif // GTEST_OS_WINDOWS
@ -93,7 +93,7 @@ GTEST_API_ TimeInMillis GetTimeInMillis();
GTEST_API_ bool ShouldUseColor(bool stdout_is_tty); GTEST_API_ bool ShouldUseColor(bool stdout_is_tty);
// Formats the given time in milliseconds as seconds. If the input is an exact N // Formats the given time in milliseconds as seconds. If the input is an exact N
// seconds, the output has a trailing decimal point (e.g., "N." intead of "N"). // seconds, the output has a trailing decimal point (e.g., "N." instead of "N").
GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms); GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms);
// Converts the given time in milliseconds to a date string in the ISO 8601 // Converts the given time in milliseconds to a date string in the ISO 8601
@ -384,7 +384,7 @@ class GTEST_API_ UnitTestOptions {
static bool FilterMatchesTest(const std::string& test_suite_name, static bool FilterMatchesTest(const std::string& test_suite_name,
const std::string& test_name); const std::string& test_name);
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
// Function for supporting the gtest_catch_exception flag. // Function for supporting the gtest_catch_exception flag.
// Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
@ -407,8 +407,8 @@ GTEST_API_ FilePath GetCurrentExecutableName();
// The role interface for getting the OS stack trace as a string. // The role interface for getting the OS stack trace as a string.
class OsStackTraceGetterInterface { class OsStackTraceGetterInterface {
public: public:
OsStackTraceGetterInterface() {} OsStackTraceGetterInterface() = default;
virtual ~OsStackTraceGetterInterface() {} virtual ~OsStackTraceGetterInterface() = default;
// Returns the current OS stack trace as an std::string. Parameters: // Returns the current OS stack trace as an std::string. Parameters:
// //
@ -436,13 +436,13 @@ class OsStackTraceGetterInterface {
// A working implementation of the OsStackTraceGetterInterface interface. // A working implementation of the OsStackTraceGetterInterface interface.
class OsStackTraceGetter : public OsStackTraceGetterInterface { class OsStackTraceGetter : public OsStackTraceGetterInterface {
public: public:
OsStackTraceGetter() {} OsStackTraceGetter() = default;
std::string CurrentStackTrace(int max_depth, int skip_count) override; std::string CurrentStackTrace(int max_depth, int skip_count) override;
void UponLeavingGTest() override; void UponLeavingGTest() override;
private: private:
#if GTEST_HAS_ABSL #ifdef GTEST_HAS_ABSL
Mutex mutex_; // Protects all internal state. Mutex mutex_; // Protects all internal state.
// We save the stack frame below the frame that calls user code. // We save the stack frame below the frame that calls user code.
@ -672,7 +672,7 @@ class GTEST_API_ UnitTestImpl {
void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc, void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc, internal::TearDownTestSuiteFunc tear_down_tc,
TestInfo* test_info) { TestInfo* test_info) {
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
// In order to support thread-safe death tests, we need to // In order to support thread-safe death tests, we need to
// remember the original working directory when the test program // remember the original working directory when the test program
// was first invoked. We cannot do this in RUN_ALL_TESTS(), as // was first invoked. We cannot do this in RUN_ALL_TESTS(), as
@ -778,7 +778,7 @@ class GTEST_API_ UnitTestImpl {
return gtest_trace_stack_.get(); return gtest_trace_stack_.get();
} }
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
void InitDeathTestSubprocessControlInfo() { void InitDeathTestSubprocessControlInfo() {
internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag()); internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag());
} }
@ -943,7 +943,7 @@ class GTEST_API_ UnitTestImpl {
// How long the test took to run, in milliseconds. // How long the test took to run, in milliseconds.
TimeInMillis elapsed_time_; TimeInMillis elapsed_time_;
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
// The decomposed components of the gtest_internal_run_death_test flag, // The decomposed components of the gtest_internal_run_death_test flag,
// parsed when RUN_ALL_TESTS is called. // parsed when RUN_ALL_TESTS is called.
std::unique_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_; std::unique_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_;
@ -967,7 +967,7 @@ inline UnitTestImpl* GetUnitTestImpl() {
return UnitTest::GetInstance()->impl(); return UnitTest::GetInstance()->impl();
} }
#if GTEST_USES_SIMPLE_RE #ifdef GTEST_USES_SIMPLE_RE
// Internal helper functions for implementing the simple regular // Internal helper functions for implementing the simple regular
// expression matcher. // expression matcher.
@ -993,7 +993,7 @@ GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str);
GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv); GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv);
GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv); GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv);
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
// Returns the message describing the last system error, regardless of the // Returns the message describing the last system error, regardless of the
// platform. // platform.
@ -1064,7 +1064,7 @@ class StreamingListener : public EmptyTestEventListener {
// Abstract base class for writing strings to a socket. // Abstract base class for writing strings to a socket.
class AbstractSocketWriter { class AbstractSocketWriter {
public: public:
virtual ~AbstractSocketWriter() {} virtual ~AbstractSocketWriter() = default;
// Sends a string to the socket. // Sends a string to the socket.
virtual void Send(const std::string& message) = 0; virtual void Send(const std::string& message) = 0;

106
googletest/src/gtest-port.cc
View File

@ -37,8 +37,12 @@
#include <cstdint> #include <cstdint>
#include <fstream> #include <fstream>
#include <memory> #include <memory>
#include <ostream>
#include <string>
#include <utility>
#include <vector>
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
#include <io.h> #include <io.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <windows.h> #include <windows.h>
@ -51,32 +55,34 @@
#include <unistd.h> #include <unistd.h>
#endif // GTEST_OS_WINDOWS #endif // GTEST_OS_WINDOWS
#if GTEST_OS_MAC #ifdef GTEST_OS_MAC
#include <mach/mach_init.h> #include <mach/mach_init.h>
#include <mach/task.h> #include <mach/task.h>
#include <mach/vm_map.h> #include <mach/vm_map.h>
#endif // GTEST_OS_MAC #endif // GTEST_OS_MAC
#if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \ #if defined(GTEST_OS_DRAGONFLY) || defined(GTEST_OS_FREEBSD) || \
GTEST_OS_NETBSD || GTEST_OS_OPENBSD defined(GTEST_OS_GNU_KFREEBSD) || defined(GTEST_OS_NETBSD) || \
defined(GTEST_OS_OPENBSD)
#include <sys/sysctl.h> #include <sys/sysctl.h>
#if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD #if defined(GTEST_OS_DRAGONFLY) || defined(GTEST_OS_FREEBSD) || \
defined(GTEST_OS_GNU_KFREEBSD)
#include <sys/user.h> #include <sys/user.h>
#endif #endif
#endif #endif
#if GTEST_OS_QNX #ifdef GTEST_OS_QNX
#include <devctl.h> #include <devctl.h>
#include <fcntl.h> #include <fcntl.h>
#include <sys/procfs.h> #include <sys/procfs.h>
#endif // GTEST_OS_QNX #endif // GTEST_OS_QNX
#if GTEST_OS_AIX #ifdef GTEST_OS_AIX
#include <procinfo.h> #include <procinfo.h>
#include <sys/types.h> #include <sys/types.h>
#endif // GTEST_OS_AIX #endif // GTEST_OS_AIX
#if GTEST_OS_FUCHSIA #ifdef GTEST_OS_FUCHSIA
#include <zircon/process.h> #include <zircon/process.h>
#include <zircon/syscalls.h> #include <zircon/syscalls.h>
#endif // GTEST_OS_FUCHSIA #endif // GTEST_OS_FUCHSIA
@ -90,7 +96,7 @@
namespace testing { namespace testing {
namespace internal { namespace internal {
#if GTEST_OS_LINUX || GTEST_OS_GNU_HURD #if defined(GTEST_OS_LINUX) || defined(GTEST_OS_GNU_HURD)
namespace { namespace {
template <typename T> template <typename T>
@ -113,7 +119,7 @@ size_t GetThreadCount() {
return ReadProcFileField<size_t>(filename, 19); return ReadProcFileField<size_t>(filename, 19);
} }
#elif GTEST_OS_MAC #elif defined(GTEST_OS_MAC)
size_t GetThreadCount() { size_t GetThreadCount() {
const task_t task = mach_task_self(); const task_t task = mach_task_self();
@ -131,20 +137,20 @@ size_t GetThreadCount() {
} }
} }
#elif GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \ #elif defined(GTEST_OS_DRAGONFLY) || defined(GTEST_OS_FREEBSD) || \
GTEST_OS_NETBSD defined(GTEST_OS_GNU_KFREEBSD) || defined(GTEST_OS_NETBSD)
#if GTEST_OS_NETBSD #ifdef GTEST_OS_NETBSD
#undef KERN_PROC #undef KERN_PROC
#define KERN_PROC KERN_PROC2 #define KERN_PROC KERN_PROC2
#define kinfo_proc kinfo_proc2 #define kinfo_proc kinfo_proc2
#endif #endif
#if GTEST_OS_DRAGONFLY #ifdef GTEST_OS_DRAGONFLY
#define KP_NLWP(kp) (kp.kp_nthreads) #define KP_NLWP(kp) (kp.kp_nthreads)
#elif GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD #elif defined(GTEST_OS_FREEBSD) || defined(GTEST_OS_GNU_KFREEBSD)
#define KP_NLWP(kp) (kp.ki_numthreads) #define KP_NLWP(kp) (kp.ki_numthreads)
#elif GTEST_OS_NETBSD #elif defined(GTEST_OS_NETBSD)
#define KP_NLWP(kp) (kp.p_nlwps) #define KP_NLWP(kp) (kp.p_nlwps)
#endif #endif
@ -156,7 +162,7 @@ size_t GetThreadCount() {
KERN_PROC, KERN_PROC,
KERN_PROC_PID, KERN_PROC_PID,
getpid(), getpid(),
#if GTEST_OS_NETBSD #ifdef GTEST_OS_NETBSD
sizeof(struct kinfo_proc), sizeof(struct kinfo_proc),
1, 1,
#endif #endif
@ -169,7 +175,7 @@ size_t GetThreadCount() {
} }
return static_cast<size_t>(KP_NLWP(info)); return static_cast<size_t>(KP_NLWP(info));
} }
#elif GTEST_OS_OPENBSD #elif defined(GTEST_OS_OPENBSD)
// 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.
@ -206,7 +212,7 @@ size_t GetThreadCount() {
return nthreads; return nthreads;
} }
#elif GTEST_OS_QNX #elif defined(GTEST_OS_QNX)
// 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.
@ -226,7 +232,7 @@ size_t GetThreadCount() {
} }
} }
#elif GTEST_OS_AIX #elif defined(GTEST_OS_AIX)
size_t GetThreadCount() { size_t GetThreadCount() {
struct procentry64 entry; struct procentry64 entry;
@ -239,7 +245,7 @@ size_t GetThreadCount() {
} }
} }
#elif GTEST_OS_FUCHSIA #elif defined(GTEST_OS_FUCHSIA)
size_t GetThreadCount() { size_t GetThreadCount() {
int dummy_buffer; int dummy_buffer;
@ -264,7 +270,7 @@ size_t GetThreadCount() {
#endif // GTEST_OS_LINUX #endif // GTEST_OS_LINUX
#if GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS #if defined(GTEST_IS_THREADSAFE) && defined(GTEST_OS_WINDOWS)
AutoHandle::AutoHandle() : handle_(INVALID_HANDLE_VALUE) {} AutoHandle::AutoHandle() : handle_(INVALID_HANDLE_VALUE) {}
@ -655,7 +661,7 @@ void ThreadLocalRegistry::OnThreadLocalDestroyed(
#endif // GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS #endif // GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS
#if GTEST_USES_POSIX_RE #ifdef GTEST_USES_POSIX_RE
// Implements RE. Currently only needed for death tests. // Implements RE. Currently only needed for death tests.
@ -668,7 +674,6 @@ RE::~RE() {
regfree(&partial_regex_); regfree(&partial_regex_);
regfree(&full_regex_); regfree(&full_regex_);
} }
free(const_cast<char*>(pattern_));
} }
// Returns true if and only if regular expression re matches the entire str. // Returns true if and only if regular expression re matches the entire str.
@ -690,7 +695,7 @@ bool RE::PartialMatch(const char* str, const RE& re) {
// Initializes an RE from its string representation. // Initializes an RE from its string representation.
void RE::Init(const char* regex) { void RE::Init(const char* regex) {
pattern_ = posix::StrDup(regex); pattern_ = regex;
// Reserves enough bytes to hold the regular expression used for a // Reserves enough bytes to hold the regular expression used for a
// full match. // full match.
@ -718,7 +723,7 @@ void RE::Init(const char* regex) {
delete[] full_pattern; delete[] full_pattern;
} }
#elif GTEST_USES_SIMPLE_RE #elif defined(GTEST_USES_SIMPLE_RE)
// Returns true if and only if ch appears anywhere in str (excluding the // Returns true if and only if ch appears anywhere in str (excluding the
// terminating '\0' character). // terminating '\0' character).
@ -920,27 +925,26 @@ bool MatchRegexAnywhere(const char* regex, const char* str) {
// Implements the RE class. // Implements the RE class.
RE::~RE() { RE::~RE() = default;
free(const_cast<char*>(pattern_));
free(const_cast<char*>(full_pattern_));
}
// Returns true if and only if regular expression re matches the entire str. // Returns true if and only if regular expression re matches the entire str.
bool RE::FullMatch(const char* str, const RE& re) { bool RE::FullMatch(const char* str, const RE& re) {
return re.is_valid_ && MatchRegexAnywhere(re.full_pattern_, str); return re.is_valid_ && MatchRegexAnywhere(re.full_pattern_.c_str(), str);
} }
// Returns true if and only if regular expression re matches a substring of // Returns true if and only if regular expression re matches a substring of
// str (including str itself). // str (including str itself).
bool RE::PartialMatch(const char* str, const RE& re) { bool RE::PartialMatch(const char* str, const RE& re) {
return re.is_valid_ && MatchRegexAnywhere(re.pattern_, str); return re.is_valid_ && MatchRegexAnywhere(re.pattern_.c_str(), str);
} }
// Initializes an RE from its string representation. // Initializes an RE from its string representation.
void RE::Init(const char* regex) { void RE::Init(const char* regex) {
pattern_ = full_pattern_ = nullptr; full_pattern_.clear();
pattern_.clear();
if (regex != nullptr) { if (regex != nullptr) {
pattern_ = posix::StrDup(regex); pattern_ = regex;
} }
is_valid_ = ValidateRegex(regex); is_valid_ = ValidateRegex(regex);
@ -949,25 +953,19 @@ void RE::Init(const char* regex) {
return; return;
} }
const size_t len = strlen(regex);
// Reserves enough bytes to hold the regular expression used for a // Reserves enough bytes to hold the regular expression used for a
// full match: we need space to prepend a '^', append a '$', and // full match: we need space to prepend a '^' and append a '$'.
// terminate the string with '\0'. full_pattern_.reserve(pattern_.size() + 2);
char* buffer = static_cast<char*>(malloc(len + 3));
full_pattern_ = buffer;
if (*regex != '^') if (pattern_.empty() || pattern_.front() != '^') {
*buffer++ = '^'; // Makes sure full_pattern_ starts with '^'. full_pattern_.push_back('^'); // Makes sure full_pattern_ starts with '^'.
}
// We don't use snprintf or strncpy, as they trigger a warning when full_pattern_.append(pattern_);
// compiled with VC++ 8.0.
memcpy(buffer, regex, len);
buffer += len;
if (len == 0 || regex[len - 1] != '$') if (pattern_.empty() || pattern_.back() != '$') {
*buffer++ = '$'; // Makes sure full_pattern_ ends with '$'. full_pattern_.push_back('$'); // Makes sure full_pattern_ ends with '$'.
}
*buffer = '\0';
} }
#endif // GTEST_USES_POSIX_RE #endif // GTEST_USES_POSIX_RE
@ -1035,7 +1033,7 @@ class CapturedStream {
public: public:
// The ctor redirects the stream to a temporary file. // The ctor redirects the stream to a temporary file.
explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) { explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
char temp_dir_path[MAX_PATH + 1] = {'\0'}; // NOLINT char temp_dir_path[MAX_PATH + 1] = {'\0'}; // NOLINT
char temp_file_path[MAX_PATH + 1] = {'\0'}; // NOLINT char temp_file_path[MAX_PATH + 1] = {'\0'}; // NOLINT
@ -1054,7 +1052,7 @@ class CapturedStream {
// directory, so we create the temporary file in a temporary directory. // directory, so we create the temporary file in a temporary directory.
std::string name_template; std::string name_template;
#if GTEST_OS_LINUX_ANDROID #ifdef GTEST_OS_LINUX_ANDROID
// Note: Android applications are expected to call the framework's // Note: Android applications are expected to call the framework's
// Context.getExternalStorageDirectory() method through JNI to get // Context.getExternalStorageDirectory() method through JNI to get
// the location of the world-writable SD Card directory. However, // the location of the world-writable SD Card directory. However,
@ -1067,7 +1065,7 @@ class CapturedStream {
// '/sdcard' and other variants cannot be relied on, as they are not // '/sdcard' and other variants cannot be relied on, as they are not
// guaranteed to be mounted, or may have a delay in mounting. // guaranteed to be mounted, or may have a delay in mounting.
name_template = "/data/local/tmp/"; name_template = "/data/local/tmp/";
#elif GTEST_OS_IOS #elif defined(GTEST_OS_IOS)
char user_temp_dir[PATH_MAX + 1]; char user_temp_dir[PATH_MAX + 1];
// Documented alternative to NSTemporaryDirectory() (for obtaining creating // Documented alternative to NSTemporaryDirectory() (for obtaining creating
@ -1227,7 +1225,7 @@ std::string ReadEntireFile(FILE* file) {
return content; return content;
} }
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
static const std::vector<std::string>* g_injected_test_argvs = static const std::vector<std::string>* g_injected_test_argvs =
nullptr; // Owned. nullptr; // Owned.
@ -1254,7 +1252,7 @@ void ClearInjectableArgvs() {
} }
#endif // GTEST_HAS_DEATH_TEST #endif // GTEST_HAS_DEATH_TEST
#if GTEST_OS_WINDOWS_MOBILE #ifdef GTEST_OS_WINDOWS_MOBILE
namespace posix { namespace posix {
void Abort() { void Abort() {
DebugBreak(); DebugBreak();

4
googletest/src/gtest-printers.cc
View File

@ -47,6 +47,8 @@
#include <cctype> #include <cctype>
#include <cstdint> #include <cstdint>
#include <cwchar> #include <cwchar>
#include <iomanip>
#include <ios>
#include <ostream> // NOLINT #include <ostream> // NOLINT
#include <string> #include <string>
#include <type_traits> #include <type_traits>
@ -528,7 +530,7 @@ void PrintStringTo(const ::std::string& s, ostream* os) {
} }
} }
#ifdef __cpp_char8_t #ifdef __cpp_lib_char8_t
void PrintU8StringTo(const ::std::u8string& s, ostream* os) { void PrintU8StringTo(const ::std::u8string& s, ostream* os) {
PrintCharsAsStringTo(s.data(), s.size(), os); PrintCharsAsStringTo(s.data(), s.size(), os);
} }

5
googletest/src/gtest-test-part.cc
View File

@ -32,13 +32,14 @@
#include "gtest/gtest-test-part.h" #include "gtest/gtest-test-part.h"
#include <ostream>
#include <string>
#include "gtest/internal/gtest-port.h" #include "gtest/internal/gtest-port.h"
#include "src/gtest-internal-inl.h" #include "src/gtest-internal-inl.h"
namespace testing { namespace testing {
using internal::GetUnitTestImpl;
// Gets the summary of the failure message by omitting the stack trace // Gets the summary of the failure message by omitting the stack trace
// in it. // in it.
std::string TestPartResult::ExtractSummary(const char* message) { std::string TestPartResult::ExtractSummary(const char* message) {

6
googletest/src/gtest-typed-test.cc
View File

@ -29,6 +29,10 @@
#include "gtest/gtest-typed-test.h" #include "gtest/gtest-typed-test.h"
#include <set>
#include <string>
#include <vector>
#include "gtest/gtest.h" #include "gtest/gtest.h"
namespace testing { namespace testing {
@ -90,7 +94,7 @@ const char* TypedTestSuitePState::VerifyRegisteredTestNames(
} }
const std::string& errors_str = errors.GetString(); const std::string& errors_str = errors.GetString();
if (errors_str != "") { if (!errors_str.empty()) {
fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(), fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(),
errors_str.c_str()); errors_str.c_str());
fflush(stderr); fflush(stderr);

240
googletest/src/gtest.cc
View File

@ -44,16 +44,21 @@
#include <chrono> // NOLINT #include <chrono> // NOLINT
#include <cmath> #include <cmath>
#include <cstdint> #include <cstdint>
#include <cstdlib>
#include <cstring>
#include <initializer_list> #include <initializer_list>
#include <iomanip> #include <iomanip>
#include <ios> #include <ios>
#include <iostream>
#include <iterator> #include <iterator>
#include <limits> #include <limits>
#include <list> #include <list>
#include <map> #include <map>
#include <ostream> // NOLINT #include <ostream> // NOLINT
#include <set>
#include <sstream> #include <sstream>
#include <unordered_set> #include <unordered_set>
#include <utility>
#include <vector> #include <vector>
#include "gtest/gtest-assertion-result.h" #include "gtest/gtest-assertion-result.h"
@ -61,7 +66,7 @@
#include "gtest/internal/custom/gtest.h" #include "gtest/internal/custom/gtest.h"
#include "gtest/internal/gtest-port.h" #include "gtest/internal/gtest-port.h"
#if GTEST_OS_LINUX #ifdef GTEST_OS_LINUX
#include <fcntl.h> // NOLINT #include <fcntl.h> // NOLINT
#include <limits.h> // NOLINT #include <limits.h> // NOLINT
@ -74,18 +79,18 @@
#include <string> #include <string>
#elif GTEST_OS_ZOS #elif defined(GTEST_OS_ZOS)
#include <sys/time.h> // NOLINT #include <sys/time.h> // NOLINT
// On z/OS we additionally need strings.h for strcasecmp. // On z/OS we additionally need strings.h for strcasecmp.
#include <strings.h> // NOLINT #include <strings.h> // NOLINT
#elif GTEST_OS_WINDOWS_MOBILE // We are on Windows CE. #elif defined(GTEST_OS_WINDOWS_MOBILE) // We are on Windows CE.
#include <windows.h> // NOLINT #include <windows.h> // NOLINT
#undef min #undef min
#elif GTEST_OS_WINDOWS // We are on Windows proper. #elif defined(GTEST_OS_WINDOWS) // We are on Windows proper.
#include <windows.h> // NOLINT #include <windows.h> // NOLINT
#undef min #undef min
@ -99,7 +104,7 @@
#include <sys/timeb.h> // NOLINT #include <sys/timeb.h> // NOLINT
#include <sys/types.h> // NOLINT #include <sys/types.h> // NOLINT
#if GTEST_OS_WINDOWS_MINGW #ifdef GTEST_OS_WINDOWS_MINGW
#include <sys/time.h> // NOLINT #include <sys/time.h> // NOLINT
#endif // GTEST_OS_WINDOWS_MINGW #endif // GTEST_OS_WINDOWS_MINGW
@ -125,17 +130,18 @@
#include "src/gtest-internal-inl.h" #include "src/gtest-internal-inl.h"
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
#define vsnprintf _vsnprintf #define vsnprintf _vsnprintf
#endif // GTEST_OS_WINDOWS #endif // GTEST_OS_WINDOWS
#if GTEST_OS_MAC #ifdef GTEST_OS_MAC
#ifndef GTEST_OS_IOS #ifndef GTEST_OS_IOS
#include <crt_externs.h> #include <crt_externs.h>
#endif #endif
#endif #endif
#if GTEST_HAS_ABSL #ifdef GTEST_HAS_ABSL
#include "absl/container/flat_hash_set.h"
#include "absl/debugging/failure_signal_handler.h" #include "absl/debugging/failure_signal_handler.h"
#include "absl/debugging/stacktrace.h" #include "absl/debugging/stacktrace.h"
#include "absl/debugging/symbolize.h" #include "absl/debugging/symbolize.h"
@ -143,6 +149,8 @@
#include "absl/flags/usage.h" #include "absl/flags/usage.h"
#include "absl/strings/str_cat.h" #include "absl/strings/str_cat.h"
#include "absl/strings/str_replace.h" #include "absl/strings/str_replace.h"
#include "absl/strings/string_view.h"
#include "absl/strings/strip.h"
#endif // GTEST_HAS_ABSL #endif // GTEST_HAS_ABSL
// Checks builtin compiler feature |x| while avoiding an extra layer of #ifdefs // Checks builtin compiler feature |x| while avoiding an extra layer of #ifdefs
@ -408,7 +416,7 @@ uint32_t Random::Generate(uint32_t range) {
// GTestIsInitialized() returns true if and only if the user has initialized // GTestIsInitialized() returns true if and only if the user has initialized
// Google Test. Useful for catching the user mistake of not initializing // Google Test. Useful for catching the user mistake of not initializing
// Google Test before calling RUN_ALL_TESTS(). // Google Test before calling RUN_ALL_TESTS().
static bool GTestIsInitialized() { return GetArgvs().size() > 0; } static bool GTestIsInitialized() { return !GetArgvs().empty(); }
// Iterates over a vector of TestSuites, keeping a running sum of the // Iterates over a vector of TestSuites, keeping a running sum of the
// results of calling a given int-returning method on each. // results of calling a given int-returning method on each.
@ -630,7 +638,7 @@ static ::std::vector<std::string> g_argvs;
FilePath GetCurrentExecutableName() { FilePath GetCurrentExecutableName() {
FilePath result; FilePath result;
#if GTEST_OS_WINDOWS || GTEST_OS_OS2 #if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_OS2)
result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe")); result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
#else #else
result.Set(FilePath(GetArgvs()[0])); result.Set(FilePath(GetArgvs()[0]));
@ -1165,7 +1173,7 @@ TimeInMillis GetTimeInMillis() {
// class String. // class String.
#if GTEST_OS_WINDOWS_MOBILE #ifdef GTEST_OS_WINDOWS_MOBILE
// Creates a UTF-16 wide string from the given ANSI string, allocating // Creates a UTF-16 wide string from the given ANSI string, allocating
// memory using new. The caller is responsible for deleting the return // memory using new. The caller is responsible for deleting the return
// value using delete[]. Returns the wide string, or NULL if the // value using delete[]. Returns the wide string, or NULL if the
@ -1867,14 +1875,14 @@ AssertionResult IsNotSubstring(const char* needle_expr,
namespace internal { namespace internal {
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
namespace { namespace {
// Helper function for IsHRESULT{SuccessFailure} predicates // Helper function for IsHRESULT{SuccessFailure} predicates
AssertionResult HRESULTFailureHelper(const char* expr, const char* expected, AssertionResult HRESULTFailureHelper(const char* expr, const char* expected,
long hr) { // NOLINT long hr) { // NOLINT
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_TV_TITLE #if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_WINDOWS_TV_TITLE)
// Windows CE doesn't support FormatMessage. // Windows CE doesn't support FormatMessage.
const char error_text[] = ""; const char error_text[] = "";
@ -2135,9 +2143,9 @@ bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
if (rhs == nullptr) return false; if (rhs == nullptr) return false;
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
return _wcsicmp(lhs, rhs) == 0; return _wcsicmp(lhs, rhs) == 0;
#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID #elif defined(GTEST_OS_LINUX) && !defined(GTEST_OS_LINUX_ANDROID)
return wcscasecmp(lhs, rhs) == 0; return wcscasecmp(lhs, rhs) == 0;
#else #else
// Android, Mac OS X and Cygwin don't define wcscasecmp. // Android, Mac OS X and Cygwin don't define wcscasecmp.
@ -2237,7 +2245,7 @@ TestResult::TestResult()
: death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {} : death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {}
// D'tor. // D'tor.
TestResult::~TestResult() {} TestResult::~TestResult() = default;
// Returns the i-th test part result among all the results. i can // Returns the i-th test part result among all the results. i can
// range from 0 to total_part_count() - 1. If i is not in that range, // range from 0 to total_part_count() - 1. If i is not in that range,
@ -2325,7 +2333,9 @@ static std::vector<std::string> GetReservedAttributesForElement(
return std::vector<std::string>(); return std::vector<std::string>();
} }
#if GTEST_HAS_FILE_SYSTEM
// TODO(jdesprez): Merge the two getReserved attributes once skip is improved // TODO(jdesprez): Merge the two getReserved attributes once skip is improved
// This function is only used when file systems are enabled.
static std::vector<std::string> GetReservedOutputAttributesForElement( static std::vector<std::string> GetReservedOutputAttributesForElement(
const std::string& xml_element) { const std::string& xml_element) {
if (xml_element == "testsuites") { if (xml_element == "testsuites") {
@ -2340,6 +2350,7 @@ static std::vector<std::string> GetReservedOutputAttributesForElement(
// This code is unreachable but some compilers may not realizes that. // This code is unreachable but some compilers may not realizes that.
return std::vector<std::string>(); return std::vector<std::string>();
} }
#endif
static std::string FormatWordList(const std::vector<std::string>& words) { static std::string FormatWordList(const std::vector<std::string>& words) {
Message word_list; Message word_list;
@ -2443,7 +2454,7 @@ Test::Test() : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {}
// The d'tor restores the states of all flags. The actual work is // The d'tor restores the states of all flags. The actual work is
// done by the d'tor of the gtest_flag_saver_ field, and thus not // done by the d'tor of the gtest_flag_saver_ field, and thus not
// visible here. // visible here.
Test::~Test() {} Test::~Test() = default;
// Sets up the test fixture. // Sets up the test fixture.
// //
@ -2978,6 +2989,25 @@ void TestSuite::Run() {
TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
// Ensure our tests are in a deterministic order.
//
// We do this by sorting lexicographically on (file, line number), providing
// an order matching what the user can see in the source code.
//
// In the common case the line number comparison shouldn't be necessary,
// because the registrations made by the TEST macro are executed in order
// within a translation unit. But this is not true of the manual registration
// API, and in more exotic scenarios a single file may be part of multiple
// translation units.
std::stable_sort(test_info_list_.begin(), test_info_list_.end(),
[](const TestInfo* const a, const TestInfo* const b) {
if (const int result = std::strcmp(a->file(), b->file())) {
return result < 0;
}
return a->line() < b->line();
});
// Call both legacy and the new API // Call both legacy and the new API
repeater->OnTestSuiteStart(*this); repeater->OnTestSuiteStart(*this);
// Legacy API is deprecated but still available // Legacy API is deprecated but still available
@ -3141,7 +3171,7 @@ static void PrintTestPartResult(const TestPartResult& test_part_result) {
// following statements add the test part result message to the Output // following statements add the test part result message to the Output
// window such that the user can double-click on it to jump to the // window such that the user can double-click on it to jump to the
// corresponding source code location; otherwise they do nothing. // corresponding source code location; otherwise they do nothing.
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE #if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE)
// We don't call OutputDebugString*() on Windows Mobile, as printing // We don't call OutputDebugString*() on Windows Mobile, as printing
// to stdout is done by OutputDebugString() there already - we don't // to stdout is done by OutputDebugString() there already - we don't
// want the same message printed twice. // want the same message printed twice.
@ -3151,8 +3181,9 @@ static void PrintTestPartResult(const TestPartResult& test_part_result) {
} }
// class PrettyUnitTestResultPrinter // class PrettyUnitTestResultPrinter
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && \ #if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE) && \
!GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW !defined(GTEST_OS_WINDOWS_PHONE) && !defined(GTEST_OS_WINDOWS_RT) && \
!defined(GTEST_OS_WINDOWS_MINGW)
// Returns the character attribute for the given color. // Returns the character attribute for the given color.
static WORD GetColorAttribute(GTestColor color) { static WORD GetColorAttribute(GTestColor color) {
@ -3224,7 +3255,7 @@ bool ShouldUseColor(bool stdout_is_tty) {
const char* const gtest_color = c.c_str(); const char* const gtest_color = c.c_str();
if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) { if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW #if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MINGW)
// On Windows the TERM variable is usually not set, but the // On Windows the TERM variable is usually not set, but the
// console there does support colors. // console there does support colors.
return stdout_is_tty; return stdout_is_tty;
@ -3279,8 +3310,9 @@ static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
return; return;
} }
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && \ #if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE) && \
!GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW !defined(GTEST_OS_WINDOWS_PHONE) && !defined(GTEST_OS_WINDOWS_RT) && \
!defined(GTEST_OS_WINDOWS_MINGW)
const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE); const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
// Gets the current text color. // Gets the current text color.
@ -3334,7 +3366,7 @@ static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
// Class PrettyUnitTestResultPrinter is copyable. // Class PrettyUnitTestResultPrinter is copyable.
class PrettyUnitTestResultPrinter : public TestEventListener { class PrettyUnitTestResultPrinter : public TestEventListener {
public: public:
PrettyUnitTestResultPrinter() {} PrettyUnitTestResultPrinter() = default;
static void PrintTestName(const char* test_suite, const char* test) { static void PrintTestName(const char* test_suite, const char* test) {
printf("%s.%s", test_suite, test); printf("%s.%s", test_suite, test);
} }
@ -3642,7 +3674,7 @@ void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
// Class BriefUnitTestResultPrinter is copyable. // Class BriefUnitTestResultPrinter is copyable.
class BriefUnitTestResultPrinter : public TestEventListener { class BriefUnitTestResultPrinter : public TestEventListener {
public: public:
BriefUnitTestResultPrinter() {} BriefUnitTestResultPrinter() = default;
static void PrintTestName(const char* test_suite, const char* test) { static void PrintTestName(const char* test_suite, const char* test) {
printf("%s.%s", test_suite, test); printf("%s.%s", test_suite, test);
} }
@ -3757,28 +3789,28 @@ class TestEventRepeater : public TestEventListener {
bool forwarding_enabled() const { return forwarding_enabled_; } bool forwarding_enabled() const { return forwarding_enabled_; }
void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; } void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; }
void OnTestProgramStart(const UnitTest& unit_test) override; void OnTestProgramStart(const UnitTest& parameter) override;
void OnTestIterationStart(const UnitTest& unit_test, int iteration) override; void OnTestIterationStart(const UnitTest& unit_test, int iteration) override;
void OnEnvironmentsSetUpStart(const UnitTest& unit_test) override; void OnEnvironmentsSetUpStart(const UnitTest& parameter) override;
void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) override; void OnEnvironmentsSetUpEnd(const UnitTest& parameter) override;
// Legacy API is deprecated but still available // Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
void OnTestCaseStart(const TestSuite& parameter) override; void OnTestCaseStart(const TestSuite& parameter) override;
#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
void OnTestSuiteStart(const TestSuite& parameter) override; void OnTestSuiteStart(const TestSuite& parameter) override;
void OnTestStart(const TestInfo& test_info) override; void OnTestStart(const TestInfo& parameter) override;
void OnTestDisabled(const TestInfo& test_info) override; void OnTestDisabled(const TestInfo& parameter) override;
void OnTestPartResult(const TestPartResult& result) override; void OnTestPartResult(const TestPartResult& parameter) override;
void OnTestEnd(const TestInfo& test_info) override; void OnTestEnd(const TestInfo& parameter) override;
// Legacy API is deprecated but still available // Legacy API is deprecated but still available
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_ #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
void OnTestCaseEnd(const TestCase& parameter) override; void OnTestCaseEnd(const TestCase& parameter) override;
#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_ #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
void OnTestSuiteEnd(const TestSuite& parameter) override; void OnTestSuiteEnd(const TestSuite& parameter) override;
void OnEnvironmentsTearDownStart(const UnitTest& unit_test) override; void OnEnvironmentsTearDownStart(const UnitTest& parameter) override;
void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) override; void OnEnvironmentsTearDownEnd(const UnitTest& parameter) override;
void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override; void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
void OnTestProgramEnd(const UnitTest& unit_test) override; void OnTestProgramEnd(const UnitTest& parameter) override;
private: private:
// Controls whether events will be forwarded to listeners_. Set to false // Controls whether events will be forwarded to listeners_. Set to false
@ -4953,7 +4985,7 @@ const char* const OsStackTraceGetterInterface::kElidedFramesMarker =
std::string OsStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count) std::string OsStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count)
GTEST_LOCK_EXCLUDED_(mutex_) { GTEST_LOCK_EXCLUDED_(mutex_) {
#if GTEST_HAS_ABSL #ifdef GTEST_HAS_ABSL
std::string result; std::string result;
if (max_depth <= 0) { if (max_depth <= 0) {
@ -5002,7 +5034,7 @@ std::string OsStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count)
} }
void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) { void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {
#if GTEST_HAS_ABSL #ifdef GTEST_HAS_ABSL
void* caller_frame = nullptr; void* caller_frame = nullptr;
if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) { if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) {
caller_frame = nullptr; caller_frame = nullptr;
@ -5013,7 +5045,7 @@ void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {
#endif // GTEST_HAS_ABSL #endif // GTEST_HAS_ABSL
} }
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
// A helper class that creates the premature-exit file in its // A helper class that creates the premature-exit file in its
// constructor and deletes the file in its destructor. // constructor and deletes the file in its destructor.
class ScopedPrematureExitFile { class ScopedPrematureExitFile {
@ -5033,7 +5065,7 @@ class ScopedPrematureExitFile {
} }
~ScopedPrematureExitFile() { ~ScopedPrematureExitFile() {
#if !GTEST_OS_ESP8266 #ifndef GTEST_OS_ESP8266
if (!premature_exit_filepath_.empty()) { if (!premature_exit_filepath_.empty()) {
int retval = remove(premature_exit_filepath_.c_str()); int retval = remove(premature_exit_filepath_.c_str());
if (retval) { if (retval) {
@ -5301,7 +5333,7 @@ void UnitTest::AddTestPartResult(TestPartResult::Type result_type,
msg << message; msg << message;
internal::MutexLock lock(&mutex_); internal::MutexLock lock(&mutex_);
if (impl_->gtest_trace_stack().size() > 0) { if (!impl_->gtest_trace_stack().empty()) {
msg << "\n" << GTEST_NAME_ << " trace:"; msg << "\n" << GTEST_NAME_ << " trace:";
for (size_t i = impl_->gtest_trace_stack().size(); i > 0; --i) { for (size_t i = impl_->gtest_trace_stack().size(); i > 0; --i) {
@ -5314,6 +5346,8 @@ void UnitTest::AddTestPartResult(TestPartResult::Type result_type,
if (os_stack_trace.c_str() != nullptr && !os_stack_trace.empty()) { if (os_stack_trace.c_str() != nullptr && !os_stack_trace.empty()) {
msg << internal::kStackTraceMarker << os_stack_trace; msg << internal::kStackTraceMarker << os_stack_trace;
} else {
msg << "\n";
} }
const TestPartResult result = TestPartResult( const TestPartResult result = TestPartResult(
@ -5329,7 +5363,8 @@ void UnitTest::AddTestPartResult(TestPartResult::Type result_type,
// with another testing framework) and specify the former on the // with another testing framework) and specify the former on the
// command line for debugging. // command line for debugging.
if (GTEST_FLAG_GET(break_on_failure)) { if (GTEST_FLAG_GET(break_on_failure)) {
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT #if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_PHONE) && \
!defined(GTEST_OS_WINDOWS_RT)
// Using DebugBreak on Windows allows gtest to still break into a debugger // Using DebugBreak on Windows allows gtest to still break into a debugger
// when a failure happens and both the --gtest_break_on_failure and // when a failure happens and both the --gtest_break_on_failure and
// the --gtest_catch_exceptions flags are specified. // the --gtest_catch_exceptions flags are specified.
@ -5377,7 +5412,7 @@ void UnitTest::RecordProperty(const std::string& key,
// We don't protect this under mutex_, as we only support calling it // We don't protect this under mutex_, as we only support calling it
// from the main thread. // from the main thread.
int UnitTest::Run() { int UnitTest::Run() {
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
const bool in_death_test_child_process = const bool in_death_test_child_process =
GTEST_FLAG_GET(internal_run_death_test).length() > 0; GTEST_FLAG_GET(internal_run_death_test).length() > 0;
@ -5406,32 +5441,36 @@ int UnitTest::Run() {
in_death_test_child_process in_death_test_child_process
? nullptr ? nullptr
: internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE")); : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
#else
const bool in_death_test_child_process = false;
#endif // GTEST_HAS_DEATH_TEST #endif // GTEST_HAS_DEATH_TEST
// Captures the value of GTEST_FLAG(catch_exceptions). This value will be // Captures the value of GTEST_FLAG(catch_exceptions). This value will be
// used for the duration of the program. // used for the duration of the program.
impl()->set_catch_exceptions(GTEST_FLAG_GET(catch_exceptions)); impl()->set_catch_exceptions(GTEST_FLAG_GET(catch_exceptions));
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
// Either the user wants Google Test to catch exceptions thrown by the // Either the user wants Google Test to catch exceptions thrown by the
// tests or this is executing in the context of death test child // tests or this is executing in the context of death test child
// process. In either case the user does not want to see pop-up dialogs // process. In either case the user does not want to see pop-up dialogs
// about crashes - they are expected. // about crashes - they are expected.
if (impl()->catch_exceptions() || in_death_test_child_process) { if (impl()->catch_exceptions() || in_death_test_child_process) {
#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT #if !defined(GTEST_OS_WINDOWS_MOBILE) && !defined(GTEST_OS_WINDOWS_PHONE) && \
!defined(GTEST_OS_WINDOWS_RT)
// SetErrorMode doesn't exist on CE. // SetErrorMode doesn't exist on CE.
SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT | SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX); SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
#endif // !GTEST_OS_WINDOWS_MOBILE #endif // !GTEST_OS_WINDOWS_MOBILE
#if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE #if (defined(_MSC_VER) || defined(GTEST_OS_WINDOWS_MINGW)) && \
!defined(GTEST_OS_WINDOWS_MOBILE)
// Death test children can be terminated with _abort(). On Windows, // Death test children can be terminated with _abort(). On Windows,
// _abort() can show a dialog with a warning message. This forces the // _abort() can show a dialog with a warning message. This forces the
// abort message to go to stderr instead. // abort message to go to stderr instead.
_set_error_mode(_OUT_TO_STDERR); _set_error_mode(_OUT_TO_STDERR);
#endif #endif
#if defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE #if defined(_MSC_VER) && !defined(GTEST_OS_WINDOWS_MOBILE)
// In the debug version, Visual Studio pops up a separate dialog // In the debug version, Visual Studio pops up a separate dialog
// offering a choice to debug the aborted program. We need to suppress // offering a choice to debug the aborted program. We need to suppress
// this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
@ -5453,6 +5492,8 @@ int UnitTest::Run() {
} }
#endif #endif
} }
#else
(void)in_death_test_child_process; // Needed inside the #if block above
#endif // GTEST_OS_WINDOWS #endif // GTEST_OS_WINDOWS
return internal::HandleExceptionsInMethodIfSupported( return internal::HandleExceptionsInMethodIfSupported(
@ -5548,7 +5589,7 @@ UnitTestImpl::UnitTestImpl(UnitTest* parent)
random_(0), // Will be reseeded before first use. random_(0), // Will be reseeded before first use.
start_timestamp_(0), start_timestamp_(0),
elapsed_time_(0), elapsed_time_(0),
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
death_test_factory_(new DefaultDeathTestFactory), death_test_factory_(new DefaultDeathTestFactory),
#endif #endif
// Will be overridden by the flag before first use. // Will be overridden by the flag before first use.
@ -5588,11 +5629,11 @@ void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
test_result->RecordProperty(xml_element, test_property); test_result->RecordProperty(xml_element, test_property);
} }
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
// Disables event forwarding if the control is currently in a death test // Disables event forwarding if the control is currently in a death test
// subprocess. Must not be called before InitGoogleTest. // subprocess. Must not be called before InitGoogleTest.
void UnitTestImpl::SuppressTestEventsIfInSubprocess() { void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
if (internal_run_death_test_flag_.get() != nullptr) if (internal_run_death_test_flag_ != nullptr)
listeners()->SuppressEventForwarding(); listeners()->SuppressEventForwarding();
} }
#endif // GTEST_HAS_DEATH_TEST #endif // GTEST_HAS_DEATH_TEST
@ -5608,7 +5649,7 @@ void UnitTestImpl::ConfigureXmlOutput() {
} else if (output_format == "json") { } else if (output_format == "json") {
listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter( listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(
UnitTestOptions::GetAbsolutePathToOutputFile().c_str())); UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
} else if (output_format != "") { } else if (!output_format.empty()) {
GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \"" GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
<< output_format << "\" ignored."; << output_format << "\" ignored.";
} }
@ -5651,7 +5692,7 @@ void UnitTestImpl::PostFlagParsingInit() {
listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_()); listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
#endif // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_) #endif // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
InitDeathTestSubprocessControlInfo(); InitDeathTestSubprocessControlInfo();
SuppressTestEventsIfInSubprocess(); SuppressTestEventsIfInSubprocess();
#endif // GTEST_HAS_DEATH_TEST #endif // GTEST_HAS_DEATH_TEST
@ -5674,7 +5715,7 @@ void UnitTestImpl::PostFlagParsingInit() {
ConfigureStreamingOutput(); ConfigureStreamingOutput();
#endif // GTEST_CAN_STREAM_RESULTS_ #endif // GTEST_CAN_STREAM_RESULTS_
#if GTEST_HAS_ABSL #ifdef GTEST_HAS_ABSL
if (GTEST_FLAG_GET(install_failure_signal_handler)) { if (GTEST_FLAG_GET(install_failure_signal_handler)) {
absl::FailureSignalHandlerOptions options; absl::FailureSignalHandlerOptions options;
absl::InstallFailureSignalHandler(options); absl::InstallFailureSignalHandler(options);
@ -5789,9 +5830,8 @@ bool UnitTestImpl::RunAllTests() {
// death test. // death test.
bool in_subprocess_for_death_test = false; bool in_subprocess_for_death_test = false;
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
in_subprocess_for_death_test = in_subprocess_for_death_test = (internal_run_death_test_flag_ != nullptr);
(internal_run_death_test_flag_.get() != nullptr);
#if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_) #if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
if (in_subprocess_for_death_test) { if (in_subprocess_for_death_test) {
GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_(); GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
@ -5954,10 +5994,6 @@ bool UnitTestImpl::RunAllTests() {
"() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_ "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_
" will start to enforce the valid usage. " " will start to enforce the valid usage. "
"Please fix it ASAP, or IT WILL START TO FAIL.\n"); // NOLINT "Please fix it ASAP, or IT WILL START TO FAIL.\n"); // NOLINT
#if GTEST_FOR_GOOGLE_
ColoredPrintf(GTestColor::kRed,
"For more details, see http://wiki/Main/ValidGUnitMain.\n");
#endif // GTEST_FOR_GOOGLE_
} }
return !failed; return !failed;
@ -6513,7 +6549,7 @@ static const char kColorEncodedHelpMessage[] =
#endif // GTEST_CAN_STREAM_RESULTS_ #endif // GTEST_CAN_STREAM_RESULTS_
"\n" "\n"
"Assertion Behavior:\n" "Assertion Behavior:\n"
#if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS #if defined(GTEST_HAS_DEATH_TEST) && !defined(GTEST_OS_WINDOWS)
" @G--" GTEST_FLAG_PREFIX_ " @G--" GTEST_FLAG_PREFIX_
"death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n" "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n"
" Set the default death test style.\n" " Set the default death test style.\n"
@ -6654,26 +6690,60 @@ void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
} }
// Parses the command line for Google Test flags, without initializing // Parses the command line for Google Test flags, without initializing
// other parts of Google Test. // other parts of Google Test. This function updates argc and argv by removing
// flags that are known to GoogleTest (including other user flags defined using
// ABSL_FLAG if GoogleTest is built with GTEST_USE_ABSL). Other arguments
// remain in place. Unrecognized flags are not reported and do not cause the
// program to exit.
void ParseGoogleTestFlagsOnly(int* argc, char** argv) { void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
#if GTEST_HAS_ABSL #ifdef GTEST_HAS_ABSL
if (*argc > 0) { if (*argc <= 0) return;
// absl::ParseCommandLine() requires *argc > 0.
auto positional_args = absl::flags_internal::ParseCommandLineImpl( std::vector<char*> positional_args;
*argc, argv, absl::flags_internal::ArgvListAction::kRemoveParsedArgs, std::vector<absl::UnrecognizedFlag> unrecognized_flags;
absl::flags_internal::UsageFlagsAction::kHandleUsage, absl::ParseAbseilFlagsOnly(*argc, argv, positional_args, unrecognized_flags);
absl::flags_internal::OnUndefinedFlag::kReportUndefined); absl::flat_hash_set<absl::string_view> unrecognized;
// Any command-line positional arguments not part of any command-line flag for (const auto& flag : unrecognized_flags) {
// (or arguments to a flag) are copied back out to argv, with the program unrecognized.insert(flag.flag_name);
// invocation name at position 0, and argc is resized. This includes }
// positional arguments after the flag-terminating delimiter '--'. absl::flat_hash_set<char*> positional;
// See https://abseil.io/docs/cpp/guides/flags. for (const auto& arg : positional_args) {
std::copy(positional_args.begin(), positional_args.end(), argv); positional.insert(arg);
if (static_cast<int>(positional_args.size()) < *argc) { }
argv[positional_args.size()] = nullptr;
*argc = static_cast<int>(positional_args.size()); int out_pos = 1;
int in_pos = 1;
for (; in_pos < *argc; ++in_pos) {
char* arg = argv[in_pos];
absl::string_view arg_str(arg);
if (absl::ConsumePrefix(&arg_str, "--")) {
// Flag-like argument. If the flag was unrecognized, keep it.
// If it was a GoogleTest flag, remove it.
if (unrecognized.contains(arg_str)) {
argv[out_pos++] = argv[in_pos];
continue;
}
}
if (arg_str.empty()) {
++in_pos;
break; // '--' indicates that the rest of the arguments are positional
}
// Probably a positional argument. If it is in fact positional, keep it.
// If it was a value for the flag argument, remove it.
if (positional.contains(arg)) {
argv[out_pos++] = arg;
} }
} }
// The rest are positional args for sure.
while (in_pos < *argc) {
argv[out_pos++] = argv[in_pos++];
}
*argc = out_pos;
argv[out_pos] = nullptr;
#else #else
ParseGoogleTestFlagsOnlyImpl(argc, argv); ParseGoogleTestFlagsOnlyImpl(argc, argv);
#endif #endif
@ -6681,7 +6751,7 @@ void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
// Fix the value of *_NSGetArgc() on macOS, but if and only if // Fix the value of *_NSGetArgc() on macOS, but if and only if
// *_NSGetArgv() == argv // *_NSGetArgv() == argv
// Only applicable to char** version of argv // Only applicable to char** version of argv
#if GTEST_OS_MAC #ifdef GTEST_OS_MAC
#ifndef GTEST_OS_IOS #ifndef GTEST_OS_IOS
if (*_NSGetArgv() == argv) { if (*_NSGetArgv() == argv) {
*_NSGetArgc() = *argc; *_NSGetArgc() = *argc;
@ -6709,7 +6779,7 @@ void InitGoogleTestImpl(int* argc, CharType** argv) {
g_argvs.push_back(StreamableToString(argv[i])); g_argvs.push_back(StreamableToString(argv[i]));
} }
#if GTEST_HAS_ABSL #ifdef GTEST_HAS_ABSL
absl::InitializeSymbolizer(g_argvs[0].c_str()); absl::InitializeSymbolizer(g_argvs[0].c_str());
// When using the Abseil Flags library, set the program usage message to the // When using the Abseil Flags library, set the program usage message to the
@ -6793,16 +6863,16 @@ static std::string GetDirFromEnv(
std::string TempDir() { std::string TempDir() {
#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_) #if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
return GTEST_CUSTOM_TEMPDIR_FUNCTION_(); return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
#elif GTEST_OS_WINDOWS || GTEST_OS_WINDOWS_MOBILE #elif defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_WINDOWS_MOBILE)
return GetDirFromEnv({"TEST_TMPDIR", "TEMP"}, "\\temp\\", '\\'); return GetDirFromEnv({"TEST_TMPDIR", "TEMP"}, "\\temp\\", '\\');
#elif GTEST_OS_LINUX_ANDROID #elif defined(GTEST_OS_LINUX_ANDROID)
return GetDirFromEnv({"TEST_TMPDIR", "TMPDIR"}, "/data/local/tmp/", '/'); return GetDirFromEnv({"TEST_TMPDIR", "TMPDIR"}, "/data/local/tmp/", '/');
#else #else
return GetDirFromEnv({"TEST_TMPDIR", "TMPDIR"}, "/tmp/", '/'); return GetDirFromEnv({"TEST_TMPDIR", "TMPDIR"}, "/tmp/", '/');
#endif #endif
} }
#if !defined(GTEST_CUSTOM_SRCDIR_FUNCTION_) #if GTEST_HAS_FILE_SYSTEM && !defined(GTEST_CUSTOM_SRCDIR_FUNCTION_)
// Returns the directory path (including terminating separator) of the current // Returns the directory path (including terminating separator) of the current
// executable as derived from argv[0]. // executable as derived from argv[0].
static std::string GetCurrentExecutableDirectory() { static std::string GetCurrentExecutableDirectory() {
@ -6811,13 +6881,14 @@ static std::string GetCurrentExecutableDirectory() {
} }
#endif #endif
#if GTEST_HAS_FILE_SYSTEM
std::string SrcDir() { std::string SrcDir() {
#if defined(GTEST_CUSTOM_SRCDIR_FUNCTION_) #if defined(GTEST_CUSTOM_SRCDIR_FUNCTION_)
return GTEST_CUSTOM_SRCDIR_FUNCTION_(); return GTEST_CUSTOM_SRCDIR_FUNCTION_();
#elif GTEST_OS_WINDOWS || GTEST_OS_WINDOWS_MOBILE #elif defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_WINDOWS_MOBILE)
return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(), return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(),
'\\'); '\\');
#elif GTEST_OS_LINUX_ANDROID #elif defined(GTEST_OS_LINUX_ANDROID)
return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(), return GetDirFromEnv({"TEST_SRCDIR"}, GetCurrentExecutableDirectory().c_str(),
'/'); '/');
#else #else
@ -6825,6 +6896,7 @@ std::string SrcDir() {
'/'); '/');
#endif #endif
} }
#endif
// Class ScopedTrace // Class ScopedTrace

8
googletest/src/gtest_main.cc
View File

@ -31,10 +31,10 @@
#include "gtest/gtest.h" #include "gtest/gtest.h"
#if GTEST_OS_ESP8266 || GTEST_OS_ESP32 #if defined(GTEST_OS_ESP8266) || defined(GTEST_OS_ESP32)
// Arduino-like platforms: program entry points are setup/loop instead of main. // Arduino-like platforms: program entry points are setup/loop instead of main.
#if GTEST_OS_ESP8266 #ifdef GTEST_OS_ESP8266
extern "C" { extern "C" {
#endif #endif
@ -42,11 +42,11 @@ void setup() { testing::InitGoogleTest(); }
void loop() { RUN_ALL_TESTS(); } void loop() { RUN_ALL_TESTS(); }
#if GTEST_OS_ESP8266 #ifdef GTEST_OS_ESP8266
} }
#endif #endif
#elif GTEST_OS_QURT #elif defined(GTEST_OS_QURT)
// QuRT: program entry point is main, but argc/argv are unusable. // QuRT: program entry point is main, but argc/argv are unusable.
GTEST_API_ int main() { GTEST_API_ int main() {

8
googletest/test/googletest-break-on-failure-unittest_.cc
View File

@ -39,7 +39,7 @@
#include "gtest/gtest.h" #include "gtest/gtest.h"
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
#include <stdlib.h> #include <stdlib.h>
#include <windows.h> #include <windows.h>
#endif #endif
@ -49,7 +49,7 @@ namespace {
// A test that's expected to fail. // A test that's expected to fail.
TEST(Foo, Bar) { EXPECT_EQ(2, 3); } TEST(Foo, Bar) { EXPECT_EQ(2, 3); }
#if GTEST_HAS_SEH && !GTEST_OS_WINDOWS_MOBILE #if GTEST_HAS_SEH && !defined(GTEST_OS_WINDOWS_MOBILE)
// On Windows Mobile global exception handlers are not supported. // On Windows Mobile global exception handlers are not supported.
LONG WINAPI LONG WINAPI
ExitWithExceptionCode(struct _EXCEPTION_POINTERS* exception_pointers) { ExitWithExceptionCode(struct _EXCEPTION_POINTERS* exception_pointers) {
@ -60,12 +60,12 @@ ExitWithExceptionCode(struct _EXCEPTION_POINTERS* exception_pointers) {
} // namespace } // namespace
int main(int argc, char** argv) { int main(int argc, char** argv) {
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
// Suppresses display of the Windows error dialog upon encountering // Suppresses display of the Windows error dialog upon encountering
// a general protection fault (segment violation). // a general protection fault (segment violation).
SetErrorMode(SEM_NOGPFAULTERRORBOX | SEM_FAILCRITICALERRORS); SetErrorMode(SEM_NOGPFAULTERRORBOX | SEM_FAILCRITICALERRORS);
#if GTEST_HAS_SEH && !GTEST_OS_WINDOWS_MOBILE #if GTEST_HAS_SEH && !defined(GTEST_OS_WINDOWS_MOBILE)
// The default unhandled exception filter does not always exit // The default unhandled exception filter does not always exit
// with the exception code as exit code - for example it exits with // with the exception code as exit code - for example it exits with

31
googletest/test/googletest-death-test-test.cc
View File

@ -37,9 +37,9 @@
using testing::internal::AlwaysFalse; using testing::internal::AlwaysFalse;
using testing::internal::AlwaysTrue; using testing::internal::AlwaysTrue;
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
#include <direct.h> // For chdir(). #include <direct.h> // For chdir().
#include <fcntl.h> // For O_BINARY #include <fcntl.h> // For O_BINARY
#include <io.h> #include <io.h>
@ -52,7 +52,10 @@ using testing::internal::AlwaysTrue;
#include <signal.h> #include <signal.h>
#include <stdio.h> #include <stdio.h>
#if GTEST_OS_LINUX #include <string>
#include <vector>
#ifdef GTEST_OS_LINUX
#include <sys/time.h> #include <sys/time.h>
#endif // GTEST_OS_LINUX #endif // GTEST_OS_LINUX
@ -200,7 +203,7 @@ int DieInDebugElse12(int* sideeffect) {
return 12; return 12;
} }
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
// Death in dbg due to Windows CRT assertion failure, not opt. // Death in dbg due to Windows CRT assertion failure, not opt.
int DieInCRTDebugElse12(int* sideeffect) { int DieInCRTDebugElse12(int* sideeffect) {
@ -220,7 +223,7 @@ int DieInCRTDebugElse12(int* sideeffect) {
#endif // GTEST_OS_WINDOWS #endif // GTEST_OS_WINDOWS
#if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA #if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_FUCHSIA)
// Tests the ExitedWithCode predicate. // Tests the ExitedWithCode predicate.
TEST(ExitStatusPredicateTest, ExitedWithCode) { TEST(ExitStatusPredicateTest, ExitedWithCode) {
@ -374,7 +377,7 @@ TEST_F(TestForDeathTest, FastDeathTestInChangedDir) {
ASSERT_DEATH(_exit(1), ""); ASSERT_DEATH(_exit(1), "");
} }
#if GTEST_OS_LINUX #ifdef GTEST_OS_LINUX
void SigprofAction(int, siginfo_t*, void*) { /* no op */ void SigprofAction(int, siginfo_t*, void*) { /* no op */
} }
@ -641,7 +644,7 @@ TEST_F(TestForDeathTest, TestExpectDebugDeath) {
#endif #endif
} }
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
// https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/crtsetreportmode // https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/crtsetreportmode
// In debug mode, the calls to _CrtSetReportMode and _CrtSetReportFile enable // In debug mode, the calls to _CrtSetReportMode and _CrtSetReportFile enable
@ -693,7 +696,7 @@ void ExpectDebugDeathHelper(bool* aborted) {
*aborted = false; *aborted = false;
} }
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
TEST(PopUpDeathTest, DoesNotShowPopUpOnAbort) { TEST(PopUpDeathTest, DoesNotShowPopUpOnAbort) {
printf( printf(
"This test should be considered failing if it shows " "This test should be considered failing if it shows "
@ -805,14 +808,14 @@ static void TestExitMacros() {
EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), ""); EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");
ASSERT_EXIT(_exit(42), testing::ExitedWithCode(42), ""); ASSERT_EXIT(_exit(42), testing::ExitedWithCode(42), "");
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
// Of all signals effects on the process exit code, only those of SIGABRT // Of all signals effects on the process exit code, only those of SIGABRT
// are documented on Windows. // are documented on Windows.
// See https://msdn.microsoft.com/en-us/query-bi/m/dwwzkt4c. // See https://msdn.microsoft.com/en-us/query-bi/m/dwwzkt4c.
EXPECT_EXIT(raise(SIGABRT), testing::ExitedWithCode(3), "") << "b_ar"; EXPECT_EXIT(raise(SIGABRT), testing::ExitedWithCode(3), "") << "b_ar";
#elif !GTEST_OS_FUCHSIA #elif !defined(GTEST_OS_FUCHSIA)
// Fuchsia has no unix signals. // Fuchsia has no unix signals.
EXPECT_EXIT(raise(SIGKILL), testing::KilledBySignal(SIGKILL), "") << "foo"; EXPECT_EXIT(raise(SIGKILL), testing::KilledBySignal(SIGKILL), "") << "foo";
@ -1177,7 +1180,7 @@ TEST(GetLastErrnoDescription, GetLastErrnoDescriptionWorks) {
EXPECT_STREQ("", GetLastErrnoDescription().c_str()); EXPECT_STREQ("", GetLastErrnoDescription().c_str());
} }
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
TEST(AutoHandleTest, AutoHandleWorks) { TEST(AutoHandleTest, AutoHandleWorks) {
HANDLE handle = ::CreateEvent(NULL, FALSE, FALSE, NULL); HANDLE handle = ::CreateEvent(NULL, FALSE, FALSE, NULL);
ASSERT_NE(INVALID_HANDLE_VALUE, handle); ASSERT_NE(INVALID_HANDLE_VALUE, handle);
@ -1204,7 +1207,7 @@ TEST(AutoHandleTest, AutoHandleWorks) {
} }
#endif // GTEST_OS_WINDOWS #endif // GTEST_OS_WINDOWS
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
typedef unsigned __int64 BiggestParsable; typedef unsigned __int64 BiggestParsable;
typedef signed __int64 BiggestSignedParsable; typedef signed __int64 BiggestSignedParsable;
#else #else
@ -1301,7 +1304,7 @@ TEST(ParseNaturalNumberTest, WorksForShorterIntegers) {
EXPECT_EQ(123, char_result); EXPECT_EQ(123, char_result);
} }
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
TEST(EnvironmentTest, HandleFitsIntoSizeT) { TEST(EnvironmentTest, HandleFitsIntoSizeT) {
ASSERT_TRUE(sizeof(HANDLE) <= sizeof(size_t)); ASSERT_TRUE(sizeof(HANDLE) <= sizeof(size_t));
} }
@ -1353,7 +1356,7 @@ void DieWithMessage(const char* message) {
TEST(MatcherDeathTest, DoesNotBreakBareRegexMatching) { TEST(MatcherDeathTest, DoesNotBreakBareRegexMatching) {
// googletest tests this, of course; here we ensure that including googlemock // googletest tests this, of course; here we ensure that including googlemock
// has not broken it. // has not broken it.
#if GTEST_USES_POSIX_RE #ifdef GTEST_USES_POSIX_RE
EXPECT_DEATH(DieWithMessage("O, I die, Horatio."), "I d[aeiou]e"); EXPECT_DEATH(DieWithMessage("O, I die, Horatio."), "I d[aeiou]e");
#else #else
EXPECT_DEATH(DieWithMessage("O, I die, Horatio."), "I di?e"); EXPECT_DEATH(DieWithMessage("O, I die, Horatio."), "I di?e");

2
googletest/test/googletest-death-test_ex_test.cc
View File

@ -33,7 +33,7 @@
#include "gtest/gtest-death-test.h" #include "gtest/gtest-death-test.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
#if GTEST_HAS_SEH #if GTEST_HAS_SEH
#include <windows.h> // For RaiseException(). #include <windows.h> // For RaiseException().

26
googletest/test/googletest-filepath-test.cc
View File

@ -41,9 +41,9 @@
#include "gtest/internal/gtest-filepath.h" #include "gtest/internal/gtest-filepath.h"
#include "src/gtest-internal-inl.h" #include "src/gtest-internal-inl.h"
#if GTEST_OS_WINDOWS_MOBILE #ifdef GTEST_OS_WINDOWS_MOBILE
#include <windows.h> // NOLINT #include <windows.h> // NOLINT
#elif GTEST_OS_WINDOWS #elif defined(GTEST_OS_WINDOWS)
#include <direct.h> // NOLINT #include <direct.h> // NOLINT
#endif // GTEST_OS_WINDOWS_MOBILE #endif // GTEST_OS_WINDOWS_MOBILE
@ -51,7 +51,7 @@ namespace testing {
namespace internal { namespace internal {
namespace { namespace {
#if GTEST_OS_WINDOWS_MOBILE #ifdef GTEST_OS_WINDOWS_MOBILE
// Windows CE doesn't have the remove C function. // Windows CE doesn't have the remove C function.
int remove(const char* path) { int remove(const char* path) {
@ -80,7 +80,7 @@ TEST(GetCurrentDirTest, ReturnsCurrentDir) {
const FilePath cwd = FilePath::GetCurrentDir(); const FilePath cwd = FilePath::GetCurrentDir();
posix::ChDir(original_dir.c_str()); posix::ChDir(original_dir.c_str());
#if GTEST_OS_WINDOWS || GTEST_OS_OS2 #if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_OS2)
// Skips the ":". // Skips the ":".
const char* const cwd_without_drive = strchr(cwd.c_str(), ':'); const char* const cwd_without_drive = strchr(cwd.c_str(), ':');
@ -174,7 +174,7 @@ TEST(RemoveDirectoryNameTest, ShouldAlsoGiveFileNameForAlternateSeparator) {
// RemoveFileName "" -> "./" // RemoveFileName "" -> "./"
TEST(RemoveFileNameTest, EmptyName) { TEST(RemoveFileNameTest, EmptyName) {
#if GTEST_OS_WINDOWS_MOBILE #ifdef GTEST_OS_WINDOWS_MOBILE
// On Windows CE, we use the root as the current directory. // On Windows CE, we use the root as the current directory.
EXPECT_EQ(GTEST_PATH_SEP_, FilePath("").RemoveFileName().string()); EXPECT_EQ(GTEST_PATH_SEP_, FilePath("").RemoveFileName().string());
#else #else
@ -357,7 +357,7 @@ TEST(RemoveTrailingPathSeparatorTest, ShouldReturnUnmodified) {
} }
TEST(DirectoryTest, RootDirectoryExists) { TEST(DirectoryTest, RootDirectoryExists) {
#if GTEST_OS_WINDOWS // We are on Windows. #ifdef GTEST_OS_WINDOWS // We are on Windows.
char current_drive[_MAX_PATH]; // NOLINT char current_drive[_MAX_PATH]; // NOLINT
current_drive[0] = static_cast<char>(_getdrive() + 'A' - 1); current_drive[0] = static_cast<char>(_getdrive() + 'A' - 1);
current_drive[1] = ':'; current_drive[1] = ':';
@ -369,7 +369,7 @@ TEST(DirectoryTest, RootDirectoryExists) {
#endif // GTEST_OS_WINDOWS #endif // GTEST_OS_WINDOWS
} }
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
TEST(DirectoryTest, RootOfWrongDriveDoesNotExists) { TEST(DirectoryTest, RootOfWrongDriveDoesNotExists) {
const int saved_drive_ = _getdrive(); const int saved_drive_ = _getdrive();
// Find a drive that doesn't exist. Start with 'Z' to avoid common ones. // Find a drive that doesn't exist. Start with 'Z' to avoid common ones.
@ -387,7 +387,7 @@ TEST(DirectoryTest, RootOfWrongDriveDoesNotExists) {
} }
#endif // GTEST_OS_WINDOWS #endif // GTEST_OS_WINDOWS
#if !GTEST_OS_WINDOWS_MOBILE #ifndef GTEST_OS_WINDOWS_MOBILE
// Windows CE _does_ consider an empty directory to exist. // Windows CE _does_ consider an empty directory to exist.
TEST(DirectoryTest, EmptyPathDirectoryDoesNotExist) { TEST(DirectoryTest, EmptyPathDirectoryDoesNotExist) {
EXPECT_FALSE(FilePath("").DirectoryExists()); EXPECT_FALSE(FilePath("").DirectoryExists());
@ -395,7 +395,7 @@ TEST(DirectoryTest, EmptyPathDirectoryDoesNotExist) {
#endif // !GTEST_OS_WINDOWS_MOBILE #endif // !GTEST_OS_WINDOWS_MOBILE
TEST(DirectoryTest, CurrentDirectoryExists) { TEST(DirectoryTest, CurrentDirectoryExists) {
#if GTEST_OS_WINDOWS // We are on Windows. #ifdef GTEST_OS_WINDOWS // We are on Windows.
#ifndef _WIN32_CE // Windows CE doesn't have a current directory. #ifndef _WIN32_CE // Windows CE doesn't have a current directory.
EXPECT_TRUE(FilePath(".").DirectoryExists()); EXPECT_TRUE(FilePath(".").DirectoryExists());
@ -423,7 +423,7 @@ TEST(NormalizeTest, MultipleConsecutiveSeparatorsInMidstring) {
// "/bar" == //bar" == "///bar" // "/bar" == //bar" == "///bar"
TEST(NormalizeTest, MultipleConsecutiveSeparatorsAtStringStart) { TEST(NormalizeTest, MultipleConsecutiveSeparatorsAtStringStart) {
EXPECT_EQ(GTEST_PATH_SEP_ "bar", FilePath(GTEST_PATH_SEP_ "bar").string()); EXPECT_EQ(GTEST_PATH_SEP_ "bar", FilePath(GTEST_PATH_SEP_ "bar").string());
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
EXPECT_EQ(GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar", EXPECT_EQ(GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar",
FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").string()); FilePath(GTEST_PATH_SEP_ GTEST_PATH_SEP_ "bar").string());
#else #else
@ -515,7 +515,7 @@ class DirectoryCreationTest : public Test {
} }
// Strings representing a directory and a file, with identical paths // Strings representing a directory and a file, with identical paths
// except for the trailing separator character that distinquishes // except for the trailing separator character that distinguishes
// a directory named 'test' from a file named 'test'. Example names: // a directory named 'test' from a file named 'test'. Example names:
FilePath testdata_path_; // "/tmp/directory_creation/test/" FilePath testdata_path_; // "/tmp/directory_creation/test/"
FilePath testdata_file_; // "/tmp/directory_creation/test" FilePath testdata_file_; // "/tmp/directory_creation/test"
@ -620,7 +620,7 @@ TEST(FilePathTest, IsDirectory) {
TEST(FilePathTest, IsAbsolutePath) { TEST(FilePathTest, IsAbsolutePath) {
EXPECT_FALSE(FilePath("is" GTEST_PATH_SEP_ "relative").IsAbsolutePath()); EXPECT_FALSE(FilePath("is" GTEST_PATH_SEP_ "relative").IsAbsolutePath());
EXPECT_FALSE(FilePath("").IsAbsolutePath()); EXPECT_FALSE(FilePath("").IsAbsolutePath());
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
EXPECT_TRUE( EXPECT_TRUE(
FilePath("c:\\" GTEST_PATH_SEP_ "is_not" GTEST_PATH_SEP_ "relative") FilePath("c:\\" GTEST_PATH_SEP_ "is_not" GTEST_PATH_SEP_ "relative")
.IsAbsolutePath()); .IsAbsolutePath());
@ -638,7 +638,7 @@ TEST(FilePathTest, IsAbsolutePath) {
} }
TEST(FilePathTest, IsRootDirectory) { TEST(FilePathTest, IsRootDirectory) {
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
EXPECT_TRUE(FilePath("a:\\").IsRootDirectory()); EXPECT_TRUE(FilePath("a:\\").IsRootDirectory());
EXPECT_TRUE(FilePath("Z:/").IsRootDirectory()); EXPECT_TRUE(FilePath("Z:/").IsRootDirectory());
EXPECT_TRUE(FilePath("e://").IsRootDirectory()); EXPECT_TRUE(FilePath("e://").IsRootDirectory());

12
googletest/test/googletest-json-outfiles-test.py
View File

@ -88,20 +88,20 @@ EXPECTED_2 = {
'time': '*', 'time': '*',
'timestamp': '*', 'timestamp': '*',
'testsuite': [{ 'testsuite': [{
'name': 'TestInt64Properties', 'name': 'TestInt64ConvertibleProperties',
'file': 'gtest_xml_outfile2_test_.cc', 'file': 'gtest_xml_outfile2_test_.cc',
'line': 41, 'line': 43,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'timestamp': '*', 'timestamp': '*',
'time': '*', 'time': '*',
'classname': 'PropertyTwo', 'classname': 'PropertyTwo',
'SetUpProp': '2', 'SetUpProp': '2',
'TestFloatProperty': '3', 'TestFloatProperty': '3.25',
'TestDoubleProperty': '4', 'TestDoubleProperty': '4.75',
'TestSizetProperty': '5', 'TestSizetProperty': '5',
'TestBoolProperty': '1', 'TestBoolProperty': 'true',
'TestCharProperty': '65', 'TestCharProperty': 'A',
'TestInt16Property': '6', 'TestInt16Property': '6',
'TestInt32Property': '7', 'TestInt32Property': '7',
'TestInt64Property': '8', 'TestInt64Property': '8',

56
googletest/test/googletest-json-output-unittest.py
View File

@ -54,7 +54,7 @@ SUPPORTS_STACK_TRACES = NO_STACKTRACE_SUPPORT_FLAG not in sys.argv
if SUPPORTS_STACK_TRACES: if SUPPORTS_STACK_TRACES:
STACK_TRACE_TEMPLATE = '\nStack trace:\n*' STACK_TRACE_TEMPLATE = '\nStack trace:\n*'
else: else:
STACK_TRACE_TEMPLATE = '' STACK_TRACE_TEMPLATE = '\n'
EXPECTED_NON_EMPTY = { EXPECTED_NON_EMPTY = {
'tests': 26, 'tests': 26,
@ -77,7 +77,7 @@ EXPECTED_NON_EMPTY = {
'testsuite': [{ 'testsuite': [{
'name': 'Succeeds', 'name': 'Succeeds',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 51, 'line': 53,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -96,7 +96,7 @@ EXPECTED_NON_EMPTY = {
'testsuite': [{ 'testsuite': [{
'name': 'Fails', 'name': 'Fails',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 59, 'line': 61,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -124,7 +124,7 @@ EXPECTED_NON_EMPTY = {
'testsuite': [{ 'testsuite': [{
'name': 'DISABLED_test_not_run', 'name': 'DISABLED_test_not_run',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 66, 'line': 68,
'status': 'NOTRUN', 'status': 'NOTRUN',
'result': 'SUPPRESSED', 'result': 'SUPPRESSED',
'time': '*', 'time': '*',
@ -144,7 +144,7 @@ EXPECTED_NON_EMPTY = {
{ {
'name': 'Skipped', 'name': 'Skipped',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 73, 'line': 75,
'status': 'RUN', 'status': 'RUN',
'result': 'SKIPPED', 'result': 'SKIPPED',
'time': '*', 'time': '*',
@ -154,7 +154,7 @@ EXPECTED_NON_EMPTY = {
{ {
'name': 'SkippedWithMessage', 'name': 'SkippedWithMessage',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 77, 'line': 79,
'status': 'RUN', 'status': 'RUN',
'result': 'SKIPPED', 'result': 'SKIPPED',
'time': '*', 'time': '*',
@ -164,7 +164,7 @@ EXPECTED_NON_EMPTY = {
{ {
'name': 'SkippedAfterFailure', 'name': 'SkippedAfterFailure',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 81, 'line': 83,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -194,7 +194,7 @@ EXPECTED_NON_EMPTY = {
{ {
'name': 'Succeeds', 'name': 'Succeeds',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 86, 'line': 88,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -204,7 +204,7 @@ EXPECTED_NON_EMPTY = {
{ {
'name': 'Fails', 'name': 'Fails',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 91, 'line': 93,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -234,7 +234,7 @@ EXPECTED_NON_EMPTY = {
{ {
'name': 'DISABLED_test', 'name': 'DISABLED_test',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 96, 'line': 98,
'status': 'NOTRUN', 'status': 'NOTRUN',
'result': 'SUPPRESSED', 'result': 'SUPPRESSED',
'time': '*', 'time': '*',
@ -254,7 +254,7 @@ EXPECTED_NON_EMPTY = {
'testsuite': [{ 'testsuite': [{
'name': 'OutputsCData', 'name': 'OutputsCData',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 100, 'line': 102,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -282,7 +282,7 @@ EXPECTED_NON_EMPTY = {
'testsuite': [{ 'testsuite': [{
'name': 'InvalidCharactersInMessage', 'name': 'InvalidCharactersInMessage',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 107, 'line': 109,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -313,7 +313,7 @@ EXPECTED_NON_EMPTY = {
{ {
'name': 'OneProperty', 'name': 'OneProperty',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 119, 'line': 121,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -324,7 +324,7 @@ EXPECTED_NON_EMPTY = {
{ {
'name': 'IntValuedProperty', 'name': 'IntValuedProperty',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 123, 'line': 125,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -335,7 +335,7 @@ EXPECTED_NON_EMPTY = {
{ {
'name': 'ThreeProperties', 'name': 'ThreeProperties',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 127, 'line': 129,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -348,7 +348,7 @@ EXPECTED_NON_EMPTY = {
{ {
'name': 'TwoValuesForOneKeyUsesLastValue', 'name': 'TwoValuesForOneKeyUsesLastValue',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 133, 'line': 135,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -370,7 +370,7 @@ EXPECTED_NON_EMPTY = {
{ {
'name': 'RecordProperty', 'name': 'RecordProperty',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 138, 'line': 140,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -381,7 +381,7 @@ EXPECTED_NON_EMPTY = {
{ {
'name': 'ExternalUtilityThatCallsRecordIntValuedProperty', 'name': 'ExternalUtilityThatCallsRecordIntValuedProperty',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 151, 'line': 153,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -394,7 +394,7 @@ EXPECTED_NON_EMPTY = {
'ExternalUtilityThatCallsRecordStringValuedProperty' 'ExternalUtilityThatCallsRecordStringValuedProperty'
), ),
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 155, 'line': 157,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -416,7 +416,7 @@ EXPECTED_NON_EMPTY = {
'name': 'HasTypeParamAttribute', 'name': 'HasTypeParamAttribute',
'type_param': 'int', 'type_param': 'int',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 171, 'line': 173,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -436,7 +436,7 @@ EXPECTED_NON_EMPTY = {
'name': 'HasTypeParamAttribute', 'name': 'HasTypeParamAttribute',
'type_param': 'long', 'type_param': 'long',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 171, 'line': 173,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -456,7 +456,7 @@ EXPECTED_NON_EMPTY = {
'name': 'HasTypeParamAttribute', 'name': 'HasTypeParamAttribute',
'type_param': 'int', 'type_param': 'int',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 178, 'line': 180,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -476,7 +476,7 @@ EXPECTED_NON_EMPTY = {
'name': 'HasTypeParamAttribute', 'name': 'HasTypeParamAttribute',
'type_param': 'long', 'type_param': 'long',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 178, 'line': 180,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -497,7 +497,7 @@ EXPECTED_NON_EMPTY = {
'name': 'HasValueParamAttribute/0', 'name': 'HasValueParamAttribute/0',
'value_param': '33', 'value_param': '33',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 162, 'line': 164,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -508,7 +508,7 @@ EXPECTED_NON_EMPTY = {
'name': 'HasValueParamAttribute/1', 'name': 'HasValueParamAttribute/1',
'value_param': '42', 'value_param': '42',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 162, 'line': 164,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -519,7 +519,7 @@ EXPECTED_NON_EMPTY = {
'name': 'AnotherTestThatHasValueParamAttribute/0', 'name': 'AnotherTestThatHasValueParamAttribute/0',
'value_param': '33', 'value_param': '33',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 163, 'line': 165,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -530,7 +530,7 @@ EXPECTED_NON_EMPTY = {
'name': 'AnotherTestThatHasValueParamAttribute/1', 'name': 'AnotherTestThatHasValueParamAttribute/1',
'value_param': '42', 'value_param': '42',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 163, 'line': 165,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',
@ -562,7 +562,7 @@ EXPECTED_FILTERED = {
'testsuite': [{ 'testsuite': [{
'name': 'Succeeds', 'name': 'Succeeds',
'file': 'gtest_xml_output_unittest_.cc', 'file': 'gtest_xml_output_unittest_.cc',
'line': 51, 'line': 53,
'status': 'RUN', 'status': 'RUN',
'result': 'COMPLETED', 'result': 'COMPLETED',
'time': '*', 'time': '*',

3
googletest/test/googletest-list-tests-unittest_.cc
View File

@ -36,6 +36,9 @@
// This program will be invoked from a Python unit test. // This program will be invoked from a Python unit test.
// Don't run it directly. // Don't run it directly.
#include <ostream>
#include <string>
#include "gtest/gtest.h" #include "gtest/gtest.h"
// Several different test cases and tests that will be listed. // Several different test cases and tests that will be listed.

9
googletest/test/googletest-listener-test.cc
View File

@ -32,19 +32,14 @@
// This file verifies Google Test event listeners receive events at the // This file verifies Google Test event listeners receive events at the
// right times. // right times.
#include <string>
#include <vector> #include <vector>
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "gtest/internal/custom/gtest.h" #include "gtest/internal/custom/gtest.h"
using ::testing::AddGlobalTestEnvironment; using ::testing::AddGlobalTestEnvironment;
using ::testing::Environment;
using ::testing::InitGoogleTest; using ::testing::InitGoogleTest;
using ::testing::Test;
using ::testing::TestEventListener;
using ::testing::TestInfo;
using ::testing::TestPartResult;
using ::testing::TestSuite;
using ::testing::UnitTest; using ::testing::UnitTest;
// Used by tests to register their events. // Used by tests to register their events.
@ -278,7 +273,7 @@ int main(int argc, char** argv) {
AddGlobalTestEnvironment(new EnvironmentInvocationCatcher); AddGlobalTestEnvironment(new EnvironmentInvocationCatcher);
GTEST_CHECK_(events.size() == 0) GTEST_CHECK_(events.empty())
<< "AddGlobalTestEnvironment should not generate any events itself."; << "AddGlobalTestEnvironment should not generate any events itself.";
GTEST_FLAG_SET(repeat, 2); GTEST_FLAG_SET(repeat, 2);

24
googletest/test/googletest-options-test.cc
View File

@ -40,11 +40,11 @@
#include "gtest/gtest.h" #include "gtest/gtest.h"
#if GTEST_OS_WINDOWS_MOBILE #ifdef GTEST_OS_WINDOWS_MOBILE
#include <windows.h> #include <windows.h>
#elif GTEST_OS_WINDOWS #elif defined(GTEST_OS_WINDOWS)
#include <direct.h> #include <direct.h>
#elif GTEST_OS_OS2 #elif defined(GTEST_OS_OS2)
// For strcasecmp on OS/2 // For strcasecmp on OS/2
#include <strings.h> #include <strings.h>
#endif // GTEST_OS_WINDOWS_MOBILE #endif // GTEST_OS_WINDOWS_MOBILE
@ -92,7 +92,7 @@ TEST(XmlOutputTest, GetOutputFileFromDirectoryPath) {
.string(); .string();
const std::string& output_file = const std::string& output_file =
UnitTestOptions::GetAbsolutePathToOutputFile(); UnitTestOptions::GetAbsolutePathToOutputFile();
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str()); EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str());
#else #else
EXPECT_EQ(expected_output_file, output_file.c_str()); EXPECT_EQ(expected_output_file, output_file.c_str());
@ -101,19 +101,19 @@ TEST(XmlOutputTest, GetOutputFileFromDirectoryPath) {
TEST(OutputFileHelpersTest, GetCurrentExecutableName) { TEST(OutputFileHelpersTest, GetCurrentExecutableName) {
const std::string exe_str = GetCurrentExecutableName().string(); const std::string exe_str = GetCurrentExecutableName().string();
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
const bool success = const bool success =
_strcmpi("googletest-options-test", exe_str.c_str()) == 0 || _strcmpi("googletest-options-test", exe_str.c_str()) == 0 ||
_strcmpi("gtest-options-ex_test", exe_str.c_str()) == 0 || _strcmpi("gtest-options-ex_test", exe_str.c_str()) == 0 ||
_strcmpi("gtest_all_test", exe_str.c_str()) == 0 || _strcmpi("gtest_all_test", exe_str.c_str()) == 0 ||
_strcmpi("gtest_dll_test", exe_str.c_str()) == 0; _strcmpi("gtest_dll_test", exe_str.c_str()) == 0;
#elif GTEST_OS_OS2 #elif defined(GTEST_OS_OS2)
const bool success = const bool success =
strcasecmp("googletest-options-test", exe_str.c_str()) == 0 || strcasecmp("googletest-options-test", exe_str.c_str()) == 0 ||
strcasecmp("gtest-options-ex_test", exe_str.c_str()) == 0 || strcasecmp("gtest-options-ex_test", exe_str.c_str()) == 0 ||
strcasecmp("gtest_all_test", exe_str.c_str()) == 0 || strcasecmp("gtest_all_test", exe_str.c_str()) == 0 ||
strcasecmp("gtest_dll_test", exe_str.c_str()) == 0; strcasecmp("gtest_dll_test", exe_str.c_str()) == 0;
#elif GTEST_OS_FUCHSIA #elif defined(GTEST_OS_FUCHSIA)
const bool success = exe_str == "app"; const bool success = exe_str == "app";
#else #else
const bool success = const bool success =
@ -123,7 +123,7 @@ TEST(OutputFileHelpersTest, GetCurrentExecutableName) {
if (!success) FAIL() << "GetCurrentExecutableName() returns " << exe_str; if (!success) FAIL() << "GetCurrentExecutableName() returns " << exe_str;
} }
#if !GTEST_OS_FUCHSIA #ifndef GTEST_OS_FUCHSIA
class XmlOutputChangeDirTest : public Test { class XmlOutputChangeDirTest : public Test {
protected: protected:
@ -176,7 +176,7 @@ TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativePath) {
.string(); .string();
const std::string& output_file = const std::string& output_file =
UnitTestOptions::GetAbsolutePathToOutputFile(); UnitTestOptions::GetAbsolutePathToOutputFile();
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str()); EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str());
#else #else
EXPECT_EQ(expected_output_file, output_file.c_str()); EXPECT_EQ(expected_output_file, output_file.c_str());
@ -184,7 +184,7 @@ TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithRelativePath) {
} }
TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsoluteFile) { TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsoluteFile) {
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
GTEST_FLAG_SET(output, "xml:c:\\tmp\\filename.abc"); GTEST_FLAG_SET(output, "xml:c:\\tmp\\filename.abc");
EXPECT_EQ(FilePath("c:\\tmp\\filename.abc").string(), EXPECT_EQ(FilePath("c:\\tmp\\filename.abc").string(),
UnitTestOptions::GetAbsolutePathToOutputFile()); UnitTestOptions::GetAbsolutePathToOutputFile());
@ -196,7 +196,7 @@ TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsoluteFile) {
} }
TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsolutePath) { TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsolutePath) {
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
const std::string path = "c:\\tmp\\"; const std::string path = "c:\\tmp\\";
#else #else
const std::string path = "/tmp/"; const std::string path = "/tmp/";
@ -208,7 +208,7 @@ TEST_F(XmlOutputChangeDirTest, PreserveOriginalWorkingDirWithAbsolutePath) {
const std::string& output_file = const std::string& output_file =
UnitTestOptions::GetAbsolutePathToOutputFile(); UnitTestOptions::GetAbsolutePathToOutputFile();
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str()); EXPECT_STRCASEEQ(expected_output_file.c_str(), output_file.c_str());
#else #else
EXPECT_EQ(expected_output_file, output_file.c_str()); EXPECT_EQ(expected_output_file, output_file.c_str());

2
googletest/test/googletest-output-test.py
View File

@ -132,7 +132,7 @@ def RemoveStackTraces(output):
"""Removes all traces of stack traces from a Google Test program's output.""" """Removes all traces of stack traces from a Google Test program's output."""
# *? means "find the shortest string that matches". # *? means "find the shortest string that matches".
return re.sub(r'Stack trace:(.|\n)*?\n\n', '', output) return re.sub(r'Stack trace:(.|\n)*?\n', '', output)
def RemoveTime(output): def RemoveTime(output):

17
googletest/test/googletest-output-test_.cc
View File

@ -35,13 +35,16 @@
#include <stdlib.h> #include <stdlib.h>
#include <algorithm>
#include <string>
#include "gtest/gtest-spi.h" #include "gtest/gtest-spi.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "src/gtest-internal-inl.h" #include "src/gtest-internal-inl.h"
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127 /* conditional expression is constant */) GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127 /* conditional expression is constant */)
#if GTEST_IS_THREADSAFE #ifdef GTEST_IS_THREADSAFE
using testing::ScopedFakeTestPartResultReporter; using testing::ScopedFakeTestPartResultReporter;
using testing::TestPartResultArray; using testing::TestPartResultArray;
@ -247,7 +250,7 @@ TEST(SCOPED_TRACETest, CanBeRepeated) {
<< "contain trace point A, B, and D."; << "contain trace point A, B, and D.";
} }
#if GTEST_IS_THREADSAFE #ifdef GTEST_IS_THREADSAFE
// Tests that SCOPED_TRACE()s can be used concurrently from multiple // Tests that SCOPED_TRACE()s can be used concurrently from multiple
// threads. Namely, an assertion should be affected by // threads. Namely, an assertion should be affected by
// SCOPED_TRACE()s in its own thread only. // SCOPED_TRACE()s in its own thread only.
@ -773,7 +776,7 @@ REGISTER_TYPED_TEST_SUITE_P(DetectNotInstantiatedTypesTest, Used);
// typedef ::testing::Types<char, int, unsigned int> MyTypes; // typedef ::testing::Types<char, int, unsigned int> MyTypes;
// INSTANTIATE_TYPED_TEST_SUITE_P(All, DetectNotInstantiatedTypesTest, MyTypes); // INSTANTIATE_TYPED_TEST_SUITE_P(All, DetectNotInstantiatedTypesTest, MyTypes);
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
// We rely on the golden file to verify that tests whose test case // We rely on the golden file to verify that tests whose test case
// name ends with DeathTest are run first. // name ends with DeathTest are run first.
@ -851,7 +854,7 @@ TEST_F(ExpectFailureTest, ExpectNonFatalFailure) {
"failure."); "failure.");
} }
#if GTEST_IS_THREADSAFE #ifdef GTEST_IS_THREADSAFE
class ExpectFailureWithThreadsTest : public ExpectFailureTest { class ExpectFailureWithThreadsTest : public ExpectFailureTest {
protected: protected:
@ -1024,11 +1027,11 @@ int main(int argc, char** argv) {
std::count(argv, argv + argc, std::count(argv, argv + argc,
std::string("internal_skip_environment_and_ad_hoc_tests")) > 0; std::string("internal_skip_environment_and_ad_hoc_tests")) > 0;
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
if (GTEST_FLAG_GET(internal_run_death_test) != "") { if (!GTEST_FLAG_GET(internal_run_death_test).empty()) {
// Skip the usual output capturing if we're running as the child // Skip the usual output capturing if we're running as the child
// process of an threadsafe-style death test. // process of an threadsafe-style death test.
#if GTEST_OS_WINDOWS #if defined(GTEST_OS_WINDOWS)
posix::FReopen("nul:", "w", stdout); posix::FReopen("nul:", "w", stdout);
#else #else
posix::FReopen("/dev/null", "w", stdout); posix::FReopen("/dev/null", "w", stdout);

2
googletest/test/googletest-param-test-invalid-name2-test_.cc
View File

@ -27,6 +27,8 @@
// (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.
#include <string>
#include "gtest/gtest.h" #include "gtest/gtest.h"
namespace { namespace {

2
googletest/test/googletest-param-test-test.cc
View File

@ -221,7 +221,7 @@ class DogAdder {
} }
DogAdder operator+(const DogAdder& other) const { DogAdder operator+(const DogAdder& other) const {
Message msg; Message msg;
msg << value_.c_str() << other.value_.c_str(); msg << value_ << other.value_;
return DogAdder(msg.GetString().c_str()); return DogAdder(msg.GetString().c_str());
} }
bool operator<(const DogAdder& other) const { return value_ < other.value_; } bool operator<(const DogAdder& other) const { return value_ < other.value_; }

52
googletest/test/googletest-port-test.cc
View File

@ -32,7 +32,7 @@
#include "gtest/internal/gtest-port.h" #include "gtest/internal/gtest-port.h"
#if GTEST_OS_MAC #ifdef GTEST_OS_MAC
#include <time.h> #include <time.h>
#endif // GTEST_OS_MAC #endif // GTEST_OS_MAC
@ -97,7 +97,7 @@ class Base {
explicit Base(int n) : member_(n) {} explicit Base(int n) : member_(n) {}
Base(const Base&) = default; Base(const Base&) = default;
Base& operator=(const Base&) = default; Base& operator=(const Base&) = default;
virtual ~Base() {} virtual ~Base() = default;
int member() { return member_; } int member() { return member_; }
private: private:
@ -281,9 +281,11 @@ TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFileAndLine) {
EXPECT_EQ("unknown file", FormatCompilerIndependentFileLocation(nullptr, -1)); EXPECT_EQ("unknown file", FormatCompilerIndependentFileLocation(nullptr, -1));
} }
#if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_QNX || GTEST_OS_FUCHSIA || \ #if defined(GTEST_OS_LINUX) || defined(GTEST_OS_MAC) || \
GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \ defined(GTEST_OS_QNX) || defined(GTEST_OS_FUCHSIA) || \
GTEST_OS_NETBSD || GTEST_OS_OPENBSD || GTEST_OS_GNU_HURD defined(GTEST_OS_DRAGONFLY) || defined(GTEST_OS_FREEBSD) || \
defined(GTEST_OS_GNU_KFREEBSD) || defined(GTEST_OS_NETBSD) || \
defined(GTEST_OS_OPENBSD) || defined(GTEST_OS_GNU_HURD)
void* ThreadFunc(void* data) { void* ThreadFunc(void* data) {
internal::Mutex* mutex = static_cast<internal::Mutex*>(data); internal::Mutex* mutex = static_cast<internal::Mutex*>(data);
mutex->Lock(); mutex->Lock();
@ -359,7 +361,7 @@ TEST(GtestCheckDeathTest, DiesWithCorrectOutputOnFailure) {
const char regex[] = const char regex[] =
#ifdef _MSC_VER #ifdef _MSC_VER
"googletest-port-test\\.cc\\(\\d+\\):" "googletest-port-test\\.cc\\(\\d+\\):"
#elif GTEST_USES_POSIX_RE #elif defined(GTEST_USES_POSIX_RE)
"googletest-port-test\\.cc:[0-9]+" "googletest-port-test\\.cc:[0-9]+"
#else #else
"googletest-port-test\\.cc:\\d+" "googletest-port-test\\.cc:\\d+"
@ -370,7 +372,7 @@ TEST(GtestCheckDeathTest, DiesWithCorrectOutputOnFailure) {
regex); regex);
} }
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
TEST(GtestCheckDeathTest, LivesSilentlyOnSuccess) { TEST(GtestCheckDeathTest, LivesSilentlyOnSuccess) {
EXPECT_EXIT( EXPECT_EXIT(
@ -388,7 +390,7 @@ TEST(GtestCheckDeathTest, LivesSilentlyOnSuccess) {
// the platform. The test will produce compiler errors in case of failure. // the platform. The test will produce compiler errors in case of failure.
// For simplicity, we only cover the most important platforms here. // For simplicity, we only cover the most important platforms here.
TEST(RegexEngineSelectionTest, SelectsCorrectRegexEngine) { TEST(RegexEngineSelectionTest, SelectsCorrectRegexEngine) {
#if GTEST_HAS_ABSL #ifdef GTEST_HAS_ABSL
EXPECT_TRUE(GTEST_USES_RE2); EXPECT_TRUE(GTEST_USES_RE2);
#elif GTEST_HAS_POSIX_RE #elif GTEST_HAS_POSIX_RE
EXPECT_TRUE(GTEST_USES_POSIX_RE); EXPECT_TRUE(GTEST_USES_POSIX_RE);
@ -397,7 +399,7 @@ TEST(RegexEngineSelectionTest, SelectsCorrectRegexEngine) {
#endif #endif
} }
#if GTEST_USES_POSIX_RE #ifdef GTEST_USES_POSIX_RE
template <typename Str> template <typename Str>
class RETest : public ::testing::Test {}; class RETest : public ::testing::Test {};
@ -454,7 +456,7 @@ TYPED_TEST(RETest, PartialMatchWorks) {
EXPECT_FALSE(RE::PartialMatch(TypeParam("zza"), re)); EXPECT_FALSE(RE::PartialMatch(TypeParam("zza"), re));
} }
#elif GTEST_USES_SIMPLE_RE #elif defined(GTEST_USES_SIMPLE_RE)
TEST(IsInSetTest, NulCharIsNotInAnySet) { TEST(IsInSetTest, NulCharIsNotInAnySet) {
EXPECT_FALSE(IsInSet('\0', "")); EXPECT_FALSE(IsInSet('\0', ""));
@ -916,7 +918,7 @@ TEST(RETest, PartialMatchWorks) {
#endif // GTEST_USES_POSIX_RE #endif // GTEST_USES_POSIX_RE
#if !GTEST_OS_WINDOWS_MOBILE #ifndef GTEST_OS_WINDOWS_MOBILE
TEST(CaptureTest, CapturesStdout) { TEST(CaptureTest, CapturesStdout) {
CaptureStdout(); CaptureStdout();
@ -977,14 +979,14 @@ TEST(ThreadLocalTest, SingleParamConstructorInitializesToParam) {
EXPECT_EQ(&i, t2.get()); EXPECT_EQ(&i, t2.get());
} }
class NoDefaultContructor { class NoDefaultConstructor {
public: public:
explicit NoDefaultContructor(const char*) {} explicit NoDefaultConstructor(const char*) {}
NoDefaultContructor(const NoDefaultContructor&) {} NoDefaultConstructor(const NoDefaultConstructor&) = default;
}; };
TEST(ThreadLocalTest, ValueDefaultContructorIsNotRequiredForParamVersion) { TEST(ThreadLocalTest, ValueDefaultContructorIsNotRequiredForParamVersion) {
ThreadLocal<NoDefaultContructor> bar(NoDefaultContructor("foo")); ThreadLocal<NoDefaultConstructor> bar(NoDefaultConstructor("foo"));
bar.pointer(); bar.pointer();
} }
@ -1009,7 +1011,7 @@ TEST(ThreadLocalTest, PointerAndConstPointerReturnSameValue) {
EXPECT_EQ(thread_local_string.pointer(), const_thread_local_string.pointer()); EXPECT_EQ(thread_local_string.pointer(), const_thread_local_string.pointer());
} }
#if GTEST_IS_THREADSAFE #ifdef GTEST_IS_THREADSAFE
void AddTwo(int* param) { *param += 2; } void AddTwo(int* param) { *param += 2; }
@ -1064,7 +1066,7 @@ class AtomicCounterWithMutex {
GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&memory_barrier_mutex)); GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&memory_barrier_mutex));
GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&memory_barrier_mutex)); GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&memory_barrier_mutex));
#elif GTEST_OS_WINDOWS #elif defined(GTEST_OS_WINDOWS)
// On Windows, performing an interlocked access puts up a memory barrier. // On Windows, performing an interlocked access puts up a memory barrier.
volatile LONG dummy = 0; volatile LONG dummy = 0;
::InterlockedIncrement(&dummy); ::InterlockedIncrement(&dummy);
@ -1102,9 +1104,9 @@ TEST(MutexTest, OnlyOneThreadCanLockAtATime) {
// Creates and runs kThreadCount threads that increment locked_counter // Creates and runs kThreadCount threads that increment locked_counter
// kCycleCount times each. // kCycleCount times each.
for (int i = 0; i < kThreadCount; ++i) { for (int i = 0; i < kThreadCount; ++i) {
counting_threads[i].reset(new ThreadType( counting_threads[i] = std::make_unique<ThreadType>(
&CountingThreadFunc, make_pair(&locked_counter, kCycleCount), &CountingThreadFunc, make_pair(&locked_counter, kCycleCount),
&threads_can_start)); &threads_can_start);
} }
threads_can_start.Notify(); threads_can_start.Notify();
for (int i = 0; i < kThreadCount; ++i) counting_threads[i]->Join(); for (int i = 0; i < kThreadCount; ++i) counting_threads[i]->Join();
@ -1146,14 +1148,14 @@ class DestructorCall {
public: public:
DestructorCall() { DestructorCall() {
invoked_ = false; invoked_ = false;
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
wait_event_.Reset(::CreateEvent(NULL, TRUE, FALSE, NULL)); wait_event_.Reset(::CreateEvent(NULL, TRUE, FALSE, NULL));
GTEST_CHECK_(wait_event_.Get() != NULL); GTEST_CHECK_(wait_event_.Get() != NULL);
#endif #endif
} }
bool CheckDestroyed() const { bool CheckDestroyed() const {
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
if (::WaitForSingleObject(wait_event_.Get(), 1000) != WAIT_OBJECT_0) if (::WaitForSingleObject(wait_event_.Get(), 1000) != WAIT_OBJECT_0)
return false; return false;
#endif #endif
@ -1162,7 +1164,7 @@ class DestructorCall {
void ReportDestroyed() { void ReportDestroyed() {
invoked_ = true; invoked_ = true;
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
::SetEvent(wait_event_.Get()); ::SetEvent(wait_event_.Get());
#endif #endif
} }
@ -1178,7 +1180,7 @@ class DestructorCall {
private: private:
bool invoked_; bool invoked_;
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
AutoHandle wait_event_; AutoHandle wait_event_;
#endif #endif
static std::vector<DestructorCall*>* const list_; static std::vector<DestructorCall*>* const list_;
@ -1278,12 +1280,12 @@ TEST(ThreadLocalTest, ThreadLocalMutationsAffectOnlyCurrentThread) {
#endif // GTEST_IS_THREADSAFE #endif // GTEST_IS_THREADSAFE
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
TEST(WindowsTypesTest, HANDLEIsVoidStar) { TEST(WindowsTypesTest, HANDLEIsVoidStar) {
StaticAssertTypeEq<HANDLE, void*>(); StaticAssertTypeEq<HANDLE, void*>();
} }
#if GTEST_OS_WINDOWS_MINGW && !defined(__MINGW64_VERSION_MAJOR) #if defined(GTEST_OS_WINDOWS_MINGW) && !defined(__MINGW64_VERSION_MAJOR)
TEST(WindowsTypesTest, _CRITICAL_SECTIONIs_CRITICAL_SECTION) { TEST(WindowsTypesTest, _CRITICAL_SECTIONIs_CRITICAL_SECTION) {
StaticAssertTypeEq<CRITICAL_SECTION, _CRITICAL_SECTION>(); StaticAssertTypeEq<CRITICAL_SECTION, _CRITICAL_SECTION>();
} }

27
googletest/test/googletest-printers-test.cc
View File

@ -42,9 +42,11 @@
#include <list> #include <list>
#include <map> #include <map>
#include <memory> #include <memory>
#include <ostream>
#include <set> #include <set>
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <tuple>
#include <unordered_map> #include <unordered_map>
#include <unordered_set> #include <unordered_set>
#include <utility> #include <utility>
@ -106,7 +108,7 @@ class UnprintableTemplateInGlobal {
// A user-defined streamable type in the global namespace. // A user-defined streamable type in the global namespace.
class StreamableInGlobal { class StreamableInGlobal {
public: public:
virtual ~StreamableInGlobal() {} virtual ~StreamableInGlobal() = default;
}; };
inline void operator<<(::std::ostream& os, const StreamableInGlobal& /* x */) { inline void operator<<(::std::ostream& os, const StreamableInGlobal& /* x */) {
@ -214,7 +216,7 @@ class PathLike {
using value_type = char; using value_type = char;
using const_iterator = iterator; using const_iterator = iterator;
PathLike() {} PathLike() = default;
iterator begin() const { return iterator(); } iterator begin() const { return iterator(); }
iterator end() const { return iterator(); } iterator end() const { return iterator(); }
@ -266,7 +268,6 @@ using ::std::set;
using ::std::vector; using ::std::vector;
using ::testing::PrintToString; using ::testing::PrintToString;
using ::testing::internal::FormatForComparisonFailureMessage; using ::testing::internal::FormatForComparisonFailureMessage;
using ::testing::internal::ImplicitCast_;
using ::testing::internal::NativeArray; using ::testing::internal::NativeArray;
using ::testing::internal::RelationToSourceReference; using ::testing::internal::RelationToSourceReference;
using ::testing::internal::Strings; using ::testing::internal::Strings;
@ -360,7 +361,7 @@ TEST(PrintCharTest, Char16) { EXPECT_EQ("U+0041", Print(u'A')); }
TEST(PrintCharTest, Char32) { EXPECT_EQ("U+0041", Print(U'A')); } TEST(PrintCharTest, Char32) { EXPECT_EQ("U+0041", Print(U'A')); }
#ifdef __cpp_char8_t #ifdef __cpp_lib_char8_t
TEST(PrintCharTest, Char8) { EXPECT_EQ("U+0041", Print(u8'A')); } TEST(PrintCharTest, Char8) { EXPECT_EQ("U+0041", Print(u8'A')); }
#endif #endif
@ -413,7 +414,7 @@ TEST(PrintBuiltInTypeTest, Integer) {
Print(std::numeric_limits<uint64_t>::max())); // uint64 Print(std::numeric_limits<uint64_t>::max())); // uint64
EXPECT_EQ("-9223372036854775808", EXPECT_EQ("-9223372036854775808",
Print(std::numeric_limits<int64_t>::min())); // int64 Print(std::numeric_limits<int64_t>::min())); // int64
#ifdef __cpp_char8_t #ifdef __cpp_lib_char8_t
EXPECT_EQ("U+0000", EXPECT_EQ("U+0000",
Print(std::numeric_limits<char8_t>::min())); // char8_t Print(std::numeric_limits<char8_t>::min())); // char8_t
EXPECT_EQ("U+00FF", EXPECT_EQ("U+00FF",
@ -432,7 +433,7 @@ TEST(PrintBuiltInTypeTest, Integer) {
// Size types. // Size types.
TEST(PrintBuiltInTypeTest, Size_t) { TEST(PrintBuiltInTypeTest, Size_t) {
EXPECT_EQ("1", Print(sizeof('a'))); // size_t. EXPECT_EQ("1", Print(sizeof('a'))); // size_t.
#if !GTEST_OS_WINDOWS #ifndef GTEST_OS_WINDOWS
// Windows has no ssize_t type. // Windows has no ssize_t type.
EXPECT_EQ("-2", Print(static_cast<ssize_t>(-2))); // ssize_t. EXPECT_EQ("-2", Print(static_cast<ssize_t>(-2))); // ssize_t.
#endif // !GTEST_OS_WINDOWS #endif // !GTEST_OS_WINDOWS
@ -519,7 +520,7 @@ TEST(PrintCStringTest, EscapesProperly) {
Print(p)); Print(p));
} }
#ifdef __cpp_char8_t #ifdef __cpp_lib_char8_t
// const char8_t*. // const char8_t*.
TEST(PrintU8StringTest, Const) { TEST(PrintU8StringTest, Const) {
const char8_t* p = u8"界"; const char8_t* p = u8"界";
@ -748,7 +749,7 @@ AssertionResult HasPrefix(const StringType& str, const StringType& prefix) {
struct Foo { struct Foo {
public: public:
virtual ~Foo() {} virtual ~Foo() = default;
int MyMethod(char x) { return x + 1; } int MyMethod(char x) { return x + 1; }
virtual char MyVirtualMethod(int /* n */) { return 'a'; } virtual char MyVirtualMethod(int /* n */) { return 'a'; }
@ -816,7 +817,7 @@ TEST(PrintArrayTest, CharArrayWithTerminatingNul) {
EXPECT_EQ("\"\\0Hi\"", PrintArrayHelper(a)); EXPECT_EQ("\"\\0Hi\"", PrintArrayHelper(a));
} }
#ifdef __cpp_char8_t #ifdef __cpp_lib_char8_t
// char_t array without terminating NUL. // char_t array without terminating NUL.
TEST(PrintArrayTest, Char8ArrayWithNoTerminatingNul) { TEST(PrintArrayTest, Char8ArrayWithNoTerminatingNul) {
// Array a contains '\0' in the middle and doesn't end with '\0'. // Array a contains '\0' in the middle and doesn't end with '\0'.
@ -936,7 +937,7 @@ TEST(PrintWideStringTest, StringAmbiguousHex) {
} }
#endif // GTEST_HAS_STD_WSTRING #endif // GTEST_HAS_STD_WSTRING
#ifdef __cpp_char8_t #ifdef __cpp_lib_char8_t
TEST(PrintStringTest, U8String) { TEST(PrintStringTest, U8String) {
std::u8string str = u8"Hello, 世界"; std::u8string str = u8"Hello, 世界";
EXPECT_EQ(str, str); // Verify EXPECT_EQ compiles with this type. EXPECT_EQ(str, str); // Verify EXPECT_EQ compiles with this type.
@ -1796,7 +1797,8 @@ TEST(UniversalPrintTest, SmartPointers) {
std::shared_ptr<int> p3(new int(1979)); std::shared_ptr<int> p3(new int(1979));
EXPECT_EQ("(ptr = " + PrintPointer(p3.get()) + ", value = 1979)", EXPECT_EQ("(ptr = " + PrintPointer(p3.get()) + ", value = 1979)",
PrintToString(p3)); PrintToString(p3));
#if __cpp_lib_shared_ptr_arrays >= 201611L #if defined(__cpp_lib_shared_ptr_arrays) && \
(__cpp_lib_shared_ptr_arrays >= 201611L)
std::shared_ptr<int[]> p4(new int[2]); std::shared_ptr<int[]> p4(new int[2]);
EXPECT_EQ("(" + PrintPointer(p4.get()) + ")", PrintToString(p4)); EXPECT_EQ("(" + PrintPointer(p4.get()) + ")", PrintToString(p4));
#endif #endif
@ -1815,7 +1817,8 @@ TEST(UniversalPrintTest, SmartPointers) {
EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<const int>())); EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<const int>()));
EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<volatile int>())); EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<volatile int>()));
EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<volatile const int>())); EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<volatile const int>()));
#if __cpp_lib_shared_ptr_arrays >= 201611L #if defined(__cpp_lib_shared_ptr_arrays) && \
(__cpp_lib_shared_ptr_arrays >= 201611L)
EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<int[]>())); EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<int[]>()));
EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<const int[]>())); EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<const int[]>()));
EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<volatile int[]>())); EXPECT_EQ("(nullptr)", PrintToString(std::shared_ptr<volatile int[]>()));

1
googletest/test/googletest-shuffle-test_.cc
View File

@ -35,7 +35,6 @@ namespace {
using ::testing::EmptyTestEventListener; using ::testing::EmptyTestEventListener;
using ::testing::InitGoogleTest; using ::testing::InitGoogleTest;
using ::testing::Message;
using ::testing::Test; using ::testing::Test;
using ::testing::TestEventListeners; using ::testing::TestEventListeners;
using ::testing::TestInfo; using ::testing::TestInfo;

4
googletest/test/gtest_dirs_test.cc
View File

@ -7,6 +7,8 @@
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "gtest/internal/gtest-port.h" #include "gtest/internal/gtest-port.h"
#if GTEST_HAS_FILE_SYSTEM
namespace { namespace {
class SetEnv { class SetEnv {
@ -94,4 +96,6 @@ TEST(SrcDirTest, NotInEnvironment) {
EXPECT_NE(testing::SrcDir(), ""); EXPECT_NE(testing::SrcDir(), "");
} }
#endif // GTEST_HAS_FILE_SYSTEM
} // namespace } // namespace

14
googletest/test/gtest_help_test.py
View File

@ -43,6 +43,7 @@ import sys
from googletest.test import gtest_test_utils from googletest.test import gtest_test_utils
IS_DARWIN = os.name == 'posix' and os.uname()[0] == 'Darwin'
IS_LINUX = os.name == 'posix' and os.uname()[0] == 'Linux' IS_LINUX = os.name == 'posix' and os.uname()[0] == 'Linux'
IS_GNUHURD = os.name == 'posix' and os.uname()[0] == 'GNU' IS_GNUHURD = os.name == 'posix' and os.uname()[0] == 'GNU'
IS_GNUKFREEBSD = os.name == 'posix' and os.uname()[0] == 'GNU/kFreeBSD' IS_GNUKFREEBSD = os.name == 'posix' and os.uname()[0] == 'GNU/kFreeBSD'
@ -53,7 +54,6 @@ PROGRAM_PATH = gtest_test_utils.GetTestExecutablePath('gtest_help_test_')
FLAG_PREFIX = '--gtest_' FLAG_PREFIX = '--gtest_'
DEATH_TEST_STYLE_FLAG = FLAG_PREFIX + 'death_test_style' DEATH_TEST_STYLE_FLAG = FLAG_PREFIX + 'death_test_style'
STREAM_RESULT_TO_FLAG = FLAG_PREFIX + 'stream_result_to' STREAM_RESULT_TO_FLAG = FLAG_PREFIX + 'stream_result_to'
UNKNOWN_GTEST_PREFIXED_FLAG = FLAG_PREFIX + 'unknown_flag_for_testing'
LIST_TESTS_FLAG = FLAG_PREFIX + 'list_tests' LIST_TESTS_FLAG = FLAG_PREFIX + 'list_tests'
INTERNAL_FLAG_FOR_TESTING = FLAG_PREFIX + 'internal_flag_for_testing' INTERNAL_FLAG_FOR_TESTING = FLAG_PREFIX + 'internal_flag_for_testing'
@ -136,7 +136,7 @@ class GTestHelpTest(gtest_test_utils.TestCase):
self.assertTrue(HELP_REGEX.search(output), output) self.assertTrue(HELP_REGEX.search(output), output)
if IS_LINUX or IS_GNUHURD or IS_GNUKFREEBSD or IS_OPENBSD: if IS_DARWIN or IS_LINUX or IS_GNUHURD or IS_GNUKFREEBSD or IS_OPENBSD:
self.assertIn(STREAM_RESULT_TO_FLAG, output) self.assertIn(STREAM_RESULT_TO_FLAG, output)
else: else:
self.assertNotIn(STREAM_RESULT_TO_FLAG, output) self.assertNotIn(STREAM_RESULT_TO_FLAG, output)
@ -176,16 +176,6 @@ class GTestHelpTest(gtest_test_utils.TestCase):
def testPrintsHelpWithFullFlag(self): def testPrintsHelpWithFullFlag(self):
self.TestHelpFlag('--help') self.TestHelpFlag('--help')
def testPrintsHelpWithUnrecognizedGoogleTestFlag(self):
# The behavior is slightly different when Abseil flags is
# used. Abseil flags rejects all unknown flags, while the builtin
# GTest flags implementation interprets an unknown flag with a
# '--gtest_' prefix as a request for help.
if HAS_ABSL_FLAGS:
self.TestUnknownFlagWithAbseil(UNKNOWN_GTEST_PREFIXED_FLAG)
else:
self.TestHelpFlag(UNKNOWN_GTEST_PREFIXED_FLAG)
def testRunsTestsWithoutHelpFlag(self): def testRunsTestsWithoutHelpFlag(self):
"""Verifies correct behavior when no help flag is specified. """Verifies correct behavior when no help flag is specified.

2
googletest/test/gtest_help_test_.cc
View File

@ -39,6 +39,6 @@ TEST(HelpFlagTest, ShouldNotBeRun) {
ASSERT_TRUE(false) << "Tests shouldn't be run when --help is specified."; ASSERT_TRUE(false) << "Tests shouldn't be run when --help is specified.";
} }
#if GTEST_HAS_DEATH_TEST #ifdef GTEST_HAS_DEATH_TEST
TEST(DeathTest, UsedByPythonScriptToDetectSupportForDeathTestsInThisBinary) {} TEST(DeathTest, UsedByPythonScriptToDetectSupportForDeathTestsInThisBinary) {}
#endif #endif

2
googletest/test/gtest_repeat_test.cc
View File

@ -61,7 +61,7 @@ int g_environment_tear_down_count = 0;
class MyEnvironment : public testing::Environment { class MyEnvironment : public testing::Environment {
public: public:
MyEnvironment() {} MyEnvironment() = default;
void SetUp() override { g_environment_set_up_count++; } void SetUp() override { g_environment_set_up_count++; }
void TearDown() override { g_environment_tear_down_count++; } void TearDown() override { g_environment_tear_down_count++; }
}; };

9
googletest/test/gtest_stress_test.cc
View File

@ -30,12 +30,15 @@
// Tests that SCOPED_TRACE() and various Google Test assertions can be // Tests that SCOPED_TRACE() and various Google Test assertions can be
// used in a large number of threads concurrently. // used in a large number of threads concurrently.
#include <algorithm>
#include <memory>
#include <string>
#include <vector> #include <vector>
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "src/gtest-internal-inl.h" #include "src/gtest-internal-inl.h"
#if GTEST_IS_THREADSAFE #ifdef GTEST_IS_THREADSAFE
namespace testing { namespace testing {
namespace { namespace {
@ -118,8 +121,8 @@ TEST(StressTest, CanUseScopedTraceAndAssertionsInManyThreads) {
std::unique_ptr<ThreadWithParam<int> > threads[kThreadCount]; std::unique_ptr<ThreadWithParam<int> > threads[kThreadCount];
Notification threads_can_start; Notification threads_can_start;
for (int i = 0; i != kThreadCount; i++) for (int i = 0; i != kThreadCount; i++)
threads[i].reset( threads[i] = std::make_unique<ThreadWithParam<int>>(&ManyAsserts, i,
new ThreadWithParam<int>(&ManyAsserts, i, &threads_can_start)); &threads_can_start);
threads_can_start.Notify(); threads_can_start.Notify();

81
googletest/test/gtest_unittest.cc
View File

@ -60,8 +60,10 @@ TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
#include <cstdint> #include <cstdint>
#include <map> #include <map>
#include <memory>
#include <ostream> #include <ostream>
#include <set> #include <set>
#include <stdexcept>
#include <string> #include <string>
#include <type_traits> #include <type_traits>
#include <unordered_set> #include <unordered_set>
@ -210,7 +212,6 @@ using testing::TestPartResult;
using testing::TestPartResultArray; using testing::TestPartResultArray;
using testing::TestProperty; using testing::TestProperty;
using testing::TestResult; using testing::TestResult;
using testing::TestSuite;
using testing::TimeInMillis; using testing::TimeInMillis;
using testing::UnitTest; using testing::UnitTest;
using testing::internal::AlwaysFalse; using testing::internal::AlwaysFalse;
@ -226,7 +227,6 @@ using testing::internal::FloatingPoint;
using testing::internal::ForEach; using testing::internal::ForEach;
using testing::internal::FormatEpochTimeInMillisAsIso8601; using testing::internal::FormatEpochTimeInMillisAsIso8601;
using testing::internal::FormatTimeInMillisAsSeconds; using testing::internal::FormatTimeInMillisAsSeconds;
using testing::internal::GetCurrentOsStackTraceExceptTop;
using testing::internal::GetElementOr; using testing::internal::GetElementOr;
using testing::internal::GetNextRandomSeed; using testing::internal::GetNextRandomSeed;
using testing::internal::GetRandomSeedFromFlag; using testing::internal::GetRandomSeedFromFlag;
@ -243,8 +243,6 @@ using testing::internal::IsNotContainer;
using testing::internal::kMaxRandomSeed; using testing::internal::kMaxRandomSeed;
using testing::internal::kTestTypeIdInGoogleTest; using testing::internal::kTestTypeIdInGoogleTest;
using testing::internal::NativeArray; using testing::internal::NativeArray;
using testing::internal::OsStackTraceGetter;
using testing::internal::OsStackTraceGetterInterface;
using testing::internal::ParseFlag; using testing::internal::ParseFlag;
using testing::internal::RelationToSourceCopy; using testing::internal::RelationToSourceCopy;
using testing::internal::RelationToSourceReference; using testing::internal::RelationToSourceReference;
@ -258,7 +256,6 @@ using testing::internal::StreamableToString;
using testing::internal::String; using testing::internal::String;
using testing::internal::TestEventListenersAccessor; using testing::internal::TestEventListenersAccessor;
using testing::internal::TestResultAccessor; using testing::internal::TestResultAccessor;
using testing::internal::UnitTestImpl;
using testing::internal::WideStringToUtf8; using testing::internal::WideStringToUtf8;
using testing::internal::edit_distance::CalculateOptimalEdits; using testing::internal::edit_distance::CalculateOptimalEdits;
using testing::internal::edit_distance::CreateUnifiedDiff; using testing::internal::edit_distance::CreateUnifiedDiff;
@ -269,7 +266,7 @@ using testing::internal::CaptureStdout;
using testing::internal::GetCapturedStdout; using testing::internal::GetCapturedStdout;
#endif #endif
#if GTEST_IS_THREADSAFE #ifdef GTEST_IS_THREADSAFE
using testing::internal::ThreadWithParam; using testing::internal::ThreadWithParam;
#endif #endif
@ -424,10 +421,12 @@ class FormatEpochTimeInMillisAsIso8601Test : public Test {
private: private:
void SetUp() override { void SetUp() override {
saved_tz_ = nullptr; saved_tz_.reset();
GTEST_DISABLE_MSC_DEPRECATED_PUSH_(/* getenv, strdup: deprecated */) GTEST_DISABLE_MSC_DEPRECATED_PUSH_(/* getenv: deprecated */)
if (getenv("TZ")) saved_tz_ = strdup(getenv("TZ")); if (const char* tz = getenv("TZ")) {
saved_tz_ = std::make_unique<std::string>(tz);
}
GTEST_DISABLE_MSC_DEPRECATED_POP_() GTEST_DISABLE_MSC_DEPRECATED_POP_()
// Set up the time zone for FormatEpochTimeInMillisAsIso8601 to use. We // Set up the time zone for FormatEpochTimeInMillisAsIso8601 to use. We
@ -437,16 +436,15 @@ class FormatEpochTimeInMillisAsIso8601Test : public Test {
} }
void TearDown() override { void TearDown() override {
SetTimeZone(saved_tz_); SetTimeZone(saved_tz_ != nullptr ? saved_tz_->c_str() : nullptr);
free(const_cast<char*>(saved_tz_)); saved_tz_.reset();
saved_tz_ = nullptr;
} }
static void SetTimeZone(const char* time_zone) { static void SetTimeZone(const char* time_zone) {
// tzset() distinguishes between the TZ variable being present and empty // tzset() distinguishes between the TZ variable being present and empty
// and not being present, so we have to consider the case of time_zone // and not being present, so we have to consider the case of time_zone
// being NULL. // being NULL.
#if defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW #if defined(_MSC_VER) || defined(GTEST_OS_WINDOWS_MINGW)
// ...Unless it's MSVC, whose standard library's _putenv doesn't // ...Unless it's MSVC, whose standard library's _putenv doesn't
// distinguish between an empty and a missing variable. // distinguish between an empty and a missing variable.
const std::string env_var = const std::string env_var =
@ -456,7 +454,7 @@ class FormatEpochTimeInMillisAsIso8601Test : public Test {
tzset(); tzset();
GTEST_DISABLE_MSC_WARNINGS_POP_() GTEST_DISABLE_MSC_WARNINGS_POP_()
#else #else
#if GTEST_OS_LINUX_ANDROID && __ANDROID_API__ < 21 #if defined(GTEST_OS_LINUX_ANDROID) && __ANDROID_API__ < 21
// Work around KitKat bug in tzset by setting "UTC" before setting "UTC+00". // Work around KitKat bug in tzset by setting "UTC" before setting "UTC+00".
// See https://github.com/android/ndk/issues/1604. // See https://github.com/android/ndk/issues/1604.
setenv("TZ", "UTC", 1); setenv("TZ", "UTC", 1);
@ -471,7 +469,7 @@ class FormatEpochTimeInMillisAsIso8601Test : public Test {
#endif #endif
} }
const char* saved_tz_; std::unique_ptr<std::string> saved_tz_; // Empty and null are different here
}; };
const TimeInMillis FormatEpochTimeInMillisAsIso8601Test::kMillisPerSec; const TimeInMillis FormatEpochTimeInMillisAsIso8601Test::kMillisPerSec;
@ -1088,7 +1086,7 @@ TEST(StringTest, CaseInsensitiveWideCStringEquals) {
EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"FOOBAR", L"foobar")); EXPECT_TRUE(String::CaseInsensitiveWideCStringEquals(L"FOOBAR", L"foobar"));
} }
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
// Tests String::ShowWideCString(). // Tests String::ShowWideCString().
TEST(StringTest, ShowWideCString) { TEST(StringTest, ShowWideCString) {
@ -1097,7 +1095,7 @@ TEST(StringTest, ShowWideCString) {
EXPECT_STREQ("foo", String::ShowWideCString(L"foo").c_str()); EXPECT_STREQ("foo", String::ShowWideCString(L"foo").c_str());
} }
#if GTEST_OS_WINDOWS_MOBILE #ifdef GTEST_OS_WINDOWS_MOBILE
TEST(StringTest, AnsiAndUtf16Null) { TEST(StringTest, AnsiAndUtf16Null) {
EXPECT_EQ(NULL, String::AnsiToUtf16(NULL)); EXPECT_EQ(NULL, String::AnsiToUtf16(NULL));
EXPECT_EQ(NULL, String::Utf16ToAnsi(NULL)); EXPECT_EQ(NULL, String::Utf16ToAnsi(NULL));
@ -1187,7 +1185,7 @@ TEST_F(ScopedFakeTestPartResultReporterTest, DeprecatedConstructor) {
EXPECT_EQ(1, results.size()); EXPECT_EQ(1, results.size());
} }
#if GTEST_IS_THREADSAFE #ifdef GTEST_IS_THREADSAFE
class ScopedFakeTestPartResultReporterWithThreadsTest class ScopedFakeTestPartResultReporterWithThreadsTest
: public ScopedFakeTestPartResultReporterTest { : public ScopedFakeTestPartResultReporterTest {
@ -1345,7 +1343,7 @@ TEST_F(ExpectNonfatalFailureTest, AcceptsMacroThatExpandsToUnprotectedComma) {
""); "");
} }
#if GTEST_IS_THREADSAFE #ifdef GTEST_IS_THREADSAFE
typedef ScopedFakeTestPartResultReporterWithThreadsTest typedef ScopedFakeTestPartResultReporterWithThreadsTest
ExpectFailureWithThreadsTest; ExpectFailureWithThreadsTest;
@ -1674,7 +1672,7 @@ TEST_F(GTestFlagSaverTest, VerifyGTestFlags) { VerifyAndModifyFlags(); }
// value. If the value argument is "", unsets the environment // value. If the value argument is "", unsets the environment
// variable. The caller must ensure that both arguments are not NULL. // variable. The caller must ensure that both arguments are not NULL.
static void SetEnv(const char* name, const char* value) { static void SetEnv(const char* name, const char* value) {
#if GTEST_OS_WINDOWS_MOBILE #ifdef GTEST_OS_WINDOWS_MOBILE
// Environment variables are not supported on Windows CE. // Environment variables are not supported on Windows CE.
return; return;
#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9) #elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
@ -1697,7 +1695,7 @@ static void SetEnv(const char* name, const char* value) {
// We cast away the 'const' since that would work for both variants. // We cast away the 'const' since that would work for both variants.
putenv(const_cast<char*>(added_env[name]->c_str())); putenv(const_cast<char*>(added_env[name]->c_str()));
delete prev_env; delete prev_env;
#elif GTEST_OS_WINDOWS // If we are on Windows proper. #elif defined(GTEST_OS_WINDOWS) // If we are on Windows proper.
_putenv((Message() << name << "=" << value).GetString().c_str()); _putenv((Message() << name << "=" << value).GetString().c_str());
#else #else
if (*value == '\0') { if (*value == '\0') {
@ -1708,7 +1706,7 @@ static void SetEnv(const char* name, const char* value) {
#endif // GTEST_OS_WINDOWS_MOBILE #endif // GTEST_OS_WINDOWS_MOBILE
} }
#if !GTEST_OS_WINDOWS_MOBILE #ifndef GTEST_OS_WINDOWS_MOBILE
// Environment variables are not supported on Windows CE. // Environment variables are not supported on Windows CE.
using testing::internal::Int32FromGTestEnv; using testing::internal::Int32FromGTestEnv;
@ -1817,7 +1815,7 @@ TEST(ParseInt32FlagTest, ParsesAndReturnsValidValue) {
// Tests that Int32FromEnvOrDie() parses the value of the var or // Tests that Int32FromEnvOrDie() parses the value of the var or
// returns the correct default. // returns the correct default.
// Environment variables are not supported on Windows CE. // Environment variables are not supported on Windows CE.
#if !GTEST_OS_WINDOWS_MOBILE #ifndef GTEST_OS_WINDOWS_MOBILE
TEST(Int32FromEnvOrDieTest, ParsesAndReturnsValidValue) { TEST(Int32FromEnvOrDieTest, ParsesAndReturnsValidValue) {
EXPECT_EQ(333, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333)); EXPECT_EQ(333, Int32FromEnvOrDie(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", 333));
SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "123"); SetEnv(GTEST_FLAG_PREFIX_UPPER_ "UnsetVar", "123");
@ -1890,7 +1888,7 @@ TEST_F(ShouldShardTest, ReturnsFalseWhenTotalShardIsOne) {
// Tests that sharding is enabled if total_shards > 1 and // Tests that sharding is enabled if total_shards > 1 and
// we are not in a death test subprocess. // we are not in a death test subprocess.
// Environment variables are not supported on Windows CE. // Environment variables are not supported on Windows CE.
#if !GTEST_OS_WINDOWS_MOBILE #ifndef GTEST_OS_WINDOWS_MOBILE
TEST_F(ShouldShardTest, WorksWhenShardEnvVarsAreValid) { TEST_F(ShouldShardTest, WorksWhenShardEnvVarsAreValid) {
SetEnv(index_var_, "4"); SetEnv(index_var_, "4");
SetEnv(total_var_, "22"); SetEnv(total_var_, "22");
@ -3920,7 +3918,7 @@ TEST(AssertionTest, NamedEnum) {
enum { enum {
kCaseA = -1, kCaseA = -1,
#if GTEST_OS_LINUX #ifdef GTEST_OS_LINUX
// We want to test the case where the size of the anonymous enum is // We want to test the case where the size of the anonymous enum is
// larger than sizeof(int), to make sure our implementation of the // larger than sizeof(int), to make sure our implementation of the
@ -3943,7 +3941,7 @@ enum {
}; };
TEST(AssertionTest, AnonymousEnum) { TEST(AssertionTest, AnonymousEnum) {
#if GTEST_OS_LINUX #ifdef GTEST_OS_LINUX
EXPECT_EQ(static_cast<int>(kCaseA), static_cast<int>(kCaseB)); EXPECT_EQ(static_cast<int>(kCaseA), static_cast<int>(kCaseB));
@ -3977,7 +3975,7 @@ TEST(AssertionTest, AnonymousEnum) {
#endif // !GTEST_OS_MAC && !defined(__SUNPRO_CC) #endif // !GTEST_OS_MAC && !defined(__SUNPRO_CC)
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
static HRESULT UnexpectedHRESULTFailure() { return E_UNEXPECTED; } static HRESULT UnexpectedHRESULTFailure() { return E_UNEXPECTED; }
@ -4337,7 +4335,7 @@ TEST(AssertionWithMessageTest, ASSERT_TRUE) {
"(null)(null)"); "(null)(null)");
} }
#if GTEST_OS_WINDOWS #ifdef GTEST_OS_WINDOWS
// Tests using wide strings in assertion messages. // Tests using wide strings in assertion messages.
TEST(AssertionWithMessageTest, WideStringMessage) { TEST(AssertionWithMessageTest, WideStringMessage) {
EXPECT_NONFATAL_FAILURE( EXPECT_NONFATAL_FAILURE(
@ -4949,7 +4947,7 @@ TEST(ComparisonAssertionTest, AcceptsUnprintableArgs) {
// both in a TEST and in a TEST_F. // both in a TEST and in a TEST_F.
class Foo { class Foo {
public: public:
Foo() {} Foo() = default;
private: private:
int Bar() const { return 1; } int Bar() const { return 1; }
@ -6172,12 +6170,12 @@ TEST_F(ParseFlagsTest, FilterBad) {
const char* argv2[] = {"foo.exe", "--gtest_filter", nullptr}; const char* argv2[] = {"foo.exe", "--gtest_filter", nullptr};
#if GTEST_HAS_ABSL && GTEST_HAS_DEATH_TEST #if defined(GTEST_HAS_ABSL) && defined(GTEST_HAS_DEATH_TEST)
// Invalid flag arguments are a fatal error when using the Abseil Flags. // Invalid flag arguments are a fatal error when using the Abseil Flags.
EXPECT_EXIT(GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true), EXPECT_EXIT(GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true),
testing::ExitedWithCode(1), testing::ExitedWithCode(1),
"ERROR: Missing the value for the flag 'gtest_filter'"); "ERROR: Missing the value for the flag 'gtest_filter'");
#elif !GTEST_HAS_ABSL #elif !defined(GTEST_HAS_ABSL)
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter(""), true);
#else #else
static_cast<void>(argv); static_cast<void>(argv);
@ -6191,12 +6189,12 @@ TEST_F(ParseFlagsTest, OutputEmpty) {
const char* argv2[] = {"foo.exe", "--gtest_output", nullptr}; const char* argv2[] = {"foo.exe", "--gtest_output", nullptr};
#if GTEST_HAS_ABSL && GTEST_HAS_DEATH_TEST #if defined(GTEST_HAS_ABSL) && defined(GTEST_HAS_DEATH_TEST)
// Invalid flag arguments are a fatal error when using the Abseil Flags. // Invalid flag arguments are a fatal error when using the Abseil Flags.
EXPECT_EXIT(GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true), EXPECT_EXIT(GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true),
testing::ExitedWithCode(1), testing::ExitedWithCode(1),
"ERROR: Missing the value for the flag 'gtest_output'"); "ERROR: Missing the value for the flag 'gtest_output'");
#elif !GTEST_HAS_ABSL #elif !defined(GTEST_HAS_ABSL)
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true); GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags(), true);
#else #else
static_cast<void>(argv); static_cast<void>(argv);
@ -6204,7 +6202,7 @@ TEST_F(ParseFlagsTest, OutputEmpty) {
#endif #endif
} }
#if GTEST_HAS_ABSL #ifdef GTEST_HAS_ABSL
TEST_F(ParseFlagsTest, AbseilPositionalFlags) { TEST_F(ParseFlagsTest, AbseilPositionalFlags) {
const char* argv[] = {"foo.exe", "--gtest_throw_on_failure=1", "--", const char* argv[] = {"foo.exe", "--gtest_throw_on_failure=1", "--",
"--other_flag", nullptr}; "--other_flag", nullptr};
@ -6218,7 +6216,16 @@ TEST_F(ParseFlagsTest, AbseilPositionalFlags) {
} }
#endif #endif
#if GTEST_OS_WINDOWS TEST_F(ParseFlagsTest, UnrecognizedFlags) {
const char* argv[] = {"foo.exe", "--gtest_filter=abcd", "--other_flag",
nullptr};
const char* argv2[] = {"foo.exe", "--other_flag", nullptr};
GTEST_TEST_PARSING_FLAGS_(argv, argv2, Flags::Filter("abcd"), false);
}
#ifdef GTEST_OS_WINDOWS
// Tests parsing wide strings. // Tests parsing wide strings.
TEST_F(ParseFlagsTest, WideStrings) { TEST_F(ParseFlagsTest, WideStrings) {
const wchar_t* argv[] = {L"foo.exe", const wchar_t* argv[] = {L"foo.exe",
@ -6608,7 +6615,7 @@ TEST(ColoredOutputTest, UsesColorsWhenStdoutIsTty) {
TEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) { TEST(ColoredOutputTest, UsesColorsWhenTermSupportsColors) {
GTEST_FLAG_SET(color, "auto"); GTEST_FLAG_SET(color, "auto");
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW #if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MINGW)
// On Windows, we ignore the TERM variable as it's usually not set. // On Windows, we ignore the TERM variable as it's usually not set.
SetEnv("TERM", "dumb"); SetEnv("TERM", "dumb");
@ -6974,7 +6981,7 @@ TEST(EventListenerTest, SuppressEventForwarding) {
// Tests that events generated by Google Test are not forwarded in // Tests that events generated by Google Test are not forwarded in
// death test subprocesses. // death test subprocesses.
TEST(EventListenerDeathTest, EventsNotForwardedInDeathTestSubprecesses) { TEST(EventListenerDeathTest, EventsNotForwardedInDeathTestSubprocesses) {
EXPECT_DEATH_IF_SUPPORTED( EXPECT_DEATH_IF_SUPPORTED(
{ {
GTEST_CHECK_(TestEventListenersAccessor::EventForwardingEnabled( GTEST_CHECK_(TestEventListenersAccessor::EventForwardingEnabled(

6
googletest/test/gtest_xml_outfile2_test_.cc
View File

@ -30,6 +30,8 @@
// gtest_xml_outfile2_test_ writes some xml via TestProperty used by // gtest_xml_outfile2_test_ writes some xml via TestProperty used by
// gtest_xml_outfiles_test.py // gtest_xml_outfiles_test.py
#include <atomic>
#include "gtest/gtest.h" #include "gtest/gtest.h"
class PropertyTwo : public testing::Test { class PropertyTwo : public testing::Test {
@ -38,9 +40,7 @@ class PropertyTwo : public testing::Test {
void TearDown() override { RecordProperty("TearDownProp", 2); } void TearDown() override { RecordProperty("TearDownProp", 2); }
}; };
TEST_F(PropertyTwo, TestInt64Properties) { TEST_F(PropertyTwo, TestInt64ConvertibleProperties) {
// Floats and doubles are written as int64_t, so we test that the values
// written are truncated to int64_t.
float float_prop = 3.25; float float_prop = 3.25;
RecordProperty("TestFloatProperty", float_prop); RecordProperty("TestFloatProperty", float_prop);

10
googletest/test/gtest_xml_outfiles_test.py
View File

@ -57,14 +57,14 @@ EXPECTED_XML_1 = """<?xml version="1.0" encoding="UTF-8"?>
EXPECTED_XML_2 = """<?xml version="1.0" encoding="UTF-8"?> EXPECTED_XML_2 = """<?xml version="1.0" encoding="UTF-8"?>
<testsuites tests="1" failures="0" disabled="0" errors="0" time="*" timestamp="*" name="AllTests"> <testsuites tests="1" failures="0" disabled="0" errors="0" time="*" timestamp="*" name="AllTests">
<testsuite name="PropertyTwo" tests="1" failures="0" skipped="0" disabled="0" errors="0" time="*" timestamp="*"> <testsuite name="PropertyTwo" tests="1" failures="0" skipped="0" disabled="0" errors="0" time="*" timestamp="*">
<testcase name="TestInt64Properties" file="gtest_xml_outfile2_test_.cc" line="41" status="run" result="completed" time="*" timestamp="*" classname="PropertyTwo"> <testcase name="TestInt64ConvertibleProperties" file="gtest_xml_outfile2_test_.cc" line="43" status="run" result="completed" time="*" timestamp="*" classname="PropertyTwo">
<properties> <properties>
<property name="SetUpProp" value="2"/> <property name="SetUpProp" value="2"/>
<property name="TestFloatProperty" value="3"/> <property name="TestFloatProperty" value="3.25"/>
<property name="TestDoubleProperty" value="4"/> <property name="TestDoubleProperty" value="4.75"/>
<property name="TestSizetProperty" value="5"/> <property name="TestSizetProperty" value="5"/>
<property name="TestBoolProperty" value="1"/> <property name="TestBoolProperty" value="true"/>
<property name="TestCharProperty" value="65"/> <property name="TestCharProperty" value="A"/>
<property name="TestInt16Property" value="6"/> <property name="TestInt16Property" value="6"/>
<property name="TestInt32Property" value="7"/> <property name="TestInt32Property" value="7"/>
<property name="TestInt64Property" value="8"/> <property name="TestInt64Property" value="8"/>

90
googletest/test/gtest_xml_output_unittest.py
View File

@ -59,135 +59,138 @@ SUPPORTS_STACK_TRACES = NO_STACKTRACE_SUPPORT_FLAG not in sys.argv
if SUPPORTS_STACK_TRACES: if SUPPORTS_STACK_TRACES:
STACK_TRACE_TEMPLATE = '\nStack trace:\n*' STACK_TRACE_TEMPLATE = '\nStack trace:\n*'
STACK_TRACE_ENTITY_TEMPLATE = ''
else: else:
STACK_TRACE_TEMPLATE = '' STACK_TRACE_TEMPLATE = '\n'
STACK_TRACE_ENTITY_TEMPLATE = '&#x0A;'
# unittest.main() can't handle unknown flags # unittest.main() can't handle unknown flags
sys.argv.remove(NO_STACKTRACE_SUPPORT_FLAG) sys.argv.remove(NO_STACKTRACE_SUPPORT_FLAG)
EXPECTED_NON_EMPTY_XML = """<?xml version="1.0" encoding="UTF-8"?> EXPECTED_NON_EMPTY_XML = """<?xml version="1.0" encoding="UTF-8"?>
<testsuites tests="26" failures="5" disabled="2" errors="0" time="*" timestamp="*" name="AllTests" ad_hoc_property="42"> <testsuites tests="26" failures="5" disabled="2" errors="0" time="*" timestamp="*" name="AllTests" ad_hoc_property="42">
<testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*"> <testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
<testcase name="Succeeds" file="gtest_xml_output_unittest_.cc" line="51" status="run" result="completed" time="*" timestamp="*" classname="SuccessfulTest"/> <testcase name="Succeeds" file="gtest_xml_output_unittest_.cc" line="53" status="run" result="completed" time="*" timestamp="*" classname="SuccessfulTest"/>
</testsuite> </testsuite>
<testsuite name="FailedTest" tests="1" failures="1" disabled="0" skipped="0" errors="0" time="*" timestamp="*"> <testsuite name="FailedTest" tests="1" failures="1" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
<testcase name="Fails" file="gtest_xml_output_unittest_.cc" line="59" status="run" result="completed" time="*" timestamp="*" classname="FailedTest"> <testcase name="Fails" file="gtest_xml_output_unittest_.cc" line="61" status="run" result="completed" time="*" timestamp="*" classname="FailedTest">
<failure message="gtest_xml_output_unittest_.cc:*&#x0A;Expected equality of these values:&#x0A; 1&#x0A; 2" type=""><![CDATA[gtest_xml_output_unittest_.cc:* <failure message="gtest_xml_output_unittest_.cc:*&#x0A;Expected equality of these values:&#x0A; 1&#x0A; 2%(stack_entity)s" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
Expected equality of these values: Expected equality of these values:
1 1
2%(stack)s]]></failure> 2%(stack)s]]></failure>
</testcase> </testcase>
</testsuite> </testsuite>
<testsuite name="MixedResultTest" tests="3" failures="1" disabled="1" skipped="0" errors="0" time="*" timestamp="*"> <testsuite name="MixedResultTest" tests="3" failures="1" disabled="1" skipped="0" errors="0" time="*" timestamp="*">
<testcase name="Succeeds" file="gtest_xml_output_unittest_.cc" line="86" status="run" result="completed" time="*" timestamp="*" classname="MixedResultTest"/> <testcase name="Succeeds" file="gtest_xml_output_unittest_.cc" line="88" status="run" result="completed" time="*" timestamp="*" classname="MixedResultTest"/>
<testcase name="Fails" file="gtest_xml_output_unittest_.cc" line="91" status="run" result="completed" time="*" timestamp="*" classname="MixedResultTest"> <testcase name="Fails" file="gtest_xml_output_unittest_.cc" line="93" status="run" result="completed" time="*" timestamp="*" classname="MixedResultTest">
<failure message="gtest_xml_output_unittest_.cc:*&#x0A;Expected equality of these values:&#x0A; 1&#x0A; 2" type=""><![CDATA[gtest_xml_output_unittest_.cc:* <failure message="gtest_xml_output_unittest_.cc:*&#x0A;Expected equality of these values:&#x0A; 1&#x0A; 2%(stack_entity)s" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
Expected equality of these values: Expected equality of these values:
1 1
2%(stack)s]]></failure> 2%(stack)s]]></failure>
<failure message="gtest_xml_output_unittest_.cc:*&#x0A;Expected equality of these values:&#x0A; 2&#x0A; 3" type=""><![CDATA[gtest_xml_output_unittest_.cc:* <failure message="gtest_xml_output_unittest_.cc:*&#x0A;Expected equality of these values:&#x0A; 2&#x0A; 3%(stack_entity)s" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
Expected equality of these values: Expected equality of these values:
2 2
3%(stack)s]]></failure> 3%(stack)s]]></failure>
</testcase> </testcase>
<testcase name="DISABLED_test" file="gtest_xml_output_unittest_.cc" line="96" status="notrun" result="suppressed" time="*" timestamp="*" classname="MixedResultTest"/> <testcase name="DISABLED_test" file="gtest_xml_output_unittest_.cc" line="98" status="notrun" result="suppressed" time="*" timestamp="*" classname="MixedResultTest"/>
</testsuite> </testsuite>
<testsuite name="XmlQuotingTest" tests="1" failures="1" disabled="0" skipped="0" errors="0" time="*" timestamp="*"> <testsuite name="XmlQuotingTest" tests="1" failures="1" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
<testcase name="OutputsCData" file="gtest_xml_output_unittest_.cc" line="100" status="run" result="completed" time="*" timestamp="*" classname="XmlQuotingTest"> <testcase name="OutputsCData" file="gtest_xml_output_unittest_.cc" line="102" status="run" result="completed" time="*" timestamp="*" classname="XmlQuotingTest">
<failure message="gtest_xml_output_unittest_.cc:*&#x0A;Failed&#x0A;XML output: &lt;?xml encoding=&quot;utf-8&quot;&gt;&lt;top&gt;&lt;![CDATA[cdata text]]&gt;&lt;/top&gt;" type=""><![CDATA[gtest_xml_output_unittest_.cc:* <failure message="gtest_xml_output_unittest_.cc:*&#x0A;Failed&#x0A;XML output: &lt;?xml encoding=&quot;utf-8&quot;&gt;&lt;top&gt;&lt;![CDATA[cdata text]]&gt;&lt;/top&gt;%(stack_entity)s" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
Failed Failed
XML output: <?xml encoding="utf-8"><top><![CDATA[cdata text]]>]]&gt;<![CDATA[</top>%(stack)s]]></failure> XML output: <?xml encoding="utf-8"><top><![CDATA[cdata text]]>]]&gt;<![CDATA[</top>%(stack)s]]></failure>
</testcase> </testcase>
</testsuite> </testsuite>
<testsuite name="InvalidCharactersTest" tests="1" failures="1" disabled="0" skipped="0" errors="0" time="*" timestamp="*"> <testsuite name="InvalidCharactersTest" tests="1" failures="1" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
<testcase name="InvalidCharactersInMessage" file="gtest_xml_output_unittest_.cc" line="107" status="run" result="completed" time="*" timestamp="*" classname="InvalidCharactersTest"> <testcase name="InvalidCharactersInMessage" file="gtest_xml_output_unittest_.cc" line="109" status="run" result="completed" time="*" timestamp="*" classname="InvalidCharactersTest">
<failure message="gtest_xml_output_unittest_.cc:*&#x0A;Failed&#x0A;Invalid characters in brackets []" type=""><![CDATA[gtest_xml_output_unittest_.cc:* <failure message="gtest_xml_output_unittest_.cc:*&#x0A;Failed&#x0A;Invalid characters in brackets []%(stack_entity)s" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
Failed Failed
Invalid characters in brackets []%(stack)s]]></failure> Invalid characters in brackets []%(stack)s]]></failure>
</testcase> </testcase>
</testsuite> </testsuite>
<testsuite name="DisabledTest" tests="1" failures="0" disabled="1" skipped="0" errors="0" time="*" timestamp="*"> <testsuite name="DisabledTest" tests="1" failures="0" disabled="1" skipped="0" errors="0" time="*" timestamp="*">
<testcase name="DISABLED_test_not_run" file="gtest_xml_output_unittest_.cc" line="66" status="notrun" result="suppressed" time="*" timestamp="*" classname="DisabledTest"/> <testcase name="DISABLED_test_not_run" file="gtest_xml_output_unittest_.cc" line="68" status="notrun" result="suppressed" time="*" timestamp="*" classname="DisabledTest"/>
</testsuite> </testsuite>
<testsuite name="SkippedTest" tests="3" failures="1" disabled="0" skipped="2" errors="0" time="*" timestamp="*"> <testsuite name="SkippedTest" tests="3" failures="1" disabled="0" skipped="2" errors="0" time="*" timestamp="*">
<testcase name="Skipped" status="run" file="gtest_xml_output_unittest_.cc" line="73" result="skipped" time="*" timestamp="*" classname="SkippedTest"> <testcase name="Skipped" status="run" file="gtest_xml_output_unittest_.cc" line="75" result="skipped" time="*" timestamp="*" classname="SkippedTest">
<skipped message="gtest_xml_output_unittest_.cc:*&#x0A;"><![CDATA[gtest_xml_output_unittest_.cc:* <skipped message="gtest_xml_output_unittest_.cc:*&#x0A;%(stack_entity)s"><![CDATA[gtest_xml_output_unittest_.cc:*
%(stack)s]]></skipped> %(stack)s]]></skipped>
</testcase> </testcase>
<testcase name="SkippedWithMessage" file="gtest_xml_output_unittest_.cc" line="77" status="run" result="skipped" time="*" timestamp="*" classname="SkippedTest"> <testcase name="SkippedWithMessage" file="gtest_xml_output_unittest_.cc" line="79" status="run" result="skipped" time="*" timestamp="*" classname="SkippedTest">
<skipped message="gtest_xml_output_unittest_.cc:*&#x0A;It is good practice to tell why you skip a test."><![CDATA[gtest_xml_output_unittest_.cc:* <skipped message="gtest_xml_output_unittest_.cc:*&#x0A;It is good practice to tell why you skip a test.%(stack_entity)s"><![CDATA[gtest_xml_output_unittest_.cc:*
It is good practice to tell why you skip a test.%(stack)s]]></skipped> It is good practice to tell why you skip a test.%(stack)s]]></skipped>
</testcase> </testcase>
<testcase name="SkippedAfterFailure" file="gtest_xml_output_unittest_.cc" line="81" status="run" result="completed" time="*" timestamp="*" classname="SkippedTest"> <testcase name="SkippedAfterFailure" file="gtest_xml_output_unittest_.cc" line="83" status="run" result="completed" time="*" timestamp="*" classname="SkippedTest">
<failure message="gtest_xml_output_unittest_.cc:*&#x0A;Expected equality of these values:&#x0A; 1&#x0A; 2" type=""><![CDATA[gtest_xml_output_unittest_.cc:* <failure message="gtest_xml_output_unittest_.cc:*&#x0A;Expected equality of these values:&#x0A; 1&#x0A; 2%(stack_entity)s" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
Expected equality of these values: Expected equality of these values:
1 1
2%(stack)s]]></failure> 2%(stack)s]]></failure>
<skipped message="gtest_xml_output_unittest_.cc:*&#x0A;It is good practice to tell why you skip a test."><![CDATA[gtest_xml_output_unittest_.cc:* <skipped message="gtest_xml_output_unittest_.cc:*&#x0A;It is good practice to tell why you skip a test.%(stack_entity)s"><![CDATA[gtest_xml_output_unittest_.cc:*
It is good practice to tell why you skip a test.%(stack)s]]></skipped> It is good practice to tell why you skip a test.%(stack)s]]></skipped>
</testcase> </testcase>
</testsuite> </testsuite>
<testsuite name="PropertyRecordingTest" tests="4" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*" SetUpTestSuite="yes" TearDownTestSuite="aye"> <testsuite name="PropertyRecordingTest" tests="4" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*" SetUpTestSuite="yes" TearDownTestSuite="aye">
<testcase name="OneProperty" file="gtest_xml_output_unittest_.cc" line="119" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest"> <testcase name="OneProperty" file="gtest_xml_output_unittest_.cc" line="121" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
<properties> <properties>
<property name="key_1" value="1"/> <property name="key_1" value="1"/>
</properties> </properties>
</testcase> </testcase>
<testcase name="IntValuedProperty" file="gtest_xml_output_unittest_.cc" line="123" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest"> <testcase name="IntValuedProperty" file="gtest_xml_output_unittest_.cc" line="125" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
<properties> <properties>
<property name="key_int" value="1"/> <property name="key_int" value="1"/>
</properties> </properties>
</testcase> </testcase>
<testcase name="ThreeProperties" file="gtest_xml_output_unittest_.cc" line="127" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest"> <testcase name="ThreeProperties" file="gtest_xml_output_unittest_.cc" line="129" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
<properties> <properties>
<property name="key_1" value="1"/> <property name="key_1" value="1"/>
<property name="key_2" value="2"/> <property name="key_2" value="2"/>
<property name="key_3" value="3"/> <property name="key_3" value="3"/>
</properties> </properties>
</testcase> </testcase>
<testcase name="TwoValuesForOneKeyUsesLastValue" file="gtest_xml_output_unittest_.cc" line="133" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest"> <testcase name="TwoValuesForOneKeyUsesLastValue" file="gtest_xml_output_unittest_.cc" line="135" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
<properties> <properties>
<property name="key_1" value="2"/> <property name="key_1" value="2"/>
</properties> </properties>
</testcase> </testcase>
</testsuite> </testsuite>
<testsuite name="NoFixtureTest" tests="3" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*"> <testsuite name="NoFixtureTest" tests="3" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
<testcase name="RecordProperty" file="gtest_xml_output_unittest_.cc" line="138" status="run" result="completed" time="*" timestamp="*" classname="NoFixtureTest"> <testcase name="RecordProperty" file="gtest_xml_output_unittest_.cc" line="140" status="run" result="completed" time="*" timestamp="*" classname="NoFixtureTest">
<properties> <properties>
<property name="key" value="1"/> <property name="key" value="1"/>
</properties> </properties>
</testcase> </testcase>
<testcase name="ExternalUtilityThatCallsRecordIntValuedProperty" file="gtest_xml_output_unittest_.cc" line="151" status="run" result="completed" time="*" timestamp="*" classname="NoFixtureTest"> <testcase name="ExternalUtilityThatCallsRecordIntValuedProperty" file="gtest_xml_output_unittest_.cc" line="153" status="run" result="completed" time="*" timestamp="*" classname="NoFixtureTest">
<properties> <properties>
<property name="key_for_utility_int" value="1"/> <property name="key_for_utility_int" value="1"/>
</properties> </properties>
</testcase> </testcase>
<testcase name="ExternalUtilityThatCallsRecordStringValuedProperty" file="gtest_xml_output_unittest_.cc" line="155" status="run" result="completed" time="*" timestamp="*" classname="NoFixtureTest"> <testcase name="ExternalUtilityThatCallsRecordStringValuedProperty" file="gtest_xml_output_unittest_.cc" line="157" status="run" result="completed" time="*" timestamp="*" classname="NoFixtureTest">
<properties> <properties>
<property name="key_for_utility_string" value="1"/> <property name="key_for_utility_string" value="1"/>
</properties> </properties>
</testcase> </testcase>
</testsuite> </testsuite>
<testsuite name="Single/ValueParamTest" tests="4" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*"> <testsuite name="Single/ValueParamTest" tests="4" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
<testcase name="HasValueParamAttribute/0" file="gtest_xml_output_unittest_.cc" line="162" value_param="33" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" /> <testcase name="HasValueParamAttribute/0" file="gtest_xml_output_unittest_.cc" line="164" value_param="33" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
<testcase name="HasValueParamAttribute/1" file="gtest_xml_output_unittest_.cc" line="162" value_param="42" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" /> <testcase name="HasValueParamAttribute/1" file="gtest_xml_output_unittest_.cc" line="164" value_param="42" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
<testcase name="AnotherTestThatHasValueParamAttribute/0" file="gtest_xml_output_unittest_.cc" line="163" value_param="33" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" /> <testcase name="AnotherTestThatHasValueParamAttribute/0" file="gtest_xml_output_unittest_.cc" line="165" value_param="33" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
<testcase name="AnotherTestThatHasValueParamAttribute/1" file="gtest_xml_output_unittest_.cc" line="163" value_param="42" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" /> <testcase name="AnotherTestThatHasValueParamAttribute/1" file="gtest_xml_output_unittest_.cc" line="165" value_param="42" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
</testsuite> </testsuite>
<testsuite name="TypedTest/0" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*"> <testsuite name="TypedTest/0" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
<testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="171" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="TypedTest/0" /> <testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="173" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="TypedTest/0" />
</testsuite> </testsuite>
<testsuite name="TypedTest/1" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*"> <testsuite name="TypedTest/1" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
<testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="171" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="TypedTest/1" /> <testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="173" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="TypedTest/1" />
</testsuite> </testsuite>
<testsuite name="Single/TypeParameterizedTestSuite/0" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*"> <testsuite name="Single/TypeParameterizedTestSuite/0" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
<testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="178" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="Single/TypeParameterizedTestSuite/0" /> <testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="180" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="Single/TypeParameterizedTestSuite/0" />
</testsuite> </testsuite>
<testsuite name="Single/TypeParameterizedTestSuite/1" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*"> <testsuite name="Single/TypeParameterizedTestSuite/1" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
<testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="178" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="Single/TypeParameterizedTestSuite/1" /> <testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="180" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="Single/TypeParameterizedTestSuite/1" />
</testsuite> </testsuite>
</testsuites>""" % { </testsuites>""" % {
'stack': STACK_TRACE_TEMPLATE 'stack': STACK_TRACE_TEMPLATE,
'stack_entity': STACK_TRACE_ENTITY_TEMPLATE,
} }
EXPECTED_FILTERED_TEST_XML = """<?xml version="1.0" encoding="UTF-8"?> EXPECTED_FILTERED_TEST_XML = """<?xml version="1.0" encoding="UTF-8"?>
@ -195,24 +198,24 @@ EXPECTED_FILTERED_TEST_XML = """<?xml version="1.0" encoding="UTF-8"?>
timestamp="*" name="AllTests" ad_hoc_property="42"> timestamp="*" name="AllTests" ad_hoc_property="42">
<testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0" skipped="0" <testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0" skipped="0"
errors="0" time="*" timestamp="*"> errors="0" time="*" timestamp="*">
<testcase name="Succeeds" file="gtest_xml_output_unittest_.cc" line="51" status="run" result="completed" time="*" timestamp="*" classname="SuccessfulTest"/> <testcase name="Succeeds" file="gtest_xml_output_unittest_.cc" line="53" status="run" result="completed" time="*" timestamp="*" classname="SuccessfulTest"/>
</testsuite> </testsuite>
</testsuites>""" </testsuites>"""
EXPECTED_SHARDED_TEST_XML = """<?xml version="1.0" encoding="UTF-8"?> EXPECTED_SHARDED_TEST_XML = """<?xml version="1.0" encoding="UTF-8"?>
<testsuites tests="3" failures="0" disabled="0" errors="0" time="*" timestamp="*" name="AllTests" ad_hoc_property="42"> <testsuites tests="3" failures="0" disabled="0" errors="0" time="*" timestamp="*" name="AllTests" ad_hoc_property="42">
<testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*"> <testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
<testcase name="Succeeds" file="gtest_xml_output_unittest_.cc" line="51" status="run" result="completed" time="*" timestamp="*" classname="SuccessfulTest"/> <testcase name="Succeeds" file="gtest_xml_output_unittest_.cc" line="53" status="run" result="completed" time="*" timestamp="*" classname="SuccessfulTest"/>
</testsuite> </testsuite>
<testsuite name="PropertyRecordingTest" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*" SetUpTestSuite="yes" TearDownTestSuite="aye"> <testsuite name="PropertyRecordingTest" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*" SetUpTestSuite="yes" TearDownTestSuite="aye">
<testcase name="IntValuedProperty" file="gtest_xml_output_unittest_.cc" line="123" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest"> <testcase name="IntValuedProperty" file="gtest_xml_output_unittest_.cc" line="125" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
<properties> <properties>
<property name="key_int" value="1"/> <property name="key_int" value="1"/>
</properties> </properties>
</testcase> </testcase>
</testsuite> </testsuite>
<testsuite name="Single/ValueParamTest" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*"> <testsuite name="Single/ValueParamTest" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
<testcase name="HasValueParamAttribute/0" file="gtest_xml_output_unittest_.cc" line="162" value_param="33" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" /> <testcase name="HasValueParamAttribute/0" file="gtest_xml_output_unittest_.cc" line="164" value_param="33" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
</testsuite> </testsuite>
</testsuites>""" </testsuites>"""
@ -221,14 +224,15 @@ EXPECTED_NO_TEST_XML = """<?xml version="1.0" encoding="UTF-8"?>
timestamp="*" name="AllTests"> timestamp="*" name="AllTests">
<testsuite name="NonTestSuiteFailure" tests="1" failures="1" disabled="0" skipped="0" errors="0" time="*" timestamp="*"> <testsuite name="NonTestSuiteFailure" tests="1" failures="1" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
<testcase name="" status="run" result="completed" time="*" timestamp="*" classname=""> <testcase name="" status="run" result="completed" time="*" timestamp="*" classname="">
<failure message="gtest_no_test_unittest.cc:*&#x0A;Expected equality of these values:&#x0A; 1&#x0A; 2" type=""><![CDATA[gtest_no_test_unittest.cc:* <failure message="gtest_no_test_unittest.cc:*&#x0A;Expected equality of these values:&#x0A; 1&#x0A; 2%(stack_entity)s" type=""><![CDATA[gtest_no_test_unittest.cc:*
Expected equality of these values: Expected equality of these values:
1 1
2%(stack)s]]></failure> 2%(stack)s]]></failure>
</testcase> </testcase>
</testsuite> </testsuite>
</testsuites>""" % { </testsuites>""" % {
'stack': STACK_TRACE_TEMPLATE 'stack': STACK_TRACE_TEMPLATE,
'stack_entity': STACK_TRACE_ENTITY_TEMPLATE,
} }
GTEST_PROGRAM_PATH = gtest_test_utils.GetTestExecutablePath(GTEST_PROGRAM_NAME) GTEST_PROGRAM_PATH = gtest_test_utils.GetTestExecutablePath(GTEST_PROGRAM_NAME)

2
googletest/test/gtest_xml_output_unittest_.cc
View File

@ -37,6 +37,8 @@
// directly. // directly.
// clang-format off // clang-format off
#include <string>
#include "gtest/gtest.h" #include "gtest/gtest.h"
using ::testing::InitGoogleTest; using ::testing::InitGoogleTest;

2
googletest/test/gtest_xml_test_utils.py
View File

@ -218,7 +218,7 @@ class GTestXMLTestCase(gtest_test_utils.TestCase):
) )
if element.tagName in ('testsuites', 'testsuite', 'testcase'): if element.tagName in ('testsuites', 'testsuite', 'testcase'):
time = element.getAttributeNode('time') time = element.getAttributeNode('time')
# The value for exact N seconds has a traling decimal point (e.g., "10." # The value for exact N seconds has a trailing decimal point (e.g., "10."
# instead of "10") # instead of "10")
time.value = re.sub(r'^\d+\.(\d+)?$', '*', time.value) time.value = re.sub(r'^\d+\.(\d+)?$', '*', time.value)
type_param = element.getAttributeNode('type_param') type_param = element.getAttributeNode('type_param')

22
googletest_deps.bzl Normal file
View File

@ -0,0 +1,22 @@
"""Load dependencies needed to use the googletest library as a 3rd-party consumer."""
load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
def googletest_deps():
"""Loads common dependencies needed to use the googletest library."""
if not native.existing_rule("com_googlesource_code_re2"):
http_archive(
name = "com_googlesource_code_re2", # 2022-12-21T14:29:10Z
sha256 = "b9ce3a51beebb38534d11d40f8928d40509b9e18a735f6a4a97ad3d014c87cb5",
strip_prefix = "re2-d0b1f8f2ecc2ea74956c7608b6f915175314ff0e",
urls = ["https://github.com/google/re2/archive/d0b1f8f2ecc2ea74956c7608b6f915175314ff0e.zip"],
)
if not native.existing_rule("com_google_absl"):
http_archive(
name = "com_google_absl", # 2023-04-06T14:42:25Z
sha256 = "a50452f02402262f9a61a8eedda60f76dda6b9538d36b34b55bce9f74a4d5ef8",
strip_prefix = "abseil-cpp-e73b9139ee9b853a4bd7812531442c138da09084",
urls = ["https://github.com/abseil/abseil-cpp/archive/e73b9139ee9b853a4bd7812531442c138da09084.zip"],
)