Update googletest to 1.18.0 and SIMDe to 0.8.2.

Googletest 1.18 asks for CMake 3.13 or newer, so configuring the tests no longer warns that CMake compatibility below 3.10 is deprecated. Co-authored-by: Cursor <cursoragent@cursor.com>
2026-09-24 14:30:19 -06:00 · 2026-09-24 14:30:19 -06:00 · 3f10e05176
commit 3f10e05176
parent e4e666f459
912 changed files with 224964 additions and 11502 deletions
--- a/test/googletest/.github/workflows/gtest-ci.yml
+++ b/test/googletest/.github/workflows/gtest-ci.yml
@ -1,43 +0,0 @@
 name: ci
 on:
  push:
  pull_request:
 env:
  BAZEL_CXXOPTS: -std=c++14
 jobs:
  Linux:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
      with:
        fetch-depth: 0
    - name: Tests
      run: bazel test --cxxopt=-std=c++14 --features=external_include_paths --test_output=errors ...
  macOS:
    runs-on: macos-latest
    steps:
    - uses: actions/checkout@v3
      with:
        fetch-depth: 0
    - name: Tests
      run:  bazel test --cxxopt=-std=c++14 --features=external_include_paths --test_output=errors ...
  Windows:
    runs-on: windows-latest
    steps:
    - uses: actions/checkout@v3
      with:
        fetch-depth: 0
    - name: Tests
      run: bazel test --cxxopt=/std:c++14 --features=external_include_paths --test_output=errors ...
--- a/test/googletest/.gitignore
+++ b/test/googletest/.gitignore
@ -8,6 +8,7 @@ bazel-genfiles
 bazel-googletest
 bazel-out
 bazel-testlogs
 MODULE.bazel.lock
 # python
 *.pyc
@ -24,6 +25,10 @@ Win32-Release/
 x64-Debug/
 x64-Release/
 # VSCode files
 .cache/
 cmake-variants.yaml
 # Ignore autoconf / automake files
 Makefile.in
 aclocal.m4
--- a/test/googletest/BUILD.bazel
+++ b/test/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"])
@ -56,6 +58,12 @@ config_setting(
    constraint_values = ["@platforms//os:openbsd"],
 )
 # NOTE: Fuchsia is not an officially supported platform.
 config_setting(
    name = "fuchsia",
    constraint_values = ["@platforms//os:fuchsia"],
 )
 config_setting(
    name = "msvc_compiler",
    flag_values = {
@ -77,6 +85,10 @@ cc_library(
 )
 # Google Test including Google Mock
 # For an actual test, use `gtest` and also `gtest_main` if you depend on gtest's
 # main(). For a library, use `gtest_for_library` instead if the library can be
 # testonly.
 cc_library(
    name = "gtest",
    srcs = glob(
@ -132,23 +144,41 @@ cc_library(
    }),
    deps = select({
        ":has_absl": [
-            "@com_google_absl//absl/debugging:failure_signal_handler",
+            "@abseil-cpp//absl/container:flat_hash_set",
-            "@com_google_absl//absl/debugging:stacktrace",
+            "@abseil-cpp//absl/debugging:failure_signal_handler",
-            "@com_google_absl//absl/debugging:symbolize",
+            "@abseil-cpp//absl/debugging:stacktrace",
-            "@com_google_absl//absl/flags:flag",
+            "@abseil-cpp//absl/debugging:symbolize",
-            "@com_google_absl//absl/flags:parse",
+            "@abseil-cpp//absl/flags:flag",
-            "@com_google_absl//absl/flags:reflection",
+            "@abseil-cpp//absl/flags:parse",
-            "@com_google_absl//absl/flags:usage",
+            "@abseil-cpp//absl/flags:reflection",
-            "@com_google_absl//absl/strings",
+            "@abseil-cpp//absl/flags:usage",
-            "@com_google_absl//absl/types:any",
+            "@abseil-cpp//absl/strings",
-            "@com_google_absl//absl/types:optional",
+            "@re2",
-            "@com_google_absl//absl/types:variant",
+        ],
-            "@com_googlesource_code_re2//:re2",
+        "//conditions:default": [],
    }) + select({
        # `gtest-death-test.cc` has `EXPECT_DEATH` that spawns a process,
        # expects it to crash and inspects its logs with the given matcher,
        # so that's why these libraries are needed.
        # Otherwise, builds targeting Fuchsia would fail to compile.
        ":fuchsia": [
            "@fuchsia_sdk//pkg/fdio",
            "@fuchsia_sdk//pkg/zx",
        ],
        "//conditions:default": [],
    }),
 )
 # `gtest`, but testonly. See guidance on `gtest` for when to use this.
 alias(
    name = "gtest_for_library",
    testonly = True,
    actual = ":gtest",
 )
 # Implements main() for tests using gtest. Prefer to depend on `gtest` as well
 # to ensure compliance with the layering_check Bazel feature where only the
 # direct hdrs values are available.
 cc_library(
    name = "gtest_main",
    srcs = ["googlemock/src/gmock_main.cc"],
@ -157,6 +187,7 @@ cc_library(
        "//conditions:default": [],
    }),
    deps = [":gtest"],
    alwayslink = True,
 )
 # The following rules build samples of how to use gTest.
--- a/test/googletest/CMakeLists.txt
+++ b/test/googletest/CMakeLists.txt
@ -1,22 +1,10 @@
 # Note: CMake support is community-based. The maintainers do not use CMake
 # internally.
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.16)
 if (POLICY CMP0048)
  cmake_policy(SET CMP0048 NEW)
 endif (POLICY CMP0048)
 if (POLICY CMP0069)
  cmake_policy(SET CMP0069 NEW)
 endif (POLICY CMP0069)
 if (POLICY CMP0077)
  cmake_policy(SET CMP0077 NEW)
 endif (POLICY CMP0077)
 project(googletest-distribution)
-set(GOOGLETEST_VERSION 1.13.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)
@ -27,11 +15,20 @@ enable_testing()
 include(CMakeDependentOption)
 include(GNUInstallDirs)
-#Note that googlemock target already builds googletest
+# Note that googlemock target already builds googletest.
 option(BUILD_GMOCK "Builds the googlemock subproject" ON)
 option(INSTALL_GTEST "Enable installation of googletest. (Projects embedding googletest may want to turn this OFF.)" ON)
 option(GTEST_HAS_ABSL "Use Abseil and RE2. Requires Abseil and RE2 to be separately added to the build." OFF)
 if(GTEST_HAS_ABSL)
  if(NOT TARGET absl::base)
    find_package(absl REQUIRED)
  endif()
  if(NOT TARGET re2::re2)
    find_package(re2 REQUIRED)
  endif()
 endif()
 if(BUILD_GMOCK)
  add_subdirectory( googlemock )
 else()
--- a/test/googletest/CONTRIBUTING.md
+++ b/test/googletest/CONTRIBUTING.md
@ -47,11 +47,11 @@ PR is acceptable as an alternative.
 ## The Google Test and Google Mock Communities
 The Google Test community exists primarily through the
-[discussion group](http://groups.google.com/group/googletestframework) and the
+[discussion group](https://groups.google.com/group/googletestframework) and the
 GitHub repository. Likewise, the Google Mock community exists primarily through
-their own [discussion group](http://groups.google.com/group/googlemock). You are
+their own [discussion group](https://groups.google.com/group/googlemock). You
-definitely encouraged to contribute to the discussion and you can also help us
+are definitely encouraged to contribute to the discussion and you can also help
-to keep the effectiveness of the group high by following and promoting the
+us to keep the effectiveness of the group high by following and promoting the
 guidelines listed here.
 ### Please Be Friendly
--- a/test/googletest/CONTRIBUTORS
+++ b/test/googletest/CONTRIBUTORS
@ -55,6 +55,7 @@ Russ Cox <rsc@google.com>
 Russ Rufer <russ@pentad.com>
 Sean Mcafee <eefacm@gmail.com>
 Sigurður Ásgeirsson <siggi@google.com>
 Soyeon Kim <sxshx818@naver.com>
 Sverre Sundsdal <sundsdal@gmail.com>
 Szymon Sobik <sobik.szymon@gmail.com>
 Takeshi Yoshino <tyoshino@google.com>
--- a/test/googletest/MODULE.bazel
+++ b/test/googletest/MODULE.bazel
@ -0,0 +1,80 @@
 # Copyright 2024 Google Inc.
 # All Rights Reserved.
 #
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
 # in the documentation and/or other materials provided with the
 # distribution.
 #     * Neither the name of Google Inc. nor the names of its
 # contributors may be used to endorse or promote products derived from
 # this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 # https://bazel.build/external/overview#bzlmod
 module(
    name = "googletest",
    version = "1.18.0",
    compatibility_level = 1,
 )
 # Only direct dependencies need to be listed below.
 # Please keep the versions in sync with the versions in the WORKSPACE file.
 bazel_dep(
    name = "abseil-cpp",
    version = "20260526.0",
 )
 bazel_dep(
    name = "platforms",
    version = "1.1.0",
 )
 bazel_dep(
    name = "re2",
    version = "2025-11-05.bcr.1",
 )
 bazel_dep(
    name = "rules_cc",
    version = "0.2.22",
 )
 bazel_dep(
    name = "rules_python",
    version = "2.2.0",
    dev_dependency = True,
 )
 # https://rules-python.readthedocs.io/en/stable/toolchains.html#library-modules-with-dev-only-python-usage
 python = use_extension(
    "@rules_python//python/extensions:python.bzl",
    "python",
    dev_dependency = True,
 )
 python.toolchain(
    ignore_root_user_error = True,
    is_default = True,
    python_version = "3.13",
 )
 # See fake_fuchsia_sdk.bzl for instructions on how to override this with a real SDK, if needed.
 fuchsia_sdk = use_extension("//:fake_fuchsia_sdk.bzl", "fuchsia_sdk")
 fuchsia_sdk.create_fake()
 use_repo(fuchsia_sdk, "fuchsia_sdk")
--- a/test/googletest/README.md
+++ b/test/googletest/README.md
@ -2,38 +2,28 @@
 ### Announcements
 #### Live at Head
 GoogleTest now follows the
 [Abseil Live at Head philosophy](https://abseil.io/about/philosophy#upgrade-support).
 We recommend
 [updating to the latest commit in the `main` branch as often as possible](https://github.com/abseil/abseil-cpp/blob/master/FAQ.md#what-is-live-at-head-and-how-do-i-do-it).
 #### Documentation Updates
 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.13.0
+#### Release 1.18.0
-[Release 1.13.0](https://github.com/google/googletest/releases/tag/v1.13.0) is
+[Release 1.18.0](https://github.com/google/googletest/releases/tag/v1.18.0) is
 now available.
-The 1.13.x branch requires at least C++14.
+The 1.18.x branch
 [requires at least C++17](https://opensource.google/documentation/policies/cplusplus-support#c_language_standard).
 #### Continuous Integration
-We use Google's internal systems for continuous integration. \
+We use Google's internal systems for continuous integration.
 GitHub Actions were added for the convenience of open source contributors. They
 are exclusively maintained by the open source community and not used by the
 GoogleTest team.
 #### Coming Soon
 *   We are planning to take a dependency on
    [Abseil](https://github.com/abseil/abseil-cpp).
 *   More documentation improvements are planned.
 ## Welcome to **GoogleTest**, Google's C++ test framework!
@ -52,16 +42,37 @@ More information about building GoogleTest can be found at
 ## Features
-*   An [xUnit](https://en.wikipedia.org/wiki/XUnit) test framework.
+*   xUnit test framework: \
-*   Test discovery.
+    Googletest is based on the [xUnit](https://en.wikipedia.org/wiki/XUnit)
-*   A rich set of assertions.
+    testing framework, a popular architecture for unit testing.
-*   User-defined assertions.
+*   Test discovery: \
-*   Death tests.
+    Googletest automatically discovers and runs your tests, eliminating the need
-*   Fatal and non-fatal failures.
+    to manually register your tests.
-*   Value-parameterized tests.
+*   Rich set of assertions: \
-*   Type-parameterized tests.
+    Googletest provides a variety of assertions, such as equality, inequality,
-*   Various options for running the tests.
+    exceptions, and more, making it easy to test your code.
-*   XML test report generation.
+*   User-defined assertions: \
    You can define your own assertions with Googletest, making it simple to
    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.
 *   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.
 *   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.
 *   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.
 *   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.
 ## Supported Platforms
@ -69,7 +80,7 @@ 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
+for a list of currently supported versions of compilers, platforms, and build
 tools.
 ## Who Is Using GoogleTest?
@ -77,12 +88,12 @@ tools.
 In addition to many internal projects at Google, GoogleTest is also used by the
 following notable projects:
-*   The [Chromium projects](http://www.chromium.org/) (behind the Chrome browser
+*   The [Chromium projects](https://www.chromium.org/) (behind the Chrome
-    and Chrome OS).
+    browser and Chrome OS).
-*   The [LLVM](http://llvm.org/) compiler.
+*   The [LLVM](https://llvm.org/) compiler.
 *   [Protocol Buffers](https://github.com/google/protobuf), Google's data
    interchange format.
-*   The [OpenCV](http://opencv.org/) computer vision library.
+*   The [OpenCV](https://opencv.org/) computer vision library.
 ## Related Open Source Projects
--- a/test/googletest/WORKSPACE
+++ b/test/googletest/WORKSPACE
@ -1,40 +1,66 @@
-workspace(name = "com_google_googletest")
+# Copyright 2024 Google Inc.
 # All Rights Reserved.
 #
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
 # in the documentation and/or other materials provided with the
 # distribution.
 #     * Neither the name of Google Inc. nor the names of its
 # contributors may be used to endorse or promote products derived from
 # this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 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 = "com_google_absl",  # 2023-01-10T21:08:25Z
+    name = "rules_python",
-    sha256 = "f9a4e749f42c386a32a90fddf0e2913ed408d10c42f7f33ccf4c59ac4f0d1d05",
+    sha256 = "e11d2e1efce1589e5bdfa93986712c74fc7467a0f093143d489d2ef5ebb1ed2a",
-    strip_prefix = "abseil-cpp-52835439ca90d86b27bf8cd1708296e95604d724",
+    strip_prefix = "rules_python-2.2.0",
-    urls = ["https://github.com/abseil/abseil-cpp/archive/52835439ca90d86b27bf8cd1708296e95604d724.zip"],
+    url = "https://github.com/bazelbuild/rules_python/releases/download/2.2.0/rules_python-2.2.0.tar.gz",
 )
-# Note this must use a commit from the `abseil` branch of the RE2 project.
+# https://github.com/bazelbuild/rules_python/releases/tag/1.1.0
-# https://github.com/google/re2/tree/abseil
+load("@rules_python//python:repositories.bzl", "py_repositories")
-http_archive(
+
-    name = "com_googlesource_code_re2",  # 2022-12-21T14:29:10Z
+py_repositories()
    sha256 = "b9ce3a51beebb38534d11d40f8928d40509b9e18a735f6a4a97ad3d014c87cb5",
    strip_prefix = "re2-d0b1f8f2ecc2ea74956c7608b6f915175314ff0e",
    urls = ["https://github.com/google/re2/archive/d0b1f8f2ecc2ea74956c7608b6f915175314ff0e.zip"],
 )
 http_archive(
-    name = "rules_python",  # 2023-01-10T22:00:51Z
+    name = "platforms",
-    sha256 = "5de54486a60ad8948dabe49605bb1c08053e04001a431ab3e96745b4d97a4419",
+    sha256 = "dbad4a23abcca6171e47b79edc53bd6a41067a3b75f9e8b104656b459ff25046",
-    strip_prefix = "rules_python-70cce26432187a60b4e950118791385e6fb3c26f",
+    urls = [
-    urls = ["https://github.com/bazelbuild/rules_python/archive/70cce26432187a60b4e950118791385e6fb3c26f.zip"],
+        "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",
    ],
 )
-http_archive(
+load("@bazel_features//:deps.bzl", "bazel_features_deps")
    name = "bazel_skylib",  # 2022-11-16T18:29:32Z
    sha256 = "a22290c26d29d3ecca286466f7f295ac6cbe32c0a9da3a91176a90e0725e3649",
    strip_prefix = "bazel-skylib-5bfcb1a684550626ce138fe0fe8f5f702b3764c3",
    urls = ["https://github.com/bazelbuild/bazel-skylib/archive/5bfcb1a684550626ce138fe0fe8f5f702b3764c3.zip"],
 )
-http_archive(
+bazel_features_deps()
-    name = "platforms",  # 2022-11-09T19:18:22Z
+
-    sha256 = "b4a3b45dc4202e2b3e34e3bc49d2b5b37295fc23ea58d88fb9e01f3642ad9b55",
+load("@rules_cc//cc:extensions.bzl", "compatibility_proxy_repo")
-    strip_prefix = "platforms-3fbc687756043fb58a407c2ea8c944bc2fe1d922",
+
-    urls = ["https://github.com/bazelbuild/platforms/archive/3fbc687756043fb58a407c2ea8c944bc2fe1d922.zip"],
+compatibility_proxy_repo()
 )
--- a/test/googletest/WORKSPACE.bzlmod
+++ b/test/googletest/WORKSPACE.bzlmod
@ -0,0 +1,35 @@
 # Copyright 2024 Google Inc.
 # All Rights Reserved.
 #
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
 # in the documentation and/or other materials provided with the
 # distribution.
 #     * Neither the name of Google Inc. nor the names of its
 # contributors may be used to endorse or promote products derived from
 # this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 # https://bazel.build/external/migration#workspace.bzlmod
 #
 # This file is intentionally empty. When bzlmod is enabled and this
 # file exists, the content of WORKSPACE is ignored. This prevents
 # bzlmod builds from unintentionally depending on the WORKSPACE file.
--- a/test/googletest/ci/linux-presubmit.sh
+++ b/test/googletest/ci/linux-presubmit.sh
@ -31,31 +31,37 @@
 set -euox pipefail
-readonly LINUX_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest:20230217"
+readonly LINUX_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest@sha256:baa99e65a3cc837bab8e5246f1870d25c76d0adf2b1d598ee5a3ec77fd2e19bd"
 readonly LINUX_GCC_FLOOR_CONTAINER="gcr.io/google.com/absl-177019/linux_gcc-floor:20230120"
 if [[ -z ${GTEST_ROOT:-} ]]; then
  GTEST_ROOT="$(realpath $(dirname ${0})/..)"
 fi
-if [[ -z ${STD:-} ]]; then
+# Use Bazel Vendor mode to reduce reliance on external dependencies.
-  STD="c++14 c++17 c++20"
+# 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
-# Test the CMake build
+if [[ -z ${STD:-} ]]; then
-for cc in /usr/local/bin/gcc /opt/llvm/clang/bin/clang; do
+  STD="c++17 c++20 c++23"
 fi
 # Test CMake + GCC
 for cmake_off_on in OFF ON; do
  time docker run \
    --volume="${GTEST_ROOT}:/src:ro" \
    --tmpfs="/build:exec" \
    --workdir="/build" \
    --rm \
-      --env="CC=${cc}" \
+    --env="CC=/usr/local/bin/gcc" \
    --env=CXXFLAGS="-Werror -Wdeprecated" \
    ${LINUX_LATEST_CONTAINER} \
    /bin/bash -c "
      cmake /src \
-          -DCMAKE_CXX_STANDARD=14 \
+        -DCMAKE_CXX_STANDARD=17 \
        -Dgtest_build_samples=ON \
        -Dgtest_build_tests=ON \
        -Dgmock_build_tests=ON \
@ -64,6 +70,27 @@ for cc in /usr/local/bin/gcc /opt/llvm/clang/bin/clang; do
      make -j$(nproc) && \
      ctest -j$(nproc) --output-on-failure"
 done
 # Test CMake + Clang
 for cmake_off_on in OFF ON; do
  time docker run \
    --volume="${GTEST_ROOT}:/src:ro" \
    --tmpfs="/build:exec" \
    --workdir="/build" \
    --rm \
    --env="CC=/opt/llvm/bin/clang" \
    --env=CXXFLAGS="-Werror -Wdeprecated --gcc-toolchain=/usr/local" \
    ${LINUX_LATEST_CONTAINER} \
    /bin/bash -c "
      cmake /src \
        -DCMAKE_CXX_STANDARD=17 \
        -Dgtest_build_samples=ON \
        -Dgtest_build_tests=ON \
        -Dgmock_build_tests=ON \
        -Dcxx_no_exception=${cmake_off_on} \
        -Dcxx_no_rtti=${cmake_off_on} && \
      make -j$(nproc) && \
      ctest -j$(nproc) --output-on-failure"
 done
 # Do one test with an older version of GCC
@ -71,19 +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++14" \
+  --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=\"-Wall\" \
-      --copt="-Werror" \
+      --copt=\"-Werror\" \
-      --copt="-Wuninitialized" \
+      --copt=\"-Wuninitialized\" \
-      --copt="-Wno-error=pragmas" \
+      --copt=\"-Wundef\" \
-      --distdir="/bazel-distdir" \
+      --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
@ -94,17 +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} \
      /bin/bash --login -c "
        /usr/local/bin/bazel test ... \
-        --copt="-Wall" \
+          --copt=\"-Wall\" \
-        --copt="-Werror" \
+          --copt=\"-Werror\" \
-        --copt="-Wuninitialized" \
+          --copt=\"-Wuninitialized\" \
-        --define="absl=${absl}" \
+          --copt=\"-Wundef\" \
-        --distdir="/bazel-distdir" \
+          --define=\"absl=${absl}\" \
          --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
 done
@ -115,20 +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} \
      /bin/bash --login -c "
        /usr/local/bin/bazel test ... \
-        --copt="--gcc-toolchain=/usr/local" \
+          --copt=\"--gcc-toolchain=/usr/local\" \
-        --copt="-Wall" \
+          --copt=\"-Wall\" \
-        --copt="-Werror" \
+          --copt=\"-Werror\" \
-        --copt="-Wuninitialized" \
+          --copt=\"-Wuninitialized\" \
-        --define="absl=${absl}" \
+          --copt=\"-Wundef\" \
-        --distdir="/bazel-distdir" \
+          --define=\"absl=${absl}\" \
          --enable_bzlmod=true \
          --features=external_include_paths \
          --keep_going \
-        --linkopt="--gcc-toolchain=/usr/local" \
+          --linkopt=\"--gcc-toolchain=/usr/local\" \
          --per_file_copt=\"external/.*@-w\" \
          --show_timestamps \
-        --test_output=errors
+          --test_output=errors \
          ${BAZEL_EXTRA_ARGS:-}"
  done
 done
--- a/test/googletest/ci/macos-presubmit.sh
+++ b/test/googletest/ci/macos-presubmit.sh
@ -31,6 +31,14 @@
 set -euox pipefail
 # 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})/..)"
 fi
@ -40,20 +48,20 @@ for cmake_off_on in OFF ON; do
  BUILD_DIR=$(mktemp -d build_dir.XXXXXXXX)
  cd ${BUILD_DIR}
  time cmake ${GTEST_ROOT} \
-    -DCMAKE_CXX_STANDARD=14 \
+    -DCMAKE_CXX_STANDARD=17 \
    -Dgtest_build_samples=ON \
    -Dgtest_build_tests=ON \
    -Dgmock_build_tests=ON \
    -Dcxx_no_exception=${cmake_off_on} \
    -Dcxx_no_rtti=${cmake_off_on}
-  time make
+  time make -j$(nproc)
  time ctest -j$(nproc) --output-on-failure
 done
 # Test the Bazel build
 # If we are running on Kokoro, check for a versioned Bazel binary.
-KOKORO_GFILE_BAZEL_BIN="bazel-5.1.1-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}
@ -61,15 +69,25 @@ 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 ... \
    --copt="-Wall" \
    --copt="-Werror" \
-    --cxxopt="-std=c++14" \
+    --copt="-Wundef" \
    --cxxopt="-std=c++17" \
    --define="absl=${absl}" \
    --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
--- a/test/googletest/ci/windows-presubmit.bat
+++ b/test/googletest/ci/windows-presubmit.bat
@ -1,29 +1,29 @@
 SETLOCAL ENABLEDELAYEDEXPANSION
-SET BAZEL_EXE=%KOKORO_GFILE_DIR%\bazel-5.1.1-windows-x86_64.exe
+SET BAZEL_EXE=%KOKORO_GFILE_DIR%\bazel-9.1.0-windows-x86_64.exe
-SET PATH=C:\Python37;%PATH%
+SET PATH=C:\Python34;%PATH%
-SET BAZEL_PYTHON=C:\python37\python.exe
+SET BAZEL_PYTHON=C:\python34\python.exe
 SET BAZEL_SH=C:\tools\msys64\usr\bin\bash.exe
-SET CMAKE_BIN="C:\Program Files\CMake\bin\cmake.exe"
+SET CMAKE_BIN="cmake.exe"
-SET CTEST_BIN="C:\Program Files\CMake\bin\ctest.exe"
+SET CTEST_BIN="ctest.exe"
 SET CTEST_OUTPUT_ON_FAILURE=1
 SET CMAKE_BUILD_PARALLEL_LEVEL=16
 SET CTEST_PARALLEL_LEVEL=16
-IF EXIST git\googletest (
+SET GTEST_ROOT=%~dp0\..
  CD git\googletest
 ) ELSE IF EXIST github\googletest (
  CD github\googletest
 )
 IF %errorlevel% neq 0 EXIT /B 1
 :: ----------------------------------------------------------------------------
-:: CMake Visual Studio 15 2017 Win64
+:: CMake
-MKDIR cmake_msvc2017
+SET CMAKE_BUILD_PATH=cmake_msvc2022
-CD cmake_msvc2017
+MKDIR %CMAKE_BUILD_PATH%
 CD %CMAKE_BUILD_PATH%
 SET CXXFLAGS="/WX"
-%CMAKE_BIN% .. ^
+%CMAKE_BIN% %GTEST_ROOT% ^
-  -G "Visual Studio 15 2017 Win64" ^
+  -G "Visual Studio 17 2022" ^
  -DCMAKE_CXX_STANDARD=17 ^
  -DPYTHON_EXECUTABLE:FILEPATH=c:\python37\python.exe ^
  -DPYTHON_INCLUDE_DIR:PATH=c:\python37\include ^
  -DPYTHON_LIBRARY:FILEPATH=c:\python37\lib\site-packages\pip ^
@ -38,19 +38,52 @@ IF %errorlevel% neq 0 EXIT /B 1
 %CTEST_BIN% -C Debug --timeout 600
 IF %errorlevel% neq 0 EXIT /B 1
-CD ..
+SET "CXXFLAGS="
-RMDIR /S /Q cmake_msvc2017
+CD %GTEST_ROOT%
 RMDIR /S /Q %CMAKE_BUILD_PATH%
 :: ----------------------------------------------------------------------------
-:: Bazel Visual Studio 15 2017 Win64
+:: Bazel
-SET BAZEL_VC=C:\Program Files (x86)\Microsoft Visual Studio\2017\BuildTools\VC
+:: The default home directory on Kokoro is a long path which causes errors
-%BAZEL_EXE% test ... ^
+:: because of Windows limitations on path length.
 :: --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 ^
  test ... ^
  --compilation_mode=dbg ^
-  --copt=/std:c++14 ^
+  --copt=/std:c++17 ^
  --copt=/WX ^
-  --features=external_include_paths ^
+  --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
 %BAZEL_EXE% ^
  --output_user_root=C:\tmp ^
  test ... ^
  --compilation_mode=dbg ^
  --copt=/std:c++20 ^
  --copt=/WX ^
  --enable_bzlmod=true ^
  --keep_going ^
  --per_file_copt=external/.*@/w ^
  --test_output=errors ^
  --test_tag_filters=-no_test_msvc2017 ^
  %VENDOR_FLAG%
 IF %errorlevel% neq 0 EXIT /B 1
--- a/test/googletest/docs/_layouts/default.html
+++ b/test/googletest/docs/_layouts/default.html
@ -7,15 +7,15 @@
 {% seo %}
    <link rel="stylesheet" href="{{ "/assets/css/style.css?v=" | append: site.github.build_revision | relative_url }}">
    <!-- Google tag (gtag.js) -->
    <script async src="https://www.googletagmanager.com/gtag/js?id=G-9PTP6FW1M5"></script>
    <script>
-      window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)};ga.l=+new Date;
+      window.dataLayer = window.dataLayer || [];
-      ga('create', 'UA-197576187-1', { 'storage': 'none' });
+      function gtag(){dataLayer.push(arguments);}
-      ga('set', 'referrer', document.referrer.split('?')[0]);
+      gtag('js', new Date());
-      ga('set', 'location', window.location.href.split('?')[0]);
+
-      ga('set', 'anonymizeIp', true);
+      gtag('config', 'G-9PTP6FW1M5');
      ga('send', 'pageview');
    </script>
    <script async src='https://www.google-analytics.com/analytics.js'></script>
  </head>
  <body>
    <div class="sidebar">
--- a/test/googletest/docs/advanced.md
+++ b/test/googletest/docs/advanced.md
@ -1,9 +1,9 @@
-# Advanced googletest Topics
+# Advanced GoogleTest Topics
 ## Introduction
-Now that you have read the [googletest Primer](primer.md) and learned how to
+Now that you have read the [GoogleTest Primer](primer.md) and learned how to
-write tests using googletest, it's time to learn some new tricks. This document
+write tests using GoogleTest, it's time to learn some new tricks. This document
 will show you more assertions as well as how to construct complex failure
 messages, propagate fatal failures, reuse and speed up your test fixtures, and
 use various flags with your tests.
@ -25,7 +25,7 @@ Reference.
 ### Predicate Assertions for Better Error Messages
-Even though googletest has a rich set of assertions, they can never be complete,
+Even though GoogleTest has a rich set of assertions, they can never be complete,
 as it's impossible (nor a good idea) to anticipate all scenarios a user might
 run into. Therefore, sometimes a user has to use `EXPECT_TRUE()` to check a
 complex expression, for lack of a better macro. This has the problem of not
@ -35,7 +35,7 @@ failure message by themselves, streaming it into `EXPECT_TRUE()`. However, this
 is awkward especially when the expression has side-effects or is expensive to
 evaluate.
-googletest gives you three different options to solve this problem:
+GoogleTest gives you three different options to solve this problem:
 #### Using an Existing Boolean Function
@ -286,7 +286,7 @@ For example:
 ```c++
 TEST(SkipTest, DoesSkip) {
  GTEST_SKIP() << "Skipping single test";
-  EXPECT_EQ(0, 1);  // Won't fail; it won't be executed
+  FAIL();  // Won't fail; it won't be executed
 }
 class SkipFixture : public ::testing::Test {
@ -298,15 +298,15 @@ class SkipFixture : public ::testing::Test {
 // Tests for SkipFixture won't be executed.
 TEST_F(SkipFixture, SkipsOneTest) {
-  EXPECT_EQ(5, 7);  // Won't fail
+  FAIL();  // Won't fail; it won't be executed
 }
 ```
 As with assertion macros, you can stream a custom message into `GTEST_SKIP()`.
-## Teaching googletest How to Print Your Values
+## Teaching GoogleTest How to Print Your Values
-When a test assertion such as `EXPECT_EQ` fails, googletest prints the argument
+When a test assertion such as `EXPECT_EQ` fails, GoogleTest prints the argument
 values to help you debug. It does this using a user-extensible value printer.
 This printer knows how to print built-in C++ types, native arrays, STL
@ -315,73 +315,143 @@ prints the raw bytes in the value and hopes that you the user can figure it out.
 As mentioned earlier, the printer is *extensible*. That means you can teach it
 to do a better job at printing your particular type than to dump the bytes. To
-do that, define `<<` for your type:
+do that, define an `AbslStringify()` overload as a `friend` function template
-
+for your type:
 ```c++
 #include <ostream>
 ```cpp
 namespace foo {
-class Bar {  // We want googletest to be able to print instances of this.
+class Point {  // We want GoogleTest to be able to print instances of this.
  ...
-  // Create a free inline friend function.
+  // Provide a friend overload.
-  friend std::ostream& operator<<(std::ostream& os, const Bar& bar) {
+  template <typename Sink>
-    return os << bar.DebugString();  // whatever needed to print bar to os
+  friend void AbslStringify(Sink& sink, const Point& point) {
    absl::Format(&sink, "(%d, %d)", point.x, point.y);
  }
  int x;
  int y;
 };
 // If you can't declare the function in the class it's important that the
-// << operator is defined in the SAME namespace that defines Bar.  C++'s look-up
+// AbslStringify overload is defined in the SAME namespace that defines Point.
-// rules rely on that.
+// C++'s look-up rules rely on that.
-std::ostream& operator<<(std::ostream& os, const Bar& bar) {
+enum class EnumWithStringify { kMany = 0, kChoices = 1 };
-  return os << bar.DebugString();  // whatever needed to print bar to os
+
 template <typename Sink>
 void AbslStringify(Sink& sink, EnumWithStringify e) {
  absl::Format(&sink, "%s", e == EnumWithStringify::kMany ? "Many" : "Choices");
 }
 }  // namespace foo
 ```
-Sometimes, this might not be an option: your team may consider it bad style to
+{: .callout .note}
-have a `<<` operator for `Bar`, or `Bar` may already have a `<<` operator that
+Note: `AbslStringify()` utilizes a generic "sink" buffer to construct its
-doesn't do what you want (and you cannot change it). If so, you can instead
+string. For more information about supported operations on `AbslStringify()`'s
-define a `PrintTo()` function like this:
+sink, see
 [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
 formatted as `"(%v, %v)"` for example, and deduce the `int` values as `%d`.
 Sometimes, `AbslStringify()` might not be an option: your team may wish to print
 types with extra debugging information for testing purposes only. If so, you can
 instead define a `PrintTo()` function like this:
 ```c++
 #include <ostream>
 namespace foo {
-class Bar {
+class Point {
  ...
-  friend void PrintTo(const Bar& bar, std::ostream* os) {
+  friend void PrintTo(const Point& point, std::ostream* os) {
-    *os << bar.DebugString();  // whatever needed to print bar to os
+    *os << "(" << point.x << "," << point.y << ")";
  }
  int x;
  int y;
 };
 // If you can't declare the function in the class it's important that PrintTo()
-// is defined in the SAME namespace that defines Bar.  C++'s look-up rules rely
+// is defined in the SAME namespace that defines Point.  C++'s look-up rules
-// on that.
+// rely on that.
-void PrintTo(const Bar& bar, std::ostream* os) {
+void PrintTo(const Point& point, std::ostream* os) {
-  *os << bar.DebugString();  // whatever needed to print bar to os
+    *os << "(" << point.x << "," << point.y << ")";
 }
 }  // namespace foo
 ```
-If you have defined both `<<` and `PrintTo()`, the latter will be used when
+If you have defined both `AbslStringify()` and `PrintTo()`, the latter will be
-googletest is concerned. This allows you to customize how the value appears in
+used by GoogleTest. This allows you to customize how the value appears in
-googletest's output without affecting code that relies on the behavior of its
+GoogleTest's output without affecting code that relies on the behavior of
-`<<` operator.
+`AbslStringify()`.
-If you want to print a value `x` using googletest's value printer yourself, just
+If you have an existing `<<` operator and would like to define an
 `AbslStringify()`, the latter will be used for GoogleTest printing.
 If you want to print a value `x` using GoogleTest's value printer yourself, just
 call `::testing::PrintToString(x)`, which returns an `std::string`:
 ```c++
-vector<pair<Bar, int> > bar_ints = GetBarIntVector();
+vector<pair<Point, int> > point_ints = GetPointIntVector();
-EXPECT_TRUE(IsCorrectBarIntVector(bar_ints))
+EXPECT_TRUE(IsCorrectPointIntVector(point_ints))
-    << "bar_ints = " << testing::PrintToString(bar_ints);
+    << "point_ints = " << testing::PrintToString(point_ints);
 ```
 For more details regarding `AbslStringify()` and its integration with other
 libraries, see
 [the documentation](https://abseil.io/docs/cpp/guides/abslstringify).
 ## Regular Expression Syntax
 When built with Bazel and using Abseil, GoogleTest uses the
 [RE2](https://github.com/google/re2/wiki/Syntax) syntax. Otherwise, for POSIX
 systems (Linux, Cygwin, Mac), GoogleTest uses the
 [POSIX extended regular expression](https://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html#tag_09_04)
 syntax. To learn about POSIX syntax, you may want to read this
 [Wikipedia entry](https://en.wikipedia.org/wiki/Regular_expression#POSIX_extended).
 On Windows, GoogleTest uses its own simple regular expression implementation. It
 lacks many features. For example, we don't support union (`"x|y"`), grouping
 (`"(xy)"`), brackets (`"[xy]"`), and repetition count (`"x{5,7}"`), among
 others. Below is what we do support (`A` denotes a literal character, period
 (`.`), or a single `\\ ` escape sequence; `x` and `y` denote regular
 expressions.):
 Expression | Meaning
 ---------- | --------------------------------------------------------------
 `c`        | matches any literal character `c`
 `\\d`      | matches any decimal digit
 `\\D`      | matches any character that's not a decimal digit
 `\\f`      | matches `\f`
 `\\n`      | matches `\n`
 `\\r`      | matches `\r`
 `\\s`      | matches any ASCII whitespace, including `\n`
 `\\S`      | matches any character that's not a whitespace
 `\\t`      | matches `\t`
 `\\v`      | matches `\v`
 `\\w`      | matches any letter, `_`, or decimal digit
 `\\W`      | matches any character that `\\w` doesn't match
 `\\c`      | matches any literal character `c`, which must be a punctuation
 `.`        | matches any single character except `\n`
 `A?`       | matches 0 or 1 occurrences of `A`
 `A*`       | matches 0 or many occurrences of `A`
 `A+`       | matches 1 or many occurrences of `A`
 `^`        | matches the beginning of a string (not that of each line)
 `$`        | matches the end of a string (not that of each line)
 `xy`       | matches `x` followed by `y`
 To help you determine which capability is available on your system, GoogleTest
 defines macros to govern which regular expression it is using. The macros are:
 `GTEST_USES_SIMPLE_RE=1` or `GTEST_USES_POSIX_RE=1`. If you want your death
 tests to work in all cases, you can either `#if` on these macros or use the more
 limited syntax only.
 ## Death Tests
 In many applications, there are assertions that can cause application failure if
@ -393,7 +463,7 @@ corruption, security holes, or worse. Hence it is vitally important to test that
 such assertion statements work as expected.
 Since these precondition checks cause the processes to die, we call such tests
-_death tests_. More generally, any test that checks that a program terminates
+*death tests*. More generally, any test that checks that a program terminates
 (except by throwing an exception) in an expected fashion is also a death test.
 Note that if a piece of code throws an exception, we don't consider it "death"
@ -439,6 +509,12 @@ verifies that:
    exit with exit code 0, and
 *   calling `KillProcess()` kills the process with signal `SIGKILL`.
 {: .callout .warning}
 Warning: If your death test contains mocks and is expecting a specific exit
 code, then you must allow the mock objects to be leaked via `Mock::AllowLeak`.
 This is because the mock leak detector will exit with its own error code if it
 detects a leak.
 The test function body may contain other assertions and statements as well, if
 necessary.
@ -451,7 +527,7 @@ Note that a death test only cares about three things:
 3.  does the stderr output match `matcher`?
 In particular, if `statement` generates an `ASSERT_*` or `EXPECT_*` failure, it
-will **not** cause the death test to fail, as googletest assertions don't abort
+will **not** cause the death test to fail, as GoogleTest assertions don't abort
 the process.
 ### Death Test Naming
@ -480,51 +556,6 @@ TEST_F(FooDeathTest, DoesThat) {
 }
 ```
 ### Regular Expression Syntax
 When built with Bazel and using Abseil, googletest uses the
 [RE2](https://github.com/google/re2/wiki/Syntax) syntax. Otherwise, for POSIX
 systems (Linux, Cygwin, Mac), googletest uses the
 [POSIX extended regular expression](http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html#tag_09_04)
 syntax. To learn about POSIX syntax, you may want to read this
 [Wikipedia entry](http://en.wikipedia.org/wiki/Regular_expression#POSIX_extended).
 On Windows, googletest uses its own simple regular expression implementation. It
 lacks many features. For example, we don't support union (`"x|y"`), grouping
 (`"(xy)"`), brackets (`"[xy]"`), and repetition count (`"x{5,7}"`), among
 others. Below is what we do support (`A` denotes a literal character, period
 (`.`), or a single `\\ ` escape sequence; `x` and `y` denote regular
 expressions.):
 Expression | Meaning
 ---------- | --------------------------------------------------------------
 `c`        | matches any literal character `c`
 `\\d`      | matches any decimal digit
 `\\D`      | matches any character that's not a decimal digit
 `\\f`      | matches `\f`
 `\\n`      | matches `\n`
 `\\r`      | matches `\r`
 `\\s`      | matches any ASCII whitespace, including `\n`
 `\\S`      | matches any character that's not a whitespace
 `\\t`      | matches `\t`
 `\\v`      | matches `\v`
 `\\w`      | matches any letter, `_`, or decimal digit
 `\\W`      | matches any character that `\\w` doesn't match
 `\\c`      | matches any literal character `c`, which must be a punctuation
 `.`        | matches any single character except `\n`
 `A?`       | matches 0 or 1 occurrences of `A`
 `A*`       | matches 0 or many occurrences of `A`
 `A+`       | matches 1 or many occurrences of `A`
 `^`        | matches the beginning of a string (not that of each line)
 `$`        | matches the end of a string (not that of each line)
 `xy`       | matches `x` followed by `y`
 To help you determine which capability is available on your system, googletest
 defines macros to govern which regular expression it is using. The macros are:
 `GTEST_USES_SIMPLE_RE=1` or `GTEST_USES_POSIX_RE=1`. If you want your death
 tests to work in all cases, you can either `#if` on these macros or use the more
 limited syntax only.
 ### How It Works
 See [Death Assertions](reference/assertions.md#death) in the Assertions
@ -539,7 +570,7 @@ arrange that kind of environment. For example, statically-initialized modules
 may start threads before main is ever reached. Once threads have been created,
 it may be difficult or impossible to clean them up.
-googletest has three features intended to raise awareness of threading issues.
+GoogleTest has three features intended to raise awareness of threading issues.
 1.  A warning is emitted if multiple threads are running when a death test is
    encountered.
@ -592,7 +623,7 @@ TEST(MyDeathTest, TestTwo) {
 The `statement` argument of `ASSERT_EXIT()` can be any valid C++ statement. If
 it leaves the current function via a `return` statement or by throwing an
-exception, the death test is considered to have failed. Some googletest macros
+exception, the death test is considered to have failed. Some GoogleTest macros
 may return from the current function (e.g. `ASSERT_TRUE()`), so be sure to avoid
 them in `statement`.
@ -704,7 +735,7 @@ Some tips on using `SCOPED_TRACE`:
 ### Propagating Fatal Failures
 A common pitfall when using `ASSERT_*` and `FAIL*` is not understanding that
-when they fail they only abort the _current function_, not the entire test. For
+when they fail they only abort the *current function*, not the entire test. For
 example, the following test will segfault:
 ```c++
@ -726,7 +757,7 @@ TEST(FooTest, Bar) {
 }
 ```
-To alleviate this, googletest provides three different solutions. You could use
+To alleviate this, GoogleTest provides three different solutions. You could use
 either exceptions, the `(ASSERT|EXPECT)_NO_FATAL_FAILURE` assertions or the
 `HasFatalFailure()` function. They are described in the following two
 subsections.
@ -760,7 +791,7 @@ in it, the test will continue after the subroutine returns. This may not be what
 you want.
 Often people want fatal failures to propagate like exceptions. For that
-googletest offers the following macros:
+GoogleTest offers the following macros:
 Fatal assertion                       | Nonfatal assertion                    | Verifies
 ------------------------------------- | ------------------------------------- | --------
@ -852,7 +883,7 @@ will output XML like this:
 >     needs to be prefixed with `::testing::Test::` if used outside of the
 >     `TEST` body and the test fixture class.
 > *   *`key`* must be a valid XML attribute name, and cannot conflict with the
->     ones already used by googletest (`name`, `status`, `time`, `classname`,
+>     ones already used by GoogleTest (`name`, `status`, `time`, `classname`,
 >     `type_param`, and `value_param`).
 > *   Calling `RecordProperty()` outside of the lifespan of a test is allowed.
 >     If it's called outside of a test but between a test suite's
@ -863,25 +894,25 @@ will output XML like this:
 ## Sharing Resources Between Tests in the Same Test Suite
-googletest creates a new test fixture object for each test in order to make
+GoogleTest creates a new test fixture object for each test in order to make
 tests independent and easier to debug. However, sometimes tests use resources
 that are expensive to set up, making the one-copy-per-test model prohibitively
 expensive.
 If the tests don't change the resource, there's no harm in their sharing a
-single resource copy. So, in addition to per-test set-up/tear-down, googletest
+single resource copy. So, in addition to per-test set-up/tear-down, GoogleTest
 also supports per-test-suite set-up/tear-down. To use it:
 1.  In your test fixture class (say `FooTest` ), declare as `static` some member
    variables to hold the shared resources.
 2.  Outside your test fixture class (typically just below it), define those
    member variables, optionally giving them initial values.
-3.  In the same test fixture class, define a `static void SetUpTestSuite()`
+3.  In the same test fixture class, define a public member function `static void
-    function (remember not to spell it as **`SetupTestSuite`** with a small
+    SetUpTestSuite()` (remember not to spell it as **`SetupTestSuite`** with a
-    `u`!) to set up the shared resources and a `static void TearDownTestSuite()`
+    small `u`!) to set up the shared resources and a `static void
-    function to tear them down.
+    TearDownTestSuite()` function to tear them down.
-That's it! googletest automatically calls `SetUpTestSuite()` before running the
+That's it! GoogleTest automatically calls `SetUpTestSuite()` before running the
 *first test* in the `FooTest` test suite (i.e. before creating the first
 `FooTest` object), and calls `TearDownTestSuite()` after running the *last test*
 in it (i.e. after deleting the last `FooTest` object). In between, the tests can
@ -974,24 +1005,34 @@ class Environment : public ::testing::Environment {
 };
 ```
-Then, you register an instance of your environment class with googletest by
+Then, you register an instance of your environment class with GoogleTest by
 calling the `::testing::AddGlobalTestEnvironment()` function:
 ```c++
 Environment* AddGlobalTestEnvironment(Environment* env);
 ```
-Now, when `RUN_ALL_TESTS()` is called, it first calls the `SetUp()` method of
+Now, when `RUN_ALL_TESTS()` is invoked, it first calls the `SetUp()` method. The
-each environment object, then runs the tests if none of the environments
+tests are then executed, provided that none of the environments have reported
-reported fatal failures and `GTEST_SKIP()` was not called. `RUN_ALL_TESTS()`
+fatal failures and `GTEST_SKIP()` has not been invoked. Finally, `TearDown()` is
-always calls `TearDown()` with each environment object, regardless of whether or
+called.
-not the tests were run.
+
 Note that `SetUp()` and `TearDown()` are only invoked if there is at least one
 test to be performed. Importantly, `TearDown()` is executed even if the test is
 not run due to a fatal failure or `GTEST_SKIP()`.
 Calling `SetUp()` and `TearDown()` for each iteration depends on the flag
 `gtest_recreate_environments_when_repeating`. `SetUp()` and `TearDown()` are
 called for each environment object when the object is recreated for each
 iteration. However, if test environments are not recreated for each iteration,
 `SetUp()` is called only on the first iteration, and `TearDown()` is called only
 on the last iteration.
 It's OK to register multiple environment objects. In this suite, their `SetUp()`
 will be called in the order they are registered, and their `TearDown()` will be
 called in the reverse order.
-Note that googletest takes ownership of the registered environment objects.
+Note that GoogleTest takes ownership of the registered environment objects.
 Therefore **do not delete them** by yourself.
 You should call `AddGlobalTestEnvironment()` before `RUN_ALL_TESTS()` is called,
@ -1043,7 +1084,7 @@ they must be declared **public** rather than **protected** in order to use
 ```c++
 class FooTest :
-    public testing::TestWithParam<const char*> {
+    public testing::TestWithParam<absl::string_view> {
  // You can implement all the usual fixture class members here.
  // To access the test parameter, call GetParam() from class
  // TestWithParam<T>.
@ -1054,7 +1095,7 @@ class BaseTest : public testing::Test {
  ...
 };
 class BarTest : public BaseTest,
-                public testing::WithParamInterface<const char*> {
+                public testing::WithParamInterface<absl::string_view> {
  ...
 };
 ```
@ -1125,8 +1166,8 @@ with parameter values `"cat"` and `"dog"` using the
 [`ValuesIn`](reference/testing.md#param-generators) parameter generator:
 ```c++
-const char* pets[] = {"cat", "dog"};
+constexpr absl::string_view kPets[] = {"cat", "dog"};
-INSTANTIATE_TEST_SUITE_P(Pets, FooTest, testing::ValuesIn(pets));
+INSTANTIATE_TEST_SUITE_P(Pets, FooTest, testing::ValuesIn(kPets));
 ```
 The tests from the instantiation above will have these names:
@ -1409,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
+    are only visible within the same translation unit. To test them, move the
-    `#include` the entire `.cc` file being tested in your `*_test.cc` file.
+    private code into the `foo::internal` namespace, where `foo` is the
-    (#including `.cc` files is not a good way to reuse code - you should not do
+    namespace your project normally uses, and put the private declarations in a
-    this in production code!)
+    `*-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.
-    However, a better approach is to move the private code into the
+{: .callout .note}
-    `foo::internal` namespace, where `foo` is the namespace your project
+NOTE: It is also technically *possible* to `#include` the entire `.cc` file
-    normally uses, and put the private declarations in a `*-internal.h` file.
+being tested in your `*_test.cc` file to test static functions and
-    Your production `.cc` files and your tests are allowed to include this
+definitions/declarations in an unnamed namespace. However, this technique is
-    internal header, but your clients are not. This way, you can fully test your
+**not recommended** by this documentation and it is only presented here for the
-    internal implementation without leaking it to your clients.
+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
@ -1432,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
+    clients aren't allowed to include this header but your tests can.
    called the
    [Pimpl](https://www.gamedev.net/articles/programming/general-and-gameplay-programming/the-c-pimpl-r1794/)
    (Private Implementation) idiom.
    Or, you can declare an individual test as a friend of your class by adding
    this line in the class body:
@ -1501,12 +1541,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
+If you are building a testing utility on top of GoogleTest, you'll want to test
-your utility. What framework would you use to test it? googletest, of course.
+your utility. What framework would you use to test it? GoogleTest, of course.
 The challenge is to verify that your testing utility reports failures correctly.
 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.
@ -1649,9 +1689,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
@ -1712,7 +1752,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()`:
@ -1723,7 +1763,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();
 }
@ -1775,13 +1815,13 @@ 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()`.
 To see a list of supported flags and their usage, please run your test program
-with the `--help` flag. You can also use `-h`, `-?`, or `/?` for short.
+with the `--help` flag.
 If an option is specified both by an environment variable and by a flag, the
 latter takes precedence.
@ -1808,10 +1848,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
@ -1842,7 +1882,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,
@ -1859,7 +1899,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++
@ -1874,7 +1914,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}
@ -1890,6 +1930,35 @@ the `--gtest_also_run_disabled_tests` flag or set the
 You can combine this with the `--gtest_filter` flag to further select which
 disabled tests to run.
 ### Enforcing Having At Least One Test Case
 A not uncommon programmer mistake is to write a test program that has no test
 case linked in. This can happen, for example, when you put test case definitions
 in a library and the library is not marked as "always link".
 To catch such mistakes, run the test program with the
 `--gtest_fail_if_no_test_linked` flag or set the `GTEST_FAIL_IF_NO_TEST_LINKED`
 environment variable to a value other than `0`. Now the program will fail if no
 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
@ -1932,16 +2001,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
@ -2000,7 +2069,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:
 <pre>...
@ -2025,25 +2094,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
@ -2052,7 +2121,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.
@ -2063,15 +2132,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
 <testsuites name="AllTests" ...>
@ -2086,8 +2155,8 @@ apply to googletest tests, as shown here:
 ```
 *   The root `<testsuites>` element corresponds to the entire test program.
-*   `<testsuite>` elements correspond to googletest test suites.
+*   `<testsuite>` elements correspond to GoogleTest test suites.
-*   `<testcase>` elements correspond to googletest test functions.
+*   `<testcase>` elements correspond to GoogleTest test functions.
 For instance, the following program
@ -2120,7 +2189,7 @@ could generate this report:
 Things to note:
 *   The `tests` attribute of a `<testsuites>` or `<testsuite>` element tells how
-    many test functions the googletest program or test suite contains, while the
+    many test functions the GoogleTest program or test suite contains, while the
    `failures` attribute tells how many of them failed.
 *   The `time` attribute expresses the duration of the test, test suite, or
@ -2132,12 +2201,12 @@ Things to note:
 *   The `file` and `line` attributes record the source file location, where the
    test was defined.
-*   Each `<failure>` element corresponds to a single failed googletest
+*   Each `<failure>` 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
@ -2148,7 +2217,7 @@ The report format conforms to the following JSON Schema:
 ```json
 {
-  "$schema": "http://json-schema.org/schema#",
+  "$schema": "https://json-schema.org/schema#",
  "type": "object",
  "definitions": {
    "TestCase": {
@ -2349,7 +2418,7 @@ IMPORTANT: The exact format of the JSON document is subject to change.
 #### Detecting Test Premature Exit
-Google Test implements the _premature-exit-file_ protocol for test runners to
+Google Test implements the *premature-exit-file* protocol for test runners to
 catch any kind of unexpected exits of test programs. Upon start, Google Test
 creates the file which will be automatically deleted after all work has been
 finished. Then, the test runner can check if this file exists. In case the file
@ -2362,7 +2431,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`
@ -2370,9 +2439,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.
@ -2410,4 +2479,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.
--- a/test/googletest/docs/faq.md
+++ b/test/googletest/docs/faq.md
@ -3,7 +3,7 @@
 ## Why should test suite names and test names not contain underscore?
 {: .callout .note}
-Note: GoogleTest reserves underscore (`_`) for special purpose keywords, such as
+Note: GoogleTest reserves underscore (`_`) for special-purpose keywords, such as
 [the `DISABLED_` prefix](advanced.md#temporarily-disabling-tests), in addition
 to the following rationale.
@ -33,9 +33,9 @@ contains `_`?
    `TestSuiteName_Bar__Test`, which is invalid.
 So clearly `TestSuiteName` and `TestName` cannot start or end with `_`
-(Actually, `TestSuiteName` can start with `_` -- as long as the `_` isn't
+(Actually, `TestSuiteName` can start with `_`—as long as the `_` isn't followed
-followed by an upper-case letter. But that's getting complicated. So for
+by an upper-case letter. But that's getting complicated. So for simplicity we
-simplicity we just say that it cannot start with `_`.).
+just say that it cannot start with `_`.).
 It may seem fine for `TestSuiteName` and `TestName` to contain `_` in the
 middle. However, consider this:
@ -128,30 +128,9 @@ both approaches a try. Practice is a much better way to grasp the subtle
 differences between the two tools. Once you have some concrete experience, you
 can much more easily decide which one to use the next time.
 ## I got some run-time errors about invalid proto descriptors when using `ProtocolMessageEquals`. Help!
 {: .callout .note}
 **Note:** `ProtocolMessageEquals` and `ProtocolMessageEquiv` are *deprecated*
 now. Please use `EqualsProto`, etc instead.
 `ProtocolMessageEquals` and `ProtocolMessageEquiv` were redefined recently and
 are now less tolerant of invalid protocol buffer definitions. In particular, if
 you have a `foo.proto` that doesn't fully qualify the type of a protocol message
 it references (e.g. `message<Bar>` where it should be `message<blah.Bar>`), you
 will now get run-time errors like:
 ```
 ... descriptor.cc:...] Invalid proto descriptor for file "path/to/foo.proto":
 ... descriptor.cc:...]  blah.MyMessage.my_field: ".Bar" is not defined.
 ```
 If you see this, your `.proto` file is broken and needs to be fixed by making
 the types fully qualified. The new definition of `ProtocolMessageEquals` and
 `ProtocolMessageEquiv` just happen to reveal your bug.
 ## My death test modifies some state, but the change seems lost after the death test finishes. Why?
-Death tests (`EXPECT_DEATH`, etc) are executed in a sub-process s.t. the
+Death tests (`EXPECT_DEATH`, etc.) are executed in a sub-process s.t. the
 expected crash won't kill the test program (i.e. the parent process). As a
 result, any in-memory side effects they incur are observable in their respective
 sub-processes, but not in the parent process. You can think of them as running
@ -192,16 +171,16 @@ class Foo {
 };
 ```
-You also need to define it *outside* of the class body in `foo.cc`:
+you also need to define it *outside* of the class body in `foo.cc`:
 ```c++
 const int Foo::kBar;  // No initializer here.
 ```
 Otherwise your code is **invalid C++**, and may break in unexpected ways. In
-particular, using it in GoogleTest comparison assertions (`EXPECT_EQ`, etc) will
+particular, using it in GoogleTest comparison assertions (`EXPECT_EQ`, etc.)
-generate an "undefined reference" linker error. The fact that "it used to work"
+will generate an "undefined reference" linker error. The fact that "it used to
-doesn't mean it's valid. It just means that you were lucky. :-)
+work" doesn't mean it's valid. It just means that you were lucky. :-)
 If the declaration of the static data member is `constexpr` then it is
 implicitly an `inline` definition, and a separate definition in `foo.cc` is not
@ -311,7 +290,7 @@ a **fresh** test fixture object, immediately call `SetUp()`, run the test body,
 call `TearDown()`, and then delete the test fixture object.
 When you need to write per-test set-up and tear-down logic, you have the choice
-between using the test fixture constructor/destructor or `SetUp()/TearDown()`.
+between using the test fixture constructor/destructor or `SetUp()`/`TearDown()`.
 The former is usually preferred, as it has the following benefits:
 *   By initializing a member variable in the constructor, we have the option to
@ -352,7 +331,7 @@ You may still want to use `SetUp()/TearDown()` in the following cases:
    GoogleTest assertions in a destructor if your code could run on such a
    platform.
-## The compiler complains "no matching function to call" when I use ASSERT_PRED*. How do I fix it?
+## The compiler complains "no matching function to call" when I use `ASSERT_PRED*`. How do I fix it?
 See details for [`EXPECT_PRED*`](reference/assertions.md#EXPECT_PRED) in the
 Assertions Reference.
@ -410,7 +389,7 @@ C++ is case-sensitive. Did you spell it as `Setup()`?
 Similarly, sometimes people spell `SetUpTestSuite()` as `SetupTestSuite()` and
 wonder why it's never called.
-## I have several test suites which share the same test fixture logic, do I have to define a new test fixture class for each of them? This seems pretty tedious.
+## I have several test suites which share the same test fixture logic; do I have to define a new test fixture class for each of them? This seems pretty tedious.
 You don't have to. Instead of
@ -532,20 +511,7 @@ However, there are cases where you have to define your own:
    list of the constructor. (Early versions of `gcc` doesn't force you to
    initialize the const member. It's a bug that has been fixed in `gcc 4`.)
-## Why does ASSERT_DEATH complain about previous threads that were already joined?
+## Why does GoogleTest require the entire test suite, instead of individual tests, to be named `*DeathTest` when it uses `ASSERT_DEATH`?
 With the Linux pthread library, there is no turning back once you cross the line
 from a single thread to multiple threads. The first time you create a thread, a
 manager thread is created in addition, so you get 3, not 2, threads. Later when
 the thread you create joins the main thread, the thread count decrements by 1,
 but the manager thread will never be killed, so you still have 2 threads, which
 means you cannot safely run a death test.
 The new NPTL thread library doesn't suffer from this problem, as it doesn't
 create a manager thread. However, if you don't control which machine your test
 runs on, you shouldn't depend on this.
 ## Why does GoogleTest require the entire test suite, instead of individual tests, to be named *DeathTest when it uses ASSERT_DEATH?
 GoogleTest does not interleave tests from different test suites. That is, it
 runs all tests in one test suite first, and then runs all tests in the next test
@ -570,7 +536,7 @@ interleave tests from different test suites, we need to run all tests in the
 `FooTest` case before running any test in the `BarTest` case. This contradicts
 with the requirement to run `BarTest.DefDeathTest` before `FooTest.Uvw`.
-## But I don't like calling my entire test suite \*DeathTest when it contains both death tests and non-death tests. What do I do?
+## But I don't like calling my entire test suite `*DeathTest` when it contains both death tests and non-death tests. What do I do?
 You don't have to, but if you like, you may split up the test suite into
 `FooTest` and `FooDeathTest`, where the names make it clear that they are
@ -607,7 +573,7 @@ defined such that we can print a value of `FooType`.
 In addition, if `FooType` is declared in a name space, the `<<` operator also
 needs to be defined in the *same* name space. See
-[Tip of the Week #49](http://abseil.io/tips/49) for details.
+[Tip of the Week #49](https://abseil.io/tips/49) for details.
 ## How do I suppress the memory leak messages on Windows?
@ -628,10 +594,10 @@ mistake in production. Such cleverness also leads to
 advise against the practice, and GoogleTest doesn't provide a way to do it.
 In general, the recommended way to cause the code to behave differently under
-test is [Dependency Injection](http://en.wikipedia.org/wiki/Dependency_injection). You can inject
+test is [Dependency Injection](https://en.wikipedia.org/wiki/Dependency_injection). You can inject
 different functionality from the test and from the production code. Since your
 production code doesn't link in the for-test logic at all (the
-[`testonly`](http://docs.bazel.build/versions/master/be/common-definitions.html#common.testonly) attribute for BUILD targets helps to ensure
+[`testonly`](https://docs.bazel.build/versions/master/be/common-definitions.html#common.testonly) attribute for BUILD targets helps to ensure
 that), there is no danger in accidentally running it.
 However, if you *really*, *really*, *really* have no choice, and if you follow
@ -654,7 +620,7 @@ the `--gtest_also_run_disabled_tests` flag.
 Yes.
 The rule is **all test methods in the same test suite must use the same fixture
-class.** This means that the following is **allowed** because both tests use the
+class**. This means that the following is **allowed** because both tests use the
 same fixture class (`::testing::Test`).
 ```c++
--- a/test/googletest/docs/gmock_cheat_sheet.md
+++ b/test/googletest/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 <gmock/gmock.h>
 class MockFoo : public Foo {
 public:
@ -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<Buzz>,
-  // to avoid interfere with other tests.
+  // to avoid interfering with other tests.
  DefaultValue<std::unique_ptr<Buzz>>::Clear();
 ```
--- a/test/googletest/docs/gmock_cook_book.md
+++ b/test/googletest/docs/gmock_cook_book.md
@ -177,7 +177,7 @@ class StackInterface {
 template <typename Elem>
 class MockStack : public StackInterface<Elem> {
  ...
-  MOCK_METHOD(int, GetSize, (), (override));
+  MOCK_METHOD(int, GetSize, (), (const, override));
  MOCK_METHOD(void, Push, (const Elem& x), (override));
 };
 ```
@ -697,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);
 }
 ```
@ -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
+provide meaningful information, it can be easier to express them with template
-generic lambdas to avoid specifying types. For example,
+parameters and `auto`. For example,
 ```cpp
 using ::testing::Contains;
 using ::testing::Property;
-inline constexpr auto HasFoo = [](const auto& f) {
+template <typename SubMatcher>
-  return Property("foo", &MyClass::foo, Contains(f));
+inline constexpr auto HasFoo(const SubMatcher& sub_matcher) {
  return Property("foo", &MyClass::foo, Contains(sub_matcher));
 };
 ...
  EXPECT_THAT(x, HasFoo("blah"));
@ -936,8 +937,8 @@ casts a matcher `m` to type `Matcher<T>`. To ensure safety, gMock checks that
    floating-point numbers), the conversion from `T` to `U` is not lossy (in
    other words, any value representable by `T` can also be represented by `U`);
    and
-3.  When `U` is a reference, `T` must also be a reference (as the underlying
+3.  When `U` is a non-const reference, `T` must also be a reference (as the
-    matcher may be interested in the address of the `U` value).
+    underlying matcher may be interested in the address of the `U` value).
 The code won't compile if any of these conditions isn't met.
@ -1129,11 +1130,11 @@ using STL's `<functional>` 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::AllOf;
-using testing::Ge;
+using ::testing::Ge;
-using testing::Le;
+using ::testing::Le;
-using testing::Matches;
+using ::testing::Matches;
-using testing::Ne;
+using ::testing::Ne;
 ...
 Matches(AllOf(Ge(0), Le(100), Ne(50)))
 ```
@ -1861,7 +1862,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:
@ -1873,7 +1874,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:
@ -1895,14 +1896,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
@ -1927,6 +1928,12 @@ class MockFoo : public Foo {
                      action_n));
 ```
 The return value of the last action **must** match the return type of the mocked
 method. In the example above, `action_n` could be `Return(true)`, or a lambda
 that returns a `bool`, but not `SaveArg`, which returns `void`. Otherwise the
 signature of `DoAll` would not match the signature expected by `WillOnce`, which
 is the signature of the mocked method, and it wouldn't compile.
 ### Verifying Complex Arguments {#SaveArgVerify}
 If you want to verify that a method is called with a particular argument but the
@ -2264,7 +2271,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).
 }
 ```
@ -2640,8 +2647,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
+  foo.DoThat();  // Returns 1 - DoThat() uses a different
-                 // counter than Bar()'s.
+                 // counter than DoThis()'s.
 ```
 versus
@ -2771,36 +2778,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
+If you just need to return a move-only value, you can use it in combination with
-`Return(ByMove(...))` action:
+`WillOnce`. For example:
 ```cpp
-  // When this fires, the unique_ptr<> specified by ByMove(...) will
+  EXPECT_CALL(mock_buzzer_, MakeBuzz("hello"))
-  // be returned.
+      .WillOnce(Return(std::make_unique<Buzz>(AccessLevel::kInternal)));
-  EXPECT_CALL(mock_buzzer_, MakeBuzz("world"))
+  EXPECT_NE(nullptr, mock_buzzer_.MakeBuzz("hello"));
      .WillOnce(Return(ByMove(std::make_unique<Buzz>(AccessLevel::kInternal))));
  EXPECT_NE(nullptr, mock_buzzer_.MakeBuzz("world"));
 ```
-Note that `ByMove()` is essential here - if you drop it, the code won’t compile.
+Quiz time! What do you think will happen if a `Return` action is performed more
-
+than once (e.g. you write `... .WillRepeatedly(Return(std::move(...)));`)? Come
-Quiz time! What do you think will happen if a `Return(ByMove(...))` action is
+think of it, after the first time the action runs, the source value will be
-performed more than once (e.g. you write `...
+consumed (since it’s a move-only value), so the next time around, there’s no
-.WillRepeatedly(Return(ByMove(...)));`)? Come think of it, after the first time
+value to move from -- you’ll get a run-time error that `Return(std::move(...))`
-the action runs, the source value will be consumed (since it’s a move-only
+can only be run once.
 value), so the next time around, there’s no value to move from -- you’ll get a
 run-time error that `Return(ByMove(...))` can only be run once.
 If you need your mock method to do more than just moving a pre-defined value,
 remember that you can always use a lambda or a callable object, which can do
@ -2817,7 +2821,7 @@ pretty much anything you want:
 ```
 Every time this `EXPECT_CALL` fires, a new `unique_ptr<Buzz>` will be created
-and returned. You cannot do this with `Return(ByMove(...))`.
+and returned. You cannot do this with `Return(std::make_unique<...>(...))`.
 That covers returning move-only values; but how do we work with methods
 accepting move-only arguments? The answer is that they work normally, although
@ -3197,11 +3201,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 <gmock/gmock.h>
-using testing::_;
+using ::testing::_;
-using testing::HasSubstr;
+using ::testing::HasSubstr;
-using testing::Return;
+using ::testing::Return;
 class MockFoo {
 public:
@ -3309,7 +3313,7 @@ For convenience, we allow the description string to be empty (`""`), in which
 case gMock will use the sequence of words in the matcher name as the
 description.
-For example:
+#### Basic Example
 ```cpp
 MATCHER(IsDivisibleBy7, "") { return (arg % 7) == 0; }
@ -3347,6 +3351,8 @@ If the above assertions fail, they will print something like:
 where the descriptions `"is divisible by 7"` and `"not (is divisible by 7)"` are
 automatically calculated from the matcher name `IsDivisibleBy7`.
 #### Adding Custom Failure Messages
 As you may have noticed, the auto-generated descriptions (especially those for
 the negation) may not be so great. You can always override them with a `string`
 expression of your own:
@ -3380,21 +3386,84 @@ With this definition, the above assertion will give a better message:
    Actual: 27 (the remainder is 6)
 ```
 #### `MatchAndExplain`
 You should let `MatchAndExplain()` print *any additional information* that can
 help a user understand the match result. Note that it should explain why the
 match succeeds in case of a success (unless it's obvious) - this is useful when
 the matcher is used inside `Not()`. There is no need to print the argument value
 itself, as gMock already prints it for you.
-{: .callout .note}
+#### Argument Types
-NOTE: The type of the value being matched (`arg_type`) is determined by the
+
-context in which you use the matcher and is supplied to you by the compiler, so
+The type of the value being matched (`arg_type`) is determined by the context in
-you don't need to worry about declaring it (nor can you). This allows the
+which you use the matcher and is supplied to you by the compiler, so you don't
-matcher to be polymorphic. For example, `IsDivisibleBy7()` can be used to match
+need to worry about declaring it (nor can you). This allows the matcher to be
-any type where the value of `(arg % 7) == 0` can be implicitly converted to a
+polymorphic. For example, `IsDivisibleBy7()` can be used to match any type where
-`bool`. In the `Bar(IsDivisibleBy7())` example above, if method `Bar()` takes an
+the value of `(arg % 7) == 0` can be implicitly converted to a `bool`. In the
-`int`, `arg_type` will be `int`; if it takes an `unsigned long`, `arg_type` will
+`Bar(IsDivisibleBy7())` example above, if method `Bar()` takes an `int`,
-be `unsigned long`; and so on.
+`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
@ -3533,12 +3602,17 @@ 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 argument type `T` implements the matcher interface for `T` and does
+A matcher of type `testing::Matcher<T>` implements the matcher interface for `T`
-two things: it tests whether a value of type `T` matches the matcher, and can
+and does two things: it tests whether a value of type `T` matches the matcher,
-describe what kind of values it matches. The latter ability is used for
+and can describe what kind of values it matches. The latter ability is used for
-generating readable error messages when expectations are violated.
+generating readable error messages when expectations are violated. Some matchers
 can even explain why it matches or doesn't match a certain value, which can be
 helpful when the reason isn't obvious.
 Because a matcher of type `testing::Matcher<T>` for a particular type `T` can
 only be used to match a value of type `T`, we call it "monomorphic."
 A matcher of `T` must declare a typedef like:
@ -3553,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);
@ -3628,10 +3702,18 @@ 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}
-Expanding what we learned above to *polymorphic* matchers is now just as simple
+Unlike a monomorphic matcher, which can only be used to match a value of a
-as adding templates in the right place.
+particular type, a *polymorphic* matcher is one that can be used to match values
 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<SomeType>` - itself is not an actual matcher, but can be
 implicitly converted to a `testing::Matcher<SomeType>` depending on the context.
 Expanding what we learned above to polymorphic matchers is now as simple as
 adding templates in the right place.
 ```cpp
@ -3757,6 +3839,26 @@ virtual.
 Like in a monomorphic matcher, you may explain the match result by streaming
 additional information to the `listener` argument in `MatchAndExplain()`.
 ### Implementing Composite Matchers {#CompositeMatchers}
 Sometimes we want to define a matcher that takes other matchers as parameters.
 For example, `DistanceFrom(target, m)` is a polymorphic matcher that takes a
 matcher `m` as a parameter. It tests that the distance from `target` to the
 value being matched satisfies sub-matcher `m`.
 If you are implementing such a composite matcher, you'll need to generate the
 description of the matcher based on the description(s) of its sub-matcher(s).
 You can see the implementation of `DistanceFrom()` in
 `googlemock/include/gmock/gmock-matchers.h` for an example. In particular, pay
 attention to `DistanceFromMatcherImpl`. Notice that it stores the sub-matcher as
 a `const Matcher<const Distance&> distance_matcher_` instead of a polymorphic
 matcher - this allows it to call `distance_matcher_.DescribeTo(os)` to describe
 the sub-matcher. If the sub-matcher is stored as a polymorphic matcher instead,
 it would not be possible to get its description as in general polymorphic
 matchers don't know how to describe themselves - they are matcher factories
 instead of actual matchers; only after being converted to `Matcher<SomeType>`
 can they be described.
 ### Writing New Cardinalities
 A cardinality is used in `Times()` to tell gMock how many times you expect a
@ -3822,15 +3924,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<int(int)> 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 <typename T>
  T operator()(T arg) { return arg * multiplier; }
@ -3845,16 +3947,16 @@ struct MultiplyBy {
 It's also fine for the callable to take no arguments, ignoring the arguments
 supplied to the mock function:
-```
+```cpp
 MockFunction<int(int)> 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
@ -4298,7 +4400,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.
--- a/test/googletest/docs/gmock_for_dummies.md
+++ b/test/googletest/docs/gmock_for_dummies.md
@ -90,14 +90,14 @@ gMock is bundled with googletest.
 ## A Case for Mock Turtles
 Let's look at an example. Suppose you are developing a graphics program that
-relies on a [LOGO](http://en.wikipedia.org/wiki/Logo_programming_language)-like
+relies on a [LOGO](https://en.wikipedia.org/wiki/Logo_programming_language)-like
 API for drawing. How would you test that it does the right thing? Well, you can
 run it and compare the screen with a golden screen snapshot, but let's admit it:
 tests like this are expensive to run and fragile (What if you just upgraded to a
 shiny new graphics card that has better anti-aliasing? Suddenly you have to
 update all your golden images.). It would be too painful if all your tests are
 like this. Fortunately, you learned about
-[Dependency Injection](http://en.wikipedia.org/wiki/Dependency_injection) and know the right thing
+[Dependency Injection](https://en.wikipedia.org/wiki/Dependency_injection) and know the right thing
 to do: instead of having your application talk to the system API directly, wrap
 the API in an interface (say, `Turtle`) and code to that interface:
@ -164,7 +164,7 @@ follow:
 After the process, you should have something like:
 ```cpp
-#include "gmock/gmock.h"  // Brings in gMock.
+#include <gmock/gmock.h>  // 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 <gmock/gmock.h>
-#include "gtest/gtest.h"
+#include <gtest/gtest.h>
 using ::testing::AtLeast;                         // #1
@ -261,6 +261,8 @@ happen. Therefore it's a good idea to turn on the heap checker in your tests
 when you allocate mocks on the heap. You get that automatically if you use the
 `gtest_main` library already.
 ###### Expectation Ordering
 **Important note:** gMock requires expectations to be set **before** the mock
 functions are called, otherwise the behavior is **undefined**. Do not alternate
 between calls to `EXPECT_CALL()` and calls to the mock functions, and do not set
--- a/test/googletest/docs/pkgconfig.md
+++ b/test/googletest/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)
+add_executable(testapp)
-target_link_libraries(testapp ${GTEST_LDFLAGS})
+target_sources(testapp PRIVATE samples/sample3_unittest.cc)
-target_compile_options(testapp PUBLIC ${GTEST_CFLAGS})
+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)
 ```
--- a/test/googletest/docs/platforms.md
+++ b/test/googletest/docs/platforms.md
@ -1,35 +1,8 @@
 # Supported Platforms
-GoogleTest requires a codebase and compiler compliant with the C++11 standard or
+GoogleTest follows Google's
-newer.
+[Foundational C++ Support Policy](https://opensource.google/documentation/policies/cplusplus-support).
-
+See
-The GoogleTest code is officially supported on the following platforms.
+[this table](https://github.com/google/oss-policies-info/blob/main/foundational-cxx-support-matrix.md)
-Operating systems or tools not listed below are community-supported. For
+for a list of currently supported versions compilers, platforms, and build
-community-supported platforms, patches that do not complicate the code may be
+tools.
 considered.
 If you notice any problems on your platform, please file an issue on the
 [GoogleTest GitHub Issue Tracker](https://github.com/google/googletest/issues).
 Pull requests containing fixes are welcome!
 ### Operating systems
 *   Linux
 *   macOS
 *   Windows
 ### Compilers
 *   gcc 5.0+
 *   clang 5.0+
 *   MSVC 2015+
 **macOS users:** Xcode 9.3+ provides clang 5.0+.
 ### Build systems
 *   [Bazel](https://bazel.build/)
 *   [CMake](https://cmake.org/)
 Bazel is the build system used by the team internally and in tests. CMake is
 supported on a best-effort basis and by the community.
--- a/test/googletest/docs/primer.md
+++ b/test/googletest/docs/primer.md
@ -1,84 +1,84 @@
-# 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
+*Note:* There might be some confusion arising from different definitions of the
-terms _Test_, _Test Case_ and _Test Suite_, so beware of misunderstanding these.
+terms *Test*, *Test Case* and *Test Suite*, so beware of misunderstanding these.
-Historically, googletest started to use the term _Test Case_ for grouping
+Historically, GoogleTest started to use the term *Test Case* for grouping
 related tests, whereas current publications, including International Software
-Testing Qualifications Board ([ISTQB](http://www.istqb.org/)) materials and
+Testing Qualifications Board ([ISTQB](https://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
+The related term *Test*, as it is used in GoogleTest, corresponds to the term
-_[Test Case][istqb test case]_ of ISTQB and others.
+*[Test Case][istqb test case]* of ISTQB and others.
-The term _Test_ is commonly of broad enough sense, including ISTQB's definition
+The term *Test* is commonly of broad enough sense, including ISTQB's definition
-of _Test Case_, so it's not much of a problem here. But the term _Test Case_ as
+of *Test Case*, so it's not much of a problem here. But the term *Test Case* as
 was used in Google Test is of contradictory sense and thus confusing.
-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](https://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]
-[istqb test case]: http://glossary.istqb.org/en/search/test%20case
+[istqb test case]: https://glossary.istqb.org/en_US/term/test-case
-[istqb test suite]: http://glossary.istqb.org/en/search/test%20suite
+[istqb test suite]: https://glossary.istqb.org/en_US/term/test-suite
 ## 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
@ -210,7 +210,7 @@ objects for several different tests.
 To create a fixture:
-1.  Derive a class from `::testing::Test` . Start its body with `protected:`, as
+1.  Derive a class from `testing::Test` . Start its body with `protected:`, as
    we'll want to access fixture members from sub-classes.
 2.  Inside the class, declare any objects you plan to use.
 3.  If necessary, write a default constructor or `SetUp()` function to prepare
@ -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()`
+Unlike `TEST()`, in `TEST_F()` the first argument must be the name of the test
-this must be the name of the test fixture class. You've probably guessed: `_F`
+fixture class. (`_F` stands for "Fixture"). No test suite name is specified for
-is for fixture.
+this macro.
 Unfortunately, the C++ macro system does not allow us to create a single macro
 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 always deletes a test fixture before it creates the next one.
-googletest does **not** reuse the same test fixture for multiple tests. Any
+GoogleTest does **not** reuse the same test fixture for multiple tests. Any
 changes one test makes to the fixture do not affect other tests.
 As an example, let's write tests for a FIFO queue class named `Queue`, which has
@ -271,16 +271,16 @@ First, define a fixture class. By convention, you should give it the name
 `FooTest` where `Foo` is the class being tested.
 ```c++
-class QueueTest : public ::testing::Test {
+class QueueTest : public testing::Test {
 protected:
-  void SetUp() override {
+  QueueTest() {
     // q0_ remains empty
     q1_.Enqueue(1);
     q2_.Enqueue(2);
     q2_.Enqueue(3);
  }
-  // void TearDown() override {}
+  // ~QueueTest() override = default;
  Queue<int> q0_;
  Queue<int> q1_;
@ -288,8 +288,9 @@ class QueueTest : public ::testing::Test {
 };
 ```
-In this case, `TearDown()` is not needed since we don't have to clean up after
+In this case, we don't need to define a destructor or a `TearDown()` method,
-each test, other than what's already done by the destructor.
+because the implicit destructor generated by the compiler will perform all of
 the necessary cleanup.
 Now we'll write tests using `TEST_F()` and this fixture.
@ -325,19 +326,17 @@ 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`.
+2.  The first test (`IsEmptyInitially`) runs on `t1`.
-3.  The first test (`IsEmptyInitially`) runs on `t1`.
+3.  `t1` is destructed.
-4.  `t1.TearDown()` cleans up after the test finishes.
+4.  The above steps are repeated on another `QueueTest` object, this time
 5.  `t1` is destructed.
 6.  The above steps are repeated on another `QueueTest` object, this time
    running the `DequeueWorks` test.
 **Availability**: Linux, Windows, Mac.
 ## 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 +347,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 +359,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 +373,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,14 +394,14 @@ You can start from this boilerplate:
 ```c++
 #include "this/package/foo.h"
-#include "gtest/gtest.h"
+#include <gtest/gtest.h>
 namespace my {
 namespace project {
 namespace {
 // The fixture for testing class Foo.
-class FooTest : public ::testing::Test {
+class FooTest : public testing::Test {
 protected:
  // You can remove any or all of the following functions if their bodies would
  // be empty.
@ -450,14 +449,14 @@ TEST_F(FooTest, DoesXyz) {
 }  // namespace my
 int main(int argc, char **argv) {
-  ::testing::InitGoogleTest(&argc, argv);
+  testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
 }
 ```
-The `::testing::InitGoogleTest()` function parses the command line for
+The `testing::InitGoogleTest()` function parses the command line for GoogleTest
-googletest flags, and removes all recognized flags. This allows the user to
+flags, and removes all recognized flags. This allows the user to control a test
-control a test program's behavior via various flags, which we'll cover in the
+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 +475,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
--- a/test/googletest/docs/quickstart-bazel.md
+++ b/test/googletest/docs/quickstart-bazel.md
@ -9,9 +9,9 @@ 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/), the preferred build system used by the
+*   [Bazel](https://bazel.build/) 7.0 or higher, the preferred build system used
-    GoogleTest team.
+    by the GoogleTest team.
 See [Supported Platforms](platforms.md) for more information about platforms
 compatible with GoogleTest.
@ -28,7 +28,7 @@ A
 [Bazel workspace](https://docs.bazel.build/versions/main/build-ref.html#workspace)
 is a directory on your filesystem that you use to manage source files for the
 software you want to build. Each workspace directory has a text file named
-`WORKSPACE` which may be empty, or may contain references to external
+`MODULE.bazel` which may be empty, or may contain references to external
 dependencies required to build the outputs.
 First, create a directory for your workspace:
@ -37,30 +37,20 @@ First, create a directory for your workspace:
 $ mkdir my_workspace && cd my_workspace
 ```
-Next, you’ll create the `WORKSPACE` file to specify dependencies. A common and
+Next, you’ll create the `MODULE.bazel` file to specify dependencies. As of Bazel
-recommended way to depend on GoogleTest is to use a
+7.0, the recommended way to consume GoogleTest is through the
-[Bazel external dependency](https://docs.bazel.build/versions/main/external.html)
+[Bazel Central Registry](https://registry.bazel.build/modules/googletest). To do
-via the
+this, create a `MODULE.bazel` file in the root directory of your Bazel workspace
-[`http_archive` rule](https://docs.bazel.build/versions/main/repo/http.html#http_archive).
+with the following content:
 To do this, in the root directory of your workspace (`my_workspace/`), create a
 file named `WORKSPACE` with the following contents:
 ```
-load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+# MODULE.bazel
-http_archive(
+# Choose the most recent version available at
-  name = "com_google_googletest",
+# https://registry.bazel.build/modules/googletest
-  urls = ["https://github.com/google/googletest/archive/5ab508a01f9eb089207ee87fd547d290da39d015.zip"],
+bazel_dep(name = "googletest", version = "1.18.0")
  strip_prefix = "googletest-5ab508a01f9eb089207ee87fd547d290da39d015",
 )
 ```
 The above configuration declares a dependency on GoogleTest which is downloaded
 as a ZIP archive from GitHub. In the above example,
 `5ab508a01f9eb089207ee87fd547d290da39d015` is the Git commit hash of the
 GoogleTest version to use; we recommend updating the hash often to point to the
 latest version. Use a recent hash on the `main` branch.
 Now you're ready to build C++ code that uses GoogleTest.
 ## Create and run a binary
@ -95,20 +85,30 @@ cc_test(
    name = "hello_test",
    size = "small",
    srcs = ["hello_test.cc"],
-  deps = ["@com_google_googletest//:gtest_main"],
+    deps = [
        "@googletest//:gtest",
        "@googletest//:gtest_main",
    ],
 )
 ```
 This `cc_test` rule declares the C++ test binary you want to build, and links to
-GoogleTest (`//:gtest_main`) using the prefix you specified in the `WORKSPACE`
+the GoogleTest library (`@googletest//:gtest"`) and the GoogleTest `main()`
-file (`@com_google_googletest`). For more information about Bazel `BUILD` files,
+function (`@googletest//:gtest_main`). For more information about Bazel `BUILD`
-see the
+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++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:
 <pre>
-<strong>my_workspace$ bazel test --test_output=all //:hello_test</strong>
+<strong>$ bazel test --cxxopt=-std=c++17 --test_output=all //:hello_test</strong>
 INFO: Analyzed target //:hello_test (26 packages loaded, 362 targets configured).
 INFO: Found 1 test target...
 INFO: From Testing //:hello_test:
--- a/test/googletest/docs/quickstart-cmake.md
+++ b/test/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,9 @@ 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
+# GoogleTest requires at least C++17
-set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 include(FetchContent)
 FetchContent_Declare(
--- a/test/googletest/docs/reference/actions.md
+++ b/test/googletest/docs/reference/actions.md
@ -24,7 +24,8 @@ provided by GoogleTest. All actions are defined in the `::testing` namespace.
 | :--------------------------------- | :-------------------------------------- |
 | `Assign(&variable, value)` | Assign `value` to variable. |
 | `DeleteArg<N>()` | Delete the `N`-th (0-based) argument, which must be a pointer. |
-| `SaveArg<N>(pointer)` | Save the `N`-th (0-based) argument to `*pointer`. |
+| `SaveArg<N>(pointer)` | Save the `N`-th (0-based) argument to `*pointer` by copy-assignment. |
 | `SaveArgByMove<N>(pointer)` | Save the `N`-th (0-based) argument to `*pointer` by move-assignment. |
 | `SaveArgPointee<N>(pointer)` | Save the value pointed to by the `N`-th (0-based) argument to `*pointer`. |
 | `SetArgReferee<N>(value)` | Assign `value` to the variable referenced by the `N`-th (0-based) argument. |
 | `SetArgPointee<N>(value)` | Assign `value` to the variable pointed by the `N`-th (0-based) argument. |
@ -47,8 +48,8 @@ functor, or lambda.
 | `InvokeWithoutArgs(object_pointer, &class::method)` | Invoke the method on the object, which takes no arguments. |
 | `InvokeArgument<N>(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
+The return value of the invoked function (except `InvokeArgument`) is used as
-action.
+the return value of the action.
 When defining a callable to be used with `Invoke*()`, you can declare any unused
 parameters as `Unused`:
--- a/test/googletest/docs/reference/assertions.md
+++ b/test/googletest/docs/reference/assertions.md
@ -1,7 +1,7 @@
 # Assertions Reference
 This page lists the assertion macros provided by GoogleTest for verifying code
-behavior. To use them, include the header `gtest/gtest.h`.
+behavior. To use them, add `#include <gtest/gtest.h>`.
 The majority of the macros listed below come as a pair with an `EXPECT_` variant
 and an `ASSERT_` variant. Upon failure, `EXPECT_` macros generate nonfatal
@ -88,7 +88,7 @@ For example, the following code verifies that the string `value1` starts with
 10:
 ```cpp
-#include "gmock/gmock.h"
+#include <gmock/gmock.h>
 using ::testing::AllOf;
 using ::testing::Gt;
@ -276,7 +276,8 @@ Units in the Last Place (ULPs). To learn more about ULPs, see the article
 `ASSERT_FLOAT_EQ(`*`val1`*`,`*`val2`*`)`
 Verifies that the two `float` values *`val1`* and *`val2`* are approximately
-equal, to within 4 ULPs from each other.
+equal, to within 4 ULPs from each other. Infinity and the largest finite float
 value are considered to be one ULP apart.
 ### EXPECT_DOUBLE_EQ {#EXPECT_DOUBLE_EQ}
@ -284,7 +285,8 @@ equal, to within 4 ULPs from each other.
 `ASSERT_DOUBLE_EQ(`*`val1`*`,`*`val2`*`)`
 Verifies that the two `double` values *`val1`* and *`val2`* are approximately
-equal, to within 4 ULPs from each other.
+equal, to within 4 ULPs from each other. Infinity and the largest finite double
 value are considered to be one ULP apart.
 ### EXPECT_NEAR {#EXPECT_NEAR}
@ -294,6 +296,11 @@ equal, to within 4 ULPs from each other.
 Verifies that the difference between *`val1`* and *`val2`* does not exceed the
 absolute error bound *`abs_error`*.
 If *`val`* and *`val2`* are both infinity of the same sign, the difference is
 considered to be 0. Otherwise, if either value is infinity, the difference is
 considered to be infinity. All non-NaN values (including infinity) are
 considered to not exceed an *`abs_error`* of infinity.
 ## Exception Assertions {#exceptions}
 The following assertions verify that a piece of code throws, or does not throw,
@ -515,7 +522,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`.
--- a/test/googletest/docs/reference/matchers.md
+++ b/test/googletest/docs/reference/matchers.md
@ -1,5 +1,7 @@
 # Matchers Reference
 <!-- disableFinding(LINK_RELATIVE_G3DOC) -->
 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:
@ -42,11 +44,14 @@ Matcher                     | Description
 | `Lt(value)`            | `argument < value`                                  |
 | `Ne(value)`            | `argument != value`                                 |
 | `IsFalse()`            | `argument` evaluates to `false` in a Boolean context. |
 | `DistanceFrom(target, m)` | The distance between `argument` and `target` (computed by `abs(argument - target)`) matches `m`. |
 | `DistanceFrom(target, get_distance, m)` | The distance between `argument` and `target` (computed by `get_distance(argument, target)`) matches `m`. |
 | `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<T>(m)`    | `argument` is `variant<>` that holds the alternative of type T with a value matching `m`. |
 | `AnyWith<T>(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<type>(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. |
@ -109,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<E>()` | The `argument` is a callable object that, when called, throws an exception of the expected type `E`. |
 | `Throws<E>(m)` | The `argument` is a callable object that, when called, throws an exception of type `E` that satisfies the matcher `m`. |
 | `ThrowsMessage<E>(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<std::runtime_error>());
 // Checks if the lambda throws a `std::runtime_error` with a specific message
 // that matches "error msg".
 EXPECT_THAT(argument,
            Throws<std::runtime_error>(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<std::runtime_error>(HasSubstr("msg")));
 ```
 ## Container Matchers
 Most STL-style containers support `==`, so you can use `Eq(expected_container)`
@ -171,6 +203,11 @@ messages, you can use:
 | `Property(&class::property, m)` | `argument.property()` (or `argument->property()` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_. The method `property()` must take no argument and be declared as `const`. |
 | `Property(property_name, &class::property, m)` | The same as the two-parameter version, but provides a better error message.
 {: .callout .warning}
 Warning: Don't use `Property()` against member functions that you do not own,
 because taking addresses of functions is fragile and generally not part of the
 contract of the function.
 **Notes:**
 *   You can use `FieldsAre()` to match any type that supports structured
@ -189,10 +226,6 @@ messages, you can use:
    EXPECT_THAT(s, FieldsAre(42, "aloha"));
    ```
 *   Don't use `Property()` against member functions that you do not own, because
    taking addresses of functions is fragile and generally not part of the
    contract of the function.
 ## Matching the Result of a Function, Functor, or Callback
 | Matcher          | Description                                       |
@ -223,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:
@ -266,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. |
--- a/test/googletest/docs/reference/mocking.md
+++ b/test/googletest/docs/reference/mocking.md
@ -1,8 +1,7 @@
 # Mocking Reference
 This page lists the facilities provided by GoogleTest for creating and working
-with mock objects. To use them, include the header
+with mock objects. To use them, add `#include <gmock/gmock.h>`.
 `gmock/gmock.h`.
 ## Macros {#macros}
--- a/test/googletest/docs/reference/testing.md
+++ b/test/googletest/docs/reference/testing.md
@ -3,7 +3,7 @@
 <!--* toc_depth: 3 *-->
 This page lists the facilities provided by GoogleTest for writing test programs.
-To use them, include the header `gtest/gtest.h`.
+To use them, add `#include <gtest/gtest.h>`.
 ## Macros
@ -94,7 +94,8 @@ Instantiates the value-parameterized test suite *`TestSuiteName`* (defined with
 The argument *`InstantiationName`* is a unique name for the instantiation of the
 test suite, to distinguish between multiple instantiations. In test output, the
 instantiation name is added as a prefix to the test suite name
-*`TestSuiteName`*.
+*`TestSuiteName`*. If *`InstantiationName`* is empty
 (`INSTANTIATE_TEST_SUITE_P(, ...)`), no prefix is added.
 The argument *`param_generator`* is one of the following GoogleTest-provided
 functions that generate the test parameters, all defined in the `::testing`
@ -109,7 +110,8 @@ namespace:
 | `ValuesIn(container)` or `ValuesIn(begin,end)` | Yields values from a C-style array, an STL-style container, or an iterator range `[begin, end)`. |
 | `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<T>(g)`     | Yields values generated by generator `g`, `static_cast` to `T`. |
+| `ConvertGenerator<T>(g)` or `ConvertGenerator(g, func)`    | Yields values generated by generator `g`, `static_cast` from `T`. (Note: `T` might not be what you expect. See [*Using ConvertGenerator*](#using-convertgenerator) below.) The second overload uses `func` to perform the conversion. |
 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 +123,8 @@ custom function can be used for more control:
 ```cpp
 INSTANTIATE_TEST_SUITE_P(
    MyInstantiation, MyTestSuite,
-    ::testing::Values(...),
+    testing::Values(...),
-    [](const ::testing::TestParamInfo<MyTestSuite::ParamType>& info) {
+    [](const testing::TestParamInfo<MyTestSuite::ParamType>& info) {
      // Can use info.param here to generate the test suffix
      std::string name = ...
      return name;
@ -135,9 +137,107 @@ For more information, see
 See also
 [`GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST`](#GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST).
 ###### Using `ConvertGenerator`
 The functions listed in the table above appear to return generators that create
 values of the desired types, but this is not generally the case. Rather, they
 typically return factory objects that convert to the the desired generators.
 This affords some flexibility in allowing you to specify values of types that
 are different from, yet implicitly convertible to, the actual parameter type
 required by your fixture class.
 For example, you can do the following with a fixture that requires an `int`
 parameter:
 ```cpp
 INSTANTIATE_TEST_SUITE_P(MyInstantiation, MyTestSuite,
    testing::Values(1, 1.2));  // Yes, Values() supports heterogeneous argument types.
 ```
 It might seem obvious that `1.2` &mdash; a `double` &mdash; will be converted to
 an `int` but in actuality it requires some template gymnastics involving the
 indirection described in the previous paragraph.
 What if your parameter type is not implicitly convertible from the generated
 type but is *explicitly* convertible? There will be no automatic conversion, but
 you can force it by applying `ConvertGenerator<T>`. The compiler can
 automatically deduce the target type (your fixture's parameter type), but
 because of the aforementioned indirection it cannot decide what the generated
 type should be. You need to tell it, by providing the type `T` explicitly. Thus
 `T` should not be your fixture's parameter type, but rather an intermediate type
 that is supported by the factory object, and which can be `static_cast` to the
 fixture's parameter type:
 ```cpp
 // The fixture's parameter type.
 class MyParam {
 public:
  // Explicit converting ctor.
  explicit MyParam(const std::tuple<int, bool>& t);
  ...
 };
 INSTANTIATE_TEST_SUITE_P(MyInstantiation, MyTestSuite,
    ConvertGenerator<std::tuple<int, bool>>(Combine(Values(0.1, 1.2), Bool())));
 ```
 In this example `Combine` supports the generation of `std::tuple<int, bool>>`
 objects (even though the provided values for the first tuple element are
 `double`s) and those `tuple`s get converted into `MyParam` objects by virtue of
 the call to `ConvertGenerator`.
 For parameter types that are not convertible from the generated types you can
 provide a callable that does the conversion. The callable accepts an object of
 the generated type and returns an object of the fixture's parameter type. The
 generated type can often be deduced by the compiler from the callable's call
 signature so you do not usually need specify it explicitly (but see a caveat
 below).
 ```cpp
 // The fixture's parameter type.
 class MyParam {
 public:
  MyParam(int, bool);
  ...
 };
 INSTANTIATE_TEST_SUITE_P(MyInstantiation, MyTestSuite,
    ConvertGenerator(Combine(Values(1, 1.2), Bool()),
        [](const std::tuple<int, bool>& t){
          const auto [i, b] = t;
          return MyParam(i, b);
        }));
 ```
 The callable may be anything that can be used to initialize a `std::function`
 with the appropriate call signature. Note the callable's return object gets
 `static_cast` to the fixture's parameter type, so it does not have to be of that
 exact type, only convertible to it.
 **Caveat:** Consider the following example.
 ```cpp
 INSTANTIATE_TEST_SUITE_P(MyInstantiation, MyTestSuite,
    ConvertGenerator(Values(std::string("s")), [](std::string_view s) { ... }));
 ```
 The `string` argument gets copied into the factory object returned by `Values`.
 Then, because the generated type deduced from the lambda is `string_view`, the
 factory object spawns a generator that holds a `string_view` referencing that
 `string`. Unfortunately, by the time this generator gets invoked, the factory
 object is gone and the `string_view` is dangling.
 To overcome this problem you can specify the generated type explicitly:
 `ConvertGenerator<std::string>(Values(std::string("s")), [](std::string_view s)
 { ... })`. Alternatively, you can change the lambda's signature to take a
 `std::string` or a `const std::string&` (the latter will not leave you with a
 dangling reference because the type deduction strips off the reference and the
 `const`).
 ### TYPED_TEST_SUITE {#TYPED_TEST_SUITE}
 `TYPED_TEST_SUITE(`*`TestFixtureName`*`,`*`Types`*`)`
 `TYPED_TEST_SUITE(`*`TestFixtureName`*`,`*`Types`*`,`*`NameGenerator`*`)`
 Defines a typed test suite based on the test fixture *`TestFixtureName`*. The
 test suite name is *`TestFixtureName`*.
@ -147,7 +247,7 @@ type, for example:
 ```cpp
 template <typename T>
-class MyFixture : public ::testing::Test {
+class MyFixture : public testing::Test {
 public:
  ...
  using List = std::list<T>;
@ -167,6 +267,22 @@ TYPED_TEST_SUITE(MyFixture, MyTypes);
 The type alias (`using` or `typedef`) is necessary for the `TYPED_TEST_SUITE`
 macro to parse correctly.
 The optional third argument *`NameGenerator`* allows specifying a class that
 exposes a templated static function `GetName(int)`. For example:
 ```cpp
 class NameGenerator {
 public:
  template <typename T>
  static std::string GetName(int) {
    if constexpr (std::is_same_v<T, char>) return "char";
    if constexpr (std::is_same_v<T, int>) return "int";
    if constexpr (std::is_same_v<T, unsigned int>) return "unsignedInt";
  }
 };
 TYPED_TEST_SUITE(MyFixture, MyTypes, NameGenerator);
 ```
 See also [`TYPED_TEST`](#TYPED_TEST) and
 [Typed Tests](../advanced.md#typed-tests) for more information.
@ -276,7 +392,8 @@ must be registered with
 The argument *`InstantiationName`* is a unique name for the instantiation of the
 test suite, to distinguish between multiple instantiations. In test output, the
 instantiation name is added as a prefix to the test suite name
-*`TestSuiteName`*.
+*`TestSuiteName`*. If *`InstantiationName`* is empty
 (`INSTANTIATE_TYPED_TEST_SUITE_P(, ...)`), no prefix is added.
 The argument *`Types`* is a [`Types`](#Types) object representing the list of
 types to run the tests on, for example:
@ -323,7 +440,7 @@ Then the test code should look like:
 ```cpp
 namespace my_namespace {
-class MyClassTest : public ::testing::Test {
+class MyClassTest : public testing::Test {
  ...
 };
@ -386,7 +503,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 +517,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 +532,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 +553,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 +569,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 +580,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 +668,7 @@ after running each individual test.
 ### TestWithParam {#TestWithParam}
-`::testing::TestWithParam<T>`
+`testing::TestWithParam<T>`
 A convenience class which inherits from both [`Test`](#Test) and
 [`WithParamInterface<T>`](#WithParamInterface).
@ -671,7 +788,7 @@ during execution of `SetUpTestSuite` and `TearDownTestSuite`.
 ### TestInfo {#TestInfo}
-`::testing::TestInfo`
+`testing::TestInfo`
 Stores information about a test.
@ -750,7 +867,7 @@ Returns the result of the test. See [`TestResult`](#TestResult).
 ### TestParamInfo {#TestParamInfo}
-`::testing::TestParamInfo<T>`
+`testing::TestParamInfo<T>`
 Describes a parameter to a value-parameterized test. The type `T` is the type of
 the parameter.
@ -760,7 +877,7 @@ and its integer index respectively.
 ### UnitTest {#UnitTest}
-`::testing::UnitTest`
+`testing::UnitTest`
 This class contains information about the test program.
@ -928,7 +1045,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 +1143,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 +1188,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 +1270,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 +1297,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 +1378,20 @@ range, aborts the program.
 ### TimeInMillis {#TimeInMillis}
-`::testing::TimeInMillis`
+`testing::TimeInMillis`
 An integer type representing time in milliseconds.
 ### Types {#Types}
-`::testing::Types<T...>`
+`testing::Types<T...>`
 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<char, int, unsigned int>
+testing::Types<char, int, unsigned int>
 ```
 See [Typed Tests](../advanced.md#typed-tests) and
@ -1283,7 +1400,7 @@ information.
 ### WithParamInterface {#WithParamInterface}
-`::testing::WithParamInterface<T>`
+`testing::WithParamInterface<T>`
 The pure interface class that all value-parameterized tests inherit from.
@ -1309,14 +1426,16 @@ tests.
 ### InitGoogleTest {#InitGoogleTest}
-`void ::testing::InitGoogleTest(int* argc, char** argv)` \
+`void testing::InitGoogleTest(int* argc, char** argv)` \
-`void ::testing::InitGoogleTest(int* argc, wchar_t** argv)` \
+`void testing::InitGoogleTest(int* argc, wchar_t** argv)` \
-`void ::testing::InitGoogleTest()`
+`void testing::InitGoogleTest()`
 Initializes GoogleTest. This must be called before calling
 [`RUN_ALL_TESTS()`](#RUN_ALL_TESTS). In particular, it parses the command line
 for the flags that GoogleTest recognizes. Whenever a GoogleTest flag is seen, it
-is removed from `argv`, and `*argc` is decremented.
+is removed from `argv`, and `*argc` is decremented. Keep in mind that `argv`
 must terminate with a `NULL` pointer (i.e. `argv[argc]` is `NULL`), which is
 already the case with the default `argv` passed to `main`.
 No value is returned. Instead, the GoogleTest flag variables are updated.
@ -1328,7 +1447,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 +1460,7 @@ See also [`Environment`](#Environment).
 ```cpp
 template <typename Factory>
-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 +1499,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<T1, T2>()`
+`testing::StaticAssertTypeEq<T1, T2>()`
 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 +1528,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 +1538,7 @@ for more information.
 ### PrintToStringParamName {#PrintToStringParamName}
-`std::string ::testing::PrintToStringParamName(TestParamInfo<T>& info)`
+`std::string testing::PrintToStringParamName(TestParamInfo<T>& info)`
 A built-in parameterized test name generator which returns the result of
 [`PrintToString`](#PrintToString) called on `info.param`. Does not work when the
--- a/test/googletest/fake_fuchsia_sdk.bzl
+++ b/test/googletest/fake_fuchsia_sdk.bzl
@ -0,0 +1,61 @@
 """Provides a fake @fuchsia_sdk implementation that's used when the real one isn't available.
 GoogleTest can be used with the [Fuchsia](https://fuchsia.dev/) SDK. However,
 because the Fuchsia SDK does not yet support bzlmod, GoogleTest's `MODULE.bazel`
 file by default provides a "fake" Fuchsia SDK.
 To override this and use the real Fuchsia SDK, you can add the following to your
 project's `MODULE.bazel` file:
    fake_fuchsia_sdk_extension =
    use_extension("@com_google_googletest//:fake_fuchsia_sdk.bzl", "fuchsia_sdk")
    override_repo(fake_fuchsia_sdk_extension, "fuchsia_sdk")
 NOTE: The `override_repo` built-in is only available in Bazel 8.0 and higher.
 See https://github.com/google/googletest/issues/4472 for more details of why the
 fake Fuchsia SDK is needed.
 """
 def _fake_fuchsia_sdk_impl(repo_ctx):
    for stub_target in repo_ctx.attr._stub_build_targets:
        stub_package = stub_target
        stub_target_name = stub_target.split("/")[-1]
        repo_ctx.file("%s/BUILD.bazel" % stub_package, """
 filegroup(
    name = "%s",
 )
 """ % stub_target_name)
 fake_fuchsia_sdk = repository_rule(
    doc = "Used to create a fake @fuchsia_sdk repository with stub build targets.",
    implementation = _fake_fuchsia_sdk_impl,
    attrs = {
        "_stub_build_targets": attr.string_list(
            doc = "The stub build targets to initialize.",
            default = [
                "pkg/fdio",
                "pkg/syslog",
                "pkg/zx",
            ],
        ),
    },
 )
 _create_fake = tag_class()
 def _fuchsia_sdk_impl(module_ctx):
    create_fake_sdk = False
    for mod in module_ctx.modules:
        for _ in mod.tags.create_fake:
            create_fake_sdk = True
    if create_fake_sdk:
        fake_fuchsia_sdk(name = "fuchsia_sdk")
    return module_ctx.extension_metadata(reproducible = True)
 fuchsia_sdk = module_extension(
    implementation = _fuchsia_sdk_impl,
    tag_classes = {"create_fake": _create_fake},
 )
--- a/test/googletest/googlemock/CMakeLists.txt
+++ b/test/googletest/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_minimum_required(VERSION 3.13)
 cmake_policy(SET CMP0048 NEW)
 project(gmock VERSION ${GOOGLETEST_VERSION} LANGUAGES CXX C)
 if (COMMAND set_up_hermetic_build)
@ -66,12 +65,13 @@ endif()
 config_compiler_and_linker() # from ${gtest_dir}/cmake/internal_utils.cmake
 # Adds Google Mock's and Google Test's header directories to the search path.
 # Get Google Test's include dirs from the target, gtest_SOURCE_DIR is broken
 # when using fetch-content with the name "GTest".
 get_target_property(gtest_include_dirs gtest INCLUDE_DIRECTORIES)
 set(gmock_build_include_dirs
  "${gmock_SOURCE_DIR}/include"
  "${gmock_SOURCE_DIR}"
-  "${gtest_SOURCE_DIR}/include"
+  "${gtest_include_dirs}")
  # This directory is needed to build directly from Google Test sources.
  "${gtest_SOURCE_DIR}")
 include_directories(${gmock_build_include_dirs})
 ########################################################################
@ -101,22 +101,18 @@ 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 ";" "$<SEMICOLON>" dirs "${gmock_build_include_dirs}")
 target_include_directories(gmock SYSTEM INTERFACE
  "$<BUILD_INTERFACE:${dirs}>"
-    "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>")
+  "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
 target_include_directories(gmock_main SYSTEM INTERFACE
  "$<BUILD_INTERFACE:${dirs}>"
-    "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>")
+  "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
 endif()
 ########################################################################
 #
-# Install rules
+# Install rules.
 install_project(gmock gmock_main)
 ########################################################################
@ -136,11 +132,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()
  endif()
  ############################################################
--- a/test/googletest/googlemock/README.md
+++ b/test/googletest/googlemock/README.md
@ -8,8 +8,8 @@ derive better designs of your system and write better tests.
 It is inspired by:
 *   [jMock](http://www.jmock.org/)
-*   [EasyMock](http://www.easymock.org/)
+*   [EasyMock](https://easymock.org/)
-*   [Hamcrest](http://code.google.com/p/hamcrest/)
+*   [Hamcrest](https://code.google.com/p/hamcrest/)
 It is designed with C++'s specifics in mind.
@ -36,5 +36,5 @@ Details and examples can be found here:
 *   [gMock Cheat Sheet](https://google.github.io/googletest/gmock_cheat_sheet.html)
 GoogleMock is a part of
-[GoogleTest C++ testing framework](http://github.com/google/googletest/) and a
+[GoogleTest C++ testing framework](https://github.com/google/googletest/) and a
 subject to the same requirements.
--- a/test/googletest/googlemock/include/gmock/gmock-actions.h
+++ b/test/googletest/googlemock/include/gmock/gmock-actions.h
@ -135,6 +135,7 @@
 #endif
 #include <algorithm>
 #include <exception>
 #include <functional>
 #include <memory>
 #include <string>
@ -175,9 +176,15 @@ struct BuiltInDefaultValueGetter<T, false> {
  static T Get() {
    Assert(false, __FILE__, __LINE__,
           "Default action undefined for the function return type.");
-    return internal::Invalid<T>();
+#if defined(__GNUC__) || defined(__clang__)
    __builtin_unreachable();
 #elif defined(_MSC_VER)
    __assume(0);
 #else
    return Invalid<T>();
    // The above statement will never be reached, but is required in
    // order for this function to compile.
 #endif
  }
 };
@ -189,7 +196,7 @@ struct BuiltInDefaultValueGetter<T, false> {
 // other type T, the built-in default T value is undefined, and the
 // function will abort the process.
 template <typename T>
-class BuiltInDefaultValue {
+class [[nodiscard]] BuiltInDefaultValue {
 public:
  // This function returns true if and only if type T has a built-in default
  // value.
@ -204,7 +211,7 @@ class BuiltInDefaultValue {
 // This partial specialization says that we use the same built-in
 // default value for T and const T.
 template <typename T>
-class BuiltInDefaultValue<const T> {
+class [[nodiscard]] BuiltInDefaultValue<const T> {
 public:
  static bool Exists() { return BuiltInDefaultValue<T>::Exists(); }
  static T Get() { return BuiltInDefaultValue<T>::Get(); }
@ -213,7 +220,7 @@ class BuiltInDefaultValue<const T> {
 // This partial specialization defines the default values for pointer
 // types.
 template <typename T>
-class BuiltInDefaultValue<T*> {
+class [[nodiscard]] BuiltInDefaultValue<T*> {
 public:
  static bool Exists() { return true; }
  static T* Get() { return nullptr; }
@ -376,7 +383,7 @@ typename std::add_const<T>::type& as_const(T& t) {
 // Specialized for function types below.
 template <typename F>
-class OnceAction;
+class [[nodiscard]] OnceAction;
 // An action that can only be used once.
 //
@ -414,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 <typename Result, typename... Args>
-class OnceAction<Result(Args...)> final {
+class [[nodiscard]] OnceAction<Result(Args...)> final {
 private:
  // True iff we can use the given callable type (or lvalue reference) directly
  // via StdFunctionAdaptor.
  template <typename Callable>
  using IsDirectlyCompatible = internal::conjunction<
      // It must be possible to capture the callable in StdFunctionAdaptor.
      std::is_constructible<typename std::decay<Callable>::type, Callable>,
      // The callable must be compatible with our signature.
-      internal::is_callable_r<Result, typename std::decay<Callable>::type,
+      internal::is_callable_r<Result, std::decay_t<Callable>, Args...>,
-                              Args...>>;
+      // It must be possible to capture the callable in StdFunctionAdaptor.
      std::is_constructible<std::decay_t<Callable>, Callable>>;
  // True iff we can use the given callable type via StdFunctionAdaptor once we
  // ignore incoming arguments.
  template <typename Callable>
  using IsCompatibleAfterIgnoringArguments = internal::conjunction<
      // It must be possible to capture the callable in a lambda.
      std::is_constructible<typename std::decay<Callable>::type, Callable>,
      // The callable must be invocable with zero arguments, returning something
      // convertible to Result.
-      internal::is_callable_r<Result, typename std::decay<Callable>::type>>;
+      internal::is_callable_r<Result, std::decay_t<Callable>>,
      // It must be possible to capture the callable in a lambda.
      std::is_constructible<std::decay_t<Callable>, Callable>>;
 public:
  // Construct from a callable that is directly compatible with our mocked
@ -567,7 +573,7 @@ class OnceAction<Result(Args...)> final {
 //   // Sets the default value for type T to be foo.
 //   DefaultValue<T>::Set(foo);
 template <typename T>
-class DefaultValue {
+class [[nodiscard]] DefaultValue {
 public:
  // Sets the default value for type T; requires T to be
  // copy-constructable and have a public destructor.
@ -611,7 +617,7 @@ class DefaultValue {
 private:
  class ValueProducer {
   public:
-    virtual ~ValueProducer() {}
+    virtual ~ValueProducer() = default;
    virtual T Produce() = 0;
  };
@ -644,7 +650,7 @@ class DefaultValue {
 // This partial specialization allows a user to set default values for
 // reference types.
 template <typename T>
-class DefaultValue<T&> {
+class [[nodiscard]] DefaultValue<T&> {
 public:
  // Sets the default value for type T&.
  static void Set(T& x) {  // NOLINT
@ -678,7 +684,7 @@ class DefaultValue<T&> {
 // This specialization allows DefaultValue<void>::Get() to
 // compile.
 template <>
-class DefaultValue<void> {
+class [[nodiscard]] DefaultValue<void> {
 public:
  static bool Exists() { return true; }
  static void Get() {}
@ -694,13 +700,13 @@ T* DefaultValue<T&>::address_ = nullptr;
 // Implement this interface to define an action for function type F.
 template <typename F>
-class ActionInterface {
+class [[nodiscard]] ActionInterface {
 public:
  typedef typename internal::Function<F>::Result Result;
  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
-  ActionInterface() {}
+  ActionInterface() = default;
-  virtual ~ActionInterface() {}
+  virtual ~ActionInterface() = default;
  // Performs the action.  This method is not const, as in general an
  // action can have side effects and be stateful.  For example, a
@ -714,7 +720,7 @@ class ActionInterface {
 };
 template <typename F>
-class Action;
+class [[nodiscard]] Action;
 // An Action<R(Args...)> is a copyable and IMMUTABLE (except by assignment)
 // object that represents an action to be taken when a mock function of type
@ -723,7 +729,7 @@ class Action;
 // can view an object implementing ActionInterface<F> as a concrete action
 // (including its current state), and an Action<F> object as a handle to it.
 template <typename R, typename... Args>
-class Action<R(Args...)> {
+class [[nodiscard]] Action<R(Args...)> {
 private:
  using F = R(Args...);
@ -749,7 +755,7 @@ class Action<R(Args...)> {
  // 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
@ -828,6 +834,10 @@ class Action<R(Args...)> {
    Result operator()(const InArgs&...) const {
      return function_impl();
    }
    template <typename... InArgs>
    Result operator()(const InArgs&...) {
      return function_impl();
    }
    FunctionImpl function_impl;
  };
@ -858,7 +868,7 @@ class Action<R(Args...)> {
 // the definition of Return(void) and SetArgumentPointee<N>(value) for
 // complete examples.
 template <typename Impl>
-class PolymorphicAction {
+class [[nodiscard]] PolymorphicAction {
 public:
  explicit PolymorphicAction(const Impl& impl) : impl_(impl) {}
@ -918,7 +928,7 @@ struct ByMoveWrapper {
 // The general implementation of Return(R). Specializations follow below.
 template <typename R>
-class ReturnAction final {
+class [[nodiscard]] ReturnAction final {
 public:
  explicit ReturnAction(R value) : value_(std::move(value)) {}
@ -1084,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 <typename T>
-class ReturnAction<ByMoveWrapper<T>> final {
+class [[nodiscard]] ReturnAction<ByMoveWrapper<T>> final {
 public:
  explicit ReturnAction(ByMoveWrapper<T> wrapper)
      : state_(new State(std::move(wrapper.payload))) {}
@ -1111,7 +1121,7 @@ class ReturnAction<ByMoveWrapper<T>> 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
@ -1123,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 <typename Result, typename ArgumentTuple>
@ -1136,7 +1146,7 @@ class ReturnVoidAction {
 // in any function that returns a reference to the type of x,
 // regardless of the argument types.
 template <typename T>
-class ReturnRefAction {
+class [[nodiscard]] ReturnRefAction {
 public:
  // Constructs a ReturnRefAction object from the reference to be returned.
  explicit ReturnRefAction(T& ref) : ref_(ref) {}  // NOLINT
@ -1177,7 +1187,7 @@ class ReturnRefAction {
 // used in any function that returns a reference to the type of x,
 // regardless of the argument types.
 template <typename T>
-class ReturnRefOfCopyAction {
+class [[nodiscard]] ReturnRefOfCopyAction {
 public:
  // Constructs a ReturnRefOfCopyAction object from the reference to
  // be returned.
@ -1218,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 <typename T>
-class ReturnRoundRobinAction {
+class [[nodiscard]] ReturnRoundRobinAction {
 public:
  explicit ReturnRoundRobinAction(std::vector<T> values) {
    GTEST_CHECK_(!values.empty())
@ -1246,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.
@ -1259,7 +1269,7 @@ class DoDefaultAction {
 // Implements the Assign action to set a given pointer referent to a
 // particular value.
 template <typename T1, typename T2>
-class AssignAction {
+class [[nodiscard]] AssignAction {
 public:
  AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {}
@ -1273,12 +1283,12 @@ 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.
 template <typename T>
-class SetErrnoAndReturnAction {
+class [[nodiscard]] SetErrnoAndReturnAction {
 public:
  SetErrnoAndReturnAction(int errno_value, T result)
      : errno_(errno_value), result_(result) {}
@ -1320,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<F> as long as f's type is compatible with F.
 template <typename FunctionImpl>
 struct InvokeWithoutArgsAction {
  FunctionImpl function_impl;
  // Allows InvokeWithoutArgs(f) to be used as any action whose type is
  // compatible with f.
  template <typename... Args>
  auto operator()(const Args&...) -> decltype(function_impl()) {
    return function_impl();
  }
 };
 // Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action.
 template <class Class, typename MethodPtr>
 struct InvokeMethodWithoutArgsAction {
@ -1386,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:
@ -1444,6 +1438,30 @@ struct WithArgsAction {
    return OA{std::move(inner_action)};
  }
  // As above, but in the case where we want to create a OnceAction from a const
  // WithArgsAction. This is fine as long as the inner action doesn't need to
  // move any of its state to create a OnceAction.
  template <
      typename R, typename... Args,
      typename std::enable_if<
          std::is_convertible<const InnerAction&,
                              OnceAction<R(internal::TupleElement<
                                           I, std::tuple<Args...>>...)>>::value,
          int>::type = 0>
  operator OnceAction<R(Args...)>() const& {  // NOLINT
    struct OA {
      OnceAction<InnerSignature<R, Args...>> inner_action;
      R operator()(Args&&... args) && {
        return std::move(inner_action)
            .Call(std::get<I>(
                std::forward_as_tuple(std::forward<Args>(args)...))...);
      }
    };
    return OA{inner_action};
  }
  template <
      typename R, typename... Args,
      typename std::enable_if<
@ -1468,11 +1486,11 @@ struct WithArgsAction {
 };
 template <typename... Actions>
-class DoAllAction;
+class [[nodiscard]] DoAllAction;
 // Base case: only a single action.
 template <typename FinalAction>
-class DoAllAction<FinalAction> {
+class [[nodiscard]] DoAllAction<FinalAction> {
 public:
  struct UserConstructorTag {};
@ -1486,6 +1504,7 @@ class DoAllAction<FinalAction> {
  // providing a call operator because even with a particular set of arguments
  // they don't have a fixed return type.
  // We support conversion to OnceAction whenever the sub-action does.
  template <typename R, typename... Args,
            typename std::enable_if<
                std::is_convertible<FinalAction, OnceAction<R(Args...)>>::value,
@ -1494,6 +1513,21 @@ class DoAllAction<FinalAction> {
    return std::move(final_action_);
  }
  // We also support conversion to OnceAction whenever the sub-action supports
  // conversion to Action (since any Action can also be a OnceAction).
  template <
      typename R, typename... Args,
      typename std::enable_if<
          conjunction<
              negation<
                  std::is_convertible<FinalAction, OnceAction<R(Args...)>>>,
              std::is_convertible<FinalAction, Action<R(Args...)>>>::value,
          int>::type = 0>
  operator OnceAction<R(Args...)>() && {  // NOLINT
    return Action<R(Args...)>(std::move(final_action_));
  }
  // We support conversion to Action whenever the sub-action does.
  template <
      typename R, typename... Args,
      typename std::enable_if<
@ -1510,7 +1544,7 @@ class DoAllAction<FinalAction> {
 // Recursive case: support N actions by calling the initial action and then
 // calling through to the base class containing N-1 actions.
 template <typename InitialAction, typename... OtherActions>
-class DoAllAction<InitialAction, OtherActions...>
+class [[nodiscard]] DoAllAction<InitialAction, OtherActions...>
    : private DoAllAction<OtherActions...> {
 private:
  using Base = DoAllAction<OtherActions...>;
@ -1573,12 +1607,12 @@ class DoAllAction<InitialAction, OtherActions...>
      : Base({}, std::forward<U>(other_actions)...),
        initial_action_(std::forward<T>(initial_action)) {}
-  template <typename R, typename... Args,
+  // We support conversion to OnceAction whenever both the initial action and
  // the rest support conversion to OnceAction.
  template <
      typename R, typename... Args,
      typename std::enable_if<
-                conjunction<
+          conjunction<std::is_convertible<
                    // Both the initial action and the rest must support
                    // conversion to OnceAction.
                    std::is_convertible<
                          InitialAction,
                          OnceAction<void(InitialActionArgType<Args>...)>>,
                      std::is_convertible<Base, OnceAction<R(Args...)>>>::value,
@ -1605,12 +1639,34 @@ class DoAllAction<InitialAction, OtherActions...>
    };
  }
  // We also support conversion to OnceAction whenever the initial action
  // supports conversion to Action (since any Action can also be a OnceAction).
  //
  // The remaining sub-actions must also be compatible, but we don't need to
  // special case them because the base class deals with them.
  template <
      typename R, typename... Args,
      typename std::enable_if<
          conjunction<
              negation<std::is_convertible<
                  InitialAction,
                  OnceAction<void(InitialActionArgType<Args>...)>>>,
              std::is_convertible<InitialAction,
                                  Action<void(InitialActionArgType<Args>...)>>,
              std::is_convertible<Base, OnceAction<R(Args...)>>>::value,
          int>::type = 0>
  operator OnceAction<R(Args...)>() && {  // NOLINT
    return DoAll(
        Action<void(InitialActionArgType<Args>...)>(std::move(initial_action_)),
        std::move(static_cast<Base&>(*this)));
  }
  // We support conversion to Action whenever both the initial action and the
  // rest support conversion to Action.
  template <
      typename R, typename... Args,
      typename std::enable_if<
          conjunction<
              // Both the initial action and the rest must support conversion to
              // Action.
              std::is_convertible<const InitialAction&,
                                  Action<void(InitialActionArgType<Args>...)>>,
              std::is_convertible<const Base&, Action<R(Args...)>>>::value,
@ -1674,6 +1730,16 @@ struct SaveArgAction {
  }
 };
 template <size_t k, typename Ptr>
 struct SaveArgByMoveAction {
  Ptr pointer;
  template <typename... Args>
  void operator()(Args&&... args) const {
    *pointer = std::move(std::get<k>(std::tie(args...)));
  }
 };
 template <size_t k, typename Ptr>
 struct SaveArgPointeeAction {
  Ptr pointer;
@ -1713,11 +1779,24 @@ struct SetArrayArgumentAction {
 };
 template <size_t k>
-struct DeleteArgAction {
+class [[nodiscard]] DeleteArgAction {
 public:
  template <typename... Args>
  void operator()(const Args&... args) const {
-    delete std::get<k>(std::tie(args...));
+    DoDelete(std::get<k>(std::tie(args...)));
  }
 private:
  template <typename T>
  static void DoDelete(T* ptr) {
    delete ptr;
  }
  template <typename T>
  [[deprecated(
      "DeleteArg<N> 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 <typename Ptr>
@ -1740,6 +1819,13 @@ struct ThrowAction {
    return [copy](Args...) -> R { throw copy; };
  }
 };
 struct RethrowAction {
  std::exception_ptr exception;
  template <typename R, typename... Args>
  operator Action<R(Args...)>() const {  // NOLINT
    return [ex = exception](Args...) -> R { std::rethrow_exception(ex); };
  }
 };
 #endif  // GTEST_HAS_EXCEPTIONS
 }  // namespace internal
@ -1776,6 +1862,13 @@ struct ThrowAction {
 //   EXPECT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin));
 typedef internal::IgnoredValue Unused;
 // Deprecated single-argument DoAll.
 template <typename Action>
 GTEST_INTERNAL_DEPRECATE_AND_INLINE("Avoid using DoAll() for single actions")
 typename std::decay<Action>::type DoAll(Action&& action) {
  return std::forward<Action>(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.
@ -1926,7 +2019,7 @@ PolymorphicAction<internal::AssignAction<T1, T2>> Assign(T1* ptr, T2 val) {
  return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val));
 }
-#if !GTEST_OS_WINDOWS_MOBILE
+#ifndef GTEST_OS_WINDOWS_MOBILE
 // Creates an action that sets errno and returns the appropriate error.
 template <typename T>
@ -1941,10 +2034,11 @@ PolymorphicAction<internal::SetErrnoAndReturnAction<T>> 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 <typename FunctionImpl>
 GTEST_INTERNAL_DEPRECATE_AND_INLINE(
    "Actions can now be implicitly constructed from callables. No need to "
    "create wrapper objects using Invoke().")
 typename std::decay<FunctionImpl>::type Invoke(FunctionImpl&& function_impl) {
  return std::forward<FunctionImpl>(function_impl);
 }
@ -1959,9 +2053,11 @@ internal::InvokeMethodAction<Class, MethodPtr> Invoke(Class* obj_ptr,
 // Creates an action that invokes 'function_impl' with no argument.
 template <typename FunctionImpl>
-internal::InvokeWithoutArgsAction<typename std::decay<FunctionImpl>::type>
+GTEST_INTERNAL_DEPRECATE_AND_INLINE(
-InvokeWithoutArgs(FunctionImpl function_impl) {
+    "Actions can now be implicitly constructed from zero-argument callables. "
-  return {std::move(function_impl)};
+    "No need to create wrapper objects using InvokeWithoutArgs().")
 std::decay_t<FunctionImpl> InvokeWithoutArgs(FunctionImpl&& function_impl) {
  return std::forward<FunctionImpl>(function_impl);
 }
 // Creates an action that invokes the given method on the given object
@ -2017,6 +2113,13 @@ internal::SaveArgAction<k, Ptr> SaveArg(Ptr pointer) {
  return {pointer};
 }
 // Action SaveArgByMove<k>(pointer) moves the k-th (0-based) argument of the
 // mock function into *pointer.
 template <size_t k, typename Ptr>
 internal::SaveArgByMoveAction<k, Ptr> SaveArgByMove(Ptr pointer) {
  return {pointer};
 }
 // Action SaveArgPointee<k>(pointer) saves the value pointed to
 // by the k-th (0-based) argument of the mock function to *pointer.
 template <size_t k, typename Ptr>
@ -2056,13 +2159,23 @@ internal::ReturnPointeeAction<Ptr> ReturnPointee(Ptr pointer) {
  return {pointer};
 }
 // Action Throw(exception) can be used in a mock function of any type
 // to throw the given exception.  Any copyable value can be thrown.
 #if GTEST_HAS_EXCEPTIONS
 // Action Throw(exception) can be used in a mock function of any type
 // to throw the given exception.  Any copyable value can be thrown,
 // except for std::exception_ptr, which is likely a mistake if
 // thrown directly.
 template <typename T>
-internal::ThrowAction<typename std::decay<T>::type> Throw(T&& exception) {
+typename std::enable_if<
    !std::is_base_of<std::exception_ptr, typename std::decay<T>::type>::value,
    internal::ThrowAction<typename std::decay<T>::type>>::type
 Throw(T&& exception) {
  return {std::forward<T>(exception)};
 }
 // Action Rethrow(exception_ptr) can be used in a mock function of any type
 // to rethrow any exception_ptr. Note that the same object is thrown each time.
 inline internal::RethrowAction Rethrow(std::exception_ptr exception) {
  return {std::move(exception)};
 }
 #endif  // GTEST_HAS_EXCEPTIONS
 namespace internal {
@ -2111,13 +2224,13 @@ struct ActionImpl<R(Args...), Impl> : ImplBase<Impl>::type {
  R operator()(Args&&... arg) const {
    static constexpr size_t kMaxArgs =
        sizeof...(Args) <= 10 ? sizeof...(Args) : 10;
-    return Apply(MakeIndexSequence<kMaxArgs>{},
+    return Apply(std::make_index_sequence<kMaxArgs>{},
-                 MakeIndexSequence<10 - kMaxArgs>{},
+                 std::make_index_sequence<10 - kMaxArgs>{},
                 args_type{std::forward<Args>(arg)...});
  }
  template <std::size_t... arg_id, std::size_t... excess_id>
-  R Apply(IndexSequence<arg_id...>, IndexSequence<excess_id...>,
+  R Apply(std::index_sequence<arg_id...>, std::index_sequence<excess_id...>,
          const args_type& args) const {
    // Impl need not be specific to the signature of action being implemented;
    // only the implementing function body needs to have all of the specific
@ -2150,9 +2263,9 @@ template <typename F, typename Impl>
 }
 #define GMOCK_INTERNAL_ARG_UNUSED(i, data, el) \
-  , const arg##i##_type& arg##i GTEST_ATTRIBUTE_UNUSED_
+  , [[maybe_unused]] const arg##i##_type& arg##i
 #define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_          \
-  const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \
+  [[maybe_unused]] const args_type& args GMOCK_PP_REPEAT( \
      GMOCK_INTERNAL_ARG_UNUSED, , 10)
 #define GMOCK_INTERNAL_ARG(i, data, el) , const arg##i##_type& arg##i
@ -2217,8 +2330,8 @@ template <typename F, typename Impl>
    std::shared_ptr<const gmock_Impl> impl_;                                   \
  };                                                                           \
  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                             \
-  inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name(                    \
+  [[nodiscard]] inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name(      \
-      GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) GTEST_MUST_USE_RESULT_;        \
+      GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params));                               \
  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                             \
  inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name(                    \
      GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) {                              \
@ -2253,7 +2366,7 @@ template <typename F, typename Impl>
      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
    };                                                                        \
  };                                                                          \
-  inline name##Action name() GTEST_MUST_USE_RESULT_;                          \
+  [[nodiscard]] inline name##Action name();                                   \
  inline name##Action name() { return name##Action(); }                       \
  template <typename function_type, typename return_type, typename args_type, \
            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                \
--- a/test/googletest/googlemock/include/gmock/gmock-cardinalities.h
+++ b/test/googletest/googlemock/include/gmock/gmock-cardinalities.h
@ -63,9 +63,9 @@ 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() {}
+  virtual ~CardinalityInterface() = default;
  // Conservative estimate on the lower/upper bound of the number of
  // calls allowed.
@ -88,11 +88,11 @@ 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.
-  Cardinality() {}
+  Cardinality() = default;
  // Constructs a Cardinality from its implementation.
  explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {}
--- a/test/googletest/googlemock/include/gmock/gmock-function-mocker.h
+++ b/test/googletest/googlemock/include/gmock/gmock-function-mocker.h
@ -37,6 +37,7 @@
 #ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_
 #define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_
 #include <cstddef>
 #include <type_traits>  // IWYU pragma: keep
 #include <utility>      // IWYU pragma: keep
@ -69,22 +70,22 @@ constexpr bool PrefixOf(const char* a, const char* b) {
  return *a == 0 || (*a == *b && internal::PrefixOf(a + 1, b + 1));
 }
-template <int N, int M>
+template <size_t N, size_t M>
 constexpr bool StartsWith(const char (&prefix)[N], const char (&str)[M]) {
  return N <= M && internal::PrefixOf(prefix, str);
 }
-template <int N, int M>
+template <size_t N, size_t M>
 constexpr bool EndsWith(const char (&suffix)[N], const char (&str)[M]) {
  return N <= M && internal::PrefixOf(suffix, str + M - N);
 }
-template <int N, int M>
+template <size_t N, size_t M>
 constexpr bool Equals(const char (&a)[N], const char (&b)[M]) {
  return N == M && internal::PrefixOf(a, b);
 }
-template <int N>
+template <size_t N>
 constexpr bool ValidateSpec(const char (&spec)[N]) {
  return internal::Equals("const", spec) ||
         internal::Equals("override", spec) ||
--- a/test/googletest/googlemock/include/gmock/gmock-matchers.h
+++ b/test/googletest/googlemock/include/gmock/gmock-matchers.h
--- a/test/googletest/googlemock/include/gmock/gmock-more-actions.h
+++ b/test/googletest/googlemock/include/gmock/gmock-more-actions.h
@ -521,8 +521,7 @@
        GMOCK_INTERNAL_DECL_##value_params)                                    \
        GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),    \
                    = default;                                                 \
-                    ,                                                          \
+                    , : impl_(std::make_shared<gmock_Impl>(                    \
                    : impl_(std::make_shared<gmock_Impl>(                      \
                          GMOCK_INTERNAL_LIST_##value_params)){})              \
            GMOCK_ACTION_CLASS_(name, value_params)(const GMOCK_ACTION_CLASS_( \
                name, value_params) &) noexcept GMOCK_INTERNAL_DEFN_COPY_      \
@ -551,10 +550,10 @@
  };                                                                           \
  template <GMOCK_INTERNAL_DECL_##template_params                              \
                GMOCK_INTERNAL_DECL_TYPE_##value_params>                       \
-  GMOCK_ACTION_CLASS_(                                                         \
+  [[nodiscard]] GMOCK_ACTION_CLASS_(                                           \
      name, value_params)<GMOCK_INTERNAL_LIST_##template_params                \
                              GMOCK_INTERNAL_LIST_TYPE_##value_params>         \
-      name(GMOCK_INTERNAL_DECL_##value_params) GTEST_MUST_USE_RESULT_;         \
+      name(GMOCK_INTERNAL_DECL_##value_params);                                \
  template <GMOCK_INTERNAL_DECL_##template_params                              \
                GMOCK_INTERNAL_DECL_TYPE_##value_params>                       \
  inline GMOCK_ACTION_CLASS_(                                                  \
@ -592,21 +591,23 @@ namespace internal {
 // Overloads for other custom-callables are provided in the
 // internal/custom/gmock-generated-actions.h header.
 template <typename F, typename... Args>
-auto InvokeArgument(F f, Args... args) -> decltype(f(args...)) {
+auto InvokeArgument(F &&f,
-  return f(args...);
+                    Args... args) -> decltype(std::forward<F>(f)(args...)) {
  return std::forward<F>(f)(args...);
 }
 template <std::size_t index, typename... Params>
 struct InvokeArgumentAction {
  template <typename... Args,
            typename = typename std::enable_if<(index < sizeof...(Args))>::type>
-  auto operator()(Args &&...args) const -> decltype(internal::InvokeArgument(
+  auto operator()(Args &&...args) const
      -> decltype(internal::InvokeArgument(
          std::get<index>(std::forward_as_tuple(std::forward<Args>(args)...)),
          std::declval<const Params &>()...)) {
    internal::FlatTuple<Args &&...> args_tuple(FlatTupleConstructTag{},
                                               std::forward<Args>(args)...);
    return params.Apply([&](const Params &...unpacked_params) {
-      auto &&callable = args_tuple.template Get<index>();
+      auto &&callable = std::move(args_tuple.template Get<index>());
      return internal::InvokeArgument(
          std::forward<decltype(callable)>(callable), unpacked_params...);
    });
--- a/test/googletest/googlemock/include/gmock/gmock-more-matchers.h
+++ b/test/googletest/googlemock/include/gmock/gmock-more-matchers.h
@ -61,7 +61,7 @@ namespace internal {
 // Implements the polymorphic IsEmpty matcher, which
 // can be used as a Matcher<T> as long as T is either a container that defines
 // empty() and size() (e.g. std::vector or std::string), or a C-style string.
-class IsEmptyMatcher {
+class [[nodiscard]] IsEmptyMatcher {
 public:
  // Matches anything that defines empty() and size().
  template <typename MatcheeContainerType>
@ -76,9 +76,22 @@ class IsEmptyMatcher {
  // Matches C-style strings.
  bool MatchAndExplain(const char* s, MatchResultListener* listener) const {
    if (s == nullptr) {
      return false;
    }
    return MatchAndExplain(std::string(s), listener);
  }
 #if GTEST_HAS_STD_WSTRING
  // Matches C-style wide strings.
  bool MatchAndExplain(const wchar_t* s, MatchResultListener* listener) const {
    if (s == nullptr) {
      return false;
    }
    return MatchAndExplain(std::wstring(s), listener);
  }
 #endif  // GTEST_HAS_STD_WSTRING
  // Describes what this matcher matches.
  void DescribeTo(std::ostream* os) const { *os << "is empty"; }
--- a/test/googletest/googlemock/include/gmock/gmock-nice-strict.h
+++ b/test/googletest/googlemock/include/gmock/gmock-nice-strict.h
@ -71,11 +71,11 @@
 namespace testing {
 template <class MockClass>
-class NiceMock;
+class [[nodiscard]] NiceMock;
 template <class MockClass>
-class NaggyMock;
+class [[nodiscard]] NaggyMock;
 template <class MockClass>
-class StrictMock;
+class [[nodiscard]] StrictMock;
 namespace internal {
 template <typename T>
@ -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.
@ -108,7 +108,7 @@ constexpr bool HasStrictnessModifier() {
 #endif
 template <typename Base>
-class NiceMockImpl {
+class [[nodiscard]] NiceMockImpl {
 public:
  NiceMockImpl() {
    ::testing::Mock::AllowUninterestingCalls(reinterpret_cast<uintptr_t>(this));
@ -120,7 +120,7 @@ class NiceMockImpl {
 };
 template <typename Base>
-class NaggyMockImpl {
+class [[nodiscard]] NaggyMockImpl {
 public:
  NaggyMockImpl() {
    ::testing::Mock::WarnUninterestingCalls(reinterpret_cast<uintptr_t>(this));
@ -132,7 +132,7 @@ class NaggyMockImpl {
 };
 template <typename Base>
-class StrictMockImpl {
+class [[nodiscard]] StrictMockImpl {
 public:
  StrictMockImpl() {
    ::testing::Mock::FailUninterestingCalls(reinterpret_cast<uintptr_t>(this));
@ -146,7 +146,7 @@ class StrictMockImpl {
 }  // namespace internal
 template <class MockClass>
-class GTEST_INTERNAL_EMPTY_BASE_CLASS NiceMock
+class [[nodiscard]] GTEST_INTERNAL_EMPTY_BASE_CLASS NiceMock
    : private internal::NiceMockImpl<MockClass>,
      public MockClass {
 public:
@ -187,7 +187,7 @@ class GTEST_INTERNAL_EMPTY_BASE_CLASS NiceMock
 };
 template <class MockClass>
-class GTEST_INTERNAL_EMPTY_BASE_CLASS NaggyMock
+class [[nodiscard]] GTEST_INTERNAL_EMPTY_BASE_CLASS NaggyMock
    : private internal::NaggyMockImpl<MockClass>,
      public MockClass {
  static_assert(!internal::HasStrictnessModifier<MockClass>(),
@ -229,7 +229,7 @@ class GTEST_INTERNAL_EMPTY_BASE_CLASS NaggyMock
 };
 template <class MockClass>
-class GTEST_INTERNAL_EMPTY_BASE_CLASS StrictMock
+class [[nodiscard]] GTEST_INTERNAL_EMPTY_BASE_CLASS StrictMock
    : private internal::StrictMockImpl<MockClass>,
      public MockClass {
 public:
--- a/test/googletest/googlemock/include/gmock/gmock-spec-builders.h
+++ b/test/googletest/googlemock/include/gmock/gmock-spec-builders.h
@ -204,6 +204,9 @@ class GTEST_API_ UntypedFunctionMockerBase {
  using UntypedExpectations = std::vector<std::shared_ptr<ExpectationBase>>;
  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(...);
@ -1289,10 +1292,10 @@ class MockSpec {
      : function_mocker_(function_mocker), matchers_(matchers) {}
  // Adds a new default action spec to the function mocker and returns
-  // the newly created spec.
+  // the newly created spec. .WillByDefault() must be called on the returned
-  internal::OnCallSpec<F>& InternalDefaultActionSetAt(const char* file,
+  // object.
-                                                      int line, const char* obj,
+  [[nodiscard]] internal::OnCallSpec<F>& InternalDefaultActionSetAt(
-                                                      const char* call) {
+      const char* file, int line, const char* obj, const char* call) {
    LogWithLocation(internal::kInfo, file, line,
                    std::string("ON_CALL(") + obj + ", " + call + ") invoked");
    return function_mocker_->AddNewOnCallSpec(file, line, matchers_);
@ -1396,6 +1399,41 @@ class Cleanup final {
  std::function<void()> f_;
 };
 struct UntypedFunctionMockerBase::UninterestingCallCleanupHandler {
  CallReaction reaction;
  std::stringstream& ss;
  ~UninterestingCallCleanupHandler() {
    ReportUninterestingCall(reaction, ss.str());
  }
 };
 struct UntypedFunctionMockerBase::FailureCleanupHandler {
  std::stringstream& ss;
  std::stringstream& why;
  std::stringstream& loc;
  const ExpectationBase* untyped_expectation;
  bool found;
  bool is_excessive;
  ~FailureCleanupHandler() {
    ss << "\n" << why.str();
    if (!found) {
      // No expectation matches this call - reports a failure.
      Expect(false, nullptr, -1, ss.str());
    } else if (is_excessive) {
      // We had an upper-bound violation and the failure message is in ss.
      Expect(false, untyped_expectation->file(), untyped_expectation->line(),
             ss.str());
    } else {
      // We had an expected call and the matching expectation is
      // described in ss.
      Log(kInfo, loc.str() + ss.str(), 2);
    }
  }
 };
 template <typename F>
 class FunctionMocker;
@ -1408,7 +1446,7 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
  using ArgumentTuple = std::tuple<Args...>;
  using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>;
-  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.
@ -1429,7 +1467,7 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
  // function have been satisfied.  If not, it will report Google Test
  // non-fatal failures for the violations.
  ~FunctionMocker() override GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
-    MutexLock l(&g_gmock_mutex);
+    MutexLock l(g_gmock_mutex);
    VerifyAndClearExpectationsLocked();
    Mock::UnregisterLocked(this);
    ClearDefaultActionsLocked();
@ -1492,7 +1530,7 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
    UntypedOnCallSpecs specs_to_delete;
    untyped_on_call_specs_.swap(specs_to_delete);
-    g_gmock_mutex.Unlock();
+    g_gmock_mutex.unlock();
    for (UntypedOnCallSpecs::const_iterator it = specs_to_delete.begin();
         it != specs_to_delete.end(); ++it) {
      delete static_cast<const OnCallSpec<F>*>(*it);
@ -1500,7 +1538,7 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
    // Lock the mutex again, since the caller expects it to be locked when we
    // return.
-    g_gmock_mutex.Lock();
+    g_gmock_mutex.lock();
  }
  // Returns the result of invoking this mock function with the given
@ -1608,7 +1646,7 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
    const ArgumentTuple& args =
        *static_cast<const ArgumentTuple*>(untyped_args);
-    MutexLock l(&g_gmock_mutex);
+    MutexLock l(g_gmock_mutex);
    TypedExpectation<F>* exp = this->FindMatchingExpectationLocked(args);
    if (exp == nullptr) {  // A match wasn't found.
      this->FormatUnexpectedCallMessageLocked(args, what, why);
@ -1794,8 +1832,14 @@ R FunctionMocker<R(Args...)>::InvokeWith(ArgumentTuple&& args)
    //
    // We use RAII to do the latter in case R is void or a non-moveable type. In
    // either case we can't assign it to a local variable.
-    const Cleanup report_uninteresting_call(
+    //
-        [&] { ReportUninterestingCall(reaction, ss.str()); });
+    // Note that std::bind() is essential here.
    // We *don't* use any local callback types (like lambdas).
    // Doing so slows down compilation dramatically because the *constructor* of
    // std::function<T> is re-instantiated with different template
    // parameters each time.
    const UninterestingCallCleanupHandler report_uninteresting_call = {reaction,
                                                                       ss};
    return PerformActionAndPrintResult(nullptr, std::move(args), ss.str(), ss);
  }
@ -1839,22 +1883,13 @@ R FunctionMocker<R(Args...)>::InvokeWith(ArgumentTuple&& args)
  //
  // We use RAII to do the latter in case R is void or a non-moveable type. In
  // either case we can't assign it to a local variable.
-  const Cleanup handle_failures([&] {
+  //
-    ss << "\n" << why.str();
+  // Note that we *don't* use any local callback types (like lambdas) here.
-
+  // Doing so slows down compilation dramatically because the *constructor* of
-    if (!found) {
+  // std::function<T> is re-instantiated with different template
-      // No expectation matches this call - reports a failure.
+  // parameters each time.
-      Expect(false, nullptr, -1, ss.str());
+  const FailureCleanupHandler handle_failures = {
-    } else if (is_excessive) {
+      ss, why, loc, untyped_expectation, found, is_excessive};
      // We had an upper-bound violation and the failure message is in ss.
      Expect(false, untyped_expectation->file(), untyped_expectation->line(),
             ss.str());
    } else {
      // We had an expected call and the matching expectation is
      // described in ss.
      Log(kInfo, loc.str() + ss.str(), 2);
    }
  });
  return PerformActionAndPrintResult(untyped_action, std::move(args), ss.str(),
                                     ss);
@ -1922,6 +1957,11 @@ struct SignatureOf<R(Args...)> {
  using type = R(Args...);
 };
 template <typename R, typename... Args>
 struct SignatureOf<R(Args...) const> {
  using type = R(Args...);
 };
 template <template <typename> class C, typename F>
 struct SignatureOf<C<F>,
                   typename std::enable_if<std::is_function<F>::value>::type>
@ -2098,7 +2138,7 @@ GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
 // failure to disambiguate two overloads of this method in the ON_CALL statement
 // is how we block callers from setting expectations on overloaded methods.
 #define GMOCK_ON_CALL_IMPL_(mock_expr, Setter, call)                      \
-  ((mock_expr).gmock_##call)(::testing::internal::GetWithoutMatchers(), \
+  ((mock_expr).gmock_##call)(::testing::internal::WithoutMatchers::Get(), \
                             nullptr)                                     \
      .Setter(__FILE__, __LINE__, #mock_expr, #call)
--- a/test/googletest/googlemock/include/gmock/gmock.h
+++ b/test/googletest/googlemock/include/gmock/gmock.h
@ -53,13 +53,14 @@
 //
 // where all clauses are optional and WillOnce() can be repeated.
-#include "gmock/gmock-actions.h"
+#include "gmock/gmock-actions.h"  // IWYU pragma: export
-#include "gmock/gmock-cardinalities.h"
+#include "gmock/gmock-cardinalities.h"  // IWYU pragma: export
-#include "gmock/gmock-function-mocker.h"
+#include "gmock/gmock-function-mocker.h"  // IWYU pragma: export
-#include "gmock/gmock-matchers.h"
+#include "gmock/gmock-matchers.h"  // IWYU pragma: export
-#include "gmock/gmock-more-actions.h"
+#include "gmock/gmock-more-actions.h"  // IWYU pragma: export
-#include "gmock/gmock-more-matchers.h"
+#include "gmock/gmock-more-matchers.h"  // IWYU pragma: export
-#include "gmock/gmock-nice-strict.h"
+#include "gmock/gmock-nice-strict.h"  // IWYU pragma: export
 #include "gmock/gmock-spec-builders.h"  // IWYU pragma: export
 #include "gmock/internal/gmock-internal-utils.h"
 #include "gmock/internal/gmock-port.h"
--- a/test/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
+++ b/test/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
@ -41,9 +41,11 @@
 #include <stdio.h>
 #include <iterator>
 #include <ostream>  // NOLINT
 #include <string>
 #include <type_traits>
 #include <utility>
 #include <vector>
 #include "gmock/internal/gmock-port.h"
@ -192,11 +194,11 @@ using LosslessArithmeticConvertibleImpl = std::integral_constant<
       // Converting between integers of different widths is allowed so long
       // as the conversion does not go from signed to unsigned.
      (((sizeof(From) < sizeof(To)) &&
-        !(std::is_signed<From>::value && !std::is_signed<To>::value)) ||
+        !(std::is_signed_v<From> && !std::is_signed_v<To>)) ||
       // Converting between integers of the same width only requires the
       // two types to have the same signedness.
       ((sizeof(From) == sizeof(To)) &&
-        (std::is_signed<From>::value == std::is_signed<To>::value)))
+        (std::is_signed_v<From> == std::is_signed_v<To>)))
       ) ? true
      // Floating point conversions are lossless if and only if `To` is at least
      // as wide as `From`.
@ -219,12 +221,12 @@ using LosslessArithmeticConvertible =
 // This interface knows how to report a Google Mock failure (either
 // non-fatal or fatal).
-class FailureReporterInterface {
+class [[nodiscard]] FailureReporterInterface {
 public:
  // 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,
@ -295,14 +297,13 @@ GTEST_API_ void Log(LogSeverity severity, const std::string& message,
 //
 //    ON_CALL(mock, Method({}, nullptr))...
 //
-class WithoutMatchers {
+class [[nodiscard]] WithoutMatchers {
 private:
-  WithoutMatchers() {}
+  WithoutMatchers() = default;
  friend GTEST_API_ WithoutMatchers GetWithoutMatchers();
 };
-// Internal use only: access the singleton instance of WithoutMatchers.
+ public:
-GTEST_API_ WithoutMatchers GetWithoutMatchers();
+  GTEST_API_ static WithoutMatchers Get();
 };
 // Invalid<T>() is usable as an expression of type T, but will terminate
 // the program with an assertion failure if actually run.  This is useful
@ -311,7 +312,8 @@ GTEST_API_ WithoutMatchers GetWithoutMatchers();
 // crashes).
 template <typename T>
 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)
@ -321,6 +323,24 @@ inline T Invalid() {
 #endif
 }
 void GetValueType(const void*);
 template <class T>
 typename std::iterator_traits<
    decltype(std::begin(std::declval<T&>()))>::value_type
 GetValueType(T*);
 template <class T, class = void>
 struct RangeTraits {
  typedef decltype(internal::GetValueType(
      static_cast<std::remove_reference_t<T>*>(nullptr))) value_type;
 };
 template <class T>
 struct RangeTraits<T, std::conditional_t<true, void, typename T::value_type>> {
  typedef typename T::value_type value_type;
 };
 // Given a raw type (i.e. having no top-level reference or const
 // modifier) RawContainer that's either an STL-style container or a
 // native array, class StlContainerView<RawContainer> has the
@ -338,13 +358,13 @@ inline T Invalid() {
 // This generic version is used when RawContainer itself is already an
 // STL-style container.
 template <class RawContainer>
-class StlContainerView {
+class [[nodiscard]] StlContainerView {
 public:
  typedef RawContainer type;
  typedef const type& const_reference;
  static const_reference ConstReference(const RawContainer& container) {
-    static_assert(!std::is_const<RawContainer>::value,
+    static_assert(!std::is_const_v<RawContainer>,
                  "RawContainer type must not be const");
    return container;
  }
@ -353,7 +373,7 @@ class StlContainerView {
 // This specialization is used when RawContainer is a native array type.
 template <typename Element, size_t N>
-class StlContainerView<Element[N]> {
+class [[nodiscard]] StlContainerView<Element[N]> {
 public:
  typedef typename std::remove_const<Element>::type RawElement;
  typedef internal::NativeArray<RawElement> type;
@ -365,7 +385,7 @@ class StlContainerView<Element[N]> {
  typedef const type const_reference;
  static const_reference ConstReference(const Element (&array)[N]) {
-    static_assert(std::is_same<Element, RawElement>::value,
+    static_assert(std::is_same_v<Element, RawElement>,
                  "Element type must not be const");
    return type(array, N, RelationToSourceReference());
  }
@ -377,7 +397,7 @@ class StlContainerView<Element[N]> {
 // This specialization is used when RawContainer is a native array
 // represented as a (pointer, size) tuple.
 template <typename ElementPointer, typename Size>
-class StlContainerView< ::std::tuple<ElementPointer, Size> > {
+class [[nodiscard]] StlContainerView< ::std::tuple<ElementPointer, Size> > {
 public:
  typedef typename std::remove_const<
      typename std::pointer_traits<ElementPointer>::element_type>::type
@ -419,7 +439,7 @@ struct RemoveConstFromKey<std::pair<const K, V> > {
 GTEST_API_ void IllegalDoDefault(const char* file, int line);
 template <typename F, typename Tuple, size_t... Idx>
-auto ApplyImpl(F&& f, Tuple&& args, IndexSequence<Idx...>)
+auto ApplyImpl(F&& f, Tuple&& args, std::index_sequence<Idx...>)
    -> decltype(std::forward<F>(f)(
        std::get<Idx>(std::forward<Tuple>(args))...)) {
  return std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...);
@ -429,11 +449,11 @@ auto ApplyImpl(F&& f, Tuple&& args, IndexSequence<Idx...>)
 template <typename F, typename Tuple>
 auto Apply(F&& f, Tuple&& args) -> decltype(ApplyImpl(
    std::forward<F>(f), std::forward<Tuple>(args),
-    MakeIndexSequence<std::tuple_size<
+    std::make_index_sequence<
-        typename std::remove_reference<Tuple>::type>::value>())) {
+        std::tuple_size_v<std::remove_reference_t<Tuple>>>())) {
  return ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
-                   MakeIndexSequence<std::tuple_size<
+                   std::make_index_sequence<
-                       typename std::remove_reference<Tuple>::type>::value>());
+                       std::tuple_size_v<std::remove_reference_t<Tuple>>>());
 }
 // Template struct Function<F>, where F must be a function type, contains
@ -464,15 +484,12 @@ struct Function<R(Args...)> {
  using MakeResultIgnoredValue = IgnoredValue(Args...);
 };
 template <typename R, typename... Args>
 constexpr size_t Function<R(Args...)>::ArgumentCount;
 // Workaround for MSVC error C2039: 'type': is not a member of 'std'
 // when std::tuple_element is used.
 // See: https://github.com/google/googletest/issues/3931
 // Can be replaced with std::tuple_element_t in C++14.
 template <size_t I, typename T>
-using TupleElement = typename std::tuple_element<I, T>::type;
+using TupleElement = std::tuple_element_t<I, T>;
 bool Base64Unescape(const std::string& encoded, std::string* decoded);
--- a/test/googletest/googlemock/include/gmock/internal/gmock-port.h
+++ b/test/googletest/googlemock/include/gmock/internal/gmock-port.h
@ -42,6 +42,7 @@
 #include <assert.h>
 #include <stdlib.h>
 #include <cstdint>
 #include <iostream>
@ -56,7 +57,7 @@
 #include "gmock/internal/custom/gmock-port.h"
 #include "gtest/internal/gtest-port.h"
-#ifdef GTEST_HAS_ABSL
+#if defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
 #include "absl/flags/declare.h"
 #include "absl/flags/flag.h"
 #endif
@ -73,7 +74,7 @@
 #define GMOCK_FLAG(name) FLAGS_gmock_##name
 // Pick a command line flags implementation.
-#ifdef GTEST_HAS_ABSL
+#if defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
 // Macros for defining flags.
 #define GMOCK_DEFINE_bool_(name, default_val, doc) \
@ -85,17 +86,17 @@
 // Macros for declaring flags.
 #define GMOCK_DECLARE_bool_(name) \
-  ABSL_DECLARE_FLAG(bool, GMOCK_FLAG_NAME_(name))
+  GTEST_API_ ABSL_DECLARE_FLAG(bool, GMOCK_FLAG_NAME_(name))
 #define GMOCK_DECLARE_int32_(name) \
-  ABSL_DECLARE_FLAG(int32_t, GMOCK_FLAG_NAME_(name))
+  GTEST_API_ ABSL_DECLARE_FLAG(int32_t, GMOCK_FLAG_NAME_(name))
 #define GMOCK_DECLARE_string_(name) \
-  ABSL_DECLARE_FLAG(std::string, GMOCK_FLAG_NAME_(name))
+  GTEST_API_ ABSL_DECLARE_FLAG(std::string, GMOCK_FLAG_NAME_(name))
 #define GMOCK_FLAG_GET(name) ::absl::GetFlag(GMOCK_FLAG(name))
 #define GMOCK_FLAG_SET(name, value) \
  (void)(::absl::SetFlag(&GMOCK_FLAG(name), value))
-#else  // GTEST_HAS_ABSL
+#else  // defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
 // Macros for defining flags.
 #define GMOCK_DEFINE_bool_(name, default_val, doc)  \
@ -134,6 +135,6 @@
 #define GMOCK_FLAG_GET(name) ::testing::GMOCK_FLAG(name)
 #define GMOCK_FLAG_SET(name, value) (void)(::testing::GMOCK_FLAG(name) = value)
-#endif  // GTEST_HAS_ABSL
+#endif  // defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
 #endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
--- a/test/googletest/googlemock/include/gmock/internal/gmock-pp.h
+++ b/test/googletest/googlemock/include/gmock/internal/gmock-pp.h
@ -25,16 +25,18 @@
 //   GMOCK_PP_NARG(x, y) => 2
 //   GMOCK_PP_NARG(PAIR) => 2
 //
-// Requires: the number of arguments after expansion is at most 15.
+// Requires: the number of arguments after expansion is at most 31.
 #define GMOCK_PP_NARG(...)                                                     \
-  GMOCK_PP_INTERNAL_16TH(  \
+  GMOCK_PP_INTERNAL_32ND((__VA_ARGS__, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, \
-      (__VA_ARGS__, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))
+                          21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9,   \
                          8, 7, 6, 5, 4, 3, 2, 1, 0))
 // Returns 1 if the expansion of arguments has an unprotected comma. Otherwise
-// returns 0. Requires no more than 15 unprotected commas.
+// returns 0. Requires no more than 31 unprotected commas.
 #define GMOCK_PP_HAS_COMMA(...)                                               \
-  GMOCK_PP_INTERNAL_16TH(       \
+  GMOCK_PP_INTERNAL_32ND((__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
-      (__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0))
+                          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,  \
                          0, 0))
 // Returns the first argument.
 #define GMOCK_PP_HEAD(...) GMOCK_PP_INTERNAL_HEAD((__VA_ARGS__, unusedArg))
@ -51,7 +53,7 @@
 // If the arguments after expansion have no tokens, evaluates to `1`. Otherwise
 // evaluates to `0`.
 //
-// Requires: * the number of arguments after expansion is at most 15.
+// Requires: * the number of arguments after expansion is at most 31.
 //           * If the argument is a macro, it must be able to be called with one
 //             argument.
 //
@ -104,7 +106,7 @@
 //   GMOCK_PP_NARG0(x, y) => 2
 //   GMOCK_PP_NARG0(PAIR) => 2
 //
-// Requires: * the number of arguments after expansion is at most 15.
+// Requires: * the number of arguments after expansion is at most 31.
 //           * If the argument is a macro, it must be able to be called with one
 //             argument.
 #define GMOCK_PP_NARG0(...) \
@ -127,7 +129,7 @@
 // Expands to _Macro(0, _Data, e1) _Macro(1, _Data, e2) ... _Macro(K -1, _Data,
 // eK) as many of GMOCK_INTERNAL_NARG0 _Tuple.
 // Requires: * |_Macro| can be called with 3 arguments.
-//           * |_Tuple| expansion has no more than 15 elements.
+//           * |_Tuple| expansion has no more than 31 elements.
 #define GMOCK_PP_FOR_EACH(_Macro, _Data, _Tuple)                        \
  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, GMOCK_PP_NARG0 _Tuple) \
  (0, _Macro, _Data, _Tuple)
@ -135,20 +137,21 @@
 // Expands to _Macro(0, _Data, ) _Macro(1, _Data, ) ... _Macro(K - 1, _Data, )
 // Empty if _K = 0.
 // Requires: * |_Macro| can be called with 3 arguments.
-//           * |_K| literal between 0 and 15
+//           * |_K| literal between 0 and 31
 #define GMOCK_PP_REPEAT(_Macro, _Data, _N)           \
  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, _N) \
  (0, _Macro, _Data, GMOCK_PP_INTENRAL_EMPTY_TUPLE)
-// Increments the argument, requires the argument to be between 0 and 15.
+// Increments the argument, requires the argument to be between 0 and 31.
 #define GMOCK_PP_INC(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_INC_, _i)
-// Returns comma if _i != 0. Requires _i to be between 0 and 15.
+// Returns comma if _i != 0. Requires _i to be between 0 and 31.
 #define GMOCK_PP_COMMA_IF(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_COMMA_IF_, _i)
 // Internal details follow. Do not use any of these symbols outside of this
 // file or we will break your code.
-#define GMOCK_PP_INTENRAL_EMPTY_TUPLE (, , , , , , , , , , , , , , , )
+#define GMOCK_PP_INTENRAL_EMPTY_TUPLE \
  (, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , )
 #define GMOCK_PP_INTERNAL_CAT(_1, _2) _1##_2
 #define GMOCK_PP_INTERNAL_STRINGIZE(...) #__VA_ARGS__
 #define GMOCK_PP_INTERNAL_CAT_5(_1, _2, _3, _4, _5) _1##_2##_3##_4##_5
@ -164,12 +167,13 @@
 // tokens. We do that by using a "IDENTITY(MACRO PARENTHESIZED_ARGS)" macro. We
 // define one per possible macro that relies on this behavior. Note "_Args" must
 // be parenthesized.
-#define GMOCK_PP_INTERNAL_INTERNAL_16TH(_1, _2, _3, _4, _5, _6, _7, _8, _9, \
+#define GMOCK_PP_INTERNAL_INTERNAL_32ND(                                       \
-                                        _10, _11, _12, _13, _14, _15, _16,  \
+    _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16,     \
-                                        ...)                                \
+    _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, \
-  _16
+    _32, ...)                                                                  \
-#define GMOCK_PP_INTERNAL_16TH(_Args) \
+  _32
-  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_16TH _Args)
+#define GMOCK_PP_INTERNAL_32ND(_Args) \
  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_32ND _Args)
 #define GMOCK_PP_INTERNAL_INTERNAL_HEAD(_1, ...) _1
 #define GMOCK_PP_INTERNAL_HEAD(_Args) \
  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_HEAD _Args)
@ -198,6 +202,22 @@
 #define GMOCK_PP_INTERNAL_INC_13 14
 #define GMOCK_PP_INTERNAL_INC_14 15
 #define GMOCK_PP_INTERNAL_INC_15 16
 #define GMOCK_PP_INTERNAL_INC_16 17
 #define GMOCK_PP_INTERNAL_INC_17 18
 #define GMOCK_PP_INTERNAL_INC_18 19
 #define GMOCK_PP_INTERNAL_INC_19 20
 #define GMOCK_PP_INTERNAL_INC_20 21
 #define GMOCK_PP_INTERNAL_INC_21 22
 #define GMOCK_PP_INTERNAL_INC_22 23
 #define GMOCK_PP_INTERNAL_INC_23 24
 #define GMOCK_PP_INTERNAL_INC_24 25
 #define GMOCK_PP_INTERNAL_INC_25 26
 #define GMOCK_PP_INTERNAL_INC_26 27
 #define GMOCK_PP_INTERNAL_INC_27 28
 #define GMOCK_PP_INTERNAL_INC_28 29
 #define GMOCK_PP_INTERNAL_INC_29 30
 #define GMOCK_PP_INTERNAL_INC_30 31
 #define GMOCK_PP_INTERNAL_INC_31 32
 #define GMOCK_PP_INTERNAL_COMMA_IF_0
 #define GMOCK_PP_INTERNAL_COMMA_IF_1 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_2 ,
@ -214,6 +234,22 @@
 #define GMOCK_PP_INTERNAL_COMMA_IF_13 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_14 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_15 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_16 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_17 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_18 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_19 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_20 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_21 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_22 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_23 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_24 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_25 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_26 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_27 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_28 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_29 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_30 ,
 #define GMOCK_PP_INTERNAL_COMMA_IF_31 ,
 #define GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, _element) \
  _Macro(_i, _Data, _element)
 #define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_0(_i, _Macro, _Data, _Tuple)
@ -275,5 +311,69 @@
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
 #define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_16(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_15(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
 #define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_17(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_16(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
 #define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_18(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_17(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
 #define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_19(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_18(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
 #define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_20(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_19(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
 #define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_21(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_20(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
 #define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_22(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_21(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
 #define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_23(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_22(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
 #define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_24(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_23(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
 #define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_25(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_24(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
 #define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_26(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_25(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
 #define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_27(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_26(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
 #define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_28(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_27(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
 #define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_29(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_28(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
 #define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_30(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_29(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
 #define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_31(_i, _Macro, _Data, _Tuple)   \
  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_30(GMOCK_PP_INC(_i), _Macro, _Data,   \
                                     (GMOCK_PP_TAIL _Tuple))
 #endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_
--- a/test/googletest/googlemock/src/gmock-cardinalities.cc
+++ b/test/googletest/googlemock/src/gmock-cardinalities.cc
@ -53,12 +53,12 @@ class BetweenCardinalityImpl : public CardinalityInterface {
      : min_(min >= 0 ? min : 0), max_(max >= min_ ? max : min_) {
    std::stringstream ss;
    if (min < 0) {
-      ss << "The invocation lower bound must be >= 0, "
+      ss << "The invocation lower bound must be >= 0, " << "but is actually "
-         << "but is actually " << min << ".";
+         << min << ".";
      internal::Expect(false, __FILE__, __LINE__, ss.str());
    } else if (max < 0) {
-      ss << "The invocation upper bound must be >= 0, "
+      ss << "The invocation upper bound must be >= 0, " << "but is actually "
-         << "but is actually " << max << ".";
+         << max << ".";
      internal::Expect(false, __FILE__, __LINE__, ss.str());
    } else if (min > max) {
      ss << "The invocation upper bound (" << max
--- a/test/googletest/googlemock/src/gmock-internal-utils.cc
+++ b/test/googletest/googlemock/src/gmock-internal-utils.cc
@ -41,8 +41,10 @@
 #include <cctype>
 #include <cstdint>
 #include <cstring>
 #include <iostream>
 #include <ostream>  // NOLINT
 #include <string>
 #include <utility>
 #include <vector>
 #include "gmock/gmock.h"
@ -87,7 +89,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);
    }
  }
@ -154,7 +156,7 @@ GTEST_API_ void Log(LogSeverity severity, const std::string& message,
  if (!LogIsVisible(severity)) return;
  // Ensures that logs from different threads don't interleave.
-  MutexLock l(&g_log_mutex);
+  MutexLock l(g_log_mutex);
  if (severity == kWarning) {
    // Prints a GMOCK WARNING marker to make the warnings easily searchable.
@ -186,7 +188,7 @@ GTEST_API_ void Log(LogSeverity severity, const std::string& message,
  std::cout << ::std::flush;
 }
-GTEST_API_ WithoutMatchers GetWithoutMatchers() { return WithoutMatchers(); }
+GTEST_API_ WithoutMatchers WithoutMatchers::Get() { return WithoutMatchers(); }
 GTEST_API_ void IllegalDoDefault(const char* file, int line) {
  internal::Assert(
@ -210,14 +212,14 @@ constexpr char UnBase64Impl(char c, const char* const base64, char carry) {
 }
 template <size_t... I>
-constexpr std::array<char, 256> UnBase64Impl(IndexSequence<I...>,
+constexpr std::array<char, 256> UnBase64Impl(std::index_sequence<I...>,
                                             const char* const base64) {
  return {
      {UnBase64Impl(UndoWebSafeEncoding(static_cast<char>(I)), base64, 0)...}};
 }
 constexpr std::array<char, 256> UnBase64(const char* const base64) {
-  return UnBase64Impl(MakeIndexSequence<256>{}, base64);
+  return UnBase64Impl(std::make_index_sequence<256>{}, base64);
 }
 static constexpr char kBase64[] =
--- a/test/googletest/googlemock/src/gmock-matchers.cc
+++ b/test/googletest/googlemock/src/gmock-matchers.cc
@ -53,7 +53,7 @@ GTEST_API_ std::string FormatMatcherDescription(
    bool negation, const char* matcher_name,
    const std::vector<const char*>& 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;
@ -120,7 +120,7 @@ GTEST_API_ std::string FormatMatcherDescription(
 //   [1] Cormen, et al (2001). "Section 26.2: The Ford-Fulkerson method".
 //       "Introduction to Algorithms (Second ed.)", pp. 651-664.
 //   [2] "Ford-Fulkerson algorithm", Wikipedia,
-//       'http://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm'
+//       'https://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm'
 class MaxBipartiteMatchState {
 public:
  explicit MaxBipartiteMatchState(const MatchMatrix& graph)
@ -236,9 +236,8 @@ static void LogElementMatcherPairVec(const ElementMatcherPairs& pairs,
  os << "{";
  const char* sep = "";
  for (Iter it = pairs.begin(); it != pairs.end(); ++it) {
-    os << sep << "\n  ("
+    os << sep << "\n  (" << "element #" << it->first << ", " << "matcher #"
-       << "element #" << it->first << ", "
+       << it->second << ")";
       << "matcher #" << it->second << ")";
    sep = ",";
  }
  os << "\n}";
@ -374,20 +373,20 @@ bool UnorderedElementsAreMatcherImplBase::VerifyMatchMatrix(
    return true;
  }
-  if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
+  const bool is_exact_match_with_size_discrepency =
-    if (matrix.LhsSize() != matrix.RhsSize()) {
+      match_flags() == UnorderedMatcherRequire::ExactMatch &&
      matrix.LhsSize() != matrix.RhsSize();
  if (is_exact_match_with_size_discrepency) {
    // The element count doesn't match.  If the container is empty,
    // there's no need to explain anything as Google Mock already
    // prints the empty container. Otherwise we just need to show
    // how many elements there actually are.
    if (matrix.LhsSize() != 0 && listener->IsInterested()) {
-        *listener << "which has " << Elements(matrix.LhsSize());
+      *listener << "which has " << Elements(matrix.LhsSize()) << "\n";
      }
      return false;
    }
  }
-  bool result = true;
+  bool result = !is_exact_match_with_size_discrepency;
  ::std::vector<char> element_matched(matrix.LhsSize(), 0);
  ::std::vector<char> matcher_matched(matrix.RhsSize(), 0);
--- a/test/googletest/googlemock/src/gmock-spec-builders.cc
+++ b/test/googletest/googlemock/src/gmock-spec-builders.cc
@ -40,6 +40,7 @@
 #include <map>
 #include <memory>
 #include <set>
 #include <sstream>
 #include <string>
 #include <unordered_map>
 #include <vector>
@ -48,10 +49,10 @@
 #include "gtest/gtest.h"
 #include "gtest/internal/gtest-port.h"
-#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC
+#if defined(GTEST_OS_CYGWIN) || defined(GTEST_OS_LINUX) || defined(GTEST_OS_MAC)
 #include <unistd.h>  // NOLINT
 #endif
-#if GTEST_OS_QURT
+#ifdef GTEST_OS_QURT
 #include <qurt_event.h>
 #endif
@ -95,7 +96,7 @@ ExpectationBase::ExpectationBase(const char* a_file, int a_line,
      action_count_checked_(false) {}
 // Destructs an ExpectationBase object.
-ExpectationBase::~ExpectationBase() {}
+ExpectationBase::~ExpectationBase() = default;
 // Explicitly specifies the cardinality of this expectation.  Used by
 // the subclasses to implement the .Times() clause.
@ -211,7 +212,7 @@ void ExpectationBase::CheckActionCountIfNotDone() const
    GTEST_LOCK_EXCLUDED_(mutex_) {
  bool should_check = false;
  {
-    MutexLock l(&mutex_);
+    MutexLock l(mutex_);
    if (!action_count_checked_) {
      action_count_checked_ = true;
      should_check = true;
@ -292,7 +293,7 @@ void ReportUninterestingCall(CallReaction reaction, const std::string& msg) {
      Log(kWarning,
          msg +
              "\nNOTE: You can safely ignore the above warning unless this "
-              "call should not happen.  Do not suppress it by blindly adding "
+              "call should not happen.  Do not suppress it by adding "
              "an EXPECT_CALL() if you don't mean to enforce the call.  "
              "See "
              "https://github.com/google/googletest/blob/main/docs/"
@ -308,7 +309,7 @@ void ReportUninterestingCall(CallReaction reaction, const std::string& msg) {
 UntypedFunctionMockerBase::UntypedFunctionMockerBase()
    : mock_obj_(nullptr), name_("") {}
-UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {}
+UntypedFunctionMockerBase::~UntypedFunctionMockerBase() = default;
 // Sets the mock object this mock method belongs to, and registers
 // this information in the global mock registry.  Will be called
@ -317,7 +318,7 @@ UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {}
 void UntypedFunctionMockerBase::RegisterOwner(const void* mock_obj)
    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
  {
-    MutexLock l(&g_gmock_mutex);
+    MutexLock l(g_gmock_mutex);
    mock_obj_ = mock_obj;
  }
  Mock::Register(mock_obj, this);
@ -331,7 +332,7 @@ void UntypedFunctionMockerBase::SetOwnerAndName(const void* mock_obj,
    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
  // We protect name_ under g_gmock_mutex in case this mock function
  // is called from two threads concurrently.
-  MutexLock l(&g_gmock_mutex);
+  MutexLock l(g_gmock_mutex);
  mock_obj_ = mock_obj;
  name_ = name;
 }
@ -344,7 +345,7 @@ const void* UntypedFunctionMockerBase::MockObject() const
  {
    // We protect mock_obj_ under g_gmock_mutex in case this mock
    // function is called from two threads concurrently.
-    MutexLock l(&g_gmock_mutex);
+    MutexLock l(g_gmock_mutex);
    Assert(mock_obj_ != nullptr, __FILE__, __LINE__,
           "MockObject() must not be called before RegisterOwner() or "
           "SetOwnerAndName() has been called.");
@ -361,7 +362,7 @@ const char* UntypedFunctionMockerBase::Name() const
  {
    // We protect name_ under g_gmock_mutex in case this mock
    // function is called from two threads concurrently.
-    MutexLock l(&g_gmock_mutex);
+    MutexLock l(g_gmock_mutex);
    Assert(name_ != nullptr, __FILE__, __LINE__,
           "Name() must not be called before SetOwnerAndName() has "
           "been called.");
@ -435,9 +436,9 @@ bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked()
  UntypedExpectations expectations_to_delete;
  untyped_expectations_.swap(expectations_to_delete);
-  g_gmock_mutex.Unlock();
+  g_gmock_mutex.unlock();
  expectations_to_delete.clear();
-  g_gmock_mutex.Lock();
+  g_gmock_mutex.lock();
  return expectations_met;
 }
@ -489,6 +490,7 @@ class MockObjectRegistry {
  // failure, unless the user explicitly asked us to ignore it.
  ~MockObjectRegistry() {
    if (!GMOCK_FLAG_GET(catch_leaked_mocks)) return;
    internal::MutexLock l(internal::g_gmock_mutex);
    int leaked_count = 0;
    for (StateMap::const_iterator it = states_.begin(); it != states_.end();
@ -503,7 +505,7 @@ class MockObjectRegistry {
      std::cout << internal::FormatFileLocation(state.first_used_file,
                                                state.first_used_line);
      std::cout << " ERROR: this mock object";
-      if (state.first_used_test != "") {
+      if (!state.first_used_test.empty()) {
        std::cout << " (used in test " << state.first_used_test_suite << "."
                  << state.first_used_test << ")";
      }
@ -526,10 +528,10 @@ class MockObjectRegistry {
      // RUN_ALL_TESTS() has already returned when this destructor is
      // called.  Therefore we cannot use the normal Google Test
      // failure reporting mechanism.
-#if GTEST_OS_QURT
+#ifdef GTEST_OS_QURT
      qurt_exception_raise_fatal();
 #else
-      _exit(1);  // We cannot call exit() as it is not reentrant and
+      _Exit(1);  // We cannot call exit() as it is not reentrant and
                 // may already have been called.
 #endif
    }
@ -557,7 +559,7 @@ UninterestingCallReactionMap() {
 void SetReactionOnUninterestingCalls(uintptr_t mock_obj,
                                     internal::CallReaction reaction)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
+  internal::MutexLock l(internal::g_gmock_mutex);
  UninterestingCallReactionMap()[mock_obj] = reaction;
 }
@ -588,7 +590,7 @@ void Mock::FailUninterestingCalls(uintptr_t mock_obj)
 // entry in the call-reaction table should be removed.
 void Mock::UnregisterCallReaction(uintptr_t mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
+  internal::MutexLock l(internal::g_gmock_mutex);
  UninterestingCallReactionMap().erase(static_cast<uintptr_t>(mock_obj));
 }
@ -596,7 +598,7 @@ void Mock::UnregisterCallReaction(uintptr_t mock_obj)
 // made on the given mock object.
 internal::CallReaction Mock::GetReactionOnUninterestingCalls(
    const void* mock_obj) GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
+  internal::MutexLock l(internal::g_gmock_mutex);
  return (UninterestingCallReactionMap().count(
              reinterpret_cast<uintptr_t>(mock_obj)) == 0)
             ? internal::intToCallReaction(
@ -609,7 +611,7 @@ internal::CallReaction Mock::GetReactionOnUninterestingCalls(
 // objects.
 void Mock::AllowLeak(const void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
+  internal::MutexLock l(internal::g_gmock_mutex);
  g_mock_object_registry.states()[mock_obj].leakable = true;
 }
@ -618,7 +620,7 @@ void Mock::AllowLeak(const void* mock_obj)
 // Test non-fatal failures and returns false.
 bool Mock::VerifyAndClearExpectations(void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
+  internal::MutexLock l(internal::g_gmock_mutex);
  return VerifyAndClearExpectationsLocked(mock_obj);
 }
@ -627,7 +629,7 @@ bool Mock::VerifyAndClearExpectations(void* mock_obj)
 // verification was successful.
 bool Mock::VerifyAndClear(void* mock_obj)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
+  internal::MutexLock l(internal::g_gmock_mutex);
  ClearDefaultActionsLocked(mock_obj);
  return VerifyAndClearExpectationsLocked(mock_obj);
 }
@ -677,7 +679,7 @@ bool Mock::IsStrict(void* mock_obj)
 void Mock::Register(const void* mock_obj,
                    internal::UntypedFunctionMockerBase* mocker)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
+  internal::MutexLock l(internal::g_gmock_mutex);
  g_mock_object_registry.states()[mock_obj].function_mockers.insert(mocker);
 }
@ -687,7 +689,7 @@ void Mock::Register(const void* mock_obj,
 void Mock::RegisterUseByOnCallOrExpectCall(const void* mock_obj,
                                           const char* file, int line)
    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
-  internal::MutexLock l(&internal::g_gmock_mutex);
+  internal::MutexLock l(internal::g_gmock_mutex);
  MockObjectState& state = g_mock_object_registry.states()[mock_obj];
  if (state.first_used_file == nullptr) {
    state.first_used_file = file;
@ -745,13 +747,13 @@ void Mock::ClearDefaultActionsLocked(void* mock_obj)
  // needed by VerifyAndClearExpectationsLocked().
 }
-Expectation::Expectation() {}
+Expectation::Expectation() = default;
 Expectation::Expectation(
    const std::shared_ptr<internal::ExpectationBase>& an_expectation_base)
    : expectation_base_(an_expectation_base) {}
-Expectation::~Expectation() {}
+Expectation::~Expectation() = default;
 // Adds an expectation to a sequence.
 void Sequence::AddExpectation(const Expectation& expectation) const {
--- a/test/googletest/googlemock/src/gmock.cc
+++ b/test/googletest/googlemock/src/gmock.cc
@ -29,6 +29,8 @@
 #include "gmock/gmock.h"
 #include <string>
 #include "gmock/internal/gmock-port.h"
 GMOCK_DEFINE_bool_(catch_leaked_mocks, true,
--- a/test/googletest/googlemock/src/gmock_main.cc
+++ b/test/googletest/googlemock/src/gmock_main.cc
@ -32,8 +32,9 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#if GTEST_OS_ESP8266 || GTEST_OS_ESP32
+#if defined(GTEST_OS_ESP8266) || defined(GTEST_OS_ESP32) || \
-#if GTEST_OS_ESP8266
+    (defined(GTEST_OS_NRF52) && defined(ARDUINO))
 #ifdef GTEST_OS_ESP8266
 extern "C" {
 #endif
 void setup() {
@ -43,7 +44,7 @@ void setup() {
  testing::InitGoogleMock();
 }
 void loop() { RUN_ALL_TESTS(); }
-#if GTEST_OS_ESP8266
+#ifdef GTEST_OS_ESP8266
 }
 #endif
@ -55,7 +56,7 @@ void loop() { RUN_ALL_TESTS(); }
 // Windows. See the following link to track the current status of this bug:
 // https://web.archive.org/web/20170912203238/connect.microsoft.com/VisualStudio/feedback/details/394464/wmain-link-error-in-the-static-library
 // // NOLINT
-#if GTEST_OS_WINDOWS_MOBILE
+#ifdef GTEST_OS_WINDOWS_MOBILE
 #include <tchar.h>  // NOLINT
 GTEST_API_ int _tmain(int argc, TCHAR** argv) {
--- a/test/googletest/googlemock/test/BUILD.bazel
+++ b/test/googletest/googlemock/test/BUILD.bazel
@ -30,6 +30,7 @@
 #
 #   Bazel Build for Google C++ Testing Framework(Google Test)-googlemock
 load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_test")
 load("@rules_python//python:defs.bzl", "py_library", "py_test")
 licenses(["notice"])
--- a/test/googletest/googlemock/test/gmock-actions_test.cc
+++ b/test/googletest/googlemock/test/gmock-actions_test.cc
@ -37,14 +37,18 @@
 #include <functional>
 #include <iterator>
 #include <memory>
 #include <sstream>
 #include <string>
 #include <tuple>
 #include <type_traits>
 #include <utility>
 #include <vector>
 #include "gmock/gmock.h"
 #include "gmock/internal/gmock-port.h"
 #include "gtest/gtest-spi.h"
 #include "gtest/gtest.h"
 #include "gtest/internal/gtest-port.h"
 // Silence C4100 (unreferenced formal parameter) and C4503 (decorated name
 // length exceeded) for MSVC.
@ -62,29 +66,29 @@ using ::testing::internal::BuiltInDefaultValue;
 TEST(TypeTraits, Negation) {
  // Direct use with std types.
-  static_assert(std::is_base_of<std::false_type,
+  static_assert(
-                                internal::negation<std::true_type>>::value,
+      std::is_base_of_v<std::false_type, internal::negation<std::true_type>>,
      "");
-  static_assert(std::is_base_of<std::true_type,
+  static_assert(
-                                internal::negation<std::false_type>>::value,
+      std::is_base_of_v<std::true_type, internal::negation<std::false_type>>,
      "");
  // With other types that fit the requirement of a value member that is
  // convertible to bool.
-  static_assert(std::is_base_of<
+  static_assert(
-                    std::true_type,
+      std::is_base_of_v<std::true_type,
-                    internal::negation<std::integral_constant<int, 0>>>::value,
+                        internal::negation<std::integral_constant<int, 0>>>,
      "");
-  static_assert(std::is_base_of<
+  static_assert(
-                    std::false_type,
+      std::is_base_of_v<std::false_type,
-                    internal::negation<std::integral_constant<int, 1>>>::value,
+                        internal::negation<std::integral_constant<int, 1>>>,
      "");
-  static_assert(std::is_base_of<
+  static_assert(
-                    std::false_type,
+      std::is_base_of_v<std::false_type,
-                    internal::negation<std::integral_constant<int, -1>>>::value,
+                        internal::negation<std::integral_constant<int, -1>>>,
      "");
 }
@ -104,79 +108,76 @@ struct MyTrue : std::integral_constant<int, -1> {};
 TEST(TypeTraits, Conjunction) {
  // Base case: always true.
-  static_assert(std::is_base_of<std::true_type, internal::conjunction<>>::value,
+  static_assert(std::is_base_of_v<std::true_type, internal::conjunction<>>, "");
                "");
  // One predicate: inherits from that predicate, regardless of value.
  static_assert(
-      std::is_base_of<MyFalse<0>, internal::conjunction<MyFalse<0>>>::value,
+      std::is_base_of_v<MyFalse<0>, internal::conjunction<MyFalse<0>>>, "");
      "");
-  static_assert(
+  static_assert(std::is_base_of_v<MyTrue<0>, internal::conjunction<MyTrue<0>>>,
-      std::is_base_of<MyTrue<0>, internal::conjunction<MyTrue<0>>>::value, "");
+                "");
  // Multiple predicates, with at least one false: inherits from that one.
  static_assert(
-      std::is_base_of<MyFalse<1>, internal::conjunction<MyTrue<0>, MyFalse<1>,
+      std::is_base_of_v<
-                                                        MyTrue<2>>>::value,
+          MyFalse<1>, internal::conjunction<MyTrue<0>, MyFalse<1>, MyTrue<2>>>,
      "");
  static_assert(
-      std::is_base_of<MyFalse<1>, internal::conjunction<MyTrue<0>, MyFalse<1>,
+      std::is_base_of_v<
-                                                        MyFalse<2>>>::value,
+          MyFalse<1>, internal::conjunction<MyTrue<0>, MyFalse<1>, MyFalse<2>>>,
      "");
  // Short circuiting: in the case above, additional predicates need not even
  // define a value member.
  struct Empty {};
  static_assert(
-      std::is_base_of<MyFalse<1>, internal::conjunction<MyTrue<0>, MyFalse<1>,
+      std::is_base_of_v<MyFalse<1>,
-                                                        Empty>>::value,
+                        internal::conjunction<MyTrue<0>, MyFalse<1>, Empty>>,
      "");
  // All predicates true: inherits from the last.
  static_assert(
-      std::is_base_of<MyTrue<2>, internal::conjunction<MyTrue<0>, MyTrue<1>,
+      std::is_base_of_v<MyTrue<2>,
-                                                       MyTrue<2>>>::value,
+                        internal::conjunction<MyTrue<0>, MyTrue<1>, MyTrue<2>>>,
      "");
 }
 TEST(TypeTraits, Disjunction) {
  // Base case: always false.
-  static_assert(
+  static_assert(std::is_base_of_v<std::false_type, internal::disjunction<>>,
-      std::is_base_of<std::false_type, internal::disjunction<>>::value, "");
+                "");
  // One predicate: inherits from that predicate, regardless of value.
  static_assert(
-      std::is_base_of<MyFalse<0>, internal::disjunction<MyFalse<0>>>::value,
+      std::is_base_of_v<MyFalse<0>, internal::disjunction<MyFalse<0>>>, "");
      "");
-  static_assert(
+  static_assert(std::is_base_of_v<MyTrue<0>, internal::disjunction<MyTrue<0>>>,
-      std::is_base_of<MyTrue<0>, internal::disjunction<MyTrue<0>>>::value, "");
+                "");
  // Multiple predicates, with at least one true: inherits from that one.
  static_assert(
-      std::is_base_of<MyTrue<1>, internal::disjunction<MyFalse<0>, MyTrue<1>,
+      std::is_base_of_v<
-                                                       MyFalse<2>>>::value,
+          MyTrue<1>, internal::disjunction<MyFalse<0>, MyTrue<1>, MyFalse<2>>>,
      "");
  static_assert(
-      std::is_base_of<MyTrue<1>, internal::disjunction<MyFalse<0>, MyTrue<1>,
+      std::is_base_of_v<
-                                                       MyTrue<2>>>::value,
+          MyTrue<1>, internal::disjunction<MyFalse<0>, MyTrue<1>, MyTrue<2>>>,
      "");
  // Short circuiting: in the case above, additional predicates need not even
  // define a value member.
  struct Empty {};
  static_assert(
-      std::is_base_of<MyTrue<1>, internal::disjunction<MyFalse<0>, MyTrue<1>,
+      std::is_base_of_v<MyTrue<1>,
-                                                       Empty>>::value,
+                        internal::disjunction<MyFalse<0>, MyTrue<1>, Empty>>,
      "");
  // All predicates false: inherits from the last.
  static_assert(
-      std::is_base_of<MyFalse<2>, internal::disjunction<MyFalse<0>, MyFalse<1>,
+      std::is_base_of_v<MyFalse<2>, internal::disjunction<
-                                                        MyFalse<2>>>::value,
+                                        MyFalse<0>, MyFalse<1>, MyFalse<2>>>,
      "");
 }
@ -184,7 +185,7 @@ TEST(TypeTraits, IsInvocableRV) {
  struct C {
    int operator()() const { return 0; }
    void operator()(int) & {}
-    std::string operator()(int) && { return ""; };
+    std::string operator()(int) && { return ""; }
  };
  // The first overload is callable for const and non-const rvalues and lvalues.
@ -218,7 +219,8 @@ TEST(TypeTraits, IsInvocableRV) {
  // In C++17 and above, where it's guaranteed that functions can return
  // non-moveable objects, everything should work fine for non-moveable rsult
  // types too.
-#if defined(__cplusplus) && __cplusplus >= 201703L
+  // TODO(b/396121064) - Fix this test under MSVC
 #ifndef _MSC_VER
  {
    struct NonMoveable {
      NonMoveable() = default;
@ -239,7 +241,7 @@ TEST(TypeTraits, IsInvocableRV) {
    static_assert(!internal::is_callable_r<int, Callable>::value);
    static_assert(!internal::is_callable_r<NonMoveable, Callable, int>::value);
  }
-#endif  // C++17 and above
+#endif  // _MSC_VER
  // Nothing should choke when we try to call other arguments besides directly
  // callable objects, but they should not show up as callable.
@ -436,15 +438,15 @@ TEST(DefaultValueDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
  EXPECT_EQ(0, DefaultValue<int>::Get());
-  EXPECT_DEATH_IF_SUPPORTED({ DefaultValue<MyNonDefaultConstructible>::Get(); },
+  EXPECT_DEATH_IF_SUPPORTED(
-                            "");
+      { DefaultValue<MyNonDefaultConstructible>::Get(); }, "");
 }
 TEST(DefaultValueTest, GetWorksForMoveOnlyIfSet) {
  EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
  EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Get() == nullptr);
  DefaultValue<std::unique_ptr<int>>::SetFactory(
-      [] { return std::unique_ptr<int>(new int(42)); });
+      [] { return std::make_unique<int>(42); });
  EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
  std::unique_ptr<int> i = DefaultValue<std::unique_ptr<int>>::Get();
  EXPECT_EQ(42, *i);
@ -500,8 +502,8 @@ TEST(DefaultValueOfReferenceDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
  EXPECT_FALSE(DefaultValue<MyNonDefaultConstructible&>::IsSet());
  EXPECT_DEATH_IF_SUPPORTED({ DefaultValue<int&>::Get(); }, "");
-  EXPECT_DEATH_IF_SUPPORTED({ DefaultValue<MyNonDefaultConstructible>::Get(); },
+  EXPECT_DEATH_IF_SUPPORTED(
-                            "");
+      { DefaultValue<MyNonDefaultConstructible>::Get(); }, "");
 }
 // Tests that ActionInterface can be implemented by defining the
@ -742,8 +744,8 @@ TEST(ReturnTest, ConversionRequiresConstLvalueReference) {
  using R = int;
  using U = std::reference_wrapper<const int>;
-  static_assert(std::is_convertible<const R&, U>::value, "");
+  static_assert(std::is_convertible_v<const R&, U>, "");
-  static_assert(!std::is_convertible<R, U>::value, "");
+  static_assert(!std::is_convertible_v<R, U>, "");
  MockFunction<U()> mock;
  EXPECT_CALL(mock, Call).WillOnce(Return(17)).WillRepeatedly(Return(19));
@ -766,11 +768,11 @@ TEST(ReturnTest, ConversionRequiresMutableLvalueReference) {
    S(std::string&) {}  // NOLINT
  };
-  static_assert(std::is_convertible<std::string&, S>::value, "");
+  static_assert(std::is_convertible_v<std::string&, S>, "");
 #ifndef _MSC_VER
-  static_assert(!std::is_convertible<std::string&&, S>::value, "");
+  static_assert(!std::is_convertible_v<std::string&&, S>, "");
 #endif
-  static_assert(!std::is_convertible<const std::string&, S>::value, "");
+  static_assert(!std::is_convertible_v<const std::string&, S>, "");
  // It shouldn't be possible to use the result of Return(std::string) in a
  // context where an S is needed.
@ -779,9 +781,9 @@ TEST(ReturnTest, ConversionRequiresMutableLvalueReference) {
  // implementation of is_convertible causes our SFINAE to be wrong.
  using RA = decltype(Return(std::string()));
-  static_assert(!std::is_convertible<RA, Action<S()>>::value, "");
+  static_assert(!std::is_convertible_v<RA, Action<S()>>, "");
 #ifndef _MSC_VER
-  static_assert(!std::is_convertible<RA, OnceAction<S()>>::value, "");
+  static_assert(!std::is_convertible_v<RA, OnceAction<S()>>, "");
 #endif
 }
@ -798,8 +800,8 @@ TEST(ReturnTest, MoveOnlyResultType) {
  // The result of Return should not be convertible to Action (so it can't be
  // used with WillRepeatedly).
-  static_assert(!std::is_convertible<decltype(Return(std::unique_ptr<int>())),
+  static_assert(!std::is_convertible_v<decltype(Return(std::unique_ptr<int>())),
-                                     Action<std::unique_ptr<int>()>>::value,
+                                       Action<std::unique_ptr<int>()>>,
                "");
 }
@ -982,7 +984,7 @@ TEST(ReturnRoundRobinTest, WorksForVector) {
 class MockClass {
 public:
-  MockClass() {}
+  MockClass() = default;
  MOCK_METHOD1(IntFunc, int(bool flag));  // NOLINT
  MOCK_METHOD0(Foo, MyNonDefaultConstructible());
@ -1025,8 +1027,7 @@ void VoidFunc(bool /* flag */) {}
 TEST(DoDefaultDeathTest, DiesIfUsedInCompositeAction) {
  MockClass mock;
-  EXPECT_CALL(mock, IntFunc(_))
+  EXPECT_CALL(mock, IntFunc(_)).WillRepeatedly(DoAll(VoidFunc, DoDefault()));
      .WillRepeatedly(DoAll(Invoke(VoidFunc), DoDefault()));
  // Ideally we should verify the error message as well.  Sadly,
  // EXPECT_DEATH() can only capture stderr, while Google Mock's
@ -1221,37 +1222,41 @@ class Foo {
 // Tests InvokeWithoutArgs(function).
 TEST(InvokeWithoutArgsTest, Function) {
  GTEST_DISABLE_DEPRECATED_PUSH_()
  // As an action that takes one argument.
-  Action<int(int)> a = InvokeWithoutArgs(Nullary);  // NOLINT
+  Action<int(int)> a = Nullary;  // NOLINT
  EXPECT_EQ(1, a.Perform(std::make_tuple(2)));
  // As an action that takes two arguments.
-  Action<int(int, double)> a2 = InvokeWithoutArgs(Nullary);  // NOLINT
+  Action<int(int, double)> a2 = Nullary;  // NOLINT
  EXPECT_EQ(1, a2.Perform(std::make_tuple(2, 3.5)));
  // As an action that returns void.
-  Action<void(int)> a3 = InvokeWithoutArgs(VoidNullary);  // NOLINT
+  Action<void(int)> a3 = VoidNullary;  // NOLINT
  g_done = false;
  a3.Perform(std::make_tuple(1));
  EXPECT_TRUE(g_done);
  GTEST_DISABLE_DEPRECATED_POP_()
 }
 // Tests InvokeWithoutArgs(functor).
 TEST(InvokeWithoutArgsTest, Functor) {
  GTEST_DISABLE_DEPRECATED_PUSH_()
  // As an action that takes no argument.
-  Action<int()> a = InvokeWithoutArgs(NullaryFunctor());  // NOLINT
+  Action<int()> a = NullaryFunctor();  // NOLINT
  EXPECT_EQ(2, a.Perform(std::make_tuple()));
  // As an action that takes three arguments.
  Action<int(int, double, char)> a2 =  // NOLINT
-      InvokeWithoutArgs(NullaryFunctor());
+      NullaryFunctor();
  EXPECT_EQ(2, a2.Perform(std::make_tuple(3, 3.5, 'a')));
  // As an action that returns void.
-  Action<void()> a3 = InvokeWithoutArgs(VoidNullaryFunctor());
+  Action<void()> a3 = VoidNullaryFunctor();
  g_done = false;
  a3.Perform(std::make_tuple());
  EXPECT_TRUE(g_done);
  GTEST_DISABLE_DEPRECATED_POP_()
 }
 // Tests InvokeWithoutArgs(obj_ptr, method).
@ -1277,7 +1282,7 @@ int ReturnOne() {
 TEST(IgnoreResultTest, MonomorphicAction) {
  g_done = false;
-  Action<void()> a = IgnoreResult(Invoke(ReturnOne));
+  Action<void()> a = IgnoreResult(&ReturnOne);
  a.Perform(std::make_tuple());
  EXPECT_TRUE(g_done);
 }
@ -1292,7 +1297,7 @@ MyNonDefaultConstructible ReturnMyNonDefaultConstructible(double /* x */) {
 TEST(IgnoreResultTest, ActionReturningClass) {
  g_done = false;
  Action<void(int)> a =
-      IgnoreResult(Invoke(ReturnMyNonDefaultConstructible));  // NOLINT
+      IgnoreResult(&ReturnMyNonDefaultConstructible);  // NOLINT
  a.Perform(std::make_tuple(2));
  EXPECT_TRUE(g_done);
 }
@ -1306,7 +1311,7 @@ TEST(AssignTest, Int) {
 TEST(AssignTest, String) {
  ::std::string x;
-  Action<void(void)> a = Assign(&x, "Hello, world");
+  Action<void()> a = Assign(&x, "Hello, world");
  a.Perform(std::make_tuple());
  EXPECT_EQ("Hello, world", x);
 }
@ -1472,9 +1477,50 @@ TEST(DoAll, SupportsTypeErasedActions) {
  }
 }
 // A multi-action DoAll action should be convertible to a OnceAction, even when
 // its component sub-actions are user-provided types that define only an Action
 // conversion operator. If they supposed being called more than once then they
 // also support being called at most once.
 //
 // Single-arg DoAll just returns its argument, so will prefer the Action<F>
 // overload for WillOnce.
 TEST(DoAll, ConvertibleToOnceActionWithUserProvidedActionConversion) {
  // Final action.
  struct CustomFinal final {
    operator Action<int()>() {  // NOLINT
      return Return(17);
    }
    operator Action<int(int, char)>() {  // NOLINT
      return Return(19);
    }
  };
  // Sub-actions.
  struct CustomInitial final {
    operator Action<void()>() {  // NOLINT
      return [] {};
    }
    operator Action<void(int, char)>() {  // NOLINT
      return [] {};
    }
  };
  {
    OnceAction<int()> action = DoAll(CustomInitial{}, CustomFinal{});
    EXPECT_EQ(17, std::move(action).Call());
  }
  {
    OnceAction<int(int, char)> action = DoAll(CustomInitial{}, CustomFinal{});
    EXPECT_EQ(19, std::move(action).Call(0, 0));
  }
 }
 // Tests using WithArgs and with an action that takes 1 argument.
 TEST(WithArgsTest, OneArg) {
-  Action<bool(double x, int n)> a = WithArgs<1>(Invoke(Unary));  // NOLINT
+  Action<bool(double x, int n)> a = WithArgs<1>(Unary);
  EXPECT_TRUE(a.Perform(std::make_tuple(1.5, -1)));
  EXPECT_FALSE(a.Perform(std::make_tuple(1.5, 1)));
 }
@ -1482,7 +1528,7 @@ TEST(WithArgsTest, OneArg) {
 // Tests using WithArgs with an action that takes 2 arguments.
 TEST(WithArgsTest, TwoArgs) {
  Action<const char*(const char* s, double x, short n)> a =  // NOLINT
-      WithArgs<0, 2>(Invoke(Binary));
+      WithArgs<0, 2>(Binary);
  const char s[] = "Hello";
  EXPECT_EQ(s + 2, a.Perform(std::make_tuple(CharPtr(s), 0.5, Short(2))));
 }
@ -1498,7 +1544,7 @@ struct ConcatAll {
 // Tests using WithArgs with an action that takes 10 arguments.
 TEST(WithArgsTest, TenArgs) {
  Action<std::string(const char*, const char*, const char*, const char*)> a =
-      WithArgs<0, 1, 2, 3, 2, 1, 0, 1, 2, 3>(Invoke(ConcatAll{}));
+      WithArgs<0, 1, 2, 3, 2, 1, 0, 1, 2, 3>(ConcatAll{});
  EXPECT_EQ("0123210123",
            a.Perform(std::make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
                                      CharPtr("3"))));
@ -1523,21 +1569,21 @@ TEST(WithArgsTest, NonInvokeAction) {
 // Tests using WithArgs to pass all original arguments in the original order.
 TEST(WithArgsTest, Identity) {
  Action<int(int x, char y, short z)> a =  // NOLINT
-      WithArgs<0, 1, 2>(Invoke(Ternary));
+      WithArgs<0, 1, 2>(Ternary);
  EXPECT_EQ(123, a.Perform(std::make_tuple(100, Char(20), Short(3))));
 }
 // Tests using WithArgs with repeated arguments.
 TEST(WithArgsTest, RepeatedArguments) {
  Action<int(bool, int m, int n)> a =  // NOLINT
-      WithArgs<1, 1, 1, 1>(Invoke(SumOf4));
+      WithArgs<1, 1, 1, 1>(SumOf4);
  EXPECT_EQ(4, a.Perform(std::make_tuple(false, 1, 10)));
 }
 // Tests using WithArgs with reversed argument order.
 TEST(WithArgsTest, ReversedArgumentOrder) {
  Action<const char*(short n, const char* input)> a =  // NOLINT
-      WithArgs<1, 0>(Invoke(Binary));
+      WithArgs<1, 0>(Binary);
  const char s[] = "Hello";
  EXPECT_EQ(s + 2, a.Perform(std::make_tuple(Short(2), CharPtr(s))));
 }
@ -1545,14 +1591,14 @@ TEST(WithArgsTest, ReversedArgumentOrder) {
 // Tests using WithArgs with compatible, but not identical, argument types.
 TEST(WithArgsTest, ArgsOfCompatibleTypes) {
  Action<long(short x, char y, double z, char c)> a =  // NOLINT
-      WithArgs<0, 1, 3>(Invoke(Ternary));
+      WithArgs<0, 1, 3>(Ternary);
  EXPECT_EQ(123,
            a.Perform(std::make_tuple(Short(100), Char(20), 5.6, Char(3))));
 }
 // Tests using WithArgs with an action that returns void.
 TEST(WithArgsTest, VoidAction) {
-  Action<void(double x, char c, int n)> a = WithArgs<2, 1>(Invoke(VoidBinary));
+  Action<void(double x, char c, int n)> a = WithArgs<2, 1>(VoidBinary);
  g_done = false;
  a.Perform(std::make_tuple(1.5, 'a', 3));
  EXPECT_TRUE(g_done);
@ -1592,7 +1638,23 @@ TEST(WithArgsTest, RefQualifiedInnerAction) {
  EXPECT_EQ(19, mock.AsStdFunction()(0, 17));
 }
-#if !GTEST_OS_WINDOWS_MOBILE
+// It should be fine to provide an lvalue WithArgsAction to WillOnce, even when
 // the inner action only wants to convert to OnceAction.
 TEST(WithArgsTest, ProvideAsLvalueToWillOnce) {
  struct SomeAction {
    operator OnceAction<int(int)>() const {  // NOLINT
      return [](const int arg) { return arg + 2; };
    }
  };
  const auto wa = WithArg<1>(SomeAction{});
  MockFunction<int(int, int)> mock;
  EXPECT_CALL(mock, Call).WillOnce(wa);
  EXPECT_EQ(19, mock.AsStdFunction()(0, 17));
 }
 #ifndef GTEST_OS_WINDOWS_MOBILE
 class SetErrnoAndReturnTest : public testing::Test {
 protected:
@ -1601,14 +1663,14 @@ class SetErrnoAndReturnTest : public testing::Test {
 };
 TEST_F(SetErrnoAndReturnTest, Int) {
-  Action<int(void)> a = SetErrnoAndReturn(ENOTTY, -5);
+  Action<int()> a = SetErrnoAndReturn(ENOTTY, -5);
  EXPECT_EQ(-5, a.Perform(std::make_tuple()));
  EXPECT_EQ(ENOTTY, errno);
 }
 TEST_F(SetErrnoAndReturnTest, Ptr) {
  int x;
-  Action<int*(void)> a = SetErrnoAndReturn(ENOTTY, &x);
+  Action<int*()> a = SetErrnoAndReturn(ENOTTY, &x);
  EXPECT_EQ(&x, a.Perform(std::make_tuple()));
  EXPECT_EQ(ENOTTY, errno);
 }
@ -1751,9 +1813,7 @@ TEST(ReturnNewTest, ConstructorThatTakes10Arguments) {
  delete c;
 }
-std::unique_ptr<int> UniquePtrSource() {
+std::unique_ptr<int> UniquePtrSource() { return std::make_unique<int>(19); }
  return std::unique_ptr<int>(new int(19));
 }
 std::vector<std::unique_ptr<int>> VectorUniquePtrSource() {
  std::vector<std::unique_ptr<int>> out;
@ -1763,7 +1823,7 @@ std::vector<std::unique_ptr<int>> VectorUniquePtrSource() {
 TEST(MockMethodTest, CanReturnMoveOnlyValue_Return) {
  MockClass mock;
-  std::unique_ptr<int> i(new int(19));
+  std::unique_ptr<int> i = std::make_unique<int>(19);
  EXPECT_CALL(mock, MakeUnique()).WillOnce(Return(ByMove(std::move(i))));
  EXPECT_CALL(mock, MakeVectorUnique())
      .WillOnce(Return(ByMove(VectorUniquePtrSource())));
@ -1786,7 +1846,7 @@ TEST(MockMethodTest, CanReturnMoveOnlyValue_Return) {
 TEST(MockMethodTest, CanReturnMoveOnlyValue_DoAllReturn) {
  testing::MockFunction<void()> mock_function;
  MockClass mock;
-  std::unique_ptr<int> i(new int(19));
+  std::unique_ptr<int> i = std::make_unique<int>(19);
  EXPECT_CALL(mock_function, Call());
  EXPECT_CALL(mock, MakeUnique())
      .WillOnce(DoAll(InvokeWithoutArgs(&mock_function,
@ -1802,12 +1862,11 @@ TEST(MockMethodTest, CanReturnMoveOnlyValue_Invoke) {
  // Check default value
  DefaultValue<std::unique_ptr<int>>::SetFactory(
-      [] { return std::unique_ptr<int>(new int(42)); });
+      [] { return std::make_unique<int>(42); });
  EXPECT_EQ(42, *mock.MakeUnique());
-  EXPECT_CALL(mock, MakeUnique()).WillRepeatedly(Invoke(UniquePtrSource));
+  EXPECT_CALL(mock, MakeUnique()).WillRepeatedly(UniquePtrSource);
-  EXPECT_CALL(mock, MakeVectorUnique())
+  EXPECT_CALL(mock, MakeVectorUnique()).WillRepeatedly(VectorUniquePtrSource);
      .WillRepeatedly(Invoke(VectorUniquePtrSource));
  std::unique_ptr<int> result1 = mock.MakeUnique();
  EXPECT_EQ(19, *result1);
  std::unique_ptr<int> result2 = mock.MakeUnique();
@ -1822,14 +1881,14 @@ TEST(MockMethodTest, CanReturnMoveOnlyValue_Invoke) {
 TEST(MockMethodTest, CanTakeMoveOnlyValue) {
  MockClass mock;
-  auto make = [](int i) { return std::unique_ptr<int>(new int(i)); };
+  auto make = [](int i) { return std::make_unique<int>(i); };
  EXPECT_CALL(mock, TakeUnique(_)).WillRepeatedly([](std::unique_ptr<int> i) {
    return *i;
  });
  // DoAll() does not compile, since it would move from its arguments twice.
  // EXPECT_CALL(mock, TakeUnique(_, _))
-  //     .WillRepeatedly(DoAll(Invoke([](std::unique_ptr<int> j) {}),
+  //     .WillRepeatedly(DoAll([](std::unique_ptr<int> j) {})),
  //     Return(1)));
  EXPECT_CALL(mock, TakeUnique(testing::Pointee(7)))
      .WillOnce(Return(-7))
@ -2053,9 +2112,7 @@ struct Double {
  }
 };
-std::unique_ptr<int> UniqueInt(int i) {
+std::unique_ptr<int> UniqueInt(int i) { return std::make_unique<int>(i); }
  return std::unique_ptr<int>(new int(i));
 }
 TEST(FunctorActionTest, ActionFromFunction) {
  Action<int(int, int&, int*)> a = &Add;
@ -2114,7 +2171,7 @@ TEST(FunctorActionTest, TypeConversion) {
  EXPECT_EQ(7, d.Perform(std::make_tuple(1)));
  // Ensure creation of an empty action succeeds.
-  Action<void(int)>(nullptr);
+  (void)Action<void(int)>(nullptr);
 }
 TEST(FunctorActionTest, UnusedArguments) {
@ -2140,7 +2197,7 @@ TEST(MoveOnlyArgumentsTest, ReturningActions) {
  EXPECT_EQ(x, 3);
 }
-ACTION(ReturnArity) { return std::tuple_size<args_type>::value; }
+ACTION(ReturnArity) { return std::tuple_size_v<args_type>; }
 TEST(ActionMacro, LargeArity) {
  EXPECT_EQ(
--- a/test/googletest/googlemock/test/gmock-cardinalities_test.cc
+++ b/test/googletest/googlemock/test/gmock-cardinalities_test.cc
@ -31,6 +31,8 @@
 //
 // This file tests the built-in cardinalities.
 #include <ostream>
 #include "gmock/gmock.h"
 #include "gtest/gtest-spi.h"
 #include "gtest/gtest.h"
@ -50,7 +52,7 @@ using testing::MakeCardinality;
 class MockFoo {
 public:
-  MockFoo() {}
+  MockFoo() = default;
  MOCK_METHOD0(Bar, int());  // NOLINT
 private:
@ -131,7 +133,7 @@ TEST(AnyNumberTest, HasCorrectBounds) {
 TEST(AtLeastTest, OnNegativeNumber) {
  EXPECT_NONFATAL_FAILURE(
      {  // NOLINT
-        AtLeast(-1);
+        (void)AtLeast(-1);
      },
      "The invocation lower bound must be >= 0");
 }
@ -184,7 +186,7 @@ TEST(AtLeastTest, HasCorrectBounds) {
 TEST(AtMostTest, OnNegativeNumber) {
  EXPECT_NONFATAL_FAILURE(
      {  // NOLINT
-        AtMost(-1);
+        (void)AtMost(-1);
      },
      "The invocation upper bound must be >= 0");
 }
@ -237,7 +239,7 @@ TEST(AtMostTest, HasCorrectBounds) {
 TEST(BetweenTest, OnNegativeStart) {
  EXPECT_NONFATAL_FAILURE(
      {  // NOLINT
-        Between(-1, 2);
+        (void)Between(-1, 2);
      },
      "The invocation lower bound must be >= 0, but is actually -1");
 }
@ -245,7 +247,7 @@ TEST(BetweenTest, OnNegativeStart) {
 TEST(BetweenTest, OnNegativeEnd) {
  EXPECT_NONFATAL_FAILURE(
      {  // NOLINT
-        Between(1, -2);
+        (void)Between(1, -2);
      },
      "The invocation upper bound must be >= 0, but is actually -2");
 }
@ -253,7 +255,7 @@ TEST(BetweenTest, OnNegativeEnd) {
 TEST(BetweenTest, OnStartBiggerThanEnd) {
  EXPECT_NONFATAL_FAILURE(
      {  // NOLINT
-        Between(2, 1);
+        (void)Between(2, 1);
      },
      "The invocation upper bound (1) must be >= "
      "the invocation lower bound (2)");
@ -338,7 +340,7 @@ TEST(BetweenTest, HasCorrectBounds) {
 TEST(ExactlyTest, OnNegativeNumber) {
  EXPECT_NONFATAL_FAILURE(
      {  // NOLINT
-        Exactly(-1);
+        (void)Exactly(-1);
      },
      "The invocation lower bound must be >= 0");
 }
--- a/test/googletest/googlemock/test/gmock-function-mocker_test.cc
+++ b/test/googletest/googlemock/test/gmock-function-mocker_test.cc
@ -35,7 +35,14 @@
 // Silence C4503 (decorated name length exceeded) for MSVC.
 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4503)
-#if GTEST_OS_WINDOWS
+#ifdef __clang__
 #pragma clang diagnostic push
 // This file intentionally tests many ways of writing Mock classes, including
 // with and without the override keyword.
 #pragma clang diagnostic ignored "-Winconsistent-missing-override"
 #endif
 #ifdef GTEST_OS_WINDOWS
 // MSDN says the header file to be included for STDMETHOD is BaseTyps.h but
 // we are getting compiler errors if we use basetyps.h, hence including
 // objbase.h for definition of STDMETHOD.
@ -70,7 +77,7 @@ using testing::TypedEq;
 template <typename T>
 class TemplatedCopyable {
 public:
-  TemplatedCopyable() {}
+  TemplatedCopyable() = default;
  template <typename U>
  TemplatedCopyable(const U& other) {}  // NOLINT
@ -78,7 +85,7 @@ class TemplatedCopyable {
 class FooInterface {
 public:
-  virtual ~FooInterface() {}
+  virtual ~FooInterface() = default;
  virtual void VoidReturning(int x) = 0;
@ -91,7 +98,7 @@ class FooInterface {
  virtual bool TakesNonConstReference(int& n) = 0;  // NOLINT
  virtual std::string TakesConstReference(const int& n) = 0;
-  virtual bool TakesConst(const int x) = 0;
+  virtual bool TakesConst(int x) = 0;
  virtual int OverloadedOnArgumentNumber() = 0;
  virtual int OverloadedOnArgumentNumber(int n) = 0;
@ -120,7 +127,7 @@ class FooInterface {
  virtual int RefQualifiedOverloaded() & = 0;
  virtual int RefQualifiedOverloaded() && = 0;
-#if GTEST_OS_WINDOWS
+#ifdef GTEST_OS_WINDOWS
  STDMETHOD_(int, CTNullary)() = 0;
  STDMETHOD_(bool, CTUnary)(int x) = 0;
  STDMETHOD_(int, CTDecimal)
@ -137,7 +144,7 @@ class FooInterface {
 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4373)
 class MockFoo : public FooInterface {
 public:
-  MockFoo() {}
+  MockFoo() = default;
  // Makes sure that a mock function parameter can be named.
  MOCK_METHOD(void, VoidReturning, (int n));  // NOLINT
@ -178,7 +185,7 @@ class MockFoo : public FooInterface {
  MOCK_METHOD(int (*)(bool), ReturnsFunctionPointer1, (int), ());
  MOCK_METHOD(fn_ptr, ReturnsFunctionPointer2, (int), ());
-#if GTEST_OS_WINDOWS
+#ifdef GTEST_OS_WINDOWS
  MOCK_METHOD(int, CTNullary, (), (Calltype(STDMETHODCALLTYPE)));
  MOCK_METHOD(bool, CTUnary, (int), (Calltype(STDMETHODCALLTYPE)));
  MOCK_METHOD(int, CTDecimal,
@ -208,7 +215,7 @@ class MockFoo : public FooInterface {
 class LegacyMockFoo : public FooInterface {
 public:
-  LegacyMockFoo() {}
+  LegacyMockFoo() = default;
  // Makes sure that a mock function parameter can be named.
  MOCK_METHOD1(VoidReturning, void(int n));  // NOLINT
@ -248,7 +255,7 @@ class LegacyMockFoo : public FooInterface {
  MOCK_METHOD1(ReturnsFunctionPointer1, int (*(int))(bool));
  MOCK_METHOD1(ReturnsFunctionPointer2, fn_ptr(int));
-#if GTEST_OS_WINDOWS
+#ifdef GTEST_OS_WINDOWS
  MOCK_METHOD0_WITH_CALLTYPE(STDMETHODCALLTYPE, CTNullary, int());
  MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, CTUnary, bool(int));  // NOLINT
  MOCK_METHOD10_WITH_CALLTYPE(STDMETHODCALLTYPE, CTDecimal,
@ -325,8 +332,8 @@ TYPED_TEST(FunctionMockerTest, MocksBinaryFunction) {
 // Tests mocking a decimal function.
 TYPED_TEST(FunctionMockerTest, MocksDecimalFunction) {
-  EXPECT_CALL(this->mock_foo_,
+  EXPECT_CALL(this->mock_foo_, Decimal(true, 'a', 0, 0, 1L, A<float>(), Lt(100),
-              Decimal(true, 'a', 0, 0, 1L, A<float>(), Lt(100), 5U, NULL, "hi"))
+                                       5U, nullptr, "hi"))
      .WillOnce(Return(5));
  EXPECT_EQ(5, this->foo_->Decimal(true, 'a', 0, 0, 1, 0, 0, 5, nullptr, "hi"));
@ -404,7 +411,7 @@ TYPED_TEST(FunctionMockerTest, MocksTypeWithTemplatedCopyCtor) {
  EXPECT_TRUE(this->foo_->TypeWithTemplatedCopyCtor(TemplatedCopyable<int>()));
 }
-#if GTEST_OS_WINDOWS
+#ifdef GTEST_OS_WINDOWS
 // Tests mocking a nullary function with calltype.
 TYPED_TEST(FunctionMockerTest, MocksNullaryFunctionWithCallType) {
  EXPECT_CALL(this->mock_foo_, CTNullary())
@ -451,6 +458,87 @@ TYPED_TEST(FunctionMockerTest, MocksReturnTypeWithCommaAndCallType) {
 #endif  // GTEST_OS_WINDOWS
 // Compilability test, to ensure macros expand to all the arguments they're
 // supposed to.
 class MockManyArgs {
  using T = int;
 public:
  MockManyArgs() = default;
  MOCK_METHOD(void, F, (), ());
  MOCK_METHOD(void, F, (T), ());
  MOCK_METHOD(void, F, (T, T), ());
  MOCK_METHOD(void, F, (T, T, T), ());
  MOCK_METHOD(void, F, (T, T, T, T), ());
  MOCK_METHOD(void, F, (T, T, T, T, T), ());
  MOCK_METHOD(void, F, (T, T, T, T, T, T), ());
  MOCK_METHOD(void, F, (T, T, T, T, T, T, T), ());
  MOCK_METHOD(void, F, (T, T, T, T, T, T, T, T), ());
  MOCK_METHOD(void, F, (T, T, T, T, T, T, T, T, T), ());
  MOCK_METHOD(void, F, (T, T, T, T, T, T, T, T, T, T), ());
  MOCK_METHOD(void, F, (T, T, T, T, T, T, T, T, T, T, T), ());
  MOCK_METHOD(void, F, (T, T, T, T, T, T, T, T, T, T, T, T), ());
  MOCK_METHOD(void, F, (T, T, T, T, T, T, T, T, T, T, T, T, T), ());
  MOCK_METHOD(void, F, (T, T, T, T, T, T, T, T, T, T, T, T, T, T), ());
  MOCK_METHOD(void, F, (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), ());
  MOCK_METHOD(void, F, (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), ());
  MOCK_METHOD(void, F, (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), ());
  MOCK_METHOD(void, F, (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T),
              ());
  MOCK_METHOD(void, F,
              (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), ());
  MOCK_METHOD(void, F,
              (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), ());
  MOCK_METHOD(void, F,
              (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T),
              ());
  MOCK_METHOD(void, F,
              (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,
               T),
              ());
  MOCK_METHOD(void, F,
              (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,
               T),
              ());
  MOCK_METHOD(void, F,
              (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,
               T, T),
              ());
  MOCK_METHOD(void, F,
              (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,
               T, T, T),
              ());
  MOCK_METHOD(void, F,
              (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,
               T, T, T, T),
              ());
  MOCK_METHOD(void, F,
              (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,
               T, T, T, T, T),
              ());
  MOCK_METHOD(void, F,
              (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,
               T, T, T, T, T, T),
              ());
  MOCK_METHOD(void, F,
              (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,
               T, T, T, T, T, T, T),
              ());
  MOCK_METHOD(void, F,
              (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,
               T, T, T, T, T, T, T, T),
              ());
  MOCK_METHOD(void, F,
              (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,
               T, T, T, T, T, T, T, T, T),
              ());
 private:
  MockManyArgs(const MockManyArgs&) = delete;
  MockManyArgs& operator=(const MockManyArgs&) = delete;
 };
 TEST(FunctionMockerTest, RefQualified) {
  MockFoo mock_foo;
@ -487,7 +575,7 @@ TEST(FunctionMockerTest, RefQualified) {
 class MockB {
 public:
-  MockB() {}
+  MockB() = default;
  MOCK_METHOD(void, DoB, ());
@ -498,7 +586,7 @@ class MockB {
 class LegacyMockB {
 public:
-  LegacyMockB() {}
+  LegacyMockB() = default;
  MOCK_METHOD0(DoB, void());
@ -534,7 +622,7 @@ TYPED_TEST(ExpectCallTest, UnmentionedFunctionCanBeCalledAnyNumberOfTimes) {
 template <typename T>
 class StackInterface {
 public:
-  virtual ~StackInterface() {}
+  virtual ~StackInterface() = default;
  // Template parameter appears in function parameter.
  virtual void Push(const T& value) = 0;
@ -547,7 +635,7 @@ class StackInterface {
 template <typename T>
 class MockStack : public StackInterface<T> {
 public:
-  MockStack() {}
+  MockStack() = default;
  MOCK_METHOD(void, Push, (const T& elem), ());
  MOCK_METHOD(void, Pop, (), (final));
@ -566,7 +654,7 @@ class MockStack : public StackInterface<T> {
 template <typename T>
 class LegacyMockStack : public StackInterface<T> {
 public:
-  LegacyMockStack() {}
+  LegacyMockStack() = default;
  MOCK_METHOD1_T(Push, void(const T& elem));
  MOCK_METHOD0_T(Pop, void());
@ -620,7 +708,7 @@ TYPED_TEST(TemplateMockTest, MethodWithCommaInReturnTypeWorks) {
  EXPECT_EQ(a_map, mock.ReturnTypeWithComma(1));
 }
-#if GTEST_OS_WINDOWS
+#ifdef GTEST_OS_WINDOWS
 // Tests mocking template interfaces with calltype.
 template <typename T>
@ -711,7 +799,7 @@ TYPED_TEST(TemplateMockTestWithCallType, Works) {
 class MockOverloadedOnArgNumber {
 public:
-  MockOverloadedOnArgNumber() {}
+  MockOverloadedOnArgNumber() = default;
  MY_MOCK_METHODS1_;
@ -723,7 +811,7 @@ class MockOverloadedOnArgNumber {
 class LegacyMockOverloadedOnArgNumber {
 public:
-  LegacyMockOverloadedOnArgNumber() {}
+  LegacyMockOverloadedOnArgNumber() = default;
  LEGACY_MY_MOCK_METHODS1_;
@ -758,7 +846,7 @@ TYPED_TEST(OverloadedMockMethodTest, CanOverloadOnArgNumberInMacroBody) {
 class MockOverloadedOnConstness {
 public:
-  MockOverloadedOnConstness() {}
+  MockOverloadedOnConstness() = default;
  MY_MOCK_METHODS2_;
@ -849,11 +937,20 @@ namespace {
 template <typename Expected, typename F>
 static constexpr bool IsMockFunctionTemplateArgumentDeducedTo(
    const internal::MockFunction<F>&) {
-  return std::is_same<F, Expected>::value;
+  return std::is_same_v<F, Expected>;
 }
 }  // namespace
 // Like std::add_const, but for function types.
 template <typename F>
 struct AddConstToFunction;
 template <typename R, typename... Args>
 struct AddConstToFunction<R(Args...)> {
  using type = R(Args...) const;
 };
 template <typename F>
 class MockMethodMockFunctionSignatureTest : public Test {};
@ -865,27 +962,71 @@ TYPED_TEST_SUITE(MockMethodMockFunctionSignatureTest,
 TYPED_TEST(MockMethodMockFunctionSignatureTest,
           IsMockFunctionTemplateArgumentDeducedForRawSignature) {
  // Non-const
  {
    using Argument = TypeParam;
    MockFunction<Argument> foo;
    EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
  }
  // Const
  {
    using Argument = typename AddConstToFunction<TypeParam>::type;
    MockFunction<Argument> foo;
    EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
  }
 }
 TYPED_TEST(MockMethodMockFunctionSignatureTest,
           IsMockFunctionTemplateArgumentDeducedForStdFunction) {
  // Non-const
  {
    using Argument = std::function<TypeParam>;
    MockFunction<Argument> foo;
    EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
  }
 // As of 2026-05 MSVC doesn't know how to deal with this, providing pages of
 // inscrutable errors about std::_Get_function_impl. But this is fine, since
 // std::function<R(Args...) const> doesn't apply the const qualifier correctly
 // anyway.
 #if !defined(_MSC_VER)
  // Const
  {
    using Argument =
        std::function<typename AddConstToFunction<TypeParam>::type>;
    MockFunction<Argument> foo;
    EXPECT_TRUE(IsMockFunctionTemplateArgumentDeducedTo<TypeParam>(foo));
  }
 #endif
 }
 TYPED_TEST(
    MockMethodMockFunctionSignatureTest,
    IsMockFunctionCallMethodSignatureTheSameForRawSignatureAndStdFunction) {
  // Non-const
  {
    using ForRawSignature = decltype(&MockFunction<TypeParam>::Call);
    using ForStdFunction =
        decltype(&MockFunction<std::function<TypeParam>>::Call);
    EXPECT_TRUE((std::is_same<ForRawSignature, ForStdFunction>::value));
  }
  // Const
  {
    using ConstTypeParam = typename AddConstToFunction<TypeParam>::type;
    using ForRawSignature = decltype(&MockFunction<ConstTypeParam>::Call);
    using ForStdFunction =
        decltype(&MockFunction<std::function<ConstTypeParam>>::Call);
    EXPECT_TRUE((std::is_same<ForRawSignature, ForStdFunction>::value));
  }
 }
 template <typename F>
 struct AlternateCallable {};
--- a/test/googletest/googlemock/test/gmock-internal-utils_test.cc
+++ b/test/googletest/googlemock/test/gmock-internal-utils_test.cc
@ -40,6 +40,7 @@
 #include <memory>
 #include <sstream>
 #include <string>
 #include <tuple>
 #include <vector>
 #include "gmock/gmock.h"
@ -56,7 +57,7 @@
 #include "src/gtest-internal-inl.h"
 #undef GTEST_IMPLEMENTATION_
-#if GTEST_OS_CYGWIN
+#ifdef GTEST_OS_CYGWIN
 #include <sys/types.h>  // For ssize_t. NOLINT
 #endif
@ -167,7 +168,7 @@ TEST(KindOfTest, Integer) {
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned long long));  // NOLINT
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(wchar_t));             // NOLINT
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(size_t));              // NOLINT
-#if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN
+#if defined(GTEST_OS_LINUX) || defined(GTEST_OS_MAC) || defined(GTEST_OS_CYGWIN)
  // ssize_t is not defined on Windows and possibly some other OSes.
  EXPECT_EQ(kInteger, GMOCK_KIND_OF_(ssize_t));  // NOLINT
 #endif
@ -544,7 +545,7 @@ TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsError) {
 void OnCallLogger() {
  DummyMock mock;
-  ON_CALL(mock, TestMethod());
+  (void)ON_CALL(mock, TestMethod());
 }
 // Verifies that ON_CALL logs if the --gmock_verbose flag is set to "info".
@ -567,7 +568,7 @@ TEST(OnCallTest, DoesNotLogWhenVerbosityIsError) {
 void OnCallAnyArgumentLogger() {
  DummyMock mock;
-  ON_CALL(mock, TestMethodArg(_));
+  (void)ON_CALL(mock, TestMethodArg(_));
 }
 // Verifies that ON_CALL prints provided _ argument.
--- a/test/googletest/googlemock/test/gmock-matchers-arithmetic_test.cc
+++ b/test/googletest/googlemock/test/gmock-matchers-arithmetic_test.cc
@ -31,9 +31,15 @@
 //
 // This file tests some commonly used argument matchers.
 #include <cmath>
 #include <limits>
 #include <memory>
 #include <ostream>
 #include <string>
 #include "gmock/gmock.h"
 #include "test/gmock-matchers_test.h"
 #include "gtest/gtest.h"
 // Silence warning C4244: 'initializing': conversion from 'int' to 'short',
 // possible loss of data and C4100, unreferenced local parameter
@ -393,6 +399,188 @@ TEST(NanSensitiveDoubleNearTest, CanDescribeSelfWithNaNs) {
  EXPECT_EQ("are an almost-equal pair", Describe(m));
 }
 // Tests that DistanceFrom() can describe itself properly.
 TEST(DistanceFrom, CanDescribeSelf) {
  Matcher<double> m = DistanceFrom(1.5, Lt(0.1));
  EXPECT_EQ(Describe(m), "is < 0.1 away from 1.5");
  m = DistanceFrom(2.5, Gt(0.2));
  EXPECT_EQ(Describe(m), "is > 0.2 away from 2.5");
 }
 // Tests that DistanceFrom() can explain match failure.
 TEST(DistanceFrom, CanExplainMatchFailure) {
  Matcher<double> m = DistanceFrom(1.5, Lt(0.1));
  EXPECT_EQ(Explain(m, 2.0), "which is 0.5 away from 1.5");
 }
 // Tests that DistanceFrom() matches a double that is within the given range of
 // the given value.
 TEST(DistanceFrom, MatchesDoubleWithinRange) {
  const Matcher<double> m = DistanceFrom(0.5, Le(0.1));
  EXPECT_TRUE(m.Matches(0.45));
  EXPECT_TRUE(m.Matches(0.5));
  EXPECT_TRUE(m.Matches(0.55));
  EXPECT_FALSE(m.Matches(0.39));
  EXPECT_FALSE(m.Matches(0.61));
 }
 // Tests that DistanceFrom() matches a double reference that is within the given
 // range of the given value.
 TEST(DistanceFrom, MatchesDoubleRefWithinRange) {
  const Matcher<const double&> m = DistanceFrom(0.5, Le(0.1));
  EXPECT_TRUE(m.Matches(0.45));
  EXPECT_TRUE(m.Matches(0.5));
  EXPECT_TRUE(m.Matches(0.55));
  EXPECT_FALSE(m.Matches(0.39));
  EXPECT_FALSE(m.Matches(0.61));
 }
 // Tests that DistanceFrom() can be implicitly converted to a matcher depending
 // on the type of the argument.
 TEST(DistanceFrom, CanBeImplicitlyConvertedToMatcher) {
  EXPECT_THAT(0.58, DistanceFrom(0.5, Le(0.1)));
  EXPECT_THAT(0.2, Not(DistanceFrom(0.5, Le(0.1))));
  EXPECT_THAT(0.58f, DistanceFrom(0.5f, Le(0.1f)));
  EXPECT_THAT(0.7f, Not(DistanceFrom(0.5f, Le(0.1f))));
 }
 // Tests that DistanceFrom() can be used on compatible types (i.e. not
 // everything has to be of the same type).
 TEST(DistanceFrom, CanBeUsedOnCompatibleTypes) {
  EXPECT_THAT(0.58, DistanceFrom(0.5, Le(0.1f)));
  EXPECT_THAT(0.2, Not(DistanceFrom(0.5, Le(0.1f))));
  EXPECT_THAT(0.58, DistanceFrom(0.5f, Le(0.1)));
  EXPECT_THAT(0.2, Not(DistanceFrom(0.5f, Le(0.1))));
  EXPECT_THAT(0.58, DistanceFrom(0.5f, Le(0.1f)));
  EXPECT_THAT(0.2, Not(DistanceFrom(0.5f, Le(0.1f))));
  EXPECT_THAT(0.58f, DistanceFrom(0.5, Le(0.1)));
  EXPECT_THAT(0.2f, Not(DistanceFrom(0.5, Le(0.1))));
  EXPECT_THAT(0.58f, DistanceFrom(0.5, Le(0.1f)));
  EXPECT_THAT(0.2f, Not(DistanceFrom(0.5, Le(0.1f))));
  EXPECT_THAT(0.58f, DistanceFrom(0.5f, Le(0.1)));
  EXPECT_THAT(0.2f, Not(DistanceFrom(0.5f, Le(0.1))));
 }
 // A 2-dimensional point. For testing using DistanceFrom() with a custom type
 // that doesn't have a built-in distance function.
 class Point {
 public:
  Point(double x, double y) : x_(x), y_(y) {}
  double x() const { return x_; }
  double y() const { return y_; }
 private:
  double x_;
  double y_;
 };
 // Returns the distance between two points.
 double PointDistance(const Point& lhs, const Point& rhs) {
  return std::sqrt(std::pow(lhs.x() - rhs.x(), 2) +
                   std::pow(lhs.y() - rhs.y(), 2));
 }
 // Tests that DistanceFrom() can be used on a type with a custom distance
 // function.
 TEST(DistanceFrom, CanBeUsedOnTypeWithCustomDistanceFunction) {
  const Matcher<Point> m =
      DistanceFrom(Point(0.5, 0.5), PointDistance, Le(0.1));
  EXPECT_THAT(Point(0.45, 0.45), m);
  EXPECT_THAT(Point(0.2, 0.45), Not(m));
 }
 // A wrapper around a double value. For testing using DistanceFrom() with a
 // custom type that has neither a built-in distance function nor a built-in
 // distance comparator.
 class Double {
 public:
  explicit Double(double value) : value_(value) {}
  Double(const Double& other) = default;
  double value() const { return value_; }
  // Defines how to print a Double value. We don't use the AbslStringify API
  // because googletest doesn't require absl yet.
  friend void PrintTo(const Double& value, std::ostream* os) {
    *os << "Double(" << value.value() << ")";
  }
 private:
  double value_;
 };
 // Returns the distance between two Double values.
 Double DoubleDistance(Double lhs, Double rhs) {
  return Double(std::abs(lhs.value() - rhs.value()));
 }
 MATCHER_P(DoubleLe, rhs, (negation ? "is > " : "is <= ") + PrintToString(rhs)) {
  return arg.value() <= rhs.value();
 }
 // Tests that DistanceFrom() can describe itself properly for a type with a
 // custom printer.
 TEST(DistanceFrom, CanDescribeWithCustomPrinter) {
  const Matcher<Double> m =
      DistanceFrom(Double(0.5), DoubleDistance, DoubleLe(Double(0.1)));
  EXPECT_EQ(Describe(m), "is <= Double(0.1) away from Double(0.5)");
  EXPECT_EQ(DescribeNegation(m), "is > Double(0.1) away from Double(0.5)");
 }
 // Tests that DistanceFrom() can be used with a custom distance function and
 // comparator.
 TEST(DistanceFrom, CanCustomizeDistanceAndComparator) {
  const Matcher<Double> m =
      DistanceFrom(Double(0.5), DoubleDistance, DoubleLe(Double(0.1)));
  EXPECT_TRUE(m.Matches(Double(0.45)));
  EXPECT_TRUE(m.Matches(Double(0.5)));
  EXPECT_FALSE(m.Matches(Double(0.39)));
  EXPECT_FALSE(m.Matches(Double(0.61)));
 }
 // For testing using DistanceFrom() with a type that supports both - and abs.
 class Float {
 public:
  explicit Float(float value) : value_(value) {}
  Float(const Float& other) = default;
  float value() const { return value_; }
 private:
  float value_ = 0.0f;
 };
 // Returns the difference between two Float values. This must be defined in the
 // same namespace as Float.
 Float operator-(const Float& lhs, const Float& rhs) {
  return Float(lhs.value() - rhs.value());
 }
 // Returns the absolute value of a Float value. This must be defined in the
 // same namespace as Float.
 Float abs(Float value) { return Float(std::abs(value.value())); }
 // Returns true if and only if the first Float value is less than the second
 // Float value. This must be defined in the same namespace as Float.
 bool operator<(const Float& lhs, const Float& rhs) {
  return lhs.value() < rhs.value();
 }
 // Tests that DistanceFrom() can be used with a type that supports both - and
 // abs.
 TEST(DistanceFrom, CanBeUsedWithTypeThatSupportsBothMinusAndAbs) {
  const Matcher<Float> m = DistanceFrom(Float(0.5f), Lt(Float(0.1f)));
  EXPECT_TRUE(m.Matches(Float(0.45f)));
  EXPECT_TRUE(m.Matches(Float(0.55f)));
  EXPECT_FALSE(m.Matches(Float(0.39f)));
  EXPECT_FALSE(m.Matches(Float(0.61f)));
 }
 // Tests that Not(m) matches any value that doesn't match m.
 TEST(NotTest, NegatesMatcher) {
  Matcher<int> m;
@ -532,7 +720,6 @@ TEST(AllOfTest, CanDescribeNegation) {
  m = AllOf(Ne(1), Ne(2), Ne(3), Ne(4), Ne(5), Ne(6), Ne(7), Ne(8), Ne(9),
            Ne(10), Ne(11));
  AllOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
  EXPECT_THAT(Describe(m), EndsWith("and (isn't equal to 11)"));
  AllOfMatches(11, m);
 }
@ -556,10 +743,9 @@ TEST_P(AllOfTestP, ExplainsResult) {
  Matcher<int> m;
  // Successful match.  Both matchers need to explain.  The second
-  // matcher doesn't give an explanation, so only the first matcher's
+  // matcher doesn't give an explanation, so the matcher description is used.
  // explanation is printed.
  m = AllOf(GreaterThan(10), Lt(30));
-  EXPECT_EQ("which is 15 more than 10", Explain(m, 25));
+  EXPECT_EQ("which is 15 more than 10, and is < 30", Explain(m, 25));
  // Successful match.  Both matchers need to explain.
  m = AllOf(GreaterThan(10), GreaterThan(20));
@ -569,7 +755,8 @@ TEST_P(AllOfTestP, ExplainsResult) {
  // Successful match.  All matchers need to explain.  The second
  // matcher doesn't given an explanation.
  m = AllOf(GreaterThan(10), Lt(30), GreaterThan(20));
-  EXPECT_EQ("which is 15 more than 10, and which is 5 more than 20",
+  EXPECT_EQ(
      "which is 15 more than 10, and is < 30, and which is 5 more than 20",
      Explain(m, 25));
  // Successful match.  All matchers need to explain.
@ -582,13 +769,14 @@ TEST_P(AllOfTestP, ExplainsResult) {
  // Failed match.  The first matcher, which failed, needs to
  // explain.
  m = AllOf(GreaterThan(10), GreaterThan(20));
-  EXPECT_EQ("which is 5 less than 10", Explain(m, 5));
+  EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20",
            Explain(m, 5));
  // Failed match.  The second matcher, which failed, needs to
-  // explain.  Since it doesn't given an explanation, nothing is
+  // explain.  Since it doesn't given an explanation, the matcher text is
  // printed.
  m = AllOf(GreaterThan(10), Lt(30));
-  EXPECT_EQ("", Explain(m, 40));
+  EXPECT_EQ("which doesn't match (is < 30)", Explain(m, 40));
  // Failed match.  The second matcher, which failed, needs to
  // explain.
@ -771,45 +959,43 @@ TEST(AnyOfTest, AnyOfMatcherSafelyCastsMonomorphicMatchers) {
 TEST_P(AnyOfTestP, ExplainsResult) {
  Matcher<int> m;
-  // Failed match.  Both matchers need to explain.  The second
+  // Failed match. The second matcher have no explanation (description is used).
  // matcher doesn't give an explanation, so only the first matcher's
  // explanation is printed.
  m = AnyOf(GreaterThan(10), Lt(0));
-  EXPECT_EQ("which is 5 less than 10", Explain(m, 5));
+  EXPECT_EQ("which is 5 less than 10, and isn't < 0", Explain(m, 5));
-  // Failed match.  Both matchers need to explain.
+  // Failed match. Both matchers have explanations.
  m = AnyOf(GreaterThan(10), GreaterThan(20));
  EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20",
            Explain(m, 5));
-  // Failed match.  All matchers need to explain.  The second
+  // Failed match. The middle matcher have no explanation.
  // matcher doesn't given an explanation.
  m = AnyOf(GreaterThan(10), Gt(20), GreaterThan(30));
-  EXPECT_EQ("which is 5 less than 10, and which is 25 less than 30",
+  EXPECT_EQ(
      "which is 5 less than 10, and isn't > 20, and which is 25 less than 30",
      Explain(m, 5));
-  // Failed match.  All matchers need to explain.
+  // Failed match. All three matchers have explanations.
  m = AnyOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
  EXPECT_EQ(
      "which is 5 less than 10, and which is 15 less than 20, "
      "and which is 25 less than 30",
      Explain(m, 5));
-  // Successful match.  The first matcher, which succeeded, needs to
+  // Successful match. The first macher succeeded and has explanation.
  // explain.
  m = AnyOf(GreaterThan(10), GreaterThan(20));
  EXPECT_EQ("which is 5 more than 10", Explain(m, 15));
-  // Successful match.  The second matcher, which succeeded, needs to
+  // Successful match. The second matcher succeeded and has explanation.
  // explain.  Since it doesn't given an explanation, nothing is
  // printed.
  m = AnyOf(GreaterThan(10), Lt(30));
  EXPECT_EQ("", Explain(m, 0));
  // Successful match.  The second matcher, which succeeded, needs to
  // explain.
  m = AnyOf(GreaterThan(30), GreaterThan(20));
  EXPECT_EQ("which is 5 more than 20", Explain(m, 25));
  // Successful match. The first matcher succeeded and has no explanation.
  m = AnyOf(Gt(10), Lt(20));
  EXPECT_EQ("which matches (is > 10)", Explain(m, 15));
  // Successful match. The second matcher succeeded and has no explanation.
  m = AnyOf(Gt(30), Gt(20));
  EXPECT_EQ("which matches (is > 20)", Explain(m, 25));
 }
 // The following predicate function and predicate functor are for
@ -952,7 +1138,7 @@ TEST(AllArgsTest, WorksForNonTuple) {
 class AllArgsHelper {
 public:
-  AllArgsHelper() {}
+  AllArgsHelper() = default;
  MOCK_METHOD2(Helper, int(char x, int y));
@ -973,7 +1159,7 @@ TEST(AllArgsTest, WorksInWithClause) {
 class OptionalMatchersHelper {
 public:
-  OptionalMatchersHelper() {}
+  OptionalMatchersHelper() = default;
  MOCK_METHOD0(NoArgs, int());
@ -1439,7 +1625,7 @@ TEST_F(DoubleNearTest, NanSensitiveDoubleNearCanMatchNaN) {
 }
 TEST(NotTest, WorksOnMoveOnlyType) {
-  std::unique_ptr<int> p(new int(3));
+  std::unique_ptr<int> p = std::make_unique<int>(3);
  EXPECT_THAT(p, Pointee(Eq(3)));
  EXPECT_THAT(p, Not(Pointee(Eq(2))));
 }
@ -1495,13 +1681,13 @@ TEST(AnyOfTest, DoesNotCallAnyOfUnqualified) {
 }  // namespace adl_test
 TEST(AllOfTest, WorksOnMoveOnlyType) {
-  std::unique_ptr<int> p(new int(3));
+  std::unique_ptr<int> p = std::make_unique<int>(3);
  EXPECT_THAT(p, AllOf(Pointee(Eq(3)), Pointee(Gt(0)), Pointee(Lt(5))));
  EXPECT_THAT(p, Not(AllOf(Pointee(Eq(3)), Pointee(Gt(0)), Pointee(Lt(3)))));
 }
 TEST(AnyOfTest, WorksOnMoveOnlyType) {
-  std::unique_ptr<int> p(new int(3));
+  std::unique_ptr<int> p = std::make_unique<int>(3);
  EXPECT_THAT(p, AnyOf(Pointee(Eq(5)), Pointee(Lt(0)), Pointee(Lt(5))));
  EXPECT_THAT(p, Not(AnyOf(Pointee(Eq(5)), Pointee(Lt(0)), Pointee(Gt(5)))));
 }
--- a/test/googletest/googlemock/test/gmock-matchers-comparisons_test.cc
+++ b/test/googletest/googlemock/test/gmock-matchers-comparisons_test.cc
@ -31,15 +31,22 @@
 //
 // This file tests some commonly used argument matchers.
 #include <functional>
 #include <memory>
 #include <optional>
 #include <string>
 #include <string_view>
 #include <tuple>
 #include <vector>
 #include "gmock/gmock.h"
 #include "test/gmock-matchers_test.h"
 #include "gtest/gtest.h"
 // Silence warning C4244: 'initializing': conversion from 'int' to 'short',
 // possible loss of data and C4100, unreferenced local parameter
 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4244 4100)
 namespace testing {
 namespace gmock_matchers_test {
 namespace {
@ -230,7 +237,6 @@ TEST(StringMatcherTest, CanBeImplicitlyConstructedFromString) {
  EXPECT_FALSE(m2.Matches("hello"));
 }
 #if GTEST_INTERNAL_HAS_STRING_VIEW
 // Tests that a C-string literal can be implicitly converted to a
 // Matcher<StringView> or Matcher<const StringView&>.
 TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromCStringLiteral) {
@ -266,7 +272,6 @@ TEST(StringViewMatcherTest, CanBeImplicitlyConstructedFromStringView) {
  EXPECT_TRUE(m2.Matches("cats"));
  EXPECT_FALSE(m2.Matches("dogs"));
 }
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
 // Tests that a std::reference_wrapper<std::string> object can be implicitly
 // converted to a Matcher<std::string> or Matcher<const std::string&> via Eq().
@ -406,9 +411,27 @@ class IntValue {
  int value_;
 };
 // For testing casting matchers between compatible types. This is similar to
 // IntValue, but takes a non-const reference to the value, showing MatcherCast
 // works with such types (and doesn't, for example, use a const ref internally).
 class MutableIntView {
 public:
  // An int& can be statically (although not implicitly) cast to a
  // MutableIntView.
  explicit MutableIntView(int& a_value) : value_(a_value) {}
  int& value() const { return value_; }
 private:
  int& value_;
 };
 // For testing casting matchers between compatible types.
 bool IsPositiveIntValue(const IntValue& foo) { return foo.value() > 0; }
 // For testing casting matchers between compatible types.
 bool IsPositiveMutableIntView(MutableIntView foo) { return foo.value() > 0; }
 // Tests that MatcherCast<T>(m) works when m is a Matcher<U> where T
 // can be statically converted to U.
 TEST(MatcherCastTest, FromCompatibleType) {
@ -424,14 +447,34 @@ TEST(MatcherCastTest, FromCompatibleType) {
  // predicate.
  EXPECT_TRUE(m4.Matches(1));
  EXPECT_FALSE(m4.Matches(0));
  Matcher<MutableIntView> m5 = Truly(IsPositiveMutableIntView);
  Matcher<int> m6 = MatcherCast<int>(m5);
  // In the following, the arguments 1 and 0 are statically converted to
  // MutableIntView objects, and then tested by the IsPositiveMutableIntView()
  // predicate.
  EXPECT_TRUE(m6.Matches(1));
  EXPECT_FALSE(m6.Matches(0));
 }
 // Tests that MatcherCast<T>(m) works when m is a Matcher<const T&>.
 TEST(MatcherCastTest, FromConstReferenceToNonReference) {
-  Matcher<const int&> m1 = Eq(0);
+  int n = 0;
  Matcher<const int&> m1 = Ref(n);
  Matcher<int> m2 = MatcherCast<int>(m1);
-  EXPECT_TRUE(m2.Matches(0));
+  int n1 = 0;
-  EXPECT_FALSE(m2.Matches(1));
+  EXPECT_TRUE(m2.Matches(n));
  EXPECT_FALSE(m2.Matches(n1));
 }
 // Tests that MatcherCast<T&>(m) works when m is a Matcher<const T&>.
 TEST(MatcherCastTest, FromConstReferenceToReference) {
  int n = 0;
  Matcher<const int&> m1 = Ref(n);
  Matcher<int&> m2 = MatcherCast<int&>(m1);
  int n1 = 0;
  EXPECT_TRUE(m2.Matches(n));
  EXPECT_FALSE(m2.Matches(n1));
 }
 // Tests that MatcherCast<T>(m) works when m is a Matcher<T&>.
@ -440,6 +483,12 @@ TEST(MatcherCastTest, FromReferenceToNonReference) {
  Matcher<int> m2 = MatcherCast<int>(m1);
  EXPECT_TRUE(m2.Matches(0));
  EXPECT_FALSE(m2.Matches(1));
  // Of course, reference identity isn't preserved since a copy is required.
  int n = 0;
  Matcher<int&> m3 = Ref(n);
  Matcher<int> m4 = MatcherCast<int>(m3);
  EXPECT_FALSE(m4.Matches(n));
 }
 // Tests that MatcherCast<const T&>(m) works when m is a Matcher<T>.
@ -572,21 +621,48 @@ struct IntReferenceWrapper {
  const int* value;
 };
 // Compared the contained values
 bool operator==(const IntReferenceWrapper& a, const IntReferenceWrapper& b) {
-  return a.value == b.value;
+  return *a.value == *b.value;
 }
-TEST(MatcherCastTest, ValueIsNotCopied) {
+TEST(MatcherCastTest, ValueIsCopied) {
  {
    // When an IntReferenceWrapper is passed.
    int n = 42;
    Matcher<IntReferenceWrapper> m =
        MatcherCast<IntReferenceWrapper>(IntReferenceWrapper(n));
    {
      int value = 42;
      EXPECT_TRUE(m.Matches(value));
      value = 10;
      EXPECT_FALSE(m.Matches(value));
      // This changes the stored reference.
      n = 10;
      EXPECT_TRUE(m.Matches(value));
    }
  }
  {
    // When an int is passed.
    int n = 42;
    Matcher<IntReferenceWrapper> m = MatcherCast<IntReferenceWrapper>(n);
-  // Verify that the matcher holds a reference to n, not to its temporary copy.
+    {
-  EXPECT_TRUE(m.Matches(n));
+      int value = 42;
      EXPECT_TRUE(m.Matches(value));
      value = 10;
      EXPECT_FALSE(m.Matches(value));
      // This does not change the stored int.
      n = 10;
      EXPECT_FALSE(m.Matches(value));
    }
  }
 }
 class Base {
 public:
-  virtual ~Base() {}
+  virtual ~Base() = default;
-  Base() {}
+  Base() = default;
 private:
  Base(const Base&) = delete;
@ -644,6 +720,16 @@ TEST(SafeMatcherCastTest, FromBaseClass) {
  EXPECT_FALSE(m4.Matches(d2));
 }
 // Tests that SafeMatcherCast<T>(m) works when m is a Matcher<const T&>.
 TEST(SafeMatcherCastTest, FromConstReferenceToNonReference) {
  int n = 0;
  Matcher<const int&> m1 = Ref(n);
  Matcher<int> m2 = SafeMatcherCast<int>(m1);
  int n1 = 0;
  EXPECT_TRUE(m2.Matches(n));
  EXPECT_FALSE(m2.Matches(n1));
 }
 // Tests that SafeMatcherCast<T&>(m) works when m is a Matcher<const T&>.
 TEST(SafeMatcherCastTest, FromConstReferenceToReference) {
  int n = 0;
@ -711,6 +797,7 @@ TEST(ExpectThat, TakesLiterals) {
  EXPECT_THAT(1, 1);
  EXPECT_THAT(1.0, 1.0);
  EXPECT_THAT(std::string(), "");
  EXPECT_THAT(std::shared_ptr<int>(), nullptr);
 }
 TEST(ExpectThat, TakesFunctions) {
@ -1004,8 +1091,20 @@ TEST(IsEmptyTest, MatchesCString) {
  const char b[] = "x";
  EXPECT_TRUE(m.Matches(a));
  EXPECT_FALSE(m.Matches(b));
  EXPECT_FALSE(m.Matches(nullptr));
 }
 #if GTEST_HAS_STD_WSTRING
 TEST(IsEmptyTest, MatchesCWideString) {
  const Matcher<const wchar_t*> m = IsEmpty();
  const wchar_t a[] = L"";
  const wchar_t b[] = L"x";
  EXPECT_TRUE(m.Matches(a));
  EXPECT_FALSE(m.Matches(b));
  EXPECT_FALSE(m.Matches(nullptr));
 }
 #endif  // GTEST_HAS_STD_WSTRING
 // Tests that IsNull() matches any NULL pointer of any type.
 TEST(IsNullTest, MatchesNullPointer) {
  Matcher<int*> m1 = IsNull();
@ -1039,6 +1138,16 @@ TEST(IsNullTest, CanDescribeSelf) {
  EXPECT_EQ("isn't NULL", DescribeNegation(m));
 }
 struct SmartPtrHelper {
  MOCK_METHOD(void, Call, (std::shared_ptr<int>));
 };
 TEST(IsNullTest, WorksWithSmartPtr) {
  SmartPtrHelper helper;
  EXPECT_CALL(helper, Call(nullptr));
  helper.Call(nullptr);
 }
 // Tests that NotNull() matches any non-NULL pointer of any type.
 TEST(NotNullTest, MatchesNonNullPointer) {
  Matcher<int*> m1 = NotNull();
@ -1144,22 +1253,26 @@ TEST(RefTest, ExplainsResult) {
 // Tests string comparison matchers.
 template <typename T = std::string>
-std::string FromStringLike(internal::StringLike<T> str) {
+internal::StringType<T> ToString(T str) {
-  return std::string(str);
+  return internal::StringType<T>(str);
 }
-TEST(StringLike, TestConversions) {
+TEST(StringType, TestConversions) {
-  EXPECT_EQ("foo", FromStringLike("foo"));
+  EXPECT_EQ("foo", ToString("foo"));
-  EXPECT_EQ("foo", FromStringLike(std::string("foo")));
+  EXPECT_EQ("foo", ToString(std::string("foo")));
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+  EXPECT_EQ("foo", ToString(internal::StringView("foo")));
-  EXPECT_EQ("foo", FromStringLike(internal::StringView("foo")));
+
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+#if GTEST_HAS_STD_WSTRING
  EXPECT_EQ(L"foo", ToString(L"foo"));
  EXPECT_EQ(L"foo", ToString(std::wstring(L"foo")));
  EXPECT_EQ(L"foo", ToString(std::wstring_view(L"foo")));
 #endif
  // Non deducible types.
-  EXPECT_EQ("", FromStringLike({}));
+  EXPECT_EQ("", ToString({}));
-  EXPECT_EQ("foo", FromStringLike({'f', 'o', 'o'}));
+  EXPECT_EQ("foo", ToString({'f', 'o', 'o'}));
  const char buf[] = "foo";
-  EXPECT_EQ("foo", FromStringLike({buf, buf + 3}));
+  EXPECT_EQ("foo", ToString({buf, buf + 3}));
 }
 TEST(StrEqTest, MatchesEqualString) {
@ -1172,7 +1285,6 @@ TEST(StrEqTest, MatchesEqualString) {
  EXPECT_TRUE(m2.Matches("Hello"));
  EXPECT_FALSE(m2.Matches("Hi"));
 #if GTEST_INTERNAL_HAS_STRING_VIEW
  Matcher<const internal::StringView&> m3 =
      StrEq(internal::StringView("Hello"));
  EXPECT_TRUE(m3.Matches(internal::StringView("Hello")));
@ -1183,7 +1295,6 @@ TEST(StrEqTest, MatchesEqualString) {
  EXPECT_TRUE(m_empty.Matches(internal::StringView("")));
  EXPECT_TRUE(m_empty.Matches(internal::StringView()));
  EXPECT_FALSE(m_empty.Matches(internal::StringView("hello")));
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
 }
 TEST(StrEqTest, CanDescribeSelf) {
@ -1210,12 +1321,10 @@ TEST(StrNeTest, MatchesUnequalString) {
  EXPECT_TRUE(m2.Matches("hello"));
  EXPECT_FALSE(m2.Matches("Hello"));
 #if GTEST_INTERNAL_HAS_STRING_VIEW
  Matcher<const internal::StringView> m3 = StrNe(internal::StringView("Hello"));
  EXPECT_TRUE(m3.Matches(internal::StringView("")));
  EXPECT_TRUE(m3.Matches(internal::StringView()));
  EXPECT_FALSE(m3.Matches(internal::StringView("Hello")));
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
 }
 TEST(StrNeTest, CanDescribeSelf) {
@ -1234,14 +1343,12 @@ TEST(StrCaseEqTest, MatchesEqualStringIgnoringCase) {
  EXPECT_TRUE(m2.Matches("hello"));
  EXPECT_FALSE(m2.Matches("Hi"));
 #if GTEST_INTERNAL_HAS_STRING_VIEW
  Matcher<const internal::StringView&> m3 =
      StrCaseEq(internal::StringView("Hello"));
  EXPECT_TRUE(m3.Matches(internal::StringView("Hello")));
  EXPECT_TRUE(m3.Matches(internal::StringView("hello")));
  EXPECT_FALSE(m3.Matches(internal::StringView("Hi")));
  EXPECT_FALSE(m3.Matches(internal::StringView()));
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
 }
 TEST(StrCaseEqTest, MatchesEqualStringWith0IgnoringCase) {
@ -1285,14 +1392,12 @@ TEST(StrCaseNeTest, MatchesUnequalStringIgnoringCase) {
  EXPECT_TRUE(m2.Matches(""));
  EXPECT_FALSE(m2.Matches("Hello"));
 #if GTEST_INTERNAL_HAS_STRING_VIEW
  Matcher<const internal::StringView> m3 =
      StrCaseNe(internal::StringView("Hello"));
  EXPECT_TRUE(m3.Matches(internal::StringView("Hi")));
  EXPECT_TRUE(m3.Matches(internal::StringView()));
  EXPECT_FALSE(m3.Matches(internal::StringView("Hello")));
  EXPECT_FALSE(m3.Matches(internal::StringView("hello")));
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
 }
 TEST(StrCaseNeTest, CanDescribeSelf) {
@ -1333,7 +1438,6 @@ TEST(HasSubstrTest, WorksForCStrings) {
  EXPECT_FALSE(m_empty.Matches(nullptr));
 }
 #if GTEST_INTERNAL_HAS_STRING_VIEW
 // Tests that HasSubstr() works for matching StringView-typed values.
 TEST(HasSubstrTest, WorksForStringViewClasses) {
  const Matcher<internal::StringView> m1 =
@ -1352,7 +1456,6 @@ TEST(HasSubstrTest, WorksForStringViewClasses) {
  EXPECT_TRUE(m3.Matches(internal::StringView("")));
  EXPECT_TRUE(m3.Matches(internal::StringView()));
 }
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
 // Tests that HasSubstr(s) describes itself properly.
 TEST(HasSubstrTest, CanDescribeSelf) {
@ -1542,7 +1645,7 @@ TEST(PairTest, MatchesCorrectly) {
 TEST(PairTest, WorksWithMoveOnly) {
  pair<std::unique_ptr<int>, std::unique_ptr<int>> p;
-  p.second.reset(new int(7));
+  p.second = std::make_unique<int>(7);
  EXPECT_THAT(p, Pair(Eq(nullptr), Ne(nullptr)));
 }
@ -1751,13 +1854,11 @@ TEST(StartsWithTest, MatchesStringWithGivenPrefix) {
  EXPECT_FALSE(m2.Matches("H"));
  EXPECT_FALSE(m2.Matches(" Hi"));
 #if GTEST_INTERNAL_HAS_STRING_VIEW
  const Matcher<internal::StringView> m_empty =
      StartsWith(internal::StringView(""));
  EXPECT_TRUE(m_empty.Matches(internal::StringView()));
  EXPECT_TRUE(m_empty.Matches(internal::StringView("")));
  EXPECT_TRUE(m_empty.Matches(internal::StringView("not empty")));
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
 }
 TEST(StartsWithTest, CanDescribeSelf) {
@ -1765,6 +1866,11 @@ TEST(StartsWithTest, CanDescribeSelf) {
  EXPECT_EQ("starts with \"Hi\"", Describe(m));
 }
 TEST(StartsWithTest, WorksWithStringMatcherOnStringViewMatchee) {
  EXPECT_THAT(internal::StringView("talk to me goose"),
              StartsWith(std::string("talk")));
 }
 // Tests EndsWith(s).
 TEST(EndsWithTest, MatchesStringWithGivenSuffix) {
@ -1780,14 +1886,12 @@ TEST(EndsWithTest, MatchesStringWithGivenSuffix) {
  EXPECT_FALSE(m2.Matches("i"));
  EXPECT_FALSE(m2.Matches("Hi "));
 #if GTEST_INTERNAL_HAS_STRING_VIEW
  const Matcher<const internal::StringView&> m4 =
      EndsWith(internal::StringView(""));
  EXPECT_TRUE(m4.Matches("Hi"));
  EXPECT_TRUE(m4.Matches(""));
  EXPECT_TRUE(m4.Matches(internal::StringView()));
  EXPECT_TRUE(m4.Matches(internal::StringView("")));
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
 }
 TEST(EndsWithTest, CanDescribeSelf) {
@ -1810,14 +1914,12 @@ TEST(WhenBase64UnescapedTest, MatchesUnescapedBase64Strings) {
  EXPECT_TRUE(m2.Matches("aGVsbG8gd29ybGQh"));   // hello world!
  EXPECT_TRUE(m2.Matches("+/-_IQ"));             // \xfb\xff\xbf!
 #if GTEST_INTERNAL_HAS_STRING_VIEW
  const Matcher<const internal::StringView&> m3 =
      WhenBase64Unescaped(EndsWith("!"));
  EXPECT_FALSE(m3.Matches("invalid base64"));
  EXPECT_FALSE(m3.Matches("aGVsbG8gd29ybGQ="));  // hello world
  EXPECT_TRUE(m3.Matches("aGVsbG8gd29ybGQh"));   // hello world!
  EXPECT_TRUE(m3.Matches("+/-_IQ"));             // \xfb\xff\xbf!
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
 }
 TEST(WhenBase64UnescapedTest, CanDescribeSelf) {
@ -1838,7 +1940,6 @@ TEST(MatchesRegexTest, MatchesStringMatchingGivenRegex) {
  EXPECT_FALSE(m2.Matches("az1"));
  EXPECT_FALSE(m2.Matches("1az"));
 #if GTEST_INTERNAL_HAS_STRING_VIEW
  const Matcher<const internal::StringView&> m3 = MatchesRegex("a.*z");
  EXPECT_TRUE(m3.Matches(internal::StringView("az")));
  EXPECT_TRUE(m3.Matches(internal::StringView("abcz")));
@ -1848,7 +1949,6 @@ TEST(MatchesRegexTest, MatchesStringMatchingGivenRegex) {
      MatchesRegex(internal::StringView(""));
  EXPECT_TRUE(m4.Matches(internal::StringView("")));
  EXPECT_TRUE(m4.Matches(internal::StringView()));
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
 }
 TEST(MatchesRegexTest, CanDescribeSelf) {
@ -1858,10 +1958,8 @@ TEST(MatchesRegexTest, CanDescribeSelf) {
  Matcher<const char*> m2 = MatchesRegex(new RE("a.*"));
  EXPECT_EQ("matches regular expression \"a.*\"", Describe(m2));
 #if GTEST_INTERNAL_HAS_STRING_VIEW
  Matcher<const internal::StringView> m3 = MatchesRegex(new RE("0.*"));
  EXPECT_EQ("matches regular expression \"0.*\"", Describe(m3));
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
 }
 // Tests ContainsRegex().
@ -1877,7 +1975,6 @@ TEST(ContainsRegexTest, MatchesStringContainingGivenRegex) {
  EXPECT_TRUE(m2.Matches("az1"));
  EXPECT_FALSE(m2.Matches("1a"));
 #if GTEST_INTERNAL_HAS_STRING_VIEW
  const Matcher<const internal::StringView&> m3 = ContainsRegex(new RE("a.*z"));
  EXPECT_TRUE(m3.Matches(internal::StringView("azbz")));
  EXPECT_TRUE(m3.Matches(internal::StringView("az1")));
@ -1887,7 +1984,6 @@ TEST(ContainsRegexTest, MatchesStringContainingGivenRegex) {
      ContainsRegex(internal::StringView(""));
  EXPECT_TRUE(m4.Matches(internal::StringView("")));
  EXPECT_TRUE(m4.Matches(internal::StringView()));
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
 }
 TEST(ContainsRegexTest, CanDescribeSelf) {
@ -1897,10 +1993,8 @@ TEST(ContainsRegexTest, CanDescribeSelf) {
  Matcher<const char*> m2 = ContainsRegex(new RE("a.*"));
  EXPECT_EQ("contains regular expression \"a.*\"", Describe(m2));
 #if GTEST_INTERNAL_HAS_STRING_VIEW
  Matcher<const internal::StringView> m3 = ContainsRegex(new RE("0.*"));
  EXPECT_EQ("contains regular expression \"0.*\"", Describe(m3));
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
 }
 // Tests for wide strings.
@ -2293,22 +2387,19 @@ PolymorphicMatcher<DivisibleByImpl> DivisibleBy(int n) {
  return MakePolymorphicMatcher(DivisibleByImpl(n));
 }
-// Tests that when AllOf() fails, only the first failing matcher is
+// Tests that when AllOf() fails, all failing matchers are asked to explain why.
 // asked to explain why.
 TEST(ExplainMatchResultTest, AllOf_False_False) {
  const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3));
-  EXPECT_EQ("which is 1 modulo 4", Explain(m, 5));
+  EXPECT_EQ("which is 1 modulo 4, and which is 2 modulo 3", Explain(m, 5));
 }
-// Tests that when AllOf() fails, only the first failing matcher is
+// Tests that when AllOf() fails, all failing matchers are asked to explain why.
 // asked to explain why.
 TEST(ExplainMatchResultTest, AllOf_False_True) {
  const Matcher<int> m = AllOf(DivisibleBy(4), DivisibleBy(3));
  EXPECT_EQ("which is 2 modulo 4", Explain(m, 6));
 }
-// Tests that when AllOf() fails, only the first failing matcher is
+// Tests that when AllOf() fails, all failing matchers are asked to explain why.
 // asked to explain why.
 TEST(ExplainMatchResultTest, AllOf_True_False) {
  const Matcher<int> m = AllOf(Ge(1), DivisibleBy(3));
  EXPECT_EQ("which is 2 modulo 3", Explain(m, 5));
@ -2321,9 +2412,79 @@ TEST(ExplainMatchResultTest, AllOf_True_True) {
  EXPECT_EQ("which is 0 modulo 2, and which is 0 modulo 3", Explain(m, 6));
 }
 // Tests that when AllOf() succeeds, but matchers have no explanation,
 // the matcher description is used.
 TEST(ExplainMatchResultTest, AllOf_True_True_2) {
  const Matcher<int> m = AllOf(Ge(2), Le(3));
-  EXPECT_EQ("", Explain(m, 2));
+  EXPECT_EQ("is >= 2, and is <= 3", Explain(m, 2));
 }
 // A matcher that records whether the listener was interested.
 template <typename T>
 class CountingMatcher : public MatcherInterface<T> {
 public:
  explicit CountingMatcher(const Matcher<T>& base_matcher,
                           std::vector<bool>* listener_interested)
      : base_matcher_(base_matcher),
        listener_interested_(listener_interested) {}
  bool MatchAndExplain(T x, MatchResultListener* listener) const override {
    listener_interested_->push_back(listener->IsInterested());
    return base_matcher_.MatchAndExplain(x, listener);
  }
  void DescribeTo(ostream* os) const override { base_matcher_.DescribeTo(os); }
 private:
  Matcher<T> base_matcher_;
  std::vector<bool>* listener_interested_;
 };
 TEST(AllOfTest, DoesNotFormatChildMatchersWhenNotInterested) {
  std::vector<bool> listener_interested;
  Matcher<int> matcher =
      MakeMatcher(new CountingMatcher<int>(Eq(1), &listener_interested));
  EXPECT_TRUE(matcher.Matches(1));
  EXPECT_THAT(listener_interested, ElementsAre(false));
  listener_interested.clear();
  Matcher<int> all_of_matcher = AllOf(matcher, matcher);
  EXPECT_TRUE(all_of_matcher.Matches(1));
  EXPECT_THAT(listener_interested, ElementsAre(false, false));
  listener_interested.clear();
  EXPECT_FALSE(all_of_matcher.Matches(0));
  EXPECT_THAT(listener_interested, ElementsAre(false));
 }
 TEST(AnyOfTest, DoesNotFormatChildMatchersWhenNotInterested) {
  std::vector<bool> listener_interested;
  Matcher<int> matcher =
      MakeMatcher(new CountingMatcher<int>(Eq(1), &listener_interested));
  EXPECT_TRUE(matcher.Matches(1));
  EXPECT_THAT(listener_interested, ElementsAre(false));
  listener_interested.clear();
  Matcher<int> any_of_matcher = AnyOf(matcher, matcher);
  EXPECT_TRUE(any_of_matcher.Matches(1));
  EXPECT_THAT(listener_interested, ElementsAre(false));
  listener_interested.clear();
  EXPECT_FALSE(any_of_matcher.Matches(0));
  EXPECT_THAT(listener_interested, ElementsAre(false, false));
 }
 TEST(OptionalTest, DoesNotFormatChildMatcherWhenNotInterested) {
  std::vector<bool> listener_interested;
  Matcher<int> matcher =
      MakeMatcher(new CountingMatcher<int>(Eq(1), &listener_interested));
  EXPECT_TRUE(matcher.Matches(1));
  EXPECT_THAT(listener_interested, ElementsAre(false));
  listener_interested.clear();
  Matcher<std::optional<int>> optional_matcher = Optional(matcher);
  EXPECT_FALSE(optional_matcher.Matches(std::nullopt));
  EXPECT_THAT(listener_interested, ElementsAre());
  EXPECT_TRUE(optional_matcher.Matches(1));
  EXPECT_THAT(listener_interested, ElementsAre(false));
  listener_interested.clear();
  EXPECT_FALSE(matcher.Matches(0));
  EXPECT_THAT(listener_interested, ElementsAre(false));
 }
 INSTANTIATE_GTEST_MATCHER_TEST_P(ExplainmatcherResultTest);
--- a/test/googletest/googlemock/test/gmock-matchers-containers_test.cc
+++ b/test/googletest/googlemock/test/gmock-matchers-containers_test.cc
@ -31,14 +31,27 @@
 //
 // This file tests some commonly used argument matchers.
 #include <algorithm>
 #include <array>
 #include <cstddef>
 #include <deque>
 #include <forward_list>
 #include <iterator>
 #include <list>
 #include <memory>
 #include <ostream>
 #include <string>
 #include <tuple>
 #include <vector>
 #include "gmock/gmock.h"
 #include "test/gmock-matchers_test.h"
 #include "gtest/gtest.h"
 // Silence warning C4244: 'initializing': conversion from 'int' to 'short',
 // possible loss of data and C4100, unreferenced local parameter
 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4244 4100)
 #include "test/gmock-matchers_test.h"
 namespace testing {
 namespace gmock_matchers_test {
 namespace {
@ -204,7 +217,7 @@ TEST(PointeeTest, ReferenceToNonConstRawPointer) {
 TEST(PointeeTest, SmartPointer) {
  const Matcher<std::unique_ptr<int>> m = Pointee(Ge(0));
-  std::unique_ptr<int> n(new int(1));
+  std::unique_ptr<int> n = std::make_unique<int>(1);
  EXPECT_TRUE(m.Matches(n));
 }
@ -241,7 +254,7 @@ TEST(PointerTest, RawPointerToConst) {
 }
 TEST(PointerTest, SmartPointer) {
-  std::unique_ptr<int> n(new int(10));
+  std::unique_ptr<int> n = std::make_unique<int>(10);
  int* raw_n = n.get();
  const Matcher<std::unique_ptr<int>> m = Pointer(Eq(raw_n));
@ -1034,7 +1047,7 @@ TEST(ResultOfTest, WorksForCompatibleMatcherTypes) {
 // a NULL function pointer.
 TEST(ResultOfDeathTest, DiesOnNullFunctionPointers) {
  EXPECT_DEATH_IF_SUPPORTED(
-      ResultOf(static_cast<std::string (*)(int dummy)>(nullptr),
+      (void)ResultOf(static_cast<std::string (*)(int dummy)>(nullptr),
                     Eq(std::string("foo"))),
      "NULL function pointer is passed into ResultOf\\(\\)\\.");
 }
@ -1192,13 +1205,16 @@ TEST(SizeIsTest, ExplainsResult) {
  vector<int> container;
  EXPECT_EQ("whose size 0 doesn't match", Explain(m1, container));
  EXPECT_EQ("whose size 0 matches", Explain(m2, container));
-  EXPECT_EQ("whose size 0 matches", Explain(m3, container));
+  EXPECT_EQ("whose size 0 matches, which matches (is equal to 0)",
            Explain(m3, container));
  EXPECT_EQ("whose size 0 doesn't match", Explain(m4, container));
  container.push_back(0);
  container.push_back(0);
  EXPECT_EQ("whose size 2 matches", Explain(m1, container));
  EXPECT_EQ("whose size 2 doesn't match", Explain(m2, container));
-  EXPECT_EQ("whose size 2 doesn't match", Explain(m3, container));
+  EXPECT_EQ(
      "whose size 2 doesn't match, isn't equal to 0, and isn't equal to 3",
      Explain(m3, container));
  EXPECT_EQ("whose size 2 matches", Explain(m4, container));
 }
@ -1256,10 +1272,11 @@ TEST(WhenSortedByTest, CanDescribeSelf) {
 TEST(WhenSortedByTest, ExplainsMatchResult) {
  const int a[] = {2, 1};
-  EXPECT_EQ("which is { 1, 2 } when sorted, whose element #0 doesn't match",
+  EXPECT_EQ(
-            Explain(WhenSortedBy(less<int>(), ElementsAre(2, 3)), a));
+      Explain(WhenSortedBy(less<int>(), ElementsAre(2, 3)), a),
-  EXPECT_EQ("which is { 1, 2 } when sorted",
+      "which is { 1, 2 } when sorted, whose element #0 (1) isn't equal to 2");
-            Explain(WhenSortedBy(less<int>(), ElementsAre(1, 2)), a));
+  EXPECT_EQ(Explain(WhenSortedBy(less<int>(), ElementsAre(1, 2)), a),
            "which is { 1, 2 } when sorted");
 }
 // WhenSorted() is a simple wrapper on WhenSortedBy().  Hence we don't
@ -1463,7 +1480,9 @@ TEST_P(BeginEndDistanceIsTestP, ExplainsResult) {
            Explain(m1, container));
  EXPECT_EQ("whose distance between begin() and end() 0 matches",
            Explain(m2, container));
-  EXPECT_EQ("whose distance between begin() and end() 0 matches",
+  EXPECT_EQ(
      "whose distance between begin() and end() 0 matches, which matches (is "
      "equal to 0)",
      Explain(m3, container));
  EXPECT_EQ(
      "whose distance between begin() and end() 0 doesn't match, which is 1 "
@ -1475,7 +1494,9 @@ TEST_P(BeginEndDistanceIsTestP, ExplainsResult) {
            Explain(m1, container));
  EXPECT_EQ("whose distance between begin() and end() 2 doesn't match",
            Explain(m2, container));
-  EXPECT_EQ("whose distance between begin() and end() 2 doesn't match",
+  EXPECT_EQ(
      "whose distance between begin() and end() 2 doesn't match, isn't equal "
      "to 0, and isn't equal to 3",
      Explain(m3, container));
  EXPECT_EQ(
      "whose distance between begin() and end() 2 matches, which is 1 more "
@ -1756,6 +1777,295 @@ TEST(IsSubsetOfTest, WorksWithMoveOnly) {
  helper.Call(MakeUniquePtrs({2}));
 }
 // A container whose iterator returns a temporary. This can iterate over the
 // characters in a string.
 class CharString {
 public:
  using value_type = char;
  class const_iterator {
   public:
    using iterator_category = std::input_iterator_tag;
    using value_type = char;
    using difference_type = std::ptrdiff_t;
    using pointer = const char*;
    using reference = const char&;
    // Create an iterator that points to the given character.
    explicit const_iterator(const char* ptr) : ptr_(ptr) {}
    // Returns the current character. IMPORTANT: this must return a temporary,
    // not a reference, to test that ElementsAre() works with containers whose
    // iterators return temporaries.
    char operator*() const { return *ptr_; }
    // Advances to the next character.
    const_iterator& operator++() {
      ++ptr_;
      return *this;
    }
    // Compares two iterators.
    bool operator==(const const_iterator& other) const {
      return ptr_ == other.ptr_;
    }
    bool operator!=(const const_iterator& other) const {
      return ptr_ != other.ptr_;
    }
   private:
    const char* ptr_ = nullptr;
  };
  // Creates a CharString that contains the given string.
  explicit CharString(const std::string& s) : s_(s) {}
  // Returns an iterator pointing to the first character in the string.
  const_iterator begin() const { return const_iterator(s_.c_str()); }
  // Returns an iterator pointing past the last character in the string.
  const_iterator end() const { return const_iterator(s_.c_str() + s_.size()); }
 private:
  std::string s_;
 };
 // Tests using ElementsAre() with a container whose iterator returns a
 // temporary.
 TEST(ElementsAreTest, WorksWithContainerThatReturnsTempInIterator) {
  CharString s("abc");
  EXPECT_THAT(s, ElementsAre('a', 'b', 'c'));
  EXPECT_THAT(s, Not(ElementsAre('a', 'b', 'd')));
 }
 // Tests using ElementsAreArray() with a container whose iterator returns a
 // temporary.
 TEST(ElementsAreArrayTest, WorksWithContainerThatReturnsTempInIterator) {
  CharString s("abc");
  EXPECT_THAT(s, ElementsAreArray({'a', 'b', 'c'}));
  EXPECT_THAT(s, Not(ElementsAreArray({'a', 'b', 'd'})));
 }
 // A container whose iterator returns a temporary and is not copy-assignable.
 // This simulates the behavior of the proxy object returned by absl::StrSplit().
 class CharString2 {
 public:
  using value_type = char;
  class const_iterator {
   public:
    using iterator_category = std::input_iterator_tag;
    using value_type = char;
    using difference_type = std::ptrdiff_t;
    using pointer = const char*;
    using reference = const char&;
    // Make const_iterator copy-constructible but not copy-assignable,
    // simulating the behavior of the proxy object returned by absl::StrSplit().
    const_iterator(const const_iterator&) = default;
    const_iterator& operator=(const const_iterator&) = delete;
    // Create an iterator that points to the given character.
    explicit const_iterator(const char* ptr) : ptr_(ptr) {}
    // Returns the current character. IMPORTANT: this must return a temporary,
    // not a reference, to test that ElementsAre() works with containers whose
    // iterators return temporaries.
    char operator*() const { return *ptr_; }
    // Advances to the next character.
    const_iterator& operator++() {
      ++ptr_;
      return *this;
    }
    // Compares two iterators.
    bool operator==(const const_iterator& other) const {
      return ptr_ == other.ptr_;
    }
    bool operator!=(const const_iterator& other) const {
      return ptr_ != other.ptr_;
    }
   private:
    const char* ptr_ = nullptr;
  };
  // Creates a CharString that contains the given string.
  explicit CharString2(const std::string& s) : s_(s) {}
  // Returns an iterator pointing to the first character in the string.
  const_iterator begin() const { return const_iterator(s_.c_str()); }
  // Returns an iterator pointing past the last character in the string.
  const_iterator end() const { return const_iterator(s_.c_str() + s_.size()); }
 private:
  std::string s_;
 };
 // Tests using ElementsAre() with a container whose iterator returns a
 // temporary and is not copy-assignable.
 TEST(ElementsAreTest, WorksWithContainerThatReturnsTempInUnassignableIterator) {
  CharString2 s("abc");
  EXPECT_THAT(s, ElementsAre('a', 'b', 'c'));
  EXPECT_THAT(s, Not(ElementsAre('a', 'b', 'd')));
 }
 // Tests using ElementsAreArray() with a container whose iterator returns a
 // temporary and is not copy-assignable.
 TEST(ElementsAreArrayTest,
     WorksWithContainerThatReturnsTempInUnassignableIterator) {
  CharString2 s("abc");
  EXPECT_THAT(s, ElementsAreArray({'a', 'b', 'c'}));
  EXPECT_THAT(s, Not(ElementsAreArray({'a', 'b', 'd'})));
 }
 // A container whose iterator returns a temporary and is neither
 // copy-constructible nor copy-assignable.
 class CharString3 {
 public:
  using value_type = char;
  class const_iterator {
   public:
    using iterator_category = std::input_iterator_tag;
    using value_type = char;
    using difference_type = std::ptrdiff_t;
    using pointer = const char*;
    using reference = const char&;
    // Make const_iterator neither copy-constructible nor copy-assignable.
    const_iterator(const const_iterator&) = delete;
    const_iterator& operator=(const const_iterator&) = delete;
    // Create an iterator that points to the given character.
    explicit const_iterator(const char* ptr) : ptr_(ptr) {}
    // Returns the current character. IMPORTANT: this must return a temporary,
    // not a reference, to test that ElementsAre() works with containers whose
    // iterators return temporaries.
    char operator*() const { return *ptr_; }
    // Advances to the next character.
    const_iterator& operator++() {
      ++ptr_;
      return *this;
    }
    // Compares two iterators.
    bool operator==(const const_iterator& other) const {
      return ptr_ == other.ptr_;
    }
    bool operator!=(const const_iterator& other) const {
      return ptr_ != other.ptr_;
    }
   private:
    const char* ptr_ = nullptr;
  };
  // Creates a CharString that contains the given string.
  explicit CharString3(const std::string& s) : s_(s) {}
  // Returns an iterator pointing to the first character in the string.
  const_iterator begin() const { return const_iterator(s_.c_str()); }
  // Returns an iterator pointing past the last character in the string.
  const_iterator end() const { return const_iterator(s_.c_str() + s_.size()); }
 private:
  std::string s_;
 };
 // Tests using ElementsAre() with a container whose iterator returns a
 // temporary and is neither copy-constructible nor copy-assignable.
 TEST(ElementsAreTest, WorksWithContainerThatReturnsTempInUncopyableIterator) {
  CharString3 s("abc");
  EXPECT_THAT(s, ElementsAre('a', 'b', 'c'));
  EXPECT_THAT(s, Not(ElementsAre('a', 'b', 'd')));
 }
 // Tests using ElementsAreArray() with a container whose iterator returns a
 // temporary and is neither copy-constructible nor copy-assignable.
 TEST(ElementsAreArrayTest,
     WorksWithContainerThatReturnsTempInUncopyableIterator) {
  CharString3 s("abc");
  EXPECT_THAT(s, ElementsAreArray({'a', 'b', 'c'}));
  EXPECT_THAT(s, Not(ElementsAreArray({'a', 'b', 'd'})));
 }
 // A container whose iterator returns a temporary, is neither
 // copy-constructible nor copy-assignable, and has no member types.
 class CharString4 {
 public:
  using value_type = char;
  class const_iterator {
   public:
    // Do not define difference_type, etc.
    // Make const_iterator neither copy-constructible nor copy-assignable.
    const_iterator(const const_iterator&) = delete;
    const_iterator& operator=(const const_iterator&) = delete;
    // Create an iterator that points to the given character.
    explicit const_iterator(const char* ptr) : ptr_(ptr) {}
    // Returns the current character. IMPORTANT: this must return a temporary,
    // not a reference, to test that ElementsAre() works with containers whose
    // iterators return temporaries.
    char operator*() const { return *ptr_; }
    // Advances to the next character.
    const_iterator& operator++() {
      ++ptr_;
      return *this;
    }
    // Compares two iterators.
    bool operator==(const const_iterator& other) const {
      return ptr_ == other.ptr_;
    }
    bool operator!=(const const_iterator& other) const {
      return ptr_ != other.ptr_;
    }
   private:
    const char* ptr_ = nullptr;
  };
  // Creates a CharString that contains the given string.
  explicit CharString4(const std::string& s) : s_(s) {}
  // Returns an iterator pointing to the first character in the string.
  const_iterator begin() const { return const_iterator(s_.c_str()); }
  // Returns an iterator pointing past the last character in the string.
  const_iterator end() const { return const_iterator(s_.c_str() + s_.size()); }
 private:
  std::string s_;
 };
 // Tests using ElementsAre() with a container whose iterator returns a
 // temporary, is neither copy-constructible nor copy-assignable, and has no
 // member types.
 TEST(ElementsAreTest, WorksWithContainerWithIteratorWithNoMemberTypes) {
  CharString4 s("abc");
  EXPECT_THAT(s, ElementsAre('a', 'b', 'c'));
  EXPECT_THAT(s, Not(ElementsAre('a', 'b', 'd')));
 }
 // Tests using ElementsAreArray() with a container whose iterator returns a
 // temporary, is neither copy-constructible nor copy-assignable, and has no
 // member types.
 TEST(ElementsAreArrayTest, WorksWithContainerWithIteratorWithNoMemberTypes) {
  CharString4 s("abc");
  EXPECT_THAT(s, ElementsAreArray({'a', 'b', 'c'}));
  EXPECT_THAT(s, Not(ElementsAreArray({'a', 'b', 'd'})));
 }
 // Tests using ElementsAre() and ElementsAreArray() with stream-like
 // "containers".
@ -1824,8 +2134,8 @@ TEST(UnorderedElementsAreArrayTest, SucceedsWhenExpected) {
 }
 TEST(UnorderedElementsAreArrayTest, VectorBool) {
-  const bool a[] = {0, 1, 0, 1, 1};
+  const bool a[] = {false, true, false, true, true};
-  const bool b[] = {1, 0, 1, 1, 0};
+  const bool b[] = {true, false, true, true, false};
  std::vector<bool> expected(std::begin(a), std::end(a));
  std::vector<bool> actual(std::begin(b), std::end(b));
  StringMatchResultListener listener;
@ -2002,7 +2312,14 @@ TEST_F(UnorderedElementsAreTest, FailMessageCountWrong) {
  StringMatchResultListener listener;
  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3), v, &listener))
      << listener.str();
-  EXPECT_THAT(listener.str(), Eq("which has 1 element"));
+  EXPECT_THAT(listener.str(),
              Eq("which has 1 element\n"
                 "where the following matchers don't match any elements:\n"
                 "matcher #0: is equal to 1,\n"
                 "matcher #1: is equal to 2,\n"
                 "matcher #2: is equal to 3\n"
                 "and where the following elements don't match any matchers:\n"
                 "element #0: 4"));
 }
 TEST_F(UnorderedElementsAreTest, FailMessageCountWrongZero) {
@ -2010,7 +2327,11 @@ TEST_F(UnorderedElementsAreTest, FailMessageCountWrongZero) {
  StringMatchResultListener listener;
  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3), v, &listener))
      << listener.str();
-  EXPECT_THAT(listener.str(), Eq(""));
+  EXPECT_THAT(listener.str(),
              Eq("where the following matchers don't match any elements:\n"
                 "matcher #0: is equal to 1,\n"
                 "matcher #1: is equal to 2,\n"
                 "matcher #2: is equal to 3"));
 }
 TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedMatchers) {
@ -2426,7 +2747,7 @@ TEST(UnorderedPointwiseTest, RejectsWrongSize) {
  const double lhs[2] = {1, 2};
  const int rhs[1] = {0};
  EXPECT_THAT(lhs, Not(UnorderedPointwise(Gt(), rhs)));
-  EXPECT_EQ("which has 2 elements",
+  EXPECT_EQ("which has 2 elements\n",
            Explain(UnorderedPointwise(Gt(), rhs), lhs));
  const int rhs2[3] = {0, 1, 2};
@ -2475,7 +2796,7 @@ TEST(UnorderedPointwiseTest, WorksWithMoveOnly) {
 }
 TEST(PointeeTest, WorksOnMoveOnlyType) {
-  std::unique_ptr<int> p(new int(3));
+  std::unique_ptr<int> p = std::make_unique<int>(3);
  EXPECT_THAT(p, Pointee(Eq(3)));
  EXPECT_THAT(p, Not(Pointee(Eq(2))));
 }
@ -2639,11 +2960,11 @@ TEST_P(ElementsAreTestP, CanExplainMismatchRightSize) {
  vector<int> v;
  v.push_back(2);
  v.push_back(1);
-  EXPECT_EQ("whose element #0 doesn't match", Explain(m, v));
+  EXPECT_EQ(Explain(m, v), "whose element #0 (2) isn't equal to 1");
  v[0] = 1;
-  EXPECT_EQ("whose element #1 doesn't match, which is 4 less than 5",
+  EXPECT_EQ(Explain(m, v),
-            Explain(m, v));
+            "whose element #1 (1) is <= 5, which is 4 less than 5");
 }
 TEST(ElementsAreTest, MatchesOneElementVector) {
@ -2776,7 +3097,7 @@ TEST(ElementsAreTest, WorksWithNativeArrayPassedByReference) {
 class NativeArrayPassedAsPointerAndSize {
 public:
-  NativeArrayPassedAsPointerAndSize() {}
+  NativeArrayPassedAsPointerAndSize() = default;
  MOCK_METHOD(void, Helper, (int* array, int size));
@ -3118,6 +3439,78 @@ TEST(ContainsTest, WorksForTwoDimensionalNativeArray) {
  EXPECT_THAT(a, Contains(Not(Contains(5))));
 }
 // Tests ContainsSubsequence().
 TEST(ContainsSubsequenceTest, WorksForNativeArray) {
  const int a[] = {1, 2, 3, 4, 5};
  EXPECT_THAT(a, ContainsSubsequence(1, 3, 4));
  EXPECT_THAT(a, Not(ContainsSubsequence(1, 3, 2)));
 }
 TEST(ContainsSubsequenceTest, AcceptsMatcher) {
  const int a[] = {1, 2, 3, 4, 5};
  EXPECT_THAT(a, ContainsSubsequence(Eq(1), Gt(3), Gt(4)));
  EXPECT_THAT(a, Not(ContainsSubsequence(1, Gt(3), Lt(3))));
 }
 TEST(ContainsSubsequenceTest, WorksForTwoDimensionalNativeArray) {
  int a[][3] = {{1, 2, 3}, {7, 8, 9}, {4, 5, 6}};
  EXPECT_THAT(a, ContainsSubsequence(ElementsAre(1, 2, 3), Contains(4)));
  EXPECT_THAT(a,
              Not(ContainsSubsequence(Contains(1), Contains(8), Contains(9))));
 }
 TEST(ContainsSubsequenceTest, WorksForVector) {
  const vector<int> a = {1, 2, 3, 4, 5};
  EXPECT_THAT(a, ContainsSubsequence(1, 3, 4));
  EXPECT_THAT(a, Not(ContainsSubsequence(1, 3, 2)));
 }
 TEST(ContainsSubsequenceTest, WorksForEmptySmallSizedSubsequences) {
  const int a[] = {1, 2, 3, 4, 5};
  EXPECT_THAT(a, ContainsSubsequence());
  EXPECT_THAT(a, ContainsSubsequence(Gt(4)));
  EXPECT_THAT(a, Not(ContainsSubsequence(Gt(6))));
  EXPECT_THAT(a, ContainsSubsequence(Lt(2), Gt(3)));
  EXPECT_THAT(a, Not(ContainsSubsequence(Lt(2), Lt(2))));
 }
 TEST(ContainsSubsequenceTest, DescribesItselfCorrectly) {
  Matcher<const int (&)[5]> m = ContainsSubsequence(1, 3, 4);
  EXPECT_EQ(
      "contains in order a subsequence of elements that matches: is equal to "
      "1, then is equal to 3, then is equal to 4",
      Describe(m));
  m = ContainsSubsequence(Eq(1), Gt(3), Gt(4));
  EXPECT_EQ(
      "contains in order a subsequence of elements that matches: is equal to "
      "1, then is > 3, then is > 4",
      Describe(m));
  m = Not(ContainsSubsequence(1, 3, 4));
  EXPECT_EQ(
      "does not contain in order a subsequence of elements that matches is "
      "equal to 1, then is equal to 3, then is equal to 4",
      Describe(m));
 }
 TEST(ContainsSubsequenceTest, ExplainsMismatchCorrectlyForSingleMatcher) {
  const int a[] = {1, 2, 3, 4, 5};
  Matcher<const int (&)[5]> m = ContainsSubsequence(Eq(6));
  EXPECT_EQ(Explain(m, a),
            "could not find a match for matcher #0 (is equal to 6)");
 }
 TEST(ContainsSubsequenceTest, ExplainsMismatchCorrectlyForMultipleMatchers) {
  const int a[] = {1, 2, 3, 4, 5};
  Matcher<const int (&)[5]> m = ContainsSubsequence(Eq(2), Gt(4), Gt(4));
  EXPECT_EQ(
      Explain(m, a),
      "found match for matcher #0 with element at position #1, found match for "
      "matcher #1 with element at position #4, but could not find a match for "
      "matcher #2 (is > 4) after the last match at position #4");
 }
 }  // namespace
 }  // namespace gmock_matchers_test
 }  // namespace testing
--- a/test/googletest/googlemock/test/gmock-matchers-misc_test.cc
+++ b/test/googletest/googlemock/test/gmock-matchers-misc_test.cc
@ -31,14 +31,23 @@
 //
 // This file tests some commonly used argument matchers.
 #include <array>
 #include <cstdint>
 #include <memory>
 #include <ostream>
 #include <string>
 #include <tuple>
 #include <utility>
 #include <vector>
 #include "gmock/gmock.h"
 #include "test/gmock-matchers_test.h"
 #include "gtest/gtest.h"
 // Silence warning C4244: 'initializing': conversion from 'int' to 'short',
 // possible loss of data and C4100, unreferenced local parameter
 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4244 4100)
 #include "test/gmock-matchers_test.h"
 namespace testing {
 namespace gmock_matchers_test {
 namespace {
@ -70,7 +79,7 @@ TEST(AddressTest, Const) {
 }
 TEST(AddressTest, MatcherDoesntCopy) {
-  std::unique_ptr<int> n(new int(1));
+  std::unique_ptr<int> n = std::make_unique<int>(1);
  const Matcher<std::unique_ptr<int>> m = Address(Eq(&n));
  EXPECT_TRUE(m.Matches(n));
@ -193,14 +202,14 @@ TEST(IsTrueTest, IsTrueIsFalse) {
  EXPECT_THAT(nullptr, Not(IsTrue()));
  EXPECT_THAT(nullptr, IsFalse());
  std::unique_ptr<int> null_unique;
-  std::unique_ptr<int> nonnull_unique(new int(0));
+  std::unique_ptr<int> nonnull_unique = std::make_unique<int>(0);
  EXPECT_THAT(null_unique, Not(IsTrue()));
  EXPECT_THAT(null_unique, IsFalse());
  EXPECT_THAT(nonnull_unique, IsTrue());
  EXPECT_THAT(nonnull_unique, Not(IsFalse()));
 }
-#if GTEST_HAS_TYPED_TEST
+#ifdef GTEST_HAS_TYPED_TEST
 // Tests ContainerEq with different container types, and
 // different element types.
@ -666,6 +675,8 @@ TEST_P(MatcherTupleTestP, ExplainsMatchFailure) {
                   // explanation.
 }
 #if GTEST_HAS_TYPED_TEST
 // Sample optional type implementation with minimal requirements for use with
 // Optional matcher.
 template <typename T>
@ -683,38 +694,94 @@ class SampleOptional {
  bool has_value_;
 };
-TEST(OptionalTest, DescribesSelf) {
+// Sample optional type implementation with alternative minimal requirements for
-  const Matcher<SampleOptional<int>> m = Optional(Eq(1));
+// use with Optional matcher. In particular, while it doesn't have a bool
 // conversion operator, it does have a has_value() method.
 template <typename T>
 class SampleOptionalWithoutBoolConversion {
 public:
  using value_type = T;
  explicit SampleOptionalWithoutBoolConversion(T value)
      : value_(std::move(value)), has_value_(true) {}
  SampleOptionalWithoutBoolConversion() : value_(), has_value_(false) {}
  bool has_value() const { return has_value_; }
  const T& operator*() const { return value_; }
 private:
  T value_;
  bool has_value_;
 };
 template <typename T>
 class OptionalTest : public testing::Test {};
 using OptionalTestTypes =
    testing::Types<SampleOptional<int>,
                   SampleOptionalWithoutBoolConversion<int>>;
 TYPED_TEST_SUITE(OptionalTest, OptionalTestTypes);
 TYPED_TEST(OptionalTest, DescribesSelf) {
  const Matcher<TypeParam> m = Optional(Eq(1));
  EXPECT_EQ("value is equal to 1", Describe(m));
 }
-TEST(OptionalTest, ExplainsSelf) {
+TYPED_TEST(OptionalTest, ExplainsSelf) {
-  const Matcher<SampleOptional<int>> m = Optional(Eq(1));
+  const Matcher<TypeParam> m = Optional(Eq(1));
-  EXPECT_EQ("whose value 1 matches", Explain(m, SampleOptional<int>(1)));
+  EXPECT_EQ("whose value 1 matches", Explain(m, TypeParam(1)));
-  EXPECT_EQ("whose value 2 doesn't match", Explain(m, SampleOptional<int>(2)));
+  EXPECT_EQ("whose value 2 doesn't match", Explain(m, TypeParam(2)));
 }
-TEST(OptionalTest, MatchesNonEmptyOptional) {
+TYPED_TEST(OptionalTest, MatchesNonEmptyOptional) {
-  const Matcher<SampleOptional<int>> m1 = Optional(1);
+  const Matcher<TypeParam> m1 = Optional(1);
-  const Matcher<SampleOptional<int>> m2 = Optional(Eq(2));
+  const Matcher<TypeParam> m2 = Optional(Eq(2));
-  const Matcher<SampleOptional<int>> m3 = Optional(Lt(3));
+  const Matcher<TypeParam> m3 = Optional(Lt(3));
-  SampleOptional<int> opt(1);
+  TypeParam opt(1);
  EXPECT_TRUE(m1.Matches(opt));
  EXPECT_FALSE(m2.Matches(opt));
  EXPECT_TRUE(m3.Matches(opt));
 }
-TEST(OptionalTest, DoesNotMatchNullopt) {
+TYPED_TEST(OptionalTest, DoesNotMatchNullopt) {
-  const Matcher<SampleOptional<int>> m = Optional(1);
+  const Matcher<TypeParam> m = Optional(1);
-  SampleOptional<int> empty;
+  TypeParam empty;
  EXPECT_FALSE(m.Matches(empty));
 }
-TEST(OptionalTest, WorksWithMoveOnly) {
+TYPED_TEST(OptionalTest, ComposesWithMonomorphicMatchersTakingReferences) {
-  Matcher<SampleOptional<std::unique_ptr<int>>> m = Optional(Eq(nullptr));
+  const Matcher<const int&> eq1 = Eq(1);
-  EXPECT_TRUE(m.Matches(SampleOptional<std::unique_ptr<int>>(nullptr)));
+  const Matcher<const int&> eq2 = Eq(2);
  TypeParam opt(1);
  EXPECT_THAT(opt, Optional(eq1));
  EXPECT_THAT(opt, Optional(Not(eq2)));
  EXPECT_THAT(opt, Optional(AllOf(eq1, Not(eq2))));
 }
 TYPED_TEST(OptionalTest, ComposesWithMonomorphicMatchersRequiringConversion) {
  const Matcher<int64_t> eq1 = Eq(1);
  const Matcher<int64_t> eq2 = Eq(2);
  TypeParam opt(1);
  EXPECT_THAT(opt, Optional(eq1));
  EXPECT_THAT(opt, Optional(Not(eq2)));
  EXPECT_THAT(opt, Optional(AllOf(eq1, Not(eq2))));
 }
 template <typename T>
 class MoveOnlyOptionalTest : public testing::Test {};
 using MoveOnlyOptionalTestTypes =
    testing::Types<SampleOptional<std::unique_ptr<int>>,
                   SampleOptionalWithoutBoolConversion<std::unique_ptr<int>>>;
 TYPED_TEST_SUITE(MoveOnlyOptionalTest, MoveOnlyOptionalTestTypes);
 TYPED_TEST(MoveOnlyOptionalTest, WorksWithMoveOnly) {
  Matcher<TypeParam> m = Optional(Eq(nullptr));
  EXPECT_TRUE(m.Matches(TypeParam(nullptr)));
 }
 #endif  // GTEST_HAS_TYPED_TEST
 class SampleVariantIntString {
 public:
  SampleVariantIntString(int i) : i_(i), has_int_(true) {}
@ -722,7 +789,7 @@ class SampleVariantIntString {
  template <typename T>
  friend bool holds_alternative(const SampleVariantIntString& value) {
-    return value.has_int_ == std::is_same<T, int>::value;
+    return value.has_int_ == std::is_same_v<T, int>;
  }
  template <typename T>
@ -1568,10 +1635,10 @@ TEST_P(AnyOfArrayTestP, ExplainsMatchResultCorrectly) {
  const Matcher<int> m1 = AnyOfArray(v1);
  const Matcher<int> m2 = AnyOfArray(v2);
  EXPECT_EQ("", Explain(m0, 0));
-  EXPECT_EQ("", Explain(m1, 1));
+  EXPECT_EQ("which matches (is equal to 1)", Explain(m1, 1));
-  EXPECT_EQ("", Explain(m1, 2));
+  EXPECT_EQ("isn't equal to 1", Explain(m1, 2));
-  EXPECT_EQ("", Explain(m2, 3));
+  EXPECT_EQ("which matches (is equal to 3)", Explain(m2, 3));
-  EXPECT_EQ("", Explain(m2, 4));
+  EXPECT_EQ("isn't equal to 2, and isn't equal to 3", Explain(m2, 4));
  EXPECT_EQ("()", Describe(m0));
  EXPECT_EQ("(is equal to 1)", Describe(m1));
  EXPECT_EQ("(is equal to 2) or (is equal to 3)", Describe(m2));
@ -1598,7 +1665,7 @@ MATCHER(IsNotNull, "") { return arg != nullptr; }
 // Verifies that a matcher defined using MATCHER() can work on
 // move-only types.
 TEST(MatcherMacroTest, WorksOnMoveOnlyType) {
-  std::unique_ptr<int> p(new int(3));
+  std::unique_ptr<int> p = std::make_unique<int>(3);
  EXPECT_THAT(p, IsNotNull());
  EXPECT_THAT(std::unique_ptr<int>(), Not(IsNotNull()));
 }
@ -1608,7 +1675,7 @@ MATCHER_P(UniquePointee, pointee, "") { return *arg == pointee; }
 // Verifies that a matcher defined using MATCHER_P*() can work on
 // move-only types.
 TEST(MatcherPMacroTest, WorksOnMoveOnlyType) {
-  std::unique_ptr<int> p(new int(3));
+  std::unique_ptr<int> p = std::make_unique<int>(3);
  EXPECT_THAT(p, UniquePointee(3));
  EXPECT_THAT(p, Not(UniquePointee(2)));
 }
--- a/test/googletest/googlemock/test/gmock-matchers_test.h
+++ b/test/googletest/googlemock/test/gmock-matchers_test.h
@ -123,8 +123,7 @@ struct GtestGreaterThanMatcher {
 };
 template <typename T>
-GtestGreaterThanMatcher<typename std::decay<T>::type> GtestGreaterThan(
+GtestGreaterThanMatcher<std::decay_t<T>> GtestGreaterThan(T&& rhs) {
    T&& rhs) {
  return {rhs};
 }
--- a/test/googletest/googlemock/test/gmock-more-actions_test.cc
+++ b/test/googletest/googlemock/test/gmock-more-actions_test.cc
@ -33,10 +33,14 @@
 #include "gmock/gmock-more-actions.h"
 #include <algorithm>
 #include <functional>
 #include <iterator>
 #include <memory>
 #include <sstream>
 #include <string>
 #include <tuple>
 #include <vector>
 #include "gmock/gmock.h"
 #include "gtest/gtest-spi.h"
@ -55,6 +59,7 @@ using testing::Invoke;
 using testing::ReturnArg;
 using testing::ReturnPointee;
 using testing::SaveArg;
 using testing::SaveArgByMove;
 using testing::SaveArgPointee;
 using testing::SetArgReferee;
 using testing::Unused;
@ -81,6 +86,16 @@ struct UnaryFunctor {
  int operator()(bool x) { return x ? 1 : -1; }
 };
 struct UnaryMoveOnlyFunctor : UnaryFunctor {
  UnaryMoveOnlyFunctor() = default;
  UnaryMoveOnlyFunctor(const UnaryMoveOnlyFunctor&) = delete;
  UnaryMoveOnlyFunctor(UnaryMoveOnlyFunctor&&) = default;
 };
 struct OneShotUnaryFunctor {
  int operator()(bool x) && { return x ? 1 : -1; }
 };
 const char* Binary(const char* input, short n) { return input + n; }  // NOLINT
 int Ternary(int x, char y, short z) { return x + y + z; }  // NOLINT
@ -187,45 +202,45 @@ class Foo {
 // Tests using Invoke() with a nullary function.
 TEST(InvokeTest, Nullary) {
-  Action<int()> a = Invoke(Nullary);  // NOLINT
+  Action<int()> a = &Nullary;
  EXPECT_EQ(1, a.Perform(std::make_tuple()));
 }
 // Tests using Invoke() with a unary function.
 TEST(InvokeTest, Unary) {
-  Action<bool(int)> a = Invoke(Unary);  // NOLINT
+  Action<bool(int)> a = &Unary;
  EXPECT_FALSE(a.Perform(std::make_tuple(1)));
  EXPECT_TRUE(a.Perform(std::make_tuple(-1)));
 }
 // Tests using Invoke() with a binary function.
 TEST(InvokeTest, Binary) {
-  Action<const char*(const char*, short)> a = Invoke(Binary);  // NOLINT
+  Action<const char*(const char*, short)> a = &Binary;  // NOLINT
  const char* p = "Hello";
  EXPECT_EQ(p + 2, a.Perform(std::make_tuple(p, Short(2))));
 }
 // Tests using Invoke() with a ternary function.
 TEST(InvokeTest, Ternary) {
-  Action<int(int, char, short)> a = Invoke(Ternary);  // NOLINT
+  Action<int(int, char, short)> a = &Ternary;  // NOLINT
  EXPECT_EQ(6, a.Perform(std::make_tuple(1, '\2', Short(3))));
 }
 // Tests using Invoke() with a 4-argument function.
 TEST(InvokeTest, FunctionThatTakes4Arguments) {
-  Action<int(int, int, int, int)> a = Invoke(SumOf4);  // NOLINT
+  Action<int(int, int, int, int)> a = &SumOf4;
  EXPECT_EQ(1234, a.Perform(std::make_tuple(1000, 200, 30, 4)));
 }
 // Tests using Invoke() with a 5-argument function.
 TEST(InvokeTest, FunctionThatTakes5Arguments) {
-  Action<int(int, int, int, int, int)> a = Invoke(SumOf5);  // NOLINT
+  Action<int(int, int, int, int, int)> a = &SumOf5;
  EXPECT_EQ(12345, a.Perform(std::make_tuple(10000, 2000, 300, 40, 5)));
 }
 // Tests using Invoke() with a 6-argument function.
 TEST(InvokeTest, FunctionThatTakes6Arguments) {
-  Action<int(int, int, int, int, int, int)> a = Invoke(SumOf6);  // NOLINT
+  Action<int(int, int, int, int, int, int)> a = &SumOf6;
  EXPECT_EQ(123456,
            a.Perform(std::make_tuple(100000, 20000, 3000, 400, 50, 6)));
 }
@ -238,7 +253,7 @@ inline const char* CharPtr(const char* s) { return s; }
 TEST(InvokeTest, FunctionThatTakes7Arguments) {
  Action<std::string(const char*, const char*, const char*, const char*,
                     const char*, const char*, const char*)>
-      a = Invoke(Concat7);
+      a = &Concat7;
  EXPECT_EQ("1234567",
            a.Perform(std::make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                      CharPtr("4"), CharPtr("5"), CharPtr("6"),
@ -249,7 +264,7 @@ TEST(InvokeTest, FunctionThatTakes7Arguments) {
 TEST(InvokeTest, FunctionThatTakes8Arguments) {
  Action<std::string(const char*, const char*, const char*, const char*,
                     const char*, const char*, const char*, const char*)>
-      a = Invoke(Concat8);
+      a = &Concat8;
  EXPECT_EQ("12345678",
            a.Perform(std::make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                      CharPtr("4"), CharPtr("5"), CharPtr("6"),
@ -261,7 +276,7 @@ TEST(InvokeTest, FunctionThatTakes9Arguments) {
  Action<std::string(const char*, const char*, const char*, const char*,
                     const char*, const char*, const char*, const char*,
                     const char*)>
-      a = Invoke(Concat9);
+      a = &Concat9;
  EXPECT_EQ("123456789", a.Perform(std::make_tuple(
                             CharPtr("1"), CharPtr("2"), CharPtr("3"),
                             CharPtr("4"), CharPtr("5"), CharPtr("6"),
@ -273,7 +288,7 @@ TEST(InvokeTest, FunctionThatTakes10Arguments) {
  Action<std::string(const char*, const char*, const char*, const char*,
                     const char*, const char*, const char*, const char*,
                     const char*, const char*)>
-      a = Invoke(Concat10);
+      a = &Concat10;
  EXPECT_EQ("1234567890",
            a.Perform(std::make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                      CharPtr("4"), CharPtr("5"), CharPtr("6"),
@ -283,12 +298,12 @@ TEST(InvokeTest, FunctionThatTakes10Arguments) {
 // Tests using Invoke() with functions with parameters declared as Unused.
 TEST(InvokeTest, FunctionWithUnusedParameters) {
-  Action<int(int, int, double, const std::string&)> a1 = Invoke(SumOfFirst2);
+  Action<int(int, int, double, const std::string&)> a1 = &SumOfFirst2;
  std::tuple<int, int, double, std::string> dummy =
      std::make_tuple(10, 2, 5.6, std::string("hi"));
  EXPECT_EQ(12, a1.Perform(dummy));
-  Action<int(int, int, bool, int*)> a2 = Invoke(SumOfFirst2);
+  Action<int(int, int, bool, int*)> a2 = &SumOfFirst2;
  EXPECT_EQ(
      23, a2.Perform(std::make_tuple(20, 3, true, static_cast<int*>(nullptr))));
 }
@ -305,13 +320,13 @@ TEST(InvokeTest, MethodWithUnusedParameters) {
 // Tests using Invoke() with a functor.
 TEST(InvokeTest, Functor) {
-  Action<long(long, int)> a = Invoke(plus<long>());  // NOLINT
+  Action<long(long, int)> a = plus<long>();  // NOLINT
  EXPECT_EQ(3L, a.Perform(std::make_tuple(1, 2)));
 }
 // Tests using Invoke(f) as an action of a compatible type.
 TEST(InvokeTest, FunctionWithCompatibleType) {
-  Action<long(int, short, char, bool)> a = Invoke(SumOf4);  // NOLINT
+  Action<long(int, short, char, bool)> a = &SumOf4;  // NOLINT
  EXPECT_EQ(4321, a.Perform(std::make_tuple(4000, Short(300), Char(20), true)));
 }
@ -432,13 +447,13 @@ TEST(InvokeMethodTest, MethodWithCompatibleType) {
 // Tests using WithoutArgs with an action that takes no argument.
 TEST(WithoutArgsTest, NoArg) {
-  Action<int(int n)> a = WithoutArgs(Invoke(Nullary));  // NOLINT
+  Action<int(int n)> a = WithoutArgs(&Nullary);  // NOLINT
  EXPECT_EQ(1, a.Perform(std::make_tuple(2)));
 }
 // Tests using WithArg with an action that takes 1 argument.
 TEST(WithArgTest, OneArg) {
-  Action<bool(double x, int n)> b = WithArg<1>(Invoke(Unary));  // NOLINT
+  Action<bool(double x, int n)> b = WithArg<1>(&Unary);  // NOLINT
  EXPECT_TRUE(b.Perform(std::make_tuple(1.5, -1)));
  EXPECT_FALSE(b.Perform(std::make_tuple(1.5, 1)));
 }
@ -478,6 +493,34 @@ TEST(SaveArgActionTest, WorksForCompatibleType) {
  EXPECT_EQ('a', result);
 }
 struct MoveOnly {
  explicit MoveOnly(int v) : i(v) {}
  MoveOnly(MoveOnly&& o) {
    i = o.i;
    o.i = -1;
  }
  MoveOnly& operator=(MoveOnly&& o) {
    i = o.i;
    o.i = -1;
    return *this;
  }
  int i;
 };
 TEST(SaveArgByMoveActionTest, WorksForSameType) {
  MoveOnly result{0};
  const Action<void(MoveOnly v)> a1 = SaveArgByMove<0>(&result);
  a1.Perform(std::make_tuple(MoveOnly{5}));
  EXPECT_EQ(5, result.i);
 }
 TEST(SaveArgByMoveActionTest, WorksForCompatibleType) {
  MoveOnly result{0};
  const Action<void(bool, MoveOnly)> a1 = SaveArgByMove<1>(&result);
  a1.Perform(std::make_tuple(true, MoveOnly{7}));
  EXPECT_EQ(7, result.i);
 }
 TEST(SaveArgPointeeActionTest, WorksForSameType) {
  int result = 0;
  const int value = 5;
@ -571,13 +614,13 @@ TEST(ThrowActionTest, ThrowsGivenExceptionInNullaryFunction) {
 class Object {
 public:
-  virtual ~Object() {}
+  virtual ~Object() = default;
  virtual void Func() {}
 };
 class MockObject : public Object {
 public:
-  ~MockObject() override {}
+  ~MockObject() override = default;
  MOCK_METHOD(void, Func, (), (override));
 };
@ -673,7 +716,7 @@ TEST(SetArrayArgumentTest, SetsTheNthArrayWithIteratorArgument) {
  Action<MyFunction> a = SetArrayArgument<1>(letters.begin(), letters.end());
  std::string s;
-  a.Perform(std::make_tuple(true, back_inserter(s)));
+  a.Perform(std::make_tuple(true, std::back_inserter(s)));
  EXPECT_EQ(letters, s);
 }
@ -694,12 +737,24 @@ TEST(InvokeArgumentTest, Function0) {
  EXPECT_EQ(1, a.Perform(std::make_tuple(2, &Nullary)));
 }
-// Tests using InvokeArgument with a unary function.
+// Tests using InvokeArgument with a unary functor.
 TEST(InvokeArgumentTest, Functor1) {
  Action<int(UnaryFunctor)> a = InvokeArgument<0>(true);  // NOLINT
  EXPECT_EQ(1, a.Perform(std::make_tuple(UnaryFunctor())));
 }
 // Tests using InvokeArgument with a unary move-only functor.
 TEST(InvokeArgumentTest, Functor1MoveOnly) {
  Action<int(UnaryMoveOnlyFunctor)> a = InvokeArgument<0>(true);  // NOLINT
  EXPECT_EQ(1, a.Perform(std::make_tuple(UnaryMoveOnlyFunctor())));
 }
 // Tests using InvokeArgument with a one-shot unary functor.
 TEST(InvokeArgumentTest, OneShotFunctor1) {
  Action<int(OneShotUnaryFunctor)> a = InvokeArgument<0>(true);  // NOLINT
  EXPECT_EQ(1, a.Perform(std::make_tuple(OneShotUnaryFunctor())));
 }
 // Tests using InvokeArgument with a 5-ary function.
 TEST(InvokeArgumentTest, Function5) {
  Action<int(int (*)(int, int, int, int, int))> a =  // NOLINT
@ -802,6 +857,22 @@ TEST(InvokeArgumentTest, ByExplicitConstReferenceFunction) {
  EXPECT_FALSE(a.Perform(std::make_tuple(&ReferencesGlobalDouble)));
 }
 TEST(InvokeArgumentTest, MoveOnlyType) {
  struct Marker {};
  struct {
    // Method takes a unique_ptr (to a type we don't care about), and an
    // invocable type.
    MOCK_METHOD(bool, MockMethod,
                (std::unique_ptr<Marker>, std::function<int()>), ());
  } mock;
  ON_CALL(mock, MockMethod(_, _)).WillByDefault(InvokeArgument<1>());
  // This compiles, but is a little opaque as a workaround:
  ON_CALL(mock, MockMethod(_, _))
      .WillByDefault(WithArg<1>(InvokeArgument<0>()));
 }
 // Tests DoAll(a1, a2).
 TEST(DoAllTest, TwoActions) {
  int n = 0;
@ -955,9 +1026,8 @@ TEST(DoAllTest, NoArgs) {
 TEST(DoAllTest, MoveOnlyArgs) {
  bool ran_first = false;
-  Action<int(std::unique_ptr<int>)> a =
+  Action<int(std::unique_ptr<int>)> a = DoAll(
-      DoAll(InvokeWithoutArgs([&] { ran_first = true; }),
+      [&] { ran_first = true; }, [](std::unique_ptr<int> p) { return *p; });
            [](std::unique_ptr<int> p) { return *p; });
  EXPECT_EQ(7, a.Perform(std::make_tuple(std::unique_ptr<int>(new int(7)))));
  EXPECT_TRUE(ran_first);
 }
--- a/test/googletest/googlemock/test/gmock-nice-strict_test.cc
+++ b/test/googletest/googlemock/test/gmock-nice-strict_test.cc
@ -40,7 +40,7 @@
 // clash with ::testing::Mock.
 class Mock {
 public:
-  Mock() {}
+  Mock() = default;
  MOCK_METHOD0(DoThis, void());
@ -78,7 +78,7 @@ class CallsMockMethodInDestructor {
 class Foo {
 public:
-  virtual ~Foo() {}
+  virtual ~Foo() = default;
  virtual void DoThis() = 0;
  virtual int DoThat(bool flag) = 0;
@ -86,7 +86,7 @@ class Foo {
 class MockFoo : public Foo {
 public:
-  MockFoo() {}
+  MockFoo() = default;
  void Delete() { delete this; }
  MOCK_METHOD0(DoThis, void());
@ -109,7 +109,7 @@ class MockBar {
           (a10 ? 'T' : 'F');
  }
-  virtual ~MockBar() {}
+  virtual ~MockBar() = default;
  const std::string& str() const { return str_; }
--- a/test/googletest/googlemock/test/gmock-pp_test.cc
+++ b/test/googletest/googlemock/test/gmock-pp_test.cc
@ -11,8 +11,10 @@ namespace internal {
 namespace gmockpp {
 static_assert(GMOCK_PP_CAT(1, 4) == 14, "");
-static_assert(GMOCK_PP_INTERNAL_INTERNAL_16TH(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
+static_assert(GMOCK_PP_INTERNAL_INTERNAL_32ND(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
-                                              12, 13, 14, 15, 16, 17, 18) == 16,
+                                              12, 13, 14, 15, 16, 17, 18, 19,
                                              20, 21, 22, 23, 24, 25, 26, 27,
                                              28, 29, 30, 31, 32, 33, 34) == 32,
              "");
 static_assert(GMOCK_PP_NARG() == 1, "");
 static_assert(GMOCK_PP_NARG(x) == 1, "");
@ -70,7 +72,7 @@ static_assert(GMOCK_PP_INTERNAL_VAR_TEST(x, y) == 2, "");
 static_assert(GMOCK_PP_INTERNAL_VAR_TEST(silly) == 1, "");
 static_assert(GMOCK_PP_INTERNAL_VAR_TEST(x, y, z) == 3, "");
-// TODO(iserna): The following asserts fail in --config=lexan.
+// TODO(iserna): The following asserts fail in --config=windows.
 #define GMOCK_PP_INTERNAL_IS_EMPTY_TEST_1
 static_assert(GMOCK_PP_IS_EMPTY(GMOCK_PP_INTERNAL_IS_EMPTY_TEST_1), "");
 static_assert(GMOCK_PP_IS_EMPTY(), "");
--- a/test/googletest/googlemock/test/gmock-spec-builders_test.cc
+++ b/test/googletest/googlemock/test/gmock-spec-builders_test.cc
@ -98,7 +98,7 @@ class NonDefaultConstructible {
 class MockA {
 public:
-  MockA() {}
+  MockA() = default;
  MOCK_METHOD1(DoA, void(int n));
  MOCK_METHOD1(ReturnResult, Result(int n));
@ -113,7 +113,7 @@ class MockA {
 class MockB {
 public:
-  MockB() {}
+  MockB() = default;
  MOCK_CONST_METHOD0(DoB, int());  // NOLINT
  MOCK_METHOD1(DoB, int(int n));   // NOLINT
@ -125,7 +125,7 @@ class MockB {
 class ReferenceHoldingMock {
 public:
-  ReferenceHoldingMock() {}
+  ReferenceHoldingMock() = default;
  MOCK_METHOD1(AcceptReference, void(std::shared_ptr<MockA>*));
@ -143,12 +143,12 @@ class ReferenceHoldingMock {
 class CC {
 public:
-  virtual ~CC() {}
+  virtual ~CC() = default;
  virtual int Method() = 0;
 };
 class MockCC : public CC {
 public:
-  MockCC() {}
+  MockCC() = default;
  MOCK_METHOD0(Method, int());
@ -160,7 +160,7 @@ class MockCC : public CC {
 // Tests that a method with expanded name compiles.
 TEST(OnCallSyntaxTest, CompilesWithMethodNameExpandedFromMacro) {
  MockCC cc;
-  ON_CALL(cc, Method());
+  (void)ON_CALL(cc, Method());
 }
 // Tests that the method with expanded name not only compiles but runs
@ -193,7 +193,7 @@ TEST(OnCallSyntaxTest, EvaluatesFirstArgumentOnce) {
  MockA a;
  MockA* pa = &a;
-  ON_CALL(*pa++, DoA(_));
+  (void)ON_CALL(*pa++, DoA(_));
  EXPECT_EQ(&a + 1, pa);
 }
@ -201,7 +201,7 @@ TEST(OnCallSyntaxTest, EvaluatesSecondArgumentOnce) {
  MockA a;
  int n = 0;
-  ON_CALL(a, DoA(n++));
+  (void)ON_CALL(a, DoA(n++));
  EXPECT_EQ(1, n);
 }
@ -232,7 +232,7 @@ TEST(OnCallSyntaxTest, WillByDefaultIsMandatory) {
  EXPECT_DEATH_IF_SUPPORTED(
      {
-        ON_CALL(a, DoA(5));
+        (void)ON_CALL(a, DoA(5));
        a.DoA(5);
      },
      "");
@ -804,39 +804,39 @@ TEST(ExpectCallTest, InfersCardinality1WhenThereIsWillRepeatedly) {
      "to be called at least once");
 }
-#if defined(__cplusplus) && __cplusplus >= 201703L
+// TODO(b/396121064) - Fix this test under MSVC
-
+#ifndef _MSC_VER
 // It should be possible to return a non-moveable type from a mock action in
 // C++17 and above, where it's guaranteed that such a type can be initialized
 // from a prvalue returned from a function.
 TEST(ExpectCallTest, NonMoveableType) {
  // Define a non-moveable result type.
-  struct Result {
+  struct NonMoveableStruct {
-    explicit Result(int x_in) : x(x_in) {}
+    explicit NonMoveableStruct(int x_in) : x(x_in) {}
-    Result(Result&&) = delete;
+    NonMoveableStruct(NonMoveableStruct&&) = delete;
    int x;
  };
-  static_assert(!std::is_move_constructible_v<Result>);
+  static_assert(!std::is_move_constructible_v<NonMoveableStruct>);
-  static_assert(!std::is_copy_constructible_v<Result>);
+  static_assert(!std::is_copy_constructible_v<NonMoveableStruct>);
-  static_assert(!std::is_move_assignable_v<Result>);
+  static_assert(!std::is_move_assignable_v<NonMoveableStruct>);
-  static_assert(!std::is_copy_assignable_v<Result>);
+  static_assert(!std::is_copy_assignable_v<NonMoveableStruct>);
  // We should be able to use a callable that returns that result as both a
  // OnceAction and an Action, whether the callable ignores arguments or not.
-  const auto return_17 = [] { return Result(17); };
+  const auto return_17 = [] { return NonMoveableStruct(17); };
-  static_cast<void>(OnceAction<Result()>{return_17});
+  static_cast<void>(OnceAction<NonMoveableStruct()>{return_17});
-  static_cast<void>(Action<Result()>{return_17});
+  static_cast<void>(Action<NonMoveableStruct()>{return_17});
-  static_cast<void>(OnceAction<Result(int)>{return_17});
+  static_cast<void>(OnceAction<NonMoveableStruct(int)>{return_17});
-  static_cast<void>(Action<Result(int)>{return_17});
+  static_cast<void>(Action<NonMoveableStruct(int)>{return_17});
  // It should be possible to return the result end to end through an
  // EXPECT_CALL statement, with both WillOnce and WillRepeatedly.
-  MockFunction<Result()> mock;
+  MockFunction<NonMoveableStruct()> mock;
  EXPECT_CALL(mock, Call)   //
      .WillOnce(return_17)  //
      .WillRepeatedly(return_17);
@ -846,7 +846,7 @@ TEST(ExpectCallTest, NonMoveableType) {
  EXPECT_EQ(17, mock.AsStdFunction()().x);
 }
-#endif  // C++17 and above
+#endif  // _MSC_VER
 // Tests that the n-th action is taken for the n-th matching
 // invocation.
@ -905,7 +905,7 @@ TEST(ExpectCallTest, TakesDefaultActionWhenWillListIsExhausted) {
                        " - returning default value."));
 }
-TEST(FunctionMockerMessageTest, ReportsExpectCallLocationForExhausedActions) {
+TEST(FunctionMockerMessageTest, ReportsExpectCallLocationForExhaustedActions) {
  MockB b;
  std::string expect_call_location = FormatFileLocation(__FILE__, __LINE__ + 1);
  EXPECT_CALL(b, DoB()).Times(AnyNumber()).WillOnce(Return(1));
@ -1088,7 +1088,7 @@ TEST(UnexpectedCallTest, UnsatisfiedPrerequisites) {
  // Verifies that the failure message contains the two unsatisfied
  // pre-requisites but not the satisfied one.
-#if GTEST_USES_POSIX_RE
+#ifdef GTEST_USES_POSIX_RE
  EXPECT_THAT(r.message(),
              ContainsRegex(
                  // POSIX RE doesn't understand the (?s) prefix, but has no
@ -1881,7 +1881,7 @@ struct Unprintable {
 class MockC {
 public:
-  MockC() {}
+  MockC() = default;
  MOCK_METHOD6(VoidMethod, void(bool cond, int n, std::string s, void* p,
                                const Printable& x, Unprintable y));
@ -2045,7 +2045,7 @@ class GMockVerboseFlagTest : public VerboseFlagPreservingFixture {
    NaggyMock<MockA> a;
    const std::string note =
        "NOTE: You can safely ignore the above warning unless this "
-        "call should not happen.  Do not suppress it by blindly adding "
+        "call should not happen.  Do not suppress it by adding "
        "an EXPECT_CALL() if you don't mean to enforce the call.  "
        "See "
        "https://github.com/google/googletest/blob/main/docs/"
@ -2121,7 +2121,7 @@ void PrintTo(PrintMeNot /* dummy */, ::std::ostream* /* os */) {
 class LogTestHelper {
 public:
-  LogTestHelper() {}
+  LogTestHelper() = default;
  MOCK_METHOD1(Foo, PrintMeNot(PrintMeNot));
--- a/test/googletest/googlemock/test/gmock_ex_test.cc
+++ b/test/googletest/googlemock/test/gmock_ex_test.cc
@ -29,6 +29,8 @@
 // Tests Google Mock's functionality that depends on exceptions.
 #include <exception>
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
--- a/test/googletest/googlemock/test/gmock_leak_test_.cc
+++ b/test/googletest/googlemock/test/gmock_leak_test_.cc
@ -40,13 +40,13 @@ using ::testing::Return;
 class FooInterface {
 public:
-  virtual ~FooInterface() {}
+  virtual ~FooInterface() = default;
  virtual void DoThis() = 0;
 };
 class MockFoo : public FooInterface {
 public:
-  MockFoo() {}
+  MockFoo() = default;
  MOCK_METHOD0(DoThis, void());
--- a/test/googletest/googlemock/test/gmock_link_test.h
+++ b/test/googletest/googlemock/test/gmock_link_test.h
@ -116,7 +116,7 @@
 #include "gmock/gmock.h"
-#if !GTEST_OS_WINDOWS_MOBILE
+#ifndef GTEST_OS_WINDOWS_MOBILE
 #include <errno.h>
 #endif
@ -181,11 +181,12 @@ using testing::WithArg;
 using testing::WithArgs;
 using testing::WithoutArgs;
-#if !GTEST_OS_WINDOWS_MOBILE
+#ifndef GTEST_OS_WINDOWS_MOBILE
 using testing::SetErrnoAndReturn;
 #endif
 #if GTEST_HAS_EXCEPTIONS
 using testing::Rethrow;
 using testing::Throw;
 #endif
@ -194,7 +195,7 @@ using testing::MatchesRegex;
 class Interface {
 public:
-  virtual ~Interface() {}
+  virtual ~Interface() = default;
  virtual void VoidFromString(char* str) = 0;
  virtual char* StringFromString(char* str) = 0;
  virtual int IntFromString(char* str) = 0;
@ -208,7 +209,7 @@ class Interface {
 class Mock : public Interface {
 public:
-  Mock() {}
+  Mock() = default;
  MOCK_METHOD1(VoidFromString, void(char* str));
  MOCK_METHOD1(StringFromString, char*(char* str));
@ -306,7 +307,7 @@ TEST(LinkTest, TestSetArrayArgument) {
  mock.VoidFromString(&ch);
 }
-#if !GTEST_OS_WINDOWS_MOBILE
+#ifndef GTEST_OS_WINDOWS_MOBILE
 // Tests the linkage of the SetErrnoAndReturn action.
 TEST(LinkTest, TestSetErrnoAndReturn) {
@ -326,7 +327,7 @@ TEST(LinkTest, TestInvoke) {
  InvokeHelper test_invoke_helper;
  EXPECT_CALL(mock, VoidFromString(_))
-      .WillOnce(Invoke(&InvokeHelper::StaticVoidFromString))
+      .WillOnce(&InvokeHelper::StaticVoidFromString)
      .WillOnce(Invoke(&test_invoke_helper, &InvokeHelper::VoidFromString));
  mock.VoidFromString(nullptr);
  mock.VoidFromString(nullptr);
@ -337,10 +338,12 @@ TEST(LinkTest, TestInvokeWithoutArgs) {
  Mock mock;
  InvokeHelper test_invoke_helper;
  GTEST_DISABLE_DEPRECATED_PUSH_()
  EXPECT_CALL(mock, VoidFromString(_))
-      .WillOnce(InvokeWithoutArgs(&InvokeHelper::StaticVoidFromVoid))
+      .WillOnce(&InvokeHelper::StaticVoidFromVoid)
      .WillOnce(
          InvokeWithoutArgs(&test_invoke_helper, &InvokeHelper::VoidFromVoid));
  GTEST_DISABLE_DEPRECATED_POP_()
  mock.VoidFromString(nullptr);
  mock.VoidFromString(nullptr);
 }
@ -359,7 +362,7 @@ TEST(LinkTest, TestWithArg) {
  Mock mock;
  EXPECT_CALL(mock, VoidFromString(_))
-      .WillOnce(WithArg<0>(Invoke(&InvokeHelper::StaticVoidFromString)));
+      .WillOnce(WithArg<0>(&InvokeHelper::StaticVoidFromString));
  mock.VoidFromString(nullptr);
 }
@ -368,7 +371,7 @@ TEST(LinkTest, TestWithArgs) {
  Mock mock;
  EXPECT_CALL(mock, VoidFromString(_))
-      .WillOnce(WithArgs<0>(Invoke(&InvokeHelper::StaticVoidFromString)));
+      .WillOnce(WithArgs<0>(&InvokeHelper::StaticVoidFromString));
  mock.VoidFromString(nullptr);
 }
@ -416,6 +419,14 @@ TEST(LinkTest, TestThrow) {
  EXPECT_CALL(mock, VoidFromString(_)).WillOnce(Throw(42));
  EXPECT_THROW(mock.VoidFromString(nullptr), int);
 }
 // Tests the linkage of the Rethrow action.
 TEST(LinkTest, TestRethrow) {
  Mock mock;
  EXPECT_CALL(mock, VoidFromString(_))
      .WillOnce(Rethrow(std::make_exception_ptr(42)));
  EXPECT_THROW(mock.VoidFromString(nullptr), int);
 }
 #endif  // GTEST_HAS_EXCEPTIONS
 // The ACTION*() macros trigger warning C4100 (unreferenced formal
--- a/test/googletest/googlemock/test/gmock_output_test_.cc
+++ b/test/googletest/googlemock/test/gmock_output_test_.cc
@ -33,7 +33,6 @@
 #include <stdio.h>
 #include <string>
 #include <tuple>
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
@ -53,7 +52,7 @@ using testing::Value;
 class MockFoo {
 public:
-  MockFoo() {}
+  MockFoo() = default;
  MOCK_METHOD3(Bar, char(const std::string& s, int i, double x));
  MOCK_METHOD2(Bar2, bool(int x, int y));
@ -255,16 +254,12 @@ TEST_F(GMockOutputTest, CatchesLeakedMocks) {
 }
 MATCHER_P2(IsPair, first, second, "") {
-  return Value(std::get<0>(arg), first) && Value(std::get<1>(arg), second);
+  return Value(arg.first, first) && Value(arg.second, second);
 }
 TEST_F(GMockOutputTest, PrintsMatcher) {
  const testing::Matcher<int> m1 = Ge(48);
-  // Explicitly using std::tuple instead of std::pair due to differences between
+  EXPECT_THAT((std::pair<int, bool>(42, true)), IsPair(m1, true));
  // MSVC and other compilers. std::pair is printed as
  // "struct std::pair<int,bool>" when using MSVC vs "std::pair<int,bool>" with
  // other compilers.
  EXPECT_THAT((std::tuple<int, bool>(42, true)), IsPair(m1, true));
 }
 void TestCatchesLeakedMocksInAdHocTests() {
--- a/test/googletest/googlemock/test/gmock_output_test_golden.txt
+++ b/test/googletest/googlemock/test/gmock_output_test_golden.txt
@ -40,6 +40,7 @@ FILE:#: EXPECT_CALL(foo_, Bar2(0, _))...
           Actual: 1
         Expected: to be called once
           Actual: never called - unsatisfied and active
 [  FAILED  ] GMockOutputTest.UnexpectedCall
 [ RUN      ] GMockOutputTest.UnexpectedCallToVoidFunction
 unknown file: Failure
@ -53,6 +54,7 @@ FILE:#: EXPECT_CALL(foo_, Bar3(0, _))...
           Actual: 1
         Expected: to be called once
           Actual: never called - unsatisfied and active
 [  FAILED  ] GMockOutputTest.UnexpectedCallToVoidFunction
 [ RUN      ] GMockOutputTest.ExcessiveCall
 FILE:#: Failure
@ -61,6 +63,7 @@ Mock function called more times than expected - returning default value.
          Returns: false
         Expected: to be called once
           Actual: called twice - over-saturated and active
 [  FAILED  ] GMockOutputTest.ExcessiveCall
 [ RUN      ] GMockOutputTest.ExcessiveCallToVoidFunction
 FILE:#: Failure
@ -68,6 +71,7 @@ Mock function called more times than expected - returning directly.
    Function call: Bar3(0, 1)
         Expected: to be called once
           Actual: called twice - over-saturated and active
 [  FAILED  ] GMockOutputTest.ExcessiveCallToVoidFunction
 [ RUN      ] GMockOutputTest.UninterestingCall
@ -75,14 +79,14 @@ GMOCK WARNING:
 Uninteresting mock function call - returning default value.
    Function call: Bar2(0, 1)
          Returns: false
-NOTE: You can safely ignore the above warning unless this call should not happen.  Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect-useoncall for details.
+NOTE: You can safely ignore the above warning unless this call should not happen.  Do not suppress it by adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect-useoncall for details.
 [       OK ] GMockOutputTest.UninterestingCall
 [ RUN      ] GMockOutputTest.UninterestingCallToVoidFunction
 GMOCK WARNING:
 Uninteresting mock function call - returning directly.
    Function call: Bar3(0, 1)
-NOTE: You can safely ignore the above warning unless this call should not happen.  Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect-useoncall for details.
+NOTE: You can safely ignore the above warning unless this call should not happen.  Do not suppress it by adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect-useoncall for details.
 [       OK ] GMockOutputTest.UninterestingCallToVoidFunction
 [ RUN      ] GMockOutputTest.RetiredExpectation
 unknown file: Failure
@ -104,6 +108,7 @@ FILE:#: tried expectation #1: EXPECT_CALL(foo_, Bar2(0, 0))...
           Actual: 1
         Expected: to be called once
           Actual: never called - unsatisfied and active
 [  FAILED  ] GMockOutputTest.RetiredExpectation
 [ RUN      ] GMockOutputTest.UnsatisfiedPrerequisite
 unknown file: Failure
@ -125,6 +130,7 @@ FILE:#: pre-requisite #0
                   (end of pre-requisites)
         Expected: to be called once
           Actual: never called - unsatisfied and active
 [  FAILED  ] GMockOutputTest.UnsatisfiedPrerequisite
 [ RUN      ] GMockOutputTest.UnsatisfiedPrerequisites
 unknown file: Failure
@ -147,6 +153,7 @@ FILE:#: pre-requisite #1
                   (end of pre-requisites)
         Expected: to be called once
           Actual: never called - unsatisfied and active
 [  FAILED  ] GMockOutputTest.UnsatisfiedPrerequisites
 [ RUN      ] GMockOutputTest.UnsatisfiedWith
 FILE:#: Failure
@ -154,16 +161,19 @@ Actual function call count doesn't match EXPECT_CALL(foo_, Bar2(_, _))...
    Expected args: are a pair where the first >= the second
         Expected: to be called once
           Actual: never called - unsatisfied and active
 [  FAILED  ] GMockOutputTest.UnsatisfiedWith
 [ RUN      ] GMockOutputTest.UnsatisfiedExpectation
 FILE:#: Failure
 Actual function call count doesn't match EXPECT_CALL(foo_, Bar2(0, _))...
         Expected: to be called twice
           Actual: called once - unsatisfied and active
 FILE:#: Failure
 Actual function call count doesn't match EXPECT_CALL(foo_, Bar(_, _, _))...
         Expected: to be called once
           Actual: never called - unsatisfied and active
 [  FAILED  ] GMockOutputTest.UnsatisfiedExpectation
 [ RUN      ] GMockOutputTest.MismatchArguments
 unknown file: Failure
@ -180,6 +190,7 @@ FILE:#: EXPECT_CALL(foo_, Bar(Ref(s), _, Ge(0)))...
           Actual: -0.1
         Expected: to be called once
           Actual: never called - unsatisfied and active
 [  FAILED  ] GMockOutputTest.MismatchArguments
 [ RUN      ] GMockOutputTest.MismatchWith
 unknown file: Failure
@ -194,6 +205,7 @@ FILE:#: EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))...
           Actual: don't match
         Expected: to be called once
           Actual: never called - unsatisfied and active
 [  FAILED  ] GMockOutputTest.MismatchWith
 [ RUN      ] GMockOutputTest.MismatchArgumentsAndWith
 unknown file: Failure
@ -210,6 +222,7 @@ FILE:#: EXPECT_CALL(foo_, Bar2(Ge(2), Ge(1)))...
           Actual: don't match
         Expected: to be called once
           Actual: never called - unsatisfied and active
 [  FAILED  ] GMockOutputTest.MismatchArgumentsAndWith
 [ RUN      ] GMockOutputTest.UnexpectedCallWithDefaultAction
 unknown file: Failure
@ -227,6 +240,7 @@ FILE:#: EXPECT_CALL(foo_, Bar2(2, 2))...
           Actual: 0
         Expected: to be called once
           Actual: never called - unsatisfied and active
 unknown file: Failure
 Unexpected mock function call - taking default action specified at:
@ -242,6 +256,7 @@ FILE:#: EXPECT_CALL(foo_, Bar2(2, 2))...
           Actual: 0
         Expected: to be called once
           Actual: never called - unsatisfied and active
 [  FAILED  ] GMockOutputTest.UnexpectedCallWithDefaultAction
 [ RUN      ] GMockOutputTest.ExcessiveCallWithDefaultAction
 FILE:#: Failure
@ -251,6 +266,7 @@ FILE:#:
          Returns: true
         Expected: to be called once
           Actual: called twice - over-saturated and active
 FILE:#: Failure
 Mock function called more times than expected - taking default action specified at:
 FILE:#:
@ -258,6 +274,7 @@ FILE:#:
          Returns: false
         Expected: to be called once
           Actual: called twice - over-saturated and active
 [  FAILED  ] GMockOutputTest.ExcessiveCallWithDefaultAction
 [ RUN      ] GMockOutputTest.UninterestingCallWithDefaultAction
@ -266,14 +283,14 @@ Uninteresting mock function call - taking default action specified at:
 FILE:#:
    Function call: Bar2(2, 2)
          Returns: true
-NOTE: You can safely ignore the above warning unless this call should not happen.  Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect-useoncall for details.
+NOTE: You can safely ignore the above warning unless this call should not happen.  Do not suppress it by adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect-useoncall for details.
 GMOCK WARNING:
 Uninteresting mock function call - taking default action specified at:
 FILE:#:
    Function call: Bar2(1, 1)
          Returns: false
-NOTE: You can safely ignore the above warning unless this call should not happen.  Do not suppress it by blindly adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect-useoncall for details.
+NOTE: You can safely ignore the above warning unless this call should not happen.  Do not suppress it by adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect-useoncall for details.
 [       OK ] GMockOutputTest.UninterestingCallWithDefaultAction
 [ RUN      ] GMockOutputTest.ExplicitActionsRunOutWithDefaultAction
@ -290,9 +307,10 @@ Stack trace:
 [       OK ] GMockOutputTest.CatchesLeakedMocks
 [ RUN      ] GMockOutputTest.PrintsMatcher
 FILE:#: Failure
-Value of: (std::tuple<int, bool>(42, true))
+Value of: (std::pair<int, bool>(42, true))
 Expected: is pair (first: is >= 48, second: true)
-  Actual: (42, true)
+  Actual: (42, true) (of type std::pair<int,bool>)
 [  FAILED  ] GMockOutputTest.PrintsMatcher
 [  FAILED  ] GMockOutputTest.UnexpectedCall
 [  FAILED  ] GMockOutputTest.UnexpectedCallToVoidFunction
--- a/test/googletest/googlemock/test/gmock_stress_test.cc
+++ b/test/googletest/googlemock/test/gmock_stress_test.cc
@ -30,6 +30,8 @@
 // Tests that Google Mock constructs can be used in a large number of
 // threads concurrently.
 #include <iterator>
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
@ -188,7 +190,7 @@ TEST(StressTest, CanUseGMockWithThreads) {
      &TestPartiallyOrderedExpectationsWithThreads,
  };
-  const int kRoutines = sizeof(test_routines) / sizeof(test_routines[0]);
+  const int kRoutines = std::size(test_routines);
  const int kCopiesOfEachRoutine = kMaxTestThreads / kRoutines;
  const int kTestThreads = kCopiesOfEachRoutine * kRoutines;
  ThreadWithParam<Dummy>* threads[kTestThreads] = {};
--- a/test/googletest/googlemock/test/gmock_test.cc
+++ b/test/googletest/googlemock/test/gmock_test.cc
@ -174,6 +174,6 @@ TEST(WideInitGoogleMockTest, ParsesGoogleMockFlagAndUnrecognizedFlag) {
 // Makes sure Google Mock flags can be accessed in code.
 TEST(FlagTest, IsAccessibleInCode) {
  bool dummy =
-      GMOCK_FLAG_GET(catch_leaked_mocks) && GMOCK_FLAG_GET(verbose) == "";
+      GMOCK_FLAG_GET(catch_leaked_mocks) && GMOCK_FLAG_GET(verbose).empty();
  (void)dummy;  // Avoids the "unused local variable" warning.
 }
--- a/test/googletest/googletest/CMakeLists.txt
+++ b/test/googletest/googletest/CMakeLists.txt
@ -35,7 +35,7 @@ endif()
 ########################################################################
 #
-# Project-wide settings
+# Project-wide settings.
 # Name of the project.
 #
@ -44,21 +44,16 @@ endif()
 # ${gtest_BINARY_DIR}.
 # Language "C" is required for find_package(Threads).
-# Project version:
+# Project version.
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.13)
 cmake_policy(SET CMP0048 NEW)
 project(gtest VERSION ${GOOGLETEST_VERSION} LANGUAGES CXX C)
 if (POLICY CMP0063) # Visibility
  cmake_policy(SET CMP0063 NEW)
 endif (POLICY CMP0063)
 if (COMMAND set_up_hermetic_build)
  set_up_hermetic_build()
 endif()
-# These commands only run if this is the main project
+# These commands only run if this is the main project.
 if(CMAKE_PROJECT_NAME STREQUAL "gtest" OR CMAKE_PROJECT_NAME STREQUAL "googletest-distribution")
  # BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to
@ -88,7 +83,7 @@ include(cmake/internal_utils.cmake)
 config_compiler_and_linker()  # Defined in internal_utils.cmake.
 # Needed to set the namespace for both the export targets and the
-# alias libraries
+# alias libraries.
 set(cmake_package_name GTest CACHE INTERNAL "")
 # Create the CMake package file descriptors.
@ -100,12 +95,14 @@ if (INSTALL_GTEST)
  set(version_file "${generated_dir}/${cmake_package_name}ConfigVersion.cmake")
  write_basic_package_version_file(${version_file} VERSION ${GOOGLETEST_VERSION} COMPATIBILITY AnyNewerVersion)
  install(EXPORT ${targets_export_name}
    COMPONENT "${PROJECT_NAME}"
    NAMESPACE ${cmake_package_name}::
    DESTINATION ${cmake_files_install_dir})
  set(config_file "${generated_dir}/${cmake_package_name}Config.cmake")
  configure_package_config_file("${gtest_SOURCE_DIR}/cmake/Config.cmake.in"
    "${config_file}" INSTALL_DESTINATION ${cmake_files_install_dir})
  install(FILES ${version_file} ${config_file}
    COMPONENT "${PROJECT_NAME}"
    DESTINATION ${cmake_files_install_dir})
 endif()
@ -135,34 +132,26 @@ if(GTEST_HAS_ABSL)
    absl::flags_reflection
    absl::flags_usage
    absl::strings
    absl::any
    absl::optional
    absl::variant
    re2::re2
  )
 endif()
 cxx_library(gtest_main "${cxx_strict}" src/gtest_main.cc)
 set_target_properties(gtest_main PROPERTIES VERSION ${GOOGLETEST_VERSION})
 # 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 ";" "$<SEMICOLON>" dirs "${gtest_build_include_dirs}")
 target_include_directories(gtest SYSTEM INTERFACE
  "$<BUILD_INTERFACE:${dirs}>"
-    "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>")
+  "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
 target_include_directories(gtest_main SYSTEM INTERFACE
  "$<BUILD_INTERFACE:${dirs}>"
-    "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>")
+  "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
-endif()
+if(CMAKE_SYSTEM_NAME MATCHES "QNX" AND CMAKE_SYSTEM_VERSION VERSION_GREATER_EQUAL 7.1)
 if(CMAKE_SYSTEM_NAME MATCHES "QNX")
  target_link_libraries(gtest PUBLIC regex)
 endif()
 target_link_libraries(gtest_main PUBLIC gtest)
 ########################################################################
 #
-# Install rules
+# Install rules.
 install_project(gtest gtest_main)
 ########################################################################
--- a/test/googletest/googletest/README.md
+++ b/test/googletest/googletest/README.md
@ -12,7 +12,7 @@ GoogleTest comes with a CMake build script
 ([CMakeLists.txt](https://github.com/google/googletest/blob/main/CMakeLists.txt))
 that can be used on a wide range of platforms ("C" stands for cross-platform.).
 If you don't have CMake installed already, you can download it for free from
-<http://www.cmake.org/>.
+<https://cmake.org/>.
 CMake works by generating native makefiles or build projects that can be used in
 the compiler environment of your choice. You can either build GoogleTest as a
@ -25,7 +25,7 @@ When building GoogleTest as a standalone project, the typical workflow starts
 with
 ```
-git clone https://github.com/google/googletest.git -b v1.13.0
+git clone https://github.com/google/googletest.git -b v1.18.0
 cd googletest        # Main directory of the cloned repository.
 mkdir build          # Create a directory to hold the build output.
 cd build
@ -124,12 +124,12 @@ match the project in which it is included.
 #### C++ Standard Version
-An environment that supports C++11 is required in order to successfully build
+An environment that supports C++17 is required in order to successfully build
 GoogleTest. One way to ensure this is to specify the standard in the top-level
-project, for example by using the `set(CMAKE_CXX_STANDARD 11)` command. If this
+project, for example by using the `set(CMAKE_CXX_STANDARD 17)` command along
-is not feasible, for example in a C project using GoogleTest for validation,
+with `set(CMAKE_CXX_STANDARD_REQUIRED ON)`. If this is not feasible, for example
-then it can be specified by adding it to the options for cmake via the
+in a C project using GoogleTest for validation, then it can be specified by
-`DCMAKE_CXX_FLAGS` option.
+adding it to the options for cmake via the`-DCMAKE_CXX_FLAGS` option.
 ### Tweaking GoogleTest
@ -145,9 +145,9 @@ We list the most frequently used macros below. For a complete list, see file
 ### Multi-threaded Tests
 GoogleTest is thread-safe where the pthread library is available. After
-`#include "gtest/gtest.h"`, you can check the
+`#include <gtest/gtest.h>`, you can check the `GTEST_IS_THREADSAFE` macro to see
-`GTEST_IS_THREADSAFE` macro to see whether this is the case (yes if the macro is
+whether this is the case (yes if the macro is `#defined` to 1, no if it's
-`#defined` to 1, no if it's undefined.).
+undefined.).
 If GoogleTest doesn't correctly detect whether pthread is available in your
 environment, you can force it with
--- a/test/googletest/googletest/cmake/Config.cmake.in
+++ b/test/googletest/googletest/cmake/Config.cmake.in
@ -4,6 +4,10 @@ if (@GTEST_HAS_PTHREAD@)
  set(THREADS_PREFER_PTHREAD_FLAG @THREADS_PREFER_PTHREAD_FLAG@)
  find_dependency(Threads)
 endif()
 if (@GTEST_HAS_ABSL@)
  find_dependency(absl)
  find_dependency(re2)
 endif()
 include("${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake")
 check_required_components("@project_name@")
--- a/test/googletest/googletest/cmake/internal_utils.cmake
+++ b/test/googletest/googletest/cmake/internal_utils.cmake
@ -12,10 +12,6 @@
 #   Test and Google Mock's option() definitions, and thus must be
 #   called *after* the options have been defined.
 if (POLICY CMP0054)
  cmake_policy(SET CMP0054 NEW)
 endif (POLICY CMP0054)
 # Tweaks CMake's default compiler/linker settings to suit Google Test's needs.
 #
 # This must be a macro(), as inside a function string() can only
@ -32,28 +28,19 @@ macro(fix_default_compiler_settings_)
             CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
             CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
      if (NOT BUILD_SHARED_LIBS AND NOT gtest_force_shared_crt)
        # When Google Test is built as a shared library, it should also use
        # shared runtime libraries.  Otherwise, it may end up with multiple
        # copies of runtime library data in different modules, resulting in
        # hard-to-find crashes. When it is built as a static library, it is
        # preferable to use CRT as static libraries, as we don't have to rely
        # on CRT DLLs being available. CMake always defaults to using shared
        # CRT libraries, so we override that default here.
        string(REPLACE "/MD" "-MT" ${flag_var} "${${flag_var}}")
        # When using Ninja with Clang, static builds pass -D_DLL on Windows.
        # This is incorrect and should not happen, so we fix that here.
-        string(REPLACE "-D_DLL" "" ${flag_var} "${${flag_var}}")
+        string(REGEX REPLACE "([/-])D_DLL" "" ${flag_var} "${${flag_var}}")
      endif()
      # We prefer more strict warning checking for building Google Test.
      # Replaces /W3 with /W4 in defaults.
-      string(REPLACE "/W3" "/W4" ${flag_var} "${${flag_var}}")
+      string(REGEX REPLACE "([/-])W3" "\\1W4" ${flag_var} "${${flag_var}}")
      # Prevent D9025 warning for targets that have exception handling
      # turned off (/EHs-c- flag). Where required, exceptions are explicitly
      # re-enabled using the cxx_exception_flags variable.
-      string(REPLACE "/EHsc" "" ${flag_var} "${${flag_var}}")
+      string(REGEX REPLACE "([/-])EHsc" "" ${flag_var} "${${flag_var}}")
    endforeach()
  endif()
 endmacro()
@ -63,10 +50,11 @@ endmacro()
 # variable's value is empty before it's explicitly assigned to.
 macro(config_compiler_and_linker)
  # Note: pthreads on MinGW is not supported, even if available
-  # instead, we use windows threading primitives
+  # instead, we use windows threading primitives.
  unset(GTEST_HAS_PTHREAD)
  if (NOT gtest_disable_pthreads AND NOT MINGW)
    # Defines CMAKE_USE_PTHREADS_INIT and CMAKE_THREAD_LIBS_INIT.
    set(THREADS_PREFER_PTHREAD_FLAG TRUE)
    find_package(Threads)
    if (CMAKE_USE_PTHREADS_INIT)
      set(GTEST_HAS_PTHREAD ON)
@ -74,30 +62,58 @@ macro(config_compiler_and_linker)
  endif()
  fix_default_compiler_settings_()
  set(cxx_strict_flags "")
  if (MSVC)
    # When Google Test is built as a shared library, it should also use shared
    # runtime libraries. Otherwise, it may end up with multiple copies of
    # runtime library data in different modules, resulting in hard-to-find
    # crashes. When it is built as a static library, it is preferable to use CRT
    # as static libraries, as we don't have to rely on CRT DLLs being available.
    # CMake always defaults to using shared CRT libraries, so we override that
    # default here.
    if (NOT BUILD_SHARED_LIBS AND NOT gtest_force_shared_crt AND NOT DEFINED CMAKE_MSVC_RUNTIME_LIBRARY
        AND CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
      set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
    endif()
    # Newlines inside flags variables break CMake's NMake generator.
    # TODO(vladl@google.com): Add -RTCs and -RTCu to debug builds.
-    set(cxx_base_flags "-GS -W4 -WX -wd4251 -wd4275 -nologo -J")
+    set(cxx_base_flags "-GS -W4 -wd4251 -wd4275 -nologo -J")
    set(cxx_base_flags "${cxx_base_flags} -D_UNICODE -DUNICODE -DWIN32 -D_WIN32")
    set(cxx_base_flags "${cxx_base_flags} -DSTRICT -DWIN32_LEAN_AND_MEAN")
    set(cxx_exception_flags "-EHsc -D_HAS_EXCEPTIONS=1")
    set(cxx_no_exception_flags "-EHs-c- -D_HAS_EXCEPTIONS=0")
    set(cxx_no_rtti_flags "-GR-")
-    # Suppress "unreachable code" warning
+    # Suppress "unreachable code" warning,
-    # http://stackoverflow.com/questions/3232669 explains the issue.
+    # https://stackoverflow.com/questions/3232669 explains the issue.
    set(cxx_base_flags "${cxx_base_flags} -wd4702")
    # Ensure MSVC treats source files as UTF-8 encoded.
    if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
      set(cxx_base_flags "${cxx_base_flags} -utf-8")
    endif()
-  elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    if (CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM")
-    set(cxx_base_flags "-Wall -Wshadow -Wconversion")
+      set(cxx_base_flags "${cxx_base_flags} /fp:precise -Wno-inconsistent-missing-override -Wno-microsoft-exception-spec -Wno-unused-function -Wno-unused-but-set-variable")
    endif()
  elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR
      CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM")
    set(cxx_base_flags "-Wall -Wshadow -Wconversion -Wundef")
    set(cxx_exception_flags "-fexceptions")
    set(cxx_no_exception_flags "-fno-exceptions")
-    set(cxx_strict_flags "-W -Wpointer-arith -Wreturn-type -Wcast-qual -Wwrite-strings -Wswitch -Wunused-parameter -Wcast-align -Wchar-subscripts -Winline -Wredundant-decls")
+    set(cxx_strict_flags "-W -Wpointer-arith -Wreturn-type -Wcast-qual -Wwrite-strings -Wswitch -Wunused-parameter -Wcast-align -Winline -Wredundant-decls")
    set(cxx_no_rtti_flags "-fno-rtti")
    if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
      set(cxx_strict_flags "${cxx_strict_flags} -Wchar-subscripts")
    endif()
    if (CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM")
      set(cxx_base_flags "${cxx_base_flags} -ffp-model=precise")
      if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 2025.2.0)
        set(cxx_base_flags "${cxx_base_flags} -Wno-implicit-float-size-conversion")
      else()
        set(cxx_base_flags "${cxx_base_flags} -Wno-sycl-implicit-float-size-conversion")
      endif()
    endif()
  elseif (CMAKE_COMPILER_IS_GNUCXX)
-    set(cxx_base_flags "-Wall -Wshadow")
+    set(cxx_base_flags "-Wall -Wshadow -Wundef")
    if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0.0)
      set(cxx_base_flags "${cxx_base_flags} -Wno-error=dangling-else")
    endif()
@ -161,7 +177,7 @@ function(cxx_library_with_type name type cxx_flags)
  set_target_properties(${name}
    PROPERTIES
    COMPILE_FLAGS "${cxx_flags}")
-  # Set the output directory for build artifacts
+  # Set the output directory for build artifacts.
  set_target_properties(${name}
    PROPERTIES
    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin"
@ -169,7 +185,7 @@ function(cxx_library_with_type name type cxx_flags)
    ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib"
    PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin"
    COMPILE_PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")
-  # make PDBs match library name
+  # Make PDBs match library name.
  get_target_property(pdb_debug_postfix ${name} DEBUG_POSTFIX)
  set_target_properties(${name}
    PROPERTIES
@ -179,26 +195,25 @@ function(cxx_library_with_type name type cxx_flags)
    COMPILE_PDB_NAME_DEBUG "${name}${pdb_debug_postfix}")
  if (BUILD_SHARED_LIBS OR type STREQUAL "SHARED")
-    set_target_properties(${name}
+    target_compile_definitions(${name} PRIVATE
-      PROPERTIES
+      "GTEST_CREATE_SHARED_LIBRARY=1")
      COMPILE_DEFINITIONS "GTEST_CREATE_SHARED_LIBRARY=1")
    if (NOT "${CMAKE_VERSION}" VERSION_LESS "2.8.11")
    target_compile_definitions(${name} INTERFACE
-        $<INSTALL_INTERFACE:GTEST_LINKED_AS_SHARED_LIBRARY=1>)
+      $<BUILD_INTERFACE:GTEST_LINKED_AS_SHARED_LIBRARY=1>
      $<INSTALL_INTERFACE:GTEST_LINKED_AS_SHARED_LIBRARY=1>
    )
    if(APPLE)
      set_target_properties(${name} PROPERTIES
        INSTALL_RPATH "@loader_path")
    elseif(UNIX)
      set_target_properties(${name} PROPERTIES
        INSTALL_RPATH "$ORIGIN")
    endif()
  endif()
  if (DEFINED GTEST_HAS_PTHREAD)
-    if ("${CMAKE_VERSION}" VERSION_LESS "3.1.0")
+    target_link_libraries(${name} PUBLIC Threads::Threads)
      set(threads_spec ${CMAKE_THREAD_LIBS_INIT})
    else()
      set(threads_spec Threads::Threads)
    endif()
    target_link_libraries(${name} PUBLIC ${threads_spec})
  endif()
-  if (NOT "${CMAKE_VERSION}" VERSION_LESS "3.8")
+  target_compile_features(${name} PUBLIC cxx_std_17)
    target_compile_features(${name} PUBLIC cxx_std_14)
  endif()
 endfunction()
 ########################################################################
@ -215,7 +230,7 @@ endfunction()
 # cxx_executable_with_flags(name cxx_flags libs srcs...)
 #
-# creates a named C++ executable that depends on the given libraries and
+# Creates a named C++ executable that depends on the given libraries and
 # is built from the given source files with the given compiler flags.
 function(cxx_executable_with_flags name cxx_flags libs)
  add_executable(${name} ${ARGN})
@ -229,9 +244,8 @@ function(cxx_executable_with_flags name cxx_flags libs)
      COMPILE_FLAGS "${cxx_flags}")
  endif()
  if (BUILD_SHARED_LIBS)
-    set_target_properties(${name}
+    target_compile_definitions(${name} PRIVATE
-      PROPERTIES
+      "GTEST_LINKED_AS_SHARED_LIBRARY=1")
      COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
  endif()
  # To support mixing linking in static and dynamic libraries, link each
  # library in with an extra call to target_link_libraries.
@ -242,7 +256,7 @@ endfunction()
 # cxx_executable(name dir lib srcs...)
 #
-# creates a named target that depends on the given libs and is built
+# Creates a named target that depends on the given libs and is built
 # from the given source files. dir/name.cc is implicitly included in
 # the source file list.
 function(cxx_executable name dir libs)
@ -250,26 +264,18 @@ function(cxx_executable name dir libs)
    ${name} "${cxx_default}" "${libs}" "${dir}/${name}.cc" ${ARGN})
 endfunction()
-# CMP0094 policy enables finding a Python executable in the LOCATION order, as
+if(gtest_build_tests)
-# specified by the PATH environment variable.
+  # Only the interpreter is needed for Python tests. Specifying the component
-if (POLICY CMP0094)
+  # explicitly avoids a crash in CMake <= 3.23's FindPython3 module when no
-  cmake_policy(SET CMP0094 NEW)
+  # Python installation is present (the module calls list(GET) on an empty
-endif()
+  # list).  QUIET lets the build continue without Python tests instead of
-
+  # failing outright.
-# Sets PYTHONINTERP_FOUND and PYTHON_EXECUTABLE.
+  find_package(Python3 COMPONENTS Interpreter QUIET)
 if ("${CMAKE_VERSION}" VERSION_LESS "3.12.0")
  find_package(PythonInterp)
  set(PYTHONINTERP_FOUND ${PYTHONINTERP_FOUND} CACHE INTERNAL "")
  set(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE} CACHE INTERNAL "")
 else()
  find_package(Python COMPONENTS Interpreter)
  set(PYTHONINTERP_FOUND ${Python_Interpreter_FOUND} CACHE INTERNAL "")
  set(PYTHON_EXECUTABLE ${Python_EXECUTABLE} CACHE INTERNAL "")
 endif()
 # cxx_test_with_flags(name cxx_flags libs srcs...)
 #
-# creates a named C++ test that depends on the given libs and is built
+# Creates a named C++ test that depends on the given libs and is built
 # from the given source files with the given compiler flags.
 function(cxx_test_with_flags name cxx_flags libs)
  cxx_executable_with_flags(${name} "${cxx_flags}" "${libs}" ${ARGN})
@ -278,7 +284,7 @@ endfunction()
 # cxx_test(name libs srcs...)
 #
-# creates a named test target that depends on the given libs and is
+# Creates a named test target that depends on the given libs and is
 # built from the given source files. Unlike cxx_test_with_flags,
 # test/name.cc is already implicitly included in the source file list.
 function(cxx_test name libs)
@ -288,37 +294,25 @@ endfunction()
 # py_test(name)
 #
-# creates a Python test with the given name whose main module is in
+# Creates a Python test with the given name whose main module is in
 # test/name.py. It does nothing if Python is not installed.
 function(py_test name)
-  if (PYTHONINTERP_FOUND)
+  if (NOT Python3_Interpreter_FOUND)
-    if ("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" VERSION_GREATER 3.1)
+    return()
      if (CMAKE_CONFIGURATION_TYPES)
        # Multi-configuration build generators as for Visual Studio save
        # output in a subdirectory of CMAKE_CURRENT_BINARY_DIR (Debug,
        # Release etc.), so we have to provide it here.
        add_test(NAME ${name}
          COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py
              --build_dir=${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG> ${ARGN})
      else (CMAKE_CONFIGURATION_TYPES)
        # Single-configuration build generators like Makefile generators
        # don't have subdirs below CMAKE_CURRENT_BINARY_DIR.
        add_test(NAME ${name}
          COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py
            --build_dir=${CMAKE_CURRENT_BINARY_DIR} ${ARGN})
      endif (CMAKE_CONFIGURATION_TYPES)
    else()
      # ${CMAKE_CURRENT_BINARY_DIR} is known at configuration time, so we can
      # directly bind it from cmake. ${CTEST_CONFIGURATION_TYPE} is known
      # only at ctest runtime (by calling ctest -c <Configuration>), so
      # we have to escape $ to delay variable substitution here.
      add_test(NAME ${name}
        COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py
          --build_dir=${CMAKE_CURRENT_BINARY_DIR}/\${CTEST_CONFIGURATION_TYPE} ${ARGN})
  endif()
  get_cmake_property(is_multi "GENERATOR_IS_MULTI_CONFIG")
  set(build_dir "${CMAKE_CURRENT_BINARY_DIR}")
  if (is_multi)
    set(build_dir "${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>")
  endif()
  add_test(NAME ${name}
      COMMAND Python3::Interpreter ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py
          --build_dir=${build_dir} ${ARGN})
  # Make the Python import path consistent between Bazel and CMake.
  set_tests_properties(${name} PROPERTIES ENVIRONMENT PYTHONPATH=${CMAKE_SOURCE_DIR})
  endif(PYTHONINTERP_FOUND)
 endfunction()
 # install_project(targets...)
@ -327,22 +321,29 @@ endfunction()
 function(install_project)
  if(INSTALL_GTEST)
    install(DIRECTORY "${PROJECT_SOURCE_DIR}/include/"
      COMPONENT "${PROJECT_NAME}"
      DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
    # Install the project targets.
    install(TARGETS ${ARGN}
      EXPORT ${targets_export_name}
      COMPONENT "${PROJECT_NAME}"
      RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
      ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
      LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")
    if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-      # Install PDBs
+      # Install PDBs.
      foreach(t ${ARGN})
        get_target_property(t_pdb_name ${t} COMPILE_PDB_NAME)
        get_target_property(t_pdb_name_debug ${t} COMPILE_PDB_NAME_DEBUG)
-        get_target_property(t_pdb_output_directory ${t} PDB_OUTPUT_DIRECTORY)
+        get_target_property(t_pdb_output_directory ${t} COMPILE_PDB_OUTPUT_DIRECTORY)
        get_target_property(t_shared_pdb_name ${t} PDB_NAME)
        get_target_property(t_shared_pdb_name_debug ${t} PDB_NAME_DEBUG)
        get_target_property(t_shared_pdb_output_directory ${t} PDB_OUTPUT_DIRECTORY)
        install(FILES
-          "${t_pdb_output_directory}/\${CMAKE_INSTALL_CONFIG_NAME}/$<$<CONFIG:Debug>:${t_pdb_name_debug}>$<$<NOT:$<CONFIG:Debug>>:${t_pdb_name}>.pdb"
+          "$<$<STREQUAL:$<TARGET_PROPERTY:${t},TYPE>,STATIC_LIBRARY>:${t_pdb_output_directory}/\${CMAKE_INSTALL_CONFIG_NAME}/$<IF:$<CONFIG:Debug>,${t_pdb_name_debug},${t_pdb_name}>.pdb>"
-          DESTINATION ${CMAKE_INSTALL_LIBDIR}
+          "$<$<STREQUAL:$<TARGET_PROPERTY:${t},TYPE>,SHARED_LIBRARY>:${t_shared_pdb_output_directory}/\${CMAKE_INSTALL_CONFIG_NAME}/$<IF:$<CONFIG:Debug>,${t_shared_pdb_name_debug},${t_shared_pdb_name}>.pdb>"
          COMPONENT "${PROJECT_NAME}"
          DESTINATION $<IF:$<STREQUAL:$<TARGET_PROPERTY:${t},TYPE>,STATIC_LIBRARY>,${CMAKE_INSTALL_LIBDIR},${CMAKE_INSTALL_BINDIR}>
          OPTIONAL)
      endforeach()
    endif()
@ -352,6 +353,7 @@ function(install_project)
      configure_file("${PROJECT_SOURCE_DIR}/cmake/${t}.pc.in"
        "${configured_pc}" @ONLY)
      install(FILES "${configured_pc}"
        COMPONENT "${PROJECT_NAME}"
        DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
    endforeach()
  endif()
--- a/test/googletest/googletest/include/gtest/gtest-assertion-result.h
+++ b/test/googletest/googletest/include/gtest/gtest-assertion-result.h
@ -130,7 +130,14 @@ namespace testing {
 //   Expected: Foo() is even
 //     Actual: it's 5
 //
-class GTEST_API_ AssertionResult {
+
 // Returned AssertionResult objects may not be ignored.
 // Note: Disabled for SWIG as it doesn't parse attributes correctly.
 #if !defined(SWIG)
 class [[nodiscard]] AssertionResult;
 #endif  // !SWIG
 class GTEST_API_ [[nodiscard]] AssertionResult {
 public:
  // Copy constructor.
  // Used in EXPECT_TRUE/FALSE(assertion_result).
@ -151,14 +158,18 @@ class GTEST_API_ AssertionResult {
  // The second parameter prevents this overload from being considered if
  // the argument is implicitly convertible to AssertionResult. In that case
  // we want AssertionResult's copy constructor to be used.
-  template <typename T>
+  template <typename T,
-  explicit AssertionResult(
+            std::enable_if_t<!std::is_convertible_v<T, AssertionResult> &&
-      const T& success,
+                                 !std::is_trivially_constructible_v<bool, T>,
-      typename std::enable_if<
+                             int> = 0>
-          !std::is_convertible<T, AssertionResult>::value>::type*
+  explicit AssertionResult(T&& success) : success_(std::forward<T>(success)) {}
-      /*enabler*/
+
-      = nullptr)
+  // Similar to the mutable overload, but for cases where mutability is
-      : success_(success) {}
+  // unnecessary or problematic (e.g., bitfields).
  template <typename T,
            std::enable_if_t<!std::is_convertible_v<const T&, AssertionResult>,
                             int> = 0>
  explicit AssertionResult(const T& success) : success_(success) {}
 #if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
  GTEST_DISABLE_MSC_WARNINGS_POP_()
@ -181,7 +192,7 @@ class GTEST_API_ AssertionResult {
  // assertion's expectation). When nothing has been streamed into the
  // object, returns an empty string.
  const char* message() const {
-    return message_.get() != nullptr ? message_->c_str() : "";
+    return message_ != nullptr ? message_->c_str() : "";
  }
  // Deprecated; please use message() instead.
  const char* failure_message() const { return message(); }
@ -204,7 +215,7 @@ class GTEST_API_ AssertionResult {
 private:
  // Appends the contents of message to message_.
  void AppendMessage(const Message& a_message) {
-    if (message_.get() == nullptr) message_.reset(new ::std::string);
+    if (message_ == nullptr) message_ = ::std::make_unique<::std::string>();
    message_->append(a_message.GetString().c_str());
  }
@ -220,6 +231,24 @@ class GTEST_API_ AssertionResult {
  std::unique_ptr< ::std::string> message_;
 };
 namespace internal {
 // A pair containing the result that an assertion is evaluating, and the
 // expected result (true, false).
 //
 // Contains a conversion operator that indicates whether the two match.
 struct AssertionResultExpectation {
  testing::AssertionResult assertion_result;
  bool expected_result;
  explicit operator bool() const {
    bool converted(assertion_result);
    return converted == expected_result;
  }
 };
 }  // namespace internal
 // Makes a successful assertion result.
 GTEST_API_ AssertionResult AssertionSuccess();
--- a/test/googletest/googletest/include/gtest/gtest-death-test.h
+++ b/test/googletest/googletest/include/gtest/gtest-death-test.h
@ -51,7 +51,7 @@ GTEST_DECLARE_string_(death_test_style);
 namespace testing {
-#if GTEST_HAS_DEATH_TEST
+#ifdef GTEST_HAS_DEATH_TEST
 namespace internal {
@ -192,7 +192,7 @@ GTEST_API_ bool InDeathTestChild();
 // Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*:
 // Tests that an exit code describes a normal exit with a given exit code.
-class GTEST_API_ ExitedWithCode {
+class GTEST_API_ [[nodiscard]] ExitedWithCode {
 public:
  explicit ExitedWithCode(int exit_code);
  ExitedWithCode(const ExitedWithCode&) = default;
@ -203,10 +203,10 @@ class GTEST_API_ ExitedWithCode {
  const int exit_code_;
 };
-#if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+#if !defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_FUCHSIA)
 // Tests that an exit code describes an exit due to termination by a
 // given signal.
-class GTEST_API_ KilledBySignal {
+class GTEST_API_ [[nodiscard]] KilledBySignal {
 public:
  explicit KilledBySignal(int signum);
  bool operator()(int exit_status) const;
@ -293,8 +293,8 @@ class GTEST_API_ KilledBySignal {
 //                statement is compiled but not executed, to ensure that
 //                EXPECT_DEATH_IF_SUPPORTED compiles with a certain
 //                parameter if and only if EXPECT_DEATH compiles with it.
-//   regex     -  A regex that a macro such as EXPECT_DEATH would use to test
+//   regex_or_matcher -  A regex that a macro such as EXPECT_DEATH would use
-//                the output of statement.  This parameter has to be
+//                to test the output of statement.  This parameter has to be
 //                compiled but not evaluated by this macro, to ensure that
 //                this macro only accepts expressions that a macro such as
 //                EXPECT_DEATH would accept.
@ -311,13 +311,13 @@ class GTEST_API_ KilledBySignal {
 //  statement unconditionally returns or throws. The Message constructor at
 //  the end allows the syntax of streaming additional messages into the
 //  macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH.
-#define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, terminator)             \
+#define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex_or_matcher, terminator)  \
  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
  if (::testing::internal::AlwaysTrue()) {                                     \
    GTEST_LOG_(WARNING) << "Death tests are not supported on this platform.\n" \
                        << "Statement '" #statement "' cannot be verified.";   \
  } else if (::testing::internal::AlwaysFalse()) {                             \
-    ::testing::internal::RE::PartialMatch(".*", (regex));                      \
+    (void)::testing::internal::MakeDeathTestMatcher(regex_or_matcher);         \
    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);                 \
    terminator;                                                                \
  } else                                                                       \
@ -328,7 +328,7 @@ class GTEST_API_ KilledBySignal {
 // death tests are supported; otherwise they just issue a warning.  This is
 // useful when you are combining death test assertions with normal test
 // assertions in one test.
-#if GTEST_HAS_DEATH_TEST
+#ifdef GTEST_HAS_DEATH_TEST
 #define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
  EXPECT_DEATH(statement, regex)
 #define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
--- a/test/googletest/googletest/include/gtest/gtest-matchers.h
+++ b/test/googletest/googletest/include/gtest/gtest-matchers.h
@ -40,9 +40,12 @@
 #define GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
 #include <atomic>
 #include <cstddef>
 #include <functional>
 #include <memory>
 #include <ostream>
 #include <string>
 #include <string_view>
 #include <type_traits>
 #include "gtest/gtest-printers.h"
@ -66,15 +69,15 @@ namespace testing {
 // To implement a matcher Foo for type T, define:
 //   1. a class FooMatcherMatcher that implements the matcher interface:
 //     using is_gtest_matcher = void;
-//     bool MatchAndExplain(const T&, std::ostream*);
+//     bool MatchAndExplain(const T&, std::ostream*) const;
 //       (MatchResultListener* can also be used instead of std::ostream*)
-//     void DescribeTo(std::ostream*);
+//     void DescribeTo(std::ostream*) const;
-//     void DescribeNegationTo(std::ostream*);
+//     void DescribeNegationTo(std::ostream*) const;
 //
 //   2. a factory function that creates a Matcher<T> object from a
 //      FooMatcherMatcher.
-class MatchResultListener {
+class [[nodiscard]] MatchResultListener {
 public:
  // Creates a listener object with the given underlying ostream.  The
  // listener does not own the ostream, and does not dereference it
@ -106,13 +109,13 @@ class MatchResultListener {
  MatchResultListener& operator=(const MatchResultListener&) = delete;
 };
-inline MatchResultListener::~MatchResultListener() {}
+inline MatchResultListener::~MatchResultListener() = default;
 // An instance of a subclass of this knows how to describe itself as a
 // matcher.
-class GTEST_API_ MatcherDescriberInterface {
+class GTEST_API_ [[nodiscard]] MatcherDescriberInterface {
 public:
-  virtual ~MatcherDescriberInterface() {}
+  virtual ~MatcherDescriberInterface() = default;
  // Describes this matcher to an ostream.  The function should print
  // a verb phrase that describes the property a value matching this
@ -136,7 +139,7 @@ class GTEST_API_ MatcherDescriberInterface {
 // The implementation of a matcher.
 template <typename T>
-class MatcherInterface : public MatcherDescriberInterface {
+class [[nodiscard]] MatcherInterface : public MatcherDescriberInterface {
 public:
  // Returns true if and only if the matcher matches x; also explains the
  // match result to 'listener' if necessary (see the next paragraph), in
@ -178,45 +181,8 @@ class MatcherInterface : public MatcherDescriberInterface {
 namespace internal {
 struct AnyEq {
  template <typename A, typename B>
  bool operator()(const A& a, const B& b) const {
    return a == b;
  }
 };
 struct AnyNe {
  template <typename A, typename B>
  bool operator()(const A& a, const B& b) const {
    return a != b;
  }
 };
 struct AnyLt {
  template <typename A, typename B>
  bool operator()(const A& a, const B& b) const {
    return a < b;
  }
 };
 struct AnyGt {
  template <typename A, typename B>
  bool operator()(const A& a, const B& b) const {
    return a > b;
  }
 };
 struct AnyLe {
  template <typename A, typename B>
  bool operator()(const A& a, const B& b) const {
    return a <= b;
  }
 };
 struct AnyGe {
  template <typename A, typename B>
  bool operator()(const A& a, const B& b) const {
    return a >= b;
  }
 };
 // A match result listener that ignores the explanation.
-class DummyMatchResultListener : public MatchResultListener {
+class [[nodiscard]] DummyMatchResultListener : public MatchResultListener {
 public:
  DummyMatchResultListener() : MatchResultListener(nullptr) {}
@ -228,7 +194,7 @@ class DummyMatchResultListener : public MatchResultListener {
 // A match result listener that forwards the explanation to a given
 // ostream.  The difference between this and MatchResultListener is
 // that the former is concrete.
-class StreamMatchResultListener : public MatchResultListener {
+class [[nodiscard]] StreamMatchResultListener : public MatchResultListener {
 public:
  explicit StreamMatchResultListener(::std::ostream* os)
      : MatchResultListener(os) {}
@ -261,7 +227,7 @@ struct SharedPayload : SharedPayloadBase {
 // from it.  We put functionalities common to all Matcher<T>
 // specializations here to avoid code duplication.
 template <typename T>
-class MatcherBase : private MatcherDescriberInterface {
+class [[nodiscard]] MatcherBase : private MatcherDescriberInterface {
 public:
  // Returns true if and only if the matcher matches x; also explains the
  // match result to 'listener'.
@ -312,8 +278,8 @@ class MatcherBase : private MatcherDescriberInterface {
    Init(impl);
  }
-  template <typename M, typename = typename std::remove_reference<
+  template <typename M,
-                            M>::type::is_gtest_matcher>
+            typename = typename std::remove_reference_t<M>::is_gtest_matcher>
  MatcherBase(M&& m) : vtable_(nullptr), buffer_() {  // NOLINT
    Init(std::forward<M>(m));
  }
@ -332,12 +298,12 @@ class MatcherBase : private MatcherDescriberInterface {
    return *this;
  }
-  MatcherBase(MatcherBase&& other)
+  MatcherBase(MatcherBase&& other) noexcept
      : vtable_(other.vtable_), buffer_(other.buffer_) {
    other.vtable_ = nullptr;
  }
-  MatcherBase& operator=(MatcherBase&& other) {
+  MatcherBase& operator=(MatcherBase&& other) noexcept {
    if (this == &other) return *this;
    Destroy();
    vtable_ = other.vtable_;
@ -398,9 +364,8 @@ class MatcherBase : private MatcherDescriberInterface {
    // from the impl, but some users really want to get their impl back when
    // they call GetDescriber().
    // We use std::get on a tuple as a workaround of not having `if constexpr`.
-    return std::get<(
+    return std::get<(std::is_convertible_v<decltype(&P::Get(m)),
-        std::is_convertible<decltype(&P::Get(m)),
+                                           const MatcherDescriberInterface*>
                            const MatcherDescriberInterface*>::value
                         ? 1
                         : 0)>(std::make_tuple(&m, &P::Get(m)));
  }
@ -431,8 +396,8 @@ class MatcherBase : private MatcherDescriberInterface {
  template <typename M>
  static constexpr bool IsInlined() {
    return sizeof(M) <= sizeof(Buffer) && alignof(M) <= alignof(Buffer) &&
-           std::is_trivially_copy_constructible<M>::value &&
+           std::is_trivially_copy_constructible_v<M> &&
-           std::is_trivially_destructible<M>::value;
+           std::is_trivially_destructible_v<M>;
  }
  template <typename M, bool = MatcherBase::IsInlined<M>()>
@ -479,7 +444,7 @@ class MatcherBase : private MatcherDescriberInterface {
  template <typename M>
  void Init(M&& m) {
-    using MM = typename std::decay<M>::type;
+    using MM = std::decay_t<M>;
    using Policy = ValuePolicy<MM>;
    vtable_ = GetVTable<Policy>();
    Policy::Init(*this, std::forward<M>(m));
@ -496,7 +461,7 @@ class MatcherBase : private MatcherDescriberInterface {
 // implementation of Matcher<T> is just a std::shared_ptr to const
 // MatcherInterface<T>.  Don't inherit from Matcher!
 template <typename T>
-class Matcher : public internal::MatcherBase<T> {
+class [[nodiscard]] Matcher : public internal::MatcherBase<T> {
 public:
  // Constructs a null matcher.  Needed for storing Matcher objects in STL
  // containers.  A default-constructed matcher is not yet initialized.  You
@ -508,35 +473,42 @@ class Matcher : public internal::MatcherBase<T> {
      : internal::MatcherBase<T>(impl) {}
  template <typename U>
-  explicit Matcher(
+  explicit Matcher(const MatcherInterface<U>* impl,
-      const MatcherInterface<U>* impl,
+                   std::enable_if_t<!std::is_same_v<U, const U&>>* = nullptr)
      typename std::enable_if<!std::is_same<U, const U&>::value>::type* =
          nullptr)
      : internal::MatcherBase<T>(impl) {}
-  template <typename M, typename = typename std::remove_reference<
+  template <typename M,
-                            M>::type::is_gtest_matcher>
+            typename = typename std::remove_reference_t<M>::is_gtest_matcher>
  Matcher(M&& m) : internal::MatcherBase<T>(std::forward<M>(m)) {}  // NOLINT
  // Implicit constructor here allows people to write
  // EXPECT_CALL(foo, Bar(5)) instead of EXPECT_CALL(foo, Bar(Eq(5))) sometimes
  Matcher(T value);  // NOLINT
  // Implicit constructor here allows people to write
  // EXPECT_THAT(foo, nullptr) instead of EXPECT_THAT(foo, IsNull()) for smart
  // pointer types.
  //
  // The second argument is needed to avoid capturing literal '0'.
  template <typename U>
  Matcher(U,  // NOLINT
          std::enable_if_t<std::is_same_v<U, std::nullptr_t>>* = nullptr);
 };
 // The following two specializations allow the user to write str
 // instead of Eq(str) and "foo" instead of Eq("foo") when a std::string
 // matcher is expected.
 template <>
-class GTEST_API_ Matcher<const std::string&>
+class GTEST_API_ [[nodiscard]]
-    : public internal::MatcherBase<const std::string&> {
+Matcher<const std::string&> : public internal::MatcherBase<const std::string&> {
 public:
-  Matcher() {}
+  Matcher() = default;
  explicit Matcher(const MatcherInterface<const std::string&>* impl)
      : internal::MatcherBase<const std::string&>(impl) {}
-  template <typename M, typename = typename std::remove_reference<
+  template <typename M,
-                            M>::type::is_gtest_matcher>
+            typename = typename std::remove_reference_t<M>::is_gtest_matcher>
  Matcher(M&& m)  // NOLINT
      : internal::MatcherBase<const std::string&>(std::forward<M>(m)) {}
@ -549,18 +521,18 @@ class GTEST_API_ Matcher<const std::string&>
 };
 template <>
-class GTEST_API_ Matcher<std::string>
+class GTEST_API_ [[nodiscard]]
-    : public internal::MatcherBase<std::string> {
+Matcher<std::string> : public internal::MatcherBase<std::string> {
 public:
-  Matcher() {}
+  Matcher() = default;
  explicit Matcher(const MatcherInterface<const std::string&>* impl)
      : internal::MatcherBase<std::string>(impl) {}
  explicit Matcher(const MatcherInterface<std::string>* impl)
      : internal::MatcherBase<std::string>(impl) {}
-  template <typename M, typename = typename std::remove_reference<
+  template <typename M,
-                            M>::type::is_gtest_matcher>
+            typename = typename std::remove_reference_t<M>::is_gtest_matcher>
  Matcher(M&& m)  // NOLINT
      : internal::MatcherBase<std::string>(std::forward<M>(m)) {}
@ -572,21 +544,20 @@ class GTEST_API_ Matcher<std::string>
  Matcher(const char* s);  // NOLINT
 };
 #if GTEST_INTERNAL_HAS_STRING_VIEW
 // The following two specializations allow the user to write str
-// instead of Eq(str) and "foo" instead of Eq("foo") when a absl::string_view
+// instead of Eq(str) and "foo" instead of Eq("foo") when a std::string_view
 // matcher is expected.
 template <>
-class GTEST_API_ Matcher<const internal::StringView&>
+class GTEST_API_ [[nodiscard]] Matcher<const internal::StringView&>
    : public internal::MatcherBase<const internal::StringView&> {
 public:
-  Matcher() {}
+  Matcher() = default;
  explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
      : internal::MatcherBase<const internal::StringView&>(impl) {}
-  template <typename M, typename = typename std::remove_reference<
+  template <typename M,
-                            M>::type::is_gtest_matcher>
+            typename = typename std::remove_reference_t<M>::is_gtest_matcher>
  Matcher(M&& m)  // NOLINT
      : internal::MatcherBase<const internal::StringView&>(std::forward<M>(m)) {
  }
@ -598,23 +569,23 @@ class GTEST_API_ Matcher<const internal::StringView&>
  // Allows the user to write "foo" instead of Eq("foo") sometimes.
  Matcher(const char* s);  // NOLINT
-  // Allows the user to pass absl::string_views or std::string_views directly.
+  // Allows the user to pass std::string_views directly.
  Matcher(internal::StringView s);  // NOLINT
 };
 template <>
-class GTEST_API_ Matcher<internal::StringView>
+class GTEST_API_ [[nodiscard]] Matcher<internal::StringView>
    : public internal::MatcherBase<internal::StringView> {
 public:
-  Matcher() {}
+  Matcher() = default;
  explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
      : internal::MatcherBase<internal::StringView>(impl) {}
  explicit Matcher(const MatcherInterface<internal::StringView>* impl)
      : internal::MatcherBase<internal::StringView>(impl) {}
-  template <typename M, typename = typename std::remove_reference<
+  template <typename M,
-                            M>::type::is_gtest_matcher>
+            typename = typename std::remove_reference_t<M>::is_gtest_matcher>
  Matcher(M&& m)  // NOLINT
      : internal::MatcherBase<internal::StringView>(std::forward<M>(m)) {}
@ -625,10 +596,9 @@ class GTEST_API_ Matcher<internal::StringView>
  // Allows the user to write "foo" instead of Eq("foo") sometimes.
  Matcher(const char* s);  // NOLINT
-  // Allows the user to pass absl::string_views or std::string_views directly.
+  // Allows the user to pass std::string_views directly.
  Matcher(internal::StringView s);  // NOLINT
 };
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
 // Prints a matcher in a human-readable format.
 template <typename T>
@ -650,7 +620,7 @@ std::ostream& operator<<(std::ostream& os, const Matcher<T>& matcher) {
 //
 // See the definition of NotNull() for a complete example.
 template <class Impl>
-class PolymorphicMatcher {
+class [[nodiscard]] PolymorphicMatcher {
 public:
  explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {}
@ -725,7 +695,7 @@ namespace internal {
 // The following template definition assumes that the Rhs parameter is
 // a "bare" type (i.e. neither 'const T' nor 'T&').
 template <typename D, typename Rhs, typename Op>
-class ComparisonBase {
+class [[nodiscard]] ComparisonBase {
 public:
  explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {}
@ -758,72 +728,122 @@ class ComparisonBase {
 };
 template <typename Rhs>
-class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> {
+class [[nodiscard]] EqMatcher
    : public ComparisonBase<EqMatcher<Rhs>, Rhs, std::equal_to<>> {
 public:
  explicit EqMatcher(const Rhs& rhs)
-      : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) {}
+      : ComparisonBase<EqMatcher<Rhs>, Rhs, std::equal_to<>>(rhs) {}
  static const char* Desc() { return "is equal to"; }
  static const char* NegatedDesc() { return "isn't equal to"; }
 };
 template <typename Rhs>
-class NeMatcher : public ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe> {
+class [[nodiscard]] NeMatcher
    : public ComparisonBase<NeMatcher<Rhs>, Rhs, std::not_equal_to<>> {
 public:
  explicit NeMatcher(const Rhs& rhs)
-      : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) {}
+      : ComparisonBase<NeMatcher<Rhs>, Rhs, std::not_equal_to<>>(rhs) {}
  static const char* Desc() { return "isn't equal to"; }
  static const char* NegatedDesc() { return "is equal to"; }
 };
 template <typename Rhs>
-class LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt> {
+class [[nodiscard]] LtMatcher
    : public ComparisonBase<LtMatcher<Rhs>, Rhs, std::less<>> {
 public:
  explicit LtMatcher(const Rhs& rhs)
-      : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) {}
+      : ComparisonBase<LtMatcher<Rhs>, Rhs, std::less<>>(rhs) {}
  static const char* Desc() { return "is <"; }
  static const char* NegatedDesc() { return "isn't <"; }
 };
 template <typename Rhs>
-class GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt> {
+class [[nodiscard]] GtMatcher
    : public ComparisonBase<GtMatcher<Rhs>, Rhs, std::greater<>> {
 public:
  explicit GtMatcher(const Rhs& rhs)
-      : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) {}
+      : ComparisonBase<GtMatcher<Rhs>, Rhs, std::greater<>>(rhs) {}
  static const char* Desc() { return "is >"; }
  static const char* NegatedDesc() { return "isn't >"; }
 };
 template <typename Rhs>
-class LeMatcher : public ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe> {
+class [[nodiscard]] LeMatcher
    : public ComparisonBase<LeMatcher<Rhs>, Rhs, std::less_equal<>> {
 public:
  explicit LeMatcher(const Rhs& rhs)
-      : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) {}
+      : ComparisonBase<LeMatcher<Rhs>, Rhs, std::less_equal<>>(rhs) {}
  static const char* Desc() { return "is <="; }
  static const char* NegatedDesc() { return "isn't <="; }
 };
 template <typename Rhs>
-class GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> {
+class [[nodiscard]] GeMatcher
    : public ComparisonBase<GeMatcher<Rhs>, Rhs, std::greater_equal<>> {
 public:
  explicit GeMatcher(const Rhs& rhs)
-      : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) {}
+      : ComparisonBase<GeMatcher<Rhs>, Rhs, std::greater_equal<>>(rhs) {}
  static const char* Desc() { return "is >="; }
  static const char* NegatedDesc() { return "isn't >="; }
 };
-template <typename T, typename = typename std::enable_if<
+// Same as `EqMatcher<Rhs>`, except that the `rhs` is stored as `StoredRhs` and
-                          std::is_constructible<std::string, T>::value>::type>
+// must be implicitly convertible to `Rhs`.
-using StringLike = T;
+template <typename Rhs, typename StoredRhs>
 class [[nodiscard]] ImplicitCastEqMatcher {
 public:
  explicit ImplicitCastEqMatcher(const StoredRhs& rhs) : stored_rhs_(rhs) {}
  using is_gtest_matcher = void;
  template <typename Lhs>
  bool MatchAndExplain(const Lhs& lhs, std::ostream*) const {
    return lhs == rhs();
  }
  void DescribeTo(std::ostream* os) const {
    *os << "is equal to ";
    UniversalPrint(rhs(), os);
  }
  void DescribeNegationTo(std::ostream* os) const {
    *os << "isn't equal to ";
    UniversalPrint(rhs(), os);
  }
 private:
  Rhs rhs() const { return ImplicitCast_<Rhs>(stored_rhs_); }
  StoredRhs stored_rhs_;
 };
 // Dummy function (never defined) whose return type evaluates to std::string if
 // the given type is a string-like type that can be converted to std::string,
 // either directly or through an intermediate std::string_view.
 template <class T>
 extern std::enable_if_t<std::is_constructible_v<std::string, T>, std::string>
 ResolveAsString(const void* /* preferred */);
 #if GTEST_HAS_STD_WSTRING
 // Same as above, but for std::wstring. In cases where both conversions are
 // possible, this overload takes lower priority.
 template <class T>
 extern std::enable_if_t<std::is_constructible_v<std::wstring, T>, std::wstring>
 ResolveAsString(... /* fallback */);
 #endif
 // Evaluates to the std::basic_string type that the given string-like type can
 // be converted to. Prefers std::string over std::wstring if both are possible.
 // Fails in a SFINAE-friendly way if no conversion was viable.
 template <typename T>
 using StringType = decltype(ResolveAsString<T>(nullptr));
 // Implements polymorphic matchers MatchesRegex(regex) and
 // ContainsRegex(regex), which can be used as a Matcher<T> as long as
 // T can be converted to a string.
-class MatchesRegexMatcher {
+class [[nodiscard]] MatchesRegexMatcher {
 public:
  MatchesRegexMatcher(const RE* regex, bool full_match)
      : regex_(regex), full_match_(full_match) {}
 #if GTEST_INTERNAL_HAS_STRING_VIEW
  bool MatchAndExplain(const internal::StringView& s,
                       MatchResultListener* listener) const {
    return MatchAndExplain(std::string(s), listener);
  }
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
  // Accepts pointer types, particularly:
  //   const char*
@ -838,7 +858,7 @@ class MatchesRegexMatcher {
  // Matches anything that can convert to std::string.
  //
  // This is a template, not just a plain function with const std::string&,
-  // because absl::string_view has some interfering non-explicit constructors.
+  // because std::string_view has some interfering non-explicit constructors.
  template <class MatcheeStringType>
  bool MatchAndExplain(const MatcheeStringType& s,
                       MatchResultListener* /* listener */) const {
@ -871,9 +891,10 @@ inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true));
 }
 template <typename T = std::string>
-PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
+std::enable_if_t<std::is_constructible_v<internal::RE, internal::StringType<T>>,
-    const internal::StringLike<T>& regex) {
+                 PolymorphicMatcher<internal::MatchesRegexMatcher>>
-  return MatchesRegex(new internal::RE(std::string(regex)));
+MatchesRegex(const T& regex) {
  return MatchesRegex(new internal::RE(internal::StringType<T>(regex)));
 }
 // Matches a string that contains regular expression 'regex'.
@ -883,9 +904,10 @@ inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false));
 }
 template <typename T = std::string>
-PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
+std::enable_if_t<std::is_constructible_v<internal::RE, internal::StringType<T>>,
-    const internal::StringLike<T>& regex) {
+                 PolymorphicMatcher<internal::MatchesRegexMatcher>>
-  return ContainsRegex(new internal::RE(std::string(regex)));
+ContainsRegex(const T& regex) {
  return ContainsRegex(new internal::RE(internal::StringType<T>(regex)));
 }
 // Creates a polymorphic matcher that matches anything equal to x.
@ -903,6 +925,14 @@ Matcher<T>::Matcher(T value) {
  *this = Eq(value);
 }
 // Constructs a Matcher<T> from nullptr. The constructed matcher matches any
 // value that is equal to nullptr.
 template <typename T>
 template <typename U>
 Matcher<T>::Matcher(U, std::enable_if_t<std::is_same_v<U, std::nullptr_t>>*) {
  *this = Eq(nullptr);
 }
 // Creates a monomorphic matcher that matches anything with type Lhs
 // and equal to rhs.  A user may need to use this instead of Eq(...)
 // in order to resolve an overloading ambiguity.
--- a/test/googletest/googletest/include/gtest/gtest-message.h
+++ b/test/googletest/googletest/include/gtest/gtest-message.h
@ -56,6 +56,13 @@
 #include "gtest/internal/gtest-port.h"
 #ifdef GTEST_HAS_ABSL
 #include <type_traits>
 #include "absl/strings/has_absl_stringify.h"
 #include "absl/strings/str_cat.h"
 #endif  // GTEST_HAS_ABSL
 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
 /* class A needs to have dll-interface to be used by clients of class B */)
@ -111,9 +118,18 @@ class GTEST_API_ Message {
    *ss_ << str;
  }
-  // Streams a non-pointer value to this object.
+  // Streams a non-pointer value to this object. If building a version of
-  template <typename T>
+  // GoogleTest with ABSL, this overload is only enabled if the value does not
-  inline Message& operator<<(const T& val) {
+  // have an AbslStringify definition.
  template <
      typename T
 #ifdef GTEST_HAS_ABSL
      ,
      typename std::enable_if<!absl::HasAbslStringify<T>::value,  // NOLINT
                              int>::type = 0
 #endif  // GTEST_HAS_ABSL
      >
  Message& operator<<(const T& val) {
        // Some libraries overload << for STL containers.  These
    // overloads are defined in the global namespace instead of ::std.
    //
@ -133,6 +149,21 @@ class GTEST_API_ Message {
    return *this;
  }
 #ifdef GTEST_HAS_ABSL
  // Streams a non-pointer value with an AbslStringify definition to this
  // object.
  template <typename T,
            typename std::enable_if<absl::HasAbslStringify<T>::value,  // NOLINT
                                    int>::type = 0>
  Message& operator<<(const T& val) {
    // ::operator<< is needed here for a similar reason as with the non-Abseil
    // version above
    using ::operator<<;
    *ss_ << absl::StrCat(val);
    return *this;
  }
 #endif  // GTEST_HAS_ABSL
  // Streams a pointer value to this object.
  //
  // This function is an overload of the previous one.  When you
--- a/test/googletest/googletest/include/gtest/gtest-param-test.h
+++ b/test/googletest/googletest/include/gtest/gtest-param-test.h
@ -174,11 +174,12 @@ TEST_P(DerivedTest, DoesBlah) {
 #endif  // 0
 #include <functional>
 #include <iterator>
 #include <utility>
 #include "gtest/internal/gtest-internal.h"
-#include "gtest/internal/gtest-param-util.h"
+#include "gtest/internal/gtest-param-util.h"  // IWYU pragma: export
 #include "gtest/internal/gtest-port.h"
 namespace testing {
@ -413,7 +414,8 @@ internal::CartesianProductHolder<Generator...> Combine(const Generator&... g) {
 // Synopsis:
 // ConvertGenerator<T>(gen)
 //   - returns a generator producing the same elements as generated by gen, but
-//     each element is static_cast to type T before being returned
+//     each T-typed element is static_cast to a type deduced from the interface
 //     that accepts this generator, and then returned
 //
 // It is useful when using the Combine() function to get the generated
 // parameters in a custom type instead of std::tuple
@ -441,10 +443,65 @@ internal::CartesianProductHolder<Generator...> Combine(const Generator&... g) {
 //                              Combine(Values("cat", "dog"),
 //                                      Values(BLACK, WHITE))));
 //
-template <typename T>
+template <typename RequestedT>
-internal::ParamConverterGenerator<T> ConvertGenerator(
+internal::ParamConverterGenerator<RequestedT> ConvertGenerator(
-    internal::ParamGenerator<T> gen) {
+    internal::ParamGenerator<RequestedT> gen) {
-  return internal::ParamConverterGenerator<T>(gen);
+  return internal::ParamConverterGenerator<RequestedT>(std::move(gen));
 }
 // As above, but takes a callable as a second argument. The callable converts
 // the generated parameter to the test fixture's parameter type. This allows you
 // to use a parameter type that does not have a converting constructor from the
 // generated type.
 //
 // Example:
 //
 // This will instantiate tests in test suite AnimalTest each one with
 // the parameter values tuple("cat", BLACK), tuple("cat", WHITE),
 // tuple("dog", BLACK), and tuple("dog", WHITE):
 //
 // enum Color { BLACK, GRAY, WHITE };
 // struct ParamType {
 //   std::string animal;
 //   Color color;
 // };
 // class AnimalTest
 //     : public testing::TestWithParam<ParamType> {...};
 //
 // TEST_P(AnimalTest, AnimalLooksNice) {...}
 //
 // INSTANTIATE_TEST_SUITE_P(
 //     AnimalVariations, AnimalTest,
 //     ConvertGenerator(Combine(Values("cat", "dog"), Values(BLACK, WHITE)),
 //                      [](std::tuple<std::string, Color> t) {
 //                        return ParamType{.animal = std::get<0>(t),
 //                                         .color = std::get<1>(t)};
 //                      }));
 //
 template <typename T, int&... ExplicitArgumentBarrier, typename Gen,
          typename Func,
          typename StdFunction = decltype(std::function(std::declval<Func>()))>
 internal::ParamConverterGenerator<T, StdFunction> ConvertGenerator(Gen&& gen,
                                                                   Func&& f) {
  return internal::ParamConverterGenerator<T, StdFunction>(
      std::forward<Gen>(gen), std::forward<Func>(f));
 }
 // As above, but infers the T from the supplied std::function instead of
 // having the caller specify it.
 template <int&... ExplicitArgumentBarrier, typename Gen, typename Func,
          typename StdFunction = decltype(std::function(std::declval<Func>()))>
 auto ConvertGenerator(Gen&& gen, Func&& f) {
  constexpr bool is_single_arg_std_function =
      internal::IsSingleArgStdFunction<StdFunction>::value;
  if constexpr (is_single_arg_std_function) {
    return ConvertGenerator<
        typename internal::FuncSingleParamType<StdFunction>::type>(
        std::forward<Gen>(gen), std::forward<Func>(f));
  } else {
    static_assert(is_single_arg_std_function,
                  "The call signature must contain a single argument.");
  }
 }
 #define TEST_P(test_suite_name, test_name)                                     \
@ -469,7 +526,7 @@ internal::ParamConverterGenerator<T> ConvertGenerator(
              ::testing::internal::CodeLocation(__FILE__, __LINE__));          \
      return 0;                                                                \
    }                                                                          \
-    static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_;               \
+    [[maybe_unused]] static int gtest_registering_dummy_;                      \
  };                                                                           \
  int GTEST_TEST_CLASS_NAME_(test_suite_name,                                  \
                             test_name)::gtest_registering_dummy_ =            \
@ -514,8 +571,7 @@ internal::ParamConverterGenerator<T> ConvertGenerator(
        ::testing::internal::DefaultParamName<test_suite_name::ParamType>,    \
        DUMMY_PARAM_))))(info);                                               \
  }                                                                           \
-  static int gtest_##prefix##test_suite_name##_dummy_                        \
+  [[maybe_unused]] static int gtest_##prefix##test_suite_name##_dummy_ =      \
      GTEST_ATTRIBUTE_UNUSED_ =                                              \
      ::testing::UnitTest::GetInstance()                                      \
          ->parameterized_test_registry()                                     \
          .GetTestSuitePatternHolder<test_suite_name>(                        \
@ -524,8 +580,8 @@ internal::ParamConverterGenerator<T> ConvertGenerator(
          ->AddTestSuiteInstantiation(                                        \
              GTEST_STRINGIFY_(prefix),                                       \
              &gtest_##prefix##test_suite_name##_EvalGenerator_,              \
-                  &gtest_##prefix##test_suite_name##_EvalGenerateName_,      \
+              &gtest_##prefix##test_suite_name##_EvalGenerateName_, __FILE__, \
-                  __FILE__, __LINE__)
+              __LINE__)
 // Allow Marking a Parameterized test class as not needing to be instantiated.
 #define GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(T)                  \
--- a/test/googletest/googletest/include/gtest/gtest-printers.h
+++ b/test/googletest/googletest/include/gtest/gtest-printers.h
@ -43,6 +43,9 @@
 //   1. foo::PrintTo(const T&, ostream*)
 //   2. operator<<(ostream&, const T&) defined in either foo or the
 //      global namespace.
 // * Prefer AbslStringify(..) to operator<<(..), per https://abseil.io/tips/215.
 // * Define foo::PrintTo(..) if the type already has AbslStringify(..), but an
 //   alternative presentation in test results is of interest.
 //
 // However if T is an STL-style container then it is printed element-wise
 // unless foo::PrintTo(const T&, ostream*) is defined. Note that
@ -101,20 +104,36 @@
 #ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
 #define GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
 #include <any>
 #include <functional>
 #include <memory>
 #include <optional>
 #include <ostream>  // NOLINT
 #include <sstream>
 #include <string>
 #include <string_view>
 #include <tuple>
 #include <type_traits>
 #include <typeinfo>
 #include <utility>
 #include <variant>
 #include <vector>
 #ifdef GTEST_HAS_ABSL
 #include "absl/strings/has_absl_stringify.h"
 #include "absl/strings/str_cat.h"
 #endif  // GTEST_HAS_ABSL
 #include "gtest/internal/gtest-internal.h"
 #include "gtest/internal/gtest-port.h"
 #if GTEST_INTERNAL_HAS_STD_SPAN
 #include <span>  // NOLINT
 #endif           // GTEST_INTERNAL_HAS_STD_SPAN
 #if GTEST_INTERNAL_HAS_COMPARE_LIB
 #include <compare>  // NOLINT
 #endif              // GTEST_INTERNAL_HAS_COMPARE_LIB
 namespace testing {
 // Definitions in the internal* namespaces are subject to change without notice.
@ -124,13 +143,32 @@ namespace internal {
 template <typename T>
 void UniversalPrint(const T& value, ::std::ostream* os);
 template <typename T>
 struct IsStdSpan {
  static constexpr bool value = false;
 };
 #if GTEST_INTERNAL_HAS_STD_SPAN
 template <typename E>
 struct IsStdSpan<std::span<E>> {
  static constexpr bool value = true;
 };
 #endif  // GTEST_INTERNAL_HAS_STD_SPAN
 // Used to print an STL-style container when the user doesn't define
 // a PrintTo() for it.
 //
 // NOTE: Since std::span does not have const_iterator until C++23, it would
 // fail IsContainerTest before C++23. However, IsContainerTest only uses
 // the presence of const_iterator to avoid treating iterators as containers
 // because of iterator::iterator. Which means std::span satisfies the *intended*
 // condition of IsContainerTest.
 struct ContainerPrinter {
  template <typename T,
            typename = typename std::enable_if<
-                (sizeof(IsContainerTest<T>(0)) == sizeof(IsContainer)) &&
+                ((sizeof(IsContainerTest<T>(0)) == sizeof(IsContainer)) &&
-                !IsRecursiveContainer<T>::value>::type>
+                 !IsRecursiveContainer<T>::value) ||
                IsStdSpan<T>::value>::type>
  static void PrintValue(const T& container, std::ostream* os) {
    const size_t kMaxCount = 32;  // The maximum number of elements to print.
    *os << '{';
@ -206,12 +244,13 @@ struct StreamPrinter {
            // Don't accept member pointers here. We'd print them via implicit
            // conversion to bool, which isn't useful.
            typename = typename std::enable_if<
-                !std::is_member_pointer<T>::value>::type,
+                !std::is_member_pointer<T>::value>::type>
  // Only accept types for which we can find a streaming operator via
  // ADL (possibly involving implicit conversions).
-            typename = decltype(std::declval<std::ostream&>()
+  // (Use SFINAE via return type, because it seems GCC < 12 doesn't handle name
-                                << std::declval<const T&>())>
+  // lookup properly when we do it in the template parameter list.)
-  static void PrintValue(const T& value, ::std::ostream* os) {
+  static auto PrintValue(const T& value, ::std::ostream* os)
      -> decltype((void)(*os << value)) {
    // Call streaming operator found by ADL, possibly with implicit conversions
    // of the arguments.
    *os << value;
@ -252,13 +291,22 @@ struct ConvertibleToIntegerPrinter {
 };
 struct ConvertibleToStringViewPrinter {
 #if GTEST_INTERNAL_HAS_STRING_VIEW
  static void PrintValue(internal::StringView value, ::std::ostream* os) {
    internal::UniversalPrint(value, os);
  }
 #endif
 };
 #ifdef GTEST_HAS_ABSL
 struct ConvertibleToAbslStringifyPrinter {
  template <typename T,
            typename = typename std::enable_if<
                absl::HasAbslStringify<T>::value>::type>  // NOLINT
  static void PrintValue(const T& value, ::std::ostream* os) {
    *os << absl::StrCat(value);
  }
 };
 #endif  // GTEST_HAS_ABSL
 // Prints the given number of bytes in the given object to the given
 // ostream.
 GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
@ -297,8 +345,8 @@ struct FindFirstPrinter<
 //  - Print containers (they have begin/end/etc).
 //  - Print function pointers.
 //  - Print object pointers.
 //  - Use the stream operator, if available.
 //  - Print protocol buffers.
 //  - Use the stream operator, if available.
 //  - Print types convertible to BiggestInt.
 //  - Print types convertible to StringView, if available.
 //  - Fallback to printing the raw bytes of the object.
@ -306,9 +354,13 @@ template <typename T>
 void PrintWithFallback(const T& value, ::std::ostream* os) {
  using Printer = typename FindFirstPrinter<
      T, void, ContainerPrinter, FunctionPointerPrinter, PointerPrinter,
      ProtobufPrinter,
 #ifdef GTEST_HAS_ABSL
      ConvertibleToAbslStringifyPrinter,
 #endif  // GTEST_HAS_ABSL
      internal_stream_operator_without_lexical_name_lookup::StreamPrinter,
-      ProtobufPrinter, ConvertibleToIntegerPrinter,
+      ConvertibleToIntegerPrinter, ConvertibleToStringViewPrinter,
-      ConvertibleToStringViewPrinter, RawBytesPrinter, FallbackPrinter>::type;
+      RawBytesPrinter, FallbackPrinter>::type;
  Printer::PrintValue(value, os);
 }
@ -328,7 +380,7 @@ void PrintWithFallback(const T& value, ::std::ostream* os) {
 // The default case.
 template <typename ToPrint, typename OtherOperand>
-class FormatForComparison {
+class [[nodiscard]] FormatForComparison {
 public:
  static ::std::string Format(const ToPrint& value) {
    return ::testing::PrintToString(value);
@ -337,7 +389,7 @@ class FormatForComparison {
 // Array.
 template <typename ToPrint, size_t N, typename OtherOperand>
-class FormatForComparison<ToPrint[N], OtherOperand> {
+class [[nodiscard]] FormatForComparison<ToPrint[N], OtherOperand> {
 public:
  static ::std::string Format(const ToPrint* value) {
    return FormatForComparison<const ToPrint*, OtherOperand>::Format(value);
@ -423,7 +475,7 @@ std::string FormatForComparisonFailureMessage(const T1& value,
 // function template), as we need to partially specialize it for
 // reference types, which cannot be done with function templates.
 template <typename T>
-class UniversalPrinter;
+class [[nodiscard]] UniversalPrinter;
 // Prints the given value using the << operator if it has one;
 // otherwise prints the bytes in it.  This is what
@ -471,11 +523,15 @@ GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os);
 GTEST_API_ void PrintTo(char32_t c, ::std::ostream* os);
 inline void PrintTo(char16_t c, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<char32_t>(c), os);
+  // TODO(b/418738869): Incorrect for values not representing valid codepoints.
  // Also see https://github.com/google/googletest/issues/4762.
  PrintTo(static_cast<char32_t>(c), os);
 }
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 inline void PrintTo(char8_t c, ::std::ostream* os) {
-  PrintTo(ImplicitCast_<char32_t>(c), os);
+  // TODO(b/418738869): Incorrect for values not representing valid codepoints.
  // Also see https://github.com/google/googletest/issues/4762.
  PrintTo(static_cast<char32_t>(c), os);
 }
 #endif
@ -506,49 +562,63 @@ int AppropriateResolution(FloatType val) {
  int full = std::numeric_limits<FloatType>::max_digits10;
  if (val < 0) val = -val;
 #ifdef __GNUC__
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfloat-equal"
 #endif
  if (val < 1000000) {
    FloatType mulfor6 = 1e10;
-    if (val >= 100000.0) {  // 100,000 to 999,999
+    // Without these static casts, the template instantiation for float would
    // fail to compile when -Wdouble-promotion is enabled, as the arithmetic and
    // comparison logic would promote floats to doubles.
    if (val >= static_cast<FloatType>(100000.0)) {  // 100,000 to 999,999
      mulfor6 = 1.0;
-    } else if (val >= 10000.0) {
+    } else if (val >= static_cast<FloatType>(10000.0)) {
      mulfor6 = 1e1;
-    } else if (val >= 1000.0) {
+    } else if (val >= static_cast<FloatType>(1000.0)) {
      mulfor6 = 1e2;
-    } else if (val >= 100.0) {
+    } else if (val >= static_cast<FloatType>(100.0)) {
      mulfor6 = 1e3;
-    } else if (val >= 10.0) {
+    } else if (val >= static_cast<FloatType>(10.0)) {
      mulfor6 = 1e4;
-    } else if (val >= 1.0) {
+    } else if (val >= static_cast<FloatType>(1.0)) {
      mulfor6 = 1e5;
-    } else if (val >= 0.1) {
+    } else if (val >= static_cast<FloatType>(0.1)) {
      mulfor6 = 1e6;
-    } else if (val >= 0.01) {
+    } else if (val >= static_cast<FloatType>(0.01)) {
      mulfor6 = 1e7;
-    } else if (val >= 0.001) {
+    } else if (val >= static_cast<FloatType>(0.001)) {
      mulfor6 = 1e8;
-    } else if (val >= 0.0001) {
+    } else if (val >= static_cast<FloatType>(0.0001)) {
      mulfor6 = 1e9;
    }
-    if (static_cast<float>(static_cast<int32_t>(val * mulfor6 + 0.5)) /
+    if (static_cast<FloatType>(static_cast<int32_t>(
            val * mulfor6 + (static_cast<FloatType>(0.5)))) /
            mulfor6 ==
        val)
      return 6;
-  } else if (val < 1e10) {
+  } else if (val < static_cast<FloatType>(1e10)) {
-    FloatType divfor6 = 1.0;
+    FloatType divfor6 = static_cast<FloatType>(1.0);
-    if (val >= 1e9) {  // 1,000,000,000 to 9,999,999,999
+    if (val >= static_cast<FloatType>(1e9)) {  // 1,000,000,000 to 9,999,999,999
      divfor6 = 10000;
-    } else if (val >= 1e8) {  // 100,000,000 to 999,999,999
+    } else if (val >=
               static_cast<FloatType>(1e8)) {  // 100,000,000 to 999,999,999
      divfor6 = 1000;
-    } else if (val >= 1e7) {  // 10,000,000 to 99,999,999
+    } else if (val >=
               static_cast<FloatType>(1e7)) {  // 10,000,000 to 99,999,999
      divfor6 = 100;
-    } else if (val >= 1e6) {  // 1,000,000 to 9,999,999
+    } else if (val >= static_cast<FloatType>(1e6)) {  // 1,000,000 to 9,999,999
      divfor6 = 10;
    }
-    if (static_cast<float>(static_cast<int32_t>(val / divfor6 + 0.5)) *
+    if (static_cast<FloatType>(static_cast<int32_t>(
            val / divfor6 + (static_cast<FloatType>(0.5)))) *
            divfor6 ==
        val)
      return 6;
  }
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif
  return full;
 }
@ -586,7 +656,7 @@ inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
 inline void PrintTo(unsigned char* s, ::std::ostream* os) {
  PrintTo(ImplicitCast_<const void*>(s), os);
 }
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 // Overloads for u8 strings.
 GTEST_API_ void PrintTo(const char8_t* s, ::std::ostream* os);
 inline void PrintTo(char8_t* s, ::std::ostream* os) {
@ -631,46 +701,63 @@ void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
  }
 }
-// Overloads for ::std::string.
+// Overloads for ::std::string and std::string_view
-GTEST_API_ void PrintStringTo(const ::std::string& s, ::std::ostream* os);
+GTEST_API_ void PrintStringTo(std::string_view s, ::std::ostream* os);
 inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
  PrintStringTo(s, os);
 }
 inline void PrintTo(std::string_view s, ::std::ostream* os) {
  PrintStringTo(s, os);
 }
-// Overloads for ::std::u8string
+// Overloads for ::std::u8string and ::std::u8string_view
 #ifdef __cpp_lib_char8_t
-GTEST_API_ void PrintU8StringTo(const ::std::u8string& s, ::std::ostream* os);
+GTEST_API_ void PrintU8StringTo(::std::u8string_view s, ::std::ostream* os);
 inline void PrintTo(const ::std::u8string& s, ::std::ostream* os) {
  PrintU8StringTo(s, os);
 }
 inline void PrintTo(::std::u8string_view s, ::std::ostream* os) {
  PrintU8StringTo(s, os);
 }
 #endif
-// Overloads for ::std::u16string
+// Overloads for ::std::u16string and ::std::u16string_view
-GTEST_API_ void PrintU16StringTo(const ::std::u16string& s, ::std::ostream* os);
+GTEST_API_ void PrintU16StringTo(::std::u16string_view s, ::std::ostream* os);
 inline void PrintTo(const ::std::u16string& s, ::std::ostream* os) {
  PrintU16StringTo(s, os);
 }
 inline void PrintTo(::std::u16string_view s, ::std::ostream* os) {
  PrintU16StringTo(s, os);
 }
-// Overloads for ::std::u32string
+// Overloads for ::std::u32string and ::std::u32string_view
-GTEST_API_ void PrintU32StringTo(const ::std::u32string& s, ::std::ostream* os);
+GTEST_API_ void PrintU32StringTo(::std::u32string_view s, ::std::ostream* os);
 inline void PrintTo(const ::std::u32string& s, ::std::ostream* os) {
  PrintU32StringTo(s, os);
 }
 inline void PrintTo(::std::u32string_view s, ::std::ostream* os) {
  PrintU32StringTo(s, os);
 }
-// Overloads for ::std::wstring.
+// Overloads for ::std::wstring and ::std::wstring_view
 #if GTEST_HAS_STD_WSTRING
-GTEST_API_ void PrintWideStringTo(const ::std::wstring& s, ::std::ostream* os);
+GTEST_API_ void PrintWideStringTo(::std::wstring_view s, ::std::ostream* os);
 inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
  PrintWideStringTo(s, os);
 }
 inline void PrintTo(::std::wstring_view s, ::std::ostream* os) {
  PrintWideStringTo(s, os);
 }
 #endif  // GTEST_HAS_STD_WSTRING
-#if GTEST_INTERNAL_HAS_STRING_VIEW
+// Overload for internal::StringView. Needed for build configurations where
-// Overload for internal::StringView.
+// internal::StringView is an alias for absl::string_view, but absl::string_view
 // is a distinct type from std::string_view.
 template <int&... ExplicitArgumentBarrier, typename T = internal::StringView,
          std::enable_if_t<!std::is_same_v<T, std::string_view>, int> = 0>
 inline void PrintTo(internal::StringView sp, ::std::ostream* os) {
-  PrintTo(::std::string(sp), os);
+  PrintStringTo(sp, os);
 }
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW
 inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os << "(nullptr)"; }
@ -722,6 +809,41 @@ void PrintTo(const std::shared_ptr<T>& ptr, std::ostream* os) {
  (PrintSmartPointer<T>)(ptr, os, 0);
 }
 #if GTEST_INTERNAL_HAS_COMPARE_LIB
 template <typename T>
 void PrintOrderingHelper(T ordering, std::ostream* os) {
  if (ordering == T::less) {
    *os << "(less)";
  } else if (ordering == T::greater) {
    *os << "(greater)";
  } else if (ordering == T::equivalent) {
    *os << "(equivalent)";
  } else {
    *os << "(unknown ordering)";
  }
 }
 inline void PrintTo(std::strong_ordering ordering, std::ostream* os) {
  if (ordering == std::strong_ordering::equal) {
    *os << "(equal)";
  } else {
    PrintOrderingHelper(ordering, os);
  }
 }
 inline void PrintTo(std::partial_ordering ordering, std::ostream* os) {
  if (ordering == std::partial_ordering::unordered) {
    *os << "(unordered)";
  } else {
    PrintOrderingHelper(ordering, os);
  }
 }
 inline void PrintTo(std::weak_ordering ordering, std::ostream* os) {
  PrintOrderingHelper(ordering, os);
 }
 #endif
 // Helper function for printing a tuple.  T must be instantiated with
 // a tuple type.
 template <typename T>
@ -737,8 +859,8 @@ void PrintTupleTo(const T& t, std::integral_constant<size_t, I>,
    GTEST_INTENTIONAL_CONST_COND_POP_()
    *os << ", ";
  }
-  UniversalPrinter<typename std::tuple_element<I - 1, T>::type>::Print(
+  UniversalPrinter<std::tuple_element_t<I - 1, T>>::Print(std::get<I - 1>(t),
-      std::get<I - 1>(t), os);
+                                                          os);
 }
 template <typename... Types>
@ -763,7 +885,7 @@ void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) {
 // Implements printing a non-reference type T by letting the compiler
 // pick the right overload of PrintTo() for T.
 template <typename T>
-class UniversalPrinter {
+class [[nodiscard]] UniversalPrinter {
 public:
  // MSVC warns about adding const to a function type, so we want to
  // disable the warning.
@ -789,16 +911,13 @@ class UniversalPrinter {
 // Remove any const-qualifiers before passing a type to UniversalPrinter.
 template <typename T>
-class UniversalPrinter<const T> : public UniversalPrinter<T> {};
+class [[nodiscard]] UniversalPrinter<const T> : public UniversalPrinter<T> {};
 #if GTEST_INTERNAL_HAS_ANY
 // Printer for std::any / absl::any
 // Printer for std::any
 template <>
-class UniversalPrinter<Any> {
+class [[nodiscard]] UniversalPrinter<std::any> {
 public:
-  static void Print(const Any& value, ::std::ostream* os) {
+  static void Print(const std::any& value, ::std::ostream* os) {
    if (value.has_value()) {
      *os << "value of type " << GetTypeName(value);
    } else {
@ -807,7 +926,7 @@ class UniversalPrinter<Any> {
  }
 private:
-  static std::string GetTypeName(const Any& value) {
+  static std::string GetTypeName(const std::any& value) {
 #if GTEST_HAS_RTTI
    return internal::GetTypeName(value.type());
 #else
@ -817,67 +936,60 @@ class UniversalPrinter<Any> {
  }
 };
-#endif  // GTEST_INTERNAL_HAS_ANY
+// Printer for std::optional
 #if GTEST_INTERNAL_HAS_OPTIONAL
 // Printer for std::optional / absl::optional
 template <typename T>
-class UniversalPrinter<Optional<T>> {
+class [[nodiscard]] UniversalPrinter<std::optional<T>> {
 public:
-  static void Print(const Optional<T>& value, ::std::ostream* os) {
+  static void Print(const std::optional<T>& value, ::std::ostream* os) {
    *os << '(';
    if (!value) {
-      *os << "nullopt";
+      UniversalPrint(std::nullopt, os);
    } else {
      *os << '(';
      UniversalPrint(*value, os);
    }
      *os << ')';
    }
  }
 };
 template <>
-class UniversalPrinter<decltype(Nullopt())> {
+class [[nodiscard]] UniversalPrinter<std::nullopt_t> {
 public:
-  static void Print(decltype(Nullopt()), ::std::ostream* os) {
+  static void Print(std::nullopt_t, ::std::ostream* os) { *os << "(nullopt)"; }
    *os << "(nullopt)";
  }
 };
-#endif  // GTEST_INTERNAL_HAS_OPTIONAL
+struct UniversalPrinterVisitor {
-
+  template <typename T>
-#if GTEST_INTERNAL_HAS_VARIANT
+  void operator()(const T& arg) const {
-
+    *os << "'" << GetTypeName<T>() << "(index = " << index << ")' with value ";
-// Printer for std::variant / absl::variant
+    UniversalPrint(arg, os);
 template <typename... T>
 class UniversalPrinter<Variant<T...>> {
 public:
  static void Print(const Variant<T...>& value, ::std::ostream* os) {
    *os << '(';
 #if GTEST_HAS_ABSL
    absl::visit(Visitor{os, value.index()}, value);
 #else
    std::visit(Visitor{os, value.index()}, value);
 #endif  // GTEST_HAS_ABSL
    *os << ')';
  }
 private:
  struct Visitor {
    template <typename U>
    void operator()(const U& u) const {
      *os << "'" << GetTypeName<U>() << "(index = " << index
          << ")' with value ";
      UniversalPrint(u, os);
  }
  ::std::ostream* os;
  std::size_t index;
 };
 // Printer for std::variant
 template <typename... T>
 class [[nodiscard]] UniversalPrinter<std::variant<T...>> {
 public:
  static void Print(const std::variant<T...>& value, ::std::ostream* os) {
    if (value.valueless_by_exception()) {
      *os << "(valueless)";
    } else {
      *os << '(';
      std::visit(UniversalPrinterVisitor{os, value.index()}, value);
      *os << ')';
    }
  }
 };
-#endif  // GTEST_INTERNAL_HAS_VARIANT
+// Printer for std::monostate
 template <>
 class [[nodiscard]] UniversalPrinter<std::monostate> {
 public:
  static void Print(std::monostate, ::std::ostream* os) {
    *os << "(monostate)";
  }
 };
 // UniversalPrintArray(begin, len, os) prints an array of 'len'
 // elements, starting at address 'begin'.
@ -906,7 +1018,7 @@ void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
 GTEST_API_ void UniversalPrintArray(const char* begin, size_t len,
                                    ::std::ostream* os);
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 // This overload prints a (const) char8_t array compactly.
 GTEST_API_ void UniversalPrintArray(const char8_t* begin, size_t len,
                                    ::std::ostream* os);
@ -926,7 +1038,7 @@ GTEST_API_ void UniversalPrintArray(const wchar_t* begin, size_t len,
 // Implements printing an array type T[N].
 template <typename T, size_t N>
-class UniversalPrinter<T[N]> {
+class [[nodiscard]] UniversalPrinter<T[N]> {
 public:
  // Prints the given array, omitting some elements when there are too
  // many.
@ -937,7 +1049,7 @@ class UniversalPrinter<T[N]> {
 // Implements printing a reference type T&.
 template <typename T>
-class UniversalPrinter<T&> {
+class [[nodiscard]] UniversalPrinter<T&> {
 public:
  // MSVC warns about adding const to a function type, so we want to
  // disable the warning.
@ -960,35 +1072,35 @@ class UniversalPrinter<T&> {
 // NUL-terminated string (but not the pointer) is printed.
 template <typename T>
-class UniversalTersePrinter {
+class [[nodiscard]] UniversalTersePrinter {
 public:
  static void Print(const T& value, ::std::ostream* os) {
    UniversalPrint(value, os);
  }
 };
 template <typename T>
-class UniversalTersePrinter<T&> {
+class [[nodiscard]] UniversalTersePrinter<T&> {
 public:
  static void Print(const T& value, ::std::ostream* os) {
    UniversalPrint(value, os);
  }
 };
 template <typename T>
-class UniversalTersePrinter<std::reference_wrapper<T>> {
+class [[nodiscard]] UniversalTersePrinter<std::reference_wrapper<T>> {
 public:
  static void Print(std::reference_wrapper<T> value, ::std::ostream* os) {
    UniversalTersePrinter<T>::Print(value.get(), os);
  }
 };
 template <typename T, size_t N>
-class UniversalTersePrinter<T[N]> {
+class [[nodiscard]] UniversalTersePrinter<T[N]> {
 public:
  static void Print(const T (&value)[N], ::std::ostream* os) {
    UniversalPrinter<T[N]>::Print(value, os);
  }
 };
 template <>
-class UniversalTersePrinter<const char*> {
+class [[nodiscard]] UniversalTersePrinter<const char*> {
 public:
  static void Print(const char* str, ::std::ostream* os) {
    if (str == nullptr) {
@ -999,12 +1111,12 @@ class UniversalTersePrinter<const char*> {
  }
 };
 template <>
-class UniversalTersePrinter<char*> : public UniversalTersePrinter<const char*> {
+class [[nodiscard]]
-};
+UniversalTersePrinter<char*> : public UniversalTersePrinter<const char*> {};
-#ifdef __cpp_char8_t
+#ifdef __cpp_lib_char8_t
 template <>
-class UniversalTersePrinter<const char8_t*> {
+class [[nodiscard]] UniversalTersePrinter<const char8_t*> {
 public:
  static void Print(const char8_t* str, ::std::ostream* os) {
    if (str == nullptr) {
@ -1015,12 +1127,12 @@ class UniversalTersePrinter<const char8_t*> {
  }
 };
 template <>
-class UniversalTersePrinter<char8_t*>
+class [[nodiscard]] UniversalTersePrinter<char8_t*>
    : public UniversalTersePrinter<const char8_t*> {};
 #endif
 template <>
-class UniversalTersePrinter<const char16_t*> {
+class [[nodiscard]] UniversalTersePrinter<const char16_t*> {
 public:
  static void Print(const char16_t* str, ::std::ostream* os) {
    if (str == nullptr) {
@ -1031,11 +1143,11 @@ class UniversalTersePrinter<const char16_t*> {
  }
 };
 template <>
-class UniversalTersePrinter<char16_t*>
+class [[nodiscard]] UniversalTersePrinter<char16_t*>
    : public UniversalTersePrinter<const char16_t*> {};
 template <>
-class UniversalTersePrinter<const char32_t*> {
+class [[nodiscard]] UniversalTersePrinter<const char32_t*> {
 public:
  static void Print(const char32_t* str, ::std::ostream* os) {
    if (str == nullptr) {
@ -1046,12 +1158,12 @@ class UniversalTersePrinter<const char32_t*> {
  }
 };
 template <>
-class UniversalTersePrinter<char32_t*>
+class [[nodiscard]] UniversalTersePrinter<char32_t*>
    : public UniversalTersePrinter<const char32_t*> {};
 #if GTEST_HAS_STD_WSTRING
 template <>
-class UniversalTersePrinter<const wchar_t*> {
+class [[nodiscard]] UniversalTersePrinter<const wchar_t*> {
 public:
  static void Print(const wchar_t* str, ::std::ostream* os) {
    if (str == nullptr) {
@ -1064,7 +1176,7 @@ class UniversalTersePrinter<const wchar_t*> {
 #endif
 template <>
-class UniversalTersePrinter<wchar_t*> {
+class [[nodiscard]] UniversalTersePrinter<wchar_t*> {
 public:
  static void Print(wchar_t* str, ::std::ostream* os) {
    UniversalTersePrinter<const wchar_t*>::Print(str, os);
@ -1113,7 +1225,7 @@ template <typename Tuple>
 Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
  Strings result;
  TersePrintPrefixToStrings(
-      value, std::integral_constant<size_t, std::tuple_size<Tuple>::value>(),
+      value, std::integral_constant<size_t, std::tuple_size_v<Tuple>>(),
      &result);
  return result;
 }
--- a/test/googletest/googletest/include/gtest/gtest-spi.h
+++ b/test/googletest/googletest/include/gtest/gtest-spi.h
@ -51,7 +51,7 @@ namespace testing {
 // generated in the same thread that created this object or it can intercept
 // all generated failures. The scope of this mock object can be controlled with
 // the second argument to the two arguments constructor.
-class GTEST_API_ ScopedFakeTestPartResultReporter
+class GTEST_API_ [[nodiscard]] ScopedFakeTestPartResultReporter
    : public TestPartResultReporterInterface {
 public:
  // The two possible mocking modes of this object.
@ -100,7 +100,7 @@ namespace internal {
 // TestPartResultArray contains exactly one failure that has the given
 // type and contains the given substring.  If that's not the case, a
 // non-fatal failure will be generated.
-class GTEST_API_ SingleFailureChecker {
+class GTEST_API_ [[nodiscard]] SingleFailureChecker {
 public:
  // The constructor remembers the arguments.
  SingleFailureChecker(const TestPartResultArray* results,
--- a/test/googletest/googletest/include/gtest/gtest-test-part.h
+++ b/test/googletest/googletest/include/gtest/gtest-test-part.h
@ -37,6 +37,7 @@
 #include <iosfwd>
 #include <ostream>
 #include <string>
 #include <string_view>
 #include <vector>
 #include "gtest/internal/gtest-internal.h"
@ -51,7 +52,7 @@ namespace testing {
 // assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()).
 //
 // Don't inherit from TestPartResult as its destructor is not virtual.
-class GTEST_API_ TestPartResult {
+class GTEST_API_ [[nodiscard]] TestPartResult {
 public:
  // The possible outcomes of a test part (i.e. an assertion or an
  // explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
@ -65,10 +66,10 @@ class GTEST_API_ TestPartResult {
  // C'tor.  TestPartResult does NOT have a default constructor.
  // Always use this constructor (with parameters) to create a
  // TestPartResult object.
-  TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
+  TestPartResult(Type a_type, std::string_view a_file_name, int a_line_number,
-                 const char* a_message)
+                 std::string_view a_message)
      : type_(a_type),
-        file_name_(a_file_name == nullptr ? "" : a_file_name),
+        file_name_(a_file_name),
        line_number_(a_line_number),
        summary_(ExtractSummary(a_message)),
        message_(a_message) {}
@ -112,7 +113,7 @@ class GTEST_API_ TestPartResult {
  // Gets the summary of the failure message by omitting the stack
  // trace in it.
-  static std::string ExtractSummary(const char* message);
+  static std::string ExtractSummary(std::string_view message);
  // The name of the source file where the test part took place, or
  // "" if the source file is unknown.
@ -131,9 +132,9 @@ std::ostream& operator<<(std::ostream& os, const TestPartResult& result);
 //
 // Don't inherit from TestPartResultArray as its destructor is not
 // virtual.
-class GTEST_API_ TestPartResultArray {
+class GTEST_API_ [[nodiscard]] TestPartResultArray {
 public:
-  TestPartResultArray() {}
+  TestPartResultArray() = default;
  // Appends the given TestPartResult to the array.
  void Append(const TestPartResult& result);
@ -152,9 +153,9 @@ class GTEST_API_ TestPartResultArray {
 };
 // This interface knows how to report a test part result.
-class GTEST_API_ TestPartResultReporterInterface {
+class GTEST_API_ [[nodiscard]] TestPartResultReporterInterface {
 public:
-  virtual ~TestPartResultReporterInterface() {}
+  virtual ~TestPartResultReporterInterface() = default;
  virtual void ReportTestPartResult(const TestPartResult& result) = 0;
 };
@ -167,7 +168,7 @@ namespace internal {
 // reported, it only delegates the reporting to the former result reporter.
 // The original result reporter is restored in the destructor.
 // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-class GTEST_API_ HasNewFatalFailureHelper
+class GTEST_API_ [[nodiscard]] HasNewFatalFailureHelper
    : public TestPartResultReporterInterface {
 public:
  HasNewFatalFailureHelper();
--- a/test/googletest/googletest/include/gtest/gtest-typed-test.h
+++ b/test/googletest/googletest/include/gtest/gtest-typed-test.h
@ -45,18 +45,18 @@
 // First, define a fixture class template.  It should be parameterized
 // by a type.  Remember to derive it from testing::Test.
 template <typename T>
-class FooTest : public testing::Test {
+class [[nodiscard]] FooTest : public testing::Test {
 public:
  ...
-  typedef std::list<T> List;
+  using List = ::std::list<T>;
  static T shared_;
  T value_;
 };
 // Next, associate a list of types with the test suite, which will be
-// repeated for each type in the list.  The typedef is necessary for
+// repeated for each type in the list.  The using-declaration is necessary for
 // the macro to parse correctly.
-typedef testing::Types<char, int, unsigned int> MyTypes;
+using MyTypes = ::testing::Types<char, int, unsigned int>;
 TYPED_TEST_SUITE(FooTest, MyTypes);
 // If the type list contains only one type, you can write that type
@ -123,7 +123,7 @@ TYPED_TEST(FooTest, HasPropertyA) { ... }
 // First, define a fixture class template.  It should be parameterized
 // by a type.  Remember to derive it from testing::Test.
 template <typename T>
-class FooTest : public testing::Test {
+class [[nodiscard]] FooTest : public testing::Test {
  ...
 };
@ -157,7 +157,7 @@ REGISTER_TYPED_TEST_SUITE_P(FooTest,
 // argument to the INSTANTIATE_* macro is a prefix that will be added
 // to the actual test suite name.  Remember to pick unique prefixes for
 // different instances.
-typedef testing::Types<char, int, unsigned int> MyTypes;
+using MyTypes = ::testing::Types<char, int, unsigned int>;
 INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
 // If the type list contains only one type, you can write that type
@ -205,8 +205,8 @@ INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
    typedef gtest_TypeParam_ TypeParam;                                       \
    void TestBody() override;                                                 \
  };                                                                          \
-  static bool gtest_##CaseName##_##TestName##_registered_                     \
+  [[maybe_unused]] static bool gtest_##CaseName##_##TestName##_registered_ =  \
-      GTEST_ATTRIBUTE_UNUSED_ = ::testing::internal::TypeParameterizedTest<   \
+      ::testing::internal::TypeParameterizedTest<                             \
          CaseName,                                                           \
          ::testing::internal::TemplateSel<GTEST_TEST_CLASS_NAME_(CaseName,   \
                                                                  TestName)>, \
@ -276,7 +276,7 @@ INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
    typedef gtest_TypeParam_ TypeParam;                       \
    void TestBody() override;                                 \
  };                                                          \
-  static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
+  [[maybe_unused]] static bool gtest_##TestName##_defined_ =  \
      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).AddTestName( \
          __FILE__, __LINE__, GTEST_STRINGIFY_(SuiteName),    \
          GTEST_STRINGIFY_(TestName));                        \
@ -290,8 +290,8 @@ INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
  namespace GTEST_SUITE_NAMESPACE_(SuiteName) {                             \
  typedef ::testing::internal::Templates<__VA_ARGS__> gtest_AllTests_;      \
  }                                                                         \
-  static const char* const GTEST_REGISTERED_TEST_NAMES_(                    \
+  [[maybe_unused]] static const char* const GTEST_REGISTERED_TEST_NAMES_(   \
-      SuiteName) GTEST_ATTRIBUTE_UNUSED_ =                                  \
+      SuiteName) =                                                          \
      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).VerifyRegisteredTestNames( \
          GTEST_STRINGIFY_(SuiteName), __FILE__, __LINE__, #__VA_ARGS__)
@ -306,7 +306,7 @@ INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
 #define INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, SuiteName, Types, ...)     \
  static_assert(sizeof(GTEST_STRINGIFY_(Prefix)) > 1,                     \
                "test-suit-prefix must not be empty");                    \
-  static bool gtest_##Prefix##_##SuiteName GTEST_ATTRIBUTE_UNUSED_ =      \
+  [[maybe_unused]] static bool gtest_##Prefix##_##SuiteName =             \
      ::testing::internal::TypeParameterizedTestSuite<                    \
          SuiteName, GTEST_SUITE_NAMESPACE_(SuiteName)::gtest_AllTests_,  \
          ::testing::internal::GenerateTypeList<Types>::type>::           \
--- a/test/googletest/googletest/include/gtest/gtest.h
+++ b/test/googletest/googletest/include/gtest/gtest.h
@ -51,26 +51,26 @@
 #include <cstddef>
 #include <cstdint>
 #include <iomanip>
 #include <limits>
 #include <memory>
 #include <ostream>
 #include <set>
 #include <sstream>
 #include <string>
 #include <string_view>
 #include <type_traits>
 #include <vector>
-#include "gtest/gtest-assertion-result.h"
+#include "gtest/gtest-assertion-result.h"  // IWYU pragma: export
-#include "gtest/gtest-death-test.h"
+#include "gtest/gtest-death-test.h"  // IWYU pragma: export
-#include "gtest/gtest-matchers.h"
+#include "gtest/gtest-matchers.h"  // IWYU pragma: export
-#include "gtest/gtest-message.h"
+#include "gtest/gtest-message.h"  // IWYU pragma: export
-#include "gtest/gtest-param-test.h"
+#include "gtest/gtest-param-test.h"  // IWYU pragma: export
-#include "gtest/gtest-printers.h"
+#include "gtest/gtest-printers.h"  // IWYU pragma: export
-#include "gtest/gtest-test-part.h"
+#include "gtest/gtest-test-part.h"  // IWYU pragma: export
-#include "gtest/gtest-typed-test.h"
+#include "gtest/gtest-typed-test.h"  // IWYU pragma: export
-#include "gtest/gtest_pred_impl.h"
+#include "gtest/gtest_pred_impl.h"  // IWYU pragma: export
-#include "gtest/gtest_prod.h"
+#include "gtest/gtest_prod.h"  // IWYU pragma: export
 #include "gtest/internal/gtest-internal.h"
 #include "gtest/internal/gtest-string.h"
@ -137,6 +137,10 @@ GTEST_DECLARE_int32_(repeat);
 // only torn down once, for the last.
 GTEST_DECLARE_bool_(recreate_environments_when_repeating);
 // Together these flags determine which tests are run if the test is sharded.
 GTEST_DECLARE_int32_(shard_index);
 GTEST_DECLARE_int32_(total_shards);
 // This flag controls whether Google Test includes Google Test internal
 // stack frames in failure stack traces.
 GTEST_DECLARE_bool_(show_internal_stack_frames);
@ -194,7 +198,7 @@ std::set<std::string>* GetIgnoredParameterizedTestSuites();
 // A base class that prevents subclasses from being copyable.
 // We do this instead of using '= delete' so as to avoid triggering warnings
 // inside user code regarding any of our declarations.
-class GTestNonCopyable {
+class [[nodiscard]] GTestNonCopyable {
 public:
  GTestNonCopyable() = default;
  GTestNonCopyable(const GTestNonCopyable&) = delete;
@ -207,15 +211,15 @@ class GTestNonCopyable {
 // The friend relationship of some of these classes is cyclic.
 // If we don't forward declare them the compiler might confuse the classes
 // in friendship clauses with same named classes on the scope.
-class Test;
+class [[nodiscard]] Test;
-class TestSuite;
+class [[nodiscard]] TestSuite;
 // Old API is still available but deprecated
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
 using TestCase = TestSuite;
 #endif
-class TestInfo;
+class [[nodiscard]] TestInfo;
-class UnitTest;
+class [[nodiscard]] UnitTest;
 // The abstract class that all tests inherit from.
 //
@ -240,7 +244,7 @@ class UnitTest;
 //   TEST_F(FooTest, Baz) { ... }
 //
 // Test is not copyable.
-class GTEST_API_ Test {
+class GTEST_API_ [[nodiscard]] Test {
 public:
  friend class TestInfo;
@ -367,7 +371,7 @@ typedef internal::TimeInMillis TimeInMillis;
 // output as a key/value string pair.
 //
 // Don't inherit from TestProperty as its destructor is not virtual.
-class TestProperty {
+class [[nodiscard]] TestProperty {
 public:
  // C'tor.  TestProperty does NOT have a default constructor.
  // Always use this constructor (with parameters) to create a
@ -397,7 +401,7 @@ class TestProperty {
 // the Test.
 //
 // TestResult is not copyable.
-class GTEST_API_ TestResult {
+class GTEST_API_ [[nodiscard]] TestResult {
 public:
  // Creates an empty TestResult.
  TestResult();
@ -531,7 +535,7 @@ class GTEST_API_ TestResult {
 // The constructor of TestInfo registers itself with the UnitTest
 // singleton such that the RUN_ALL_TESTS() macro knows which tests to
 // run.
-class GTEST_API_ TestInfo {
+class GTEST_API_ [[nodiscard]] TestInfo {
 public:
  // Destructs a TestInfo object.  This function is not virtual, so
  // don't inherit from TestInfo.
@ -551,14 +555,14 @@ class GTEST_API_ TestInfo {
  // Returns the name of the parameter type, or NULL if this is not a typed
  // or a type-parameterized test.
  const char* type_param() const {
-    if (type_param_.get() != nullptr) return type_param_->c_str();
+    if (type_param_ != nullptr) return type_param_->c_str();
    return nullptr;
  }
  // Returns the text representation of the value parameter, or NULL if this
  // is not a value-parameterized test.
  const char* value_param() const {
-    if (value_param_.get() != nullptr) return value_param_->c_str();
+    if (value_param_ != nullptr) return value_param_->c_str();
    return nullptr;
  }
@ -600,7 +604,7 @@ class GTEST_API_ TestInfo {
  const TestResult* result() const { return &result_; }
 private:
-#if GTEST_HAS_DEATH_TEST
+#ifdef GTEST_HAS_DEATH_TEST
  friend class internal::DefaultDeathTestFactory;
 #endif  // GTEST_HAS_DEATH_TEST
  friend class Test;
@ -608,7 +612,7 @@ class GTEST_API_ TestInfo {
  friend class internal::UnitTestImpl;
  friend class internal::StreamingListenerTest;
  friend TestInfo* internal::MakeAndRegisterTestInfo(
-      const char* test_suite_name, const char* name, const char* type_param,
+      std::string test_suite_name, const char* name, const char* type_param,
      const char* value_param, internal::CodeLocation code_location,
      internal::TypeId fixture_class_id, internal::SetUpTestSuiteFunc set_up_tc,
      internal::TearDownTestSuiteFunc tear_down_tc,
@ -616,7 +620,7 @@ class GTEST_API_ TestInfo {
  // Constructs a TestInfo object. The newly constructed instance assumes
  // ownership of the factory object.
-  TestInfo(const std::string& test_suite_name, const std::string& name,
+  TestInfo(std::string test_suite_name, std::string name,
           const char* a_type_param,   // NULL if not a type-parameterized test
           const char* a_value_param,  // NULL if not a value-parameterized test
           internal::CodeLocation a_code_location,
@ -670,7 +674,7 @@ class GTEST_API_ TestInfo {
 // A test suite, which consists of a vector of TestInfos.
 //
 // TestSuite is not copyable.
-class GTEST_API_ TestSuite {
+class GTEST_API_ [[nodiscard]] TestSuite {
 public:
  // Creates a TestSuite with the given name.
  //
@ -684,7 +688,7 @@ class GTEST_API_ TestSuite {
  //                 this is not a type-parameterized test.
  //   set_up_tc:    pointer to the function that sets up the test suite
  //   tear_down_tc: pointer to the function that tears down the test suite
-  TestSuite(const char* name, const char* a_type_param,
+  TestSuite(const std::string& name, const char* a_type_param,
            internal::SetUpTestSuiteFunc set_up_tc,
            internal::TearDownTestSuiteFunc tear_down_tc);
@ -697,7 +701,7 @@ class GTEST_API_ TestSuite {
  // Returns the name of the parameter type, or NULL if this is not a
  // type-parameterized test suite.
  const char* type_param() const {
-    if (type_param_.get() != nullptr) return type_param_->c_str();
+    if (type_param_ != nullptr) return type_param_->c_str();
    return nullptr;
  }
@ -891,10 +895,10 @@ class GTEST_API_ TestSuite {
 //      available.
 //   2. You cannot use ASSERT_* directly in a constructor or
 //      destructor.
-class Environment {
+class [[nodiscard]] Environment {
 public:
  // The d'tor is virtual as we need to subclass Environment.
-  virtual ~Environment() {}
+  virtual ~Environment() = default;
  // Override this to define how to set up the environment.
  virtual void SetUp() {}
@ -912,7 +916,7 @@ class Environment {
 #if GTEST_HAS_EXCEPTIONS
 // Exception which can be thrown from TestEventListener::OnTestPartResult.
-class GTEST_API_ AssertionException
+class GTEST_API_ [[nodiscard]] AssertionException
    : public internal::GoogleTestFailureException {
 public:
  explicit AssertionException(const TestPartResult& result)
@ -923,9 +927,9 @@ class GTEST_API_ AssertionException
 // The interface for tracing execution of tests. The methods are organized in
 // the order the corresponding events are fired.
-class TestEventListener {
+class [[nodiscard]] TestEventListener {
 public:
-  virtual ~TestEventListener() {}
+  virtual ~TestEventListener() = default;
  // Fired before any test activity starts.
  virtual void OnTestProgramStart(const UnitTest& unit_test) = 0;
@ -990,7 +994,7 @@ class TestEventListener {
 // the methods they override will not be caught during the build.  For
 // comments about each method please see the definition of TestEventListener
 // above.
-class EmptyTestEventListener : public TestEventListener {
+class [[nodiscard]] EmptyTestEventListener : public TestEventListener {
 public:
  void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
  void OnTestIterationStart(const UnitTest& /*unit_test*/,
@ -1020,7 +1024,7 @@ class EmptyTestEventListener : public TestEventListener {
 };
 // TestEventListeners lets users add listeners to track events in Google Test.
-class GTEST_API_ TestEventListeners {
+class GTEST_API_ [[nodiscard]] TestEventListeners {
 public:
  TestEventListeners();
  ~TestEventListeners();
@ -1055,6 +1059,10 @@ class GTEST_API_ TestEventListeners {
    return default_xml_generator_;
  }
  // Controls whether events will be forwarded by the repeater to the
  // listeners in the list.
  void SuppressEventForwarding(bool);
 private:
  friend class TestSuite;
  friend class TestInfo;
@ -1084,7 +1092,6 @@ class GTEST_API_ TestEventListeners {
  // Controls whether events will be forwarded by the repeater to the
  // listeners in the list.
  bool EventForwardingEnabled() const;
  void SuppressEventForwarding();
  // The actual list of listeners.
  internal::TestEventRepeater* repeater_;
@ -1108,7 +1115,7 @@ class GTEST_API_ TestEventListeners {
 //
 // This class is thread-safe as long as the methods are called
 // according to their specification.
-class GTEST_API_ UnitTest {
+class GTEST_API_ [[nodiscard]] UnitTest {
 public:
  // Gets the singleton UnitTest object.  The first time this method
  // is called, a UnitTest object is constructed and returned.
@ -1121,7 +1128,7 @@ class GTEST_API_ UnitTest {
  // This method can only be called from the main thread.
  //
  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-  int Run() GTEST_MUST_USE_RESULT_;
+  [[nodiscard]] int Run();
  // Returns the working directory when the first TEST() or TEST_F()
  // was executed.  The UnitTest object owns the string.
@ -1244,7 +1251,7 @@ class GTEST_API_ UnitTest {
  // eventually call this to report their results.  The user code
  // should use the assertion macros instead of calling this directly.
  void AddTestPartResult(TestPartResult::Type result_type,
-                         const char* file_name, int line_number,
+                         std::string_view file_name, int line_number,
                         const std::string& message,
                         const std::string& os_stack_trace)
      GTEST_LOCK_EXCLUDED_(mutex_);
@ -1260,6 +1267,20 @@ class GTEST_API_ UnitTest {
  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
  TestSuite* GetMutableTestSuite(int i);
  // Invokes OsStackTrackGetterInterface::UponLeavingGTest. UponLeavingGTest()
  // should be called immediately before Google Test calls user code. It saves
  // some information about the current stack that CurrentStackTrace() will use
  // to find and hide Google Test stack frames.
  void UponLeavingGTest();
  // Sets the TestSuite object for the test that's currently running.
  void set_current_test_suite(TestSuite* a_current_test_suite)
      GTEST_LOCK_EXCLUDED_(mutex_);
  // Sets the TestInfo object for the test that's currently running.
  void set_current_test_info(TestInfo* a_current_test_info)
      GTEST_LOCK_EXCLUDED_(mutex_);
  // Accessors for the implementation object.
  internal::UnitTestImpl* impl() { return impl_; }
  const internal::UnitTestImpl* impl() const { return impl_; }
@ -1268,6 +1289,8 @@ class GTEST_API_ UnitTest {
  // members of UnitTest.
  friend class ScopedTrace;
  friend class Test;
  friend class TestInfo;
  friend class TestSuite;
  friend class internal::AssertHelper;
  friend class internal::StreamingListenerTest;
  friend class internal::UnitTestRecordPropertyTestHelper;
@ -1380,7 +1403,7 @@ AssertionResult CmpHelperEQ(const char* lhs_expression,
  return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
 }
-class EqHelper {
+class [[nodiscard]] EqHelper {
 public:
  // This templatized version is for the general case.
  template <
@ -1571,12 +1594,12 @@ AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression,
  }
  ::std::stringstream lhs_ss;
-  lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+  lhs_ss.precision(std::numeric_limits<RawType>::digits10 + 2);
-         << lhs_value;
+  lhs_ss << lhs_value;
  ::std::stringstream rhs_ss;
-  rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+  rhs_ss.precision(std::numeric_limits<RawType>::digits10 + 2);
-         << rhs_value;
+  rhs_ss << rhs_value;
  return EqFailure(lhs_expression, rhs_expression,
                   StringStreamToString(&lhs_ss), StringStreamToString(&rhs_ss),
@ -1592,18 +1615,23 @@ GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
                                                double val1, double val2,
                                                double abs_error);
 using GoogleTest_NotSupported_OnFunctionReturningNonVoid = void;
 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
 // A class that enables one to stream messages to assertion macros
-class GTEST_API_ AssertHelper {
+class GTEST_API_ [[nodiscard]] AssertHelper {
 public:
  // Constructor.
  AssertHelper(TestPartResult::Type type, const char* file, int line,
               const char* message);
  AssertHelper(TestPartResult::Type type, std::string_view file, int line,
               std::string_view message);
  ~AssertHelper();
  // Message assignment is a semantic trick to enable assertion
  // streaming; see the GTEST_MESSAGE_ macro below.
-  void operator=(const Message& message) const;
+  GoogleTest_NotSupported_OnFunctionReturningNonVoid operator=(
      const Message& message) const;
 private:
  // We put our data in a struct so that the size of the AssertHelper class can
@ -1611,12 +1639,12 @@ class GTEST_API_ AssertHelper {
  // re-using stack space even for temporary variables, so every EXPECT_EQ
  // reserves stack space for another AssertHelper.
  struct AssertHelperData {
-    AssertHelperData(TestPartResult::Type t, const char* srcfile, int line_num,
+    AssertHelperData(TestPartResult::Type t, std::string_view srcfile,
-                     const char* msg)
+                     int line_num, std::string_view msg)
        : type(t), file(srcfile), line(line_num), message(msg) {}
    TestPartResult::Type const type;
-    const char* const file;
+    const std::string_view file;
    int const line;
    std::string const message;
@ -1668,14 +1696,14 @@ class GTEST_API_ AssertHelper {
 // INSTANTIATE_TEST_SUITE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));
 template <typename T>
-class WithParamInterface {
+class [[nodiscard]] WithParamInterface {
 public:
  typedef T ParamType;
-  virtual ~WithParamInterface() {}
+  virtual ~WithParamInterface() = default;
  // The current parameter value. Is also available in the test fixture's
  // constructor.
-  static const ParamType& GetParam() {
+  [[nodiscard]] static const ParamType& GetParam() {
    GTEST_CHECK_(parameter_ != nullptr)
        << "GetParam() can only be called inside a value-parameterized test "
        << "-- did you intend to write TEST_P instead of TEST_F?";
@ -1702,7 +1730,8 @@ const T* WithParamInterface<T>::parameter_ = nullptr;
 // WithParamInterface, and can just inherit from ::testing::TestWithParam.
 template <typename T>
-class TestWithParam : public Test, public WithParamInterface<T> {};
+class [[nodiscard]] TestWithParam : public Test,
                                    public WithParamInterface<T> {};
 // Macros for indicating success/failure in test code.
@ -1747,8 +1776,9 @@ class TestWithParam : public Test, public WithParamInterface<T> {};
 // Define this macro to 1 to omit the definition of FAIL(), which is a
 // generic name and clashes with some other libraries.
-#if !GTEST_DONT_DEFINE_FAIL
+#if !(defined(GTEST_DONT_DEFINE_FAIL) && GTEST_DONT_DEFINE_FAIL)
 #define FAIL() GTEST_FAIL()
 #define FAIL_AT(file, line) GTEST_FAIL_AT(file, line)
 #endif
 // Generates a success with a generic message.
@ -1756,7 +1786,7 @@ class TestWithParam : public Test, public WithParamInterface<T> {};
 // Define this macro to 1 to omit the definition of SUCCEED(), which
 // is a generic name and clashes with some other libraries.
-#if !GTEST_DONT_DEFINE_SUCCEED
+#if !(defined(GTEST_DONT_DEFINE_SUCCEED) && GTEST_DONT_DEFINE_SUCCEED)
 #define SUCCEED() GTEST_SUCCEED()
 #endif
@ -1789,30 +1819,29 @@ class TestWithParam : public Test, public WithParamInterface<T> {};
  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
                      GTEST_NONFATAL_FAILURE_)
 #define GTEST_EXPECT_FALSE(condition)                     \
-  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
+  GTEST_TEST_BOOLEAN_(condition, #condition, true, false, \
                      GTEST_NONFATAL_FAILURE_)
 #define GTEST_ASSERT_TRUE(condition) \
  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, GTEST_FATAL_FAILURE_)
 #define GTEST_ASSERT_FALSE(condition) \
-  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
+  GTEST_TEST_BOOLEAN_(condition, #condition, true, false, GTEST_FATAL_FAILURE_)
                      GTEST_FATAL_FAILURE_)
 // Define these macros to 1 to omit the definition of the corresponding
 // EXPECT or ASSERT, which clashes with some users' own code.
-#if !GTEST_DONT_DEFINE_EXPECT_TRUE
+#if !(defined(GTEST_DONT_DEFINE_EXPECT_TRUE) && GTEST_DONT_DEFINE_EXPECT_TRUE)
 #define EXPECT_TRUE(condition) GTEST_EXPECT_TRUE(condition)
 #endif
-#if !GTEST_DONT_DEFINE_EXPECT_FALSE
+#if !(defined(GTEST_DONT_DEFINE_EXPECT_FALSE) && GTEST_DONT_DEFINE_EXPECT_FALSE)
 #define EXPECT_FALSE(condition) GTEST_EXPECT_FALSE(condition)
 #endif
-#if !GTEST_DONT_DEFINE_ASSERT_TRUE
+#if !(defined(GTEST_DONT_DEFINE_ASSERT_TRUE) && GTEST_DONT_DEFINE_ASSERT_TRUE)
 #define ASSERT_TRUE(condition) GTEST_ASSERT_TRUE(condition)
 #endif
-#if !GTEST_DONT_DEFINE_ASSERT_FALSE
+#if !(defined(GTEST_DONT_DEFINE_ASSERT_FALSE) && GTEST_DONT_DEFINE_ASSERT_FALSE)
 #define ASSERT_FALSE(condition) GTEST_ASSERT_FALSE(condition)
 #endif
@ -1891,27 +1920,27 @@ class TestWithParam : public Test, public WithParamInterface<T> {};
 // Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of
 // ASSERT_XY(), which clashes with some users' own code.
-#if !GTEST_DONT_DEFINE_ASSERT_EQ
+#if !(defined(GTEST_DONT_DEFINE_ASSERT_EQ) && GTEST_DONT_DEFINE_ASSERT_EQ)
 #define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
 #endif
-#if !GTEST_DONT_DEFINE_ASSERT_NE
+#if !(defined(GTEST_DONT_DEFINE_ASSERT_NE) && GTEST_DONT_DEFINE_ASSERT_NE)
 #define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
 #endif
-#if !GTEST_DONT_DEFINE_ASSERT_LE
+#if !(defined(GTEST_DONT_DEFINE_ASSERT_LE) && GTEST_DONT_DEFINE_ASSERT_LE)
 #define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
 #endif
-#if !GTEST_DONT_DEFINE_ASSERT_LT
+#if !(defined(GTEST_DONT_DEFINE_ASSERT_LT) && GTEST_DONT_DEFINE_ASSERT_LT)
 #define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
 #endif
-#if !GTEST_DONT_DEFINE_ASSERT_GE
+#if !(defined(GTEST_DONT_DEFINE_ASSERT_GE) && GTEST_DONT_DEFINE_ASSERT_GE)
 #define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
 #endif
-#if !GTEST_DONT_DEFINE_ASSERT_GT
+#if !(defined(GTEST_DONT_DEFINE_ASSERT_GT) && GTEST_DONT_DEFINE_ASSERT_GT)
 #define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
 #endif
@ -1999,7 +2028,7 @@ GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2,
 GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
                                    double val1, double val2);
-#if GTEST_OS_WINDOWS
+#ifdef GTEST_OS_WINDOWS
 // Macros that test for HRESULT failure and success, these are only useful
 // on Windows, and rely on Windows SDK macros and APIs to compile.
@ -2049,7 +2078,7 @@ GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
 // Example:
 //   testing::ScopedTrace trace("file.cc", 123, "message");
 //
-class GTEST_API_ ScopedTrace {
+class GTEST_API_ [[nodiscard]] ScopedTrace {
 public:
  // The c'tor pushes the given source file location and message onto
  // a trace stack maintained by Google Test.
@ -2099,7 +2128,7 @@ class GTEST_API_ ScopedTrace {
 // Therefore, a SCOPED_TRACE() would (correctly) only affect the
 // assertions in its own thread.
 #define SCOPED_TRACE(message)                                               \
-  ::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)( \
+  const ::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)( \
      __FILE__, __LINE__, (message))
 // Compile-time assertion for type equality.
@ -2134,7 +2163,7 @@ class GTEST_API_ ScopedTrace {
 // to cause a compiler error.
 template <typename T1, typename T2>
 constexpr bool StaticAssertTypeEq() noexcept {
-  static_assert(std::is_same<T1, T2>::value, "T1 and T2 are not the same type");
+  static_assert(std::is_same_v<T1, T2>, "T1 and T2 are not the same type");
  return true;
 }
@ -2169,7 +2198,7 @@ constexpr bool StaticAssertTypeEq() noexcept {
 // Define this macro to 1 to omit the definition of TEST(), which
 // is a generic name and clashes with some other libraries.
-#if !GTEST_DONT_DEFINE_TEST
+#if !(defined(GTEST_DONT_DEFINE_TEST) && GTEST_DONT_DEFINE_TEST)
 #define TEST(test_suite_name, test_name) GTEST_TEST(test_suite_name, test_name)
 #endif
@ -2201,7 +2230,7 @@ constexpr bool StaticAssertTypeEq() noexcept {
 #define GTEST_TEST_F(test_fixture, test_name)        \
  GTEST_TEST_(test_fixture, test_name, test_fixture, \
              ::testing::internal::GetTypeId<test_fixture>())
-#if !GTEST_DONT_DEFINE_TEST_F
+#if !(defined(GTEST_DONT_DEFINE_TEST_F) && GTEST_DONT_DEFINE_TEST_F)
 #define TEST_F(test_fixture, test_name) GTEST_TEST_F(test_fixture, test_name)
 #endif
@ -2280,7 +2309,7 @@ template <int&... ExplicitParameterBarrier, typename Factory>
 TestInfo* 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) {
-  using TestT = typename std::remove_pointer<decltype(factory())>::type;
+  using TestT = std::remove_pointer_t<decltype(factory())>;
  class FactoryImpl : public internal::TestFactoryBase {
   public:
@ -2305,11 +2334,12 @@ TestInfo* RegisterTest(const char* test_suite_name, const char* test_name,
 // tests are successful, or 1 otherwise.
 //
 // RUN_ALL_TESTS() should be invoked after the command line has been
-// parsed by InitGoogleTest().
+// parsed by InitGoogleTest(). RUN_ALL_TESTS will tear down and delete any
 // installed environments and should only be called once per binary.
 //
 // This function was formerly a macro; thus, it is in the global
 // namespace and has an all-caps name.
-int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
+[[nodiscard]] int RUN_ALL_TESTS();
 inline int RUN_ALL_TESTS() { return ::testing::UnitTest::GetInstance()->Run(); }
--- a/test/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
+++ b/test/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
@ -43,21 +43,47 @@
 #include <memory>
 #include <string>
 #include <string_view>
 #include "gtest/gtest-matchers.h"
 #include "gtest/internal/gtest-internal.h"
 #include "gtest/internal/gtest-port.h"
 GTEST_DECLARE_string_(internal_run_death_test);
 namespace testing {
 namespace internal {
-// Names of the flags (needed for parsing Google Test flags).
+// Name of the flag (needed for parsing Google Test flag).
 const char kDeathTestStyleFlag[] = "death_test_style";
 const char kDeathTestUseFork[] = "death_test_use_fork";
 const char kInternalRunDeathTestFlag[] = "internal_run_death_test";
-#if GTEST_HAS_DEATH_TEST
+// A string passed to EXPECT_DEATH (etc.) is caught by one of these overloads
 // and interpreted as a regex (rather than an Eq matcher) for legacy
 // compatibility.
 inline Matcher<const ::std::string&> MakeDeathTestMatcher(
    ::testing::internal::RE regex) {
  return ContainsRegex(regex.pattern());
 }
 inline Matcher<const ::std::string&> MakeDeathTestMatcher(
    std::string_view regex) {
  return ContainsRegex(regex);
 }
 inline Matcher<const ::std::string&> MakeDeathTestMatcher(const char* regex) {
  return ContainsRegex(regex);
 }
 inline Matcher<const ::std::string&> MakeDeathTestMatcher(
    const ::std::string& regex) {
  return ContainsRegex(regex);
 }
 // If a Matcher<const ::std::string&> is passed to EXPECT_DEATH (etc.), it's
 // used directly.
 inline Matcher<const ::std::string&> MakeDeathTestMatcher(
    Matcher<const ::std::string&> matcher) {
  return matcher;
 }
 #ifdef GTEST_HAS_DEATH_TEST
 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
 /* class A needs to have dll-interface to be used by clients of class B */)
@ -73,9 +99,9 @@ GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
 //
 // exit status:  The integer exit information in the format specified
 //               by wait(2)
-// exit code:    The integer code passed to exit(3), _exit(2), or
+// exit code:    The integer code passed to exit(3), _Exit(2), or
 //               returned from main()
-class GTEST_API_ DeathTest {
+class GTEST_API_ [[nodiscard]] DeathTest {
 public:
  // Create returns false if there was an error determining the
  // appropriate action to take for the current death test; for example,
@ -88,7 +114,7 @@ class GTEST_API_ DeathTest {
  static bool Create(const char* statement, Matcher<const std::string&> matcher,
                     const char* file, int line, DeathTest** test);
  DeathTest();
-  virtual ~DeathTest() {}
+  virtual ~DeathTest() = default;
  // A helper class that aborts a death test when it's deleted.
  class ReturnSentinel {
@ -151,16 +177,16 @@ class GTEST_API_ DeathTest {
 GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
 // Factory interface for death tests.  May be mocked out for testing.
-class DeathTestFactory {
+class [[nodiscard]] DeathTestFactory {
 public:
-  virtual ~DeathTestFactory() {}
+  virtual ~DeathTestFactory() = default;
  virtual bool Create(const char* statement,
                      Matcher<const std::string&> matcher, const char* file,
                      int line, DeathTest** test) = 0;
 };
 // A concrete DeathTestFactory implementation for normal use.
-class DefaultDeathTestFactory : public DeathTestFactory {
+class [[nodiscard]] DefaultDeathTestFactory : public DeathTestFactory {
 public:
  bool Create(const char* statement, Matcher<const std::string&> matcher,
              const char* file, int line, DeathTest** test) override;
@ -170,28 +196,6 @@ class DefaultDeathTestFactory : public DeathTestFactory {
 // by a signal, or exited normally with a nonzero exit code.
 GTEST_API_ bool ExitedUnsuccessfully(int exit_status);
 // A string passed to EXPECT_DEATH (etc.) is caught by one of these overloads
 // and interpreted as a regex (rather than an Eq matcher) for legacy
 // compatibility.
 inline Matcher<const ::std::string&> MakeDeathTestMatcher(
    ::testing::internal::RE regex) {
  return ContainsRegex(regex.pattern());
 }
 inline Matcher<const ::std::string&> MakeDeathTestMatcher(const char* regex) {
  return ContainsRegex(regex);
 }
 inline Matcher<const ::std::string&> MakeDeathTestMatcher(
    const ::std::string& regex) {
  return ContainsRegex(regex);
 }
 // If a Matcher<const ::std::string&> is passed to EXPECT_DEATH (etc.), it's
 // used directly.
 inline Matcher<const ::std::string&> MakeDeathTestMatcher(
    Matcher<const ::std::string&> matcher) {
  return matcher;
 }
 // Traps C++ exceptions escaping statement and reports them as test
 // failures. Note that trapping SEH exceptions is not implemented here.
 #if GTEST_HAS_EXCEPTIONS
@ -230,7 +234,8 @@ inline Matcher<const ::std::string&> MakeDeathTestMatcher(
      goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);                        \
    }                                                                          \
    if (gtest_dt != nullptr) {                                                 \
-      std::unique_ptr< ::testing::internal::DeathTest> gtest_dt_ptr(gtest_dt); \
+      const std::unique_ptr< ::testing::internal::DeathTest> gtest_dt_ptr(     \
          gtest_dt);                                                           \
      switch (gtest_dt->AssumeRole()) {                                        \
        case ::testing::internal::DeathTest::OVERSEE_TEST:                     \
          if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) {                \
@ -262,14 +267,14 @@ inline Matcher<const ::std::string&> MakeDeathTestMatcher(
  if (::testing::internal::AlwaysTrue()) {                             \
    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);         \
  } else if (!::testing::internal::AlwaysTrue()) {                     \
-    ::testing::internal::MakeDeathTestMatcher(regex_or_matcher); \
+    (void)::testing::internal::MakeDeathTestMatcher(regex_or_matcher); \
  } else                                                               \
    ::testing::Message()
 // A class representing the parsed contents of the
 // --gtest_internal_run_death_test flag, as it existed when
 // RUN_ALL_TESTS was called.
-class InternalRunDeathTestFlag {
+class [[nodiscard]] InternalRunDeathTestFlag {
 public:
  InternalRunDeathTestFlag(const std::string& a_file, int a_line, int an_index,
                           int a_write_fd)
--- a/test/googletest/googletest/include/gtest/internal/gtest-filepath.h
+++ b/test/googletest/googletest/include/gtest/internal/gtest-filepath.h
@ -43,6 +43,7 @@
 #define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
 #include <string>
 #include <utility>
 #include "gtest/internal/gtest-port.h"
 #include "gtest/internal/gtest-string.h"
@ -66,12 +67,13 @@ namespace internal {
 // Names are NOT checked for syntax correctness -- no checking for illegal
 // characters, malformed paths, etc.
-class GTEST_API_ FilePath {
+class GTEST_API_ [[nodiscard]] FilePath {
 public:
  FilePath() : pathname_("") {}
  FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) {}
  FilePath(FilePath&& rhs) noexcept : pathname_(std::move(rhs.pathname_)) {}
-  explicit FilePath(const std::string& pathname) : pathname_(pathname) {
+  explicit FilePath(std::string pathname) : pathname_(std::move(pathname)) {
    Normalize();
  }
@ -79,6 +81,10 @@ class GTEST_API_ FilePath {
    Set(rhs);
    return *this;
  }
  FilePath& operator=(FilePath&& rhs) noexcept {
    pathname_ = std::move(rhs.pathname_);
    return *this;
  }
  void Set(const FilePath& rhs) { pathname_ = rhs.pathname_; }
--- a/test/googletest/googletest/include/gtest/internal/gtest-internal.h
+++ b/test/googletest/googletest/include/gtest/internal/gtest-internal.h
@ -41,7 +41,7 @@
 #include "gtest/internal/gtest-port.h"
-#if GTEST_OS_LINUX
+#ifdef GTEST_OS_LINUX
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/wait.h>
@ -58,7 +58,6 @@
 #include <cstdint>
 #include <functional>
 #include <iomanip>
 #include <limits>
 #include <map>
 #include <set>
@ -79,7 +78,7 @@
 //
 // will result in the token foo__LINE__, instead of foo followed by
 // the current line number.  For more details, see
-// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
+// https://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
 #define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
 #define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo##bar
@ -96,7 +95,13 @@
 #define GTEST_STRINGIFY_(...) GTEST_STRINGIFY_HELPER_(__VA_ARGS__, )
 namespace proto2 {
-class MessageLite;
+class [[nodiscard]] MessageLite;
 // Dummy forward declaration of `DynamicCastMessage`. Does not match any actual
 // overloads of `DynamicCastMessage`, but can be used to assist name resolution
 // in templates.
 template <typename T>
 T DynamicCastMessage() = delete;
 }
 namespace testing {
@ -116,15 +121,15 @@ template <typename T>
 namespace internal {
 struct TraceInfo;    // Information about a trace point.
-class TestInfoImpl;  // Opaque implementation of TestInfo
+class [[nodiscard]] TestInfoImpl;  // Opaque implementation of TestInfo
-class UnitTestImpl;  // Opaque implementation of UnitTest
+class [[nodiscard]] UnitTestImpl;  // Opaque implementation of UnitTest
 // The text used in failure messages to indicate the start of the
 // stack trace.
 GTEST_API_ extern const char kStackTraceMarker[];
 // An IgnoredValue object can be implicitly constructed from ANY value.
-class IgnoredValue {
+class [[nodiscard]] IgnoredValue {
  struct Sink {};
 public:
@ -156,7 +161,8 @@ GTEST_DISABLE_MSC_WARNINGS_PUSH_(
 // errors presumably detectable only at run time.  Since
 // std::runtime_error inherits from std::exception, many testing
 // frameworks know how to extract and print the message inside it.
-class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
+class GTEST_API_ [[nodiscard]] GoogleTestFailureException
    : public ::std::runtime_error {
 public:
  explicit GoogleTestFailureException(const TestPartResult& failure);
 };
@ -170,7 +176,7 @@ namespace edit_distance {
 // All edits cost the same, with replace having lower priority than
 // add/remove.
 // Simple implementation of the Wagner-Fischer algorithm.
-// See http://en.wikipedia.org/wiki/Wagner-Fischer_algorithm
+// See https://en.wikipedia.org/wiki/Wagner-Fischer_algorithm
 enum EditType { kMatch, kAdd, kRemove, kReplace };
 GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
    const std::vector<size_t>& left, const std::vector<size_t>& right);
@ -237,13 +243,13 @@ GTEST_API_ std::string GetBoolAssertionFailureMessage(
 //   For double, there are 11 exponent bits and 52 fraction bits.
 //
 //   More details can be found at
-//   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
+//   https://en.wikipedia.org/wiki/IEEE_floating-point_standard.
 //
 // Template parameter:
 //
 //   RawType: the raw floating-point type (either float or double)
 template <typename RawType>
-class FloatingPoint {
+class [[nodiscard]] FloatingPoint {
 public:
  // Defines the unsigned integer type that has the same size as the
  // floating point number.
@ -282,7 +288,7 @@ class FloatingPoint {
  // bits.  Therefore, 4 should be enough for ordinary use.
  //
  // See the following article for more details on ULP:
-  // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+  // https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
  static const uint32_t kMaxUlps = 4;
  // Constructs a FloatingPoint from a raw floating-point number.
@ -291,17 +297,17 @@ class FloatingPoint {
  // around may change its bits, although the new value is guaranteed
  // to be also a NAN.  Therefore, don't expect this constructor to
  // preserve the bits in x when x is a NAN.
-  explicit FloatingPoint(const RawType& x) { u_.value_ = x; }
+  explicit FloatingPoint(RawType x) { memcpy(&bits_, &x, sizeof(x)); }
  // Static methods
  // Reinterprets a bit pattern as a floating-point number.
  //
  // This function is needed to test the AlmostEquals() method.
-  static RawType ReinterpretBits(const Bits bits) {
+  static RawType ReinterpretBits(Bits bits) {
-    FloatingPoint fp(0);
+    RawType fp;
-    fp.u_.bits_ = bits;
+    memcpy(&fp, &bits, sizeof(fp));
-    return fp.u_.value_;
+    return fp;
  }
  // Returns the floating-point number that represent positive infinity.
@ -310,16 +316,16 @@ class FloatingPoint {
  // Non-static methods
  // Returns the bits that represents this number.
-  const Bits& bits() const { return u_.bits_; }
+  const Bits& bits() const { return bits_; }
  // Returns the exponent bits of this number.
-  Bits exponent_bits() const { return kExponentBitMask & u_.bits_; }
+  Bits exponent_bits() const { return kExponentBitMask & bits_; }
  // Returns the fraction bits of this number.
-  Bits fraction_bits() const { return kFractionBitMask & u_.bits_; }
+  Bits fraction_bits() const { return kFractionBitMask & bits_; }
  // Returns the sign bit of this number.
-  Bits sign_bit() const { return kSignBitMask & u_.bits_; }
+  Bits sign_bit() const { return kSignBitMask & bits_; }
  // Returns true if and only if this is NAN (not a number).
  bool is_nan() const {
@ -333,23 +339,16 @@ class FloatingPoint {
  //
  //   - returns false if either number is (or both are) NAN.
  //   - treats really large numbers as almost equal to infinity.
-  //   - thinks +0.0 and -0.0 are 0 DLP's apart.
+  //   - thinks +0.0 and -0.0 are 0 ULP's apart.
  bool AlmostEquals(const FloatingPoint& rhs) const {
    // The IEEE standard says that any comparison operation involving
    // a NAN must return false.
    if (is_nan() || rhs.is_nan()) return false;
-    return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_) <=
+    return DistanceBetweenSignAndMagnitudeNumbers(bits_, rhs.bits_) <= kMaxUlps;
           kMaxUlps;
  }
 private:
  // The data type used to store the actual floating-point number.
  union FloatingPointUnion {
    RawType value_;  // The raw floating-point number.
    Bits bits_;      // The bits that represent the number.
  };
  // Converts an integer from the sign-and-magnitude representation to
  // the biased representation.  More precisely, let N be 2 to the
  // power of (kBitCount - 1), an integer x is represented by the
@ -363,9 +362,9 @@ class FloatingPoint {
  //   N - 1  (the biggest number representable using
  //          sign-and-magnitude) is represented by 2N - 1.
  //
-  // Read http://en.wikipedia.org/wiki/Signed_number_representations
+  // Read https://en.wikipedia.org/wiki/Signed_number_representations
  // for more details on signed number representations.
-  static Bits SignAndMagnitudeToBiased(const Bits& sam) {
+  static Bits SignAndMagnitudeToBiased(Bits sam) {
    if (kSignBitMask & sam) {
      // sam represents a negative number.
      return ~sam + 1;
@ -377,14 +376,13 @@ class FloatingPoint {
  // Given two numbers in the sign-and-magnitude representation,
  // returns the distance between them as an unsigned number.
-  static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits& sam1,
+  static Bits DistanceBetweenSignAndMagnitudeNumbers(Bits sam1, Bits sam2) {
                                                     const Bits& sam2) {
    const Bits biased1 = SignAndMagnitudeToBiased(sam1);
    const Bits biased2 = SignAndMagnitudeToBiased(sam2);
    return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
  }
-  FloatingPointUnion u_;
+  Bits bits_;  // The bits that represent the number.
 };
 // Typedefs the instances of the FloatingPoint template class that we
@ -401,7 +399,7 @@ typedef FloatingPoint<double> Double;
 typedef const void* TypeId;
 template <typename T>
-class TypeIdHelper {
+class [[nodiscard]] TypeIdHelper {
 public:
  // dummy_ must not have a const type.  Otherwise an overly eager
  // compiler (e.g. MSVC 7.1 & 8.0) may try to merge
@ -433,9 +431,9 @@ GTEST_API_ TypeId GetTestTypeId();
 // Defines the abstract factory interface that creates instances
 // of a Test object.
-class TestFactoryBase {
+class [[nodiscard]] TestFactoryBase {
 public:
-  virtual ~TestFactoryBase() {}
+  virtual ~TestFactoryBase() = default;
  // Creates a test instance to run. The instance is both created and destroyed
  // within TestInfoImpl::Run()
@ -452,12 +450,12 @@ class TestFactoryBase {
 // This class provides implementation of TestFactoryBase interface.
 // It is used in TEST and TEST_F macros.
 template <class TestClass>
-class TestFactoryImpl : public TestFactoryBase {
+class [[nodiscard]] TestFactoryImpl : public TestFactoryBase {
 public:
  Test* CreateTest() override { return new TestClass; }
 };
-#if GTEST_OS_WINDOWS
+#ifdef GTEST_OS_WINDOWS
 // Predicate-formatters for implementing the HRESULT checking macros
 // {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}
@ -475,8 +473,8 @@ using SetUpTestSuiteFunc = void (*)();
 using TearDownTestSuiteFunc = void (*)();
 struct CodeLocation {
-  CodeLocation(const std::string& a_file, int a_line)
+  CodeLocation(std::string a_file, int a_line)
-      : file(a_file), line(a_line) {}
+      : file(std::move(a_file)), line(a_line) {}
  std::string file;
  int line;
@ -556,7 +554,7 @@ struct SuiteApiResolver : T {
 //   type_param:       the name of the test's type parameter, or NULL if
 //                     this is not a typed or a type-parameterized test.
 //   value_param:      text representation of the test's value parameter,
-//                     or NULL if this is not a type-parameterized test.
+//                     or NULL if this is not a value-parameterized test.
 //   code_location:    code location where the test is defined
 //   fixture_class_id: ID of the test fixture class
 //   set_up_tc:        pointer to the function that sets up the test suite
@ -565,7 +563,7 @@ struct SuiteApiResolver : T {
 //                     The newly created TestInfo instance will assume
 //                     ownership of the factory object.
 GTEST_API_ TestInfo* MakeAndRegisterTestInfo(
-    const char* test_suite_name, const char* name, const char* type_param,
+    std::string test_suite_name, const char* name, const char* type_param,
    const char* value_param, CodeLocation code_location,
    TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory);
@ -579,7 +577,7 @@ GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
 /* class A needs to have dll-interface to be used by clients of class B */)
 // State of the definition of a type-parameterized test suite.
-class GTEST_API_ TypedTestSuitePState {
+class GTEST_API_ [[nodiscard]] TypedTestSuitePState {
 public:
  TypedTestSuitePState() : registered_(false) {}
@ -596,8 +594,7 @@ class GTEST_API_ TypedTestSuitePState {
      fflush(stderr);
      posix::Abort();
    }
-    registered_tests_.insert(
+    registered_tests_.emplace(test_name, CodeLocation(file, line));
        ::std::make_pair(test_name, CodeLocation(file, line)));
    return true;
  }
@ -695,13 +692,13 @@ std::vector<std::string> GenerateNames() {
 // Implementation note: The GTEST_TEMPLATE_ macro declares a template
 // template parameter.  It's defined in gtest-type-util.h.
 template <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types>
-class TypeParameterizedTest {
+class [[nodiscard]] TypeParameterizedTest {
 public:
  // 'index' is the index of the test in the type list 'Types'
  // specified in INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, TestSuite,
  // Types).  Valid values for 'index' are [0, N - 1] where N is the
  // length of Types.
-  static bool Register(const char* prefix, const CodeLocation& code_location,
+  static bool Register(const char* prefix, CodeLocation code_location,
                       const char* case_name, const char* test_names, int index,
                       const std::vector<std::string>& type_names =
                           GenerateNames<DefaultNameGenerator, Types>()) {
@ -713,8 +710,7 @@ class TypeParameterizedTest {
    // list.
    MakeAndRegisterTestInfo(
        (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name +
-         "/" + type_names[static_cast<size_t>(index)])
+         "/" + type_names[static_cast<size_t>(index)]),
            .c_str(),
        StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(),
        GetTypeName<Type>().c_str(),
        nullptr,  // No value parameter.
@ -726,21 +722,17 @@ class TypeParameterizedTest {
        new TestFactoryImpl<TestClass>);
    // Next, recurses (at compile time) with the tail of the type list.
-    return TypeParameterizedTest<Fixture, TestSel,
+    return TypeParameterizedTest<Fixture, TestSel, typename Types::Tail>::
-                                 typename Types::Tail>::Register(prefix,
+        Register(prefix, std::move(code_location), case_name, test_names,
-                                                                 code_location,
+                 index + 1, type_names);
                                                                 case_name,
                                                                 test_names,
                                                                 index + 1,
                                                                 type_names);
  }
 };
 // The base case for the compile time recursion.
 template <GTEST_TEMPLATE_ Fixture, class TestSel>
-class TypeParameterizedTest<Fixture, TestSel, internal::None> {
+class [[nodiscard]] TypeParameterizedTest<Fixture, TestSel, internal::None> {
 public:
-  static bool Register(const char* /*prefix*/, const CodeLocation&,
+  static bool Register(const char* /*prefix*/, CodeLocation,
                       const char* /*case_name*/, const char* /*test_names*/,
                       int /*index*/,
                       const std::vector<std::string>& =
@ -759,7 +751,7 @@ GTEST_API_ void RegisterTypeParameterizedTestSuiteInstantiation(
 // Test.  The return value is insignificant - we just need to return
 // something such that we can call this function in a namespace scope.
 template <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types>
-class TypeParameterizedTestSuite {
+class [[nodiscard]] TypeParameterizedTestSuite {
 public:
  static bool Register(const char* prefix, CodeLocation code_location,
                       const TypedTestSuitePState* state, const char* case_name,
@ -787,7 +779,8 @@ class TypeParameterizedTestSuite {
    // Next, recurses (at compile time) with the tail of the test list.
    return TypeParameterizedTestSuite<Fixture, typename Tests::Tail,
-                                      Types>::Register(prefix, code_location,
+                                      Types>::Register(prefix,
                                                       std::move(code_location),
                                                       state, case_name,
                                                       SkipComma(test_names),
                                                       type_names);
@ -796,7 +789,7 @@ class TypeParameterizedTestSuite {
 // The base case for the compile time recursion.
 template <GTEST_TEMPLATE_ Fixture, typename Types>
-class TypeParameterizedTestSuite<Fixture, internal::None, Types> {
+class [[nodiscard]] TypeParameterizedTestSuite<Fixture, internal::None, Types> {
 public:
  static bool Register(const char* /*prefix*/, const CodeLocation&,
                       const TypedTestSuitePState* /*state*/,
@ -852,7 +845,7 @@ struct TrueWithString {
 // doesn't use global state (and therefore can't interfere with user
 // code).  Unlike rand_r(), it's portable.  An LCG isn't very random,
 // but it's good enough for our purposes.
-class GTEST_API_ Random {
+class GTEST_API_ [[nodiscard]] Random {
 public:
  static const uint32_t kMaxRange = 1u << 31;
@ -878,7 +871,7 @@ class GTEST_API_ Random {
 // that's true if and only if T has methods DebugString() and ShortDebugString()
 // that return std::string.
 template <typename T>
-class HasDebugStringAndShortDebugString {
+class [[nodiscard]] HasDebugStringAndShortDebugString {
 private:
  template <typename C>
  static auto CheckDebugString(C*) -> typename std::is_same<
@ -900,11 +893,6 @@ class HasDebugStringAndShortDebugString {
      HasDebugStringType::value && HasShortDebugStringType::value;
 };
 #ifdef GTEST_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
 template <typename T>
 constexpr bool HasDebugStringAndShortDebugString<T>::value;
 #endif
 // When the compiler sees expression IsContainerTest<C>(0), if C is an
 // STL-style container class, the first overload of IsContainerTest
 // will be viable (since both C::iterator* and C::const_iterator* are
@ -1083,7 +1071,7 @@ struct RelationToSourceCopy {};
 // this requirement.  Element can be an array type itself (hence
 // multi-dimensional arrays are supported).
 template <typename Element>
-class NativeArray {
+class [[nodiscard]] NativeArray {
 public:
  // STL-style container typedefs.
  typedef Element value_type;
@ -1143,40 +1131,6 @@ class NativeArray {
  void (NativeArray::*clone_)(const Element*, size_t);
 };
 // Backport of std::index_sequence.
 template <size_t... Is>
 struct IndexSequence {
  using type = IndexSequence;
 };
 // Double the IndexSequence, and one if plus_one is true.
 template <bool plus_one, typename T, size_t sizeofT>
 struct DoubleSequence;
 template <size_t... I, size_t sizeofT>
 struct DoubleSequence<true, IndexSequence<I...>, sizeofT> {
  using type = IndexSequence<I..., (sizeofT + I)..., 2 * sizeofT>;
 };
 template <size_t... I, size_t sizeofT>
 struct DoubleSequence<false, IndexSequence<I...>, sizeofT> {
  using type = IndexSequence<I..., (sizeofT + I)...>;
 };
 // Backport of std::make_index_sequence.
 // It uses O(ln(N)) instantiation depth.
 template <size_t N>
 struct MakeIndexSequenceImpl
    : DoubleSequence<N % 2 == 1, typename MakeIndexSequenceImpl<N / 2>::type,
                     N / 2>::type {};
 template <>
 struct MakeIndexSequenceImpl<0> : IndexSequence<> {};
 template <size_t N>
 using MakeIndexSequence = typename MakeIndexSequenceImpl<N>::type;
 template <typename... T>
 using IndexSequenceFor = typename MakeIndexSequence<sizeof...(T)>::type;
 template <size_t>
 struct Ignore {
  Ignore(...);  // NOLINT
@ -1185,7 +1139,7 @@ struct Ignore {
 template <typename>
 struct ElemFromListImpl;
 template <size_t... I>
-struct ElemFromListImpl<IndexSequence<I...>> {
+struct ElemFromListImpl<std::index_sequence<I...>> {
  // We make Ignore a template to solve a problem with MSVC.
  // A non-template Ignore would work fine with `decltype(Ignore(I))...`, but
  // MSVC doesn't understand how to deal with that pack expansion.
@ -1196,15 +1150,14 @@ struct ElemFromListImpl<IndexSequence<I...>> {
 template <size_t N, typename... T>
 struct ElemFromList {
-  using type =
+  using type = decltype(ElemFromListImpl<std::make_index_sequence<N>>::Apply(
      decltype(ElemFromListImpl<typename MakeIndexSequence<N>::type>::Apply(
      static_cast<T (*)()>(nullptr)...));
 };
 struct FlatTupleConstructTag {};
 template <typename... T>
-class FlatTuple;
+class [[nodiscard]] FlatTuple;
 template <typename Derived, size_t I>
 struct FlatTupleElemBase;
@ -1223,9 +1176,9 @@ template <typename Derived, typename Idx>
 struct FlatTupleBase;
 template <size_t... Idx, typename... T>
-struct FlatTupleBase<FlatTuple<T...>, IndexSequence<Idx...>>
+struct FlatTupleBase<FlatTuple<T...>, std::index_sequence<Idx...>>
    : FlatTupleElemBase<FlatTuple<T...>, Idx>... {
-  using Indices = IndexSequence<Idx...>;
+  using Indices = std::index_sequence<Idx...>;
  FlatTupleBase() = default;
  template <typename... Args>
  explicit FlatTupleBase(FlatTupleConstructTag, Args&&... args)
@ -1260,14 +1213,15 @@ struct FlatTupleBase<FlatTuple<T...>, IndexSequence<Idx...>>
 // implementations.
 // FlatTuple and ElemFromList are not recursive and have a fixed depth
 // regardless of T...
-// MakeIndexSequence, on the other hand, it is recursive but with an
+// std::make_index_sequence, on the other hand, it is recursive but with an
 // instantiation depth of O(ln(N)).
 template <typename... T>
-class FlatTuple
+class [[nodiscard]] FlatTuple
    : private FlatTupleBase<FlatTuple<T...>,
-                            typename MakeIndexSequence<sizeof...(T)>::type> {
+                            std::make_index_sequence<sizeof...(T)>> {
-  using Indices = typename FlatTupleBase<
+  using Indices =
-      FlatTuple<T...>, typename MakeIndexSequence<sizeof...(T)>::type>::Indices;
+      typename FlatTupleBase<FlatTuple<T...>,
                             std::make_index_sequence<sizeof...(T)>>::Indices;
 public:
  FlatTuple() = default;
@ -1281,30 +1235,40 @@ class FlatTuple
 // Utility functions to be called with static_assert to induce deprecation
 // warnings.
-GTEST_INTERNAL_DEPRECATED(
+[[deprecated(
    "INSTANTIATE_TEST_CASE_P is deprecated, please use "
-    "INSTANTIATE_TEST_SUITE_P")
+    "INSTANTIATE_TEST_SUITE_P")]]
-constexpr bool InstantiateTestCase_P_IsDeprecated() { return true; }
+constexpr bool InstantiateTestCase_P_IsDeprecated() {
  return true;
 }
-GTEST_INTERNAL_DEPRECATED(
+[[deprecated(
    "TYPED_TEST_CASE_P is deprecated, please use "
-    "TYPED_TEST_SUITE_P")
+    "TYPED_TEST_SUITE_P")]]
-constexpr bool TypedTestCase_P_IsDeprecated() { return true; }
+constexpr bool TypedTestCase_P_IsDeprecated() {
  return true;
 }
-GTEST_INTERNAL_DEPRECATED(
+[[deprecated(
    "TYPED_TEST_CASE is deprecated, please use "
-    "TYPED_TEST_SUITE")
+    "TYPED_TEST_SUITE")]]
-constexpr bool TypedTestCaseIsDeprecated() { return true; }
+constexpr bool TypedTestCaseIsDeprecated() {
  return true;
 }
-GTEST_INTERNAL_DEPRECATED(
+[[deprecated(
    "REGISTER_TYPED_TEST_CASE_P is deprecated, please use "
-    "REGISTER_TYPED_TEST_SUITE_P")
+    "REGISTER_TYPED_TEST_SUITE_P")]]
-constexpr bool RegisterTypedTestCase_P_IsDeprecated() { return true; }
+constexpr bool RegisterTypedTestCase_P_IsDeprecated() {
  return true;
 }
-GTEST_INTERNAL_DEPRECATED(
+[[deprecated(
    "INSTANTIATE_TYPED_TEST_CASE_P is deprecated, please use "
-    "INSTANTIATE_TYPED_TEST_SUITE_P")
+    "INSTANTIATE_TYPED_TEST_SUITE_P")]]
-constexpr bool InstantiateTypedTestCase_P_IsDeprecated() { return true; }
+constexpr bool InstantiateTypedTestCase_P_IsDeprecated() {
  return true;
 }
 }  // namespace internal
 }  // namespace testing
@ -1360,7 +1324,7 @@ struct tuple_size<testing::internal::FlatTuple<Ts...>>
 namespace testing {
 namespace internal {
-class NeverThrown {
+class [[nodiscard]] NeverThrown {
 public:
  const char* what() const noexcept {
    return "this exception should never be thrown";
@ -1489,23 +1453,23 @@ class NeverThrown {
 // representation of expression as it was passed into the EXPECT_TRUE.
 #define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail)      \
  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                            \
-  if (const ::testing::AssertionResult gtest_ar_ =                    \
+  if (const ::testing::internal::AssertionResultExpectation gtest_are_ = { \
-          ::testing::AssertionResult(expression))                     \
+          ::testing::AssertionResult(expression), expected})               \
    ;                                                                      \
-  else                                                                \
+  else /* NOLINT */                                                        \
    fail(::testing::internal::GetBoolAssertionFailureMessage(              \
-             gtest_ar_, text, #actual, #expected)                     \
+        gtest_are_.assertion_result, text, #actual, #expected))
             .c_str())
 #define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail)               \
  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                     \
  if (::testing::internal::AlwaysTrue()) {                          \
-    ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
+    const ::testing::internal::HasNewFatalFailureHelper             \
        gtest_fatal_failure_checker;                                \
    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);      \
    if (gtest_fatal_failure_checker.has_new_fatal_failure()) {      \
      goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
    }                                                               \
-  } else                                                                       \
+  } else /* NOLINT */                                               \
    GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__)         \
        : fail("Expected: " #statement                              \
               " doesn't generate new fatal "                       \
@ -1540,7 +1504,7 @@ class NeverThrown {
                                                                               \
   private:                                                                    \
    void TestBody() override;                                                  \
-    static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;      \
+    [[maybe_unused]] static ::testing::TestInfo* const test_info_;             \
  };                                                                           \
                                                                               \
  ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name,           \
--- a/test/googletest/googletest/include/gtest/internal/gtest-param-util.h
+++ b/test/googletest/googletest/include/gtest/internal/gtest-param-util.h
@ -39,6 +39,7 @@
 #include <ctype.h>
 #include <cassert>
 #include <functional>
 #include <iterator>
 #include <map>
 #include <memory>
@ -47,6 +48,7 @@
 #include <string>
 #include <tuple>
 #include <type_traits>
 #include <unordered_map>
 #include <utility>
 #include <vector>
@ -85,19 +87,19 @@ namespace internal {
 // TEST_P macro is used to define two tests with the same name
 // but in different namespaces.
 GTEST_API_ void ReportInvalidTestSuiteType(const char* test_suite_name,
-                                           CodeLocation code_location);
+                                           const CodeLocation& code_location);
 template <typename>
-class ParamGeneratorInterface;
+class [[nodiscard]] ParamGeneratorInterface;
 template <typename>
-class ParamGenerator;
+class [[nodiscard]] ParamGenerator;
 // Interface for iterating over elements provided by an implementation
 // of ParamGeneratorInterface<T>.
 template <typename T>
-class ParamIteratorInterface {
+class [[nodiscard]] ParamIteratorInterface {
 public:
-  virtual ~ParamIteratorInterface() {}
+  virtual ~ParamIteratorInterface() = default;
  // A pointer to the base generator instance.
  // Used only for the purposes of iterator comparison
  // to make sure that two iterators belong to the same generator.
@ -125,7 +127,7 @@ class ParamIteratorInterface {
 // ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T>
 // and implements the const forward iterator concept.
 template <typename T>
-class ParamIterator {
+class [[nodiscard]] ParamIterator {
 public:
  typedef T value_type;
  typedef const T& reference;
@ -167,11 +169,11 @@ class ParamIterator {
 // ParamGeneratorInterface<T> is the binary interface to access generators
 // defined in other translation units.
 template <typename T>
-class ParamGeneratorInterface {
+class [[nodiscard]] ParamGeneratorInterface {
 public:
  typedef T ParamType;
-  virtual ~ParamGeneratorInterface() {}
+  virtual ~ParamGeneratorInterface() = default;
  // Generator interface definition
  virtual ParamIteratorInterface<T>* Begin() const = 0;
@ -184,7 +186,7 @@ class ParamGeneratorInterface {
 // ParamGeneratorInterface<T> instance is shared among all copies
 // of the original object. This is possible because that instance is immutable.
 template <typename T>
-class ParamGenerator {
+class [[nodiscard]] ParamGenerator {
 public:
  typedef ParamIterator<T> iterator;
@ -208,14 +210,14 @@ class ParamGenerator {
 // operator<().
 // This class is used in the Range() function.
 template <typename T, typename IncrementT>
-class RangeGenerator : public ParamGeneratorInterface<T> {
+class [[nodiscard]] RangeGenerator : public ParamGeneratorInterface<T> {
 public:
  RangeGenerator(T begin, T end, IncrementT step)
      : begin_(begin),
        end_(end),
        step_(step),
        end_index_(CalculateEndIndex(begin, end, step)) {}
-  ~RangeGenerator() override {}
+  ~RangeGenerator() override = default;
  ParamIteratorInterface<T>* Begin() const override {
    return new Iterator(this, begin_, 0, step_);
@ -230,7 +232,7 @@ class RangeGenerator : public ParamGeneratorInterface<T> {
    Iterator(const ParamGeneratorInterface<T>* base, T value, int index,
             IncrementT step)
        : base_(base), value_(value), index_(index), step_(step) {}
-    ~Iterator() override {}
+    ~Iterator() override = default;
    const ParamGeneratorInterface<T>* BaseGenerator() const override {
      return base_;
@ -294,12 +296,13 @@ class RangeGenerator : public ParamGeneratorInterface<T> {
 // since the source can be located on the stack, and the generator
 // is likely to persist beyond that stack frame.
 template <typename T>
-class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
+class [[nodiscard]] ValuesInIteratorRangeGenerator
    : public ParamGeneratorInterface<T> {
 public:
  template <typename ForwardIterator>
  ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
      : container_(begin, end) {}
-  ~ValuesInIteratorRangeGenerator() override {}
+  ~ValuesInIteratorRangeGenerator() override = default;
  ParamIteratorInterface<T>* Begin() const override {
    return new Iterator(this, container_.begin());
@ -316,7 +319,7 @@ class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
    Iterator(const ParamGeneratorInterface<T>* base,
             typename ContainerType::const_iterator iterator)
        : base_(base), iterator_(iterator) {}
-    ~Iterator() override {}
+    ~Iterator() override = default;
    const ParamGeneratorInterface<T>* BaseGenerator() const override {
      return base_;
@ -379,9 +382,7 @@ class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
 // integer test parameter index.
 template <class ParamType>
 std::string DefaultParamName(const TestParamInfo<ParamType>& info) {
-  Message name_stream;
+  return std::to_string(info.index);
  name_stream << info.index;
  return name_stream.GetString();
 }
 template <typename T = int>
@ -396,7 +397,7 @@ void TestNotEmpty(const T&) {}
 // Stores a parameter value and later creates tests parameterized with that
 // value.
 template <class TestClass>
-class ParameterizedTestFactory : public TestFactoryBase {
+class [[nodiscard]] ParameterizedTestFactory : public TestFactoryBase {
 public:
  typedef typename TestClass::ParamType ParamType;
  explicit ParameterizedTestFactory(ParamType parameter)
@ -418,9 +419,9 @@ class ParameterizedTestFactory : public TestFactoryBase {
 // TestMetaFactoryBase is a base class for meta-factories that create
 // test factories for passing into MakeAndRegisterTestInfo function.
 template <class ParamType>
-class TestMetaFactoryBase {
+class [[nodiscard]] TestMetaFactoryBase {
 public:
-  virtual ~TestMetaFactoryBase() {}
+  virtual ~TestMetaFactoryBase() = default;
  virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0;
 };
@ -434,12 +435,12 @@ class TestMetaFactoryBase {
 // it for each Test/Parameter value combination. Thus it needs meta factory
 // creator class.
 template <class TestSuite>
-class TestMetaFactory
+class [[nodiscard]] TestMetaFactory
    : public TestMetaFactoryBase<typename TestSuite::ParamType> {
 public:
  using ParamType = typename TestSuite::ParamType;
-  TestMetaFactory() {}
+  TestMetaFactory() = default;
  TestFactoryBase* CreateTestFactory(ParamType parameter) override {
    return new ParameterizedTestFactory<TestSuite>(parameter);
@ -460,9 +461,9 @@ class TestMetaFactory
 // in RegisterTests method. The ParameterizeTestSuiteRegistry class holds
 // a collection of pointers to the ParameterizedTestSuiteInfo objects
 // and calls RegisterTests() on each of them when asked.
-class ParameterizedTestSuiteInfoBase {
+class [[nodiscard]] ParameterizedTestSuiteInfoBase {
 public:
-  virtual ~ParameterizedTestSuiteInfoBase() {}
+  virtual ~ParameterizedTestSuiteInfoBase() = default;
  // Base part of test suite name for display purposes.
  virtual const std::string& GetTestSuiteName() const = 0;
@ -503,7 +504,8 @@ GTEST_API_ void InsertSyntheticTestCase(const std::string& name,
 // test suite. It registers tests with all values generated by all
 // generators when asked.
 template <class TestSuite>
-class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
+class [[nodiscard]] ParameterizedTestSuiteInfo
    : public ParameterizedTestSuiteInfoBase {
 public:
  // ParamType and GeneratorCreationFunc are private types but are required
  // for declarations of public methods AddTestPattern() and
@ -513,9 +515,10 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
  typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
  using ParamNameGeneratorFunc = std::string(const TestParamInfo<ParamType>&);
-  explicit ParameterizedTestSuiteInfo(const char* name,
+  explicit ParameterizedTestSuiteInfo(std::string name,
                                      CodeLocation code_location)
-      : test_suite_name_(name), code_location_(code_location) {}
+      : test_suite_name_(std::move(name)),
        code_location_(std::move(code_location)) {}
  // Test suite base name for display purposes.
  const std::string& GetTestSuiteName() const override {
@ -529,20 +532,20 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
  // prefix). test_base_name is the name of an individual test without
  // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
  // test suite base name and DoBar is test base name.
-  void AddTestPattern(const char* test_suite_name, const char* test_base_name,
+  void AddTestPattern(const char*, const char* test_base_name,
                      TestMetaFactoryBase<ParamType>* meta_factory,
                      CodeLocation code_location) {
-    tests_.push_back(std::shared_ptr<TestInfo>(new TestInfo(
+    tests_.emplace_back(
-        test_suite_name, test_base_name, meta_factory, code_location)));
+        new TestInfo(test_base_name, meta_factory, std::move(code_location)));
  }
  // INSTANTIATE_TEST_SUITE_P macro uses AddGenerator() to record information
  // about a generator.
-  int AddTestSuiteInstantiation(const std::string& instantiation_name,
+  int AddTestSuiteInstantiation(std::string instantiation_name,
                                GeneratorCreationFunc* func,
                                ParamNameGeneratorFunc* name_func,
                                const char* file, int line) {
-    instantiations_.push_back(
+    instantiations_.emplace_back(std::move(instantiation_name), func, name_func,
-        InstantiationInfo(instantiation_name, func, name_func, file, line));
+                                 file, line);
    return 0;  // Return value used only to run this method in namespace scope.
  }
  // UnitTest class invokes this method to register tests in this test suite
@ -553,60 +556,61 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
  void RegisterTests() override {
    bool generated_instantiations = false;
    for (typename TestInfoContainer::iterator test_it = tests_.begin();
         test_it != tests_.end(); ++test_it) {
      std::shared_ptr<TestInfo> test_info = *test_it;
      for (typename InstantiationContainer::iterator gen_it =
               instantiations_.begin();
           gen_it != instantiations_.end(); ++gen_it) {
        const std::string& instantiation_name = gen_it->name;
        ParamGenerator<ParamType> generator((*gen_it->generator)());
        ParamNameGeneratorFunc* name_func = gen_it->name_func;
        const char* file = gen_it->file;
        int line = gen_it->line;
    std::string test_suite_name;
    std::string test_name;
    for (const std::shared_ptr<TestInfo>& test_info : tests_) {
      for (const InstantiationInfo& instantiation : instantiations_) {
        const std::string& instantiation_name = instantiation.name;
        ParamGenerator<ParamType> generator((*instantiation.generator)());
        ParamNameGeneratorFunc* name_func = instantiation.name_func;
        const char* file = instantiation.file;
        int line = instantiation.line;
        if (!instantiation_name.empty())
          test_suite_name = instantiation_name + "/";
-        test_suite_name += test_info->test_suite_base_name;
+        else
          test_suite_name.clear();
        test_suite_name += test_suite_name_;
        size_t i = 0;
        std::set<std::string> test_param_names;
-        for (typename ParamGenerator<ParamType>::iterator param_it =
+        for (const auto& param : generator) {
                 generator.begin();
             param_it != generator.end(); ++param_it, ++i) {
          generated_instantiations = true;
-          Message test_name_stream;
+          test_name.clear();
          std::string param_name =
-              name_func(TestParamInfo<ParamType>(*param_it, i));
+              name_func(TestParamInfo<ParamType>(param, i));
          GTEST_CHECK_(IsValidParamName(param_name))
              << "Parameterized test name '" << param_name
-              << "' is invalid, in " << file << " line " << line << std::endl;
+              << "' is invalid (contains spaces, dashes, or any "
                 "non-alphanumeric characters other than underscores), in "
              << file << " line " << line << "" << std::endl;
          GTEST_CHECK_(test_param_names.count(param_name) == 0)
              << "Duplicate parameterized test name '" << param_name << "', in "
              << file << " line " << line << std::endl;
          test_param_names.insert(param_name);
          if (!test_info->test_base_name.empty()) {
-            test_name_stream << test_info->test_base_name << "/";
+            test_name.append(test_info->test_base_name).append("/");
          }
-          test_name_stream << param_name;
+          test_name += param_name;
          test_param_names.insert(std::move(param_name));
          MakeAndRegisterTestInfo(
-              test_suite_name.c_str(), test_name_stream.GetString().c_str(),
+              test_suite_name, test_name.c_str(),
              nullptr,  // No type parameter.
-              PrintToString(*param_it).c_str(), test_info->code_location,
+              PrintToString(param).c_str(), test_info->code_location,
              GetTestSuiteTypeId(),
              SuiteApiResolver<TestSuite>::GetSetUpCaseOrSuite(file, line),
              SuiteApiResolver<TestSuite>::GetTearDownCaseOrSuite(file, line),
-              test_info->test_meta_factory->CreateTestFactory(*param_it));
+              test_info->test_meta_factory->CreateTestFactory(param));
-        }  // for param_it
+          ++i;
-      }    // for gen_it
+        }  // for param
-    }      // for test_it
+      }  // for instantiation
    }  // for test_info
    if (!generated_instantiations) {
      // There are no generaotrs, or they all generate nothing ...
@ -619,15 +623,13 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
  // LocalTestInfo structure keeps information about a single test registered
  // with TEST_P macro.
  struct TestInfo {
-    TestInfo(const char* a_test_suite_base_name, const char* a_test_base_name,
+    TestInfo(const char* a_test_base_name,
             TestMetaFactoryBase<ParamType>* a_test_meta_factory,
             CodeLocation a_code_location)
-        : test_suite_base_name(a_test_suite_base_name),
+        : test_base_name(a_test_base_name),
          test_base_name(a_test_base_name),
          test_meta_factory(a_test_meta_factory),
-          code_location(a_code_location) {}
+          code_location(std::move(a_code_location)) {}
    const std::string test_suite_base_name;
    const std::string test_base_name;
    const std::unique_ptr<TestMetaFactoryBase<ParamType>> test_meta_factory;
    const CodeLocation code_location;
@ -637,11 +639,10 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
  //  <Instantiation name, Sequence generator creation function,
  //     Name generator function, Source file, Source line>
  struct InstantiationInfo {
-    InstantiationInfo(const std::string& name_in,
+    InstantiationInfo(std::string name_in, GeneratorCreationFunc* generator_in,
                      GeneratorCreationFunc* generator_in,
                      ParamNameGeneratorFunc* name_func_in, const char* file_in,
                      int line_in)
-        : name(name_in),
+        : name(std::move(name_in)),
          generator(generator_in),
          name_func(name_func_in),
          file(file_in),
@ -689,9 +690,9 @@ using ParameterizedTestCaseInfo = ParameterizedTestSuiteInfo<TestCase>;
 // ParameterizedTestSuiteInfoBase classes accessed by test suite names. TEST_P
 // and INSTANTIATE_TEST_SUITE_P macros use it to locate their corresponding
 // ParameterizedTestSuiteInfo descriptors.
-class ParameterizedTestSuiteRegistry {
+class [[nodiscard]] ParameterizedTestSuiteRegistry {
 public:
-  ParameterizedTestSuiteRegistry() {}
+  ParameterizedTestSuiteRegistry() = default;
  ~ParameterizedTestSuiteRegistry() {
    for (auto& test_suite_info : test_suite_infos_) {
      delete test_suite_info;
@ -702,29 +703,32 @@ class ParameterizedTestSuiteRegistry {
  // tests and instantiations of a particular test suite.
  template <class TestSuite>
  ParameterizedTestSuiteInfo<TestSuite>* GetTestSuitePatternHolder(
-      const char* test_suite_name, CodeLocation code_location) {
+      std::string test_suite_name, CodeLocation code_location) {
    ParameterizedTestSuiteInfo<TestSuite>* typed_test_info = nullptr;
-    for (auto& test_suite_info : test_suite_infos_) {
+
-      if (test_suite_info->GetTestSuiteName() == test_suite_name) {
+    auto item_it = suite_name_to_info_index_.find(test_suite_name);
    if (item_it != suite_name_to_info_index_.end()) {
      auto* test_suite_info = test_suite_infos_[item_it->second];
      if (test_suite_info->GetTestSuiteTypeId() != GetTypeId<TestSuite>()) {
        // Complain about incorrect usage of Google Test facilities
        // and terminate the program since we cannot guaranty correct
        // test suite setup and tear-down in this case.
-          ReportInvalidTestSuiteType(test_suite_name, code_location);
+        ReportInvalidTestSuiteType(test_suite_name.c_str(), code_location);
        posix::Abort();
      } else {
        // At this point we are sure that the object we found is of the same
        // type we are looking for, so we downcast it to that type
        // without further checks.
-          typed_test_info = CheckedDowncastToActualType<
+        typed_test_info =
-              ParameterizedTestSuiteInfo<TestSuite>>(test_suite_info);
+            CheckedDowncastToActualType<ParameterizedTestSuiteInfo<TestSuite>>(
-        }
+                test_suite_info);
        break;
      }
    }
    if (typed_test_info == nullptr) {
      typed_test_info = new ParameterizedTestSuiteInfo<TestSuite>(
-          test_suite_name, code_location);
+          test_suite_name, std::move(code_location));
      suite_name_to_info_index_.emplace(std::move(test_suite_name),
                                        test_suite_infos_.size());
      test_suite_infos_.push_back(typed_test_info);
    }
    return typed_test_info;
@ -738,8 +742,9 @@ class ParameterizedTestSuiteRegistry {
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  template <class TestCase>
  ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
-      const char* test_case_name, CodeLocation code_location) {
+      std::string test_case_name, CodeLocation code_location) {
-    return GetTestSuitePatternHolder<TestCase>(test_case_name, code_location);
+    return GetTestSuitePatternHolder<TestCase>(std::move(test_case_name),
                                               std::move(code_location));
  }
 #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
@ -748,6 +753,7 @@ class ParameterizedTestSuiteRegistry {
  using TestSuiteInfoContainer = ::std::vector<ParameterizedTestSuiteInfoBase*>;
  TestSuiteInfoContainer test_suite_infos_;
  ::std::unordered_map<std::string, size_t> suite_name_to_info_index_;
  ParameterizedTestSuiteRegistry(const ParameterizedTestSuiteRegistry&) =
      delete;
@ -758,7 +764,7 @@ class ParameterizedTestSuiteRegistry {
 // Keep track of what type-parameterized test suite are defined and
 // where as well as which are intatiated. This allows susequently
 // identifying suits that are defined but never used.
-class TypeParameterizedTestSuiteRegistry {
+class [[nodiscard]] TypeParameterizedTestSuiteRegistry {
 public:
  // Add a suite definition
  void RegisterTestSuite(const char* test_suite_name,
@ -774,7 +780,7 @@ class TypeParameterizedTestSuiteRegistry {
 private:
  struct TypeParameterizedTestSuiteInfo {
    explicit TypeParameterizedTestSuiteInfo(CodeLocation c)
-        : code_location(c), instantiated(false) {}
+        : code_location(std::move(c)), instantiated(false) {}
    CodeLocation code_location;
    bool instantiated;
@ -797,18 +803,18 @@ namespace internal {
 GTEST_DISABLE_MSC_WARNINGS_PUSH_(4100)
 template <typename... Ts>
-class ValueArray {
+class [[nodiscard]] ValueArray {
 public:
  explicit ValueArray(Ts... v) : v_(FlatTupleConstructTag{}, std::move(v)...) {}
  template <typename T>
  operator ParamGenerator<T>() const {  // NOLINT
-    return ValuesIn(MakeVector<T>(MakeIndexSequence<sizeof...(Ts)>()));
+    return ValuesIn(MakeVector<T>(std::make_index_sequence<sizeof...(Ts)>()));
  }
 private:
  template <typename T, size_t... I>
-  std::vector<T> MakeVector(IndexSequence<I...>) const {
+  std::vector<T> MakeVector(std::index_sequence<I...>) const {
    return std::vector<T>{static_cast<T>(v_.template Get<I>())...};
  }
@ -818,14 +824,14 @@ class ValueArray {
 GTEST_DISABLE_MSC_WARNINGS_POP_()  // 4100
 template <typename... T>
-class CartesianProductGenerator
+class [[nodiscard]] CartesianProductGenerator
    : public ParamGeneratorInterface<::std::tuple<T...>> {
 public:
  typedef ::std::tuple<T...> ParamType;
  CartesianProductGenerator(const std::tuple<ParamGenerator<T>...>& g)
      : generators_(g) {}
-  ~CartesianProductGenerator() override {}
+  ~CartesianProductGenerator() override = default;
  ParamIteratorInterface<ParamType>* Begin() const override {
    return new Iterator(this, generators_, false);
@ -838,7 +844,7 @@ class CartesianProductGenerator
  template <class I>
  class IteratorImpl;
  template <size_t... I>
-  class IteratorImpl<IndexSequence<I...>>
+  class IteratorImpl<std::index_sequence<I...>>
      : public ParamIteratorInterface<ParamType> {
   public:
    IteratorImpl(const ParamGeneratorInterface<ParamType>* base,
@ -850,7 +856,7 @@ class CartesianProductGenerator
          current_(is_end ? end_ : begin_) {
      ComputeCurrentValue();
    }
-    ~IteratorImpl() override {}
+    ~IteratorImpl() override = default;
    const ParamGeneratorInterface<ParamType>* BaseGenerator() const override {
      return base_;
@ -929,13 +935,13 @@ class CartesianProductGenerator
    std::shared_ptr<ParamType> current_value_;
  };
-  using Iterator = IteratorImpl<typename MakeIndexSequence<sizeof...(T)>::type>;
+  using Iterator = IteratorImpl<std::make_index_sequence<sizeof...(T)>>;
  std::tuple<ParamGenerator<T>...> generators_;
 };
 template <class... Gen>
-class CartesianProductHolder {
+class [[nodiscard]] CartesianProductHolder {
 public:
  CartesianProductHolder(const Gen&... g) : generators_(g...) {}
  template <typename... T>
@ -948,11 +954,12 @@ class CartesianProductHolder {
  std::tuple<Gen...> generators_;
 };
-template <typename From, typename To>
+template <typename From, typename To, typename Func>
-class ParamGeneratorConverter : public ParamGeneratorInterface<To> {
+class [[nodiscard]] ParamGeneratorConverter
    : public ParamGeneratorInterface<To> {
 public:
-  ParamGeneratorConverter(ParamGenerator<From> gen)  // NOLINT
+  ParamGeneratorConverter(ParamGenerator<From> gen, Func converter)  // NOLINT
-      : generator_(std::move(gen)) {}
+      : generator_(std::move(gen)), converter_(std::move(converter)) {}
  ParamIteratorInterface<To>* Begin() const override {
    return new Iterator(this, generator_.begin(), generator_.end());
@ -961,22 +968,32 @@ class ParamGeneratorConverter : public ParamGeneratorInterface<To> {
    return new Iterator(this, generator_.end(), generator_.end());
  }
  // Returns the std::function wrapping the user-supplied converter callable. It
  // is used by the iterator (see class Iterator below) to convert the object
  // (of type FROM) returned by the ParamGenerator to an object of a type that
  // can be static_cast to type TO.
  const Func& TypeConverter() const { return converter_; }
 private:
  class Iterator : public ParamIteratorInterface<To> {
   public:
-    Iterator(const ParamGeneratorInterface<To>* base, ParamIterator<From> it,
+    Iterator(const ParamGeneratorConverter* base, ParamIterator<From> it,
             ParamIterator<From> end)
        : base_(base), it_(it), end_(end) {
-      if (it_ != end_) value_ = std::make_shared<To>(static_cast<To>(*it_));
+      if (it_ != end_)
        value_ =
            std::make_shared<To>(static_cast<To>(base->TypeConverter()(*it_)));
    }
-    ~Iterator() override {}
+    ~Iterator() override = default;
    const ParamGeneratorInterface<To>* BaseGenerator() const override {
      return base_;
    }
    void Advance() override {
      ++it_;
-      if (it_ != end_) value_ = std::make_shared<To>(static_cast<To>(*it_));
+      if (it_ != end_)
        value_ =
            std::make_shared<To>(static_cast<To>(base_->TypeConverter()(*it_)));
    }
    ParamIteratorInterface<To>* Clone() const override {
      return new Iterator(*this);
@ -996,30 +1013,54 @@ class ParamGeneratorConverter : public ParamGeneratorInterface<To> {
   private:
    Iterator(const Iterator& other) = default;
-    const ParamGeneratorInterface<To>* const base_;
+    const ParamGeneratorConverter* const base_;
    ParamIterator<From> it_;
    ParamIterator<From> end_;
    std::shared_ptr<To> value_;
  };  // class ParamGeneratorConverter::Iterator
  ParamGenerator<From> generator_;
  Func converter_;
 };  // class ParamGeneratorConverter
-template <class Gen>
+template <class GeneratedT,
-class ParamConverterGenerator {
+          typename StdFunction =
              std::function<const GeneratedT&(const GeneratedT&)>>
 class [[nodiscard]] ParamConverterGenerator {
 public:
-  ParamConverterGenerator(ParamGenerator<Gen> g)  // NOLINT
+  ParamConverterGenerator(ParamGenerator<GeneratedT> g)  // NOLINT
-      : generator_(std::move(g)) {}
+      : generator_(std::move(g)), converter_(Identity) {}
  ParamConverterGenerator(ParamGenerator<GeneratedT> g, StdFunction converter)
      : generator_(std::move(g)), converter_(std::move(converter)) {}
  template <typename T>
  operator ParamGenerator<T>() const {  // NOLINT
-    return ParamGenerator<T>(new ParamGeneratorConverter<Gen, T>(generator_));
+    return ParamGenerator<T>(
        new ParamGeneratorConverter<GeneratedT, T, StdFunction>(generator_,
                                                                converter_));
  }
 private:
-  ParamGenerator<Gen> generator_;
+  static const GeneratedT& Identity(const GeneratedT& v) { return v; }
  ParamGenerator<GeneratedT> generator_;
  StdFunction converter_;
 };
 // Template to determine the param type of a single-param std::function.
 template <typename T>
 struct FuncSingleParamType;
 template <typename R, typename P>
 struct FuncSingleParamType<std::function<R(P)>> {
  using type = std::remove_cv_t<std::remove_reference_t<P>>;
 };
 template <typename T>
 struct IsSingleArgStdFunction : public std::false_type {};
 template <typename R, typename P>
 struct IsSingleArgStdFunction<std::function<R(P)>> : public std::true_type {};
 }  // namespace internal
 }  // namespace testing
--- a/test/googletest/googletest/include/gtest/internal/gtest-port-arch.h
+++ b/test/googletest/googletest/include/gtest/internal/gtest-port-arch.h
@ -56,6 +56,8 @@
 #elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_TV_TITLE)
 #define GTEST_OS_WINDOWS_PHONE 1
 #define GTEST_OS_WINDOWS_TV_TITLE 1
 #elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_GAMES)
 #define GTEST_OS_WINDOWS_GAMES 1
 #else
 // WINAPI_FAMILY defined but no known partition matched.
 // Default to desktop.
@ -113,6 +115,12 @@
 #define GTEST_OS_XTENSA 1
 #elif defined(__hexagon__)
 #define GTEST_OS_QURT 1
 #elif defined(CPU_QN9090) || defined(CPU_QN9090HN)
 #define GTEST_OS_NXP_QN9090 1
 #elif defined(NRF52)
 #define GTEST_OS_NRF52 1
 #elif defined(__EMSCRIPTEN__)
 #define GTEST_OS_EMSCRIPTEN 1
 #endif  // __CYGWIN__
 #endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
--- a/test/googletest/googletest/include/gtest/internal/gtest-port.h
+++ b/test/googletest/googletest/include/gtest/internal/gtest-port.h
--- a/test/googletest/googletest/include/gtest/internal/gtest-string.h
+++ b/test/googletest/googletest/include/gtest/internal/gtest-string.h
@ -60,7 +60,7 @@ namespace testing {
 namespace internal {
 // String - an abstract class holding static string utilities.
-class GTEST_API_ String {
+class GTEST_API_ [[nodiscard]] String {
 public:
  // Static utility methods
@ -73,7 +73,7 @@ class GTEST_API_ String {
  // memory using malloc().
  static const char* CloneCString(const char* c_str);
-#if GTEST_OS_WINDOWS_MOBILE
+#ifdef GTEST_OS_WINDOWS_MOBILE
  // Windows CE does not have the 'ANSI' versions of Win32 APIs. To be
  // able to pass strings to Win32 APIs on CE we need to convert them
  // to 'Unicode', UTF-16.
--- a/test/googletest/googletest/include/gtest/internal/gtest-type-util.h
+++ b/test/googletest/googletest/include/gtest/internal/gtest-type-util.h
@ -67,6 +67,22 @@ inline std::string CanonicalizeForStdLibVersioning(std::string s) {
      s.erase(strlen("std"), end - strlen("std"));
    }
  }
  // Strip redundant spaces in typename to match MSVC
  // For example, std::pair<int, bool> -> std::pair<int,bool>
  static const char to_search[] = ", ";
  const char replace_char = ',';
  size_t pos = 0;
  while (true) {
    // Get the next occurrence from the current position
    pos = s.find(to_search, pos);
    if (pos == std::string::npos) {
      break;
    }
    // Replace this occurrence of substring
    s.replace(pos, strlen(to_search), 1, replace_char);
    ++pos;
  }
  return s;
 }
@ -85,6 +101,20 @@ inline std::string GetTypeName(const std::type_info& type) {
  const std::string name_str(status == 0 ? readable_name : name);
  free(readable_name);
  return CanonicalizeForStdLibVersioning(name_str);
 #elif defined(_MSC_VER)
  // Strip struct and class due to differences between
  // MSVC and other compilers. std::pair<int,bool> is printed as
  // "struct std::pair<int,bool>" when using MSVC vs "std::pair<int, bool>" with
  // other compilers.
  std::string s = name;
  // Only strip the leading "struct " and "class ", so uses rfind == 0 to
  // ensure that
  if (s.rfind("struct ", 0) == 0) {
    s = s.substr(strlen("struct "));
  } else if (s.rfind("class ", 0) == 0) {
    s = s.substr(strlen("class "));
  }
  return s;
 #else
  return name;
 #endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
--- a/test/googletest/googletest/samples/prime_tables.h
+++ b/test/googletest/googletest/samples/prime_tables.h
@ -39,7 +39,7 @@
 // The prime table interface.
 class PrimeTable {
 public:
-  virtual ~PrimeTable() {}
+  virtual ~PrimeTable() = default;
  // Returns true if and only if n is a prime number.
  virtual bool IsPrime(int n) const = 0;
--- a/test/googletest/googletest/samples/sample10_unittest.cc
+++ b/test/googletest/googletest/samples/sample10_unittest.cc
@ -38,7 +38,6 @@ using ::testing::InitGoogleTest;
 using ::testing::Test;
 using ::testing::TestEventListeners;
 using ::testing::TestInfo;
 using ::testing::TestPartResult;
 using ::testing::UnitTest;
 namespace {
--- a/test/googletest/googletest/samples/sample2_unittest.cc
+++ b/test/googletest/googletest/samples/sample2_unittest.cc
@ -39,6 +39,8 @@
 #include "sample2.h"
 #include <iterator>
 #include "gtest/gtest.h"
 namespace {
 // In this example, we test the MyString class (a simple string).
@ -78,7 +80,7 @@ const char kHelloString[] = "Hello, world!";
 TEST(MyString, ConstructorFromCString) {
  const MyString s(kHelloString);
  EXPECT_EQ(0, strcmp(s.c_string(), kHelloString));
-  EXPECT_EQ(sizeof(kHelloString) / sizeof(kHelloString[0]) - 1, s.Length());
+  EXPECT_EQ(std::size(kHelloString) - 1, s.Length());
 }
 // Tests the copy c'tor.
--- a/test/googletest/googletest/samples/sample8_unittest.cc
+++ b/test/googletest/googletest/samples/sample8_unittest.cc
@ -32,6 +32,8 @@
 // and each test is given one combination as a parameter.
 // Use class definitions to test from this header.
 #include <tuple>
 #include "prime_tables.h"
 #include "gtest/gtest.h"
 namespace {
--- a/test/googletest/googletest/samples/sample9_unittest.cc
+++ b/test/googletest/googletest/samples/sample9_unittest.cc
@ -40,7 +40,6 @@ using ::testing::Test;
 using ::testing::TestEventListeners;
 using ::testing::TestInfo;
 using ::testing::TestPartResult;
 using ::testing::TestSuite;
 using ::testing::UnitTest;
 namespace {
 // Provides alternative output mode which produces minimal amount of
--- a/test/googletest/googletest/src/gtest-assertion-result.cc
+++ b/test/googletest/googletest/src/gtest-assertion-result.cc
@ -44,7 +44,7 @@ namespace testing {
 // Used in EXPECT_TRUE/FALSE(assertion_result).
 AssertionResult::AssertionResult(const AssertionResult& other)
    : success_(other.success_),
-      message_(other.message_.get() != nullptr
+      message_(other.message_ != nullptr
                   ? new ::std::string(*other.message_)
                   : static_cast< ::std::string*>(nullptr)) {}
@ -58,7 +58,7 @@ void AssertionResult::swap(AssertionResult& other) {
 // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
 AssertionResult AssertionResult::operator!() const {
  AssertionResult negation(!success_);
-  if (message_.get() != nullptr) negation << *message_;
+  if (message_ != nullptr) negation << *message_;
  return negation;
 }
--- a/test/googletest/googletest/src/gtest-death-test.cc
+++ b/test/googletest/googletest/src/gtest-death-test.cc
@ -32,17 +32,21 @@
 #include "gtest/gtest-death-test.h"
 #include <stdlib.h>
 #include <functional>
 #include <memory>
 #include <sstream>
 #include <string>
 #include <utility>
 #include <vector>
 #include "gtest/internal/custom/gtest.h"
 #include "gtest/internal/gtest-port.h"
-#if GTEST_HAS_DEATH_TEST
+#ifdef GTEST_HAS_DEATH_TEST
-#if GTEST_OS_MAC
+#ifdef GTEST_OS_MAC
 #include <crt_externs.h>
 #endif  // GTEST_OS_MAC
@ -50,24 +54,24 @@
 #include <fcntl.h>
 #include <limits.h>
-#if GTEST_OS_LINUX
+#ifdef GTEST_OS_LINUX
 #include <signal.h>
 #endif  // GTEST_OS_LINUX
 #include <stdarg.h>
-#if GTEST_OS_WINDOWS
+#ifdef GTEST_OS_WINDOWS
 #include <windows.h>
 #else
 #include <sys/mman.h>
 #include <sys/wait.h>
 #endif  // GTEST_OS_WINDOWS
-#if GTEST_OS_QNX
+#ifdef GTEST_OS_QNX
 #include <spawn.h>
 #endif  // GTEST_OS_QNX
-#if GTEST_OS_FUCHSIA
+#ifdef GTEST_OS_FUCHSIA
 #include <lib/fdio/fd.h>
 #include <lib/fdio/io.h>
 #include <lib/fdio/spawn.h>
@ -113,7 +117,7 @@ GTEST_DEFINE_string_(
 GTEST_DEFINE_bool_(
    death_test_use_fork,
    testing::internal::BoolFromGTestEnv("death_test_use_fork", false),
-    "Instructs to use fork()/_exit() instead of clone() in death tests. "
+    "Instructs to use fork()/_Exit() instead of clone() in death tests. "
    "Ignored and always uses fork() on POSIX systems where clone() is not "
    "implemented. Useful when running under valgrind or similar tools if "
    "those do not support clone(). Valgrind 3.3.1 will just fail if "
@ -133,13 +137,13 @@ GTEST_DEFINE_string_(
 namespace testing {
-#if GTEST_HAS_DEATH_TEST
+#ifdef GTEST_HAS_DEATH_TEST
 namespace internal {
 // Valid only for fast death tests. Indicates the code is running in the
 // child process of a fast style death test.
-#if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+#if !defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_FUCHSIA)
 static bool g_in_fast_death_test_child = false;
 #endif
@ -149,7 +153,7 @@ static bool g_in_fast_death_test_child = false;
 // tests.  IMPORTANT: This is an internal utility.  Using it may break the
 // implementation of death tests.  User code MUST NOT use it.
 bool InDeathTestChild() {
-#if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+#if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_FUCHSIA)
  // On Windows and Fuchsia, death tests are thread-safe regardless of the value
  // of the death_test_style flag.
@ -171,7 +175,7 @@ ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) {}
 // ExitedWithCode function-call operator.
 bool ExitedWithCode::operator()(int exit_status) const {
-#if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+#if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_FUCHSIA)
  return exit_status == exit_code_;
@ -182,7 +186,7 @@ bool ExitedWithCode::operator()(int exit_status) const {
 #endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
 }
-#if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+#if !defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_FUCHSIA)
 // KilledBySignal constructor.
 KilledBySignal::KilledBySignal(int signum) : signum_(signum) {}
@ -209,7 +213,7 @@ namespace internal {
 static std::string ExitSummary(int exit_code) {
  Message m;
-#if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+#if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_FUCHSIA)
  m << "Exited with exit status " << exit_code;
@ -236,7 +240,7 @@ bool ExitedUnsuccessfully(int exit_status) {
  return !ExitedWithCode(0)(exit_status);
 }
-#if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+#if !defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_FUCHSIA)
 // Generates a textual failure message when a death test finds more than
 // one thread running, or cannot determine the number of threads, prior
 // to executing the given statement.  It is the responsibility of the
@ -265,7 +269,7 @@ static const char kDeathTestReturned = 'R';
 static const char kDeathTestThrew = 'T';
 static const char kDeathTestInternalError = 'I';
-#if GTEST_OS_FUCHSIA
+#ifdef GTEST_OS_FUCHSIA
 // File descriptor used for the pipe in the child process.
 static const int kFuchsiaReadPipeFd = 3;
@ -297,7 +301,7 @@ enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW };
    fputc(kDeathTestInternalError, parent);
    fprintf(parent, "%s", message.c_str());
    fflush(parent);
-    _exit(1);
+    _Exit(1);
  } else {
    fprintf(stderr, "%s", message.c_str());
    fflush(stderr);
@ -509,7 +513,7 @@ std::string DeathTestImpl::GetErrorLogs() { return GetCapturedStderr(); }
 // Signals that the death test code which should have exited, didn't.
 // Should be called only in a death test child process.
 // Writes a status byte to the child's status file descriptor, then
-// calls _exit(1).
+// calls _Exit(1).
 void DeathTestImpl::Abort(AbortReason reason) {
  // The parent process considers the death test to be a failure if
  // it finds any data in our pipe.  So, here we write a single flag byte
@ -521,13 +525,13 @@ void DeathTestImpl::Abort(AbortReason reason) {
  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1));
  // We are leaking the descriptor here because on some platforms (i.e.,
  // when built as Windows DLL), destructors of global objects will still
-  // run after calling _exit(). On such systems, write_fd_ will be
+  // run after calling _Exit(). On such systems, write_fd_ will be
  // indirectly closed from the destructor of UnitTestImpl, causing double
  // close if it is also closed here. On debug configurations, double close
  // may assert. As there are no in-process buffers to flush here, we are
  // relying on the OS to close the descriptor after the process terminates
  // when the destructors are not run.
-  _exit(1);  // Exits w/o any normal exit hooks (we were supposed to crash)
+  _Exit(1);  // Exits w/o any normal exit hooks (we were supposed to crash)
 }
 // Returns an indented copy of stderr output for a death test.
@ -623,18 +627,21 @@ bool DeathTestImpl::Passed(bool status_ok) {
  return success;
 }
 #ifndef GTEST_OS_WINDOWS
 // Note: The return value points into args, so the return value's lifetime is
 // bound to that of args.
-std::unique_ptr<char*[]> CreateArgvFromArgs(std::vector<std::string>& args) {
+static std::vector<char*> CreateArgvFromArgs(std::vector<std::string>& args) {
-  auto result = std::make_unique<char*[]>(args.size() + 1);
+  std::vector<char*> result;
-  for (size_t i = 0; i < args.size(); ++i) {
+  result.reserve(args.size() + 1);
-    result[i] = &args[i][0];
+  for (auto& arg : args) {
    result.push_back(&arg[0]);
  }
-  result[args.size()] = nullptr;  // extra null terminator
+  result.push_back(nullptr);  // Extra null terminator.
  return result;
 }
 #endif
-#if GTEST_OS_WINDOWS
+#ifdef GTEST_OS_WINDOWS
 // WindowsDeathTest implements death tests on Windows. Due to the
 // specifics of starting new processes on Windows, death tests there are
 // always threadsafe, and Google Test considers the
@ -778,7 +785,7 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
      StreamableToString(static_cast<unsigned int>(::GetCurrentProcessId())) +
      // size_t has the same width as pointers on both 32-bit and 64-bit
      // Windows platforms.
-      // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
+      // See https://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
      "|" + StreamableToString(reinterpret_cast<size_t>(write_handle)) + "|" +
      StreamableToString(reinterpret_cast<size_t>(event_handle_.Get()));
@ -821,7 +828,7 @@ DeathTest::TestRole WindowsDeathTest::AssumeRole() {
  return OVERSEE_TEST;
 }
-#elif GTEST_OS_FUCHSIA
+#elif defined(GTEST_OS_FUCHSIA)
 class FuchsiaDeathTest : public DeathTestImpl {
 public:
@ -1024,8 +1031,13 @@ DeathTest::TestRole FuchsiaDeathTest::AssumeRole() {
  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
  // Spawn the child process.
-  std::unique_ptr<char*[]> argv = CreateArgvFromArgs(args);
+  // Note: The test component must have `fuchsia.process.Launcher` declared
-  status = fdio_spawn_etc(child_job, FDIO_SPAWN_CLONE_ALL, argv[0], argv.get(),
+  // in its manifest. (Fuchsia integration tests require creating a
  // "Fuchsia Test Component" which contains a "Fuchsia Component Manifest")
  // Launching processes is a privileged operation in Fuchsia, and the
  // declaration indicates that the ability is required for the component.
  std::vector<char*> argv = CreateArgvFromArgs(args);
  status = fdio_spawn_etc(child_job, FDIO_SPAWN_CLONE_ALL, argv[0], argv.data(),
                          nullptr, 2, spawn_actions,
                          child_process_.reset_and_get_address(), nullptr);
  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
@ -1118,7 +1130,7 @@ DeathTest::TestRole NoExecDeathTest::AssumeRole() {
    LogToStderr();
    // Event forwarding to the listeners of event listener API mush be shut
    // down in death test subprocesses.
-    GetUnitTestImpl()->listeners()->SuppressEventForwarding();
+    GetUnitTestImpl()->listeners()->SuppressEventForwarding(true);
    g_in_fast_death_test_child = true;
    return EXECUTE_TEST;
  } else {
@ -1164,7 +1176,7 @@ struct ExecDeathTestArgs {
  int close_fd;       // File descriptor to close; the read end of a pipe
 };
-#if GTEST_OS_QNX
+#ifdef GTEST_OS_QNX
 extern "C" char** environ;
 #else   // GTEST_OS_QNX
 // The main function for a threadsafe-style death test child process.
@ -1245,7 +1257,7 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
  ExecDeathTestArgs args = {argv, close_fd};
  pid_t child_pid = -1;
-#if GTEST_OS_QNX
+#ifdef GTEST_OS_QNX
  // Obtains the current directory and sets it to be closed in the child
  // process.
  const int cwd_fd = open(".", O_RDONLY);
@ -1276,7 +1288,7 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd));
 #else  // GTEST_OS_QNX
-#if GTEST_OS_LINUX
+#ifdef GTEST_OS_LINUX
  // When a SIGPROF signal is received while fork() or clone() are executing,
  // the process may hang. To avoid this, we ignore SIGPROF here and re-enable
  // it after the call to fork()/clone() is complete.
@ -1323,11 +1335,10 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
 #endif  // GTEST_HAS_CLONE
  if (use_fork && (child_pid = fork()) == 0) {
-    ExecDeathTestChildMain(&args);
+    _Exit(ExecDeathTestChildMain(&args));
    _exit(0);
  }
 #endif  // GTEST_OS_QNX
-#if GTEST_OS_LINUX
+#ifdef GTEST_OS_LINUX
  GTEST_DEATH_TEST_CHECK_SYSCALL_(
      sigaction(SIGPROF, &saved_sigprof_action, nullptr));
 #endif  // GTEST_OS_LINUX
@ -1377,8 +1388,8 @@ DeathTest::TestRole ExecDeathTest::AssumeRole() {
  // is necessary.
  FlushInfoLog();
-  std::unique_ptr<char*[]> argv = CreateArgvFromArgs(args);
+  std::vector<char*> argv = CreateArgvFromArgs(args);
-  const pid_t child_pid = ExecDeathTestSpawnChild(argv.get(), pipe_fd[0]);
+  const pid_t child_pid = ExecDeathTestSpawnChild(argv.data(), pipe_fd[0]);
  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
  set_child_pid(child_pid);
  set_read_fd(pipe_fd[0]);
@ -1419,14 +1430,14 @@ bool DefaultDeathTestFactory::Create(const char* statement,
    }
  }
-#if GTEST_OS_WINDOWS
+#ifdef GTEST_OS_WINDOWS
  if (GTEST_FLAG_GET(death_test_style) == "threadsafe" ||
      GTEST_FLAG_GET(death_test_style) == "fast") {
    *test = new WindowsDeathTest(statement, std::move(matcher), file, line);
  }
-#elif GTEST_OS_FUCHSIA
+#elif defined(GTEST_OS_FUCHSIA)
  if (GTEST_FLAG_GET(death_test_style) == "threadsafe" ||
      GTEST_FLAG_GET(death_test_style) == "fast") {
@ -1453,7 +1464,7 @@ bool DefaultDeathTestFactory::Create(const char* statement,
  return true;
 }
-#if GTEST_OS_WINDOWS
+#ifdef GTEST_OS_WINDOWS
 // Recreates the pipe and event handles from the provided parameters,
 // signals the event, and returns a file descriptor wrapped around the pipe
 // handle. This function is called in the child process only.
@ -1520,7 +1531,7 @@ static int GetStatusFileDescriptor(unsigned int parent_process_id,
 // initialized from the GTEST_FLAG(internal_run_death_test) flag if
 // the flag is specified; otherwise returns NULL.
 InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
-  if (GTEST_FLAG_GET(internal_run_death_test) == "") return nullptr;
+  if (GTEST_FLAG_GET(internal_run_death_test).empty()) return nullptr;
  // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
  // can use it here.
@ -1530,7 +1541,7 @@ InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
  SplitString(GTEST_FLAG_GET(internal_run_death_test), '|', &fields);
  int write_fd = -1;
-#if GTEST_OS_WINDOWS
+#ifdef GTEST_OS_WINDOWS
  unsigned int parent_process_id = 0;
  size_t write_handle_as_size_t = 0;
@ -1547,7 +1558,7 @@ InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
  write_fd = GetStatusFileDescriptor(parent_process_id, write_handle_as_size_t,
                                     event_handle_as_size_t);
-#elif GTEST_OS_FUCHSIA
+#elif defined(GTEST_OS_FUCHSIA)
  if (fields.size() != 3 || !ParseNaturalNumber(fields[1], &line) ||
      !ParseNaturalNumber(fields[2], &index)) {
--- a/Show more
+++ b/Show more