Update googletest
Been a while since we'd done that.
Change-Id: Ia5c71ca9df0bcd951f2a4f165b736e7350b2f2af
Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/76767
Auto-Submit: David Benjamin <davidben@google.com>
Commit-Queue: Adam Langley <agl@google.com>
Reviewed-by: Adam Langley <agl@google.com>
diff --git a/third_party/googletest/.github/workflows/gtest-ci.yml b/third_party/googletest/.github/workflows/gtest-ci.yml
deleted file mode 100644
index 03a8cc5..0000000
--- a/third_party/googletest/.github/workflows/gtest-ci.yml
+++ /dev/null
@@ -1,43 +0,0 @@
-name: ci
-
-on:
- push:
- pull_request:
-
-env:
- BAZEL_CXXOPTS: -std=c++14
-
-jobs:
- Linux:
- runs-on: ubuntu-latest
- steps:
-
- - uses: actions/checkout@v3
- with:
- fetch-depth: 0
-
- - name: Tests
- run: bazel test --cxxopt=-std=c++14 --features=external_include_paths --test_output=errors ...
-
- macOS:
- runs-on: macos-latest
- steps:
-
- - uses: actions/checkout@v3
- with:
- fetch-depth: 0
-
- - name: Tests
- run: bazel test --cxxopt=-std=c++14 --features=external_include_paths --test_output=errors ...
-
-
- Windows:
- runs-on: windows-latest
- steps:
-
- - uses: actions/checkout@v3
- with:
- fetch-depth: 0
-
- - name: Tests
- run: bazel test --cxxopt=/std:c++14 --features=external_include_paths --test_output=errors ...
diff --git a/third_party/googletest/.gitignore b/third_party/googletest/.gitignore
index fede02f..f0df39d 100644
--- a/third_party/googletest/.gitignore
+++ b/third_party/googletest/.gitignore
@@ -8,6 +8,7 @@
bazel-googletest
bazel-out
bazel-testlogs
+MODULE.bazel.lock
# python
*.pyc
diff --git a/third_party/googletest/BUILD.bazel b/third_party/googletest/BUILD.bazel
index b1e3b7f..0306468 100644
--- a/third_party/googletest/BUILD.bazel
+++ b/third_party/googletest/BUILD.bazel
@@ -56,6 +56,12 @@
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 = {
@@ -132,19 +138,30 @@
}),
deps = select({
":has_absl": [
- "@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",
+ "@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",
+ "@abseil-cpp//absl/types:any",
+ "@abseil-cpp//absl/types:optional",
+ "@abseil-cpp//absl/types:variant",
+ "@re2//:re2",
+ ],
+ "//conditions:default": [],
+ }) + select({
+ # `gtest-death-test.cc` has `EXPECT_DEATH` that spawns a process,
+ # expects it to crash and inspects its logs with the given matcher,
+ # so that's why these libraries are needed.
+ # Otherwise, builds targeting Fuchsia would fail to compile.
+ ":fuchsia": [
+ "@fuchsia_sdk//pkg/fdio",
+ "@fuchsia_sdk//pkg/syslog",
+ "@fuchsia_sdk//pkg/zx",
],
"//conditions:default": [],
}),
diff --git a/third_party/googletest/CMakeLists.txt b/third_party/googletest/CMakeLists.txt
index 089ac98..c784f3c 100644
--- a/third_party/googletest/CMakeLists.txt
+++ b/third_party/googletest/CMakeLists.txt
@@ -1,10 +1,10 @@
# Note: CMake support is community-based. The maintainers do not use CMake
# internally.
-cmake_minimum_required(VERSION 3.13)
+cmake_minimum_required(VERSION 3.16)
project(googletest-distribution)
-set(GOOGLETEST_VERSION 1.14.0)
+set(GOOGLETEST_VERSION 1.16.0)
if(NOT CYGWIN AND NOT MSYS AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL QNX)
set(CMAKE_CXX_EXTENSIONS OFF)
@@ -15,11 +15,20 @@
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()
diff --git a/third_party/googletest/CONTRIBUTORS b/third_party/googletest/CONTRIBUTORS
index 77397a5..ccea41e 100644
--- a/third_party/googletest/CONTRIBUTORS
+++ b/third_party/googletest/CONTRIBUTORS
@@ -55,6 +55,7 @@
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>
diff --git a/third_party/googletest/METADATA b/third_party/googletest/METADATA
index 0766f88..7679179 100644
--- a/third_party/googletest/METADATA
+++ b/third_party/googletest/METADATA
@@ -6,6 +6,6 @@
type: HOMEPAGE
value: "https://github.com/google/googletest"
}
- version: "8a6feabf04bec8fb125e0df0ad1195c42350725f"
- last_upgrade_date { year: 2023 month: 9 day: 1 }
+ version: "54501746a6cfd366b6e7bab3c902e0f8d5826521"
+ last_upgrade_date { year: 2025 month: 2 day: 24 }
}
diff --git a/third_party/googletest/MODULE.bazel b/third_party/googletest/MODULE.bazel
new file mode 100644
index 0000000..66eee54
--- /dev/null
+++ b/third_party/googletest/MODULE.bazel
@@ -0,0 +1,76 @@
+# 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 = "20250127.0",
+)
+bazel_dep(
+ name = "platforms",
+ version = "0.0.10",
+)
+bazel_dep(
+ name = "re2",
+ version = "2024-07-02",
+)
+
+bazel_dep(
+ name = "rules_python",
+ version = "1.1.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")
diff --git a/third_party/googletest/README.md b/third_party/googletest/README.md
index c1c1446..2a2a722 100644
--- a/third_party/googletest/README.md
+++ b/third_party/googletest/README.md
@@ -9,7 +9,7 @@
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.14.0`).
+`v${major}.${minor}.${patch}` (e.g. `v1.16.0`).
#### Documentation Updates
@@ -17,25 +17,24 @@
https://google.github.io/googletest/. We recommend browsing the documentation on
GitHub Pages rather than directly in the repository.
-#### Release 1.14.0
+#### Release 1.16.0
-[Release 1.14.0](https://github.com/google/googletest/releases/tag/v1.14.0) is
+[Release 1.16.0](https://github.com/google/googletest/releases/tag/v1.16.0) is
now available.
-The 1.14.x branch requires at least C++14.
+The 1.16.x branch requires at least C++14.
+
+The 1.16.x branch will be the last to support C++14. Future development will
+[require at least C++17](https://opensource.google/documentation/policies/cplusplus-support#c_language_standard).
#### Continuous Integration
-We use Google's internal systems for continuous integration. \
-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.
+We use Google's internal systems for continuous integration.
#### 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!
diff --git a/third_party/googletest/WORKSPACE b/third_party/googletest/WORKSPACE
index f819ffe..4c76102 100644
--- a/third_party/googletest/WORKSPACE
+++ b/third_party/googletest/WORKSPACE
@@ -1,4 +1,34 @@
-workspace(name = "com_google_googletest")
+# Copyright 2024 Google Inc.
+# All Rights Reserved.
+#
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+# * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+workspace(name = "googletest")
load("//:googletest_deps.bzl", "googletest_deps")
googletest_deps()
@@ -6,22 +36,26 @@
load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
http_archive(
- 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"],
+ name = "rules_python",
+ sha256 = "9c6e26911a79fbf510a8f06d8eedb40f412023cf7fa6d1461def27116bff022c",
+ strip_prefix = "rules_python-1.1.0",
+ url = "https://github.com/bazelbuild/rules_python/releases/download/1.1.0/rules_python-1.1.0.tar.gz",
+)
+# https://github.com/bazelbuild/rules_python/releases/tag/1.1.0
+load("@rules_python//python:repositories.bzl", "py_repositories")
+py_repositories()
+
+http_archive(
+ name = "bazel_skylib",
+ sha256 = "cd55a062e763b9349921f0f5db8c3933288dc8ba4f76dd9416aac68acee3cb94",
+ urls = ["https://github.com/bazelbuild/bazel-skylib/releases/download/1.5.0/bazel-skylib-1.5.0.tar.gz"],
)
http_archive(
- 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"],
-)
-
-http_archive(
- name = "platforms", # 2023-07-28T19:44:27Z
- sha256 = "40eb313613ff00a5c03eed20aba58890046f4d38dec7344f00bb9a8867853526",
- strip_prefix = "platforms-4ad40ef271da8176d4fc0194d2089b8a76e19d7b",
- urls = ["https://github.com/bazelbuild/platforms/archive/4ad40ef271da8176d4fc0194d2089b8a76e19d7b.zip"],
+ name = "platforms",
+ urls = [
+ "https://mirror.bazel.build/github.com/bazelbuild/platforms/releases/download/0.0.10/platforms-0.0.10.tar.gz",
+ "https://github.com/bazelbuild/platforms/releases/download/0.0.10/platforms-0.0.10.tar.gz",
+ ],
+ sha256 = "218efe8ee736d26a3572663b374a253c012b716d8af0c07e842e82f238a0a7ee",
)
diff --git a/third_party/googletest/WORKSPACE.bzlmod b/third_party/googletest/WORKSPACE.bzlmod
new file mode 100644
index 0000000..381432c
--- /dev/null
+++ b/third_party/googletest/WORKSPACE.bzlmod
@@ -0,0 +1,35 @@
+# Copyright 2024 Google Inc.
+# All Rights Reserved.
+#
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+# * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# https://bazel.build/external/migration#workspace.bzlmod
+#
+# This file is intentionally empty. When bzlmod is enabled and this
+# file exists, the content of WORKSPACE is ignored. This prevents
+# bzlmod builds from unintentionally depending on the WORKSPACE file.
diff --git a/third_party/googletest/ci/linux-presubmit.sh b/third_party/googletest/ci/linux-presubmit.sh
index a1caa27..6491e79 100644
--- a/third_party/googletest/ci/linux-presubmit.sh
+++ b/third_party/googletest/ci/linux-presubmit.sh
@@ -31,39 +31,59 @@
set -euox pipefail
-readonly LINUX_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest:20230816"
-readonly LINUX_GCC_FLOOR_CONTAINER="gcr.io/google.com/absl-177019/linux_gcc-floor:20230120"
+readonly LINUX_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest:20241218"
+readonly LINUX_GCC_FLOOR_CONTAINER="gcr.io/google.com/absl-177019/linux_gcc-floor:20250205"
if [[ -z ${GTEST_ROOT:-} ]]; then
GTEST_ROOT="$(realpath $(dirname ${0})/..)"
fi
if [[ -z ${STD:-} ]]; then
- STD="c++14 c++17 c++20"
+ STD="c++17 c++20"
fi
-# 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
+# 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"
done
# Do one test with an older version of GCC
@@ -72,7 +92,7 @@
--workdir="/src" \
--rm \
--env="CC=/usr/local/bin/gcc" \
- --env="BAZEL_CXXOPTS=-std=c++14" \
+ --env="BAZEL_CXXOPTS=-std=c++17" \
${LINUX_GCC_FLOOR_CONTAINER} \
/usr/local/bin/bazel test ... \
--copt="-Wall" \
@@ -80,7 +100,7 @@
--copt="-Wuninitialized" \
--copt="-Wundef" \
--copt="-Wno-error=pragmas" \
- --distdir="/bazel-distdir" \
+ --enable_bzlmod=false \
--features=external_include_paths \
--keep_going \
--show_timestamps \
@@ -102,7 +122,7 @@
--copt="-Wuninitialized" \
--copt="-Wundef" \
--define="absl=${absl}" \
- --distdir="/bazel-distdir" \
+ --enable_bzlmod=true \
--features=external_include_paths \
--keep_going \
--show_timestamps \
@@ -127,7 +147,7 @@
--copt="-Wuninitialized" \
--copt="-Wundef" \
--define="absl=${absl}" \
- --distdir="/bazel-distdir" \
+ --enable_bzlmod=true \
--features=external_include_paths \
--keep_going \
--linkopt="--gcc-toolchain=/usr/local" \
diff --git a/third_party/googletest/ci/macos-presubmit.sh b/third_party/googletest/ci/macos-presubmit.sh
index 681ebc2..5370ed6 100644
--- a/third_party/googletest/ci/macos-presubmit.sh
+++ b/third_party/googletest/ci/macos-presubmit.sh
@@ -31,6 +31,9 @@
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
@@ -40,20 +43,20 @@
BUILD_DIR=$(mktemp -d build_dir.XXXXXXXX)
cd ${BUILD_DIR}
time cmake ${GTEST_ROOT} \
- -DCMAKE_CXX_STANDARD=14 \
+ -DCMAKE_CXX_STANDARD=17 \
-Dgtest_build_samples=ON \
-Dgtest_build_tests=ON \
-Dgmock_build_tests=ON \
-Dcxx_no_exception=${cmake_off_on} \
-Dcxx_no_rtti=${cmake_off_on}
- time make
+ time make -j$(nproc)
time ctest -j$(nproc) --output-on-failure
done
# Test the Bazel build
# If we are running on Kokoro, check for a versioned Bazel binary.
-KOKORO_GFILE_BAZEL_BIN="bazel-5.1.1-darwin-x86_64"
+KOKORO_GFILE_BAZEL_BIN="bazel-8.0.0-darwin-x86_64"
if [[ ${KOKORO_GFILE_DIR:-} ]] && [[ -f ${KOKORO_GFILE_DIR}/${KOKORO_GFILE_BAZEL_BIN} ]]; then
BAZEL_BIN="${KOKORO_GFILE_DIR}/${KOKORO_GFILE_BAZEL_BIN}"
chmod +x ${BAZEL_BIN}
@@ -67,8 +70,9 @@
--copt="-Wall" \
--copt="-Werror" \
--copt="-Wundef" \
- --cxxopt="-std=c++14" \
+ --cxxopt="-std=c++17" \
--define="absl=${absl}" \
+ --enable_bzlmod=true \
--features=external_include_paths \
--keep_going \
--show_timestamps \
diff --git a/third_party/googletest/ci/windows-presubmit.bat b/third_party/googletest/ci/windows-presubmit.bat
index 48962eb..e2664c5 100644
--- a/third_party/googletest/ci/windows-presubmit.bat
+++ b/third_party/googletest/ci/windows-presubmit.bat
@@ -1,6 +1,6 @@
SETLOCAL ENABLEDELAYEDEXPANSION
-SET BAZEL_EXE=%KOKORO_GFILE_DIR%\bazel-5.1.1-windows-x86_64.exe
+SET BAZEL_EXE=%KOKORO_GFILE_DIR%\bazel-8.0.0-windows-x86_64.exe
SET PATH=C:\Python34;%PATH%
SET BAZEL_PYTHON=C:\python34\python.exe
@@ -11,21 +11,18 @@
SET CMAKE_BUILD_PARALLEL_LEVEL=16
SET CTEST_PARALLEL_LEVEL=16
-IF EXIST git\googletest (
- CD git\googletest
-) ELSE IF EXIST github\googletest (
- CD github\googletest
-)
-
+SET GTEST_ROOT=%~dp0\..
IF %errorlevel% neq 0 EXIT /B 1
:: ----------------------------------------------------------------------------
:: CMake
-MKDIR cmake_msvc2022
-CD cmake_msvc2022
+SET CMAKE_BUILD_PATH=cmake_msvc2022
+MKDIR %CMAKE_BUILD_PATH%
+CD %CMAKE_BUILD_PATH%
-%CMAKE_BIN% .. ^
+%CMAKE_BIN% %GTEST_ROOT% ^
-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 ^
@@ -40,18 +37,38 @@
%CTEST_BIN% -C Debug --timeout 600
IF %errorlevel% neq 0 EXIT /B 1
-CD ..
-RMDIR /S /Q cmake_msvc2022
+CD %GTEST_ROOT%
+RMDIR /S /Q %CMAKE_BUILD_PATH%
:: ----------------------------------------------------------------------------
:: 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
-%BAZEL_EXE% test ... ^
+
+:: C++17
+%BAZEL_EXE% ^
+ --output_user_root=C:\tmp ^
+ test ... ^
--compilation_mode=dbg ^
- --copt=/std:c++14 ^
+ --copt=/std:c++17 ^
--copt=/WX ^
- --features=external_include_paths ^
+ --enable_bzlmod=true ^
+ --keep_going ^
+ --test_output=errors ^
+ --test_tag_filters=-no_test_msvc2017
+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
diff --git a/third_party/googletest/docs/advanced.md b/third_party/googletest/docs/advanced.md
index 0e1f812..9b1220a 100644
--- a/third_party/googletest/docs/advanced.md
+++ b/third_party/googletest/docs/advanced.md
@@ -286,7 +286,7 @@
```c++
TEST(SkipTest, DoesSkip) {
GTEST_SKIP() << "Skipping single test";
- EXPECT_EQ(0, 1); // Won't fail; it won't be executed
+ FAIL(); // Won't fail; it won't be executed
}
class SkipFixture : public ::testing::Test {
@@ -298,7 +298,7 @@
// Tests for SkipFixture won't be executed.
TEST_F(SkipFixture, SkipsOneTest) {
- EXPECT_EQ(5, 7); // Won't fail
+ FAIL(); // Won't fail; it won't be executed
}
```
@@ -405,6 +405,51 @@
For more details regarding `AbslStringify()` and its integration with other
libraries, see go/abslstringify.
+## Regular Expression Syntax
+
+When built with Bazel and using Abseil, GoogleTest uses the
+[RE2](https://github.com/google/re2/wiki/Syntax) syntax. Otherwise, for POSIX
+systems (Linux, Cygwin, Mac), GoogleTest uses the
+[POSIX extended regular expression](https://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap09.html#tag_09_04)
+syntax. To learn about POSIX syntax, you may want to read this
+[Wikipedia entry](https://en.wikipedia.org/wiki/Regular_expression#POSIX_extended).
+
+On Windows, GoogleTest uses its own simple regular expression implementation. It
+lacks many features. For example, we don't support union (`"x|y"`), grouping
+(`"(xy)"`), brackets (`"[xy]"`), and repetition count (`"x{5,7}"`), among
+others. Below is what we do support (`A` denotes a literal character, period
+(`.`), or a single `\\ ` escape sequence; `x` and `y` denote regular
+expressions.):
+
+Expression | Meaning
+---------- | --------------------------------------------------------------
+`c` | matches any literal character `c`
+`\\d` | matches any decimal digit
+`\\D` | matches any character that's not a decimal digit
+`\\f` | matches `\f`
+`\\n` | matches `\n`
+`\\r` | matches `\r`
+`\\s` | matches any ASCII whitespace, including `\n`
+`\\S` | matches any character that's not a whitespace
+`\\t` | matches `\t`
+`\\v` | matches `\v`
+`\\w` | matches any letter, `_`, or decimal digit
+`\\W` | matches any character that `\\w` doesn't match
+`\\c` | matches any literal character `c`, which must be a punctuation
+`.` | matches any single character except `\n`
+`A?` | matches 0 or 1 occurrences of `A`
+`A*` | matches 0 or many occurrences of `A`
+`A+` | matches 1 or many occurrences of `A`
+`^` | matches the beginning of a string (not that of each line)
+`$` | matches the end of a string (not that of each line)
+`xy` | matches `x` followed by `y`
+
+To help you determine which capability is available on your system, GoogleTest
+defines macros to govern which regular expression it is using. The macros are:
+`GTEST_USES_SIMPLE_RE=1` or `GTEST_USES_POSIX_RE=1`. If you want your death
+tests to work in all cases, you can either `#if` on these macros or use the more
+limited syntax only.
+
## Death Tests
In many applications, there are assertions that can cause application failure if
@@ -416,7 +461,7 @@
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"
@@ -462,6 +507,12 @@
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.
@@ -503,51 +554,6 @@
}
```
-### 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://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](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.
-
### How It Works
See [Death Assertions](reference/assertions.md#death) in the Assertions
@@ -727,7 +733,7 @@
### 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++
@@ -1004,11 +1010,21 @@
Environment* AddGlobalTestEnvironment(Environment* env);
```
-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.
+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.
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
@@ -1804,7 +1820,7 @@
`::testing::InitGoogleTest()` before calling `RUN_ALL_TESTS()`.
To see a list of supported flags and their usage, please run your test program
-with the `--help` flag. You can also use `-h`, `-?`, or `/?` for short.
+with the `--help` flag.
If an option is specified both by an environment variable and by a flag, the
latter takes precedence.
@@ -1913,6 +1929,20 @@
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.
+
### Repeating the Tests
Once in a while you'll run into a test whose result is hit-or-miss. Perhaps it
@@ -2372,7 +2402,7 @@
#### 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
diff --git a/third_party/googletest/docs/faq.md b/third_party/googletest/docs/faq.md
index 90c2497..c7d10b5 100644
--- a/third_party/googletest/docs/faq.md
+++ b/third_party/googletest/docs/faq.md
@@ -3,7 +3,7 @@
## Why should test suite names and test names not contain underscore?
{: .callout .note}
-Note: GoogleTest reserves underscore (`_`) for special purpose keywords, such as
+Note: GoogleTest reserves underscore (`_`) for special-purpose keywords, such as
[the `DISABLED_` prefix](advanced.md#temporarily-disabling-tests), in addition
to the following rationale.
@@ -33,9 +33,9 @@
`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,30 +128,9 @@
differences between the two tools. Once you have some concrete experience, you
can much more easily decide which one to use the next time.
-## I got some run-time errors about invalid proto descriptors when using `ProtocolMessageEquals`. Help!
-
-{: .callout .note}
-**Note:** `ProtocolMessageEquals` and `ProtocolMessageEquiv` are *deprecated*
-now. Please use `EqualsProto`, etc instead.
-
-`ProtocolMessageEquals` and `ProtocolMessageEquiv` were redefined recently and
-are now less tolerant of invalid protocol buffer definitions. In particular, if
-you have a `foo.proto` that doesn't fully qualify the type of a protocol message
-it references (e.g. `message<Bar>` where it should be `message<blah.Bar>`), you
-will now get run-time errors like:
-
-```
-... descriptor.cc:...] Invalid proto descriptor for file "path/to/foo.proto":
-... descriptor.cc:...] blah.MyMessage.my_field: ".Bar" is not defined.
-```
-
-If you see this, your `.proto` file is broken and needs to be fixed by making
-the types fully qualified. The new definition of `ProtocolMessageEquals` and
-`ProtocolMessageEquiv` just happen to reveal your bug.
-
## My death test modifies some state, but the change seems lost after the death test finishes. Why?
-Death tests (`EXPECT_DEATH`, etc) are executed in a sub-process s.t. the
+Death tests (`EXPECT_DEATH`, etc.) are executed in a sub-process s.t. the
expected crash won't kill the test program (i.e. the parent process). As a
result, any in-memory side effects they incur are observable in their respective
sub-processes, but not in the parent process. You can think of them as running
@@ -192,16 +171,16 @@
};
```
-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
@@ -311,7 +290,7 @@
call `TearDown()`, and then delete the test fixture object.
When you need to write per-test set-up and tear-down logic, you have the choice
-between using the test fixture constructor/destructor or `SetUp()/TearDown()`.
+between using the test fixture constructor/destructor or `SetUp()`/`TearDown()`.
The former is usually preferred, as it has the following benefits:
* By initializing a member variable in the constructor, we have the option to
@@ -352,7 +331,7 @@
GoogleTest assertions in a destructor if your code could run on such a
platform.
-## The compiler complains "no matching function to call" when I use ASSERT_PRED*. How do I fix it?
+## The compiler complains "no matching function to call" when I use `ASSERT_PRED*`. How do I fix it?
See details for [`EXPECT_PRED*`](reference/assertions.md#EXPECT_PRED) in the
Assertions Reference.
@@ -410,7 +389,7 @@
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
@@ -545,7 +524,7 @@
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?
+## Why does GoogleTest require the entire test suite, instead of individual tests, to be named `*DeathTest` when it uses `ASSERT_DEATH`?
GoogleTest does not interleave tests from different test suites. That is, it
runs all tests in one test suite first, and then runs all tests in the next test
@@ -570,7 +549,7 @@
`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
@@ -654,7 +633,7 @@
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++
diff --git a/third_party/googletest/docs/gmock_cook_book.md b/third_party/googletest/docs/gmock_cook_book.md
index da10918..633dbc3 100644
--- a/third_party/googletest/docs/gmock_cook_book.md
+++ b/third_party/googletest/docs/gmock_cook_book.md
@@ -177,7 +177,7 @@
template <typename Elem>
class MockStack : public StackInterface<Elem> {
...
- MOCK_METHOD(int, GetSize, (), (override));
+ MOCK_METHOD(int, GetSize, (), (const, override));
MOCK_METHOD(void, Push, (const Elem& x), (override));
};
```
@@ -936,8 +936,8 @@
floating-point numbers), the conversion from `T` to `U` is not lossy (in
other words, any value representable by `T` can also be represented by `U`);
and
-3. When `U` is a reference, `T` must also be a reference (as the underlying
- matcher may be interested in the address of the `U` value).
+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).
The code won't compile if any of these conditions isn't met.
@@ -1927,6 +1927,12 @@
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
@@ -3306,7 +3312,7 @@
case gMock will use the sequence of words in the matcher name as the
description.
-For example:
+#### Basic Example
```cpp
MATCHER(IsDivisibleBy7, "") { return (arg % 7) == 0; }
@@ -3344,6 +3350,8 @@
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:
@@ -3377,21 +3385,48 @@
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.
-{: .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.
+#### 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.
### Writing New Parameterized Matchers Quickly
diff --git a/third_party/googletest/docs/gmock_for_dummies.md b/third_party/googletest/docs/gmock_for_dummies.md
index 9f24dca..ed2297c 100644
--- a/third_party/googletest/docs/gmock_for_dummies.md
+++ b/third_party/googletest/docs/gmock_for_dummies.md
@@ -261,6 +261,8 @@
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
diff --git a/third_party/googletest/docs/primer.md b/third_party/googletest/docs/primer.md
index 4901e1a..69d6c6d 100644
--- a/third_party/googletest/docs/primer.md
+++ b/third_party/googletest/docs/primer.md
@@ -73,8 +73,8 @@
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/search/test%20case
-[istqb test suite]: https://glossary.istqb.org/en/search/test%20suite
+[istqb test case]: https://glossary.istqb.org/en_US/term/test-case
+[istqb test suite]: https://glossary.istqb.org/en_US/term/test-suite
## Basic Concepts
@@ -210,7 +210,7 @@
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 @@
`FooTest` where `Foo` is the class being tested.
```c++
-class QueueTest : public ::testing::Test {
+class QueueTest : public testing::Test {
protected:
- void SetUp() override {
+ QueueTest() {
// q0_ remains empty
q1_.Enqueue(1);
q2_.Enqueue(2);
q2_.Enqueue(3);
}
- // void TearDown() override {}
+ // ~QueueTest() override = default;
Queue<int> q0_;
Queue<int> q1_;
@@ -288,8 +288,9 @@
};
```
-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.
+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.
Now we'll write tests using `TEST_F()` and this fixture.
@@ -326,11 +327,9 @@
When these tests run, the following happens:
1. GoogleTest constructs a `QueueTest` object (let's call it `t1`).
-2. `t1.SetUp()` initializes `t1`.
-3. The first test (`IsEmptyInitially`) runs on `t1`.
-4. `t1.TearDown()` cleans up after the test finishes.
-5. `t1` is destructed.
-6. The above steps are repeated on another `QueueTest` object, this time
+2. The first test (`IsEmptyInitially`) runs on `t1`.
+3. `t1` is destructed.
+4. The above steps are repeated on another `QueueTest` object, this time
running the `DequeueWorks` test.
**Availability**: Linux, Windows, Mac.
@@ -402,7 +401,7 @@
namespace {
// The fixture for testing class Foo.
-class FooTest : public ::testing::Test {
+class FooTest : public testing::Test {
protected:
// You can remove any or all of the following functions if their bodies would
// be empty.
@@ -450,14 +449,14 @@
} // 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.
diff --git a/third_party/googletest/docs/quickstart-bazel.md b/third_party/googletest/docs/quickstart-bazel.md
index 4f693db..5750f02 100644
--- a/third_party/googletest/docs/quickstart-bazel.md
+++ b/third_party/googletest/docs/quickstart-bazel.md
@@ -10,8 +10,8 @@
* A compatible operating system (e.g. Linux, macOS, Windows).
* A compatible C++ compiler that supports at least C++14.
-* [Bazel](https://bazel.build/), the preferred build system used by the
- GoogleTest team.
+* [Bazel](https://bazel.build/) 7.0 or higher, 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 @@
[Bazel workspace](https://docs.bazel.build/versions/main/build-ref.html#workspace)
is a directory on your filesystem that you use to manage source files for the
software you want to build. Each workspace directory has a text file named
-`WORKSPACE` which may be empty, or may contain references to external
+`MODULE.bazel` which may be empty, or may contain references to external
dependencies required to build the outputs.
First, create a directory for your workspace:
@@ -37,30 +37,20 @@
$ mkdir my_workspace && cd my_workspace
```
-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:
+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:
```
-load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+# MODULE.bazel
-http_archive(
- name = "com_google_googletest",
- urls = ["https://github.com/google/googletest/archive/5ab508a01f9eb089207ee87fd547d290da39d015.zip"],
- strip_prefix = "googletest-5ab508a01f9eb089207ee87fd547d290da39d015",
-)
+# Choose the most recent version available at
+# https://registry.bazel.build/modules/googletest
+bazel_dep(name = "googletest", version = "1.15.2")
```
-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
@@ -92,17 +82,20 @@
```
cc_test(
- name = "hello_test",
- size = "small",
- srcs = ["hello_test.cc"],
- deps = ["@com_google_googletest//:gtest_main"],
+ name = "hello_test",
+ size = "small",
+ srcs = ["hello_test.cc"],
+ deps = [
+ "@googletest//:gtest",
+ "@googletest//:gtest_main",
+ ],
)
```
This `cc_test` rule declares the C++ test binary you want to build, and links to
-GoogleTest (`//:gtest_main`) using the prefix you specified in the `WORKSPACE`
-file (`@com_google_googletest`). For more information about Bazel `BUILD` files,
-see the
+the GoogleTest library (`@googletest//:gtest"`) and the GoogleTest `main()`
+function (`@googletest//:gtest_main`). For more information about Bazel `BUILD`
+files, see the
[Bazel C++ Tutorial](https://docs.bazel.build/versions/main/tutorial/cpp.html).
{: .callout .note}
@@ -115,7 +108,7 @@
Now you can build and run your test:
<pre>
-<strong>my_workspace$ bazel test --cxxopt=-std=c++14 --test_output=all //:hello_test</strong>
+<strong>$ 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:
diff --git a/third_party/googletest/docs/reference/actions.md b/third_party/googletest/docs/reference/actions.md
index ab81a12..0ebdc1e 100644
--- a/third_party/googletest/docs/reference/actions.md
+++ b/third_party/googletest/docs/reference/actions.md
@@ -24,7 +24,8 @@
| :--------------------------------- | :-------------------------------------- |
| `Assign(&variable, value)` | Assign `value` to variable. |
| `DeleteArg<N>()` | Delete the `N`-th (0-based) argument, which must be a pointer. |
-| `SaveArg<N>(pointer)` | Save the `N`-th (0-based) argument to `*pointer`. |
+| `SaveArg<N>(pointer)` | Save the `N`-th (0-based) argument to `*pointer` by copy-assignment. |
+| `SaveArgByMove<N>(pointer)` | Save the `N`-th (0-based) argument to `*pointer` by move-assignment. |
| `SaveArgPointee<N>(pointer)` | Save the value pointed to by the `N`-th (0-based) argument to `*pointer`. |
| `SetArgReferee<N>(value)` | Assign `value` to the variable referenced by the `N`-th (0-based) argument. |
| `SetArgPointee<N>(value)` | Assign `value` to the variable pointed by the `N`-th (0-based) argument. |
diff --git a/third_party/googletest/docs/reference/assertions.md b/third_party/googletest/docs/reference/assertions.md
index 492ff5e..eeec4a0 100644
--- a/third_party/googletest/docs/reference/assertions.md
+++ b/third_party/googletest/docs/reference/assertions.md
@@ -276,7 +276,8 @@
`ASSERT_FLOAT_EQ(`*`val1`*`,`*`val2`*`)`
Verifies that the two `float` values *`val1`* and *`val2`* are approximately
-equal, to within 4 ULPs from each other.
+equal, to within 4 ULPs from each other. Infinity and the largest finite float
+value are considered to be one ULP apart.
### EXPECT_DOUBLE_EQ {#EXPECT_DOUBLE_EQ}
@@ -284,7 +285,8 @@
`ASSERT_DOUBLE_EQ(`*`val1`*`,`*`val2`*`)`
Verifies that the two `double` values *`val1`* and *`val2`* are approximately
-equal, to within 4 ULPs from each other.
+equal, to within 4 ULPs from each other. Infinity and the largest finite double
+value are considered to be one ULP apart.
### EXPECT_NEAR {#EXPECT_NEAR}
@@ -294,6 +296,11 @@
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,
diff --git a/third_party/googletest/docs/reference/matchers.md b/third_party/googletest/docs/reference/matchers.md
index 243e3f9..16397ef 100644
--- a/third_party/googletest/docs/reference/matchers.md
+++ b/third_party/googletest/docs/reference/matchers.md
@@ -171,6 +171,11 @@
| `Property(&class::property, m)` | `argument.property()` (or `argument->property()` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_. The method `property()` must take no argument and be declared as `const`. |
| `Property(property_name, &class::property, m)` | The same as the two-parameter version, but provides a better error message.
+{: .callout .warning}
+Warning: Don't use `Property()` against member functions that you do not own,
+because taking addresses of functions is fragile and generally not part of the
+contract of the function.
+
**Notes:**
* You can use `FieldsAre()` to match any type that supports structured
@@ -189,10 +194,6 @@
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 |
diff --git a/third_party/googletest/docs/reference/testing.md b/third_party/googletest/docs/reference/testing.md
index ead66b3..3ed5211 100644
--- a/third_party/googletest/docs/reference/testing.md
+++ b/third_party/googletest/docs/reference/testing.md
@@ -94,7 +94,8 @@
The argument *`InstantiationName`* is a unique name for the instantiation of the
test suite, to distinguish between multiple instantiations. In test output, the
instantiation name is added as a prefix to the test suite name
-*`TestSuiteName`*.
+*`TestSuiteName`*. If *`InstantiationName`* is empty
+(`INSTANTIATE_TEST_SUITE_P(, ...)`), no prefix is added.
The argument *`param_generator`* is one of the following GoogleTest-provided
functions that generate the test parameters, all defined in the `::testing`
@@ -139,6 +140,7 @@
### 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`*.
@@ -168,6 +170,22 @@
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.
@@ -277,7 +295,8 @@
The argument *`InstantiationName`* is a unique name for the instantiation of the
test suite, to distinguish between multiple instantiations. In test output, the
instantiation name is added as a prefix to the test suite name
-*`TestSuiteName`*.
+*`TestSuiteName`*. If *`InstantiationName`* is empty
+(`INSTANTIATE_TYPED_TEST_SUITE_P(, ...)`), no prefix is added.
The argument *`Types`* is a [`Types`](#Types) object representing the list of
types to run the tests on, for example:
@@ -1317,7 +1336,9 @@
Initializes GoogleTest. This must be called before calling
[`RUN_ALL_TESTS()`](#RUN_ALL_TESTS). In particular, it parses the command line
for the flags that GoogleTest recognizes. Whenever a GoogleTest flag is seen, it
-is removed from `argv`, and `*argc` is decremented.
+is removed from `argv`, and `*argc` is decremented. Keep in mind that `argv`
+must terminate with a `NULL` pointer (i.e. `argv[argc]` is `NULL`), which is
+already the case with the default `argv` passed to `main`.
No value is returned. Instead, the GoogleTest flag variables are updated.
diff --git a/third_party/googletest/fake_fuchsia_sdk.bzl b/third_party/googletest/fake_fuchsia_sdk.bzl
new file mode 100644
index 0000000..bc5b927
--- /dev/null
+++ b/third_party/googletest/fake_fuchsia_sdk.bzl
@@ -0,0 +1,61 @@
+"""Provides a fake @fuchsia_sdk implementation that's used when the real one isn't available.
+
+GoogleTest can be used with the [Fuchsia](https://fuchsia.dev/) SDK. However,
+because the Fuchsia SDK does not yet support bzlmod, GoogleTest's `MODULE.bazel`
+file by default provides a "fake" Fuchsia SDK.
+
+To override this and use the real Fuchsia SDK, you can add the following to your
+project's `MODULE.bazel` file:
+
+ fake_fuchsia_sdk_extension =
+ use_extension("@com_google_googletest//:fake_fuchsia_sdk.bzl", "fuchsia_sdk")
+ override_repo(fake_fuchsia_sdk_extension, "fuchsia_sdk")
+
+NOTE: The `override_repo` built-in is only available in Bazel 8.0 and higher.
+
+See https://github.com/google/googletest/issues/4472 for more details of why the
+fake Fuchsia SDK is needed.
+"""
+
+def _fake_fuchsia_sdk_impl(repo_ctx):
+ for stub_target in repo_ctx.attr._stub_build_targets:
+ stub_package = stub_target
+ stub_target_name = stub_target.split("/")[-1]
+ repo_ctx.file("%s/BUILD.bazel" % stub_package, """
+filegroup(
+ name = "%s",
+)
+""" % stub_target_name)
+
+fake_fuchsia_sdk = repository_rule(
+ doc = "Used to create a fake @fuchsia_sdk repository with stub build targets.",
+ implementation = _fake_fuchsia_sdk_impl,
+ attrs = {
+ "_stub_build_targets": attr.string_list(
+ doc = "The stub build targets to initialize.",
+ default = [
+ "pkg/fdio",
+ "pkg/syslog",
+ "pkg/zx",
+ ],
+ ),
+ },
+)
+
+_create_fake = tag_class()
+
+def _fuchsia_sdk_impl(module_ctx):
+ create_fake_sdk = False
+ for mod in module_ctx.modules:
+ for _ in mod.tags.create_fake:
+ create_fake_sdk = True
+
+ if create_fake_sdk:
+ fake_fuchsia_sdk(name = "fuchsia_sdk")
+
+ return module_ctx.extension_metadata(reproducible = True)
+
+fuchsia_sdk = module_extension(
+ implementation = _fuchsia_sdk_impl,
+ tag_classes = {"create_fake": _create_fake},
+)
diff --git a/third_party/googletest/googlemock/CMakeLists.txt b/third_party/googletest/googlemock/CMakeLists.txt
index a9aa072..99b2411 100644
--- a/third_party/googletest/googlemock/CMakeLists.txt
+++ b/third_party/googletest/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 @@
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,25 +60,26 @@
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_SOURCE_DIR}/include"
- # This directory is needed to build directly from Google Test sources.
- "${gtest_SOURCE_DIR}")
+ "${gtest_include_dirs}")
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)
@@ -111,7 +112,7 @@
########################################################################
#
-# Install rules
+# Install rules.
install_project(gmock gmock_main)
########################################################################
@@ -121,8 +122,8 @@
# 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)
@@ -187,7 +188,7 @@
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
diff --git a/third_party/googletest/googlemock/include/gmock/gmock-actions.h b/third_party/googletest/googlemock/include/gmock/gmock-actions.h
index f20258b..040e702 100644
--- a/third_party/googletest/googlemock/include/gmock/gmock-actions.h
+++ b/third_party/googletest/googlemock/include/gmock/gmock-actions.h
@@ -135,6 +135,7 @@
#endif
#include <algorithm>
+#include <exception>
#include <functional>
#include <memory>
#include <string>
@@ -1492,6 +1493,7 @@
// 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,
@@ -1500,6 +1502,21 @@
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<
@@ -1579,16 +1596,16 @@
: Base({}, std::forward<U>(other_actions)...),
initial_action_(std::forward<T>(initial_action)) {}
- 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>
+ // 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>
operator OnceAction<R(Args...)>() && { // NOLINT
// Return an action that first calls the initial action with arguments
// filtered through InitialActionArgType, then forwards arguments directly
@@ -1611,12 +1628,34 @@
};
}
+ // 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<
- // Both the initial action and the rest must support conversion to
- // Action.
+ 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<
std::is_convertible<const InitialAction&,
Action<void(InitialActionArgType<Args>...)>>,
std::is_convertible<const Base&, Action<R(Args...)>>>::value,
@@ -1664,8 +1703,9 @@
struct ReturnArgAction {
template <typename... Args,
typename = typename std::enable_if<(k < sizeof...(Args))>::type>
- auto operator()(Args&&... args) const -> decltype(std::get<k>(
- std::forward_as_tuple(std::forward<Args>(args)...))) {
+ auto operator()(Args&&... args) const
+ -> decltype(std::get<k>(
+ std::forward_as_tuple(std::forward<Args>(args)...))) {
return std::get<k>(std::forward_as_tuple(std::forward<Args>(args)...));
}
};
@@ -1681,6 +1721,16 @@
};
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;
@@ -1746,6 +1796,13 @@
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
@@ -2023,6 +2080,13 @@
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>
@@ -2062,13 +2126,23 @@
return {pointer};
}
-// Action Throw(exception) can be used in a mock function of any type
-// to throw the given exception. Any copyable value can be thrown.
#if GTEST_HAS_EXCEPTIONS
+// Action Throw(exception) can be used in a mock function of any type
+// to throw the given exception. Any copyable value can be thrown,
+// except for std::exception_ptr, which is likely a mistake if
+// thrown directly.
template <typename T>
-internal::ThrowAction<typename std::decay<T>::type> Throw(T&& exception) {
+typename std::enable_if<
+ !std::is_base_of<std::exception_ptr, typename std::decay<T>::type>::value,
+ internal::ThrowAction<typename std::decay<T>::type>>::type
+Throw(T&& exception) {
return {std::forward<T>(exception)};
}
+// Action Rethrow(exception_ptr) can be used in a mock function of any type
+// to rethrow any exception_ptr. Note that the same object is thrown each time.
+inline internal::RethrowAction Rethrow(std::exception_ptr exception) {
+ return {std::move(exception)};
+}
#endif // GTEST_HAS_EXCEPTIONS
namespace internal {
@@ -2117,13 +2191,13 @@
R operator()(Args&&... arg) const {
static constexpr size_t kMaxArgs =
sizeof...(Args) <= 10 ? sizeof...(Args) : 10;
- return Apply(MakeIndexSequence<kMaxArgs>{},
- MakeIndexSequence<10 - kMaxArgs>{},
+ return Apply(std::make_index_sequence<kMaxArgs>{},
+ std::make_index_sequence<10 - kMaxArgs>{},
args_type{std::forward<Args>(arg)...});
}
template <std::size_t... arg_id, std::size_t... excess_id>
- R Apply(IndexSequence<arg_id...>, IndexSequence<excess_id...>,
+ R Apply(std::index_sequence<arg_id...>, std::index_sequence<excess_id...>,
const args_type& args) const {
// Impl need not be specific to the signature of action being implemented;
// only the implementing function body needs to have all of the specific
@@ -2156,9 +2230,9 @@
}
#define GMOCK_INTERNAL_ARG_UNUSED(i, data, el) \
- , 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( \
+ , [[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( \
GMOCK_INTERNAL_ARG_UNUSED, , 10)
#define GMOCK_INTERNAL_ARG(i, data, el) , const arg##i##_type& arg##i
@@ -2223,8 +2297,8 @@
std::shared_ptr<const gmock_Impl> impl_; \
}; \
template <GMOCK_ACTION_TYPENAME_PARAMS_(params)> \
- inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name( \
- GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) GTEST_MUST_USE_RESULT_; \
+ [[nodiscard]] inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name( \
+ GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)); \
template <GMOCK_ACTION_TYPENAME_PARAMS_(params)> \
inline full_name<GMOCK_ACTION_TYPE_PARAMS_(params)> name( \
GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) { \
@@ -2259,7 +2333,7 @@
return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
}; \
}; \
- inline name##Action name() GTEST_MUST_USE_RESULT_; \
+ [[nodiscard]] inline name##Action name(); \
inline name##Action name() { return name##Action(); } \
template <typename function_type, typename return_type, typename args_type, \
GMOCK_ACTION_TEMPLATE_ARGS_NAMES_> \
diff --git a/third_party/googletest/googlemock/include/gmock/gmock-function-mocker.h b/third_party/googletest/googlemock/include/gmock/gmock-function-mocker.h
index 1a1f126..d2cb13c 100644
--- a/third_party/googletest/googlemock/include/gmock/gmock-function-mocker.h
+++ b/third_party/googletest/googlemock/include/gmock/gmock-function-mocker.h
@@ -37,6 +37,7 @@
#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_
#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_FUNCTION_MOCKER_H_
+#include <cstddef>
#include <type_traits> // IWYU pragma: keep
#include <utility> // IWYU pragma: keep
@@ -69,22 +70,22 @@
return *a == 0 || (*a == *b && internal::PrefixOf(a + 1, b + 1));
}
-template <int N, int M>
+template <size_t N, size_t M>
constexpr bool StartsWith(const char (&prefix)[N], const char (&str)[M]) {
return N <= M && internal::PrefixOf(prefix, str);
}
-template <int N, int M>
+template <size_t N, size_t M>
constexpr bool EndsWith(const char (&suffix)[N], const char (&str)[M]) {
return N <= M && internal::PrefixOf(suffix, str + M - N);
}
-template <int N, int M>
+template <size_t N, size_t M>
constexpr bool Equals(const char (&a)[N], const char (&b)[M]) {
return N == M && internal::PrefixOf(a, b);
}
-template <int N>
+template <size_t N>
constexpr bool ValidateSpec(const char (&spec)[N]) {
return internal::Equals("const", spec) ||
internal::Equals("override", spec) ||
diff --git a/third_party/googletest/googlemock/include/gmock/gmock-matchers.h b/third_party/googletest/googlemock/include/gmock/gmock-matchers.h
index 0f67713..8903c7a 100644
--- a/third_party/googletest/googlemock/include/gmock/gmock-matchers.h
+++ b/third_party/googletest/googlemock/include/gmock/gmock-matchers.h
@@ -408,13 +408,22 @@
}
private:
- class Impl : public MatcherInterface<T> {
+ // If it's possible to implicitly convert a `const T&` to U, then `Impl` can
+ // take that as input to avoid a copy. Otherwise, such as when `T` is a
+ // non-const reference type or a type explicitly constructible only from a
+ // non-const reference, then `Impl` must use `T` as-is (potentially copying).
+ using ImplArgT =
+ typename std::conditional<std::is_convertible<const T&, const U&>::value,
+ const T&, T>::type;
+
+ class Impl : public MatcherInterface<ImplArgT> {
public:
explicit Impl(const Matcher<U>& source_matcher)
: source_matcher_(source_matcher) {}
// We delegate the matching logic to the source matcher.
- bool MatchAndExplain(T x, MatchResultListener* listener) const override {
+ bool MatchAndExplain(ImplArgT x,
+ MatchResultListener* listener) const override {
using FromType = typename std::remove_cv<typename std::remove_pointer<
typename std::remove_reference<T>::type>::type>::type;
using ToType = typename std::remove_cv<typename std::remove_pointer<
@@ -431,9 +440,8 @@
// Do the cast to `U` explicitly if necessary.
// Otherwise, let implicit conversions do the trick.
- using CastType =
- typename std::conditional<std::is_convertible<T&, const U&>::value,
- T&, U>::type;
+ using CastType = typename std::conditional<
+ std::is_convertible<ImplArgT&, const U&>::value, ImplArgT&, U>::type;
return source_matcher_.MatchAndExplain(static_cast<CastType>(x),
listener);
@@ -490,12 +498,12 @@
template <typename F>
operator ::testing::Matcher<F>() const { // NOLINT(runtime/explicit)
- return Apply<F>(MakeIndexSequence<sizeof...(Ts)>{});
+ return Apply<F>(std::make_index_sequence<sizeof...(Ts)>{});
}
private:
template <typename F, std::size_t... tuple_ids>
- ::testing::Matcher<F> Apply(IndexSequence<tuple_ids...>) const {
+ ::testing::Matcher<F> Apply(std::index_sequence<tuple_ids...>) const {
return ::testing::Matcher<F>(
new typename Derived<Ts...>::template gmock_Impl<F>(
std::get<tuple_ids>(params_)...));
@@ -528,18 +536,16 @@
// safely convert a Matcher<U> to a Matcher<T> (i.e. Matcher is
// contravariant): just keep a copy of the original Matcher<U>, convert the
// argument from type T to U, and then pass it to the underlying Matcher<U>.
-// The only exception is when U is a reference and T is not, as the
+// The only exception is when U is a non-const reference and T is not, as the
// underlying Matcher<U> may be interested in the argument's address, which
-// is not preserved in the conversion from T to U.
+// cannot be preserved in the conversion from T to U (since a copy of the input
+// T argument would be required to provide a non-const reference U).
template <typename T, typename U>
inline Matcher<T> SafeMatcherCast(const Matcher<U>& matcher) {
// Enforce that T can be implicitly converted to U.
static_assert(std::is_convertible<const T&, const U&>::value,
- "T must be implicitly convertible to U");
- // Enforce that we are not converting a non-reference type T to a reference
- // type U.
- static_assert(std::is_reference<T>::value || !std::is_reference<U>::value,
- "cannot convert non reference arg to reference");
+ "T must be implicitly convertible to U (and T must be a "
+ "non-const reference if U is a non-const reference)");
// In case both T and U are arithmetic types, enforce that the
// conversion is not lossy.
typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT;
@@ -561,6 +567,11 @@
// and MUST NOT BE USED IN USER CODE!!!
namespace internal {
+// Used per go/ranked-overloads for dispatching.
+struct Rank0 {};
+struct Rank1 : Rank0 {};
+using HighestRank = Rank1;
+
// If the explanation is not empty, prints it to the ostream.
inline void PrintIfNotEmpty(const std::string& explanation,
::std::ostream* os) {
@@ -1048,7 +1059,7 @@
template <typename MatcheeStringType>
bool MatchAndExplain(const MatcheeStringType& s,
MatchResultListener* /* listener */) const {
- const StringType& s2(s);
+ const StringType s2(s);
return s2.length() >= prefix_.length() &&
s2.substr(0, prefix_.length()) == prefix_;
}
@@ -1102,7 +1113,7 @@
template <typename MatcheeStringType>
bool MatchAndExplain(const MatcheeStringType& s,
MatchResultListener* /* listener */) const {
- const StringType& s2(s);
+ const StringType s2(s);
return s2.length() >= suffix_.length() &&
s2.substr(s2.length() - suffix_.length()) == suffix_;
}
@@ -1300,34 +1311,48 @@
bool MatchAndExplain(const T& x,
MatchResultListener* listener) const override {
- // If either matcher1_ or matcher2_ doesn't match x, we only need
- // to explain why one of them fails.
+ // This method uses matcher's explanation when explaining the result.
+ // However, if matcher doesn't provide one, this method uses matcher's
+ // description.
std::string all_match_result;
-
- for (size_t i = 0; i < matchers_.size(); ++i) {
+ for (const Matcher<T>& matcher : matchers_) {
StringMatchResultListener slistener;
- if (matchers_[i].MatchAndExplain(x, &slistener)) {
- if (all_match_result.empty()) {
- all_match_result = slistener.str();
+ // Return explanation for first failed matcher.
+ if (!matcher.MatchAndExplain(x, &slistener)) {
+ const std::string explanation = slistener.str();
+ if (!explanation.empty()) {
+ *listener << explanation;
} else {
- std::string result = slistener.str();
- if (!result.empty()) {
- all_match_result += ", and ";
- all_match_result += result;
- }
+ *listener << "which doesn't match (" << Describe(matcher) << ")";
}
- } else {
- *listener << slistener.str();
return false;
}
+ // Keep track of explanations in case all matchers succeed.
+ std::string explanation = slistener.str();
+ if (explanation.empty()) {
+ explanation = Describe(matcher);
+ }
+ if (all_match_result.empty()) {
+ all_match_result = explanation;
+ } else {
+ if (!explanation.empty()) {
+ all_match_result += ", and ";
+ all_match_result += explanation;
+ }
+ }
}
- // Otherwise we need to explain why *both* of them match.
*listener << all_match_result;
return true;
}
private:
+ // Returns matcher description as a string.
+ std::string Describe(const Matcher<T>& matcher) const {
+ StringMatchResultListener listener;
+ matcher.DescribeTo(listener.stream());
+ return listener.str();
+ }
const std::vector<Matcher<T>> matchers_;
};
@@ -1405,34 +1430,55 @@
bool MatchAndExplain(const T& x,
MatchResultListener* listener) const override {
+ // This method uses matcher's explanation when explaining the result.
+ // However, if matcher doesn't provide one, this method uses matcher's
+ // description.
std::string no_match_result;
-
- // If either matcher1_ or matcher2_ matches x, we just need to
- // explain why *one* of them matches.
- for (size_t i = 0; i < matchers_.size(); ++i) {
+ for (const Matcher<T>& matcher : matchers_) {
StringMatchResultListener slistener;
- if (matchers_[i].MatchAndExplain(x, &slistener)) {
- *listener << slistener.str();
- return true;
- } else {
- if (no_match_result.empty()) {
- no_match_result = slistener.str();
+ // Return explanation for first match.
+ if (matcher.MatchAndExplain(x, &slistener)) {
+ const std::string explanation = slistener.str();
+ if (!explanation.empty()) {
+ *listener << explanation;
} else {
- std::string result = slistener.str();
- if (!result.empty()) {
- no_match_result += ", and ";
- no_match_result += result;
- }
+ *listener << "which matches (" << Describe(matcher) << ")";
+ }
+ return true;
+ }
+ // Keep track of explanations in case there is no match.
+ std::string explanation = slistener.str();
+ if (explanation.empty()) {
+ explanation = DescribeNegation(matcher);
+ }
+ if (no_match_result.empty()) {
+ no_match_result = explanation;
+ } else {
+ if (!explanation.empty()) {
+ no_match_result += ", and ";
+ no_match_result += explanation;
}
}
}
- // Otherwise we need to explain why *both* of them fail.
*listener << no_match_result;
return false;
}
private:
+ // Returns matcher description as a string.
+ std::string Describe(const Matcher<T>& matcher) const {
+ StringMatchResultListener listener;
+ matcher.DescribeTo(listener.stream());
+ return listener.str();
+ }
+
+ std::string DescribeNegation(const Matcher<T>& matcher) const {
+ StringMatchResultListener listener;
+ matcher.DescribeNegationTo(listener.stream());
+ return listener.str();
+ }
+
const std::vector<Matcher<T>> matchers_;
};
@@ -1483,7 +1529,7 @@
}
private:
- const ::std::vector<T> matchers_;
+ const std::vector<std::remove_const_t<T>> matchers_;
};
template <typename T>
@@ -2235,6 +2281,9 @@
class Impl : public MatcherInterface<T> {
using ResultType = decltype(CallableTraits<Callable>::template Invoke<T>(
std::declval<CallableStorageType>(), std::declval<T>()));
+ using InnerType = std::conditional_t<
+ std::is_lvalue_reference<ResultType>::value,
+ const typename std::remove_reference<ResultType>::type&, ResultType>;
public:
template <typename M>
@@ -2242,7 +2291,7 @@
const CallableStorageType& callable, const M& matcher)
: result_description_(result_description),
callable_(callable),
- matcher_(MatcherCast<ResultType>(matcher)) {}
+ matcher_(MatcherCast<InnerType>(matcher)) {}
void DescribeTo(::std::ostream* os) const override {
if (result_description_.empty()) {
@@ -2272,7 +2321,7 @@
// takes a non-const reference as argument.
// Also, specifying template argument explicitly is needed because T could
// be a non-const reference (e.g. Matcher<Uncopyable&>).
- ResultType result =
+ InnerType result =
CallableTraits<Callable>::template Invoke<T>(callable_, obj);
return MatchPrintAndExplain(result, matcher_, listener);
}
@@ -2285,7 +2334,7 @@
// use stateful callables with ResultOf(), which doesn't guarantee
// how many times the callable will be invoked.
mutable CallableStorageType callable_;
- const Matcher<ResultType> matcher_;
+ const Matcher<InnerType> matcher_;
}; // class Impl
const std::string result_description_;
@@ -2920,26 +2969,23 @@
const M inner_matcher_;
};
-struct Rank1 {};
-struct Rank0 : Rank1 {};
-
namespace pair_getters {
using std::get;
template <typename T>
-auto First(T& x, Rank1) -> decltype(get<0>(x)) { // NOLINT
+auto First(T& x, Rank0) -> decltype(get<0>(x)) { // NOLINT
return get<0>(x);
}
template <typename T>
-auto First(T& x, Rank0) -> decltype((x.first)) { // NOLINT
+auto First(T& x, Rank1) -> decltype((x.first)) { // NOLINT
return x.first;
}
template <typename T>
-auto Second(T& x, Rank1) -> decltype(get<1>(x)) { // NOLINT
+auto Second(T& x, Rank0) -> decltype(get<1>(x)) { // NOLINT
return get<1>(x);
}
template <typename T>
-auto Second(T& x, Rank0) -> decltype((x.second)) { // NOLINT
+auto Second(T& x, Rank1) -> decltype((x.second)) { // NOLINT
return x.second;
}
} // namespace pair_getters
@@ -2965,7 +3011,7 @@
MatchResultListener* listener) const override {
StringMatchResultListener inner_listener;
const bool match = inner_matcher_.MatchAndExplain(
- pair_getters::First(key_value, Rank0()), &inner_listener);
+ pair_getters::First(key_value, Rank1()), &inner_listener);
const std::string explanation = inner_listener.str();
if (!explanation.empty()) {
*listener << "whose first field is a value " << explanation;
@@ -3087,18 +3133,18 @@
if (!listener->IsInterested()) {
// If the listener is not interested, we don't need to construct the
// explanation.
- return first_matcher_.Matches(pair_getters::First(a_pair, Rank0())) &&
- second_matcher_.Matches(pair_getters::Second(a_pair, Rank0()));
+ return first_matcher_.Matches(pair_getters::First(a_pair, Rank1())) &&
+ second_matcher_.Matches(pair_getters::Second(a_pair, Rank1()));
}
StringMatchResultListener first_inner_listener;
- if (!first_matcher_.MatchAndExplain(pair_getters::First(a_pair, Rank0()),
+ if (!first_matcher_.MatchAndExplain(pair_getters::First(a_pair, Rank1()),
&first_inner_listener)) {
*listener << "whose first field does not match";
PrintIfNotEmpty(first_inner_listener.str(), listener->stream());
return false;
}
StringMatchResultListener second_inner_listener;
- if (!second_matcher_.MatchAndExplain(pair_getters::Second(a_pair, Rank0()),
+ if (!second_matcher_.MatchAndExplain(pair_getters::Second(a_pair, Rank1()),
&second_inner_listener)) {
*listener << "whose second field does not match";
PrintIfNotEmpty(second_inner_listener.str(), listener->stream());
@@ -3151,8 +3197,8 @@
};
template <typename T, size_t... I>
-auto UnpackStructImpl(const T& t, IndexSequence<I...>, int)
- -> decltype(std::tie(get<I>(t)...)) {
+auto UnpackStructImpl(const T& t, std::index_sequence<I...>,
+ int) -> decltype(std::tie(get<I>(t)...)) {
static_assert(std::tuple_size<T>::value == sizeof...(I),
"Number of arguments doesn't match the number of fields.");
return std::tie(get<I>(t)...);
@@ -3160,106 +3206,111 @@
#if defined(__cpp_structured_bindings) && __cpp_structured_bindings >= 201606
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<1>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<1>, char) {
const auto& [a] = t;
return std::tie(a);
}
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<2>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<2>, char) {
const auto& [a, b] = t;
return std::tie(a, b);
}
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<3>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<3>, char) {
const auto& [a, b, c] = t;
return std::tie(a, b, c);
}
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<4>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<4>, char) {
const auto& [a, b, c, d] = t;
return std::tie(a, b, c, d);
}
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<5>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<5>, char) {
const auto& [a, b, c, d, e] = t;
return std::tie(a, b, c, d, e);
}
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<6>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<6>, char) {
const auto& [a, b, c, d, e, f] = t;
return std::tie(a, b, c, d, e, f);
}
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<7>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<7>, char) {
const auto& [a, b, c, d, e, f, g] = t;
return std::tie(a, b, c, d, e, f, g);
}
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<8>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<8>, char) {
const auto& [a, b, c, d, e, f, g, h] = t;
return std::tie(a, b, c, d, e, f, g, h);
}
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<9>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<9>, char) {
const auto& [a, b, c, d, e, f, g, h, i] = t;
return std::tie(a, b, c, d, e, f, g, h, i);
}
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<10>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<10>, char) {
const auto& [a, b, c, d, e, f, g, h, i, j] = t;
return std::tie(a, b, c, d, e, f, g, h, i, j);
}
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<11>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<11>, char) {
const auto& [a, b, c, d, e, f, g, h, i, j, k] = t;
return std::tie(a, b, c, d, e, f, g, h, i, j, k);
}
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<12>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<12>, char) {
const auto& [a, b, c, d, e, f, g, h, i, j, k, l] = t;
return std::tie(a, b, c, d, e, f, g, h, i, j, k, l);
}
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<13>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<13>, char) {
const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m] = t;
return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m);
}
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<14>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<14>, char) {
const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n] = t;
return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
}
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<15>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<15>, char) {
const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o] = t;
return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
}
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<16>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<16>, char) {
const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p] = t;
return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p);
}
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<17>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<17>, char) {
const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q] = t;
return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q);
}
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<18>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<18>, char) {
const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r] = t;
return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r);
}
template <typename T>
-auto UnpackStructImpl(const T& t, MakeIndexSequence<19>, char) {
+auto UnpackStructImpl(const T& t, std::make_index_sequence<19>, char) {
const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s] = t;
return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s);
}
+template <typename T>
+auto UnpackStructImpl(const T& u, std::make_index_sequence<20>, char) {
+ const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t] = u;
+ return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t);
+}
#endif // defined(__cpp_structured_bindings)
template <size_t I, typename T>
auto UnpackStruct(const T& t)
- -> decltype((UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0)) {
- return (UnpackStructImpl)(t, MakeIndexSequence<I>{}, 0);
+ -> decltype((UnpackStructImpl)(t, std::make_index_sequence<I>{}, 0)) {
+ return (UnpackStructImpl)(t, std::make_index_sequence<I>{}, 0);
}
// Helper function to do comma folding in C++11.
@@ -3272,7 +3323,7 @@
class FieldsAreMatcherImpl;
template <typename Struct, size_t... I>
-class FieldsAreMatcherImpl<Struct, IndexSequence<I...>>
+class FieldsAreMatcherImpl<Struct, std::index_sequence<I...>>
: public MatcherInterface<Struct> {
using UnpackedType =
decltype(UnpackStruct<sizeof...(I)>(std::declval<const Struct&>()));
@@ -3354,8 +3405,8 @@
template <typename Struct>
operator Matcher<Struct>() const { // NOLINT
return Matcher<Struct>(
- new FieldsAreMatcherImpl<const Struct&, IndexSequenceFor<Inner...>>(
- matchers_));
+ new FieldsAreMatcherImpl<const Struct&,
+ std::index_sequence_for<Inner...>>(matchers_));
}
private:
@@ -3768,7 +3819,7 @@
private:
UnorderedMatcherRequire::Flags match_flags_;
- ::std::vector<T> matchers_;
+ std::vector<std::remove_const_t<T>> matchers_;
};
// Implements ElementsAreArray().
@@ -3789,7 +3840,7 @@
}
private:
- const ::std::vector<T> matchers_;
+ const std::vector<std::remove_const_t<T>> matchers_;
};
// Given a 2-tuple matcher tm of type Tuple2Matcher and a value second
@@ -3876,6 +3927,21 @@
bool negation, const char* matcher_name,
const std::vector<const char*>& param_names, const Strings& param_values);
+// Overloads to support `OptionalMatcher` being used with a type that either
+// supports implicit conversion to bool or a `has_value()` method.
+template <typename Optional>
+auto IsOptionalEngaged(const Optional& optional,
+ Rank1) -> decltype(!!optional) {
+ // The use of double-negation here is to preserve historical behavior where
+ // the matcher used `operator!` rather than directly using `operator bool`.
+ return !static_cast<bool>(!optional);
+}
+template <typename Optional>
+auto IsOptionalEngaged(const Optional& optional,
+ Rank0) -> decltype(!optional.has_value()) {
+ return optional.has_value();
+}
+
// Implements a matcher that checks the value of a optional<> type variable.
template <typename ValueMatcher>
class OptionalMatcher {
@@ -3908,7 +3974,7 @@
bool MatchAndExplain(Optional optional,
MatchResultListener* listener) const override {
- if (!optional) {
+ if (!IsOptionalEngaged(optional, HighestRank())) {
*listener << "which is not engaged";
return false;
}
@@ -4387,6 +4453,10 @@
// matches 'matcher'. For example,
// Property(&Foo::str, StartsWith("hi"))
// matches a Foo object x if and only if x.str() starts with "hi".
+//
+// 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.
template <typename Class, typename PropertyType, typename PropertyMatcher>
inline PolymorphicMatcher<internal::PropertyMatcher<
Class, PropertyType, PropertyType (Class::*)() const>>
@@ -4741,9 +4811,10 @@
// Supports the Pointwise(m, {a, b, c}) syntax.
template <typename TupleMatcher, typename T>
-inline internal::PointwiseMatcher<TupleMatcher, std::vector<T>> Pointwise(
- const TupleMatcher& tuple_matcher, std::initializer_list<T> rhs) {
- return Pointwise(tuple_matcher, std::vector<T>(rhs));
+inline internal::PointwiseMatcher<TupleMatcher,
+ std::vector<std::remove_const_t<T>>>
+Pointwise(const TupleMatcher& tuple_matcher, std::initializer_list<T> rhs) {
+ return Pointwise(tuple_matcher, std::vector<std::remove_const_t<T>>(rhs));
}
// UnorderedPointwise(pair_matcher, rhs) matches an STL-style
@@ -4905,7 +4976,7 @@
// - {1} matches IsSubsetOf({Gt(0), Lt(0)}), as 1 matches Gt(0).
// - {1, -1} matches IsSubsetOf({Lt(0), Gt(0)}), as 1 matches Gt(0) and -1
// matches Lt(0).
-// - {1, 2} doesn't matches IsSubsetOf({Gt(0), Lt(0)}), even though 1 and 2 both
+// - {1, 2} doesn't match IsSubsetOf({Gt(0), Lt(0)}), even though 1 and 2 both
// match Gt(0). The reason is that different matchers must be used for
// elements in different slots of the container.
//
@@ -5230,9 +5301,10 @@
}
// Returns a matcher that matches the value of an optional<> type variable.
-// The matcher implementation only uses '!arg' and requires that the optional<>
-// type has a 'value_type' member type and that '*arg' is of type 'value_type'
-// and is printable using 'PrintToString'. It is compatible with
+// The matcher implementation only uses '!arg' (or 'arg.has_value()' if '!arg`
+// isn't a valid expression) and requires that the optional<> type has a
+// 'value_type' member type and that '*arg' is of type 'value_type' and is
+// printable using 'PrintToString'. It is compatible with
// std::optional/std::experimental::optional.
// Note that to compare an optional type variable against nullopt you should
// use Eq(nullopt) and not Eq(Optional(nullopt)). The latter implies that the
@@ -5444,47 +5516,46 @@
::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)
// MATCHER* macros itself are listed below.
-#define MATCHER(name, description) \
- class name##Matcher \
- : public ::testing::internal::MatcherBaseImpl<name##Matcher> { \
- public: \
- template <typename arg_type> \
- class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> { \
- public: \
- gmock_Impl() {} \
- bool MatchAndExplain( \
- const arg_type& arg, \
- ::testing::MatchResultListener* result_listener) const override; \
- void DescribeTo(::std::ostream* gmock_os) const override { \
- *gmock_os << FormatDescription(false); \
- } \
- void DescribeNegationTo(::std::ostream* gmock_os) const override { \
- *gmock_os << FormatDescription(true); \
- } \
- \
- private: \
- ::std::string FormatDescription(bool negation) const { \
- /* NOLINTNEXTLINE readability-redundant-string-init */ \
- ::std::string gmock_description = (description); \
- if (!gmock_description.empty()) { \
- return gmock_description; \
- } \
- return ::testing::internal::FormatMatcherDescription(negation, #name, \
- {}, {}); \
- } \
- }; \
- }; \
- inline name##Matcher GMOCK_INTERNAL_WARNING_PUSH() \
- GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-function") \
- GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-member-function") \
- name GMOCK_INTERNAL_WARNING_POP()() { \
- return {}; \
- } \
- template <typename arg_type> \
- bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain( \
- const arg_type& arg, \
- ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) \
- const
+#define MATCHER(name, description) \
+ class name##Matcher \
+ : public ::testing::internal::MatcherBaseImpl<name##Matcher> { \
+ public: \
+ template <typename arg_type> \
+ class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> { \
+ public: \
+ gmock_Impl() {} \
+ bool MatchAndExplain( \
+ const arg_type& arg, \
+ ::testing::MatchResultListener* result_listener) const override; \
+ void DescribeTo(::std::ostream* gmock_os) const override { \
+ *gmock_os << FormatDescription(false); \
+ } \
+ void DescribeNegationTo(::std::ostream* gmock_os) const override { \
+ *gmock_os << FormatDescription(true); \
+ } \
+ \
+ private: \
+ ::std::string FormatDescription(bool negation) const { \
+ /* NOLINTNEXTLINE readability-redundant-string-init */ \
+ ::std::string gmock_description = (description); \
+ if (!gmock_description.empty()) { \
+ return gmock_description; \
+ } \
+ return ::testing::internal::FormatMatcherDescription(negation, #name, \
+ {}, {}); \
+ } \
+ }; \
+ }; \
+ inline name##Matcher GMOCK_INTERNAL_WARNING_PUSH() \
+ GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-function") \
+ GMOCK_INTERNAL_WARNING_CLANG(ignored, "-Wunused-member-function") \
+ name GMOCK_INTERNAL_WARNING_POP()() { \
+ return {}; \
+ } \
+ template <typename arg_type> \
+ bool name##Matcher::gmock_Impl<arg_type>::MatchAndExplain( \
+ const arg_type& arg, \
+ [[maybe_unused]] ::testing::MatchResultListener* result_listener) const
#define MATCHER_P(name, p0, description) \
GMOCK_INTERNAL_MATCHER(name, name##MatcherP, description, (#p0), (p0))
@@ -5566,11 +5637,11 @@
} \
template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)> \
template <typename arg_type> \
- bool full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>::gmock_Impl< \
- arg_type>::MatchAndExplain(const arg_type& arg, \
- ::testing::MatchResultListener* \
- result_listener GTEST_ATTRIBUTE_UNUSED_) \
- const
+ bool full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>:: \
+ gmock_Impl<arg_type>::MatchAndExplain( \
+ const arg_type& arg, \
+ [[maybe_unused]] ::testing::MatchResultListener* result_listener) \
+ const
#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args) \
GMOCK_PP_TAIL( \
@@ -5605,8 +5676,8 @@
#define GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args) \
GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_ARG_USAGE, , args))
-#define GMOCK_INTERNAL_MATCHER_ARG_USAGE(i, data_unused, arg_unused) \
- , gmock_p##i
+#define GMOCK_INTERNAL_MATCHER_ARG_USAGE(i, data_unused, arg) \
+ , ::std::forward<arg##_type>(gmock_p##i)
// To prevent ADL on certain functions we put them on a separate namespace.
using namespace no_adl; // NOLINT
diff --git a/third_party/googletest/googlemock/include/gmock/gmock-more-actions.h b/third_party/googletest/googlemock/include/gmock/gmock-more-actions.h
index 4030076..eacfdcd 100644
--- a/third_party/googletest/googlemock/include/gmock/gmock-more-actions.h
+++ b/third_party/googletest/googlemock/include/gmock/gmock-more-actions.h
@@ -521,9 +521,8 @@
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 \
@@ -551,10 +550,10 @@
}; \
template <GMOCK_INTERNAL_DECL_##template_params \
GMOCK_INTERNAL_DECL_TYPE_##value_params> \
- GMOCK_ACTION_CLASS_( \
+ [[nodiscard]] GMOCK_ACTION_CLASS_( \
name, value_params)<GMOCK_INTERNAL_LIST_##template_params \
GMOCK_INTERNAL_LIST_TYPE_##value_params> \
- name(GMOCK_INTERNAL_DECL_##value_params) GTEST_MUST_USE_RESULT_; \
+ name(GMOCK_INTERNAL_DECL_##value_params); \
template <GMOCK_INTERNAL_DECL_##template_params \
GMOCK_INTERNAL_DECL_TYPE_##value_params> \
inline GMOCK_ACTION_CLASS_( \
@@ -592,21 +591,23 @@
// Overloads for other custom-callables are provided in the
// internal/custom/gmock-generated-actions.h header.
template <typename F, typename... Args>
-auto InvokeArgument(F f, Args... args) -> decltype(f(args...)) {
- return f(args...);
+auto InvokeArgument(F &&f,
+ Args... args) -> decltype(std::forward<F>(f)(args...)) {
+ return std::forward<F>(f)(args...);
}
template <std::size_t index, typename... Params>
struct InvokeArgumentAction {
template <typename... Args,
typename = typename std::enable_if<(index < sizeof...(Args))>::type>
- auto operator()(Args &&...args) const -> decltype(internal::InvokeArgument(
- 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 = args_tuple.template Get<index>();
+ auto &&callable = std::move(args_tuple.template Get<index>());
return internal::InvokeArgument(
std::forward<decltype(callable)>(callable), unpacked_params...);
});
diff --git a/third_party/googletest/googlemock/include/gmock/gmock-spec-builders.h b/third_party/googletest/googlemock/include/gmock/gmock-spec-builders.h
index 78ca15d..c4c42b7 100644
--- a/third_party/googletest/googlemock/include/gmock/gmock-spec-builders.h
+++ b/third_party/googletest/googlemock/include/gmock/gmock-spec-builders.h
@@ -868,7 +868,7 @@
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;
@@ -1838,9 +1838,8 @@
// 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);
}
@@ -1890,8 +1889,7 @@
// 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);
diff --git a/third_party/googletest/googlemock/include/gmock/gmock.h b/third_party/googletest/googlemock/include/gmock/gmock.h
index 568c8c7..c78fb8e 100644
--- a/third_party/googletest/googlemock/include/gmock/gmock.h
+++ b/third_party/googletest/googlemock/include/gmock/gmock.h
@@ -53,13 +53,14 @@
//
// where all clauses are optional and WillOnce() can be repeated.
-#include "gmock/gmock-actions.h"
-#include "gmock/gmock-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/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/internal/gmock-internal-utils.h"
#include "gmock/internal/gmock-port.h"
diff --git a/third_party/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h b/third_party/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
index ead6d7c..8fc1ddc 100644
--- a/third_party/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
+++ b/third_party/googletest/googlemock/include/gmock/internal/gmock-internal-utils.h
@@ -44,6 +44,7 @@
#include <ostream> // NOLINT
#include <string>
#include <type_traits>
+#include <utility>
#include <vector>
#include "gmock/internal/gmock-port.h"
@@ -420,7 +421,7 @@
GTEST_API_ void IllegalDoDefault(const char* file, int line);
template <typename F, typename Tuple, size_t... Idx>
-auto ApplyImpl(F&& f, Tuple&& args, IndexSequence<Idx...>)
+auto ApplyImpl(F&& f, Tuple&& args, std::index_sequence<Idx...>)
-> decltype(std::forward<F>(f)(
std::get<Idx>(std::forward<Tuple>(args))...)) {
return std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...);
@@ -428,12 +429,13 @@
// 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),
- MakeIndexSequence<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),
+ std::make_index_sequence<std::tuple_size<
+ typename std::remove_reference<Tuple>::type>::value>())) {
return ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
- MakeIndexSequence<std::tuple_size<
+ std::make_index_sequence<std::tuple_size<
typename std::remove_reference<Tuple>::type>::value>());
}
@@ -465,11 +467,6 @@
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
diff --git a/third_party/googletest/googlemock/include/gmock/internal/gmock-port.h b/third_party/googletest/googlemock/include/gmock/internal/gmock-port.h
index 55ddfb6..42d36d2 100644
--- a/third_party/googletest/googlemock/include/gmock/internal/gmock-port.h
+++ b/third_party/googletest/googlemock/include/gmock/internal/gmock-port.h
@@ -42,6 +42,7 @@
#include <assert.h>
#include <stdlib.h>
+
#include <cstdint>
#include <iostream>
@@ -56,7 +57,7 @@
#include "gmock/internal/custom/gmock-port.h"
#include "gtest/internal/gtest-port.h"
-#ifdef GTEST_HAS_ABSL
+#if defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
#include "absl/flags/declare.h"
#include "absl/flags/flag.h"
#endif
@@ -73,7 +74,7 @@
#define GMOCK_FLAG(name) FLAGS_gmock_##name
// Pick a command line flags implementation.
-#ifdef GTEST_HAS_ABSL
+#if defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
// Macros for defining flags.
#define GMOCK_DEFINE_bool_(name, default_val, doc) \
@@ -95,7 +96,7 @@
#define GMOCK_FLAG_SET(name, value) \
(void)(::absl::SetFlag(&GMOCK_FLAG(name), value))
-#else // GTEST_HAS_ABSL
+#else // defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
// Macros for defining flags.
#define GMOCK_DEFINE_bool_(name, default_val, doc) \
@@ -134,6 +135,6 @@
#define GMOCK_FLAG_GET(name) ::testing::GMOCK_FLAG(name)
#define GMOCK_FLAG_SET(name, value) (void)(::testing::GMOCK_FLAG(name) = value)
-#endif // GTEST_HAS_ABSL
+#endif // defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
#endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
diff --git a/third_party/googletest/googlemock/src/gmock-cardinalities.cc b/third_party/googletest/googlemock/src/gmock-cardinalities.cc
index 92cde34..a7283aa 100644
--- a/third_party/googletest/googlemock/src/gmock-cardinalities.cc
+++ b/third_party/googletest/googlemock/src/gmock-cardinalities.cc
@@ -53,12 +53,12 @@
: 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
diff --git a/third_party/googletest/googlemock/src/gmock-internal-utils.cc b/third_party/googletest/googlemock/src/gmock-internal-utils.cc
index 5c2ce0d..96c7e30 100644
--- a/third_party/googletest/googlemock/src/gmock-internal-utils.cc
+++ b/third_party/googletest/googlemock/src/gmock-internal-utils.cc
@@ -44,6 +44,7 @@
#include <iostream>
#include <ostream> // NOLINT
#include <string>
+#include <utility>
#include <vector>
#include "gmock/gmock.h"
@@ -211,14 +212,14 @@
}
template <size_t... I>
-constexpr std::array<char, 256> UnBase64Impl(IndexSequence<I...>,
+constexpr std::array<char, 256> UnBase64Impl(std::index_sequence<I...>,
const char* const base64) {
return {
{UnBase64Impl(UndoWebSafeEncoding(static_cast<char>(I)), base64, 0)...}};
}
constexpr std::array<char, 256> UnBase64(const char* const base64) {
- return UnBase64Impl(MakeIndexSequence<256>{}, base64);
+ return UnBase64Impl(std::make_index_sequence<256>{}, base64);
}
static constexpr char kBase64[] =
diff --git a/third_party/googletest/googlemock/src/gmock-matchers.cc b/third_party/googletest/googlemock/src/gmock-matchers.cc
index 81a5b7e..277add6 100644
--- a/third_party/googletest/googlemock/src/gmock-matchers.cc
+++ b/third_party/googletest/googlemock/src/gmock-matchers.cc
@@ -236,9 +236,8 @@
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}";
@@ -374,20 +373,20 @@
return true;
}
- 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;
+ 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";
}
}
- bool result = true;
+ bool result = !is_exact_match_with_size_discrepency;
::std::vector<char> element_matched(matrix.LhsSize(), 0);
::std::vector<char> matcher_matched(matrix.RhsSize(), 0);
diff --git a/third_party/googletest/googlemock/src/gmock-spec-builders.cc b/third_party/googletest/googlemock/src/gmock-spec-builders.cc
index de89471..ffdf03d 100644
--- a/third_party/googletest/googlemock/src/gmock-spec-builders.cc
+++ b/third_party/googletest/googlemock/src/gmock-spec-builders.cc
@@ -490,6 +490,7 @@
// 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();
@@ -530,7 +531,7 @@
#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
}
diff --git a/third_party/googletest/googlemock/test/gmock-actions_test.cc b/third_party/googletest/googlemock/test/gmock-actions_test.cc
index da1675c..84db511 100644
--- a/third_party/googletest/googlemock/test/gmock-actions_test.cc
+++ b/third_party/googletest/googlemock/test/gmock-actions_test.cc
@@ -222,8 +222,8 @@
// In C++17 and above, where it's guaranteed that functions can return
// non-moveable objects, everything should work fine for non-moveable rsult
// types too.
-#if defined(GTEST_INTERNAL_CPLUSPLUS_LANG) && \
- GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
+ // TODO(b/396121064) - Fix this test under MSVC
+#ifndef _MSC_VER
{
struct NonMoveable {
NonMoveable() = default;
@@ -244,7 +244,7 @@
static_assert(!internal::is_callable_r<int, Callable>::value);
static_assert(!internal::is_callable_r<NonMoveable, Callable, int>::value);
}
-#endif // C++17 and above
+#endif // _MSC_VER
// Nothing should choke when we try to call other arguments besides directly
// callable objects, but they should not show up as callable.
@@ -441,8 +441,8 @@
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 @@
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
@@ -1477,6 +1477,54 @@
}
}
+// A 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.
+TEST(DoAll, ConvertibleToOnceActionWithUserProvidedActionConversion) {
+ // Simplest case: only one sub-action.
+ struct CustomFinal final {
+ operator Action<int()>() { // NOLINT
+ return Return(17);
+ }
+
+ operator Action<int(int, char)>() { // NOLINT
+ return Return(19);
+ }
+ };
+
+ {
+ OnceAction<int()> action = DoAll(CustomFinal{});
+ EXPECT_EQ(17, std::move(action).Call());
+ }
+
+ {
+ OnceAction<int(int, char)> action = DoAll(CustomFinal{});
+ EXPECT_EQ(19, std::move(action).Call(0, 0));
+ }
+
+ // It should also work with multiple sub-actions.
+ struct CustomInitial final {
+ operator Action<void()>() { // NOLINT
+ return [] {};
+ }
+
+ operator Action<void(int, char)>() { // NOLINT
+ return [] {};
+ }
+ };
+
+ {
+ OnceAction<int()> action = DoAll(CustomInitial{}, CustomFinal{});
+ EXPECT_EQ(17, std::move(action).Call());
+ }
+
+ {
+ OnceAction<int(int, char)> action = DoAll(CustomInitial{}, CustomFinal{});
+ EXPECT_EQ(19, std::move(action).Call(0, 0));
+ }
+}
+
// Tests using WithArgs and with an action that takes 1 argument.
TEST(WithArgsTest, OneArg) {
Action<bool(double x, int n)> a = WithArgs<1>(Invoke(Unary)); // NOLINT
diff --git a/third_party/googletest/googlemock/test/gmock-function-mocker_test.cc b/third_party/googletest/googlemock/test/gmock-function-mocker_test.cc
index f7b31ae..cdac79b 100644
--- a/third_party/googletest/googlemock/test/gmock-function-mocker_test.cc
+++ b/third_party/googletest/googlemock/test/gmock-function-mocker_test.cc
@@ -325,8 +325,8 @@
// 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, NULL, "hi"))
+ EXPECT_CALL(this->mock_foo_, Decimal(true, 'a', 0, 0, 1L, A<float>(), Lt(100),
+ 5U, nullptr, "hi"))
.WillOnce(Return(5));
EXPECT_EQ(5, this->foo_->Decimal(true, 'a', 0, 0, 1, 0, 0, 5, nullptr, "hi"));
diff --git a/third_party/googletest/googlemock/test/gmock-matchers-arithmetic_test.cc b/third_party/googletest/googlemock/test/gmock-matchers-arithmetic_test.cc
index f176962..06b0b47 100644
--- a/third_party/googletest/googlemock/test/gmock-matchers-arithmetic_test.cc
+++ b/third_party/googletest/googlemock/test/gmock-matchers-arithmetic_test.cc
@@ -36,7 +36,9 @@
#include <memory>
#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
@@ -559,10 +561,9 @@
Matcher<int> m;
// Successful match. Both matchers need to explain. The second
- // matcher doesn't give an explanation, so only the first matcher's
- // explanation is printed.
+ // matcher doesn't give an explanation, so the matcher description is used.
m = AllOf(GreaterThan(10), Lt(30));
- EXPECT_EQ("which is 15 more than 10", Explain(m, 25));
+ EXPECT_EQ("which is 15 more than 10, and is < 30", Explain(m, 25));
// Successful match. Both matchers need to explain.
m = AllOf(GreaterThan(10), GreaterThan(20));
@@ -572,8 +573,9 @@
// Successful match. All matchers need to explain. The second
// matcher doesn't given an explanation.
m = AllOf(GreaterThan(10), Lt(30), GreaterThan(20));
- EXPECT_EQ("which is 15 more than 10, and which is 5 more than 20",
- Explain(m, 25));
+ EXPECT_EQ(
+ "which is 15 more than 10, and is < 30, and which is 5 more than 20",
+ Explain(m, 25));
// Successful match. All matchers need to explain.
m = AllOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
@@ -588,10 +590,10 @@
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, nothing is
+ // explain. Since it doesn't given an explanation, the matcher text is
// printed.
m = AllOf(GreaterThan(10), Lt(30));
- EXPECT_EQ("", Explain(m, 40));
+ EXPECT_EQ("which doesn't match (is < 30)", Explain(m, 40));
// Failed match. The second matcher, which failed, needs to
// explain.
@@ -774,45 +776,43 @@
TEST_P(AnyOfTestP, ExplainsResult) {
Matcher<int> m;
- // Failed match. Both matchers need to explain. The second
- // matcher doesn't give an explanation, so only the first matcher's
- // explanation is printed.
+ // Failed match. The second matcher have no explanation (description is used).
m = AnyOf(GreaterThan(10), Lt(0));
- EXPECT_EQ("which is 5 less than 10", Explain(m, 5));
+ EXPECT_EQ("which is 5 less than 10, and isn't < 0", Explain(m, 5));
- // Failed match. Both matchers need to explain.
+ // Failed match. Both matchers have explanations.
m = AnyOf(GreaterThan(10), GreaterThan(20));
EXPECT_EQ("which is 5 less than 10, and which is 15 less than 20",
Explain(m, 5));
- // Failed match. All matchers need to explain. The second
- // matcher doesn't given an explanation.
+ // Failed match. The middle matcher have no explanation.
m = AnyOf(GreaterThan(10), Gt(20), GreaterThan(30));
- EXPECT_EQ("which is 5 less than 10, and which is 25 less than 30",
- Explain(m, 5));
+ EXPECT_EQ(
+ "which is 5 less than 10, and isn't > 20, and which is 25 less than 30",
+ Explain(m, 5));
- // Failed match. All matchers need to explain.
+ // Failed match. All three matchers have explanations.
m = AnyOf(GreaterThan(10), GreaterThan(20), GreaterThan(30));
EXPECT_EQ(
"which is 5 less than 10, and which is 15 less than 20, "
"and which is 25 less than 30",
Explain(m, 5));
- // Successful match. The first matcher, which succeeded, needs to
- // explain.
+ // Successful match. The first macher succeeded and has explanation.
m = AnyOf(GreaterThan(10), GreaterThan(20));
EXPECT_EQ("which is 5 more than 10", Explain(m, 15));
- // Successful match. The second matcher, which succeeded, needs to
- // 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.
+ // Successful match. The second matcher succeeded and has explanation.
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
diff --git a/third_party/googletest/googlemock/test/gmock-matchers-comparisons_test.cc b/third_party/googletest/googlemock/test/gmock-matchers-comparisons_test.cc
index b2ce99e..a331aec 100644
--- a/third_party/googletest/googlemock/test/gmock-matchers-comparisons_test.cc
+++ b/third_party/googletest/googlemock/test/gmock-matchers-comparisons_test.cc
@@ -37,13 +37,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)
-
namespace testing {
namespace gmock_matchers_test {
namespace {
@@ -410,9 +411,27 @@
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) {
@@ -428,14 +447,34 @@
// predicate.
EXPECT_TRUE(m4.Matches(1));
EXPECT_FALSE(m4.Matches(0));
+
+ Matcher<MutableIntView> m5 = Truly(IsPositiveMutableIntView);
+ Matcher<int> m6 = MatcherCast<int>(m5);
+ // In the following, the arguments 1 and 0 are statically converted to
+ // MutableIntView objects, and then tested by the IsPositiveMutableIntView()
+ // predicate.
+ EXPECT_TRUE(m6.Matches(1));
+ EXPECT_FALSE(m6.Matches(0));
}
// Tests that MatcherCast<T>(m) works when m is a Matcher<const T&>.
TEST(MatcherCastTest, FromConstReferenceToNonReference) {
- Matcher<const int&> m1 = Eq(0);
+ int n = 0;
+ Matcher<const int&> m1 = Ref(n);
Matcher<int> m2 = MatcherCast<int>(m1);
- EXPECT_TRUE(m2.Matches(0));
- EXPECT_FALSE(m2.Matches(1));
+ 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));
}
// Tests that MatcherCast<T>(m) works when m is a Matcher<T&>.
@@ -444,6 +483,12 @@
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>.
@@ -648,6 +693,16 @@
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;
@@ -1769,6 +1824,15 @@
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) {
@@ -2325,9 +2389,11 @@
EXPECT_EQ("which is 0 modulo 2, and which is 0 modulo 3", Explain(m, 6));
}
+// Tests that when AllOf() succeeds, but matchers have no explanation,
+// the matcher description is used.
TEST(ExplainMatchResultTest, AllOf_True_True_2) {
const Matcher<int> m = AllOf(Ge(2), Le(3));
- EXPECT_EQ("", Explain(m, 2));
+ EXPECT_EQ("is >= 2, and is <= 3", Explain(m, 2));
}
INSTANTIATE_GTEST_MATCHER_TEST_P(ExplainmatcherResultTest);
diff --git a/third_party/googletest/googlemock/test/gmock-matchers-containers_test.cc b/third_party/googletest/googlemock/test/gmock-matchers-containers_test.cc
index 38fd9a5..751fb60 100644
--- a/third_party/googletest/googlemock/test/gmock-matchers-containers_test.cc
+++ b/third_party/googletest/googlemock/test/gmock-matchers-containers_test.cc
@@ -43,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 {
@@ -1204,13 +1204,16 @@
vector<int> container;
EXPECT_EQ("whose size 0 doesn't match", Explain(m1, container));
EXPECT_EQ("whose size 0 matches", Explain(m2, container));
- EXPECT_EQ("whose size 0 matches", Explain(m3, container));
+ EXPECT_EQ("whose size 0 matches, which matches (is equal to 0)",
+ Explain(m3, container));
EXPECT_EQ("whose size 0 doesn't match", Explain(m4, container));
container.push_back(0);
container.push_back(0);
EXPECT_EQ("whose size 2 matches", Explain(m1, container));
EXPECT_EQ("whose size 2 doesn't match", Explain(m2, container));
- EXPECT_EQ("whose size 2 doesn't match", Explain(m3, container));
+ EXPECT_EQ(
+ "whose size 2 doesn't match, isn't equal to 0, and isn't equal to 3",
+ Explain(m3, container));
EXPECT_EQ("whose size 2 matches", Explain(m4, container));
}
@@ -1475,8 +1478,10 @@
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",
- Explain(m3, 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 doesn't match, which is 1 "
"less than 1",
@@ -1487,8 +1492,10 @@
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",
- Explain(m3, 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 matches, which is 1 more "
"than 1",
@@ -2014,7 +2021,14 @@
StringMatchResultListener listener;
EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3), v, &listener))
<< listener.str();
- EXPECT_THAT(listener.str(), Eq("which has 1 element"));
+ EXPECT_THAT(listener.str(),
+ Eq("which has 1 element\n"
+ "where the following matchers don't match any elements:\n"
+ "matcher #0: is equal to 1,\n"
+ "matcher #1: is equal to 2,\n"
+ "matcher #2: is equal to 3\n"
+ "and where the following elements don't match any matchers:\n"
+ "element #0: 4"));
}
TEST_F(UnorderedElementsAreTest, FailMessageCountWrongZero) {
@@ -2022,7 +2036,11 @@
StringMatchResultListener listener;
EXPECT_FALSE(ExplainMatchResult(UnorderedElementsAre(1, 2, 3), v, &listener))
<< listener.str();
- EXPECT_THAT(listener.str(), Eq(""));
+ EXPECT_THAT(listener.str(),
+ Eq("where the following matchers don't match any elements:\n"
+ "matcher #0: is equal to 1,\n"
+ "matcher #1: is equal to 2,\n"
+ "matcher #2: is equal to 3"));
}
TEST_F(UnorderedElementsAreTest, FailMessageUnmatchedMatchers) {
@@ -2438,7 +2456,7 @@
const double lhs[2] = {1, 2};
const int rhs[1] = {0};
EXPECT_THAT(lhs, Not(UnorderedPointwise(Gt(), rhs)));
- EXPECT_EQ("which has 2 elements",
+ EXPECT_EQ("which has 2 elements\n",
Explain(UnorderedPointwise(Gt(), rhs), lhs));
const int rhs2[3] = {0, 1, 2};
diff --git a/third_party/googletest/googlemock/test/gmock-matchers-misc_test.cc b/third_party/googletest/googlemock/test/gmock-matchers-misc_test.cc
index b8f6458..de8b76c 100644
--- a/third_party/googletest/googlemock/test/gmock-matchers-misc_test.cc
+++ b/third_party/googletest/googlemock/test/gmock-matchers-misc_test.cc
@@ -32,6 +32,7 @@
// This file tests some commonly used argument matchers.
#include <array>
+#include <cstdint>
#include <memory>
#include <ostream>
#include <string>
@@ -39,14 +40,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 {
@@ -674,6 +675,8 @@
// explanation.
}
+#if GTEST_HAS_TYPED_TEST
+
// Sample optional type implementation with minimal requirements for use with
// Optional matcher.
template <typename T>
@@ -691,38 +694,94 @@
bool has_value_;
};
-TEST(OptionalTest, DescribesSelf) {
- const Matcher<SampleOptional<int>> m = Optional(Eq(1));
+// 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));
EXPECT_EQ("value is equal to 1", Describe(m));
}
-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, 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, 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);
+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);
EXPECT_TRUE(m1.Matches(opt));
EXPECT_FALSE(m2.Matches(opt));
EXPECT_TRUE(m3.Matches(opt));
}
-TEST(OptionalTest, DoesNotMatchNullopt) {
- const Matcher<SampleOptional<int>> m = Optional(1);
- SampleOptional<int> empty;
+TYPED_TEST(OptionalTest, DoesNotMatchNullopt) {
+ const Matcher<TypeParam> m = Optional(1);
+ TypeParam empty;
EXPECT_FALSE(m.Matches(empty));
}
-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, 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))));
}
+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) {}
@@ -1576,10 +1635,10 @@
const Matcher<int> m1 = AnyOfArray(v1);
const Matcher<int> m2 = AnyOfArray(v2);
EXPECT_EQ("", Explain(m0, 0));
- EXPECT_EQ("", Explain(m1, 1));
- EXPECT_EQ("", Explain(m1, 2));
- EXPECT_EQ("", Explain(m2, 3));
- EXPECT_EQ("", Explain(m2, 4));
+ 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("()", Describe(m0));
EXPECT_EQ("(is equal to 1)", Describe(m1));
EXPECT_EQ("(is equal to 2) or (is equal to 3)", Describe(m2));
diff --git a/third_party/googletest/googlemock/test/gmock-more-actions_test.cc b/third_party/googletest/googlemock/test/gmock-more-actions_test.cc
index 9980f3b..5b8b566 100644
--- a/third_party/googletest/googlemock/test/gmock-more-actions_test.cc
+++ b/third_party/googletest/googlemock/test/gmock-more-actions_test.cc
@@ -59,6 +59,7 @@
using testing::ReturnArg;
using testing::ReturnPointee;
using testing::SaveArg;
+using testing::SaveArgByMove;
using testing::SaveArgPointee;
using testing::SetArgReferee;
using testing::Unused;
@@ -85,6 +86,16 @@
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
@@ -482,6 +493,34 @@
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;
@@ -698,12 +737,24 @@
EXPECT_EQ(1, a.Perform(std::make_tuple(2, &Nullary)));
}
-// Tests using InvokeArgument with a unary function.
+// Tests using InvokeArgument with a unary functor.
TEST(InvokeArgumentTest, Functor1) {
Action<int(UnaryFunctor)> a = InvokeArgument<0>(true); // NOLINT
EXPECT_EQ(1, a.Perform(std::make_tuple(UnaryFunctor())));
}
+// Tests using InvokeArgument with a unary move-only functor.
+TEST(InvokeArgumentTest, Functor1MoveOnly) {
+ Action<int(UnaryMoveOnlyFunctor)> a = InvokeArgument<0>(true); // NOLINT
+ EXPECT_EQ(1, a.Perform(std::make_tuple(UnaryMoveOnlyFunctor())));
+}
+
+// Tests using InvokeArgument with a one-shot unary functor.
+TEST(InvokeArgumentTest, OneShotFunctor1) {
+ Action<int(OneShotUnaryFunctor)> a = InvokeArgument<0>(true); // NOLINT
+ EXPECT_EQ(1, a.Perform(std::make_tuple(OneShotUnaryFunctor())));
+}
+
// Tests using InvokeArgument with a 5-ary function.
TEST(InvokeArgumentTest, Function5) {
Action<int(int (*)(int, int, int, int, int))> a = // NOLINT
@@ -734,34 +785,34 @@
// 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");
@@ -806,6 +857,22 @@
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;
diff --git a/third_party/googletest/googlemock/test/gmock-pp_test.cc b/third_party/googletest/googlemock/test/gmock-pp_test.cc
index 5d1566e..e447f76 100644
--- a/third_party/googletest/googlemock/test/gmock-pp_test.cc
+++ b/third_party/googletest/googlemock/test/gmock-pp_test.cc
@@ -70,7 +70,7 @@
static_assert(GMOCK_PP_INTERNAL_VAR_TEST(silly) == 1, "");
static_assert(GMOCK_PP_INTERNAL_VAR_TEST(x, y, z) == 3, "");
-// TODO(iserna): The following asserts fail in --config=lexan.
+// TODO(iserna): The following asserts fail in --config=windows.
#define GMOCK_PP_INTERNAL_IS_EMPTY_TEST_1
static_assert(GMOCK_PP_IS_EMPTY(GMOCK_PP_INTERNAL_IS_EMPTY_TEST_1), "");
static_assert(GMOCK_PP_IS_EMPTY(), "");
diff --git a/third_party/googletest/googlemock/test/gmock-spec-builders_test.cc b/third_party/googletest/googlemock/test/gmock-spec-builders_test.cc
index aaf88d7..9e68aa0 100644
--- a/third_party/googletest/googlemock/test/gmock-spec-builders_test.cc
+++ b/third_party/googletest/googlemock/test/gmock-spec-builders_test.cc
@@ -804,9 +804,8 @@
"to be called at least once");
}
-#if defined(GTEST_INTERNAL_CPLUSPLUS_LANG) && \
- GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
-
+// TODO(b/396121064) - Fix this test under MSVC
+#ifndef _MSC_VER
// It should be possible to return a non-moveable type from a mock action in
// C++17 and above, where it's guaranteed that such a type can be initialized
// from a prvalue returned from a function.
@@ -847,7 +846,7 @@
EXPECT_EQ(17, mock.AsStdFunction()().x);
}
-#endif // C++17 and above
+#endif // _MSC_VER
// Tests that the n-th action is taken for the n-th matching
// invocation.
diff --git a/third_party/googletest/googlemock/test/gmock_link_test.h b/third_party/googletest/googlemock/test/gmock_link_test.h
index db11c2d..cb5179b 100644
--- a/third_party/googletest/googlemock/test/gmock_link_test.h
+++ b/third_party/googletest/googlemock/test/gmock_link_test.h
@@ -186,6 +186,7 @@
#endif
#if GTEST_HAS_EXCEPTIONS
+using testing::Rethrow;
using testing::Throw;
#endif
@@ -416,6 +417,14 @@
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
diff --git a/third_party/googletest/googletest/CMakeLists.txt b/third_party/googletest/googletest/CMakeLists.txt
index caafa8c..dce6a7c 100644
--- a/third_party/googletest/googletest/CMakeLists.txt
+++ b/third_party/googletest/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 @@
########################################################################
#
-# Project-wide settings
+# Project-wide settings.
# Name of the project.
#
@@ -44,7 +44,7 @@
# ${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 @@
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 @@
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 @@
########################################################################
#
-# 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)
@@ -147,22 +147,22 @@
target_include_directories(gtest_main SYSTEM INTERFACE
"$<BUILD_INTERFACE:${dirs}>"
"$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>")
-if(CMAKE_SYSTEM_NAME MATCHES "QNX")
+if(CMAKE_SYSTEM_NAME MATCHES "QNX" AND CMAKE_SYSTEM_VERSION VERSION_GREATER_EQUAL 7.1)
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)
@@ -185,8 +185,8 @@
# 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)
@@ -268,7 +268,7 @@
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}"
diff --git a/third_party/googletest/googletest/README.md b/third_party/googletest/googletest/README.md
index 44fd69b..5de23c5 100644
--- a/third_party/googletest/googletest/README.md
+++ b/third_party/googletest/googletest/README.md
@@ -25,7 +25,7 @@
with
```
-git clone https://github.com/google/googletest.git -b v1.14.0
+git clone https://github.com/google/googletest.git -b v1.16.0
cd googletest # Main directory of the cloned repository.
mkdir build # Create a directory to hold the build output.
cd build
diff --git a/third_party/googletest/googletest/cmake/Config.cmake.in b/third_party/googletest/googletest/cmake/Config.cmake.in
index 12be449..3f70661 100644
--- a/third_party/googletest/googletest/cmake/Config.cmake.in
+++ b/third_party/googletest/googletest/cmake/Config.cmake.in
@@ -4,6 +4,10 @@
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@")
diff --git a/third_party/googletest/googletest/cmake/internal_utils.cmake b/third_party/googletest/googletest/cmake/internal_utils.cmake
index d4f67f4..7ca256a 100644
--- a/third_party/googletest/googletest/cmake/internal_utils.cmake
+++ b/third_party/googletest/googletest/cmake/internal_utils.cmake
@@ -29,7 +29,7 @@
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 @@
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,7 +79,7 @@
set(cxx_exception_flags "-EHsc -D_HAS_EXCEPTIONS=1")
set(cxx_no_exception_flags "-EHs-c- -D_HAS_EXCEPTIONS=0")
set(cxx_no_rtti_flags "-GR-")
- # Suppress "unreachable code" warning
+ # Suppress "unreachable code" warning,
# https://stackoverflow.com/questions/3232669 explains the issue.
set(cxx_base_flags "${cxx_base_flags} -wd4702")
# Ensure MSVC treats source files as UTF-8 encoded.
@@ -110,7 +110,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
target_link_libraries(${name} PUBLIC Threads::Threads)
endif()
- target_compile_features(${name} PUBLIC cxx_std_14)
+ target_compile_features(${name} PUBLIC cxx_std_17)
endfunction()
########################################################################
@@ -212,7 +212,7 @@
# 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,19 +239,21 @@
# 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()
-find_package(Python3)
+if(gtest_build_tests)
+ find_package(Python3)
+endif()
# cxx_test_with_flags(name cxx_flags libs srcs...)
#
-# creates a named C++ test that depends on the given libs and is built
+# Creates a named C++ test that depends on the given libs and is built
# from the given source files with the given compiler flags.
function(cxx_test_with_flags name cxx_flags libs)
cxx_executable_with_flags(${name} "${cxx_flags}" "${libs}" ${ARGN})
@@ -260,8 +262,8 @@
# 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}"
@@ -270,8 +272,8 @@
# 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()
@@ -307,7 +309,7 @@
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)
diff --git a/third_party/googletest/googletest/include/gtest/gtest-assertion-result.h b/third_party/googletest/googletest/include/gtest/gtest-assertion-result.h
index 56fe128..954e7c4 100644
--- a/third_party/googletest/googletest/include/gtest/gtest-assertion-result.h
+++ b/third_party/googletest/googletest/include/gtest/gtest-assertion-result.h
@@ -130,6 +130,13 @@
// 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.
diff --git a/third_party/googletest/googletest/include/gtest/gtest-death-test.h b/third_party/googletest/googletest/include/gtest/gtest-death-test.h
index 08fef8c..3c61909 100644
--- a/third_party/googletest/googletest/include/gtest/gtest-death-test.h
+++ b/third_party/googletest/googletest/include/gtest/gtest-death-test.h
@@ -293,8 +293,8 @@
// statement is compiled but not executed, to ensure that
// EXPECT_DEATH_IF_SUPPORTED compiles with a certain
// parameter if and only if EXPECT_DEATH compiles with it.
-// regex - A regex that a macro such as EXPECT_DEATH would use to test
-// the output of statement. This parameter has to be
+// 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
// 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 @@
// statement unconditionally returns or throws. The Message constructor at
// the end allows the syntax of streaming additional messages into the
// macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH.
-#define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, terminator) \
+#define GTEST_UNSUPPORTED_DEATH_TEST(statement, regex_or_matcher, terminator) \
GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
if (::testing::internal::AlwaysTrue()) { \
GTEST_LOG_(WARNING) << "Death tests are not supported on this platform.\n" \
<< "Statement '" #statement "' cannot be verified."; \
} else if (::testing::internal::AlwaysFalse()) { \
- ::testing::internal::RE::PartialMatch(".*", (regex)); \
+ ::testing::internal::MakeDeathTestMatcher(regex_or_matcher); \
GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
terminator; \
} else \
diff --git a/third_party/googletest/googletest/include/gtest/gtest-matchers.h b/third_party/googletest/googletest/include/gtest/gtest-matchers.h
index eae210e..78160f0 100644
--- a/third_party/googletest/googletest/include/gtest/gtest-matchers.h
+++ b/third_party/googletest/googletest/include/gtest/gtest-matchers.h
@@ -67,10 +67,10 @@
// To implement a matcher Foo for type T, define:
// 1. a class FooMatcherMatcher that implements the matcher interface:
// using is_gtest_matcher = void;
-// bool MatchAndExplain(const T&, std::ostream*);
+// bool MatchAndExplain(const T&, std::ostream*) const;
// (MatchResultListener* can also be used instead of std::ostream*)
-// void DescribeTo(std::ostream*);
-// void DescribeNegationTo(std::ostream*);
+// void DescribeTo(std::ostream*) const;
+// void DescribeNegationTo(std::ostream*) const;
//
// 2. a factory function that creates a Matcher<T> object from a
// FooMatcherMatcher.
diff --git a/third_party/googletest/googletest/include/gtest/gtest-message.h b/third_party/googletest/googletest/include/gtest/gtest-message.h
index 59b805e..448ac6b 100644
--- a/third_party/googletest/googletest/include/gtest/gtest-message.h
+++ b/third_party/googletest/googletest/include/gtest/gtest-message.h
@@ -59,7 +59,7 @@
#ifdef GTEST_HAS_ABSL
#include <type_traits>
-#include "absl/strings/internal/has_absl_stringify.h"
+#include "absl/strings/has_absl_stringify.h"
#include "absl/strings/str_cat.h"
#endif // GTEST_HAS_ABSL
@@ -121,14 +121,14 @@
// 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::strings_internal::HasAbslStringify<T>::value, // NOLINT
- int>::type = 0
+ ,
+ typename std::enable_if<!absl::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,9 +153,8 @@
// Streams a non-pointer value with an AbslStringify definition to this
// object.
template <typename T,
- typename std::enable_if<
- absl::strings_internal::HasAbslStringify<T>::value, // NOLINT
- int>::type = 0>
+ typename std::enable_if<absl::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
diff --git a/third_party/googletest/googletest/include/gtest/gtest-param-test.h b/third_party/googletest/googletest/include/gtest/gtest-param-test.h
index 49a47ea..dbfc5c8 100644
--- a/third_party/googletest/googletest/include/gtest/gtest-param-test.h
+++ b/third_party/googletest/googletest/include/gtest/gtest-param-test.h
@@ -178,7 +178,7 @@
#include <utility>
#include "gtest/internal/gtest-internal.h"
-#include "gtest/internal/gtest-param-util.h"
+#include "gtest/internal/gtest-param-util.h" // IWYU pragma: export
#include "gtest/internal/gtest-port.h"
namespace testing {
@@ -469,7 +469,7 @@
::testing::internal::CodeLocation(__FILE__, __LINE__)); \
return 0; \
} \
- static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_; \
+ [[maybe_unused]] static int gtest_registering_dummy_; \
}; \
int GTEST_TEST_CLASS_NAME_(test_suite_name, \
test_name)::gtest_registering_dummy_ = \
@@ -493,39 +493,38 @@
#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); \
- } \
- 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), \
- >est_##prefix##test_suite_name##_EvalGenerator_, \
- >est_##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); \
+ } \
+ [[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), \
+ >est_##prefix##test_suite_name##_EvalGenerator_, \
+ >est_##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) \
diff --git a/third_party/googletest/googletest/include/gtest/gtest-printers.h b/third_party/googletest/googletest/include/gtest/gtest-printers.h
index 9ccbff7..198a769 100644
--- a/third_party/googletest/googletest/include/gtest/gtest-printers.h
+++ b/third_party/googletest/googletest/include/gtest/gtest-printers.h
@@ -116,7 +116,7 @@
#include <vector>
#ifdef GTEST_HAS_ABSL
-#include "absl/strings/internal/has_absl_stringify.h"
+#include "absl/strings/has_absl_stringify.h"
#include "absl/strings/str_cat.h"
#endif // GTEST_HAS_ABSL
#include "gtest/internal/gtest-internal.h"
@@ -124,7 +124,11 @@
#if GTEST_INTERNAL_HAS_STD_SPAN
#include <span> // NOLINT
-#endif // GTEST_INTERNAL_HAS_STD_SPAN
+#endif // GTEST_INTERNAL_HAS_STD_SPAN
+
+#if GTEST_INTERNAL_HAS_COMPARE_LIB
+#include <compare> // NOLINT
+#endif // GTEST_INTERNAL_HAS_COMPARE_LIB
namespace testing {
@@ -241,8 +245,8 @@
// ADL (possibly involving implicit conversions).
// (Use SFINAE via return type, because it seems GCC < 12 doesn't handle name
// lookup properly when we do it in the template parameter list.)
- static auto PrintValue(const T& value, ::std::ostream* os)
- -> decltype((void)(*os << value)) {
+ static auto PrintValue(const T& value,
+ ::std::ostream* os) -> decltype((void)(*os << value)) {
// Call streaming operator found by ADL, possibly with implicit conversions
// of the arguments.
*os << value;
@@ -292,10 +296,9 @@
#ifdef GTEST_HAS_ABSL
struct ConvertibleToAbslStringifyPrinter {
- template <
- typename T,
- typename = typename std::enable_if<
- absl::strings_internal::HasAbslStringify<T>::value>::type> // NOLINT
+ template <typename T,
+ typename = typename std::enable_if<
+ absl::HasAbslStringify<T>::value>::type> // NOLINT
static void PrintValue(const T& value, ::std::ostream* os) {
*os << absl::StrCat(value);
}
@@ -553,49 +556,63 @@
int full = std::numeric_limits<FloatType>::max_digits10;
if (val < 0) val = -val;
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
if (val < 1000000) {
FloatType mulfor6 = 1e10;
- if (val >= 100000.0) { // 100,000 to 999,999
+ // Without these static casts, the template instantiation for float would
+ // fail to compile when -Wdouble-promotion is enabled, as the arithmetic and
+ // comparison logic would promote floats to doubles.
+ if (val >= static_cast<FloatType>(100000.0)) { // 100,000 to 999,999
mulfor6 = 1.0;
- } else if (val >= 10000.0) {
+ } else if (val >= static_cast<FloatType>(10000.0)) {
mulfor6 = 1e1;
- } else if (val >= 1000.0) {
+ } else if (val >= static_cast<FloatType>(1000.0)) {
mulfor6 = 1e2;
- } else if (val >= 100.0) {
+ } else if (val >= static_cast<FloatType>(100.0)) {
mulfor6 = 1e3;
- } else if (val >= 10.0) {
+ } else if (val >= static_cast<FloatType>(10.0)) {
mulfor6 = 1e4;
- } else if (val >= 1.0) {
+ } else if (val >= static_cast<FloatType>(1.0)) {
mulfor6 = 1e5;
- } else if (val >= 0.1) {
+ } else if (val >= static_cast<FloatType>(0.1)) {
mulfor6 = 1e6;
- } else if (val >= 0.01) {
+ } else if (val >= static_cast<FloatType>(0.01)) {
mulfor6 = 1e7;
- } else if (val >= 0.001) {
+ } else if (val >= static_cast<FloatType>(0.001)) {
mulfor6 = 1e8;
- } else if (val >= 0.0001) {
+ } else if (val >= static_cast<FloatType>(0.0001)) {
mulfor6 = 1e9;
}
- if (static_cast<FloatType>(static_cast<int32_t>(val * mulfor6 + 0.5)) /
+ if (static_cast<FloatType>(static_cast<int32_t>(
+ val * mulfor6 + (static_cast<FloatType>(0.5)))) /
mulfor6 ==
val)
return 6;
- } else if (val < 1e10) {
- FloatType divfor6 = 1.0;
- if (val >= 1e9) { // 1,000,000,000 to 9,999,999,999
+ } 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
divfor6 = 10000;
- } else if (val >= 1e8) { // 100,000,000 to 999,999,999
+ } else if (val >=
+ static_cast<FloatType>(1e8)) { // 100,000,000 to 999,999,999
divfor6 = 1000;
- } else if (val >= 1e7) { // 10,000,000 to 99,999,999
+ } else if (val >=
+ static_cast<FloatType>(1e7)) { // 10,000,000 to 99,999,999
divfor6 = 100;
- } else if (val >= 1e6) { // 1,000,000 to 9,999,999
+ } else if (val >= static_cast<FloatType>(1e6)) { // 1,000,000 to 9,999,999
divfor6 = 10;
}
- if (static_cast<FloatType>(static_cast<int32_t>(val / divfor6 + 0.5)) *
+ if (static_cast<FloatType>(static_cast<int32_t>(
+ val / divfor6 + (static_cast<FloatType>(0.5)))) *
divfor6 ==
val)
return 6;
}
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
return full;
}
@@ -769,6 +786,41 @@
(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>
diff --git a/third_party/googletest/googletest/include/gtest/gtest-typed-test.h b/third_party/googletest/googletest/include/gtest/gtest-typed-test.h
index 72de536..442e00b 100644
--- a/third_party/googletest/googletest/include/gtest/gtest-typed-test.h
+++ b/third_party/googletest/googletest/include/gtest/gtest-typed-test.h
@@ -205,8 +205,8 @@
typedef gtest_TypeParam_ TypeParam; \
void TestBody() override; \
}; \
- static bool gtest_##CaseName##_##TestName##_registered_ \
- GTEST_ATTRIBUTE_UNUSED_ = ::testing::internal::TypeParameterizedTest< \
+ [[maybe_unused]] static bool gtest_##CaseName##_##TestName##_registered_ = \
+ ::testing::internal::TypeParameterizedTest< \
CaseName, \
::testing::internal::TemplateSel<GTEST_TEST_CLASS_NAME_(CaseName, \
TestName)>, \
@@ -267,22 +267,22 @@
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; \
- }; \
- 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_( \
+#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_( \
SuiteName)::TestName<gtest_TypeParam_>::TestBody()
// Note: this won't work correctly if the trailing arguments are macros.
@@ -290,8 +290,8 @@
namespace GTEST_SUITE_NAMESPACE_(SuiteName) { \
typedef ::testing::internal::Templates<__VA_ARGS__> gtest_AllTests_; \
} \
- static const char* const GTEST_REGISTERED_TEST_NAMES_( \
- SuiteName) GTEST_ATTRIBUTE_UNUSED_ = \
+ [[maybe_unused]] static const char* const GTEST_REGISTERED_TEST_NAMES_( \
+ SuiteName) = \
GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).VerifyRegisteredTestNames( \
GTEST_STRINGIFY_(SuiteName), __FILE__, __LINE__, #__VA_ARGS__)
@@ -306,7 +306,7 @@
#define INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, SuiteName, Types, ...) \
static_assert(sizeof(GTEST_STRINGIFY_(Prefix)) > 1, \
"test-suit-prefix must not be empty"); \
- static bool gtest_##Prefix##_##SuiteName GTEST_ATTRIBUTE_UNUSED_ = \
+ [[maybe_unused]] static bool gtest_##Prefix##_##SuiteName = \
::testing::internal::TypeParameterizedTestSuite< \
SuiteName, GTEST_SUITE_NAMESPACE_(SuiteName)::gtest_AllTests_, \
::testing::internal::GenerateTypeList<Types>::type>:: \
diff --git a/third_party/googletest/googletest/include/gtest/gtest.h b/third_party/googletest/googletest/include/gtest/gtest.h
index a932e68..7be0caa 100644
--- a/third_party/googletest/googletest/include/gtest/gtest.h
+++ b/third_party/googletest/googletest/include/gtest/gtest.h
@@ -60,16 +60,16 @@
#include <type_traits>
#include <vector>
-#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/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/internal/gtest-internal.h"
#include "gtest/internal/gtest-string.h"
@@ -607,7 +607,7 @@
friend class internal::UnitTestImpl;
friend class internal::StreamingListenerTest;
friend TestInfo* internal::MakeAndRegisterTestInfo(
- const char* test_suite_name, const char* name, const char* type_param,
+ std::string test_suite_name, const char* name, const char* type_param,
const char* value_param, internal::CodeLocation code_location,
internal::TypeId fixture_class_id, internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc,
@@ -615,7 +615,7 @@
// Constructs a TestInfo object. The newly constructed instance assumes
// ownership of the factory object.
- TestInfo(const std::string& test_suite_name, const std::string& name,
+ TestInfo(std::string test_suite_name, std::string name,
const char* a_type_param, // NULL if not a type-parameterized test
const char* a_value_param, // NULL if not a value-parameterized test
internal::CodeLocation a_code_location,
@@ -683,7 +683,7 @@
// this is not a type-parameterized test.
// set_up_tc: pointer to the function that sets up the test suite
// tear_down_tc: pointer to the function that tears down the test suite
- TestSuite(const char* name, const char* a_type_param,
+ TestSuite(const std::string& name, const char* a_type_param,
internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc);
@@ -1123,7 +1123,7 @@
// This method can only be called from the main thread.
//
// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
- int Run() GTEST_MUST_USE_RESULT_;
+ [[nodiscard]] int Run();
// Returns the working directory when the first TEST() or TEST_F()
// was executed. The UnitTest object owns the string.
@@ -1262,6 +1262,20 @@
// 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_; }
@@ -1270,6 +1284,8 @@
// 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;
@@ -1751,6 +1767,7 @@
// 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.
@@ -2307,11 +2324,12 @@
// tests are successful, or 1 otherwise.
//
// RUN_ALL_TESTS() should be invoked after the command line has been
-// parsed by InitGoogleTest().
+// parsed by InitGoogleTest(). RUN_ALL_TESTS will tear down and delete any
+// installed environments and should only be called once per binary.
//
// This function was formerly a macro; thus, it is in the global
// namespace and has an all-caps name.
-int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_;
+[[nodiscard]] int RUN_ALL_TESTS();
inline int RUN_ALL_TESTS() { return ::testing::UnitTest::GetInstance()->Run(); }
diff --git a/third_party/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h b/third_party/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
index 8e9c988..b363259 100644
--- a/third_party/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
+++ b/third_party/googletest/googletest/include/gtest/internal/gtest-death-test-internal.h
@@ -46,17 +46,38 @@
#include "gtest/gtest-matchers.h"
#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-port.h"
GTEST_DECLARE_string_(internal_run_death_test);
namespace testing {
namespace internal {
-// Names of the flags (needed for parsing Google Test flags).
-const char kDeathTestStyleFlag[] = "death_test_style";
-const char kDeathTestUseFork[] = "death_test_use_fork";
+// Name of the flag (needed for parsing Google Test flag).
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 \
@@ -73,7 +94,7 @@
//
// 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:
@@ -170,28 +191,6 @@
// 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
diff --git a/third_party/googletest/googletest/include/gtest/internal/gtest-filepath.h b/third_party/googletest/googletest/include/gtest/internal/gtest-filepath.h
index 5189c81..6dc47be 100644
--- a/third_party/googletest/googletest/include/gtest/internal/gtest-filepath.h
+++ b/third_party/googletest/googletest/include/gtest/internal/gtest-filepath.h
@@ -43,6 +43,7 @@
#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
#include <string>
+#include <utility>
#include "gtest/internal/gtest-port.h"
#include "gtest/internal/gtest-string.h"
@@ -70,8 +71,9 @@
public:
FilePath() : pathname_("") {}
FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) {}
+ FilePath(FilePath&& rhs) noexcept : pathname_(std::move(rhs.pathname_)) {}
- explicit FilePath(const std::string& pathname) : pathname_(pathname) {
+ explicit FilePath(std::string pathname) : pathname_(std::move(pathname)) {
Normalize();
}
@@ -79,6 +81,10 @@
Set(rhs);
return *this;
}
+ FilePath& operator=(FilePath&& rhs) noexcept {
+ pathname_ = std::move(rhs.pathname_);
+ return *this;
+ }
void Set(const FilePath& rhs) { pathname_ = rhs.pathname_; }
diff --git a/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h b/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h
index 4f077fc..dcab397 100644
--- a/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h
+++ b/third_party/googletest/googletest/include/gtest/internal/gtest-internal.h
@@ -474,8 +474,8 @@
using TearDownTestSuiteFunc = void (*)();
struct CodeLocation {
- CodeLocation(const std::string& a_file, int a_line)
- : file(a_file), line(a_line) {}
+ CodeLocation(std::string a_file, int a_line)
+ : file(std::move(a_file)), line(a_line) {}
std::string file;
int line;
@@ -555,7 +555,7 @@
// type_param: the name of the test's type parameter, or NULL if
// this is not a typed or a type-parameterized test.
// value_param: text representation of the test's value parameter,
-// or NULL if this is not a type-parameterized test.
+// or NULL if this is not a value-parameterized test.
// code_location: code location where the test is defined
// fixture_class_id: ID of the test fixture class
// set_up_tc: pointer to the function that sets up the test suite
@@ -564,7 +564,7 @@
// The newly created TestInfo instance will assume
// ownership of the factory object.
GTEST_API_ TestInfo* MakeAndRegisterTestInfo(
- const char* test_suite_name, const char* name, const char* type_param,
+ std::string test_suite_name, const char* name, const char* type_param,
const char* value_param, CodeLocation code_location,
TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory);
@@ -595,8 +595,7 @@
fflush(stderr);
posix::Abort();
}
- registered_tests_.insert(
- ::std::make_pair(test_name, CodeLocation(file, line)));
+ registered_tests_.emplace(test_name, CodeLocation(file, line));
return true;
}
@@ -700,7 +699,7 @@
// specified in INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, TestSuite,
// Types). Valid values for 'index' are [0, N - 1] where N is the
// length of Types.
- static bool Register(const char* prefix, const CodeLocation& code_location,
+ static bool Register(const char* prefix, CodeLocation code_location,
const char* case_name, const char* test_names, int index,
const std::vector<std::string>& type_names =
GenerateNames<DefaultNameGenerator, Types>()) {
@@ -712,8 +711,7 @@
// list.
MakeAndRegisterTestInfo(
(std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name +
- "/" + type_names[static_cast<size_t>(index)])
- .c_str(),
+ "/" + type_names[static_cast<size_t>(index)]),
StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(),
GetTypeName<Type>().c_str(),
nullptr, // No value parameter.
@@ -725,13 +723,9 @@
new TestFactoryImpl<TestClass>);
// Next, recurses (at compile time) with the tail of the type list.
- return TypeParameterizedTest<Fixture, TestSel,
- typename Types::Tail>::Register(prefix,
- code_location,
- case_name,
- test_names,
- index + 1,
- type_names);
+ return TypeParameterizedTest<Fixture, TestSel, typename Types::Tail>::
+ Register(prefix, std::move(code_location), case_name, test_names,
+ index + 1, type_names);
}
};
@@ -739,7 +733,7 @@
template <GTEST_TEMPLATE_ Fixture, class TestSel>
class TypeParameterizedTest<Fixture, TestSel, internal::None> {
public:
- static bool Register(const char* /*prefix*/, const CodeLocation&,
+ static bool Register(const char* /*prefix*/, CodeLocation,
const char* /*case_name*/, const char* /*test_names*/,
int /*index*/,
const std::vector<std::string>& =
@@ -786,7 +780,8 @@
// Next, recurses (at compile time) with the tail of the test list.
return TypeParameterizedTestSuite<Fixture, typename Tests::Tail,
- Types>::Register(prefix, code_location,
+ Types>::Register(prefix,
+ std::move(code_location),
state, case_name,
SkipComma(test_names),
type_names);
@@ -899,11 +894,6 @@
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
@@ -1142,40 +1132,6 @@
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
@@ -1184,7 +1140,7 @@
template <typename>
struct ElemFromListImpl;
template <size_t... I>
-struct ElemFromListImpl<IndexSequence<I...>> {
+struct ElemFromListImpl<std::index_sequence<I...>> {
// We make Ignore a template to solve a problem with MSVC.
// A non-template Ignore would work fine with `decltype(Ignore(I))...`, but
// MSVC doesn't understand how to deal with that pack expansion.
@@ -1195,9 +1151,8 @@
template <size_t N, typename... T>
struct ElemFromList {
- using type =
- decltype(ElemFromListImpl<typename MakeIndexSequence<N>::type>::Apply(
- static_cast<T (*)()>(nullptr)...));
+ using type = decltype(ElemFromListImpl<std::make_index_sequence<N>>::Apply(
+ static_cast<T (*)()>(nullptr)...));
};
struct FlatTupleConstructTag {};
@@ -1222,9 +1177,9 @@
struct FlatTupleBase;
template <size_t... Idx, typename... T>
-struct FlatTupleBase<FlatTuple<T...>, IndexSequence<Idx...>>
+struct FlatTupleBase<FlatTuple<T...>, std::index_sequence<Idx...>>
: FlatTupleElemBase<FlatTuple<T...>, Idx>... {
- using Indices = IndexSequence<Idx...>;
+ using Indices = std::index_sequence<Idx...>;
FlatTupleBase() = default;
template <typename... Args>
explicit FlatTupleBase(FlatTupleConstructTag, Args&&... args)
@@ -1259,14 +1214,15 @@
// implementations.
// FlatTuple and ElemFromList are not recursive and have a fixed depth
// regardless of T...
-// MakeIndexSequence, on the other hand, it is recursive but with an
+// std::make_index_sequence, on the other hand, it is recursive but with an
// instantiation depth of O(ln(N)).
template <typename... T>
class FlatTuple
: private FlatTupleBase<FlatTuple<T...>,
- typename MakeIndexSequence<sizeof...(T)>::type> {
- using Indices = typename FlatTupleBase<
- FlatTuple<T...>, typename MakeIndexSequence<sizeof...(T)>::type>::Indices;
+ std::make_index_sequence<sizeof...(T)>> {
+ using Indices =
+ typename FlatTupleBase<FlatTuple<T...>,
+ std::make_index_sequence<sizeof...(T)>>::Indices;
public:
FlatTuple() = default;
@@ -1280,30 +1236,40 @@
// Utility functions to be called with static_assert to induce deprecation
// warnings.
-GTEST_INTERNAL_DEPRECATED(
+[[deprecated(
"INSTANTIATE_TEST_CASE_P is deprecated, please use "
- "INSTANTIATE_TEST_SUITE_P")
-constexpr bool InstantiateTestCase_P_IsDeprecated() { return true; }
+ "INSTANTIATE_TEST_SUITE_P")]]
+constexpr bool InstantiateTestCase_P_IsDeprecated() {
+ return true;
+}
-GTEST_INTERNAL_DEPRECATED(
+[[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;
+}
-GTEST_INTERNAL_DEPRECATED(
+[[deprecated(
"TYPED_TEST_CASE is deprecated, please use "
- "TYPED_TEST_SUITE")
-constexpr bool TypedTestCaseIsDeprecated() { return true; }
+ "TYPED_TEST_SUITE")]]
+constexpr bool TypedTestCaseIsDeprecated() {
+ return true;
+}
-GTEST_INTERNAL_DEPRECATED(
+[[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;
+}
-GTEST_INTERNAL_DEPRECATED(
+[[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
@@ -1540,7 +1506,7 @@
\
private: \
void TestBody() override; \
- static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_; \
+ [[maybe_unused]] static ::testing::TestInfo* const test_info_; \
}; \
\
::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name, \
diff --git a/third_party/googletest/googletest/include/gtest/internal/gtest-param-util.h b/third_party/googletest/googletest/include/gtest/internal/gtest-param-util.h
index dd39e98..cc7ea53 100644
--- a/third_party/googletest/googletest/include/gtest/internal/gtest-param-util.h
+++ b/third_party/googletest/googletest/include/gtest/internal/gtest-param-util.h
@@ -47,6 +47,7 @@
#include <string>
#include <tuple>
#include <type_traits>
+#include <unordered_map>
#include <utility>
#include <vector>
@@ -85,7 +86,7 @@
// TEST_P macro is used to define two tests with the same name
// but in different namespaces.
GTEST_API_ void ReportInvalidTestSuiteType(const char* test_suite_name,
- CodeLocation code_location);
+ const CodeLocation& code_location);
template <typename>
class ParamGeneratorInterface;
@@ -379,9 +380,7 @@
// integer test parameter index.
template <class ParamType>
std::string DefaultParamName(const TestParamInfo<ParamType>& info) {
- Message name_stream;
- name_stream << info.index;
- return name_stream.GetString();
+ return std::to_string(info.index);
}
template <typename T = int>
@@ -513,9 +512,10 @@
typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
using ParamNameGeneratorFunc = std::string(const TestParamInfo<ParamType>&);
- explicit ParameterizedTestSuiteInfo(const char* name,
+ explicit ParameterizedTestSuiteInfo(std::string name,
CodeLocation code_location)
- : test_suite_name_(name), code_location_(code_location) {}
+ : test_suite_name_(std::move(name)),
+ code_location_(std::move(code_location)) {}
// Test suite base name for display purposes.
const std::string& GetTestSuiteName() const override {
@@ -529,20 +529,21 @@
// prefix). test_base_name is the name of an individual test without
// parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is
// test suite base name and DoBar is test base name.
- void AddTestPattern(const char* test_suite_name, const char* test_base_name,
+ void AddTestPattern(const char*,
+ const char* test_base_name,
TestMetaFactoryBase<ParamType>* meta_factory,
CodeLocation code_location) {
- tests_.push_back(std::shared_ptr<TestInfo>(new TestInfo(
- test_suite_name, test_base_name, meta_factory, code_location)));
+ tests_.emplace_back(
+ new TestInfo(test_base_name, meta_factory, std::move(code_location)));
}
// INSTANTIATE_TEST_SUITE_P macro uses AddGenerator() to record information
// about a generator.
- int AddTestSuiteInstantiation(const std::string& instantiation_name,
+ int AddTestSuiteInstantiation(std::string instantiation_name,
GeneratorCreationFunc* func,
ParamNameGeneratorFunc* name_func,
const char* file, int line) {
- instantiations_.push_back(
- InstantiationInfo(instantiation_name, func, name_func, file, line));
+ instantiations_.emplace_back(std::move(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
@@ -553,62 +554,61 @@
void RegisterTests() override {
bool generated_instantiations = false;
- for (typename TestInfoContainer::iterator test_it = tests_.begin();
- test_it != tests_.end(); ++test_it) {
- std::shared_ptr<TestInfo> test_info = *test_it;
- for (typename InstantiationContainer::iterator gen_it =
- instantiations_.begin();
- gen_it != instantiations_.end(); ++gen_it) {
- const std::string& instantiation_name = gen_it->name;
- ParamGenerator<ParamType> generator((*gen_it->generator)());
- ParamNameGeneratorFunc* name_func = gen_it->name_func;
- const char* file = gen_it->file;
- int line = gen_it->line;
+ std::string test_suite_name;
+ std::string test_name;
+ for (const std::shared_ptr<TestInfo>& test_info : tests_) {
+ for (const InstantiationInfo& instantiation : instantiations_) {
+ const std::string& instantiation_name = instantiation.name;
+ ParamGenerator<ParamType> generator((*instantiation.generator)());
+ ParamNameGeneratorFunc* name_func = instantiation.name_func;
+ const char* file = instantiation.file;
+ int line = instantiation.line;
- std::string test_suite_name;
if (!instantiation_name.empty())
test_suite_name = instantiation_name + "/";
- test_suite_name += test_info->test_suite_base_name;
+ else
+ test_suite_name.clear();
+ test_suite_name += test_suite_name_;
size_t i = 0;
std::set<std::string> test_param_names;
- for (typename ParamGenerator<ParamType>::iterator param_it =
- generator.begin();
- param_it != generator.end(); ++param_it, ++i) {
+ for (const auto& param : generator) {
generated_instantiations = true;
- Message test_name_stream;
+ test_name.clear();
std::string param_name =
- name_func(TestParamInfo<ParamType>(*param_it, i));
+ name_func(TestParamInfo<ParamType>(param, i));
GTEST_CHECK_(IsValidParamName(param_name))
<< "Parameterized test name '" << param_name
- << "' is invalid (contains spaces, dashes, underscores, or "
- "non-alphanumeric characters), in "
+ << "' is invalid (contains spaces, dashes, or any "
+ "non-alphanumeric characters other than underscores), in "
<< file << " line " << line << "" << std::endl;
GTEST_CHECK_(test_param_names.count(param_name) == 0)
<< "Duplicate parameterized test name '" << param_name << "', in "
<< file << " line " << line << std::endl;
- test_param_names.insert(param_name);
-
if (!test_info->test_base_name.empty()) {
- test_name_stream << test_info->test_base_name << "/";
+ test_name.append(test_info->test_base_name).append("/");
}
- test_name_stream << param_name;
+ test_name += param_name;
+
+ test_param_names.insert(std::move(param_name));
+
MakeAndRegisterTestInfo(
- test_suite_name.c_str(), test_name_stream.GetString().c_str(),
+ test_suite_name, test_name.c_str(),
nullptr, // No type parameter.
- PrintToString(*param_it).c_str(), test_info->code_location,
+ PrintToString(param).c_str(), test_info->code_location,
GetTestSuiteTypeId(),
SuiteApiResolver<TestSuite>::GetSetUpCaseOrSuite(file, line),
SuiteApiResolver<TestSuite>::GetTearDownCaseOrSuite(file, line),
- test_info->test_meta_factory->CreateTestFactory(*param_it));
- } // for param_it
- } // for gen_it
- } // for test_it
+ test_info->test_meta_factory->CreateTestFactory(param));
+ ++i;
+ } // for param
+ } // for instantiation
+ } // for test_info
if (!generated_instantiations) {
// There are no generaotrs, or they all generate nothing ...
@@ -621,15 +621,13 @@
// LocalTestInfo structure keeps information about a single test registered
// with TEST_P macro.
struct TestInfo {
- TestInfo(const char* a_test_suite_base_name, const char* a_test_base_name,
+ TestInfo(const char* a_test_base_name,
TestMetaFactoryBase<ParamType>* a_test_meta_factory,
CodeLocation a_code_location)
- : test_suite_base_name(a_test_suite_base_name),
- test_base_name(a_test_base_name),
+ : test_base_name(a_test_base_name),
test_meta_factory(a_test_meta_factory),
- code_location(a_code_location) {}
+ code_location(std::move(a_code_location)) {}
- const std::string test_suite_base_name;
const std::string test_base_name;
const std::unique_ptr<TestMetaFactoryBase<ParamType>> test_meta_factory;
const CodeLocation code_location;
@@ -639,11 +637,10 @@
// <Instantiation name, Sequence generator creation function,
// Name generator function, Source file, Source line>
struct InstantiationInfo {
- InstantiationInfo(const std::string& name_in,
- GeneratorCreationFunc* generator_in,
+ InstantiationInfo(std::string name_in, GeneratorCreationFunc* generator_in,
ParamNameGeneratorFunc* name_func_in, const char* file_in,
int line_in)
- : name(name_in),
+ : name(std::move(name_in)),
generator(generator_in),
name_func(name_func_in),
file(file_in),
@@ -704,29 +701,32 @@
// tests and instantiations of a particular test suite.
template <class TestSuite>
ParameterizedTestSuiteInfo<TestSuite>* GetTestSuitePatternHolder(
- const char* test_suite_name, CodeLocation code_location) {
+ std::string test_suite_name, CodeLocation code_location) {
ParameterizedTestSuiteInfo<TestSuite>* typed_test_info = nullptr;
- for (auto& test_suite_info : test_suite_infos_) {
- if (test_suite_info->GetTestSuiteName() == test_suite_name) {
- 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;
+
+ 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);
}
}
if (typed_test_info == nullptr) {
typed_test_info = new ParameterizedTestSuiteInfo<TestSuite>(
- test_suite_name, code_location);
+ test_suite_name, std::move(code_location));
+ suite_name_to_info_index_.emplace(std::move(test_suite_name),
+ test_suite_infos_.size());
test_suite_infos_.push_back(typed_test_info);
}
return typed_test_info;
@@ -740,8 +740,9 @@
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
template <class TestCase>
ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
- const char* test_case_name, CodeLocation code_location) {
- return GetTestSuitePatternHolder<TestCase>(test_case_name, code_location);
+ std::string test_case_name, CodeLocation code_location) {
+ return GetTestSuitePatternHolder<TestCase>(std::move(test_case_name),
+ std::move(code_location));
}
#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
@@ -750,6 +751,7 @@
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;
@@ -776,7 +778,7 @@
private:
struct TypeParameterizedTestSuiteInfo {
explicit TypeParameterizedTestSuiteInfo(CodeLocation c)
- : code_location(c), instantiated(false) {}
+ : code_location(std::move(c)), instantiated(false) {}
CodeLocation code_location;
bool instantiated;
@@ -805,12 +807,12 @@
template <typename T>
operator ParamGenerator<T>() const { // NOLINT
- return ValuesIn(MakeVector<T>(MakeIndexSequence<sizeof...(Ts)>()));
+ return ValuesIn(MakeVector<T>(std::make_index_sequence<sizeof...(Ts)>()));
}
private:
template <typename T, size_t... I>
- std::vector<T> MakeVector(IndexSequence<I...>) const {
+ std::vector<T> MakeVector(std::index_sequence<I...>) const {
return std::vector<T>{static_cast<T>(v_.template Get<I>())...};
}
@@ -840,7 +842,7 @@
template <class I>
class IteratorImpl;
template <size_t... I>
- class IteratorImpl<IndexSequence<I...>>
+ class IteratorImpl<std::index_sequence<I...>>
: public ParamIteratorInterface<ParamType> {
public:
IteratorImpl(const ParamGeneratorInterface<ParamType>* base,
@@ -931,7 +933,7 @@
std::shared_ptr<ParamType> current_value_;
};
- using Iterator = IteratorImpl<typename MakeIndexSequence<sizeof...(T)>::type>;
+ using Iterator = IteratorImpl<std::make_index_sequence<sizeof...(T)>>;
std::tuple<ParamGenerator<T>...> generators_;
};
diff --git a/third_party/googletest/googletest/include/gtest/internal/gtest-port-arch.h b/third_party/googletest/googletest/include/gtest/internal/gtest-port-arch.h
index 3162f2b..7ec968f 100644
--- a/third_party/googletest/googletest/include/gtest/internal/gtest-port-arch.h
+++ b/third_party/googletest/googletest/include/gtest/internal/gtest-port-arch.h
@@ -56,6 +56,8 @@
#elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_TV_TITLE)
#define GTEST_OS_WINDOWS_PHONE 1
#define GTEST_OS_WINDOWS_TV_TITLE 1
+#elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_GAMES)
+#define GTEST_OS_WINDOWS_GAMES 1
#else
// WINAPI_FAMILY defined but no known partition matched.
// Default to desktop.
diff --git a/third_party/googletest/googletest/include/gtest/internal/gtest-port.h b/third_party/googletest/googletest/include/gtest/internal/gtest-port.h
index 35544a0..4cfc16c 100644
--- a/third_party/googletest/googletest/include/gtest/internal/gtest-port.h
+++ b/third_party/googletest/googletest/include/gtest/internal/gtest-port.h
@@ -194,9 +194,6 @@
//
// 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
@@ -262,11 +259,6 @@
// 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.
@@ -277,8 +269,24 @@
#endif
#if !defined(GTEST_INTERNAL_CPLUSPLUS_LANG) || \
- GTEST_INTERNAL_CPLUSPLUS_LANG < 201402L
-#error C++ versions less than C++14 are not supported.
+ 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.
+#if GTEST_INTERNAL_CPLUSPLUS_LANG >= 202002L && \
+ (!defined(__has_include) || GTEST_INTERNAL_HAS_INCLUDE(<version>))
+#include <version> // C++20 and later
+#elif (!defined(__has_include) || GTEST_INTERNAL_HAS_INCLUDE(<ciso646>))
+#include <ciso646> // Pre-C++20
#endif
#include <ctype.h> // for isspace, etc
@@ -322,7 +330,8 @@
#define GTEST_HAS_NOTIFICATION_ 0
#endif
-#ifdef GTEST_HAS_ABSL
+#if defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
+#define GTEST_INTERNAL_HAS_ABSL_FLAGS // Used only in this file.
#include "absl/flags/declare.h"
#include "absl/flags/flag.h"
#include "absl/flags/reflection.h"
@@ -592,7 +601,8 @@
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_GNU_HURD) || defined(GTEST_OS_SOLARIS) || \
+ defined(GTEST_OS_AIX) || defined(GTEST_OS_ZOS))
#define GTEST_HAS_PTHREAD 1
#else
#define GTEST_HAS_PTHREAD 0
@@ -642,9 +652,9 @@
// 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_ESP8266) || \
- defined(GTEST_OS_XTENSA) || defined(GTEST_OS_QURT) || \
- !GTEST_HAS_FILE_SYSTEM
+ 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
#define GTEST_HAS_STREAM_REDIRECTION 0
#else
#define GTEST_HAS_STREAM_REDIRECTION 1
@@ -654,7 +664,7 @@
// 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_SOLARIS) || defined(GTEST_OS_ZOS) || \
(defined(GTEST_OS_MAC) && !defined(GTEST_OS_IOS)) || \
(defined(GTEST_OS_WINDOWS_DESKTOP) && _MSC_VER) || \
defined(GTEST_OS_WINDOWS_MINGW) || defined(GTEST_OS_AIX) || \
@@ -732,6 +742,20 @@
#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
@@ -742,17 +766,6 @@
#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
@@ -767,17 +780,6 @@
#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:
@@ -829,9 +831,9 @@
#ifndef GTEST_API_
#ifdef _MSC_VER
-#if GTEST_LINKED_AS_SHARED_LIBRARY
+#if defined(GTEST_LINKED_AS_SHARED_LIBRARY) && GTEST_LINKED_AS_SHARED_LIBRARY
#define GTEST_API_ __declspec(dllimport)
-#elif GTEST_CREATE_SHARED_LIBRARY
+#elif defined(GTEST_CREATE_SHARED_LIBRARY) && GTEST_CREATE_SHARED_LIBRARY
#define GTEST_API_ __declspec(dllexport)
#endif
#elif GTEST_HAVE_ATTRIBUTE_(visibility)
@@ -1989,7 +1991,9 @@
namespace posix {
// File system porting.
-#if GTEST_HAS_FILE_SYSTEM
+// 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.
#ifdef GTEST_OS_WINDOWS
typedef struct _stat StatStruct;
@@ -2000,27 +2004,32 @@
// 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
@@ -2029,9 +2038,9 @@
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.
@@ -2084,8 +2093,9 @@
// 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_ESP8266) && \
- !defined(GTEST_OS_XTENSA) && !defined(GTEST_OS_QURT)
+ !defined(GTEST_OS_WINDOWS_RT) && !defined(GTEST_OS_WINDOWS_GAMES) && \
+ !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) {
@@ -2229,7 +2239,7 @@
#endif // !defined(GTEST_FLAG)
// Pick a command line flags implementation.
-#ifdef GTEST_HAS_ABSL
+#ifdef GTEST_INTERNAL_HAS_ABSL_FLAGS
// Macros for defining flags.
#define GTEST_DEFINE_bool_(name, default_val, doc) \
@@ -2254,7 +2264,8 @@
(void)(::absl::SetFlag(>EST_FLAG(name), value))
#define GTEST_USE_OWN_FLAGFILE_FLAG_ 0
-#else // GTEST_HAS_ABSL
+#undef GTEST_INTERNAL_HAS_ABSL_FLAGS
+#else // ndef GTEST_INTERNAL_HAS_ABSL_FLAGS
// Macros for defining flags.
#define GTEST_DEFINE_bool_(name, default_val, doc) \
@@ -2296,7 +2307,7 @@
#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
#define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
-#endif // GTEST_HAS_ABSL
+#endif // GTEST_INTERNAL_HAS_ABSL_FLAGS
// Thread annotations
#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
@@ -2320,26 +2331,6 @@
} // namespace internal
} // namespace testing
-#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_DEPRECATED(message)
-#endif
-
-#endif // !defined(GTEST_INTERNAL_DEPRECATED)
-
#ifdef GTEST_HAS_ABSL
// Always use absl::any for UniversalPrinter<> specializations if googletest
// is built with absl support.
@@ -2351,9 +2342,9 @@
} // namespace internal
} // namespace testing
#else
-#ifdef __has_include
-#if __has_include(<any>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L && \
- (!defined(_MSC_VER) || GTEST_HAS_RTTI)
+#if defined(__cpp_lib_any) || (GTEST_INTERNAL_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
@@ -2365,8 +2356,7 @@
} // 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 // __cpp_lib_any
#endif // GTEST_HAS_ABSL
#ifndef GTEST_INTERNAL_HAS_ANY
@@ -2386,8 +2376,8 @@
} // namespace internal
} // namespace testing
#else
-#ifdef __has_include
-#if __has_include(<optional>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
+#if defined(__cpp_lib_optional) || (GTEST_INTERNAL_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
@@ -2401,19 +2391,17 @@
} // 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 // __cpp_lib_optional
#endif // GTEST_HAS_ABSL
#ifndef GTEST_INTERNAL_HAS_OPTIONAL
#define GTEST_INTERNAL_HAS_OPTIONAL 0
#endif
-#ifdef __has_include
-#if __has_include(<span>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 202002L
+#if defined(__cpp_lib_span) || (GTEST_INTERNAL_HAS_INCLUDE(<span>) && \
+ GTEST_INTERNAL_CPLUSPLUS_LANG >= 202002L)
#define GTEST_INTERNAL_HAS_STD_SPAN 1
-#endif // __has_include(<span>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 202002L
-#endif // __has_include
+#endif // __cpp_lib_span
#ifndef GTEST_INTERNAL_HAS_STD_SPAN
#define GTEST_INTERNAL_HAS_STD_SPAN 0
@@ -2430,8 +2418,9 @@
} // namespace internal
} // namespace testing
#else
-#ifdef __has_include
-#if __has_include(<string_view>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
+#if defined(__cpp_lib_string_view) || \
+ (GTEST_INTERNAL_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
@@ -2443,9 +2432,7 @@
} // namespace testing
// The case where absl is configured NOT to alias std::string_view is not
// supported.
-#endif // __has_include(<string_view>) && GTEST_INTERNAL_CPLUSPLUS_LANG >=
- // 201703L
-#endif // __has_include
+#endif // __cpp_lib_string_view
#endif // GTEST_HAS_ABSL
#ifndef GTEST_INTERNAL_HAS_STRING_VIEW
@@ -2464,8 +2451,8 @@
} // namespace internal
} // namespace testing
#else
-#ifdef __has_include
-#if __has_include(<variant>) && GTEST_INTERNAL_CPLUSPLUS_LANG >= 201703L
+#if defined(__cpp_lib_variant) || (GTEST_INTERNAL_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
@@ -2477,17 +2464,19 @@
} // 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 // __cpp_lib_variant
#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
+#if (defined(__cpp_lib_three_way_comparison) || \
+ (GTEST_INTERNAL_HAS_INCLUDE(<compare>) && \
+ GTEST_INTERNAL_CPLUSPLUS_LANG >= 201907L))
+#define GTEST_INTERNAL_HAS_COMPARE_LIB 1
+#else
+#define GTEST_INTERNAL_HAS_COMPARE_LIB 0
#endif
#endif // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
diff --git a/third_party/googletest/googletest/include/gtest/internal/gtest-type-util.h b/third_party/googletest/googletest/include/gtest/internal/gtest-type-util.h
index f94cf61..78da053 100644
--- a/third_party/googletest/googletest/include/gtest/internal/gtest-type-util.h
+++ b/third_party/googletest/googletest/include/gtest/internal/gtest-type-util.h
@@ -71,7 +71,7 @@
// Strip redundant spaces in typename to match MSVC
// For example, std::pair<int, bool> -> std::pair<int,bool>
static const char to_search[] = ", ";
- static const char replace_str[] = ",";
+ const char replace_char = ',';
size_t pos = 0;
while (true) {
// Get the next occurrence from the current position
@@ -80,8 +80,8 @@
break;
}
// Replace this occurrence of substring
- s.replace(pos, strlen(to_search), replace_str);
- pos += strlen(replace_str);
+ s.replace(pos, strlen(to_search), 1, replace_char);
+ ++pos;
}
return s;
}
diff --git a/third_party/googletest/googletest/src/gtest-death-test.cc b/third_party/googletest/googletest/src/gtest-death-test.cc
index 8417a30..15472f1 100644
--- a/third_party/googletest/googletest/src/gtest-death-test.cc
+++ b/third_party/googletest/googletest/src/gtest-death-test.cc
@@ -32,6 +32,8 @@
#include "gtest/gtest-death-test.h"
+#include <stdlib.h>
+
#include <functional>
#include <memory>
#include <sstream>
@@ -115,7 +117,7 @@
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 "
@@ -299,7 +301,7 @@
fputc(kDeathTestInternalError, parent);
fprintf(parent, "%s", message.c_str());
fflush(parent);
- _exit(1);
+ _Exit(1);
} else {
fprintf(stderr, "%s", message.c_str());
fflush(stderr);
@@ -511,7 +513,7 @@
// 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
@@ -523,13 +525,13 @@
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.
@@ -628,13 +630,13 @@
#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::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];
+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]);
}
- result[args.size()] = nullptr; // extra null terminator
+ result.push_back(nullptr); // Extra null terminator.
return result;
}
#endif
@@ -1034,8 +1036,8 @@
// "Fuchsia Test Component" which contains a "Fuchsia Component Manifest")
// Launching processes is a privileged operation in Fuchsia, and the
// declaration indicates that the ability is required for the component.
- std::unique_ptr<char*[]> argv = CreateArgvFromArgs(args);
- status = fdio_spawn_etc(child_job, FDIO_SPAWN_CLONE_ALL, argv[0], argv.get(),
+ std::vector<char*> argv = CreateArgvFromArgs(args);
+ status = fdio_spawn_etc(child_job, FDIO_SPAWN_CLONE_ALL, argv[0], argv.data(),
nullptr, 2, spawn_actions,
child_process_.reset_and_get_address(), nullptr);
GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
@@ -1333,7 +1335,7 @@
#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
@@ -1386,8 +1388,8 @@
// is necessary.
FlushInfoLog();
- std::unique_ptr<char*[]> argv = CreateArgvFromArgs(args);
- const pid_t child_pid = ExecDeathTestSpawnChild(argv.get(), pipe_fd[0]);
+ std::vector<char*> argv = CreateArgvFromArgs(args);
+ const pid_t child_pid = ExecDeathTestSpawnChild(argv.data(), pipe_fd[0]);
GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
set_child_pid(child_pid);
set_read_fd(pipe_fd[0]);
diff --git a/third_party/googletest/googletest/src/gtest-filepath.cc b/third_party/googletest/googletest/src/gtest-filepath.cc
index 513e947..902d8c7 100644
--- a/third_party/googletest/googletest/src/gtest-filepath.cc
+++ b/third_party/googletest/googletest/src/gtest-filepath.cc
@@ -336,7 +336,7 @@
return false;
}
- if (pathname_.length() == 0 || this->DirectoryExists()) {
+ if (pathname_.empty() || this->DirectoryExists()) {
return true;
}
diff --git a/third_party/googletest/googletest/src/gtest-internal-inl.h b/third_party/googletest/googletest/src/gtest-internal-inl.h
index 4799a1e..cc6f004 100644
--- a/third_party/googletest/googletest/src/gtest-internal-inl.h
+++ b/third_party/googletest/googletest/src/gtest-internal-inl.h
@@ -46,6 +46,7 @@
#include <memory>
#include <set>
#include <string>
+#include <unordered_map>
#include <vector>
#include "gtest/internal/gtest-port.h"
@@ -649,13 +650,15 @@
// 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 char* test_suite_name, const char* type_param,
+ TestSuite* GetTestSuite(const std::string& 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 char* test_case_name, const char* type_param,
+ TestCase* GetTestCase(const std::string& 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);
@@ -681,13 +684,13 @@
// AddTestInfo(), which is called to register a TEST or TEST_F
// before main() is reached.
if (original_working_dir_.IsEmpty()) {
- original_working_dir_.Set(FilePath::GetCurrentDir());
+ original_working_dir_ = 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);
}
@@ -709,18 +712,6 @@
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
@@ -835,12 +826,30 @@
bool catch_exceptions() const { return catch_exceptions_; }
private:
+ 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_;
@@ -873,6 +882,9 @@
// 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
diff --git a/third_party/googletest/googletest/src/gtest-port.cc b/third_party/googletest/googletest/src/gtest-port.cc
index 2aaf2bc..1038ad7 100644
--- a/third_party/googletest/googletest/src/gtest-port.cc
+++ b/third_party/googletest/googletest/src/gtest-port.cc
@@ -158,13 +158,13 @@
// 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]);
@@ -587,9 +587,11 @@
// thread's ID.
typedef std::map<DWORD, ThreadLocalValues> ThreadIdToThreadLocals;
- // Holds the thread id and thread handle that we pass from
- // StartWatcherThreadFor to WatcherThreadFunc.
- typedef std::pair<DWORD, HANDLE> ThreadIdAndHandle;
+ struct WatcherThreadParams {
+ DWORD thread_id;
+ HANDLE handle;
+ Notification has_initialized;
+ };
static void StartWatcherThreadFor(DWORD thread_id) {
// The returned handle will be kept in thread_map and closed by
@@ -597,15 +599,20 @@
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>(new ThreadIdAndHandle(thread_id, thread)),
- CREATE_SUSPENDED, &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);
GTEST_CHECK_(watcher_thread != nullptr)
<< "CreateThread failed with error " << ::GetLastError() << ".";
// Give the watcher thread the same priority as ours to avoid being
@@ -614,17 +621,25 @@
::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) {
- 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;
+ 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;
return 0;
}
@@ -697,13 +712,24 @@
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_EXTENDED) == 0;
+ is_valid_ = regcomp(&full_regex_, full_pattern, reg_flags) == 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
@@ -714,7 +740,7 @@
// 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_EXTENDED) == 0;
+ is_valid_ = regcomp(&partial_regex_, partial_regex, reg_flags) == 0;
}
EXPECT_TRUE(is_valid_)
<< "Regular expression \"" << regex
@@ -1022,11 +1048,21 @@
}
}
+#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_()
-#if GTEST_HAS_STREAM_REDIRECTION
+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
// Object that captures an output stream (stdout/stderr).
class CapturedStream {
@@ -1064,7 +1100,13 @@
// 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.
- name_template = "/data/local/tmp/";
+ //
+ // 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]);
+
#elif defined(GTEST_OS_IOS)
char user_temp_dir[PATH_MAX + 1];
@@ -1084,7 +1126,7 @@
::confstr(_CS_DARWIN_USER_TEMP_DIR, user_temp_dir, sizeof(user_temp_dir));
name_template = user_temp_dir;
- if (name_template.back() != GTEST_PATH_SEP_[0])
+ if (!EndsWithPathSeparator(name_template))
name_template.push_back(GTEST_PATH_SEP_[0]);
#else
name_template = "/tmp/";
@@ -1306,8 +1348,8 @@
) {
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;
diff --git a/third_party/googletest/googletest/src/gtest.cc b/third_party/googletest/googletest/src/gtest.cc
index 62dfef6..81096ae 100644
--- a/third_party/googletest/googletest/src/gtest.cc
+++ b/third_party/googletest/googletest/src/gtest.cc
@@ -43,6 +43,7 @@
#include <algorithm>
#include <chrono> // NOLINT
#include <cmath>
+#include <csignal> // NOLINT: raise(3) is used on some platforms
#include <cstdint>
#include <cstdlib>
#include <cstring>
@@ -161,6 +162,10 @@
#define GTEST_HAS_BUILTIN(x) 0
#endif // defined(__has_builtin)
+#if defined(GTEST_HAS_ABSL) && !defined(GTEST_NO_ABSL_FLAGS)
+#define GTEST_HAS_ABSL_FLAGS
+#endif
+
namespace testing {
using internal::CountIf;
@@ -254,6 +259,12 @@
"True if and only if a test failure should stop further test execution.");
GTEST_DEFINE_bool_(
+ fail_if_no_test_linked,
+ testing::internal::BoolFromGTestEnv("fail_if_no_test_linked", false),
+ "True if and only if the test should fail if no test case (including "
+ "disabled test cases) is linked.");
+
+GTEST_DEFINE_bool_(
also_run_disabled_tests,
testing::internal::BoolFromGTestEnv("also_run_disabled_tests", false),
"Run disabled tests too, in addition to the tests normally being run.");
@@ -374,7 +385,7 @@
testing::internal::StringFromGTestEnv("stream_result_to", ""),
"This flag specifies the host name and the port number on which to stream "
"test results. Example: \"localhost:555\". The flag is effective only on "
- "Linux.");
+ "Linux and macOS.");
GTEST_DEFINE_bool_(
throw_on_failure,
@@ -446,6 +457,19 @@
return test_suite->should_run();
}
+namespace {
+
+// Returns true if test part results of type `type` should include a stack
+// trace.
+bool ShouldEmitStackTraceForResultType(TestPartResult::Type type) {
+ // Suppress emission of the stack trace for SUCCEED() since it likely never
+ // requires investigation, and GTEST_SKIP() since skipping is an intentional
+ // act by the developer rather than a failure requiring investigation.
+ return type != TestPartResult::kSuccess && type != TestPartResult::kSkip;
+}
+
+} // namespace
+
// AssertHelper constructor.
AssertHelper::AssertHelper(TestPartResult::Type type, const char* file,
int line, const char* message)
@@ -458,7 +482,9 @@
UnitTest::GetInstance()->AddTestPartResult(
data_->type, data_->file, data_->line,
AppendUserMessage(data_->message, message),
- UnitTest::GetInstance()->impl()->CurrentOsStackTraceExceptTop(1)
+ ShouldEmitStackTraceForResultType(data_->type)
+ ? UnitTest::GetInstance()->impl()->CurrentOsStackTraceExceptTop(1)
+ : ""
// Skips the stack frame for this function itself.
); // NOLINT
}
@@ -516,7 +542,8 @@
if (ignored.find(name) != ignored.end()) return;
const char kMissingInstantiation[] = //
- " is defined via TEST_P, but never instantiated. None of the test cases "
+ " is defined via TEST_P, but never instantiated. None of the test "
+ "cases "
"will run. Either no INSTANTIATE_TEST_SUITE_P is provided or the only "
"ones provided expand to nothing."
"\n\n"
@@ -557,7 +584,7 @@
void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
CodeLocation code_location) {
GetUnitTestImpl()->type_parameterized_test_registry().RegisterTestSuite(
- test_suite_name, code_location);
+ test_suite_name, std::move(code_location));
}
void RegisterTypeParameterizedTestSuiteInstantiation(const char* case_name) {
@@ -568,7 +595,7 @@
void TypeParameterizedTestSuiteRegistry::RegisterTestSuite(
const char* test_suite_name, CodeLocation code_location) {
suites_.emplace(std::string(test_suite_name),
- TypeParameterizedTestSuiteInfo(code_location));
+ TypeParameterizedTestSuiteInfo(std::move(code_location)));
}
void TypeParameterizedTestSuiteRegistry::RegisterInstantiation(
@@ -595,10 +622,12 @@
"\n\n"
"Ideally, TYPED_TEST_P definitions should only ever be included as "
"part of binaries that intend to use them. (As opposed to, for "
- "example, being placed in a library that may be linked in to get other "
+ "example, being placed in a library that may be linked in to get "
+ "other "
"utilities.)"
"\n\n"
- "To suppress this error for this test suite, insert the following line "
+ "To suppress this error for this test suite, insert the following "
+ "line "
"(in a non-header) in the namespace it is defined in:"
"\n\n"
"GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(" +
@@ -638,11 +667,14 @@
FilePath GetCurrentExecutableName() {
FilePath result;
+ auto args = GetArgvs();
+ if (!args.empty()) {
#if defined(GTEST_OS_WINDOWS) || defined(GTEST_OS_OS2)
- result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
+ result.Set(FilePath(args[0]).RemoveExtension("exe"));
#else
- result.Set(FilePath(GetArgvs()[0]));
+ result.Set(FilePath(args[0]));
#endif // GTEST_OS_WINDOWS
+ }
return result.RemoveDirectoryName();
}
@@ -778,7 +810,7 @@
// Returns true if and only if name matches at least one of the patterns in
// the filter.
bool MatchesName(const std::string& name) const {
- return exact_match_patterns_.count(name) > 0 ||
+ return exact_match_patterns_.find(name) != exact_match_patterns_.end() ||
std::any_of(glob_patterns_.begin(), glob_patterns_.end(),
[&name](const std::string& pattern) {
return PatternMatchesString(
@@ -1634,10 +1666,25 @@
return msg.GetString();
}
-// Helper function for implementing ASSERT_NEAR.
+// Helper function for implementing ASSERT_NEAR. Treats infinity as a specific
+// value, such that comparing infinity to infinity is equal, the distance
+// between -infinity and +infinity is infinity, and infinity <= infinity is
+// true.
AssertionResult DoubleNearPredFormat(const char* expr1, const char* expr2,
const char* abs_error_expr, double val1,
double val2, double abs_error) {
+ // We want to return success when the two values are infinity and at least
+ // one of the following is true:
+ // * The values are the same-signed infinity.
+ // * The error limit itself is infinity.
+ // This is done here so that we don't end up with a NaN when calculating the
+ // difference in values.
+ if (std::isinf(val1) && std::isinf(val2) &&
+ (std::signbit(val1) == std::signbit(val2) ||
+ (abs_error > 0.0 && std::isinf(abs_error)))) {
+ return AssertionSuccess();
+ }
+
const double diff = fabs(val1 - val2);
if (diff <= abs_error) return AssertionSuccess();
@@ -2317,7 +2364,7 @@
"type_param", "value_param", "file", "line"};
// Use a slightly different set for allowed output to ensure existing tests can
-// still RecordProperty("result") or "RecordProperty(timestamp")
+// still RecordProperty("result") or RecordProperty("timestamp")
static const char* const kReservedOutputTestCaseAttributes[] = {
"classname", "name", "status", "time", "type_param",
"value_param", "file", "line", "result", "timestamp"};
@@ -2717,18 +2764,16 @@
// Constructs a TestInfo object. It assumes ownership of the test factory
// object.
-TestInfo::TestInfo(const std::string& a_test_suite_name,
- const std::string& a_name, const char* a_type_param,
- const char* a_value_param,
+TestInfo::TestInfo(std::string a_test_suite_name, std::string a_name,
+ const char* a_type_param, const char* a_value_param,
internal::CodeLocation a_code_location,
internal::TypeId fixture_class_id,
internal::TestFactoryBase* factory)
- : test_suite_name_(a_test_suite_name),
- // begin()/end() is MSVC 17.3.3 ASAN crash workaround (GitHub issue #3997)
- name_(a_name.begin(), a_name.end()),
+ : test_suite_name_(std::move(a_test_suite_name)),
+ name_(std::move(a_name)),
type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
value_param_(a_value_param ? new std::string(a_value_param) : nullptr),
- location_(a_code_location),
+ location_(std::move(a_code_location)),
fixture_class_id_(fixture_class_id),
should_run_(false),
is_disabled_(false),
@@ -2761,19 +2806,19 @@
// The newly created TestInfo instance will assume
// ownership of the factory object.
TestInfo* MakeAndRegisterTestInfo(
- const char* test_suite_name, const char* name, const char* type_param,
+ std::string test_suite_name, const char* name, const char* type_param,
const char* value_param, CodeLocation code_location,
TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory) {
TestInfo* const test_info =
- new TestInfo(test_suite_name, name, type_param, value_param,
- code_location, fixture_class_id, factory);
+ new TestInfo(std::move(test_suite_name), name, type_param, value_param,
+ std::move(code_location), fixture_class_id, factory);
GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
return test_info;
}
void ReportInvalidTestSuiteType(const char* test_suite_name,
- CodeLocation code_location) {
+ const CodeLocation& code_location) {
Message errors;
errors
<< "Attempted redefinition of test suite " << test_suite_name << ".\n"
@@ -2813,14 +2858,13 @@
}
// Tells UnitTest where to store test result.
- internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
- impl->set_current_test_info(this);
+ UnitTest::GetInstance()->set_current_test_info(this);
// Notifies the unit test event listeners that a test is about to start.
repeater->OnTestStart(*this);
result_.set_start_timestamp(internal::GetTimeInMillis());
internal::Timer timer;
- impl->os_stack_trace_getter()->UponLeavingGTest();
+ UnitTest::GetInstance()->UponLeavingGTest();
// Creates the test object.
Test* const test = internal::HandleExceptionsInMethodIfSupported(
@@ -2838,7 +2882,7 @@
if (test != nullptr) {
// Deletes the test object.
- impl->os_stack_trace_getter()->UponLeavingGTest();
+ UnitTest::GetInstance()->UponLeavingGTest();
internal::HandleExceptionsInMethodIfSupported(
test, &Test::DeleteSelf_, "the test fixture's destructor");
}
@@ -2850,15 +2894,14 @@
// Tells UnitTest to stop associating assertion results to this
// test.
- impl->set_current_test_info(nullptr);
+ UnitTest::GetInstance()->set_current_test_info(nullptr);
}
// Skip and records a skipped test result for this object.
void TestInfo::Skip() {
if (!should_run_) return;
- internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
- impl->set_current_test_info(this);
+ UnitTest::GetInstance()->set_current_test_info(this);
TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
@@ -2867,12 +2910,13 @@
const TestPartResult test_part_result =
TestPartResult(TestPartResult::kSkip, this->file(), this->line(), "");
- impl->GetTestPartResultReporterForCurrentThread()->ReportTestPartResult(
- test_part_result);
+ internal::GetUnitTestImpl()
+ ->GetTestPartResultReporterForCurrentThread()
+ ->ReportTestPartResult(test_part_result);
// Notifies the unit test event listener that a test has just finished.
repeater->OnTestEnd(*this);
- impl->set_current_test_info(nullptr);
+ UnitTest::GetInstance()->set_current_test_info(nullptr);
}
// class TestSuite
@@ -2926,7 +2970,7 @@
// this is not a typed or a type-parameterized test suite.
// 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::TestSuite(const char* a_name, const char* a_type_param,
+TestSuite::TestSuite(const std::string& a_name, const char* a_type_param,
internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc)
: name_(a_name),
@@ -2968,8 +3012,7 @@
void TestSuite::Run() {
if (!should_run_) return;
- internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
- impl->set_current_test_suite(this);
+ UnitTest::GetInstance()->set_current_test_suite(this);
TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
@@ -2999,7 +3042,7 @@
repeater->OnTestCaseStart(*this);
#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
- impl->os_stack_trace_getter()->UponLeavingGTest();
+ UnitTest::GetInstance()->UponLeavingGTest();
internal::HandleExceptionsInMethodIfSupported(
this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()");
@@ -3024,7 +3067,7 @@
}
elapsed_time_ = timer.Elapsed();
- impl->os_stack_trace_getter()->UponLeavingGTest();
+ UnitTest::GetInstance()->UponLeavingGTest();
internal::HandleExceptionsInMethodIfSupported(
this, &TestSuite::RunTearDownTestSuite, "TearDownTestSuite()");
@@ -3035,15 +3078,14 @@
repeater->OnTestCaseEnd(*this);
#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
- impl->set_current_test_suite(nullptr);
+ UnitTest::GetInstance()->set_current_test_suite(nullptr);
}
// Skips all tests under this TestSuite.
void TestSuite::Skip() {
if (!should_run_) return;
- internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
- impl->set_current_test_suite(this);
+ UnitTest::GetInstance()->set_current_test_suite(this);
TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
@@ -3065,7 +3107,7 @@
repeater->OnTestCaseEnd(*this);
#endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
- impl->set_current_test_suite(nullptr);
+ UnitTest::GetInstance()->set_current_test_suite(nullptr);
}
// Clears the results of all tests in this test suite.
@@ -3166,9 +3208,9 @@
}
// class PrettyUnitTestResultPrinter
-#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE) && \
- !defined(GTEST_OS_WINDOWS_PHONE) && !defined(GTEST_OS_WINDOWS_RT) && \
- !defined(GTEST_OS_WINDOWS_MINGW)
+#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE) && \
+ !defined(GTEST_OS_WINDOWS_GAMES) && !defined(GTEST_OS_WINDOWS_PHONE) && \
+ !defined(GTEST_OS_WINDOWS_RT) && !defined(GTEST_OS_WINDOWS_MINGW)
// Returns the character attribute for the given color.
static WORD GetColorAttribute(GTestColor color) {
@@ -3252,6 +3294,7 @@
term != nullptr && (String::CStringEquals(term, "xterm") ||
String::CStringEquals(term, "xterm-color") ||
String::CStringEquals(term, "xterm-kitty") ||
+ String::CStringEquals(term, "alacritty") ||
String::CStringEquals(term, "screen") ||
String::CStringEquals(term, "tmux") ||
String::CStringEquals(term, "rxvt-unicode") ||
@@ -3282,11 +3325,9 @@
va_start(args, fmt);
static const bool in_color_mode =
-#if GTEST_HAS_FILE_SYSTEM
+ // We don't condition this on GTEST_HAS_FILE_SYSTEM because we still need
+ // to be able to detect terminal I/O regardless.
ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
-#else
- false;
-#endif // GTEST_HAS_FILE_SYSTEM
const bool use_color = in_color_mode && (color != GTestColor::kDefault);
@@ -3296,9 +3337,9 @@
return;
}
-#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE) && \
- !defined(GTEST_OS_WINDOWS_PHONE) && !defined(GTEST_OS_WINDOWS_RT) && \
- !defined(GTEST_OS_WINDOWS_MINGW)
+#if defined(GTEST_OS_WINDOWS) && !defined(GTEST_OS_WINDOWS_MOBILE) && \
+ !defined(GTEST_OS_WINDOWS_GAMES) && !defined(GTEST_OS_WINDOWS_PHONE) && \
+ !defined(GTEST_OS_WINDOWS_RT) && !defined(GTEST_OS_WINDOWS_MINGW)
const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
// Gets the current text color.
@@ -3954,6 +3995,12 @@
static void OutputXmlTestSuiteForTestResult(::std::ostream* stream,
const TestResult& result);
+ // Streams a test case XML stanza containing the given test result.
+ //
+ // Requires: result.Failed()
+ static void OutputXmlTestCaseForTestResult(::std::ostream* stream,
+ const TestResult& result);
+
// Streams an XML representation of a TestResult object.
static void OutputXmlTestResult(::std::ostream* stream,
const TestResult& result);
@@ -3971,16 +4018,11 @@
static void PrintXmlUnitTest(::std::ostream* stream,
const UnitTest& unit_test);
- // Produces a string representing the test properties in a result as space
- // delimited XML attributes based on the property key="value" pairs.
- // When the std::string is not empty, it includes a space at the beginning,
- // to delimit this attribute from prior attributes.
- static std::string TestPropertiesAsXmlAttributes(const TestResult& result);
-
// Streams an XML representation of the test properties of a TestResult
// object.
static void OutputXmlTestProperties(std::ostream* stream,
- const TestResult& result);
+ const TestResult& result,
+ const std::string& indent);
// The output file.
const std::string output_file_;
@@ -4201,6 +4243,15 @@
FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
*stream << ">";
+ OutputXmlTestCaseForTestResult(stream, result);
+
+ // Complete the test suite.
+ *stream << " </testsuite>\n";
+}
+
+// Streams a test case XML stanza containing the given test result.
+void XmlUnitTestResultPrinter::OutputXmlTestCaseForTestResult(
+ ::std::ostream* stream, const TestResult& result) {
// Output the boilerplate for a minimal test case with a single test.
*stream << " <testcase";
OutputXmlAttribute(stream, "testcase", "name", "");
@@ -4215,9 +4266,6 @@
// Output the actual test result.
OutputXmlTestResult(stream, result);
-
- // Complete the test suite.
- *stream << " </testsuite>\n";
}
// Prints an XML representation of a TestInfo object.
@@ -4308,7 +4356,7 @@
if (failures == 0 && skips == 0) {
*stream << ">\n";
}
- OutputXmlTestProperties(stream, result);
+ OutputXmlTestProperties(stream, result, /*indent=*/" ");
*stream << " </testcase>\n";
}
}
@@ -4337,13 +4385,18 @@
OutputXmlAttribute(
stream, kTestsuite, "timestamp",
FormatEpochTimeInMillisAsIso8601(test_suite.start_timestamp()));
- *stream << TestPropertiesAsXmlAttributes(test_suite.ad_hoc_test_result());
}
*stream << ">\n";
+ OutputXmlTestProperties(stream, test_suite.ad_hoc_test_result(),
+ /*indent=*/" ");
for (int i = 0; i < test_suite.total_test_count(); ++i) {
if (test_suite.GetTestInfo(i)->is_reportable())
OutputXmlTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
}
+ if (test_suite.ad_hoc_test_result().Failed()) {
+ OutputXmlTestCaseForTestResult(stream, test_suite.ad_hoc_test_result());
+ }
+
*stream << " </" << kTestsuite << ">\n";
}
@@ -4373,11 +4426,12 @@
OutputXmlAttribute(stream, kTestsuites, "random_seed",
StreamableToString(unit_test.random_seed()));
}
- *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result());
OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
*stream << ">\n";
+ OutputXmlTestProperties(stream, unit_test.ad_hoc_test_result(),
+ /*indent=*/" ");
for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
if (unit_test.GetTestSuite(i)->reportable_test_count() > 0)
PrintXmlTestSuite(stream, *unit_test.GetTestSuite(i));
@@ -4414,21 +4468,8 @@
*stream << "</" << kTestsuites << ">\n";
}
-// Produces a string representing the test properties in a result as space
-// delimited XML attributes based on the property key="value" pairs.
-std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
- const TestResult& result) {
- Message attributes;
- for (int i = 0; i < result.test_property_count(); ++i) {
- const TestProperty& property = result.GetTestProperty(i);
- attributes << " " << property.key() << "="
- << "\"" << EscapeXmlAttribute(property.value()) << "\"";
- }
- return attributes.GetString();
-}
-
void XmlUnitTestResultPrinter::OutputXmlTestProperties(
- std::ostream* stream, const TestResult& result) {
+ std::ostream* stream, const TestResult& result, const std::string& indent) {
const std::string kProperties = "properties";
const std::string kProperty = "property";
@@ -4436,15 +4477,15 @@
return;
}
- *stream << " <" << kProperties << ">\n";
+ *stream << indent << "<" << kProperties << ">\n";
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
- *stream << " <" << kProperty;
+ *stream << indent << " <" << kProperty;
*stream << " name=\"" << EscapeXmlAttribute(property.key()) << "\"";
*stream << " value=\"" << EscapeXmlAttribute(property.value()) << "\"";
*stream << "/>\n";
}
- *stream << " </" << kProperties << ">\n";
+ *stream << indent << "</" << kProperties << ">\n";
}
// End XmlUnitTestResultPrinter
@@ -4483,6 +4524,12 @@
static void OutputJsonTestSuiteForTestResult(::std::ostream* stream,
const TestResult& result);
+ // Streams a test case JSON stanza containing the given test result.
+ //
+ // Requires: result.Failed()
+ static void OutputJsonTestCaseForTestResult(::std::ostream* stream,
+ const TestResult& result);
+
// Streams a JSON representation of a TestResult object.
static void OutputJsonTestResult(::std::ostream* stream,
const TestResult& result);
@@ -4653,6 +4700,15 @@
}
*stream << Indent(6) << "\"testsuite\": [\n";
+ OutputJsonTestCaseForTestResult(stream, result);
+
+ // Finish the test suite.
+ *stream << "\n" << Indent(6) << "]\n" << Indent(4) << "}";
+}
+
+// Streams a test case JSON stanza containing the given test result.
+void JsonUnitTestResultPrinter::OutputJsonTestCaseForTestResult(
+ ::std::ostream* stream, const TestResult& result) {
// Output the boilerplate for a new test case.
*stream << Indent(8) << "{\n";
OutputJsonKey(stream, "testcase", "name", "", Indent(10));
@@ -4669,9 +4725,6 @@
// Output the actual test result.
OutputJsonTestResult(stream, result);
-
- // Finish the test suite.
- *stream << "\n" << Indent(6) << "]\n" << Indent(4) << "}";
}
// Prints a JSON representation of a TestInfo object.
@@ -4726,28 +4779,53 @@
const TestResult& result) {
const std::string kIndent = Indent(10);
- int failures = 0;
- for (int i = 0; i < result.total_part_count(); ++i) {
- const TestPartResult& part = result.GetTestPartResult(i);
- if (part.failed()) {
- *stream << ",\n";
- if (++failures == 1) {
- *stream << kIndent << "\""
- << "failures"
- << "\": [\n";
+ {
+ int failures = 0;
+ for (int i = 0; i < result.total_part_count(); ++i) {
+ const TestPartResult& part = result.GetTestPartResult(i);
+ if (part.failed()) {
+ *stream << ",\n";
+ if (++failures == 1) {
+ *stream << kIndent << "\"" << "failures" << "\": [\n";
+ }
+ const std::string location =
+ internal::FormatCompilerIndependentFileLocation(part.file_name(),
+ part.line_number());
+ const std::string message =
+ EscapeJson(location + "\n" + part.message());
+ *stream << kIndent << " {\n"
+ << kIndent << " \"failure\": \"" << message << "\",\n"
+ << kIndent << " \"type\": \"\"\n"
+ << kIndent << " }";
}
- const std::string location =
- internal::FormatCompilerIndependentFileLocation(part.file_name(),
- part.line_number());
- const std::string message = EscapeJson(location + "\n" + part.message());
- *stream << kIndent << " {\n"
- << kIndent << " \"failure\": \"" << message << "\",\n"
- << kIndent << " \"type\": \"\"\n"
- << kIndent << " }";
}
+
+ if (failures > 0) *stream << "\n" << kIndent << "]";
}
- if (failures > 0) *stream << "\n" << kIndent << "]";
+ {
+ int skipped = 0;
+ for (int i = 0; i < result.total_part_count(); ++i) {
+ const TestPartResult& part = result.GetTestPartResult(i);
+ if (part.skipped()) {
+ *stream << ",\n";
+ if (++skipped == 1) {
+ *stream << kIndent << "\"" << "skipped" << "\": [\n";
+ }
+ const std::string location =
+ internal::FormatCompilerIndependentFileLocation(part.file_name(),
+ part.line_number());
+ const std::string message =
+ EscapeJson(location + "\n" + part.message());
+ *stream << kIndent << " {\n"
+ << kIndent << " \"message\": \"" << message << "\"\n"
+ << kIndent << " }";
+ }
+ }
+
+ if (skipped > 0) *stream << "\n" << kIndent << "]";
+ }
+
*stream << "\n" << Indent(8) << "}";
}
@@ -4791,6 +4869,16 @@
OutputJsonTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
}
}
+
+ // If there was a failure in the test suite setup or teardown include that in
+ // the output.
+ if (test_suite.ad_hoc_test_result().Failed()) {
+ if (comma) {
+ *stream << ",\n";
+ }
+ OutputJsonTestCaseForTestResult(stream, test_suite.ad_hoc_test_result());
+ }
+
*stream << "\n" << kIndent << "]\n" << Indent(4) << "}";
}
@@ -4884,8 +4972,8 @@
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
attributes << ",\n"
- << indent << "\"" << property.key() << "\": "
- << "\"" << EscapeJson(property.value()) << "\"";
+ << indent << "\"" << property.key() << "\": " << "\""
+ << EscapeJson(property.value()) << "\"";
}
return attributes.GetString();
}
@@ -5283,6 +5371,22 @@
return impl()->GetMutableSuiteCase(i);
}
+void UnitTest::UponLeavingGTest() {
+ impl()->os_stack_trace_getter()->UponLeavingGTest();
+}
+
+// Sets the TestSuite object for the test that's currently running.
+void UnitTest::set_current_test_suite(TestSuite* a_current_test_suite) {
+ internal::MutexLock lock(&mutex_);
+ impl_->set_current_test_suite(a_current_test_suite);
+}
+
+// Sets the TestInfo object for the test that's currently running.
+void UnitTest::set_current_test_info(TestInfo* a_current_test_info) {
+ internal::MutexLock lock(&mutex_);
+ impl_->set_current_test_info(a_current_test_info);
+}
+
// Returns the list of event listeners that can be used to track events
// inside Google Test.
TestEventListeners& UnitTest::listeners() { return *impl()->listeners(); }
@@ -5400,7 +5504,7 @@
int UnitTest::Run() {
#ifdef GTEST_HAS_DEATH_TEST
const bool in_death_test_child_process =
- GTEST_FLAG_GET(internal_run_death_test).length() > 0;
+ !GTEST_FLAG_GET(internal_run_death_test).empty();
// Google Test implements this protocol for catching that a test
// program exits before returning control to Google Test:
@@ -5442,7 +5546,7 @@
// about crashes - they are expected.
if (impl()->catch_exceptions() || in_death_test_child_process) {
#if !defined(GTEST_OS_WINDOWS_MOBILE) && !defined(GTEST_OS_WINDOWS_PHONE) && \
- !defined(GTEST_OS_WINDOWS_RT)
+ !defined(GTEST_OS_WINDOWS_RT) && !defined(GTEST_OS_WINDOWS_GAMES)
// SetErrorMode doesn't exist on CE.
SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
@@ -5712,29 +5816,6 @@
}
}
-// A predicate that checks the name of a TestSuite against a known
-// value.
-//
-// This is used for implementation of the UnitTest class only. We put
-// it in the anonymous namespace to prevent polluting the outer
-// namespace.
-//
-// TestSuiteNameIs is copyable.
-class TestSuiteNameIs {
- public:
- // Constructor.
- explicit TestSuiteNameIs(const std::string& name) : name_(name) {}
-
- // Returns true if and only if the name of test_suite matches name_.
- bool operator()(const TestSuite* test_suite) const {
- return test_suite != nullptr &&
- strcmp(test_suite->name(), name_.c_str()) == 0;
- }
-
- private:
- std::string name_;
-};
-
// Finds and returns a TestSuite with the given name. If one doesn't
// exist, creates one and returns it. It's the CALLER'S
// RESPONSIBILITY to ensure that this function is only called WHEN THE
@@ -5748,19 +5829,27 @@
// 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* UnitTestImpl::GetTestSuite(
- const char* test_suite_name, const char* type_param,
+ const std::string& test_suite_name, const char* type_param,
internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc) {
- // Can we find a TestSuite with the given name?
- const auto test_suite =
- std::find_if(test_suites_.rbegin(), test_suites_.rend(),
- TestSuiteNameIs(test_suite_name));
+ // During initialization, all TestInfos for a given suite are added in
+ // sequence. To optimize this case, see if the most recently added suite is
+ // the one being requested now.
+ if (!test_suites_.empty() &&
+ (*test_suites_.rbegin())->name_ == test_suite_name) {
+ return *test_suites_.rbegin();
+ }
- if (test_suite != test_suites_.rend()) return *test_suite;
+ // Fall back to searching the collection.
+ auto item_it = test_suites_by_name_.find(test_suite_name);
+ if (item_it != test_suites_by_name_.end()) {
+ return item_it->second;
+ }
- // No. Let's create one.
+ // Not found. Create a new instance.
auto* const new_test_suite =
new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc);
+ test_suites_by_name_.emplace(test_suite_name, new_test_suite);
const UnitTestFilter death_test_suite_filter(kDeathTestSuiteFilter);
// Is this a death test suite?
@@ -5807,6 +5896,14 @@
// user didn't call InitGoogleTest.
PostFlagParsingInit();
+ if (GTEST_FLAG_GET(fail_if_no_test_linked) && total_test_count() == 0) {
+ ColoredPrintf(
+ GTestColor::kRed,
+ "This test program does NOT link in any test case. This is INVALID. "
+ "Please make sure to link in at least one test case.\n");
+ return false;
+ }
+
#if GTEST_HAS_FILE_SYSTEM
// Even if sharding is not on, test runners may want to use the
// GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding
@@ -5973,6 +6070,12 @@
}
repeater->OnTestProgramEnd(*parent_);
+ // Destroy environments in normal code, not in static teardown.
+ bool delete_environment_on_teardown = true;
+ if (delete_environment_on_teardown) {
+ ForEach(environments_, internal::Delete<Environment>);
+ environments_.clear();
+ }
if (!gtest_is_initialized_before_run_all_tests) {
ColoredPrintf(
@@ -6106,12 +6209,11 @@
int num_runnable_tests = 0;
int num_selected_tests = 0;
for (auto* test_suite : test_suites_) {
- const std::string& test_suite_name = test_suite->name();
+ const std::string& test_suite_name = test_suite->name_;
test_suite->set_should_run(false);
- for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
- TestInfo* const test_info = test_suite->test_info_list()[j];
- const std::string test_name(test_info->name());
+ for (TestInfo* test_info : test_suite->test_info_list()) {
+ const std::string& test_name = test_info->name_;
// A test is disabled if test suite name or test name matches
// kDisableTestFilter.
const bool is_disabled =
@@ -6202,8 +6304,8 @@
#if GTEST_HAS_FILE_SYSTEM
const std::string& output_format = UnitTestOptions::GetOutputFormat();
if (output_format == "xml" || output_format == "json") {
- FILE* fileout = OpenFileForWriting(
- UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
+ FILE* fileout =
+ OpenFileForWriting(UnitTestOptions::GetAbsolutePathToOutputFile());
std::stringstream stream;
if (output_format == "xml") {
XmlUnitTestResultPrinter(
@@ -6589,6 +6691,7 @@
GTEST_INTERNAL_PARSE_FLAG(death_test_style);
GTEST_INTERNAL_PARSE_FLAG(death_test_use_fork);
GTEST_INTERNAL_PARSE_FLAG(fail_fast);
+ GTEST_INTERNAL_PARSE_FLAG(fail_if_no_test_linked);
GTEST_INTERNAL_PARSE_FLAG(filter);
GTEST_INTERNAL_PARSE_FLAG(internal_run_death_test);
GTEST_INTERNAL_PARSE_FLAG(list_tests);
@@ -6652,17 +6755,17 @@
}
if (remove_flag) {
- // Shift the remainder of the argv list left by one. Note
- // that argv has (*argc + 1) elements, the last one always being
- // NULL. The following loop moves the trailing NULL element as
- // well.
- for (int j = i; j != *argc; j++) {
- argv[j] = argv[j + 1];
+ // Shift the remainder of the argv list left by one.
+ for (int j = i + 1; j < *argc; ++j) {
+ argv[j - 1] = argv[j];
}
// Decrements the argument count.
(*argc)--;
+ // Terminate the array with nullptr.
+ argv[*argc] = nullptr;
+
// We also need to decrement the iterator as we just removed
// an element.
i--;
@@ -6684,7 +6787,7 @@
// remain in place. Unrecognized flags are not reported and do not cause the
// program to exit.
void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
-#ifdef GTEST_HAS_ABSL
+#ifdef GTEST_HAS_ABSL_FLAGS
if (*argc <= 0) return;
std::vector<char*> positional_args;
@@ -6770,11 +6873,13 @@
#ifdef GTEST_HAS_ABSL
absl::InitializeSymbolizer(g_argvs[0].c_str());
+#ifdef GTEST_HAS_ABSL_FLAGS
// When using the Abseil Flags library, set the program usage message to the
// help message, but remove the color-encoding from the message first.
absl::SetProgramUsageMessage(absl::StrReplaceAll(
kColorEncodedHelpMessage,
{{"@D", ""}, {"@R", ""}, {"@G", ""}, {"@Y", ""}, {"@@", "@"}}));
+#endif // GTEST_HAS_ABSL_FLAGS
#endif // GTEST_HAS_ABSL
ParseGoogleTestFlagsOnly(argc, argv);
diff --git a/third_party/googletest/googletest/test/BUILD.bazel b/third_party/googletest/googletest/test/BUILD.bazel
index 1890b6f..c561ef8 100644
--- a/third_party/googletest/googletest/test/BUILD.bazel
+++ b/third_party/googletest/googletest/test/BUILD.bazel
@@ -45,36 +45,38 @@
"gtest-*.cc",
"googletest-*.cc",
"*.h",
- "googletest/include/gtest/**/*.h",
],
exclude = [
- "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",
- "googletest-param-test-test.cc",
- "googletest-param-test2-test.cc",
+ # 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-break-on-failure-unittest_.cc",
+ "googletest-list-tests-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",
+ "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",
+ "googletest/src/gtest-all.cc",
+ "gtest-death-test_ex_test.cc",
+ "gtest-listener_test.cc",
+ "gtest-unittest-api_test.cc",
+ "gtest_all_test.cc",
+ # go/keep-sorted end
],
) + select({
"//:windows": [],
@@ -324,6 +326,26 @@
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",
@@ -364,6 +386,18 @@
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"],
diff --git a/third_party/googletest/googletest/test/googletest-color-test.py b/third_party/googletest/googletest/test/googletest-color-test.py
index 8926a48..8968cf1 100755
--- a/third_party/googletest/googletest/test/googletest-color-test.py
+++ b/third_party/googletest/googletest/test/googletest-color-test.py
@@ -80,6 +80,7 @@
self.assertTrue(UsesColor('xterm', None, None))
self.assertTrue(UsesColor('xterm-color', 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):
diff --git a/third_party/googletest/googletest/test/googletest-death-test-test.cc b/third_party/googletest/googletest/test/googletest-death-test-test.cc
index 4cc81b7..44b8046 100644
--- a/third_party/googletest/googletest/test/googletest-death-test-test.cc
+++ b/third_party/googletest/googletest/test/googletest-death-test-test.cc
@@ -30,6 +30,8 @@
//
// Tests for death tests.
+#include <stdlib.h>
+
#include "gtest/gtest-death-test.h"
#include "gtest/gtest.h"
#include "gtest/internal/gtest-filepath.h"
@@ -111,15 +113,15 @@
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) {
@@ -238,13 +240,13 @@
#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);
@@ -260,7 +262,7 @@
pid_t child_pid = fork();
if (child_pid == 0) {
raise(signum);
- _exit(1);
+ _Exit(1);
}
int status;
waitpid(child_pid, &status, 0);
@@ -289,7 +291,9 @@
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__ <= 21)
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));
@@ -313,7 +317,7 @@
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"
@@ -324,7 +328,7 @@
if (AlwaysFalse())
;
else
- EXPECT_DEATH(_exit(1), "") << 1 << 2 << 3;
+ EXPECT_DEATH(_Exit(1), "") << 1 << 2 << 3;
}
#ifdef __GNUC__
#pragma GCC diagnostic pop
@@ -339,11 +343,11 @@
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_()
}
@@ -371,10 +375,10 @@
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
@@ -416,7 +420,7 @@
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);
@@ -425,7 +429,7 @@
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);
@@ -449,24 +453,24 @@
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
@@ -480,7 +484,7 @@
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);
}
}
@@ -805,8 +809,8 @@
// 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
@@ -823,7 +827,7 @@
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.");
@@ -849,7 +853,7 @@
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.");
}
@@ -1140,7 +1144,7 @@
// 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));
@@ -1152,21 +1156,21 @@
// 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");
}
@@ -1330,7 +1334,7 @@
{
fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside");
fflush(stderr);
- _exit(1);
+ _Exit(1);
},
"Inside");
}
@@ -1342,7 +1346,7 @@
{
fprintf(stderr, InDeathTestChild() ? "Inside" : "Outside");
fflush(stderr);
- _exit(1);
+ _Exit(1);
},
"Inside");
}
@@ -1350,7 +1354,7 @@
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) {
@@ -1466,7 +1470,7 @@
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"
@@ -1477,7 +1481,7 @@
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
@@ -1492,11 +1496,11 @@
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_()
}
diff --git a/third_party/googletest/googletest/test/googletest-fail-if-no-test-linked-test-with-disabled-test_.cc b/third_party/googletest/googletest/test/googletest-fail-if-no-test-linked-test-with-disabled-test_.cc
new file mode 100644
index 0000000..56d2690
--- /dev/null
+++ b/third_party/googletest/googletest/test/googletest-fail-if-no-test-linked-test-with-disabled-test_.cc
@@ -0,0 +1,38 @@
+// 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) {}
diff --git a/third_party/googletest/googletest/test/googletest-fail-if-no-test-linked-test-with-enabled-test_.cc b/third_party/googletest/googletest/test/googletest-fail-if-no-test-linked-test-with-enabled-test_.cc
new file mode 100644
index 0000000..1ed2034
--- /dev/null
+++ b/third_party/googletest/googletest/test/googletest-fail-if-no-test-linked-test-with-enabled-test_.cc
@@ -0,0 +1,38 @@
+// 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) {}
diff --git a/third_party/googletest/googletest/test/googletest-fail-if-no-test-linked-test.py b/third_party/googletest/googletest/test/googletest-fail-if-no-test-linked-test.py
new file mode 100755
index 0000000..3ecf208
--- /dev/null
+++ b/third_party/googletest/googletest/test/googletest-fail-if-no-test-linked-test.py
@@ -0,0 +1,114 @@
+#!/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."""
+
+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"
+
+
+class GTestFailIfNoTestLinkedTest(gtest_test_utils.TestCase):
+ """Tests the --gtest_fail_if_no_test_linked flag."""
+
+ def Run(self, program_name, flag=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.
+
+ 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)
+ 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 testFailsIfNoTestLinkedAndFlagSpecified(self):
+ """Tests the behavior of no test linked and flag specified."""
+
+ self.assertFalse(
+ self.Run(
+ "googletest-fail-if-no-test-linked-test-without-test_",
+ f"--{FAIL_IF_NO_TEST_LINKED_FLAG}",
+ )
+ )
+
+ def testSucceedsIfEnabledTestLinkedAndFlagNotSpecified(self):
+ """Tests the behavior of enabled test linked and flag not specified."""
+
+ self.assertTrue(
+ self.Run("googletest-fail-if-no-test-linked-test-with-enabled-test_")
+ )
+
+ def testSucceedsIfEnabledTestLinkedAndFlagSpecified(self):
+ """Tests the behavior of enabled test linked and flag specified."""
+
+ self.assertTrue(
+ self.Run(
+ "googletest-fail-if-no-test-linked-test-with-enabled-test_",
+ f"--{FAIL_IF_NO_TEST_LINKED_FLAG}",
+ )
+ )
+
+ def testSucceedsIfDisabledTestLinkedAndFlagNotSpecified(self):
+ """Tests the behavior of disabled test linked and flag not specified."""
+
+ self.assertTrue(
+ self.Run("googletest-fail-if-no-test-linked-test-with-disabled-test_")
+ )
+
+ def testSucceedsIfDisabledTestLinkedAndFlagSpecified(self):
+ """Tests the behavior of disabled test linked and flag specified."""
+
+ self.assertTrue(
+ self.Run(
+ "googletest-fail-if-no-test-linked-test-with-disabled-test_",
+ f"--{FAIL_IF_NO_TEST_LINKED_FLAG}",
+ )
+ )
+
+
+if __name__ == "__main__":
+ gtest_test_utils.Main()
diff --git a/third_party/googletest/googletest/test/googletest-json-output-unittest.py b/third_party/googletest/googletest/test/googletest-json-output-unittest.py
index cb97694..c75051c 100644
--- a/third_party/googletest/googletest/test/googletest-json-output-unittest.py
+++ b/third_party/googletest/googletest/test/googletest-json-output-unittest.py
@@ -57,7 +57,7 @@
STACK_TRACE_TEMPLATE = '\n'
EXPECTED_NON_EMPTY = {
- 'tests': 26,
+ 'tests': 28,
'failures': 5,
'disabled': 2,
'errors': 0,
@@ -150,6 +150,9 @@
'time': '*',
'timestamp': '*',
'classname': 'SkippedTest',
+ 'skipped': [
+ {'message': 'gtest_xml_output_unittest_.cc:*\n\n'}
+ ],
},
{
'name': 'SkippedWithMessage',
@@ -160,6 +163,12 @@
'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',
@@ -179,6 +188,12 @@
),
'type': '',
}],
+ 'skipped': [{
+ 'message': (
+ 'gtest_xml_output_unittest_.cc:*\n'
+ 'It is good practice to tell why you skip a test.\n'
+ )
+ }],
},
],
},
@@ -308,12 +323,14 @@
'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': 121,
+ 'line': 125,
'status': 'RUN',
'result': 'COMPLETED',
'time': '*',
@@ -324,7 +341,7 @@
{
'name': 'IntValuedProperty',
'file': 'gtest_xml_output_unittest_.cc',
- 'line': 125,
+ 'line': 129,
'status': 'RUN',
'result': 'COMPLETED',
'time': '*',
@@ -335,7 +352,7 @@
{
'name': 'ThreeProperties',
'file': 'gtest_xml_output_unittest_.cc',
- 'line': 129,
+ 'line': 133,
'status': 'RUN',
'result': 'COMPLETED',
'time': '*',
@@ -348,7 +365,7 @@
{
'name': 'TwoValuesForOneKeyUsesLastValue',
'file': 'gtest_xml_output_unittest_.cc',
- 'line': 135,
+ 'line': 139,
'status': 'RUN',
'result': 'COMPLETED',
'time': '*',
@@ -370,7 +387,7 @@
{
'name': 'RecordProperty',
'file': 'gtest_xml_output_unittest_.cc',
- 'line': 140,
+ 'line': 144,
'status': 'RUN',
'result': 'COMPLETED',
'time': '*',
@@ -381,7 +398,7 @@
{
'name': 'ExternalUtilityThatCallsRecordIntValuedProperty',
'file': 'gtest_xml_output_unittest_.cc',
- 'line': 153,
+ 'line': 157,
'status': 'RUN',
'result': 'COMPLETED',
'time': '*',
@@ -394,7 +411,7 @@
'ExternalUtilityThatCallsRecordStringValuedProperty'
),
'file': 'gtest_xml_output_unittest_.cc',
- 'line': 157,
+ 'line': 161,
'status': 'RUN',
'result': 'COMPLETED',
'time': '*',
@@ -405,6 +422,83 @@
],
},
{
+ '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,
'failures': 0,
@@ -416,7 +510,7 @@
'name': 'HasTypeParamAttribute',
'type_param': 'int',
'file': 'gtest_xml_output_unittest_.cc',
- 'line': 173,
+ 'line': 193,
'status': 'RUN',
'result': 'COMPLETED',
'time': '*',
@@ -436,7 +530,7 @@
'name': 'HasTypeParamAttribute',
'type_param': 'long',
'file': 'gtest_xml_output_unittest_.cc',
- 'line': 173,
+ 'line': 193,
'status': 'RUN',
'result': 'COMPLETED',
'time': '*',
@@ -456,7 +550,7 @@
'name': 'HasTypeParamAttribute',
'type_param': 'int',
'file': 'gtest_xml_output_unittest_.cc',
- 'line': 180,
+ 'line': 200,
'status': 'RUN',
'result': 'COMPLETED',
'time': '*',
@@ -476,7 +570,7 @@
'name': 'HasTypeParamAttribute',
'type_param': 'long',
'file': 'gtest_xml_output_unittest_.cc',
- 'line': 180,
+ 'line': 200,
'status': 'RUN',
'result': 'COMPLETED',
'time': '*',
@@ -497,7 +591,7 @@
'name': 'HasValueParamAttribute/0',
'value_param': '33',
'file': 'gtest_xml_output_unittest_.cc',
- 'line': 164,
+ 'line': 184,
'status': 'RUN',
'result': 'COMPLETED',
'time': '*',
@@ -508,7 +602,7 @@
'name': 'HasValueParamAttribute/1',
'value_param': '42',
'file': 'gtest_xml_output_unittest_.cc',
- 'line': 164,
+ 'line': 184,
'status': 'RUN',
'result': 'COMPLETED',
'time': '*',
@@ -519,7 +613,7 @@
'name': 'AnotherTestThatHasValueParamAttribute/0',
'value_param': '33',
'file': 'gtest_xml_output_unittest_.cc',
- 'line': 165,
+ 'line': 185,
'status': 'RUN',
'result': 'COMPLETED',
'time': '*',
@@ -530,7 +624,7 @@
'name': 'AnotherTestThatHasValueParamAttribute/1',
'value_param': '42',
'file': 'gtest_xml_output_unittest_.cc',
- 'line': 165,
+ 'line': 185,
'status': 'RUN',
'result': 'COMPLETED',
'time': '*',
diff --git a/third_party/googletest/googletest/test/googletest-options-test.cc b/third_party/googletest/googletest/test/googletest-options-test.cc
index b712c06..91d06a5 100644
--- a/third_party/googletest/googletest/test/googletest-options-test.cc
+++ b/third_party/googletest/googletest/test/googletest-options-test.cc
@@ -115,11 +115,14 @@
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 // GTEST_OS_WINDOWS
+#endif // platform ifdefs
+
if (!success) FAIL() << "GetCurrentExecutableName() returns " << exe_str;
}
diff --git a/third_party/googletest/googletest/test/googletest-output-test-golden-lin.txt b/third_party/googletest/googletest/test/googletest-output-test-golden-lin.txt
index 6ddf822..533eb8c 100644
--- a/third_party/googletest/googletest/test/googletest-output-test-golden-lin.txt
+++ b/third_party/googletest/googletest/test/googletest-output-test-golden-lin.txt
@@ -696,7 +696,6 @@
Actual:
googletest-output-test_.cc:#: Success:
Succeeded
-Stack trace: (omitted)
Stack trace: (omitted)
@@ -733,7 +732,6 @@
Actual:
googletest-output-test_.cc:#: Success:
Succeeded
-Stack trace: (omitted)
Stack trace: (omitted)
@@ -770,7 +768,6 @@
Actual:
googletest-output-test_.cc:#: Success:
Succeeded
-Stack trace: (omitted)
Stack trace: (omitted)
@@ -807,7 +804,6 @@
Actual:
googletest-output-test_.cc:#: Success:
Succeeded
-Stack trace: (omitted)
Stack trace: (omitted)
@@ -970,7 +966,6 @@
[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
diff --git a/third_party/googletest/googletest/test/googletest-port-test.cc b/third_party/googletest/googletest/test/googletest-port-test.cc
index e0793ba..9f05a01 100644
--- a/third_party/googletest/googletest/test/googletest-port-test.cc
+++ b/third_party/googletest/googletest/test/googletest-port-test.cc
@@ -296,7 +296,7 @@
TEST(GetThreadCountTest, ReturnsCorrectValue) {
size_t starting_count;
size_t thread_count_after_create;
- size_t thread_count_after_join;
+ size_t thread_count_after_join = 0;
// We can't guarantee that no other thread was created or destroyed between
// any two calls to GetThreadCount(). We make multiple attempts, hoping that
@@ -316,9 +316,9 @@
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));
@@ -418,8 +418,8 @@
const RE simple(TypeParam("hello"));
EXPECT_STREQ("hello", simple.pattern());
- const RE normal(TypeParam(".*([[:alnum:]_]+)"));
- EXPECT_STREQ(".*([[:alnum:]_]+)", normal.pattern());
+ const RE normal(TypeParam(".*(\\w+)"));
+ EXPECT_STREQ(".*(\\w+)", normal.pattern());
}
// Tests that RE's constructors reject invalid regular expressions.
diff --git a/third_party/googletest/googletest/test/googletest-printers-test.cc b/third_party/googletest/googletest/test/googletest-printers-test.cc
index d5061be..52b2c49 100644
--- a/third_party/googletest/googletest/test/googletest-printers-test.cc
+++ b/third_party/googletest/googletest/test/googletest-printers-test.cc
@@ -64,6 +64,10 @@
#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.
@@ -117,6 +121,9 @@
// 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;
};
@@ -568,6 +575,8 @@
}
// 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) +
@@ -575,7 +584,8 @@
"hello \\xE4\\xB8\\x96\\xE7\\x95\\x8C\"",
Print(p));
}
-#endif
+#endif // _MSC_VER
+#endif // __cpp_lib_char8_t
// const char16_t*.
TEST(PrintU16StringTest, Const) {
@@ -1970,6 +1980,26 @@
PrintToString(Type(NonPrintable{})));
}
#endif // GTEST_INTERNAL_HAS_VARIANT
+
+#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
+
namespace {
class string_ref;
diff --git a/third_party/googletest/googletest/test/googletest-setuptestsuite-test_.cc b/third_party/googletest/googletest/test/googletest-setuptestsuite-test_.cc
index d20899f..f4c43cc 100644
--- a/third_party/googletest/googletest/test/googletest-setuptestsuite-test_.cc
+++ b/third_party/googletest/googletest/test/googletest-setuptestsuite-test_.cc
@@ -31,14 +31,14 @@
class SetupFailTest : public ::testing::Test {
protected:
- static void SetUpTestSuite() { ASSERT_EQ("", "SET_UP_FAIL"); }
+ static void SetUpTestSuite() { ASSERT_STREQ("", "SET_UP_FAIL"); }
};
TEST_F(SetupFailTest, NoopPassingTest) {}
class TearDownFailTest : public ::testing::Test {
protected:
- static void TearDownTestSuite() { ASSERT_EQ("", "TEAR_DOWN_FAIL"); }
+ static void TearDownTestSuite() { ASSERT_STREQ("", "TEAR_DOWN_FAIL"); }
};
TEST_F(TearDownFailTest, NoopPassingTest) {}
diff --git a/third_party/googletest/googletest/test/gtest_environment_test.cc b/third_party/googletest/googletest/test/gtest_environment_test.cc
index 122eaf3..03657c7 100644
--- a/third_party/googletest/googletest/test/gtest_environment_test.cc
+++ b/third_party/googletest/googletest/test/gtest_environment_test.cc
@@ -40,16 +40,21 @@
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:
@@ -65,36 +70,18 @@
// 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; }
@@ -112,67 +99,88 @@
// The 'failure' parameter specifies the type of failure that should
// be generated by the global set-up.
int RunAllTests(MyEnvironment* env, FailureType failure) {
- env->Reset();
- env->set_failure_in_set_up(failure);
+ set_up_was_run = false;
+ tear_down_was_run = false;
test_was_run = false;
+ env->set_failure_in_set_up(failure);
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);
- // 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.");
+ TestGlobalSetUp();
+ TestTestsRun();
+ TestNoTestsRunSetUpFailure();
+ TestNoTestsSkipsSetUp();
printf("PASS\n");
return 0;
diff --git a/third_party/googletest/googletest/test/gtest_json_test_utils.py b/third_party/googletest/googletest/test/gtest_json_test_utils.py
index 86a5925..694a7a6 100644
--- a/third_party/googletest/googletest/test/gtest_json_test_utils.py
+++ b/third_party/googletest/googletest/test/gtest_json_test_utils.py
@@ -51,6 +51,9 @@
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:
diff --git a/third_party/googletest/googletest/test/gtest_repeat_test.cc b/third_party/googletest/googletest/test/gtest_repeat_test.cc
index f67b788..55103d0 100644
--- a/third_party/googletest/googletest/test/gtest_repeat_test.cc
+++ b/third_party/googletest/googletest/test/gtest_repeat_test.cc
@@ -61,7 +61,6 @@
class MyEnvironment : public testing::Environment {
public:
- MyEnvironment() = default;
void SetUp() override { g_environment_set_up_count++; }
void TearDown() override { g_environment_tear_down_count++; }
};
@@ -117,6 +116,7 @@
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,8 +197,6 @@
int main(int argc, char **argv) {
testing::InitGoogleTest(&argc, argv);
- testing::AddGlobalTestEnvironment(new MyEnvironment);
-
TestRepeatUnspecified();
TestRepeat(0);
TestRepeat(1);
diff --git a/third_party/googletest/googletest/test/gtest_unittest.cc b/third_party/googletest/googletest/test/gtest_unittest.cc
index 67d776e..559d34c 100644
--- a/third_party/googletest/googletest/test/gtest_unittest.cc
+++ b/third_party/googletest/googletest/test/gtest_unittest.cc
@@ -422,11 +422,14 @@
EXPECT_EQ("-1234567.89", FormatTimeInMillisAsSeconds(-1234567890));
}
+// TODO: b/287046337 - In emscripten, local time zone modification is not
+// supported.
+#if !defined(__EMSCRIPTEN__)
// Tests FormatEpochTimeInMillisAsIso8601(). The correctness of conversion
// for particular dates below was verified in Python using
// datetime.datetime.fromutctimestamp(<timestamp>/1000).
-// FormatEpochTimeInMillisAsIso8601 depends on the current timezone, so we
+// FormatEpochTimeInMillisAsIso8601 depends on the local timezone, so we
// have to set up a particular timezone to obtain predictable results.
class FormatEpochTimeInMillisAsIso8601Test : public Test {
public:
@@ -445,9 +448,8 @@
}
GTEST_DISABLE_MSC_DEPRECATED_POP_()
- // Set up the time zone for FormatEpochTimeInMillisAsIso8601 to use. We
- // cannot use the local time zone because the function's output depends
- // on the time zone.
+ // Set the local time zone for FormatEpochTimeInMillisAsIso8601 to be
+ // a fixed time zone for reproducibility purposes.
SetTimeZone("UTC+00");
}
@@ -514,6 +516,8 @@
EXPECT_EQ("1970-01-01T00:00:00.000", FormatEpochTimeInMillisAsIso8601(0));
}
+#endif // __EMSCRIPTEN__
+
#ifdef __BORLANDC__
// Silences warnings: "Condition is always true", "Unreachable code"
#pragma option push -w-ccc -w-rch
@@ -2159,7 +2163,7 @@
};
// This will test property recording outside of any test or test case.
-static Environment* record_property_env GTEST_ATTRIBUTE_UNUSED_ =
+[[maybe_unused]] static Environment* record_property_env =
AddGlobalTestEnvironment(new UnitTestRecordPropertyTestEnvironment);
// This group of tests is for predicate assertions (ASSERT_PRED*, etc)
@@ -2866,6 +2870,8 @@
// This ensures that no overflow occurs when comparing numbers whose
// absolute value is very large.
TEST_F(FloatTest, Infinity) {
+ EXPECT_FLOAT_EQ(values_.infinity, values_.infinity);
+ EXPECT_FLOAT_EQ(-values_.infinity, -values_.infinity);
EXPECT_FLOAT_EQ(values_.infinity, values_.close_to_infinity);
EXPECT_FLOAT_EQ(-values_.infinity, -values_.close_to_infinity);
EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(values_.infinity, -values_.infinity),
@@ -2890,6 +2896,11 @@
EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan1), "v.nan1");
EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(v.nan1, v.nan2), "v.nan2");
EXPECT_NONFATAL_FAILURE(EXPECT_FLOAT_EQ(1.0, v.nan1), "v.nan1");
+ EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0f, v.nan1, 1.0f), "v.nan1");
+ EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0f, v.nan1, v.infinity), "v.nan1");
+ EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(v.infinity, v.nan1, 1.0f), "v.nan1");
+ EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(v.infinity, v.nan1, v.infinity),
+ "v.nan1");
EXPECT_FATAL_FAILURE(ASSERT_FLOAT_EQ(v.nan1, v.infinity), "v.infinity");
}
@@ -2913,11 +2924,28 @@
// Tests EXPECT_NEAR.
TEST_F(FloatTest, EXPECT_NEAR) {
+ static const FloatTest::TestValues& v = this->values_;
+
EXPECT_NEAR(-1.0f, -1.1f, 0.2f);
EXPECT_NEAR(2.0f, 3.0f, 1.0f);
+ EXPECT_NEAR(v.infinity, v.infinity, 0.0f);
+ EXPECT_NEAR(-v.infinity, -v.infinity, 0.0f);
+ EXPECT_NEAR(0.0f, 1.0f, v.infinity);
+ EXPECT_NEAR(v.infinity, -v.infinity, v.infinity);
+ EXPECT_NEAR(-v.infinity, v.infinity, v.infinity);
EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0f, 1.5f, 0.25f), // NOLINT
"The difference between 1.0f and 1.5f is 0.5, "
"which exceeds 0.25f");
+ EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(v.infinity, -v.infinity, 0.0f), // NOLINT
+ "The difference between v.infinity and -v.infinity "
+ "is inf, which exceeds 0.0f");
+ EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(-v.infinity, v.infinity, 0.0f), // NOLINT
+ "The difference between -v.infinity and v.infinity "
+ "is inf, which exceeds 0.0f");
+ EXPECT_NONFATAL_FAILURE(
+ EXPECT_NEAR(v.infinity, v.close_to_infinity, v.further_from_infinity),
+ "The difference between v.infinity and v.close_to_infinity is inf, which "
+ "exceeds v.further_from_infinity");
}
// Tests ASSERT_NEAR.
@@ -3024,6 +3052,8 @@
// This ensures that no overflow occurs when comparing numbers whose
// absolute value is very large.
TEST_F(DoubleTest, Infinity) {
+ EXPECT_DOUBLE_EQ(values_.infinity, values_.infinity);
+ EXPECT_DOUBLE_EQ(-values_.infinity, -values_.infinity);
EXPECT_DOUBLE_EQ(values_.infinity, values_.close_to_infinity);
EXPECT_DOUBLE_EQ(-values_.infinity, -values_.close_to_infinity);
EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(values_.infinity, -values_.infinity),
@@ -3043,6 +3073,12 @@
EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan1), "v.nan1");
EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(v.nan1, v.nan2), "v.nan2");
EXPECT_NONFATAL_FAILURE(EXPECT_DOUBLE_EQ(1.0, v.nan1), "v.nan1");
+ EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0, v.nan1, 1.0), "v.nan1");
+ EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0, v.nan1, v.infinity), "v.nan1");
+ EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(v.infinity, v.nan1, 1.0), "v.nan1");
+ EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(v.infinity, v.nan1, v.infinity),
+ "v.nan1");
+
EXPECT_FATAL_FAILURE(ASSERT_DOUBLE_EQ(v.nan1, v.infinity), "v.infinity");
}
@@ -3065,11 +3101,28 @@
// Tests EXPECT_NEAR.
TEST_F(DoubleTest, EXPECT_NEAR) {
+ static const DoubleTest::TestValues& v = this->values_;
+
EXPECT_NEAR(-1.0, -1.1, 0.2);
EXPECT_NEAR(2.0, 3.0, 1.0);
+ EXPECT_NEAR(v.infinity, v.infinity, 0.0);
+ EXPECT_NEAR(-v.infinity, -v.infinity, 0.0);
+ EXPECT_NEAR(0.0, 1.0, v.infinity);
+ EXPECT_NEAR(v.infinity, -v.infinity, v.infinity);
+ EXPECT_NEAR(-v.infinity, v.infinity, v.infinity);
EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(1.0, 1.5, 0.25), // NOLINT
"The difference between 1.0 and 1.5 is 0.5, "
"which exceeds 0.25");
+ EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(v.infinity, -v.infinity, 0.0),
+ "The difference between v.infinity and -v.infinity "
+ "is inf, which exceeds 0.0");
+ EXPECT_NONFATAL_FAILURE(EXPECT_NEAR(-v.infinity, v.infinity, 0.0),
+ "The difference between -v.infinity and v.infinity "
+ "is inf, which exceeds 0.0");
+ EXPECT_NONFATAL_FAILURE(
+ EXPECT_NEAR(v.infinity, v.close_to_infinity, v.further_from_infinity),
+ "The difference between v.infinity and v.close_to_infinity is inf, which "
+ "exceeds v.further_from_infinity");
// At this magnitude adjacent doubles are 512.0 apart, so this triggers a
// slightly different failure reporting path.
EXPECT_NONFATAL_FAILURE(
@@ -4168,8 +4221,8 @@
#endif
TEST(AssertionSyntaxTest, NoFatalFailureAssertionsBehavesLikeSingleStatement) {
if (AlwaysFalse())
- EXPECT_NO_FATAL_FAILURE(FAIL()) << "This should never be executed. "
- << "It's a compilation test only.";
+ EXPECT_NO_FATAL_FAILURE(FAIL())
+ << "This should never be executed. " << "It's a compilation test only.";
else
; // NOLINT
@@ -6667,6 +6720,9 @@
SetEnv("TERM", "xterm-kitty"); // TERM supports colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
+ SetEnv("TERM", "alacritty"); // TERM supports colors.
+ EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
+
SetEnv("TERM", "xterm-256color"); // TERM supports colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
@@ -6691,15 +6747,15 @@
SetEnv("TERM", "linux"); // TERM supports colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
- SetEnv("TERM", "cygwin"); // TERM supports colors.
+ SetEnv("TERM", "cygwin"); // TERM supports colors.
EXPECT_TRUE(ShouldUseColor(true)); // Stdout is a TTY.
#endif // GTEST_OS_WINDOWS
}
// Verifies that StaticAssertTypeEq works in a namespace scope.
-static bool dummy1 GTEST_ATTRIBUTE_UNUSED_ = StaticAssertTypeEq<bool, bool>();
-static bool dummy2 GTEST_ATTRIBUTE_UNUSED_ =
+[[maybe_unused]] static bool dummy1 = StaticAssertTypeEq<bool, bool>();
+[[maybe_unused]] static bool dummy2 =
StaticAssertTypeEq<const int, const int>();
// Verifies that StaticAssertTypeEq works in a class.
@@ -7475,22 +7531,6 @@
EXPECT_EQ(a, na.begin());
}
-// IndexSequence
-TEST(IndexSequence, MakeIndexSequence) {
- using testing::internal::IndexSequence;
- using testing::internal::MakeIndexSequence;
- EXPECT_TRUE(
- (std::is_same<IndexSequence<>, MakeIndexSequence<0>::type>::value));
- EXPECT_TRUE(
- (std::is_same<IndexSequence<0>, MakeIndexSequence<1>::type>::value));
- EXPECT_TRUE(
- (std::is_same<IndexSequence<0, 1>, MakeIndexSequence<2>::type>::value));
- EXPECT_TRUE((
- std::is_same<IndexSequence<0, 1, 2>, MakeIndexSequence<3>::type>::value));
- EXPECT_TRUE(
- (std::is_base_of<IndexSequence<0, 1, 2>, MakeIndexSequence<3>>::value));
-}
-
// ElemFromList
TEST(ElemFromList, Basic) {
using testing::internal::ElemFromList;
diff --git a/third_party/googletest/googletest/test/gtest_xml_output_unittest.py b/third_party/googletest/googletest/test/gtest_xml_output_unittest.py
index 422569e..87a7683 100755
--- a/third_party/googletest/googletest/test/gtest_xml_output_unittest.py
+++ b/third_party/googletest/googletest/test/gtest_xml_output_unittest.py
@@ -29,14 +29,14 @@
# (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 the gtest_xml_output module"""
+"""Unit test for the gtest_xml_output module."""
import datetime
import errno
import os
import re
import sys
-from xml.dom import minidom, Node
+from xml.dom import minidom
from googletest.test import gtest_test_utils
from googletest.test import gtest_xml_test_utils
@@ -67,7 +67,10 @@
sys.argv.remove(NO_STACKTRACE_SUPPORT_FLAG)
EXPECTED_NON_EMPTY_XML = """<?xml version="1.0" encoding="UTF-8"?>
-<testsuites tests="26" failures="5" disabled="2" errors="0" time="*" timestamp="*" name="AllTests" ad_hoc_property="42">
+<testsuites tests="28" failures="5" disabled="2" errors="0" time="*" timestamp="*" name="AllTests">
+ <properties>
+ <property name="ad_hoc_property" value="42"/>
+ </properties>
<testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
<testcase name="Succeeds" file="gtest_xml_output_unittest_.cc" line="53" status="run" result="completed" time="*" timestamp="*" classname="SuccessfulTest"/>
</testsuite>
@@ -112,81 +115,111 @@
</testsuite>
<testsuite name="SkippedTest" tests="3" failures="1" disabled="0" skipped="2" errors="0" time="*" timestamp="*">
<testcase name="Skipped" status="run" file="gtest_xml_output_unittest_.cc" line="75" result="skipped" time="*" timestamp="*" classname="SkippedTest">
- <skipped message="gtest_xml_output_unittest_.cc:*
%(stack_entity)s"><![CDATA[gtest_xml_output_unittest_.cc:*
-%(stack)s]]></skipped>
+ <skipped message="gtest_xml_output_unittest_.cc:*

"><![CDATA[gtest_xml_output_unittest_.cc:*
+
+]]></skipped>
</testcase>
<testcase name="SkippedWithMessage" file="gtest_xml_output_unittest_.cc" line="79" status="run" result="skipped" time="*" timestamp="*" classname="SkippedTest">
- <skipped message="gtest_xml_output_unittest_.cc:*
It is good practice to tell why you skip a test.%(stack_entity)s"><![CDATA[gtest_xml_output_unittest_.cc:*
-It is good practice to tell why you skip a test.%(stack)s]]></skipped>
+ <skipped message="gtest_xml_output_unittest_.cc:*
It is good practice to tell why you skip a test.
"><![CDATA[gtest_xml_output_unittest_.cc:*
+It is good practice to tell why you skip a test.
+]]></skipped>
</testcase>
<testcase name="SkippedAfterFailure" file="gtest_xml_output_unittest_.cc" line="83" status="run" result="completed" time="*" timestamp="*" classname="SkippedTest">
<failure message="gtest_xml_output_unittest_.cc:*
Expected equality of these values:
 1
 2%(stack_entity)s" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
Expected equality of these values:
1
2%(stack)s]]></failure>
- <skipped message="gtest_xml_output_unittest_.cc:*
It is good practice to tell why you skip a test.%(stack_entity)s"><![CDATA[gtest_xml_output_unittest_.cc:*
-It is good practice to tell why you skip a test.%(stack)s]]></skipped>
+ <skipped message="gtest_xml_output_unittest_.cc:*
It is good practice to tell why you skip a test.
"><![CDATA[gtest_xml_output_unittest_.cc:*
+It is good practice to tell why you skip a test.
+]]></skipped>
</testcase>
</testsuite>
- <testsuite name="PropertyRecordingTest" tests="4" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*" SetUpTestSuite="yes" TearDownTestSuite="aye">
- <testcase name="OneProperty" file="gtest_xml_output_unittest_.cc" line="121" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
+ <testsuite name="PropertyRecordingTest" tests="4" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
+ <properties>
+ <property name="SetUpTestSuite" value="yes"/>
+ <property name="SetUpTestSuite (with whitespace)" value="yes and yes"/>
+ <property name="TearDownTestSuite" value="aye"/>
+ <property name="TearDownTestSuite (with whitespace)" value="aye and aye"/>
+ </properties>
+ <testcase name="OneProperty" file="gtest_xml_output_unittest_.cc" line="125" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
<properties>
<property name="key_1" value="1"/>
</properties>
</testcase>
- <testcase name="IntValuedProperty" file="gtest_xml_output_unittest_.cc" line="125" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
+ <testcase name="IntValuedProperty" file="gtest_xml_output_unittest_.cc" line="129" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
<properties>
<property name="key_int" value="1"/>
</properties>
</testcase>
- <testcase name="ThreeProperties" file="gtest_xml_output_unittest_.cc" line="129" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
+ <testcase name="ThreeProperties" file="gtest_xml_output_unittest_.cc" line="133" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
<properties>
<property name="key_1" value="1"/>
<property name="key_2" value="2"/>
<property name="key_3" value="3"/>
</properties>
</testcase>
- <testcase name="TwoValuesForOneKeyUsesLastValue" file="gtest_xml_output_unittest_.cc" line="135" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
+ <testcase name="TwoValuesForOneKeyUsesLastValue" file="gtest_xml_output_unittest_.cc" line="139" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
<properties>
<property name="key_1" value="2"/>
</properties>
</testcase>
</testsuite>
<testsuite name="NoFixtureTest" tests="3" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
- <testcase name="RecordProperty" file="gtest_xml_output_unittest_.cc" line="140" status="run" result="completed" time="*" timestamp="*" classname="NoFixtureTest">
+ <testcase name="RecordProperty" file="gtest_xml_output_unittest_.cc" line="144" status="run" result="completed" time="*" timestamp="*" classname="NoFixtureTest">
<properties>
<property name="key" value="1"/>
</properties>
</testcase>
- <testcase name="ExternalUtilityThatCallsRecordIntValuedProperty" file="gtest_xml_output_unittest_.cc" line="153" status="run" result="completed" time="*" timestamp="*" classname="NoFixtureTest">
+ <testcase name="ExternalUtilityThatCallsRecordIntValuedProperty" file="gtest_xml_output_unittest_.cc" line="157" status="run" result="completed" time="*" timestamp="*" classname="NoFixtureTest">
<properties>
<property name="key_for_utility_int" value="1"/>
</properties>
</testcase>
- <testcase name="ExternalUtilityThatCallsRecordStringValuedProperty" file="gtest_xml_output_unittest_.cc" line="157" status="run" result="completed" time="*" timestamp="*" classname="NoFixtureTest">
+ <testcase name="ExternalUtilityThatCallsRecordStringValuedProperty" file="gtest_xml_output_unittest_.cc" line="161" status="run" result="completed" time="*" timestamp="*" classname="NoFixtureTest">
<properties>
<property name="key_for_utility_string" value="1"/>
</properties>
</testcase>
</testsuite>
+ <testsuite name="SetupFailTest" tests="1" failures="0" disabled="0" skipped="1" errors="0" time="*" timestamp="*">
+ <testcase name="NoopPassingTest" file="gtest_xml_output_unittest_.cc" line="172" status="run" result="skipped" time="*" timestamp="*" classname="SetupFailTest">
+ <skipped message="gtest_xml_output_unittest_.cc:*
"><![CDATA[gtest_xml_output_unittest_.cc:*
+]]></skipped>
+ </testcase>
+ <testcase name="" status="run" result="completed" classname="" time="*" timestamp="*">
+ <failure message="gtest_xml_output_unittest_.cc:*
Expected equality of these values:
 1
 2%(stack_entity)s" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
+Expected equality of these values:
+ 1
+ 2%(stack)s]]></failure>
+ </testcase>
+ </testsuite>
+ <testsuite name="TearDownFailTest" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
+ <testcase name="NoopPassingTest" file="gtest_xml_output_unittest_.cc" line="179" status="run" result="completed" time="*" timestamp="*" classname="TearDownFailTest"/>
+ <testcase name="" status="run" result="completed" classname="" time="*" timestamp="*">
+ <failure message="gtest_xml_output_unittest_.cc:*
Expected equality of these values:
 1
 2%(stack_entity)s" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
+Expected equality of these values:
+ 1
+ 2%(stack)s]]></failure>
+ </testcase>
+ </testsuite>
<testsuite name="Single/ValueParamTest" tests="4" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
- <testcase name="HasValueParamAttribute/0" file="gtest_xml_output_unittest_.cc" line="164" value_param="33" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
- <testcase name="HasValueParamAttribute/1" file="gtest_xml_output_unittest_.cc" line="164" value_param="42" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
- <testcase name="AnotherTestThatHasValueParamAttribute/0" file="gtest_xml_output_unittest_.cc" line="165" value_param="33" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
- <testcase name="AnotherTestThatHasValueParamAttribute/1" file="gtest_xml_output_unittest_.cc" line="165" value_param="42" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
+ <testcase name="HasValueParamAttribute/0" file="gtest_xml_output_unittest_.cc" line="184" value_param="33" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
+ <testcase name="HasValueParamAttribute/1" file="gtest_xml_output_unittest_.cc" line="184" value_param="42" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
+ <testcase name="AnotherTestThatHasValueParamAttribute/0" file="gtest_xml_output_unittest_.cc" line="185" value_param="33" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
+ <testcase name="AnotherTestThatHasValueParamAttribute/1" file="gtest_xml_output_unittest_.cc" line="185" value_param="42" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
</testsuite>
<testsuite name="TypedTest/0" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
- <testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="173" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="TypedTest/0" />
+ <testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="193" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="TypedTest/0" />
</testsuite>
<testsuite name="TypedTest/1" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
- <testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="173" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="TypedTest/1" />
+ <testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="193" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="TypedTest/1" />
</testsuite>
<testsuite name="Single/TypeParameterizedTestSuite/0" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
- <testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="180" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="Single/TypeParameterizedTestSuite/0" />
+ <testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="200" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="Single/TypeParameterizedTestSuite/0" />
</testsuite>
<testsuite name="Single/TypeParameterizedTestSuite/1" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
- <testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="180" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="Single/TypeParameterizedTestSuite/1" />
+ <testcase name="HasTypeParamAttribute" file="gtest_xml_output_unittest_.cc" line="200" type_param="*" status="run" result="completed" time="*" timestamp="*" classname="Single/TypeParameterizedTestSuite/1" />
</testsuite>
</testsuites>""" % {
'stack': STACK_TRACE_TEMPLATE,
@@ -194,8 +227,10 @@
}
EXPECTED_FILTERED_TEST_XML = """<?xml version="1.0" encoding="UTF-8"?>
-<testsuites tests="1" failures="0" disabled="0" errors="0" time="*"
- timestamp="*" name="AllTests" ad_hoc_property="42">
+<testsuites tests="1" failures="0" disabled="0" errors="0" time="*" timestamp="*" name="AllTests">
+ <properties>
+ <property name="ad_hoc_property" value="42"/>
+ </properties>
<testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0" skipped="0"
errors="0" time="*" timestamp="*">
<testcase name="Succeeds" file="gtest_xml_output_unittest_.cc" line="53" status="run" result="completed" time="*" timestamp="*" classname="SuccessfulTest"/>
@@ -203,19 +238,28 @@
</testsuites>"""
EXPECTED_SHARDED_TEST_XML = """<?xml version="1.0" encoding="UTF-8"?>
-<testsuites tests="3" failures="0" disabled="0" errors="0" time="*" timestamp="*" name="AllTests" ad_hoc_property="42">
+<testsuites tests="3" failures="0" disabled="0" errors="0" time="*" timestamp="*" name="AllTests">
+ <properties>
+ <property name="ad_hoc_property" value="42"/>
+ </properties>
<testsuite name="SuccessfulTest" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
<testcase name="Succeeds" file="gtest_xml_output_unittest_.cc" line="53" status="run" result="completed" time="*" timestamp="*" classname="SuccessfulTest"/>
</testsuite>
- <testsuite name="PropertyRecordingTest" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*" SetUpTestSuite="yes" TearDownTestSuite="aye">
- <testcase name="IntValuedProperty" file="gtest_xml_output_unittest_.cc" line="125" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
+ <testsuite name="PropertyRecordingTest" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
+ <properties>
+ <property name="SetUpTestSuite" value="yes"/>
+ <property name="SetUpTestSuite (with whitespace)" value="yes and yes"/>
+ <property name="TearDownTestSuite" value="aye"/>
+ <property name="TearDownTestSuite (with whitespace)" value="aye and aye"/>
+ </properties>
+ <testcase name="IntValuedProperty" file="gtest_xml_output_unittest_.cc" line="129" status="run" result="completed" time="*" timestamp="*" classname="PropertyRecordingTest">
<properties>
<property name="key_int" value="1"/>
</properties>
</testcase>
</testsuite>
- <testsuite name="Single/ValueParamTest" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
- <testcase name="HasValueParamAttribute/0" file="gtest_xml_output_unittest_.cc" line="164" value_param="33" status="run" result="completed" time="*" timestamp="*" classname="Single/ValueParamTest" />
+ <testsuite name="Single/TypeParameterizedTestSuite/0" tests="1" failures="0" disabled="0" skipped="0" errors="0" time="*" timestamp="*">
+ <testcase name="HasTypeParamAttribute" type_param="*" file="gtest_xml_output_unittest_.cc" line="200" status="run" result="completed" time="*" timestamp="*" classname="Single/TypeParameterizedTestSuite/0" />
</testsuite>
</testsuites>"""
diff --git a/third_party/googletest/googletest/test/gtest_xml_output_unittest_.cc b/third_party/googletest/googletest/test/gtest_xml_output_unittest_.cc
index 0ab3302..fe196b6 100644
--- a/third_party/googletest/googletest/test/gtest_xml_output_unittest_.cc
+++ b/third_party/googletest/googletest/test/gtest_xml_output_unittest_.cc
@@ -112,8 +112,12 @@
class PropertyRecordingTest : public Test {
public:
- static void SetUpTestSuite() { RecordProperty("SetUpTestSuite", "yes"); }
+ static void SetUpTestSuite() {
+ RecordProperty("SetUpTestSuite (with whitespace)", "yes and yes");
+ RecordProperty("SetUpTestSuite", "yes");
+ }
static void TearDownTestSuite() {
+ RecordProperty("TearDownTestSuite (with whitespace)", "aye and aye");
RecordProperty("TearDownTestSuite", "aye");
}
};
@@ -158,6 +162,22 @@
ExternalUtilityThatCallsRecordProperty("key_for_utility_string", "1");
}
+// Ensures that SetUpTestSuite and TearDownTestSuite failures are reported in
+// the XML output.
+class SetupFailTest : public ::testing::Test {
+ protected:
+ static void SetUpTestSuite() { ASSERT_EQ(1, 2); }
+};
+
+TEST_F(SetupFailTest, NoopPassingTest) {}
+
+class TearDownFailTest : public ::testing::Test {
+ protected:
+ static void TearDownTestSuite() { ASSERT_EQ(1, 2); }
+};
+
+TEST_F(TearDownFailTest, NoopPassingTest) {}
+
// Verifies that the test parameter value is output in the 'value_param'
// XML attribute for value-parameterized tests.
class ValueParamTest : public TestWithParam<int> {};
diff --git a/third_party/googletest/googletest_deps.bzl b/third_party/googletest/googletest_deps.bzl
index e25f5a1..d3dd03e 100644
--- a/third_party/googletest/googletest_deps.bzl
+++ b/third_party/googletest/googletest_deps.bzl
@@ -1,22 +1,28 @@
"""Load dependencies needed to use the googletest library as a 3rd-party consumer."""
load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+load("//:fake_fuchsia_sdk.bzl", "fake_fuchsia_sdk")
def googletest_deps():
"""Loads common dependencies needed to use the googletest library."""
- if not native.existing_rule("com_googlesource_code_re2"):
+ if not native.existing_rule("re2"):
http_archive(
- name = "com_googlesource_code_re2", # 2023-03-17T11:36:51Z
- sha256 = "cb8b5312a65f2598954545a76e8bce913f35fbb3a21a5c88797a4448e9f9b9d9",
- strip_prefix = "re2-578843a516fd1da7084ae46209a75f3613b6065e",
- urls = ["https://github.com/google/re2/archive/578843a516fd1da7084ae46209a75f3613b6065e.zip"],
+ name = "re2",
+ sha256 = "eb2df807c781601c14a260a507a5bb4509be1ee626024cb45acbd57cb9d4032b",
+ strip_prefix = "re2-2024-07-02",
+ urls = ["https://github.com/google/re2/releases/download/2024-07-02/re2-2024-07-02.tar.gz"],
)
- if not native.existing_rule("com_google_absl"):
+ if not native.existing_rule("abseil-cpp"):
http_archive(
- name = "com_google_absl", # 2023-08-01T14:59:13Z
- sha256 = "d2c09bf3b3aba57ad87a56082020bee2948445407756e92ddaf3595396086853",
- strip_prefix = "abseil-cpp-22091f4c0d6626b3ef40446ce3d4ccab19425ca3",
- urls = ["https://github.com/abseil/abseil-cpp/archive/22091f4c0d6626b3ef40446ce3d4ccab19425ca3.zip"],
+ name = "abseil-cpp",
+ sha256 = "16242f394245627e508ec6bb296b433c90f8d914f73b9c026fddb905e27276e8",
+ strip_prefix = "abseil-cpp-20250127.0",
+ urls = ["https://github.com/abseil/abseil-cpp/releases/download/20250127.0/abseil-cpp-20250127.0.tar.gz"],
+ )
+
+ if not native.existing_rule("fuchsia_sdk"):
+ fake_fuchsia_sdk(
+ name = "fuchsia_sdk",
)
