2025-12-07 17:26:53 +08:00
104 changed files with 2122 additions and 5020 deletions
--- a/.github/workflows/gtest-ci.yml
+++ b/.github/workflows/gtest-ci.yml
@ -0,0 +1,43 @@
+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/.gitignore
+++ b/.gitignore
@ -8,7 +8,6 @@ bazel-genfiles
 bazel-googletest
 bazel-out
 bazel-testlogs
-MODULE.bazel.lock
 # python
 *.pyc

--- a/BUILD.bazel
+++ b/BUILD.bazel
@ -30,8 +30,6 @@
 #
 #   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"])
@ -58,12 +56,6 @@ 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 = {
@ -85,10 +77,6 @@ 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(
@ -144,41 +132,24 @@ cc_library(
    }),
    deps = select({
        ":has_absl": [
-            "@abseil-cpp//absl/container:flat_hash_set",
-            "@abseil-cpp//absl/debugging:failure_signal_handler",
-            "@abseil-cpp//absl/debugging:stacktrace",
-            "@abseil-cpp//absl/debugging:symbolize",
-            "@abseil-cpp//absl/flags:flag",
-            "@abseil-cpp//absl/flags:parse",
-            "@abseil-cpp//absl/flags:reflection",
-            "@abseil-cpp//absl/flags:usage",
-            "@abseil-cpp//absl/strings",
-            "@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",
+            "@com_google_absl//absl/container:flat_hash_set",
+            "@com_google_absl//absl/debugging:failure_signal_handler",
+            "@com_google_absl//absl/debugging:stacktrace",
+            "@com_google_absl//absl/debugging:symbolize",
+            "@com_google_absl//absl/flags:flag",
+            "@com_google_absl//absl/flags:parse",
+            "@com_google_absl//absl/flags:reflection",
+            "@com_google_absl//absl/flags:usage",
+            "@com_google_absl//absl/strings",
+            "@com_google_absl//absl/types:any",
+            "@com_google_absl//absl/types:optional",
+            "@com_google_absl//absl/types:variant",
+            "@com_googlesource_code_re2//:re2",
        ],
        "//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"],
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,10 +1,10 @@
 # Note: CMake support is community-based. The maintainers do not use CMake
 # internally.

-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.13)

 project(googletest-distribution)
-set(GOOGLETEST_VERSION 1.16.0)
+set(GOOGLETEST_VERSION 1.14.0)

 if(NOT CYGWIN AND NOT MSYS AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL QNX)
  set(CMAKE_CXX_EXTENSIONS OFF)
@ -15,20 +15,11 @@ 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/CONTRIBUTING.md
+++ b/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](https://groups.google.com/group/googletestframework) and the
+[discussion group](http://groups.google.com/group/googletestframework) and the
 GitHub repository. Likewise, the Google Mock community exists primarily through
-their own [discussion group](https://groups.google.com/group/googlemock). You
-are definitely encouraged to contribute to the discussion and you can also help
-us to keep the effectiveness of the group high by following and promoting the
+their own [discussion group](http://groups.google.com/group/googlemock). You are
+definitely encouraged to contribute to the discussion and you can also help us
+to keep the effectiveness of the group high by following and promoting the
 guidelines listed here.

 ### Please Be Friendly
--- a/1
+++ b/1
@ -55,7 +55,6 @@ 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/MODULE.bazel
+++ b/MODULE.bazel
@ -1,81 +0,0 @@
-# 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 = "head",
-    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 = "20250814.0",
-)
-bazel_dep(
-    name = "platforms",
-    version = "0.0.11",
-)
-bazel_dep(
-    name = "re2",
-    version = "2024-07-02.bcr.1",
-)
-
-bazel_dep(
-    name = "rules_cc",
-    version = "0.2.8"
-)
-
-bazel_dep(
-    name = "rules_python",
-    version = "1.3.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.12",
-)
-
-# 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/README.md
+++ b/README.md
@ -2,28 +2,40 @@

 ### 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).
+We do publish occasional semantic versions, tagged with
+`v${major}.${minor}.${patch}` (e.g. `v1.13.0`).
+
 #### 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.17.0
+#### Release 1.13.0

-[Release 1.17.0](https://github.com/google/googletest/releases/tag/v1.17.0) is
+[Release 1.13.0](https://github.com/google/googletest/releases/tag/v1.13.0) is
 now available.

-The 1.17.x branch
-[requires at least C++17](https://opensource.google/documentation/policies/cplusplus-support#c_language_standard).
+The 1.13.x branch requires at least C++14.

 #### 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!

@ -88,12 +100,12 @@ tools.
 In addition to many internal projects at Google, GoogleTest is also used by the
 following notable projects:

-*   The [Chromium projects](https://www.chromium.org/) (behind the Chrome
-    browser and Chrome OS).
-*   The [LLVM](https://llvm.org/) compiler.
+*   The [Chromium projects](http://www.chromium.org/) (behind the Chrome browser
+    and Chrome OS).
+*   The [LLVM](http://llvm.org/) compiler.
 *   [Protocol Buffers](https://github.com/google/protobuf), Google's data
    interchange format.
-*   The [OpenCV](https://opencv.org/) computer vision library.
+*   The [OpenCV](http://opencv.org/) computer vision library.

 ## Related Open Source Projects

--- a/64
+++ b/64
@ -1,34 +1,4 @@
-# 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")
+workspace(name = "com_google_googletest")

 load("//:googletest_deps.bzl", "googletest_deps")
 googletest_deps()
@ -36,26 +6,22 @@ googletest_deps()
 load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

 http_archive(
-    name = "rules_python",
-    sha256 = "2cc26bbd53854ceb76dd42a834b1002cd4ba7f8df35440cf03482e045affc244",
-    strip_prefix = "rules_python-1.3.0",
-    url = "https://github.com/bazelbuild/rules_python/releases/download/1.3.0/rules_python-1.3.0.tar.gz",
+  name = "rules_python",  # 2023-07-31T20:39:27Z
+  sha256 = "1250b59a33c591a1c4ba68c62e95fc88a84c334ec35a2e23f46cbc1b9a5a8b55",
+  strip_prefix = "rules_python-e355becc30275939d87116a4ec83dad4bb50d9e1",
+  urls = ["https://github.com/bazelbuild/rules_python/archive/e355becc30275939d87116a4ec83dad4bb50d9e1.zip"],
 )
-# https://github.com/bazelbuild/rules_python/releases/tag/1.1.0
-load("@rules_python//python:repositories.bzl", "py_repositories")
-py_repositories()

 http_archive(
-    name = "platforms",
-    urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/platforms/releases/download/0.0.11/platforms-0.0.11.tar.gz",
-        "https://github.com/bazelbuild/platforms/releases/download/0.0.11/platforms-0.0.11.tar.gz",
-    ],
-    sha256 = "29742e87275809b5e598dc2f04d86960cc7a55b3067d97221c9abbc9926bff0f",
+  name = "bazel_skylib",  # 2023-05-31T19:24:07Z
+  sha256 = "08c0386f45821ce246bbbf77503c973246ed6ee5c3463e41efc197fa9bc3a7f4",
+  strip_prefix = "bazel-skylib-288731ef9f7f688932bd50e704a91a45ec185f9b",
+  urls = ["https://github.com/bazelbuild/bazel-skylib/archive/288731ef9f7f688932bd50e704a91a45ec185f9b.zip"],
 )

-load("@bazel_features//:deps.bzl", "bazel_features_deps")
-bazel_features_deps()
-
-load("@rules_cc//cc:extensions.bzl", "compatibility_proxy_repo")
-compatibility_proxy_repo()
+http_archive(
+  name = "platforms",  # 2023-07-28T19:44:27Z
+  sha256 = "40eb313613ff00a5c03eed20aba58890046f4d38dec7344f00bb9a8867853526",
+  strip_prefix = "platforms-4ad40ef271da8176d4fc0194d2089b8a76e19d7b",
+  urls = ["https://github.com/bazelbuild/platforms/archive/4ad40ef271da8176d4fc0194d2089b8a76e19d7b.zip"],
+)
--- a/WORKSPACE.bzlmod
+++ b/WORKSPACE.bzlmod
@ -1,35 +0,0 @@
-# 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/ci/linux-presubmit.sh
+++ b/ci/linux-presubmit.sh
@ -31,67 +31,39 @@

 set -euox pipefail

-readonly LINUX_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest:20250430"
-readonly LINUX_GCC_FLOOR_CONTAINER="gcr.io/google.com/absl-177019/linux_gcc-floor:20250430"
+readonly LINUX_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest:20230217"
+readonly LINUX_GCC_FLOOR_CONTAINER="gcr.io/google.com/absl-177019/linux_gcc-floor:20230120"

 if [[ -z ${GTEST_ROOT:-} ]]; then
  GTEST_ROOT="$(realpath $(dirname ${0})/..)"
 fi

-# Use Bazel Vendor mode to reduce reliance on external dependencies.
-# See https://bazel.build/external/vendor and the Dockerfile for
-# an explaination of how this works.
-if [[ ${KOKORO_GFILE_DIR:-} ]] && [[ -f "${KOKORO_GFILE_DIR}/distdir/googletest_vendor.tar.gz" ]]; then
-  DOCKER_EXTRA_ARGS="--mount type=bind,source=${KOKORO_GFILE_DIR}/distdir,target=/distdir,readonly --env=BAZEL_VENDOR_ARCHIVE=/distdir/googletest_vendor.tar.gz ${DOCKER_EXTRA_ARGS:-}"
-  BAZEL_EXTRA_ARGS="--vendor_dir=/googletest_vendor ${BAZEL_EXTRA_ARGS:-}"
-fi
-
 if [[ -z ${STD:-} ]]; then
-  STD="c++17 c++20 c++23"
+  STD="c++14 c++17 c++20"
 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=/usr/local/bin/gcc" \
-    --env=CXXFLAGS="-Werror -Wdeprecated" \
-    ${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
-
-# 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/clang/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"
+# Test the CMake build
+for cc in /usr/local/bin/gcc /opt/llvm/clang/bin/clang; do
+  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=CXXFLAGS="-Werror -Wdeprecated" \
+      ${LINUX_LATEST_CONTAINER} \
+      /bin/bash -c "
+        cmake /src \
+          -DCMAKE_CXX_STANDARD=14 \
+          -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
 done

 # Do one test with an older version of GCC
@ -100,22 +72,19 @@ time docker run \
  --workdir="/src" \
  --rm \
  --env="CC=/usr/local/bin/gcc" \
-  --env="BAZEL_CXXOPTS=-std=c++17" \
-  ${DOCKER_EXTRA_ARGS:-} \
+  --env="BAZEL_CXXOPTS=-std=c++14" \
  ${LINUX_GCC_FLOOR_CONTAINER} \
-  /bin/bash --login -c "
    /usr/local/bin/bazel test ... \
-      --copt=\"-Wall\" \
-      --copt=\"-Werror\" \
-      --copt=\"-Wuninitialized\" \
-      --copt=\"-Wundef\" \
-      --copt=\"-Wno-error=pragmas\" \
-      --enable_bzlmod=false \
+      --copt="-Wall" \
+      --copt="-Werror" \
+      --copt="-Wuninitialized" \
+      --copt="-Wundef" \
+      --copt="-Wno-error=pragmas" \
+      --distdir="/bazel-distdir" \
      --features=external_include_paths \
      --keep_going \
      --show_timestamps \
-      --test_output=errors \
-      ${BAZEL_EXTRA_ARGS:-}"
+      --test_output=errors

 # Test GCC
 for std in ${STD}; do
@ -126,21 +95,18 @@ for std in ${STD}; do
      --rm \
      --env="CC=/usr/local/bin/gcc" \
      --env="BAZEL_CXXOPTS=-std=${std}" \
-      ${DOCKER_EXTRA_ARGS:-} \
      ${LINUX_LATEST_CONTAINER} \
-      /bin/bash --login -c "
-        /usr/local/bin/bazel test ... \
-          --copt=\"-Wall\" \
-          --copt=\"-Werror\" \
-          --copt=\"-Wuninitialized\" \
-          --copt=\"-Wundef\" \
-          --define=\"absl=${absl}\" \
-          --enable_bzlmod=true \
-          --features=external_include_paths \
-          --keep_going \
-          --show_timestamps \
-          --test_output=errors \
-          ${BAZEL_EXTRA_ARGS:-}"
+      /usr/local/bin/bazel test ... \
+        --copt="-Wall" \
+        --copt="-Werror" \
+        --copt="-Wuninitialized" \
+        --copt="-Wundef" \
+        --define="absl=${absl}" \
+        --distdir="/bazel-distdir" \
+        --features=external_include_paths \
+        --keep_going \
+        --show_timestamps \
+        --test_output=errors
  done
 done

@ -153,22 +119,19 @@ for std in ${STD}; do
      --rm \
      --env="CC=/opt/llvm/clang/bin/clang" \
      --env="BAZEL_CXXOPTS=-std=${std}" \
-      ${DOCKER_EXTRA_ARGS:-} \
      ${LINUX_LATEST_CONTAINER} \
-      /bin/bash --login -c "
-        /usr/local/bin/bazel test ... \
-          --copt=\"--gcc-toolchain=/usr/local\" \
-          --copt=\"-Wall\" \
-          --copt=\"-Werror\" \
-          --copt=\"-Wuninitialized\" \
-          --copt=\"-Wundef\" \
-          --define=\"absl=${absl}\" \
-          --enable_bzlmod=true \
-          --features=external_include_paths \
-          --keep_going \
-          --linkopt=\"--gcc-toolchain=/usr/local\" \
-          --show_timestamps \
-          --test_output=errors \
-          ${BAZEL_EXTRA_ARGS:-}"
+      /usr/local/bin/bazel test ... \
+        --copt="--gcc-toolchain=/usr/local" \
+        --copt="-Wall" \
+        --copt="-Werror" \
+        --copt="-Wuninitialized" \
+        --copt="-Wundef" \
+        --define="absl=${absl}" \
+        --distdir="/bazel-distdir" \
+        --features=external_include_paths \
+        --keep_going \
+        --linkopt="--gcc-toolchain=/usr/local" \
+        --show_timestamps \
+        --test_output=errors
  done
 done
--- a/ci/macos-presubmit.sh
+++ b/ci/macos-presubmit.sh
@ -31,9 +31,6 @@

 set -euox pipefail

-# Use Xcode 16.0
-sudo xcode-select -s /Applications/Xcode_16.0.app/Contents/Developer
-
 if [[ -z ${GTEST_ROOT:-} ]]; then
  GTEST_ROOT="$(realpath $(dirname ${0})/..)"
 fi
@ -43,20 +40,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=17 \
+    -DCMAKE_CXX_STANDARD=14 \
    -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 -j$(nproc)
+  time make
  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-8.2.1-darwin-x86_64"
+KOKORO_GFILE_BAZEL_BIN="bazel-5.1.1-darwin-x86_64"
 if [[ ${KOKORO_GFILE_DIR:-} ]] && [[ -f ${KOKORO_GFILE_DIR}/${KOKORO_GFILE_BAZEL_BIN} ]]; then
  BAZEL_BIN="${KOKORO_GFILE_DIR}/${KOKORO_GFILE_BAZEL_BIN}"
  chmod +x ${BAZEL_BIN}
@ -64,24 +61,16 @@ 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" \
    --copt="-Wundef" \
-    --cxxopt="-std=c++17" \
+    --cxxopt="-std=c++14" \
    --define="absl=${absl}" \
-    --enable_bzlmod=true \
    --features=external_include_paths \
    --keep_going \
    --show_timestamps \
-    --test_output=errors \
-    ${BAZEL_EXTRA_ARGS:-}
+    --test_output=errors
 done
--- a/ci/windows-presubmit.bat
+++ b/ci/windows-presubmit.bat
@ -1,6 +1,6 @@
 SETLOCAL ENABLEDELAYEDEXPANSION

-SET BAZEL_EXE=%KOKORO_GFILE_DIR%\bazel-8.2.1-windows-x86_64.exe
+SET BAZEL_EXE=%KOKORO_GFILE_DIR%\bazel-5.1.1-windows-x86_64.exe

 SET PATH=C:\Python34;%PATH%
 SET BAZEL_PYTHON=C:\python34\python.exe
@ -11,18 +11,21 @@ SET CTEST_OUTPUT_ON_FAILURE=1
 SET CMAKE_BUILD_PARALLEL_LEVEL=16
 SET CTEST_PARALLEL_LEVEL=16

-SET GTEST_ROOT=%~dp0\..
+IF EXIST git\googletest (
+  CD git\googletest
+) ELSE IF EXIST github\googletest (
+  CD github\googletest
+)
+
 IF %errorlevel% neq 0 EXIT /B 1

 :: ----------------------------------------------------------------------------
 :: CMake
-SET CMAKE_BUILD_PATH=cmake_msvc2022
-MKDIR %CMAKE_BUILD_PATH%
-CD %CMAKE_BUILD_PATH%
+MKDIR cmake_msvc2022
+CD cmake_msvc2022

-%CMAKE_BIN% %GTEST_ROOT% ^
+%CMAKE_BIN% .. ^
  -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 ^
@ -37,49 +40,19 @@ IF %errorlevel% neq 0 EXIT /B 1
 %CTEST_BIN% -C Debug --timeout 600
 IF %errorlevel% neq 0 EXIT /B 1

-CD %GTEST_ROOT%
-RMDIR /S /Q %CMAKE_BUILD_PATH%
+CD ..
+RMDIR /S /Q cmake_msvc2022

 :: ----------------------------------------------------------------------------
 :: Bazel

-:: The default home directory on Kokoro is a long path which causes errors
-:: 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 ... ^
+%BAZEL_EXE% test ... ^
  --compilation_mode=dbg ^
-  --copt=/std:c++17 ^
+  --copt=/std:c++14 ^
  --copt=/WX ^
-  --enable_bzlmod=true ^
+  --features=external_include_paths ^
  --keep_going ^
  --test_output=errors ^
-  --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 ^
-  --test_output=errors ^
-  --test_tag_filters=-no_test_msvc2017 ^
-  %VENDOR_FLAG%
+  --test_tag_filters=-no_test_msvc2017
 IF %errorlevel% neq 0 EXIT /B 1
--- a/docs/_layouts/default.html
+++ b/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.dataLayer = window.dataLayer || [];
-      function gtag(){dataLayer.push(arguments);}
-      gtag('js', new Date());
-
-      gtag('config', 'G-9PTP6FW1M5');
+      window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)};ga.l=+new Date;
+      ga('create', 'UA-197576187-1', { 'storage': 'none' });
+      ga('set', 'referrer', document.referrer.split('?')[0]);
+      ga('set', 'location', window.location.href.split('?')[0]);
+      ga('set', 'anonymizeIp', true);
+      ga('send', 'pageview');
    </script>
+    <script async src='https://www.google-analytics.com/analytics.js'></script>
  </head>
  <body>
    <div class="sidebar">
--- a/docs/advanced.md
+++ b/docs/advanced.md
@ -286,7 +286,7 @@ For example:
 ```c++
 TEST(SkipTest, DoesSkip) {
  GTEST_SKIP() << "Skipping single test";
-  FAIL();  // Won't fail; it won't be executed
+  EXPECT_EQ(0, 1);  // Won't fail; it won't be executed
 }

 class SkipFixture : public ::testing::Test {
@ -298,7 +298,7 @@ class SkipFixture : public ::testing::Test {

 // Tests for SkipFixture won't be executed.
 TEST_F(SkipFixture, SkipsOneTest) {
-  FAIL();  // Won't fail; it won't be executed
+  EXPECT_EQ(5, 7);  // Won't fail
 }
 ```

@ -349,8 +349,7 @@ void AbslStringify(Sink& sink, EnumWithStringify e) {
 {: .callout .note}
 Note: `AbslStringify()` utilizes a generic "sink" buffer to construct its
 string. For more information about supported operations on `AbslStringify()`'s
-sink, see
-[the `AbslStringify()` documentation](https://abseil.io/docs/cpp/guides/abslstringify).
+sink, see go/abslstringify.

 `AbslStringify()` can also use `absl::StrFormat`'s catch-all `%v` type specifier
 within its own format strings to perform type deduction. `Point` above could be
@ -404,53 +403,7 @@ EXPECT_TRUE(IsCorrectPointIntVector(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.
+libraries, see go/abslstringify.

 ## Death Tests

@ -463,7 +416,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"
@ -509,12 +462,6 @@ 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.

@ -556,6 +503,51 @@ 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
@ -735,7 +727,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++
@ -907,10 +899,10 @@ also supports per-test-suite set-up/tear-down. To use it:
    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 public member function `static void
-    SetUpTestSuite()` (remember not to spell it as **`SetupTestSuite`** with a
-    small `u`!) to set up the shared resources and a `static void
-    TearDownTestSuite()` function to tear them down.
+3.  In the same test fixture class, define a `static void SetUpTestSuite()`
+    function (remember not to spell it as **`SetupTestSuite`** with a small
+    `u`!) to set up the shared resources and a `static void TearDownTestSuite()`
+    function to tear them down.

 That's it! GoogleTest automatically calls `SetUpTestSuite()` before running the
 *first test* in the `FooTest` test suite (i.e. before creating the first
@ -1012,21 +1004,11 @@ calling the `::testing::AddGlobalTestEnvironment()` function:
 Environment* AddGlobalTestEnvironment(Environment* env);
 ```

-Now, when `RUN_ALL_TESTS()` is invoked, it first calls the `SetUp()` method. The
-tests are then executed, provided that none of the environments have reported
-fatal failures and `GTEST_SKIP()` has not been invoked. Finally, `TearDown()` is
-called.
-
-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.
+Now, when `RUN_ALL_TESTS()` is called, it first calls the `SetUp()` method of
+each environment object, then runs the tests if none of the environments
+reported fatal failures and `GTEST_SKIP()` was not called. `RUN_ALL_TESTS()`
+always calls `TearDown()` with each environment object, regardless of whether or
+not the tests were run.

 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
@ -1450,19 +1432,17 @@ 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, move the
-    private code into the `foo::internal` namespace, where `foo` is the
-    namespace your project normally uses, and put the private declarations in a
-    `*-internal.h` file. Your production `.cc` files and your tests are allowed
-    to include this internal header, but your clients are not. This way, you can
-    fully test your internal implementation without leaking it to your clients.
+    are only visible within the same translation unit. To test them, you can
+    `#include` the entire `.cc` file being tested in your `*_test.cc` file.
+    (#including `.cc` files is not a good way to reuse code - you should not do
+    this in production code!)

-{: .callout .note}
-NOTE: It is also technically *possible* to `#include` the entire `.cc` file
-being tested in your `*_test.cc` file to test static functions and
-definitions/declarations in an unnamed namespace. However, this technique is
-**not recommended** by this documentation and it is only presented here for the
-sake of completeness.
+    However, a better approach is to move the private code into the
+    `foo::internal` namespace, where `foo` is the namespace your project
+    normally uses, and put the private declarations in a `*-internal.h` file.
+    Your production `.cc` files and your tests are allowed to include this
+    internal header, but your clients are not. This way, you can fully test your
+    internal implementation without leaking it to your clients.

 *   Private class members are only accessible from within the class or by
    friends. To access a class' private members, you can declare your test
@ -1475,7 +1455,10 @@ sake of completeness.

    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.
+    clients aren't allowed to include this header but your tests can. Such is
+    called the
+    [Pimpl](https://www.gamedev.net/articles/programming/general-and-gameplay-programming/the-c-pimpl-r1794/)
+    (Private Implementation) idiom.

    Or, you can declare an individual test as a friend of your class by adding
    this line in the class body:
@ -1821,7 +1804,7 @@ 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.
+with the `--help` flag. You can also use `-h`, `-?`, or `/?` for short.

 If an option is specified both by an environment variable and by a flag, the
 latter takes precedence.
@ -1930,35 +1913,6 @@ 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
@ -2217,7 +2171,7 @@ The report format conforms to the following JSON Schema:

 ```json
 {
-  "$schema": "https://json-schema.org/schema#",
+  "$schema": "http://json-schema.org/schema#",
  "type": "object",
  "definitions": {
    "TestCase": {
@ -2418,7 +2372,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
--- a/docs/faq.md
+++ b/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 followed
-by an upper-case letter. But that's getting complicated. So for simplicity we
-just say that it cannot start with `_`.).
+(Actually, `TestSuiteName` can start with `_` -- as long as the `_` isn't
+followed by an upper-case letter. But that's getting complicated. So for
+simplicity we just say that it cannot start with `_`.).

 It may seem fine for `TestSuiteName` and `TestName` to contain `_` in the
 middle. However, consider this:
@ -128,9 +128,30 @@ 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
@ -171,16 +192,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 generate an "undefined reference" linker error. The fact that "it used to
-work" doesn't mean it's valid. It just means that you were lucky. :-)
+particular, using it in GoogleTest comparison assertions (`EXPECT_EQ`, etc) will
+generate an "undefined reference" linker error. The fact that "it used to 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
@ -290,7 +311,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
@ -331,7 +352,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.
@ -389,7 +410,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

@ -511,7 +532,20 @@ 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 GoogleTest require the entire test suite, instead of individual tests, to be named `*DeathTest` when it uses `ASSERT_DEATH`?
+## Why does ASSERT_DEATH complain about previous threads that were already joined?
+
+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
@ -536,7 +570,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
@ -573,7 +607,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](https://abseil.io/tips/49) for details.
+[Tip of the Week #49](http://abseil.io/tips/49) for details.

 ## How do I suppress the memory leak messages on Windows?

@ -594,10 +628,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](https://en.wikipedia.org/wiki/Dependency_injection). You can inject
+test is [Dependency Injection](http://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`](https://docs.bazel.build/versions/master/be/common-definitions.html#common.testonly) attribute for BUILD targets helps to ensure
+[`testonly`](http://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
@ -620,7 +654,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/docs/gmock_cheat_sheet.md
+++ b/docs/gmock_cheat_sheet.md
@ -130,7 +130,7 @@ TEST(BarTest, DoesThis) {
 ## Setting Default Actions {#OnCall}

 gMock has a **built-in default action** for any function that returns `void`,
-`bool`, a numeric value, or a pointer. In C++11, it additionally returns
+`bool`, a numeric value, or a pointer. In C++11, it will 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
--- a/docs/gmock_cook_book.md
+++ b/docs/gmock_cook_book.md
@ -177,7 +177,7 @@ class StackInterface {
 template <typename Elem>
 class MockStack : public StackInterface<Elem> {
  ...
-  MOCK_METHOD(int, GetSize, (), (const, override));
+  MOCK_METHOD(int, GetSize, (), (override));
  MOCK_METHOD(void, Push, (const Elem& x), (override));
 };
 ```
@ -900,16 +900,15 @@ 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 template
-parameters and `auto`. For example,
+provide meaningful information, it can be easier to express them with C++14
+generic lambdas to avoid specifying types. For example,

 ```cpp
 using ::testing::Contains;
 using ::testing::Property;

-template <typename SubMatcher>
-inline constexpr auto HasFoo(const SubMatcher& sub_matcher) {
-  return Property("foo", &MyClass::foo, Contains(sub_matcher));
+inline constexpr auto HasFoo = [](const auto& f) {
+  return Property("foo", &MyClass::foo, Contains(f));
 };
 ...
  EXPECT_THAT(x, HasFoo("blah"));
@ -937,8 +936,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 non-const reference, `T` must also be a reference (as the
-    underlying matcher may be interested in the address of the `U` value).
+3.  When `U` is a reference, `T` must also be a reference (as the 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.

@ -1928,12 +1927,6 @@ 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
@ -3313,7 +3306,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.

-#### Basic Example
+For example:

 ```cpp
 MATCHER(IsDivisibleBy7, "") { return (arg % 7) == 0; }
@ -3351,8 +3344,6 @@ 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:
@ -3386,48 +3377,21 @@ With this definition, the above assertion will give a better message:
    Actual: 27 (the remainder is 6)
 ```

-#### Using EXPECT_ Statements in Matchers
-
-You can also use `EXPECT_...` statements inside custom matcher definitions. In
-many cases, this allows you to write your matcher more concisely while still
-providing an informative error message. For example:
-
-```cpp
-MATCHER(IsDivisibleBy7, "") {
-  const auto remainder = arg % 7;
-  EXPECT_EQ(remainder, 0);
-  return true;
-}
-```
-
-If you write a test that includes the line `EXPECT_THAT(27, IsDivisibleBy7());`,
-you will get an error something like the following:
-
-```shell
-Expected equality of these values:
-  remainder
-    Which is: 6
-  0
-```
-
-#### `MatchAndExplain`
-
 You should let `MatchAndExplain()` print *any additional information* that can
 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.

-#### Argument Types
-
-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 you don't
-need to worry about declaring it (nor can you). This allows the matcher to be
-polymorphic. For example, `IsDivisibleBy7()` can be used to match any type where
-the value of `(arg % 7) == 0` can be implicitly converted to a `bool`. In the
-`Bar(IsDivisibleBy7())` example above, if method `Bar()` takes an `int`,
-`arg_type` will be `int`; if it takes an `unsigned long`, `arg_type` will be
-`unsigned long`; and so on.
+{: .callout .note}
+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
+you don't need to worry about declaring it (nor can you). This allows the
+matcher to be polymorphic. For example, `IsDivisibleBy7()` can be used to match
+any type where the value of `(arg % 7) == 0` can be implicitly converted to a
+`bool`. In the `Bar(IsDivisibleBy7())` example above, if method `Bar()` takes an
+`int`, `arg_type` will be `int`; if it takes an `unsigned long`, `arg_type` will
+be `unsigned long`; and so on.

 ### Writing New Parameterized Matchers Quickly

@ -3568,15 +3532,10 @@ just based on the number of parameters).

 ### Writing New Monomorphic Matchers

-A matcher of type `testing::Matcher<T>` implements the matcher interface for `T`
-and does two things: it tests whether a value of type `T` matches the matcher,
-and can describe what kind of values it matches. The latter ability is used for
-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 argument type `T` implements the matcher interface for `T` and does
+two things: it tests whether a value of type `T` matches the matcher, and can
+describe what kind of values it matches. The latter ability is used for
+generating readable error messages when expectations are violated.

 A matcher of `T` must declare a typedef like:

@ -3668,16 +3627,8 @@ instead of `std::ostream*`.

 ### Writing New Polymorphic Matchers

-Unlike a monomorphic matcher, which can only be used to match a value of a
-particular type, a *polymorphic* matcher is one that can be used to match values
-of multiple types. For example, `Eq(5)` is a polymorhpic matcher as it can be
-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.
+Expanding what we learned above to *polymorphic* matchers is now just as simple
+as adding templates in the right place.

 ```cpp

@ -3803,26 +3754,6 @@ 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
--- a/docs/gmock_for_dummies.md
+++ b/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](https://en.wikipedia.org/wiki/Logo_programming_language)-like
+relies on a [LOGO](http://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](https://en.wikipedia.org/wiki/Dependency_injection) and know the right thing
+[Dependency Injection](http://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:

@ -261,8 +261,6 @@ 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/docs/primer.md
+++ b/docs/primer.md
@ -50,7 +50,7 @@ terms *Test*, *Test Case* and *Test Suite*, so beware of misunderstanding these.

 Historically, GoogleTest started to use the term *Test Case* for grouping
 related tests, whereas current publications, including International Software
-Testing Qualifications Board ([ISTQB](https://www.istqb.org/)) materials and
+Testing Qualifications Board ([ISTQB](http://www.istqb.org/)) materials and
 various textbooks on software quality, use the term
 *[Test Suite][istqb test suite]* for this.

@ -68,13 +68,13 @@ deprecated and refactored away.
 So please be aware of the different definitions of the terms:


-Meaning                                                                              | GoogleTest Term         | [ISTQB](https://www.istqb.org/) Term
+Meaning                                                                              | GoogleTest Term         | [ISTQB](http://www.istqb.org/) Term
 :----------------------------------------------------------------------------------- | :---------------------- | :----------------------------------
 Exercise a particular program path with specific input values and verify the results | [TEST()](#simple-tests) | [Test Case][istqb test case]


-[istqb test case]: https://glossary.istqb.org/en_US/term/test-case
-[istqb test suite]: https://glossary.istqb.org/en_US/term/test-suite
+[istqb test case]: http://glossary.istqb.org/en/search/test%20case
+[istqb test suite]: http://glossary.istqb.org/en/search/test%20suite

 ## Basic Concepts

@ -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
@ -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:
-  QueueTest() {
+  void SetUp() override {
     // q0_ remains empty
     q1_.Enqueue(1);
     q2_.Enqueue(2);
     q2_.Enqueue(3);
  }

-  // ~QueueTest() override = default;
+  // void TearDown() override {}

  Queue<int> q0_;
  Queue<int> q1_;
@ -288,9 +288,8 @@ class QueueTest : public testing::Test {
 };
 ```

-In this case, we don't need to define a destructor or a `TearDown()` method,
-because the implicit destructor generated by the compiler will perform all of
-the necessary cleanup.
+In this case, `TearDown()` is not needed since we don't have to clean up after
+each test, other than what's already done by the destructor.

 Now we'll write tests using `TEST_F()` and this fixture.

@ -327,9 +326,11 @@ 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`).
-2.  The first test (`IsEmptyInitially`) runs on `t1`.
-3.  `t1` is destructed.
-4.  The above steps are repeated on another `QueueTest` object, this time
+2.  `t1.SetUp()` initializes `t1`.
+3.  The first test (`IsEmptyInitially`) runs on `t1`.
+4.  `t1.TearDown()` cleans up after the test finishes.
+5.  `t1` is destructed.
+6.  The above steps are repeated on another `QueueTest` object, this time
    running the `DequeueWorks` test.

 **Availability**: Linux, Windows, Mac.
@ -401,7 +402,7 @@ 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.
@ -449,14 +450,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 GoogleTest
-flags, and removes all recognized flags. This allows the user to control a test
-program's behavior via various flags, which we'll cover in the
+The `::testing::InitGoogleTest()` function parses the command line for
+GoogleTest flags, and removes all recognized flags. This allows the user to
+control a test program's behavior via various flags, which we'll cover in the
 [AdvancedGuide](advanced.md). You **must** call this function before calling
 `RUN_ALL_TESTS()`, or the flags won't be properly initialized.

--- a/docs/quickstart-bazel.md
+++ b/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++17.
-*   [Bazel](https://bazel.build/) 7.0 or higher, the preferred build system used
-    by the GoogleTest team.
+*   A compatible C++ compiler that supports at least C++14.
+*   [Bazel](https://bazel.build/), the preferred build system used 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
-`MODULE.bazel` which may be empty, or may contain references to external
+`WORKSPACE` which may be empty, or may contain references to external
 dependencies required to build the outputs.

 First, create a directory for your workspace:
@ -37,20 +37,30 @@ First, create a directory for your workspace:
 $ mkdir my_workspace && cd my_workspace
 ```

-Next, you’ll create the `MODULE.bazel` file to specify dependencies. As of Bazel
-7.0, the recommended way to consume GoogleTest is through the
-[Bazel Central Registry](https://registry.bazel.build/modules/googletest). To do
-this, create a `MODULE.bazel` file in the root directory of your Bazel workspace
-with the following content:
+Next, you’ll create the `WORKSPACE` file to specify dependencies. A common and
+recommended way to depend on GoogleTest is to use a
+[Bazel external dependency](https://docs.bazel.build/versions/main/external.html)
+via the
+[`http_archive` rule](https://docs.bazel.build/versions/main/repo/http.html#http_archive).
+To do this, in the root directory of your workspace (`my_workspace/`), create a
+file named `WORKSPACE` with the following contents:

 ```
-# MODULE.bazel
+load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

-# Choose the most recent version available at
-# https://registry.bazel.build/modules/googletest
-bazel_dep(name = "googletest", version = "1.17.0")
+http_archive(
+  name = "com_google_googletest",
+  urls = ["https://github.com/google/googletest/archive/5ab508a01f9eb089207ee87fd547d290da39d015.zip"],
+  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
@ -82,33 +92,30 @@ following contents:

 ```
 cc_test(
-    name = "hello_test",
-    size = "small",
-    srcs = ["hello_test.cc"],
-    deps = [
-        "@googletest//:gtest",
-        "@googletest//:gtest_main",
-    ],
+  name = "hello_test",
+  size = "small",
+  srcs = ["hello_test.cc"],
+  deps = ["@com_google_googletest//:gtest_main"],
 )
 ```

 This `cc_test` rule declares the C++ test binary you want to build, and links to
-the GoogleTest library (`@googletest//:gtest"`) and the GoogleTest `main()`
-function (`@googletest//:gtest_main`). For more information about Bazel `BUILD`
-files, see the
+GoogleTest (`//:gtest_main`) using the prefix you specified in the `WORKSPACE`
+file (`@com_google_googletest`). For more information about Bazel `BUILD` files,
+see the
 [Bazel C++ Tutorial](https://docs.bazel.build/versions/main/tutorial/cpp.html).

 {: .callout .note}
-NOTE: In the example below, we assume Clang or GCC and set `--cxxopt=-std=c++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.
+NOTE: In the example below, we assume Clang or GCC and set `--cxxopt=-std=c++14`
+to ensure that GoogleTest is compiled as C++14 instead of the compiler's default
+setting (which could be C++11). For MSVC, the equivalent would be
+`--cxxopt=/std:c++14`. See [Supported Platforms](platforms.md) for more details
+on supported language versions.

 Now you can build and run your test:

 <pre>
-<strong>$ bazel test --cxxopt=-std=c++17 --test_output=all //:hello_test</strong>
+<strong>my_workspace$ bazel test --cxxopt=-std=c++14 --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/docs/quickstart-cmake.md
+++ b/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++17.
+*   A compatible C++ compiler that supports at least C++14.
 *   [CMake](https://cmake.org/) and a compatible build tool for building the
    project.
    *   Compatible build tools include
@ -52,8 +52,8 @@ To do this, in your project directory (`my_project`), create a file named
 cmake_minimum_required(VERSION 3.14)
 project(my_project)

-# GoogleTest requires at least C++17
-set(CMAKE_CXX_STANDARD 17)
+# GoogleTest requires at least C++14
+set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)

 include(FetchContent)
--- a/docs/reference/actions.md
+++ b/docs/reference/actions.md
@ -24,8 +24,7 @@ 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` by copy-assignment. |
-| `SaveArgByMove<N>(pointer)` | Save the `N`-th (0-based) argument to `*pointer` by move-assignment. |
+| `SaveArg<N>(pointer)` | Save the `N`-th (0-based) argument to `*pointer`. |
 | `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. |
@ -48,8 +47,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 (except `InvokeArgument`) is used as
-the return value of the action.
+The return value of the invoked function is used as the return value of the
+action.

 When defining a callable to be used with `Invoke*()`, you can declare any unused
 parameters as `Unused`:
--- a/docs/reference/assertions.md
+++ b/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, add `#include <gtest/gtest.h>`.
+behavior. To use them, include the header `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
@ -276,8 +276,7 @@ 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. Infinity and the largest finite float
-value are considered to be one ULP apart.
+equal, to within 4 ULPs from each other.

 ### EXPECT_DOUBLE_EQ {#EXPECT_DOUBLE_EQ}

@ -285,8 +284,7 @@ value are considered to be one ULP apart.
 `ASSERT_DOUBLE_EQ(`*`val1`*`,`*`val2`*`)`

 Verifies that the two `double` values *`val1`* and *`val2`* are approximately
-equal, to within 4 ULPs from each other. Infinity and the largest finite double
-value are considered to be one ULP apart.
+equal, to within 4 ULPs from each other.

 ### EXPECT_NEAR {#EXPECT_NEAR}

@ -296,11 +294,6 @@ value are considered to be one ULP apart.
 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,
--- a/docs/reference/matchers.md
+++ b/docs/reference/matchers.md
@ -42,14 +42,11 @@ 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 `==`.)|
 | `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. |

@ -112,33 +109,6 @@ 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)`
@ -201,11 +171,6 @@ 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
@ -224,6 +189,10 @@ contract of the function.
    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                                       |
--- a/docs/reference/mocking.md
+++ b/docs/reference/mocking.md
@ -1,7 +1,8 @@
 # Mocking Reference

 This page lists the facilities provided by GoogleTest for creating and working
-with mock objects. To use them, add `#include <gmock/gmock.h>`.
+with mock objects. To use them, include the header
+`gmock/gmock.h`.

 ## Macros {#macros}

--- a/docs/reference/testing.md
+++ b/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, add `#include <gtest/gtest.h>`.
+To use them, include the header `gtest/gtest.h`.

 ## Macros

@ -94,8 +94,7 @@ 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`*. If *`InstantiationName`* is empty
-(`INSTANTIATE_TEST_SUITE_P(, ...)`), no prefix is added.
+*`TestSuiteName`*.

 The argument *`param_generator`* is one of the following GoogleTest-provided
 functions that generate the test parameters, all defined in the `::testing`
@ -110,7 +109,7 @@ 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)` 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. |
+| `ConvertGenerator<T>(g)`     | Yields values generated by generator `g`, `static_cast` to `T`. |

 The optional last argument *`name_generator`* is a function or functor that
 generates custom test name suffixes based on the test parameters. The function
@ -137,107 +136,9 @@ 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`*.
@ -267,22 +168,6 @@ 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.

@ -392,8 +277,7 @@ 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`*. If *`InstantiationName`* is empty
-(`INSTANTIATE_TYPED_TEST_SUITE_P(, ...)`), no prefix is added.
+*`TestSuiteName`*.

 The argument *`Types`* is a [`Types`](#Types) object representing the list of
 types to run the tests on, for example:
@ -1433,9 +1317,7 @@ tests.
 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. 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`.
+is removed from `argv`, and `*argc` is decremented.

 No value is returned. Instead, the GoogleTest flag variables are updated.

--- a/fake_fuchsia_sdk.bzl
+++ b/fake_fuchsia_sdk.bzl
@ -1,61 +0,0 @@
-"""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/googlemock/CMakeLists.txt
+++ b/googlemock/CMakeLists.txt
@ -5,7 +5,7 @@
 # CMake build script for Google Mock.
 #
 # To run the tests for Google Mock itself on Linux, use 'make test' or
-# ctest. You can select which tests to run using 'ctest -R regex'.
+# ctest.  You can select which tests to run using 'ctest -R regex'.
 # For more options, run 'ctest --help'.

 option(gmock_build_tests "Build all of Google Mock's own tests." OFF)
@ -44,7 +44,7 @@ if (COMMAND set_up_hermetic_build)
 endif()

 # Instructs CMake to process Google Test's CMakeLists.txt and add its
-# targets to the current scope. We are placing Google Test's binary
+# targets to the current scope.  We are placing Google Test's binary
 # directory in a subdirectory of our own as VC compilation may break
 # if they are the same (the default).
 add_subdirectory("${gtest_dir}" "${gmock_BINARY_DIR}/${gtest_dir}")
@ -60,26 +60,25 @@ else()
 endif()

 # Although Google Test's CMakeLists.txt calls this function, the
-# changes there don't affect the current scope. Therefore we have to
+# changes there don't affect the current scope.  Therefore we have to
 # call it again here.
-config_compiler_and_linker() # from ${gtest_dir}/cmake/internal_utils.cmake
+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_include_dirs}")
+  "${gtest_SOURCE_DIR}/include"
+  # This directory is needed to build directly from Google Test sources.
+  "${gtest_SOURCE_DIR}")
 include_directories(${gmock_build_include_dirs})

 ########################################################################
 #
-# Defines the gmock & gmock_main libraries. User tests should link
+# Defines the gmock & gmock_main libraries.  User tests should link
 # with one of them.

-# Google Mock libraries. We build them using more strict warnings than what
+# Google Mock libraries.  We build them using more strict warnings than what
 # are used for other targets, to ensure that Google Mock can be compiled by
 # a user aggressive about warnings.
 if (MSVC)
@ -112,7 +111,7 @@ target_include_directories(gmock_main SYSTEM INTERFACE

 ########################################################################
 #
-# Install rules.
+# Install rules
 install_project(gmock gmock_main)

 ########################################################################
@ -122,8 +121,8 @@ install_project(gmock gmock_main)
 # You can skip this section if you aren't interested in testing
 # Google Mock itself.
 #
-# The tests are not built by default. To build them, set the
-# gmock_build_tests option to ON. You can do it by running ccmake
+# The tests are not built by default.  To build them, set the
+# gmock_build_tests option to ON.  You can do it by running ccmake
 # or specifying the -Dgmock_build_tests=ON flag when running cmake.

 if (gmock_build_tests)
@ -188,7 +187,7 @@ if (gmock_build_tests)
  cxx_shared_library(shared_gmock_main "${cxx_default}"
    "${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc)

-  # Tests that a binary can be built with Google Mock as a shared library. On
+  # Tests that a binary can be built with Google Mock as a shared library.  On
  # some system configurations, it may not possible to run the binary without
  # knowing more details about the system configurations. We do not try to run
  # this binary. To get a more robust shared library coverage, configure with
--- a/googlemock/README.md
+++ b/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](https://easymock.org/)
-*   [Hamcrest](https://code.google.com/p/hamcrest/)
+*   [EasyMock](http://www.easymock.org/)
+*   [Hamcrest](http://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](https://github.com/google/googletest/) and a
+[GoogleTest C++ testing framework](http://github.com/google/googletest/) and a
 subject to the same requirements.
--- a/googlemock/include/gmock/gmock-actions.h
+++ b/googlemock/include/gmock/gmock-actions.h
@ -135,7 +135,6 @@
 #endif

 #include <algorithm>
-#include <exception>
 #include <functional>
 #include <memory>
 #include <string>
@ -176,15 +175,9 @@ struct BuiltInDefaultValueGetter<T, false> {
  static T Get() {
    Assert(false, __FILE__, __LINE__,
           "Default action undefined for the function return type.");
-#if defined(__GNUC__) || defined(__clang__)
-    __builtin_unreachable();
-#elif defined(_MSC_VER)
-    __assume(0);
-#else
-    return Invalid<T>();
+    return internal::Invalid<T>();
    // The above statement will never be reached, but is required in
    // order for this function to compile.
-#endif
  }
 };

@ -835,10 +828,6 @@ 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;
  };
@ -1455,30 +1444,6 @@ 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<
@ -1521,7 +1486,6 @@ 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,
@ -1530,21 +1494,6 @@ 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<
@ -1624,16 +1573,16 @@ class DoAllAction<InitialAction, OtherActions...>
      : Base({}, std::forward<U>(other_actions)...),
        initial_action_(std::forward<T>(initial_action)) {}

-  // 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<std::is_convertible<
-                          InitialAction,
-                          OnceAction<void(InitialActionArgType<Args>...)>>,
-                      std::is_convertible<Base, OnceAction<R(Args...)>>>::value,
-          int>::type = 0>
+  template <typename R, typename... Args,
+            typename std::enable_if<
+                conjunction<
+                    // 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,
+                int>::type = 0>
  operator OnceAction<R(Args...)>() && {  // NOLINT
    // Return an action that first calls the initial action with arguments
    // filtered through InitialActionArgType, then forwards arguments directly
@ -1656,34 +1605,12 @@ 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,
@ -1747,16 +1674,6 @@ 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;
@ -1796,24 +1713,11 @@ struct SetArrayArgumentAction {
 };

 template <size_t k>
-class DeleteArgAction {
- public:
+struct DeleteArgAction {
  template <typename... Args>
  void operator()(const Args&... args) const {
-    DoDelete(std::get<k>(std::tie(args...)));
+    delete 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>
@ -1836,13 +1740,6 @@ 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
@ -1879,13 +1776,6 @@ struct RethrowAction {
 //   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.
@ -2051,11 +1941,10 @@ 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);
 }
@ -2128,13 +2017,6 @@ 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>
@ -2174,23 +2056,13 @@ internal::ReturnPointeeAction<Ptr> ReturnPointee(Ptr pointer) {
  return {pointer};
 }

-#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.
+// to throw the given exception.  Any copyable value can be thrown.
+#if GTEST_HAS_EXCEPTIONS
 template <typename T>
-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) {
+internal::ThrowAction<typename std::decay<T>::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 {
@ -2239,13 +2111,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(std::make_index_sequence<kMaxArgs>{},
-                 std::make_index_sequence<10 - kMaxArgs>{},
+    return Apply(MakeIndexSequence<kMaxArgs>{},
+                 MakeIndexSequence<10 - kMaxArgs>{},
                 args_type{std::forward<Args>(arg)...});
  }

  template <std::size_t... arg_id, std::size_t... excess_id>
-  R Apply(std::index_sequence<arg_id...>, std::index_sequence<excess_id...>,
+  R Apply(IndexSequence<arg_id...>, IndexSequence<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
@ -2278,9 +2150,9 @@ template <typename F, typename Impl>
 }

 #define GMOCK_INTERNAL_ARG_UNUSED(i, data, el) \
-  , [[maybe_unused]] const arg##i##_type& arg##i
-#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_          \
-  [[maybe_unused]] const args_type& args GMOCK_PP_REPEAT( \
+  , const arg##i##_type& arg##i GTEST_ATTRIBUTE_UNUSED_
+#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_                 \
+  const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \
      GMOCK_INTERNAL_ARG_UNUSED, , 10)

 #define GMOCK_INTERNAL_ARG(i, data, el) , const arg##i##_type& arg##i
@ -2345,8 +2217,8 @@ template <typename F, typename Impl>
    std::shared_ptr<const gmock_Impl> impl_;                                   \
  };                                                                           \
  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                             \
-  [[nodiscard]] inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name(      \
-      GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params));                               \
+  inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name(                    \
+      GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) GTEST_MUST_USE_RESULT_;        \
  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                             \
  inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name(                    \
      GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) {                              \
@ -2381,7 +2253,7 @@ template <typename F, typename Impl>
      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
    };                                                                        \
  };                                                                          \
-  [[nodiscard]] inline name##Action name();                                   \
+  inline name##Action name() GTEST_MUST_USE_RESULT_;                          \
  inline name##Action name() { return name##Action(); }                       \
  template <typename function_type, typename return_type, typename args_type, \
            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                \
--- a/googlemock/include/gmock/gmock-function-mocker.h
+++ b/googlemock/include/gmock/gmock-function-mocker.h
@ -37,7 +37,6 @@
 #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

@ -70,22 +69,22 @@ constexpr bool PrefixOf(const char* a, const char* b) {
  return *a == 0 || (*a == *b && internal::PrefixOf(a + 1, b + 1));
 }

-template <size_t N, size_t M>
+template <int N, int M>
 constexpr bool StartsWith(const char (&prefix)[N], const char (&str)[M]) {
  return N <= M && internal::PrefixOf(prefix, str);
 }

-template <size_t N, size_t M>
+template <int N, int M>
 constexpr bool EndsWith(const char (&suffix)[N], const char (&str)[M]) {
  return N <= M && internal::PrefixOf(suffix, str + M - N);
 }

-template <size_t N, size_t M>
+template <int N, int M>
 constexpr bool Equals(const char (&a)[N], const char (&b)[M]) {
  return N == M && internal::PrefixOf(a, b);
 }

-template <size_t N>
+template <int N>
 constexpr bool ValidateSpec(const char (&spec)[N]) {
  return internal::Equals("const", spec) ||
         internal::Equals("override", spec) ||
--- a/googlemock/include/gmock/gmock-matchers.h
+++ b/googlemock/include/gmock/gmock-matchers.h
--- a/googlemock/include/gmock/gmock-more-actions.h
+++ b/googlemock/include/gmock/gmock-more-actions.h
@ -521,8 +521,9 @@
        GMOCK_INTERNAL_DECL_##value_params)                                    \
        GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),    \
                    = default;                                                 \
-                    , : impl_(std::make_shared<gmock_Impl>(                    \
-                          GMOCK_INTERNAL_LIST_##value_params)){})              \
+                    ,                                                          \
+                    : 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_      \
        ##value_params                                                         \
@ -550,10 +551,10 @@
  };                                                                           \
  template <GMOCK_INTERNAL_DECL_##template_params                              \
                GMOCK_INTERNAL_DECL_TYPE_##value_params>                       \
-  [[nodiscard]] GMOCK_ACTION_CLASS_(                                           \
+  GMOCK_ACTION_CLASS_(                                                         \
      name, value_params)<GMOCK_INTERNAL_LIST_##template_params                \
                              GMOCK_INTERNAL_LIST_TYPE_##value_params>         \
-      name(GMOCK_INTERNAL_DECL_##value_params);                                \
+      name(GMOCK_INTERNAL_DECL_##value_params) GTEST_MUST_USE_RESULT_;         \
  template <GMOCK_INTERNAL_DECL_##template_params                              \
                GMOCK_INTERNAL_DECL_TYPE_##value_params>                       \
  inline GMOCK_ACTION_CLASS_(                                                  \
@ -591,23 +592,21 @@ 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(std::forward<F>(f)(args...)) {
-  return std::forward<F>(f)(args...);
+auto InvokeArgument(F f, Args... args) -> decltype(f(args...)) {
+  return 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(
-          std::get<index>(std::forward_as_tuple(std::forward<Args>(args)...)),
-          std::declval<const Params &>()...)) {
+  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 = std::move(args_tuple.template Get<index>());
+      auto &&callable = args_tuple.template Get<index>();
      return internal::InvokeArgument(
          std::forward<decltype(callable)>(callable), unpacked_params...);
    });
--- a/googlemock/include/gmock/gmock-spec-builders.h
+++ b/googlemock/include/gmock/gmock-spec-builders.h
@ -868,7 +868,7 @@ class GTEST_API_ ExpectationBase {
  Clause last_clause_;
  mutable bool action_count_checked_;  // Under mutex_.
  mutable Mutex mutex_;                // Protects action_count_checked_.
-};  // class ExpectationBase
+};                                     // class ExpectationBase

 template <typename F>
 class TypedExpectation;
@ -1292,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. .WillByDefault() must be called on the returned
-  // object.
-  [[nodiscard]] internal::OnCallSpec<F>& InternalDefaultActionSetAt(
-      const char* file, int line, const char* obj, const char* call) {
+  // the newly created spec.
+  internal::OnCallSpec<F>& InternalDefaultActionSetAt(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_);
@ -1467,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();
@ -1530,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);
@ -1538,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
@ -1646,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);
@ -1838,8 +1838,9 @@ R FunctionMocker<R(Args...)>::InvokeWith(ArgumentTuple&& args)
    // 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};
+    const UninterestingCallCleanupHandler report_uninteresting_call = {
+        reaction, ss
+    };

    return PerformActionAndPrintResult(nullptr, std::move(args), ss.str(), ss);
  }
@ -1889,7 +1890,8 @@ R FunctionMocker<R(Args...)>::InvokeWith(ArgumentTuple&& args)
  // std::function<T> is re-instantiated with different template
  // parameters each time.
  const FailureCleanupHandler handle_failures = {
-      ss, why, loc, untyped_expectation, found, is_excessive};
+      ss, why, loc, untyped_expectation, found, is_excessive
+  };

  return PerformActionAndPrintResult(untyped_action, std::move(args), ss.str(),
                                     ss);
--- a/googlemock/include/gmock/gmock.h
+++ b/googlemock/include/gmock/gmock.h
@ -53,14 +53,13 @@
 //
 // where all clauses are optional and WillOnce() can be repeated.

-#include "gmock/gmock-actions.h"  // IWYU pragma: export
-#include "gmock/gmock-cardinalities.h"  // IWYU pragma: export
-#include "gmock/gmock-function-mocker.h"  // IWYU pragma: export
-#include "gmock/gmock-matchers.h"  // IWYU pragma: export
-#include "gmock/gmock-more-actions.h"  // IWYU pragma: export
-#include "gmock/gmock-more-matchers.h"  // IWYU pragma: export
-#include "gmock/gmock-nice-strict.h"  // IWYU pragma: export
-#include "gmock/gmock-spec-builders.h"  // IWYU pragma: export
+#include "gmock/gmock-actions.h"
+#include "gmock/gmock-cardinalities.h"
+#include "gmock/gmock-function-mocker.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/gmock-more-actions.h"
+#include "gmock/gmock-more-matchers.h"
+#include "gmock/gmock-nice-strict.h"
 #include "gmock/internal/gmock-internal-utils.h"
 #include "gmock/internal/gmock-port.h"

--- a/googlemock/include/gmock/internal/gmock-internal-utils.h
+++ b/googlemock/include/gmock/internal/gmock-internal-utils.h
@ -44,7 +44,6 @@
 #include <ostream>  // NOLINT
 #include <string>
 #include <type_traits>
-#include <utility>
 #include <vector>

 #include "gmock/internal/gmock-port.h"
@ -298,7 +297,7 @@ GTEST_API_ void Log(LogSeverity severity, const std::string& message,
 //
 class WithoutMatchers {
 private:
-  WithoutMatchers() = default;
+  WithoutMatchers() {}
  friend GTEST_API_ WithoutMatchers GetWithoutMatchers();
 };

@ -421,7 +420,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, std::index_sequence<Idx...>)
+auto ApplyImpl(F&& f, Tuple&& args, IndexSequence<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,13 +428,12 @@ auto ApplyImpl(F&& f, Tuple&& args, std::index_sequence<Idx...>)

 // Apply the function to a tuple of arguments.
 template <typename F, typename Tuple>
-auto Apply(F&& f, Tuple&& args)
-    -> decltype(ApplyImpl(
-        std::forward<F>(f), std::forward<Tuple>(args),
-        std::make_index_sequence<std::tuple_size<
-            typename std::remove_reference<Tuple>::type>::value>())) {
+auto Apply(F&& f, Tuple&& args) -> decltype(ApplyImpl(
+    std::forward<F>(f), std::forward<Tuple>(args),
+    MakeIndexSequence<std::tuple_size<
+        typename std::remove_reference<Tuple>::type>::value>())) {
  return ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
-                   std::make_index_sequence<std::tuple_size<
+                   MakeIndexSequence<std::tuple_size<
                       typename std::remove_reference<Tuple>::type>::value>());
 }

@ -467,6 +465,11 @@ struct Function<R(Args...)> {
  using MakeResultIgnoredValue = IgnoredValue(Args...);
 };

+#ifdef GTEST_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL
+template <typename R, typename... Args>
+constexpr size_t Function<R(Args...)>::ArgumentCount;
+#endif
+
 // 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
--- a/googlemock/include/gmock/internal/gmock-port.h
+++ b/googlemock/include/gmock/internal/gmock-port.h
@ -42,7 +42,6 @@

 #include <assert.h>
 #include <stdlib.h>
-
 #include <cstdint>
 #include <iostream>

@ -57,7 +56,7 @@
 #include "gmock/internal/custom/gmock-port.h"
 #include "gtest/internal/gtest-port.h"

-#if defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
+#ifdef GTEST_HAS_ABSL
 #include "absl/flags/declare.h"
 #include "absl/flags/flag.h"
 #endif
@ -74,7 +73,7 @@
 #define GMOCK_FLAG(name) FLAGS_gmock_##name

 // Pick a command line flags implementation.
-#if defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
+#ifdef GTEST_HAS_ABSL

 // Macros for defining flags.
 #define GMOCK_DEFINE_bool_(name, default_val, doc) \
@ -96,7 +95,7 @@
 #define GMOCK_FLAG_SET(name, value) \
  (void)(::absl::SetFlag(&GMOCK_FLAG(name), value))

-#else  // defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
+#else  // GTEST_HAS_ABSL

 // Macros for defining flags.
 #define GMOCK_DEFINE_bool_(name, default_val, doc)  \
@ -135,6 +134,6 @@
 #define GMOCK_FLAG_GET(name) ::testing::GMOCK_FLAG(name)
 #define GMOCK_FLAG_SET(name, value) (void)(::testing::GMOCK_FLAG(name) = value)

-#endif  // defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
+#endif  // GTEST_HAS_ABSL

 #endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
--- a/googlemock/src/gmock-cardinalities.cc
+++ b/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, " << "but is actually "
-         << min << ".";
+      ss << "The invocation lower bound must be >= 0, "
+         << "but is actually " << min << ".";
      internal::Expect(false, __FILE__, __LINE__, ss.str());
    } else if (max < 0) {
-      ss << "The invocation upper bound must be >= 0, " << "but is actually "
-         << max << ".";
+      ss << "The invocation upper bound must be >= 0, "
+         << "but is actually " << max << ".";
      internal::Expect(false, __FILE__, __LINE__, ss.str());
    } else if (min > max) {
      ss << "The invocation upper bound (" << max
--- a/googlemock/src/gmock-internal-utils.cc
+++ b/googlemock/src/gmock-internal-utils.cc
@ -44,7 +44,6 @@
 #include <iostream>
 #include <ostream>  // NOLINT
 #include <string>
-#include <utility>
 #include <vector>

 #include "gmock/gmock.h"
@ -156,7 +155,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.
@ -212,14 +211,14 @@ constexpr char UnBase64Impl(char c, const char* const base64, char carry) {
 }

 template <size_t... I>
-constexpr std::array<char, 256> UnBase64Impl(std::index_sequence<I...>,
+constexpr std::array<char, 256> UnBase64Impl(IndexSequence<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(std::make_index_sequence<256>{}, base64);
+  return UnBase64Impl(MakeIndexSequence<256>{}, base64);
 }

 static constexpr char kBase64[] =
--- a/googlemock/src/gmock-matchers.cc
+++ b/googlemock/src/gmock-matchers.cc
@ -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,
-//       'https://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm'
+//       'http://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm'
 class MaxBipartiteMatchState {
 public:
  explicit MaxBipartiteMatchState(const MatchMatrix& graph)
@ -236,8 +236,9 @@ static void LogElementMatcherPairVec(const ElementMatcherPairs& pairs,
  os << "{";
  const char* sep = "";
  for (Iter it = pairs.begin(); it != pairs.end(); ++it) {
-    os << sep << "\n  (" << "element #" << it->first << ", " << "matcher #"
-       << it->second << ")";
+    os << sep << "\n  ("
+       << "element #" << it->first << ", "
+       << "matcher #" << it->second << ")";
    sep = ",";
  }
  os << "\n}";
@ -373,20 +374,20 @@ bool UnorderedElementsAreMatcherImplBase::VerifyMatchMatrix(
    return true;
  }

-  const bool is_exact_match_with_size_discrepency =
-      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()) << "\n";
+  if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
+    if (matrix.LhsSize() != matrix.RhsSize()) {
+      // 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());
+      }
+      return false;
    }
  }

-  bool result = !is_exact_match_with_size_discrepency;
+  bool result = true;
  ::std::vector<char> element_matched(matrix.LhsSize(), 0);
  ::std::vector<char> matcher_matched(matrix.RhsSize(), 0);

--- a/googlemock/src/gmock-spec-builders.cc
+++ b/googlemock/src/gmock-spec-builders.cc
@ -212,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;
@ -293,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 adding "
+              "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/"
@ -318,7 +318,7 @@ UntypedFunctionMockerBase::~UntypedFunctionMockerBase() = default;
 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);
@ -332,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;
 }
@ -345,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.");
@ -362,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.");
@ -436,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;
 }
@ -490,7 +490,6 @@ 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();
@ -531,7 +530,7 @@ class MockObjectRegistry {
 #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
    }
@ -559,7 +558,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;
 }

@ -590,7 +589,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));
 }

@ -598,7 +597,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(
@ -611,7 +610,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;
 }

@ -620,7 +619,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);
 }

@ -629,7 +628,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);
 }
@ -679,7 +678,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);
 }

@ -689,7 +688,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;
--- a/googlemock/test/BUILD.bazel
+++ b/googlemock/test/BUILD.bazel
@ -30,7 +30,6 @@
 #
 #   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/googlemock/test/gmock-actions_test.cc
+++ b/googlemock/test/gmock-actions_test.cc
@ -188,7 +188,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.
@ -222,8 +222,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.
-  // TODO(b/396121064) - Fix this test under MSVC
-#ifndef _MSC_VER
+#if defined(GTEST_INTERNAL_CPLUSPLUS_LANG) && \
+    GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
  {
    struct NonMoveable {
      NonMoveable() = default;
@ -244,7 +244,7 @@ TEST(TypeTraits, IsInvocableRV) {
    static_assert(!internal::is_callable_r<int, Callable>::value);
    static_assert(!internal::is_callable_r<NonMoveable, Callable, int>::value);
  }
-#endif  // _MSC_VER
+#endif  // C++17 and above

  // Nothing should choke when we try to call other arguments besides directly
  // callable objects, but they should not show up as callable.
@ -441,8 +441,8 @@ 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) {
@ -505,8 +505,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
@ -1030,7 +1030,8 @@ void VoidFunc(bool /* flag */) {}

 TEST(DoDefaultDeathTest, DiesIfUsedInCompositeAction) {
  MockClass mock;
-  EXPECT_CALL(mock, IntFunc(_)).WillRepeatedly(DoAll(VoidFunc, DoDefault()));
+  EXPECT_CALL(mock, IntFunc(_))
+      .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
@ -1281,7 +1282,7 @@ int ReturnOne() {

 TEST(IgnoreResultTest, MonomorphicAction) {
  g_done = false;
-  Action<void()> a = IgnoreResult(&ReturnOne);
+  Action<void()> a = IgnoreResult(Invoke(ReturnOne));
  a.Perform(std::make_tuple());
  EXPECT_TRUE(g_done);
 }
@ -1296,7 +1297,7 @@ MyNonDefaultConstructible ReturnMyNonDefaultConstructible(double /* x */) {
 TEST(IgnoreResultTest, ActionReturningClass) {
  g_done = false;
  Action<void(int)> a =
-      IgnoreResult(&ReturnMyNonDefaultConstructible);  // NOLINT
+      IgnoreResult(Invoke(ReturnMyNonDefaultConstructible));  // NOLINT
  a.Perform(std::make_tuple(2));
  EXPECT_TRUE(g_done);
 }
@ -1476,50 +1477,9 @@ 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>(Unary);
+  Action<bool(double x, int n)> a = WithArgs<1>(Invoke(Unary));  // NOLINT
  EXPECT_TRUE(a.Perform(std::make_tuple(1.5, -1)));
  EXPECT_FALSE(a.Perform(std::make_tuple(1.5, 1)));
 }
@ -1527,7 +1487,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>(Binary);
+      WithArgs<0, 2>(Invoke(Binary));
  const char s[] = "Hello";
  EXPECT_EQ(s + 2, a.Perform(std::make_tuple(CharPtr(s), 0.5, Short(2))));
 }
@ -1543,7 +1503,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>(ConcatAll{});
+      WithArgs<0, 1, 2, 3, 2, 1, 0, 1, 2, 3>(Invoke(ConcatAll{}));
  EXPECT_EQ("0123210123",
            a.Perform(std::make_tuple(CharPtr("0"), CharPtr("1"), CharPtr("2"),
                                      CharPtr("3"))));
@ -1568,21 +1528,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>(Ternary);
+      WithArgs<0, 1, 2>(Invoke(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>(SumOf4);
+      WithArgs<1, 1, 1, 1>(Invoke(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>(Binary);
+      WithArgs<1, 0>(Invoke(Binary));
  const char s[] = "Hello";
  EXPECT_EQ(s + 2, a.Perform(std::make_tuple(Short(2), CharPtr(s))));
 }
@ -1590,14 +1550,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>(Ternary);
+      WithArgs<0, 1, 3>(Invoke(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>(VoidBinary);
+  Action<void(double x, char c, int n)> a = WithArgs<2, 1>(Invoke(VoidBinary));
  g_done = false;
  a.Perform(std::make_tuple(1.5, 'a', 3));
  EXPECT_TRUE(g_done);
@ -1637,22 +1597,6 @@ TEST(WithArgsTest, RefQualifiedInnerAction) {
  EXPECT_EQ(19, mock.AsStdFunction()(0, 17));
 }

-// 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 {
@ -1822,7 +1766,7 @@ std::vector<std::unique_ptr<int>> VectorUniquePtrSource() {

 TEST(MockMethodTest, CanReturnMoveOnlyValue_Return) {
  MockClass mock;
-  std::unique_ptr<int> i = std::make_unique<int>(19);
+  std::unique_ptr<int> i(new int(19));
  EXPECT_CALL(mock, MakeUnique()).WillOnce(Return(ByMove(std::move(i))));
  EXPECT_CALL(mock, MakeVectorUnique())
      .WillOnce(Return(ByMove(VectorUniquePtrSource())));
@ -1845,7 +1789,7 @@ TEST(MockMethodTest, CanReturnMoveOnlyValue_Return) {
 TEST(MockMethodTest, CanReturnMoveOnlyValue_DoAllReturn) {
  testing::MockFunction<void()> mock_function;
  MockClass mock;
-  std::unique_ptr<int> i = std::make_unique<int>(19);
+  std::unique_ptr<int> i(new int(19));
  EXPECT_CALL(mock_function, Call());
  EXPECT_CALL(mock, MakeUnique())
      .WillOnce(DoAll(InvokeWithoutArgs(&mock_function,
@ -1864,8 +1808,9 @@ TEST(MockMethodTest, CanReturnMoveOnlyValue_Invoke) {
      [] { return std::make_unique<int>(42); });
  EXPECT_EQ(42, *mock.MakeUnique());

-  EXPECT_CALL(mock, MakeUnique()).WillRepeatedly(UniquePtrSource);
-  EXPECT_CALL(mock, MakeVectorUnique()).WillRepeatedly(VectorUniquePtrSource);
+  EXPECT_CALL(mock, MakeUnique()).WillRepeatedly(Invoke(UniquePtrSource));
+  EXPECT_CALL(mock, MakeVectorUnique())
+      .WillRepeatedly(Invoke(VectorUniquePtrSource));
  std::unique_ptr<int> result1 = mock.MakeUnique();
  EXPECT_EQ(19, *result1);
  std::unique_ptr<int> result2 = mock.MakeUnique();
@ -1887,7 +1832,7 @@ TEST(MockMethodTest, CanTakeMoveOnlyValue) {
  });
  // DoAll() does not compile, since it would move from its arguments twice.
  // EXPECT_CALL(mock, TakeUnique(_, _))
-  //     .WillRepeatedly(DoAll([](std::unique_ptr<int> j) {})),
+  //     .WillRepeatedly(DoAll(Invoke([](std::unique_ptr<int> j) {}),
  //     Return(1)));
  EXPECT_CALL(mock, TakeUnique(testing::Pointee(7)))
      .WillOnce(Return(-7))
--- a/googlemock/test/gmock-function-mocker_test.cc
+++ b/googlemock/test/gmock-function-mocker_test.cc
@ -91,7 +91,7 @@ class FooInterface {

  virtual bool TakesNonConstReference(int& n) = 0;  // NOLINT
  virtual std::string TakesConstReference(const int& n) = 0;
-  virtual bool TakesConst(int x) = 0;
+  virtual bool TakesConst(const int x) = 0;

  virtual int OverloadedOnArgumentNumber() = 0;
  virtual int OverloadedOnArgumentNumber(int n) = 0;
@ -325,8 +325,8 @@ TYPED_TEST(FunctionMockerTest, MocksBinaryFunction) {

 // Tests mocking a decimal function.
 TYPED_TEST(FunctionMockerTest, MocksDecimalFunction) {
-  EXPECT_CALL(this->mock_foo_, Decimal(true, 'a', 0, 0, 1L, A<float>(), Lt(100),
-                                       5U, nullptr, "hi"))
+  EXPECT_CALL(this->mock_foo_,
+              Decimal(true, 'a', 0, 0, 1L, A<float>(), Lt(100), 5U, NULL, "hi"))
      .WillOnce(Return(5));

  EXPECT_EQ(5, this->foo_->Decimal(true, 'a', 0, 0, 1, 0, 0, 5, nullptr, "hi"));
--- a/googlemock/test/gmock-internal-utils_test.cc
+++ b/googlemock/test/gmock-internal-utils_test.cc
@ -545,7 +545,7 @@ TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsError) {

 void OnCallLogger() {
  DummyMock mock;
-  (void)ON_CALL(mock, TestMethod());
+  ON_CALL(mock, TestMethod());
 }

 // Verifies that ON_CALL logs if the --gmock_verbose flag is set to "info".
@ -568,7 +568,7 @@ TEST(OnCallTest, DoesNotLogWhenVerbosityIsError) {

 void OnCallAnyArgumentLogger() {
  DummyMock mock;
-  (void)ON_CALL(mock, TestMethodArg(_));
+  ON_CALL(mock, TestMethodArg(_));
 }

 // Verifies that ON_CALL prints provided _ argument.
--- a/googlemock/test/gmock-matchers-arithmetic_test.cc
+++ b/googlemock/test/gmock-matchers-arithmetic_test.cc
@ -34,12 +34,9 @@
 #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
@ -399,188 +396,6 @@ 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;
@ -744,9 +559,10 @@ TEST_P(AllOfTestP, ExplainsResult) {
  Matcher<int> m;

  // Successful match.  Both matchers need to explain.  The second
-  // matcher doesn't give an explanation, so the matcher description is used.
+  // matcher doesn't give an explanation, so only the first matcher's
+  // explanation is printed.
  m = AllOf(GreaterThan(10), Lt(30));
-  EXPECT_EQ("which is 15 more than 10, and is < 30", Explain(m, 25));
+  EXPECT_EQ("which is 15 more than 10", Explain(m, 25));

  // Successful match.  Both matchers need to explain.
  m = AllOf(GreaterThan(10), GreaterThan(20));
@ -756,9 +572,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 is < 30, and which is 5 more than 20",
-      Explain(m, 25));
+  EXPECT_EQ("which is 15 more than 10, and which is 5 more than 20",
+            Explain(m, 25));

  // Successful match.  All matchers need to explain.
  m = AllOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
@ -770,14 +585,13 @@ 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, and which is 15 less than 20",
-            Explain(m, 5));
+  EXPECT_EQ("which is 5 less than 10", Explain(m, 5));

  // Failed match.  The second matcher, which failed, needs to
-  // explain.  Since it doesn't given an explanation, the matcher text is
+  // explain.  Since it doesn't given an explanation, nothing is
  // printed.
  m = AllOf(GreaterThan(10), Lt(30));
-  EXPECT_EQ("which doesn't match (is < 30)", Explain(m, 40));
+  EXPECT_EQ("", Explain(m, 40));

  // Failed match.  The second matcher, which failed, needs to
  // explain.
@ -960,43 +774,45 @@ TEST(AnyOfTest, AnyOfMatcherSafelyCastsMonomorphicMatchers) {
 TEST_P(AnyOfTestP, ExplainsResult) {
  Matcher<int> m;

-  // Failed match. The second matcher have no explanation (description is used).
+  // Failed match.  Both matchers need to explain.  The second
+  // 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, and isn't < 0", Explain(m, 5));
+  EXPECT_EQ("which is 5 less than 10", Explain(m, 5));

-  // Failed match. Both matchers have explanations.
+  // Failed match.  Both matchers need to explain.
  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. The middle matcher have no explanation.
+  // Failed match.  All matchers need to explain.  The second
+  // matcher doesn't given an explanation.
  m = AnyOf(GreaterThan(10), Gt(20), GreaterThan(30));
-  EXPECT_EQ(
-      "which is 5 less than 10, and isn't > 20, and which is 25 less than 30",
-      Explain(m, 5));
+  EXPECT_EQ("which is 5 less than 10, and which is 25 less than 30",
+            Explain(m, 5));

-  // Failed match. All three matchers have explanations.
+  // Failed match.  All matchers need to explain.
  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 macher succeeded and has explanation.
+  // Successful match.  The first matcher, which succeeded, needs to
+  // explain.
  m = AnyOf(GreaterThan(10), GreaterThan(20));
  EXPECT_EQ("which is 5 more than 10", Explain(m, 15));

-  // Successful match. The second matcher succeeded and has explanation.
+  // Successful match.  The second matcher, which succeeded, needs to
+  // 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
@ -1626,7 +1442,7 @@ TEST_F(DoubleNearTest, NanSensitiveDoubleNearCanMatchNaN) {
 }

 TEST(NotTest, WorksOnMoveOnlyType) {
-  std::unique_ptr<int> p = std::make_unique<int>(3);
+  std::unique_ptr<int> p(new int(3));
  EXPECT_THAT(p, Pointee(Eq(3)));
  EXPECT_THAT(p, Not(Pointee(Eq(2))));
 }
@ -1682,13 +1498,13 @@ TEST(AnyOfTest, DoesNotCallAnyOfUnqualified) {
 }  // namespace adl_test

 TEST(AllOfTest, WorksOnMoveOnlyType) {
-  std::unique_ptr<int> p = std::make_unique<int>(3);
+  std::unique_ptr<int> p(new 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 = std::make_unique<int>(3);
+  std::unique_ptr<int> p(new 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/googlemock/test/gmock-matchers-comparisons_test.cc
+++ b/googlemock/test/gmock-matchers-comparisons_test.cc
@ -33,19 +33,17 @@

 #include <functional>
 #include <memory>
-#include <optional>
 #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)

+
 namespace testing {
 namespace gmock_matchers_test {
 namespace {
@ -412,27 +410,9 @@ 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) {
@ -448,34 +428,14 @@ 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) {
-  int n = 0;
-  Matcher<const int&> m1 = Ref(n);
+  Matcher<const int&> m1 = Eq(0);
  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<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));
+  EXPECT_TRUE(m2.Matches(0));
+  EXPECT_FALSE(m2.Matches(1));
 }

 // Tests that MatcherCast<T>(m) works when m is a Matcher<T&>.
@ -484,12 +444,6 @@ 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>.
@ -622,42 +576,15 @@ 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, 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);
-    {
-      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));
-    }
-  }
+TEST(MatcherCastTest, ValueIsNotCopied) {
+  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));
 }

 class Base {
@ -721,16 +648,6 @@ 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;
@ -1852,15 +1769,6 @@ TEST(StartsWithTest, CanDescribeSelf) {
  EXPECT_EQ("starts with \"Hi\"", Describe(m));
 }

-TEST(StartsWithTest, WorksWithStringMatcherOnStringViewMatchee) {
-#if GTEST_INTERNAL_HAS_STRING_VIEW
-  EXPECT_THAT(internal::StringView("talk to me goose"),
-              StartsWith(std::string("talk")));
-#else
-  GTEST_SKIP() << "Not applicable without internal::StringView.";
-#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
-}
-
 // Tests EndsWith(s).

 TEST(EndsWithTest, MatchesStringWithGivenSuffix) {
@ -2389,19 +2297,22 @@ PolymorphicMatcher<DivisibleByImpl> DivisibleBy(int n) {
  return MakePolymorphicMatcher(DivisibleByImpl(n));
 }

-// Tests that when AllOf() fails, all failing matchers are asked to explain why.
+// Tests that when AllOf() fails, only the first failing matcher is
+// 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, and which is 2 modulo 3", Explain(m, 5));
+  EXPECT_EQ("which is 1 modulo 4", Explain(m, 5));
 }

-// Tests that when AllOf() fails, all failing matchers are asked to explain why.
+// Tests that when AllOf() fails, only the first failing matcher is
+// 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, all failing matchers are asked to explain why.
+// Tests that when AllOf() fails, only the first failing matcher is
+// 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));
@ -2414,79 +2325,9 @@ 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("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));
+  EXPECT_EQ("", Explain(m, 2));
 }

 INSTANTIATE_GTEST_MATCHER_TEST_P(ExplainmatcherResultTest);
--- a/googlemock/test/gmock-matchers-containers_test.cc
+++ b/googlemock/test/gmock-matchers-containers_test.cc
@ -33,7 +33,6 @@

 #include <algorithm>
 #include <array>
-#include <cstddef>
 #include <deque>
 #include <forward_list>
 #include <iterator>
@ -44,14 +43,14 @@
 #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 {
@ -217,7 +216,7 @@ TEST(PointeeTest, ReferenceToNonConstRawPointer) {
 TEST(PointeeTest, SmartPointer) {
  const Matcher<std::unique_ptr<int>> m = Pointee(Ge(0));

-  std::unique_ptr<int> n = std::make_unique<int>(1);
+  std::unique_ptr<int> n(new int(1));
  EXPECT_TRUE(m.Matches(n));
 }

@ -254,7 +253,7 @@ TEST(PointerTest, RawPointerToConst) {
 }

 TEST(PointerTest, SmartPointer) {
-  std::unique_ptr<int> n = std::make_unique<int>(10);
+  std::unique_ptr<int> n(new int(10));
  int* raw_n = n.get();
  const Matcher<std::unique_ptr<int>> m = Pointer(Eq(raw_n));

@ -1205,16 +1204,13 @@ 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, which matches (is equal to 0)",
-            Explain(m3, container));
+  EXPECT_EQ("whose size 0 matches", 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, isn't equal to 0, and isn't equal to 3",
-      Explain(m3, container));
+  EXPECT_EQ("whose size 2 doesn't match", Explain(m3, container));
  EXPECT_EQ("whose size 2 matches", Explain(m4, container));
 }

@ -1272,11 +1268,10 @@ TEST(WhenSortedByTest, CanDescribeSelf) {

 TEST(WhenSortedByTest, ExplainsMatchResult) {
  const int a[] = {2, 1};
-  EXPECT_EQ(
-      Explain(WhenSortedBy(less<int>(), ElementsAre(2, 3)), a),
-      "which is { 1, 2 } when sorted, whose element #0 (1) isn't equal to 2");
-  EXPECT_EQ(Explain(WhenSortedBy(less<int>(), ElementsAre(1, 2)), a),
-            "which is { 1, 2 } when sorted");
+  EXPECT_EQ("which is { 1, 2 } when sorted, whose element #0 doesn't match",
+            Explain(WhenSortedBy(less<int>(), ElementsAre(2, 3)), a));
+  EXPECT_EQ("which is { 1, 2 } when sorted",
+            Explain(WhenSortedBy(less<int>(), ElementsAre(1, 2)), a));
 }

 // WhenSorted() is a simple wrapper on WhenSortedBy().  Hence we don't
@ -1480,10 +1475,8 @@ 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, which matches (is "
-      "equal to 0)",
-      Explain(m3, container));
+  EXPECT_EQ("whose distance between begin() and end() 0 matches",
+            Explain(m3, container));
  EXPECT_EQ(
      "whose distance between begin() and end() 0 doesn't match, which is 1 "
      "less than 1",
@ -1494,10 +1487,8 @@ 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, isn't equal "
-      "to 0, and isn't equal to 3",
-      Explain(m3, container));
+  EXPECT_EQ("whose distance between begin() and end() 2 doesn't match",
+            Explain(m3, container));
  EXPECT_EQ(
      "whose distance between begin() and end() 2 matches, which is 1 more "
      "than 1",
@ -1777,295 +1768,6 @@ 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".

@ -2312,14 +2014,7 @@ 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\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"));
+  EXPECT_THAT(listener.str(), Eq("which has 1 element"));
 }

 TEST_F(UnorderedElementsAreTest, FailMessageCountWrongZero) {
@ -2327,11 +2022,7 @@ TEST_F(UnorderedElementsAreTest, FailMessageCountWrongZero) {
  StringMatchResultListener listener;
  EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3), v, &listener))
      << listener.str();
-  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"));
+  EXPECT_THAT(listener.str(), Eq(""));
 }

 TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedMatchers) {
@ -2446,7 +2137,7 @@ TEST_P(EachTestP, ExplainsMatchResultCorrectly) {
  Matcher<set<int>> m = Each(2);
  EXPECT_EQ("", Explain(m, a));

-  Matcher<const int (&)[1]> n = Each(1);  // NOLINT
+  Matcher<const int(&)[1]> n = Each(1);  // NOLINT

  const int b[1] = {1};
  EXPECT_EQ("", Explain(n, b));
@ -2581,7 +2272,7 @@ TEST(PointwiseTest, MakesCopyOfRhs) {
  rhs.push_back(4);

  int lhs[] = {1, 2};
-  const Matcher<const int (&)[2]> m = Pointwise(IsHalfOf(), rhs);
+  const Matcher<const int(&)[2]> m = Pointwise(IsHalfOf(), rhs);
  EXPECT_THAT(lhs, m);

  // Changing rhs now shouldn't affect m, which made a copy of rhs.
@ -2709,7 +2400,7 @@ TEST(UnorderedPointwiseTest, MakesCopyOfRhs) {
  rhs.push_back(4);

  int lhs[] = {2, 1};
-  const Matcher<const int (&)[2]> m = UnorderedPointwise(IsHalfOf(), rhs);
+  const Matcher<const int(&)[2]> m = UnorderedPointwise(IsHalfOf(), rhs);
  EXPECT_THAT(lhs, m);

  // Changing rhs now shouldn't affect m, which made a copy of rhs.
@ -2747,7 +2438,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\n",
+  EXPECT_EQ("which has 2 elements",
            Explain(UnorderedPointwise(Gt(), rhs), lhs));

  const int rhs2[3] = {0, 1, 2};
@ -2796,7 +2487,7 @@ TEST(UnorderedPointwiseTest, WorksWithMoveOnly) {
 }

 TEST(PointeeTest, WorksOnMoveOnlyType) {
-  std::unique_ptr<int> p = std::make_unique<int>(3);
+  std::unique_ptr<int> p(new int(3));
  EXPECT_THAT(p, Pointee(Eq(3)));
  EXPECT_THAT(p, Not(Pointee(Eq(2))));
 }
@ -2960,11 +2651,11 @@ TEST_P(ElementsAreTestP, CanExplainMismatchRightSize) {
  vector<int> v;
  v.push_back(2);
  v.push_back(1);
-  EXPECT_EQ(Explain(m, v), "whose element #0 (2) isn't equal to 1");
+  EXPECT_EQ("whose element #0 doesn't match", Explain(m, v));

  v[0] = 1;
-  EXPECT_EQ(Explain(m, v),
-            "whose element #1 (1) is <= 5, which is 4 less than 5");
+  EXPECT_EQ("whose element #1 doesn't match, which is 4 less than 5",
+            Explain(m, v));
 }

 TEST(ElementsAreTest, MatchesOneElementVector) {
@ -3364,7 +3055,7 @@ TEST(ContainsTest, SetDoesNotMatchWhenElementIsNotInContainer) {

 TEST_P(ContainsTestP, ExplainsMatchResultCorrectly) {
  const int a[2] = {1, 2};
-  Matcher<const int (&)[2]> m = Contains(2);
+  Matcher<const int(&)[2]> m = Contains(2);
  EXPECT_EQ("whose element #1 matches", Explain(m, a));

  m = Contains(3);
--- a/googlemock/test/gmock-matchers-misc_test.cc
+++ b/googlemock/test/gmock-matchers-misc_test.cc
@ -32,7 +32,6 @@
 // This file tests some commonly used argument matchers.

 #include <array>
-#include <cstdint>
 #include <memory>
 #include <ostream>
 #include <string>
@ -40,14 +39,14 @@
 #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 {
@ -79,7 +78,7 @@ TEST(AddressTest, Const) {
 }

 TEST(AddressTest, MatcherDoesntCopy) {
-  std::unique_ptr<int> n = std::make_unique<int>(1);
+  std::unique_ptr<int> n(new int(1));
  const Matcher<std::unique_ptr<int>> m = Address(Eq(&n));

  EXPECT_TRUE(m.Matches(n));
@ -202,7 +201,7 @@ TEST(IsTrueTest, IsTrueIsFalse) {
  EXPECT_THAT(nullptr, Not(IsTrue()));
  EXPECT_THAT(nullptr, IsFalse());
  std::unique_ptr<int> null_unique;
-  std::unique_ptr<int> nonnull_unique = std::make_unique<int>(0);
+  std::unique_ptr<int> nonnull_unique(new int(0));
  EXPECT_THAT(null_unique, Not(IsTrue()));
  EXPECT_THAT(null_unique, IsFalse());
  EXPECT_THAT(nonnull_unique, IsTrue());
@ -675,8 +674,6 @@ 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>
@ -694,94 +691,38 @@ class SampleOptional {
  bool has_value_;
 };

-// Sample optional type implementation with alternative minimal requirements for
-// 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));
+TEST(OptionalTest, DescribesSelf) {
+  const Matcher<SampleOptional<int>> m = Optional(Eq(1));
  EXPECT_EQ("value is equal to 1", Describe(m));
 }

-TYPED_TEST(OptionalTest, ExplainsSelf) {
-  const Matcher<TypeParam> m = Optional(Eq(1));
-  EXPECT_EQ("whose value 1 matches", Explain(m, TypeParam(1)));
-  EXPECT_EQ("whose value 2 doesn't match", Explain(m, TypeParam(2)));
+TEST(OptionalTest, ExplainsSelf) {
+  const Matcher<SampleOptional<int>> m = Optional(Eq(1));
+  EXPECT_EQ("whose value 1 matches", Explain(m, SampleOptional<int>(1)));
+  EXPECT_EQ("whose value 2 doesn't match", Explain(m, SampleOptional<int>(2)));
 }

-TYPED_TEST(OptionalTest, MatchesNonEmptyOptional) {
-  const Matcher<TypeParam> m1 = Optional(1);
-  const Matcher<TypeParam> m2 = Optional(Eq(2));
-  const Matcher<TypeParam> m3 = Optional(Lt(3));
-  TypeParam opt(1);
+TEST(OptionalTest, MatchesNonEmptyOptional) {
+  const Matcher<SampleOptional<int>> m1 = Optional(1);
+  const Matcher<SampleOptional<int>> m2 = Optional(Eq(2));
+  const Matcher<SampleOptional<int>> m3 = Optional(Lt(3));
+  SampleOptional<int> opt(1);
  EXPECT_TRUE(m1.Matches(opt));
  EXPECT_FALSE(m2.Matches(opt));
  EXPECT_TRUE(m3.Matches(opt));
 }

-TYPED_TEST(OptionalTest, DoesNotMatchNullopt) {
-  const Matcher<TypeParam> m = Optional(1);
-  TypeParam empty;
+TEST(OptionalTest, DoesNotMatchNullopt) {
+  const Matcher<SampleOptional<int>> m = Optional(1);
+  SampleOptional<int> empty;
  EXPECT_FALSE(m.Matches(empty));
 }

-TYPED_TEST(OptionalTest, ComposesWithMonomorphicMatchersTakingReferences) {
-  const Matcher<const int&> eq1 = Eq(1);
-  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))));
+TEST(OptionalTest, WorksWithMoveOnly) {
+  Matcher<SampleOptional<std::unique_ptr<int>>> m = Optional(Eq(nullptr));
+  EXPECT_TRUE(m.Matches(SampleOptional<std::unique_ptr<int>>(nullptr)));
 }

-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) {}
@ -1635,10 +1576,10 @@ TEST_P(AnyOfArrayTestP, ExplainsMatchResultCorrectly) {
  const Matcher<int> m1 = AnyOfArray(v1);
  const Matcher<int> m2 = AnyOfArray(v2);
  EXPECT_EQ("", Explain(m0, 0));
-  EXPECT_EQ("which matches (is equal to 1)", Explain(m1, 1));
-  EXPECT_EQ("isn't equal to 1", Explain(m1, 2));
-  EXPECT_EQ("which matches (is equal to 3)", Explain(m2, 3));
-  EXPECT_EQ("isn't equal to 2, and isn't equal to 3", Explain(m2, 4));
+  EXPECT_EQ("", Explain(m1, 1));
+  EXPECT_EQ("", Explain(m1, 2));
+  EXPECT_EQ("", Explain(m2, 3));
+  EXPECT_EQ("", 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));
@ -1665,7 +1606,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 = std::make_unique<int>(3);
+  std::unique_ptr<int> p(new int(3));
  EXPECT_THAT(p, IsNotNull());
  EXPECT_THAT(std::unique_ptr<int>(), Not(IsNotNull()));
 }
@ -1675,7 +1616,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 = std::make_unique<int>(3);
+  std::unique_ptr<int> p(new int(3));
  EXPECT_THAT(p, UniquePointee(3));
  EXPECT_THAT(p, Not(UniquePointee(2)));
 }
--- a/googlemock/test/gmock-more-actions_test.cc
+++ b/googlemock/test/gmock-more-actions_test.cc
@ -59,7 +59,6 @@ using testing::Invoke;
 using testing::ReturnArg;
 using testing::ReturnPointee;
 using testing::SaveArg;
-using testing::SaveArgByMove;
 using testing::SaveArgPointee;
 using testing::SetArgReferee;
 using testing::Unused;
@ -86,16 +85,6 @@ 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
@ -202,45 +191,45 @@ class Foo {

 // Tests using Invoke() with a nullary function.
 TEST(InvokeTest, Nullary) {
-  Action<int()> a = &Nullary;
+  Action<int()> a = Invoke(Nullary);  // NOLINT
  EXPECT_EQ(1, a.Perform(std::make_tuple()));
 }

 // Tests using Invoke() with a unary function.
 TEST(InvokeTest, Unary) {
-  Action<bool(int)> a = &Unary;
+  Action<bool(int)> a = Invoke(Unary);  // NOLINT
  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 = &Binary;  // NOLINT
+  Action<const char*(const char*, short)> a = Invoke(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 = &Ternary;  // NOLINT
+  Action<int(int, char, short)> a = Invoke(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 = &SumOf4;
+  Action<int(int, int, int, int)> a = Invoke(SumOf4);  // NOLINT
  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 = &SumOf5;
+  Action<int(int, int, int, int, int)> a = Invoke(SumOf5);  // NOLINT
  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 = &SumOf6;
+  Action<int(int, int, int, int, int, int)> a = Invoke(SumOf6);  // NOLINT
  EXPECT_EQ(123456,
            a.Perform(std::make_tuple(100000, 20000, 3000, 400, 50, 6)));
 }
@ -253,7 +242,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 = &Concat7;
+      a = Invoke(Concat7);
  EXPECT_EQ("1234567",
            a.Perform(std::make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                      CharPtr("4"), CharPtr("5"), CharPtr("6"),
@ -264,7 +253,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 = &Concat8;
+      a = Invoke(Concat8);
  EXPECT_EQ("12345678",
            a.Perform(std::make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                      CharPtr("4"), CharPtr("5"), CharPtr("6"),
@ -276,7 +265,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 = &Concat9;
+      a = Invoke(Concat9);
  EXPECT_EQ("123456789", a.Perform(std::make_tuple(
                             CharPtr("1"), CharPtr("2"), CharPtr("3"),
                             CharPtr("4"), CharPtr("5"), CharPtr("6"),
@ -288,7 +277,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 = &Concat10;
+      a = Invoke(Concat10);
  EXPECT_EQ("1234567890",
            a.Perform(std::make_tuple(CharPtr("1"), CharPtr("2"), CharPtr("3"),
                                      CharPtr("4"), CharPtr("5"), CharPtr("6"),
@ -298,12 +287,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 = &SumOfFirst2;
+  Action<int(int, int, double, const std::string&)> a1 = Invoke(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 = &SumOfFirst2;
+  Action<int(int, int, bool, int*)> a2 = Invoke(SumOfFirst2);
  EXPECT_EQ(
      23, a2.Perform(std::make_tuple(20, 3, true, static_cast<int*>(nullptr))));
 }
@ -320,13 +309,13 @@ TEST(InvokeTest, MethodWithUnusedParameters) {

 // Tests using Invoke() with a functor.
 TEST(InvokeTest, Functor) {
-  Action<long(long, int)> a = plus<long>();  // NOLINT
+  Action<long(long, int)> a = Invoke(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 = &SumOf4;  // NOLINT
+  Action<long(int, short, char, bool)> a = Invoke(SumOf4);  // NOLINT
  EXPECT_EQ(4321, a.Perform(std::make_tuple(4000, Short(300), Char(20), true)));
 }

@ -447,13 +436,13 @@ TEST(InvokeMethodTest, MethodWithCompatibleType) {

 // Tests using WithoutArgs with an action that takes no argument.
 TEST(WithoutArgsTest, NoArg) {
-  Action<int(int n)> a = WithoutArgs(&Nullary);  // NOLINT
+  Action<int(int n)> a = WithoutArgs(Invoke(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>(&Unary);  // NOLINT
+  Action<bool(double x, int n)> b = WithArg<1>(Invoke(Unary));  // NOLINT
  EXPECT_TRUE(b.Perform(std::make_tuple(1.5, -1)));
  EXPECT_FALSE(b.Perform(std::make_tuple(1.5, 1)));
 }
@ -493,34 +482,6 @@ 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;
@ -737,24 +698,12 @@ TEST(InvokeArgumentTest, Function0) {
  EXPECT_EQ(1, a.Perform(std::make_tuple(2, &Nullary)));
 }

-// Tests using InvokeArgument with a unary functor.
+// Tests using InvokeArgument with a unary function.
 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
@ -785,34 +734,34 @@ TEST(InvokeArgumentTest, Functor6) {

 // Tests using InvokeArgument with a 7-ary function.
 TEST(InvokeArgumentTest, Function7) {
-  Action<std::string(std::string (*)(const char*, const char*, const char*,
-                                     const char*, const char*, const char*,
-                                     const char*))>
+  Action<std::string(std::string(*)(const char*, const char*, const char*,
+                                    const char*, const char*, const char*,
+                                    const char*))>
      a = InvokeArgument<0>("1", "2", "3", "4", "5", "6", "7");
  EXPECT_EQ("1234567", a.Perform(std::make_tuple(&Concat7)));
 }

 // Tests using InvokeArgument with a 8-ary function.
 TEST(InvokeArgumentTest, Function8) {
-  Action<std::string(std::string (*)(const char*, const char*, const char*,
-                                     const char*, const char*, const char*,
-                                     const char*, const char*))>
+  Action<std::string(std::string(*)(const char*, const char*, const char*,
+                                    const char*, const char*, const char*,
+                                    const char*, const char*))>
      a = InvokeArgument<0>("1", "2", "3", "4", "5", "6", "7", "8");
  EXPECT_EQ("12345678", a.Perform(std::make_tuple(&Concat8)));
 }

 // Tests using InvokeArgument with a 9-ary function.
 TEST(InvokeArgumentTest, Function9) {
-  Action<std::string(std::string (*)(const char*, const char*, const char*,
-                                     const char*, const char*, const char*,
-                                     const char*, const char*, const char*))>
+  Action<std::string(std::string(*)(const char*, const char*, const char*,
+                                    const char*, const char*, const char*,
+                                    const char*, const char*, const char*))>
      a = InvokeArgument<0>("1", "2", "3", "4", "5", "6", "7", "8", "9");
  EXPECT_EQ("123456789", a.Perform(std::make_tuple(&Concat9)));
 }

 // Tests using InvokeArgument with a 10-ary function.
 TEST(InvokeArgumentTest, Function10) {
-  Action<std::string(std::string (*)(
+  Action<std::string(std::string(*)(
      const char*, const char*, const char*, const char*, const char*,
      const char*, const char*, const char*, const char*, const char*))>
      a = InvokeArgument<0>("1", "2", "3", "4", "5", "6", "7", "8", "9", "0");
@ -857,22 +806,6 @@ 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;
--- a/googlemock/test/gmock-pp_test.cc
+++ b/googlemock/test/gmock-pp_test.cc
@ -70,7 +70,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=windows.
+// TODO(iserna): The following asserts fail in --config=lexan.
 #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/googlemock/test/gmock-spec-builders_test.cc
+++ b/googlemock/test/gmock-spec-builders_test.cc
@ -160,7 +160,7 @@ class MockCC : public CC {
 // Tests that a method with expanded name compiles.
 TEST(OnCallSyntaxTest, CompilesWithMethodNameExpandedFromMacro) {
  MockCC cc;
-  (void)ON_CALL(cc, Method());
+  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;

-  (void)ON_CALL(*pa++, DoA(_));
+  ON_CALL(*pa++, DoA(_));
  EXPECT_EQ(&a + 1, pa);
 }

@ -201,7 +201,7 @@ TEST(OnCallSyntaxTest, EvaluatesSecondArgumentOnce) {
  MockA a;
  int n = 0;

-  (void)ON_CALL(a, DoA(n++));
+  ON_CALL(a, DoA(n++));
  EXPECT_EQ(1, n);
 }

@ -232,7 +232,7 @@ TEST(OnCallSyntaxTest, WillByDefaultIsMandatory) {

  EXPECT_DEATH_IF_SUPPORTED(
      {
-        (void)ON_CALL(a, DoA(5));
+        ON_CALL(a, DoA(5));
        a.DoA(5);
      },
      "");
@ -804,8 +804,9 @@ TEST(ExpectCallTest, InfersCardinality1WhenThereIsWillRepeatedly) {
      "to be called at least once");
 }

-// TODO(b/396121064) - Fix this test under MSVC
-#ifndef _MSC_VER
+#if defined(GTEST_INTERNAL_CPLUSPLUS_LANG) && \
+    GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
+
 // It should be possible to return a non-moveable type from a mock action in
 // C++17 and above, where it's guaranteed that such a type can be initialized
 // from a prvalue returned from a function.
@ -846,7 +847,7 @@ TEST(ExpectCallTest, NonMoveableType) {
  EXPECT_EQ(17, mock.AsStdFunction()().x);
 }

-#endif  // _MSC_VER
+#endif  // C++17 and above

 // Tests that the n-th action is taken for the n-th matching
 // invocation.
@ -905,7 +906,7 @@ TEST(ExpectCallTest, TakesDefaultActionWhenWillListIsExhausted) {
                        " - returning default value."));
 }

-TEST(FunctionMockerMessageTest, ReportsExpectCallLocationForExhaustedActions) {
+TEST(FunctionMockerMessageTest, ReportsExpectCallLocationForExhausedActions) {
  MockB b;
  std::string expect_call_location = FormatFileLocation(__FILE__, __LINE__ + 1);
  EXPECT_CALL(b, DoB()).Times(AnyNumber()).WillOnce(Return(1));
@ -2045,7 +2046,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 adding "
+        "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/"
--- a/googlemock/test/gmock_link_test.h
+++ b/googlemock/test/gmock_link_test.h
@ -186,7 +186,6 @@ using testing::SetErrnoAndReturn;
 #endif

 #if GTEST_HAS_EXCEPTIONS
-using testing::Rethrow;
 using testing::Throw;
 #endif

@ -417,14 +416,6 @@ 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/googlemock/test/gmock_output_test_golden.txt
+++ b/googlemock/test/gmock_output_test_golden.txt
@ -79,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 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 blindly adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect-useoncall for details.
 [       OK ] GMockOutputTest.UninterestingCall
 [ 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 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 blindly adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect-useoncall for details.
 [       OK ] GMockOutputTest.UninterestingCallToVoidFunction
 [ RUN      ] GMockOutputTest.RetiredExpectation
 unknown file: Failure
@ -283,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 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 blindly adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect-useoncall for details.

 GMOCK WARNING:
 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 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 blindly adding an EXPECT_CALL() if you don't mean to enforce the call.  See https://github.com/google/googletest/blob/main/docs/gmock_cook_book.md#knowing-when-to-expect-useoncall for details.
 [       OK ] GMockOutputTest.UninterestingCallWithDefaultAction
 [ RUN      ] GMockOutputTest.ExplicitActionsRunOutWithDefaultAction

--- a/googletest/CMakeLists.txt
+++ b/googletest/CMakeLists.txt
@ -5,7 +5,7 @@
 # CMake build script for Google Test.
 #
 # To run the tests for Google Test itself on Linux, use 'make test' or
-# ctest. You can select which tests to run using 'ctest -R regex'.
+# ctest.  You can select which tests to run using 'ctest -R regex'.
 # For more options, run 'ctest --help'.

 # When other libraries are using a shared version of runtime libraries,
@ -35,7 +35,7 @@ endif()

 ########################################################################
 #
-# Project-wide settings.
+# Project-wide settings

 # Name of the project.
 #
@ -44,7 +44,7 @@ endif()
 # ${gtest_BINARY_DIR}.
 # Language "C" is required for find_package(Threads).

-# Project version.
+# Project version:

 cmake_minimum_required(VERSION 3.13)
 project(gtest VERSION ${GOOGLETEST_VERSION} LANGUAGES CXX C)
@ -53,7 +53,7 @@ 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
@ -83,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.
@ -114,10 +114,10 @@ include_directories(${gtest_build_include_dirs})

 ########################################################################
 #
-# Defines the gtest & gtest_main libraries. User tests should link
+# Defines the gtest & gtest_main libraries.  User tests should link
 # with one of them.

-# Google Test libraries. We build them using more strict warnings than what
+# Google Test libraries.  We build them using more strict warnings than what
 # are used for other targets, to ensure that gtest can be compiled by a user
 # aggressive about warnings.
 cxx_library(gtest "${cxx_strict}" src/gtest-all.cc)
@ -132,6 +132,9 @@ if(GTEST_HAS_ABSL)
    absl::flags_reflection
    absl::flags_usage
    absl::strings
+    absl::any
+    absl::optional
+    absl::variant
    re2::re2
  )
 endif()
@ -144,22 +147,22 @@ target_include_directories(gtest SYSTEM INTERFACE
 target_include_directories(gtest_main SYSTEM INTERFACE
  "$<BUILD_INTERFACE:${dirs}>"
  "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>")
-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)

 ########################################################################
 #
 # Samples on how to link user tests with gtest or gtest_main.
 #
-# They are not built by default. To build them, set the
-# gtest_build_samples option to ON. You can do it by running ccmake
+# They are not built by default.  To build them, set the
+# gtest_build_samples option to ON.  You can do it by running ccmake
 # or specifying the -Dgtest_build_samples=ON flag when running cmake.

 if (gtest_build_samples)
@ -182,8 +185,8 @@ endif()
 # You can skip this section if you aren't interested in testing
 # Google Test itself.
 #
-# The tests are not built by default. To build them, set the
-# gtest_build_tests option to ON. You can do it by running ccmake
+# The tests are not built by default.  To build them, set the
+# gtest_build_tests option to ON.  You can do it by running ccmake
 # or specifying the -Dgtest_build_tests=ON flag when running cmake.

 if (gtest_build_tests)
@ -265,7 +268,7 @@ if (gtest_build_tests)
  py_test(gtest_skip_environment_check_output_test)

  # Visual Studio .NET 2003 does not support STL with exceptions disabled.
-  if (NOT MSVC OR MSVC_VERSION GREATER 1310) # 1310 is Visual Studio .NET 2003
+  if (NOT MSVC OR MSVC_VERSION GREATER 1310)  # 1310 is Visual Studio .NET 2003
    cxx_executable_with_flags(
      googletest-catch-exceptions-no-ex-test_
      "${cxx_no_exception}"
--- a/googletest/README.md
+++ b/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
-<https://cmake.org/>.
+<http://www.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.17.0
+git clone https://github.com/google/googletest.git -b v1.13.0
 cd googletest        # Main directory of the cloned repository.
 mkdir build          # Create a directory to hold the build output.
 cd build
@ -124,9 +124,9 @@ match the project in which it is included.

 #### C++ Standard Version

-An environment that supports C++17 is required in order to successfully build
+An environment that supports C++14 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 17)` command along
+project, for example by using the `set(CMAKE_CXX_STANDARD 14)` command along
 with `set(CMAKE_CXX_STANDARD_REQUIRED ON)`. If this is not feasible, for example
 in a C project using GoogleTest for validation, then it can be specified by
 adding it to the options for cmake via the`-DCMAKE_CXX_FLAGS` option.
@ -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 `GTEST_IS_THREADSAFE` macro to see
-whether this is the case (yes if the macro is `#defined` to 1, no if it's
-undefined.).
+`#include <gtest/gtest.h>`, you can check the
+`GTEST_IS_THREADSAFE` macro to see whether this is the case (yes if the macro is
+`#defined` to 1, no if it's undefined.).

 If GoogleTest doesn't correctly detect whether pthread is available in your
 environment, you can force it with
--- a/googletest/cmake/Config.cmake.in
+++ b/googletest/cmake/Config.cmake.in
@ -4,10 +4,6 @@ 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/googletest/cmake/internal_utils.cmake
+++ b/googletest/cmake/internal_utils.cmake
@ -29,7 +29,7 @@ macro(fix_default_compiler_settings_)
             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
+        # 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
@ -55,11 +55,11 @@ macro(fix_default_compiler_settings_)
 endmacro()

 # Defines the compiler/linker flags used to build Google Test and
-# Google Mock. You can tweak these definitions to suit your need. A
+# Google Mock.  You can tweak these definitions to suit your need.  A
 # 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.
@ -79,8 +79,8 @@ macro(config_compiler_and_linker)
    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,
-    # https://stackoverflow.com/questions/3232669 explains the issue.
+    # Suppress "unreachable code" warning
+    # http://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")
@ -110,7 +110,7 @@ macro(config_compiler_and_linker)
    set(cxx_exception_flags "-fexceptions")
    set(cxx_no_exception_flags "-fno-exceptions")
    # Until version 4.3.2, GCC doesn't define a macro to indicate
-    # whether RTTI is enabled. Therefore we define GTEST_HAS_RTTI
+    # whether RTTI is enabled.  Therefore we define GTEST_HAS_RTTI
    # explicitly.
    set(cxx_no_rtti_flags "-fno-rtti -DGTEST_HAS_RTTI=0")
    set(cxx_strict_flags
@ -127,7 +127,7 @@ macro(config_compiler_and_linker)
    set(cxx_exception_flags "-qeh")
    set(cxx_no_exception_flags "-qnoeh")
    # Until version 9.0, Visual Age doesn't define a macro to indicate
-    # whether RTTI is enabled. Therefore we define GTEST_HAS_RTTI
+    # whether RTTI is enabled.  Therefore we define GTEST_HAS_RTTI
    # explicitly.
    set(cxx_no_rtti_flags "-qnortti -DGTEST_HAS_RTTI=0")
  elseif (CMAKE_CXX_COMPILER_ID STREQUAL "HP")
@ -157,7 +157,7 @@ macro(config_compiler_and_linker)
  set(cxx_strict "${cxx_default} ${cxx_strict_flags}")
 endmacro()

-# Defines the gtest & gtest_main libraries. User tests should link
+# Defines the gtest & gtest_main libraries.  User tests should link
 # with one of them.
 function(cxx_library_with_type name type cxx_flags)
  # type can be either STATIC or SHARED to denote a static or shared library.
@ -167,7 +167,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"
@ -175,7 +175,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
@ -195,7 +195,7 @@ function(cxx_library_with_type name type cxx_flags)
    target_link_libraries(${name} PUBLIC Threads::Threads)
  endif()

-  target_compile_features(${name} PUBLIC cxx_std_17)
+  target_compile_features(${name} PUBLIC cxx_std_14)
 endfunction()

 ########################################################################
@ -212,7 +212,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})
@ -239,21 +239,19 @@ endfunction()

 # cxx_executable(name dir lib srcs...)
 #
-# 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
+# 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)
  cxx_executable_with_flags(
    ${name} "${cxx_default}" "${libs}" "${dir}/${name}.cc" ${ARGN})
 endfunction()

-if(gtest_build_tests)
-  find_package(Python3)
-endif()
+find_package(Python3)

 # 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})
@ -262,8 +260,8 @@ endfunction()

 # cxx_test(name libs srcs...)
 #
-# Creates a named test target that depends on the given libs and is
-# built from the given source files. Unlike cxx_test_with_flags,
+# 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)
  cxx_test_with_flags("${name}" "${cxx_default}" "${libs}"
@ -272,8 +270,8 @@ endfunction()

 # py_test(name)
 #
-# Creates a Python test with the given name whose main module is in
-# test/name.py. It does nothing if Python is not installed.
+# 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 (NOT Python3_Interpreter_FOUND)
    return()
@ -309,7 +307,7 @@ function(install_project)
      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)
--- a/googletest/include/gtest/gtest-assertion-result.h
+++ b/googletest/include/gtest/gtest-assertion-result.h
@ -130,13 +130,6 @@ namespace testing {
 //   Expected: Foo() is even
 //     Actual: it's 5
 //
-
-// 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_ AssertionResult {
 public:
  // Copy constructor.
--- a/googletest/include/gtest/gtest-death-test.h
+++ b/googletest/include/gtest/gtest-death-test.h
@ -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_or_matcher -  A regex that a macro such as EXPECT_DEATH would use
-//                to test the output of statement.  This parameter has to be
+//   regex     -  A regex that a macro such as EXPECT_DEATH would use 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_or_matcher, terminator)  \
+#define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, 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::MakeDeathTestMatcher(regex_or_matcher);               \
+    ::testing::internal::RE::PartialMatch(".*", (regex));                      \
    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);                 \
    terminator;                                                                \
  } else                                                                       \
--- a/googletest/include/gtest/gtest-matchers.h
+++ b/googletest/include/gtest/gtest-matchers.h
@ -67,10 +67,10 @@ 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*) const;
+//     bool MatchAndExplain(const T&, std::ostream*);
 //       (MatchResultListener* can also be used instead of std::ostream*)
-//     void DescribeTo(std::ostream*) const;
-//     void DescribeNegationTo(std::ostream*) const;
+//     void DescribeTo(std::ostream*);
+//     void DescribeNegationTo(std::ostream*);
 //
 //   2. a factory function that creates a Matcher<T> object from a
 //      FooMatcherMatcher.
@ -296,12 +296,12 @@ class MatcherBase : private MatcherDescriberInterface {
    return *this;
  }

-  MatcherBase(MatcherBase&& other) noexcept
+  MatcherBase(MatcherBase&& other)
      : vtable_(other.vtable_), buffer_(other.buffer_) {
    other.vtable_ = nullptr;
  }

-  MatcherBase& operator=(MatcherBase&& other) noexcept {
+  MatcherBase& operator=(MatcherBase&& other) {
    if (this == &other) return *this;
    Destroy();
    vtable_ = other.vtable_;
@ -773,35 +773,6 @@ class GeMatcher
  static const char* NegatedDesc() { return "isn't >="; }
 };

-// Same as `EqMatcher<Rhs>`, except that the `rhs` is stored as `StoredRhs` and
-// must be implicitly convertible to `Rhs`.
-template <typename Rhs, typename StoredRhs>
-class 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_;
-};
-
 template <typename T, typename = typename std::enable_if<
                          std::is_constructible<std::string, T>::value>::type>
 using StringLike = T;
--- a/googletest/include/gtest/gtest-message.h
+++ b/googletest/include/gtest/gtest-message.h
@ -59,7 +59,7 @@
 #ifdef GTEST_HAS_ABSL
 #include <type_traits>

-#include "absl/strings/has_absl_stringify.h"
+#include "absl/strings/internal/has_absl_stringify.h"
 #include "absl/strings/str_cat.h"
 #endif  // GTEST_HAS_ABSL

@ -121,14 +121,14 @@ class GTEST_API_ Message {
  // Streams a non-pointer value to this object. If building a version of
  // GoogleTest with ABSL, this overload is only enabled if the value does not
  // have an AbslStringify definition.
-  template <
-      typename T
+  template <typename T
 #ifdef GTEST_HAS_ABSL
-      ,
-      typename std::enable_if<!absl::HasAbslStringify<T>::value,  // NOLINT
-                              int>::type = 0
+            ,
+            typename std::enable_if<
+                !absl::strings_internal::HasAbslStringify<T>::value,  // NOLINT
+                int>::type = 0
 #endif  // GTEST_HAS_ABSL
-      >
+            >
  inline Message& operator<<(const T& val) {
        // Some libraries overload << for STL containers.  These
    // overloads are defined in the global namespace instead of ::std.
@ -153,8 +153,9 @@ class GTEST_API_ Message {
  // 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>
+            typename std::enable_if<
+                absl::strings_internal::HasAbslStringify<T>::value,  // NOLINT
+                int>::type = 0>
  inline Message& operator<<(const T& val) {
    // ::operator<< is needed here for a similar reason as with the non-Abseil
    // version above
--- a/googletest/include/gtest/gtest-param-test.h
+++ b/googletest/include/gtest/gtest-param-test.h
@ -174,12 +174,11 @@ 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"  // IWYU pragma: export
+#include "gtest/internal/gtest-param-util.h"
 #include "gtest/internal/gtest-port.h"

 namespace testing {
@ -414,8 +413,7 @@ internal::CartesianProductHolder<Generator...> Combine(const Generator&... g) {
 // Synopsis:
 // ConvertGenerator<T>(gen)
 //   - returns a generator producing the same elements as generated by gen, but
-//     each T-typed element is static_cast to a type deduced from the interface
-//     that accepts this generator, and then returned
+//     each element is static_cast to type T before being returned
 //
 // It is useful when using the Combine() function to get the generated
 // parameters in a custom type instead of std::tuple
@ -443,65 +441,10 @@ internal::CartesianProductHolder<Generator...> Combine(const Generator&... g) {
 //                              Combine(Values("cat", "dog"),
 //                                      Values(BLACK, WHITE))));
 //
-template <typename RequestedT>
-internal::ParamConverterGenerator<RequestedT> ConvertGenerator(
-    internal::ParamGenerator<RequestedT> 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.");
-  }
+template <typename T>
+internal::ParamConverterGenerator<T> ConvertGenerator(
+    internal::ParamGenerator<T> gen) {
+  return internal::ParamConverterGenerator<T>(gen);
 }

 #define TEST_P(test_suite_name, test_name)                                     \
@ -526,7 +469,7 @@ auto ConvertGenerator(Gen&& gen, Func&& f) {
              ::testing::internal::CodeLocation(__FILE__, __LINE__));          \
      return 0;                                                                \
    }                                                                          \
-    [[maybe_unused]] static int gtest_registering_dummy_;                      \
+    static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_;               \
  };                                                                           \
  int GTEST_TEST_CLASS_NAME_(test_suite_name,                                  \
                             test_name)::gtest_registering_dummy_ =            \
@ -550,38 +493,39 @@ auto ConvertGenerator(Gen&& gen, Func&& f) {
 #define GTEST_GET_FIRST_(first, ...) first
 #define GTEST_GET_SECOND_(first, second, ...) second

-#define INSTANTIATE_TEST_SUITE_P(prefix, test_suite_name, ...)                \
-  static ::testing::internal::ParamGenerator<test_suite_name::ParamType>      \
-      gtest_##prefix##test_suite_name##_EvalGenerator_() {                    \
-    return GTEST_EXPAND_(GTEST_GET_FIRST_(__VA_ARGS__, DUMMY_PARAM_));        \
-  }                                                                           \
-  static ::std::string gtest_##prefix##test_suite_name##_EvalGenerateName_(   \
-      const ::testing::TestParamInfo<test_suite_name::ParamType>& info) {     \
-    if (::testing::internal::AlwaysFalse()) {                                 \
-      ::testing::internal::TestNotEmpty(GTEST_EXPAND_(GTEST_GET_SECOND_(      \
-          __VA_ARGS__,                                                        \
-          ::testing::internal::DefaultParamName<test_suite_name::ParamType>,  \
-          DUMMY_PARAM_)));                                                    \
-      auto t = std::make_tuple(__VA_ARGS__);                                  \
-      static_assert(std::tuple_size<decltype(t)>::value <= 2,                 \
-                    "Too Many Args!");                                        \
-    }                                                                         \
-    return ((GTEST_EXPAND_(GTEST_GET_SECOND_(                                 \
-        __VA_ARGS__,                                                          \
-        ::testing::internal::DefaultParamName<test_suite_name::ParamType>,    \
-        DUMMY_PARAM_))))(info);                                               \
-  }                                                                           \
-  [[maybe_unused]] static int gtest_##prefix##test_suite_name##_dummy_ =      \
-      ::testing::UnitTest::GetInstance()                                      \
-          ->parameterized_test_registry()                                     \
-          .GetTestSuitePatternHolder<test_suite_name>(                        \
-              GTEST_STRINGIFY_(test_suite_name),                              \
-              ::testing::internal::CodeLocation(__FILE__, __LINE__))          \
-          ->AddTestSuiteInstantiation(                                        \
-              GTEST_STRINGIFY_(prefix),                                       \
-              &gtest_##prefix##test_suite_name##_EvalGenerator_,              \
-              &gtest_##prefix##test_suite_name##_EvalGenerateName_, __FILE__, \
-              __LINE__)
+#define INSTANTIATE_TEST_SUITE_P(prefix, test_suite_name, ...)               \
+  static ::testing::internal::ParamGenerator<test_suite_name::ParamType>     \
+      gtest_##prefix##test_suite_name##_EvalGenerator_() {                   \
+    return GTEST_EXPAND_(GTEST_GET_FIRST_(__VA_ARGS__, DUMMY_PARAM_));       \
+  }                                                                          \
+  static ::std::string gtest_##prefix##test_suite_name##_EvalGenerateName_(  \
+      const ::testing::TestParamInfo<test_suite_name::ParamType>& info) {    \
+    if (::testing::internal::AlwaysFalse()) {                                \
+      ::testing::internal::TestNotEmpty(GTEST_EXPAND_(GTEST_GET_SECOND_(     \
+          __VA_ARGS__,                                                       \
+          ::testing::internal::DefaultParamName<test_suite_name::ParamType>, \
+          DUMMY_PARAM_)));                                                   \
+      auto t = std::make_tuple(__VA_ARGS__);                                 \
+      static_assert(std::tuple_size<decltype(t)>::value <= 2,                \
+                    "Too Many Args!");                                       \
+    }                                                                        \
+    return ((GTEST_EXPAND_(GTEST_GET_SECOND_(                                \
+        __VA_ARGS__,                                                         \
+        ::testing::internal::DefaultParamName<test_suite_name::ParamType>,   \
+        DUMMY_PARAM_))))(info);                                              \
+  }                                                                          \
+  static int gtest_##prefix##test_suite_name##_dummy_                        \
+      GTEST_ATTRIBUTE_UNUSED_ =                                              \
+          ::testing::UnitTest::GetInstance()                                 \
+              ->parameterized_test_registry()                                \
+              .GetTestSuitePatternHolder<test_suite_name>(                   \
+                  GTEST_STRINGIFY_(test_suite_name),                         \
+                  ::testing::internal::CodeLocation(__FILE__, __LINE__))     \
+              ->AddTestSuiteInstantiation(                                   \
+                  GTEST_STRINGIFY_(prefix),                                  \
+                  &gtest_##prefix##test_suite_name##_EvalGenerator_,         \
+                  &gtest_##prefix##test_suite_name##_EvalGenerateName_,      \
+                  __FILE__, __LINE__)

 // Allow Marking a Parameterized test class as not needing to be instantiated.
 #define GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(T)                  \
--- a/googletest/include/gtest/gtest-printers.h
+++ b/googletest/include/gtest/gtest-printers.h
@ -104,36 +104,24 @@
 #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/internal/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.
@ -143,32 +131,13 @@ 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)) &&
-                 !IsRecursiveContainer<T>::value) ||
-                IsStdSpan<T>::value>::type>
+                (sizeof(IsContainerTest<T>(0)) == sizeof(IsContainer)) &&
+                !IsRecursiveContainer<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 << '{';
@ -300,9 +269,10 @@ struct ConvertibleToStringViewPrinter {

 #ifdef GTEST_HAS_ABSL
 struct ConvertibleToAbslStringifyPrinter {
-  template <typename T,
-            typename = typename std::enable_if<
-                absl::HasAbslStringify<T>::value>::type>  // NOLINT
+  template <
+      typename T,
+      typename = typename std::enable_if<
+          absl::strings_internal::HasAbslStringify<T>::value>::type>  // NOLINT
  static void PrintValue(const T& value, ::std::ostream* os) {
    *os << absl::StrCat(value);
  }
@ -525,15 +495,11 @@ 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) {
-  // 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);
+  PrintTo(ImplicitCast_<char32_t>(c), os);
 }
 #ifdef __cpp_lib_char8_t
 inline void PrintTo(char8_t c, ::std::ostream* 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);
+  PrintTo(ImplicitCast_<char32_t>(c), os);
 }
 #endif

@ -564,63 +530,49 @@ 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;
-    // 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
+    if (val >= 100000.0) {  // 100,000 to 999,999
      mulfor6 = 1.0;
-    } else if (val >= static_cast<FloatType>(10000.0)) {
+    } else if (val >= 10000.0) {
      mulfor6 = 1e1;
-    } else if (val >= static_cast<FloatType>(1000.0)) {
+    } else if (val >= 1000.0) {
      mulfor6 = 1e2;
-    } else if (val >= static_cast<FloatType>(100.0)) {
+    } else if (val >= 100.0) {
      mulfor6 = 1e3;
-    } else if (val >= static_cast<FloatType>(10.0)) {
+    } else if (val >= 10.0) {
      mulfor6 = 1e4;
-    } else if (val >= static_cast<FloatType>(1.0)) {
+    } else if (val >= 1.0) {
      mulfor6 = 1e5;
-    } else if (val >= static_cast<FloatType>(0.1)) {
+    } else if (val >= 0.1) {
      mulfor6 = 1e6;
-    } else if (val >= static_cast<FloatType>(0.01)) {
+    } else if (val >= 0.01) {
      mulfor6 = 1e7;
-    } else if (val >= static_cast<FloatType>(0.001)) {
+    } else if (val >= 0.001) {
      mulfor6 = 1e8;
-    } else if (val >= static_cast<FloatType>(0.0001)) {
+    } else if (val >= 0.0001) {
      mulfor6 = 1e9;
    }
-    if (static_cast<FloatType>(static_cast<int32_t>(
-            val * mulfor6 + (static_cast<FloatType>(0.5)))) /
+    if (static_cast<FloatType>(static_cast<int32_t>(val * mulfor6 + 0.5)) /
            mulfor6 ==
        val)
      return 6;
-  } else if (val < static_cast<FloatType>(1e10)) {
-    FloatType divfor6 = static_cast<FloatType>(1.0);
-    if (val >= static_cast<FloatType>(1e9)) {  // 1,000,000,000 to 9,999,999,999
+  } else if (val < 1e10) {
+    FloatType divfor6 = 1.0;
+    if (val >= 1e9) {  // 1,000,000,000 to 9,999,999,999
      divfor6 = 10000;
-    } else if (val >=
-               static_cast<FloatType>(1e8)) {  // 100,000,000 to 999,999,999
+    } else if (val >= 1e8) {  // 100,000,000 to 999,999,999
      divfor6 = 1000;
-    } else if (val >=
-               static_cast<FloatType>(1e7)) {  // 10,000,000 to 99,999,999
+    } else if (val >= 1e7) {  // 10,000,000 to 99,999,999
      divfor6 = 100;
-    } else if (val >= static_cast<FloatType>(1e6)) {  // 1,000,000 to 9,999,999
+    } else if (val >= 1e6) {  // 1,000,000 to 9,999,999
      divfor6 = 10;
    }
-    if (static_cast<FloatType>(static_cast<int32_t>(
-            val / divfor6 + (static_cast<FloatType>(0.5)))) *
+    if (static_cast<FloatType>(static_cast<int32_t>(val / divfor6 + 0.5)) *
            divfor6 ==
        val)
      return 6;
  }
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
  return full;
 }

@ -703,63 +655,44 @@ void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
  }
 }

-// Overloads for ::std::string and ::std::string_view
-GTEST_API_ void PrintStringTo(::std::string_view s, ::std::ostream* os);
+// Overloads for ::std::string.
+GTEST_API_ void PrintStringTo(const ::std::string& 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 and ::std::u8string_view
+// Overloads for ::std::u8string
 #ifdef __cpp_lib_char8_t
-GTEST_API_ void PrintU8StringTo(::std::u8string_view s, ::std::ostream* os);
+GTEST_API_ void PrintU8StringTo(const ::std::u8string& 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 and ::std::u16string_view
-GTEST_API_ void PrintU16StringTo(::std::u16string_view s, ::std::ostream* os);
+// Overloads for ::std::u16string
+GTEST_API_ void PrintU16StringTo(const ::std::u16string& 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 and ::std::u32string_view
-GTEST_API_ void PrintU32StringTo(::std::u32string_view s, ::std::ostream* os);
+// Overloads for ::std::u32string
+GTEST_API_ void PrintU32StringTo(const ::std::u32string& 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 and ::std::wstring_view
+// Overloads for ::std::wstring.
 #if GTEST_HAS_STD_WSTRING
-GTEST_API_ void PrintWideStringTo(::std::wstring_view s, ::std::ostream* os);
+GTEST_API_ void PrintWideStringTo(const ::std::wstring& 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
-// 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>
+// Overload for internal::StringView.
 inline void PrintTo(internal::StringView sp, ::std::ostream* os) {
-  PrintStringTo(sp, os);
+  PrintTo(::std::string(sp), os);
 }
 #endif  // GTEST_INTERNAL_HAS_STRING_VIEW

@ -813,41 +746,6 @@ 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>
@ -917,11 +815,14 @@ class UniversalPrinter {
 template <typename T>
 class UniversalPrinter<const T> : public UniversalPrinter<T> {};

-// Printer for std::any
+#if GTEST_INTERNAL_HAS_ANY
+
+// Printer for std::any / absl::any
+
 template <>
-class UniversalPrinter<std::any> {
+class UniversalPrinter<Any> {
 public:
-  static void Print(const std::any& value, ::std::ostream* os) {
+  static void Print(const Any& value, ::std::ostream* os) {
    if (value.has_value()) {
      *os << "value of type " << GetTypeName(value);
    } else {
@ -930,7 +831,7 @@ class UniversalPrinter<std::any> {
  }

 private:
-  static std::string GetTypeName(const std::any& value) {
+  static std::string GetTypeName(const Any& value) {
 #if GTEST_HAS_RTTI
    return internal::GetTypeName(value.type());
 #else
@ -940,11 +841,16 @@ class UniversalPrinter<std::any> {
  }
 };

-// Printer for std::optional
+#endif  // GTEST_INTERNAL_HAS_ANY
+
+#if GTEST_INTERNAL_HAS_OPTIONAL
+
+// Printer for std::optional / absl::optional
+
 template <typename T>
-class UniversalPrinter<std::optional<T>> {
+class UniversalPrinter<Optional<T>> {
 public:
-  static void Print(const std::optional<T>& value, ::std::ostream* os) {
+  static void Print(const Optional<T>& value, ::std::ostream* os) {
    *os << '(';
    if (!value) {
      *os << "nullopt";
@ -956,18 +862,29 @@ class UniversalPrinter<std::optional<T>> {
 };

 template <>
-class UniversalPrinter<std::nullopt_t> {
+class UniversalPrinter<decltype(Nullopt())> {
 public:
-  static void Print(std::nullopt_t, ::std::ostream* os) { *os << "(nullopt)"; }
+  static void Print(decltype(Nullopt()), ::std::ostream* os) {
+    *os << "(nullopt)";
+  }
 };

-// Printer for std::variant
+#endif  // GTEST_INTERNAL_HAS_OPTIONAL
+
+#if GTEST_INTERNAL_HAS_VARIANT
+
+// Printer for std::variant / absl::variant
+
 template <typename... T>
-class UniversalPrinter<std::variant<T...>> {
+class UniversalPrinter<Variant<T...>> {
 public:
-  static void Print(const std::variant<T...>& value, ::std::ostream* os) {
+  static void Print(const Variant<T...>& value, ::std::ostream* os) {
    *os << '(';
+#ifdef GTEST_HAS_ABSL
+    absl::visit(Visitor{os, value.index()}, value);
+#else
    std::visit(Visitor{os, value.index()}, value);
+#endif  // GTEST_HAS_ABSL
    *os << ')';
  }

@ -984,6 +901,8 @@ class UniversalPrinter<std::variant<T...>> {
  };
 };

+#endif  // GTEST_INTERNAL_HAS_VARIANT
+
 // UniversalPrintArray(begin, len, os) prints an array of 'len'
 // elements, starting at address 'begin'.
 template <typename T>
--- a/googletest/include/gtest/gtest-typed-test.h
+++ b/googletest/include/gtest/gtest-typed-test.h
@ -48,15 +48,15 @@ template <typename T>
 class FooTest : public testing::Test {
 public:
  ...
-  using List = ::std::list<T>;
+  typedef std::list<T> List;
  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 using-declaration is necessary for
+// repeated for each type in the list.  The typedef is necessary for
 // the macro to parse correctly.
-using MyTypes = ::testing::Types<char, int, unsigned int>;
+typedef testing::Types<char, int, unsigned int> MyTypes;
 TYPED_TEST_SUITE(FooTest, MyTypes);

 // If the type list contains only one type, you can write that type
@ -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.
-using MyTypes = ::testing::Types<char, int, unsigned int>;
+typedef testing::Types<char, int, unsigned int> MyTypes;
 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;                                                 \
  };                                                                          \
-  [[maybe_unused]] static bool gtest_##CaseName##_##TestName##_registered_ =  \
-      ::testing::internal::TypeParameterizedTest<                             \
+  static bool gtest_##CaseName##_##TestName##_registered_                     \
+      GTEST_ATTRIBUTE_UNUSED_ = ::testing::internal::TypeParameterizedTest<   \
          CaseName,                                                           \
          ::testing::internal::TemplateSel<GTEST_TEST_CLASS_NAME_(CaseName,   \
                                                                  TestName)>, \
@ -267,22 +267,22 @@ INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
  TYPED_TEST_SUITE_P
 #endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_

-#define TYPED_TEST_P(SuiteName, TestName)                     \
-  namespace GTEST_SUITE_NAMESPACE_(SuiteName) {               \
-  template <typename gtest_TypeParam_>                        \
-  class TestName : public SuiteName<gtest_TypeParam_> {       \
-   private:                                                   \
-    typedef SuiteName<gtest_TypeParam_> TestFixture;          \
-    typedef gtest_TypeParam_ TypeParam;                       \
-    void TestBody() override;                                 \
-  };                                                          \
-  [[maybe_unused]] static bool gtest_##TestName##_defined_ =  \
-      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).AddTestName( \
-          __FILE__, __LINE__, GTEST_STRINGIFY_(SuiteName),    \
-          GTEST_STRINGIFY_(TestName));                        \
-  }                                                           \
-  template <typename gtest_TypeParam_>                        \
-  void GTEST_SUITE_NAMESPACE_(                                \
+#define TYPED_TEST_P(SuiteName, TestName)                           \
+  namespace GTEST_SUITE_NAMESPACE_(SuiteName) {                     \
+  template <typename gtest_TypeParam_>                              \
+  class TestName : public SuiteName<gtest_TypeParam_> {             \
+   private:                                                         \
+    typedef SuiteName<gtest_TypeParam_> TestFixture;                \
+    typedef gtest_TypeParam_ TypeParam;                             \
+    void TestBody() override;                                       \
+  };                                                                \
+  static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \
+      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).AddTestName(       \
+          __FILE__, __LINE__, GTEST_STRINGIFY_(SuiteName),          \
+          GTEST_STRINGIFY_(TestName));                              \
+  }                                                                 \
+  template <typename gtest_TypeParam_>                              \
+  void GTEST_SUITE_NAMESPACE_(                                      \
      SuiteName)::TestName<gtest_TypeParam_>::TestBody()

 // Note: this won't work correctly if the trailing arguments are macros.
@ -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_;      \
  }                                                                         \
-  [[maybe_unused]] static const char* const GTEST_REGISTERED_TEST_NAMES_(   \
-      SuiteName) =                                                          \
+  static const char* const GTEST_REGISTERED_TEST_NAMES_(                    \
+      SuiteName) GTEST_ATTRIBUTE_UNUSED_ =                                  \
      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");                    \
-  [[maybe_unused]] static bool gtest_##Prefix##_##SuiteName =             \
+  static bool gtest_##Prefix##_##SuiteName GTEST_ATTRIBUTE_UNUSED_ =      \
      ::testing::internal::TypeParameterizedTestSuite<                    \
          SuiteName, GTEST_SUITE_NAMESPACE_(SuiteName)::gtest_AllTests_,  \
          ::testing::internal::GenerateTypeList<Types>::type>::           \
--- a/googletest/include/gtest/gtest.h
+++ b/googletest/include/gtest/gtest.h
@ -51,6 +51,7 @@

 #include <cstddef>
 #include <cstdint>
+#include <iomanip>
 #include <limits>
 #include <memory>
 #include <ostream>
@ -60,16 +61,16 @@
 #include <type_traits>
 #include <vector>

-#include "gtest/gtest-assertion-result.h"  // IWYU pragma: export
-#include "gtest/gtest-death-test.h"  // IWYU pragma: export
-#include "gtest/gtest-matchers.h"  // IWYU pragma: export
-#include "gtest/gtest-message.h"  // IWYU pragma: export
-#include "gtest/gtest-param-test.h"  // IWYU pragma: export
-#include "gtest/gtest-printers.h"  // IWYU pragma: export
-#include "gtest/gtest-test-part.h"  // IWYU pragma: export
-#include "gtest/gtest-typed-test.h"  // IWYU pragma: export
-#include "gtest/gtest_pred_impl.h"  // IWYU pragma: export
-#include "gtest/gtest_prod.h"  // IWYU pragma: export
+#include "gtest/gtest-assertion-result.h"
+#include "gtest/gtest-death-test.h"
+#include "gtest/gtest-matchers.h"
+#include "gtest/gtest-message.h"
+#include "gtest/gtest-param-test.h"
+#include "gtest/gtest-printers.h"
+#include "gtest/gtest-test-part.h"
+#include "gtest/gtest-typed-test.h"
+#include "gtest/gtest_pred_impl.h"
+#include "gtest/gtest_prod.h"
 #include "gtest/internal/gtest-internal.h"
 #include "gtest/internal/gtest-string.h"

@ -607,7 +608,7 @@ class GTEST_API_ TestInfo {
  friend class internal::UnitTestImpl;
  friend class internal::StreamingListenerTest;
  friend TestInfo* internal::MakeAndRegisterTestInfo(
-      std::string test_suite_name, const char* name, const char* type_param,
+      const char* 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,
@ -615,7 +616,7 @@ class GTEST_API_ TestInfo {

  // Constructs a TestInfo object. The newly constructed instance assumes
  // ownership of the factory object.
-  TestInfo(std::string test_suite_name, std::string name,
+  TestInfo(const std::string& test_suite_name, const 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,
@ -683,7 +684,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 std::string& name, const char* a_type_param,
+  TestSuite(const char* name, const char* a_type_param,
            internal::SetUpTestSuiteFunc set_up_tc,
            internal::TearDownTestSuiteFunc tear_down_tc);

@ -1123,7 +1124,7 @@ class GTEST_API_ UnitTest {
  // This method can only be called from the main thread.
  //
  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
-  [[nodiscard]] int Run();
+  int Run() GTEST_MUST_USE_RESULT_;

  // Returns the working directory when the first TEST() or TEST_F()
  // was executed.  The UnitTest object owns the string.
@ -1262,20 +1263,6 @@ 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_; }
@ -1284,8 +1271,6 @@ 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;
@ -1589,12 +1574,12 @@ AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression,
  }

  ::std::stringstream lhs_ss;
-  lhs_ss.precision(std::numeric_limits<RawType>::digits10 + 2);
-  lhs_ss << lhs_value;
+  lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+         << lhs_value;

  ::std::stringstream rhs_ss;
-  rhs_ss.precision(std::numeric_limits<RawType>::digits10 + 2);
-  rhs_ss << rhs_value;
+  rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+         << rhs_value;

  return EqFailure(lhs_expression, rhs_expression,
                   StringStreamToString(&lhs_ss), StringStreamToString(&rhs_ss),
@ -1610,8 +1595,6 @@ 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 {
@ -1623,8 +1606,7 @@ class GTEST_API_ AssertHelper {

  // Message assignment is a semantic trick to enable assertion
  // streaming; see the GTEST_MESSAGE_ macro below.
-  GoogleTest_NotSupported_OnFunctionReturningNonVoid operator=(
-      const Message& message) const;
+  void operator=(const Message& message) const;

 private:
  // We put our data in a struct so that the size of the AssertHelper class can
@ -1696,7 +1678,7 @@ class WithParamInterface {

  // The current parameter value. Is also available in the test fixture's
  // constructor.
-  [[nodiscard]] static const ParamType& GetParam() {
+  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?";
@ -1770,7 +1752,6 @@ class TestWithParam : public Test, public WithParamInterface<T> {};
 // generic name and clashes with some other libraries.
 #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.
@ -2327,12 +2308,11 @@ 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(). RUN_ALL_TESTS will tear down and delete any
-// installed environments and should only be called once per binary.
+// parsed by InitGoogleTest().
 //
 // This function was formerly a macro; thus, it is in the global
 // namespace and has an all-caps name.
-[[nodiscard]] int RUN_ALL_TESTS();
+int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;

 inline int RUN_ALL_TESTS() { return ::testing::UnitTest::GetInstance()->Run(); }

--- a/googletest/include/gtest/internal/gtest-death-test-internal.h
+++ b/googletest/include/gtest/internal/gtest-death-test-internal.h
@ -46,38 +46,17 @@

 #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 {

-// Name of the flag (needed for parsing Google Test flag).
+// Names of the flags (needed for parsing Google Test flags).
+const char kDeathTestStyleFlag[] = "death_test_style";
+const char kDeathTestUseFork[] = "death_test_use_fork";
 const char kInternalRunDeathTestFlag[] = "internal_run_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(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 \
@ -94,7 +73,7 @@ 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 {
 public:
@ -191,6 +170,28 @@ 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
--- a/googletest/include/gtest/internal/gtest-filepath.h
+++ b/googletest/include/gtest/internal/gtest-filepath.h
@ -43,7 +43,6 @@
 #define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_

 #include <string>
-#include <utility>

 #include "gtest/internal/gtest-port.h"
 #include "gtest/internal/gtest-string.h"
@ -71,9 +70,8 @@ class GTEST_API_ FilePath {
 public:
  FilePath() : pathname_("") {}
  FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) {}
-  FilePath(FilePath&& rhs) noexcept : pathname_(std::move(rhs.pathname_)) {}

-  explicit FilePath(std::string pathname) : pathname_(std::move(pathname)) {
+  explicit FilePath(const std::string& pathname) : pathname_(pathname) {
    Normalize();
  }

@ -81,10 +79,6 @@ 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/googletest/include/gtest/internal/gtest-internal.h
+++ b/googletest/include/gtest/internal/gtest-internal.h
@ -58,6 +58,7 @@

 #include <cstdint>
 #include <functional>
+#include <iomanip>
 #include <limits>
 #include <map>
 #include <set>
@ -78,7 +79,7 @@
 //
 // will result in the token foo__LINE__, instead of foo followed by
 // the current line number.  For more details, see
-// https://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
+// http://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

@ -169,7 +170,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 https://en.wikipedia.org/wiki/Wagner-Fischer_algorithm
+// See http://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);
@ -236,7 +237,7 @@ GTEST_API_ std::string GetBoolAssertionFailureMessage(
 //   For double, there are 11 exponent bits and 52 fraction bits.
 //
 //   More details can be found at
-//   https://en.wikipedia.org/wiki/IEEE_floating-point_standard.
+//   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
 //
 // Template parameter:
 //
@ -281,7 +282,7 @@ class FloatingPoint {
  // bits.  Therefore, 4 should be enough for ordinary use.
  //
  // See the following article for more details on ULP:
-  // https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+  // http://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.
@ -290,17 +291,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(RawType x) { memcpy(&bits_, &x, sizeof(x)); }
+  explicit FloatingPoint(const RawType& x) { u_.value_ = x; }

  // Static methods

  // Reinterprets a bit pattern as a floating-point number.
  //
  // This function is needed to test the AlmostEquals() method.
-  static RawType ReinterpretBits(Bits bits) {
-    RawType fp;
-    memcpy(&fp, &bits, sizeof(fp));
-    return fp;
+  static RawType ReinterpretBits(const Bits bits) {
+    FloatingPoint fp(0);
+    fp.u_.bits_ = bits;
+    return fp.u_.value_;
  }

  // Returns the floating-point number that represent positive infinity.
@ -309,16 +310,16 @@ class FloatingPoint {
  // Non-static methods

  // Returns the bits that represents this number.
-  const Bits& bits() const { return bits_; }
+  const Bits& bits() const { return u_.bits_; }

  // Returns the exponent bits of this number.
-  Bits exponent_bits() const { return kExponentBitMask & bits_; }
+  Bits exponent_bits() const { return kExponentBitMask & u_.bits_; }

  // Returns the fraction bits of this number.
-  Bits fraction_bits() const { return kFractionBitMask & bits_; }
+  Bits fraction_bits() const { return kFractionBitMask & u_.bits_; }

  // Returns the sign bit of this number.
-  Bits sign_bit() const { return kSignBitMask & bits_; }
+  Bits sign_bit() const { return kSignBitMask & u_.bits_; }

  // Returns true if and only if this is NAN (not a number).
  bool is_nan() const {
@ -332,16 +333,23 @@ 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 ULP's apart.
+  //   - thinks +0.0 and -0.0 are 0 DLP'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(bits_, rhs.bits_) <= kMaxUlps;
+    return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_) <=
+           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
@ -355,9 +363,9 @@ class FloatingPoint {
  //   N - 1  (the biggest number representable using
  //          sign-and-magnitude) is represented by 2N - 1.
  //
-  // Read https://en.wikipedia.org/wiki/Signed_number_representations
+  // Read http://en.wikipedia.org/wiki/Signed_number_representations
  // for more details on signed number representations.
-  static Bits SignAndMagnitudeToBiased(Bits sam) {
+  static Bits SignAndMagnitudeToBiased(const Bits& sam) {
    if (kSignBitMask & sam) {
      // sam represents a negative number.
      return ~sam + 1;
@ -369,13 +377,14 @@ class FloatingPoint {

  // Given two numbers in the sign-and-magnitude representation,
  // returns the distance between them as an unsigned number.
-  static Bits DistanceBetweenSignAndMagnitudeNumbers(Bits sam1, Bits sam2) {
+  static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits& sam1,
+                                                     const Bits& sam2) {
    const Bits biased1 = SignAndMagnitudeToBiased(sam1);
    const Bits biased2 = SignAndMagnitudeToBiased(sam2);
    return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
  }

-  Bits bits_;  // The bits that represent the number.
+  FloatingPointUnion u_;
 };

 // Typedefs the instances of the FloatingPoint template class that we
@ -466,8 +475,8 @@ using SetUpTestSuiteFunc = void (*)();
 using TearDownTestSuiteFunc = void (*)();

 struct CodeLocation {
-  CodeLocation(std::string a_file, int a_line)
-      : file(std::move(a_file)), line(a_line) {}
+  CodeLocation(const std::string& a_file, int a_line)
+      : file(a_file), line(a_line) {}

  std::string file;
  int line;
@ -547,7 +556,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 value-parameterized test.
+//                     or NULL if this is not a type-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
@ -556,7 +565,7 @@ struct SuiteApiResolver : T {
 //                     The newly created TestInfo instance will assume
 //                     ownership of the factory object.
 GTEST_API_ TestInfo* MakeAndRegisterTestInfo(
-    std::string test_suite_name, const char* name, const char* type_param,
+    const char* 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);
@ -587,7 +596,8 @@ class GTEST_API_ TypedTestSuitePState {
      fflush(stderr);
      posix::Abort();
    }
-    registered_tests_.emplace(test_name, CodeLocation(file, line));
+    registered_tests_.insert(
+        ::std::make_pair(test_name, CodeLocation(file, line)));
    return true;
  }

@ -691,7 +701,7 @@ class TypeParameterizedTest {
  // 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, CodeLocation code_location,
+  static bool Register(const char* prefix, const CodeLocation& code_location,
                       const char* case_name, const char* test_names, int index,
                       const std::vector<std::string>& type_names =
                           GenerateNames<DefaultNameGenerator, Types>()) {
@ -703,7 +713,8 @@ 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.
@ -715,9 +726,13 @@ class TypeParameterizedTest {
        new TestFactoryImpl<TestClass>);

    // Next, recurses (at compile time) with the tail of the type list.
-    return TypeParameterizedTest<Fixture, TestSel, typename Types::Tail>::
-        Register(prefix, std::move(code_location), case_name, test_names,
-                 index + 1, type_names);
+    return TypeParameterizedTest<Fixture, TestSel,
+                                 typename Types::Tail>::Register(prefix,
+                                                                 code_location,
+                                                                 case_name,
+                                                                 test_names,
+                                                                 index + 1,
+                                                                 type_names);
  }
 };

@ -725,7 +740,7 @@ class TypeParameterizedTest {
 template <GTEST_TEMPLATE_ Fixture, class TestSel>
 class TypeParameterizedTest<Fixture, TestSel, internal::None> {
 public:
-  static bool Register(const char* /*prefix*/, CodeLocation,
+  static bool Register(const char* /*prefix*/, const CodeLocation&,
                       const char* /*case_name*/, const char* /*test_names*/,
                       int /*index*/,
                       const std::vector<std::string>& =
@ -772,8 +787,7 @@ class TypeParameterizedTestSuite {

    // Next, recurses (at compile time) with the tail of the test list.
    return TypeParameterizedTestSuite<Fixture, typename Tests::Tail,
-                                      Types>::Register(prefix,
-                                                       std::move(code_location),
+                                      Types>::Register(prefix, code_location,
                                                       state, case_name,
                                                       SkipComma(test_names),
                                                       type_names);
@ -886,6 +900,11 @@ 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
@ -1124,6 +1143,40 @@ 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
@ -1132,7 +1185,7 @@ struct Ignore {
 template <typename>
 struct ElemFromListImpl;
 template <size_t... I>
-struct ElemFromListImpl<std::index_sequence<I...>> {
+struct ElemFromListImpl<IndexSequence<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.
@ -1143,8 +1196,9 @@ struct ElemFromListImpl<std::index_sequence<I...>> {

 template <size_t N, typename... T>
 struct ElemFromList {
-  using type = decltype(ElemFromListImpl<std::make_index_sequence<N>>::Apply(
-      static_cast<T (*)()>(nullptr)...));
+  using type =
+      decltype(ElemFromListImpl<typename MakeIndexSequence<N>::type>::Apply(
+          static_cast<T (*)()>(nullptr)...));
 };

 struct FlatTupleConstructTag {};
@ -1169,9 +1223,9 @@ template <typename Derived, typename Idx>
 struct FlatTupleBase;

 template <size_t... Idx, typename... T>
-struct FlatTupleBase<FlatTuple<T...>, std::index_sequence<Idx...>>
+struct FlatTupleBase<FlatTuple<T...>, IndexSequence<Idx...>>
    : FlatTupleElemBase<FlatTuple<T...>, Idx>... {
-  using Indices = std::index_sequence<Idx...>;
+  using Indices = IndexSequence<Idx...>;
  FlatTupleBase() = default;
  template <typename... Args>
  explicit FlatTupleBase(FlatTupleConstructTag, Args&&... args)
@ -1206,15 +1260,14 @@ struct FlatTupleBase<FlatTuple<T...>, std::index_sequence<Idx...>>
 // implementations.
 // FlatTuple and ElemFromList are not recursive and have a fixed depth
 // regardless of T...
-// std::make_index_sequence, on the other hand, it is recursive but with an
+// MakeIndexSequence, on the other hand, it is recursive but with an
 // instantiation depth of O(ln(N)).
 template <typename... T>
 class FlatTuple
    : private FlatTupleBase<FlatTuple<T...>,
-                            std::make_index_sequence<sizeof...(T)>> {
-  using Indices =
-      typename FlatTupleBase<FlatTuple<T...>,
-                             std::make_index_sequence<sizeof...(T)>>::Indices;
+                            typename MakeIndexSequence<sizeof...(T)>::type> {
+  using Indices = typename FlatTupleBase<
+      FlatTuple<T...>, typename MakeIndexSequence<sizeof...(T)>::type>::Indices;

 public:
  FlatTuple() = default;
@ -1228,40 +1281,30 @@ class FlatTuple

 // Utility functions to be called with static_assert to induce deprecation
 // warnings.
-[[deprecated(
+GTEST_INTERNAL_DEPRECATED(
    "INSTANTIATE_TEST_CASE_P is deprecated, please use "
-    "INSTANTIATE_TEST_SUITE_P")]]
-constexpr bool InstantiateTestCase_P_IsDeprecated() {
-  return true;
-}
+    "INSTANTIATE_TEST_SUITE_P")
+constexpr bool InstantiateTestCase_P_IsDeprecated() { return true; }

-[[deprecated(
+GTEST_INTERNAL_DEPRECATED(
    "TYPED_TEST_CASE_P is deprecated, please use "
-    "TYPED_TEST_SUITE_P")]]
-constexpr bool TypedTestCase_P_IsDeprecated() {
-  return true;
-}
+    "TYPED_TEST_SUITE_P")
+constexpr bool TypedTestCase_P_IsDeprecated() { return true; }

-[[deprecated(
+GTEST_INTERNAL_DEPRECATED(
    "TYPED_TEST_CASE is deprecated, please use "
-    "TYPED_TEST_SUITE")]]
-constexpr bool TypedTestCaseIsDeprecated() {
-  return true;
-}
+    "TYPED_TEST_SUITE")
+constexpr bool TypedTestCaseIsDeprecated() { return true; }

-[[deprecated(
+GTEST_INTERNAL_DEPRECATED(
    "REGISTER_TYPED_TEST_CASE_P is deprecated, please use "
-    "REGISTER_TYPED_TEST_SUITE_P")]]
-constexpr bool RegisterTypedTestCase_P_IsDeprecated() {
-  return true;
-}
+    "REGISTER_TYPED_TEST_SUITE_P")
+constexpr bool RegisterTypedTestCase_P_IsDeprecated() { return true; }

-[[deprecated(
+GTEST_INTERNAL_DEPRECATED(
    "INSTANTIATE_TYPED_TEST_CASE_P is deprecated, please use "
-    "INSTANTIATE_TYPED_TEST_SUITE_P")]]
-constexpr bool InstantiateTypedTestCase_P_IsDeprecated() {
-  return true;
-}
+    "INSTANTIATE_TYPED_TEST_SUITE_P")
+constexpr bool InstantiateTypedTestCase_P_IsDeprecated() { return true; }

 }  // namespace internal
 }  // namespace testing
@ -1498,7 +1541,7 @@ class NeverThrown {
                                                                               \
   private:                                                                    \
    void TestBody() override;                                                  \
-    [[maybe_unused]] static ::testing::TestInfo* const test_info_;             \
+    static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;      \
  };                                                                           \
                                                                               \
  ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name,           \
--- a/googletest/include/gtest/internal/gtest-param-util.h
+++ b/googletest/include/gtest/internal/gtest-param-util.h
@ -39,7 +39,6 @@
 #include <ctype.h>

 #include <cassert>
-#include <functional>
 #include <iterator>
 #include <map>
 #include <memory>
@ -48,7 +47,6 @@
 #include <string>
 #include <tuple>
 #include <type_traits>
-#include <unordered_map>
 #include <utility>
 #include <vector>

@ -87,7 +85,7 @@ 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,
-                                           const CodeLocation& code_location);
+                                           CodeLocation code_location);

 template <typename>
 class ParamGeneratorInterface;
@ -381,7 +379,9 @@ class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
 // integer test parameter index.
 template <class ParamType>
 std::string DefaultParamName(const TestParamInfo<ParamType>& info) {
-  return std::to_string(info.index);
+  Message name_stream;
+  name_stream << info.index;
+  return name_stream.GetString();
 }

 template <typename T = int>
@ -513,10 +513,9 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
  typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
  using ParamNameGeneratorFunc = std::string(const TestParamInfo<ParamType>&);

-  explicit ParameterizedTestSuiteInfo(std::string name,
+  explicit ParameterizedTestSuiteInfo(const char* name,
                                      CodeLocation code_location)
-      : test_suite_name_(std::move(name)),
-        code_location_(std::move(code_location)) {}
+      : test_suite_name_(name), code_location_(code_location) {}

  // Test suite base name for display purposes.
  const std::string& GetTestSuiteName() const override {
@ -530,20 +529,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*, const char* test_base_name,
+  void AddTestPattern(const char* test_suite_name, const char* test_base_name,
                      TestMetaFactoryBase<ParamType>* meta_factory,
                      CodeLocation code_location) {
-    tests_.emplace_back(
-        new TestInfo(test_base_name, meta_factory, std::move(code_location)));
+    tests_.push_back(std::shared_ptr<TestInfo>(new TestInfo(
+        test_suite_name, test_base_name, meta_factory, code_location)));
  }
  // INSTANTIATE_TEST_SUITE_P macro uses AddGenerator() to record information
  // about a generator.
-  int AddTestSuiteInstantiation(std::string instantiation_name,
+  int AddTestSuiteInstantiation(const std::string& instantiation_name,
                                GeneratorCreationFunc* func,
                                ParamNameGeneratorFunc* name_func,
                                const char* file, int line) {
-    instantiations_.emplace_back(std::move(instantiation_name), func, name_func,
-                                 file, line);
+    instantiations_.push_back(
+        InstantiationInfo(instantiation_name, func, name_func, 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
@ -554,61 +553,60 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
  void RegisterTests() override {
    bool generated_instantiations = false;

-    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;
+    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;
        if (!instantiation_name.empty())
          test_suite_name = instantiation_name + "/";
-        else
-          test_suite_name.clear();
-        test_suite_name += test_suite_name_;
+        test_suite_name += test_info->test_suite_base_name;

        size_t i = 0;
        std::set<std::string> test_param_names;
-        for (const auto& param : generator) {
+        for (typename ParamGenerator<ParamType>::iterator param_it =
+                 generator.begin();
+             param_it != generator.end(); ++param_it, ++i) {
          generated_instantiations = true;

-          test_name.clear();
+          Message test_name_stream;

          std::string param_name =
-              name_func(TestParamInfo<ParamType>(param, i));
+              name_func(TestParamInfo<ParamType>(*param_it, i));

          GTEST_CHECK_(IsValidParamName(param_name))
              << "Parameterized test name '" << param_name
-              << "' is invalid (contains spaces, dashes, or any "
-                 "non-alphanumeric characters other than underscores), in "
-              << file << " line " << line << "" << std::endl;
+              << "' is invalid, 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.append(test_info->test_base_name).append("/");
+            test_name_stream << test_info->test_base_name << "/";
          }
-          test_name += param_name;
-
-          test_param_names.insert(std::move(param_name));
-
+          test_name_stream << param_name;
          MakeAndRegisterTestInfo(
-              test_suite_name, test_name.c_str(),
+              test_suite_name.c_str(), test_name_stream.GetString().c_str(),
              nullptr,  // No type parameter.
-              PrintToString(param).c_str(), test_info->code_location,
+              PrintToString(*param_it).c_str(), test_info->code_location,
              GetTestSuiteTypeId(),
              SuiteApiResolver<TestSuite>::GetSetUpCaseOrSuite(file, line),
              SuiteApiResolver<TestSuite>::GetTearDownCaseOrSuite(file, line),
-              test_info->test_meta_factory->CreateTestFactory(param));
-          ++i;
-        }  // for param
-      }  // for instantiation
-    }  // for test_info
+              test_info->test_meta_factory->CreateTestFactory(*param_it));
+        }  // for param_it
+      }    // for gen_it
+    }      // for test_it

    if (!generated_instantiations) {
      // There are no generaotrs, or they all generate nothing ...
@ -621,13 +619,15 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
  // LocalTestInfo structure keeps information about a single test registered
  // with TEST_P macro.
  struct TestInfo {
-    TestInfo(const char* a_test_base_name,
+    TestInfo(const char* a_test_suite_base_name, const char* a_test_base_name,
             TestMetaFactoryBase<ParamType>* a_test_meta_factory,
             CodeLocation a_code_location)
-        : test_base_name(a_test_base_name),
+        : test_suite_base_name(a_test_suite_base_name),
+          test_base_name(a_test_base_name),
          test_meta_factory(a_test_meta_factory),
-          code_location(std::move(a_code_location)) {}
+          code_location(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,10 +637,11 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
  //  <Instantiation name, Sequence generator creation function,
  //     Name generator function, Source file, Source line>
  struct InstantiationInfo {
-    InstantiationInfo(std::string name_in, GeneratorCreationFunc* generator_in,
+    InstantiationInfo(const std::string& name_in,
+                      GeneratorCreationFunc* generator_in,
                      ParamNameGeneratorFunc* name_func_in, const char* file_in,
                      int line_in)
-        : name(std::move(name_in)),
+        : name(name_in),
          generator(generator_in),
          name_func(name_func_in),
          file(file_in),
@ -701,32 +702,29 @@ class ParameterizedTestSuiteRegistry {
  // tests and instantiations of a particular test suite.
  template <class TestSuite>
  ParameterizedTestSuiteInfo<TestSuite>* GetTestSuitePatternHolder(
-      std::string test_suite_name, CodeLocation code_location) {
+      const char* test_suite_name, CodeLocation code_location) {
    ParameterizedTestSuiteInfo<TestSuite>* typed_test_info = nullptr;
-
-    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.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<ParameterizedTestSuiteInfo<TestSuite>>(
-                test_suite_info);
+    for (auto& test_suite_info : test_suite_infos_) {
+      if (test_suite_info->GetTestSuiteName() == test_suite_name) {
+        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);
+          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<
+              ParameterizedTestSuiteInfo<TestSuite>>(test_suite_info);
+        }
+        break;
      }
    }
    if (typed_test_info == nullptr) {
      typed_test_info = new ParameterizedTestSuiteInfo<TestSuite>(
-          test_suite_name, std::move(code_location));
-      suite_name_to_info_index_.emplace(std::move(test_suite_name),
-                                        test_suite_infos_.size());
+          test_suite_name, code_location);
      test_suite_infos_.push_back(typed_test_info);
    }
    return typed_test_info;
@ -740,9 +738,8 @@ class ParameterizedTestSuiteRegistry {
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
  template <class TestCase>
  ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
-      std::string test_case_name, CodeLocation code_location) {
-    return GetTestSuitePatternHolder<TestCase>(std::move(test_case_name),
-                                               std::move(code_location));
+      const char* test_case_name, CodeLocation code_location) {
+    return GetTestSuitePatternHolder<TestCase>(test_case_name, code_location);
  }

 #endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
@ -751,7 +748,6 @@ 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;
@ -778,7 +774,7 @@ class TypeParameterizedTestSuiteRegistry {
 private:
  struct TypeParameterizedTestSuiteInfo {
    explicit TypeParameterizedTestSuiteInfo(CodeLocation c)
-        : code_location(std::move(c)), instantiated(false) {}
+        : code_location(c), instantiated(false) {}

    CodeLocation code_location;
    bool instantiated;
@ -807,12 +803,12 @@ class ValueArray {

  template <typename T>
  operator ParamGenerator<T>() const {  // NOLINT
-    return ValuesIn(MakeVector<T>(std::make_index_sequence<sizeof...(Ts)>()));
+    return ValuesIn(MakeVector<T>(MakeIndexSequence<sizeof...(Ts)>()));
  }

 private:
  template <typename T, size_t... I>
-  std::vector<T> MakeVector(std::index_sequence<I...>) const {
+  std::vector<T> MakeVector(IndexSequence<I...>) const {
    return std::vector<T>{static_cast<T>(v_.template Get<I>())...};
  }

@ -842,7 +838,7 @@ class CartesianProductGenerator
  template <class I>
  class IteratorImpl;
  template <size_t... I>
-  class IteratorImpl<std::index_sequence<I...>>
+  class IteratorImpl<IndexSequence<I...>>
      : public ParamIteratorInterface<ParamType> {
   public:
    IteratorImpl(const ParamGeneratorInterface<ParamType>* base,
@ -933,7 +929,7 @@ class CartesianProductGenerator
    std::shared_ptr<ParamType> current_value_;
  };

-  using Iterator = IteratorImpl<std::make_index_sequence<sizeof...(T)>>;
+  using Iterator = IteratorImpl<typename MakeIndexSequence<sizeof...(T)>::type>;

  std::tuple<ParamGenerator<T>...> generators_;
 };
@ -952,11 +948,11 @@ class CartesianProductHolder {
  std::tuple<Gen...> generators_;
 };

-template <typename From, typename To, typename Func>
+template <typename From, typename To>
 class ParamGeneratorConverter : public ParamGeneratorInterface<To> {
 public:
-  ParamGeneratorConverter(ParamGenerator<From> gen, Func converter)  // NOLINT
-      : generator_(std::move(gen)), converter_(std::move(converter)) {}
+  ParamGeneratorConverter(ParamGenerator<From> gen)  // NOLINT
+      : generator_(std::move(gen)) {}

  ParamIteratorInterface<To>* Begin() const override {
    return new Iterator(this, generator_.begin(), generator_.end());
@ -965,21 +961,13 @@ 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 ParamGeneratorConverter* base, ParamIterator<From> it,
+    Iterator(const ParamGeneratorInterface<To>* base, ParamIterator<From> it,
             ParamIterator<From> end)
        : base_(base), it_(it), end_(end) {
-      if (it_ != end_)
-        value_ =
-            std::make_shared<To>(static_cast<To>(base->TypeConverter()(*it_)));
+      if (it_ != end_) value_ = std::make_shared<To>(static_cast<To>(*it_));
    }
    ~Iterator() override = default;

@ -988,9 +976,7 @@ class ParamGeneratorConverter : public ParamGeneratorInterface<To> {
    }
    void Advance() override {
      ++it_;
-      if (it_ != end_)
-        value_ =
-            std::make_shared<To>(static_cast<To>(base_->TypeConverter()(*it_)));
+      if (it_ != end_) value_ = std::make_shared<To>(static_cast<To>(*it_));
    }
    ParamIteratorInterface<To>* Clone() const override {
      return new Iterator(*this);
@ -1010,54 +996,30 @@ class ParamGeneratorConverter : public ParamGeneratorInterface<To> {
   private:
    Iterator(const Iterator& other) = default;

-    const ParamGeneratorConverter* const base_;
+    const ParamGeneratorInterface<To>* 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 GeneratedT,
-          typename StdFunction =
-              std::function<const GeneratedT&(const GeneratedT&)>>
+template <class Gen>
 class ParamConverterGenerator {
 public:
-  ParamConverterGenerator(ParamGenerator<GeneratedT> g)  // NOLINT
-      : generator_(std::move(g)), converter_(Identity) {}
-
-  ParamConverterGenerator(ParamGenerator<GeneratedT> g, StdFunction converter)
-      : generator_(std::move(g)), converter_(std::move(converter)) {}
+  ParamConverterGenerator(ParamGenerator<Gen> g)  // NOLINT
+      : generator_(std::move(g)) {}

  template <typename T>
  operator ParamGenerator<T>() const {  // NOLINT
-    return ParamGenerator<T>(
-        new ParamGeneratorConverter<GeneratedT, T, StdFunction>(generator_,
-                                                                converter_));
+    return ParamGenerator<T>(new ParamGeneratorConverter<Gen, T>(generator_));
  }

 private:
-  static const GeneratedT& Identity(const GeneratedT& v) { return v; }
-
-  ParamGenerator<GeneratedT> generator_;
-  StdFunction converter_;
+  ParamGenerator<Gen> generator_;
 };

-// 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/googletest/include/gtest/internal/gtest-port-arch.h
+++ b/googletest/include/gtest/internal/gtest-port-arch.h
@ -56,8 +56,6 @@
 #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.
--- a/googletest/include/gtest/internal/gtest-port.h
+++ b/googletest/include/gtest/internal/gtest-port.h
@ -194,12 +194,26 @@
 //
 // Macros for basic C++ coding:
 //   GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
+//   GTEST_ATTRIBUTE_UNUSED_  - declares that a class' instances or a
+//                              variable don't have to be used.
+//   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
 //   GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is
 //                                        suppressed (constant conditional).
 //   GTEST_INTENTIONAL_CONST_COND_POP_  - finish code section where MSVC C4127
 //                                        is suppressed.
-//   GTEST_INTERNAL_HAS_STD_SPAN - for enabling UniversalPrinter<std::span>
-//                                 specializations. Always defined to 0 or 1
+//   GTEST_INTERNAL_HAS_ANY - for enabling UniversalPrinter<std::any> or
+//                            UniversalPrinter<absl::any> specializations.
+//                            Always defined to 0 or 1.
+//   GTEST_INTERNAL_HAS_OPTIONAL - for enabling UniversalPrinter<std::optional>
+//   or
+//                                 UniversalPrinter<absl::optional>
+//                                 specializations. Always defined to 0 or 1.
+//   GTEST_INTERNAL_HAS_STRING_VIEW - for enabling Matcher<std::string_view> or
+//                                    Matcher<absl::string_view>
+//                                    specializations. Always defined to 0 or 1.
+//   GTEST_INTERNAL_HAS_VARIANT - for enabling UniversalPrinter<std::variant> or
+//                                UniversalPrinter<absl::variant>
+//                                specializations. Always defined to 0 or 1.
 //   GTEST_USE_OWN_FLAGFILE_FLAG_ - Always defined to 0 or 1.
 //   GTEST_HAS_CXXABI_H_ - Always defined to 0 or 1.
 //   GTEST_CAN_STREAM_RESULTS_ - Always defined to 0 or 1.
@ -246,6 +260,11 @@
 //   BoolFromGTestEnv()   - parses a bool environment variable.
 //   Int32FromGTestEnv()  - parses an int32_t environment variable.
 //   StringFromGTestEnv() - parses a string environment variable.
+//
+// Deprecation warnings:
+//   GTEST_INTERNAL_DEPRECATED(message) - attribute marking a function as
+//                                        deprecated; calling a marked function
+//                                        should generate a compiler warning

 // The definition of GTEST_INTERNAL_CPLUSPLUS_LANG comes first because it can
 // potentially be used as an #include guard.
@ -256,28 +275,8 @@
 #endif

 #if !defined(GTEST_INTERNAL_CPLUSPLUS_LANG) || \
-    GTEST_INTERNAL_CPLUSPLUS_LANG < 201703L
-#error C++ versions less than C++17 are not supported.
-#endif
-
-// MSVC >= 19.11 (VS 2017 Update 3) supports __has_include.
-#ifdef __has_include
-#define GTEST_INTERNAL_HAS_INCLUDE __has_include
-#else
-#define GTEST_INTERNAL_HAS_INCLUDE(...) 0
-#endif
-
-// Detect C++ feature test macros as gracefully as possible.
-// MSVC >= 19.15, Clang >= 3.4.1, and GCC >= 4.1.2 support feature test macros.
-//
-// GCC15 warns that <ciso646> is deprecated in C++17 and suggests using
-// <version> instead, even though <version> is not available in C++17 mode prior
-// to GCC9.
-#if GTEST_INTERNAL_CPLUSPLUS_LANG >= 202002L || \
-    GTEST_INTERNAL_HAS_INCLUDE(<version>)
-#include <version>  // C++20 or <version> support.
-#else
-#include <ciso646>  // Pre-C++20
+    GTEST_INTERNAL_CPLUSPLUS_LANG < 201402L
+#error C++ versions less than C++14 are not supported.
 #endif

 #include <ctype.h>   // for isspace, etc
@ -321,8 +320,7 @@
 #define GTEST_HAS_NOTIFICATION_ 0
 #endif

-#if defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
-#define GTEST_INTERNAL_HAS_ABSL_FLAGS  // Used only in this file.
+#ifdef GTEST_HAS_ABSL
 #include "absl/flags/declare.h"
 #include "absl/flags/flag.h"
 #include "absl/flags/reflection.h"
@ -592,8 +590,7 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
     defined(GTEST_OS_NETBSD) || defined(GTEST_OS_FUCHSIA) ||         \
     defined(GTEST_OS_DRAGONFLY) || defined(GTEST_OS_GNU_KFREEBSD) || \
     defined(GTEST_OS_OPENBSD) || defined(GTEST_OS_HAIKU) ||          \
-     defined(GTEST_OS_GNU_HURD) || defined(GTEST_OS_SOLARIS) ||       \
-     defined(GTEST_OS_AIX) || defined(GTEST_OS_ZOS))
+     defined(GTEST_OS_GNU_HURD))
 #define GTEST_HAS_PTHREAD 1
 #else
 #define GTEST_HAS_PTHREAD 0
@ -612,7 +609,7 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 // Determines whether clone(2) is supported.
 // Usually it will only be available on Linux, excluding
 // Linux on the Itanium architecture.
-// Also see https://linux.die.net/man/2/clone.
+// Also see http://linux.die.net/man/2/clone.
 #ifndef GTEST_HAS_CLONE
 // The user didn't tell us, so we need to figure it out.

@ -643,9 +640,9 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 // platforms except known mobile / embedded ones. Also, if the port doesn't have
 // a file system, stream redirection is not supported.
 #if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_WINDOWS_PHONE) || \
-    defined(GTEST_OS_WINDOWS_RT) || defined(GTEST_OS_WINDOWS_GAMES) ||     \
-    defined(GTEST_OS_ESP8266) || defined(GTEST_OS_XTENSA) ||               \
-    defined(GTEST_OS_QURT) || !GTEST_HAS_FILE_SYSTEM
+    defined(GTEST_OS_WINDOWS_RT) || defined(GTEST_OS_ESP8266) ||           \
+    defined(GTEST_OS_XTENSA) || defined(GTEST_OS_QURT) ||                  \
+    !GTEST_HAS_FILE_SYSTEM
 #define GTEST_HAS_STREAM_REDIRECTION 0
 #else
 #define GTEST_HAS_STREAM_REDIRECTION 1
@ -655,7 +652,7 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 // Determines whether to support death tests.
 // pops up a dialog window that cannot be suppressed programmatically.
 #if (defined(GTEST_OS_LINUX) || defined(GTEST_OS_CYGWIN) ||           \
-     defined(GTEST_OS_SOLARIS) || defined(GTEST_OS_ZOS) ||            \
+     defined(GTEST_OS_SOLARIS) ||                                     \
     (defined(GTEST_OS_MAC) && !defined(GTEST_OS_IOS)) ||             \
     (defined(GTEST_OS_WINDOWS_DESKTOP) && _MSC_VER) ||               \
     defined(GTEST_OS_WINDOWS_MINGW) || defined(GTEST_OS_AIX) ||      \
@ -733,20 +730,6 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 #define GTEST_HAVE_ATTRIBUTE_(x) 0
 #endif

-// GTEST_INTERNAL_HAVE_CPP_ATTRIBUTE
-//
-// A function-like feature checking macro that accepts C++11 style attributes.
-// It's a wrapper around `__has_cpp_attribute`, defined by ISO C++ SD-6
-// (https://en.cppreference.com/w/cpp/experimental/feature_test). If we don't
-// find `__has_cpp_attribute`, will evaluate to 0.
-#if defined(__has_cpp_attribute)
-// NOTE: requiring __cplusplus above should not be necessary, but
-// works around https://bugs.llvm.org/show_bug.cgi?id=23435.
-#define GTEST_INTERNAL_HAVE_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
-#else
-#define GTEST_INTERNAL_HAVE_CPP_ATTRIBUTE(x) 0
-#endif
-
 // GTEST_HAVE_FEATURE_
 //
 // A function-like feature checking macro that is a wrapper around
@ -757,6 +740,17 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 #define GTEST_HAVE_FEATURE_(x) 0
 #endif

+// Use this annotation after a variable or parameter declaration to tell the
+// compiler the variable/parameter does not have to be used.
+// Example:
+//
+//   GTEST_ATTRIBUTE_UNUSED_ int foo = bar();
+#if GTEST_HAVE_ATTRIBUTE_(unused)
+#define GTEST_ATTRIBUTE_UNUSED_ __attribute__((unused))
+#else
+#define GTEST_ATTRIBUTE_UNUSED_
+#endif
+
 // Use this annotation before a function that takes a printf format string.
 #if GTEST_HAVE_ATTRIBUTE_(format) && defined(__MINGW_PRINTF_FORMAT)
 // MinGW has two different printf implementations. Ensure the format macro
@ -771,6 +765,17 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 #define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check)
 #endif

+// Tell the compiler to warn about unused return values for functions declared
+// with this macro.  The macro should be used on function declarations
+// following the argument list:
+//
+//   Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_;
+#if GTEST_HAVE_ATTRIBUTE_(warn_unused_result)
+#define GTEST_MUST_USE_RESULT_ __attribute__((warn_unused_result))
+#else
+#define GTEST_MUST_USE_RESULT_
+#endif
+
 // MS C++ compiler emits warning when a conditional expression is compile time
 // constant. In some contexts this warning is false positive and needs to be
 // suppressed. Use the following two macros in such cases:
@ -822,9 +827,9 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
 #ifndef GTEST_API_

 #ifdef _MSC_VER
-#if defined(GTEST_LINKED_AS_SHARED_LIBRARY) && GTEST_LINKED_AS_SHARED_LIBRARY
+#if GTEST_LINKED_AS_SHARED_LIBRARY
 #define GTEST_API_ __declspec(dllimport)
-#elif defined(GTEST_CREATE_SHARED_LIBRARY) && GTEST_CREATE_SHARED_LIBRARY
+#elif GTEST_CREATE_SHARED_LIBRARY
 #define GTEST_API_ __declspec(dllexport)
 #endif
 #elif GTEST_HAVE_ATTRIBUTE_(visibility)
@ -1385,9 +1390,9 @@ class GTEST_API_ Mutex {
  Mutex();
  ~Mutex();

-  void lock();
+  void Lock();

-  void unlock();
+  void Unlock();

  // Does nothing if the current thread holds the mutex. Otherwise, crashes
  // with high probability.
@ -1424,11 +1429,12 @@ class GTEST_API_ Mutex {
 // "MutexLock l(&mu)".  Hence the typedef trick below.
 class GTestMutexLock {
 public:
-  explicit GTestMutexLock(Mutex& mutex) : mutex_(mutex) { mutex_.lock(); }
-  ~GTestMutexLock() { mutex_.unlock(); }
+  explicit GTestMutexLock(Mutex* mutex) : mutex_(mutex) { mutex_->Lock(); }
+
+  ~GTestMutexLock() { mutex_->Unlock(); }

 private:
-  Mutex& mutex_;
+  Mutex* const mutex_;

  GTestMutexLock(const GTestMutexLock&) = delete;
  GTestMutexLock& operator=(const GTestMutexLock&) = delete;
@ -1640,14 +1646,14 @@ class ThreadLocal : public ThreadLocalBase {
 class MutexBase {
 public:
  // Acquires this mutex.
-  void lock() {
+  void Lock() {
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
    owner_ = pthread_self();
    has_owner_ = true;
  }

  // Releases this mutex.
-  void unlock() {
+  void Unlock() {
    // Since the lock is being released the owner_ field should no longer be
    // considered valid. We don't protect writing to has_owner_ here, as it's
    // the caller's responsibility to ensure that the current thread holds the
@ -1715,11 +1721,12 @@ class Mutex : public MutexBase {
 // "MutexLock l(&mu)".  Hence the typedef trick below.
 class GTestMutexLock {
 public:
-  explicit GTestMutexLock(MutexBase& mutex) : mutex_(mutex) { mutex_.lock(); }
-  ~GTestMutexLock() { mutex_.unlock(); }
+  explicit GTestMutexLock(MutexBase* mutex) : mutex_(mutex) { mutex_->Lock(); }
+
+  ~GTestMutexLock() { mutex_->Unlock(); }

 private:
-  MutexBase& mutex_;
+  MutexBase* const mutex_;

  GTestMutexLock(const GTestMutexLock&) = delete;
  GTestMutexLock& operator=(const GTestMutexLock&) = delete;
@ -1862,8 +1869,8 @@ class GTEST_API_ ThreadLocal {
 class Mutex {
 public:
  Mutex() {}
-  void lock() {}
-  void unlock() {}
+  void Lock() {}
+  void Unlock() {}
  void AssertHeld() const {}
 };

@ -1879,7 +1886,7 @@ class Mutex {
 // "MutexLock l(&mu)".  Hence the typedef trick below.
 class GTestMutexLock {
 public:
-  explicit GTestMutexLock(Mutex&) {}  // NOLINT
+  explicit GTestMutexLock(Mutex*) {}  // NOLINT
 };

 typedef GTestMutexLock MutexLock;
@ -1980,9 +1987,7 @@ inline std::string StripTrailingSpaces(std::string str) {
 namespace posix {

 // File system porting.
-// Note: Not every I/O-related function is related to file systems, so don't
-// just disable all of them here. For example, fileno() and isatty(), etc. must
-// always be available in order to detect if a pipe points to a terminal.
+#if GTEST_HAS_FILE_SYSTEM
 #ifdef GTEST_OS_WINDOWS

 typedef struct _stat StatStruct;
@ -1993,32 +1998,27 @@ inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
 // time and thus not defined there.
 #else
 inline int FileNo(FILE* file) { return _fileno(file); }
-#if GTEST_HAS_FILE_SYSTEM
 inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); }
 inline int RmDir(const char* dir) { return _rmdir(dir); }
 inline bool IsDir(const StatStruct& st) { return (_S_IFDIR & st.st_mode) != 0; }
-#endif
 #endif  // GTEST_OS_WINDOWS_MOBILE

 #elif defined(GTEST_OS_ESP8266)
 typedef struct stat StatStruct;

 inline int FileNo(FILE* file) { return fileno(file); }
-#if GTEST_HAS_FILE_SYSTEM
 inline int Stat(const char* path, StatStruct* buf) {
  // stat function not implemented on ESP8266
  return 0;
 }
 inline int RmDir(const char* dir) { return rmdir(dir); }
 inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
-#endif

 #else

 typedef struct stat StatStruct;

 inline int FileNo(FILE* file) { return fileno(file); }
-#if GTEST_HAS_FILE_SYSTEM
 inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
 #ifdef GTEST_OS_QURT
 // QuRT doesn't support any directory functions, including rmdir
@ -2027,9 +2027,9 @@ inline int RmDir(const char*) { return 0; }
 inline int RmDir(const char* dir) { return rmdir(dir); }
 #endif
 inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
-#endif

 #endif  // GTEST_OS_WINDOWS
+#endif  // GTEST_HAS_FILE_SYSTEM

 // Other functions with a different name on Windows.

@ -2082,9 +2082,8 @@ GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
 // defined there.
 #if GTEST_HAS_FILE_SYSTEM
 #if !defined(GTEST_OS_WINDOWS_MOBILE) && !defined(GTEST_OS_WINDOWS_PHONE) && \
-    !defined(GTEST_OS_WINDOWS_RT) && !defined(GTEST_OS_WINDOWS_GAMES) &&     \
-    !defined(GTEST_OS_ESP8266) && !defined(GTEST_OS_XTENSA) &&               \
-    !defined(GTEST_OS_QURT)
+    !defined(GTEST_OS_WINDOWS_RT) && !defined(GTEST_OS_ESP8266) &&           \
+    !defined(GTEST_OS_XTENSA) && !defined(GTEST_OS_QURT)
 inline int ChDir(const char* dir) { return chdir(dir); }
 #endif
 inline FILE* FOpen(const char* path, const char* mode) {
@ -2228,7 +2227,7 @@ using TimeInMillis = int64_t;  // Represents time in milliseconds.
 #endif  // !defined(GTEST_FLAG)

 // Pick a command line flags implementation.
-#ifdef GTEST_INTERNAL_HAS_ABSL_FLAGS
+#ifdef GTEST_HAS_ABSL

 // Macros for defining flags.
 #define GTEST_DEFINE_bool_(name, default_val, doc) \
@ -2253,8 +2252,7 @@ using TimeInMillis = int64_t;  // Represents time in milliseconds.
  (void)(::absl::SetFlag(&GTEST_FLAG(name), value))
 #define GTEST_USE_OWN_FLAGFILE_FLAG_ 0

-#undef GTEST_INTERNAL_HAS_ABSL_FLAGS
-#else  // ndef GTEST_INTERNAL_HAS_ABSL_FLAGS
+#else  // GTEST_HAS_ABSL

 // Macros for defining flags.
 #define GTEST_DEFINE_bool_(name, default_val, doc)  \
@ -2296,7 +2294,7 @@ using TimeInMillis = int64_t;  // Represents time in milliseconds.
 #define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
 #define GTEST_USE_OWN_FLAGFILE_FLAG_ 1

-#endif  // GTEST_INTERNAL_HAS_ABSL_FLAGS
+#endif  // GTEST_HAS_ABSL

 // Thread annotations
 #if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
@ -2320,20 +2318,93 @@ const char* StringFromGTestEnv(const char* flag, const char* default_val);
 }  // namespace internal
 }  // namespace testing

-#if GTEST_INTERNAL_HAVE_CPP_ATTRIBUTE(clang::annotate)
-#define GTEST_INTERNAL_DEPRECATE_AND_INLINE(msg) \
-  [[deprecated(msg), clang::annotate("inline-me")]]
+#if !defined(GTEST_INTERNAL_DEPRECATED)
+
+// Internal Macro to mark an API deprecated, for googletest usage only
+// Usage: class GTEST_INTERNAL_DEPRECATED(message) MyClass or
+// GTEST_INTERNAL_DEPRECATED(message) <return_type> myFunction(); Every usage of
+// a deprecated entity will trigger a warning when compiled with
+// `-Wdeprecated-declarations` option (clang, gcc, any __GNUC__ compiler).
+// For msvc /W3 option will need to be used
+// Note that for 'other' compilers this macro evaluates to nothing to prevent
+// compilations errors.
+#if defined(_MSC_VER)
+#define GTEST_INTERNAL_DEPRECATED(message) __declspec(deprecated(message))
+#elif defined(__GNUC__)
+#define GTEST_INTERNAL_DEPRECATED(message) __attribute__((deprecated(message)))
 #else
-#define GTEST_INTERNAL_DEPRECATE_AND_INLINE(msg) [[deprecated(msg)]]
+#define GTEST_INTERNAL_DEPRECATED(message)
 #endif

-#if defined(__cpp_lib_span) || (GTEST_INTERNAL_HAS_INCLUDE(<span>) && \
-                                GTEST_INTERNAL_CPLUSPLUS_LANG >= 202002L)
-#define GTEST_INTERNAL_HAS_STD_SPAN 1
-#endif  // __cpp_lib_span
+#endif  // !defined(GTEST_INTERNAL_DEPRECATED)

-#ifndef GTEST_INTERNAL_HAS_STD_SPAN
-#define GTEST_INTERNAL_HAS_STD_SPAN 0
+#ifdef GTEST_HAS_ABSL
+// Always use absl::any for UniversalPrinter<> specializations if googletest
+// is built with absl support.
+#define GTEST_INTERNAL_HAS_ANY 1
+#include "absl/types/any.h"
+namespace testing {
+namespace internal {
+using Any = ::absl::any;
+}  // namespace internal
+}  // namespace testing
+#else
+#ifdef __has_include
+#if __has_include(<any>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L && \
+    (!defined(_MSC_VER) || GTEST_HAS_RTTI)
+// Otherwise for C++17 and higher use std::any for UniversalPrinter<>
+// specializations.
+#define GTEST_INTERNAL_HAS_ANY 1
+#include <any>
+namespace testing {
+namespace internal {
+using Any = ::std::any;
+}  // namespace internal
+}  // namespace testing
+// The case where absl is configured NOT to alias std::any is not
+// supported.
+#endif  // __has_include(<any>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
+#endif  // __has_include
+#endif  // GTEST_HAS_ABSL
+
+#ifndef GTEST_INTERNAL_HAS_ANY
+#define GTEST_INTERNAL_HAS_ANY 0
+#endif
+
+#ifdef GTEST_HAS_ABSL
+// Always use absl::optional for UniversalPrinter<> specializations if
+// googletest is built with absl support.
+#define GTEST_INTERNAL_HAS_OPTIONAL 1
+#include "absl/types/optional.h"
+namespace testing {
+namespace internal {
+template <typename T>
+using Optional = ::absl::optional<T>;
+inline ::absl::nullopt_t Nullopt() { return ::absl::nullopt; }
+}  // namespace internal
+}  // namespace testing
+#else
+#ifdef __has_include
+#if __has_include(<optional>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
+// Otherwise for C++17 and higher use std::optional for UniversalPrinter<>
+// specializations.
+#define GTEST_INTERNAL_HAS_OPTIONAL 1
+#include <optional>
+namespace testing {
+namespace internal {
+template <typename T>
+using Optional = ::std::optional<T>;
+inline ::std::nullopt_t Nullopt() { return ::std::nullopt; }
+}  // namespace internal
+}  // namespace testing
+// The case where absl is configured NOT to alias std::optional is not
+// supported.
+#endif  // __has_include(<optional>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
+#endif  // __has_include
+#endif  // GTEST_HAS_ABSL
+
+#ifndef GTEST_INTERNAL_HAS_OPTIONAL
+#define GTEST_INTERNAL_HAS_OPTIONAL 0
 #endif

 #ifdef GTEST_HAS_ABSL
@ -2347,9 +2418,8 @@ using StringView = ::absl::string_view;
 }  // namespace internal
 }  // namespace testing
 #else
-#if defined(__cpp_lib_string_view) ||             \
-    (GTEST_INTERNAL_HAS_INCLUDE(<string_view>) && \
-     GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L)
+#ifdef __has_include
+#if __has_include(<string_view>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
 // Otherwise for C++17 and higher use std::string_view for Matcher<>
 // specializations.
 #define GTEST_INTERNAL_HAS_STRING_VIEW 1
@ -2361,19 +2431,51 @@ using StringView = ::std::string_view;
 }  // namespace testing
 // The case where absl is configured NOT to alias std::string_view is not
 // supported.
-#endif  // __cpp_lib_string_view
+#endif  // __has_include(<string_view>) && GTEST_INTERNAL_CPLUSPLUS_LANG >=
+        // 201703L
+#endif  // __has_include
 #endif  // GTEST_HAS_ABSL

 #ifndef GTEST_INTERNAL_HAS_STRING_VIEW
 #define GTEST_INTERNAL_HAS_STRING_VIEW 0
 #endif

-#if (defined(__cpp_lib_three_way_comparison) || \
-     (GTEST_INTERNAL_HAS_INCLUDE(<compare>) &&  \
-      GTEST_INTERNAL_CPLUSPLUS_LANG >= 201907L))
-#define GTEST_INTERNAL_HAS_COMPARE_LIB 1
+#ifdef GTEST_HAS_ABSL
+// Always use absl::variant for UniversalPrinter<> specializations if googletest
+// is built with absl support.
+#define GTEST_INTERNAL_HAS_VARIANT 1
+#include "absl/types/variant.h"
+namespace testing {
+namespace internal {
+template <typename... T>
+using Variant = ::absl::variant<T...>;
+}  // namespace internal
+}  // namespace testing
 #else
-#define GTEST_INTERNAL_HAS_COMPARE_LIB 0
+#ifdef __has_include
+#if __has_include(<variant>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
+// Otherwise for C++17 and higher use std::variant for UniversalPrinter<>
+// specializations.
+#define GTEST_INTERNAL_HAS_VARIANT 1
+#include <variant>
+namespace testing {
+namespace internal {
+template <typename... T>
+using Variant = ::std::variant<T...>;
+}  // namespace internal
+}  // namespace testing
+// The case where absl is configured NOT to alias std::variant is not supported.
+#endif  // __has_include(<variant>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
+#endif  // __has_include
+#endif  // GTEST_HAS_ABSL
+
+#ifndef GTEST_INTERNAL_HAS_VARIANT
+#define GTEST_INTERNAL_HAS_VARIANT 0
+#endif
+
+#if defined(GTEST_INTERNAL_CPLUSPLUS_LANG) && \
+    GTEST_INTERNAL_CPLUSPLUS_LANG < 201703L
+#define GTEST_INTERNAL_NEED_REDUNDANT_CONSTEXPR_DECL 1
 #endif

 #endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
--- a/googletest/include/gtest/internal/gtest-type-util.h
+++ b/googletest/include/gtest/internal/gtest-type-util.h
@ -71,7 +71,7 @@ inline std::string CanonicalizeForStdLibVersioning(std::string s) {
  // 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 = ',';
+  static const char replace_str[] = ",";
  size_t pos = 0;
  while (true) {
    // Get the next occurrence from the current position
@ -80,8 +80,8 @@ inline std::string CanonicalizeForStdLibVersioning(std::string s) {
      break;
    }
    // Replace this occurrence of substring
-    s.replace(pos, strlen(to_search), 1, replace_char);
-    ++pos;
+    s.replace(pos, strlen(to_search), replace_str);
+    pos += strlen(replace_str);
  }
  return s;
 }
--- a/googletest/src/gtest-death-test.cc
+++ b/googletest/src/gtest-death-test.cc
@ -32,8 +32,6 @@

 #include "gtest/gtest-death-test.h"

-#include <stdlib.h>
-
 #include <functional>
 #include <memory>
 #include <sstream>
@ -117,7 +115,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 "
@ -301,7 +299,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);
@ -513,7 +511,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
@ -525,13 +523,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.
@ -630,13 +628,13 @@ bool DeathTestImpl::Passed(bool status_ok) {
 #ifndef GTEST_OS_WINDOWS
 // Note: The return value points into args, so the return value's lifetime is
 // bound to that of args.
-static std::vector<char*> CreateArgvFromArgs(std::vector<std::string>& args) {
-  std::vector<char*> result;
-  result.reserve(args.size() + 1);
-  for (auto& arg : args) {
-    result.push_back(&arg[0]);
+static std::unique_ptr<char*[]> CreateArgvFromArgs(
+    std::vector<std::string>& args) {
+  auto result = std::make_unique<char*[]>(args.size() + 1);
+  for (size_t i = 0; i < args.size(); ++i) {
+    result[i] = &args[i][0];
  }
-  result.push_back(nullptr);  // Extra null terminator.
+  result[args.size()] = nullptr;  // extra null terminator
  return result;
 }
 #endif
@ -785,7 +783,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 https://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
+      // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
      "|" + StreamableToString(reinterpret_cast<size_t>(write_handle)) + "|" +
      StreamableToString(reinterpret_cast<size_t>(event_handle_.Get()));

@ -1036,8 +1034,8 @@ DeathTest::TestRole FuchsiaDeathTest::AssumeRole() {
  // "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(),
+  std::unique_ptr<char*[]> argv = CreateArgvFromArgs(args);
+  status = fdio_spawn_etc(child_job, FDIO_SPAWN_CLONE_ALL, argv[0], argv.get(),
                          nullptr, 2, spawn_actions,
                          child_process_.reset_and_get_address(), nullptr);
  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
@ -1335,7 +1333,7 @@ static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
 #endif  // GTEST_HAS_CLONE

  if (use_fork && (child_pid = fork()) == 0) {
-    _Exit(ExecDeathTestChildMain(&args));
+    _exit(ExecDeathTestChildMain(&args));
  }
 #endif  // GTEST_OS_QNX
 #ifdef GTEST_OS_LINUX
@ -1388,8 +1386,8 @@ DeathTest::TestRole ExecDeathTest::AssumeRole() {
  // is necessary.
  FlushInfoLog();

-  std::vector<char*> argv = CreateArgvFromArgs(args);
-  const pid_t child_pid = ExecDeathTestSpawnChild(argv.data(), pipe_fd[0]);
+  std::unique_ptr<char*[]> argv = CreateArgvFromArgs(args);
+  const pid_t child_pid = ExecDeathTestSpawnChild(argv.get(), pipe_fd[0]);
  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
  set_child_pid(child_pid);
  set_read_fd(pipe_fd[0]);
--- a/googletest/src/gtest-filepath.cc
+++ b/googletest/src/gtest-filepath.cc
@ -336,7 +336,7 @@ bool FilePath::CreateDirectoriesRecursively() const {
    return false;
  }

-  if (pathname_.empty() || this->DirectoryExists()) {
+  if (pathname_.length() == 0 || this->DirectoryExists()) {
    return true;
  }

--- a/googletest/src/gtest-internal-inl.h
+++ b/googletest/src/gtest-internal-inl.h
@ -46,7 +46,6 @@
 #include <memory>
 #include <set>
 #include <string>
-#include <unordered_map>
 #include <vector>

 #include "gtest/internal/gtest-port.h"
@ -313,7 +312,7 @@ void ShuffleRange(internal::Random* random, int begin, int end,
      << begin << ", " << size << "].";

  // Fisher-Yates shuffle, from
-  // https://en.wikipedia.org/wiki/Fisher-Yates_shuffle
+  // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
  for (int range_width = end - begin; range_width >= 2; range_width--) {
    const int last_in_range = begin + range_width - 1;
    const int selected =
@ -650,15 +649,13 @@ class GTEST_API_ UnitTestImpl {
  //                    this is not a typed or 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* GetTestSuite(const std::string& test_suite_name,
-                          const char* type_param,
+  TestSuite* GetTestSuite(const char* test_suite_name, const char* type_param,
                          internal::SetUpTestSuiteFunc set_up_tc,
                          internal::TearDownTestSuiteFunc tear_down_tc);

 //  Legacy API is deprecated but still available
 #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
-  TestCase* GetTestCase(const std::string& test_case_name,
-                        const char* type_param,
+  TestCase* GetTestCase(const char* test_case_name, const char* type_param,
                        internal::SetUpTestSuiteFunc set_up_tc,
                        internal::TearDownTestSuiteFunc tear_down_tc) {
    return GetTestSuite(test_case_name, type_param, set_up_tc, tear_down_tc);
@ -684,13 +681,13 @@ class GTEST_API_ UnitTestImpl {
    // AddTestInfo(), which is called to register a TEST or TEST_F
    // before main() is reached.
    if (original_working_dir_.IsEmpty()) {
-      original_working_dir_ = FilePath::GetCurrentDir();
+      original_working_dir_.Set(FilePath::GetCurrentDir());
      GTEST_CHECK_(!original_working_dir_.IsEmpty())
          << "Failed to get the current working directory.";
    }
 #endif  // GTEST_HAS_FILE_SYSTEM

-    GetTestSuite(test_info->test_suite_name_, test_info->type_param(),
+    GetTestSuite(test_info->test_suite_name(), test_info->type_param(),
                 set_up_tc, tear_down_tc)
        ->AddTestInfo(test_info);
  }
@ -712,6 +709,18 @@ class GTEST_API_ UnitTestImpl {
    return type_parameterized_test_registry_;
  }

+  // Sets the TestSuite object for the test that's currently running.
+  void set_current_test_suite(TestSuite* a_current_test_suite) {
+    current_test_suite_ = a_current_test_suite;
+  }
+
+  // Sets the TestInfo object for the test that's currently running.  If
+  // current_test_info is NULL, the assertion results will be stored in
+  // ad_hoc_test_result_.
+  void set_current_test_info(TestInfo* a_current_test_info) {
+    current_test_info_ = a_current_test_info;
+  }
+
  // Registers all parameterized tests defined using TEST_P and
  // INSTANTIATE_TEST_SUITE_P, creating regular tests for each test/parameter
  // combination. This method can be called more then once; it has guards
@ -826,34 +835,12 @@ class GTEST_API_ UnitTestImpl {
  bool catch_exceptions() const { return catch_exceptions_; }

 private:
-  // Returns true if a warning should be issued if no tests match the test
-  // filter flag.
-  bool ShouldWarnIfNoTestsMatchFilter() const;
-
-  struct CompareTestSuitesByPointer {
-    bool operator()(const TestSuite* lhs, const TestSuite* rhs) const {
-      return lhs->name_ < rhs->name_;
-    }
-  };
-
  friend class ::testing::UnitTest;

  // Used by UnitTest::Run() to capture the state of
  // GTEST_FLAG(catch_exceptions) at the moment it starts.
  void set_catch_exceptions(bool value) { catch_exceptions_ = value; }

-  // Sets the TestSuite object for the test that's currently running.
-  void set_current_test_suite(TestSuite* a_current_test_suite) {
-    current_test_suite_ = a_current_test_suite;
-  }
-
-  // Sets the TestInfo object for the test that's currently running.  If
-  // current_test_info is NULL, the assertion results will be stored in
-  // ad_hoc_test_result_.
-  void set_current_test_info(TestInfo* a_current_test_info) {
-    current_test_info_ = a_current_test_info;
-  }
-
  // The UnitTest object that owns this implementation object.
  UnitTest* const parent_;

@ -886,9 +873,6 @@ class GTEST_API_ UnitTestImpl {
  // elements in the vector.
  std::vector<TestSuite*> test_suites_;

-  // The set of TestSuites by name.
-  std::unordered_map<std::string, TestSuite*> test_suites_by_name_;
-
  // Provides a level of indirection for the test suite list to allow
  // easy shuffling and restoring the test suite order.  The i-th
  // element of this vector is the index of the i-th test suite in the
--- a/googletest/src/gtest-port.cc
+++ b/googletest/src/gtest-port.cc
@ -158,13 +158,13 @@ size_t GetThreadCount() {
 // we cannot detect it.
 size_t GetThreadCount() {
  int mib[] = {
-      CTL_KERN,
-      KERN_PROC,
-      KERN_PROC_PID,
-      getpid(),
+    CTL_KERN,
+    KERN_PROC,
+    KERN_PROC_PID,
+    getpid(),
 #ifdef GTEST_OS_NETBSD
-      sizeof(struct kinfo_proc),
-      1,
+    sizeof(struct kinfo_proc),
+    1,
 #endif
  };
  u_int miblen = sizeof(mib) / sizeof(mib[0]);
@ -320,13 +320,13 @@ Mutex::~Mutex() {
  }
 }

-void Mutex::lock() {
+void Mutex::Lock() {
  ThreadSafeLazyInit();
  ::EnterCriticalSection(critical_section_);
  owner_thread_id_ = ::GetCurrentThreadId();
 }

-void Mutex::unlock() {
+void Mutex::Unlock() {
  ThreadSafeLazyInit();
  // We don't protect writing to owner_thread_id_ here, as it's the
  // caller's responsibility to ensure that the current thread holds the
@ -499,7 +499,7 @@ class ThreadLocalRegistryImpl {
    MemoryIsNotDeallocated memory_is_not_deallocated;
 #endif  // _MSC_VER
    DWORD current_thread = ::GetCurrentThreadId();
-    MutexLock lock(mutex_);
+    MutexLock lock(&mutex_);
    ThreadIdToThreadLocals* const thread_to_thread_locals =
        GetThreadLocalsMapLocked();
    ThreadIdToThreadLocals::iterator thread_local_pos =
@ -532,7 +532,7 @@ class ThreadLocalRegistryImpl {
    // Clean up the ThreadLocalValues data structure while holding the lock, but
    // defer the destruction of the ThreadLocalValueHolderBases.
    {
-      MutexLock lock(mutex_);
+      MutexLock lock(&mutex_);
      ThreadIdToThreadLocals* const thread_to_thread_locals =
          GetThreadLocalsMapLocked();
      for (ThreadIdToThreadLocals::iterator it =
@ -559,7 +559,7 @@ class ThreadLocalRegistryImpl {
    // Clean up the ThreadIdToThreadLocals data structure while holding the
    // lock, but defer the destruction of the ThreadLocalValueHolderBases.
    {
-      MutexLock lock(mutex_);
+      MutexLock lock(&mutex_);
      ThreadIdToThreadLocals* const thread_to_thread_locals =
          GetThreadLocalsMapLocked();
      ThreadIdToThreadLocals::iterator thread_local_pos =
@ -587,11 +587,9 @@ class ThreadLocalRegistryImpl {
  // thread's ID.
  typedef std::map<DWORD, ThreadLocalValues> ThreadIdToThreadLocals;

-  struct WatcherThreadParams {
-    DWORD thread_id;
-    HANDLE handle;
-    Notification has_initialized;
-  };
+  // Holds the thread id and thread handle that we pass from
+  // StartWatcherThreadFor to WatcherThreadFunc.
+  typedef std::pair<DWORD, HANDLE> ThreadIdAndHandle;

  static void StartWatcherThreadFor(DWORD thread_id) {
    // The returned handle will be kept in thread_map and closed by
@ -599,20 +597,15 @@ class ThreadLocalRegistryImpl {
    HANDLE thread =
        ::OpenThread(SYNCHRONIZE | THREAD_QUERY_INFORMATION, FALSE, thread_id);
    GTEST_CHECK_(thread != nullptr);
-
-    WatcherThreadParams* watcher_thread_params = new WatcherThreadParams;
-    watcher_thread_params->thread_id = thread_id;
-    watcher_thread_params->handle = thread;
-
    // We need to pass a valid thread ID pointer into CreateThread for it
    // to work correctly under Win98.
    DWORD watcher_thread_id;
-    HANDLE watcher_thread =
-        ::CreateThread(nullptr,  // Default security.
-                       0,        // Default stack size
-                       &ThreadLocalRegistryImpl::WatcherThreadFunc,
-                       reinterpret_cast<LPVOID>(watcher_thread_params),
-                       CREATE_SUSPENDED, &watcher_thread_id);
+    HANDLE watcher_thread = ::CreateThread(
+        nullptr,  // Default security.
+        0,        // Default stack size
+        &ThreadLocalRegistryImpl::WatcherThreadFunc,
+        reinterpret_cast<LPVOID>(new ThreadIdAndHandle(thread_id, thread)),
+        CREATE_SUSPENDED, &watcher_thread_id);
    GTEST_CHECK_(watcher_thread != nullptr)
        << "CreateThread failed with error " << ::GetLastError() << ".";
    // Give the watcher thread the same priority as ours to avoid being
@ -621,25 +614,17 @@ class ThreadLocalRegistryImpl {
                        ::GetThreadPriority(::GetCurrentThread()));
    ::ResumeThread(watcher_thread);
    ::CloseHandle(watcher_thread);
-
-    // Wait for the watcher thread to start to avoid race conditions.
-    // One specific race condition that can happen is that we have returned
-    // from main and have started to tear down, the newly spawned watcher
-    // thread may access already-freed variables, like global shared_ptrs.
-    watcher_thread_params->has_initialized.WaitForNotification();
  }

  // Monitors exit from a given thread and notifies those
  // ThreadIdToThreadLocals about thread termination.
  static DWORD WINAPI WatcherThreadFunc(LPVOID param) {
-    WatcherThreadParams* watcher_thread_params =
-        reinterpret_cast<WatcherThreadParams*>(param);
-    watcher_thread_params->has_initialized.Notify();
-    GTEST_CHECK_(::WaitForSingleObject(watcher_thread_params->handle,
-                                       INFINITE) == WAIT_OBJECT_0);
-    OnThreadExit(watcher_thread_params->thread_id);
-    ::CloseHandle(watcher_thread_params->handle);
-    delete watcher_thread_params;
+    const ThreadIdAndHandle* tah =
+        reinterpret_cast<const ThreadIdAndHandle*>(param);
+    GTEST_CHECK_(::WaitForSingleObject(tah->second, INFINITE) == WAIT_OBJECT_0);
+    OnThreadExit(tah->first);
+    ::CloseHandle(tah->second);
+    delete tah;
    return 0;
  }

@ -712,24 +697,13 @@ bool RE::PartialMatch(const char* str, const RE& re) {
 void RE::Init(const char* regex) {
  pattern_ = regex;

-  // NetBSD (and Android, which takes its regex implemntation from NetBSD) does
-  // not include the GNU regex extensions (such as Perl style character classes
-  // like \w) in REG_EXTENDED. REG_EXTENDED is only specified to include the
-  // [[:alpha:]] style character classes. Enable REG_GNU wherever it is defined
-  // so users can use those extensions.
-#if defined(REG_GNU)
-  constexpr int reg_flags = REG_EXTENDED | REG_GNU;
-#else
-  constexpr int reg_flags = REG_EXTENDED;
-#endif
-
  // Reserves enough bytes to hold the regular expression used for a
  // full match.
  const size_t full_regex_len = strlen(regex) + 10;
  char* const full_pattern = new char[full_regex_len];

  snprintf(full_pattern, full_regex_len, "^(%s)$", regex);
-  is_valid_ = regcomp(&full_regex_, full_pattern, reg_flags) == 0;
+  is_valid_ = regcomp(&full_regex_, full_pattern, REG_EXTENDED) == 0;
  // We want to call regcomp(&partial_regex_, ...) even if the
  // previous expression returns false.  Otherwise partial_regex_ may
  // not be properly initialized can may cause trouble when it's
@ -740,7 +714,7 @@ void RE::Init(const char* regex) {
  // regex.  We change it to an equivalent form "()" to be safe.
  if (is_valid_) {
    const char* const partial_regex = (*regex == '\0') ? "()" : regex;
-    is_valid_ = regcomp(&partial_regex_, partial_regex, reg_flags) == 0;
+    is_valid_ = regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0;
  }
  EXPECT_TRUE(is_valid_)
      << "Regular expression \"" << regex
@ -1048,21 +1022,11 @@ GTestLog::~GTestLog() {
  }
 }

-#if GTEST_HAS_STREAM_REDIRECTION
-
 // Disable Microsoft deprecation warnings for POSIX functions called from
 // this class (creat, dup, dup2, and close)
 GTEST_DISABLE_MSC_DEPRECATED_PUSH_()

-namespace {
-
-#if defined(GTEST_OS_LINUX_ANDROID) || defined(GTEST_OS_IOS)
-bool EndsWithPathSeparator(const std::string& path) {
-  return !path.empty() && path.back() == GTEST_PATH_SEP_[0];
-}
-#endif
-
-}  // namespace
+#if GTEST_HAS_STREAM_REDIRECTION

 // Object that captures an output stream (stdout/stderr).
 class CapturedStream {
@ -1100,13 +1064,7 @@ class CapturedStream {
    // The location /data/local/tmp is directly accessible from native code.
    // '/sdcard' and other variants cannot be relied on, as they are not
    // guaranteed to be mounted, or may have a delay in mounting.
-    //
-    // However, prefer using the TMPDIR environment variable if set, as newer
-    // devices may have /data/local/tmp read-only.
-    name_template = TempDir();
-    if (!EndsWithPathSeparator(name_template))
-      name_template.push_back(GTEST_PATH_SEP_[0]);
-
+    name_template = "/data/local/tmp/";
 #elif defined(GTEST_OS_IOS)
    char user_temp_dir[PATH_MAX + 1];

@ -1126,7 +1084,7 @@ class CapturedStream {
    ::confstr(_CS_DARWIN_USER_TEMP_DIR, user_temp_dir, sizeof(user_temp_dir));

    name_template = user_temp_dir;
-    if (!EndsWithPathSeparator(name_template))
+    if (name_template.back() != GTEST_PATH_SEP_[0])
      name_template.push_back(GTEST_PATH_SEP_[0]);
 #else
    name_template = "/tmp/";
@ -1348,8 +1306,8 @@ bool ParseInt32(const Message& src_text, const char* str, int32_t* value) {
  ) {
    Message msg;
    msg << "WARNING: " << src_text
-        << " is expected to be a 32-bit integer, but actually" << " has value "
-        << str << ", which overflows.\n";
+        << " is expected to be a 32-bit integer, but actually"
+        << " has value " << str << ", which overflows.\n";
    printf("%s", msg.GetString().c_str());
    fflush(stdout);
    return false;
--- a/googletest/src/gtest-printers.cc
+++ b/googletest/src/gtest-printers.cc
@ -50,7 +50,7 @@
 #include <iomanip>
 #include <ios>
 #include <ostream>  // NOLINT
-#include <string_view>
+#include <string>
 #include <type_traits>

 #include "gtest/internal/gtest-port.h"
@ -333,14 +333,14 @@ void PrintTo(__int128_t v, ::std::ostream* os) {

 // Prints the given array of characters to the ostream.  CharType must be either
 // char, char8_t, char16_t, char32_t, or wchar_t.
-// The array starts at begin (which may be nullptr) and contains len characters.
-// The array may include '\0' characters and may not be NUL-terminated.
+// The array starts at begin, the length is len, it may include '\0' characters
+// and may not be NUL-terminated.
 template <typename CharType>
 GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
    GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
        GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ static CharFormat
        PrintCharsAsStringTo(const CharType* begin, size_t len, ostream* os) {
-  const char* const quote_prefix = GetCharWidthPrefix(CharType());
+  const char* const quote_prefix = GetCharWidthPrefix(*begin);
  *os << quote_prefix << "\"";
  bool is_previous_hex = false;
  CharFormat print_format = kAsIs;
@ -516,13 +516,13 @@ bool IsValidUTF8(const char* str, size_t length) {
 void ConditionalPrintAsText(const char* str, size_t length, ostream* os) {
  if (!ContainsUnprintableControlCodes(str, length) &&
      IsValidUTF8(str, length)) {
-    *os << "\n    As Text: \"" << ::std::string_view(str, length) << "\"";
+    *os << "\n    As Text: \"" << str << "\"";
  }
 }

 }  // anonymous namespace

-void PrintStringTo(::std::string_view s, ostream* os) {
+void PrintStringTo(const ::std::string& s, ostream* os) {
  if (PrintCharsAsStringTo(s.data(), s.size(), os) == kHexEscape) {
    if (GTEST_FLAG_GET(print_utf8)) {
      ConditionalPrintAsText(s.data(), s.size(), os);
@ -531,21 +531,21 @@ void PrintStringTo(::std::string_view s, ostream* os) {
 }

 #ifdef __cpp_lib_char8_t
-void PrintU8StringTo(::std::u8string_view s, ostream* os) {
+void PrintU8StringTo(const ::std::u8string& s, ostream* os) {
  PrintCharsAsStringTo(s.data(), s.size(), os);
 }
 #endif

-void PrintU16StringTo(::std::u16string_view s, ostream* os) {
+void PrintU16StringTo(const ::std::u16string& s, ostream* os) {
  PrintCharsAsStringTo(s.data(), s.size(), os);
 }

-void PrintU32StringTo(::std::u32string_view s, ostream* os) {
+void PrintU32StringTo(const ::std::u32string& s, ostream* os) {
  PrintCharsAsStringTo(s.data(), s.size(), os);
 }

 #if GTEST_HAS_STD_WSTRING
-void PrintWideStringTo(::std::wstring_view s, ostream* os) {
+void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
  PrintCharsAsStringTo(s.data(), s.size(), os);
 }
 #endif  // GTEST_HAS_STD_WSTRING
--- a/googletest/src/gtest.cc
+++ b/googletest/src/gtest.cc
--- a/googletest/test/BUILD.bazel
+++ b/googletest/test/BUILD.bazel
@ -30,7 +30,6 @@
 #
 # Bazel BUILD for The Google C++ Testing Framework (Google Test)

-load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_test")
 load("@rules_python//python:defs.bzl", "py_library", "py_test")

 licenses(["notice"])
@ -46,38 +45,36 @@ cc_test(
            "gtest-*.cc",
            "googletest-*.cc",
            "*.h",
+            "googletest/include/gtest/**/*.h",
        ],
        exclude = [
-            # go/keep-sorted start
-            "googletest-break-on-failure-unittest_.cc",
-            "googletest-catch-exceptions-test_.cc",
-            "googletest-color-test_.cc",
-            "googletest-death-test_ex_test.cc",
-            "googletest-env-var-test_.cc",
-            "googletest-fail-if-no-test-linked-test-with-disabled-test_.cc",
-            "googletest-fail-if-no-test-linked-test-with-enabled-test_.cc",
-            "googletest-failfast-unittest_.cc",
-            "googletest-filter-unittest_.cc",
-            "googletest-global-environment-unittest_.cc",
-            "googletest-list-tests-unittest_.cc",
-            "googletest-listener-test.cc",
-            "googletest-message-test.cc",
-            "googletest-output-test_.cc",
-            "googletest-param-test-invalid-name1-test_.cc",
-            "googletest-param-test-invalid-name2-test_.cc",
-            "googletest-param-test-test",
-            "googletest-param-test-test.cc",
-            "googletest-param-test2-test.cc",
-            "googletest-setuptestsuite-test_.cc",
-            "googletest-shuffle-test_.cc",
-            "googletest-throw-on-failure-test_.cc",
-            "googletest-uninitialized-test_.cc",
+            "gtest-unittest-api_test.cc",
            "googletest/src/gtest-all.cc",
+            "gtest_all_test.cc",
            "gtest-death-test_ex_test.cc",
            "gtest-listener_test.cc",
            "gtest-unittest-api_test.cc",
-            "gtest_all_test.cc",
-            # go/keep-sorted end
+            "googletest-param-test-test.cc",
+            "googletest-param-test2-test.cc",
+            "googletest-catch-exceptions-test_.cc",
+            "googletest-color-test_.cc",
+            "googletest-env-var-test_.cc",
+            "googletest-failfast-unittest_.cc",
+            "googletest-filter-unittest_.cc",
+            "googletest-global-environment-unittest_.cc",
+            "googletest-break-on-failure-unittest_.cc",
+            "googletest-listener-test.cc",
+            "googletest-message-test.cc",
+            "googletest-output-test_.cc",
+            "googletest-list-tests-unittest_.cc",
+            "googletest-shuffle-test_.cc",
+            "googletest-setuptestsuite-test_.cc",
+            "googletest-uninitialized-test_.cc",
+            "googletest-death-test_ex_test.cc",
+            "googletest-param-test-test",
+            "googletest-throw-on-failure-test_.cc",
+            "googletest-param-test-invalid-name1-test_.cc",
+            "googletest-param-test-invalid-name2-test_.cc",
        ],
    ) + select({
        "//:windows": [],
@ -327,26 +324,6 @@ cc_binary(
    deps = ["//:gtest"],
 )

-cc_binary(
-    name = "googletest-fail-if-no-test-linked-test-without-test_",
-    testonly = 1,
-    deps = ["//:gtest_main"],
-)
-
-cc_binary(
-    name = "googletest-fail-if-no-test-linked-test-with-disabled-test_",
-    testonly = 1,
-    srcs = ["googletest-fail-if-no-test-linked-test-with-disabled-test_.cc"],
-    deps = ["//:gtest_main"],
-)
-
-cc_binary(
-    name = "googletest-fail-if-no-test-linked-test-with-enabled-test_",
-    testonly = 1,
-    srcs = ["googletest-fail-if-no-test-linked-test-with-enabled-test_.cc"],
-    deps = ["//:gtest_main"],
-)
-
 cc_test(
    name = "gtest_skip_test",
    size = "small",
@ -387,18 +364,6 @@ py_test(
    deps = [":gtest_test_utils"],
 )

-py_test(
-    name = "googletest-fail-if-no-test-linked-test",
-    size = "small",
-    srcs = ["googletest-fail-if-no-test-linked-test.py"],
-    data = [
-        ":googletest-fail-if-no-test-linked-test-with-disabled-test_",
-        ":googletest-fail-if-no-test-linked-test-with-enabled-test_",
-        ":googletest-fail-if-no-test-linked-test-without-test_",
-    ],
-    deps = [":gtest_test_utils"],
-)
-
 cc_binary(
    name = "googletest-shuffle-test_",
    srcs = ["googletest-shuffle-test_.cc"],
--- a/googletest/test/googletest-color-test.py
+++ b/googletest/test/googletest-color-test.py
@ -79,9 +79,7 @@ class GTestColorTest(gtest_test_utils.TestCase):
    self.assertTrue(UsesColor('cygwin', None, None))
    self.assertTrue(UsesColor('xterm', None, None))
    self.assertTrue(UsesColor('xterm-color', None, None))
-    self.assertTrue(UsesColor('xterm-ghostty', None, None))
    self.assertTrue(UsesColor('xterm-kitty', None, None))
-    self.assertTrue(UsesColor('alacritty', None, None))
    self.assertTrue(UsesColor('xterm-256color', None, None))

  def testFlagOnly(self):
--- a/googletest/test/googletest-death-test-test.cc
+++ b/googletest/test/googletest-death-test-test.cc
@ -30,8 +30,6 @@
 //
 // Tests for death tests.

-#include <stdlib.h>
-
 #include "gtest/gtest-death-test.h"
 #include "gtest/gtest.h"
 #include "gtest/internal/gtest-filepath.h"
@ -113,15 +111,15 @@ void DieWithMessage(const ::std::string& message) {
  fprintf(stderr, "%s", message.c_str());
  fflush(stderr);  // Make sure the text is printed before the process exits.

-  // We call _Exit() instead of exit(), as the former is a direct
+  // We call _exit() instead of exit(), as the former is a direct
  // system call and thus safer in the presence of threads.  exit()
  // will invoke user-defined exit-hooks, which may do dangerous
  // things that conflict with death tests.
  //
-  // Some compilers can recognize that _Exit() never returns and issue the
+  // Some compilers can recognize that _exit() never returns and issue the
  // 'unreachable code' warning for code following this function, unless
  // fooled by a fake condition.
-  if (AlwaysTrue()) _Exit(1);
+  if (AlwaysTrue()) _exit(1);
 }

 void DieInside(const ::std::string& function) {
@ -240,13 +238,13 @@ TEST(ExitStatusPredicateTest, ExitedWithCode) {

 #else

-// Returns the exit status of a process that calls _Exit(2) with a
+// Returns the exit status of a process that calls _exit(2) with a
 // given exit code.  This is a helper function for the
 // ExitStatusPredicateTest test suite.
 static int NormalExitStatus(int exit_code) {
  pid_t child_pid = fork();
  if (child_pid == 0) {
-    _Exit(exit_code);
+    _exit(exit_code);
  }
  int status;
  waitpid(child_pid, &status, 0);
@ -262,7 +260,7 @@ static int KilledExitStatus(int signum) {
  pid_t child_pid = fork();
  if (child_pid == 0) {
    raise(signum);
-    _Exit(1);
+    _exit(1);
  }
  int status;
  waitpid(child_pid, &status, 0);
@ -291,9 +289,7 @@ TEST(ExitStatusPredicateTest, KilledBySignal) {
  const int status_kill = KilledExitStatus(SIGKILL);
  const testing::KilledBySignal pred_segv(SIGSEGV);
  const testing::KilledBySignal pred_kill(SIGKILL);
-#if !(defined(GTEST_OS_LINUX_ANDROID) && __ANDROID_API__ <= 23)
  EXPECT_PRED1(pred_segv, status_segv);
-#endif
  EXPECT_PRED1(pred_kill, status_kill);
  EXPECT_FALSE(pred_segv(status_kill));
  EXPECT_FALSE(pred_kill(status_segv));
@ -317,7 +313,7 @@ TEST_F(TestForDeathTest, SingleStatement) {
    ASSERT_DEATH(return, "");

  if (AlwaysTrue())
-    EXPECT_DEATH(_Exit(1), "");
+    EXPECT_DEATH(_exit(1), "");
  else
    // This empty "else" branch is meant to ensure that EXPECT_DEATH
    // doesn't expand into an "if" statement without an "else"
@ -328,7 +324,7 @@ TEST_F(TestForDeathTest, SingleStatement) {
  if (AlwaysFalse())
    ;
  else
-    EXPECT_DEATH(_Exit(1), "") << 1 << 2 << 3;
+    EXPECT_DEATH(_exit(1), "") << 1 << 2 << 3;
 }
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
@ -343,11 +339,11 @@ TEST_F(TestForDeathTest, SwitchStatement) {

  switch (0)
  default:
-    ASSERT_DEATH(_Exit(1), "") << "exit in default switch handler";
+    ASSERT_DEATH(_exit(1), "") << "exit in default switch handler";

  switch (0)
  case 0:
-    EXPECT_DEATH(_Exit(1), "") << "exit in switch case";
+    EXPECT_DEATH(_exit(1), "") << "exit in switch case";

  GTEST_DISABLE_MSC_WARNINGS_POP_()
 }
@ -375,10 +371,10 @@ TEST_F(TestForDeathTest, FastDeathTestInChangedDir) {
  GTEST_FLAG_SET(death_test_style, "fast");

  ChangeToRootDir();
-  EXPECT_EXIT(_Exit(1), testing::ExitedWithCode(1), "");
+  EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");

  ChangeToRootDir();
-  ASSERT_DEATH(_Exit(1), "");
+  ASSERT_DEATH(_exit(1), "");
 }

 #ifdef GTEST_OS_LINUX
@ -420,7 +416,7 @@ void DisableSigprofActionAndTimer(struct sigaction* old_signal_action) {
 TEST_F(TestForDeathTest, FastSigprofActionSet) {
  GTEST_FLAG_SET(death_test_style, "fast");
  SetSigprofActionAndTimer();
-  EXPECT_DEATH(_Exit(1), "");
+  EXPECT_DEATH(_exit(1), "");
  struct sigaction old_signal_action;
  DisableSigprofActionAndTimer(&old_signal_action);
  EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction);
@ -429,7 +425,7 @@ TEST_F(TestForDeathTest, FastSigprofActionSet) {
 TEST_F(TestForDeathTest, ThreadSafeSigprofActionSet) {
  GTEST_FLAG_SET(death_test_style, "threadsafe");
  SetSigprofActionAndTimer();
-  EXPECT_DEATH(_Exit(1), "");
+  EXPECT_DEATH(_exit(1), "");
  struct sigaction old_signal_action;
  DisableSigprofActionAndTimer(&old_signal_action);
  EXPECT_TRUE(old_signal_action.sa_sigaction == SigprofAction);
@ -453,24 +449,24 @@ TEST_F(TestForDeathTest, ThreadsafeDeathTestInLoop) {
  GTEST_FLAG_SET(death_test_style, "threadsafe");

  for (int i = 0; i < 3; ++i)
-    EXPECT_EXIT(_Exit(i), testing::ExitedWithCode(i), "") << ": i = " << i;
+    EXPECT_EXIT(_exit(i), testing::ExitedWithCode(i), "") << ": i = " << i;
 }

 TEST_F(TestForDeathTest, ThreadsafeDeathTestInChangedDir) {
  GTEST_FLAG_SET(death_test_style, "threadsafe");

  ChangeToRootDir();
-  EXPECT_EXIT(_Exit(1), testing::ExitedWithCode(1), "");
+  EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");

  ChangeToRootDir();
-  ASSERT_DEATH(_Exit(1), "");
+  ASSERT_DEATH(_exit(1), "");
 }

 TEST_F(TestForDeathTest, MixedStyles) {
  GTEST_FLAG_SET(death_test_style, "threadsafe");
-  EXPECT_DEATH(_Exit(1), "");
+  EXPECT_DEATH(_exit(1), "");
  GTEST_FLAG_SET(death_test_style, "fast");
-  EXPECT_DEATH(_Exit(1), "");
+  EXPECT_DEATH(_exit(1), "");
 }

 #if GTEST_HAS_CLONE && GTEST_HAS_PTHREAD
@ -484,7 +480,7 @@ TEST_F(TestForDeathTest, DoesNotExecuteAtforkHooks) {
    GTEST_FLAG_SET(death_test_style, "threadsafe");
    pthread_flag = false;
    ASSERT_EQ(0, pthread_atfork(&SetPthreadFlag, nullptr, nullptr));
-    ASSERT_DEATH(_Exit(1), "");
+    ASSERT_DEATH(_exit(1), "");
    ASSERT_FALSE(pthread_flag);
  }
 }
@ -809,8 +805,8 @@ TEST_F(TestForDeathTest, AssertDebugDeathAborts10) {

 // Tests the *_EXIT family of macros, using a variety of predicates.
 static void TestExitMacros() {
-  EXPECT_EXIT(_Exit(1), testing::ExitedWithCode(1), "");
-  ASSERT_EXIT(_Exit(42), testing::ExitedWithCode(42), "");
+  EXPECT_EXIT(_exit(1), testing::ExitedWithCode(1), "");
+  ASSERT_EXIT(_exit(42), testing::ExitedWithCode(42), "");

 #ifdef GTEST_OS_WINDOWS

@ -827,7 +823,7 @@ static void TestExitMacros() {

  EXPECT_FATAL_FAILURE(
      {  // NOLINT
-        ASSERT_EXIT(_Exit(0), testing::KilledBySignal(SIGSEGV), "")
+        ASSERT_EXIT(_exit(0), testing::KilledBySignal(SIGSEGV), "")
            << "This failure is expected, too.";
      },
      "This failure is expected, too.");
@ -853,7 +849,7 @@ TEST_F(TestForDeathTest, InvalidStyle) {
  GTEST_FLAG_SET(death_test_style, "rococo");
  EXPECT_NONFATAL_FAILURE(
      {  // NOLINT
-        EXPECT_DEATH(_Exit(0), "") << "This failure is expected.";
+        EXPECT_DEATH(_exit(0), "") << "This failure is expected.";
      },
      "This failure is expected.");
 }
@ -1144,7 +1140,7 @@ TEST_F(MacroLogicDeathTest, ChildDoesNotDie) {
  // This time there are two calls to Abort: one since the test didn't
  // die, and another from the ReturnSentinel when it's destroyed.  The
  // sentinel normally isn't destroyed if a test doesn't die, since
-  // _Exit(2) is called in that case by ForkingDeathTest, but not by
+  // _exit(2) is called in that case by ForkingDeathTest, but not by
  // our MockDeathTest.
  ASSERT_EQ(2U, factory_->AbortCalls());
  EXPECT_EQ(DeathTest::TEST_DID_NOT_DIE, factory_->AbortArgument(0));
@ -1156,21 +1152,21 @@ TEST_F(MacroLogicDeathTest, ChildDoesNotDie) {
 // Tests that a successful death test does not register a successful
 // test part.
 TEST(SuccessRegistrationDeathTest, NoSuccessPart) {
-  EXPECT_DEATH(_Exit(1), "");
+  EXPECT_DEATH(_exit(1), "");
  EXPECT_EQ(0, GetUnitTestImpl()->current_test_result()->total_part_count());
 }

 TEST(StreamingAssertionsDeathTest, DeathTest) {
-  EXPECT_DEATH(_Exit(1), "") << "unexpected failure";
-  ASSERT_DEATH(_Exit(1), "") << "unexpected failure";
+  EXPECT_DEATH(_exit(1), "") << "unexpected failure";
+  ASSERT_DEATH(_exit(1), "") << "unexpected failure";
  EXPECT_NONFATAL_FAILURE(
      {  // NOLINT
-        EXPECT_DEATH(_Exit(0), "") << "expected failure";
+        EXPECT_DEATH(_exit(0), "") << "expected failure";
      },
      "expected failure");
  EXPECT_FATAL_FAILURE(
      {  // NOLINT
-        ASSERT_DEATH(_Exit(0), "") << "expected failure";
+        ASSERT_DEATH(_exit(0), "") << "expected failure";
      },
      "expected failure");
 }
@ -1334,7 +1330,7 @@ TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInFastStyle) {
      {
        fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside");
        fflush(stderr);
-        _Exit(1);
+        _exit(1);
      },
      "Inside");
 }
@ -1346,7 +1342,7 @@ TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInThreadSafeStyle) {
      {
        fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside");
        fflush(stderr);
-        _Exit(1);
+        _exit(1);
      },
      "Inside");
 }
@ -1354,7 +1350,7 @@ TEST(InDeathTestChildDeathTest, ReportsDeathTestCorrectlyInThreadSafeStyle) {
 void DieWithMessage(const char* message) {
  fputs(message, stderr);
  fflush(stderr);  // Make sure the text is printed before the process exits.
-  _Exit(1);
+  _exit(1);
 }

 TEST(MatcherDeathTest, DoesNotBreakBareRegexMatching) {
@ -1470,7 +1466,7 @@ TEST(ConditionalDeathMacrosSyntaxDeathTest, SingleStatement) {
    ASSERT_DEATH_IF_SUPPORTED(return, "");

  if (AlwaysTrue())
-    EXPECT_DEATH_IF_SUPPORTED(_Exit(1), "");
+    EXPECT_DEATH_IF_SUPPORTED(_exit(1), "");
  else
    // This empty "else" branch is meant to ensure that EXPECT_DEATH
    // doesn't expand into an "if" statement without an "else"
@ -1481,7 +1477,7 @@ TEST(ConditionalDeathMacrosSyntaxDeathTest, SingleStatement) {
  if (AlwaysFalse())
    ;  // NOLINT
  else
-    EXPECT_DEATH_IF_SUPPORTED(_Exit(1), "") << 1 << 2 << 3;
+    EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << 1 << 2 << 3;
 }
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
@ -1496,11 +1492,11 @@ TEST(ConditionalDeathMacrosSyntaxDeathTest, SwitchStatement) {

  switch (0)
  default:
-    ASSERT_DEATH_IF_SUPPORTED(_Exit(1), "") << "exit in default switch handler";
+    ASSERT_DEATH_IF_SUPPORTED(_exit(1), "") << "exit in default switch handler";

  switch (0)
  case 0:
-    EXPECT_DEATH_IF_SUPPORTED(_Exit(1), "") << "exit in switch case";
+    EXPECT_DEATH_IF_SUPPORTED(_exit(1), "") << "exit in switch case";

  GTEST_DISABLE_MSC_WARNINGS_POP_()
 }
--- a/googletest/test/googletest-fail-if-no-test-linked-test-with-disabled-test_.cc
+++ b/googletest/test/googletest-fail-if-no-test-linked-test-with-disabled-test_.cc
@ -1,38 +0,0 @@
-// Copyright 2025, 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.
-
-// Unit test for Google Test's --gtest_fail_if_no_test_linked flag.
-//
-// This program will be invoked from a Python test.
-// Don't run it directly.
-
-#include "gtest/gtest.h"
-
-// A dummy test that is disabled.
-TEST(SomeTest, DISABLED_Test1) {}
--- a/googletest/test/googletest-fail-if-no-test-linked-test-with-enabled-test_.cc
+++ b/googletest/test/googletest-fail-if-no-test-linked-test-with-enabled-test_.cc
@ -1,38 +0,0 @@
-// Copyright 2025, 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.
-
-// Unit test for Google Test's --gtest_fail_if_no_test_linked flag.
-//
-// This program will be invoked from a Python test.
-// Don't run it directly.
-
-#include "gtest/gtest.h"
-
-// A dummy test that is enabled.
-TEST(SomeTest, Test1) {}
--- a/googletest/test/googletest-fail-if-no-test-linked-test.py
+++ b/googletest/test/googletest-fail-if-no-test-linked-test.py
@ -1,165 +0,0 @@
-#!/usr/bin/env python3  # pylint: disable=g-interpreter-mismatch
-#
-# Copyright 2025, 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.
-
-"""Tests for Google Test's --gtest_fail_if_no_test_linked flag."""
-
-import os
-from googletest.test import gtest_test_utils
-
-# The command line flag for enabling the fail-if-no-test-linked behavior.
-FAIL_IF_NO_TEST_LINKED_FLAG = "gtest_fail_if_no_test_linked"
-
-# The environment variable for the test output warnings file.
-TEST_WARNINGS_OUTPUT_FILE = "TEST_WARNINGS_OUTPUT_FILE"
-
-
-class GTestFailIfNoTestLinkedTest(gtest_test_utils.TestCase):
-  """Tests the --gtest_fail_if_no_test_linked flag."""
-
-  def Run(self, program_name, flag=None, env=None):
-    """Run the given program with the given flag.
-
-    Args:
-      program_name: Name of the program to run.
-      flag: The command line flag to pass to the program, or None.
-      env: Dictionary with environment to pass to the subprocess.
-
-    Returns:
-      True if the program exits with code 0, false otherwise.
-    """
-
-    exe_path = gtest_test_utils.GetTestExecutablePath(program_name)
-    args = [exe_path]
-    if flag is not None:
-      args += [flag]
-    process = gtest_test_utils.Subprocess(args, capture_stderr=False, env=env)
-    return process.exited and process.exit_code == 0
-
-  def testSucceedsIfNoTestLinkedAndFlagNotSpecified(self):
-    """Tests the behavior of no test linked and flag not specified."""
-    self.assertTrue(
-        self.Run("googletest-fail-if-no-test-linked-test-without-test_")
-    )
-
-  def testSucceedsIfNoTestLinkedAndFlagNotSpecifiedWithWarningFile(self):
-    """Tests that no test linked results in warning file output."""
-
-    warning_file = os.path.join(gtest_test_utils.GetTempDir(), "NO_TEST_LINKED")
-    self.assertTrue(
-        self.Run(
-            "googletest-fail-if-no-test-linked-test-without-test_",
-            env={TEST_WARNINGS_OUTPUT_FILE: warning_file},
-        )
-    )
-    warning_file_contents = open(warning_file, "r").read()
-    self.assertIn("does NOT link", warning_file_contents)
-
-  def testFailsIfNoTestLinkedAndFlagSpecified(self):
-    """Tests the behavior of no test linked and flag specified."""
-
-    warning_file = os.path.join(
-        gtest_test_utils.GetTempDir(), "SHOULD_NOT_EXIST"
-    )
-    self.assertFalse(
-        self.Run(
-            "googletest-fail-if-no-test-linked-test-without-test_",
-            f"--{FAIL_IF_NO_TEST_LINKED_FLAG}",
-            env={TEST_WARNINGS_OUTPUT_FILE: warning_file},
-        )
-    )
-    with self.assertRaises(FileNotFoundError):
-      open(warning_file, "r")
-
-  def testSucceedsIfEnabledTestLinkedAndFlagNotSpecified(self):
-    """Tests the behavior of enabled test linked and flag not specified."""
-
-    warning_file = os.path.join(
-        gtest_test_utils.GetTempDir(), "SHOULD_NOT_EXIST"
-    )
-    self.assertTrue(
-        self.Run(
-            "googletest-fail-if-no-test-linked-test-with-enabled-test_",
-            env={TEST_WARNINGS_OUTPUT_FILE: warning_file},
-        )
-    )
-    with self.assertRaises(FileNotFoundError):
-      open(warning_file, "r")
-
-  def testSucceedsIfEnabledTestLinkedAndFlagSpecified(self):
-    """Tests the behavior of enabled test linked and flag specified."""
-
-    warning_file = os.path.join(
-        gtest_test_utils.GetTempDir(), "SHOULD_NOT_EXIST"
-    )
-    self.assertTrue(
-        self.Run(
-            "googletest-fail-if-no-test-linked-test-with-enabled-test_",
-            f"--{FAIL_IF_NO_TEST_LINKED_FLAG}",
-            env={TEST_WARNINGS_OUTPUT_FILE: warning_file},
-        )
-    )
-    with self.assertRaises(FileNotFoundError):
-      open(warning_file, "r")
-
-  def testSucceedsIfDisabledTestLinkedAndFlagNotSpecified(self):
-    """Tests the behavior of disabled test linked and flag not specified."""
-
-    warning_file = os.path.join(
-        gtest_test_utils.GetTempDir(), "SHOULD_NOT_EXIST"
-    )
-    self.assertTrue(
-        self.Run(
-            "googletest-fail-if-no-test-linked-test-with-disabled-test_",
-            env={TEST_WARNINGS_OUTPUT_FILE: warning_file},
-        )
-    )
-    with self.assertRaises(FileNotFoundError):
-      open(warning_file, "r")
-
-  def testSucceedsIfDisabledTestLinkedAndFlagSpecified(self):
-    """Tests the behavior of disabled test linked and flag specified."""
-
-    warning_file = os.path.join(
-        gtest_test_utils.GetTempDir(), "SHOULD_NOT_EXIST"
-    )
-    self.assertTrue(
-        self.Run(
-            "googletest-fail-if-no-test-linked-test-with-disabled-test_",
-            f"--{FAIL_IF_NO_TEST_LINKED_FLAG}",
-            env={TEST_WARNINGS_OUTPUT_FILE: warning_file},
-        )
-    )
-    with self.assertRaises(FileNotFoundError):
-      open(warning_file, "r")
-
-
-if __name__ == "__main__":
-  gtest_test_utils.Main()
--- a/googletest/test/googletest-fail-if-no-test-selected-test.py
+++ b/googletest/test/googletest-fail-if-no-test-selected-test.py
@ -1,91 +0,0 @@
-#!/usr/bin/env python3  # pylint: disable=g-interpreter-mismatch
-#
-# Copyright 2025, 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.
-"""Tests for Google Test's --gtest_fail_if_no_test_selected flag."""
-
-from googletest.test import gtest_test_utils
-
-
-# The command line flag for enabling the fail-if-no-test-selected behavior.
-FAIL_IF_NO_TEST_SELECTED_FLAG = "gtest_fail_if_no_test_selected"
-
-# The environment variable for the test output warnings file.
-TEST_WARNINGS_OUTPUT_FILE = "TEST_WARNINGS_OUTPUT_FILE"
-
-
-class GTestFailIfNoTestSelectedTest(gtest_test_utils.TestCase):
-  """Tests the --gtest_fail_if_no_test_selected flag."""
-
-  def Run(self, program_name, flags=None, env=None):
-    """Run the given program with the given flag.
-
-    Args:
-      program_name: Name of the program to run.
-      flags: The command line flags to pass to the program, or None.
-      env: Dictionary with environment to pass to the subprocess.
-
-    Returns:
-      True if the program exits with code 0, false otherwise.
-    """
-
-    exe_path = gtest_test_utils.GetTestExecutablePath(program_name)
-    args = [exe_path]
-    if flags is not None:
-      args.extend(flags)
-    process = gtest_test_utils.Subprocess(args, capture_stderr=False, env=env)
-    return process.exited and process.exit_code == 0
-
-  def testSucceedsWhenFlagIsNotSetAndOnlyDisabledTestsPresent(self):
-    """Tests that no test selected results in success without the flag set."""
-    self.assertTrue(
-        self.Run("googletest-fail-if-no-test-linked-test-with-disabled-test_"),
-    )
-
-  def testFailsWhenFlagIsSetAndOnlyDisabledTestsPresent(self):
-    """Tests that no test selected results in failure with the flag set."""
-    self.assertFalse(
-        self.Run(
-            "googletest-fail-if-no-test-linked-test-with-disabled-test_",
-            flags=[f"--{FAIL_IF_NO_TEST_SELECTED_FLAG}"],
-        ),
-    )
-
-  def testSucceedsWhenFlagIsSetAndEnabledTestsPresent(self):
-    """Tests that a test running still succeeds when the flag is set."""
-    self.assertTrue(
-        self.Run(
-            "googletest-fail-if-no-test-linked-test-with-enabled-test_",
-            flags=[f"--{FAIL_IF_NO_TEST_SELECTED_FLAG}"],
-        ),
-    )
-
-
-if __name__ == "__main__":
-  gtest_test_utils.Main()
--- a/googletest/test/googletest-filter-unittest.py
+++ b/googletest/test/googletest-filter-unittest.py
@ -97,9 +97,6 @@ TOTAL_SHARDS_ENV_VAR = 'GTEST_TOTAL_SHARDS'
 SHARD_INDEX_ENV_VAR = 'GTEST_SHARD_INDEX'
 SHARD_STATUS_FILE_ENV_VAR = 'GTEST_SHARD_STATUS_FILE'

-# The environment variable for the test warnings output file.
-TEST_WARNINGS_OUTPUT_FILE = 'TEST_WARNINGS_OUTPUT_FILE'
-
 # The command line flag for specifying the test filters.
 FILTER_FLAG = 'gtest_filter'

@ -422,22 +419,6 @@ class GTestFilterUnitTest(gtest_test_utils.TestCase):
    self.RunAndVerify('BadFilter', [])
    self.RunAndVerifyAllowingDisabled('BadFilter', [])

-  def testBadFilterWithWarningFile(self):
-    """Tests the warning file when a filter that matches nothing."""
-
-    warning_file = os.path.join(
-        gtest_test_utils.GetTempDir(), 'testBadFilterWithWarningFile'
-    )
-    extra_env = {TEST_WARNINGS_OUTPUT_FILE: warning_file}
-    args = ['--%s=%s' % (FILTER_FLAG, 'BadFilter')]
-    InvokeWithModifiedEnv(extra_env, RunAndReturnOutput, args)
-    with open(warning_file, 'r') as f:
-      warning_file_contents = f.read()
-      self.assertEqual(
-          warning_file_contents,
-          'filter "BadFilter" did not match any test; no tests were run\n',
-      )
-
  def testFullName(self):
    """Tests filtering by full name."""

--- a/googletest/test/googletest-json-output-unittest.py
+++ b/googletest/test/googletest-json-output-unittest.py
@ -57,7 +57,7 @@ else:
  STACK_TRACE_TEMPLATE = '\n'

 EXPECTED_NON_EMPTY = {
-    'tests': 28,
+    'tests': 26,
    'failures': 5,
    'disabled': 2,
    'errors': 0,
@ -150,9 +150,6 @@ EXPECTED_NON_EMPTY = {
                    'time': '*',
                    'timestamp': '*',
                    'classname': 'SkippedTest',
-                    'skipped': [
-                        {'message': 'gtest_xml_output_unittest_.cc:*\n\n'}
-                    ],
                },
                {
                    'name': 'SkippedWithMessage',
@ -163,12 +160,6 @@ EXPECTED_NON_EMPTY = {
                    'time': '*',
                    'timestamp': '*',
                    'classname': 'SkippedTest',
-                    'skipped': [{
-                        'message': (
-                            'gtest_xml_output_unittest_.cc:*\n'
-                            'It is good practice to tell why you skip a test.\n'
-                        )
-                    }],
                },
                {
                    'name': 'SkippedAfterFailure',
@ -188,12 +179,6 @@ EXPECTED_NON_EMPTY = {
                        ),
                        'type': '',
                    }],
-                    'skipped': [{
-                        'message': (
-                            'gtest_xml_output_unittest_.cc:*\n'
-                            'It is good practice to tell why you skip a test.\n'
-                        )
-                    }],
                },
            ],
        },
@ -323,14 +308,12 @@ EXPECTED_NON_EMPTY = {
            'time': '*',
            'timestamp': '*',
            'SetUpTestSuite': 'yes',
-            'SetUpTestSuite (with whitespace)': 'yes and yes',
            'TearDownTestSuite': 'aye',
-            'TearDownTestSuite (with whitespace)': 'aye and aye',
            'testsuite': [
                {
                    'name': 'OneProperty',
                    'file': 'gtest_xml_output_unittest_.cc',
-                    'line': 125,
+                    'line': 121,
                    'status': 'RUN',
                    'result': 'COMPLETED',
                    'time': '*',
@ -341,7 +324,7 @@ EXPECTED_NON_EMPTY = {
                {
                    'name': 'IntValuedProperty',
                    'file': 'gtest_xml_output_unittest_.cc',
-                    'line': 129,
+                    'line': 125,
                    'status': 'RUN',
                    'result': 'COMPLETED',
                    'time': '*',
@ -352,7 +335,7 @@ EXPECTED_NON_EMPTY = {
                {
                    'name': 'ThreeProperties',
                    'file': 'gtest_xml_output_unittest_.cc',
-                    'line': 133,
+                    'line': 129,
                    'status': 'RUN',
                    'result': 'COMPLETED',
                    'time': '*',
@ -365,7 +348,7 @@ EXPECTED_NON_EMPTY = {
                {
                    'name': 'TwoValuesForOneKeyUsesLastValue',
                    'file': 'gtest_xml_output_unittest_.cc',
-                    'line': 139,
+                    'line': 135,
                    'status': 'RUN',
                    'result': 'COMPLETED',
                    'time': '*',
@ -387,7 +370,7 @@ EXPECTED_NON_EMPTY = {
                {
                    'name': 'RecordProperty',
                    'file': 'gtest_xml_output_unittest_.cc',
-                    'line': 144,
+                    'line': 140,
                    'status': 'RUN',
                    'result': 'COMPLETED',
                    'time': '*',
@ -398,7 +381,7 @@ EXPECTED_NON_EMPTY = {
                {
                    'name': 'ExternalUtilityThatCallsRecordIntValuedProperty',
                    'file': 'gtest_xml_output_unittest_.cc',
-                    'line': 157,
+                    'line': 153,
                    'status': 'RUN',
                    'result': 'COMPLETED',
                    'time': '*',
@ -411,7 +394,7 @@ EXPECTED_NON_EMPTY = {
                        'ExternalUtilityThatCallsRecordStringValuedProperty'
                    ),
                    'file': 'gtest_xml_output_unittest_.cc',
-                    'line': 161,
+                    'line': 157,
                    'status': 'RUN',
                    'result': 'COMPLETED',
                    'time': '*',
@ -421,83 +404,6 @@ EXPECTED_NON_EMPTY = {
                },
            ],
        },
-        {
-            'name': 'SetupFailTest',
-            'tests': 1,
-            'failures': 0,
-            'disabled': 0,
-            'errors': 0,
-            'time': '*',
-            'timestamp': '*',
-            'testsuite': [
-                {
-                    'name': 'NoopPassingTest',
-                    'file': 'gtest_xml_output_unittest_.cc',
-                    'line': 172,
-                    'status': 'RUN',
-                    'result': 'SKIPPED',
-                    'timestamp': '*',
-                    'time': '*',
-                    'classname': 'SetupFailTest',
-                    'skipped': [
-                        {'message': 'gtest_xml_output_unittest_.cc:*\n'}
-                    ],
-                },
-                {
-                    'name': '',
-                    'status': 'RUN',
-                    'result': 'COMPLETED',
-                    'timestamp': '*',
-                    'time': '*',
-                    'classname': '',
-                    'failures': [{
-                        'failure': (
-                            'gtest_xml_output_unittest_.cc:*\nExpected equality'
-                            ' of these values:\n  1\n  2'
-                            + STACK_TRACE_TEMPLATE
-                        ),
-                        'type': '',
-                    }],
-                },
-            ],
-        },
-        {
-            'name': 'TearDownFailTest',
-            'tests': 1,
-            'failures': 0,
-            'disabled': 0,
-            'errors': 0,
-            'timestamp': '*',
-            'time': '*',
-            'testsuite': [
-                {
-                    'name': 'NoopPassingTest',
-                    'file': 'gtest_xml_output_unittest_.cc',
-                    'line': 179,
-                    'status': 'RUN',
-                    'result': 'COMPLETED',
-                    'timestamp': '*',
-                    'time': '*',
-                    'classname': 'TearDownFailTest',
-                },
-                {
-                    'name': '',
-                    'status': 'RUN',
-                    'result': 'COMPLETED',
-                    'timestamp': '*',
-                    'time': '*',
-                    'classname': '',
-                    'failures': [{
-                        'failure': (
-                            'gtest_xml_output_unittest_.cc:*\nExpected equality'
-                            ' of these values:\n  1\n  2'
-                            + STACK_TRACE_TEMPLATE
-                        ),
-                        'type': '',
-                    }],
-                },
-            ],
-        },
        {
            'name': 'TypedTest/0',
            'tests': 1,
@ -510,7 +416,7 @@ EXPECTED_NON_EMPTY = {
                'name': 'HasTypeParamAttribute',
                'type_param': 'int',
                'file': 'gtest_xml_output_unittest_.cc',
-                'line': 193,
+                'line': 173,
                'status': 'RUN',
                'result': 'COMPLETED',
                'time': '*',
@ -530,7 +436,7 @@ EXPECTED_NON_EMPTY = {
                'name': 'HasTypeParamAttribute',
                'type_param': 'long',
                'file': 'gtest_xml_output_unittest_.cc',
-                'line': 193,
+                'line': 173,
                'status': 'RUN',
                'result': 'COMPLETED',
                'time': '*',
@ -550,7 +456,7 @@ EXPECTED_NON_EMPTY = {
                'name': 'HasTypeParamAttribute',
                'type_param': 'int',
                'file': 'gtest_xml_output_unittest_.cc',
-                'line': 200,
+                'line': 180,
                'status': 'RUN',
                'result': 'COMPLETED',
                'time': '*',
@ -570,7 +476,7 @@ EXPECTED_NON_EMPTY = {
                'name': 'HasTypeParamAttribute',
                'type_param': 'long',
                'file': 'gtest_xml_output_unittest_.cc',
-                'line': 200,
+                'line': 180,
                'status': 'RUN',
                'result': 'COMPLETED',
                'time': '*',
@ -591,7 +497,7 @@ EXPECTED_NON_EMPTY = {
                    'name': 'HasValueParamAttribute/0',
                    'value_param': '33',
                    'file': 'gtest_xml_output_unittest_.cc',
-                    'line': 184,
+                    'line': 164,
                    'status': 'RUN',
                    'result': 'COMPLETED',
                    'time': '*',
@ -602,7 +508,7 @@ EXPECTED_NON_EMPTY = {
                    'name': 'HasValueParamAttribute/1',
                    'value_param': '42',
                    'file': 'gtest_xml_output_unittest_.cc',
-                    'line': 184,
+                    'line': 164,
                    'status': 'RUN',
                    'result': 'COMPLETED',
                    'time': '*',
@ -613,7 +519,7 @@ EXPECTED_NON_EMPTY = {
                    'name': 'AnotherTestThatHasValueParamAttribute/0',
                    'value_param': '33',
                    'file': 'gtest_xml_output_unittest_.cc',
-                    'line': 185,
+                    'line': 165,
                    'status': 'RUN',
                    'result': 'COMPLETED',
                    'time': '*',
@ -624,7 +530,7 @@ EXPECTED_NON_EMPTY = {
                    'name': 'AnotherTestThatHasValueParamAttribute/1',
                    'value_param': '42',
                    'file': 'gtest_xml_output_unittest_.cc',
-                    'line': 185,
+                    'line': 165,
                    'status': 'RUN',
                    'result': 'COMPLETED',
                    'time': '*',
--- a/googletest/test/googletest-options-test.cc
+++ b/googletest/test/googletest-options-test.cc
@ -115,14 +115,11 @@ TEST(OutputFileHelpersTest, GetCurrentExecutableName) {
      strcasecmp("gtest_dll_test", exe_str.c_str()) == 0;
 #elif defined(GTEST_OS_FUCHSIA)
  const bool success = exe_str == "app";
-#elif defined(__EMSCRIPTEN__)
-  const bool success = exe_str == "patched_googletest-options-test.js";
 #else
  const bool success =
      exe_str == "googletest-options-test" || exe_str == "gtest_all_test" ||
      exe_str == "lt-gtest_all_test" || exe_str == "gtest_dll_test";
-#endif  // platform ifdefs
-
+#endif  // GTEST_OS_WINDOWS
  if (!success) FAIL() << "GetCurrentExecutableName() returns " << exe_str;
 }

--- a/googletest/test/googletest-output-test-golden-lin.txt
+++ b/googletest/test/googletest-output-test-golden-lin.txt
@ -62,7 +62,7 @@ Expected equality of these values:
    Which is: "\"Line\0 1\"\nLine 2"
  "Line 2"
 With diff:
-@@ -1,2 +1 @@
+@@ -1,2 @@
 -\"Line\0 1\"
 Line 2

@ -696,6 +696,7 @@ Expected: 1 fatal failure
  Actual:
 googletest-output-test_.cc:#: Success:
 Succeeded
+Stack trace: (omitted)


 Stack trace: (omitted)
@ -732,6 +733,7 @@ Expected: 1 non-fatal failure
  Actual:
 googletest-output-test_.cc:#: Success:
 Succeeded
+Stack trace: (omitted)


 Stack trace: (omitted)
@ -768,6 +770,7 @@ Expected: 1 fatal failure
  Actual:
 googletest-output-test_.cc:#: Success:
 Succeeded
+Stack trace: (omitted)


 Stack trace: (omitted)
@ -804,6 +807,7 @@ Expected: 1 non-fatal failure
  Actual:
 googletest-output-test_.cc:#: Success:
 Succeeded
+Stack trace: (omitted)


 Stack trace: (omitted)
@ -966,6 +970,7 @@ googletest-output-test_.cc:#: Skipped
 [0;32m[----------] [m1 test from TestSuiteThatSkipsInSetUp
 googletest-output-test_.cc:#: Skipped
 Skip entire test suite
+Stack trace: (omitted)

 [0;32m[ RUN      ] [mTestSuiteThatSkipsInSetUp.ShouldNotRun
 googletest-output-test_.cc:#: Skipped
--- a/googletest/test/googletest-param-test-test.cc
+++ b/googletest/test/googletest-param-test-test.cc
@ -35,17 +35,12 @@
 #include "test/googletest-param-test-test.h"

 #include <algorithm>
-#include <cstddef>
-#include <cstdint>
-#include <functional>
 #include <iostream>
 #include <list>
 #include <set>
 #include <sstream>
 #include <string>
-#include <string_view>
 #include <tuple>
-#include <type_traits>
 #include <vector>

 #include "gtest/gtest.h"
@ -588,71 +583,6 @@ TEST(ConvertTest, NonDefaultConstructAssign) {
  EXPECT_TRUE(it == gen.end());
 }

-TEST(ConvertTest, WithConverterLambdaAndDeducedType) {
-  const ParamGenerator<ConstructFromT<int8_t>> gen =
-      ConvertGenerator(Values("0", std::string("1")), [](const std::string& s) {
-        size_t pos;
-        int64_t value = std::stoll(s, &pos);
-        EXPECT_EQ(pos, s.size());
-        return value;
-      });
-
-  ConstructFromT<int8_t> expected_values[] = {ConstructFromT<int8_t>(0),
-                                              ConstructFromT<int8_t>(1)};
-  VerifyGenerator(gen, expected_values);
-}
-
-TEST(ConvertTest, WithConverterLambdaAndExplicitType) {
-  auto convert_generator = ConvertGenerator<std::string>(
-      Values("0", std::string("1")), [](std::string_view s) {
-        size_t pos;
-        int64_t value = std::stoll(std::string(s), &pos);
-        EXPECT_EQ(pos, s.size());
-        return value;
-      });
-  constexpr bool is_correct_type = std::is_same_v<
-      decltype(convert_generator),
-      testing::internal::ParamConverterGenerator<
-          std::string, std::function<int64_t(std::string_view)>>>;
-  EXPECT_TRUE(is_correct_type);
-  const ParamGenerator<ConstructFromT<int8_t>> gen = convert_generator;
-
-  ConstructFromT<int8_t> expected_values[] = {ConstructFromT<int8_t>(0),
-                                              ConstructFromT<int8_t>(1)};
-  VerifyGenerator(gen, expected_values);
-}
-
-TEST(ConvertTest, WithConverterFunctionPointer) {
-  int64_t (*func_ptr)(const std::string&) = [](const std::string& s) {
-    size_t pos;
-    int64_t value = std::stoll(s, &pos);
-    EXPECT_EQ(pos, s.size());
-    return value;
-  };
-  const ParamGenerator<ConstructFromT<int8_t>> gen =
-      ConvertGenerator(Values("0", std::string("1")), func_ptr);
-
-  ConstructFromT<int8_t> expected_values[] = {ConstructFromT<int8_t>(0),
-                                              ConstructFromT<int8_t>(1)};
-  VerifyGenerator(gen, expected_values);
-}
-
-TEST(ConvertTest, WithConverterFunctionReference) {
-  int64_t (*func_ptr)(const std::string&) = [](const std::string& s) {
-    size_t pos;
-    int64_t value = std::stoll(s, &pos);
-    EXPECT_EQ(pos, s.size());
-    return value;
-  };
-  int64_t (&func_ref)(const std::string&) = *func_ptr;
-  const ParamGenerator<ConstructFromT<int8_t>> gen =
-      ConvertGenerator(Values("0", std::string("1")), func_ref);
-
-  ConstructFromT<int8_t> expected_values[] = {ConstructFromT<int8_t>(0),
-                                              ConstructFromT<int8_t>(1)};
-  VerifyGenerator(gen, expected_values);
-}
-
 // Tests that an generator produces correct sequence after being
 // assigned from another generator.
 TEST(ParamGeneratorTest, AssignmentWorks) {
@ -696,7 +626,7 @@ class TestGenerationEnvironment : public ::testing::Environment {
      msg << "TestsExpandedAndRun/" << i;
      if (UnitTestOptions::FilterMatchesTest(
              "TestExpansionModule/MultipleTestGenerationTest",
-              msg.GetString())) {
+              msg.GetString().c_str())) {
        perform_check = true;
      }
    }
@ -1174,7 +1104,7 @@ TEST_P(ParameterizedDerivedTest, SeesSequence) {
 class ParameterizedDeathTest : public ::testing::TestWithParam<int> {};

 TEST_F(ParameterizedDeathTest, GetParamDiesFromTestF) {
-  EXPECT_DEATH_IF_SUPPORTED((void)GetParam(), ".* value-parameterized test .*");
+  EXPECT_DEATH_IF_SUPPORTED(GetParam(), ".* value-parameterized test .*");
 }

 INSTANTIATE_TEST_SUITE_P(RangeZeroToFive, ParameterizedDerivedTest,
--- a/googletest/test/googletest-port-test.cc
+++ b/googletest/test/googletest-port-test.cc
@ -288,15 +288,15 @@ TEST(FormatCompilerIndependentFileLocationTest, FormatsUknownFileAndLine) {
    defined(GTEST_OS_OPENBSD) || defined(GTEST_OS_GNU_HURD)
 void* ThreadFunc(void* data) {
  internal::Mutex* mutex = static_cast<internal::Mutex*>(data);
-  mutex->lock();
-  mutex->unlock();
+  mutex->Lock();
+  mutex->Unlock();
  return nullptr;
 }

 TEST(GetThreadCountTest, ReturnsCorrectValue) {
  size_t starting_count;
  size_t thread_count_after_create;
-  size_t thread_count_after_join = 0;
+  size_t thread_count_after_join;

  // We can't guarantee that no other thread was created or destroyed between
  // any two calls to GetThreadCount(). We make multiple attempts, hoping that
@ -308,7 +308,7 @@ TEST(GetThreadCountTest, ReturnsCorrectValue) {

    internal::Mutex mutex;
    {
-      internal::MutexLock lock(mutex);
+      internal::MutexLock lock(&mutex);
      pthread_attr_t attr;
      ASSERT_EQ(0, pthread_attr_init(&attr));
      ASSERT_EQ(0, pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE));
@ -316,10 +316,10 @@ TEST(GetThreadCountTest, ReturnsCorrectValue) {
      const int status = pthread_create(&thread_id, &attr, &ThreadFunc, &mutex);
      ASSERT_EQ(0, pthread_attr_destroy(&attr));
      ASSERT_EQ(0, status);
-
-      thread_count_after_create = GetThreadCount();
    }

+    thread_count_after_create = GetThreadCount();
+
    void* dummy;
    ASSERT_EQ(0, pthread_join(thread_id, &dummy));

@ -1028,9 +1028,7 @@ TEST(MutexDeathTest, AssertHeldShouldAssertWhenNotLocked) {
  EXPECT_DEATH_IF_SUPPORTED(
      {
        Mutex m;
-        {
-          MutexLock lock(m);
-        }
+        { MutexLock lock(&m); }
        m.AssertHeld();
      },
      "thread .*hold");
@ -1038,13 +1036,13 @@ TEST(MutexDeathTest, AssertHeldShouldAssertWhenNotLocked) {

 TEST(MutexTest, AssertHeldShouldNotAssertWhenLocked) {
  Mutex m;
-  MutexLock lock(m);
+  MutexLock lock(&m);
  m.AssertHeld();
 }

 class AtomicCounterWithMutex {
 public:
-  explicit AtomicCounterWithMutex(Mutex& mutex)
+  explicit AtomicCounterWithMutex(Mutex* mutex)
      : value_(0), mutex_(mutex), random_(42) {}

  void Increment() {
@ -1085,7 +1083,7 @@ class AtomicCounterWithMutex {

 private:
  volatile int value_;
-  Mutex& mutex_;  // Protects value_.
+  Mutex* const mutex_;  // Protects value_.
  Random random_;
 };

@ -1096,7 +1094,7 @@ void CountingThreadFunc(pair<AtomicCounterWithMutex*, int> param) {
 // Tests that the mutex only lets one thread at a time to lock it.
 TEST(MutexTest, OnlyOneThreadCanLockAtATime) {
  Mutex mutex;
-  AtomicCounterWithMutex locked_counter(mutex);
+  AtomicCounterWithMutex locked_counter(&mutex);

  typedef ThreadWithParam<pair<AtomicCounterWithMutex*, int> > ThreadType;
  const int kCycleCount = 20;
--- a/googletest/test/googletest-printers-test.cc
+++ b/googletest/test/googletest-printers-test.cc
@ -32,7 +32,6 @@
 // This file tests the universal value printer.

 #include <algorithm>
-#include <any>
 #include <cctype>
 #include <cstdint>
 #include <cstring>
@ -43,35 +42,23 @@
 #include <list>
 #include <map>
 #include <memory>
-#include <optional>
 #include <ostream>
 #include <set>
 #include <sstream>
 #include <string>
-#include <string_view>
 #include <tuple>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
-#include <variant>
 #include <vector>

 #include "gtest/gtest-printers.h"
 #include "gtest/gtest.h"
-#include "gtest/internal/gtest-port.h"

 #ifdef GTEST_HAS_ABSL
 #include "absl/strings/str_format.h"
 #endif

-#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
-
 // Some user-defined types for testing the universal value printer.

 // An anonymous enum type.
@ -125,9 +112,6 @@ class UnprintableTemplateInGlobal {
 // A user-defined streamable type in the global namespace.
 class StreamableInGlobal {
 public:
-  StreamableInGlobal() = default;
-  StreamableInGlobal(const StreamableInGlobal&) = default;
-  StreamableInGlobal& operator=(const StreamableInGlobal&) = default;
  virtual ~StreamableInGlobal() = default;
 };

@ -579,8 +563,6 @@ TEST(PrintU8StringTest, Null) {
 }

 // Tests that u8 strings are escaped properly.
-// TODO(b/396121064) - Fix this test under MSVC
-#ifndef _MSC_VER
 TEST(PrintU8StringTest, EscapesProperly) {
  const char8_t* p = u8"'\"?\\\a\b\f\n\r\t\v\x7F\xFF hello 世界";
  EXPECT_EQ(PrintPointer(p) +
@ -588,8 +570,7 @@ TEST(PrintU8StringTest, EscapesProperly) {
                "hello \\xE4\\xB8\\x96\\xE7\\x95\\x8C\"",
            Print(p));
 }
-#endif  // _MSC_VER
-#endif  // __cpp_lib_char8_t
+#endif

 // const char16_t*.
 TEST(PrintU16StringTest, Const) {
@ -800,7 +781,7 @@ struct Foo {
 TEST(PrintPointerTest, MemberVariablePointer) {
  EXPECT_TRUE(HasPrefix(Print(&Foo::value),
                        Print(sizeof(&Foo::value)) + "-byte object "));
-  int Foo::* p = NULL;  // NOLINT
+  int Foo::*p = NULL;  // NOLINT
  EXPECT_TRUE(HasPrefix(Print(p), Print(sizeof(p)) + "-byte object "));
 }

@ -927,7 +908,7 @@ TEST(PrintArrayTest, BigArray) {
            PrintArrayHelper(a));
 }

-// Tests printing ::std::string and ::string_view.
+// Tests printing ::string and ::std::string.

 // ::std::string.
 TEST(PrintStringTest, StringInStdNamespace) {
@ -937,13 +918,6 @@ TEST(PrintStringTest, StringInStdNamespace) {
            Print(str));
 }

-TEST(PrintStringTest, StringViewInStdNamespace) {
-  const char s[] = "'\"?\\\a\b\f\n\0\r\t\v\x7F\xFF a";
-  const ::std::string_view str(s, sizeof(s));
-  EXPECT_EQ("\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v\\x7F\\xFF a\\0\"",
-            Print(str));
-}
-
 TEST(PrintStringTest, StringAmbiguousHex) {
  // "\x6BANANA" is ambiguous, it can be interpreted as starting with either of:
  // '\x6', '\x6B', or '\x6BA'.
@ -961,7 +935,7 @@ TEST(PrintStringTest, StringAmbiguousHex) {
  EXPECT_EQ("\"!\\x5-!\"", Print(::std::string("!\x5-!")));
 }

-// Tests printing ::std::wstring and ::std::wstring_view.
+// Tests printing ::std::wstring.
 #if GTEST_HAS_STD_WSTRING
 // ::std::wstring.
 TEST(PrintWideStringTest, StringInStdNamespace) {
@ -973,15 +947,6 @@ TEST(PrintWideStringTest, StringInStdNamespace) {
      Print(str));
 }

-TEST(PrintWideStringTest, StringViewInStdNamespace) {
-  const wchar_t s[] = L"'\"?\\\a\b\f\n\0\r\t\v\xD3\x576\x8D3\xC74D a";
-  const ::std::wstring_view str(s, sizeof(s) / sizeof(wchar_t));
-  EXPECT_EQ(
-      "L\"'\\\"?\\\\\\a\\b\\f\\n\\0\\r\\t\\v"
-      "\\xD3\\x576\\x8D3\\xC74D a\\0\"",
-      Print(str));
-}
-
 TEST(PrintWideStringTest, StringAmbiguousHex) {
  // same for wide strings.
  EXPECT_EQ("L\"0\\x12\" L\"3\"", Print(::std::wstring(L"0\x12"
@ -1000,12 +965,6 @@ TEST(PrintStringTest, U8String) {
  EXPECT_EQ(str, str);  // Verify EXPECT_EQ compiles with this type.
  EXPECT_EQ("u8\"Hello, \\xE4\\xB8\\x96\\xE7\\x95\\x8C\"", Print(str));
 }
-
-TEST(PrintStringTest, U8StringView) {
-  std::u8string_view str = u8"Hello, 世界";
-  EXPECT_EQ(str, str);  // Verify EXPECT_EQ compiles with this type.
-  EXPECT_EQ("u8\"Hello, \\xE4\\xB8\\x96\\xE7\\x95\\x8C\"", Print(str));
-}
 #endif

 TEST(PrintStringTest, U16String) {
@ -1014,24 +973,12 @@ TEST(PrintStringTest, U16String) {
  EXPECT_EQ("u\"Hello, \\x4E16\\x754C\"", Print(str));
 }

-TEST(PrintStringTest, U16StringView) {
-  std::u16string_view str = u"Hello, 世界";
-  EXPECT_EQ(str, str);  // Verify EXPECT_EQ compiles with this type.
-  EXPECT_EQ("u\"Hello, \\x4E16\\x754C\"", Print(str));
-}
-
 TEST(PrintStringTest, U32String) {
  std::u32string str = U"Hello, 🗺️";
  EXPECT_EQ(str, str);  // Verify EXPECT_EQ compiles with this type
  EXPECT_EQ("U\"Hello, \\x1F5FA\\xFE0F\"", Print(str));
 }

-TEST(PrintStringTest, U32StringView) {
-  std::u32string_view str = U"Hello, 🗺️";
-  EXPECT_EQ(str, str);  // Verify EXPECT_EQ compiles with this type
-  EXPECT_EQ("U\"Hello, \\x1F5FA\\xFE0F\"", Print(str));
-}
-
 // Tests printing types that support generic streaming (i.e. streaming
 // to std::basic_ostream<Char, CharTraits> for any valid Char and
 // CharTraits types).
@ -1232,17 +1179,6 @@ TEST(PrintStlContainerTest, Vector) {
  EXPECT_EQ("{ 1, 2 }", Print(v));
 }

-TEST(PrintStlContainerTest, StdSpan) {
-#if GTEST_INTERNAL_HAS_STD_SPAN
-  int a[] = {3, 6, 5};
-  std::span<int> s = a;
-
-  EXPECT_EQ("{ 3, 6, 5 }", Print(s));
-#else
-  GTEST_SKIP() << "Does not have std::span.";
-#endif  // GTEST_INTERNAL_HAS_STD_SPAN
-}
-
 TEST(PrintStlContainerTest, LongSequence) {
  const int a[100] = {1, 2, 3};
  const vector<int> v(a, a + 100);
@ -1491,7 +1427,7 @@ TEST(PrintReferenceTest, HandlesMemberFunctionPointer) {
 // Tests that the universal printer prints a member variable pointer
 // passed by reference.
 TEST(PrintReferenceTest, HandlesMemberVariablePointer) {
-  int Foo::* p = &Foo::value;  // NOLINT
+  int Foo::*p = &Foo::value;  // NOLINT
  EXPECT_TRUE(HasPrefix(PrintByRef(p), "@" + PrintPointer(&p) + " " +
                                           Print(sizeof(p)) + "-byte object "));
 }
@ -1699,7 +1635,7 @@ TEST(PrintToStringTest, ContainsNonLatin) {
  EXPECT_PRINT_TO_STRING_(non_ascii_str,
                          "\"\\xEC\\x98\\xA4\\xEC\\xA0\\x84 4:30\"\n"
                          "    As Text: \"오전 4:30\"");
-  non_ascii_str = "From ä — ẑ";
+  non_ascii_str = ::std::string("From ä — ẑ");
  EXPECT_PRINT_TO_STRING_(non_ascii_str,
                          "\"From \\xC3\\xA4 \\xE2\\x80\\x94 \\xE1\\xBA\\x91\""
                          "\n    As Text: \"From ä — ẑ\"");
@ -1929,22 +1865,6 @@ TEST(UniversalPrintTest, SmartPointers) {
            PrintToString(std::shared_ptr<void>(p.get(), [](void*) {})));
 }

-TEST(UniversalPrintTest, StringViewNonZeroTerminated) {
-  // Craft a non-ASCII UTF-8 input (to trigger a special path in
-  // `ConditionalPrintAsText`). Use array notation instead of the string
-  // literal syntax, to avoid placing a terminating 0 at the end of the input.
-  const char s[] = {'\357', '\243', '\242', 'X'};
-  // Only include the first 3 bytes in the `string_view` and leave the last one
-  // ('X') outside. This way, if the code tries to use `str.data()` with
-  // `strlen` instead of `str.size()`, it will include 'X' and cause a visible
-  // difference (in addition to ASAN tests detecting a buffer overflow due to
-  // the missing 0 at the end).
-  const ::std::string_view str(s, 3);
-  ::std::stringstream ss;
-  UniversalPrint(str, &ss);
-  EXPECT_EQ("\"\\xEF\\xA3\\xA2\"\n    As Text: \"\xEF\xA3\xA2\"", ss.str());
-}
-
 TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsEmptyTuple) {
  Strings result = UniversalTersePrintTupleFieldsToStrings(::std::make_tuple());
  EXPECT_EQ(0u, result.size());
@ -1974,6 +1894,7 @@ TEST(UniversalTersePrintTupleFieldsToStringsTestWithStd, PrintsTersely) {
  EXPECT_EQ("\"a\"", result[1]);
 }

+#if GTEST_INTERNAL_HAS_ANY
 class PrintAnyTest : public ::testing::Test {
 protected:
  template <typename T>
@ -1987,12 +1908,12 @@ class PrintAnyTest : public ::testing::Test {
 };

 TEST_F(PrintAnyTest, Empty) {
-  std::any any;
+  internal::Any any;
  EXPECT_EQ("no value", PrintToString(any));
 }

 TEST_F(PrintAnyTest, NonEmpty) {
-  std::any any;
+  internal::Any any;
  constexpr int val1 = 10;
  const std::string val2 = "content";

@ -2003,23 +1924,27 @@ TEST_F(PrintAnyTest, NonEmpty) {
  EXPECT_EQ("value of type " + ExpectedTypeName<std::string>(),
            PrintToString(any));
 }
+#endif  // GTEST_INTERNAL_HAS_ANY

+#if GTEST_INTERNAL_HAS_OPTIONAL
 TEST(PrintOptionalTest, Basic) {
-  EXPECT_EQ("(nullopt)", PrintToString(std::nullopt));
-  std::optional<int> value;
+  EXPECT_EQ("(nullopt)", PrintToString(internal::Nullopt()));
+  internal::Optional<int> value;
  EXPECT_EQ("(nullopt)", PrintToString(value));
  value = {7};
  EXPECT_EQ("(7)", PrintToString(value));
-  EXPECT_EQ("(1.1)", PrintToString(std::optional<double>{1.1}));
-  EXPECT_EQ("(\"A\")", PrintToString(std::optional<std::string>{"A"}));
+  EXPECT_EQ("(1.1)", PrintToString(internal::Optional<double>{1.1}));
+  EXPECT_EQ("(\"A\")", PrintToString(internal::Optional<std::string>{"A"}));
 }
+#endif  // GTEST_INTERNAL_HAS_OPTIONAL

+#if GTEST_INTERNAL_HAS_VARIANT
 struct NonPrintable {
  unsigned char contents = 17;
 };

 TEST(PrintOneofTest, Basic) {
-  using Type = std::variant<int, StreamableInGlobal, NonPrintable>;
+  using Type = internal::Variant<int, StreamableInGlobal, NonPrintable>;
  EXPECT_EQ("('int(index = 0)' with value 7)", PrintToString(Type(7)));
  EXPECT_EQ("('StreamableInGlobal(index = 1)' with value StreamableInGlobal)",
            PrintToString(Type(StreamableInGlobal{})));
@ -2028,26 +1953,7 @@ TEST(PrintOneofTest, Basic) {
      "1-byte object <11>)",
      PrintToString(Type(NonPrintable{})));
 }
-
-#if GTEST_INTERNAL_HAS_COMPARE_LIB
-TEST(PrintOrderingTest, Basic) {
-  EXPECT_EQ("(less)", PrintToString(std::strong_ordering::less));
-  EXPECT_EQ("(greater)", PrintToString(std::strong_ordering::greater));
-  // equal == equivalent for strong_ordering.
-  EXPECT_EQ("(equal)", PrintToString(std::strong_ordering::equivalent));
-  EXPECT_EQ("(equal)", PrintToString(std::strong_ordering::equal));
-
-  EXPECT_EQ("(less)", PrintToString(std::weak_ordering::less));
-  EXPECT_EQ("(greater)", PrintToString(std::weak_ordering::greater));
-  EXPECT_EQ("(equivalent)", PrintToString(std::weak_ordering::equivalent));
-
-  EXPECT_EQ("(less)", PrintToString(std::partial_ordering::less));
-  EXPECT_EQ("(greater)", PrintToString(std::partial_ordering::greater));
-  EXPECT_EQ("(equivalent)", PrintToString(std::partial_ordering::equivalent));
-  EXPECT_EQ("(unordered)", PrintToString(std::partial_ordering::unordered));
-}
-#endif
-
+#endif  // GTEST_INTERNAL_HAS_VARIANT
 namespace {
 class string_ref;

--- a/googletest/test/googletest-setuptestsuite-test_.cc
+++ b/googletest/test/googletest-setuptestsuite-test_.cc
@ -31,14 +31,14 @@

 class SetupFailTest : public ::testing::Test {
 protected:
-  static void SetUpTestSuite() { ASSERT_STREQ("", "SET_UP_FAIL"); }
+  static void SetUpTestSuite() { ASSERT_EQ("", "SET_UP_FAIL"); }
 };

 TEST_F(SetupFailTest, NoopPassingTest) {}

 class TearDownFailTest : public ::testing::Test {
 protected:
-  static void TearDownTestSuite() { ASSERT_STREQ("", "TEAR_DOWN_FAIL"); }
+  static void TearDownTestSuite() { ASSERT_EQ("", "TEAR_DOWN_FAIL"); }
 };

 TEST_F(TearDownFailTest, NoopPassingTest) {}
--- a/googletest/test/gtest_environment_test.cc
+++ b/googletest/test/gtest_environment_test.cc
@ -40,21 +40,16 @@ namespace {

 enum FailureType { NO_FAILURE, NON_FATAL_FAILURE, FATAL_FAILURE };

-// Was SetUp run?
-bool set_up_was_run;
-// Was TearDown run?
-bool tear_down_was_run;
-// Was the TEST run?
-bool test_was_run;
-
 // For testing using global test environments.
 class MyEnvironment : public testing::Environment {
 public:
+  MyEnvironment() { Reset(); }
+
  // Depending on the value of failure_in_set_up_, SetUp() will
  // generate a non-fatal failure, generate a fatal failure, or
  // succeed.
  void SetUp() override {
-    set_up_was_run = true;
+    set_up_was_run_ = true;

    switch (failure_in_set_up_) {
      case NON_FATAL_FAILURE:
@ -70,18 +65,36 @@ class MyEnvironment : public testing::Environment {

  // Generates a non-fatal failure.
  void TearDown() override {
-    tear_down_was_run = true;
+    tear_down_was_run_ = true;
    ADD_FAILURE() << "Expected non-fatal failure in global tear-down.";
  }

+  // Resets the state of the environment s.t. it can be reused.
+  void Reset() {
+    failure_in_set_up_ = NO_FAILURE;
+    set_up_was_run_ = false;
+    tear_down_was_run_ = false;
+  }
+
  // We call this function to set the type of failure SetUp() should
  // generate.
  void set_failure_in_set_up(FailureType type) { failure_in_set_up_ = type; }

+  // Was SetUp() run?
+  bool set_up_was_run() const { return set_up_was_run_; }
+
+  // Was TearDown() run?
+  bool tear_down_was_run() const { return tear_down_was_run_; }
+
 private:
  FailureType failure_in_set_up_;
+  bool set_up_was_run_;
+  bool tear_down_was_run_;
 };

+// Was the TEST run?
+bool test_was_run;
+
 // The sole purpose of this TEST is to enable us to check whether it
 // was run.
 TEST(FooTest, Bar) { test_was_run = true; }
@ -99,88 +112,67 @@ void Check(bool condition, const char* msg) {
 // The 'failure' parameter specifies the type of failure that should
 // be generated by the global set-up.
 int RunAllTests(MyEnvironment* env, FailureType failure) {
-  set_up_was_run = false;
-  tear_down_was_run = false;
-  test_was_run = false;
+  env->Reset();
  env->set_failure_in_set_up(failure);
+  test_was_run = false;
  testing::internal::GetUnitTestImpl()->ClearAdHocTestResult();
  return RUN_ALL_TESTS();
 }

-// Registers a global test environment, and verifies that the
-// registration function returns its argument.
-MyEnvironment* RegisterTestEnv() {
-  MyEnvironment* const env = new MyEnvironment;
-  Check(testing::AddGlobalTestEnvironment(env) == env,
-        "AddGlobalTestEnvironment() should return its argument.");
-  return env;
-}
-
-// Verifies that RUN_ALL_TESTS() runs the tests when the global
-// set-up is successful.
-void TestGlobalSetUp() {
-  MyEnvironment* const env = RegisterTestEnv();
-  Check(RunAllTests(env, NO_FAILURE) != 0,
-        "RUN_ALL_TESTS() should return non-zero, as the global tear-down "
-        "should generate a failure.");
-  Check(test_was_run,
-        "The tests should run, as the global set-up should generate no "
-        "failure");
-  Check(tear_down_was_run,
-        "The global tear-down should run, as the global set-up was run.");
-}
-
-// Verifies that RUN_ALL_TESTS() runs the tests when the global
-// set-up generates no fatal failure.
-void TestTestsRun() {
-  MyEnvironment* const env = RegisterTestEnv();
-  Check(RunAllTests(env, NON_FATAL_FAILURE) != 0,
-        "RUN_ALL_TESTS() should return non-zero, as both the global set-up "
-        "and the global tear-down should generate a non-fatal failure.");
-  Check(test_was_run,
-        "The tests should run, as the global set-up should generate no "
-        "fatal failure.");
-  Check(tear_down_was_run,
-        "The global tear-down should run, as the global set-up was run.");
-}
-
-// Verifies that RUN_ALL_TESTS() runs no test when the global set-up
-// generates a fatal failure.
-void TestNoTestsRunSetUpFailure() {
-  MyEnvironment* const env = RegisterTestEnv();
-  Check(RunAllTests(env, FATAL_FAILURE) != 0,
-        "RUN_ALL_TESTS() should return non-zero, as the global set-up "
-        "should generate a fatal failure.");
-  Check(!test_was_run,
-        "The tests should not run, as the global set-up should generate "
-        "a fatal failure.");
-  Check(tear_down_was_run,
-        "The global tear-down should run, as the global set-up was run.");
-}
-
-// Verifies that RUN_ALL_TESTS() doesn't do global set-up or
-// tear-down when there is no test to run.
-void TestNoTestsSkipsSetUp() {
-  MyEnvironment* const env = RegisterTestEnv();
-  GTEST_FLAG_SET(filter, "-*");
-  Check(RunAllTests(env, NO_FAILURE) == 0,
-        "RUN_ALL_TESTS() should return zero, as there is no test to run.");
-  Check(!set_up_was_run,
-        "The global set-up should not run, as there is no test to run.");
-  Check(!tear_down_was_run,
-        "The global tear-down should not run, "
-        "as the global set-up was not run.");
-}
-
 }  // namespace

 int main(int argc, char** argv) {
  testing::InitGoogleTest(&argc, argv);

-  TestGlobalSetUp();
-  TestTestsRun();
-  TestNoTestsRunSetUpFailure();
-  TestNoTestsSkipsSetUp();
+  // Registers a global test environment, and verifies that the
+  // registration function returns its argument.
+  MyEnvironment* const env = new MyEnvironment;
+  Check(testing::AddGlobalTestEnvironment(env) == env,
+        "AddGlobalTestEnvironment() should return its argument.");
+
+  // Verifies that RUN_ALL_TESTS() runs the tests when the global
+  // set-up is successful.
+  Check(RunAllTests(env, NO_FAILURE) != 0,
+        "RUN_ALL_TESTS() should return non-zero, as the global tear-down "
+        "should generate a failure.");
+  Check(test_was_run,
+        "The tests should run, as the global set-up should generate no "
+        "failure");
+  Check(env->tear_down_was_run(),
+        "The global tear-down should run, as the global set-up was run.");
+
+  // Verifies that RUN_ALL_TESTS() runs the tests when the global
+  // set-up generates no fatal failure.
+  Check(RunAllTests(env, NON_FATAL_FAILURE) != 0,
+        "RUN_ALL_TESTS() should return non-zero, as both the global set-up "
+        "and the global tear-down should generate a non-fatal failure.");
+  Check(test_was_run,
+        "The tests should run, as the global set-up should generate no "
+        "fatal failure.");
+  Check(env->tear_down_was_run(),
+        "The global tear-down should run, as the global set-up was run.");
+
+  // Verifies that RUN_ALL_TESTS() runs no test when the global set-up
+  // generates a fatal failure.
+  Check(RunAllTests(env, FATAL_FAILURE) != 0,
+        "RUN_ALL_TESTS() should return non-zero, as the global set-up "
+        "should generate a fatal failure.");
+  Check(!test_was_run,
+        "The tests should not run, as the global set-up should generate "
+        "a fatal failure.");
+  Check(env->tear_down_was_run(),
+        "The global tear-down should run, as the global set-up was run.");
+
+  // Verifies that RUN_ALL_TESTS() doesn't do global set-up or
+  // tear-down when there is no test to run.
+  GTEST_FLAG_SET(filter, "-*");
+  Check(RunAllTests(env, NO_FAILURE) == 0,
+        "RUN_ALL_TESTS() should return zero, as there is no test to run.");
+  Check(!env->set_up_was_run(),
+        "The global set-up should not run, as there is no test to run.");
+  Check(!env->tear_down_was_run(),
+        "The global tear-down should not run, "
+        "as the global set-up was not run.");

  printf("PASS\n");
  return 0;
--- a/googletest/test/gtest_help_test.py
+++ b/googletest/test/gtest_help_test.py
@ -43,22 +43,11 @@ import sys
 from googletest.test import gtest_test_utils


-FREEBSD = ('FreeBSD', 'GNU/kFreeBSD')
-NETBSD = ('NetBSD',)
-OPENBSD = ('OpenBSD',)
-
-
-def is_bsd_based_os() -> bool:
-  """Determine whether or not the OS is BSD-based."""
-  if os.name != 'posix':
-    return False
-
-  return os.uname()[0] in (FREEBSD + NETBSD + OPENBSD)
-
-
 IS_DARWIN = os.name == 'posix' and os.uname()[0] == 'Darwin'
 IS_LINUX = os.name == 'posix' and os.uname()[0] == 'Linux'
 IS_GNUHURD = os.name == 'posix' and os.uname()[0] == 'GNU'
+IS_GNUKFREEBSD = os.name == 'posix' and os.uname()[0] == 'GNU/kFreeBSD'
+IS_OPENBSD = os.name == 'posix' and os.uname()[0] == 'OpenBSD'
 IS_WINDOWS = os.name == 'nt'

 PROGRAM_PATH = gtest_test_utils.GetTestExecutablePath('gtest_help_test_')
@ -107,7 +96,7 @@ HELP_REGEX = re.compile(
 )


-def run_with_flag(flag):
+def RunWithFlag(flag):
  """Runs gtest_help_test_ with the given flag.

  Returns:
@ -127,14 +116,17 @@ def run_with_flag(flag):
 class GTestHelpTest(gtest_test_utils.TestCase):
  """Tests the --help flag and its equivalent forms."""

-  def test_prints_help_with_full_flag(self):
+  def TestHelpFlag(self, flag):
    """Verifies correct behavior when help flag is specified.

    The right message must be printed and the tests must
    skipped when the given flag is specified.
+
+    Args:
+      flag:  A flag to pass to the binary or None.
    """

-    exit_code, output = run_with_flag('--help')
+    exit_code, output = RunWithFlag(flag)
    if HAS_ABSL_FLAGS:
      # The Abseil flags library prints the ProgramUsageMessage() with
      # --help and returns 1.
@ -144,7 +136,7 @@ class GTestHelpTest(gtest_test_utils.TestCase):

    self.assertTrue(HELP_REGEX.search(output), output)

-    if IS_DARWIN or IS_LINUX or IS_GNUHURD or is_bsd_based_os():
+    if IS_DARWIN or IS_LINUX or IS_GNUHURD or IS_GNUKFREEBSD or IS_OPENBSD:
      self.assertIn(STREAM_RESULT_TO_FLAG, output)
    else:
      self.assertNotIn(STREAM_RESULT_TO_FLAG, output)
@ -154,27 +146,53 @@ class GTestHelpTest(gtest_test_utils.TestCase):
    else:
      self.assertNotIn(DEATH_TEST_STYLE_FLAG, output)

-  def test_runs_tests_without_help_flag(self):
+  def TestUnknownFlagWithAbseil(self, flag):
+    """Verifies correct behavior when an unknown flag is specified.
+
+    The right message must be printed and the tests must
+    skipped when the given flag is specified.
+
+    Args:
+      flag:  A flag to pass to the binary or None.
+    """
+    exit_code, output = RunWithFlag(flag)
+    self.assertEqual(1, exit_code)
+    self.assertIn('ERROR: Unknown command line flag', output)
+
+  def TestNonHelpFlag(self, flag):
+    """Verifies correct behavior when no help flag is specified.
+
+    Verifies that when no help flag is specified, the tests are run
+    and the help message is not printed.
+
+    Args:
+      flag:  A flag to pass to the binary or None.
+    """
+
+    exit_code, output = RunWithFlag(flag)
+    self.assertNotEqual(exit_code, 0)
+    self.assertFalse(HELP_REGEX.search(output), output)
+
+  def testPrintsHelpWithFullFlag(self):
+    self.TestHelpFlag('--help')
+
+  def testRunsTestsWithoutHelpFlag(self):
    """Verifies correct behavior when no help flag is specified.

    Verifies that when no help flag is specified, the tests are run
    and the help message is not printed.
    """

-    exit_code, output = run_with_flag(None)
-    self.assertNotEqual(exit_code, 0)
-    self.assertFalse(HELP_REGEX.search(output), output)
+    self.TestNonHelpFlag(None)

-  def test_runs_tests_with_gtest_internal_flag(self):
+  def testRunsTestsWithGtestInternalFlag(self):
    """Verifies correct behavior when internal testing flag is specified.

    Verifies that the tests are run and no help message is printed when
    a flag starting with Google Test prefix and 'internal_' is supplied.
    """

-    exit_code, output = run_with_flag(INTERNAL_FLAG_FOR_TESTING)
-    self.assertNotEqual(exit_code, 0)
-    self.assertFalse(HELP_REGEX.search(output), output)
+    self.TestNonHelpFlag(INTERNAL_FLAG_FOR_TESTING)


 if __name__ == '__main__':
--- a/googletest/test/gtest_json_test_utils.py
+++ b/googletest/test/gtest_json_test_utils.py
@ -51,9 +51,6 @@ def normalize(obj):
    elif key == 'failure':
      value = re.sub(r'^.*[/\\](.*:)\d+\n', '\\1*\n', value)
      return re.sub(r'Stack trace:\n(.|\n)*', 'Stack trace:\n*', value)
-    elif key == 'message':
-      value = re.sub(r'^.*[/\\](.*:)\d+\n', '\\1*\n', value)
-      return re.sub(r'Stack trace:\n(.|\n)*', 'Stack trace:\n*', value)
    elif key == 'file':
      return re.sub(r'^.*[/\\](.*)', '\\1', value)
    else:
--- a/googletest/test/gtest_repeat_test.cc
+++ b/googletest/test/gtest_repeat_test.cc
@ -61,6 +61,7 @@ int g_environment_tear_down_count = 0;

 class MyEnvironment : public testing::Environment {
 public:
+  MyEnvironment() = default;
  void SetUp() override { g_environment_set_up_count++; }
  void TearDown() override { g_environment_tear_down_count++; }
 };
@ -116,7 +117,6 @@ void ResetCounts() {
  g_should_pass_count = 0;
  g_death_test_count = 0;
  g_param_test_count = 0;
-  testing::AddGlobalTestEnvironment(new MyEnvironment);
 }

 // Checks that the count for each test is expected.
@ -197,6 +197,8 @@ void TestRepeatWithFilterForFailedTests(int repeat) {
 int main(int argc, char **argv) {
  testing::InitGoogleTest(&argc, argv);

+  testing::AddGlobalTestEnvironment(new MyEnvironment);
+
  TestRepeatUnspecified();
  TestRepeat(0);
  TestRepeat(1);
--- a/googletest/test/gtest_stress_test.cc
+++ b/googletest/test/gtest_stress_test.cc
@ -95,9 +95,9 @@ void ManyAsserts(int id) {

    // RecordProperty() should interact safely with other threads as well.
    // The shared_key forces property updates.
-    Test::RecordProperty(IdToKey(id, "string"), IdToString(id));
+    Test::RecordProperty(IdToKey(id, "string").c_str(), IdToString(id).c_str());
    Test::RecordProperty(IdToKey(id, "int").c_str(), id);
-    Test::RecordProperty("shared_key", IdToString(id));
+    Test::RecordProperty("shared_key", IdToString(id).c_str());

    // This assertion should fail kThreadCount times per thread.  It
    // is for testing whether Google Test can handle failed assertions in a
--- a/Show More
+++ b/Show More