{
...
};
```
@@ -1119,8 +1148,8 @@ with parameter values `"cat"` and `"dog"` using the
[`ValuesIn`](reference/testing.md#param-generators) parameter generator:
```c++
-const char* pets[] = {"cat", "dog"};
-INSTANTIATE_TEST_SUITE_P(Pets, FooTest, testing::ValuesIn(pets));
+constexpr absl::string_view kPets[] = {"cat", "dog"};
+INSTANTIATE_TEST_SUITE_P(Pets, FooTest, testing::ValuesIn(kPets));
```
The tests from the instantiation above will have these names:
@@ -1495,12 +1524,12 @@ To test them, we use the following special techniques:
## "Catching" Failures
-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.
+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.
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
-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?
`"gtest/gtest-spi.h"` contains some constructs to do this.
@@ -1643,9 +1672,9 @@ particular, you cannot find the test suite name in `SetUpTestSuite()`,
`TearDownTestSuite()` (where you know the test suite name implicitly), or
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
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
@@ -1706,7 +1735,7 @@ Here's an example:
### Using Event Listeners
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"
at the end of the name) in your `main()` function, before calling
`RUN_ALL_TESTS()`:
@@ -1717,7 +1746,7 @@ int main(int argc, char** argv) {
// Gets hold of the event listener list.
testing::TestEventListeners& 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);
return RUN_ALL_TESTS();
}
@@ -1769,7 +1798,7 @@ See [sample10_unittest.cc] for an example of a failure-raising listener.
## 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
and/or command line flags. For the flags to work, your programs must call
`::testing::InitGoogleTest()` before calling `RUN_ALL_TESTS()`.
@@ -1802,10 +1831,10 @@ corresponding environment variable for this flag.
#### 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
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.
The format of a filter is a '`:`'-separated list of wildcard patterns (called
@@ -1836,7 +1865,7 @@ For example:
#### 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
test execution upon first failure (trading improved latency for completeness).
If `GTEST_FAIL_FAST` environment variable or `--gtest_fail_fast` flag is set,
@@ -1853,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
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:
```c++
@@ -1868,7 +1897,7 @@ TEST_F(DISABLED_BarTest, DoesXyz) { ... }
{: .callout .note}
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.
{: .callout .tip}
@@ -1926,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.
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
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`
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
-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.
-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.
### Distributing Test Functions to Multiple Machines
@@ -1994,7 +2023,7 @@ shards, but here's one possible scenario:
#### 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:
...
@@ -2019,25 +2048,25 @@ important information:
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,
-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
platforms) the `TERM` environment variable is set to `xterm` or `xterm-color`.
#### 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
`--gtest_brief=1`, or set the GTEST_BRIEF environment variable to `1`.
#### 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
set the GTEST_PRINT_TIME environment variable to `0`.
#### 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
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
@@ -2046,7 +2075,7 @@ environment variable to `0`.
#### 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
you identify slow tests.
@@ -2057,15 +2086,15 @@ in which case the output can be found in the `test_detail.xml` file in the
current directory.
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
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.
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
-apply to googletest tests, as shown here:
+apply to GoogleTest tests, as shown here:
```xml
@@ -2080,8 +2109,8 @@ apply to googletest tests, as shown here:
```
* The root `` element corresponds to the entire test program.
-* `` elements correspond to googletest test suites.
-* `` elements correspond to googletest test functions.
+* `` elements correspond to GoogleTest test suites.
+* `` elements correspond to GoogleTest test functions.
For instance, the following program
@@ -2114,7 +2143,7 @@ could generate this report:
Things to note:
* The `tests` attribute of a `` or `` 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.
* The `time` attribute expresses the duration of the test, test suite, or
@@ -2126,12 +2155,12 @@ Things to note:
* The `file` and `line` attributes record the source file location, where the
test was defined.
-* Each `` element corresponds to a single failed googletest
+* Each `` element corresponds to a single failed GoogleTest
assertion.
#### 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
`--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
@@ -2356,7 +2385,7 @@ variable has been set.
When running test programs under a debugger, it's very convenient if the
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
other than `0`. Alternatively, you can use the `--gtest_break_on_failure`
@@ -2364,9 +2393,9 @@ command line flag.
#### 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
-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
uncaught exception will cause a pop-up window, so catching the exceptions allows
you to run the tests automatically.
@@ -2404,4 +2433,4 @@ void __tsan_on_report() {
```
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.
diff --git a/third-party/googletest-1.13.0/docs/assets/css/style.scss b/third-party/googletest-1.14.0/docs/assets/css/style.scss
similarity index 100%
rename from third-party/googletest-1.13.0/docs/assets/css/style.scss
rename to third-party/googletest-1.14.0/docs/assets/css/style.scss
diff --git a/third-party/googletest-1.13.0/docs/community_created_documentation.md b/third-party/googletest-1.14.0/docs/community_created_documentation.md
similarity index 100%
rename from third-party/googletest-1.13.0/docs/community_created_documentation.md
rename to third-party/googletest-1.14.0/docs/community_created_documentation.md
diff --git a/third-party/googletest-1.13.0/docs/faq.md b/third-party/googletest-1.14.0/docs/faq.md
similarity index 100%
rename from third-party/googletest-1.13.0/docs/faq.md
rename to third-party/googletest-1.14.0/docs/faq.md
diff --git a/third-party/googletest-1.13.0/docs/gmock_cheat_sheet.md b/third-party/googletest-1.14.0/docs/gmock_cheat_sheet.md
similarity index 99%
rename from third-party/googletest-1.13.0/docs/gmock_cheat_sheet.md
rename to third-party/googletest-1.14.0/docs/gmock_cheat_sheet.md
index 2fb0403e61..ddafaaa220 100644
--- a/third-party/googletest-1.13.0/docs/gmock_cheat_sheet.md
+++ b/third-party/googletest-1.14.0/docs/gmock_cheat_sheet.md
@@ -20,7 +20,7 @@ class Foo {
(note that `~Foo()` **must** be virtual) we can define its mock as
```cpp
-#include "gmock/gmock.h"
+#include
class MockFoo : public Foo {
public:
diff --git a/third-party/googletest-1.13.0/docs/gmock_cook_book.md b/third-party/googletest-1.14.0/docs/gmock_cook_book.md
similarity index 98%
rename from third-party/googletest-1.13.0/docs/gmock_cook_book.md
rename to third-party/googletest-1.14.0/docs/gmock_cook_book.md
index fc7db35b82..da10918c96 100644
--- a/third-party/googletest-1.13.0/docs/gmock_cook_book.md
+++ b/third-party/googletest-1.14.0/docs/gmock_cook_book.md
@@ -285,6 +285,10 @@ If you are concerned about the performance overhead incurred by virtual
functions, and profiling confirms your concern, you can combine this with the
recipe for [mocking non-virtual methods](#MockingNonVirtualMethods).
+Alternatively, instead of introducing a new interface, you can rewrite your code
+to accept a std::function instead of the free function, and then use
+[MockFunction](#MockFunction) to mock the std::function.
+
### Old-Style `MOCK_METHODn` Macros
Before the generic `MOCK_METHOD` macro
@@ -693,9 +697,9 @@ TEST(AbcTest, Xyz) {
EXPECT_CALL(foo, DoThat(_, _));
int n = 0;
- EXPECT_EQ('+', foo.DoThis(5)); // FakeFoo::DoThis() is invoked.
+ EXPECT_EQ(foo.DoThis(5), '+'); // FakeFoo::DoThis() is invoked.
foo.DoThat("Hi", &n); // FakeFoo::DoThat() is invoked.
- EXPECT_EQ(2, n);
+ EXPECT_EQ(n, 2);
}
```
@@ -1125,11 +1129,11 @@ using STL's `` header is just painful). For example, here's a
predicate that's satisfied by any number that is >= 0, <= 100, and != 50:
```cpp
-using testing::AllOf;
-using testing::Ge;
-using testing::Le;
-using testing::Matches;
-using testing::Ne;
+using ::testing::AllOf;
+using ::testing::Ge;
+using ::testing::Le;
+using ::testing::Matches;
+using ::testing::Ne;
...
Matches(AllOf(Ge(0), Le(100), Ne(50)))
```
@@ -1857,7 +1861,7 @@ error. So, what shall you do?
Though you may be tempted, DO NOT use `std::ref()`:
```cpp
-using testing::Return;
+using ::testing::Return;
class MockFoo : public Foo {
public:
@@ -1869,7 +1873,7 @@ class MockFoo : public Foo {
EXPECT_CALL(foo, GetValue())
.WillRepeatedly(Return(std::ref(x))); // Wrong!
x = 42;
- EXPECT_EQ(42, foo.GetValue());
+ EXPECT_EQ(foo.GetValue(), 42);
```
Unfortunately, it doesn't work here. The above code will fail with error:
@@ -1891,14 +1895,14 @@ the expectation is set, and `Return(std::ref(x))` will always return 0.
returns the value pointed to by `pointer` at the time the action is *executed*:
```cpp
-using testing::ReturnPointee;
+using ::testing::ReturnPointee;
...
int x = 0;
MockFoo foo;
EXPECT_CALL(foo, GetValue())
.WillRepeatedly(ReturnPointee(&x)); // Note the & here.
x = 42;
- EXPECT_EQ(42, foo.GetValue()); // This will succeed now.
+ EXPECT_EQ(foo.GetValue(), 42); // This will succeed now.
```
### Combining Actions
@@ -2260,7 +2264,7 @@ TEST_F(FooTest, Test) {
EXPECT_CALL(foo, DoThis(2))
.WillOnce(Invoke(NewPermanentCallback(SignOfSum, 5)));
- EXPECT_EQ('+', foo.DoThis(2)); // Invokes SignOfSum(5, 2).
+ EXPECT_EQ(foo.DoThis(2), '+'); // Invokes SignOfSum(5, 2).
}
```
@@ -2636,8 +2640,8 @@ action will exhibit different behaviors. Example:
.WillRepeatedly(IncrementCounter(0));
foo.DoThis(); // Returns 1.
foo.DoThis(); // Returns 2.
- foo.DoThat(); // Returns 1 - Blah() uses a different
- // counter than Bar()'s.
+ foo.DoThat(); // Returns 1 - DoThat() uses a different
+ // counter than DoThis()'s.
```
versus
@@ -2767,36 +2771,33 @@ returns a null `unique_ptr`, that’s what you’ll get if you don’t specify a
action:
```cpp
+using ::testing::IsNull;
+...
// Use the default action.
EXPECT_CALL(mock_buzzer_, MakeBuzz("hello"));
// Triggers the previous EXPECT_CALL.
- EXPECT_EQ(nullptr, mock_buzzer_.MakeBuzz("hello"));
+ EXPECT_THAT(mock_buzzer_.MakeBuzz("hello"), IsNull());
```
If you are not happy with the default action, you can tweak it as usual; see
[Setting Default Actions](#OnCall).
-If you just need to return a pre-defined move-only value, you can use the
-`Return(ByMove(...))` action:
+If you just need to return a move-only value, you can use it in combination with
+`WillOnce`. For example:
```cpp
- // When this fires, the unique_ptr<> specified by ByMove(...) will
- // be returned.
- EXPECT_CALL(mock_buzzer_, MakeBuzz("world"))
- .WillOnce(Return(ByMove(std::make_unique(AccessLevel::kInternal))));
-
- EXPECT_NE(nullptr, mock_buzzer_.MakeBuzz("world"));
+ EXPECT_CALL(mock_buzzer_, MakeBuzz("hello"))
+ .WillOnce(Return(std::make_unique(AccessLevel::kInternal)));
+ EXPECT_NE(nullptr, mock_buzzer_.MakeBuzz("hello"));
```
-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(ByMove(...))` action is
-performed more than once (e.g. you write `...
-.WillRepeatedly(Return(ByMove(...)));`)? Come think of it, after the first time
-the action runs, the source value will be consumed (since it’s a move-only
-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.
+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
+think of it, after the first time the action runs, the source value will be
+consumed (since it’s a move-only value), so the next time around, there’s no
+value to move from -- you’ll get a run-time error that `Return(std::move(...))`
+can only be run once.
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
@@ -2813,7 +2814,7 @@ pretty much anything you want:
```
Every time this `EXPECT_CALL` fires, a new `unique_ptr` 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
accepting move-only arguments? The answer is that they work normally, although
@@ -3193,11 +3194,11 @@ You can unlock this power by running your test with the `--gmock_verbose=info`
flag. For example, given the test program:
```cpp
-#include "gmock/gmock.h"
+#include
-using testing::_;
-using testing::HasSubstr;
-using testing::Return;
+using ::testing::_;
+using ::testing::HasSubstr;
+using ::testing::Return;
class MockFoo {
public:
@@ -3818,15 +3819,15 @@ If the built-in actions don't work for you, you can easily define your own one.
All you need is a call operator with a signature compatible with the mocked
function. So you can use a lambda:
-```
+```cpp
MockFunction mock;
EXPECT_CALL(mock, Call).WillOnce([](const int input) { return input * 7; });
-EXPECT_EQ(14, mock.AsStdFunction()(2));
+EXPECT_EQ(mock.AsStdFunction()(2), 14);
```
Or a struct with a call operator (even a templated one):
-```
+```cpp
struct MultiplyBy {
template
T operator()(T arg) { return arg * multiplier; }
@@ -3841,16 +3842,16 @@ struct MultiplyBy {
It's also fine for the callable to take no arguments, ignoring the arguments
supplied to the mock function:
-```
+```cpp
MockFunction mock;
EXPECT_CALL(mock, Call).WillOnce([] { return 17; });
-EXPECT_EQ(17, mock.AsStdFunction()(0));
+EXPECT_EQ(mock.AsStdFunction()(0), 17);
```
When used with `WillOnce`, the callable can assume it will be called at most
once and is allowed to be a move-only type:
-```
+```cpp
// An action that contains move-only types and has an &&-qualified operator,
// demanding in the type system that it be called at most once. This can be
// used with WillOnce, but the compiler will reject it if handed to
@@ -4294,7 +4295,7 @@ particular type than to dump the bytes.
### Mock std::function {#MockFunction}
`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.
But fear not - `MockFunction` can help you with that.
diff --git a/third-party/googletest-1.13.0/docs/gmock_faq.md b/third-party/googletest-1.14.0/docs/gmock_faq.md
similarity index 100%
rename from third-party/googletest-1.13.0/docs/gmock_faq.md
rename to third-party/googletest-1.14.0/docs/gmock_faq.md
diff --git a/third-party/googletest-1.13.0/docs/gmock_for_dummies.md b/third-party/googletest-1.14.0/docs/gmock_for_dummies.md
similarity index 99%
rename from third-party/googletest-1.13.0/docs/gmock_for_dummies.md
rename to third-party/googletest-1.14.0/docs/gmock_for_dummies.md
index b7264d3587..43f907aaa5 100644
--- a/third-party/googletest-1.13.0/docs/gmock_for_dummies.md
+++ b/third-party/googletest-1.14.0/docs/gmock_for_dummies.md
@@ -164,7 +164,7 @@ follow:
After the process, you should have something like:
```cpp
-#include "gmock/gmock.h" // Brings in gMock.
+#include // Brings in gMock.
class MockTurtle : public Turtle {
public:
@@ -224,8 +224,8 @@ Here's an example:
```cpp
#include "path/to/mock-turtle.h"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
+#include
+#include
using ::testing::AtLeast; // #1
diff --git a/third-party/googletest-1.13.0/docs/index.md b/third-party/googletest-1.14.0/docs/index.md
similarity index 100%
rename from third-party/googletest-1.13.0/docs/index.md
rename to third-party/googletest-1.14.0/docs/index.md
diff --git a/third-party/googletest-1.13.0/docs/pkgconfig.md b/third-party/googletest-1.14.0/docs/pkgconfig.md
similarity index 94%
rename from third-party/googletest-1.13.0/docs/pkgconfig.md
rename to third-party/googletest-1.14.0/docs/pkgconfig.md
index 18a2546a38..bf05d59316 100644
--- a/third-party/googletest-1.13.0/docs/pkgconfig.md
+++ b/third-party/googletest-1.14.0/docs/pkgconfig.md
@@ -19,19 +19,15 @@ examples here we assume you want to compile the sample
Using `pkg-config` in CMake is fairly easy:
```cmake
-cmake_minimum_required(VERSION 3.0)
-
-cmake_policy(SET CMP0048 NEW)
-project(my_gtest_pkgconfig VERSION 0.0.1 LANGUAGES CXX)
-
find_package(PkgConfig)
pkg_search_module(GTEST REQUIRED gtest_main)
-add_executable(testapp samples/sample3_unittest.cc)
-target_link_libraries(testapp ${GTEST_LDFLAGS})
-target_compile_options(testapp PUBLIC ${GTEST_CFLAGS})
+add_executable(testapp)
+target_sources(testapp PRIVATE samples/sample3_unittest.cc)
+target_link_libraries(testapp PRIVATE ${GTEST_LDFLAGS})
+target_compile_options(testapp PRIVATE ${GTEST_CFLAGS})
-include(CTest)
+enable_testing()
add_test(first_and_only_test testapp)
```
diff --git a/third-party/googletest-1.14.0/docs/platforms.md b/third-party/googletest-1.14.0/docs/platforms.md
new file mode 100644
index 0000000000..d35a7be054
--- /dev/null
+++ b/third-party/googletest-1.14.0/docs/platforms.md
@@ -0,0 +1,8 @@
+# Supported Platforms
+
+GoogleTest follows Google's
+[Foundational C++ Support Policy](https://opensource.google/documentation/policies/cplusplus-support).
+See
+[this table](https://github.com/google/oss-policies-info/blob/main/foundational-cxx-support-matrix.md)
+for a list of currently supported versions compilers, platforms, and build
+tools.
diff --git a/third-party/googletest-1.13.0/docs/primer.md b/third-party/googletest-1.14.0/docs/primer.md
similarity index 85%
rename from third-party/googletest-1.13.0/docs/primer.md
rename to third-party/googletest-1.14.0/docs/primer.md
index 2ffbf53bc8..f2a97a7269 100644
--- a/third-party/googletest-1.13.0/docs/primer.md
+++ b/third-party/googletest-1.14.0/docs/primer.md
@@ -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
-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.
-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
- 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,
- 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
- 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
easy to maintain. Such consistency is especially helpful when people switch
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
- 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
- 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
- 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
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
cycle.
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
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
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
minutes to learn the basics and get started. So let's go!
-## Beware of the nomenclature
+## Beware of the Nomenclature
{: .callout .note}
-_Note:_ There might be some confusion arising from different definitions of the
-terms _Test_, _Test Case_ and _Test Suite_, so beware of misunderstanding these.
+*Note:* There might be some confusion arising from different definitions of the
+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
Testing Qualifications Board ([ISTQB](http://www.istqb.org/)) materials and
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
-_[Test Case][istqb test case]_ of ISTQB and others.
+The related term *Test*, as it is used in GoogleTest, corresponds to the term
+*[Test Case][istqb test case]* of ISTQB and others.
-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
+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
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
deprecated and refactored away.
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]
@@ -78,7 +78,7 @@ Exercise a particular program path with specific input values and verify the res
## 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*,
*nonfatal failure*, or *fatal failure*. If a fatal failure occurs, it aborts the
current function; otherwise the program continues normally.
@@ -98,11 +98,11 @@ assertion level and building up to tests and test suites.
## 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,
-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
-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
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
ordinary C++ functions that don't return a value.
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
test fails (either fatally or non-fatally), or if the test crashes, the
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
`TEST()` should be the same. In the above example, we have two tests,
`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:
```c++
-TEST_F(TestFixtureName, TestName) {
+TEST_F(TestFixtureClassName, TestName) {
... test body ...
}
```
-Like `TEST()`, the first argument is the test suite name, but for `TEST_F()`
-this must be the name of the test fixture class. You've probably guessed: `_F`
-is for fixture.
+Unlike `TEST()`, in `TEST_F()` the first argument must be the name of the test
+fixture class. (`_F` stands for "Fixture"). No test suite name is specified for
+this 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
@@ -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
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
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
-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 always deletes a test fixture before it creates the next one.
+GoogleTest does **not** reuse the same test fixture for multiple tests. Any
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
@@ -325,7 +325,7 @@ would lead to a segfault when `n` is `NULL`.
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`.
3. The first test (`IsEmptyInitially`) runs on `t1`.
4. `t1.TearDown()` cleans up after the test finishes.
@@ -337,7 +337,7 @@ When these tests run, the following happens:
## 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
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:
-* Saves the state of all googletest flags.
+* Saves the state of all GoogleTest flags.
* Creates a test fixture object for the first test.
@@ -360,7 +360,7 @@ When invoked, the `RUN_ALL_TESTS()` macro:
* 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.
@@ -374,14 +374,14 @@ If a fatal failure happens the subsequent steps will be skipped.
> return the value of `RUN_ALL_TESTS()`.
>
> 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.
**Availability**: Linux, Windows, Mac.
## 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
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
@@ -395,7 +395,7 @@ You can start from this boilerplate:
```c++
#include "this/package/foo.h"
-#include "gtest/gtest.h"
+#include
namespace my {
namespace project {
@@ -456,7 +456,7 @@ int main(int argc, char **argv) {
```
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
[AdvancedGuide](advanced.md). You **must** call this function before calling
`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
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
the assertions are done in the main thread. If you want to help, you can
volunteer to implement the necessary synchronization primitives in
diff --git a/third-party/googletest-1.13.0/docs/quickstart-bazel.md b/third-party/googletest-1.14.0/docs/quickstart-bazel.md
similarity index 91%
rename from third-party/googletest-1.13.0/docs/quickstart-bazel.md
rename to third-party/googletest-1.14.0/docs/quickstart-bazel.md
index 15c27a22ed..4f693dbe7f 100644
--- a/third-party/googletest-1.13.0/docs/quickstart-bazel.md
+++ b/third-party/googletest-1.14.0/docs/quickstart-bazel.md
@@ -105,10 +105,17 @@ file (`@com_google_googletest`). For more information about Bazel `BUILD` files,
see the
[Bazel C++ Tutorial](https://docs.bazel.build/versions/main/tutorial/cpp.html).
+{: .callout .note}
+NOTE: In the example below, we assume Clang or GCC and set `--cxxopt=-std=c++14`
+to ensure that GoogleTest is compiled as C++14 instead of the compiler's default
+setting (which could be C++11). For MSVC, the equivalent would be
+`--cxxopt=/std:c++14`. See [Supported Platforms](platforms.md) for more details
+on supported language versions.
+
Now you can build and run your test:
-my_workspace$ bazel test --test_output=all //:hello_test
+my_workspace$ bazel test --cxxopt=-std=c++14 --test_output=all //:hello_test
INFO: Analyzed target //:hello_test (26 packages loaded, 362 targets configured).
INFO: Found 1 test target...
INFO: From Testing //:hello_test:
diff --git a/third-party/googletest-1.13.0/docs/quickstart-cmake.md b/third-party/googletest-1.14.0/docs/quickstart-cmake.md
similarity index 99%
rename from third-party/googletest-1.13.0/docs/quickstart-cmake.md
rename to third-party/googletest-1.14.0/docs/quickstart-cmake.md
index 5abe504412..4e422b74f8 100644
--- a/third-party/googletest-1.13.0/docs/quickstart-cmake.md
+++ b/third-party/googletest-1.14.0/docs/quickstart-cmake.md
@@ -54,6 +54,7 @@ project(my_project)
# GoogleTest requires at least C++14
set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
include(FetchContent)
FetchContent_Declare(
diff --git a/third-party/googletest-1.13.0/docs/reference/actions.md b/third-party/googletest-1.14.0/docs/reference/actions.md
similarity index 100%
rename from third-party/googletest-1.13.0/docs/reference/actions.md
rename to third-party/googletest-1.14.0/docs/reference/actions.md
diff --git a/third-party/googletest-1.13.0/docs/reference/assertions.md b/third-party/googletest-1.14.0/docs/reference/assertions.md
similarity index 99%
rename from third-party/googletest-1.13.0/docs/reference/assertions.md
rename to third-party/googletest-1.14.0/docs/reference/assertions.md
index 7bf03a3dde..aa1dbc04bd 100644
--- a/third-party/googletest-1.13.0/docs/reference/assertions.md
+++ b/third-party/googletest-1.14.0/docs/reference/assertions.md
@@ -88,7 +88,7 @@ For example, the following code verifies that the string `value1` starts with
10:
```cpp
-#include "gmock/gmock.h"
+#include
using ::testing::AllOf;
using ::testing::Gt;
@@ -515,7 +515,7 @@ Verifies that *`expression`* is a success `HRESULT`.
### EXPECT_HRESULT_FAILED {#EXPECT_HRESULT_FAILED}
`EXPECT_HRESULT_FAILED(`*`expression`*`)` \
-`EXPECT_HRESULT_FAILED(`*`expression`*`)`
+`ASSERT_HRESULT_FAILED(`*`expression`*`)`
Verifies that *`expression`* is a failure `HRESULT`.
diff --git a/third-party/googletest-1.13.0/docs/reference/matchers.md b/third-party/googletest-1.14.0/docs/reference/matchers.md
similarity index 97%
rename from third-party/googletest-1.13.0/docs/reference/matchers.md
rename to third-party/googletest-1.14.0/docs/reference/matchers.md
index 9fb1592751..243e3f9516 100644
--- a/third-party/googletest-1.13.0/docs/reference/matchers.md
+++ b/third-party/googletest-1.14.0/docs/reference/matchers.md
@@ -102,7 +102,7 @@ The `argument` can be either a C string or a C++ string object:
| `StrCaseNe(string)` | `argument` is not equal to `string`, ignoring case. |
| `StrEq(string)` | `argument` is equal to `string`. |
| `StrNe(string)` | `argument` is not equal to `string`. |
-| `WhenBase64Unescaped(m)` | `argument` is a base-64 escaped string whose unescaped string matches `m`. |
+| `WhenBase64Unescaped(m)` | `argument` is a base-64 escaped string whose unescaped string matches `m`. The web-safe format from [RFC 4648](https://www.rfc-editor.org/rfc/rfc4648#section-5) is supported. |
`ContainsRegex()` and `MatchesRegex()` take ownership of the `RE` object. They
use the regular expression syntax defined
@@ -288,3 +288,15 @@ which must be a permanent callback.
return ExplainMatchResult(matcher, arg.nested().property(), result_listener);
}
```
+
+5. You can use `DescribeMatcher<>` to describe another matcher. For example:
+
+ ```cpp
+ MATCHER_P(XAndYThat, matcher,
+ "X that " + DescribeMatcher(matcher, negation) +
+ (negation ? " or" : " and") + " Y that " +
+ DescribeMatcher(matcher, negation)) {
+ return ExplainMatchResult(matcher, arg.x(), result_listener) &&
+ ExplainMatchResult(matcher, arg.y(), result_listener);
+ }
+ ```
diff --git a/third-party/googletest-1.13.0/docs/reference/mocking.md b/third-party/googletest-1.14.0/docs/reference/mocking.md
similarity index 100%
rename from third-party/googletest-1.13.0/docs/reference/mocking.md
rename to third-party/googletest-1.14.0/docs/reference/mocking.md
diff --git a/third-party/googletest-1.13.0/docs/reference/testing.md b/third-party/googletest-1.14.0/docs/reference/testing.md
similarity index 96%
rename from third-party/googletest-1.13.0/docs/reference/testing.md
rename to third-party/googletest-1.14.0/docs/reference/testing.md
index 62cdcc1c65..17225a682f 100644
--- a/third-party/googletest-1.13.0/docs/reference/testing.md
+++ b/third-party/googletest-1.14.0/docs/reference/testing.md
@@ -110,6 +110,7 @@ namespace:
| `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`. |
| `ConvertGenerator(g)` | Yields values generated by generator `g`, `static_cast` to `T`. |
+
The optional last argument *`name_generator`* is a function or functor that
generates custom test name suffixes based on the test parameters. The function
must accept an argument of type
@@ -121,8 +122,8 @@ custom function can be used for more control:
```cpp
INSTANTIATE_TEST_SUITE_P(
MyInstantiation, MyTestSuite,
- ::testing::Values(...),
- [](const ::testing::TestParamInfo& info) {
+ testing::Values(...),
+ [](const testing::TestParamInfo& info) {
// Can use info.param here to generate the test suffix
std::string name = ...
return name;
@@ -147,7 +148,7 @@ type, for example:
```cpp
template
-class MyFixture : public ::testing::Test {
+class MyFixture : public testing::Test {
public:
...
using List = std::list;
@@ -323,7 +324,7 @@ Then the test code should look like:
```cpp
namespace my_namespace {
-class MyClassTest : public ::testing::Test {
+class MyClassTest : public testing::Test {
...
};
@@ -386,7 +387,7 @@ GoogleTest defines the following classes and types to help with writing tests.
### AssertionResult {#AssertionResult}
-`::testing::AssertionResult`
+`testing::AssertionResult`
A class for indicating whether an assertion was successful.
@@ -400,14 +401,14 @@ To create an instance of this class, use one of the factory functions
### AssertionException {#AssertionException}
-`::testing::AssertionException`
+`testing::AssertionException`
Exception which can be thrown from
[`TestEventListener::OnTestPartResult`](#TestEventListener::OnTestPartResult).
### EmptyTestEventListener {#EmptyTestEventListener}
-`::testing::EmptyTestEventListener`
+`testing::EmptyTestEventListener`
Provides an empty implementation of all methods in the
[`TestEventListener`](#TestEventListener) interface, such that a subclass only
@@ -415,7 +416,7 @@ needs to override the methods it cares about.
### Environment {#Environment}
-`::testing::Environment`
+`testing::Environment`
Represents a global test environment. See
[Global Set-Up and Tear-Down](../advanced.md#global-set-up-and-tear-down).
@@ -436,7 +437,7 @@ Override this to define how to tear down the environment.
### ScopedTrace {#ScopedTrace}
-`::testing::ScopedTrace`
+`testing::ScopedTrace`
An instance of this class causes a trace to be included in every test failure
message generated by code in the scope of the lifetime of the `ScopedTrace`
@@ -452,7 +453,7 @@ ScopedTrace(const char* file, int line, const T& message)
Example usage:
```cpp
-::testing::ScopedTrace trace("file.cc", 123, "message");
+testing::ScopedTrace trace("file.cc", 123, "message");
```
The resulting trace includes the given source file path and line number, and the
@@ -463,7 +464,7 @@ See also [`SCOPED_TRACE`](#SCOPED_TRACE).
### Test {#Test}
-`::testing::Test`
+`testing::Test`
The abstract class that all tests inherit from. `Test` is not copyable.
@@ -551,7 +552,7 @@ after running each individual test.
### TestWithParam {#TestWithParam}
-`::testing::TestWithParam`
+`testing::TestWithParam`
A convenience class which inherits from both [`Test`](#Test) and
[`WithParamInterface`](#WithParamInterface).
@@ -671,7 +672,7 @@ during execution of `SetUpTestSuite` and `TearDownTestSuite`.
### TestInfo {#TestInfo}
-`::testing::TestInfo`
+`testing::TestInfo`
Stores information about a test.
@@ -750,7 +751,7 @@ Returns the result of the test. See [`TestResult`](#TestResult).
### TestParamInfo {#TestParamInfo}
-`::testing::TestParamInfo`
+`testing::TestParamInfo`
Describes a parameter to a value-parameterized test. The type `T` is the type of
the parameter.
@@ -760,7 +761,7 @@ and its integer index respectively.
### UnitTest {#UnitTest}
-`::testing::UnitTest`
+`testing::UnitTest`
This class contains information about the test program.
@@ -928,7 +929,7 @@ GoogleTest. See [`TestEventListeners`](#TestEventListeners).
### TestEventListener {#TestEventListener}
-`::testing::TestEventListener`
+`testing::TestEventListener`
The interface for tracing execution of tests. The methods below are listed in
the order the corresponding events are fired.
@@ -1026,7 +1027,7 @@ Fired after all test activities have ended.
### TestEventListeners {#TestEventListeners}
-`::testing::TestEventListeners`
+`testing::TestEventListeners`
Lets users add listeners to track events in GoogleTest.
@@ -1071,7 +1072,7 @@ the caller and makes this function return `NULL` the next time.
### TestPartResult {#TestPartResult}
-`::testing::TestPartResult`
+`testing::TestPartResult`
A copyable object representing the result of a test part (i.e. an assertion or
an explicit `FAIL()`, `ADD_FAILURE()`, or `SUCCESS()`).
@@ -1153,7 +1154,7 @@ Returns true if and only if the test part failed.
### TestProperty {#TestProperty}
-`::testing::TestProperty`
+`testing::TestProperty`
A copyable object representing a user-specified test property which can be
output as a key/value string pair.
@@ -1180,7 +1181,7 @@ Sets a new value, overriding the previous one.
### TestResult {#TestResult}
-`::testing::TestResult`
+`testing::TestResult`
Contains information about the result of a single test.
@@ -1261,20 +1262,20 @@ range, aborts the program.
### TimeInMillis {#TimeInMillis}
-`::testing::TimeInMillis`
+`testing::TimeInMillis`
An integer type representing time in milliseconds.
### Types {#Types}
-`::testing::Types`
+`testing::Types`
Represents a list of types for use in typed tests and type-parameterized tests.
The template argument `T...` can be any number of types, for example:
```
-::testing::Types
+testing::Types
```
See [Typed Tests](../advanced.md#typed-tests) and
@@ -1283,7 +1284,7 @@ information.
### WithParamInterface {#WithParamInterface}
-`::testing::WithParamInterface`
+`testing::WithParamInterface`
The pure interface class that all value-parameterized tests inherit from.
@@ -1309,9 +1310,9 @@ tests.
### InitGoogleTest {#InitGoogleTest}
-`void ::testing::InitGoogleTest(int* argc, char** argv)` \
-`void ::testing::InitGoogleTest(int* argc, wchar_t** argv)` \
-`void ::testing::InitGoogleTest()`
+`void testing::InitGoogleTest(int* argc, char** argv)` \
+`void testing::InitGoogleTest(int* argc, wchar_t** argv)` \
+`void testing::InitGoogleTest()`
Initializes GoogleTest. This must be called before calling
[`RUN_ALL_TESTS()`](#RUN_ALL_TESTS). In particular, it parses the command line
@@ -1328,7 +1329,7 @@ platforms where there is no `argc`/`argv`.
### AddGlobalTestEnvironment {#AddGlobalTestEnvironment}
-`Environment* ::testing::AddGlobalTestEnvironment(Environment* env)`
+`Environment* testing::AddGlobalTestEnvironment(Environment* env)`
Adds a test environment to the test program. Must be called before
[`RUN_ALL_TESTS()`](#RUN_ALL_TESTS) is called. See
@@ -1341,7 +1342,7 @@ See also [`Environment`](#Environment).
```cpp
template
-TestInfo* ::testing::RegisterTest(const char* test_suite_name, const char* test_name,
+TestInfo* testing::RegisterTest(const char* test_suite_name, const char* test_name,
const char* type_param, const char* value_param,
const char* file, int line, Factory factory)
```
@@ -1380,27 +1381,27 @@ an all-caps name.
### AssertionSuccess {#AssertionSuccess}
-`AssertionResult ::testing::AssertionSuccess()`
+`AssertionResult testing::AssertionSuccess()`
Creates a successful assertion result. See
[`AssertionResult`](#AssertionResult).
### AssertionFailure {#AssertionFailure}
-`AssertionResult ::testing::AssertionFailure()`
+`AssertionResult testing::AssertionFailure()`
Creates a failed assertion result. Use the `<<` operator to store a failure
message:
```cpp
-::testing::AssertionFailure() << "My failure message";
+testing::AssertionFailure() << "My failure message";
```
See [`AssertionResult`](#AssertionResult).
### StaticAssertTypeEq {#StaticAssertTypeEq}
-`::testing::StaticAssertTypeEq()`
+`testing::StaticAssertTypeEq()`
Compile-time assertion for type equality. Compiles if and only if `T1` and `T2`
are the same type. The value it returns is irrelevant.
@@ -1409,7 +1410,7 @@ See [Type Assertions](../advanced.md#type-assertions) for more information.
### PrintToString {#PrintToString}
-`std::string ::testing::PrintToString(x)`
+`std::string testing::PrintToString(x)`
Prints any value `x` using GoogleTest's value printer.
@@ -1419,7 +1420,7 @@ for more information.
### PrintToStringParamName {#PrintToStringParamName}
-`std::string ::testing::PrintToStringParamName(TestParamInfo& info)`
+`std::string testing::PrintToStringParamName(TestParamInfo& info)`
A built-in parameterized test name generator which returns the result of
[`PrintToString`](#PrintToString) called on `info.param`. Does not work when the
diff --git a/third-party/googletest-1.13.0/docs/samples.md b/third-party/googletest-1.14.0/docs/samples.md
similarity index 100%
rename from third-party/googletest-1.13.0/docs/samples.md
rename to third-party/googletest-1.14.0/docs/samples.md
diff --git a/third-party/googletest-1.13.0/googlemock/CMakeLists.txt b/third-party/googletest-1.14.0/googlemock/CMakeLists.txt
similarity index 89%
rename from third-party/googletest-1.13.0/googlemock/CMakeLists.txt
rename to third-party/googletest-1.14.0/googlemock/CMakeLists.txt
index 5c1f0dafea..a9aa0723fb 100644
--- a/third-party/googletest-1.13.0/googlemock/CMakeLists.txt
+++ b/third-party/googletest-1.14.0/googlemock/CMakeLists.txt
@@ -36,8 +36,7 @@ endif()
# as ${gmock_SOURCE_DIR} and to the root binary directory as
# ${gmock_BINARY_DIR}.
# Language "C" is required for find_package(Threads).
-cmake_minimum_required(VERSION 3.5)
-cmake_policy(SET CMP0048 NEW)
+cmake_minimum_required(VERSION 3.13)
project(gmock VERSION ${GOOGLETEST_VERSION} LANGUAGES CXX C)
if (COMMAND set_up_hermetic_build)
@@ -101,18 +100,14 @@ else()
target_link_libraries(gmock_main PUBLIC gmock)
set_target_properties(gmock_main PROPERTIES VERSION ${GOOGLETEST_VERSION})
endif()
-# If the CMake version supports it, attach header directory information
-# to the targets for when we are part of a parent build (ie being pulled
-# in via add_subdirectory() rather than being a standalone build).
-if (DEFINED CMAKE_VERSION AND NOT "${CMAKE_VERSION}" VERSION_LESS "2.8.11")
- string(REPLACE ";" "$" dirs "${gmock_build_include_dirs}")
- target_include_directories(gmock SYSTEM INTERFACE
- "$"
- "$/${CMAKE_INSTALL_INCLUDEDIR}>")
- target_include_directories(gmock_main SYSTEM INTERFACE
- "$"
- "$/${CMAKE_INSTALL_INCLUDEDIR}>")
-endif()
+
+string(REPLACE ";" "$" dirs "${gmock_build_include_dirs}")
+target_include_directories(gmock SYSTEM INTERFACE
+ "$"
+ "$/${CMAKE_INSTALL_INCLUDEDIR}>")
+target_include_directories(gmock_main SYSTEM INTERFACE
+ "$"
+ "$/${CMAKE_INSTALL_INCLUDEDIR}>")
########################################################################
#
@@ -136,11 +131,7 @@ if (gmock_build_tests)
enable_testing()
if (MINGW OR CYGWIN)
- if (CMAKE_VERSION VERSION_LESS "2.8.12")
- add_compile_options("-Wa,-mbig-obj")
- else()
- add_definitions("-Wa,-mbig-obj")
- endif()
+ add_compile_options("-Wa,-mbig-obj")
endif()
############################################################
diff --git a/third-party/googletest-1.13.0/googlemock/README.md b/third-party/googletest-1.14.0/googlemock/README.md
similarity index 100%
rename from third-party/googletest-1.13.0/googlemock/README.md
rename to third-party/googletest-1.14.0/googlemock/README.md
diff --git a/third-party/googletest-1.13.0/googlemock/cmake/gmock.pc.in b/third-party/googletest-1.14.0/googlemock/cmake/gmock.pc.in
similarity index 100%
rename from third-party/googletest-1.13.0/googlemock/cmake/gmock.pc.in
rename to third-party/googletest-1.14.0/googlemock/cmake/gmock.pc.in
diff --git a/third-party/googletest-1.13.0/googlemock/cmake/gmock_main.pc.in b/third-party/googletest-1.14.0/googlemock/cmake/gmock_main.pc.in
similarity index 100%
rename from third-party/googletest-1.13.0/googlemock/cmake/gmock_main.pc.in
rename to third-party/googletest-1.14.0/googlemock/cmake/gmock_main.pc.in
diff --git a/third-party/googletest-1.13.0/googlemock/docs/README.md b/third-party/googletest-1.14.0/googlemock/docs/README.md
similarity index 100%
rename from third-party/googletest-1.13.0/googlemock/docs/README.md
rename to third-party/googletest-1.14.0/googlemock/docs/README.md
diff --git a/third-party/googletest-1.13.0/googlemock/include/gmock/gmock-actions.h b/third-party/googletest-1.14.0/googlemock/include/gmock/gmock-actions.h
similarity index 97%
rename from third-party/googletest-1.13.0/googlemock/include/gmock/gmock-actions.h
rename to third-party/googletest-1.14.0/googlemock/include/gmock/gmock-actions.h
index aad07d51cc..bd9ba73ee6 100644
--- a/third-party/googletest-1.13.0/googlemock/include/gmock/gmock-actions.h
+++ b/third-party/googletest-1.14.0/googlemock/include/gmock/gmock-actions.h
@@ -146,10 +146,7 @@
#include "gmock/internal/gmock-port.h"
#include "gmock/internal/gmock-pp.h"
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4100)
namespace testing {
@@ -614,7 +611,7 @@ class DefaultValue {
private:
class ValueProducer {
public:
- virtual ~ValueProducer() {}
+ virtual ~ValueProducer() = default;
virtual T Produce() = 0;
};
@@ -702,8 +699,8 @@ class ActionInterface {
typedef typename internal::Function::Result Result;
typedef typename internal::Function::ArgumentTuple ArgumentTuple;
- ActionInterface() {}
- virtual ~ActionInterface() {}
+ ActionInterface() = default;
+ virtual ~ActionInterface() = default;
// Performs the action. This method is not const, as in general an
// action can have side effects and be stateful. For example, a
@@ -752,7 +749,7 @@ class Action {
// Constructs a null Action. Needed for storing Action objects in
// STL containers.
- Action() {}
+ Action() = default;
// Construct an Action from a specified callable.
// This cannot take std::function directly, because then Action would not be
@@ -1276,7 +1273,7 @@ class AssignAction {
const T2 value_;
};
-#if !GTEST_OS_WINDOWS_MOBILE
+#ifndef GTEST_OS_WINDOWS_MOBILE
// Implements the SetErrnoAndReturn action to simulate return from
// various system calls and libc functions.
@@ -1420,19 +1417,19 @@ struct WithArgsAction {
// providing a call operator because even with a particular set of arguments
// they don't have a fixed return type.
- template >...)>>::value,
- int>::type = 0>
+ template <
+ typename R, typename... Args,
+ typename std::enable_if<
+ std::is_convertible>...)>>::value,
+ int>::type = 0>
operator OnceAction() && { // NOLINT
struct OA {
OnceAction> inner_action;
@@ -1447,19 +1444,19 @@ struct WithArgsAction {
return OA{std::move(inner_action)};
}
- template >...)>>::value,
- int>::type = 0>
+ template <
+ typename R, typename... Args,
+ typename std::enable_if<
+ std::is_convertible>...)>>::value,
+ int>::type = 0>
operator Action() const { // NOLINT
Action> converted(inner_action);
@@ -1929,7 +1926,7 @@ PolymorphicAction> Assign(T1* ptr, T2 val) {
return MakePolymorphicAction(internal::AssignAction(ptr, val));
}
-#if !GTEST_OS_WINDOWS_MOBILE
+#ifndef GTEST_OS_WINDOWS_MOBILE
// Creates an action that sets errno and returns the appropriate error.
template
@@ -2295,8 +2292,6 @@ ::testing::Action MakeAction(std::shared_ptr impl) {
} // namespace testing
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
+GTEST_DISABLE_MSC_WARNINGS_POP_() // 4100
#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
diff --git a/third-party/googletest-1.13.0/googlemock/include/gmock/gmock-cardinalities.h b/third-party/googletest-1.14.0/googlemock/include/gmock/gmock-cardinalities.h
similarity index 98%
rename from third-party/googletest-1.13.0/googlemock/include/gmock/gmock-cardinalities.h
rename to third-party/googletest-1.14.0/googlemock/include/gmock/gmock-cardinalities.h
index b6ab648e50..533e604f32 100644
--- a/third-party/googletest-1.13.0/googlemock/include/gmock/gmock-cardinalities.h
+++ b/third-party/googletest-1.14.0/googlemock/include/gmock/gmock-cardinalities.h
@@ -65,7 +65,7 @@ namespace testing {
// The implementation of a cardinality.
class CardinalityInterface {
public:
- virtual ~CardinalityInterface() {}
+ virtual ~CardinalityInterface() = default;
// Conservative estimate on the lower/upper bound of the number of
// calls allowed.
@@ -92,7 +92,7 @@ class GTEST_API_ Cardinality {
public:
// Constructs a null cardinality. Needed for storing Cardinality
// objects in STL containers.
- Cardinality() {}
+ Cardinality() = default;
// Constructs a Cardinality from its implementation.
explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {}
diff --git a/third-party/googletest-1.13.0/googlemock/include/gmock/gmock-function-mocker.h b/third-party/googletest-1.14.0/googlemock/include/gmock/gmock-function-mocker.h
similarity index 99%
rename from third-party/googletest-1.13.0/googlemock/include/gmock/gmock-function-mocker.h
rename to third-party/googletest-1.14.0/googlemock/include/gmock/gmock-function-mocker.h
index 73065493b3..1a1f126e49 100644
--- a/third-party/googletest-1.13.0/googlemock/include/gmock/gmock-function-mocker.h
+++ b/third-party/googletest-1.14.0/googlemock/include/gmock/gmock-function-mocker.h
@@ -180,8 +180,9 @@ using internal::FunctionMocker;
_Signature)>::Result \
GMOCK_INTERNAL_EXPAND(_CallType) \
_MethodName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N)) \
- GMOCK_PP_IF(_Constness, const, ) _RefSpec _NoexceptSpec \
- GMOCK_PP_IF(_Override, override, ) GMOCK_PP_IF(_Final, final, ) { \
+ GMOCK_PP_IF(_Constness, const, ) \
+ _RefSpec _NoexceptSpec GMOCK_PP_IF(_Override, override, ) \
+ GMOCK_PP_IF(_Final, final, ) { \
GMOCK_MOCKER_(_N, _Constness, _MethodName) \
.SetOwnerAndName(this, #_MethodName); \
return GMOCK_MOCKER_(_N, _Constness, _MethodName) \
diff --git a/third-party/googletest-1.13.0/googlemock/include/gmock/gmock-matchers.h b/third-party/googletest-1.14.0/googlemock/include/gmock/gmock-matchers.h
similarity index 99%
rename from third-party/googletest-1.13.0/googlemock/include/gmock/gmock-matchers.h
rename to third-party/googletest-1.14.0/googlemock/include/gmock/gmock-matchers.h
index 9e634f7f1c..0f67713776 100644
--- a/third-party/googletest-1.13.0/googlemock/include/gmock/gmock-matchers.h
+++ b/third-party/googletest-1.14.0/googlemock/include/gmock/gmock-matchers.h
@@ -257,6 +257,8 @@
#include
#include
+#include
+#include
#include
#include
#include
@@ -562,7 +564,7 @@ namespace internal {
// If the explanation is not empty, prints it to the ostream.
inline void PrintIfNotEmpty(const std::string& explanation,
::std::ostream* os) {
- if (explanation != "" && os != nullptr) {
+ if (!explanation.empty() && os != nullptr) {
*os << ", " << explanation;
}
}
@@ -1199,27 +1201,27 @@ class PairMatchBase {
};
};
-class Eq2Matcher : public PairMatchBase {
+class Eq2Matcher : public PairMatchBase> {
public:
static const char* Desc() { return "an equal pair"; }
};
-class Ne2Matcher : public PairMatchBase {
+class Ne2Matcher : public PairMatchBase> {
public:
static const char* Desc() { return "an unequal pair"; }
};
-class Lt2Matcher : public PairMatchBase {
+class Lt2Matcher : public PairMatchBase> {
public:
static const char* Desc() { return "a pair where the first < the second"; }
};
-class Gt2Matcher : public PairMatchBase {
+class Gt2Matcher : public PairMatchBase> {
public:
static const char* Desc() { return "a pair where the first > the second"; }
};
-class Le2Matcher : public PairMatchBase {
+class Le2Matcher : public PairMatchBase> {
public:
static const char* Desc() { return "a pair where the first <= the second"; }
};
-class Ge2Matcher : public PairMatchBase {
+class Ge2Matcher : public PairMatchBase> {
public:
static const char* Desc() { return "a pair where the first >= the second"; }
};
@@ -1473,6 +1475,7 @@ class SomeOfArrayMatcher {
operator Matcher() const { // NOLINT
using RawU = typename std::decay::type;
std::vector> matchers;
+ matchers.reserve(matchers_.size());
for (const auto& matcher : matchers_) {
matchers.push_back(MatcherCast(matcher));
}
@@ -2964,7 +2967,7 @@ class KeyMatcherImpl : public MatcherInterface {
const bool match = inner_matcher_.MatchAndExplain(
pair_getters::First(key_value, Rank0()), &inner_listener);
const std::string explanation = inner_listener.str();
- if (explanation != "") {
+ if (!explanation.empty()) {
*listener << "whose first field is a value " << explanation;
}
return match;
@@ -3111,12 +3114,12 @@ class PairMatcherImpl : public MatcherInterface {
const std::string& second_explanation,
MatchResultListener* listener) const {
*listener << "whose both fields match";
- if (first_explanation != "") {
+ if (!first_explanation.empty()) {
*listener << ", where the first field is a value " << first_explanation;
}
- if (second_explanation != "") {
+ if (!second_explanation.empty()) {
*listener << ", ";
- if (first_explanation != "") {
+ if (!first_explanation.empty()) {
*listener << "and ";
} else {
*listener << "where ";
@@ -3317,8 +3320,8 @@ class FieldsAreMatcherImpl>
std::vector inner_listener(sizeof...(I));
VariadicExpand(
- {failed_pos == ~size_t{}&& !std::get(matchers_).MatchAndExplain(
- std::get(tuple), &inner_listener[I])
+ {failed_pos == ~size_t{} && !std::get(matchers_).MatchAndExplain(
+ std::get(tuple), &inner_listener[I])
? failed_pos = I
: 0 ...});
if (failed_pos != ~size_t{}) {
@@ -5474,8 +5477,7 @@ PolymorphicMatcher> ThrowsMessage(
inline name##Matcher GMOCK_INTERNAL_WARNING_PUSH() \
GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-function") \
GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-member-function") \
- name \
- GMOCK_INTERNAL_WARNING_POP()() { \
+ name GMOCK_INTERNAL_WARNING_POP()() { \
return {}; \
} \
template \
@@ -5543,7 +5545,8 @@ PolymorphicMatcher> ThrowsMessage(
\
private: \
::std::string FormatDescription(bool negation) const { \
- ::std::string gmock_description = (description); \
+ ::std::string gmock_description; \
+ gmock_description = (description); \
if (!gmock_description.empty()) { \
return gmock_description; \
} \
diff --git a/third-party/googletest-1.13.0/googlemock/include/gmock/gmock-more-actions.h b/third-party/googletest-1.14.0/googlemock/include/gmock/gmock-more-actions.h
similarity index 97%
rename from third-party/googletest-1.13.0/googlemock/include/gmock/gmock-more-actions.h
rename to third-party/googletest-1.14.0/googlemock/include/gmock/gmock-more-actions.h
index 148ac01721..40300766f0 100644
--- a/third-party/googletest-1.13.0/googlemock/include/gmock/gmock-more-actions.h
+++ b/third-party/googletest-1.14.0/googlemock/include/gmock/gmock-more-actions.h
@@ -526,9 +526,10 @@
GMOCK_INTERNAL_LIST_##value_params)){}) \
GMOCK_ACTION_CLASS_(name, value_params)(const GMOCK_ACTION_CLASS_( \
name, value_params) &) noexcept GMOCK_INTERNAL_DEFN_COPY_ \
- ##value_params GMOCK_ACTION_CLASS_(name, value_params)( \
- GMOCK_ACTION_CLASS_(name, value_params) &&) noexcept \
- GMOCK_INTERNAL_DEFN_COPY_##value_params template \
+ ##value_params \
+ GMOCK_ACTION_CLASS_(name, value_params)(GMOCK_ACTION_CLASS_( \
+ name, value_params) &&) noexcept GMOCK_INTERNAL_DEFN_COPY_ \
+ ##value_params template \
operator ::testing::Action() const { \
return GMOCK_PP_IF( \
GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params), \
@@ -582,10 +583,7 @@ namespace testing {
// the macro definition, as the warnings are generated when the macro
// is expanded and macro expansion cannot contain #pragma. Therefore
// we suppress them here.
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4100)
namespace internal {
@@ -602,13 +600,13 @@ template
struct InvokeArgumentAction {
template ::type>
- auto operator()(Args&&... args) const -> decltype(internal::InvokeArgument(
+ auto operator()(Args &&...args) const -> decltype(internal::InvokeArgument(
std::get(std::forward_as_tuple(std::forward(args)...)),
- std::declval()...)) {
- internal::FlatTuple args_tuple(FlatTupleConstructTag{},
- std::forward(args)...);
- return params.Apply([&](const Params&... unpacked_params) {
- auto&& callable = args_tuple.template Get();
+ std::declval()...)) {
+ internal::FlatTuple args_tuple(FlatTupleConstructTag{},
+ std::forward(args)...);
+ return params.Apply([&](const Params &...unpacked_params) {
+ auto &&callable = args_tuple.template Get();
return internal::InvokeArgument(
std::forward(callable), unpacked_params...);
});
@@ -648,14 +646,12 @@ struct InvokeArgumentAction {
// later.
template
internal::InvokeArgumentAction::type...>
-InvokeArgument(Params&&... params) {
+InvokeArgument(Params &&...params) {
return {internal::FlatTuple::type...>(
internal::FlatTupleConstructTag{}, std::forward(params)...)};
}
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
+GTEST_DISABLE_MSC_WARNINGS_POP_() // 4100
} // namespace testing
diff --git a/third-party/googletest-1.13.0/googlemock/include/gmock/gmock-more-matchers.h b/third-party/googletest-1.14.0/googlemock/include/gmock/gmock-more-matchers.h
similarity index 94%
rename from third-party/googletest-1.13.0/googlemock/include/gmock/gmock-more-matchers.h
rename to third-party/googletest-1.14.0/googlemock/include/gmock/gmock-more-matchers.h
index d9a9210738..54ea68be96 100644
--- a/third-party/googletest-1.13.0/googlemock/include/gmock/gmock-more-matchers.h
+++ b/third-party/googletest-1.14.0/googlemock/include/gmock/gmock-more-matchers.h
@@ -49,14 +49,11 @@ namespace testing {
// Silence C4100 (unreferenced formal
// parameter) for MSVC
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#if (_MSC_VER == 1900)
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4100)
+#if defined(_MSC_VER) && (_MSC_VER == 1900)
// and silence C4800 (C4800: 'int *const ': forcing value
// to bool 'true' or 'false') for MSVC 14
-#pragma warning(disable : 4800)
-#endif
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800)
#endif
namespace internal {
@@ -113,9 +110,10 @@ MATCHER(IsFalse, negation ? "is true" : "is false") {
return !static_cast(arg);
}
-#ifdef _MSC_VER
-#pragma warning(pop)
+#if defined(_MSC_VER) && (_MSC_VER == 1900)
+GTEST_DISABLE_MSC_WARNINGS_POP_() // 4800
#endif
+GTEST_DISABLE_MSC_WARNINGS_POP_() // 4100
} // namespace testing
diff --git a/third-party/googletest-1.13.0/googlemock/include/gmock/gmock-nice-strict.h b/third-party/googletest-1.14.0/googlemock/include/gmock/gmock-nice-strict.h
similarity index 99%
rename from third-party/googletest-1.13.0/googlemock/include/gmock/gmock-nice-strict.h
rename to third-party/googletest-1.14.0/googlemock/include/gmock/gmock-nice-strict.h
index 4f0eb35db7..056d471417 100644
--- a/third-party/googletest-1.13.0/googlemock/include/gmock/gmock-nice-strict.h
+++ b/third-party/googletest-1.14.0/googlemock/include/gmock/gmock-nice-strict.h
@@ -98,7 +98,7 @@ constexpr bool HasStrictnessModifier() {
// deregistration. This guarantees that MockClass's constructor and destructor
// 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__))
// We need to mark these classes with this declspec to ensure that
// the empty base class optimization is performed.
diff --git a/third-party/googletest-1.13.0/googlemock/include/gmock/gmock-spec-builders.h b/third-party/googletest-1.14.0/googlemock/include/gmock/gmock-spec-builders.h
similarity index 98%
rename from third-party/googletest-1.13.0/googlemock/include/gmock/gmock-spec-builders.h
rename to third-party/googletest-1.14.0/googlemock/include/gmock/gmock-spec-builders.h
index 4e498d8f54..78ca15d05e 100644
--- a/third-party/googletest-1.13.0/googlemock/include/gmock/gmock-spec-builders.h
+++ b/third-party/googletest-1.14.0/googlemock/include/gmock/gmock-spec-builders.h
@@ -204,6 +204,9 @@ class GTEST_API_ UntypedFunctionMockerBase {
using UntypedExpectations = std::vector>;
+ struct UninterestingCallCleanupHandler;
+ struct FailureCleanupHandler;
+
// Returns an Expectation object that references and co-owns exp,
// which must be an expectation on this mock function.
Expectation GetHandleOf(ExpectationBase* exp);
@@ -563,7 +566,7 @@ class ExpectationSet {
typedef Expectation::Set::value_type value_type;
// Constructs an empty set.
- ExpectationSet() {}
+ ExpectationSet() = default;
// This single-argument ctor must not be explicit, in order to support the
// ExpectationSet es = EXPECT_CALL(...);
@@ -1396,6 +1399,41 @@ class Cleanup final {
std::function 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
class FunctionMocker;
@@ -1408,7 +1446,7 @@ class FunctionMocker final : public UntypedFunctionMockerBase {
using ArgumentTuple = std::tuple;
using ArgumentMatcherTuple = std::tuple...>;
- FunctionMocker() {}
+ FunctionMocker() = default;
// There is no generally useful and implementable semantics of
// copying a mock object, so copying a mock is usually a user error.
@@ -1794,8 +1832,15 @@ R FunctionMocker::InvokeWith(ArgumentTuple&& args)
//
// 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.
- 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 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);
}
@@ -1839,22 +1884,14 @@ R FunctionMocker::InvokeWith(ArgumentTuple&& args)
//
// 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.
- const Cleanup handle_failures([&] {
- 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);
- }
- });
+ //
+ // Note that we *don't* use any local callback types (like lambdas) here.
+ // Doing so slows down compilation dramatically because the *constructor* of
+ // std::function is re-instantiated with different template
+ // parameters each time.
+ const FailureCleanupHandler handle_failures = {
+ ss, why, loc, untyped_expectation, found, is_excessive
+ };
return PerformActionAndPrintResult(untyped_action, std::move(args), ss.str(),
ss);
diff --git a/third-party/googletest-1.13.0/googlemock/include/gmock/gmock.h b/third-party/googletest-1.14.0/googlemock/include/gmock/gmock.h
similarity index 100%
rename from third-party/googletest-1.13.0/googlemock/include/gmock/gmock.h
rename to third-party/googletest-1.14.0/googlemock/include/gmock/gmock.h
diff --git a/third-party/googletest-1.13.0/googlemock/include/gmock/internal/custom/README.md b/third-party/googletest-1.14.0/googlemock/include/gmock/internal/custom/README.md
similarity index 100%
rename from third-party/googletest-1.13.0/googlemock/include/gmock/internal/custom/README.md
rename to third-party/googletest-1.14.0/googlemock/include/gmock/internal/custom/README.md
diff --git a/third-party/googletest-1.13.0/googlemock/include/gmock/internal/custom/gmock-generated-actions.h b/third-party/googletest-1.14.0/googlemock/include/gmock/internal/custom/gmock-generated-actions.h
similarity index 100%
rename from third-party/googletest-1.13.0/googlemock/include/gmock/internal/custom/gmock-generated-actions.h
rename to third-party/googletest-1.14.0/googlemock/include/gmock/internal/custom/gmock-generated-actions.h
diff --git a/third-party/googletest-1.13.0/googlemock/include/gmock/internal/custom/gmock-matchers.h b/third-party/googletest-1.14.0/googlemock/include/gmock/internal/custom/gmock-matchers.h
similarity index 100%
rename from third-party/googletest-1.13.0/googlemock/include/gmock/internal/custom/gmock-matchers.h
rename to third-party/googletest-1.14.0/googlemock/include/gmock/internal/custom/gmock-matchers.h
diff --git a/third-party/googletest-1.13.0/googlemock/include/gmock/internal/custom/gmock-port.h b/third-party/googletest-1.14.0/googlemock/include/gmock/internal/custom/gmock-port.h
similarity index 100%
rename from third-party/googletest-1.13.0/googlemock/include/gmock/internal/custom/gmock-port.h
rename to third-party/googletest-1.14.0/googlemock/include/gmock/internal/custom/gmock-port.h
diff --git a/third-party/googletest-1.13.0/googlemock/include/gmock/internal/gmock-internal-utils.h b/third-party/googletest-1.14.0/googlemock/include/gmock/internal/gmock-internal-utils.h
similarity index 98%
rename from third-party/googletest-1.13.0/googlemock/include/gmock/internal/gmock-internal-utils.h
rename to third-party/googletest-1.14.0/googlemock/include/gmock/internal/gmock-internal-utils.h
index 36ab8e26a8..ead6d7c805 100644
--- a/third-party/googletest-1.13.0/googlemock/include/gmock/internal/gmock-internal-utils.h
+++ b/third-party/googletest-1.14.0/googlemock/include/gmock/internal/gmock-internal-utils.h
@@ -58,11 +58,7 @@ namespace internal {
// Silence MSVC C4100 (unreferenced formal parameter) and
// C4805('==': unsafe mix of type 'const int' and type 'const bool')
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#pragma warning(disable : 4805)
-#endif
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4100 4805)
// Joins a vector of strings as if they are fields of a tuple; returns
// the joined string.
@@ -228,7 +224,7 @@ class FailureReporterInterface {
// The type of a failure (either non-fatal or fatal).
enum FailureType { kNonfatal, kFatal };
- virtual ~FailureReporterInterface() {}
+ virtual ~FailureReporterInterface() = default;
// Reports a failure that occurred at the given source file location.
virtual void ReportFailure(FailureType type, const char* file, int line,
@@ -315,7 +311,8 @@ GTEST_API_ WithoutMatchers GetWithoutMatchers();
// crashes).
template
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__)
__builtin_unreachable();
#elif defined(_MSC_VER)
@@ -468,8 +465,10 @@ struct Function {
using MakeResultIgnoredValue = IgnoredValue(Args...);
};
+#ifdef GTEST_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
template
constexpr size_t Function::ArgumentCount;
+#endif
// Workaround for MSVC error C2039: 'type': is not a member of 'std'
// when std::tuple_element is used.
@@ -480,9 +479,7 @@ using TupleElement = typename std::tuple_element::type;
bool Base64Unescape(const std::string& encoded, std::string* decoded);
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
+GTEST_DISABLE_MSC_WARNINGS_POP_() // 4100 4805
} // namespace internal
} // namespace testing
diff --git a/third-party/googletest-1.13.0/googlemock/include/gmock/internal/gmock-port.h b/third-party/googletest-1.14.0/googlemock/include/gmock/internal/gmock-port.h
similarity index 99%
rename from third-party/googletest-1.13.0/googlemock/include/gmock/internal/gmock-port.h
rename to third-party/googletest-1.14.0/googlemock/include/gmock/internal/gmock-port.h
index bc18a25f34..55ddfb6c6a 100644
--- a/third-party/googletest-1.13.0/googlemock/include/gmock/internal/gmock-port.h
+++ b/third-party/googletest-1.14.0/googlemock/include/gmock/internal/gmock-port.h
@@ -56,7 +56,7 @@
#include "gmock/internal/custom/gmock-port.h"
#include "gtest/internal/gtest-port.h"
-#if GTEST_HAS_ABSL
+#ifdef GTEST_HAS_ABSL
#include "absl/flags/declare.h"
#include "absl/flags/flag.h"
#endif
@@ -73,7 +73,7 @@
#define GMOCK_FLAG(name) FLAGS_gmock_##name
// Pick a command line flags implementation.
-#if GTEST_HAS_ABSL
+#ifdef GTEST_HAS_ABSL
// Macros for defining flags.
#define GMOCK_DEFINE_bool_(name, default_val, doc) \
diff --git a/third-party/googletest-1.13.0/googlemock/include/gmock/internal/gmock-pp.h b/third-party/googletest-1.14.0/googlemock/include/gmock/internal/gmock-pp.h
similarity index 100%
rename from third-party/googletest-1.13.0/googlemock/include/gmock/internal/gmock-pp.h
rename to third-party/googletest-1.14.0/googlemock/include/gmock/internal/gmock-pp.h
diff --git a/third-party/googletest-1.13.0/googlemock/src/gmock-all.cc b/third-party/googletest-1.14.0/googlemock/src/gmock-all.cc
similarity index 100%
rename from third-party/googletest-1.13.0/googlemock/src/gmock-all.cc
rename to third-party/googletest-1.14.0/googlemock/src/gmock-all.cc
diff --git a/third-party/googletest-1.13.0/googlemock/src/gmock-cardinalities.cc b/third-party/googletest-1.14.0/googlemock/src/gmock-cardinalities.cc
similarity index 100%
rename from third-party/googletest-1.13.0/googlemock/src/gmock-cardinalities.cc
rename to third-party/googletest-1.14.0/googlemock/src/gmock-cardinalities.cc
diff --git a/third-party/googletest-1.13.0/googlemock/src/gmock-internal-utils.cc b/third-party/googletest-1.14.0/googlemock/src/gmock-internal-utils.cc
similarity index 97%
rename from third-party/googletest-1.13.0/googlemock/src/gmock-internal-utils.cc
rename to third-party/googletest-1.14.0/googlemock/src/gmock-internal-utils.cc
index 7bfff02a33..5c2ce0d57e 100644
--- a/third-party/googletest-1.13.0/googlemock/src/gmock-internal-utils.cc
+++ b/third-party/googletest-1.14.0/googlemock/src/gmock-internal-utils.cc
@@ -41,6 +41,7 @@
#include
#include
#include
+#include
#include // NOLINT
#include
#include
@@ -87,7 +88,7 @@ GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name) {
(!IsDigit(prev_char) && IsDigit(*p));
if (IsAlNum(*p)) {
- if (starts_new_word && result != "") result += ' ';
+ if (starts_new_word && !result.empty()) result += ' ';
result += ToLower(*p);
}
}
@@ -198,6 +199,10 @@ GTEST_API_ void IllegalDoDefault(const char* file, int line) {
"the variable in various places.");
}
+constexpr char UndoWebSafeEncoding(char c) {
+ return c == '-' ? '+' : c == '_' ? '/' : c;
+}
+
constexpr char UnBase64Impl(char c, const char* const base64, char carry) {
return *base64 == 0 ? static_cast(65)
: *base64 == c
@@ -208,7 +213,8 @@ constexpr char UnBase64Impl(char c, const char* const base64, char carry) {
template
constexpr std::array UnBase64Impl(IndexSequence,
const char* const base64) {
- return {{UnBase64Impl(static_cast(I), base64, 0)...}};
+ return {
+ {UnBase64Impl(UndoWebSafeEncoding(static_cast(I)), base64, 0)...}};
}
constexpr std::array UnBase64(const char* const base64) {
diff --git a/third-party/googletest-1.13.0/googlemock/src/gmock-matchers.cc b/third-party/googletest-1.14.0/googlemock/src/gmock-matchers.cc
similarity index 99%
rename from third-party/googletest-1.13.0/googlemock/src/gmock-matchers.cc
rename to third-party/googletest-1.14.0/googlemock/src/gmock-matchers.cc
index 5810b6aa39..07bba4f010 100644
--- a/third-party/googletest-1.13.0/googlemock/src/gmock-matchers.cc
+++ b/third-party/googletest-1.14.0/googlemock/src/gmock-matchers.cc
@@ -53,7 +53,7 @@ GTEST_API_ std::string FormatMatcherDescription(
bool negation, const char* matcher_name,
const std::vector& param_names, const Strings& param_values) {
std::string result = ConvertIdentifierNameToWords(matcher_name);
- if (param_values.size() >= 1) {
+ if (!param_values.empty()) {
result += " " + JoinAsKeyValueTuple(param_names, param_values);
}
return negation ? "not (" + result + ")" : result;
diff --git a/third-party/googletest-1.13.0/googlemock/src/gmock-spec-builders.cc b/third-party/googletest-1.14.0/googlemock/src/gmock-spec-builders.cc
similarity index 97%
rename from third-party/googletest-1.13.0/googlemock/src/gmock-spec-builders.cc
rename to third-party/googletest-1.14.0/googlemock/src/gmock-spec-builders.cc
index ea821f855a..de89471635 100644
--- a/third-party/googletest-1.13.0/googlemock/src/gmock-spec-builders.cc
+++ b/third-party/googletest-1.14.0/googlemock/src/gmock-spec-builders.cc
@@ -40,6 +40,7 @@
#include