diff --git a/VERSION.txt b/VERSION.txt index 3a651c03a..a5589f37e 100644 --- a/VERSION.txt +++ b/VERSION.txt @@ -1 +1 @@ -1.20261013.0 +1.20261014.0 diff --git a/extern/README.md b/extern/README.md index 196bf26f7..fb1c5e82e 100644 --- a/extern/README.md +++ b/extern/README.md @@ -1,5 +1,5 @@ [libOpenCOR](https://opencor.ws/libopencor/index.html) relies on the following external projects: -- [GoogleTest](https://github.com/google/googletest) [1.17.0](https://github.com/google/googletest/releases/tag/v1.17.0) +- [GoogleTest](https://github.com/google/googletest) [1.18.0](https://github.com/google/googletest/releases/tag/v1.18.0) - [modp_b64](https://chromium.googlesource.com/chromium/src/third_party/modp_b64/) at commit [5068510](https://chromium.googlesource.com/chromium/src/third_party/modp_b64/+/50685101d51ef9aabbd60c94f52d9e026d39c509) -- [nanobind](https://github.com/wjakob/nanobind) [2.13.0](https://github.com/wjakob/nanobind/releases/tag/v2.13.0) +- [nanobind](https://github.com/wjakob/nanobind) [3.1.0](https://github.com/wjakob/nanobind/releases/tag/v3.1.0) diff --git a/extern/googletest/BUILD.bazel b/extern/googletest/BUILD.bazel index 53501454c..03392c6b4 100644 --- a/extern/googletest/BUILD.bazel +++ b/extern/googletest/BUILD.bazel @@ -30,6 +30,8 @@ # # Bazel Build for Google C++ Testing Framework(Google Test) +load("@rules_cc//cc:defs.bzl", "cc_library", "cc_test") + package(default_visibility = ["//visibility:public"]) licenses(["notice"]) @@ -151,10 +153,7 @@ cc_library( "@abseil-cpp//absl/flags:reflection", "@abseil-cpp//absl/flags:usage", "@abseil-cpp//absl/strings", - "@abseil-cpp//absl/types:any", - "@abseil-cpp//absl/types:optional", - "@abseil-cpp//absl/types:variant", - "@re2//:re2", + "@re2", ], "//conditions:default": [], }) + select({ @@ -164,7 +163,6 @@ cc_library( # Otherwise, builds targeting Fuchsia would fail to compile. ":fuchsia": [ "@fuchsia_sdk//pkg/fdio", - "@fuchsia_sdk//pkg/syslog", "@fuchsia_sdk//pkg/zx", ], "//conditions:default": [], @@ -174,8 +172,8 @@ cc_library( # `gtest`, but testonly. See guidance on `gtest` for when to use this. alias( name = "gtest_for_library", - actual = ":gtest", testonly = True, + actual = ":gtest", ) # Implements main() for tests using gtest. Prefer to depend on `gtest` as well @@ -189,6 +187,7 @@ cc_library( "//conditions:default": [], }), deps = [":gtest"], + alwayslink = True, ) # The following rules build samples of how to use gTest. diff --git a/extern/googletest/CMakeLists.txt b/extern/googletest/CMakeLists.txt index 0567ae7da..793c8d3cd 100644 --- a/extern/googletest/CMakeLists.txt +++ b/extern/googletest/CMakeLists.txt @@ -4,7 +4,7 @@ cmake_minimum_required(VERSION 3.16) project(googletest-distribution) -set(GOOGLETEST_VERSION 1.17.0) +set(GOOGLETEST_VERSION 1.18.0) if(NOT CYGWIN AND NOT MSYS AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL QNX) set(CMAKE_CXX_EXTENSIONS OFF) diff --git a/extern/googletest/MODULE.bazel b/extern/googletest/MODULE.bazel index 5cb0b156f..badf0de66 100644 --- a/extern/googletest/MODULE.bazel +++ b/extern/googletest/MODULE.bazel @@ -32,7 +32,7 @@ module( name = "googletest", - version = "1.17.0", + version = "1.18.0", compatibility_level = 1, ) @@ -41,20 +41,24 @@ module( bazel_dep( name = "abseil-cpp", - version = "20250127.1", + version = "20260526.0", ) bazel_dep( name = "platforms", - version = "0.0.11", + version = "1.1.0", ) bazel_dep( name = "re2", - version = "2024-07-02.bcr.1", + version = "2025-11-05.bcr.1", +) +bazel_dep( + name = "rules_cc", + version = "0.2.22", ) bazel_dep( name = "rules_python", - version = "1.3.0", + version = "2.2.0", dev_dependency = True, ) @@ -67,7 +71,7 @@ python = use_extension( python.toolchain( ignore_root_user_error = True, is_default = True, - python_version = "3.12", + python_version = "3.13", ) # See fake_fuchsia_sdk.bzl for instructions on how to override this with a real SDK, if needed. diff --git a/extern/googletest/README.md b/extern/googletest/README.md index 598cf3124..b4e9b434f 100644 --- a/extern/googletest/README.md +++ b/extern/googletest/README.md @@ -8,12 +8,13 @@ Our documentation is now live on GitHub Pages at https://google.github.io/googletest/. We recommend browsing the documentation on GitHub Pages rather than directly in the repository. -#### Release 1.17.0 +#### Release 1.18.0 -[Release 1.17.0](https://github.com/google/googletest/releases/tag/v1.17.0) is +[Release 1.18.0](https://github.com/google/googletest/releases/tag/v1.18.0) is now available. -The 1.17.x branch [requires at least C++17]((https://opensource.google/documentation/policies/cplusplus-support#c_language_standard). +The 1.18.x branch +[requires at least C++17](https://opensource.google/documentation/policies/cplusplus-support#c_language_standard). #### Continuous Integration @@ -43,35 +44,35 @@ More information about building GoogleTest can be found at * xUnit test framework: \ Googletest is based on the [xUnit](https://en.wikipedia.org/wiki/XUnit) - testing framework, a popular architecture for unit testing + testing framework, a popular architecture for unit testing. * Test discovery: \ Googletest automatically discovers and runs your tests, eliminating the need - to manually register your tests + to manually register your tests. * Rich set of assertions: \ Googletest provides a variety of assertions, such as equality, inequality, - exceptions, and more, making it easy to test your code + exceptions, and more, making it easy to test your code. * User-defined assertions: \ You can define your own assertions with Googletest, making it simple to - write tests that are specific to your code + write tests that are specific to your code. * Death tests: \ Googletest supports death tests, which verify that your code exits in a - certain way, making it useful for testing error-handling code + certain way, making it useful for testing error-handling code. * Fatal and non-fatal failures: \ You can specify whether a test failure should be treated as fatal or non-fatal with Googletest, allowing tests to continue running even if a - failure occurs + failure occurs. * Value-parameterized tests: \ Googletest supports value-parameterized tests, which run multiple times with different input values, making it useful for testing functions that take - different inputs + different inputs. * Type-parameterized tests: \ Googletest also supports type-parameterized tests, which run with different data types, making it useful for testing functions that work with different - data types + data types. * Various options for running tests: \ Googletest provides many options for running tests including running individual tests, running tests in a specific order and running tests in - parallel + parallel. ## Supported Platforms diff --git a/extern/googletest/WORKSPACE b/extern/googletest/WORKSPACE index 0ae5dee92..b6635f6cd 100644 --- a/extern/googletest/WORKSPACE +++ b/extern/googletest/WORKSPACE @@ -31,31 +31,36 @@ workspace(name = "googletest") load("//:googletest_deps.bzl", "googletest_deps") + googletest_deps() load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive") http_archive( name = "rules_python", - sha256 = "2cc26bbd53854ceb76dd42a834b1002cd4ba7f8df35440cf03482e045affc244", - strip_prefix = "rules_python-1.3.0", - url = "https://github.com/bazelbuild/rules_python/releases/download/1.3.0/rules_python-1.3.0.tar.gz", + sha256 = "e11d2e1efce1589e5bdfa93986712c74fc7467a0f093143d489d2ef5ebb1ed2a", + strip_prefix = "rules_python-2.2.0", + url = "https://github.com/bazelbuild/rules_python/releases/download/2.2.0/rules_python-2.2.0.tar.gz", ) + # https://github.com/bazelbuild/rules_python/releases/tag/1.1.0 load("@rules_python//python:repositories.bzl", "py_repositories") -py_repositories() -http_archive( - name = "bazel_skylib", - sha256 = "cd55a062e763b9349921f0f5db8c3933288dc8ba4f76dd9416aac68acee3cb94", - urls = ["https://github.com/bazelbuild/bazel-skylib/releases/download/1.5.0/bazel-skylib-1.5.0.tar.gz"], -) +py_repositories() http_archive( name = "platforms", + sha256 = "dbad4a23abcca6171e47b79edc53bd6a41067a3b75f9e8b104656b459ff25046", urls = [ - "https://mirror.bazel.build/github.com/bazelbuild/platforms/releases/download/0.0.11/platforms-0.0.11.tar.gz", - "https://github.com/bazelbuild/platforms/releases/download/0.0.11/platforms-0.0.11.tar.gz", + "https://mirror.bazel.build/github.com/bazelbuild/platforms/releases/download/1.1.0/platforms-1.1.0.tar.gz", + "https://github.com/bazelbuild/platforms/releases/download/1.1.0/platforms-1.1.0.tar.gz", ], - sha256 = "29742e87275809b5e598dc2f04d86960cc7a55b3067d97221c9abbc9926bff0f", ) + +load("@bazel_features//:deps.bzl", "bazel_features_deps") + +bazel_features_deps() + +load("@rules_cc//cc:extensions.bzl", "compatibility_proxy_repo") + +compatibility_proxy_repo() diff --git a/extern/googletest/ci/linux-presubmit.sh b/extern/googletest/ci/linux-presubmit.sh index 6491e7984..26d2e7a13 100644 --- a/extern/googletest/ci/linux-presubmit.sh +++ b/extern/googletest/ci/linux-presubmit.sh @@ -31,15 +31,22 @@ set -euox pipefail -readonly LINUX_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest:20241218" -readonly LINUX_GCC_FLOOR_CONTAINER="gcr.io/google.com/absl-177019/linux_gcc-floor:20250205" +readonly LINUX_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest@sha256:baa99e65a3cc837bab8e5246f1870d25c76d0adf2b1d598ee5a3ec77fd2e19bd" if [[ -z ${GTEST_ROOT:-} ]]; then GTEST_ROOT="$(realpath $(dirname ${0})/..)" fi +# Use Bazel Vendor mode to reduce reliance on external dependencies. +# See https://bazel.build/external/vendor and the Dockerfile for +# an explaination of how this works. +if [[ ${KOKORO_GFILE_DIR:-} ]] && [[ -f "${KOKORO_GFILE_DIR}/distdir/googletest_vendor.tar.gz" ]]; then + DOCKER_EXTRA_ARGS="--mount type=bind,source=${KOKORO_GFILE_DIR}/distdir,target=/distdir,readonly --env=BAZEL_VENDOR_ARCHIVE=/distdir/googletest_vendor.tar.gz ${DOCKER_EXTRA_ARGS:-}" + BAZEL_EXTRA_ARGS="--vendor_dir=/googletest_vendor ${BAZEL_EXTRA_ARGS:-}" +fi + if [[ -z ${STD:-} ]]; then - STD="c++17 c++20" + STD="c++17 c++20 c++23" fi # Test CMake + GCC @@ -71,7 +78,7 @@ for cmake_off_on in OFF ON; do --tmpfs="/build:exec" \ --workdir="/build" \ --rm \ - --env="CC=/opt/llvm/clang/bin/clang" \ + --env="CC=/opt/llvm/bin/clang" \ --env=CXXFLAGS="-Werror -Wdeprecated --gcc-toolchain=/usr/local" \ ${LINUX_LATEST_CONTAINER} \ /bin/bash -c " @@ -91,20 +98,27 @@ time docker run \ --volume="${GTEST_ROOT}:/src:ro" \ --workdir="/src" \ --rm \ - --env="CC=/usr/local/bin/gcc" \ + --env="CC=/opt/gcc-10/bin/gcc" \ --env="BAZEL_CXXOPTS=-std=c++17" \ - ${LINUX_GCC_FLOOR_CONTAINER} \ + --env="BAZEL_LINKOPTS=-L/opt/gcc-10/lib64:-Wl,-rpath=/opt/gcc-10/lib64" \ + --env="USE_BAZEL_VERSION=8.5.1" \ + ${DOCKER_EXTRA_ARGS:-} \ + ${LINUX_LATEST_CONTAINER} \ + /bin/bash --login -c " /usr/local/bin/bazel test ... \ - --copt="-Wall" \ - --copt="-Werror" \ - --copt="-Wuninitialized" \ - --copt="-Wundef" \ - --copt="-Wno-error=pragmas" \ + --copt=\"-Wall\" \ + --copt=\"-Werror\" \ + --copt=\"-Wuninitialized\" \ + --copt=\"-Wundef\" \ + --copt=\"-Wno-error=pragmas\" \ --enable_bzlmod=false \ + --enable_workspace=true \ --features=external_include_paths \ --keep_going \ + --per_file_copt=\"external/.*@-w\" \ --show_timestamps \ - --test_output=errors + --test_output=errors \ + ${BAZEL_EXTRA_ARGS:-}" # Test GCC for std in ${STD}; do @@ -115,18 +129,23 @@ for std in ${STD}; do --rm \ --env="CC=/usr/local/bin/gcc" \ --env="BAZEL_CXXOPTS=-std=${std}" \ + --env="USE_BAZEL_VERSION=9.1.0" \ + ${DOCKER_EXTRA_ARGS:-} \ ${LINUX_LATEST_CONTAINER} \ - /usr/local/bin/bazel test ... \ - --copt="-Wall" \ - --copt="-Werror" \ - --copt="-Wuninitialized" \ - --copt="-Wundef" \ - --define="absl=${absl}" \ - --enable_bzlmod=true \ - --features=external_include_paths \ - --keep_going \ - --show_timestamps \ - --test_output=errors + /bin/bash --login -c " + /usr/local/bin/bazel test ... \ + --copt=\"-Wall\" \ + --copt=\"-Werror\" \ + --copt=\"-Wuninitialized\" \ + --copt=\"-Wundef\" \ + --define=\"absl=${absl}\" \ + --enable_bzlmod=true \ + --features=external_include_paths \ + --keep_going \ + --per_file_copt=\"external/.*@-w\" \ + --show_timestamps \ + --test_output=errors \ + ${BAZEL_EXTRA_ARGS:-}" done done @@ -137,21 +156,26 @@ for std in ${STD}; do --volume="${GTEST_ROOT}:/src:ro" \ --workdir="/src" \ --rm \ - --env="CC=/opt/llvm/clang/bin/clang" \ + --env="CC=/opt/llvm/bin/clang" \ --env="BAZEL_CXXOPTS=-std=${std}" \ + --env="USE_BAZEL_VERSION=9.1.0" \ + ${DOCKER_EXTRA_ARGS:-} \ ${LINUX_LATEST_CONTAINER} \ - /usr/local/bin/bazel test ... \ - --copt="--gcc-toolchain=/usr/local" \ - --copt="-Wall" \ - --copt="-Werror" \ - --copt="-Wuninitialized" \ - --copt="-Wundef" \ - --define="absl=${absl}" \ - --enable_bzlmod=true \ - --features=external_include_paths \ - --keep_going \ - --linkopt="--gcc-toolchain=/usr/local" \ - --show_timestamps \ - --test_output=errors + /bin/bash --login -c " + /usr/local/bin/bazel test ... \ + --copt=\"--gcc-toolchain=/usr/local\" \ + --copt=\"-Wall\" \ + --copt=\"-Werror\" \ + --copt=\"-Wuninitialized\" \ + --copt=\"-Wundef\" \ + --define=\"absl=${absl}\" \ + --enable_bzlmod=true \ + --features=external_include_paths \ + --keep_going \ + --linkopt=\"--gcc-toolchain=/usr/local\" \ + --per_file_copt=\"external/.*@-w\" \ + --show_timestamps \ + --test_output=errors \ + ${BAZEL_EXTRA_ARGS:-}" done done diff --git a/extern/googletest/ci/macos-presubmit.sh b/extern/googletest/ci/macos-presubmit.sh index 5370ed60d..46b7a4cbd 100644 --- a/extern/googletest/ci/macos-presubmit.sh +++ b/extern/googletest/ci/macos-presubmit.sh @@ -31,8 +31,13 @@ set -euox pipefail -# Use Xcode 16.0 -sudo xcode-select -s /Applications/Xcode_16.0.app/Contents/Developer +# Use Xcode 26.2 +sudo xcode-select -s /Applications/Xcode_26.2.app/Contents/Developer + +brew install cmake + +export CMAKE_BUILD_PARALLEL_LEVEL=$(sysctl -n hw.ncpu) +export CTEST_PARALLEL_LEVEL=$(sysctl -n hw.ncpu) if [[ -z ${GTEST_ROOT:-} ]]; then GTEST_ROOT="$(realpath $(dirname ${0})/..)" @@ -56,7 +61,7 @@ done # Test the Bazel build # If we are running on Kokoro, check for a versioned Bazel binary. -KOKORO_GFILE_BAZEL_BIN="bazel-8.0.0-darwin-x86_64" +KOKORO_GFILE_BAZEL_BIN="bazel-9.1.0-darwin-x86_64" if [[ ${KOKORO_GFILE_DIR:-} ]] && [[ -f ${KOKORO_GFILE_DIR}/${KOKORO_GFILE_BAZEL_BIN} ]]; then BAZEL_BIN="${KOKORO_GFILE_DIR}/${KOKORO_GFILE_BAZEL_BIN}" chmod +x ${BAZEL_BIN} @@ -64,6 +69,12 @@ else BAZEL_BIN="bazel" fi +# Use Bazel Vendor mode to reduce reliance on external dependencies. +if [[ ${KOKORO_GFILE_DIR:-} ]] && [[ -f "${KOKORO_GFILE_DIR}/distdir/googletest_vendor.tar.gz" ]]; then + tar -xf "${KOKORO_GFILE_DIR}/distdir/googletest_vendor.tar.gz" -C "${HOME}/" + BAZEL_EXTRA_ARGS="--vendor_dir=${HOME}/googletest_vendor ${BAZEL_EXTRA_ARGS:-}" +fi + cd ${GTEST_ROOT} for absl in 0 1; do ${BAZEL_BIN} test ... \ @@ -75,6 +86,8 @@ for absl in 0 1; do --enable_bzlmod=true \ --features=external_include_paths \ --keep_going \ + --per_file_copt="external/.*@-w" \ --show_timestamps \ - --test_output=errors + --test_output=errors \ + ${BAZEL_EXTRA_ARGS:-} done diff --git a/extern/googletest/ci/windows-presubmit.bat b/extern/googletest/ci/windows-presubmit.bat index e2664c538..cce732b30 100644 --- a/extern/googletest/ci/windows-presubmit.bat +++ b/extern/googletest/ci/windows-presubmit.bat @@ -1,6 +1,6 @@ SETLOCAL ENABLEDELAYEDEXPANSION -SET BAZEL_EXE=%KOKORO_GFILE_DIR%\bazel-8.0.0-windows-x86_64.exe +SET BAZEL_EXE=%KOKORO_GFILE_DIR%\bazel-9.1.0-windows-x86_64.exe SET PATH=C:\Python34;%PATH% SET BAZEL_PYTHON=C:\python34\python.exe @@ -19,6 +19,7 @@ IF %errorlevel% neq 0 EXIT /B 1 SET CMAKE_BUILD_PATH=cmake_msvc2022 MKDIR %CMAKE_BUILD_PATH% CD %CMAKE_BUILD_PATH% +SET CXXFLAGS="/WX" %CMAKE_BIN% %GTEST_ROOT% ^ -G "Visual Studio 17 2022" ^ @@ -37,6 +38,7 @@ IF %errorlevel% neq 0 EXIT /B 1 %CTEST_BIN% -C Debug --timeout 600 IF %errorlevel% neq 0 EXIT /B 1 +SET "CXXFLAGS=" CD %GTEST_ROOT% RMDIR /S /Q %CMAKE_BUILD_PATH% @@ -48,6 +50,14 @@ RMDIR /S /Q %CMAKE_BUILD_PATH% :: --output_user_root=C:\tmp causes Bazel to use a shorter path. SET BAZEL_VS=C:\Program Files\Microsoft Visual Studio\2022\Community +:: Use Bazel Vendor mode to reduce reliance on external dependencies. +IF EXIST "%KOKORO_GFILE_DIR%\distdir\googletest_vendor.tar.gz" ( + tar --force-local -xf "%KOKORO_GFILE_DIR%\distdir\googletest_vendor.tar.gz" -C c: + SET VENDOR_FLAG=--vendor_dir=c:\googletest_vendor +) ELSE ( + SET VENDOR_FLAG= +) + :: C++17 %BAZEL_EXE% ^ --output_user_root=C:\tmp ^ @@ -57,8 +67,10 @@ SET BAZEL_VS=C:\Program Files\Microsoft Visual Studio\2022\Community --copt=/WX ^ --enable_bzlmod=true ^ --keep_going ^ + --per_file_copt=external/.*@/w ^ --test_output=errors ^ - --test_tag_filters=-no_test_msvc2017 + --test_tag_filters=-no_test_msvc2017 ^ + %VENDOR_FLAG% IF %errorlevel% neq 0 EXIT /B 1 :: C++20 @@ -70,6 +82,8 @@ IF %errorlevel% neq 0 EXIT /B 1 --copt=/WX ^ --enable_bzlmod=true ^ --keep_going ^ + --per_file_copt=external/.*@/w ^ --test_output=errors ^ - --test_tag_filters=-no_test_msvc2017 + --test_tag_filters=-no_test_msvc2017 ^ + %VENDOR_FLAG% IF %errorlevel% neq 0 EXIT /B 1 diff --git a/extern/googletest/docs/_layouts/default.html b/extern/googletest/docs/_layouts/default.html index c7f331b87..f0ae47426 100644 --- a/extern/googletest/docs/_layouts/default.html +++ b/extern/googletest/docs/_layouts/default.html @@ -7,15 +7,15 @@ {% seo %} + + -
diff --git a/extern/googletest/docs/advanced.md b/extern/googletest/docs/advanced.md index 9b1220a1e..d703a7b1c 100644 --- a/extern/googletest/docs/advanced.md +++ b/extern/googletest/docs/advanced.md @@ -349,7 +349,8 @@ void AbslStringify(Sink& sink, EnumWithStringify e) { {: .callout .note} Note: `AbslStringify()` utilizes a generic "sink" buffer to construct its string. For more information about supported operations on `AbslStringify()`'s -sink, see go/abslstringify. +sink, see +[the `AbslStringify()` documentation](https://abseil.io/docs/cpp/guides/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 @@ -403,7 +404,8 @@ EXPECT_TRUE(IsCorrectPointIntVector(point_ints)) ``` For more details regarding `AbslStringify()` and its integration with other -libraries, see go/abslstringify. +libraries, see +[the documentation](https://abseil.io/docs/cpp/guides/abslstringify). ## Regular Expression Syntax @@ -1448,17 +1450,19 @@ are two cases to consider: To test them, we use the following special techniques: * Both static functions and definitions/declarations in an unnamed namespace - are only visible within the same translation unit. To test them, you can - `#include` the entire `.cc` file being tested in your `*_test.cc` file. - (#including `.cc` files is not a good way to reuse code - you should not do - this in production code!) - - However, a better approach is to move the private code into the - `foo::internal` namespace, where `foo` is the namespace your project - normally uses, and put the private declarations in a `*-internal.h` file. - Your production `.cc` files and your tests are allowed to include this - internal header, but your clients are not. This way, you can fully test your - internal implementation without leaking it to your clients. + are only visible within the same translation unit. To test them, move the + private code into the `foo::internal` namespace, where `foo` is the + namespace your project normally uses, and put the private declarations in a + `*-internal.h` file. Your production `.cc` files and your tests are allowed + to include this internal header, but your clients are not. This way, you can + fully test your internal implementation without leaking it to your clients. + +{: .callout .note} +NOTE: It is also technically *possible* to `#include` the entire `.cc` file +being tested in your `*_test.cc` file to test static functions and +definitions/declarations in an unnamed namespace. However, this technique is +**not recommended** by this documentation and it is only presented here for the +sake of completeness. * Private class members are only accessible from within the class or by friends. To access a class' private members, you can declare your test @@ -1471,10 +1475,7 @@ To test them, we use the following special techniques: Another way to test private members is to refactor them into an implementation class, which is then declared in a `*-internal.h` file. Your - clients aren't allowed to include this header but your tests can. Such is - called the - [Pimpl](https://www.gamedev.net/articles/programming/general-and-gameplay-programming/the-c-pimpl-r1794/) - (Private Implementation) idiom. + clients aren't allowed to include this header but your tests can. Or, you can declare an individual test as a friend of your class by adding this line in the class body: @@ -1943,6 +1944,21 @@ test case is linked in. Note that *any* test case linked in makes the program valid for the purpose of this check. In particular, even a disabled test case suffices. +### Enforcing Running At Least One Test Case + +In addition to enforcing that tests are defined in the binary with +`--gtest_fail_if_no_test_linked`, it is also possible to enforce that a test +case was actually executed to ensure that resources are not consumed by tests +that do nothing. + +To catch such optimization opportunities, run the test program with the +`--gtest_fail_if_no_test_selected` flag or set the +`GTEST_FAIL_IF_NO_TEST_SELECTED` environment variable to a value other than `0`. + +A test is considered selected if it begins to run, even if it is later skipped +via `GTEST_SKIP`. Thus, `DISABLED` tests do not count as selected and neither do +tests that are not matched by `--gtest_filter`. + ### Repeating the Tests Once in a while you'll run into a test whose result is hit-or-miss. Perhaps it diff --git a/extern/googletest/docs/gmock_cheat_sheet.md b/extern/googletest/docs/gmock_cheat_sheet.md index ddafaaa22..dd63226c6 100644 --- a/extern/googletest/docs/gmock_cheat_sheet.md +++ b/extern/googletest/docs/gmock_cheat_sheet.md @@ -130,7 +130,7 @@ TEST(BarTest, DoesThis) { ## Setting Default Actions {#OnCall} gMock has a **built-in default action** for any function that returns `void`, -`bool`, a numeric value, or a pointer. In C++11, it will additionally returns +`bool`, a numeric value, or a pointer. In C++11, it additionally returns the default-constructed value, if one exists for the given type. To customize the default action for functions with return type `T`, use @@ -153,7 +153,7 @@ To customize the default action for functions with return type `T`, use EXPECT_NE(buzz1, buzz2); // Resets the default action for return type std::unique_ptr, - // to avoid interfere with other tests. + // to avoid interfering with other tests. DefaultValue>::Clear(); ``` diff --git a/extern/googletest/docs/gmock_cook_book.md b/extern/googletest/docs/gmock_cook_book.md index 9e59b4cf4..cee1da8e2 100644 --- a/extern/googletest/docs/gmock_cook_book.md +++ b/extern/googletest/docs/gmock_cook_book.md @@ -900,15 +900,16 @@ using ::testing::Not; Matchers are function objects, and parametrized matchers can be composed just like any other function. However because their types can be long and rarely -provide meaningful information, it can be easier to express them with C++14 -generic lambdas to avoid specifying types. For example, +provide meaningful information, it can be easier to express them with template +parameters and `auto`. For example, ```cpp using ::testing::Contains; using ::testing::Property; -inline constexpr auto HasFoo = [](const auto& f) { - return Property("foo", &MyClass::foo, Contains(f)); +template +inline constexpr auto HasFoo(const SubMatcher& sub_matcher) { + return Property("foo", &MyClass::foo, Contains(sub_matcher)); }; ... EXPECT_THAT(x, HasFoo("blah")); @@ -3385,30 +3386,6 @@ With this definition, the above assertion will give a better message: Actual: 27 (the remainder is 6) ``` -#### Using EXPECT_ Statements in Matchers - -You can also use `EXPECT_...` statements inside custom matcher definitions. In -many cases, this allows you to write your matcher more concisely while still -providing an informative error message. For example: - -```cpp -MATCHER(IsDivisibleBy7, "") { - const auto remainder = arg % 7; - EXPECT_EQ(remainder, 0); - return true; -} -``` - -If you write a test that includes the line `EXPECT_THAT(27, IsDivisibleBy7());`, -you will get an error something like the following: - -```shell -Expected equality of these values: - remainder - Which is: 6 - 0 -``` - #### `MatchAndExplain` You should let `MatchAndExplain()` print *any additional information* that can @@ -3428,6 +3405,66 @@ the value of `(arg % 7) == 0` can be implicitly converted to a `bool`. In the `arg_type` will be `int`; if it takes an `unsigned long`, `arg_type` will be `unsigned long`; and so on. +#### Anti-pattern: Using EXPECT_ Statements in Matchers + +Using `EXPECT_...` statements inside custom matcher definitions is an +**anti-pattern** and should be avoided. + +While it might appear to write matchers more concisely and generate informative +messages, this pattern has critical issues: + +1. **Negation Breakage (`Not`):** If wrapped in `Not(IsDivisibleBy7())`, + evaluating it still triggers the internal `EXPECT_EQ`, registering a test + failure on the runner even when the overall assertion is expected to + succeed. +2. **Composition / Container Breakage (`AnyOf`, `AllOf`, `Contains`):** When + composed or used inside container matchers, elements that are expected + mismatches will trigger the internal `EXPECT_` and register spurious + failures. +3. **ASSERT_* compilation errors:** `ASSERT_*` macros use `return;` to abort + from a void function. Since matchers return `bool`, using `ASSERT_` inside + them triggers a compilation error. +4. **Purity Violations:** Matchers must be functionally pure (side-effect + free), whereas registering global failures is a major side effect. +5. **Line Number Confusion:** Failure reports point to the matcher's definition + line rather than the calling `EXPECT_THAT` + line. + +##### The Anti-Pattern + +```cpp +// Anti-pattern: Do not do this! +MATCHER(IsDivisibleBy7, "") { + const auto remainder = arg % 7; + EXPECT_EQ(remainder, 0); // Spurious failures if negated/composed! + return true; +} +``` + +##### The Correct Solution + +To write concise matchers that delegate to other matchers and safely propagate +the mismatch explanation, use **`::testing::ExplainMatchResult`** instead, +passing it the sub-matcher, the value to check, and the `result_listener`: + +```cpp +MATCHER(IsDivisibleBy7, "") { + const auto remainder = arg % 7; + return ::testing::ExplainMatchResult(::testing::Eq(0), remainder, + result_listener); +} +``` + +If you write a test that includes the line: + +```cpp +EXPECT_THAT(28, Not(IsDivisibleBy7())); +``` + +it will correctly report the mismatch, properly point to the `EXPECT_THAT` line +number, and support negation (`Not`) and composition (`AllOf`, `AnyOf`, etc.) +without registering spurious failures. + ### Writing New Parameterized Matchers Quickly Sometimes you'll want to define a matcher that has parameters. For that you can @@ -3565,7 +3602,7 @@ general leads to better compiler error messages that pay off in the long run. They also allow overloading matchers based on parameter types (as opposed to just based on the number of parameters). -### Writing New Monomorphic Matchers +### Writing New Monomorphic Matchers {#MonomorphicMatchers} A matcher of type `testing::Matcher` implements the matcher interface for `T` and does two things: it tests whether a value of type `T` matches the matcher, @@ -3590,7 +3627,7 @@ and supports the following operations: bool matched = matcher.MatchAndExplain(value, maybe_os); // where `value` is of type `T` and // `maybe_os` is of type `std::ostream*`, where it can be null if the caller -// is not interested in there textual explanation. +// is not interested in the textual explanation. matcher.DescribeTo(os); matcher.DescribeNegationTo(os); @@ -3665,11 +3702,11 @@ Expected: is divisible by 7 Tip: for convenience, `MatchAndExplain()` can take a `MatchResultListener*` instead of `std::ostream*`. -### Writing New Polymorphic Matchers +### Writing New Polymorphic Matchers {#PolymorphicMatchers} Unlike a monomorphic matcher, which can only be used to match a value of a particular type, a *polymorphic* matcher is one that can be used to match values -of multiple types. For example, `Eq(5)` is a polymorhpic matcher as it can be +of multiple types. For example, `Eq(5)` is a polymorphic matcher as it can be used to match an `int`, a `double`, a `float`, and so on. You should think of a polymorphic matcher as a *matcher factory* as opposed to a `testing::Matcher` - itself is not an actual matcher, but can be diff --git a/extern/googletest/docs/quickstart-bazel.md b/extern/googletest/docs/quickstart-bazel.md index 5750f026f..af6fba84a 100644 --- a/extern/googletest/docs/quickstart-bazel.md +++ b/extern/googletest/docs/quickstart-bazel.md @@ -9,7 +9,7 @@ we recommend this tutorial as a starting point. To complete this tutorial, you'll need: * A compatible operating system (e.g. Linux, macOS, Windows). -* A compatible C++ compiler that supports at least C++14. +* A compatible C++ compiler that supports at least C++17. * [Bazel](https://bazel.build/) 7.0 or higher, the preferred build system used by the GoogleTest team. @@ -48,7 +48,7 @@ with the following content: # Choose the most recent version available at # https://registry.bazel.build/modules/googletest -bazel_dep(name = "googletest", version = "1.15.2") +bazel_dep(name = "googletest", version = "1.18.0") ``` Now you're ready to build C++ code that uses GoogleTest. @@ -99,16 +99,16 @@ 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. +NOTE: In the example below, we assume Clang or GCC and set `--cxxopt=-std=c++17` +to ensure that GoogleTest is compiled as C++17 instead of the compiler's default +setting. For MSVC, the equivalent would be `--cxxopt=/std:c++17`. See +[Supported Platforms](platforms.md) for more details on supported language +versions. Now you can build and run your test: 
-$ bazel test --cxxopt=-std=c++14 --test_output=all //:hello_test
+$ bazel test --cxxopt=-std=c++17 --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/extern/googletest/docs/quickstart-cmake.md b/extern/googletest/docs/quickstart-cmake.md
index 4e422b74f..bcdb1b5cf 100644
--- a/extern/googletest/docs/quickstart-cmake.md
+++ b/extern/googletest/docs/quickstart-cmake.md
@@ -10,7 +10,7 @@ this tutorial as a starting point. If your project uses Bazel, see the
 To complete this tutorial, you'll need:
 
 *   A compatible operating system (e.g. Linux, macOS, Windows).
-*   A compatible C++ compiler that supports at least C++14.
+*   A compatible C++ compiler that supports at least C++17.
 *   [CMake](https://cmake.org/) and a compatible build tool for building the
     project.
     *   Compatible build tools include
@@ -52,8 +52,8 @@ To do this, in your project directory (`my_project`), create a file named
 cmake_minimum_required(VERSION 3.14)
 project(my_project)
 
-# GoogleTest requires at least C++14
-set(CMAKE_CXX_STANDARD 14)
+# GoogleTest requires at least C++17
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 include(FetchContent)
diff --git a/extern/googletest/docs/reference/actions.md b/extern/googletest/docs/reference/actions.md
index 0ebdc1e84..2ca3a9fd0 100644
--- a/extern/googletest/docs/reference/actions.md
+++ b/extern/googletest/docs/reference/actions.md
@@ -48,8 +48,8 @@ functor, or lambda.
 | `InvokeWithoutArgs(object_pointer, &class::method)` | Invoke the method on the object, which takes no arguments. |
 | `InvokeArgument(arg1, arg2, ..., argk)` | Invoke the mock function's `N`-th (0-based) argument, which must be a function or a functor, with the `k` arguments. |
 
-The return value of the invoked function is used as the return value of the
-action.
+The return value of the invoked function (except `InvokeArgument`) is used as
+the return value of the action.
 
 When defining a callable to be used with `Invoke*()`, you can declare any unused
 parameters as `Unused`:
diff --git a/extern/googletest/docs/reference/matchers.md b/extern/googletest/docs/reference/matchers.md
index 8ff9e0bc9..0956c1758 100644
--- a/extern/googletest/docs/reference/matchers.md
+++ b/extern/googletest/docs/reference/matchers.md
@@ -1,5 +1,7 @@
 # Matchers Reference
 
+
+
 A **matcher** matches a *single* argument. You can use it inside `ON_CALL()` or
 `EXPECT_CALL()`, or use it to validate a value directly using two macros:
 
@@ -47,8 +49,9 @@ Matcher                     | Description
 | `IsTrue()`             | `argument` evaluates to `true` in a Boolean context. |
 | `IsNull()`             | `argument` is a `NULL` pointer (raw or smart).      |
 | `NotNull()`            | `argument` is a non-null pointer (raw or smart).    |
-| `Optional(m)`          | `argument` is `optional<>` that contains a value matching `m`. (For testing whether an `optional<>` is set, check for equality with `nullopt`. You may need to use `Eq(nullopt)` if the inner type doesn't have `==`.)|
+| `Optional(m)`          | `argument` is `optional<>` that contains a value matching `m`. (For testing whether an `optional<>` is unset, check for equality with `nullopt`. You may need to use `Eq(nullopt)` if the inner type doesn't have `==`.)|
 | `VariantWith(m)`    | `argument` is `variant<>` that holds the alternative of type T with a value matching `m`. |
+| `AnyWith(m)`        | `argument` is `any<>` that holds a value of type T with a value matching `m`. |
 | `Ref(variable)`        | `argument` is a reference to `variable`.            |
 | `TypedEq(value)` | `argument` has type `type` and is equal to `value`. You may need to use this instead of `Eq(value)` when the mock function is overloaded. |
 
@@ -111,6 +114,33 @@ use the regular expression syntax defined
 [here](../advanced.md#regular-expression-syntax). All of these matchers, except
 `ContainsRegex()` and `MatchesRegex()` work for wide strings as well.
 
+## Exception Matchers
+
+| Matcher                                   | Description                      |
+| :---------------------------------------- | :------------------------------- |
+| `Throws()` | The `argument` is a callable object that, when called, throws an exception of the expected type `E`. |
+| `Throws(m)` | The `argument` is a callable object that, when called, throws an exception of type `E` that satisfies the matcher `m`. |
+| `ThrowsMessage(m)` | The `argument` is a callable object that, when called, throws an exception of type `E` with a message that satisfies the matcher `m`. |
+
+Examples:
+
+```cpp
+auto argument = [] { throw std::runtime_error("error msg"); };
+
+// Checks if the lambda throws a `std::runtime_error`.
+EXPECT_THAT(argument, Throws());
+
+// Checks if the lambda throws a `std::runtime_error` with a specific message
+// that matches "error msg".
+EXPECT_THAT(argument,
+            Throws(Property(&std::runtime_error::what,
+                                                Eq("error msg"))));
+
+// Checks if the lambda throws a `std::runtime_error` with a message that
+// contains "msg".
+EXPECT_THAT(argument, ThrowsMessage(HasSubstr("msg")));
+```
+
 ## Container Matchers
 
 Most STL-style containers support `==`, so you can use `Eq(expected_container)`
@@ -226,6 +256,14 @@ Matcher | Description
 `Le()`  | `x <= y`
 `Lt()`  | `x < y`
 `Ne()`  | `x != y`
+`FloatEq()` | `x` approximately equals `y`
+`DoubleEq()` | `x` approximately equals `y`
+`NanSensitiveFloatEq()` | Same as `FloatEq()`, but treats two NaNs as equal
+`NanSensitiveDoubleEq()` | Same as `DoubleEq()`, but treats two NaNs as equal
+`FloatNear(max_abs_error)` | `x` is within `max_abs_error` of `y`
+`DoubleNear(max_abs_error)` | `x` is within `max_abs_error` of `y`
+`NanSensitiveFloatNear(max_abs_error)` | Same as `FloatNear(max_abs_error)`, but treats two NaNs as near
+`NanSensitiveDoubleNear(max_abs_error)` | Same as `DoubleNear(max_abs_error)`, but treats two NaNs as near
 
 You can use the following selectors to pick a subset of the arguments (or
 reorder them) to participate in the matching:
@@ -269,6 +307,13 @@ which must be a permanent callback.
 
 ## Defining Matchers
 
+{: .callout .note}
+Note: full details about defining new matchers are in the
+[cookbook](../gmock_cook_book.md#NewMatchers). In particular, if `MATCHER`
+macros are not sufficient, you can directly implement
+[monomorphic](../gmock_cook_book.md#MonomorphicMatchers) or
+[polymorphic](../gmock_cook_book.md#PolymorphicMatchers) matchers.
+
 | Macro                                | Description                           |
 | :----------------------------------- | :------------------------------------ |
 | `MATCHER(IsEven, "") { return (arg % 2) == 0; }` | Defines a matcher `IsEven()` to match an even number. |
diff --git a/extern/googletest/docs/reference/testing.md b/extern/googletest/docs/reference/testing.md
index d7dc5cf9b..ea43721e5 100644
--- a/extern/googletest/docs/reference/testing.md
+++ b/extern/googletest/docs/reference/testing.md
@@ -203,7 +203,7 @@ class MyParam {
 
 INSTANTIATE_TEST_SUITE_P(MyInstantiation, MyTestSuite,
     ConvertGenerator(Combine(Values(1, 1.2), Bool()),
-        [](const std::tuple& t){
+        [](const std::tuple& t){
           const auto [i, b] = t;
           return MyParam(i, b);
         }));
diff --git a/extern/googletest/googlemock/CMakeLists.txt b/extern/googletest/googlemock/CMakeLists.txt
index 99b2411f3..33ec96363 100644
--- a/extern/googletest/googlemock/CMakeLists.txt
+++ b/extern/googletest/googlemock/CMakeLists.txt
@@ -105,10 +105,10 @@ 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}>")
+  "$")
 
 ########################################################################
 #
diff --git a/extern/googletest/googlemock/include/gmock/gmock-actions.h b/extern/googletest/googlemock/include/gmock/gmock-actions.h
index 5fe50e3d8..b0a6bdefe 100644
--- a/extern/googletest/googlemock/include/gmock/gmock-actions.h
+++ b/extern/googletest/googlemock/include/gmock/gmock-actions.h
@@ -196,7 +196,7 @@ struct BuiltInDefaultValueGetter {
 // other type T, the built-in default T value is undefined, and the
 // function will abort the process.
 template 
-class BuiltInDefaultValue {
+class [[nodiscard]] BuiltInDefaultValue {
  public:
   // This function returns true if and only if type T has a built-in default
   // value.
@@ -211,7 +211,7 @@ class BuiltInDefaultValue {
 // This partial specialization says that we use the same built-in
 // default value for T and const T.
 template 
-class BuiltInDefaultValue {
+class [[nodiscard]] BuiltInDefaultValue {
  public:
   static bool Exists() { return BuiltInDefaultValue::Exists(); }
   static T Get() { return BuiltInDefaultValue::Get(); }
@@ -220,7 +220,7 @@ class BuiltInDefaultValue {
 // This partial specialization defines the default values for pointer
 // types.
 template 
-class BuiltInDefaultValue {
+class [[nodiscard]] BuiltInDefaultValue {
  public:
   static bool Exists() { return true; }
   static T* Get() { return nullptr; }
@@ -383,7 +383,7 @@ typename std::add_const::type& as_const(T& t) {
 
 // Specialized for function types below.
 template 
-class OnceAction;
+class [[nodiscard]] OnceAction;
 
 // An action that can only be used once.
 //
@@ -421,27 +421,26 @@ class OnceAction;
 // A less-contrived example would be an action that returns an arbitrary type,
 // whose &&-qualified call operator is capable of dealing with move-only types.
 template 
-class OnceAction final {
+class [[nodiscard]] OnceAction final {
  private:
   // True iff we can use the given callable type (or lvalue reference) directly
   // via StdFunctionAdaptor.
   template 
   using IsDirectlyCompatible = internal::conjunction<
-      // It must be possible to capture the callable in StdFunctionAdaptor.
-      std::is_constructible::type, Callable>,
       // The callable must be compatible with our signature.
-      internal::is_callable_r::type,
-                              Args...>>;
+      internal::is_callable_r, Args...>,
+      // It must be possible to capture the callable in StdFunctionAdaptor.
+      std::is_constructible, Callable>>;
 
   // True iff we can use the given callable type via StdFunctionAdaptor once we
   // ignore incoming arguments.
   template 
   using IsCompatibleAfterIgnoringArguments = internal::conjunction<
-      // It must be possible to capture the callable in a lambda.
-      std::is_constructible::type, Callable>,
       // The callable must be invocable with zero arguments, returning something
       // convertible to Result.
-      internal::is_callable_r::type>>;
+      internal::is_callable_r>,
+      // It must be possible to capture the callable in a lambda.
+      std::is_constructible, Callable>>;
 
  public:
   // Construct from a callable that is directly compatible with our mocked
@@ -574,7 +573,7 @@ class OnceAction final {
 //   // Sets the default value for type T to be foo.
 //   DefaultValue::Set(foo);
 template 
-class DefaultValue {
+class [[nodiscard]] DefaultValue {
  public:
   // Sets the default value for type T; requires T to be
   // copy-constructable and have a public destructor.
@@ -651,7 +650,7 @@ class DefaultValue {
 // This partial specialization allows a user to set default values for
 // reference types.
 template 
-class DefaultValue {
+class [[nodiscard]] DefaultValue {
  public:
   // Sets the default value for type T&.
   static void Set(T& x) {  // NOLINT
@@ -685,7 +684,7 @@ class DefaultValue {
 // This specialization allows DefaultValue::Get() to
 // compile.
 template <>
-class DefaultValue {
+class [[nodiscard]] DefaultValue {
  public:
   static bool Exists() { return true; }
   static void Get() {}
@@ -701,7 +700,7 @@ T* DefaultValue::address_ = nullptr;
 
 // Implement this interface to define an action for function type F.
 template 
-class ActionInterface {
+class [[nodiscard]] ActionInterface {
  public:
   typedef typename internal::Function::Result Result;
   typedef typename internal::Function::ArgumentTuple ArgumentTuple;
@@ -721,7 +720,7 @@ class ActionInterface {
 };
 
 template 
-class Action;
+class [[nodiscard]] Action;
 
 // An Action is a copyable and IMMUTABLE (except by assignment)
 // object that represents an action to be taken when a mock function of type
@@ -730,7 +729,7 @@ class Action;
 // can view an object implementing ActionInterface as a concrete action
 // (including its current state), and an Action object as a handle to it.
 template 
-class Action {
+class [[nodiscard]] Action {
  private:
   using F = R(Args...);
 
@@ -869,7 +868,7 @@ class Action {
 // the definition of Return(void) and SetArgumentPointee(value) for
 // complete examples.
 template 
-class PolymorphicAction {
+class [[nodiscard]] PolymorphicAction {
  public:
   explicit PolymorphicAction(const Impl& impl) : impl_(impl) {}
 
@@ -929,7 +928,7 @@ struct ByMoveWrapper {
 
 // The general implementation of Return(R). Specializations follow below.
 template 
-class ReturnAction final {
+class [[nodiscard]] ReturnAction final {
  public:
   explicit ReturnAction(R value) : value_(std::move(value)) {}
 
@@ -1095,7 +1094,7 @@ class ReturnAction final {
 // the const call operator, checking at runtime that it isn't called more than
 // once, since the user has declared their intent to do so by using ByMove.
 template 
-class ReturnAction> final {
+class [[nodiscard]] ReturnAction> final {
  public:
   explicit ReturnAction(ByMoveWrapper wrapper)
       : state_(new State(std::move(wrapper.payload))) {}
@@ -1122,7 +1121,7 @@ class ReturnAction> final {
 };
 
 // Implements the ReturnNull() action.
-class ReturnNullAction {
+class [[nodiscard]] ReturnNullAction {
  public:
   // Allows ReturnNull() to be used in any pointer-returning function. In C++11
   // this is enforced by returning nullptr, and in non-C++11 by asserting a
@@ -1134,7 +1133,7 @@ class ReturnNullAction {
 };
 
 // Implements the Return() action.
-class ReturnVoidAction {
+class [[nodiscard]] ReturnVoidAction {
  public:
   // Allows Return() to be used in any void-returning function.
   template 
@@ -1147,7 +1146,7 @@ class ReturnVoidAction {
 // in any function that returns a reference to the type of x,
 // regardless of the argument types.
 template 
-class ReturnRefAction {
+class [[nodiscard]] ReturnRefAction {
  public:
   // Constructs a ReturnRefAction object from the reference to be returned.
   explicit ReturnRefAction(T& ref) : ref_(ref) {}  // NOLINT
@@ -1188,7 +1187,7 @@ class ReturnRefAction {
 // used in any function that returns a reference to the type of x,
 // regardless of the argument types.
 template 
-class ReturnRefOfCopyAction {
+class [[nodiscard]] ReturnRefOfCopyAction {
  public:
   // Constructs a ReturnRefOfCopyAction object from the reference to
   // be returned.
@@ -1229,7 +1228,7 @@ class ReturnRefOfCopyAction {
 // Implements the polymorphic ReturnRoundRobin(v) action, which can be
 // used in any function that returns the element_type of v.
 template 
-class ReturnRoundRobinAction {
+class [[nodiscard]] ReturnRoundRobinAction {
  public:
   explicit ReturnRoundRobinAction(std::vector values) {
     GTEST_CHECK_(!values.empty())
@@ -1257,7 +1256,7 @@ class ReturnRoundRobinAction {
 };
 
 // Implements the polymorphic DoDefault() action.
-class DoDefaultAction {
+class [[nodiscard]] DoDefaultAction {
  public:
   // This template type conversion operator allows DoDefault() to be
   // used in any function.
@@ -1270,7 +1269,7 @@ class DoDefaultAction {
 // Implements the Assign action to set a given pointer referent to a
 // particular value.
 template 
-class AssignAction {
+class [[nodiscard]] AssignAction {
  public:
   AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {}
 
@@ -1289,7 +1288,7 @@ class AssignAction {
 // Implements the SetErrnoAndReturn action to simulate return from
 // various system calls and libc functions.
 template 
-class SetErrnoAndReturnAction {
+class [[nodiscard]] SetErrnoAndReturnAction {
  public:
   SetErrnoAndReturnAction(int errno_value, T result)
       : errno_(errno_value), result_(result) {}
@@ -1331,22 +1330,6 @@ struct InvokeMethodAction {
   }
 };
 
-// Implements the InvokeWithoutArgs(f) action.  The template argument
-// FunctionImpl is the implementation type of f, which can be either a
-// function pointer or a functor.  InvokeWithoutArgs(f) can be used as an
-// Action as long as f's type is compatible with F.
-template 
-struct InvokeWithoutArgsAction {
-  FunctionImpl function_impl;
-
-  // Allows InvokeWithoutArgs(f) to be used as any action whose type is
-  // compatible with f.
-  template 
-  auto operator()(const Args&...) -> decltype(function_impl()) {
-    return function_impl();
-  }
-};
-
 // Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action.
 template 
 struct InvokeMethodWithoutArgsAction {
@@ -1397,7 +1380,7 @@ class IgnoreResultAction {
 
     void Perform(const ArgumentTuple& args) override {
       // Performs the action and ignores its result.
-      action_.Perform(args);
+      (void)action_.Perform(args);
     }
 
    private:
@@ -1503,11 +1486,11 @@ struct WithArgsAction {
 };
 
 template 
-class DoAllAction;
+class [[nodiscard]] DoAllAction;
 
 // Base case: only a single action.
 template 
-class DoAllAction {
+class [[nodiscard]] DoAllAction {
  public:
   struct UserConstructorTag {};
 
@@ -1561,7 +1544,7 @@ class DoAllAction {
 // Recursive case: support N actions by calling the initial action and then
 // calling through to the base class containing N-1 actions.
 template 
-class DoAllAction
+class [[nodiscard]] DoAllAction
     : private DoAllAction {
  private:
   using Base = DoAllAction;
@@ -1796,11 +1779,24 @@ struct SetArrayArgumentAction {
 };
 
 template 
-struct DeleteArgAction {
+class [[nodiscard]] DeleteArgAction {
+ public:
   template 
   void operator()(const Args&... args) const {
-    delete std::get(std::tie(args...));
+    DoDelete(std::get(std::tie(args...)));
+  }
+
+ private:
+  template 
+  static void DoDelete(T* ptr) {
+    delete ptr;
   }
+
+  template 
+  [[deprecated(
+      "DeleteArg used for a non-pointer argument, it was likely migrated "
+      "to a smart pointer type. This action should be removed.")]]
+  static void DoDelete(T&) {}
 };
 
 template 
@@ -1866,6 +1862,13 @@ struct RethrowAction {
 //   EXPECT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin));
 typedef internal::IgnoredValue Unused;
 
+// Deprecated single-argument DoAll.
+template 
+GTEST_INTERNAL_DEPRECATE_AND_INLINE("Avoid using DoAll() for single actions")
+typename std::decay::type DoAll(Action&& action) {
+  return std::forward(action);
+}
+
 // Creates an action that does actions a1, a2, ..., sequentially in
 // each invocation. All but the last action will have a readonly view of the
 // arguments.
@@ -2031,10 +2034,11 @@ PolymorphicAction> SetErrnoAndReturn(
 // Various overloads for Invoke().
 
 // Legacy function.
-// Actions can now be implicitly constructed from callables. No need to create
-// wrapper objects.
 // This function exists for backwards compatibility.
 template 
+GTEST_INTERNAL_DEPRECATE_AND_INLINE(
+    "Actions can now be implicitly constructed from callables. No need to "
+    "create wrapper objects using Invoke().")
 typename std::decay::type Invoke(FunctionImpl&& function_impl) {
   return std::forward(function_impl);
 }
@@ -2049,9 +2053,11 @@ internal::InvokeMethodAction Invoke(Class* obj_ptr,
 
 // Creates an action that invokes 'function_impl' with no argument.
 template 
-internal::InvokeWithoutArgsAction::type>
-InvokeWithoutArgs(FunctionImpl function_impl) {
-  return {std::move(function_impl)};
+GTEST_INTERNAL_DEPRECATE_AND_INLINE(
+    "Actions can now be implicitly constructed from zero-argument callables. "
+    "No need to create wrapper objects using InvokeWithoutArgs().")
+std::decay_t InvokeWithoutArgs(FunctionImpl&& function_impl) {
+  return std::forward(function_impl);
 }
 
 // Creates an action that invokes the given method on the given object
diff --git a/extern/googletest/googlemock/include/gmock/gmock-cardinalities.h b/extern/googletest/googlemock/include/gmock/gmock-cardinalities.h
index 533e604f3..c88c00c44 100644
--- a/extern/googletest/googlemock/include/gmock/gmock-cardinalities.h
+++ b/extern/googletest/googlemock/include/gmock/gmock-cardinalities.h
@@ -63,7 +63,7 @@ namespace testing {
 // management as Cardinality objects can now be copied like plain values.
 
 // The implementation of a cardinality.
-class CardinalityInterface {
+class [[nodiscard]] CardinalityInterface {
  public:
   virtual ~CardinalityInterface() = default;
 
@@ -88,7 +88,7 @@ class CardinalityInterface {
 // object that specifies how many times a mock function is expected to
 // be called.  The implementation of Cardinality is just a std::shared_ptr
 // to const CardinalityInterface. Don't inherit from Cardinality!
-class GTEST_API_ Cardinality {
+class GTEST_API_ [[nodiscard]] Cardinality {
  public:
   // Constructs a null cardinality.  Needed for storing Cardinality
   // objects in STL containers.
diff --git a/extern/googletest/googlemock/include/gmock/gmock-matchers.h b/extern/googletest/googlemock/include/gmock/gmock-matchers.h
index aa3a5eb16..9caee1d6a 100644
--- a/extern/googletest/googlemock/include/gmock/gmock-matchers.h
+++ b/extern/googletest/googlemock/include/gmock/gmock-matchers.h
@@ -258,7 +258,6 @@
 #include 
 #include 
 #include 
-#include 
 #include 
 #include 
 #include 
@@ -268,14 +267,15 @@
 #include   // NOLINT
 #include 
 #include 
+#include 
 #include 
 #include 
 #include 
 
 #include "gmock/internal/gmock-internal-utils.h"
-#include "gmock/internal/gmock-port.h"
 #include "gmock/internal/gmock-pp.h"
 #include "gtest/gtest.h"
+#include "gtest/internal/gtest-internal.h"
 
 // MSVC warning C5046 is new as of VS2017 version 15.8.
 #if defined(_MSC_VER) && _MSC_VER >= 1915
@@ -284,6 +284,44 @@
 #define GMOCK_MAYBE_5046_
 #endif
 
+#if GTEST_HAS_RTTI
+namespace proto2 {
+namespace internal {
+
+// A type trait to essentially determine if `DynamicCastMessage` is available,
+// since older versions of protobuf don't have this function.
+template 
+static constexpr bool kHasDynamicCastMessage = false;
+template 
+static constexpr bool kHasDynamicCastMessage<
+    T, std::void_t(
+           std::declval()))>> = true;
+
+// A helper function to call `DynamicCastMessage` if available, otherwise
+// falling back to `dynamic_cast`. Note that we must declare this function in
+// the `proto2` namespace because we need ADL to find the right
+// `DynamicCastMessage`, and ADL only applies to unqualified function calls.
+template 
+const T* DynamicCastMessageForGtest(const proto2::MessageLite* msg) {
+  if constexpr (kHasDynamicCastMessage) {
+    return DynamicCastMessage(msg);
+  } else {
+    return dynamic_cast(msg);
+  }
+}
+template 
+T* DynamicCastMessageForGtest(proto2::MessageLite* msg) {
+  if constexpr (kHasDynamicCastMessage) {
+    return DynamicCastMessage(msg);
+  } else {
+    return dynamic_cast(msg);
+  }
+}
+
+}  // namespace internal
+}  // namespace proto2
+#endif  // GTEST_HAS_RTTI
+
 GTEST_DISABLE_MSC_WARNINGS_PUSH_(
     4251 GMOCK_MAYBE_5046_ /* class A needs to have dll-interface to be used by
                               clients of class B */
@@ -304,7 +342,7 @@ namespace testing {
 // plain values.
 
 // A match result listener that stores the explanation in a string.
-class StringMatchResultListener : public MatchResultListener {
+class [[nodiscard]] StringMatchResultListener : public MatchResultListener {
  public:
   StringMatchResultListener() : MatchResultListener(&ss_) {}
 
@@ -337,7 +375,7 @@ namespace internal {
 // Matcher but is not one yet; for example, Eq(value)) or a value (for
 // example, "hello").
 template 
-class MatcherCastImpl {
+class [[nodiscard]] MatcherCastImpl {
  public:
   static Matcher Cast(const M& polymorphic_matcher_or_value) {
     // M can be a polymorphic matcher, in which case we want to use
@@ -376,11 +414,16 @@ class MatcherCastImpl {
 
   // M can't be implicitly converted to Matcher, so M isn't a polymorphic
   // matcher. It's a value of a type implicitly convertible to T. Use direct
-  // initialization to create a matcher.
+  // initialization or `ImplicitCastEqMatcher` to create a matcher.
   static Matcher CastImpl(const M& value,
                              std::false_type /* convertible_to_matcher */,
                              std::true_type /* convertible_to_T */) {
-    return Matcher(ImplicitCast_(value));
+    using NoRefT = std::remove_cv_t>;
+    if constexpr (std::is_same_v) {
+      return Matcher(value);
+    } else {
+      return ImplicitCastEqMatcher>(value);
+    }
   }
 
   // M can't be implicitly converted to either Matcher or T. Attempt to use
@@ -391,18 +434,18 @@ class MatcherCastImpl {
   // latter calls bool operator==(const Lhs& lhs, const Rhs& rhs) in the end
   // which might be undefined even when Rhs is implicitly convertible to Lhs
   // (e.g. std::pair vs. std::pair).
-  //
-  // We don't define this method inline as we need the declaration of Eq().
   static Matcher CastImpl(const M& value,
                              std::false_type /* convertible_to_matcher */,
-                             std::false_type /* convertible_to_T */);
+                             std::false_type /* convertible_to_T */) {
+    return Eq(value);
+  }
 };
 
 // This more specialized version is used when MatcherCast()'s argument
 // is already a Matcher.  This only compiles when type T can be
 // statically converted to type U.
 template 
-class MatcherCastImpl> {
+class [[nodiscard]] MatcherCastImpl> {
  public:
   static Matcher Cast(const Matcher& source_matcher) {
     return Matcher(new Impl(source_matcher));
@@ -464,14 +507,14 @@ class MatcherCastImpl> {
 // This even more specialized version is used for efficiently casting
 // a matcher to its own type.
 template 
-class MatcherCastImpl> {
+class [[nodiscard]] MatcherCastImpl> {
  public:
   static Matcher Cast(const Matcher& matcher) { return matcher; }
 };
 
 // Template specialization for parameterless Matcher.
 template 
-class MatcherBaseImpl {
+class [[nodiscard]] MatcherBaseImpl {
  public:
   MatcherBaseImpl() = default;
 
@@ -484,7 +527,7 @@ class MatcherBaseImpl {
 
 // Template specialization for Matcher with parameters.
 template