From c5cc79ee6f5efe195920ffafc2f0d009c99fadae Mon Sep 17 00:00:00 2001
From: winlin <winlin@vip.126.com>
Date: Thu, 17 Mar 2022 08:42:44 +0800
Subject: [PATCH 1/4] SRT: Support debug and run with CLion. v4.0.249

---
 .run/srt.run.xml                     |  7 +++++++
 trunk/doc/CHANGELOG.md               |  1 +
 trunk/ide/srs_clion/CMakeLists.txt   | 14 +++++++++++---
 trunk/src/core/srs_core_version4.hpp |  2 +-
 4 files changed, 20 insertions(+), 4 deletions(-)
 create mode 100644 .run/srt.run.xml

diff --git a/.run/srt.run.xml b/.run/srt.run.xml
new file mode 100644
index 000000000..10040056c
--- /dev/null
+++ b/.run/srt.run.xml
@@ -0,0 +1,7 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="srt" type="CMakeRunConfiguration" factoryName="Application" PROGRAM_PARAMS="-c conf/srt.conf" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" WORKING_DIR="file://$CMakeCurrentBuildDir$/../../../" PASS_PARENT_ENVS_2="true" PROJECT_NAME="srs" TARGET_NAME="srs" CONFIG_NAME="Debug" RUN_TARGET_PROJECT_NAME="srs" RUN_TARGET_NAME="srs">
+    <method v="2">
+      <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/trunk/doc/CHANGELOG.md b/trunk/doc/CHANGELOG.md
index 92357b9b3..bbdd18531 100644
--- a/trunk/doc/CHANGELOG.md
+++ b/trunk/doc/CHANGELOG.md
@@ -8,6 +8,7 @@ The changelog for SRS.
 
 ## SRS 4.0 Changelog
 
+* v4.0, 2022-03-17, SRT: Support debug and run with CLion. v4.0.249
 * v4.0, 2022-03-15, Merge [#2966](https://github.com/ossrs/srs/pull/2966): Bugfix: Fix rtcp nack blp encode bug (#2966). v4.0.248
 * v4.0, 2022-03-07, RTC: Identify the WebRTC publisher in param for hooks. v4.0.247
 * v4.0, 2022-03-07, SRT: Append vhost to stream, not app. v4.0.246
diff --git a/trunk/ide/srs_clion/CMakeLists.txt b/trunk/ide/srs_clion/CMakeLists.txt
index 1108fb66a..9efcffbb9 100755
--- a/trunk/ide/srs_clion/CMakeLists.txt
+++ b/trunk/ide/srs_clion/CMakeLists.txt
@@ -1,5 +1,6 @@
 cmake_minimum_required(VERSION 2.8.12)
 project(srs CXX)
+set (CMAKE_CXX_STANDARD 11)
 
 ###########################################################
 execute_process(
@@ -16,7 +17,7 @@ ProcessorCount(JOBS)
 
 # We should always configure SRS for switching between branches.
 IF (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-    EXEC_PROGRAM("cd ${SRS_DIR} && ./configure --osx --jobs=${JOBS}")
+    EXEC_PROGRAM("cd ${SRS_DIR} && ./configure --osx --srt=on --jobs=${JOBS}")
 ELSE ()
     EXEC_PROGRAM("cd ${SRS_DIR} && ./configure --jobs=${JOBS}")
 ENDIF ()
@@ -28,7 +29,8 @@ set(DEPS_LIBS ${SRS_DIR}/objs/st/libst.a
         ${SRS_DIR}/objs/ffmpeg/lib/libavcodec.a
         ${SRS_DIR}/objs/ffmpeg/lib/libavutil.a
         ${SRS_DIR}/objs/opus/lib/libopus.a
-        ${SRS_DIR}/objs/ffmpeg/lib/libswresample.a)
+        ${SRS_DIR}/objs/ffmpeg/lib/libswresample.a
+        ${SRS_DIR}/objs/srt/lib/libsrt.a)
 foreach(DEPS_LIB ${DEPS_LIBS})
     IF (NOT EXISTS ${DEPS_LIB})
         MESSAGE(FATAL_ERROR "${DEPS_LIB} not found")
@@ -45,17 +47,23 @@ INCLUDE_DIRECTORIES(${SRS_DIR}/objs
         ${SRS_DIR}/objs/srtp2/include
         ${SRS_DIR}/objs/opus/include
         ${SRS_DIR}/objs/ffmpeg/include
+        ${SRS_DIR}/objs/srt/include
         ${SRS_DIR}/src/core
         ${SRS_DIR}/src/kernel
         ${SRS_DIR}/src/protocol
         ${SRS_DIR}/src/app
-        ${SRS_DIR}/src/service)
+        ${SRS_DIR}/src/service
+        ${SRS_DIR}/src/srt)
 
 set(SOURCE_FILES ${SRS_DIR}/src/main/srs_main_server.cpp)
 AUX_SOURCE_DIRECTORY(${SRS_DIR}/src/core SOURCE_FILES)
 AUX_SOURCE_DIRECTORY(${SRS_DIR}/src/kernel SOURCE_FILES)
 AUX_SOURCE_DIRECTORY(${SRS_DIR}/src/protocol SOURCE_FILES)
 AUX_SOURCE_DIRECTORY(${SRS_DIR}/src/app SOURCE_FILES)
+AUX_SOURCE_DIRECTORY(${SRS_DIR}/src/srt SOURCE_FILES)
+
+# Remove the duplicated main.
+list(REMOVE_ITEM SOURCE_FILES ${SRS_DIR}/src/srt/ts_demux_test.cpp)
 
 ADD_DEFINITIONS("-g -O0")
 
diff --git a/trunk/src/core/srs_core_version4.hpp b/trunk/src/core/srs_core_version4.hpp
index da4e606a8..553ceeff9 100644
--- a/trunk/src/core/srs_core_version4.hpp
+++ b/trunk/src/core/srs_core_version4.hpp
@@ -9,6 +9,6 @@
 
 #define VERSION_MAJOR       4
 #define VERSION_MINOR       0
-#define VERSION_REVISION    248
+#define VERSION_REVISION    249
 
 #endif

From 350c05c589c8ba0944fc79c138c4aeda552ad33c Mon Sep 17 00:00:00 2001
From: Winlin <winlin@vip.126.com>
Date: Thu, 17 Mar 2022 16:56:52 +0800
Subject: [PATCH 2/4] UTest: Upgrade gtest to 1.11 and support clion. (#2970)

---
 .run/include.run.xml                          |    7 +
 .run/ingest.run.xml                           |    7 +
 .run/private.run.xml                          |    7 +
 .run/srs-ingest.run.xml                       |    7 -
 .run/utest.run.xml                            |    7 +
 trunk/3rdparty/README.md                      |    6 +-
 trunk/3rdparty/gtest-1.6.0.zip                |  Bin 1121697 -> 0 bytes
 trunk/3rdparty/gtest-fit/.gitignore           |   84 +
 trunk/3rdparty/gtest-fit/CMakeLists.txt       |   32 +
 trunk/3rdparty/gtest-fit/LICENSE              |   28 +
 .../gtest-fit/googlemock/CMakeLists.txt       |  218 +
 trunk/3rdparty/gtest-fit/googlemock/README.md |   44 +
 .../gtest-fit/googlemock/cmake/gmock.pc.in    |   10 +
 .../googlemock/cmake/gmock_main.pc.in         |   10 +
 .../googlemock/include/gmock/gmock-actions.h  | 1687 +++++
 .../include/gmock/gmock-cardinalities.h       |  157 +
 .../include/gmock/gmock-function-mocker.h     |  479 ++
 .../googlemock/include/gmock/gmock-matchers.h | 5392 +++++++++++++
 .../include/gmock/gmock-more-actions.h        |  573 ++
 .../include/gmock/gmock-more-matchers.h       |   92 +
 .../include/gmock/gmock-nice-strict.h         |  261 +
 .../include/gmock/gmock-spec-builders.h       | 2038 +++++
 .../googlemock/include/gmock/gmock.h          |   98 +
 .../include/gmock/internal/custom/README.md   |   16 +
 .../internal/custom/gmock-generated-actions.h |    6 +
 .../gmock/internal/custom/gmock-matchers.h    |   36 +
 .../gmock/internal/custom/gmock-port.h        |   39 +
 .../gmock/internal/gmock-internal-utils.h     |  459 ++
 .../include/gmock/internal/gmock-port.h       |   87 +
 .../include/gmock/internal/gmock-pp.h         |  279 +
 .../gtest-fit/googlemock/src/gmock-all.cc     |   46 +
 .../googlemock/src/gmock-cardinalities.cc     |  155 +
 .../googlemock/src/gmock-internal-utils.cc    |  200 +
 .../googlemock/src/gmock-matchers.cc          |  459 ++
 .../googlemock/src/gmock-spec-builders.cc     |  908 +++
 .../gtest-fit/googlemock/src/gmock.cc         |  213 +
 .../gtest-fit/googlemock/src/gmock_main.cc    |   72 +
 .../gtest-fit/googletest/CMakeLists.txt       |  323 +
 trunk/3rdparty/gtest-fit/googletest/README.md |  215 +
 .../googletest/cmake/Config.cmake.in          |    9 +
 .../gtest-fit/googletest/cmake/gtest.pc.in    |    9 +
 .../googletest/cmake/gtest_main.pc.in         |   10 +
 .../googletest/cmake/internal_utils.cmake     |  344 +
 .../gtest-fit/googletest/cmake/libgtest.la.in |   21 +
 .../include/gtest/gtest-death-test.h          |  346 +
 .../googletest/include/gtest/gtest-matchers.h |  930 +++
 .../googletest/include/gtest/gtest-message.h  |  219 +
 .../include/gtest/gtest-param-test.h          |  507 ++
 .../googletest/include/gtest/gtest-printers.h | 1029 +++
 .../googletest/include/gtest/gtest-spi.h      |  238 +
 .../include/gtest/gtest-test-part.h           |  184 +
 .../include/gtest/gtest-typed-test.h          |  329 +
 .../googletest/include/gtest/gtest.h          | 2495 ++++++
 .../include/gtest/gtest_pred_impl.h           |  359 +
 .../googletest/include/gtest/gtest_prod.h     |   61 +
 .../include/gtest/internal/custom/README.md   |   56 +
 .../gtest/internal/custom/gtest-port.h        |   37 +
 .../gtest/internal/custom/gtest-printers.h    |   42 +
 .../include/gtest/internal/custom/gtest.h     |   37 +
 .../internal/gtest-death-test-internal.h      |  304 +
 .../include/gtest/internal/gtest-filepath.h   |  211 +
 .../include/gtest/internal/gtest-internal.h   | 1560 ++++
 .../include/gtest/internal/gtest-param-util.h |  947 +++
 .../include/gtest/internal/gtest-port-arch.h  |  114 +
 .../include/gtest/internal/gtest-port.h       | 2389 ++++++
 .../include/gtest/internal/gtest-string.h     |  175 +
 .../include/gtest/internal/gtest-type-util.h  |  183 +
 .../gtest-fit/googletest/src/gtest-all.cc     |   48 +
 .../googletest/src/gtest-death-test.cc        | 1644 ++++
 .../googletest/src/gtest-filepath.cc          |  369 +
 .../googletest/src/gtest-internal-inl.h       | 1221 +++
 .../googletest/src/gtest-matchers.cc          |   97 +
 .../gtest-fit/googletest/src/gtest-port.cc    | 1433 ++++
 .../googletest/src/gtest-printers.cc          |  533 ++
 .../googletest/src/gtest-test-part.cc         |  108 +
 .../googletest/src/gtest-typed-test.cc        |  107 +
 .../gtest-fit/googletest/src/gtest.cc         | 6746 +++++++++++++++++
 .../gtest-fit/googletest/src/gtest_main.cc    |   54 +
 trunk/Dockerfile.cov                          |    8 +-
 trunk/Dockerfile.test                         |    9 +-
 trunk/auto/depends.sh                         |   19 +-
 trunk/auto/utest.sh                           |    2 +
 trunk/ide/srs_clion/CMakeLists.txt            |   49 +-
 83 files changed, 40318 insertions(+), 31 deletions(-)
 create mode 100644 .run/include.run.xml
 create mode 100644 .run/ingest.run.xml
 create mode 100644 .run/private.run.xml
 delete mode 100644 .run/srs-ingest.run.xml
 create mode 100644 .run/utest.run.xml
 delete mode 100644 trunk/3rdparty/gtest-1.6.0.zip
 create mode 100644 trunk/3rdparty/gtest-fit/.gitignore
 create mode 100644 trunk/3rdparty/gtest-fit/CMakeLists.txt
 create mode 100644 trunk/3rdparty/gtest-fit/LICENSE
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/CMakeLists.txt
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/README.md
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/cmake/gmock.pc.in
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/cmake/gmock_main.pc.in
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-actions.h
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-cardinalities.h
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-function-mocker.h
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-matchers.h
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-more-actions.h
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-more-matchers.h
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-nice-strict.h
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-spec-builders.h
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock.h
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/custom/README.md
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/custom/gmock-generated-actions.h
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/custom/gmock-matchers.h
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/custom/gmock-port.h
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/gmock-internal-utils.h
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/gmock-port.h
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/gmock-pp.h
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/src/gmock-all.cc
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/src/gmock-cardinalities.cc
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/src/gmock-internal-utils.cc
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/src/gmock-matchers.cc
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/src/gmock-spec-builders.cc
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/src/gmock.cc
 create mode 100644 trunk/3rdparty/gtest-fit/googlemock/src/gmock_main.cc
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/CMakeLists.txt
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/README.md
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/cmake/Config.cmake.in
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/cmake/gtest.pc.in
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/cmake/gtest_main.pc.in
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/cmake/internal_utils.cmake
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/cmake/libgtest.la.in
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-death-test.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-matchers.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-message.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-param-test.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-printers.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-spi.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-test-part.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-typed-test.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest_pred_impl.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest_prod.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/custom/README.md
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/custom/gtest-port.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/custom/gtest-printers.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/custom/gtest.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-death-test-internal.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-filepath.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-internal.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-param-util.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-port-arch.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-port.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-string.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-type-util.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/src/gtest-all.cc
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/src/gtest-death-test.cc
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/src/gtest-filepath.cc
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/src/gtest-internal-inl.h
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/src/gtest-matchers.cc
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/src/gtest-port.cc
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/src/gtest-printers.cc
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/src/gtest-test-part.cc
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/src/gtest-typed-test.cc
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/src/gtest.cc
 create mode 100644 trunk/3rdparty/gtest-fit/googletest/src/gtest_main.cc

diff --git a/.run/include.run.xml b/.run/include.run.xml
new file mode 100644
index 000000000..b11c4e82f
--- /dev/null
+++ b/.run/include.run.xml
@@ -0,0 +1,7 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="include" type="CMakeRunConfiguration" factoryName="Application" PROGRAM_PARAMS="-c include.conf" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" WORKING_DIR="file://$CMakeCurrentBuildDir$/../../../" PASS_PARENT_ENVS_2="true" PROJECT_NAME="srs" TARGET_NAME="srs" CONFIG_NAME="Debug" RUN_TARGET_PROJECT_NAME="srs" RUN_TARGET_NAME="srs">
+    <method v="2">
+      <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/.run/ingest.run.xml b/.run/ingest.run.xml
new file mode 100644
index 000000000..f7c1b87bc
--- /dev/null
+++ b/.run/ingest.run.xml
@@ -0,0 +1,7 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="ingest" type="CMakeRunConfiguration" factoryName="Application" PROGRAM_PARAMS="-c conf/clion-ingest.conf" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" WORKING_DIR="file://$CMakeCurrentBuildDir$/../../../" PASS_PARENT_ENVS_2="true" PROJECT_NAME="srs" TARGET_NAME="srs" CONFIG_NAME="Debug" RUN_TARGET_PROJECT_NAME="srs" RUN_TARGET_NAME="srs">
+    <method v="2">
+      <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/.run/private.run.xml b/.run/private.run.xml
new file mode 100644
index 000000000..6496d2e86
--- /dev/null
+++ b/.run/private.run.xml
@@ -0,0 +1,7 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="private" type="CMakeRunConfiguration" factoryName="Application" PROGRAM_PARAMS="-c console.conf" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" WORKING_DIR="file://$CMakeCurrentBuildDir$/../../../" PASS_PARENT_ENVS_2="true" PROJECT_NAME="srs" TARGET_NAME="srs" CONFIG_NAME="Debug" RUN_TARGET_PROJECT_NAME="srs" RUN_TARGET_NAME="srs">
+    <method v="2">
+      <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/.run/srs-ingest.run.xml b/.run/srs-ingest.run.xml
deleted file mode 100644
index 1ef1dba30..000000000
--- a/.run/srs-ingest.run.xml
+++ /dev/null
@@ -1,7 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="srs-ingest" type="CMakeRunConfiguration" factoryName="Application" PROGRAM_PARAMS="-c conf/clion-ingest.conf" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" WORKING_DIR="file://$CMakeCurrentBuildDir$/../../../" PASS_PARENT_ENVS_2="true" PROJECT_NAME="srs" TARGET_NAME="srs" CONFIG_NAME="Debug" RUN_TARGET_PROJECT_NAME="srs" RUN_TARGET_NAME="srs">
-    <method v="2">
-      <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
-    </method>
-  </configuration>
-</component>
\ No newline at end of file
diff --git a/.run/utest.run.xml b/.run/utest.run.xml
new file mode 100644
index 000000000..19d8812ec
--- /dev/null
+++ b/.run/utest.run.xml
@@ -0,0 +1,7 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="utest" type="CMakeRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" WORKING_DIR="file://$CMakeCurrentBuildDir$/../../../" PASS_PARENT_ENVS_2="true" PROJECT_NAME="srs" TARGET_NAME="utest" CONFIG_NAME="Debug" RUN_TARGET_PROJECT_NAME="srs" RUN_TARGET_NAME="utest">
+    <method v="2">
+      <option name="com.jetbrains.cidr.execution.CidrBuildBeforeRunTaskProvider$BuildBeforeRunTask" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/trunk/3rdparty/README.md b/trunk/3rdparty/README.md
index 355f0938d..0ef512211 100644
--- a/trunk/3rdparty/README.md
+++ b/trunk/3rdparty/README.md
@@ -37,10 +37,10 @@ opus-1.3.1.tar.gz
 * https://github.com/xiph/opus/releases/tag/v1.3.1
 * To support RTMP/WebRTC transcoding.
 * https://github.com/ossrs/srs/wiki/LicenseMixing#ffmpeg
-    
-gtest-1.6.0.zip
+
+gtest-fit
 * google test framework.
-* https://code.google.com/p/googletest/downloads/list
+* https://github.com/google/googletest/releases/tag/release-1.11.0
 
 gperftools-2-fit
 * gperf tools for performance benchmark.
diff --git a/trunk/3rdparty/gtest-1.6.0.zip b/trunk/3rdparty/gtest-1.6.0.zip
deleted file mode 100644
index f07c43a74640781378fba578b2f379d7deff89cb..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1121697
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%0D0+fY?Mi3Qb`uVY5LtnFbnz
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
E4_riuj{pDw

diff --git a/trunk/3rdparty/gtest-fit/.gitignore b/trunk/3rdparty/gtest-fit/.gitignore
new file mode 100644
index 000000000..f08cb72a3
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/.gitignore
@@ -0,0 +1,84 @@
+# Ignore CI build directory
+build/
+xcuserdata
+cmake-build-debug/
+.idea/
+bazel-bin
+bazel-genfiles
+bazel-googletest
+bazel-out
+bazel-testlogs
+# python
+*.pyc
+
+# Visual Studio files
+.vs
+*.sdf
+*.opensdf
+*.VC.opendb
+*.suo
+*.user
+_ReSharper.Caches/
+Win32-Debug/
+Win32-Release/
+x64-Debug/
+x64-Release/
+
+# Ignore autoconf / automake files
+Makefile.in
+aclocal.m4
+configure
+build-aux/
+autom4te.cache/
+googletest/m4/libtool.m4
+googletest/m4/ltoptions.m4
+googletest/m4/ltsugar.m4
+googletest/m4/ltversion.m4
+googletest/m4/lt~obsolete.m4
+googlemock/m4
+
+# Ignore generated directories.
+googlemock/fused-src/
+googletest/fused-src/
+
+# macOS files
+.DS_Store
+googletest/.DS_Store
+googletest/xcode/.DS_Store
+
+# Ignore cmake generated directories and files.
+CMakeFiles
+CTestTestfile.cmake
+Makefile
+cmake_install.cmake
+googlemock/CMakeFiles
+googlemock/CTestTestfile.cmake
+googlemock/Makefile
+googlemock/cmake_install.cmake
+googlemock/gtest
+/bin
+/googlemock/gmock.dir
+/googlemock/gmock_main.dir
+/googlemock/RUN_TESTS.vcxproj.filters
+/googlemock/RUN_TESTS.vcxproj
+/googlemock/INSTALL.vcxproj.filters
+/googlemock/INSTALL.vcxproj
+/googlemock/gmock_main.vcxproj.filters
+/googlemock/gmock_main.vcxproj
+/googlemock/gmock.vcxproj.filters
+/googlemock/gmock.vcxproj
+/googlemock/gmock.sln
+/googlemock/ALL_BUILD.vcxproj.filters
+/googlemock/ALL_BUILD.vcxproj
+/lib
+/Win32
+/ZERO_CHECK.vcxproj.filters
+/ZERO_CHECK.vcxproj
+/RUN_TESTS.vcxproj.filters
+/RUN_TESTS.vcxproj
+/INSTALL.vcxproj.filters
+/INSTALL.vcxproj
+/googletest-distribution.sln
+/CMakeCache.txt
+/ALL_BUILD.vcxproj.filters
+/ALL_BUILD.vcxproj
diff --git a/trunk/3rdparty/gtest-fit/CMakeLists.txt b/trunk/3rdparty/gtest-fit/CMakeLists.txt
new file mode 100644
index 000000000..ea81ab129
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/CMakeLists.txt
@@ -0,0 +1,32 @@
+# Note: CMake support is community-based. The maintainers do not use CMake
+# internally.
+
+cmake_minimum_required(VERSION 2.8.12)
+
+if (POLICY CMP0048)
+  cmake_policy(SET CMP0048 NEW)
+endif (POLICY CMP0048)
+
+project(googletest-distribution)
+set(GOOGLETEST_VERSION 1.11.0)
+
+if (CMAKE_VERSION VERSION_GREATER "3.0.2")
+  if(NOT CYGWIN AND NOT MSYS AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL QNX)
+    set(CMAKE_CXX_EXTENSIONS OFF)
+  endif()
+endif()
+
+enable_testing()
+
+include(CMakeDependentOption)
+include(GNUInstallDirs)
+
+#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)
+
+if(BUILD_GMOCK)
+  add_subdirectory( googlemock )
+else()
+  add_subdirectory( googletest )
+endif()
diff --git a/trunk/3rdparty/gtest-fit/LICENSE b/trunk/3rdparty/gtest-fit/LICENSE
new file mode 100644
index 000000000..1941a11f8
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/LICENSE
@@ -0,0 +1,28 @@
+Copyright 2008, 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.
diff --git a/trunk/3rdparty/gtest-fit/googlemock/CMakeLists.txt b/trunk/3rdparty/gtest-fit/googlemock/CMakeLists.txt
new file mode 100644
index 000000000..e7df8ec53
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/CMakeLists.txt
@@ -0,0 +1,218 @@
+########################################################################
+# Note: CMake support is community-based. The maintainers do not use CMake
+# internally.
+#
+# 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'.
+# For more options, run 'ctest --help'.
+
+option(gmock_build_tests "Build all of Google Mock's own tests." OFF)
+
+# A directory to find Google Test sources.
+if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/gtest/CMakeLists.txt")
+  set(gtest_dir gtest)
+else()
+  set(gtest_dir ../googletest)
+endif()
+
+# Defines pre_project_set_up_hermetic_build() and set_up_hermetic_build().
+include("${gtest_dir}/cmake/hermetic_build.cmake" OPTIONAL)
+
+if (COMMAND pre_project_set_up_hermetic_build)
+  # Google Test also calls hermetic setup functions from add_subdirectory,
+  # although its changes will not affect things at the current scope.
+  pre_project_set_up_hermetic_build()
+endif()
+
+########################################################################
+#
+# Project-wide settings
+
+# Name of the project.
+#
+# CMake files in this project can refer to the root source directory
+# as ${gmock_SOURCE_DIR} and to the root binary directory as
+# ${gmock_BINARY_DIR}.
+# Language "C" is required for find_package(Threads).
+if (CMAKE_VERSION VERSION_LESS 3.0)
+  project(gmock CXX C)
+else()
+  cmake_policy(SET CMP0048 NEW)
+  project(gmock VERSION ${GOOGLETEST_VERSION} LANGUAGES CXX C)
+endif()
+cmake_minimum_required(VERSION 2.8.12)
+
+if (COMMAND set_up_hermetic_build)
+  set_up_hermetic_build()
+endif()
+
+# Instructs CMake to process Google Test's CMakeLists.txt and add its
+# targets to the current scope.  We are placing Google Test's binary
+# 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}")
+
+
+# These commands only run if this is the main project
+if(CMAKE_PROJECT_NAME STREQUAL "gmock" OR CMAKE_PROJECT_NAME STREQUAL "googletest-distribution")
+  # BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to
+  # make it prominent in the GUI.
+  option(BUILD_SHARED_LIBS "Build shared libraries (DLLs)." OFF)
+else()
+  mark_as_advanced(gmock_build_tests)
+endif()
+
+# Although Google Test's CMakeLists.txt calls this function, the
+# 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
+
+# Adds Google Mock's and Google Test's header directories to the search path.
+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}")
+include_directories(${gmock_build_include_dirs})
+
+########################################################################
+#
+# 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
+# are used for other targets, to ensure that Google Mock can be compiled by
+# a user aggressive about warnings.
+if (MSVC)
+  cxx_library(gmock
+              "${cxx_strict}"
+              "${gtest_dir}/src/gtest-all.cc"
+              src/gmock-all.cc)
+
+  cxx_library(gmock_main
+              "${cxx_strict}"
+              "${gtest_dir}/src/gtest-all.cc"
+              src/gmock-all.cc
+              src/gmock_main.cc)
+else()
+  cxx_library(gmock "${cxx_strict}" src/gmock-all.cc)
+  target_link_libraries(gmock PUBLIC gtest)
+  set_target_properties(gmock PROPERTIES VERSION ${GOOGLETEST_VERSION})
+  cxx_library(gmock_main "${cxx_strict}" src/gmock_main.cc)
+  target_link_libraries(gmock_main PUBLIC gmock)
+  set_target_properties(gmock_main PROPERTIES VERSION ${GOOGLETEST_VERSION})
+endif()
+# If the CMake version supports it, attach header directory information
+# to the targets for when we are part of a parent build (ie being pulled
+# in via add_subdirectory() rather than being a standalone build).
+if (DEFINED CMAKE_VERSION AND NOT "${CMAKE_VERSION}" VERSION_LESS "2.8.11")
+  target_include_directories(gmock SYSTEM INTERFACE
+    "$<BUILD_INTERFACE:${gmock_build_include_dirs}>"
+    "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>")
+  target_include_directories(gmock_main SYSTEM INTERFACE
+    "$<BUILD_INTERFACE:${gmock_build_include_dirs}>"
+    "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>")
+endif()
+
+########################################################################
+#
+# Install rules
+install_project(gmock gmock_main)
+
+########################################################################
+#
+# Google Mock's own tests.
+#
+# 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
+# or specifying the -Dgmock_build_tests=ON flag when running cmake.
+
+if (gmock_build_tests)
+  # This must be set in the root directory for the tests to be run by
+  # 'make test' or ctest.
+  enable_testing()
+
+  if (MINGW OR CYGWIN)
+    if (CMAKE_VERSION VERSION_LESS "2.8.12")
+      add_compile_options("-Wa,-mbig-obj")
+    else()
+      add_definitions("-Wa,-mbig-obj")
+    endif()
+  endif()
+
+  ############################################################
+  # C++ tests built with standard compiler flags.
+
+  cxx_test(gmock-actions_test gmock_main)
+  cxx_test(gmock-cardinalities_test gmock_main)
+  cxx_test(gmock_ex_test gmock_main)
+  cxx_test(gmock-function-mocker_test gmock_main)
+  cxx_test(gmock-internal-utils_test gmock_main)
+  cxx_test(gmock-matchers_test gmock_main)
+  cxx_test(gmock-more-actions_test gmock_main)
+  cxx_test(gmock-nice-strict_test gmock_main)
+  cxx_test(gmock-port_test gmock_main)
+  cxx_test(gmock-spec-builders_test gmock_main)
+  cxx_test(gmock_link_test gmock_main test/gmock_link2_test.cc)
+  cxx_test(gmock_test gmock_main)
+
+  if (DEFINED GTEST_HAS_PTHREAD)
+    cxx_test(gmock_stress_test gmock)
+  endif()
+
+  # gmock_all_test is commented to save time building and running tests.
+  # Uncomment if necessary.
+  # cxx_test(gmock_all_test gmock_main)
+
+  ############################################################
+  # C++ tests built with non-standard compiler flags.
+
+  if (MSVC)
+    cxx_library(gmock_main_no_exception "${cxx_no_exception}"
+      "${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc)
+
+    cxx_library(gmock_main_no_rtti "${cxx_no_rtti}"
+      "${gtest_dir}/src/gtest-all.cc" src/gmock-all.cc src/gmock_main.cc)
+
+  else()
+    cxx_library(gmock_main_no_exception "${cxx_no_exception}" src/gmock_main.cc)
+    target_link_libraries(gmock_main_no_exception PUBLIC gmock)
+
+    cxx_library(gmock_main_no_rtti "${cxx_no_rtti}" src/gmock_main.cc)
+    target_link_libraries(gmock_main_no_rtti PUBLIC gmock)
+  endif()
+  cxx_test_with_flags(gmock-more-actions_no_exception_test "${cxx_no_exception}"
+    gmock_main_no_exception test/gmock-more-actions_test.cc)
+
+  cxx_test_with_flags(gmock_no_rtti_test "${cxx_no_rtti}"
+    gmock_main_no_rtti test/gmock-spec-builders_test.cc)
+
+  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
+  # 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
+  # -DBUILD_SHARED_LIBS=ON.
+  cxx_executable_with_flags(shared_gmock_test_ "${cxx_default}"
+    shared_gmock_main test/gmock-spec-builders_test.cc)
+  set_target_properties(shared_gmock_test_
+    PROPERTIES
+    COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
+
+  ############################################################
+  # Python tests.
+
+  cxx_executable(gmock_leak_test_ test gmock_main)
+  py_test(gmock_leak_test)
+
+  cxx_executable(gmock_output_test_ test gmock)
+  py_test(gmock_output_test)
+endif()
diff --git a/trunk/3rdparty/gtest-fit/googlemock/README.md b/trunk/3rdparty/gtest-fit/googlemock/README.md
new file mode 100644
index 000000000..ead688325
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/README.md
@@ -0,0 +1,44 @@
+# Googletest Mocking (gMock) Framework
+
+### Overview
+
+Google's framework for writing and using C++ mock classes. It can help you
+derive better designs of your system and write better tests.
+
+It is inspired by:
+
+*   [jMock](http://www.jmock.org/)
+*   [EasyMock](http://www.easymock.org/)
+*   [Hamcrest](http://code.google.com/p/hamcrest/)
+
+It is designed with C++'s specifics in mind.
+
+gMock:
+
+-   Provides a declarative syntax for defining mocks.
+-   Can define partial (hybrid) mocks, which are a cross of real and mock
+    objects.
+-   Handles functions of arbitrary types and overloaded functions.
+-   Comes with a rich set of matchers for validating function arguments.
+-   Uses an intuitive syntax for controlling the behavior of a mock.
+-   Does automatic verification of expectations (no record-and-replay needed).
+-   Allows arbitrary (partial) ordering constraints on function calls to be
+    expressed.
+-   Lets a user extend it by defining new matchers and actions.
+-   Does not use exceptions.
+-   Is easy to learn and use.
+
+Details and examples can be found here:
+
+*   [gMock for Dummies](https://google.github.io/googletest/gmock_for_dummies.html)
+*   [Legacy gMock FAQ](https://google.github.io/googletest/gmock_faq.html)
+*   [gMock Cookbook](https://google.github.io/googletest/gmock_cook_book.html)
+*   [gMock Cheat Sheet](https://google.github.io/googletest/gmock_cheat_sheet.html)
+
+Please note that code under scripts/generator/ is from the
+[cppclean project](http://code.google.com/p/cppclean/) and under the Apache
+License, which is different from GoogleMock's license.
+
+GoogleMock is a part of
+[GoogleTest C++ testing framework](http://github.com/google/googletest/) and a
+subject to the same requirements.
diff --git a/trunk/3rdparty/gtest-fit/googlemock/cmake/gmock.pc.in b/trunk/3rdparty/gtest-fit/googlemock/cmake/gmock.pc.in
new file mode 100644
index 000000000..23c67b5c8
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/cmake/gmock.pc.in
@@ -0,0 +1,10 @@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+
+Name: gmock
+Description: GoogleMock (without main() function)
+Version: @PROJECT_VERSION@
+URL: https://github.com/google/googletest
+Requires: gtest = @PROJECT_VERSION@
+Libs: -L${libdir} -lgmock @CMAKE_THREAD_LIBS_INIT@
+Cflags: -I${includedir} @GTEST_HAS_PTHREAD_MACRO@
diff --git a/trunk/3rdparty/gtest-fit/googlemock/cmake/gmock_main.pc.in b/trunk/3rdparty/gtest-fit/googlemock/cmake/gmock_main.pc.in
new file mode 100644
index 000000000..66ffea7f4
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/cmake/gmock_main.pc.in
@@ -0,0 +1,10 @@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+
+Name: gmock_main
+Description: GoogleMock (with main() function)
+Version: @PROJECT_VERSION@
+URL: https://github.com/google/googletest
+Requires: gmock = @PROJECT_VERSION@
+Libs: -L${libdir} -lgmock_main @CMAKE_THREAD_LIBS_INIT@
+Cflags: -I${includedir} @GTEST_HAS_PTHREAD_MACRO@
diff --git a/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-actions.h b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-actions.h
new file mode 100644
index 000000000..f2393bd3a
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-actions.h
@@ -0,0 +1,1687 @@
+// Copyright 2007, 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.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// The ACTION* family of macros can be used in a namespace scope to
+// define custom actions easily.  The syntax:
+//
+//   ACTION(name) { statements; }
+//
+// will define an action with the given name that executes the
+// statements.  The value returned by the statements will be used as
+// the return value of the action.  Inside the statements, you can
+// refer to the K-th (0-based) argument of the mock function by
+// 'argK', and refer to its type by 'argK_type'.  For example:
+//
+//   ACTION(IncrementArg1) {
+//     arg1_type temp = arg1;
+//     return ++(*temp);
+//   }
+//
+// allows you to write
+//
+//   ...WillOnce(IncrementArg1());
+//
+// You can also refer to the entire argument tuple and its type by
+// 'args' and 'args_type', and refer to the mock function type and its
+// return type by 'function_type' and 'return_type'.
+//
+// Note that you don't need to specify the types of the mock function
+// arguments.  However rest assured that your code is still type-safe:
+// you'll get a compiler error if *arg1 doesn't support the ++
+// operator, or if the type of ++(*arg1) isn't compatible with the
+// mock function's return type, for example.
+//
+// Sometimes you'll want to parameterize the action.   For that you can use
+// another macro:
+//
+//   ACTION_P(name, param_name) { statements; }
+//
+// For example:
+//
+//   ACTION_P(Add, n) { return arg0 + n; }
+//
+// will allow you to write:
+//
+//   ...WillOnce(Add(5));
+//
+// Note that you don't need to provide the type of the parameter
+// either.  If you need to reference the type of a parameter named
+// 'foo', you can write 'foo_type'.  For example, in the body of
+// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type
+// of 'n'.
+//
+// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support
+// multi-parameter actions.
+//
+// For the purpose of typing, you can view
+//
+//   ACTION_Pk(Foo, p1, ..., pk) { ... }
+//
+// as shorthand for
+//
+//   template <typename p1_type, ..., typename pk_type>
+//   FooActionPk<p1_type, ..., pk_type> Foo(p1_type p1, ..., pk_type pk) { ... }
+//
+// In particular, you can provide the template type arguments
+// explicitly when invoking Foo(), as in Foo<long, bool>(5, false);
+// although usually you can rely on the compiler to infer the types
+// for you automatically.  You can assign the result of expression
+// Foo(p1, ..., pk) to a variable of type FooActionPk<p1_type, ...,
+// pk_type>.  This can be useful when composing actions.
+//
+// You can also overload actions with different numbers of parameters:
+//
+//   ACTION_P(Plus, a) { ... }
+//   ACTION_P2(Plus, a, b) { ... }
+//
+// While it's tempting to always use the ACTION* macros when defining
+// a new action, you should also consider implementing ActionInterface
+// or using MakePolymorphicAction() instead, especially if you need to
+// use the action a lot.  While these approaches require more work,
+// they give you more control on the types of the mock function
+// arguments and the action parameters, which in general leads to
+// better compiler error messages that pay off in the long run.  They
+// also allow overloading actions based on parameter types (as opposed
+// to just based on the number of parameters).
+//
+// CAVEAT:
+//
+// ACTION*() can only be used in a namespace scope as templates cannot be
+// declared inside of a local class.
+// Users can, however, define any local functors (e.g. a lambda) that
+// can be used as actions.
+//
+// MORE INFORMATION:
+//
+// To learn more about using these macros, please search for 'ACTION' on
+// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
+
+#ifndef _WIN32_WCE
+# include <errno.h>
+#endif
+
+#include <algorithm>
+#include <functional>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "gmock/internal/gmock-internal-utils.h"
+#include "gmock/internal/gmock-port.h"
+#include "gmock/internal/gmock-pp.h"
+
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#endif
+
+namespace testing {
+
+// To implement an action Foo, define:
+//   1. a class FooAction that implements the ActionInterface interface, and
+//   2. a factory function that creates an Action object from a
+//      const FooAction*.
+//
+// The two-level delegation design follows that of Matcher, providing
+// consistency for extension developers.  It also eases ownership
+// management as Action objects can now be copied like plain values.
+
+namespace internal {
+
+// BuiltInDefaultValueGetter<T, true>::Get() returns a
+// default-constructed T value.  BuiltInDefaultValueGetter<T,
+// false>::Get() crashes with an error.
+//
+// This primary template is used when kDefaultConstructible is true.
+template <typename T, bool kDefaultConstructible>
+struct BuiltInDefaultValueGetter {
+  static T Get() { return T(); }
+};
+template <typename T>
+struct BuiltInDefaultValueGetter<T, false> {
+  static T Get() {
+    Assert(false, __FILE__, __LINE__,
+           "Default action undefined for the function return type.");
+    return internal::Invalid<T>();
+    // The above statement will never be reached, but is required in
+    // order for this function to compile.
+  }
+};
+
+// BuiltInDefaultValue<T>::Get() returns the "built-in" default value
+// for type T, which is NULL when T is a raw pointer type, 0 when T is
+// a numeric type, false when T is bool, or "" when T is string or
+// std::string.  In addition, in C++11 and above, it turns a
+// default-constructed T value if T is default constructible.  For any
+// other type T, the built-in default T value is undefined, and the
+// function will abort the process.
+template <typename T>
+class BuiltInDefaultValue {
+ public:
+  // This function returns true if and only if type T has a built-in default
+  // value.
+  static bool Exists() {
+    return ::std::is_default_constructible<T>::value;
+  }
+
+  static T Get() {
+    return BuiltInDefaultValueGetter<
+        T, ::std::is_default_constructible<T>::value>::Get();
+  }
+};
+
+// This partial specialization says that we use the same built-in
+// default value for T and const T.
+template <typename T>
+class BuiltInDefaultValue<const T> {
+ public:
+  static bool Exists() { return BuiltInDefaultValue<T>::Exists(); }
+  static T Get() { return BuiltInDefaultValue<T>::Get(); }
+};
+
+// This partial specialization defines the default values for pointer
+// types.
+template <typename T>
+class BuiltInDefaultValue<T*> {
+ public:
+  static bool Exists() { return true; }
+  static T* Get() { return nullptr; }
+};
+
+// The following specializations define the default values for
+// specific types we care about.
+#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \
+  template <> \
+  class BuiltInDefaultValue<type> { \
+   public: \
+    static bool Exists() { return true; } \
+    static type Get() { return value; } \
+  }
+
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void, );  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string, "");
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(bool, false);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned char, '\0');
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed char, '\0');
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(char, '\0');
+
+// There's no need for a default action for signed wchar_t, as that
+// type is the same as wchar_t for gcc, and invalid for MSVC.
+//
+// There's also no need for a default action for unsigned wchar_t, as
+// that type is the same as unsigned int for gcc, and invalid for
+// MSVC.
+#if GMOCK_WCHAR_T_IS_NATIVE_
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(wchar_t, 0U);  // NOLINT
+#endif
+
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned short, 0U);  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed short, 0);     // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned int, 0U);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed int, 0);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long, 0UL);  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long, 0L);     // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long long, 0);  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long long, 0);  // NOLINT
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(float, 0);
+GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0);
+
+#undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_
+
+// Simple two-arg form of std::disjunction.
+template <typename P, typename Q>
+using disjunction = typename ::std::conditional<P::value, P, Q>::type;
+
+}  // namespace internal
+
+// When an unexpected function call is encountered, Google Mock will
+// let it return a default value if the user has specified one for its
+// return type, or if the return type has a built-in default value;
+// otherwise Google Mock won't know what value to return and will have
+// to abort the process.
+//
+// The DefaultValue<T> class allows a user to specify the
+// default value for a type T that is both copyable and publicly
+// destructible (i.e. anything that can be used as a function return
+// type).  The usage is:
+//
+//   // Sets the default value for type T to be foo.
+//   DefaultValue<T>::Set(foo);
+template <typename T>
+class DefaultValue {
+ public:
+  // Sets the default value for type T; requires T to be
+  // copy-constructable and have a public destructor.
+  static void Set(T x) {
+    delete producer_;
+    producer_ = new FixedValueProducer(x);
+  }
+
+  // Provides a factory function to be called to generate the default value.
+  // This method can be used even if T is only move-constructible, but it is not
+  // limited to that case.
+  typedef T (*FactoryFunction)();
+  static void SetFactory(FactoryFunction factory) {
+    delete producer_;
+    producer_ = new FactoryValueProducer(factory);
+  }
+
+  // Unsets the default value for type T.
+  static void Clear() {
+    delete producer_;
+    producer_ = nullptr;
+  }
+
+  // Returns true if and only if the user has set the default value for type T.
+  static bool IsSet() { return producer_ != nullptr; }
+
+  // Returns true if T has a default return value set by the user or there
+  // exists a built-in default value.
+  static bool Exists() {
+    return IsSet() || internal::BuiltInDefaultValue<T>::Exists();
+  }
+
+  // Returns the default value for type T if the user has set one;
+  // otherwise returns the built-in default value. Requires that Exists()
+  // is true, which ensures that the return value is well-defined.
+  static T Get() {
+    return producer_ == nullptr ? internal::BuiltInDefaultValue<T>::Get()
+                                : producer_->Produce();
+  }
+
+ private:
+  class ValueProducer {
+   public:
+    virtual ~ValueProducer() {}
+    virtual T Produce() = 0;
+  };
+
+  class FixedValueProducer : public ValueProducer {
+   public:
+    explicit FixedValueProducer(T value) : value_(value) {}
+    T Produce() override { return value_; }
+
+   private:
+    const T value_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(FixedValueProducer);
+  };
+
+  class FactoryValueProducer : public ValueProducer {
+   public:
+    explicit FactoryValueProducer(FactoryFunction factory)
+        : factory_(factory) {}
+    T Produce() override { return factory_(); }
+
+   private:
+    const FactoryFunction factory_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(FactoryValueProducer);
+  };
+
+  static ValueProducer* producer_;
+};
+
+// This partial specialization allows a user to set default values for
+// reference types.
+template <typename T>
+class DefaultValue<T&> {
+ public:
+  // Sets the default value for type T&.
+  static void Set(T& x) {  // NOLINT
+    address_ = &x;
+  }
+
+  // Unsets the default value for type T&.
+  static void Clear() { address_ = nullptr; }
+
+  // Returns true if and only if the user has set the default value for type T&.
+  static bool IsSet() { return address_ != nullptr; }
+
+  // Returns true if T has a default return value set by the user or there
+  // exists a built-in default value.
+  static bool Exists() {
+    return IsSet() || internal::BuiltInDefaultValue<T&>::Exists();
+  }
+
+  // Returns the default value for type T& if the user has set one;
+  // otherwise returns the built-in default value if there is one;
+  // otherwise aborts the process.
+  static T& Get() {
+    return address_ == nullptr ? internal::BuiltInDefaultValue<T&>::Get()
+                               : *address_;
+  }
+
+ private:
+  static T* address_;
+};
+
+// This specialization allows DefaultValue<void>::Get() to
+// compile.
+template <>
+class DefaultValue<void> {
+ public:
+  static bool Exists() { return true; }
+  static void Get() {}
+};
+
+// Points to the user-set default value for type T.
+template <typename T>
+typename DefaultValue<T>::ValueProducer* DefaultValue<T>::producer_ = nullptr;
+
+// Points to the user-set default value for type T&.
+template <typename T>
+T* DefaultValue<T&>::address_ = nullptr;
+
+// Implement this interface to define an action for function type F.
+template <typename F>
+class ActionInterface {
+ public:
+  typedef typename internal::Function<F>::Result Result;
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  ActionInterface() {}
+  virtual ~ActionInterface() {}
+
+  // Performs the action.  This method is not const, as in general an
+  // action can have side effects and be stateful.  For example, a
+  // get-the-next-element-from-the-collection action will need to
+  // remember the current element.
+  virtual Result Perform(const ArgumentTuple& args) = 0;
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionInterface);
+};
+
+// An Action<F> is a copyable and IMMUTABLE (except by assignment)
+// object that represents an action to be taken when a mock function
+// of type F is called.  The implementation of Action<T> is just a
+// std::shared_ptr to const ActionInterface<T>. Don't inherit from Action!
+// You can view an object implementing ActionInterface<F> as a
+// concrete action (including its current state), and an Action<F>
+// object as a handle to it.
+template <typename F>
+class Action {
+  // Adapter class to allow constructing Action from a legacy ActionInterface.
+  // New code should create Actions from functors instead.
+  struct ActionAdapter {
+    // Adapter must be copyable to satisfy std::function requirements.
+    ::std::shared_ptr<ActionInterface<F>> impl_;
+
+    template <typename... Args>
+    typename internal::Function<F>::Result operator()(Args&&... args) {
+      return impl_->Perform(
+          ::std::forward_as_tuple(::std::forward<Args>(args)...));
+    }
+  };
+
+  template <typename G>
+  using IsCompatibleFunctor = std::is_constructible<std::function<F>, G>;
+
+ public:
+  typedef typename internal::Function<F>::Result Result;
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+  // Constructs a null Action.  Needed for storing Action objects in
+  // STL containers.
+  Action() {}
+
+  // Construct an Action from a specified callable.
+  // This cannot take std::function directly, because then Action would not be
+  // directly constructible from lambda (it would require two conversions).
+  template <
+      typename G,
+      typename = typename std::enable_if<internal::disjunction<
+          IsCompatibleFunctor<G>, std::is_constructible<std::function<Result()>,
+                                                        G>>::value>::type>
+  Action(G&& fun) {  // NOLINT
+    Init(::std::forward<G>(fun), IsCompatibleFunctor<G>());
+  }
+
+  // Constructs an Action from its implementation.
+  explicit Action(ActionInterface<F>* impl)
+      : fun_(ActionAdapter{::std::shared_ptr<ActionInterface<F>>(impl)}) {}
+
+  // This constructor allows us to turn an Action<Func> object into an
+  // Action<F>, as long as F's arguments can be implicitly converted
+  // to Func's and Func's return type can be implicitly converted to F's.
+  template <typename Func>
+  explicit Action(const Action<Func>& action) : fun_(action.fun_) {}
+
+  // Returns true if and only if this is the DoDefault() action.
+  bool IsDoDefault() const { return fun_ == nullptr; }
+
+  // Performs the action.  Note that this method is const even though
+  // the corresponding method in ActionInterface is not.  The reason
+  // is that a const Action<F> means that it cannot be re-bound to
+  // another concrete action, not that the concrete action it binds to
+  // cannot change state.  (Think of the difference between a const
+  // pointer and a pointer to const.)
+  Result Perform(ArgumentTuple args) const {
+    if (IsDoDefault()) {
+      internal::IllegalDoDefault(__FILE__, __LINE__);
+    }
+    return internal::Apply(fun_, ::std::move(args));
+  }
+
+ private:
+  template <typename G>
+  friend class Action;
+
+  template <typename G>
+  void Init(G&& g, ::std::true_type) {
+    fun_ = ::std::forward<G>(g);
+  }
+
+  template <typename G>
+  void Init(G&& g, ::std::false_type) {
+    fun_ = IgnoreArgs<typename ::std::decay<G>::type>{::std::forward<G>(g)};
+  }
+
+  template <typename FunctionImpl>
+  struct IgnoreArgs {
+    template <typename... Args>
+    Result operator()(const Args&...) const {
+      return function_impl();
+    }
+
+    FunctionImpl function_impl;
+  };
+
+  // fun_ is an empty function if and only if this is the DoDefault() action.
+  ::std::function<F> fun_;
+};
+
+// The PolymorphicAction class template makes it easy to implement a
+// polymorphic action (i.e. an action that can be used in mock
+// functions of than one type, e.g. Return()).
+//
+// To define a polymorphic action, a user first provides a COPYABLE
+// implementation class that has a Perform() method template:
+//
+//   class FooAction {
+//    public:
+//     template <typename Result, typename ArgumentTuple>
+//     Result Perform(const ArgumentTuple& args) const {
+//       // Processes the arguments and returns a result, using
+//       // std::get<N>(args) to get the N-th (0-based) argument in the tuple.
+//     }
+//     ...
+//   };
+//
+// Then the user creates the polymorphic action using
+// MakePolymorphicAction(object) where object has type FooAction.  See
+// the definition of Return(void) and SetArgumentPointee<N>(value) for
+// complete examples.
+template <typename Impl>
+class PolymorphicAction {
+ public:
+  explicit PolymorphicAction(const Impl& impl) : impl_(impl) {}
+
+  template <typename F>
+  operator Action<F>() const {
+    return Action<F>(new MonomorphicImpl<F>(impl_));
+  }
+
+ private:
+  template <typename F>
+  class MonomorphicImpl : public ActionInterface<F> {
+   public:
+    typedef typename internal::Function<F>::Result Result;
+    typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
+
+    Result Perform(const ArgumentTuple& args) override {
+      return impl_.template Perform<Result>(args);
+    }
+
+   private:
+    Impl impl_;
+  };
+
+  Impl impl_;
+};
+
+// Creates an Action from its implementation and returns it.  The
+// created Action object owns the implementation.
+template <typename F>
+Action<F> MakeAction(ActionInterface<F>* impl) {
+  return Action<F>(impl);
+}
+
+// Creates a polymorphic action from its implementation.  This is
+// easier to use than the PolymorphicAction<Impl> constructor as it
+// doesn't require you to explicitly write the template argument, e.g.
+//
+//   MakePolymorphicAction(foo);
+// vs
+//   PolymorphicAction<TypeOfFoo>(foo);
+template <typename Impl>
+inline PolymorphicAction<Impl> MakePolymorphicAction(const Impl& impl) {
+  return PolymorphicAction<Impl>(impl);
+}
+
+namespace internal {
+
+// Helper struct to specialize ReturnAction to execute a move instead of a copy
+// on return. Useful for move-only types, but could be used on any type.
+template <typename T>
+struct ByMoveWrapper {
+  explicit ByMoveWrapper(T value) : payload(std::move(value)) {}
+  T payload;
+};
+
+// Implements the polymorphic Return(x) action, which can be used in
+// any function that returns the type of x, regardless of the argument
+// types.
+//
+// Note: The value passed into Return must be converted into
+// Function<F>::Result when this action is cast to Action<F> rather than
+// when that action is performed. This is important in scenarios like
+//
+// MOCK_METHOD1(Method, T(U));
+// ...
+// {
+//   Foo foo;
+//   X x(&foo);
+//   EXPECT_CALL(mock, Method(_)).WillOnce(Return(x));
+// }
+//
+// In the example above the variable x holds reference to foo which leaves
+// scope and gets destroyed.  If copying X just copies a reference to foo,
+// that copy will be left with a hanging reference.  If conversion to T
+// makes a copy of foo, the above code is safe. To support that scenario, we
+// need to make sure that the type conversion happens inside the EXPECT_CALL
+// statement, and conversion of the result of Return to Action<T(U)> is a
+// good place for that.
+//
+// The real life example of the above scenario happens when an invocation
+// of gtl::Container() is passed into Return.
+//
+template <typename R>
+class ReturnAction {
+ public:
+  // Constructs a ReturnAction object from the value to be returned.
+  // 'value' is passed by value instead of by const reference in order
+  // to allow Return("string literal") to compile.
+  explicit ReturnAction(R value) : value_(new R(std::move(value))) {}
+
+  // This template type conversion operator allows Return(x) to be
+  // used in ANY function that returns x's type.
+  template <typename F>
+  operator Action<F>() const {  // NOLINT
+    // Assert statement belongs here because this is the best place to verify
+    // conditions on F. It produces the clearest error messages
+    // in most compilers.
+    // Impl really belongs in this scope as a local class but can't
+    // because MSVC produces duplicate symbols in different translation units
+    // in this case. Until MS fixes that bug we put Impl into the class scope
+    // and put the typedef both here (for use in assert statement) and
+    // in the Impl class. But both definitions must be the same.
+    typedef typename Function<F>::Result Result;
+    GTEST_COMPILE_ASSERT_(
+        !std::is_reference<Result>::value,
+        use_ReturnRef_instead_of_Return_to_return_a_reference);
+    static_assert(!std::is_void<Result>::value,
+                  "Can't use Return() on an action expected to return `void`.");
+    return Action<F>(new Impl<R, F>(value_));
+  }
+
+ private:
+  // Implements the Return(x) action for a particular function type F.
+  template <typename R_, typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    // The implicit cast is necessary when Result has more than one
+    // single-argument constructor (e.g. Result is std::vector<int>) and R
+    // has a type conversion operator template.  In that case, value_(value)
+    // won't compile as the compiler doesn't known which constructor of
+    // Result to call.  ImplicitCast_ forces the compiler to convert R to
+    // Result without considering explicit constructors, thus resolving the
+    // ambiguity. value_ is then initialized using its copy constructor.
+    explicit Impl(const std::shared_ptr<R>& value)
+        : value_before_cast_(*value),
+          value_(ImplicitCast_<Result>(value_before_cast_)) {}
+
+    Result Perform(const ArgumentTuple&) override { return value_; }
+
+   private:
+    GTEST_COMPILE_ASSERT_(!std::is_reference<Result>::value,
+                          Result_cannot_be_a_reference_type);
+    // We save the value before casting just in case it is being cast to a
+    // wrapper type.
+    R value_before_cast_;
+    Result value_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
+  };
+
+  // Partially specialize for ByMoveWrapper. This version of ReturnAction will
+  // move its contents instead.
+  template <typename R_, typename F>
+  class Impl<ByMoveWrapper<R_>, F> : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(const std::shared_ptr<R>& wrapper)
+        : performed_(false), wrapper_(wrapper) {}
+
+    Result Perform(const ArgumentTuple&) override {
+      GTEST_CHECK_(!performed_)
+          << "A ByMove() action should only be performed once.";
+      performed_ = true;
+      return std::move(wrapper_->payload);
+    }
+
+   private:
+    bool performed_;
+    const std::shared_ptr<R> wrapper_;
+  };
+
+  const std::shared_ptr<R> value_;
+};
+
+// Implements the ReturnNull() action.
+class ReturnNullAction {
+ public:
+  // Allows ReturnNull() to be used in any pointer-returning function. In C++11
+  // this is enforced by returning nullptr, and in non-C++11 by asserting a
+  // pointer type on compile time.
+  template <typename Result, typename ArgumentTuple>
+  static Result Perform(const ArgumentTuple&) {
+    return nullptr;
+  }
+};
+
+// Implements the Return() action.
+class ReturnVoidAction {
+ public:
+  // Allows Return() to be used in any void-returning function.
+  template <typename Result, typename ArgumentTuple>
+  static void Perform(const ArgumentTuple&) {
+    static_assert(std::is_void<Result>::value, "Result should be void.");
+  }
+};
+
+// Implements the polymorphic ReturnRef(x) action, which can be used
+// in any function that returns a reference to the type of x,
+// regardless of the argument types.
+template <typename T>
+class ReturnRefAction {
+ public:
+  // Constructs a ReturnRefAction object from the reference to be returned.
+  explicit ReturnRefAction(T& ref) : ref_(ref) {}  // NOLINT
+
+  // This template type conversion operator allows ReturnRef(x) to be
+  // used in ANY function that returns a reference to x's type.
+  template <typename F>
+  operator Action<F>() const {
+    typedef typename Function<F>::Result Result;
+    // Asserts that the function return type is a reference.  This
+    // catches the user error of using ReturnRef(x) when Return(x)
+    // should be used, and generates some helpful error message.
+    GTEST_COMPILE_ASSERT_(std::is_reference<Result>::value,
+                          use_Return_instead_of_ReturnRef_to_return_a_value);
+    return Action<F>(new Impl<F>(ref_));
+  }
+
+ private:
+  // Implements the ReturnRef(x) action for a particular function type F.
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(T& ref) : ref_(ref) {}  // NOLINT
+
+    Result Perform(const ArgumentTuple&) override { return ref_; }
+
+   private:
+    T& ref_;
+  };
+
+  T& ref_;
+};
+
+// Implements the polymorphic ReturnRefOfCopy(x) action, which can be
+// used in any function that returns a reference to the type of x,
+// regardless of the argument types.
+template <typename T>
+class ReturnRefOfCopyAction {
+ public:
+  // Constructs a ReturnRefOfCopyAction object from the reference to
+  // be returned.
+  explicit ReturnRefOfCopyAction(const T& value) : value_(value) {}  // NOLINT
+
+  // This template type conversion operator allows ReturnRefOfCopy(x) to be
+  // used in ANY function that returns a reference to x's type.
+  template <typename F>
+  operator Action<F>() const {
+    typedef typename Function<F>::Result Result;
+    // Asserts that the function return type is a reference.  This
+    // catches the user error of using ReturnRefOfCopy(x) when Return(x)
+    // should be used, and generates some helpful error message.
+    GTEST_COMPILE_ASSERT_(
+        std::is_reference<Result>::value,
+        use_Return_instead_of_ReturnRefOfCopy_to_return_a_value);
+    return Action<F>(new Impl<F>(value_));
+  }
+
+ private:
+  // Implements the ReturnRefOfCopy(x) action for a particular function type F.
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename Function<F>::Result Result;
+    typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(const T& value) : value_(value) {}  // NOLINT
+
+    Result Perform(const ArgumentTuple&) override { return value_; }
+
+   private:
+    T value_;
+  };
+
+  const T value_;
+};
+
+// Implements the polymorphic ReturnRoundRobin(v) action, which can be
+// used in any function that returns the element_type of v.
+template <typename T>
+class ReturnRoundRobinAction {
+ public:
+  explicit ReturnRoundRobinAction(std::vector<T> values) {
+    GTEST_CHECK_(!values.empty())
+        << "ReturnRoundRobin requires at least one element.";
+    state_->values = std::move(values);
+  }
+
+  template <typename... Args>
+  T operator()(Args&&...) const {
+     return state_->Next();
+  }
+
+ private:
+  struct State {
+    T Next() {
+      T ret_val = values[i++];
+      if (i == values.size()) i = 0;
+      return ret_val;
+    }
+
+    std::vector<T> values;
+    size_t i = 0;
+  };
+  std::shared_ptr<State> state_ = std::make_shared<State>();
+};
+
+// Implements the polymorphic DoDefault() action.
+class DoDefaultAction {
+ public:
+  // This template type conversion operator allows DoDefault() to be
+  // used in any function.
+  template <typename F>
+  operator Action<F>() const { return Action<F>(); }  // NOLINT
+};
+
+// Implements the Assign action to set a given pointer referent to a
+// particular value.
+template <typename T1, typename T2>
+class AssignAction {
+ public:
+  AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {}
+
+  template <typename Result, typename ArgumentTuple>
+  void Perform(const ArgumentTuple& /* args */) const {
+    *ptr_ = value_;
+  }
+
+ private:
+  T1* const ptr_;
+  const T2 value_;
+};
+
+#if !GTEST_OS_WINDOWS_MOBILE
+
+// Implements the SetErrnoAndReturn action to simulate return from
+// various system calls and libc functions.
+template <typename T>
+class SetErrnoAndReturnAction {
+ public:
+  SetErrnoAndReturnAction(int errno_value, T result)
+      : errno_(errno_value),
+        result_(result) {}
+  template <typename Result, typename ArgumentTuple>
+  Result Perform(const ArgumentTuple& /* args */) const {
+    errno = errno_;
+    return result_;
+  }
+
+ private:
+  const int errno_;
+  const T result_;
+};
+
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+// Implements the SetArgumentPointee<N>(x) action for any function
+// whose N-th argument (0-based) is a pointer to x's type.
+template <size_t N, typename A, typename = void>
+struct SetArgumentPointeeAction {
+  A value;
+
+  template <typename... Args>
+  void operator()(const Args&... args) const {
+    *::std::get<N>(std::tie(args...)) = value;
+  }
+};
+
+// Implements the Invoke(object_ptr, &Class::Method) action.
+template <class Class, typename MethodPtr>
+struct InvokeMethodAction {
+  Class* const obj_ptr;
+  const MethodPtr method_ptr;
+
+  template <typename... Args>
+  auto operator()(Args&&... args) const
+      -> decltype((obj_ptr->*method_ptr)(std::forward<Args>(args)...)) {
+    return (obj_ptr->*method_ptr)(std::forward<Args>(args)...);
+  }
+};
+
+// Implements the InvokeWithoutArgs(f) action.  The template argument
+// FunctionImpl is the implementation type of f, which can be either a
+// function pointer or a functor.  InvokeWithoutArgs(f) can be used as an
+// Action<F> as long as f's type is compatible with F.
+template <typename FunctionImpl>
+struct InvokeWithoutArgsAction {
+  FunctionImpl function_impl;
+
+  // Allows InvokeWithoutArgs(f) to be used as any action whose type is
+  // compatible with f.
+  template <typename... Args>
+  auto operator()(const Args&...) -> decltype(function_impl()) {
+    return function_impl();
+  }
+};
+
+// Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action.
+template <class Class, typename MethodPtr>
+struct InvokeMethodWithoutArgsAction {
+  Class* const obj_ptr;
+  const MethodPtr method_ptr;
+
+  using ReturnType =
+      decltype((std::declval<Class*>()->*std::declval<MethodPtr>())());
+
+  template <typename... Args>
+  ReturnType operator()(const Args&...) const {
+    return (obj_ptr->*method_ptr)();
+  }
+};
+
+// Implements the IgnoreResult(action) action.
+template <typename A>
+class IgnoreResultAction {
+ public:
+  explicit IgnoreResultAction(const A& action) : action_(action) {}
+
+  template <typename F>
+  operator Action<F>() const {
+    // Assert statement belongs here because this is the best place to verify
+    // conditions on F. It produces the clearest error messages
+    // in most compilers.
+    // Impl really belongs in this scope as a local class but can't
+    // because MSVC produces duplicate symbols in different translation units
+    // in this case. Until MS fixes that bug we put Impl into the class scope
+    // and put the typedef both here (for use in assert statement) and
+    // in the Impl class. But both definitions must be the same.
+    typedef typename internal::Function<F>::Result Result;
+
+    // Asserts at compile time that F returns void.
+    static_assert(std::is_void<Result>::value, "Result type should be void.");
+
+    return Action<F>(new Impl<F>(action_));
+  }
+
+ private:
+  template <typename F>
+  class Impl : public ActionInterface<F> {
+   public:
+    typedef typename internal::Function<F>::Result Result;
+    typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+
+    explicit Impl(const A& action) : action_(action) {}
+
+    void Perform(const ArgumentTuple& args) override {
+      // Performs the action and ignores its result.
+      action_.Perform(args);
+    }
+
+   private:
+    // Type OriginalFunction is the same as F except that its return
+    // type is IgnoredValue.
+    typedef typename internal::Function<F>::MakeResultIgnoredValue
+        OriginalFunction;
+
+    const Action<OriginalFunction> action_;
+  };
+
+  const A action_;
+};
+
+template <typename InnerAction, size_t... I>
+struct WithArgsAction {
+  InnerAction action;
+
+  // The inner action could be anything convertible to Action<X>.
+  // We use the conversion operator to detect the signature of the inner Action.
+  template <typename R, typename... Args>
+  operator Action<R(Args...)>() const {  // NOLINT
+    using TupleType = std::tuple<Args...>;
+    Action<R(typename std::tuple_element<I, TupleType>::type...)>
+        converted(action);
+
+    return [converted](Args... args) -> R {
+      return converted.Perform(std::forward_as_tuple(
+        std::get<I>(std::forward_as_tuple(std::forward<Args>(args)...))...));
+    };
+  }
+};
+
+template <typename... Actions>
+struct DoAllAction {
+ private:
+  template <typename T>
+  using NonFinalType =
+      typename std::conditional<std::is_scalar<T>::value, T, const T&>::type;
+
+  template <typename ActionT, size_t... I>
+  std::vector<ActionT> Convert(IndexSequence<I...>) const {
+    return {ActionT(std::get<I>(actions))...};
+  }
+
+ public:
+  std::tuple<Actions...> actions;
+
+  template <typename R, typename... Args>
+  operator Action<R(Args...)>() const {  // NOLINT
+    struct Op {
+      std::vector<Action<void(NonFinalType<Args>...)>> converted;
+      Action<R(Args...)> last;
+      R operator()(Args... args) const {
+        auto tuple_args = std::forward_as_tuple(std::forward<Args>(args)...);
+        for (auto& a : converted) {
+          a.Perform(tuple_args);
+        }
+        return last.Perform(std::move(tuple_args));
+      }
+    };
+    return Op{Convert<Action<void(NonFinalType<Args>...)>>(
+                  MakeIndexSequence<sizeof...(Actions) - 1>()),
+              std::get<sizeof...(Actions) - 1>(actions)};
+  }
+};
+
+template <typename T, typename... Params>
+struct ReturnNewAction {
+  T* operator()() const {
+    return internal::Apply(
+        [](const Params&... unpacked_params) {
+          return new T(unpacked_params...);
+        },
+        params);
+  }
+  std::tuple<Params...> params;
+};
+
+template <size_t k>
+struct ReturnArgAction {
+  template <typename... Args>
+  auto operator()(const Args&... args) const ->
+      typename std::tuple_element<k, std::tuple<Args...>>::type {
+    return std::get<k>(std::tie(args...));
+  }
+};
+
+template <size_t k, typename Ptr>
+struct SaveArgAction {
+  Ptr pointer;
+
+  template <typename... Args>
+  void operator()(const Args&... args) const {
+    *pointer = std::get<k>(std::tie(args...));
+  }
+};
+
+template <size_t k, typename Ptr>
+struct SaveArgPointeeAction {
+  Ptr pointer;
+
+  template <typename... Args>
+  void operator()(const Args&... args) const {
+    *pointer = *std::get<k>(std::tie(args...));
+  }
+};
+
+template <size_t k, typename T>
+struct SetArgRefereeAction {
+  T value;
+
+  template <typename... Args>
+  void operator()(Args&&... args) const {
+    using argk_type =
+        typename ::std::tuple_element<k, std::tuple<Args...>>::type;
+    static_assert(std::is_lvalue_reference<argk_type>::value,
+                  "Argument must be a reference type.");
+    std::get<k>(std::tie(args...)) = value;
+  }
+};
+
+template <size_t k, typename I1, typename I2>
+struct SetArrayArgumentAction {
+  I1 first;
+  I2 last;
+
+  template <typename... Args>
+  void operator()(const Args&... args) const {
+    auto value = std::get<k>(std::tie(args...));
+    for (auto it = first; it != last; ++it, (void)++value) {
+      *value = *it;
+    }
+  }
+};
+
+template <size_t k>
+struct DeleteArgAction {
+  template <typename... Args>
+  void operator()(const Args&... args) const {
+    delete std::get<k>(std::tie(args...));
+  }
+};
+
+template <typename Ptr>
+struct ReturnPointeeAction {
+  Ptr pointer;
+  template <typename... Args>
+  auto operator()(const Args&...) const -> decltype(*pointer) {
+    return *pointer;
+  }
+};
+
+#if GTEST_HAS_EXCEPTIONS
+template <typename T>
+struct ThrowAction {
+  T exception;
+  // We use a conversion operator to adapt to any return type.
+  template <typename R, typename... Args>
+  operator Action<R(Args...)>() const {  // NOLINT
+    T copy = exception;
+    return [copy](Args...) -> R { throw copy; };
+  }
+};
+#endif  // GTEST_HAS_EXCEPTIONS
+
+}  // namespace internal
+
+// An Unused object can be implicitly constructed from ANY value.
+// This is handy when defining actions that ignore some or all of the
+// mock function arguments.  For example, given
+//
+//   MOCK_METHOD3(Foo, double(const string& label, double x, double y));
+//   MOCK_METHOD3(Bar, double(int index, double x, double y));
+//
+// instead of
+//
+//   double DistanceToOriginWithLabel(const string& label, double x, double y) {
+//     return sqrt(x*x + y*y);
+//   }
+//   double DistanceToOriginWithIndex(int index, double x, double y) {
+//     return sqrt(x*x + y*y);
+//   }
+//   ...
+//   EXPECT_CALL(mock, Foo("abc", _, _))
+//       .WillOnce(Invoke(DistanceToOriginWithLabel));
+//   EXPECT_CALL(mock, Bar(5, _, _))
+//       .WillOnce(Invoke(DistanceToOriginWithIndex));
+//
+// you could write
+//
+//   // We can declare any uninteresting argument as Unused.
+//   double DistanceToOrigin(Unused, double x, double y) {
+//     return sqrt(x*x + y*y);
+//   }
+//   ...
+//   EXPECT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin));
+//   EXPECT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin));
+typedef internal::IgnoredValue Unused;
+
+// Creates an action that does actions a1, a2, ..., sequentially in
+// each invocation. All but the last action will have a readonly view of the
+// arguments.
+template <typename... Action>
+internal::DoAllAction<typename std::decay<Action>::type...> DoAll(
+    Action&&... action) {
+  return {std::forward_as_tuple(std::forward<Action>(action)...)};
+}
+
+// WithArg<k>(an_action) creates an action that passes the k-th
+// (0-based) argument of the mock function to an_action and performs
+// it.  It adapts an action accepting one argument to one that accepts
+// multiple arguments.  For convenience, we also provide
+// WithArgs<k>(an_action) (defined below) as a synonym.
+template <size_t k, typename InnerAction>
+internal::WithArgsAction<typename std::decay<InnerAction>::type, k>
+WithArg(InnerAction&& action) {
+  return {std::forward<InnerAction>(action)};
+}
+
+// WithArgs<N1, N2, ..., Nk>(an_action) creates an action that passes
+// the selected arguments of the mock function to an_action and
+// performs it.  It serves as an adaptor between actions with
+// different argument lists.
+template <size_t k, size_t... ks, typename InnerAction>
+internal::WithArgsAction<typename std::decay<InnerAction>::type, k, ks...>
+WithArgs(InnerAction&& action) {
+  return {std::forward<InnerAction>(action)};
+}
+
+// WithoutArgs(inner_action) can be used in a mock function with a
+// non-empty argument list to perform inner_action, which takes no
+// argument.  In other words, it adapts an action accepting no
+// argument to one that accepts (and ignores) arguments.
+template <typename InnerAction>
+internal::WithArgsAction<typename std::decay<InnerAction>::type>
+WithoutArgs(InnerAction&& action) {
+  return {std::forward<InnerAction>(action)};
+}
+
+// Creates an action that returns 'value'.  'value' is passed by value
+// instead of const reference - otherwise Return("string literal")
+// will trigger a compiler error about using array as initializer.
+template <typename R>
+internal::ReturnAction<R> Return(R value) {
+  return internal::ReturnAction<R>(std::move(value));
+}
+
+// Creates an action that returns NULL.
+inline PolymorphicAction<internal::ReturnNullAction> ReturnNull() {
+  return MakePolymorphicAction(internal::ReturnNullAction());
+}
+
+// Creates an action that returns from a void function.
+inline PolymorphicAction<internal::ReturnVoidAction> Return() {
+  return MakePolymorphicAction(internal::ReturnVoidAction());
+}
+
+// Creates an action that returns the reference to a variable.
+template <typename R>
+inline internal::ReturnRefAction<R> ReturnRef(R& x) {  // NOLINT
+  return internal::ReturnRefAction<R>(x);
+}
+
+// Prevent using ReturnRef on reference to temporary.
+template <typename R, R* = nullptr>
+internal::ReturnRefAction<R> ReturnRef(R&&) = delete;
+
+// Creates an action that returns the reference to a copy of the
+// argument.  The copy is created when the action is constructed and
+// lives as long as the action.
+template <typename R>
+inline internal::ReturnRefOfCopyAction<R> ReturnRefOfCopy(const R& x) {
+  return internal::ReturnRefOfCopyAction<R>(x);
+}
+
+// Modifies the parent action (a Return() action) to perform a move of the
+// argument instead of a copy.
+// Return(ByMove()) actions can only be executed once and will assert this
+// invariant.
+template <typename R>
+internal::ByMoveWrapper<R> ByMove(R x) {
+  return internal::ByMoveWrapper<R>(std::move(x));
+}
+
+// Creates an action that returns an element of `vals`. Calling this action will
+// repeatedly return the next value from `vals` until it reaches the end and
+// will restart from the beginning.
+template <typename T>
+internal::ReturnRoundRobinAction<T> ReturnRoundRobin(std::vector<T> vals) {
+  return internal::ReturnRoundRobinAction<T>(std::move(vals));
+}
+
+// Creates an action that returns an element of `vals`. Calling this action will
+// repeatedly return the next value from `vals` until it reaches the end and
+// will restart from the beginning.
+template <typename T>
+internal::ReturnRoundRobinAction<T> ReturnRoundRobin(
+    std::initializer_list<T> vals) {
+  return internal::ReturnRoundRobinAction<T>(std::vector<T>(vals));
+}
+
+// Creates an action that does the default action for the give mock function.
+inline internal::DoDefaultAction DoDefault() {
+  return internal::DoDefaultAction();
+}
+
+// Creates an action that sets the variable pointed by the N-th
+// (0-based) function argument to 'value'.
+template <size_t N, typename T>
+internal::SetArgumentPointeeAction<N, T> SetArgPointee(T value) {
+  return {std::move(value)};
+}
+
+// The following version is DEPRECATED.
+template <size_t N, typename T>
+internal::SetArgumentPointeeAction<N, T> SetArgumentPointee(T value) {
+  return {std::move(value)};
+}
+
+// Creates an action that sets a pointer referent to a given value.
+template <typename T1, typename T2>
+PolymorphicAction<internal::AssignAction<T1, T2> > Assign(T1* ptr, T2 val) {
+  return MakePolymorphicAction(internal::AssignAction<T1, T2>(ptr, val));
+}
+
+#if !GTEST_OS_WINDOWS_MOBILE
+
+// Creates an action that sets errno and returns the appropriate error.
+template <typename T>
+PolymorphicAction<internal::SetErrnoAndReturnAction<T> >
+SetErrnoAndReturn(int errval, T result) {
+  return MakePolymorphicAction(
+      internal::SetErrnoAndReturnAction<T>(errval, result));
+}
+
+#endif  // !GTEST_OS_WINDOWS_MOBILE
+
+// Various overloads for Invoke().
+
+// Legacy function.
+// Actions can now be implicitly constructed from callables. No need to create
+// wrapper objects.
+// This function exists for backwards compatibility.
+template <typename FunctionImpl>
+typename std::decay<FunctionImpl>::type Invoke(FunctionImpl&& function_impl) {
+  return std::forward<FunctionImpl>(function_impl);
+}
+
+// Creates an action that invokes the given method on the given object
+// with the mock function's arguments.
+template <class Class, typename MethodPtr>
+internal::InvokeMethodAction<Class, MethodPtr> Invoke(Class* obj_ptr,
+                                                      MethodPtr method_ptr) {
+  return {obj_ptr, method_ptr};
+}
+
+// Creates an action that invokes 'function_impl' with no argument.
+template <typename FunctionImpl>
+internal::InvokeWithoutArgsAction<typename std::decay<FunctionImpl>::type>
+InvokeWithoutArgs(FunctionImpl function_impl) {
+  return {std::move(function_impl)};
+}
+
+// Creates an action that invokes the given method on the given object
+// with no argument.
+template <class Class, typename MethodPtr>
+internal::InvokeMethodWithoutArgsAction<Class, MethodPtr> InvokeWithoutArgs(
+    Class* obj_ptr, MethodPtr method_ptr) {
+  return {obj_ptr, method_ptr};
+}
+
+// Creates an action that performs an_action and throws away its
+// result.  In other words, it changes the return type of an_action to
+// void.  an_action MUST NOT return void, or the code won't compile.
+template <typename A>
+inline internal::IgnoreResultAction<A> IgnoreResult(const A& an_action) {
+  return internal::IgnoreResultAction<A>(an_action);
+}
+
+// Creates a reference wrapper for the given L-value.  If necessary,
+// you can explicitly specify the type of the reference.  For example,
+// suppose 'derived' is an object of type Derived, ByRef(derived)
+// would wrap a Derived&.  If you want to wrap a const Base& instead,
+// where Base is a base class of Derived, just write:
+//
+//   ByRef<const Base>(derived)
+//
+// N.B. ByRef is redundant with std::ref, std::cref and std::reference_wrapper.
+// However, it may still be used for consistency with ByMove().
+template <typename T>
+inline ::std::reference_wrapper<T> ByRef(T& l_value) {  // NOLINT
+  return ::std::reference_wrapper<T>(l_value);
+}
+
+// The ReturnNew<T>(a1, a2, ..., a_k) action returns a pointer to a new
+// instance of type T, constructed on the heap with constructor arguments
+// a1, a2, ..., and a_k. The caller assumes ownership of the returned value.
+template <typename T, typename... Params>
+internal::ReturnNewAction<T, typename std::decay<Params>::type...> ReturnNew(
+    Params&&... params) {
+  return {std::forward_as_tuple(std::forward<Params>(params)...)};
+}
+
+// Action ReturnArg<k>() returns the k-th argument of the mock function.
+template <size_t k>
+internal::ReturnArgAction<k> ReturnArg() {
+  return {};
+}
+
+// Action SaveArg<k>(pointer) saves the k-th (0-based) argument of the
+// mock function to *pointer.
+template <size_t k, typename Ptr>
+internal::SaveArgAction<k, Ptr> SaveArg(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>
+internal::SaveArgPointeeAction<k, Ptr> SaveArgPointee(Ptr pointer) {
+  return {pointer};
+}
+
+// Action SetArgReferee<k>(value) assigns 'value' to the variable
+// referenced by the k-th (0-based) argument of the mock function.
+template <size_t k, typename T>
+internal::SetArgRefereeAction<k, typename std::decay<T>::type> SetArgReferee(
+    T&& value) {
+  return {std::forward<T>(value)};
+}
+
+// Action SetArrayArgument<k>(first, last) copies the elements in
+// source range [first, last) to the array pointed to by the k-th
+// (0-based) argument, which can be either a pointer or an
+// iterator. The action does not take ownership of the elements in the
+// source range.
+template <size_t k, typename I1, typename I2>
+internal::SetArrayArgumentAction<k, I1, I2> SetArrayArgument(I1 first,
+                                                             I2 last) {
+  return {first, last};
+}
+
+// Action DeleteArg<k>() deletes the k-th (0-based) argument of the mock
+// function.
+template <size_t k>
+internal::DeleteArgAction<k> DeleteArg() {
+  return {};
+}
+
+// This action returns the value pointed to by 'pointer'.
+template <typename Ptr>
+internal::ReturnPointeeAction<Ptr> ReturnPointee(Ptr pointer) {
+  return {pointer};
+}
+
+// Action Throw(exception) can be used in a mock function of any type
+// to throw the given exception.  Any copyable value can be thrown.
+#if GTEST_HAS_EXCEPTIONS
+template <typename T>
+internal::ThrowAction<typename std::decay<T>::type> Throw(T&& exception) {
+  return {std::forward<T>(exception)};
+}
+#endif  // GTEST_HAS_EXCEPTIONS
+
+namespace internal {
+
+// A macro from the ACTION* family (defined later in gmock-generated-actions.h)
+// defines an action that can be used in a mock function.  Typically,
+// these actions only care about a subset of the arguments of the mock
+// function.  For example, if such an action only uses the second
+// argument, it can be used in any mock function that takes >= 2
+// arguments where the type of the second argument is compatible.
+//
+// Therefore, the action implementation must be prepared to take more
+// arguments than it needs.  The ExcessiveArg type is used to
+// represent those excessive arguments.  In order to keep the compiler
+// error messages tractable, we define it in the testing namespace
+// instead of testing::internal.  However, this is an INTERNAL TYPE
+// and subject to change without notice, so a user MUST NOT USE THIS
+// TYPE DIRECTLY.
+struct ExcessiveArg {};
+
+// Builds an implementation of an Action<> for some particular signature, using
+// a class defined by an ACTION* macro.
+template <typename F, typename Impl> struct ActionImpl;
+
+template <typename Impl>
+struct ImplBase {
+  struct Holder {
+    // Allows each copy of the Action<> to get to the Impl.
+    explicit operator const Impl&() const { return *ptr; }
+    std::shared_ptr<Impl> ptr;
+  };
+  using type = typename std::conditional<std::is_constructible<Impl>::value,
+                                         Impl, Holder>::type;
+};
+
+template <typename R, typename... Args, typename Impl>
+struct ActionImpl<R(Args...), Impl> : ImplBase<Impl>::type {
+  using Base = typename ImplBase<Impl>::type;
+  using function_type = R(Args...);
+  using args_type = std::tuple<Args...>;
+
+  ActionImpl() = default;  // Only defined if appropriate for Base.
+  explicit ActionImpl(std::shared_ptr<Impl> impl) : Base{std::move(impl)} { }
+
+  R operator()(Args&&... arg) const {
+    static constexpr size_t kMaxArgs =
+        sizeof...(Args) <= 10 ? sizeof...(Args) : 10;
+    return Apply(MakeIndexSequence<kMaxArgs>{},
+                 MakeIndexSequence<10 - kMaxArgs>{},
+                 args_type{std::forward<Args>(arg)...});
+  }
+
+  template <std::size_t... arg_id, std::size_t... excess_id>
+  R Apply(IndexSequence<arg_id...>, IndexSequence<excess_id...>,
+          const args_type& args) const {
+    // Impl need not be specific to the signature of action being implemented;
+    // only the implementing function body needs to have all of the specific
+    // types instantiated.  Up to 10 of the args that are provided by the
+    // args_type get passed, followed by a dummy of unspecified type for the
+    // remainder up to 10 explicit args.
+    static constexpr ExcessiveArg kExcessArg{};
+    return static_cast<const Impl&>(*this).template gmock_PerformImpl<
+        /*function_type=*/function_type, /*return_type=*/R,
+        /*args_type=*/args_type,
+        /*argN_type=*/typename std::tuple_element<arg_id, args_type>::type...>(
+        /*args=*/args, std::get<arg_id>(args)...,
+        ((void)excess_id, kExcessArg)...);
+  }
+};
+
+// Stores a default-constructed Impl as part of the Action<>'s
+// std::function<>. The Impl should be trivial to copy.
+template <typename F, typename Impl>
+::testing::Action<F> MakeAction() {
+  return ::testing::Action<F>(ActionImpl<F, Impl>());
+}
+
+// Stores just the one given instance of Impl.
+template <typename F, typename Impl>
+::testing::Action<F> MakeAction(std::shared_ptr<Impl> impl) {
+  return ::testing::Action<F>(ActionImpl<F, Impl>(std::move(impl)));
+}
+
+#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( \
+      GMOCK_INTERNAL_ARG_UNUSED, , 10)
+
+#define GMOCK_INTERNAL_ARG(i, data, el) , const arg##i##_type& arg##i
+#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_ \
+  const args_type& args GMOCK_PP_REPEAT(GMOCK_INTERNAL_ARG, , 10)
+
+#define GMOCK_INTERNAL_TEMPLATE_ARG(i, data, el) , typename arg##i##_type
+#define GMOCK_ACTION_TEMPLATE_ARGS_NAMES_ \
+  GMOCK_PP_TAIL(GMOCK_PP_REPEAT(GMOCK_INTERNAL_TEMPLATE_ARG, , 10))
+
+#define GMOCK_INTERNAL_TYPENAME_PARAM(i, data, param) , typename param##_type
+#define GMOCK_ACTION_TYPENAME_PARAMS_(params) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPENAME_PARAM, , params))
+
+#define GMOCK_INTERNAL_TYPE_PARAM(i, data, param) , param##_type
+#define GMOCK_ACTION_TYPE_PARAMS_(params) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_PARAM, , params))
+
+#define GMOCK_INTERNAL_TYPE_GVALUE_PARAM(i, data, param) \
+  , param##_type gmock_p##i
+#define GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_GVALUE_PARAM, , params))
+
+#define GMOCK_INTERNAL_GVALUE_PARAM(i, data, param) \
+  , std::forward<param##_type>(gmock_p##i)
+#define GMOCK_ACTION_GVALUE_PARAMS_(params) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GVALUE_PARAM, , params))
+
+#define GMOCK_INTERNAL_INIT_PARAM(i, data, param) \
+  , param(::std::forward<param##_type>(gmock_p##i))
+#define GMOCK_ACTION_INIT_PARAMS_(params) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_INIT_PARAM, , params))
+
+#define GMOCK_INTERNAL_FIELD_PARAM(i, data, param) param##_type param;
+#define GMOCK_ACTION_FIELD_PARAMS_(params) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_FIELD_PARAM, , params)
+
+#define GMOCK_INTERNAL_ACTION(name, full_name, params)                        \
+  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
+  class full_name {                                                           \
+   public:                                                                    \
+    explicit full_name(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params))              \
+        : impl_(std::make_shared<gmock_Impl>(                                 \
+                GMOCK_ACTION_GVALUE_PARAMS_(params))) { }                     \
+    full_name(const full_name&) = default;                                    \
+    full_name(full_name&&) noexcept = default;                                \
+    template <typename F>                                                     \
+    operator ::testing::Action<F>() const {                                   \
+      return ::testing::internal::MakeAction<F>(impl_);                       \
+    }                                                                         \
+   private:                                                                   \
+    class gmock_Impl {                                                        \
+     public:                                                                  \
+      explicit gmock_Impl(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params))           \
+          : GMOCK_ACTION_INIT_PARAMS_(params) {}                              \
+      template <typename function_type, typename return_type,                 \
+                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>        \
+      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
+      GMOCK_ACTION_FIELD_PARAMS_(params)                                      \
+    };                                                                        \
+    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)) {                             \
+    return full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>(                      \
+        GMOCK_ACTION_GVALUE_PARAMS_(params));                                 \
+  }                                                                           \
+  template <GMOCK_ACTION_TYPENAME_PARAMS_(params)>                            \
+  template <typename function_type, typename return_type, typename args_type, \
+            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                \
+  return_type full_name<GMOCK_ACTION_TYPE_PARAMS_(params)>::gmock_Impl::      \
+  gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+}  // namespace internal
+
+// Similar to GMOCK_INTERNAL_ACTION, but no bound parameters are stored.
+#define ACTION(name)                                                          \
+  class name##Action {                                                        \
+   public:                                                                    \
+   explicit name##Action() noexcept {}                                        \
+   name##Action(const name##Action&) noexcept {}                              \
+    template <typename F>                                                     \
+    operator ::testing::Action<F>() const {                                   \
+      return ::testing::internal::MakeAction<F, gmock_Impl>();                \
+    }                                                                         \
+   private:                                                                   \
+    class gmock_Impl {                                                        \
+     public:                                                                  \
+      template <typename function_type, typename return_type,                 \
+                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>        \
+      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \
+    };                                                                        \
+  };                                                                          \
+  inline name##Action name() GTEST_MUST_USE_RESULT_;                          \
+  inline name##Action name() { return name##Action(); }                       \
+  template <typename function_type, typename return_type, typename args_type, \
+            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                \
+  return_type name##Action::gmock_Impl::gmock_PerformImpl(                    \
+      GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+#define ACTION_P(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP, (__VA_ARGS__))
+
+#define ACTION_P2(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP2, (__VA_ARGS__))
+
+#define ACTION_P3(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP3, (__VA_ARGS__))
+
+#define ACTION_P4(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP4, (__VA_ARGS__))
+
+#define ACTION_P5(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP5, (__VA_ARGS__))
+
+#define ACTION_P6(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP6, (__VA_ARGS__))
+
+#define ACTION_P7(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP7, (__VA_ARGS__))
+
+#define ACTION_P8(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP8, (__VA_ARGS__))
+
+#define ACTION_P9(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP9, (__VA_ARGS__))
+
+#define ACTION_P10(name, ...) \
+  GMOCK_INTERNAL_ACTION(name, name##ActionP10, (__VA_ARGS__))
+
+}  // namespace testing
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_
diff --git a/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-cardinalities.h b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-cardinalities.h
new file mode 100644
index 000000000..fc7f803a7
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-cardinalities.h
@@ -0,0 +1,157 @@
+// Copyright 2007, 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.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some commonly used cardinalities.  More
+// cardinalities can be defined by the user implementing the
+// CardinalityInterface interface if necessary.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
+
+#include <limits.h>
+#include <memory>
+#include <ostream>  // NOLINT
+#include "gmock/internal/gmock-port.h"
+#include "gtest/gtest.h"
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// To implement a cardinality Foo, define:
+//   1. a class FooCardinality that implements the
+//      CardinalityInterface interface, and
+//   2. a factory function that creates a Cardinality object from a
+//      const FooCardinality*.
+//
+// The two-level delegation design follows that of Matcher, providing
+// consistency for extension developers.  It also eases ownership
+// management as Cardinality objects can now be copied like plain values.
+
+// The implementation of a cardinality.
+class CardinalityInterface {
+ public:
+  virtual ~CardinalityInterface() {}
+
+  // Conservative estimate on the lower/upper bound of the number of
+  // calls allowed.
+  virtual int ConservativeLowerBound() const { return 0; }
+  virtual int ConservativeUpperBound() const { return INT_MAX; }
+
+  // Returns true if and only if call_count calls will satisfy this
+  // cardinality.
+  virtual bool IsSatisfiedByCallCount(int call_count) const = 0;
+
+  // Returns true if and only if call_count calls will saturate this
+  // cardinality.
+  virtual bool IsSaturatedByCallCount(int call_count) const = 0;
+
+  // Describes self to an ostream.
+  virtual void DescribeTo(::std::ostream* os) const = 0;
+};
+
+// A Cardinality is a copyable and IMMUTABLE (except by assignment)
+// object that specifies how many times a mock function is expected to
+// be called.  The implementation of Cardinality is just a std::shared_ptr
+// to const CardinalityInterface. Don't inherit from Cardinality!
+class GTEST_API_ Cardinality {
+ public:
+  // Constructs a null cardinality.  Needed for storing Cardinality
+  // objects in STL containers.
+  Cardinality() {}
+
+  // Constructs a Cardinality from its implementation.
+  explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {}
+
+  // Conservative estimate on the lower/upper bound of the number of
+  // calls allowed.
+  int ConservativeLowerBound() const { return impl_->ConservativeLowerBound(); }
+  int ConservativeUpperBound() const { return impl_->ConservativeUpperBound(); }
+
+  // Returns true if and only if call_count calls will satisfy this
+  // cardinality.
+  bool IsSatisfiedByCallCount(int call_count) const {
+    return impl_->IsSatisfiedByCallCount(call_count);
+  }
+
+  // Returns true if and only if call_count calls will saturate this
+  // cardinality.
+  bool IsSaturatedByCallCount(int call_count) const {
+    return impl_->IsSaturatedByCallCount(call_count);
+  }
+
+  // Returns true if and only if call_count calls will over-saturate this
+  // cardinality, i.e. exceed the maximum number of allowed calls.
+  bool IsOverSaturatedByCallCount(int call_count) const {
+    return impl_->IsSaturatedByCallCount(call_count) &&
+        !impl_->IsSatisfiedByCallCount(call_count);
+  }
+
+  // Describes self to an ostream
+  void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); }
+
+  // Describes the given actual call count to an ostream.
+  static void DescribeActualCallCountTo(int actual_call_count,
+                                        ::std::ostream* os);
+
+ private:
+  std::shared_ptr<const CardinalityInterface> impl_;
+};
+
+// Creates a cardinality that allows at least n calls.
+GTEST_API_ Cardinality AtLeast(int n);
+
+// Creates a cardinality that allows at most n calls.
+GTEST_API_ Cardinality AtMost(int n);
+
+// Creates a cardinality that allows any number of calls.
+GTEST_API_ Cardinality AnyNumber();
+
+// Creates a cardinality that allows between min and max calls.
+GTEST_API_ Cardinality Between(int min, int max);
+
+// Creates a cardinality that allows exactly n calls.
+GTEST_API_ Cardinality Exactly(int n);
+
+// Creates a cardinality from its implementation.
+inline Cardinality MakeCardinality(const CardinalityInterface* c) {
+  return Cardinality(c);
+}
+
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_
diff --git a/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-function-mocker.h b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-function-mocker.h
new file mode 100644
index 000000000..0fc6f6f3f
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-function-mocker.h
@@ -0,0 +1,479 @@
+// Copyright 2007, 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.
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements MOCK_METHOD.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_  // NOLINT
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_  // NOLINT
+
+#include <type_traits>  // IWYU pragma: keep
+#include <utility>      // IWYU pragma: keep
+
+#include "gmock/gmock-spec-builders.h"
+#include "gmock/internal/gmock-internal-utils.h"
+#include "gmock/internal/gmock-pp.h"
+
+namespace testing {
+namespace internal {
+template <typename T>
+using identity_t = T;
+
+template <typename Pattern>
+struct ThisRefAdjuster {
+  template <typename T>
+  using AdjustT = typename std::conditional<
+      std::is_const<typename std::remove_reference<Pattern>::type>::value,
+      typename std::conditional<std::is_lvalue_reference<Pattern>::value,
+                                const T&, const T&&>::type,
+      typename std::conditional<std::is_lvalue_reference<Pattern>::value, T&,
+                                T&&>::type>::type;
+
+  template <typename MockType>
+  static AdjustT<MockType> Adjust(const MockType& mock) {
+    return static_cast<AdjustT<MockType>>(const_cast<MockType&>(mock));
+  }
+};
+
+}  // namespace internal
+
+// The style guide prohibits "using" statements in a namespace scope
+// inside a header file.  However, the FunctionMocker class template
+// is meant to be defined in the ::testing namespace.  The following
+// line is just a trick for working around a bug in MSVC 8.0, which
+// cannot handle it if we define FunctionMocker in ::testing.
+using internal::FunctionMocker;
+}  // namespace testing
+
+#define MOCK_METHOD(...) \
+  GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_MOCK_METHOD_ARG_, __VA_ARGS__)
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_1(...) \
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_2(...) \
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_3(_Ret, _MethodName, _Args) \
+  GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, ())
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, _Spec)     \
+  GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Args);                                   \
+  GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Spec);                                   \
+  GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(                                      \
+      GMOCK_PP_NARG0 _Args, GMOCK_INTERNAL_SIGNATURE(_Ret, _Args));           \
+  GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec)                                     \
+  GMOCK_INTERNAL_MOCK_METHOD_IMPL(                                            \
+      GMOCK_PP_NARG0 _Args, _MethodName, GMOCK_INTERNAL_HAS_CONST(_Spec),     \
+      GMOCK_INTERNAL_HAS_OVERRIDE(_Spec), GMOCK_INTERNAL_HAS_FINAL(_Spec),    \
+      GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Spec),                                \
+      GMOCK_INTERNAL_GET_CALLTYPE(_Spec), GMOCK_INTERNAL_GET_REF_SPEC(_Spec), \
+      (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)))
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_5(...) \
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_6(...) \
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
+
+#define GMOCK_INTERNAL_MOCK_METHOD_ARG_7(...) \
+  GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__)
+
+#define GMOCK_INTERNAL_WRONG_ARITY(...)                                      \
+  static_assert(                                                             \
+      false,                                                                 \
+      "MOCK_METHOD must be called with 3 or 4 arguments. _Ret, "             \
+      "_MethodName, _Args and optionally _Spec. _Args and _Spec must be "    \
+      "enclosed in parentheses. If _Ret is a type with unprotected commas, " \
+      "it must also be enclosed in parentheses.")
+
+#define GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Tuple) \
+  static_assert(                                  \
+      GMOCK_PP_IS_ENCLOSED_PARENS(_Tuple),        \
+      GMOCK_PP_STRINGIZE(_Tuple) " should be enclosed in parentheses.")
+
+#define GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(_N, ...)                 \
+  static_assert(                                                       \
+      std::is_function<__VA_ARGS__>::value,                            \
+      "Signature must be a function type, maybe return type contains " \
+      "unprotected comma.");                                           \
+  static_assert(                                                       \
+      ::testing::tuple_size<typename ::testing::internal::Function<    \
+              __VA_ARGS__>::ArgumentTuple>::value == _N,               \
+      "This method does not take " GMOCK_PP_STRINGIZE(                 \
+          _N) " arguments. Parenthesize all types with unprotected commas.")
+
+#define GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT, ~, _Spec)
+
+#define GMOCK_INTERNAL_MOCK_METHOD_IMPL(_N, _MethodName, _Constness,           \
+                                        _Override, _Final, _NoexceptSpec,      \
+                                        _CallType, _RefSpec, _Signature)       \
+  typename ::testing::internal::Function<GMOCK_PP_REMOVE_PARENS(               \
+      _Signature)>::Result                                                     \
+  GMOCK_INTERNAL_EXPAND(_CallType)                                             \
+      _MethodName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N))   \
+          GMOCK_PP_IF(_Constness, const, ) _RefSpec _NoexceptSpec              \
+          GMOCK_PP_IF(_Override, override, ) GMOCK_PP_IF(_Final, final, ) {    \
+    GMOCK_MOCKER_(_N, _Constness, _MethodName)                                 \
+        .SetOwnerAndName(this, #_MethodName);                                  \
+    return GMOCK_MOCKER_(_N, _Constness, _MethodName)                          \
+        .Invoke(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N));  \
+  }                                                                            \
+  ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \
+      GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N))       \
+      GMOCK_PP_IF(_Constness, const, ) _RefSpec {                              \
+    GMOCK_MOCKER_(_N, _Constness, _MethodName).RegisterOwner(this);            \
+    return GMOCK_MOCKER_(_N, _Constness, _MethodName)                          \
+        .With(GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_ARGUMENT, , _N));         \
+  }                                                                            \
+  ::testing::MockSpec<GMOCK_PP_REMOVE_PARENS(_Signature)> gmock_##_MethodName( \
+      const ::testing::internal::WithoutMatchers&,                             \
+      GMOCK_PP_IF(_Constness, const, )::testing::internal::Function<           \
+          GMOCK_PP_REMOVE_PARENS(_Signature)>*) const _RefSpec _NoexceptSpec { \
+    return ::testing::internal::ThisRefAdjuster<GMOCK_PP_IF(                   \
+        _Constness, const, ) int _RefSpec>::Adjust(*this)                      \
+        .gmock_##_MethodName(GMOCK_PP_REPEAT(                                  \
+            GMOCK_INTERNAL_A_MATCHER_ARGUMENT, _Signature, _N));               \
+  }                                                                            \
+  mutable ::testing::FunctionMocker<GMOCK_PP_REMOVE_PARENS(_Signature)>        \
+      GMOCK_MOCKER_(_N, _Constness, _MethodName)
+
+#define GMOCK_INTERNAL_EXPAND(...) __VA_ARGS__
+
+// Five Valid modifiers.
+#define GMOCK_INTERNAL_HAS_CONST(_Tuple) \
+  GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_CONST, ~, _Tuple))
+
+#define GMOCK_INTERNAL_HAS_OVERRIDE(_Tuple) \
+  GMOCK_PP_HAS_COMMA(                       \
+      GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_OVERRIDE, ~, _Tuple))
+
+#define GMOCK_INTERNAL_HAS_FINAL(_Tuple) \
+  GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_FINAL, ~, _Tuple))
+
+#define GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Tuple) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT, ~, _Tuple)
+
+#define GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT(_i, _, _elem)          \
+  GMOCK_PP_IF(                                                          \
+      GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)), \
+      _elem, )
+
+#define GMOCK_INTERNAL_GET_REF_SPEC(_Tuple) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_REF_SPEC_IF_REF, ~, _Tuple)
+
+#define GMOCK_INTERNAL_REF_SPEC_IF_REF(_i, _, _elem)                       \
+  GMOCK_PP_IF(GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)), \
+              GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), )
+
+#define GMOCK_INTERNAL_GET_CALLTYPE(_Tuple) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_CALLTYPE_IMPL, ~, _Tuple)
+
+#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem)            \
+  static_assert(                                                          \
+      (GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem)) +    \
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem)) + \
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem)) +    \
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)) + \
+       GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)) +      \
+       GMOCK_INTERNAL_IS_CALLTYPE(_elem)) == 1,                           \
+      GMOCK_PP_STRINGIZE(                                                 \
+          _elem) " cannot be recognized as a valid specification modifier.");
+
+// Modifiers implementation.
+#define GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem) \
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CONST_I_, _elem)
+
+#define GMOCK_INTERNAL_DETECT_CONST_I_const ,
+
+#define GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem) \
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_OVERRIDE_I_, _elem)
+
+#define GMOCK_INTERNAL_DETECT_OVERRIDE_I_override ,
+
+#define GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem) \
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_FINAL_I_, _elem)
+
+#define GMOCK_INTERNAL_DETECT_FINAL_I_final ,
+
+#define GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem) \
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_NOEXCEPT_I_, _elem)
+
+#define GMOCK_INTERNAL_DETECT_NOEXCEPT_I_noexcept ,
+
+#define GMOCK_INTERNAL_DETECT_REF(_i, _, _elem) \
+  GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_REF_I_, _elem)
+
+#define GMOCK_INTERNAL_DETECT_REF_I_ref ,
+
+#define GMOCK_INTERNAL_UNPACK_ref(x) x
+
+#define GMOCK_INTERNAL_GET_CALLTYPE_IMPL(_i, _, _elem)           \
+  GMOCK_PP_IF(GMOCK_INTERNAL_IS_CALLTYPE(_elem),                 \
+              GMOCK_INTERNAL_GET_VALUE_CALLTYPE, GMOCK_PP_EMPTY) \
+  (_elem)
+
+// TODO(iserna): GMOCK_INTERNAL_IS_CALLTYPE and
+// GMOCK_INTERNAL_GET_VALUE_CALLTYPE needed more expansions to work on windows
+// maybe they can be simplified somehow.
+#define GMOCK_INTERNAL_IS_CALLTYPE(_arg) \
+  GMOCK_INTERNAL_IS_CALLTYPE_I(          \
+      GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg))
+#define GMOCK_INTERNAL_IS_CALLTYPE_I(_arg) GMOCK_PP_IS_ENCLOSED_PARENS(_arg)
+
+#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE(_arg) \
+  GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I(          \
+      GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg))
+#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I(_arg) \
+  GMOCK_PP_IDENTITY _arg
+
+#define GMOCK_INTERNAL_IS_CALLTYPE_HELPER_Calltype
+
+// Note: The use of `identity_t` here allows _Ret to represent return types that
+// would normally need to be specified in a different way. For example, a method
+// returning a function pointer must be written as
+//
+// fn_ptr_return_t (*method(method_args_t...))(fn_ptr_args_t...)
+//
+// But we only support placing the return type at the beginning. To handle this,
+// we wrap all calls in identity_t, so that a declaration will be expanded to
+//
+// identity_t<fn_ptr_return_t (*)(fn_ptr_args_t...)> method(method_args_t...)
+//
+// This allows us to work around the syntactic oddities of function/method
+// types.
+#define GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)                                 \
+  ::testing::internal::identity_t<GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_Ret), \
+                                              GMOCK_PP_REMOVE_PARENS,         \
+                                              GMOCK_PP_IDENTITY)(_Ret)>(      \
+      GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_TYPE, _, _Args))
+
+#define GMOCK_INTERNAL_GET_TYPE(_i, _, _elem)                          \
+  GMOCK_PP_COMMA_IF(_i)                                                \
+  GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_elem), GMOCK_PP_REMOVE_PARENS, \
+              GMOCK_PP_IDENTITY)                                       \
+  (_elem)
+
+#define GMOCK_INTERNAL_PARAMETER(_i, _Signature, _)            \
+  GMOCK_PP_COMMA_IF(_i)                                        \
+  GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \
+  gmock_a##_i
+
+#define GMOCK_INTERNAL_FORWARD_ARG(_i, _Signature, _) \
+  GMOCK_PP_COMMA_IF(_i)                               \
+  ::std::forward<GMOCK_INTERNAL_ARG_O(                \
+      _i, GMOCK_PP_REMOVE_PARENS(_Signature))>(gmock_a##_i)
+
+#define GMOCK_INTERNAL_MATCHER_PARAMETER(_i, _Signature, _)        \
+  GMOCK_PP_COMMA_IF(_i)                                            \
+  GMOCK_INTERNAL_MATCHER_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \
+  gmock_a##_i
+
+#define GMOCK_INTERNAL_MATCHER_ARGUMENT(_i, _1, _2) \
+  GMOCK_PP_COMMA_IF(_i)                             \
+  gmock_a##_i
+
+#define GMOCK_INTERNAL_A_MATCHER_ARGUMENT(_i, _Signature, _) \
+  GMOCK_PP_COMMA_IF(_i)                                      \
+  ::testing::A<GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature))>()
+
+#define GMOCK_INTERNAL_ARG_O(_i, ...) \
+  typename ::testing::internal::Function<__VA_ARGS__>::template Arg<_i>::type
+
+#define GMOCK_INTERNAL_MATCHER_O(_i, ...)                          \
+  const ::testing::Matcher<typename ::testing::internal::Function< \
+      __VA_ARGS__>::template Arg<_i>::type>&
+
+#define MOCK_METHOD0(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 0, __VA_ARGS__)
+#define MOCK_METHOD1(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 1, __VA_ARGS__)
+#define MOCK_METHOD2(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 2, __VA_ARGS__)
+#define MOCK_METHOD3(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 3, __VA_ARGS__)
+#define MOCK_METHOD4(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 4, __VA_ARGS__)
+#define MOCK_METHOD5(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 5, __VA_ARGS__)
+#define MOCK_METHOD6(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 6, __VA_ARGS__)
+#define MOCK_METHOD7(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 7, __VA_ARGS__)
+#define MOCK_METHOD8(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 8, __VA_ARGS__)
+#define MOCK_METHOD9(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 9, __VA_ARGS__)
+#define MOCK_METHOD10(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, , m, 10, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 0, __VA_ARGS__)
+#define MOCK_CONST_METHOD1(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 1, __VA_ARGS__)
+#define MOCK_CONST_METHOD2(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 2, __VA_ARGS__)
+#define MOCK_CONST_METHOD3(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 3, __VA_ARGS__)
+#define MOCK_CONST_METHOD4(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 4, __VA_ARGS__)
+#define MOCK_CONST_METHOD5(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 5, __VA_ARGS__)
+#define MOCK_CONST_METHOD6(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 6, __VA_ARGS__)
+#define MOCK_CONST_METHOD7(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 7, __VA_ARGS__)
+#define MOCK_CONST_METHOD8(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 8, __VA_ARGS__)
+#define MOCK_CONST_METHOD9(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 9, __VA_ARGS__)
+#define MOCK_CONST_METHOD10(m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, , m, 10, __VA_ARGS__)
+
+#define MOCK_METHOD0_T(m, ...) MOCK_METHOD0(m, __VA_ARGS__)
+#define MOCK_METHOD1_T(m, ...) MOCK_METHOD1(m, __VA_ARGS__)
+#define MOCK_METHOD2_T(m, ...) MOCK_METHOD2(m, __VA_ARGS__)
+#define MOCK_METHOD3_T(m, ...) MOCK_METHOD3(m, __VA_ARGS__)
+#define MOCK_METHOD4_T(m, ...) MOCK_METHOD4(m, __VA_ARGS__)
+#define MOCK_METHOD5_T(m, ...) MOCK_METHOD5(m, __VA_ARGS__)
+#define MOCK_METHOD6_T(m, ...) MOCK_METHOD6(m, __VA_ARGS__)
+#define MOCK_METHOD7_T(m, ...) MOCK_METHOD7(m, __VA_ARGS__)
+#define MOCK_METHOD8_T(m, ...) MOCK_METHOD8(m, __VA_ARGS__)
+#define MOCK_METHOD9_T(m, ...) MOCK_METHOD9(m, __VA_ARGS__)
+#define MOCK_METHOD10_T(m, ...) MOCK_METHOD10(m, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0_T(m, ...) MOCK_CONST_METHOD0(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD1_T(m, ...) MOCK_CONST_METHOD1(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD2_T(m, ...) MOCK_CONST_METHOD2(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD3_T(m, ...) MOCK_CONST_METHOD3(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD4_T(m, ...) MOCK_CONST_METHOD4(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD5_T(m, ...) MOCK_CONST_METHOD5(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD6_T(m, ...) MOCK_CONST_METHOD6(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD7_T(m, ...) MOCK_CONST_METHOD7(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD8_T(m, ...) MOCK_CONST_METHOD8(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD9_T(m, ...) MOCK_CONST_METHOD9(m, __VA_ARGS__)
+#define MOCK_CONST_METHOD10_T(m, ...) MOCK_CONST_METHOD10(m, __VA_ARGS__)
+
+#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 0, __VA_ARGS__)
+#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 1, __VA_ARGS__)
+#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 2, __VA_ARGS__)
+#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 3, __VA_ARGS__)
+#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 4, __VA_ARGS__)
+#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 5, __VA_ARGS__)
+#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 6, __VA_ARGS__)
+#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 7, __VA_ARGS__)
+#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 8, __VA_ARGS__)
+#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 9, __VA_ARGS__)
+#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 10, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 0, __VA_ARGS__)
+#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 1, __VA_ARGS__)
+#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 2, __VA_ARGS__)
+#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 3, __VA_ARGS__)
+#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 4, __VA_ARGS__)
+#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 5, __VA_ARGS__)
+#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 6, __VA_ARGS__)
+#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 7, __VA_ARGS__)
+#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 8, __VA_ARGS__)
+#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 9, __VA_ARGS__)
+#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \
+  GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 10, __VA_ARGS__)
+
+#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+
+#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \
+  MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__)
+
+#define GMOCK_INTERNAL_MOCK_METHODN(constness, ct, Method, args_num, ...) \
+  GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(                                  \
+      args_num, ::testing::internal::identity_t<__VA_ARGS__>);            \
+  GMOCK_INTERNAL_MOCK_METHOD_IMPL(                                        \
+      args_num, Method, GMOCK_PP_NARG0(constness), 0, 0, , ct, ,          \
+      (::testing::internal::identity_t<__VA_ARGS__>))
+
+#define GMOCK_MOCKER_(arity, constness, Method) \
+  GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__)
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_
diff --git a/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-matchers.h b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-matchers.h
new file mode 100644
index 000000000..86be9c176
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-matchers.h
@@ -0,0 +1,5392 @@
+// Copyright 2007, 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.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// The MATCHER* family of macros can be used in a namespace scope to
+// define custom matchers easily.
+//
+// Basic Usage
+// ===========
+//
+// The syntax
+//
+//   MATCHER(name, description_string) { statements; }
+//
+// defines a matcher with the given name that executes the statements,
+// which must return a bool to indicate if the match succeeds.  Inside
+// the statements, you can refer to the value being matched by 'arg',
+// and refer to its type by 'arg_type'.
+//
+// The description string documents what the matcher does, and is used
+// to generate the failure message when the match fails.  Since a
+// MATCHER() is usually defined in a header file shared by multiple
+// C++ source files, we require the description to be a C-string
+// literal to avoid possible side effects.  It can be empty, in which
+// case we'll use the sequence of words in the matcher name as the
+// description.
+//
+// For example:
+//
+//   MATCHER(IsEven, "") { return (arg % 2) == 0; }
+//
+// allows you to write
+//
+//   // Expects mock_foo.Bar(n) to be called where n is even.
+//   EXPECT_CALL(mock_foo, Bar(IsEven()));
+//
+// or,
+//
+//   // Verifies that the value of some_expression is even.
+//   EXPECT_THAT(some_expression, IsEven());
+//
+// If the above assertion fails, it will print something like:
+//
+//   Value of: some_expression
+//   Expected: is even
+//     Actual: 7
+//
+// where the description "is even" is automatically calculated from the
+// matcher name IsEven.
+//
+// Argument Type
+// =============
+//
+// Note that 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, IsEven() can be used to match any type
+// where the value of "(arg % 2) == 0" can be implicitly converted to
+// a bool.  In the "Bar(IsEven())" 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.
+//
+// Parameterizing Matchers
+// =======================
+//
+// Sometimes you'll want to parameterize the matcher.  For that you
+// can use another macro:
+//
+//   MATCHER_P(name, param_name, description_string) { statements; }
+//
+// For example:
+//
+//   MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; }
+//
+// will allow you to write:
+//
+//   EXPECT_THAT(Blah("a"), HasAbsoluteValue(n));
+//
+// which may lead to this message (assuming n is 10):
+//
+//   Value of: Blah("a")
+//   Expected: has absolute value 10
+//     Actual: -9
+//
+// Note that both the matcher description and its parameter are
+// printed, making the message human-friendly.
+//
+// In the matcher definition body, you can write 'foo_type' to
+// reference the type of a parameter named 'foo'.  For example, in the
+// body of MATCHER_P(HasAbsoluteValue, value) above, you can write
+// 'value_type' to refer to the type of 'value'.
+//
+// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P$n to
+// support multi-parameter matchers.
+//
+// Describing Parameterized Matchers
+// =================================
+//
+// The last argument to MATCHER*() is a string-typed expression.  The
+// expression can reference all of the matcher's parameters and a
+// special bool-typed variable named 'negation'.  When 'negation' is
+// false, the expression should evaluate to the matcher's description;
+// otherwise it should evaluate to the description of the negation of
+// the matcher.  For example,
+//
+//   using testing::PrintToString;
+//
+//   MATCHER_P2(InClosedRange, low, hi,
+//       std::string(negation ? "is not" : "is") + " in range [" +
+//       PrintToString(low) + ", " + PrintToString(hi) + "]") {
+//     return low <= arg && arg <= hi;
+//   }
+//   ...
+//   EXPECT_THAT(3, InClosedRange(4, 6));
+//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
+//
+// would generate two failures that contain the text:
+//
+//   Expected: is in range [4, 6]
+//   ...
+//   Expected: is not in range [2, 4]
+//
+// If you specify "" as the description, the failure message will
+// contain the sequence of words in the matcher name followed by the
+// parameter values printed as a tuple.  For example,
+//
+//   MATCHER_P2(InClosedRange, low, hi, "") { ... }
+//   ...
+//   EXPECT_THAT(3, InClosedRange(4, 6));
+//   EXPECT_THAT(3, Not(InClosedRange(2, 4)));
+//
+// would generate two failures that contain the text:
+//
+//   Expected: in closed range (4, 6)
+//   ...
+//   Expected: not (in closed range (2, 4))
+//
+// Types of Matcher Parameters
+// ===========================
+//
+// For the purpose of typing, you can view
+//
+//   MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... }
+//
+// as shorthand for
+//
+//   template <typename p1_type, ..., typename pk_type>
+//   FooMatcherPk<p1_type, ..., pk_type>
+//   Foo(p1_type p1, ..., pk_type pk) { ... }
+//
+// When you write Foo(v1, ..., vk), the compiler infers the types of
+// the parameters v1, ..., and vk for you.  If you are not happy with
+// the result of the type inference, you can specify the types by
+// explicitly instantiating the template, as in Foo<long, bool>(5,
+// false).  As said earlier, you don't get to (or need to) specify
+// 'arg_type' as that's determined by the context in which the matcher
+// is used.  You can assign the result of expression Foo(p1, ..., pk)
+// to a variable of type FooMatcherPk<p1_type, ..., pk_type>.  This
+// can be useful when composing matchers.
+//
+// While you can instantiate a matcher template with reference types,
+// passing the parameters by pointer usually makes your code more
+// readable.  If, however, you still want to pass a parameter by
+// reference, be aware that in the failure message generated by the
+// matcher you will see the value of the referenced object but not its
+// address.
+//
+// Explaining Match Results
+// ========================
+//
+// Sometimes the matcher description alone isn't enough to explain why
+// the match has failed or succeeded.  For example, when expecting a
+// long string, it can be very helpful to also print the diff between
+// the expected string and the actual one.  To achieve that, you can
+// optionally stream additional information to a special variable
+// named result_listener, whose type is a pointer to class
+// MatchResultListener:
+//
+//   MATCHER_P(EqualsLongString, str, "") {
+//     if (arg == str) return true;
+//
+//     *result_listener << "the difference: "
+///                     << DiffStrings(str, arg);
+//     return false;
+//   }
+//
+// Overloading Matchers
+// ====================
+//
+// You can overload matchers with different numbers of parameters:
+//
+//   MATCHER_P(Blah, a, description_string1) { ... }
+//   MATCHER_P2(Blah, a, b, description_string2) { ... }
+//
+// Caveats
+// =======
+//
+// When defining a new matcher, you should also consider implementing
+// MatcherInterface or using MakePolymorphicMatcher().  These
+// approaches require more work than the MATCHER* macros, but also
+// give you more control on the types of the value being matched and
+// the matcher parameters, which may leads to better compiler error
+// messages when the matcher is used wrong.  They also allow
+// overloading matchers based on parameter types (as opposed to just
+// based on the number of parameters).
+//
+// MATCHER*() can only be used in a namespace scope as templates cannot be
+// declared inside of a local class.
+//
+// More Information
+// ================
+//
+// To learn more about using these macros, please search for 'MATCHER'
+// on
+// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md
+//
+// This file also implements some commonly used argument matchers.  More
+// matchers can be defined by the user implementing the
+// MatcherInterface<T> interface if necessary.
+//
+// See googletest/include/gtest/gtest-matchers.h for the definition of class
+// Matcher, class MatcherInterface, and others.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
+
+#include <algorithm>
+#include <cmath>
+#include <initializer_list>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "gmock/internal/gmock-internal-utils.h"
+#include "gmock/internal/gmock-port.h"
+#include "gmock/internal/gmock-pp.h"
+#include "gtest/gtest.h"
+
+// MSVC warning C5046 is new as of VS2017 version 15.8.
+#if defined(_MSC_VER) && _MSC_VER >= 1915
+#define GMOCK_MAYBE_5046_ 5046
+#else
+#define GMOCK_MAYBE_5046_
+#endif
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(
+    4251 GMOCK_MAYBE_5046_ /* class A needs to have dll-interface to be used by
+                              clients of class B */
+    /* Symbol involving type with internal linkage not defined */)
+
+namespace testing {
+
+// To implement a matcher Foo for type T, define:
+//   1. a class FooMatcherImpl that implements the
+//      MatcherInterface<T> interface, and
+//   2. a factory function that creates a Matcher<T> object from a
+//      FooMatcherImpl*.
+//
+// The two-level delegation design makes it possible to allow a user
+// to write "v" instead of "Eq(v)" where a Matcher is expected, which
+// is impossible if we pass matchers by pointers.  It also eases
+// ownership management as Matcher objects can now be copied like
+// plain values.
+
+// A match result listener that stores the explanation in a string.
+class StringMatchResultListener : public MatchResultListener {
+ public:
+  StringMatchResultListener() : MatchResultListener(&ss_) {}
+
+  // Returns the explanation accumulated so far.
+  std::string str() const { return ss_.str(); }
+
+  // Clears the explanation accumulated so far.
+  void Clear() { ss_.str(""); }
+
+ private:
+  ::std::stringstream ss_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StringMatchResultListener);
+};
+
+// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
+// and MUST NOT BE USED IN USER CODE!!!
+namespace internal {
+
+// The MatcherCastImpl class template is a helper for implementing
+// MatcherCast().  We need this helper in order to partially
+// specialize the implementation of MatcherCast() (C++ allows
+// class/struct templates to be partially specialized, but not
+// function templates.).
+
+// This general version is used when MatcherCast()'s argument is a
+// polymorphic matcher (i.e. something that can be converted to a
+// Matcher but is not one yet; for example, Eq(value)) or a value (for
+// example, "hello").
+template <typename T, typename M>
+class MatcherCastImpl {
+ public:
+  static Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
+    // M can be a polymorphic matcher, in which case we want to use
+    // its conversion operator to create Matcher<T>.  Or it can be a value
+    // that should be passed to the Matcher<T>'s constructor.
+    //
+    // We can't call Matcher<T>(polymorphic_matcher_or_value) when M is a
+    // polymorphic matcher because it'll be ambiguous if T has an implicit
+    // constructor from M (this usually happens when T has an implicit
+    // constructor from any type).
+    //
+    // It won't work to unconditionally implicit_cast
+    // polymorphic_matcher_or_value to Matcher<T> because it won't trigger
+    // a user-defined conversion from M to T if one exists (assuming M is
+    // a value).
+    return CastImpl(polymorphic_matcher_or_value,
+                    std::is_convertible<M, Matcher<T>>{},
+                    std::is_convertible<M, T>{});
+  }
+
+ private:
+  template <bool Ignore>
+  static Matcher<T> CastImpl(const M& polymorphic_matcher_or_value,
+                             std::true_type /* convertible_to_matcher */,
+                             std::integral_constant<bool, Ignore>) {
+    // M is implicitly convertible to Matcher<T>, which means that either
+    // M is a polymorphic matcher or Matcher<T> has an implicit constructor
+    // from M.  In both cases using the implicit conversion will produce a
+    // matcher.
+    //
+    // Even if T has an implicit constructor from M, it won't be called because
+    // creating Matcher<T> would require a chain of two user-defined conversions
+    // (first to create T from M and then to create Matcher<T> from T).
+    return polymorphic_matcher_or_value;
+  }
+
+  // M can't be implicitly converted to Matcher<T>, so M isn't a polymorphic
+  // matcher. It's a value of a type implicitly convertible to T. Use direct
+  // initialization to create a matcher.
+  static Matcher<T> CastImpl(const M& value,
+                             std::false_type /* convertible_to_matcher */,
+                             std::true_type /* convertible_to_T */) {
+    return Matcher<T>(ImplicitCast_<T>(value));
+  }
+
+  // M can't be implicitly converted to either Matcher<T> or T. Attempt to use
+  // polymorphic matcher Eq(value) in this case.
+  //
+  // Note that we first attempt to perform an implicit cast on the value and
+  // only fall back to the polymorphic Eq() matcher afterwards because the
+  // latter calls bool operator==(const Lhs& lhs, const Rhs& rhs) in the end
+  // which might be undefined even when Rhs is implicitly convertible to Lhs
+  // (e.g. std::pair<const int, int> vs. std::pair<int, int>).
+  //
+  // We don't define this method inline as we need the declaration of Eq().
+  static Matcher<T> CastImpl(const M& value,
+                             std::false_type /* convertible_to_matcher */,
+                             std::false_type /* convertible_to_T */);
+};
+
+// This more specialized version is used when MatcherCast()'s argument
+// is already a Matcher.  This only compiles when type T can be
+// statically converted to type U.
+template <typename T, typename U>
+class MatcherCastImpl<T, Matcher<U> > {
+ public:
+  static Matcher<T> Cast(const Matcher<U>& source_matcher) {
+    return Matcher<T>(new Impl(source_matcher));
+  }
+
+ private:
+  class Impl : public MatcherInterface<T> {
+   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 {
+      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<
+          typename std::remove_reference<U>::type>::type>::type;
+      // Do not allow implicitly converting base*/& to derived*/&.
+      static_assert(
+          // Do not trigger if only one of them is a pointer. That implies a
+          // regular conversion and not a down_cast.
+          (std::is_pointer<typename std::remove_reference<T>::type>::value !=
+           std::is_pointer<typename std::remove_reference<U>::type>::value) ||
+              std::is_same<FromType, ToType>::value ||
+              !std::is_base_of<FromType, ToType>::value,
+          "Can't implicitly convert from <base> to <derived>");
+
+      // 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;
+
+      return source_matcher_.MatchAndExplain(static_cast<CastType>(x),
+                                             listener);
+    }
+
+    void DescribeTo(::std::ostream* os) const override {
+      source_matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      source_matcher_.DescribeNegationTo(os);
+    }
+
+   private:
+    const Matcher<U> source_matcher_;
+  };
+};
+
+// This even more specialized version is used for efficiently casting
+// a matcher to its own type.
+template <typename T>
+class MatcherCastImpl<T, Matcher<T> > {
+ public:
+  static Matcher<T> Cast(const Matcher<T>& matcher) { return matcher; }
+};
+
+// Template specialization for parameterless Matcher.
+template <typename Derived>
+class MatcherBaseImpl {
+ public:
+  MatcherBaseImpl() = default;
+
+  template <typename T>
+  operator ::testing::Matcher<T>() const {  // NOLINT(runtime/explicit)
+    return ::testing::Matcher<T>(new
+                                 typename Derived::template gmock_Impl<T>());
+  }
+};
+
+// Template specialization for Matcher with parameters.
+template <template <typename...> class Derived, typename... Ts>
+class MatcherBaseImpl<Derived<Ts...>> {
+ public:
+  // Mark the constructor explicit for single argument T to avoid implicit
+  // conversions.
+  template <typename E = std::enable_if<sizeof...(Ts) == 1>,
+            typename E::type* = nullptr>
+  explicit MatcherBaseImpl(Ts... params)
+      : params_(std::forward<Ts>(params)...) {}
+  template <typename E = std::enable_if<sizeof...(Ts) != 1>,
+            typename = typename E::type>
+  MatcherBaseImpl(Ts... params)  // NOLINT
+      : params_(std::forward<Ts>(params)...) {}
+
+  template <typename F>
+  operator ::testing::Matcher<F>() const {  // NOLINT(runtime/explicit)
+    return Apply<F>(MakeIndexSequence<sizeof...(Ts)>{});
+  }
+
+ private:
+  template <typename F, std::size_t... tuple_ids>
+  ::testing::Matcher<F> Apply(IndexSequence<tuple_ids...>) const {
+    return ::testing::Matcher<F>(
+        new typename Derived<Ts...>::template gmock_Impl<F>(
+            std::get<tuple_ids>(params_)...));
+  }
+
+  const std::tuple<Ts...> params_;
+};
+
+}  // namespace internal
+
+// In order to be safe and clear, casting between different matcher
+// types is done explicitly via MatcherCast<T>(m), which takes a
+// matcher m and returns a Matcher<T>.  It compiles only when T can be
+// statically converted to the argument type of m.
+template <typename T, typename M>
+inline Matcher<T> MatcherCast(const M& matcher) {
+  return internal::MatcherCastImpl<T, M>::Cast(matcher);
+}
+
+// This overload handles polymorphic matchers and values only since
+// monomorphic matchers are handled by the next one.
+template <typename T, typename M>
+inline Matcher<T> SafeMatcherCast(const M& polymorphic_matcher_or_value) {
+  return MatcherCast<T>(polymorphic_matcher_or_value);
+}
+
+// This overload handles monomorphic matchers.
+//
+// In general, if type T can be implicitly converted to type U, we can
+// 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
+// underlying Matcher<U> may be interested in the argument's address, which
+// is not preserved in the conversion from T to 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.
+  GTEST_COMPILE_ASSERT_(
+      std::is_reference<T>::value || !std::is_reference<U>::value,
+      cannot_convert_non_reference_arg_to_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;
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU;
+  constexpr bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther;
+  constexpr bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther;
+  GTEST_COMPILE_ASSERT_(
+      kTIsOther || kUIsOther ||
+      (internal::LosslessArithmeticConvertible<RawT, RawU>::value),
+      conversion_of_arithmetic_types_must_be_lossless);
+  return MatcherCast<T>(matcher);
+}
+
+// A<T>() returns a matcher that matches any value of type T.
+template <typename T>
+Matcher<T> A();
+
+// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
+// and MUST NOT BE USED IN USER CODE!!!
+namespace internal {
+
+// If the explanation is not empty, prints it to the ostream.
+inline void PrintIfNotEmpty(const std::string& explanation,
+                            ::std::ostream* os) {
+  if (explanation != "" && os != nullptr) {
+    *os << ", " << explanation;
+  }
+}
+
+// Returns true if the given type name is easy to read by a human.
+// This is used to decide whether printing the type of a value might
+// be helpful.
+inline bool IsReadableTypeName(const std::string& type_name) {
+  // We consider a type name readable if it's short or doesn't contain
+  // a template or function type.
+  return (type_name.length() <= 20 ||
+          type_name.find_first_of("<(") == std::string::npos);
+}
+
+// Matches the value against the given matcher, prints the value and explains
+// the match result to the listener. Returns the match result.
+// 'listener' must not be NULL.
+// Value cannot be passed by const reference, because some matchers take a
+// non-const argument.
+template <typename Value, typename T>
+bool MatchPrintAndExplain(Value& value, const Matcher<T>& matcher,
+                          MatchResultListener* listener) {
+  if (!listener->IsInterested()) {
+    // If the listener is not interested, we do not need to construct the
+    // inner explanation.
+    return matcher.Matches(value);
+  }
+
+  StringMatchResultListener inner_listener;
+  const bool match = matcher.MatchAndExplain(value, &inner_listener);
+
+  UniversalPrint(value, listener->stream());
+#if GTEST_HAS_RTTI
+  const std::string& type_name = GetTypeName<Value>();
+  if (IsReadableTypeName(type_name))
+    *listener->stream() << " (of type " << type_name << ")";
+#endif
+  PrintIfNotEmpty(inner_listener.str(), listener->stream());
+
+  return match;
+}
+
+// An internal helper class for doing compile-time loop on a tuple's
+// fields.
+template <size_t N>
+class TuplePrefix {
+ public:
+  // TuplePrefix<N>::Matches(matcher_tuple, value_tuple) returns true
+  // if and only if the first N fields of matcher_tuple matches
+  // the first N fields of value_tuple, respectively.
+  template <typename MatcherTuple, typename ValueTuple>
+  static bool Matches(const MatcherTuple& matcher_tuple,
+                      const ValueTuple& value_tuple) {
+    return TuplePrefix<N - 1>::Matches(matcher_tuple, value_tuple) &&
+           std::get<N - 1>(matcher_tuple).Matches(std::get<N - 1>(value_tuple));
+  }
+
+  // TuplePrefix<N>::ExplainMatchFailuresTo(matchers, values, os)
+  // describes failures in matching the first N fields of matchers
+  // against the first N fields of values.  If there is no failure,
+  // nothing will be streamed to os.
+  template <typename MatcherTuple, typename ValueTuple>
+  static void ExplainMatchFailuresTo(const MatcherTuple& matchers,
+                                     const ValueTuple& values,
+                                     ::std::ostream* os) {
+    // First, describes failures in the first N - 1 fields.
+    TuplePrefix<N - 1>::ExplainMatchFailuresTo(matchers, values, os);
+
+    // Then describes the failure (if any) in the (N - 1)-th (0-based)
+    // field.
+    typename std::tuple_element<N - 1, MatcherTuple>::type matcher =
+        std::get<N - 1>(matchers);
+    typedef typename std::tuple_element<N - 1, ValueTuple>::type Value;
+    const Value& value = std::get<N - 1>(values);
+    StringMatchResultListener listener;
+    if (!matcher.MatchAndExplain(value, &listener)) {
+      *os << "  Expected arg #" << N - 1 << ": ";
+      std::get<N - 1>(matchers).DescribeTo(os);
+      *os << "\n           Actual: ";
+      // We remove the reference in type Value to prevent the
+      // universal printer from printing the address of value, which
+      // isn't interesting to the user most of the time.  The
+      // matcher's MatchAndExplain() method handles the case when
+      // the address is interesting.
+      internal::UniversalPrint(value, os);
+      PrintIfNotEmpty(listener.str(), os);
+      *os << "\n";
+    }
+  }
+};
+
+// The base case.
+template <>
+class TuplePrefix<0> {
+ public:
+  template <typename MatcherTuple, typename ValueTuple>
+  static bool Matches(const MatcherTuple& /* matcher_tuple */,
+                      const ValueTuple& /* value_tuple */) {
+    return true;
+  }
+
+  template <typename MatcherTuple, typename ValueTuple>
+  static void ExplainMatchFailuresTo(const MatcherTuple& /* matchers */,
+                                     const ValueTuple& /* values */,
+                                     ::std::ostream* /* os */) {}
+};
+
+// TupleMatches(matcher_tuple, value_tuple) returns true if and only if
+// all matchers in matcher_tuple match the corresponding fields in
+// value_tuple.  It is a compiler error if matcher_tuple and
+// value_tuple have different number of fields or incompatible field
+// types.
+template <typename MatcherTuple, typename ValueTuple>
+bool TupleMatches(const MatcherTuple& matcher_tuple,
+                  const ValueTuple& value_tuple) {
+  // Makes sure that matcher_tuple and value_tuple have the same
+  // number of fields.
+  GTEST_COMPILE_ASSERT_(std::tuple_size<MatcherTuple>::value ==
+                            std::tuple_size<ValueTuple>::value,
+                        matcher_and_value_have_different_numbers_of_fields);
+  return TuplePrefix<std::tuple_size<ValueTuple>::value>::Matches(matcher_tuple,
+                                                                  value_tuple);
+}
+
+// Describes failures in matching matchers against values.  If there
+// is no failure, nothing will be streamed to os.
+template <typename MatcherTuple, typename ValueTuple>
+void ExplainMatchFailureTupleTo(const MatcherTuple& matchers,
+                                const ValueTuple& values,
+                                ::std::ostream* os) {
+  TuplePrefix<std::tuple_size<MatcherTuple>::value>::ExplainMatchFailuresTo(
+      matchers, values, os);
+}
+
+// TransformTupleValues and its helper.
+//
+// TransformTupleValuesHelper hides the internal machinery that
+// TransformTupleValues uses to implement a tuple traversal.
+template <typename Tuple, typename Func, typename OutIter>
+class TransformTupleValuesHelper {
+ private:
+  typedef ::std::tuple_size<Tuple> TupleSize;
+
+ public:
+  // For each member of tuple 't', taken in order, evaluates '*out++ = f(t)'.
+  // Returns the final value of 'out' in case the caller needs it.
+  static OutIter Run(Func f, const Tuple& t, OutIter out) {
+    return IterateOverTuple<Tuple, TupleSize::value>()(f, t, out);
+  }
+
+ private:
+  template <typename Tup, size_t kRemainingSize>
+  struct IterateOverTuple {
+    OutIter operator() (Func f, const Tup& t, OutIter out) const {
+      *out++ = f(::std::get<TupleSize::value - kRemainingSize>(t));
+      return IterateOverTuple<Tup, kRemainingSize - 1>()(f, t, out);
+    }
+  };
+  template <typename Tup>
+  struct IterateOverTuple<Tup, 0> {
+    OutIter operator() (Func /* f */, const Tup& /* t */, OutIter out) const {
+      return out;
+    }
+  };
+};
+
+// Successively invokes 'f(element)' on each element of the tuple 't',
+// appending each result to the 'out' iterator. Returns the final value
+// of 'out'.
+template <typename Tuple, typename Func, typename OutIter>
+OutIter TransformTupleValues(Func f, const Tuple& t, OutIter out) {
+  return TransformTupleValuesHelper<Tuple, Func, OutIter>::Run(f, t, out);
+}
+
+// Implements _, a matcher that matches any value of any
+// type.  This is a polymorphic matcher, so we need a template type
+// conversion operator to make it appearing as a Matcher<T> for any
+// type T.
+class AnythingMatcher {
+ public:
+  using is_gtest_matcher = void;
+
+  template <typename T>
+  bool MatchAndExplain(const T& /* x */, std::ostream* /* listener */) const {
+    return true;
+  }
+  void DescribeTo(std::ostream* os) const { *os << "is anything"; }
+  void DescribeNegationTo(::std::ostream* os) const {
+    // This is mostly for completeness' sake, as it's not very useful
+    // to write Not(A<bool>()).  However we cannot completely rule out
+    // such a possibility, and it doesn't hurt to be prepared.
+    *os << "never matches";
+  }
+};
+
+// Implements the polymorphic IsNull() matcher, which matches any raw or smart
+// pointer that is NULL.
+class IsNullMatcher {
+ public:
+  template <typename Pointer>
+  bool MatchAndExplain(const Pointer& p,
+                       MatchResultListener* /* listener */) const {
+    return p == nullptr;
+  }
+
+  void DescribeTo(::std::ostream* os) const { *os << "is NULL"; }
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "isn't NULL";
+  }
+};
+
+// Implements the polymorphic NotNull() matcher, which matches any raw or smart
+// pointer that is not NULL.
+class NotNullMatcher {
+ public:
+  template <typename Pointer>
+  bool MatchAndExplain(const Pointer& p,
+                       MatchResultListener* /* listener */) const {
+    return p != nullptr;
+  }
+
+  void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; }
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is NULL";
+  }
+};
+
+// Ref(variable) matches any argument that is a reference to
+// 'variable'.  This matcher is polymorphic as it can match any
+// super type of the type of 'variable'.
+//
+// The RefMatcher template class implements Ref(variable).  It can
+// only be instantiated with a reference type.  This prevents a user
+// from mistakenly using Ref(x) to match a non-reference function
+// argument.  For example, the following will righteously cause a
+// compiler error:
+//
+//   int n;
+//   Matcher<int> m1 = Ref(n);   // This won't compile.
+//   Matcher<int&> m2 = Ref(n);  // This will compile.
+template <typename T>
+class RefMatcher;
+
+template <typename T>
+class RefMatcher<T&> {
+  // Google Mock is a generic framework and thus needs to support
+  // mocking any function types, including those that take non-const
+  // reference arguments.  Therefore the template parameter T (and
+  // Super below) can be instantiated to either a const type or a
+  // non-const type.
+ public:
+  // RefMatcher() takes a T& instead of const T&, as we want the
+  // compiler to catch using Ref(const_value) as a matcher for a
+  // non-const reference.
+  explicit RefMatcher(T& x) : object_(x) {}  // NOLINT
+
+  template <typename Super>
+  operator Matcher<Super&>() const {
+    // By passing object_ (type T&) to Impl(), which expects a Super&,
+    // we make sure that Super is a super type of T.  In particular,
+    // this catches using Ref(const_value) as a matcher for a
+    // non-const reference, as you cannot implicitly convert a const
+    // reference to a non-const reference.
+    return MakeMatcher(new Impl<Super>(object_));
+  }
+
+ private:
+  template <typename Super>
+  class Impl : public MatcherInterface<Super&> {
+   public:
+    explicit Impl(Super& x) : object_(x) {}  // NOLINT
+
+    // MatchAndExplain() takes a Super& (as opposed to const Super&)
+    // in order to match the interface MatcherInterface<Super&>.
+    bool MatchAndExplain(Super& x,
+                         MatchResultListener* listener) const override {
+      *listener << "which is located @" << static_cast<const void*>(&x);
+      return &x == &object_;
+    }
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "references the variable ";
+      UniversalPrinter<Super&>::Print(object_, os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "does not reference the variable ";
+      UniversalPrinter<Super&>::Print(object_, os);
+    }
+
+   private:
+    const Super& object_;
+  };
+
+  T& object_;
+};
+
+// Polymorphic helper functions for narrow and wide string matchers.
+inline bool CaseInsensitiveCStringEquals(const char* lhs, const char* rhs) {
+  return String::CaseInsensitiveCStringEquals(lhs, rhs);
+}
+
+inline bool CaseInsensitiveCStringEquals(const wchar_t* lhs,
+                                         const wchar_t* rhs) {
+  return String::CaseInsensitiveWideCStringEquals(lhs, rhs);
+}
+
+// String comparison for narrow or wide strings that can have embedded NUL
+// characters.
+template <typename StringType>
+bool CaseInsensitiveStringEquals(const StringType& s1,
+                                 const StringType& s2) {
+  // Are the heads equal?
+  if (!CaseInsensitiveCStringEquals(s1.c_str(), s2.c_str())) {
+    return false;
+  }
+
+  // Skip the equal heads.
+  const typename StringType::value_type nul = 0;
+  const size_t i1 = s1.find(nul), i2 = s2.find(nul);
+
+  // Are we at the end of either s1 or s2?
+  if (i1 == StringType::npos || i2 == StringType::npos) {
+    return i1 == i2;
+  }
+
+  // Are the tails equal?
+  return CaseInsensitiveStringEquals(s1.substr(i1 + 1), s2.substr(i2 + 1));
+}
+
+// String matchers.
+
+// Implements equality-based string matchers like StrEq, StrCaseNe, and etc.
+template <typename StringType>
+class StrEqualityMatcher {
+ public:
+  StrEqualityMatcher(StringType str, bool expect_eq, bool case_sensitive)
+      : string_(std::move(str)),
+        expect_eq_(expect_eq),
+        case_sensitive_(case_sensitive) {}
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  bool MatchAndExplain(const internal::StringView& s,
+                       MatchResultListener* listener) const {
+    // This should fail to compile if StringView is used with wide
+    // strings.
+    const StringType& str = std::string(s);
+    return MatchAndExplain(str, listener);
+  }
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    if (s == nullptr) {
+      return !expect_eq_;
+    }
+    return MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringView has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const StringType s2(s);
+    const bool eq = case_sensitive_ ? s2 == string_ :
+        CaseInsensitiveStringEquals(s2, string_);
+    return expect_eq_ == eq;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    DescribeToHelper(expect_eq_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    DescribeToHelper(!expect_eq_, os);
+  }
+
+ private:
+  void DescribeToHelper(bool expect_eq, ::std::ostream* os) const {
+    *os << (expect_eq ? "is " : "isn't ");
+    *os << "equal to ";
+    if (!case_sensitive_) {
+      *os << "(ignoring case) ";
+    }
+    UniversalPrint(string_, os);
+  }
+
+  const StringType string_;
+  const bool expect_eq_;
+  const bool case_sensitive_;
+};
+
+// Implements the polymorphic HasSubstr(substring) matcher, which
+// can be used as a Matcher<T> as long as T can be converted to a
+// string.
+template <typename StringType>
+class HasSubstrMatcher {
+ public:
+  explicit HasSubstrMatcher(const StringType& substring)
+      : substring_(substring) {}
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  bool MatchAndExplain(const internal::StringView& s,
+                       MatchResultListener* listener) const {
+    // This should fail to compile if StringView is used with wide
+    // strings.
+    const StringType& str = std::string(s);
+    return MatchAndExplain(str, listener);
+  }
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != nullptr && MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringView has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    return StringType(s).find(substring_) != StringType::npos;
+  }
+
+  // Describes what this matcher matches.
+  void DescribeTo(::std::ostream* os) const {
+    *os << "has substring ";
+    UniversalPrint(substring_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "has no substring ";
+    UniversalPrint(substring_, os);
+  }
+
+ private:
+  const StringType substring_;
+};
+
+// Implements the polymorphic StartsWith(substring) matcher, which
+// can be used as a Matcher<T> as long as T can be converted to a
+// string.
+template <typename StringType>
+class StartsWithMatcher {
+ public:
+  explicit StartsWithMatcher(const StringType& prefix) : prefix_(prefix) {
+  }
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  bool MatchAndExplain(const internal::StringView& s,
+                       MatchResultListener* listener) const {
+    // This should fail to compile if StringView is used with wide
+    // strings.
+    const StringType& str = std::string(s);
+    return MatchAndExplain(str, listener);
+  }
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != nullptr && MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringView has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const StringType& s2(s);
+    return s2.length() >= prefix_.length() &&
+        s2.substr(0, prefix_.length()) == prefix_;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "starts with ";
+    UniversalPrint(prefix_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't start with ";
+    UniversalPrint(prefix_, os);
+  }
+
+ private:
+  const StringType prefix_;
+};
+
+// Implements the polymorphic EndsWith(substring) matcher, which
+// can be used as a Matcher<T> as long as T can be converted to a
+// string.
+template <typename StringType>
+class EndsWithMatcher {
+ public:
+  explicit EndsWithMatcher(const StringType& suffix) : suffix_(suffix) {}
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  bool MatchAndExplain(const internal::StringView& s,
+                       MatchResultListener* listener) const {
+    // This should fail to compile if StringView is used with wide
+    // strings.
+    const StringType& str = std::string(s);
+    return MatchAndExplain(str, listener);
+  }
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != nullptr && MatchAndExplain(StringType(s), listener);
+  }
+
+  // Matches anything that can convert to StringType.
+  //
+  // This is a template, not just a plain function with const StringType&,
+  // because StringView has some interfering non-explicit constructors.
+  template <typename MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const StringType& s2(s);
+    return s2.length() >= suffix_.length() &&
+        s2.substr(s2.length() - suffix_.length()) == suffix_;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "ends with ";
+    UniversalPrint(suffix_, os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't end with ";
+    UniversalPrint(suffix_, os);
+  }
+
+ private:
+  const StringType suffix_;
+};
+
+// Implements a matcher that compares the two fields of a 2-tuple
+// using one of the ==, <=, <, etc, operators.  The two fields being
+// compared don't have to have the same type.
+//
+// The matcher defined here is polymorphic (for example, Eq() can be
+// used to match a std::tuple<int, short>, a std::tuple<const long&, double>,
+// etc).  Therefore we use a template type conversion operator in the
+// implementation.
+template <typename D, typename Op>
+class PairMatchBase {
+ public:
+  template <typename T1, typename T2>
+  operator Matcher<::std::tuple<T1, T2>>() const {
+    return Matcher<::std::tuple<T1, T2>>(new Impl<const ::std::tuple<T1, T2>&>);
+  }
+  template <typename T1, typename T2>
+  operator Matcher<const ::std::tuple<T1, T2>&>() const {
+    return MakeMatcher(new Impl<const ::std::tuple<T1, T2>&>);
+  }
+
+ private:
+  static ::std::ostream& GetDesc(::std::ostream& os) {  // NOLINT
+    return os << D::Desc();
+  }
+
+  template <typename Tuple>
+  class Impl : public MatcherInterface<Tuple> {
+   public:
+    bool MatchAndExplain(Tuple args,
+                         MatchResultListener* /* listener */) const override {
+      return Op()(::std::get<0>(args), ::std::get<1>(args));
+    }
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "are " << GetDesc;
+    }
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "aren't " << GetDesc;
+    }
+  };
+};
+
+class Eq2Matcher : public PairMatchBase<Eq2Matcher, AnyEq> {
+ public:
+  static const char* Desc() { return "an equal pair"; }
+};
+class Ne2Matcher : public PairMatchBase<Ne2Matcher, AnyNe> {
+ public:
+  static const char* Desc() { return "an unequal pair"; }
+};
+class Lt2Matcher : public PairMatchBase<Lt2Matcher, AnyLt> {
+ public:
+  static const char* Desc() { return "a pair where the first < the second"; }
+};
+class Gt2Matcher : public PairMatchBase<Gt2Matcher, AnyGt> {
+ public:
+  static const char* Desc() { return "a pair where the first > the second"; }
+};
+class Le2Matcher : public PairMatchBase<Le2Matcher, AnyLe> {
+ public:
+  static const char* Desc() { return "a pair where the first <= the second"; }
+};
+class Ge2Matcher : public PairMatchBase<Ge2Matcher, AnyGe> {
+ public:
+  static const char* Desc() { return "a pair where the first >= the second"; }
+};
+
+// Implements the Not(...) matcher for a particular argument type T.
+// We do not nest it inside the NotMatcher class template, as that
+// will prevent different instantiations of NotMatcher from sharing
+// the same NotMatcherImpl<T> class.
+template <typename T>
+class NotMatcherImpl : public MatcherInterface<const T&> {
+ public:
+  explicit NotMatcherImpl(const Matcher<T>& matcher)
+      : matcher_(matcher) {}
+
+  bool MatchAndExplain(const T& x,
+                       MatchResultListener* listener) const override {
+    return !matcher_.MatchAndExplain(x, listener);
+  }
+
+  void DescribeTo(::std::ostream* os) const override {
+    matcher_.DescribeNegationTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    matcher_.DescribeTo(os);
+  }
+
+ private:
+  const Matcher<T> matcher_;
+};
+
+// Implements the Not(m) matcher, which matches a value that doesn't
+// match matcher m.
+template <typename InnerMatcher>
+class NotMatcher {
+ public:
+  explicit NotMatcher(InnerMatcher matcher) : matcher_(matcher) {}
+
+  // This template type conversion operator allows Not(m) to be used
+  // to match any type m can match.
+  template <typename T>
+  operator Matcher<T>() const {
+    return Matcher<T>(new NotMatcherImpl<T>(SafeMatcherCast<T>(matcher_)));
+  }
+
+ private:
+  InnerMatcher matcher_;
+};
+
+// Implements the AllOf(m1, m2) matcher for a particular argument type
+// T. We do not nest it inside the BothOfMatcher class template, as
+// that will prevent different instantiations of BothOfMatcher from
+// sharing the same BothOfMatcherImpl<T> class.
+template <typename T>
+class AllOfMatcherImpl : public MatcherInterface<const T&> {
+ public:
+  explicit AllOfMatcherImpl(std::vector<Matcher<T> > matchers)
+      : matchers_(std::move(matchers)) {}
+
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "(";
+    for (size_t i = 0; i < matchers_.size(); ++i) {
+      if (i != 0) *os << ") and (";
+      matchers_[i].DescribeTo(os);
+    }
+    *os << ")";
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "(";
+    for (size_t i = 0; i < matchers_.size(); ++i) {
+      if (i != 0) *os << ") or (";
+      matchers_[i].DescribeNegationTo(os);
+    }
+    *os << ")";
+  }
+
+  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.
+    std::string all_match_result;
+
+    for (size_t i = 0; i < matchers_.size(); ++i) {
+      StringMatchResultListener slistener;
+      if (matchers_[i].MatchAndExplain(x, &slistener)) {
+        if (all_match_result.empty()) {
+          all_match_result = slistener.str();
+        } else {
+          std::string result = slistener.str();
+          if (!result.empty()) {
+            all_match_result += ", and ";
+            all_match_result += result;
+          }
+        }
+      } else {
+        *listener << slistener.str();
+        return false;
+      }
+    }
+
+    // Otherwise we need to explain why *both* of them match.
+    *listener << all_match_result;
+    return true;
+  }
+
+ private:
+  const std::vector<Matcher<T> > matchers_;
+};
+
+// VariadicMatcher is used for the variadic implementation of
+// AllOf(m_1, m_2, ...) and AnyOf(m_1, m_2, ...).
+// CombiningMatcher<T> is used to recursively combine the provided matchers
+// (of type Args...).
+template <template <typename T> class CombiningMatcher, typename... Args>
+class VariadicMatcher {
+ public:
+  VariadicMatcher(const Args&... matchers)  // NOLINT
+      : matchers_(matchers...) {
+    static_assert(sizeof...(Args) > 0, "Must have at least one matcher.");
+  }
+
+  VariadicMatcher(const VariadicMatcher&) = default;
+  VariadicMatcher& operator=(const VariadicMatcher&) = delete;
+
+  // This template type conversion operator allows an
+  // VariadicMatcher<Matcher1, Matcher2...> object to match any type that
+  // all of the provided matchers (Matcher1, Matcher2, ...) can match.
+  template <typename T>
+  operator Matcher<T>() const {
+    std::vector<Matcher<T> > values;
+    CreateVariadicMatcher<T>(&values, std::integral_constant<size_t, 0>());
+    return Matcher<T>(new CombiningMatcher<T>(std::move(values)));
+  }
+
+ private:
+  template <typename T, size_t I>
+  void CreateVariadicMatcher(std::vector<Matcher<T> >* values,
+                             std::integral_constant<size_t, I>) const {
+    values->push_back(SafeMatcherCast<T>(std::get<I>(matchers_)));
+    CreateVariadicMatcher<T>(values, std::integral_constant<size_t, I + 1>());
+  }
+
+  template <typename T>
+  void CreateVariadicMatcher(
+      std::vector<Matcher<T> >*,
+      std::integral_constant<size_t, sizeof...(Args)>) const {}
+
+  std::tuple<Args...> matchers_;
+};
+
+template <typename... Args>
+using AllOfMatcher = VariadicMatcher<AllOfMatcherImpl, Args...>;
+
+// Implements the AnyOf(m1, m2) matcher for a particular argument type
+// T.  We do not nest it inside the AnyOfMatcher class template, as
+// that will prevent different instantiations of AnyOfMatcher from
+// sharing the same EitherOfMatcherImpl<T> class.
+template <typename T>
+class AnyOfMatcherImpl : public MatcherInterface<const T&> {
+ public:
+  explicit AnyOfMatcherImpl(std::vector<Matcher<T> > matchers)
+      : matchers_(std::move(matchers)) {}
+
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "(";
+    for (size_t i = 0; i < matchers_.size(); ++i) {
+      if (i != 0) *os << ") or (";
+      matchers_[i].DescribeTo(os);
+    }
+    *os << ")";
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "(";
+    for (size_t i = 0; i < matchers_.size(); ++i) {
+      if (i != 0) *os << ") and (";
+      matchers_[i].DescribeNegationTo(os);
+    }
+    *os << ")";
+  }
+
+  bool MatchAndExplain(const T& x,
+                       MatchResultListener* listener) const override {
+    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) {
+      StringMatchResultListener slistener;
+      if (matchers_[i].MatchAndExplain(x, &slistener)) {
+        *listener << slistener.str();
+        return true;
+      } else {
+        if (no_match_result.empty()) {
+          no_match_result = slistener.str();
+        } else {
+          std::string result = slistener.str();
+          if (!result.empty()) {
+            no_match_result += ", and ";
+            no_match_result += result;
+          }
+        }
+      }
+    }
+
+    // Otherwise we need to explain why *both* of them fail.
+    *listener << no_match_result;
+    return false;
+  }
+
+ private:
+  const std::vector<Matcher<T> > matchers_;
+};
+
+// AnyOfMatcher is used for the variadic implementation of AnyOf(m_1, m_2, ...).
+template <typename... Args>
+using AnyOfMatcher = VariadicMatcher<AnyOfMatcherImpl, Args...>;
+
+// Wrapper for implementation of Any/AllOfArray().
+template <template <class> class MatcherImpl, typename T>
+class SomeOfArrayMatcher {
+ public:
+  // Constructs the matcher from a sequence of element values or
+  // element matchers.
+  template <typename Iter>
+  SomeOfArrayMatcher(Iter first, Iter last) : matchers_(first, last) {}
+
+  template <typename U>
+  operator Matcher<U>() const {  // NOLINT
+    using RawU = typename std::decay<U>::type;
+    std::vector<Matcher<RawU>> matchers;
+    for (const auto& matcher : matchers_) {
+      matchers.push_back(MatcherCast<RawU>(matcher));
+    }
+    return Matcher<U>(new MatcherImpl<RawU>(std::move(matchers)));
+  }
+
+ private:
+  const ::std::vector<T> matchers_;
+};
+
+template <typename T>
+using AllOfArrayMatcher = SomeOfArrayMatcher<AllOfMatcherImpl, T>;
+
+template <typename T>
+using AnyOfArrayMatcher = SomeOfArrayMatcher<AnyOfMatcherImpl, T>;
+
+// Used for implementing Truly(pred), which turns a predicate into a
+// matcher.
+template <typename Predicate>
+class TrulyMatcher {
+ public:
+  explicit TrulyMatcher(Predicate pred) : predicate_(pred) {}
+
+  // This method template allows Truly(pred) to be used as a matcher
+  // for type T where T is the argument type of predicate 'pred'.  The
+  // argument is passed by reference as the predicate may be
+  // interested in the address of the argument.
+  template <typename T>
+  bool MatchAndExplain(T& x,  // NOLINT
+                       MatchResultListener* listener) const {
+    // Without the if-statement, MSVC sometimes warns about converting
+    // a value to bool (warning 4800).
+    //
+    // We cannot write 'return !!predicate_(x);' as that doesn't work
+    // when predicate_(x) returns a class convertible to bool but
+    // having no operator!().
+    if (predicate_(x))
+      return true;
+    *listener << "didn't satisfy the given predicate";
+    return false;
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "satisfies the given predicate";
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't satisfy the given predicate";
+  }
+
+ private:
+  Predicate predicate_;
+};
+
+// Used for implementing Matches(matcher), which turns a matcher into
+// a predicate.
+template <typename M>
+class MatcherAsPredicate {
+ public:
+  explicit MatcherAsPredicate(M matcher) : matcher_(matcher) {}
+
+  // This template operator() allows Matches(m) to be used as a
+  // predicate on type T where m is a matcher on type T.
+  //
+  // The argument x is passed by reference instead of by value, as
+  // some matcher may be interested in its address (e.g. as in
+  // Matches(Ref(n))(x)).
+  template <typename T>
+  bool operator()(const T& x) const {
+    // We let matcher_ commit to a particular type here instead of
+    // when the MatcherAsPredicate object was constructed.  This
+    // allows us to write Matches(m) where m is a polymorphic matcher
+    // (e.g. Eq(5)).
+    //
+    // If we write Matcher<T>(matcher_).Matches(x) here, it won't
+    // compile when matcher_ has type Matcher<const T&>; if we write
+    // Matcher<const T&>(matcher_).Matches(x) here, it won't compile
+    // when matcher_ has type Matcher<T>; if we just write
+    // matcher_.Matches(x), it won't compile when matcher_ is
+    // polymorphic, e.g. Eq(5).
+    //
+    // MatcherCast<const T&>() is necessary for making the code work
+    // in all of the above situations.
+    return MatcherCast<const T&>(matcher_).Matches(x);
+  }
+
+ private:
+  M matcher_;
+};
+
+// For implementing ASSERT_THAT() and EXPECT_THAT().  The template
+// argument M must be a type that can be converted to a matcher.
+template <typename M>
+class PredicateFormatterFromMatcher {
+ public:
+  explicit PredicateFormatterFromMatcher(M m) : matcher_(std::move(m)) {}
+
+  // This template () operator allows a PredicateFormatterFromMatcher
+  // object to act as a predicate-formatter suitable for using with
+  // Google Test's EXPECT_PRED_FORMAT1() macro.
+  template <typename T>
+  AssertionResult operator()(const char* value_text, const T& x) const {
+    // We convert matcher_ to a Matcher<const T&> *now* instead of
+    // when the PredicateFormatterFromMatcher object was constructed,
+    // as matcher_ may be polymorphic (e.g. NotNull()) and we won't
+    // know which type to instantiate it to until we actually see the
+    // type of x here.
+    //
+    // We write SafeMatcherCast<const T&>(matcher_) instead of
+    // Matcher<const T&>(matcher_), as the latter won't compile when
+    // matcher_ has type Matcher<T> (e.g. An<int>()).
+    // We don't write MatcherCast<const T&> either, as that allows
+    // potentially unsafe downcasting of the matcher argument.
+    const Matcher<const T&> matcher = SafeMatcherCast<const T&>(matcher_);
+
+    // The expected path here is that the matcher should match (i.e. that most
+    // tests pass) so optimize for this case.
+    if (matcher.Matches(x)) {
+      return AssertionSuccess();
+    }
+
+    ::std::stringstream ss;
+    ss << "Value of: " << value_text << "\n"
+       << "Expected: ";
+    matcher.DescribeTo(&ss);
+
+    // Rerun the matcher to "PrintAndExplain" the failure.
+    StringMatchResultListener listener;
+    if (MatchPrintAndExplain(x, matcher, &listener)) {
+      ss << "\n  The matcher failed on the initial attempt; but passed when "
+            "rerun to generate the explanation.";
+    }
+    ss << "\n  Actual: " << listener.str();
+    return AssertionFailure() << ss.str();
+  }
+
+ private:
+  const M matcher_;
+};
+
+// A helper function for converting a matcher to a predicate-formatter
+// without the user needing to explicitly write the type.  This is
+// used for implementing ASSERT_THAT() and EXPECT_THAT().
+// Implementation detail: 'matcher' is received by-value to force decaying.
+template <typename M>
+inline PredicateFormatterFromMatcher<M>
+MakePredicateFormatterFromMatcher(M matcher) {
+  return PredicateFormatterFromMatcher<M>(std::move(matcher));
+}
+
+// Implements the polymorphic IsNan() matcher, which matches any floating type
+// value that is Nan.
+class IsNanMatcher {
+ public:
+  template <typename FloatType>
+  bool MatchAndExplain(const FloatType& f,
+                       MatchResultListener* /* listener */) const {
+    return (::std::isnan)(f);
+  }
+
+  void DescribeTo(::std::ostream* os) const { *os << "is NaN"; }
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "isn't NaN";
+  }
+};
+
+// Implements the polymorphic floating point equality matcher, which matches
+// two float values using ULP-based approximation or, optionally, a
+// user-specified epsilon.  The template is meant to be instantiated with
+// FloatType being either float or double.
+template <typename FloatType>
+class FloatingEqMatcher {
+ public:
+  // Constructor for FloatingEqMatcher.
+  // The matcher's input will be compared with expected.  The matcher treats two
+  // NANs as equal if nan_eq_nan is true.  Otherwise, under IEEE standards,
+  // equality comparisons between NANs will always return false.  We specify a
+  // negative max_abs_error_ term to indicate that ULP-based approximation will
+  // be used for comparison.
+  FloatingEqMatcher(FloatType expected, bool nan_eq_nan) :
+    expected_(expected), nan_eq_nan_(nan_eq_nan), max_abs_error_(-1) {
+  }
+
+  // Constructor that supports a user-specified max_abs_error that will be used
+  // for comparison instead of ULP-based approximation.  The max absolute
+  // should be non-negative.
+  FloatingEqMatcher(FloatType expected, bool nan_eq_nan,
+                    FloatType max_abs_error)
+      : expected_(expected),
+        nan_eq_nan_(nan_eq_nan),
+        max_abs_error_(max_abs_error) {
+    GTEST_CHECK_(max_abs_error >= 0)
+        << ", where max_abs_error is" << max_abs_error;
+  }
+
+  // Implements floating point equality matcher as a Matcher<T>.
+  template <typename T>
+  class Impl : public MatcherInterface<T> {
+   public:
+    Impl(FloatType expected, bool nan_eq_nan, FloatType max_abs_error)
+        : expected_(expected),
+          nan_eq_nan_(nan_eq_nan),
+          max_abs_error_(max_abs_error) {}
+
+    bool MatchAndExplain(T value,
+                         MatchResultListener* listener) const override {
+      const FloatingPoint<FloatType> actual(value), expected(expected_);
+
+      // Compares NaNs first, if nan_eq_nan_ is true.
+      if (actual.is_nan() || expected.is_nan()) {
+        if (actual.is_nan() && expected.is_nan()) {
+          return nan_eq_nan_;
+        }
+        // One is nan; the other is not nan.
+        return false;
+      }
+      if (HasMaxAbsError()) {
+        // We perform an equality check so that inf will match inf, regardless
+        // of error bounds.  If the result of value - expected_ would result in
+        // overflow or if either value is inf, the default result is infinity,
+        // which should only match if max_abs_error_ is also infinity.
+        if (value == expected_) {
+          return true;
+        }
+
+        const FloatType diff = value - expected_;
+        if (::std::fabs(diff) <= max_abs_error_) {
+          return true;
+        }
+
+        if (listener->IsInterested()) {
+          *listener << "which is " << diff << " from " << expected_;
+        }
+        return false;
+      } else {
+        return actual.AlmostEquals(expected);
+      }
+    }
+
+    void DescribeTo(::std::ostream* os) const override {
+      // os->precision() returns the previously set precision, which we
+      // store to restore the ostream to its original configuration
+      // after outputting.
+      const ::std::streamsize old_precision = os->precision(
+          ::std::numeric_limits<FloatType>::digits10 + 2);
+      if (FloatingPoint<FloatType>(expected_).is_nan()) {
+        if (nan_eq_nan_) {
+          *os << "is NaN";
+        } else {
+          *os << "never matches";
+        }
+      } else {
+        *os << "is approximately " << expected_;
+        if (HasMaxAbsError()) {
+          *os << " (absolute error <= " << max_abs_error_ << ")";
+        }
+      }
+      os->precision(old_precision);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      // As before, get original precision.
+      const ::std::streamsize old_precision = os->precision(
+          ::std::numeric_limits<FloatType>::digits10 + 2);
+      if (FloatingPoint<FloatType>(expected_).is_nan()) {
+        if (nan_eq_nan_) {
+          *os << "isn't NaN";
+        } else {
+          *os << "is anything";
+        }
+      } else {
+        *os << "isn't approximately " << expected_;
+        if (HasMaxAbsError()) {
+          *os << " (absolute error > " << max_abs_error_ << ")";
+        }
+      }
+      // Restore original precision.
+      os->precision(old_precision);
+    }
+
+   private:
+    bool HasMaxAbsError() const {
+      return max_abs_error_ >= 0;
+    }
+
+    const FloatType expected_;
+    const bool nan_eq_nan_;
+    // max_abs_error will be used for value comparison when >= 0.
+    const FloatType max_abs_error_;
+  };
+
+  // The following 3 type conversion operators allow FloatEq(expected) and
+  // NanSensitiveFloatEq(expected) to be used as a Matcher<float>, a
+  // Matcher<const float&>, or a Matcher<float&>, but nothing else.
+  operator Matcher<FloatType>() const {
+    return MakeMatcher(
+        new Impl<FloatType>(expected_, nan_eq_nan_, max_abs_error_));
+  }
+
+  operator Matcher<const FloatType&>() const {
+    return MakeMatcher(
+        new Impl<const FloatType&>(expected_, nan_eq_nan_, max_abs_error_));
+  }
+
+  operator Matcher<FloatType&>() const {
+    return MakeMatcher(
+        new Impl<FloatType&>(expected_, nan_eq_nan_, max_abs_error_));
+  }
+
+ private:
+  const FloatType expected_;
+  const bool nan_eq_nan_;
+  // max_abs_error will be used for value comparison when >= 0.
+  const FloatType max_abs_error_;
+};
+
+// A 2-tuple ("binary") wrapper around FloatingEqMatcher:
+// FloatingEq2Matcher() matches (x, y) by matching FloatingEqMatcher(x, false)
+// against y, and FloatingEq2Matcher(e) matches FloatingEqMatcher(x, false, e)
+// against y. The former implements "Eq", the latter "Near". At present, there
+// is no version that compares NaNs as equal.
+template <typename FloatType>
+class FloatingEq2Matcher {
+ public:
+  FloatingEq2Matcher() { Init(-1, false); }
+
+  explicit FloatingEq2Matcher(bool nan_eq_nan) { Init(-1, nan_eq_nan); }
+
+  explicit FloatingEq2Matcher(FloatType max_abs_error) {
+    Init(max_abs_error, false);
+  }
+
+  FloatingEq2Matcher(FloatType max_abs_error, bool nan_eq_nan) {
+    Init(max_abs_error, nan_eq_nan);
+  }
+
+  template <typename T1, typename T2>
+  operator Matcher<::std::tuple<T1, T2>>() const {
+    return MakeMatcher(
+        new Impl<::std::tuple<T1, T2>>(max_abs_error_, nan_eq_nan_));
+  }
+  template <typename T1, typename T2>
+  operator Matcher<const ::std::tuple<T1, T2>&>() const {
+    return MakeMatcher(
+        new Impl<const ::std::tuple<T1, T2>&>(max_abs_error_, nan_eq_nan_));
+  }
+
+ private:
+  static ::std::ostream& GetDesc(::std::ostream& os) {  // NOLINT
+    return os << "an almost-equal pair";
+  }
+
+  template <typename Tuple>
+  class Impl : public MatcherInterface<Tuple> {
+   public:
+    Impl(FloatType max_abs_error, bool nan_eq_nan) :
+        max_abs_error_(max_abs_error),
+        nan_eq_nan_(nan_eq_nan) {}
+
+    bool MatchAndExplain(Tuple args,
+                         MatchResultListener* listener) const override {
+      if (max_abs_error_ == -1) {
+        FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_);
+        return static_cast<Matcher<FloatType>>(fm).MatchAndExplain(
+            ::std::get<1>(args), listener);
+      } else {
+        FloatingEqMatcher<FloatType> fm(::std::get<0>(args), nan_eq_nan_,
+                                        max_abs_error_);
+        return static_cast<Matcher<FloatType>>(fm).MatchAndExplain(
+            ::std::get<1>(args), listener);
+      }
+    }
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "are " << GetDesc;
+    }
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "aren't " << GetDesc;
+    }
+
+   private:
+    FloatType max_abs_error_;
+    const bool nan_eq_nan_;
+  };
+
+  void Init(FloatType max_abs_error_val, bool nan_eq_nan_val) {
+    max_abs_error_ = max_abs_error_val;
+    nan_eq_nan_ = nan_eq_nan_val;
+  }
+  FloatType max_abs_error_;
+  bool nan_eq_nan_;
+};
+
+// Implements the Pointee(m) matcher for matching a pointer whose
+// pointee matches matcher m.  The pointer can be either raw or smart.
+template <typename InnerMatcher>
+class PointeeMatcher {
+ public:
+  explicit PointeeMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}
+
+  // This type conversion operator template allows Pointee(m) to be
+  // used as a matcher for any pointer type whose pointee type is
+  // compatible with the inner matcher, where type Pointer can be
+  // either a raw pointer or a smart pointer.
+  //
+  // The reason we do this instead of relying on
+  // MakePolymorphicMatcher() is that the latter is not flexible
+  // enough for implementing the DescribeTo() method of Pointee().
+  template <typename Pointer>
+  operator Matcher<Pointer>() const {
+    return Matcher<Pointer>(new Impl<const Pointer&>(matcher_));
+  }
+
+ private:
+  // The monomorphic implementation that works for a particular pointer type.
+  template <typename Pointer>
+  class Impl : public MatcherInterface<Pointer> {
+   public:
+    using Pointee =
+        typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_(
+            Pointer)>::element_type;
+
+    explicit Impl(const InnerMatcher& matcher)
+        : matcher_(MatcherCast<const Pointee&>(matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "points to a value that ";
+      matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "does not point to a value that ";
+      matcher_.DescribeTo(os);
+    }
+
+    bool MatchAndExplain(Pointer pointer,
+                         MatchResultListener* listener) const override {
+      if (GetRawPointer(pointer) == nullptr) return false;
+
+      *listener << "which points to ";
+      return MatchPrintAndExplain(*pointer, matcher_, listener);
+    }
+
+   private:
+    const Matcher<const Pointee&> matcher_;
+  };
+
+  const InnerMatcher matcher_;
+};
+
+// Implements the Pointer(m) matcher
+// Implements the Pointer(m) matcher for matching a pointer that matches matcher
+// m.  The pointer can be either raw or smart, and will match `m` against the
+// raw pointer.
+template <typename InnerMatcher>
+class PointerMatcher {
+ public:
+  explicit PointerMatcher(const InnerMatcher& matcher) : matcher_(matcher) {}
+
+  // This type conversion operator template allows Pointer(m) to be
+  // used as a matcher for any pointer type whose pointer type is
+  // compatible with the inner matcher, where type PointerType can be
+  // either a raw pointer or a smart pointer.
+  //
+  // The reason we do this instead of relying on
+  // MakePolymorphicMatcher() is that the latter is not flexible
+  // enough for implementing the DescribeTo() method of Pointer().
+  template <typename PointerType>
+  operator Matcher<PointerType>() const {  // NOLINT
+    return Matcher<PointerType>(new Impl<const PointerType&>(matcher_));
+  }
+
+ private:
+  // The monomorphic implementation that works for a particular pointer type.
+  template <typename PointerType>
+  class Impl : public MatcherInterface<PointerType> {
+   public:
+    using Pointer =
+        const typename std::pointer_traits<GTEST_REMOVE_REFERENCE_AND_CONST_(
+            PointerType)>::element_type*;
+
+    explicit Impl(const InnerMatcher& matcher)
+        : matcher_(MatcherCast<Pointer>(matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "is a pointer that ";
+      matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "is not a pointer that ";
+      matcher_.DescribeTo(os);
+    }
+
+    bool MatchAndExplain(PointerType pointer,
+                         MatchResultListener* listener) const override {
+      *listener << "which is a pointer that ";
+      Pointer p = GetRawPointer(pointer);
+      return MatchPrintAndExplain(p, matcher_, listener);
+    }
+
+   private:
+    Matcher<Pointer> matcher_;
+  };
+
+  const InnerMatcher matcher_;
+};
+
+#if GTEST_HAS_RTTI
+// Implements the WhenDynamicCastTo<T>(m) matcher that matches a pointer or
+// reference that matches inner_matcher when dynamic_cast<T> is applied.
+// The result of dynamic_cast<To> is forwarded to the inner matcher.
+// If To is a pointer and the cast fails, the inner matcher will receive NULL.
+// If To is a reference and the cast fails, this matcher returns false
+// immediately.
+template <typename To>
+class WhenDynamicCastToMatcherBase {
+ public:
+  explicit WhenDynamicCastToMatcherBase(const Matcher<To>& matcher)
+      : matcher_(matcher) {}
+
+  void DescribeTo(::std::ostream* os) const {
+    GetCastTypeDescription(os);
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    GetCastTypeDescription(os);
+    matcher_.DescribeNegationTo(os);
+  }
+
+ protected:
+  const Matcher<To> matcher_;
+
+  static std::string GetToName() {
+    return GetTypeName<To>();
+  }
+
+ private:
+  static void GetCastTypeDescription(::std::ostream* os) {
+    *os << "when dynamic_cast to " << GetToName() << ", ";
+  }
+};
+
+// Primary template.
+// To is a pointer. Cast and forward the result.
+template <typename To>
+class WhenDynamicCastToMatcher : public WhenDynamicCastToMatcherBase<To> {
+ public:
+  explicit WhenDynamicCastToMatcher(const Matcher<To>& matcher)
+      : WhenDynamicCastToMatcherBase<To>(matcher) {}
+
+  template <typename From>
+  bool MatchAndExplain(From from, MatchResultListener* listener) const {
+    To to = dynamic_cast<To>(from);
+    return MatchPrintAndExplain(to, this->matcher_, listener);
+  }
+};
+
+// Specialize for references.
+// In this case we return false if the dynamic_cast fails.
+template <typename To>
+class WhenDynamicCastToMatcher<To&> : public WhenDynamicCastToMatcherBase<To&> {
+ public:
+  explicit WhenDynamicCastToMatcher(const Matcher<To&>& matcher)
+      : WhenDynamicCastToMatcherBase<To&>(matcher) {}
+
+  template <typename From>
+  bool MatchAndExplain(From& from, MatchResultListener* listener) const {
+    // We don't want an std::bad_cast here, so do the cast with pointers.
+    To* to = dynamic_cast<To*>(&from);
+    if (to == nullptr) {
+      *listener << "which cannot be dynamic_cast to " << this->GetToName();
+      return false;
+    }
+    return MatchPrintAndExplain(*to, this->matcher_, listener);
+  }
+};
+#endif  // GTEST_HAS_RTTI
+
+// Implements the Field() matcher for matching a field (i.e. member
+// variable) of an object.
+template <typename Class, typename FieldType>
+class FieldMatcher {
+ public:
+  FieldMatcher(FieldType Class::*field,
+               const Matcher<const FieldType&>& matcher)
+      : field_(field), matcher_(matcher), whose_field_("whose given field ") {}
+
+  FieldMatcher(const std::string& field_name, FieldType Class::*field,
+               const Matcher<const FieldType&>& matcher)
+      : field_(field),
+        matcher_(matcher),
+        whose_field_("whose field `" + field_name + "` ") {}
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "is an object " << whose_field_;
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is an object " << whose_field_;
+    matcher_.DescribeNegationTo(os);
+  }
+
+  template <typename T>
+  bool MatchAndExplain(const T& value, MatchResultListener* listener) const {
+    // FIXME: The dispatch on std::is_pointer was introduced as a workaround for
+    // a compiler bug, and can now be removed.
+    return MatchAndExplainImpl(
+        typename std::is_pointer<typename std::remove_const<T>::type>::type(),
+        value, listener);
+  }
+
+ private:
+  bool MatchAndExplainImpl(std::false_type /* is_not_pointer */,
+                           const Class& obj,
+                           MatchResultListener* listener) const {
+    *listener << whose_field_ << "is ";
+    return MatchPrintAndExplain(obj.*field_, matcher_, listener);
+  }
+
+  bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p,
+                           MatchResultListener* listener) const {
+    if (p == nullptr) return false;
+
+    *listener << "which points to an object ";
+    // Since *p has a field, it must be a class/struct/union type and
+    // thus cannot be a pointer.  Therefore we pass false_type() as
+    // the first argument.
+    return MatchAndExplainImpl(std::false_type(), *p, listener);
+  }
+
+  const FieldType Class::*field_;
+  const Matcher<const FieldType&> matcher_;
+
+  // Contains either "whose given field " if the name of the field is unknown
+  // or "whose field `name_of_field` " if the name is known.
+  const std::string whose_field_;
+};
+
+// Implements the Property() matcher for matching a property
+// (i.e. return value of a getter method) of an object.
+//
+// Property is a const-qualified member function of Class returning
+// PropertyType.
+template <typename Class, typename PropertyType, typename Property>
+class PropertyMatcher {
+ public:
+  typedef const PropertyType& RefToConstProperty;
+
+  PropertyMatcher(Property property, const Matcher<RefToConstProperty>& matcher)
+      : property_(property),
+        matcher_(matcher),
+        whose_property_("whose given property ") {}
+
+  PropertyMatcher(const std::string& property_name, Property property,
+                  const Matcher<RefToConstProperty>& matcher)
+      : property_(property),
+        matcher_(matcher),
+        whose_property_("whose property `" + property_name + "` ") {}
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "is an object " << whose_property_;
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is an object " << whose_property_;
+    matcher_.DescribeNegationTo(os);
+  }
+
+  template <typename T>
+  bool MatchAndExplain(const T&value, MatchResultListener* listener) const {
+    return MatchAndExplainImpl(
+        typename std::is_pointer<typename std::remove_const<T>::type>::type(),
+        value, listener);
+  }
+
+ private:
+  bool MatchAndExplainImpl(std::false_type /* is_not_pointer */,
+                           const Class& obj,
+                           MatchResultListener* listener) const {
+    *listener << whose_property_ << "is ";
+    // Cannot pass the return value (for example, int) to MatchPrintAndExplain,
+    // which takes a non-const reference as argument.
+    RefToConstProperty result = (obj.*property_)();
+    return MatchPrintAndExplain(result, matcher_, listener);
+  }
+
+  bool MatchAndExplainImpl(std::true_type /* is_pointer */, const Class* p,
+                           MatchResultListener* listener) const {
+    if (p == nullptr) return false;
+
+    *listener << "which points to an object ";
+    // Since *p has a property method, it must be a class/struct/union
+    // type and thus cannot be a pointer.  Therefore we pass
+    // false_type() as the first argument.
+    return MatchAndExplainImpl(std::false_type(), *p, listener);
+  }
+
+  Property property_;
+  const Matcher<RefToConstProperty> matcher_;
+
+  // Contains either "whose given property " if the name of the property is
+  // unknown or "whose property `name_of_property` " if the name is known.
+  const std::string whose_property_;
+};
+
+// Type traits specifying various features of different functors for ResultOf.
+// The default template specifies features for functor objects.
+template <typename Functor>
+struct CallableTraits {
+  typedef Functor StorageType;
+
+  static void CheckIsValid(Functor /* functor */) {}
+
+  template <typename T>
+  static auto Invoke(Functor f, const T& arg) -> decltype(f(arg)) {
+    return f(arg);
+  }
+};
+
+// Specialization for function pointers.
+template <typename ArgType, typename ResType>
+struct CallableTraits<ResType(*)(ArgType)> {
+  typedef ResType ResultType;
+  typedef ResType(*StorageType)(ArgType);
+
+  static void CheckIsValid(ResType(*f)(ArgType)) {
+    GTEST_CHECK_(f != nullptr)
+        << "NULL function pointer is passed into ResultOf().";
+  }
+  template <typename T>
+  static ResType Invoke(ResType(*f)(ArgType), T arg) {
+    return (*f)(arg);
+  }
+};
+
+// Implements the ResultOf() matcher for matching a return value of a
+// unary function of an object.
+template <typename Callable, typename InnerMatcher>
+class ResultOfMatcher {
+ public:
+  ResultOfMatcher(Callable callable, InnerMatcher matcher)
+      : callable_(std::move(callable)), matcher_(std::move(matcher)) {
+    CallableTraits<Callable>::CheckIsValid(callable_);
+  }
+
+  template <typename T>
+  operator Matcher<T>() const {
+    return Matcher<T>(new Impl<const T&>(callable_, matcher_));
+  }
+
+ private:
+  typedef typename CallableTraits<Callable>::StorageType CallableStorageType;
+
+  template <typename T>
+  class Impl : public MatcherInterface<T> {
+    using ResultType = decltype(CallableTraits<Callable>::template Invoke<T>(
+        std::declval<CallableStorageType>(), std::declval<T>()));
+
+   public:
+    template <typename M>
+    Impl(const CallableStorageType& callable, const M& matcher)
+        : callable_(callable), matcher_(MatcherCast<ResultType>(matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "is mapped by the given callable to a value that ";
+      matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "is mapped by the given callable to a value that ";
+      matcher_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(T obj, MatchResultListener* listener) const override {
+      *listener << "which is mapped by the given callable to ";
+      // Cannot pass the return value directly to MatchPrintAndExplain, which
+      // 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 =
+          CallableTraits<Callable>::template Invoke<T>(callable_, obj);
+      return MatchPrintAndExplain(result, matcher_, listener);
+    }
+
+   private:
+    // Functors often define operator() as non-const method even though
+    // they are actually stateless. But we need to use them even when
+    // 'this' is a const pointer. It's the user's responsibility not to
+    // use stateful callables with ResultOf(), which doesn't guarantee
+    // how many times the callable will be invoked.
+    mutable CallableStorageType callable_;
+    const Matcher<ResultType> matcher_;
+  };  // class Impl
+
+  const CallableStorageType callable_;
+  const InnerMatcher matcher_;
+};
+
+// Implements a matcher that checks the size of an STL-style container.
+template <typename SizeMatcher>
+class SizeIsMatcher {
+ public:
+  explicit SizeIsMatcher(const SizeMatcher& size_matcher)
+       : size_matcher_(size_matcher) {
+  }
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return Matcher<Container>(new Impl<const Container&>(size_matcher_));
+  }
+
+  template <typename Container>
+  class Impl : public MatcherInterface<Container> {
+   public:
+    using SizeType = decltype(std::declval<Container>().size());
+    explicit Impl(const SizeMatcher& size_matcher)
+        : size_matcher_(MatcherCast<SizeType>(size_matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "size ";
+      size_matcher_.DescribeTo(os);
+    }
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "size ";
+      size_matcher_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(Container container,
+                         MatchResultListener* listener) const override {
+      SizeType size = container.size();
+      StringMatchResultListener size_listener;
+      const bool result = size_matcher_.MatchAndExplain(size, &size_listener);
+      *listener
+          << "whose size " << size << (result ? " matches" : " doesn't match");
+      PrintIfNotEmpty(size_listener.str(), listener->stream());
+      return result;
+    }
+
+   private:
+    const Matcher<SizeType> size_matcher_;
+  };
+
+ private:
+  const SizeMatcher size_matcher_;
+};
+
+// Implements a matcher that checks the begin()..end() distance of an STL-style
+// container.
+template <typename DistanceMatcher>
+class BeginEndDistanceIsMatcher {
+ public:
+  explicit BeginEndDistanceIsMatcher(const DistanceMatcher& distance_matcher)
+      : distance_matcher_(distance_matcher) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return Matcher<Container>(new Impl<const Container&>(distance_matcher_));
+  }
+
+  template <typename Container>
+  class Impl : public MatcherInterface<Container> {
+   public:
+    typedef internal::StlContainerView<
+        GTEST_REMOVE_REFERENCE_AND_CONST_(Container)> ContainerView;
+    typedef typename std::iterator_traits<
+        typename ContainerView::type::const_iterator>::difference_type
+        DistanceType;
+    explicit Impl(const DistanceMatcher& distance_matcher)
+        : distance_matcher_(MatcherCast<DistanceType>(distance_matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "distance between begin() and end() ";
+      distance_matcher_.DescribeTo(os);
+    }
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "distance between begin() and end() ";
+      distance_matcher_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(Container container,
+                         MatchResultListener* listener) const override {
+      using std::begin;
+      using std::end;
+      DistanceType distance = std::distance(begin(container), end(container));
+      StringMatchResultListener distance_listener;
+      const bool result =
+          distance_matcher_.MatchAndExplain(distance, &distance_listener);
+      *listener << "whose distance between begin() and end() " << distance
+                << (result ? " matches" : " doesn't match");
+      PrintIfNotEmpty(distance_listener.str(), listener->stream());
+      return result;
+    }
+
+   private:
+    const Matcher<DistanceType> distance_matcher_;
+  };
+
+ private:
+  const DistanceMatcher distance_matcher_;
+};
+
+// Implements an equality matcher for any STL-style container whose elements
+// support ==. This matcher is like Eq(), but its failure explanations provide
+// more detailed information that is useful when the container is used as a set.
+// The failure message reports elements that are in one of the operands but not
+// the other. The failure messages do not report duplicate or out-of-order
+// elements in the containers (which don't properly matter to sets, but can
+// occur if the containers are vectors or lists, for example).
+//
+// Uses the container's const_iterator, value_type, operator ==,
+// begin(), and end().
+template <typename Container>
+class ContainerEqMatcher {
+ public:
+  typedef internal::StlContainerView<Container> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+
+  static_assert(!std::is_const<Container>::value,
+                "Container type must not be const");
+  static_assert(!std::is_reference<Container>::value,
+                "Container type must not be a reference");
+
+  // We make a copy of expected in case the elements in it are modified
+  // after this matcher is created.
+  explicit ContainerEqMatcher(const Container& expected)
+      : expected_(View::Copy(expected)) {}
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << "equals ";
+    UniversalPrint(expected_, os);
+  }
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "does not equal ";
+    UniversalPrint(expected_, os);
+  }
+
+  template <typename LhsContainer>
+  bool MatchAndExplain(const LhsContainer& lhs,
+                       MatchResultListener* listener) const {
+    typedef internal::StlContainerView<
+        typename std::remove_const<LhsContainer>::type>
+        LhsView;
+    typedef typename LhsView::type LhsStlContainer;
+    StlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
+    if (lhs_stl_container == expected_)
+      return true;
+
+    ::std::ostream* const os = listener->stream();
+    if (os != nullptr) {
+      // Something is different. Check for extra values first.
+      bool printed_header = false;
+      for (typename LhsStlContainer::const_iterator it =
+               lhs_stl_container.begin();
+           it != lhs_stl_container.end(); ++it) {
+        if (internal::ArrayAwareFind(expected_.begin(), expected_.end(), *it) ==
+            expected_.end()) {
+          if (printed_header) {
+            *os << ", ";
+          } else {
+            *os << "which has these unexpected elements: ";
+            printed_header = true;
+          }
+          UniversalPrint(*it, os);
+        }
+      }
+
+      // Now check for missing values.
+      bool printed_header2 = false;
+      for (typename StlContainer::const_iterator it = expected_.begin();
+           it != expected_.end(); ++it) {
+        if (internal::ArrayAwareFind(
+                lhs_stl_container.begin(), lhs_stl_container.end(), *it) ==
+            lhs_stl_container.end()) {
+          if (printed_header2) {
+            *os << ", ";
+          } else {
+            *os << (printed_header ? ",\nand" : "which")
+                << " doesn't have these expected elements: ";
+            printed_header2 = true;
+          }
+          UniversalPrint(*it, os);
+        }
+      }
+    }
+
+    return false;
+  }
+
+ private:
+  const StlContainer expected_;
+};
+
+// A comparator functor that uses the < operator to compare two values.
+struct LessComparator {
+  template <typename T, typename U>
+  bool operator()(const T& lhs, const U& rhs) const { return lhs < rhs; }
+};
+
+// Implements WhenSortedBy(comparator, container_matcher).
+template <typename Comparator, typename ContainerMatcher>
+class WhenSortedByMatcher {
+ public:
+  WhenSortedByMatcher(const Comparator& comparator,
+                      const ContainerMatcher& matcher)
+      : comparator_(comparator), matcher_(matcher) {}
+
+  template <typename LhsContainer>
+  operator Matcher<LhsContainer>() const {
+    return MakeMatcher(new Impl<LhsContainer>(comparator_, matcher_));
+  }
+
+  template <typename LhsContainer>
+  class Impl : public MatcherInterface<LhsContainer> {
+   public:
+    typedef internal::StlContainerView<
+         GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView;
+    typedef typename LhsView::type LhsStlContainer;
+    typedef typename LhsView::const_reference LhsStlContainerReference;
+    // Transforms std::pair<const Key, Value> into std::pair<Key, Value>
+    // so that we can match associative containers.
+    typedef typename RemoveConstFromKey<
+        typename LhsStlContainer::value_type>::type LhsValue;
+
+    Impl(const Comparator& comparator, const ContainerMatcher& matcher)
+        : comparator_(comparator), matcher_(matcher) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "(when sorted) ";
+      matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "(when sorted) ";
+      matcher_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(LhsContainer lhs,
+                         MatchResultListener* listener) const override {
+      LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
+      ::std::vector<LhsValue> sorted_container(lhs_stl_container.begin(),
+                                               lhs_stl_container.end());
+      ::std::sort(
+           sorted_container.begin(), sorted_container.end(), comparator_);
+
+      if (!listener->IsInterested()) {
+        // If the listener is not interested, we do not need to
+        // construct the inner explanation.
+        return matcher_.Matches(sorted_container);
+      }
+
+      *listener << "which is ";
+      UniversalPrint(sorted_container, listener->stream());
+      *listener << " when sorted";
+
+      StringMatchResultListener inner_listener;
+      const bool match = matcher_.MatchAndExplain(sorted_container,
+                                                  &inner_listener);
+      PrintIfNotEmpty(inner_listener.str(), listener->stream());
+      return match;
+    }
+
+   private:
+    const Comparator comparator_;
+    const Matcher<const ::std::vector<LhsValue>&> matcher_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
+  };
+
+ private:
+  const Comparator comparator_;
+  const ContainerMatcher matcher_;
+};
+
+// Implements Pointwise(tuple_matcher, rhs_container).  tuple_matcher
+// must be able to be safely cast to Matcher<std::tuple<const T1&, const
+// T2&> >, where T1 and T2 are the types of elements in the LHS
+// container and the RHS container respectively.
+template <typename TupleMatcher, typename RhsContainer>
+class PointwiseMatcher {
+  GTEST_COMPILE_ASSERT_(
+      !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(RhsContainer)>::value,
+      use_UnorderedPointwise_with_hash_tables);
+
+ public:
+  typedef internal::StlContainerView<RhsContainer> RhsView;
+  typedef typename RhsView::type RhsStlContainer;
+  typedef typename RhsStlContainer::value_type RhsValue;
+
+  static_assert(!std::is_const<RhsContainer>::value,
+                "RhsContainer type must not be const");
+  static_assert(!std::is_reference<RhsContainer>::value,
+                "RhsContainer type must not be a reference");
+
+  // Like ContainerEq, we make a copy of rhs in case the elements in
+  // it are modified after this matcher is created.
+  PointwiseMatcher(const TupleMatcher& tuple_matcher, const RhsContainer& rhs)
+      : tuple_matcher_(tuple_matcher), rhs_(RhsView::Copy(rhs)) {}
+
+  template <typename LhsContainer>
+  operator Matcher<LhsContainer>() const {
+    GTEST_COMPILE_ASSERT_(
+        !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)>::value,
+        use_UnorderedPointwise_with_hash_tables);
+
+    return Matcher<LhsContainer>(
+        new Impl<const LhsContainer&>(tuple_matcher_, rhs_));
+  }
+
+  template <typename LhsContainer>
+  class Impl : public MatcherInterface<LhsContainer> {
+   public:
+    typedef internal::StlContainerView<
+         GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)> LhsView;
+    typedef typename LhsView::type LhsStlContainer;
+    typedef typename LhsView::const_reference LhsStlContainerReference;
+    typedef typename LhsStlContainer::value_type LhsValue;
+    // We pass the LHS value and the RHS value to the inner matcher by
+    // reference, as they may be expensive to copy.  We must use tuple
+    // instead of pair here, as a pair cannot hold references (C++ 98,
+    // 20.2.2 [lib.pairs]).
+    typedef ::std::tuple<const LhsValue&, const RhsValue&> InnerMatcherArg;
+
+    Impl(const TupleMatcher& tuple_matcher, const RhsStlContainer& rhs)
+        // mono_tuple_matcher_ holds a monomorphic version of the tuple matcher.
+        : mono_tuple_matcher_(SafeMatcherCast<InnerMatcherArg>(tuple_matcher)),
+          rhs_(rhs) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "contains " << rhs_.size()
+          << " values, where each value and its corresponding value in ";
+      UniversalPrinter<RhsStlContainer>::Print(rhs_, os);
+      *os << " ";
+      mono_tuple_matcher_.DescribeTo(os);
+    }
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "doesn't contain exactly " << rhs_.size()
+          << " values, or contains a value x at some index i"
+          << " where x and the i-th value of ";
+      UniversalPrint(rhs_, os);
+      *os << " ";
+      mono_tuple_matcher_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(LhsContainer lhs,
+                         MatchResultListener* listener) const override {
+      LhsStlContainerReference lhs_stl_container = LhsView::ConstReference(lhs);
+      const size_t actual_size = lhs_stl_container.size();
+      if (actual_size != rhs_.size()) {
+        *listener << "which contains " << actual_size << " values";
+        return false;
+      }
+
+      typename LhsStlContainer::const_iterator left = lhs_stl_container.begin();
+      typename RhsStlContainer::const_iterator right = rhs_.begin();
+      for (size_t i = 0; i != actual_size; ++i, ++left, ++right) {
+        if (listener->IsInterested()) {
+          StringMatchResultListener inner_listener;
+          // Create InnerMatcherArg as a temporarily object to avoid it outlives
+          // *left and *right. Dereference or the conversion to `const T&` may
+          // return temp objects, e.g for vector<bool>.
+          if (!mono_tuple_matcher_.MatchAndExplain(
+                  InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left),
+                                  ImplicitCast_<const RhsValue&>(*right)),
+                  &inner_listener)) {
+            *listener << "where the value pair (";
+            UniversalPrint(*left, listener->stream());
+            *listener << ", ";
+            UniversalPrint(*right, listener->stream());
+            *listener << ") at index #" << i << " don't match";
+            PrintIfNotEmpty(inner_listener.str(), listener->stream());
+            return false;
+          }
+        } else {
+          if (!mono_tuple_matcher_.Matches(
+                  InnerMatcherArg(ImplicitCast_<const LhsValue&>(*left),
+                                  ImplicitCast_<const RhsValue&>(*right))))
+            return false;
+        }
+      }
+
+      return true;
+    }
+
+   private:
+    const Matcher<InnerMatcherArg> mono_tuple_matcher_;
+    const RhsStlContainer rhs_;
+  };
+
+ private:
+  const TupleMatcher tuple_matcher_;
+  const RhsStlContainer rhs_;
+};
+
+// Holds the logic common to ContainsMatcherImpl and EachMatcherImpl.
+template <typename Container>
+class QuantifierMatcherImpl : public MatcherInterface<Container> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+  typedef StlContainerView<RawContainer> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+  typedef typename StlContainer::value_type Element;
+
+  template <typename InnerMatcher>
+  explicit QuantifierMatcherImpl(InnerMatcher inner_matcher)
+      : inner_matcher_(
+           testing::SafeMatcherCast<const Element&>(inner_matcher)) {}
+
+  // Checks whether:
+  // * All elements in the container match, if all_elements_should_match.
+  // * Any element in the container matches, if !all_elements_should_match.
+  bool MatchAndExplainImpl(bool all_elements_should_match,
+                           Container container,
+                           MatchResultListener* listener) const {
+    StlContainerReference stl_container = View::ConstReference(container);
+    size_t i = 0;
+    for (typename StlContainer::const_iterator it = stl_container.begin();
+         it != stl_container.end(); ++it, ++i) {
+      StringMatchResultListener inner_listener;
+      const bool matches = inner_matcher_.MatchAndExplain(*it, &inner_listener);
+
+      if (matches != all_elements_should_match) {
+        *listener << "whose element #" << i
+                  << (matches ? " matches" : " doesn't match");
+        PrintIfNotEmpty(inner_listener.str(), listener->stream());
+        return !all_elements_should_match;
+      }
+    }
+    return all_elements_should_match;
+  }
+
+ protected:
+  const Matcher<const Element&> inner_matcher_;
+};
+
+// Implements Contains(element_matcher) for the given argument type Container.
+// Symmetric to EachMatcherImpl.
+template <typename Container>
+class ContainsMatcherImpl : public QuantifierMatcherImpl<Container> {
+ public:
+  template <typename InnerMatcher>
+  explicit ContainsMatcherImpl(InnerMatcher inner_matcher)
+      : QuantifierMatcherImpl<Container>(inner_matcher) {}
+
+  // Describes what this matcher does.
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "contains at least one element that ";
+    this->inner_matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "doesn't contain any element that ";
+    this->inner_matcher_.DescribeTo(os);
+  }
+
+  bool MatchAndExplain(Container container,
+                       MatchResultListener* listener) const override {
+    return this->MatchAndExplainImpl(false, container, listener);
+  }
+};
+
+// Implements Each(element_matcher) for the given argument type Container.
+// Symmetric to ContainsMatcherImpl.
+template <typename Container>
+class EachMatcherImpl : public QuantifierMatcherImpl<Container> {
+ public:
+  template <typename InnerMatcher>
+  explicit EachMatcherImpl(InnerMatcher inner_matcher)
+      : QuantifierMatcherImpl<Container>(inner_matcher) {}
+
+  // Describes what this matcher does.
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "only contains elements that ";
+    this->inner_matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "contains some element that ";
+    this->inner_matcher_.DescribeNegationTo(os);
+  }
+
+  bool MatchAndExplain(Container container,
+                       MatchResultListener* listener) const override {
+    return this->MatchAndExplainImpl(true, container, listener);
+  }
+};
+
+// Implements polymorphic Contains(element_matcher).
+template <typename M>
+class ContainsMatcher {
+ public:
+  explicit ContainsMatcher(M m) : inner_matcher_(m) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return Matcher<Container>(
+        new ContainsMatcherImpl<const Container&>(inner_matcher_));
+  }
+
+ private:
+  const M inner_matcher_;
+};
+
+// Implements polymorphic Each(element_matcher).
+template <typename M>
+class EachMatcher {
+ public:
+  explicit EachMatcher(M m) : inner_matcher_(m) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return Matcher<Container>(
+        new EachMatcherImpl<const Container&>(inner_matcher_));
+  }
+
+ private:
+  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
+  return get<0>(x);
+}
+template <typename T>
+auto First(T& x, Rank0) -> decltype((x.first)) {  // NOLINT
+  return x.first;
+}
+
+template <typename T>
+auto Second(T& x, Rank1) -> decltype(get<1>(x)) {  // NOLINT
+  return get<1>(x);
+}
+template <typename T>
+auto Second(T& x, Rank0) -> decltype((x.second)) {  // NOLINT
+  return x.second;
+}
+}  // namespace pair_getters
+
+// Implements Key(inner_matcher) for the given argument pair type.
+// Key(inner_matcher) matches an std::pair whose 'first' field matches
+// inner_matcher.  For example, Contains(Key(Ge(5))) can be used to match an
+// std::map that contains at least one element whose key is >= 5.
+template <typename PairType>
+class KeyMatcherImpl : public MatcherInterface<PairType> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;
+  typedef typename RawPairType::first_type KeyType;
+
+  template <typename InnerMatcher>
+  explicit KeyMatcherImpl(InnerMatcher inner_matcher)
+      : inner_matcher_(
+          testing::SafeMatcherCast<const KeyType&>(inner_matcher)) {
+  }
+
+  // Returns true if and only if 'key_value.first' (the key) matches the inner
+  // matcher.
+  bool MatchAndExplain(PairType key_value,
+                       MatchResultListener* listener) const override {
+    StringMatchResultListener inner_listener;
+    const bool match = inner_matcher_.MatchAndExplain(
+        pair_getters::First(key_value, Rank0()), &inner_listener);
+    const std::string explanation = inner_listener.str();
+    if (explanation != "") {
+      *listener << "whose first field is a value " << explanation;
+    }
+    return match;
+  }
+
+  // Describes what this matcher does.
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "has a key that ";
+    inner_matcher_.DescribeTo(os);
+  }
+
+  // Describes what the negation of this matcher does.
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "doesn't have a key that ";
+    inner_matcher_.DescribeTo(os);
+  }
+
+ private:
+  const Matcher<const KeyType&> inner_matcher_;
+};
+
+// Implements polymorphic Key(matcher_for_key).
+template <typename M>
+class KeyMatcher {
+ public:
+  explicit KeyMatcher(M m) : matcher_for_key_(m) {}
+
+  template <typename PairType>
+  operator Matcher<PairType>() const {
+    return Matcher<PairType>(
+        new KeyMatcherImpl<const PairType&>(matcher_for_key_));
+  }
+
+ private:
+  const M matcher_for_key_;
+};
+
+// Implements polymorphic Address(matcher_for_address).
+template <typename InnerMatcher>
+class AddressMatcher {
+ public:
+  explicit AddressMatcher(InnerMatcher m) : matcher_(m) {}
+
+  template <typename Type>
+  operator Matcher<Type>() const {  // NOLINT
+    return Matcher<Type>(new Impl<const Type&>(matcher_));
+  }
+
+ private:
+  // The monomorphic implementation that works for a particular object type.
+  template <typename Type>
+  class Impl : public MatcherInterface<Type> {
+   public:
+    using Address = const GTEST_REMOVE_REFERENCE_AND_CONST_(Type) *;
+    explicit Impl(const InnerMatcher& matcher)
+        : matcher_(MatcherCast<Address>(matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "has address that ";
+      matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "does not have address that ";
+      matcher_.DescribeTo(os);
+    }
+
+    bool MatchAndExplain(Type object,
+                         MatchResultListener* listener) const override {
+      *listener << "which has address ";
+      Address address = std::addressof(object);
+      return MatchPrintAndExplain(address, matcher_, listener);
+    }
+
+   private:
+    const Matcher<Address> matcher_;
+  };
+  const InnerMatcher matcher_;
+};
+
+// Implements Pair(first_matcher, second_matcher) for the given argument pair
+// type with its two matchers. See Pair() function below.
+template <typename PairType>
+class PairMatcherImpl : public MatcherInterface<PairType> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(PairType) RawPairType;
+  typedef typename RawPairType::first_type FirstType;
+  typedef typename RawPairType::second_type SecondType;
+
+  template <typename FirstMatcher, typename SecondMatcher>
+  PairMatcherImpl(FirstMatcher first_matcher, SecondMatcher second_matcher)
+      : first_matcher_(
+            testing::SafeMatcherCast<const FirstType&>(first_matcher)),
+        second_matcher_(
+            testing::SafeMatcherCast<const SecondType&>(second_matcher)) {
+  }
+
+  // Describes what this matcher does.
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "has a first field that ";
+    first_matcher_.DescribeTo(os);
+    *os << ", and has a second field that ";
+    second_matcher_.DescribeTo(os);
+  }
+
+  // Describes what the negation of this matcher does.
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "has a first field that ";
+    first_matcher_.DescribeNegationTo(os);
+    *os << ", or has a second field that ";
+    second_matcher_.DescribeNegationTo(os);
+  }
+
+  // Returns true if and only if 'a_pair.first' matches first_matcher and
+  // 'a_pair.second' matches second_matcher.
+  bool MatchAndExplain(PairType a_pair,
+                       MatchResultListener* listener) const override {
+    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()));
+    }
+    StringMatchResultListener first_inner_listener;
+    if (!first_matcher_.MatchAndExplain(pair_getters::First(a_pair, Rank0()),
+                                        &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()),
+                                         &second_inner_listener)) {
+      *listener << "whose second field does not match";
+      PrintIfNotEmpty(second_inner_listener.str(), listener->stream());
+      return false;
+    }
+    ExplainSuccess(first_inner_listener.str(), second_inner_listener.str(),
+                   listener);
+    return true;
+  }
+
+ private:
+  void ExplainSuccess(const std::string& first_explanation,
+                      const std::string& second_explanation,
+                      MatchResultListener* listener) const {
+    *listener << "whose both fields match";
+    if (first_explanation != "") {
+      *listener << ", where the first field is a value " << first_explanation;
+    }
+    if (second_explanation != "") {
+      *listener << ", ";
+      if (first_explanation != "") {
+        *listener << "and ";
+      } else {
+        *listener << "where ";
+      }
+      *listener << "the second field is a value " << second_explanation;
+    }
+  }
+
+  const Matcher<const FirstType&> first_matcher_;
+  const Matcher<const SecondType&> second_matcher_;
+};
+
+// Implements polymorphic Pair(first_matcher, second_matcher).
+template <typename FirstMatcher, typename SecondMatcher>
+class PairMatcher {
+ public:
+  PairMatcher(FirstMatcher first_matcher, SecondMatcher second_matcher)
+      : first_matcher_(first_matcher), second_matcher_(second_matcher) {}
+
+  template <typename PairType>
+  operator Matcher<PairType> () const {
+    return Matcher<PairType>(
+        new PairMatcherImpl<const PairType&>(first_matcher_, second_matcher_));
+  }
+
+ private:
+  const FirstMatcher first_matcher_;
+  const SecondMatcher second_matcher_;
+};
+
+template <typename T, size_t... I>
+auto UnpackStructImpl(const T& t, IndexSequence<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)...);
+}
+
+#if defined(__cpp_structured_bindings) && __cpp_structured_bindings >= 201606
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<1>, char) {
+  const auto& [a] = t;
+  return std::tie(a);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<2>, char) {
+  const auto& [a, b] = t;
+  return std::tie(a, b);
+}
+template <typename T>
+auto UnpackStructImpl(const T& t, MakeIndexSequence<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) {
+  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) {
+  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) {
+  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) {
+  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) {
+  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) {
+  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) {
+  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) {
+  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) {
+  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) {
+  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) {
+  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) {
+  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) {
+  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);
+}
+#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);
+}
+
+// Helper function to do comma folding in C++11.
+// The array ensures left-to-right order of evaluation.
+// Usage: VariadicExpand({expr...});
+template <typename T, size_t N>
+void VariadicExpand(const T (&)[N]) {}
+
+template <typename Struct, typename StructSize>
+class FieldsAreMatcherImpl;
+
+template <typename Struct, size_t... I>
+class FieldsAreMatcherImpl<Struct, IndexSequence<I...>>
+    : public MatcherInterface<Struct> {
+  using UnpackedType =
+      decltype(UnpackStruct<sizeof...(I)>(std::declval<const Struct&>()));
+  using MatchersType = std::tuple<
+      Matcher<const typename std::tuple_element<I, UnpackedType>::type&>...>;
+
+ public:
+  template <typename Inner>
+  explicit FieldsAreMatcherImpl(const Inner& matchers)
+      : matchers_(testing::SafeMatcherCast<
+                  const typename std::tuple_element<I, UnpackedType>::type&>(
+            std::get<I>(matchers))...) {}
+
+  void DescribeTo(::std::ostream* os) const override {
+    const char* separator = "";
+    VariadicExpand(
+        {(*os << separator << "has field #" << I << " that ",
+          std::get<I>(matchers_).DescribeTo(os), separator = ", and ")...});
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    const char* separator = "";
+    VariadicExpand({(*os << separator << "has field #" << I << " that ",
+                     std::get<I>(matchers_).DescribeNegationTo(os),
+                     separator = ", or ")...});
+  }
+
+  bool MatchAndExplain(Struct t, MatchResultListener* listener) const override {
+    return MatchInternal((UnpackStruct<sizeof...(I)>)(t), listener);
+  }
+
+ private:
+  bool MatchInternal(UnpackedType tuple, MatchResultListener* listener) const {
+    if (!listener->IsInterested()) {
+      // If the listener is not interested, we don't need to construct the
+      // explanation.
+      bool good = true;
+      VariadicExpand({good = good && std::get<I>(matchers_).Matches(
+                                         std::get<I>(tuple))...});
+      return good;
+    }
+
+    size_t failed_pos = ~size_t{};
+
+    std::vector<StringMatchResultListener> inner_listener(sizeof...(I));
+
+    VariadicExpand(
+        {failed_pos == ~size_t{} && !std::get<I>(matchers_).MatchAndExplain(
+                                        std::get<I>(tuple), &inner_listener[I])
+             ? failed_pos = I
+             : 0 ...});
+    if (failed_pos != ~size_t{}) {
+      *listener << "whose field #" << failed_pos << " does not match";
+      PrintIfNotEmpty(inner_listener[failed_pos].str(), listener->stream());
+      return false;
+    }
+
+    *listener << "whose all elements match";
+    const char* separator = ", where";
+    for (size_t index = 0; index < sizeof...(I); ++index) {
+      const std::string str = inner_listener[index].str();
+      if (!str.empty()) {
+        *listener << separator << " field #" << index << " is a value " << str;
+        separator = ", and";
+      }
+    }
+
+    return true;
+  }
+
+  MatchersType matchers_;
+};
+
+template <typename... Inner>
+class FieldsAreMatcher {
+ public:
+  explicit FieldsAreMatcher(Inner... inner) : matchers_(std::move(inner)...) {}
+
+  template <typename Struct>
+  operator Matcher<Struct>() const {  // NOLINT
+    return Matcher<Struct>(
+        new FieldsAreMatcherImpl<const Struct&, IndexSequenceFor<Inner...>>(
+            matchers_));
+  }
+
+ private:
+  std::tuple<Inner...> matchers_;
+};
+
+// Implements ElementsAre() and ElementsAreArray().
+template <typename Container>
+class ElementsAreMatcherImpl : public MatcherInterface<Container> {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+  typedef internal::StlContainerView<RawContainer> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+  typedef typename StlContainer::value_type Element;
+
+  // Constructs the matcher from a sequence of element values or
+  // element matchers.
+  template <typename InputIter>
+  ElementsAreMatcherImpl(InputIter first, InputIter last) {
+    while (first != last) {
+      matchers_.push_back(MatcherCast<const Element&>(*first++));
+    }
+  }
+
+  // Describes what this matcher does.
+  void DescribeTo(::std::ostream* os) const override {
+    if (count() == 0) {
+      *os << "is empty";
+    } else if (count() == 1) {
+      *os << "has 1 element that ";
+      matchers_[0].DescribeTo(os);
+    } else {
+      *os << "has " << Elements(count()) << " where\n";
+      for (size_t i = 0; i != count(); ++i) {
+        *os << "element #" << i << " ";
+        matchers_[i].DescribeTo(os);
+        if (i + 1 < count()) {
+          *os << ",\n";
+        }
+      }
+    }
+  }
+
+  // Describes what the negation of this matcher does.
+  void DescribeNegationTo(::std::ostream* os) const override {
+    if (count() == 0) {
+      *os << "isn't empty";
+      return;
+    }
+
+    *os << "doesn't have " << Elements(count()) << ", or\n";
+    for (size_t i = 0; i != count(); ++i) {
+      *os << "element #" << i << " ";
+      matchers_[i].DescribeNegationTo(os);
+      if (i + 1 < count()) {
+        *os << ", or\n";
+      }
+    }
+  }
+
+  bool MatchAndExplain(Container container,
+                       MatchResultListener* listener) const override {
+    // To work with stream-like "containers", we must only walk
+    // through the elements in one pass.
+
+    const bool listener_interested = listener->IsInterested();
+
+    // explanations[i] is the explanation of the element at index i.
+    ::std::vector<std::string> explanations(count());
+    StlContainerReference stl_container = View::ConstReference(container);
+    typename StlContainer::const_iterator it = stl_container.begin();
+    size_t exam_pos = 0;
+    bool mismatch_found = false;  // Have we found a mismatched element yet?
+
+    // Go through the elements and matchers in pairs, until we reach
+    // the end of either the elements or the matchers, or until we find a
+    // mismatch.
+    for (; it != stl_container.end() && exam_pos != count(); ++it, ++exam_pos) {
+      bool match;  // Does the current element match the current matcher?
+      if (listener_interested) {
+        StringMatchResultListener s;
+        match = matchers_[exam_pos].MatchAndExplain(*it, &s);
+        explanations[exam_pos] = s.str();
+      } else {
+        match = matchers_[exam_pos].Matches(*it);
+      }
+
+      if (!match) {
+        mismatch_found = true;
+        break;
+      }
+    }
+    // If mismatch_found is true, 'exam_pos' is the index of the mismatch.
+
+    // Find how many elements the actual container has.  We avoid
+    // calling size() s.t. this code works for stream-like "containers"
+    // that don't define size().
+    size_t actual_count = exam_pos;
+    for (; it != stl_container.end(); ++it) {
+      ++actual_count;
+    }
+
+    if (actual_count != count()) {
+      // 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 (listener_interested && (actual_count != 0)) {
+        *listener << "which has " << Elements(actual_count);
+      }
+      return false;
+    }
+
+    if (mismatch_found) {
+      // The element count matches, but the exam_pos-th element doesn't match.
+      if (listener_interested) {
+        *listener << "whose element #" << exam_pos << " doesn't match";
+        PrintIfNotEmpty(explanations[exam_pos], listener->stream());
+      }
+      return false;
+    }
+
+    // Every element matches its expectation.  We need to explain why
+    // (the obvious ones can be skipped).
+    if (listener_interested) {
+      bool reason_printed = false;
+      for (size_t i = 0; i != count(); ++i) {
+        const std::string& s = explanations[i];
+        if (!s.empty()) {
+          if (reason_printed) {
+            *listener << ",\nand ";
+          }
+          *listener << "whose element #" << i << " matches, " << s;
+          reason_printed = true;
+        }
+      }
+    }
+    return true;
+  }
+
+ private:
+  static Message Elements(size_t count) {
+    return Message() << count << (count == 1 ? " element" : " elements");
+  }
+
+  size_t count() const { return matchers_.size(); }
+
+  ::std::vector<Matcher<const Element&> > matchers_;
+};
+
+// Connectivity matrix of (elements X matchers), in element-major order.
+// Initially, there are no edges.
+// Use NextGraph() to iterate over all possible edge configurations.
+// Use Randomize() to generate a random edge configuration.
+class GTEST_API_ MatchMatrix {
+ public:
+  MatchMatrix(size_t num_elements, size_t num_matchers)
+      : num_elements_(num_elements),
+        num_matchers_(num_matchers),
+        matched_(num_elements_* num_matchers_, 0) {
+  }
+
+  size_t LhsSize() const { return num_elements_; }
+  size_t RhsSize() const { return num_matchers_; }
+  bool HasEdge(size_t ilhs, size_t irhs) const {
+    return matched_[SpaceIndex(ilhs, irhs)] == 1;
+  }
+  void SetEdge(size_t ilhs, size_t irhs, bool b) {
+    matched_[SpaceIndex(ilhs, irhs)] = b ? 1 : 0;
+  }
+
+  // Treating the connectivity matrix as a (LhsSize()*RhsSize())-bit number,
+  // adds 1 to that number; returns false if incrementing the graph left it
+  // empty.
+  bool NextGraph();
+
+  void Randomize();
+
+  std::string DebugString() const;
+
+ private:
+  size_t SpaceIndex(size_t ilhs, size_t irhs) const {
+    return ilhs * num_matchers_ + irhs;
+  }
+
+  size_t num_elements_;
+  size_t num_matchers_;
+
+  // Each element is a char interpreted as bool. They are stored as a
+  // flattened array in lhs-major order, use 'SpaceIndex()' to translate
+  // a (ilhs, irhs) matrix coordinate into an offset.
+  ::std::vector<char> matched_;
+};
+
+typedef ::std::pair<size_t, size_t> ElementMatcherPair;
+typedef ::std::vector<ElementMatcherPair> ElementMatcherPairs;
+
+// Returns a maximum bipartite matching for the specified graph 'g'.
+// The matching is represented as a vector of {element, matcher} pairs.
+GTEST_API_ ElementMatcherPairs
+FindMaxBipartiteMatching(const MatchMatrix& g);
+
+struct UnorderedMatcherRequire {
+  enum Flags {
+    Superset = 1 << 0,
+    Subset = 1 << 1,
+    ExactMatch = Superset | Subset,
+  };
+};
+
+// Untyped base class for implementing UnorderedElementsAre.  By
+// putting logic that's not specific to the element type here, we
+// reduce binary bloat and increase compilation speed.
+class GTEST_API_ UnorderedElementsAreMatcherImplBase {
+ protected:
+  explicit UnorderedElementsAreMatcherImplBase(
+      UnorderedMatcherRequire::Flags matcher_flags)
+      : match_flags_(matcher_flags) {}
+
+  // A vector of matcher describers, one for each element matcher.
+  // Does not own the describers (and thus can be used only when the
+  // element matchers are alive).
+  typedef ::std::vector<const MatcherDescriberInterface*> MatcherDescriberVec;
+
+  // Describes this UnorderedElementsAre matcher.
+  void DescribeToImpl(::std::ostream* os) const;
+
+  // Describes the negation of this UnorderedElementsAre matcher.
+  void DescribeNegationToImpl(::std::ostream* os) const;
+
+  bool VerifyMatchMatrix(const ::std::vector<std::string>& element_printouts,
+                         const MatchMatrix& matrix,
+                         MatchResultListener* listener) const;
+
+  bool FindPairing(const MatchMatrix& matrix,
+                   MatchResultListener* listener) const;
+
+  MatcherDescriberVec& matcher_describers() {
+    return matcher_describers_;
+  }
+
+  static Message Elements(size_t n) {
+    return Message() << n << " element" << (n == 1 ? "" : "s");
+  }
+
+  UnorderedMatcherRequire::Flags match_flags() const { return match_flags_; }
+
+ private:
+  UnorderedMatcherRequire::Flags match_flags_;
+  MatcherDescriberVec matcher_describers_;
+};
+
+// Implements UnorderedElementsAre, UnorderedElementsAreArray, IsSubsetOf, and
+// IsSupersetOf.
+template <typename Container>
+class UnorderedElementsAreMatcherImpl
+    : public MatcherInterface<Container>,
+      public UnorderedElementsAreMatcherImplBase {
+ public:
+  typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+  typedef internal::StlContainerView<RawContainer> View;
+  typedef typename View::type StlContainer;
+  typedef typename View::const_reference StlContainerReference;
+  typedef typename StlContainer::const_iterator StlContainerConstIterator;
+  typedef typename StlContainer::value_type Element;
+
+  template <typename InputIter>
+  UnorderedElementsAreMatcherImpl(UnorderedMatcherRequire::Flags matcher_flags,
+                                  InputIter first, InputIter last)
+      : UnorderedElementsAreMatcherImplBase(matcher_flags) {
+    for (; first != last; ++first) {
+      matchers_.push_back(MatcherCast<const Element&>(*first));
+    }
+    for (const auto& m : matchers_) {
+      matcher_describers().push_back(m.GetDescriber());
+    }
+  }
+
+  // Describes what this matcher does.
+  void DescribeTo(::std::ostream* os) const override {
+    return UnorderedElementsAreMatcherImplBase::DescribeToImpl(os);
+  }
+
+  // Describes what the negation of this matcher does.
+  void DescribeNegationTo(::std::ostream* os) const override {
+    return UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(os);
+  }
+
+  bool MatchAndExplain(Container container,
+                       MatchResultListener* listener) const override {
+    StlContainerReference stl_container = View::ConstReference(container);
+    ::std::vector<std::string> element_printouts;
+    MatchMatrix matrix =
+        AnalyzeElements(stl_container.begin(), stl_container.end(),
+                        &element_printouts, listener);
+
+    if (matrix.LhsSize() == 0 && matrix.RhsSize() == 0) {
+      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;
+      }
+    }
+
+    return VerifyMatchMatrix(element_printouts, matrix, listener) &&
+           FindPairing(matrix, listener);
+  }
+
+ private:
+  template <typename ElementIter>
+  MatchMatrix AnalyzeElements(ElementIter elem_first, ElementIter elem_last,
+                              ::std::vector<std::string>* element_printouts,
+                              MatchResultListener* listener) const {
+    element_printouts->clear();
+    ::std::vector<char> did_match;
+    size_t num_elements = 0;
+    DummyMatchResultListener dummy;
+    for (; elem_first != elem_last; ++num_elements, ++elem_first) {
+      if (listener->IsInterested()) {
+        element_printouts->push_back(PrintToString(*elem_first));
+      }
+      for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) {
+        did_match.push_back(
+            matchers_[irhs].MatchAndExplain(*elem_first, &dummy));
+      }
+    }
+
+    MatchMatrix matrix(num_elements, matchers_.size());
+    ::std::vector<char>::const_iterator did_match_iter = did_match.begin();
+    for (size_t ilhs = 0; ilhs != num_elements; ++ilhs) {
+      for (size_t irhs = 0; irhs != matchers_.size(); ++irhs) {
+        matrix.SetEdge(ilhs, irhs, *did_match_iter++ != 0);
+      }
+    }
+    return matrix;
+  }
+
+  ::std::vector<Matcher<const Element&> > matchers_;
+};
+
+// Functor for use in TransformTuple.
+// Performs MatcherCast<Target> on an input argument of any type.
+template <typename Target>
+struct CastAndAppendTransform {
+  template <typename Arg>
+  Matcher<Target> operator()(const Arg& a) const {
+    return MatcherCast<Target>(a);
+  }
+};
+
+// Implements UnorderedElementsAre.
+template <typename MatcherTuple>
+class UnorderedElementsAreMatcher {
+ public:
+  explicit UnorderedElementsAreMatcher(const MatcherTuple& args)
+      : matchers_(args) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+    typedef typename internal::StlContainerView<RawContainer>::type View;
+    typedef typename View::value_type Element;
+    typedef ::std::vector<Matcher<const Element&> > MatcherVec;
+    MatcherVec matchers;
+    matchers.reserve(::std::tuple_size<MatcherTuple>::value);
+    TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
+                         ::std::back_inserter(matchers));
+    return Matcher<Container>(
+        new UnorderedElementsAreMatcherImpl<const Container&>(
+            UnorderedMatcherRequire::ExactMatch, matchers.begin(),
+            matchers.end()));
+  }
+
+ private:
+  const MatcherTuple matchers_;
+};
+
+// Implements ElementsAre.
+template <typename MatcherTuple>
+class ElementsAreMatcher {
+ public:
+  explicit ElementsAreMatcher(const MatcherTuple& args) : matchers_(args) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    GTEST_COMPILE_ASSERT_(
+        !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value ||
+            ::std::tuple_size<MatcherTuple>::value < 2,
+        use_UnorderedElementsAre_with_hash_tables);
+
+    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
+    typedef typename internal::StlContainerView<RawContainer>::type View;
+    typedef typename View::value_type Element;
+    typedef ::std::vector<Matcher<const Element&> > MatcherVec;
+    MatcherVec matchers;
+    matchers.reserve(::std::tuple_size<MatcherTuple>::value);
+    TransformTupleValues(CastAndAppendTransform<const Element&>(), matchers_,
+                         ::std::back_inserter(matchers));
+    return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>(
+        matchers.begin(), matchers.end()));
+  }
+
+ private:
+  const MatcherTuple matchers_;
+};
+
+// Implements UnorderedElementsAreArray(), IsSubsetOf(), and IsSupersetOf().
+template <typename T>
+class UnorderedElementsAreArrayMatcher {
+ public:
+  template <typename Iter>
+  UnorderedElementsAreArrayMatcher(UnorderedMatcherRequire::Flags match_flags,
+                                   Iter first, Iter last)
+      : match_flags_(match_flags), matchers_(first, last) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    return Matcher<Container>(
+        new UnorderedElementsAreMatcherImpl<const Container&>(
+            match_flags_, matchers_.begin(), matchers_.end()));
+  }
+
+ private:
+  UnorderedMatcherRequire::Flags match_flags_;
+  ::std::vector<T> matchers_;
+};
+
+// Implements ElementsAreArray().
+template <typename T>
+class ElementsAreArrayMatcher {
+ public:
+  template <typename Iter>
+  ElementsAreArrayMatcher(Iter first, Iter last) : matchers_(first, last) {}
+
+  template <typename Container>
+  operator Matcher<Container>() const {
+    GTEST_COMPILE_ASSERT_(
+        !IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value,
+        use_UnorderedElementsAreArray_with_hash_tables);
+
+    return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>(
+        matchers_.begin(), matchers_.end()));
+  }
+
+ private:
+  const ::std::vector<T> matchers_;
+};
+
+// Given a 2-tuple matcher tm of type Tuple2Matcher and a value second
+// of type Second, BoundSecondMatcher<Tuple2Matcher, Second>(tm,
+// second) is a polymorphic matcher that matches a value x if and only if
+// tm matches tuple (x, second).  Useful for implementing
+// UnorderedPointwise() in terms of UnorderedElementsAreArray().
+//
+// BoundSecondMatcher is copyable and assignable, as we need to put
+// instances of this class in a vector when implementing
+// UnorderedPointwise().
+template <typename Tuple2Matcher, typename Second>
+class BoundSecondMatcher {
+ public:
+  BoundSecondMatcher(const Tuple2Matcher& tm, const Second& second)
+      : tuple2_matcher_(tm), second_value_(second) {}
+
+  BoundSecondMatcher(const BoundSecondMatcher& other) = default;
+
+  template <typename T>
+  operator Matcher<T>() const {
+    return MakeMatcher(new Impl<T>(tuple2_matcher_, second_value_));
+  }
+
+  // We have to define this for UnorderedPointwise() to compile in
+  // C++98 mode, as it puts BoundSecondMatcher instances in a vector,
+  // which requires the elements to be assignable in C++98.  The
+  // compiler cannot generate the operator= for us, as Tuple2Matcher
+  // and Second may not be assignable.
+  //
+  // However, this should never be called, so the implementation just
+  // need to assert.
+  void operator=(const BoundSecondMatcher& /*rhs*/) {
+    GTEST_LOG_(FATAL) << "BoundSecondMatcher should never be assigned.";
+  }
+
+ private:
+  template <typename T>
+  class Impl : public MatcherInterface<T> {
+   public:
+    typedef ::std::tuple<T, Second> ArgTuple;
+
+    Impl(const Tuple2Matcher& tm, const Second& second)
+        : mono_tuple2_matcher_(SafeMatcherCast<const ArgTuple&>(tm)),
+          second_value_(second) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "and ";
+      UniversalPrint(second_value_, os);
+      *os << " ";
+      mono_tuple2_matcher_.DescribeTo(os);
+    }
+
+    bool MatchAndExplain(T x, MatchResultListener* listener) const override {
+      return mono_tuple2_matcher_.MatchAndExplain(ArgTuple(x, second_value_),
+                                                  listener);
+    }
+
+   private:
+    const Matcher<const ArgTuple&> mono_tuple2_matcher_;
+    const Second second_value_;
+  };
+
+  const Tuple2Matcher tuple2_matcher_;
+  const Second second_value_;
+};
+
+// Given a 2-tuple matcher tm and a value second,
+// MatcherBindSecond(tm, second) returns a matcher that matches a
+// value x if and only if tm matches tuple (x, second).  Useful for
+// implementing UnorderedPointwise() in terms of UnorderedElementsAreArray().
+template <typename Tuple2Matcher, typename Second>
+BoundSecondMatcher<Tuple2Matcher, Second> MatcherBindSecond(
+    const Tuple2Matcher& tm, const Second& second) {
+  return BoundSecondMatcher<Tuple2Matcher, Second>(tm, second);
+}
+
+// Returns the description for a matcher defined using the MATCHER*()
+// macro where the user-supplied description string is "", if
+// 'negation' is false; otherwise returns the description of the
+// negation of the matcher.  'param_values' contains a list of strings
+// that are the print-out of the matcher's parameters.
+GTEST_API_ std::string FormatMatcherDescription(bool negation,
+                                                const char* matcher_name,
+                                                const Strings& param_values);
+
+// Implements a matcher that checks the value of a optional<> type variable.
+template <typename ValueMatcher>
+class OptionalMatcher {
+ public:
+  explicit OptionalMatcher(const ValueMatcher& value_matcher)
+      : value_matcher_(value_matcher) {}
+
+  template <typename Optional>
+  operator Matcher<Optional>() const {
+    return Matcher<Optional>(new Impl<const Optional&>(value_matcher_));
+  }
+
+  template <typename Optional>
+  class Impl : public MatcherInterface<Optional> {
+   public:
+    typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Optional) OptionalView;
+    typedef typename OptionalView::value_type ValueType;
+    explicit Impl(const ValueMatcher& value_matcher)
+        : value_matcher_(MatcherCast<ValueType>(value_matcher)) {}
+
+    void DescribeTo(::std::ostream* os) const override {
+      *os << "value ";
+      value_matcher_.DescribeTo(os);
+    }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      *os << "value ";
+      value_matcher_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(Optional optional,
+                         MatchResultListener* listener) const override {
+      if (!optional) {
+        *listener << "which is not engaged";
+        return false;
+      }
+      const ValueType& value = *optional;
+      StringMatchResultListener value_listener;
+      const bool match = value_matcher_.MatchAndExplain(value, &value_listener);
+      *listener << "whose value " << PrintToString(value)
+                << (match ? " matches" : " doesn't match");
+      PrintIfNotEmpty(value_listener.str(), listener->stream());
+      return match;
+    }
+
+   private:
+    const Matcher<ValueType> value_matcher_;
+  };
+
+ private:
+  const ValueMatcher value_matcher_;
+};
+
+namespace variant_matcher {
+// Overloads to allow VariantMatcher to do proper ADL lookup.
+template <typename T>
+void holds_alternative() {}
+template <typename T>
+void get() {}
+
+// Implements a matcher that checks the value of a variant<> type variable.
+template <typename T>
+class VariantMatcher {
+ public:
+  explicit VariantMatcher(::testing::Matcher<const T&> matcher)
+      : matcher_(std::move(matcher)) {}
+
+  template <typename Variant>
+  bool MatchAndExplain(const Variant& value,
+                       ::testing::MatchResultListener* listener) const {
+    using std::get;
+    if (!listener->IsInterested()) {
+      return holds_alternative<T>(value) && matcher_.Matches(get<T>(value));
+    }
+
+    if (!holds_alternative<T>(value)) {
+      *listener << "whose value is not of type '" << GetTypeName() << "'";
+      return false;
+    }
+
+    const T& elem = get<T>(value);
+    StringMatchResultListener elem_listener;
+    const bool match = matcher_.MatchAndExplain(elem, &elem_listener);
+    *listener << "whose value " << PrintToString(elem)
+              << (match ? " matches" : " doesn't match");
+    PrintIfNotEmpty(elem_listener.str(), listener->stream());
+    return match;
+  }
+
+  void DescribeTo(std::ostream* os) const {
+    *os << "is a variant<> with value of type '" << GetTypeName()
+        << "' and the value ";
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(std::ostream* os) const {
+    *os << "is a variant<> with value of type other than '" << GetTypeName()
+        << "' or the value ";
+    matcher_.DescribeNegationTo(os);
+  }
+
+ private:
+  static std::string GetTypeName() {
+#if GTEST_HAS_RTTI
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(
+        return internal::GetTypeName<T>());
+#endif
+    return "the element type";
+  }
+
+  const ::testing::Matcher<const T&> matcher_;
+};
+
+}  // namespace variant_matcher
+
+namespace any_cast_matcher {
+
+// Overloads to allow AnyCastMatcher to do proper ADL lookup.
+template <typename T>
+void any_cast() {}
+
+// Implements a matcher that any_casts the value.
+template <typename T>
+class AnyCastMatcher {
+ public:
+  explicit AnyCastMatcher(const ::testing::Matcher<const T&>& matcher)
+      : matcher_(matcher) {}
+
+  template <typename AnyType>
+  bool MatchAndExplain(const AnyType& value,
+                       ::testing::MatchResultListener* listener) const {
+    if (!listener->IsInterested()) {
+      const T* ptr = any_cast<T>(&value);
+      return ptr != nullptr && matcher_.Matches(*ptr);
+    }
+
+    const T* elem = any_cast<T>(&value);
+    if (elem == nullptr) {
+      *listener << "whose value is not of type '" << GetTypeName() << "'";
+      return false;
+    }
+
+    StringMatchResultListener elem_listener;
+    const bool match = matcher_.MatchAndExplain(*elem, &elem_listener);
+    *listener << "whose value " << PrintToString(*elem)
+              << (match ? " matches" : " doesn't match");
+    PrintIfNotEmpty(elem_listener.str(), listener->stream());
+    return match;
+  }
+
+  void DescribeTo(std::ostream* os) const {
+    *os << "is an 'any' type with value of type '" << GetTypeName()
+        << "' and the value ";
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(std::ostream* os) const {
+    *os << "is an 'any' type with value of type other than '" << GetTypeName()
+        << "' or the value ";
+    matcher_.DescribeNegationTo(os);
+  }
+
+ private:
+  static std::string GetTypeName() {
+#if GTEST_HAS_RTTI
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(
+        return internal::GetTypeName<T>());
+#endif
+    return "the element type";
+  }
+
+  const ::testing::Matcher<const T&> matcher_;
+};
+
+}  // namespace any_cast_matcher
+
+// Implements the Args() matcher.
+template <class ArgsTuple, size_t... k>
+class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
+ public:
+  using RawArgsTuple = typename std::decay<ArgsTuple>::type;
+  using SelectedArgs =
+      std::tuple<typename std::tuple_element<k, RawArgsTuple>::type...>;
+  using MonomorphicInnerMatcher = Matcher<const SelectedArgs&>;
+
+  template <typename InnerMatcher>
+  explicit ArgsMatcherImpl(const InnerMatcher& inner_matcher)
+      : inner_matcher_(SafeMatcherCast<const SelectedArgs&>(inner_matcher)) {}
+
+  bool MatchAndExplain(ArgsTuple args,
+                       MatchResultListener* listener) const override {
+    // Workaround spurious C4100 on MSVC<=15.7 when k is empty.
+    (void)args;
+    const SelectedArgs& selected_args =
+        std::forward_as_tuple(std::get<k>(args)...);
+    if (!listener->IsInterested()) return inner_matcher_.Matches(selected_args);
+
+    PrintIndices(listener->stream());
+    *listener << "are " << PrintToString(selected_args);
+
+    StringMatchResultListener inner_listener;
+    const bool match =
+        inner_matcher_.MatchAndExplain(selected_args, &inner_listener);
+    PrintIfNotEmpty(inner_listener.str(), listener->stream());
+    return match;
+  }
+
+  void DescribeTo(::std::ostream* os) const override {
+    *os << "are a tuple ";
+    PrintIndices(os);
+    inner_matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const override {
+    *os << "are a tuple ";
+    PrintIndices(os);
+    inner_matcher_.DescribeNegationTo(os);
+  }
+
+ private:
+  // Prints the indices of the selected fields.
+  static void PrintIndices(::std::ostream* os) {
+    *os << "whose fields (";
+    const char* sep = "";
+    // Workaround spurious C4189 on MSVC<=15.7 when k is empty.
+    (void)sep;
+    const char* dummy[] = {"", (*os << sep << "#" << k, sep = ", ")...};
+    (void)dummy;
+    *os << ") ";
+  }
+
+  MonomorphicInnerMatcher inner_matcher_;
+};
+
+template <class InnerMatcher, size_t... k>
+class ArgsMatcher {
+ public:
+  explicit ArgsMatcher(InnerMatcher inner_matcher)
+      : inner_matcher_(std::move(inner_matcher)) {}
+
+  template <typename ArgsTuple>
+  operator Matcher<ArgsTuple>() const {  // NOLINT
+    return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, k...>(inner_matcher_));
+  }
+
+ private:
+  InnerMatcher inner_matcher_;
+};
+
+}  // namespace internal
+
+// ElementsAreArray(iterator_first, iterator_last)
+// ElementsAreArray(pointer, count)
+// ElementsAreArray(array)
+// ElementsAreArray(container)
+// ElementsAreArray({ e1, e2, ..., en })
+//
+// The ElementsAreArray() functions are like ElementsAre(...), except
+// that they are given a homogeneous sequence rather than taking each
+// element as a function argument. The sequence can be specified as an
+// array, a pointer and count, a vector, an initializer list, or an
+// STL iterator range. In each of these cases, the underlying sequence
+// can be either a sequence of values or a sequence of matchers.
+//
+// All forms of ElementsAreArray() make a copy of the input matcher sequence.
+
+template <typename Iter>
+inline internal::ElementsAreArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+ElementsAreArray(Iter first, Iter last) {
+  typedef typename ::std::iterator_traits<Iter>::value_type T;
+  return internal::ElementsAreArrayMatcher<T>(first, last);
+}
+
+template <typename T>
+inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
+    const T* pointer, size_t count) {
+  return ElementsAreArray(pointer, pointer + count);
+}
+
+template <typename T, size_t N>
+inline internal::ElementsAreArrayMatcher<T> ElementsAreArray(
+    const T (&array)[N]) {
+  return ElementsAreArray(array, N);
+}
+
+template <typename Container>
+inline internal::ElementsAreArrayMatcher<typename Container::value_type>
+ElementsAreArray(const Container& container) {
+  return ElementsAreArray(container.begin(), container.end());
+}
+
+template <typename T>
+inline internal::ElementsAreArrayMatcher<T>
+ElementsAreArray(::std::initializer_list<T> xs) {
+  return ElementsAreArray(xs.begin(), xs.end());
+}
+
+// UnorderedElementsAreArray(iterator_first, iterator_last)
+// UnorderedElementsAreArray(pointer, count)
+// UnorderedElementsAreArray(array)
+// UnorderedElementsAreArray(container)
+// UnorderedElementsAreArray({ e1, e2, ..., en })
+//
+// UnorderedElementsAreArray() verifies that a bijective mapping onto a
+// collection of matchers exists.
+//
+// The matchers can be specified as an array, a pointer and count, a container,
+// an initializer list, or an STL iterator range. In each of these cases, the
+// underlying matchers can be either values or matchers.
+
+template <typename Iter>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+UnorderedElementsAreArray(Iter first, Iter last) {
+  typedef typename ::std::iterator_traits<Iter>::value_type T;
+  return internal::UnorderedElementsAreArrayMatcher<T>(
+      internal::UnorderedMatcherRequire::ExactMatch, first, last);
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T>
+UnorderedElementsAreArray(const T* pointer, size_t count) {
+  return UnorderedElementsAreArray(pointer, pointer + count);
+}
+
+template <typename T, size_t N>
+inline internal::UnorderedElementsAreArrayMatcher<T>
+UnorderedElementsAreArray(const T (&array)[N]) {
+  return UnorderedElementsAreArray(array, N);
+}
+
+template <typename Container>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename Container::value_type>
+UnorderedElementsAreArray(const Container& container) {
+  return UnorderedElementsAreArray(container.begin(), container.end());
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T>
+UnorderedElementsAreArray(::std::initializer_list<T> xs) {
+  return UnorderedElementsAreArray(xs.begin(), xs.end());
+}
+
+// _ is a matcher that matches anything of any type.
+//
+// This definition is fine as:
+//
+//   1. The C++ standard permits using the name _ in a namespace that
+//      is not the global namespace or ::std.
+//   2. The AnythingMatcher class has no data member or constructor,
+//      so it's OK to create global variables of this type.
+//   3. c-style has approved of using _ in this case.
+const internal::AnythingMatcher _ = {};
+// Creates a matcher that matches any value of the given type T.
+template <typename T>
+inline Matcher<T> A() {
+  return _;
+}
+
+// Creates a matcher that matches any value of the given type T.
+template <typename T>
+inline Matcher<T> An() {
+  return _;
+}
+
+template <typename T, typename M>
+Matcher<T> internal::MatcherCastImpl<T, M>::CastImpl(
+    const M& value, std::false_type /* convertible_to_matcher */,
+    std::false_type /* convertible_to_T */) {
+  return Eq(value);
+}
+
+// Creates a polymorphic matcher that matches any NULL pointer.
+inline PolymorphicMatcher<internal::IsNullMatcher > IsNull() {
+  return MakePolymorphicMatcher(internal::IsNullMatcher());
+}
+
+// Creates a polymorphic matcher that matches any non-NULL pointer.
+// This is convenient as Not(NULL) doesn't compile (the compiler
+// thinks that that expression is comparing a pointer with an integer).
+inline PolymorphicMatcher<internal::NotNullMatcher > NotNull() {
+  return MakePolymorphicMatcher(internal::NotNullMatcher());
+}
+
+// Creates a polymorphic matcher that matches any argument that
+// references variable x.
+template <typename T>
+inline internal::RefMatcher<T&> Ref(T& x) {  // NOLINT
+  return internal::RefMatcher<T&>(x);
+}
+
+// Creates a polymorphic matcher that matches any NaN floating point.
+inline PolymorphicMatcher<internal::IsNanMatcher> IsNan() {
+  return MakePolymorphicMatcher(internal::IsNanMatcher());
+}
+
+// Creates a matcher that matches any double argument approximately
+// equal to rhs, where two NANs are considered unequal.
+inline internal::FloatingEqMatcher<double> DoubleEq(double rhs) {
+  return internal::FloatingEqMatcher<double>(rhs, false);
+}
+
+// Creates a matcher that matches any double argument approximately
+// equal to rhs, including NaN values when rhs is NaN.
+inline internal::FloatingEqMatcher<double> NanSensitiveDoubleEq(double rhs) {
+  return internal::FloatingEqMatcher<double>(rhs, true);
+}
+
+// Creates a matcher that matches any double argument approximately equal to
+// rhs, up to the specified max absolute error bound, where two NANs are
+// considered unequal.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<double> DoubleNear(
+    double rhs, double max_abs_error) {
+  return internal::FloatingEqMatcher<double>(rhs, false, max_abs_error);
+}
+
+// Creates a matcher that matches any double argument approximately equal to
+// rhs, up to the specified max absolute error bound, including NaN values when
+// rhs is NaN.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<double> NanSensitiveDoubleNear(
+    double rhs, double max_abs_error) {
+  return internal::FloatingEqMatcher<double>(rhs, true, max_abs_error);
+}
+
+// Creates a matcher that matches any float argument approximately
+// equal to rhs, where two NANs are considered unequal.
+inline internal::FloatingEqMatcher<float> FloatEq(float rhs) {
+  return internal::FloatingEqMatcher<float>(rhs, false);
+}
+
+// Creates a matcher that matches any float argument approximately
+// equal to rhs, including NaN values when rhs is NaN.
+inline internal::FloatingEqMatcher<float> NanSensitiveFloatEq(float rhs) {
+  return internal::FloatingEqMatcher<float>(rhs, true);
+}
+
+// Creates a matcher that matches any float argument approximately equal to
+// rhs, up to the specified max absolute error bound, where two NANs are
+// considered unequal.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<float> FloatNear(
+    float rhs, float max_abs_error) {
+  return internal::FloatingEqMatcher<float>(rhs, false, max_abs_error);
+}
+
+// Creates a matcher that matches any float argument approximately equal to
+// rhs, up to the specified max absolute error bound, including NaN values when
+// rhs is NaN.  The max absolute error bound must be non-negative.
+inline internal::FloatingEqMatcher<float> NanSensitiveFloatNear(
+    float rhs, float max_abs_error) {
+  return internal::FloatingEqMatcher<float>(rhs, true, max_abs_error);
+}
+
+// Creates a matcher that matches a pointer (raw or smart) that points
+// to a value that matches inner_matcher.
+template <typename InnerMatcher>
+inline internal::PointeeMatcher<InnerMatcher> Pointee(
+    const InnerMatcher& inner_matcher) {
+  return internal::PointeeMatcher<InnerMatcher>(inner_matcher);
+}
+
+#if GTEST_HAS_RTTI
+// Creates a matcher that matches a pointer or reference that matches
+// inner_matcher when dynamic_cast<To> is applied.
+// The result of dynamic_cast<To> is forwarded to the inner matcher.
+// If To is a pointer and the cast fails, the inner matcher will receive NULL.
+// If To is a reference and the cast fails, this matcher returns false
+// immediately.
+template <typename To>
+inline PolymorphicMatcher<internal::WhenDynamicCastToMatcher<To> >
+WhenDynamicCastTo(const Matcher<To>& inner_matcher) {
+  return MakePolymorphicMatcher(
+      internal::WhenDynamicCastToMatcher<To>(inner_matcher));
+}
+#endif  // GTEST_HAS_RTTI
+
+// Creates a matcher that matches an object whose given field matches
+// 'matcher'.  For example,
+//   Field(&Foo::number, Ge(5))
+// matches a Foo object x if and only if x.number >= 5.
+template <typename Class, typename FieldType, typename FieldMatcher>
+inline PolymorphicMatcher<
+  internal::FieldMatcher<Class, FieldType> > Field(
+    FieldType Class::*field, const FieldMatcher& matcher) {
+  return MakePolymorphicMatcher(
+      internal::FieldMatcher<Class, FieldType>(
+          field, MatcherCast<const FieldType&>(matcher)));
+  // The call to MatcherCast() is required for supporting inner
+  // matchers of compatible types.  For example, it allows
+  //   Field(&Foo::bar, m)
+  // to compile where bar is an int32 and m is a matcher for int64.
+}
+
+// Same as Field() but also takes the name of the field to provide better error
+// messages.
+template <typename Class, typename FieldType, typename FieldMatcher>
+inline PolymorphicMatcher<internal::FieldMatcher<Class, FieldType> > Field(
+    const std::string& field_name, FieldType Class::*field,
+    const FieldMatcher& matcher) {
+  return MakePolymorphicMatcher(internal::FieldMatcher<Class, FieldType>(
+      field_name, field, MatcherCast<const FieldType&>(matcher)));
+}
+
+// Creates a matcher that matches an object whose given property
+// matches 'matcher'.  For example,
+//   Property(&Foo::str, StartsWith("hi"))
+// matches a Foo object x if and only if x.str() starts with "hi".
+template <typename Class, typename PropertyType, typename PropertyMatcher>
+inline PolymorphicMatcher<internal::PropertyMatcher<
+    Class, PropertyType, PropertyType (Class::*)() const> >
+Property(PropertyType (Class::*property)() const,
+         const PropertyMatcher& matcher) {
+  return MakePolymorphicMatcher(
+      internal::PropertyMatcher<Class, PropertyType,
+                                PropertyType (Class::*)() const>(
+          property, MatcherCast<const PropertyType&>(matcher)));
+  // The call to MatcherCast() is required for supporting inner
+  // matchers of compatible types.  For example, it allows
+  //   Property(&Foo::bar, m)
+  // to compile where bar() returns an int32 and m is a matcher for int64.
+}
+
+// Same as Property() above, but also takes the name of the property to provide
+// better error messages.
+template <typename Class, typename PropertyType, typename PropertyMatcher>
+inline PolymorphicMatcher<internal::PropertyMatcher<
+    Class, PropertyType, PropertyType (Class::*)() const> >
+Property(const std::string& property_name,
+         PropertyType (Class::*property)() const,
+         const PropertyMatcher& matcher) {
+  return MakePolymorphicMatcher(
+      internal::PropertyMatcher<Class, PropertyType,
+                                PropertyType (Class::*)() const>(
+          property_name, property, MatcherCast<const PropertyType&>(matcher)));
+}
+
+// The same as above but for reference-qualified member functions.
+template <typename Class, typename PropertyType, typename PropertyMatcher>
+inline PolymorphicMatcher<internal::PropertyMatcher<
+    Class, PropertyType, PropertyType (Class::*)() const &> >
+Property(PropertyType (Class::*property)() const &,
+         const PropertyMatcher& matcher) {
+  return MakePolymorphicMatcher(
+      internal::PropertyMatcher<Class, PropertyType,
+                                PropertyType (Class::*)() const&>(
+          property, MatcherCast<const PropertyType&>(matcher)));
+}
+
+// Three-argument form for reference-qualified member functions.
+template <typename Class, typename PropertyType, typename PropertyMatcher>
+inline PolymorphicMatcher<internal::PropertyMatcher<
+    Class, PropertyType, PropertyType (Class::*)() const &> >
+Property(const std::string& property_name,
+         PropertyType (Class::*property)() const &,
+         const PropertyMatcher& matcher) {
+  return MakePolymorphicMatcher(
+      internal::PropertyMatcher<Class, PropertyType,
+                                PropertyType (Class::*)() const&>(
+          property_name, property, MatcherCast<const PropertyType&>(matcher)));
+}
+
+// Creates a matcher that matches an object if and only if the result of
+// applying a callable to x matches 'matcher'. For example,
+//   ResultOf(f, StartsWith("hi"))
+// matches a Foo object x if and only if f(x) starts with "hi".
+// `callable` parameter can be a function, function pointer, or a functor. It is
+// required to keep no state affecting the results of the calls on it and make
+// no assumptions about how many calls will be made. Any state it keeps must be
+// protected from the concurrent access.
+template <typename Callable, typename InnerMatcher>
+internal::ResultOfMatcher<Callable, InnerMatcher> ResultOf(
+    Callable callable, InnerMatcher matcher) {
+  return internal::ResultOfMatcher<Callable, InnerMatcher>(
+      std::move(callable), std::move(matcher));
+}
+
+// String matchers.
+
+// Matches a string equal to str.
+template <typename T = std::string>
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrEq(
+    const internal::StringLike<T>& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::string>(std::string(str), true, true));
+}
+
+// Matches a string not equal to str.
+template <typename T = std::string>
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrNe(
+    const internal::StringLike<T>& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::string>(std::string(str), false, true));
+}
+
+// Matches a string equal to str, ignoring case.
+template <typename T = std::string>
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseEq(
+    const internal::StringLike<T>& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::string>(std::string(str), true, false));
+}
+
+// Matches a string not equal to str, ignoring case.
+template <typename T = std::string>
+PolymorphicMatcher<internal::StrEqualityMatcher<std::string> > StrCaseNe(
+    const internal::StringLike<T>& str) {
+  return MakePolymorphicMatcher(internal::StrEqualityMatcher<std::string>(
+      std::string(str), false, false));
+}
+
+// Creates a matcher that matches any string, std::string, or C string
+// that contains the given substring.
+template <typename T = std::string>
+PolymorphicMatcher<internal::HasSubstrMatcher<std::string> > HasSubstr(
+    const internal::StringLike<T>& substring) {
+  return MakePolymorphicMatcher(
+      internal::HasSubstrMatcher<std::string>(std::string(substring)));
+}
+
+// Matches a string that starts with 'prefix' (case-sensitive).
+template <typename T = std::string>
+PolymorphicMatcher<internal::StartsWithMatcher<std::string> > StartsWith(
+    const internal::StringLike<T>& prefix) {
+  return MakePolymorphicMatcher(
+      internal::StartsWithMatcher<std::string>(std::string(prefix)));
+}
+
+// Matches a string that ends with 'suffix' (case-sensitive).
+template <typename T = std::string>
+PolymorphicMatcher<internal::EndsWithMatcher<std::string> > EndsWith(
+    const internal::StringLike<T>& suffix) {
+  return MakePolymorphicMatcher(
+      internal::EndsWithMatcher<std::string>(std::string(suffix)));
+}
+
+#if GTEST_HAS_STD_WSTRING
+// Wide string matchers.
+
+// Matches a string equal to str.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > StrEq(
+    const std::wstring& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::wstring>(str, true, true));
+}
+
+// Matches a string not equal to str.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> > StrNe(
+    const std::wstring& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::wstring>(str, false, true));
+}
+
+// Matches a string equal to str, ignoring case.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> >
+StrCaseEq(const std::wstring& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::wstring>(str, true, false));
+}
+
+// Matches a string not equal to str, ignoring case.
+inline PolymorphicMatcher<internal::StrEqualityMatcher<std::wstring> >
+StrCaseNe(const std::wstring& str) {
+  return MakePolymorphicMatcher(
+      internal::StrEqualityMatcher<std::wstring>(str, false, false));
+}
+
+// Creates a matcher that matches any ::wstring, std::wstring, or C wide string
+// that contains the given substring.
+inline PolymorphicMatcher<internal::HasSubstrMatcher<std::wstring> > HasSubstr(
+    const std::wstring& substring) {
+  return MakePolymorphicMatcher(
+      internal::HasSubstrMatcher<std::wstring>(substring));
+}
+
+// Matches a string that starts with 'prefix' (case-sensitive).
+inline PolymorphicMatcher<internal::StartsWithMatcher<std::wstring> >
+StartsWith(const std::wstring& prefix) {
+  return MakePolymorphicMatcher(
+      internal::StartsWithMatcher<std::wstring>(prefix));
+}
+
+// Matches a string that ends with 'suffix' (case-sensitive).
+inline PolymorphicMatcher<internal::EndsWithMatcher<std::wstring> > EndsWith(
+    const std::wstring& suffix) {
+  return MakePolymorphicMatcher(
+      internal::EndsWithMatcher<std::wstring>(suffix));
+}
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field == the second field.
+inline internal::Eq2Matcher Eq() { return internal::Eq2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field >= the second field.
+inline internal::Ge2Matcher Ge() { return internal::Ge2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field > the second field.
+inline internal::Gt2Matcher Gt() { return internal::Gt2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field <= the second field.
+inline internal::Le2Matcher Le() { return internal::Le2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field < the second field.
+inline internal::Lt2Matcher Lt() { return internal::Lt2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where the
+// first field != the second field.
+inline internal::Ne2Matcher Ne() { return internal::Ne2Matcher(); }
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// FloatEq(first field) matches the second field.
+inline internal::FloatingEq2Matcher<float> FloatEq() {
+  return internal::FloatingEq2Matcher<float>();
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// DoubleEq(first field) matches the second field.
+inline internal::FloatingEq2Matcher<double> DoubleEq() {
+  return internal::FloatingEq2Matcher<double>();
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// FloatEq(first field) matches the second field with NaN equality.
+inline internal::FloatingEq2Matcher<float> NanSensitiveFloatEq() {
+  return internal::FloatingEq2Matcher<float>(true);
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// DoubleEq(first field) matches the second field with NaN equality.
+inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleEq() {
+  return internal::FloatingEq2Matcher<double>(true);
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// FloatNear(first field, max_abs_error) matches the second field.
+inline internal::FloatingEq2Matcher<float> FloatNear(float max_abs_error) {
+  return internal::FloatingEq2Matcher<float>(max_abs_error);
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// DoubleNear(first field, max_abs_error) matches the second field.
+inline internal::FloatingEq2Matcher<double> DoubleNear(double max_abs_error) {
+  return internal::FloatingEq2Matcher<double>(max_abs_error);
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// FloatNear(first field, max_abs_error) matches the second field with NaN
+// equality.
+inline internal::FloatingEq2Matcher<float> NanSensitiveFloatNear(
+    float max_abs_error) {
+  return internal::FloatingEq2Matcher<float>(max_abs_error, true);
+}
+
+// Creates a polymorphic matcher that matches a 2-tuple where
+// DoubleNear(first field, max_abs_error) matches the second field with NaN
+// equality.
+inline internal::FloatingEq2Matcher<double> NanSensitiveDoubleNear(
+    double max_abs_error) {
+  return internal::FloatingEq2Matcher<double>(max_abs_error, true);
+}
+
+// Creates a matcher that matches any value of type T that m doesn't
+// match.
+template <typename InnerMatcher>
+inline internal::NotMatcher<InnerMatcher> Not(InnerMatcher m) {
+  return internal::NotMatcher<InnerMatcher>(m);
+}
+
+// Returns a matcher that matches anything that satisfies the given
+// predicate.  The predicate can be any unary function or functor
+// whose return type can be implicitly converted to bool.
+template <typename Predicate>
+inline PolymorphicMatcher<internal::TrulyMatcher<Predicate> >
+Truly(Predicate pred) {
+  return MakePolymorphicMatcher(internal::TrulyMatcher<Predicate>(pred));
+}
+
+// Returns a matcher that matches the container size. The container must
+// support both size() and size_type which all STL-like containers provide.
+// Note that the parameter 'size' can be a value of type size_type as well as
+// matcher. For instance:
+//   EXPECT_THAT(container, SizeIs(2));     // Checks container has 2 elements.
+//   EXPECT_THAT(container, SizeIs(Le(2));  // Checks container has at most 2.
+template <typename SizeMatcher>
+inline internal::SizeIsMatcher<SizeMatcher>
+SizeIs(const SizeMatcher& size_matcher) {
+  return internal::SizeIsMatcher<SizeMatcher>(size_matcher);
+}
+
+// Returns a matcher that matches the distance between the container's begin()
+// iterator and its end() iterator, i.e. the size of the container. This matcher
+// can be used instead of SizeIs with containers such as std::forward_list which
+// do not implement size(). The container must provide const_iterator (with
+// valid iterator_traits), begin() and end().
+template <typename DistanceMatcher>
+inline internal::BeginEndDistanceIsMatcher<DistanceMatcher>
+BeginEndDistanceIs(const DistanceMatcher& distance_matcher) {
+  return internal::BeginEndDistanceIsMatcher<DistanceMatcher>(distance_matcher);
+}
+
+// Returns a matcher that matches an equal container.
+// This matcher behaves like Eq(), but in the event of mismatch lists the
+// values that are included in one container but not the other. (Duplicate
+// values and order differences are not explained.)
+template <typename Container>
+inline PolymorphicMatcher<internal::ContainerEqMatcher<
+    typename std::remove_const<Container>::type>>
+ContainerEq(const Container& rhs) {
+  return MakePolymorphicMatcher(internal::ContainerEqMatcher<Container>(rhs));
+}
+
+// Returns a matcher that matches a container that, when sorted using
+// the given comparator, matches container_matcher.
+template <typename Comparator, typename ContainerMatcher>
+inline internal::WhenSortedByMatcher<Comparator, ContainerMatcher>
+WhenSortedBy(const Comparator& comparator,
+             const ContainerMatcher& container_matcher) {
+  return internal::WhenSortedByMatcher<Comparator, ContainerMatcher>(
+      comparator, container_matcher);
+}
+
+// Returns a matcher that matches a container that, when sorted using
+// the < operator, matches container_matcher.
+template <typename ContainerMatcher>
+inline internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>
+WhenSorted(const ContainerMatcher& container_matcher) {
+  return
+      internal::WhenSortedByMatcher<internal::LessComparator, ContainerMatcher>(
+          internal::LessComparator(), container_matcher);
+}
+
+// Matches an STL-style container or a native array that contains the
+// same number of elements as in rhs, where its i-th element and rhs's
+// i-th element (as a pair) satisfy the given pair matcher, for all i.
+// TupleMatcher must be able to be safely cast to Matcher<std::tuple<const
+// T1&, const T2&> >, where T1 and T2 are the types of elements in the
+// LHS container and the RHS container respectively.
+template <typename TupleMatcher, typename Container>
+inline internal::PointwiseMatcher<TupleMatcher,
+                                  typename std::remove_const<Container>::type>
+Pointwise(const TupleMatcher& tuple_matcher, const Container& rhs) {
+  return internal::PointwiseMatcher<TupleMatcher, Container>(tuple_matcher,
+                                                             rhs);
+}
+
+
+// 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));
+}
+
+
+// UnorderedPointwise(pair_matcher, rhs) matches an STL-style
+// container or a native array that contains the same number of
+// elements as in rhs, where in some permutation of the container, its
+// i-th element and rhs's i-th element (as a pair) satisfy the given
+// pair matcher, for all i.  Tuple2Matcher must be able to be safely
+// cast to Matcher<std::tuple<const T1&, const T2&> >, where T1 and T2 are
+// the types of elements in the LHS container and the RHS container
+// respectively.
+//
+// This is like Pointwise(pair_matcher, rhs), except that the element
+// order doesn't matter.
+template <typename Tuple2Matcher, typename RhsContainer>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename internal::BoundSecondMatcher<
+        Tuple2Matcher,
+        typename internal::StlContainerView<
+            typename std::remove_const<RhsContainer>::type>::type::value_type>>
+UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
+                   const RhsContainer& rhs_container) {
+  // RhsView allows the same code to handle RhsContainer being a
+  // STL-style container and it being a native C-style array.
+  typedef typename internal::StlContainerView<RhsContainer> RhsView;
+  typedef typename RhsView::type RhsStlContainer;
+  typedef typename RhsStlContainer::value_type Second;
+  const RhsStlContainer& rhs_stl_container =
+      RhsView::ConstReference(rhs_container);
+
+  // Create a matcher for each element in rhs_container.
+  ::std::vector<internal::BoundSecondMatcher<Tuple2Matcher, Second> > matchers;
+  for (typename RhsStlContainer::const_iterator it = rhs_stl_container.begin();
+       it != rhs_stl_container.end(); ++it) {
+    matchers.push_back(
+        internal::MatcherBindSecond(tuple2_matcher, *it));
+  }
+
+  // Delegate the work to UnorderedElementsAreArray().
+  return UnorderedElementsAreArray(matchers);
+}
+
+
+// Supports the UnorderedPointwise(m, {a, b, c}) syntax.
+template <typename Tuple2Matcher, typename T>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename internal::BoundSecondMatcher<Tuple2Matcher, T> >
+UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
+                   std::initializer_list<T> rhs) {
+  return UnorderedPointwise(tuple2_matcher, std::vector<T>(rhs));
+}
+
+
+// Matches an STL-style container or a native array that contains at
+// least one element matching the given value or matcher.
+//
+// Examples:
+//   ::std::set<int> page_ids;
+//   page_ids.insert(3);
+//   page_ids.insert(1);
+//   EXPECT_THAT(page_ids, Contains(1));
+//   EXPECT_THAT(page_ids, Contains(Gt(2)));
+//   EXPECT_THAT(page_ids, Not(Contains(4)));
+//
+//   ::std::map<int, size_t> page_lengths;
+//   page_lengths[1] = 100;
+//   EXPECT_THAT(page_lengths,
+//               Contains(::std::pair<const int, size_t>(1, 100)));
+//
+//   const char* user_ids[] = { "joe", "mike", "tom" };
+//   EXPECT_THAT(user_ids, Contains(Eq(::std::string("tom"))));
+template <typename M>
+inline internal::ContainsMatcher<M> Contains(M matcher) {
+  return internal::ContainsMatcher<M>(matcher);
+}
+
+// IsSupersetOf(iterator_first, iterator_last)
+// IsSupersetOf(pointer, count)
+// IsSupersetOf(array)
+// IsSupersetOf(container)
+// IsSupersetOf({e1, e2, ..., en})
+//
+// IsSupersetOf() verifies that a surjective partial mapping onto a collection
+// of matchers exists. In other words, a container matches
+// IsSupersetOf({e1, ..., en}) if and only if there is a permutation
+// {y1, ..., yn} of some of the container's elements where y1 matches e1,
+// ..., and yn matches en. Obviously, the size of the container must be >= n
+// in order to have a match. Examples:
+//
+// - {1, 2, 3} matches IsSupersetOf({Ge(3), Ne(0)}), as 3 matches Ge(3) and
+//   1 matches Ne(0).
+// - {1, 2} doesn't match IsSupersetOf({Eq(1), Lt(2)}), even though 1 matches
+//   both Eq(1) and Lt(2). The reason is that different matchers must be used
+//   for elements in different slots of the container.
+// - {1, 1, 2} matches IsSupersetOf({Eq(1), Lt(2)}), as (the first) 1 matches
+//   Eq(1) and (the second) 1 matches Lt(2).
+// - {1, 2, 3} matches IsSupersetOf(Gt(1), Gt(1)), as 2 matches (the first)
+//   Gt(1) and 3 matches (the second) Gt(1).
+//
+// The matchers can be specified as an array, a pointer and count, a container,
+// an initializer list, or an STL iterator range. In each of these cases, the
+// underlying matchers can be either values or matchers.
+
+template <typename Iter>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+IsSupersetOf(Iter first, Iter last) {
+  typedef typename ::std::iterator_traits<Iter>::value_type T;
+  return internal::UnorderedElementsAreArrayMatcher<T>(
+      internal::UnorderedMatcherRequire::Superset, first, last);
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(
+    const T* pointer, size_t count) {
+  return IsSupersetOf(pointer, pointer + count);
+}
+
+template <typename T, size_t N>
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(
+    const T (&array)[N]) {
+  return IsSupersetOf(array, N);
+}
+
+template <typename Container>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename Container::value_type>
+IsSupersetOf(const Container& container) {
+  return IsSupersetOf(container.begin(), container.end());
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(
+    ::std::initializer_list<T> xs) {
+  return IsSupersetOf(xs.begin(), xs.end());
+}
+
+// IsSubsetOf(iterator_first, iterator_last)
+// IsSubsetOf(pointer, count)
+// IsSubsetOf(array)
+// IsSubsetOf(container)
+// IsSubsetOf({e1, e2, ..., en})
+//
+// IsSubsetOf() verifies that an injective mapping onto a collection of matchers
+// exists.  In other words, a container matches IsSubsetOf({e1, ..., en}) if and
+// only if there is a subset of matchers {m1, ..., mk} which would match the
+// container using UnorderedElementsAre.  Obviously, the size of the container
+// must be <= n in order to have a match. Examples:
+//
+// - {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
+//   match Gt(0). The reason is that different matchers must be used for
+//   elements in different slots of the container.
+//
+// The matchers can be specified as an array, a pointer and count, a container,
+// an initializer list, or an STL iterator range. In each of these cases, the
+// underlying matchers can be either values or matchers.
+
+template <typename Iter>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+IsSubsetOf(Iter first, Iter last) {
+  typedef typename ::std::iterator_traits<Iter>::value_type T;
+  return internal::UnorderedElementsAreArrayMatcher<T>(
+      internal::UnorderedMatcherRequire::Subset, first, last);
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(
+    const T* pointer, size_t count) {
+  return IsSubsetOf(pointer, pointer + count);
+}
+
+template <typename T, size_t N>
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(
+    const T (&array)[N]) {
+  return IsSubsetOf(array, N);
+}
+
+template <typename Container>
+inline internal::UnorderedElementsAreArrayMatcher<
+    typename Container::value_type>
+IsSubsetOf(const Container& container) {
+  return IsSubsetOf(container.begin(), container.end());
+}
+
+template <typename T>
+inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(
+    ::std::initializer_list<T> xs) {
+  return IsSubsetOf(xs.begin(), xs.end());
+}
+
+// Matches an STL-style container or a native array that contains only
+// elements matching the given value or matcher.
+//
+// Each(m) is semantically equivalent to Not(Contains(Not(m))). Only
+// the messages are different.
+//
+// Examples:
+//   ::std::set<int> page_ids;
+//   // Each(m) matches an empty container, regardless of what m is.
+//   EXPECT_THAT(page_ids, Each(Eq(1)));
+//   EXPECT_THAT(page_ids, Each(Eq(77)));
+//
+//   page_ids.insert(3);
+//   EXPECT_THAT(page_ids, Each(Gt(0)));
+//   EXPECT_THAT(page_ids, Not(Each(Gt(4))));
+//   page_ids.insert(1);
+//   EXPECT_THAT(page_ids, Not(Each(Lt(2))));
+//
+//   ::std::map<int, size_t> page_lengths;
+//   page_lengths[1] = 100;
+//   page_lengths[2] = 200;
+//   page_lengths[3] = 300;
+//   EXPECT_THAT(page_lengths, Not(Each(Pair(1, 100))));
+//   EXPECT_THAT(page_lengths, Each(Key(Le(3))));
+//
+//   const char* user_ids[] = { "joe", "mike", "tom" };
+//   EXPECT_THAT(user_ids, Not(Each(Eq(::std::string("tom")))));
+template <typename M>
+inline internal::EachMatcher<M> Each(M matcher) {
+  return internal::EachMatcher<M>(matcher);
+}
+
+// Key(inner_matcher) matches an std::pair whose 'first' field matches
+// inner_matcher.  For example, Contains(Key(Ge(5))) can be used to match an
+// std::map that contains at least one element whose key is >= 5.
+template <typename M>
+inline internal::KeyMatcher<M> Key(M inner_matcher) {
+  return internal::KeyMatcher<M>(inner_matcher);
+}
+
+// Pair(first_matcher, second_matcher) matches a std::pair whose 'first' field
+// matches first_matcher and whose 'second' field matches second_matcher.  For
+// example, EXPECT_THAT(map_type, ElementsAre(Pair(Ge(5), "foo"))) can be used
+// to match a std::map<int, string> that contains exactly one element whose key
+// is >= 5 and whose value equals "foo".
+template <typename FirstMatcher, typename SecondMatcher>
+inline internal::PairMatcher<FirstMatcher, SecondMatcher>
+Pair(FirstMatcher first_matcher, SecondMatcher second_matcher) {
+  return internal::PairMatcher<FirstMatcher, SecondMatcher>(
+      first_matcher, second_matcher);
+}
+
+namespace no_adl {
+// FieldsAre(matchers...) matches piecewise the fields of compatible structs.
+// These include those that support `get<I>(obj)`, and when structured bindings
+// are enabled any class that supports them.
+// In particular, `std::tuple`, `std::pair`, `std::array` and aggregate types.
+template <typename... M>
+internal::FieldsAreMatcher<typename std::decay<M>::type...> FieldsAre(
+    M&&... matchers) {
+  return internal::FieldsAreMatcher<typename std::decay<M>::type...>(
+      std::forward<M>(matchers)...);
+}
+
+// Creates a matcher that matches a pointer (raw or smart) that matches
+// inner_matcher.
+template <typename InnerMatcher>
+inline internal::PointerMatcher<InnerMatcher> Pointer(
+    const InnerMatcher& inner_matcher) {
+  return internal::PointerMatcher<InnerMatcher>(inner_matcher);
+}
+
+// Creates a matcher that matches an object that has an address that matches
+// inner_matcher.
+template <typename InnerMatcher>
+inline internal::AddressMatcher<InnerMatcher> Address(
+    const InnerMatcher& inner_matcher) {
+  return internal::AddressMatcher<InnerMatcher>(inner_matcher);
+}
+}  // namespace no_adl
+
+// Returns a predicate that is satisfied by anything that matches the
+// given matcher.
+template <typename M>
+inline internal::MatcherAsPredicate<M> Matches(M matcher) {
+  return internal::MatcherAsPredicate<M>(matcher);
+}
+
+// Returns true if and only if the value matches the matcher.
+template <typename T, typename M>
+inline bool Value(const T& value, M matcher) {
+  return testing::Matches(matcher)(value);
+}
+
+// Matches the value against the given matcher and explains the match
+// result to listener.
+template <typename T, typename M>
+inline bool ExplainMatchResult(
+    M matcher, const T& value, MatchResultListener* listener) {
+  return SafeMatcherCast<const T&>(matcher).MatchAndExplain(value, listener);
+}
+
+// Returns a string representation of the given matcher.  Useful for description
+// strings of matchers defined using MATCHER_P* macros that accept matchers as
+// their arguments.  For example:
+//
+// MATCHER_P(XAndYThat, matcher,
+//           "X that " + DescribeMatcher<int>(matcher, negation) +
+//               " and Y that " + DescribeMatcher<double>(matcher, negation)) {
+//   return ExplainMatchResult(matcher, arg.x(), result_listener) &&
+//          ExplainMatchResult(matcher, arg.y(), result_listener);
+// }
+template <typename T, typename M>
+std::string DescribeMatcher(const M& matcher, bool negation = false) {
+  ::std::stringstream ss;
+  Matcher<T> monomorphic_matcher = SafeMatcherCast<T>(matcher);
+  if (negation) {
+    monomorphic_matcher.DescribeNegationTo(&ss);
+  } else {
+    monomorphic_matcher.DescribeTo(&ss);
+  }
+  return ss.str();
+}
+
+template <typename... Args>
+internal::ElementsAreMatcher<
+    std::tuple<typename std::decay<const Args&>::type...>>
+ElementsAre(const Args&... matchers) {
+  return internal::ElementsAreMatcher<
+      std::tuple<typename std::decay<const Args&>::type...>>(
+      std::make_tuple(matchers...));
+}
+
+template <typename... Args>
+internal::UnorderedElementsAreMatcher<
+    std::tuple<typename std::decay<const Args&>::type...>>
+UnorderedElementsAre(const Args&... matchers) {
+  return internal::UnorderedElementsAreMatcher<
+      std::tuple<typename std::decay<const Args&>::type...>>(
+      std::make_tuple(matchers...));
+}
+
+// Define variadic matcher versions.
+template <typename... Args>
+internal::AllOfMatcher<typename std::decay<const Args&>::type...> AllOf(
+    const Args&... matchers) {
+  return internal::AllOfMatcher<typename std::decay<const Args&>::type...>(
+      matchers...);
+}
+
+template <typename... Args>
+internal::AnyOfMatcher<typename std::decay<const Args&>::type...> AnyOf(
+    const Args&... matchers) {
+  return internal::AnyOfMatcher<typename std::decay<const Args&>::type...>(
+      matchers...);
+}
+
+// AnyOfArray(array)
+// AnyOfArray(pointer, count)
+// AnyOfArray(container)
+// AnyOfArray({ e1, e2, ..., en })
+// AnyOfArray(iterator_first, iterator_last)
+//
+// AnyOfArray() verifies whether a given value matches any member of a
+// collection of matchers.
+//
+// AllOfArray(array)
+// AllOfArray(pointer, count)
+// AllOfArray(container)
+// AllOfArray({ e1, e2, ..., en })
+// AllOfArray(iterator_first, iterator_last)
+//
+// AllOfArray() verifies whether a given value matches all members of a
+// collection of matchers.
+//
+// The matchers can be specified as an array, a pointer and count, a container,
+// an initializer list, or an STL iterator range. In each of these cases, the
+// underlying matchers can be either values or matchers.
+
+template <typename Iter>
+inline internal::AnyOfArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+AnyOfArray(Iter first, Iter last) {
+  return internal::AnyOfArrayMatcher<
+      typename ::std::iterator_traits<Iter>::value_type>(first, last);
+}
+
+template <typename Iter>
+inline internal::AllOfArrayMatcher<
+    typename ::std::iterator_traits<Iter>::value_type>
+AllOfArray(Iter first, Iter last) {
+  return internal::AllOfArrayMatcher<
+      typename ::std::iterator_traits<Iter>::value_type>(first, last);
+}
+
+template <typename T>
+inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T* ptr, size_t count) {
+  return AnyOfArray(ptr, ptr + count);
+}
+
+template <typename T>
+inline internal::AllOfArrayMatcher<T> AllOfArray(const T* ptr, size_t count) {
+  return AllOfArray(ptr, ptr + count);
+}
+
+template <typename T, size_t N>
+inline internal::AnyOfArrayMatcher<T> AnyOfArray(const T (&array)[N]) {
+  return AnyOfArray(array, N);
+}
+
+template <typename T, size_t N>
+inline internal::AllOfArrayMatcher<T> AllOfArray(const T (&array)[N]) {
+  return AllOfArray(array, N);
+}
+
+template <typename Container>
+inline internal::AnyOfArrayMatcher<typename Container::value_type> AnyOfArray(
+    const Container& container) {
+  return AnyOfArray(container.begin(), container.end());
+}
+
+template <typename Container>
+inline internal::AllOfArrayMatcher<typename Container::value_type> AllOfArray(
+    const Container& container) {
+  return AllOfArray(container.begin(), container.end());
+}
+
+template <typename T>
+inline internal::AnyOfArrayMatcher<T> AnyOfArray(
+    ::std::initializer_list<T> xs) {
+  return AnyOfArray(xs.begin(), xs.end());
+}
+
+template <typename T>
+inline internal::AllOfArrayMatcher<T> AllOfArray(
+    ::std::initializer_list<T> xs) {
+  return AllOfArray(xs.begin(), xs.end());
+}
+
+// Args<N1, N2, ..., Nk>(a_matcher) matches a tuple if the selected
+// fields of it matches a_matcher.  C++ doesn't support default
+// arguments for function templates, so we have to overload it.
+template <size_t... k, typename InnerMatcher>
+internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...> Args(
+    InnerMatcher&& matcher) {
+  return internal::ArgsMatcher<typename std::decay<InnerMatcher>::type, k...>(
+      std::forward<InnerMatcher>(matcher));
+}
+
+// AllArgs(m) is a synonym of m.  This is useful in
+//
+//   EXPECT_CALL(foo, Bar(_, _)).With(AllArgs(Eq()));
+//
+// which is easier to read than
+//
+//   EXPECT_CALL(foo, Bar(_, _)).With(Eq());
+template <typename InnerMatcher>
+inline InnerMatcher AllArgs(const InnerMatcher& matcher) { return matcher; }
+
+// 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
+// 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
+// optional value contains an optional itself.
+template <typename ValueMatcher>
+inline internal::OptionalMatcher<ValueMatcher> Optional(
+    const ValueMatcher& value_matcher) {
+  return internal::OptionalMatcher<ValueMatcher>(value_matcher);
+}
+
+// Returns a matcher that matches the value of a absl::any type variable.
+template <typename T>
+PolymorphicMatcher<internal::any_cast_matcher::AnyCastMatcher<T> > AnyWith(
+    const Matcher<const T&>& matcher) {
+  return MakePolymorphicMatcher(
+      internal::any_cast_matcher::AnyCastMatcher<T>(matcher));
+}
+
+// Returns a matcher that matches the value of a variant<> type variable.
+// The matcher implementation uses ADL to find the holds_alternative and get
+// functions.
+// It is compatible with std::variant.
+template <typename T>
+PolymorphicMatcher<internal::variant_matcher::VariantMatcher<T> > VariantWith(
+    const Matcher<const T&>& matcher) {
+  return MakePolymorphicMatcher(
+      internal::variant_matcher::VariantMatcher<T>(matcher));
+}
+
+#if GTEST_HAS_EXCEPTIONS
+
+// Anything inside the `internal` namespace is internal to the implementation
+// and must not be used in user code!
+namespace internal {
+
+class WithWhatMatcherImpl {
+ public:
+  WithWhatMatcherImpl(Matcher<std::string> matcher)
+      : matcher_(std::move(matcher)) {}
+
+  void DescribeTo(std::ostream* os) const {
+    *os << "contains .what() that ";
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(std::ostream* os) const {
+    *os << "contains .what() that does not ";
+    matcher_.DescribeTo(os);
+  }
+
+  template <typename Err>
+  bool MatchAndExplain(const Err& err, MatchResultListener* listener) const {
+    *listener << "which contains .what() that ";
+    return matcher_.MatchAndExplain(err.what(), listener);
+  }
+
+ private:
+  const Matcher<std::string> matcher_;
+};
+
+inline PolymorphicMatcher<WithWhatMatcherImpl> WithWhat(
+    Matcher<std::string> m) {
+  return MakePolymorphicMatcher(WithWhatMatcherImpl(std::move(m)));
+}
+
+template <typename Err>
+class ExceptionMatcherImpl {
+  class NeverThrown {
+   public:
+    const char* what() const noexcept {
+      return "this exception should never be thrown";
+    }
+  };
+
+  // If the matchee raises an exception of a wrong type, we'd like to
+  // catch it and print its message and type. To do that, we add an additional
+  // catch clause:
+  //
+  //     try { ... }
+  //     catch (const Err&) { /* an expected exception */ }
+  //     catch (const std::exception&) { /* exception of a wrong type */ }
+  //
+  // However, if the `Err` itself is `std::exception`, we'd end up with two
+  // identical `catch` clauses:
+  //
+  //     try { ... }
+  //     catch (const std::exception&) { /* an expected exception */ }
+  //     catch (const std::exception&) { /* exception of a wrong type */ }
+  //
+  // This can cause a warning or an error in some compilers. To resolve
+  // the issue, we use a fake error type whenever `Err` is `std::exception`:
+  //
+  //     try { ... }
+  //     catch (const std::exception&) { /* an expected exception */ }
+  //     catch (const NeverThrown&) { /* exception of a wrong type */ }
+  using DefaultExceptionType = typename std::conditional<
+      std::is_same<typename std::remove_cv<
+                       typename std::remove_reference<Err>::type>::type,
+                   std::exception>::value,
+      const NeverThrown&, const std::exception&>::type;
+
+ public:
+  ExceptionMatcherImpl(Matcher<const Err&> matcher)
+      : matcher_(std::move(matcher)) {}
+
+  void DescribeTo(std::ostream* os) const {
+    *os << "throws an exception which is a " << GetTypeName<Err>();
+    *os << " which ";
+    matcher_.DescribeTo(os);
+  }
+
+  void DescribeNegationTo(std::ostream* os) const {
+    *os << "throws an exception which is not a " << GetTypeName<Err>();
+    *os << " which ";
+    matcher_.DescribeNegationTo(os);
+  }
+
+  template <typename T>
+  bool MatchAndExplain(T&& x, MatchResultListener* listener) const {
+    try {
+      (void)(std::forward<T>(x)());
+    } catch (const Err& err) {
+      *listener << "throws an exception which is a " << GetTypeName<Err>();
+      *listener << " ";
+      return matcher_.MatchAndExplain(err, listener);
+    } catch (DefaultExceptionType err) {
+#if GTEST_HAS_RTTI
+      *listener << "throws an exception of type " << GetTypeName(typeid(err));
+      *listener << " ";
+#else
+      *listener << "throws an std::exception-derived type ";
+#endif
+      *listener << "with description \"" << err.what() << "\"";
+      return false;
+    } catch (...) {
+      *listener << "throws an exception of an unknown type";
+      return false;
+    }
+
+    *listener << "does not throw any exception";
+    return false;
+  }
+
+ private:
+  const Matcher<const Err&> matcher_;
+};
+
+}  // namespace internal
+
+// Throws()
+// Throws(exceptionMatcher)
+// ThrowsMessage(messageMatcher)
+//
+// This matcher accepts a callable and verifies that when invoked, it throws
+// an exception with the given type and properties.
+//
+// Examples:
+//
+//   EXPECT_THAT(
+//       []() { throw std::runtime_error("message"); },
+//       Throws<std::runtime_error>());
+//
+//   EXPECT_THAT(
+//       []() { throw std::runtime_error("message"); },
+//       ThrowsMessage<std::runtime_error>(HasSubstr("message")));
+//
+//   EXPECT_THAT(
+//       []() { throw std::runtime_error("message"); },
+//       Throws<std::runtime_error>(
+//           Property(&std::runtime_error::what, HasSubstr("message"))));
+
+template <typename Err>
+PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> Throws() {
+  return MakePolymorphicMatcher(
+      internal::ExceptionMatcherImpl<Err>(A<const Err&>()));
+}
+
+template <typename Err, typename ExceptionMatcher>
+PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> Throws(
+    const ExceptionMatcher& exception_matcher) {
+  // Using matcher cast allows users to pass a matcher of a more broad type.
+  // For example user may want to pass Matcher<std::exception>
+  // to Throws<std::runtime_error>, or Matcher<int64> to Throws<int32>.
+  return MakePolymorphicMatcher(internal::ExceptionMatcherImpl<Err>(
+      SafeMatcherCast<const Err&>(exception_matcher)));
+}
+
+template <typename Err, typename MessageMatcher>
+PolymorphicMatcher<internal::ExceptionMatcherImpl<Err>> ThrowsMessage(
+    MessageMatcher&& message_matcher) {
+  static_assert(std::is_base_of<std::exception, Err>::value,
+                "expected an std::exception-derived type");
+  return Throws<Err>(internal::WithWhat(
+      MatcherCast<std::string>(std::forward<MessageMatcher>(message_matcher))));
+}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// These macros allow using matchers to check values in Google Test
+// tests.  ASSERT_THAT(value, matcher) and EXPECT_THAT(value, matcher)
+// succeed if and only if the value matches the matcher.  If the assertion
+// fails, the value and the description of the matcher will be printed.
+#define ASSERT_THAT(value, matcher) ASSERT_PRED_FORMAT1(\
+    ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)
+#define EXPECT_THAT(value, matcher) EXPECT_PRED_FORMAT1(\
+    ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value)
+
+// MATCHER* macroses 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 {                   \
+        ::std::string gmock_description = (description);                       \
+        if (!gmock_description.empty()) {                                      \
+          return gmock_description;                                            \
+        }                                                                      \
+        return ::testing::internal::FormatMatcherDescription(negation, #name,  \
+                                                             {});              \
+      }                                                                        \
+    };                                                                         \
+  };                                                                           \
+  GTEST_ATTRIBUTE_UNUSED_ inline name##Matcher name() { 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_P(name, p0, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP, description, (p0))
+#define MATCHER_P2(name, p0, p1, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP2, description, (p0, p1))
+#define MATCHER_P3(name, p0, p1, p2, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP3, description, (p0, p1, p2))
+#define MATCHER_P4(name, p0, p1, p2, p3, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP4, description, (p0, p1, p2, p3))
+#define MATCHER_P5(name, p0, p1, p2, p3, p4, description)    \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP5, description, \
+                         (p0, p1, p2, p3, p4))
+#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP6, description,  \
+                         (p0, p1, p2, p3, p4, p5))
+#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP7, description,      \
+                         (p0, p1, p2, p3, p4, p5, p6))
+#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP8, description,          \
+                         (p0, p1, p2, p3, p4, p5, p6, p7))
+#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP9, description,              \
+                         (p0, p1, p2, p3, p4, p5, p6, p7, p8))
+#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description) \
+  GMOCK_INTERNAL_MATCHER(name, name##MatcherP10, description,                  \
+                         (p0, p1, p2, p3, p4, p5, p6, p7, p8, p9))
+
+#define GMOCK_INTERNAL_MATCHER(name, full_name, description, args)             \
+  template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \
+  class full_name : public ::testing::internal::MatcherBaseImpl<               \
+                        full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>> { \
+   public:                                                                     \
+    using full_name::MatcherBaseImpl::MatcherBaseImpl;                         \
+    template <typename arg_type>                                               \
+    class gmock_Impl : public ::testing::MatcherInterface<const arg_type&> {   \
+     public:                                                                   \
+      explicit gmock_Impl(GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args))          \
+          : GMOCK_INTERNAL_MATCHER_FORWARD_ARGS(args) {}                       \
+      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);                                  \
+      }                                                                        \
+      GMOCK_INTERNAL_MATCHER_MEMBERS(args)                                     \
+                                                                               \
+     private:                                                                  \
+      ::std::string FormatDescription(bool negation) const {                   \
+        ::std::string gmock_description = (description);                       \
+        if (!gmock_description.empty()) {                                      \
+          return gmock_description;                                            \
+        }                                                                      \
+        return ::testing::internal::FormatMatcherDescription(                  \
+            negation, #name,                                                   \
+            ::testing::internal::UniversalTersePrintTupleFieldsToStrings(      \
+                ::std::tuple<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>(        \
+                    GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args))));             \
+      }                                                                        \
+    };                                                                         \
+  };                                                                           \
+  template <GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args)>                      \
+  inline full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)> name(             \
+      GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args)) {                            \
+    return full_name<GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args)>(                \
+        GMOCK_INTERNAL_MATCHER_ARGS_USAGE(args));                              \
+  }                                                                            \
+  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
+
+#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAMS(args) \
+  GMOCK_PP_TAIL(                                     \
+      GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAM, , args))
+#define GMOCK_INTERNAL_MATCHER_TEMPLATE_PARAM(i_unused, data_unused, arg) \
+  , typename arg##_type
+
+#define GMOCK_INTERNAL_MATCHER_TYPE_PARAMS(args) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_TYPE_PARAM, , args))
+#define GMOCK_INTERNAL_MATCHER_TYPE_PARAM(i_unused, data_unused, arg) \
+  , arg##_type
+
+#define GMOCK_INTERNAL_MATCHER_FUNCTION_ARGS(args) \
+  GMOCK_PP_TAIL(dummy_first GMOCK_PP_FOR_EACH(     \
+      GMOCK_INTERNAL_MATCHER_FUNCTION_ARG, , args))
+#define GMOCK_INTERNAL_MATCHER_FUNCTION_ARG(i, data_unused, arg) \
+  , arg##_type gmock_p##i
+
+#define GMOCK_INTERNAL_MATCHER_FORWARD_ARGS(args) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_FORWARD_ARG, , args))
+#define GMOCK_INTERNAL_MATCHER_FORWARD_ARG(i, data_unused, arg) \
+  , arg(::std::forward<arg##_type>(gmock_p##i))
+
+#define GMOCK_INTERNAL_MATCHER_MEMBERS(args) \
+  GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_MEMBER, , args)
+#define GMOCK_INTERNAL_MATCHER_MEMBER(i_unused, data_unused, arg) \
+  const arg##_type arg;
+
+#define GMOCK_INTERNAL_MATCHER_MEMBERS_USAGE(args) \
+  GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_MATCHER_MEMBER_USAGE, , args))
+#define GMOCK_INTERNAL_MATCHER_MEMBER_USAGE(i_unused, data_unused, arg) , arg
+
+#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
+
+// To prevent ADL on certain functions we put them on a separate namespace.
+using namespace no_adl;  // NOLINT
+
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 5046
+
+// Include any custom callback matchers added by the local installation.
+// We must include this header at the end to make sure it can use the
+// declarations from this file.
+#include "gmock/internal/custom/gmock-matchers.h"
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
diff --git a/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-more-actions.h b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-more-actions.h
new file mode 100644
index 000000000..fd293358a
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-more-actions.h
@@ -0,0 +1,573 @@
+// Copyright 2007, 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.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some commonly used variadic actions.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
+
+#include <memory>
+#include <utility>
+
+#include "gmock/gmock-actions.h"
+#include "gmock/internal/gmock-port.h"
+
+// Include any custom callback actions added by the local installation.
+#include "gmock/internal/custom/gmock-generated-actions.h"
+
+// Sometimes you want to give an action explicit template parameters
+// that cannot be inferred from its value parameters.  ACTION() and
+// ACTION_P*() don't support that.  ACTION_TEMPLATE() remedies that
+// and can be viewed as an extension to ACTION() and ACTION_P*().
+//
+// The syntax:
+//
+//   ACTION_TEMPLATE(ActionName,
+//                   HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m),
+//                   AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; }
+//
+// defines an action template that takes m explicit template
+// parameters and n value parameters.  name_i is the name of the i-th
+// template parameter, and kind_i specifies whether it's a typename,
+// an integral constant, or a template.  p_i is the name of the i-th
+// value parameter.
+//
+// Example:
+//
+//   // DuplicateArg<k, T>(output) converts the k-th argument of the mock
+//   // function to type T and copies it to *output.
+//   ACTION_TEMPLATE(DuplicateArg,
+//                   HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
+//                   AND_1_VALUE_PARAMS(output)) {
+//     *output = T(::std::get<k>(args));
+//   }
+//   ...
+//     int n;
+//     EXPECT_CALL(mock, Foo(_, _))
+//         .WillOnce(DuplicateArg<1, unsigned char>(&n));
+//
+// To create an instance of an action template, write:
+//
+//   ActionName<t1, ..., t_m>(v1, ..., v_n)
+//
+// where the ts are the template arguments and the vs are the value
+// arguments.  The value argument types are inferred by the compiler.
+// If you want to explicitly specify the value argument types, you can
+// provide additional template arguments:
+//
+//   ActionName<t1, ..., t_m, u1, ..., u_k>(v1, ..., v_n)
+//
+// where u_i is the desired type of v_i.
+//
+// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the
+// number of value parameters, but not on the number of template
+// parameters.  Without the restriction, the meaning of the following
+// is unclear:
+//
+//   OverloadedAction<int, bool>(x);
+//
+// Are we using a single-template-parameter action where 'bool' refers
+// to the type of x, or are we using a two-template-parameter action
+// where the compiler is asked to infer the type of x?
+//
+// Implementation notes:
+//
+// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and
+// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for
+// implementing ACTION_TEMPLATE.  The main trick we use is to create
+// new macro invocations when expanding a macro.  For example, we have
+//
+//   #define ACTION_TEMPLATE(name, template_params, value_params)
+//       ... GMOCK_INTERNAL_DECL_##template_params ...
+//
+// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...)
+// to expand to
+//
+//       ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ...
+//
+// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the
+// preprocessor will continue to expand it to
+//
+//       ... typename T ...
+//
+// This technique conforms to the C++ standard and is portable.  It
+// allows us to implement action templates using O(N) code, where N is
+// the maximum number of template/value parameters supported.  Without
+// using it, we'd have to devote O(N^2) amount of code to implement all
+// combinations of m and n.
+
+// Declares the template parameters.
+#define GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(kind0, name0) kind0 name0
+#define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
+    name1) kind0 name0, kind1 name1
+#define GMOCK_INTERNAL_DECL_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2) kind0 name0, kind1 name1, kind2 name2
+#define GMOCK_INTERNAL_DECL_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3) kind0 name0, kind1 name1, kind2 name2, \
+    kind3 name3
+#define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4) kind0 name0, kind1 name1, \
+    kind2 name2, kind3 name3, kind4 name4
+#define GMOCK_INTERNAL_DECL_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5) kind0 name0, \
+    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5
+#define GMOCK_INTERNAL_DECL_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
+    name6) kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \
+    kind5 name5, kind6 name6
+#define GMOCK_INTERNAL_DECL_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
+    kind7, name7) kind0 name0, kind1 name1, kind2 name2, kind3 name3, \
+    kind4 name4, kind5 name5, kind6 name6, kind7 name7
+#define GMOCK_INTERNAL_DECL_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
+    kind7, name7, kind8, name8) kind0 name0, kind1 name1, kind2 name2, \
+    kind3 name3, kind4 name4, kind5 name5, kind6 name6, kind7 name7, \
+    kind8 name8
+#define GMOCK_INTERNAL_DECL_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
+    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
+    name6, kind7, name7, kind8, name8, kind9, name9) kind0 name0, \
+    kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5, \
+    kind6 name6, kind7 name7, kind8 name8, kind9 name9
+
+// Lists the template parameters.
+#define GMOCK_INTERNAL_LIST_HAS_1_TEMPLATE_PARAMS(kind0, name0) name0
+#define GMOCK_INTERNAL_LIST_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \
+    name1) name0, name1
+#define GMOCK_INTERNAL_LIST_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2) name0, name1, name2
+#define GMOCK_INTERNAL_LIST_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3) name0, name1, name2, name3
+#define GMOCK_INTERNAL_LIST_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4) name0, name1, name2, name3, \
+    name4
+#define GMOCK_INTERNAL_LIST_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5) name0, name1, \
+    name2, name3, name4, name5
+#define GMOCK_INTERNAL_LIST_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
+    name6) name0, name1, name2, name3, name4, name5, name6
+#define GMOCK_INTERNAL_LIST_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
+    kind7, name7) name0, name1, name2, name3, name4, name5, name6, name7
+#define GMOCK_INTERNAL_LIST_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \
+    kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \
+    kind7, name7, kind8, name8) name0, name1, name2, name3, name4, name5, \
+    name6, name7, name8
+#define GMOCK_INTERNAL_LIST_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \
+    name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \
+    name6, kind7, name7, kind8, name8, kind9, name9) name0, name1, name2, \
+    name3, name4, name5, name6, name7, name8, name9
+
+// Declares the types of value parameters.
+#define GMOCK_INTERNAL_DECL_TYPE_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_DECL_TYPE_AND_1_VALUE_PARAMS(p0) , typename p0##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_2_VALUE_PARAMS(p0, p1) , \
+    typename p0##_type, typename p1##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , \
+    typename p0##_type, typename p1##_type, typename p2##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
+    typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
+    typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
+    typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type, typename p5##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) , typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type, typename p5##_type, \
+    typename p6##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7) , typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type, typename p5##_type, \
+    typename p6##_type, typename p7##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7, p8) , typename p0##_type, typename p1##_type, typename p2##_type, \
+    typename p3##_type, typename p4##_type, typename p5##_type, \
+    typename p6##_type, typename p7##_type, typename p8##_type
+#define GMOCK_INTERNAL_DECL_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7, p8, p9) , typename p0##_type, typename p1##_type, \
+    typename p2##_type, typename p3##_type, typename p4##_type, \
+    typename p5##_type, typename p6##_type, typename p7##_type, \
+    typename p8##_type, typename p9##_type
+
+// Initializes the value parameters.
+#define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS()\
+    ()
+#define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0)\
+    (p0##_type gmock_p0) : p0(::std::move(gmock_p0))
+#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\
+    (p0##_type gmock_p0, p1##_type gmock_p1) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1))
+#define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, \
+        p2##_type gmock_p2) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2))
+#define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3))
+#define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4))
+#define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, \
+        p5##_type gmock_p5) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
+        p5(::std::move(gmock_p5))
+#define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+        p6##_type gmock_p6) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
+        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6))
+#define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+        p6##_type gmock_p6, p7##_type gmock_p7) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
+        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
+        p7(::std::move(gmock_p7))
+#define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+        p6##_type gmock_p6, p7##_type gmock_p7, \
+        p8##_type gmock_p8) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
+        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
+        p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8))
+#define GMOCK_INTERNAL_INIT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9)\
+    (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \
+        p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \
+        p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \
+        p9##_type gmock_p9) : p0(::std::move(gmock_p0)), \
+        p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \
+        p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \
+        p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \
+        p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)), \
+        p9(::std::move(gmock_p9))
+
+// Defines the copy constructor
+#define GMOCK_INTERNAL_DEFN_COPY_AND_0_VALUE_PARAMS() \
+    {}  // Avoid https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82134
+#define GMOCK_INTERNAL_DEFN_COPY_AND_1_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_2_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_3_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_4_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_5_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_6_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_7_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_8_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_9_VALUE_PARAMS(...) = default;
+#define GMOCK_INTERNAL_DEFN_COPY_AND_10_VALUE_PARAMS(...) = default;
+
+// Declares the fields for storing the value parameters.
+#define GMOCK_INTERNAL_DEFN_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_DEFN_AND_1_VALUE_PARAMS(p0) p0##_type p0;
+#define GMOCK_INTERNAL_DEFN_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0; \
+    p1##_type p1;
+#define GMOCK_INTERNAL_DEFN_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0; \
+    p1##_type p1; p2##_type p2;
+#define GMOCK_INTERNAL_DEFN_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0; \
+    p1##_type p1; p2##_type p2; p3##_type p3;
+#define GMOCK_INTERNAL_DEFN_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
+    p4) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4;
+#define GMOCK_INTERNAL_DEFN_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
+    p5) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
+    p5##_type p5;
+#define GMOCK_INTERNAL_DEFN_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
+    p5##_type p5; p6##_type p6;
+#define GMOCK_INTERNAL_DEFN_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \
+    p5##_type p5; p6##_type p6; p7##_type p7;
+#define GMOCK_INTERNAL_DEFN_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
+    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8;
+#define GMOCK_INTERNAL_DEFN_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \
+    p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; \
+    p9##_type p9;
+
+// Lists the value parameters.
+#define GMOCK_INTERNAL_LIST_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_LIST_AND_1_VALUE_PARAMS(p0) p0
+#define GMOCK_INTERNAL_LIST_AND_2_VALUE_PARAMS(p0, p1) p0, p1
+#define GMOCK_INTERNAL_LIST_AND_3_VALUE_PARAMS(p0, p1, p2) p0, p1, p2
+#define GMOCK_INTERNAL_LIST_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0, p1, p2, p3
+#define GMOCK_INTERNAL_LIST_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) p0, p1, \
+    p2, p3, p4
+#define GMOCK_INTERNAL_LIST_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) p0, \
+    p1, p2, p3, p4, p5
+#define GMOCK_INTERNAL_LIST_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) p0, p1, p2, p3, p4, p5, p6
+#define GMOCK_INTERNAL_LIST_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7) p0, p1, p2, p3, p4, p5, p6, p7
+#define GMOCK_INTERNAL_LIST_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8) p0, p1, p2, p3, p4, p5, p6, p7, p8
+#define GMOCK_INTERNAL_LIST_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9) p0, p1, p2, p3, p4, p5, p6, p7, p8, p9
+
+// Lists the value parameter types.
+#define GMOCK_INTERNAL_LIST_TYPE_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_LIST_TYPE_AND_1_VALUE_PARAMS(p0) , p0##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_2_VALUE_PARAMS(p0, p1) , p0##_type, \
+    p1##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , p0##_type, \
+    p1##_type, p2##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \
+    p0##_type, p1##_type, p2##_type, p3##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \
+    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \
+    p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \
+    p6##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+    p5##_type, p6##_type, p7##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7, p8) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+    p5##_type, p6##_type, p7##_type, p8##_type
+#define GMOCK_INTERNAL_LIST_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6, p7, p8, p9) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \
+    p5##_type, p6##_type, p7##_type, p8##_type, p9##_type
+
+// Declares the value parameters.
+#define GMOCK_INTERNAL_DECL_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_DECL_AND_1_VALUE_PARAMS(p0) p0##_type p0
+#define GMOCK_INTERNAL_DECL_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0, \
+    p1##_type p1
+#define GMOCK_INTERNAL_DECL_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0, \
+    p1##_type p1, p2##_type p2
+#define GMOCK_INTERNAL_DECL_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0, \
+    p1##_type p1, p2##_type p2, p3##_type p3
+#define GMOCK_INTERNAL_DECL_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \
+    p4) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4
+#define GMOCK_INTERNAL_DECL_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \
+    p5) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
+    p5##_type p5
+#define GMOCK_INTERNAL_DECL_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \
+    p6) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
+    p5##_type p5, p6##_type p6
+#define GMOCK_INTERNAL_DECL_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \
+    p5##_type p5, p6##_type p6, p7##_type p7
+#define GMOCK_INTERNAL_DECL_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
+    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8
+#define GMOCK_INTERNAL_DECL_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \
+    p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \
+    p9##_type p9
+
+// The suffix of the class template implementing the action template.
+#define GMOCK_INTERNAL_COUNT_AND_0_VALUE_PARAMS()
+#define GMOCK_INTERNAL_COUNT_AND_1_VALUE_PARAMS(p0) P
+#define GMOCK_INTERNAL_COUNT_AND_2_VALUE_PARAMS(p0, p1) P2
+#define GMOCK_INTERNAL_COUNT_AND_3_VALUE_PARAMS(p0, p1, p2) P3
+#define GMOCK_INTERNAL_COUNT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) P4
+#define GMOCK_INTERNAL_COUNT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) P5
+#define GMOCK_INTERNAL_COUNT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) P6
+#define GMOCK_INTERNAL_COUNT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) P7
+#define GMOCK_INTERNAL_COUNT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7) P8
+#define GMOCK_INTERNAL_COUNT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8) P9
+#define GMOCK_INTERNAL_COUNT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \
+    p7, p8, p9) P10
+
+// The name of the class template implementing the action template.
+#define GMOCK_ACTION_CLASS_(name, value_params)\
+    GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params)
+
+#define ACTION_TEMPLATE(name, template_params, value_params)                   \
+  template <GMOCK_INTERNAL_DECL_##template_params                              \
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
+  class GMOCK_ACTION_CLASS_(name, value_params) {                              \
+   public:                                                                     \
+    explicit GMOCK_ACTION_CLASS_(name, value_params)(                          \
+        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)) { })      \
+    GMOCK_ACTION_CLASS_(name, value_params)(                                   \
+        const GMOCK_ACTION_CLASS_(name, value_params)&) noexcept               \
+        GMOCK_INTERNAL_DEFN_COPY_##value_params                                \
+    GMOCK_ACTION_CLASS_(name, value_params)(                                   \
+        GMOCK_ACTION_CLASS_(name, value_params)&&) noexcept                    \
+        GMOCK_INTERNAL_DEFN_COPY_##value_params                                \
+    template <typename F>                                                      \
+    operator ::testing::Action<F>() const {                                    \
+      return GMOCK_PP_IF(                                                      \
+          GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),              \
+                      (::testing::internal::MakeAction<F, gmock_Impl>()),      \
+                      (::testing::internal::MakeAction<F>(impl_)));            \
+    }                                                                          \
+   private:                                                                    \
+    class gmock_Impl {                                                         \
+     public:                                                                   \
+      explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}                \
+      template <typename function_type, typename return_type,                  \
+                typename args_type, GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>         \
+      return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const;  \
+      GMOCK_INTERNAL_DEFN_##value_params                                       \
+    };                                                                         \
+    GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(GMOCK_INTERNAL_COUNT_##value_params),        \
+                , std::shared_ptr<const gmock_Impl> impl_;)                    \
+  };                                                                           \
+  template <GMOCK_INTERNAL_DECL_##template_params                              \
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
+  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_;          \
+  template <GMOCK_INTERNAL_DECL_##template_params                              \
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
+  inline GMOCK_ACTION_CLASS_(name, value_params)<                              \
+      GMOCK_INTERNAL_LIST_##template_params                                    \
+      GMOCK_INTERNAL_LIST_TYPE_##value_params> name(                           \
+          GMOCK_INTERNAL_DECL_##value_params) {                                \
+    return GMOCK_ACTION_CLASS_(name, value_params)<                            \
+        GMOCK_INTERNAL_LIST_##template_params                                  \
+        GMOCK_INTERNAL_LIST_TYPE_##value_params>(                              \
+            GMOCK_INTERNAL_LIST_##value_params);                               \
+  }                                                                            \
+  template <GMOCK_INTERNAL_DECL_##template_params                              \
+            GMOCK_INTERNAL_DECL_TYPE_##value_params>                           \
+  template <typename function_type, typename return_type, typename args_type,  \
+            GMOCK_ACTION_TEMPLATE_ARGS_NAMES_>                                 \
+  return_type GMOCK_ACTION_CLASS_(name, value_params)<                         \
+      GMOCK_INTERNAL_LIST_##template_params                                    \
+      GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl::gmock_PerformImpl( \
+          GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const
+
+namespace testing {
+
+// The ACTION*() macros trigger warning C4100 (unreferenced formal
+// parameter) in MSVC with -W4.  Unfortunately they cannot be fixed in
+// the macro definition, as the warnings are generated when the macro
+// is expanded and macro expansion cannot contain #pragma.  Therefore
+// we suppress them here.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#endif
+
+namespace internal {
+
+// internal::InvokeArgument - a helper for InvokeArgument action.
+// The basic overloads are provided here for generic functors.
+// 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...);
+}
+
+template <std::size_t index, typename... Params>
+struct InvokeArgumentAction {
+  template <typename... Args>
+  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>();
+      return internal::InvokeArgument(
+          std::forward<decltype(callable)>(callable), unpacked_params...);
+    });
+  }
+
+  internal::FlatTuple<Params...> params;
+};
+
+}  // namespace internal
+
+// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
+// (0-based) argument, which must be a k-ary callable, of the mock
+// function, with arguments a1, a2, ..., a_k.
+//
+// Notes:
+//
+//   1. The arguments are passed by value by default.  If you need to
+//   pass an argument by reference, wrap it inside std::ref().  For
+//   example,
+//
+//     InvokeArgument<1>(5, string("Hello"), std::ref(foo))
+//
+//   passes 5 and string("Hello") by value, and passes foo by
+//   reference.
+//
+//   2. If the callable takes an argument by reference but std::ref() is
+//   not used, it will receive the reference to a copy of the value,
+//   instead of the original value.  For example, when the 0-th
+//   argument of the mock function takes a const string&, the action
+//
+//     InvokeArgument<0>(string("Hello"))
+//
+//   makes a copy of the temporary string("Hello") object and passes a
+//   reference of the copy, instead of the original temporary object,
+//   to the callable.  This makes it easy for a user to define an
+//   InvokeArgument action from temporary values and have it performed
+//   later.
+template <std::size_t index, typename... Params>
+internal::InvokeArgumentAction<index, typename std::decay<Params>::type...>
+InvokeArgument(Params&&... params) {
+  return {internal::FlatTuple<typename std::decay<Params>::type...>(
+      internal::FlatTupleConstructTag{}, std::forward<Params>(params)...)};
+}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+}  // namespace testing
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
diff --git a/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-more-matchers.h b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-more-matchers.h
new file mode 100644
index 000000000..dfc77e359
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-more-matchers.h
@@ -0,0 +1,92 @@
+// Copyright 2013, 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.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements some matchers that depend on gmock-matchers.h.
+//
+// Note that tests are implemented in gmock-matchers_test.cc rather than
+// gmock-more-matchers-test.cc.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_
+
+#include "gmock/gmock-matchers.h"
+
+namespace testing {
+
+// Silence C4100 (unreferenced formal
+// parameter) for MSVC
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+#if (_MSC_VER == 1900)
+// and silence C4800 (C4800: 'int *const ': forcing value
+// to bool 'true' or 'false') for MSVC 14
+# pragma warning(disable:4800)
+  #endif
+#endif
+
+// Defines a matcher that matches an empty container. The container must
+// support both size() and empty(), which all STL-like containers provide.
+MATCHER(IsEmpty, negation ? "isn't empty" : "is empty") {
+  if (arg.empty()) {
+    return true;
+  }
+  *result_listener << "whose size is " << arg.size();
+  return false;
+}
+
+// Define a matcher that matches a value that evaluates in boolean
+// context to true.  Useful for types that define "explicit operator
+// bool" operators and so can't be compared for equality with true
+// and false.
+MATCHER(IsTrue, negation ? "is false" : "is true") {
+  return static_cast<bool>(arg);
+}
+
+// Define a matcher that matches a value that evaluates in boolean
+// context to false.  Useful for types that define "explicit operator
+// bool" operators and so can't be compared for equality with true
+// and false.
+MATCHER(IsFalse, negation ? "is true" : "is false") {
+  return !static_cast<bool>(arg);
+}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+
+}  // namespace testing
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MORE_MATCHERS_H_
diff --git a/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-nice-strict.h b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-nice-strict.h
new file mode 100644
index 000000000..b03b770c7
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-nice-strict.h
@@ -0,0 +1,261 @@
+// Copyright 2008, 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.
+
+
+// Implements class templates NiceMock, NaggyMock, and StrictMock.
+//
+// Given a mock class MockFoo that is created using Google Mock,
+// NiceMock<MockFoo> is a subclass of MockFoo that allows
+// uninteresting calls (i.e. calls to mock methods that have no
+// EXPECT_CALL specs), NaggyMock<MockFoo> is a subclass of MockFoo
+// that prints a warning when an uninteresting call occurs, and
+// StrictMock<MockFoo> is a subclass of MockFoo that treats all
+// uninteresting calls as errors.
+//
+// Currently a mock is naggy by default, so MockFoo and
+// NaggyMock<MockFoo> behave like the same.  However, we will soon
+// switch the default behavior of mocks to be nice, as that in general
+// leads to more maintainable tests.  When that happens, MockFoo will
+// stop behaving like NaggyMock<MockFoo> and start behaving like
+// NiceMock<MockFoo>.
+//
+// NiceMock, NaggyMock, and StrictMock "inherit" the constructors of
+// their respective base class.  Therefore you can write
+// NiceMock<MockFoo>(5, "a") to construct a nice mock where MockFoo
+// has a constructor that accepts (int, const char*), for example.
+//
+// A known limitation is that NiceMock<MockFoo>, NaggyMock<MockFoo>,
+// and StrictMock<MockFoo> only works for mock methods defined using
+// the MOCK_METHOD* family of macros DIRECTLY in the MockFoo class.
+// If a mock method is defined in a base class of MockFoo, the "nice"
+// or "strict" modifier may not affect it, depending on the compiler.
+// In particular, nesting NiceMock, NaggyMock, and StrictMock is NOT
+// supported.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
+
+#include <type_traits>
+
+#include "gmock/gmock-spec-builders.h"
+#include "gmock/internal/gmock-port.h"
+
+namespace testing {
+template <class MockClass>
+class NiceMock;
+template <class MockClass>
+class NaggyMock;
+template <class MockClass>
+class StrictMock;
+
+namespace internal {
+template <typename T>
+std::true_type StrictnessModifierProbe(const NiceMock<T>&);
+template <typename T>
+std::true_type StrictnessModifierProbe(const NaggyMock<T>&);
+template <typename T>
+std::true_type StrictnessModifierProbe(const StrictMock<T>&);
+std::false_type StrictnessModifierProbe(...);
+
+template <typename T>
+constexpr bool HasStrictnessModifier() {
+  return decltype(StrictnessModifierProbe(std::declval<const T&>()))::value;
+}
+
+// Base classes that register and deregister with testing::Mock to alter the
+// default behavior around uninteresting calls. Inheriting from one of these
+// classes first and then MockClass ensures the MockClass constructor is run
+// after registration, and that the MockClass destructor runs before
+// deregistration. This guarantees that MockClass's constructor and destructor
+// run with the same level of strictness as its instance methods.
+
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW && \
+    (defined(_MSC_VER) || defined(__clang__))
+// We need to mark these classes with this declspec to ensure that
+// the empty base class optimization is performed.
+#define GTEST_INTERNAL_EMPTY_BASE_CLASS __declspec(empty_bases)
+#else
+#define GTEST_INTERNAL_EMPTY_BASE_CLASS
+#endif
+
+template <typename Base>
+class NiceMockImpl {
+ public:
+  NiceMockImpl() { ::testing::Mock::AllowUninterestingCalls(this); }
+
+  ~NiceMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
+};
+
+template <typename Base>
+class NaggyMockImpl {
+ public:
+  NaggyMockImpl() { ::testing::Mock::WarnUninterestingCalls(this); }
+
+  ~NaggyMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
+};
+
+template <typename Base>
+class StrictMockImpl {
+ public:
+  StrictMockImpl() { ::testing::Mock::FailUninterestingCalls(this); }
+
+  ~StrictMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
+};
+
+}  // namespace internal
+
+template <class MockClass>
+class GTEST_INTERNAL_EMPTY_BASE_CLASS NiceMock
+    : private internal::NiceMockImpl<MockClass>,
+      public MockClass {
+ public:
+  static_assert(!internal::HasStrictnessModifier<MockClass>(),
+                "Can't apply NiceMock to a class hierarchy that already has a "
+                "strictness modifier. See "
+                "https://google.github.io/googletest/"
+                "gmock_cook_book.html#NiceStrictNaggy");
+  NiceMock() : MockClass() {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+  // Ideally, we would inherit base class's constructors through a using
+  // declaration, which would preserve their visibility. However, many existing
+  // tests rely on the fact that current implementation reexports protected
+  // constructors as public. These tests would need to be cleaned up first.
+
+  // Single argument constructor is special-cased so that it can be
+  // made explicit.
+  template <typename A>
+  explicit NiceMock(A&& arg) : MockClass(std::forward<A>(arg)) {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+  template <typename TArg1, typename TArg2, typename... An>
+  NiceMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
+      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
+                  std::forward<An>(args)...) {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
+};
+
+template <class MockClass>
+class GTEST_INTERNAL_EMPTY_BASE_CLASS NaggyMock
+    : private internal::NaggyMockImpl<MockClass>,
+      public MockClass {
+  static_assert(!internal::HasStrictnessModifier<MockClass>(),
+                "Can't apply NaggyMock to a class hierarchy that already has a "
+                "strictness modifier. See "
+                "https://google.github.io/googletest/"
+                "gmock_cook_book.html#NiceStrictNaggy");
+
+ public:
+  NaggyMock() : MockClass() {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+  // Ideally, we would inherit base class's constructors through a using
+  // declaration, which would preserve their visibility. However, many existing
+  // tests rely on the fact that current implementation reexports protected
+  // constructors as public. These tests would need to be cleaned up first.
+
+  // Single argument constructor is special-cased so that it can be
+  // made explicit.
+  template <typename A>
+  explicit NaggyMock(A&& arg) : MockClass(std::forward<A>(arg)) {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+  template <typename TArg1, typename TArg2, typename... An>
+  NaggyMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
+      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
+                  std::forward<An>(args)...) {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
+};
+
+template <class MockClass>
+class GTEST_INTERNAL_EMPTY_BASE_CLASS StrictMock
+    : private internal::StrictMockImpl<MockClass>,
+      public MockClass {
+ public:
+  static_assert(
+      !internal::HasStrictnessModifier<MockClass>(),
+      "Can't apply StrictMock to a class hierarchy that already has a "
+      "strictness modifier. See "
+      "https://google.github.io/googletest/"
+      "gmock_cook_book.html#NiceStrictNaggy");
+  StrictMock() : MockClass() {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+  // Ideally, we would inherit base class's constructors through a using
+  // declaration, which would preserve their visibility. However, many existing
+  // tests rely on the fact that current implementation reexports protected
+  // constructors as public. These tests would need to be cleaned up first.
+
+  // Single argument constructor is special-cased so that it can be
+  // made explicit.
+  template <typename A>
+  explicit StrictMock(A&& arg) : MockClass(std::forward<A>(arg)) {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+  template <typename TArg1, typename TArg2, typename... An>
+  StrictMock(TArg1&& arg1, TArg2&& arg2, An&&... args)
+      : MockClass(std::forward<TArg1>(arg1), std::forward<TArg2>(arg2),
+                  std::forward<An>(args)...) {
+    static_assert(sizeof(*this) == sizeof(MockClass),
+                  "The impl subclass shouldn't introduce any padding");
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
+};
+
+#undef GTEST_INTERNAL_EMPTY_BASE_CLASS
+
+}  // namespace testing
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
diff --git a/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-spec-builders.h b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-spec-builders.h
new file mode 100644
index 000000000..41323c1cc
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock-spec-builders.h
@@ -0,0 +1,2038 @@
+// Copyright 2007, 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.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements the ON_CALL() and EXPECT_CALL() macros.
+//
+// A user can use the ON_CALL() macro to specify the default action of
+// a mock method.  The syntax is:
+//
+//   ON_CALL(mock_object, Method(argument-matchers))
+//       .With(multi-argument-matcher)
+//       .WillByDefault(action);
+//
+//  where the .With() clause is optional.
+//
+// A user can use the EXPECT_CALL() macro to specify an expectation on
+// a mock method.  The syntax is:
+//
+//   EXPECT_CALL(mock_object, Method(argument-matchers))
+//       .With(multi-argument-matchers)
+//       .Times(cardinality)
+//       .InSequence(sequences)
+//       .After(expectations)
+//       .WillOnce(action)
+//       .WillRepeatedly(action)
+//       .RetiresOnSaturation();
+//
+// where all clauses are optional, and .InSequence()/.After()/
+// .WillOnce() can appear any number of times.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include "gmock/gmock-actions.h"
+#include "gmock/gmock-cardinalities.h"
+#include "gmock/gmock-matchers.h"
+#include "gmock/internal/gmock-internal-utils.h"
+#include "gmock/internal/gmock-port.h"
+#include "gtest/gtest.h"
+
+#if GTEST_HAS_EXCEPTIONS
+# include <stdexcept>  // NOLINT
+#endif
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// An abstract handle of an expectation.
+class Expectation;
+
+// A set of expectation handles.
+class ExpectationSet;
+
+// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
+// and MUST NOT BE USED IN USER CODE!!!
+namespace internal {
+
+// Implements a mock function.
+template <typename F> class FunctionMocker;
+
+// Base class for expectations.
+class ExpectationBase;
+
+// Implements an expectation.
+template <typename F> class TypedExpectation;
+
+// Helper class for testing the Expectation class template.
+class ExpectationTester;
+
+// Helper classes for implementing NiceMock, StrictMock, and NaggyMock.
+template <typename MockClass>
+class NiceMockImpl;
+template <typename MockClass>
+class StrictMockImpl;
+template <typename MockClass>
+class NaggyMockImpl;
+
+// Protects the mock object registry (in class Mock), all function
+// mockers, and all expectations.
+//
+// The reason we don't use more fine-grained protection is: when a
+// mock function Foo() is called, it needs to consult its expectations
+// to see which one should be picked.  If another thread is allowed to
+// call a mock function (either Foo() or a different one) at the same
+// time, it could affect the "retired" attributes of Foo()'s
+// expectations when InSequence() is used, and thus affect which
+// expectation gets picked.  Therefore, we sequence all mock function
+// calls to ensure the integrity of the mock objects' states.
+GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_gmock_mutex);
+
+// Untyped base class for ActionResultHolder<R>.
+class UntypedActionResultHolderBase;
+
+// Abstract base class of FunctionMocker.  This is the
+// type-agnostic part of the function mocker interface.  Its pure
+// virtual methods are implemented by FunctionMocker.
+class GTEST_API_ UntypedFunctionMockerBase {
+ public:
+  UntypedFunctionMockerBase();
+  virtual ~UntypedFunctionMockerBase();
+
+  // Verifies that all expectations on this mock function have been
+  // satisfied.  Reports one or more Google Test non-fatal failures
+  // and returns false if not.
+  bool VerifyAndClearExpectationsLocked()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Clears the ON_CALL()s set on this mock function.
+  virtual void ClearDefaultActionsLocked()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) = 0;
+
+  // In all of the following Untyped* functions, it's the caller's
+  // responsibility to guarantee the correctness of the arguments'
+  // types.
+
+  // Performs the default action with the given arguments and returns
+  // the action's result.  The call description string will be used in
+  // the error message to describe the call in the case the default
+  // action fails.
+  // L = *
+  virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
+      void* untyped_args, const std::string& call_description) const = 0;
+
+  // Performs the given action with the given arguments and returns
+  // the action's result.
+  // L = *
+  virtual UntypedActionResultHolderBase* UntypedPerformAction(
+      const void* untyped_action, void* untyped_args) const = 0;
+
+  // Writes a message that the call is uninteresting (i.e. neither
+  // explicitly expected nor explicitly unexpected) to the given
+  // ostream.
+  virtual void UntypedDescribeUninterestingCall(
+      const void* untyped_args,
+      ::std::ostream* os) const
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
+
+  // Returns the expectation that matches the given function arguments
+  // (or NULL is there's no match); when a match is found,
+  // untyped_action is set to point to the action that should be
+  // performed (or NULL if the action is "do default"), and
+  // is_excessive is modified to indicate whether the call exceeds the
+  // expected number.
+  virtual const ExpectationBase* UntypedFindMatchingExpectation(
+      const void* untyped_args,
+      const void** untyped_action, bool* is_excessive,
+      ::std::ostream* what, ::std::ostream* why)
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) = 0;
+
+  // Prints the given function arguments to the ostream.
+  virtual void UntypedPrintArgs(const void* untyped_args,
+                                ::std::ostream* os) const = 0;
+
+  // Sets the mock object this mock method belongs to, and registers
+  // this information in the global mock registry.  Will be called
+  // whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
+  // method.
+  void RegisterOwner(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Sets the mock object this mock method belongs to, and sets the
+  // name of the mock function.  Will be called upon each invocation
+  // of this mock function.
+  void SetOwnerAndName(const void* mock_obj, const char* name)
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Returns the mock object this mock method belongs to.  Must be
+  // called after RegisterOwner() or SetOwnerAndName() has been
+  // called.
+  const void* MockObject() const
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Returns the name of this mock method.  Must be called after
+  // SetOwnerAndName() has been called.
+  const char* Name() const
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+  // Returns the result of invoking this mock function with the given
+  // arguments.  This function can be safely called from multiple
+  // threads concurrently.  The caller is responsible for deleting the
+  // result.
+  UntypedActionResultHolderBase* UntypedInvokeWith(void* untyped_args)
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
+
+ protected:
+  typedef std::vector<const void*> UntypedOnCallSpecs;
+
+  using UntypedExpectations = std::vector<std::shared_ptr<ExpectationBase>>;
+
+  // Returns an Expectation object that references and co-owns exp,
+  // which must be an expectation on this mock function.
+  Expectation GetHandleOf(ExpectationBase* exp);
+
+  // Address of the mock object this mock method belongs to.  Only
+  // valid after this mock method has been called or
+  // ON_CALL/EXPECT_CALL has been invoked on it.
+  const void* mock_obj_;  // Protected by g_gmock_mutex.
+
+  // Name of the function being mocked.  Only valid after this mock
+  // method has been called.
+  const char* name_;  // Protected by g_gmock_mutex.
+
+  // All default action specs for this function mocker.
+  UntypedOnCallSpecs untyped_on_call_specs_;
+
+  // All expectations for this function mocker.
+  //
+  // It's undefined behavior to interleave expectations (EXPECT_CALLs
+  // or ON_CALLs) and mock function calls.  Also, the order of
+  // expectations is important.  Therefore it's a logic race condition
+  // to read/write untyped_expectations_ concurrently.  In order for
+  // tools like tsan to catch concurrent read/write accesses to
+  // untyped_expectations, we deliberately leave accesses to it
+  // unprotected.
+  UntypedExpectations untyped_expectations_;
+};  // class UntypedFunctionMockerBase
+
+// Untyped base class for OnCallSpec<F>.
+class UntypedOnCallSpecBase {
+ public:
+  // The arguments are the location of the ON_CALL() statement.
+  UntypedOnCallSpecBase(const char* a_file, int a_line)
+      : file_(a_file), line_(a_line), last_clause_(kNone) {}
+
+  // Where in the source file was the default action spec defined?
+  const char* file() const { return file_; }
+  int line() const { return line_; }
+
+ protected:
+  // Gives each clause in the ON_CALL() statement a name.
+  enum Clause {
+    // Do not change the order of the enum members!  The run-time
+    // syntax checking relies on it.
+    kNone,
+    kWith,
+    kWillByDefault
+  };
+
+  // Asserts that the ON_CALL() statement has a certain property.
+  void AssertSpecProperty(bool property,
+                          const std::string& failure_message) const {
+    Assert(property, file_, line_, failure_message);
+  }
+
+  // Expects that the ON_CALL() statement has a certain property.
+  void ExpectSpecProperty(bool property,
+                          const std::string& failure_message) const {
+    Expect(property, file_, line_, failure_message);
+  }
+
+  const char* file_;
+  int line_;
+
+  // The last clause in the ON_CALL() statement as seen so far.
+  // Initially kNone and changes as the statement is parsed.
+  Clause last_clause_;
+};  // class UntypedOnCallSpecBase
+
+// This template class implements an ON_CALL spec.
+template <typename F>
+class OnCallSpec : public UntypedOnCallSpecBase {
+ public:
+  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
+
+  // Constructs an OnCallSpec object from the information inside
+  // the parenthesis of an ON_CALL() statement.
+  OnCallSpec(const char* a_file, int a_line,
+             const ArgumentMatcherTuple& matchers)
+      : UntypedOnCallSpecBase(a_file, a_line),
+        matchers_(matchers),
+        // By default, extra_matcher_ should match anything.  However,
+        // we cannot initialize it with _ as that causes ambiguity between
+        // Matcher's copy and move constructor for some argument types.
+        extra_matcher_(A<const ArgumentTuple&>()) {}
+
+  // Implements the .With() clause.
+  OnCallSpec& With(const Matcher<const ArgumentTuple&>& m) {
+    // Makes sure this is called at most once.
+    ExpectSpecProperty(last_clause_ < kWith,
+                       ".With() cannot appear "
+                       "more than once in an ON_CALL().");
+    last_clause_ = kWith;
+
+    extra_matcher_ = m;
+    return *this;
+  }
+
+  // Implements the .WillByDefault() clause.
+  OnCallSpec& WillByDefault(const Action<F>& action) {
+    ExpectSpecProperty(last_clause_ < kWillByDefault,
+                       ".WillByDefault() must appear "
+                       "exactly once in an ON_CALL().");
+    last_clause_ = kWillByDefault;
+
+    ExpectSpecProperty(!action.IsDoDefault(),
+                       "DoDefault() cannot be used in ON_CALL().");
+    action_ = action;
+    return *this;
+  }
+
+  // Returns true if and only if the given arguments match the matchers.
+  bool Matches(const ArgumentTuple& args) const {
+    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
+  }
+
+  // Returns the action specified by the user.
+  const Action<F>& GetAction() const {
+    AssertSpecProperty(last_clause_ == kWillByDefault,
+                       ".WillByDefault() must appear exactly "
+                       "once in an ON_CALL().");
+    return action_;
+  }
+
+ private:
+  // The information in statement
+  //
+  //   ON_CALL(mock_object, Method(matchers))
+  //       .With(multi-argument-matcher)
+  //       .WillByDefault(action);
+  //
+  // is recorded in the data members like this:
+  //
+  //   source file that contains the statement => file_
+  //   line number of the statement            => line_
+  //   matchers                                => matchers_
+  //   multi-argument-matcher                  => extra_matcher_
+  //   action                                  => action_
+  ArgumentMatcherTuple matchers_;
+  Matcher<const ArgumentTuple&> extra_matcher_;
+  Action<F> action_;
+};  // class OnCallSpec
+
+// Possible reactions on uninteresting calls.
+enum CallReaction {
+  kAllow,
+  kWarn,
+  kFail,
+};
+
+}  // namespace internal
+
+// Utilities for manipulating mock objects.
+class GTEST_API_ Mock {
+ public:
+  // The following public methods can be called concurrently.
+
+  // Tells Google Mock to ignore mock_obj when checking for leaked
+  // mock objects.
+  static void AllowLeak(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Verifies and clears all expectations on the given mock object.
+  // If the expectations aren't satisfied, generates one or more
+  // Google Test non-fatal failures and returns false.
+  static bool VerifyAndClearExpectations(void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Verifies all expectations on the given mock object and clears its
+  // default actions and expectations.  Returns true if and only if the
+  // verification was successful.
+  static bool VerifyAndClear(void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Returns whether the mock was created as a naggy mock (default)
+  static bool IsNaggy(void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+  // Returns whether the mock was created as a nice mock
+  static bool IsNice(void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+  // Returns whether the mock was created as a strict mock
+  static bool IsStrict(void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+ private:
+  friend class internal::UntypedFunctionMockerBase;
+
+  // Needed for a function mocker to register itself (so that we know
+  // how to clear a mock object).
+  template <typename F>
+  friend class internal::FunctionMocker;
+
+  template <typename MockClass>
+  friend class internal::NiceMockImpl;
+  template <typename MockClass>
+  friend class internal::NaggyMockImpl;
+  template <typename MockClass>
+  friend class internal::StrictMockImpl;
+
+  // Tells Google Mock to allow uninteresting calls on the given mock
+  // object.
+  static void AllowUninterestingCalls(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock to warn the user about uninteresting calls on
+  // the given mock object.
+  static void WarnUninterestingCalls(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock to fail uninteresting calls on the given mock
+  // object.
+  static void FailUninterestingCalls(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock the given mock object is being destroyed and
+  // its entry in the call-reaction table should be removed.
+  static void UnregisterCallReaction(const void* mock_obj)
+      GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Returns the reaction Google Mock will have on uninteresting calls
+  // made on the given mock object.
+  static internal::CallReaction GetReactionOnUninterestingCalls(
+      const void* mock_obj)
+          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Verifies that all expectations on the given mock object have been
+  // satisfied.  Reports one or more Google Test non-fatal failures
+  // and returns false if not.
+  static bool VerifyAndClearExpectationsLocked(void* mock_obj)
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
+
+  // Clears all ON_CALL()s set on the given mock object.
+  static void ClearDefaultActionsLocked(void* mock_obj)
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
+
+  // Registers a mock object and a mock method it owns.
+  static void Register(
+      const void* mock_obj,
+      internal::UntypedFunctionMockerBase* mocker)
+          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Tells Google Mock where in the source code mock_obj is used in an
+  // ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
+  // information helps the user identify which object it is.
+  static void RegisterUseByOnCallOrExpectCall(
+      const void* mock_obj, const char* file, int line)
+          GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
+
+  // Unregisters a mock method; removes the owning mock object from
+  // the registry when the last mock method associated with it has
+  // been unregistered.  This is called only in the destructor of
+  // FunctionMocker.
+  static void UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex);
+};  // class Mock
+
+// An abstract handle of an expectation.  Useful in the .After()
+// clause of EXPECT_CALL() for setting the (partial) order of
+// expectations.  The syntax:
+//
+//   Expectation e1 = EXPECT_CALL(...)...;
+//   EXPECT_CALL(...).After(e1)...;
+//
+// sets two expectations where the latter can only be matched after
+// the former has been satisfied.
+//
+// Notes:
+//   - This class is copyable and has value semantics.
+//   - Constness is shallow: a const Expectation object itself cannot
+//     be modified, but the mutable methods of the ExpectationBase
+//     object it references can be called via expectation_base().
+
+class GTEST_API_ Expectation {
+ public:
+  // Constructs a null object that doesn't reference any expectation.
+  Expectation();
+  Expectation(Expectation&&) = default;
+  Expectation(const Expectation&) = default;
+  Expectation& operator=(Expectation&&) = default;
+  Expectation& operator=(const Expectation&) = default;
+  ~Expectation();
+
+  // This single-argument ctor must not be explicit, in order to support the
+  //   Expectation e = EXPECT_CALL(...);
+  // syntax.
+  //
+  // A TypedExpectation object stores its pre-requisites as
+  // Expectation objects, and needs to call the non-const Retire()
+  // method on the ExpectationBase objects they reference.  Therefore
+  // Expectation must receive a *non-const* reference to the
+  // ExpectationBase object.
+  Expectation(internal::ExpectationBase& exp);  // NOLINT
+
+  // The compiler-generated copy ctor and operator= work exactly as
+  // intended, so we don't need to define our own.
+
+  // Returns true if and only if rhs references the same expectation as this
+  // object does.
+  bool operator==(const Expectation& rhs) const {
+    return expectation_base_ == rhs.expectation_base_;
+  }
+
+  bool operator!=(const Expectation& rhs) const { return !(*this == rhs); }
+
+ private:
+  friend class ExpectationSet;
+  friend class Sequence;
+  friend class ::testing::internal::ExpectationBase;
+  friend class ::testing::internal::UntypedFunctionMockerBase;
+
+  template <typename F>
+  friend class ::testing::internal::FunctionMocker;
+
+  template <typename F>
+  friend class ::testing::internal::TypedExpectation;
+
+  // This comparator is needed for putting Expectation objects into a set.
+  class Less {
+   public:
+    bool operator()(const Expectation& lhs, const Expectation& rhs) const {
+      return lhs.expectation_base_.get() < rhs.expectation_base_.get();
+    }
+  };
+
+  typedef ::std::set<Expectation, Less> Set;
+
+  Expectation(
+      const std::shared_ptr<internal::ExpectationBase>& expectation_base);
+
+  // Returns the expectation this object references.
+  const std::shared_ptr<internal::ExpectationBase>& expectation_base() const {
+    return expectation_base_;
+  }
+
+  // A shared_ptr that co-owns the expectation this handle references.
+  std::shared_ptr<internal::ExpectationBase> expectation_base_;
+};
+
+// A set of expectation handles.  Useful in the .After() clause of
+// EXPECT_CALL() for setting the (partial) order of expectations.  The
+// syntax:
+//
+//   ExpectationSet es;
+//   es += EXPECT_CALL(...)...;
+//   es += EXPECT_CALL(...)...;
+//   EXPECT_CALL(...).After(es)...;
+//
+// sets three expectations where the last one can only be matched
+// after the first two have both been satisfied.
+//
+// This class is copyable and has value semantics.
+class ExpectationSet {
+ public:
+  // A bidirectional iterator that can read a const element in the set.
+  typedef Expectation::Set::const_iterator const_iterator;
+
+  // An object stored in the set.  This is an alias of Expectation.
+  typedef Expectation::Set::value_type value_type;
+
+  // Constructs an empty set.
+  ExpectationSet() {}
+
+  // This single-argument ctor must not be explicit, in order to support the
+  //   ExpectationSet es = EXPECT_CALL(...);
+  // syntax.
+  ExpectationSet(internal::ExpectationBase& exp) {  // NOLINT
+    *this += Expectation(exp);
+  }
+
+  // This single-argument ctor implements implicit conversion from
+  // Expectation and thus must not be explicit.  This allows either an
+  // Expectation or an ExpectationSet to be used in .After().
+  ExpectationSet(const Expectation& e) {  // NOLINT
+    *this += e;
+  }
+
+  // The compiler-generator ctor and operator= works exactly as
+  // intended, so we don't need to define our own.
+
+  // Returns true if and only if rhs contains the same set of Expectation
+  // objects as this does.
+  bool operator==(const ExpectationSet& rhs) const {
+    return expectations_ == rhs.expectations_;
+  }
+
+  bool operator!=(const ExpectationSet& rhs) const { return !(*this == rhs); }
+
+  // Implements the syntax
+  //   expectation_set += EXPECT_CALL(...);
+  ExpectationSet& operator+=(const Expectation& e) {
+    expectations_.insert(e);
+    return *this;
+  }
+
+  int size() const { return static_cast<int>(expectations_.size()); }
+
+  const_iterator begin() const { return expectations_.begin(); }
+  const_iterator end() const { return expectations_.end(); }
+
+ private:
+  Expectation::Set expectations_;
+};
+
+
+// Sequence objects are used by a user to specify the relative order
+// in which the expectations should match.  They are copyable (we rely
+// on the compiler-defined copy constructor and assignment operator).
+class GTEST_API_ Sequence {
+ public:
+  // Constructs an empty sequence.
+  Sequence() : last_expectation_(new Expectation) {}
+
+  // Adds an expectation to this sequence.  The caller must ensure
+  // that no other thread is accessing this Sequence object.
+  void AddExpectation(const Expectation& expectation) const;
+
+ private:
+  // The last expectation in this sequence.
+  std::shared_ptr<Expectation> last_expectation_;
+};  // class Sequence
+
+// An object of this type causes all EXPECT_CALL() statements
+// encountered in its scope to be put in an anonymous sequence.  The
+// work is done in the constructor and destructor.  You should only
+// create an InSequence object on the stack.
+//
+// The sole purpose for this class is to support easy definition of
+// sequential expectations, e.g.
+//
+//   {
+//     InSequence dummy;  // The name of the object doesn't matter.
+//
+//     // The following expectations must match in the order they appear.
+//     EXPECT_CALL(a, Bar())...;
+//     EXPECT_CALL(a, Baz())...;
+//     ...
+//     EXPECT_CALL(b, Xyz())...;
+//   }
+//
+// You can create InSequence objects in multiple threads, as long as
+// they are used to affect different mock objects.  The idea is that
+// each thread can create and set up its own mocks as if it's the only
+// thread.  However, for clarity of your tests we recommend you to set
+// up mocks in the main thread unless you have a good reason not to do
+// so.
+class GTEST_API_ InSequence {
+ public:
+  InSequence();
+  ~InSequence();
+ private:
+  bool sequence_created_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(InSequence);  // NOLINT
+} GTEST_ATTRIBUTE_UNUSED_;
+
+namespace internal {
+
+// Points to the implicit sequence introduced by a living InSequence
+// object (if any) in the current thread or NULL.
+GTEST_API_ extern ThreadLocal<Sequence*> g_gmock_implicit_sequence;
+
+// Base class for implementing expectations.
+//
+// There are two reasons for having a type-agnostic base class for
+// Expectation:
+//
+//   1. We need to store collections of expectations of different
+//   types (e.g. all pre-requisites of a particular expectation, all
+//   expectations in a sequence).  Therefore these expectation objects
+//   must share a common base class.
+//
+//   2. We can avoid binary code bloat by moving methods not depending
+//   on the template argument of Expectation to the base class.
+//
+// This class is internal and mustn't be used by user code directly.
+class GTEST_API_ ExpectationBase {
+ public:
+  // source_text is the EXPECT_CALL(...) source that created this Expectation.
+  ExpectationBase(const char* file, int line, const std::string& source_text);
+
+  virtual ~ExpectationBase();
+
+  // Where in the source file was the expectation spec defined?
+  const char* file() const { return file_; }
+  int line() const { return line_; }
+  const char* source_text() const { return source_text_.c_str(); }
+  // Returns the cardinality specified in the expectation spec.
+  const Cardinality& cardinality() const { return cardinality_; }
+
+  // Describes the source file location of this expectation.
+  void DescribeLocationTo(::std::ostream* os) const {
+    *os << FormatFileLocation(file(), line()) << " ";
+  }
+
+  // Describes how many times a function call matching this
+  // expectation has occurred.
+  void DescribeCallCountTo(::std::ostream* os) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // If this mock method has an extra matcher (i.e. .With(matcher)),
+  // describes it to the ostream.
+  virtual void MaybeDescribeExtraMatcherTo(::std::ostream* os) = 0;
+
+ protected:
+  friend class ::testing::Expectation;
+  friend class UntypedFunctionMockerBase;
+
+  enum Clause {
+    // Don't change the order of the enum members!
+    kNone,
+    kWith,
+    kTimes,
+    kInSequence,
+    kAfter,
+    kWillOnce,
+    kWillRepeatedly,
+    kRetiresOnSaturation
+  };
+
+  typedef std::vector<const void*> UntypedActions;
+
+  // Returns an Expectation object that references and co-owns this
+  // expectation.
+  virtual Expectation GetHandle() = 0;
+
+  // Asserts that the EXPECT_CALL() statement has the given property.
+  void AssertSpecProperty(bool property,
+                          const std::string& failure_message) const {
+    Assert(property, file_, line_, failure_message);
+  }
+
+  // Expects that the EXPECT_CALL() statement has the given property.
+  void ExpectSpecProperty(bool property,
+                          const std::string& failure_message) const {
+    Expect(property, file_, line_, failure_message);
+  }
+
+  // Explicitly specifies the cardinality of this expectation.  Used
+  // by the subclasses to implement the .Times() clause.
+  void SpecifyCardinality(const Cardinality& cardinality);
+
+  // Returns true if and only if the user specified the cardinality
+  // explicitly using a .Times().
+  bool cardinality_specified() const { return cardinality_specified_; }
+
+  // Sets the cardinality of this expectation spec.
+  void set_cardinality(const Cardinality& a_cardinality) {
+    cardinality_ = a_cardinality;
+  }
+
+  // The following group of methods should only be called after the
+  // EXPECT_CALL() statement, and only when g_gmock_mutex is held by
+  // the current thread.
+
+  // Retires all pre-requisites of this expectation.
+  void RetireAllPreRequisites()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Returns true if and only if this expectation is retired.
+  bool is_retired() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return retired_;
+  }
+
+  // Retires this expectation.
+  void Retire()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    retired_ = true;
+  }
+
+  // Returns true if and only if this expectation is satisfied.
+  bool IsSatisfied() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return cardinality().IsSatisfiedByCallCount(call_count_);
+  }
+
+  // Returns true if and only if this expectation is saturated.
+  bool IsSaturated() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return cardinality().IsSaturatedByCallCount(call_count_);
+  }
+
+  // Returns true if and only if this expectation is over-saturated.
+  bool IsOverSaturated() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return cardinality().IsOverSaturatedByCallCount(call_count_);
+  }
+
+  // Returns true if and only if all pre-requisites of this expectation are
+  // satisfied.
+  bool AllPrerequisitesAreSatisfied() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Adds unsatisfied pre-requisites of this expectation to 'result'.
+  void FindUnsatisfiedPrerequisites(ExpectationSet* result) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex);
+
+  // Returns the number this expectation has been invoked.
+  int call_count() const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return call_count_;
+  }
+
+  // Increments the number this expectation has been invoked.
+  void IncrementCallCount()
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    call_count_++;
+  }
+
+  // Checks the action count (i.e. the number of WillOnce() and
+  // WillRepeatedly() clauses) against the cardinality if this hasn't
+  // been done before.  Prints a warning if there are too many or too
+  // few actions.
+  void CheckActionCountIfNotDone() const
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  friend class ::testing::Sequence;
+  friend class ::testing::internal::ExpectationTester;
+
+  template <typename Function>
+  friend class TypedExpectation;
+
+  // Implements the .Times() clause.
+  void UntypedTimes(const Cardinality& a_cardinality);
+
+  // This group of fields are part of the spec and won't change after
+  // an EXPECT_CALL() statement finishes.
+  const char* file_;          // The file that contains the expectation.
+  int line_;                  // The line number of the expectation.
+  const std::string source_text_;  // The EXPECT_CALL(...) source text.
+  // True if and only if the cardinality is specified explicitly.
+  bool cardinality_specified_;
+  Cardinality cardinality_;            // The cardinality of the expectation.
+  // The immediate pre-requisites (i.e. expectations that must be
+  // satisfied before this expectation can be matched) of this
+  // expectation.  We use std::shared_ptr in the set because we want an
+  // Expectation object to be co-owned by its FunctionMocker and its
+  // successors.  This allows multiple mock objects to be deleted at
+  // different times.
+  ExpectationSet immediate_prerequisites_;
+
+  // This group of fields are the current state of the expectation,
+  // and can change as the mock function is called.
+  int call_count_;  // How many times this expectation has been invoked.
+  bool retired_;    // True if and only if this expectation has retired.
+  UntypedActions untyped_actions_;
+  bool extra_matcher_specified_;
+  bool repeated_action_specified_;  // True if a WillRepeatedly() was specified.
+  bool retires_on_saturation_;
+  Clause last_clause_;
+  mutable bool action_count_checked_;  // Under mutex_.
+  mutable Mutex mutex_;  // Protects action_count_checked_.
+};  // class ExpectationBase
+
+// Impements an expectation for the given function type.
+template <typename F>
+class TypedExpectation : public ExpectationBase {
+ public:
+  typedef typename Function<F>::ArgumentTuple ArgumentTuple;
+  typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
+  typedef typename Function<F>::Result Result;
+
+  TypedExpectation(FunctionMocker<F>* owner, const char* a_file, int a_line,
+                   const std::string& a_source_text,
+                   const ArgumentMatcherTuple& m)
+      : ExpectationBase(a_file, a_line, a_source_text),
+        owner_(owner),
+        matchers_(m),
+        // By default, extra_matcher_ should match anything.  However,
+        // we cannot initialize it with _ as that causes ambiguity between
+        // Matcher's copy and move constructor for some argument types.
+        extra_matcher_(A<const ArgumentTuple&>()),
+        repeated_action_(DoDefault()) {}
+
+  ~TypedExpectation() override {
+    // Check the validity of the action count if it hasn't been done
+    // yet (for example, if the expectation was never used).
+    CheckActionCountIfNotDone();
+    for (UntypedActions::const_iterator it = untyped_actions_.begin();
+         it != untyped_actions_.end(); ++it) {
+      delete static_cast<const Action<F>*>(*it);
+    }
+  }
+
+  // Implements the .With() clause.
+  TypedExpectation& With(const Matcher<const ArgumentTuple&>& m) {
+    if (last_clause_ == kWith) {
+      ExpectSpecProperty(false,
+                         ".With() cannot appear "
+                         "more than once in an EXPECT_CALL().");
+    } else {
+      ExpectSpecProperty(last_clause_ < kWith,
+                         ".With() must be the first "
+                         "clause in an EXPECT_CALL().");
+    }
+    last_clause_ = kWith;
+
+    extra_matcher_ = m;
+    extra_matcher_specified_ = true;
+    return *this;
+  }
+
+  // Implements the .Times() clause.
+  TypedExpectation& Times(const Cardinality& a_cardinality) {
+    ExpectationBase::UntypedTimes(a_cardinality);
+    return *this;
+  }
+
+  // Implements the .Times() clause.
+  TypedExpectation& Times(int n) {
+    return Times(Exactly(n));
+  }
+
+  // Implements the .InSequence() clause.
+  TypedExpectation& InSequence(const Sequence& s) {
+    ExpectSpecProperty(last_clause_ <= kInSequence,
+                       ".InSequence() cannot appear after .After(),"
+                       " .WillOnce(), .WillRepeatedly(), or "
+                       ".RetiresOnSaturation().");
+    last_clause_ = kInSequence;
+
+    s.AddExpectation(GetHandle());
+    return *this;
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2) {
+    return InSequence(s1).InSequence(s2);
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
+                               const Sequence& s3) {
+    return InSequence(s1, s2).InSequence(s3);
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
+                               const Sequence& s3, const Sequence& s4) {
+    return InSequence(s1, s2, s3).InSequence(s4);
+  }
+  TypedExpectation& InSequence(const Sequence& s1, const Sequence& s2,
+                               const Sequence& s3, const Sequence& s4,
+                               const Sequence& s5) {
+    return InSequence(s1, s2, s3, s4).InSequence(s5);
+  }
+
+  // Implements that .After() clause.
+  TypedExpectation& After(const ExpectationSet& s) {
+    ExpectSpecProperty(last_clause_ <= kAfter,
+                       ".After() cannot appear after .WillOnce(),"
+                       " .WillRepeatedly(), or "
+                       ".RetiresOnSaturation().");
+    last_clause_ = kAfter;
+
+    for (ExpectationSet::const_iterator it = s.begin(); it != s.end(); ++it) {
+      immediate_prerequisites_ += *it;
+    }
+    return *this;
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2) {
+    return After(s1).After(s2);
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
+                          const ExpectationSet& s3) {
+    return After(s1, s2).After(s3);
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
+                          const ExpectationSet& s3, const ExpectationSet& s4) {
+    return After(s1, s2, s3).After(s4);
+  }
+  TypedExpectation& After(const ExpectationSet& s1, const ExpectationSet& s2,
+                          const ExpectationSet& s3, const ExpectationSet& s4,
+                          const ExpectationSet& s5) {
+    return After(s1, s2, s3, s4).After(s5);
+  }
+
+  // Implements the .WillOnce() clause.
+  TypedExpectation& WillOnce(const Action<F>& action) {
+    ExpectSpecProperty(last_clause_ <= kWillOnce,
+                       ".WillOnce() cannot appear after "
+                       ".WillRepeatedly() or .RetiresOnSaturation().");
+    last_clause_ = kWillOnce;
+
+    untyped_actions_.push_back(new Action<F>(action));
+    if (!cardinality_specified()) {
+      set_cardinality(Exactly(static_cast<int>(untyped_actions_.size())));
+    }
+    return *this;
+  }
+
+  // Implements the .WillRepeatedly() clause.
+  TypedExpectation& WillRepeatedly(const Action<F>& action) {
+    if (last_clause_ == kWillRepeatedly) {
+      ExpectSpecProperty(false,
+                         ".WillRepeatedly() cannot appear "
+                         "more than once in an EXPECT_CALL().");
+    } else {
+      ExpectSpecProperty(last_clause_ < kWillRepeatedly,
+                         ".WillRepeatedly() cannot appear "
+                         "after .RetiresOnSaturation().");
+    }
+    last_clause_ = kWillRepeatedly;
+    repeated_action_specified_ = true;
+
+    repeated_action_ = action;
+    if (!cardinality_specified()) {
+      set_cardinality(AtLeast(static_cast<int>(untyped_actions_.size())));
+    }
+
+    // Now that no more action clauses can be specified, we check
+    // whether their count makes sense.
+    CheckActionCountIfNotDone();
+    return *this;
+  }
+
+  // Implements the .RetiresOnSaturation() clause.
+  TypedExpectation& RetiresOnSaturation() {
+    ExpectSpecProperty(last_clause_ < kRetiresOnSaturation,
+                       ".RetiresOnSaturation() cannot appear "
+                       "more than once.");
+    last_clause_ = kRetiresOnSaturation;
+    retires_on_saturation_ = true;
+
+    // Now that no more action clauses can be specified, we check
+    // whether their count makes sense.
+    CheckActionCountIfNotDone();
+    return *this;
+  }
+
+  // Returns the matchers for the arguments as specified inside the
+  // EXPECT_CALL() macro.
+  const ArgumentMatcherTuple& matchers() const {
+    return matchers_;
+  }
+
+  // Returns the matcher specified by the .With() clause.
+  const Matcher<const ArgumentTuple&>& extra_matcher() const {
+    return extra_matcher_;
+  }
+
+  // Returns the action specified by the .WillRepeatedly() clause.
+  const Action<F>& repeated_action() const { return repeated_action_; }
+
+  // If this mock method has an extra matcher (i.e. .With(matcher)),
+  // describes it to the ostream.
+  void MaybeDescribeExtraMatcherTo(::std::ostream* os) override {
+    if (extra_matcher_specified_) {
+      *os << "    Expected args: ";
+      extra_matcher_.DescribeTo(os);
+      *os << "\n";
+    }
+  }
+
+ private:
+  template <typename Function>
+  friend class FunctionMocker;
+
+  // Returns an Expectation object that references and co-owns this
+  // expectation.
+  Expectation GetHandle() override { return owner_->GetHandleOf(this); }
+
+  // The following methods will be called only after the EXPECT_CALL()
+  // statement finishes and when the current thread holds
+  // g_gmock_mutex.
+
+  // Returns true if and only if this expectation matches the given arguments.
+  bool Matches(const ArgumentTuple& args) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    return TupleMatches(matchers_, args) && extra_matcher_.Matches(args);
+  }
+
+  // Returns true if and only if this expectation should handle the given
+  // arguments.
+  bool ShouldHandleArguments(const ArgumentTuple& args) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+
+    // In case the action count wasn't checked when the expectation
+    // was defined (e.g. if this expectation has no WillRepeatedly()
+    // or RetiresOnSaturation() clause), we check it when the
+    // expectation is used for the first time.
+    CheckActionCountIfNotDone();
+    return !is_retired() && AllPrerequisitesAreSatisfied() && Matches(args);
+  }
+
+  // Describes the result of matching the arguments against this
+  // expectation to the given ostream.
+  void ExplainMatchResultTo(
+      const ArgumentTuple& args,
+      ::std::ostream* os) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+
+    if (is_retired()) {
+      *os << "         Expected: the expectation is active\n"
+          << "           Actual: it is retired\n";
+    } else if (!Matches(args)) {
+      if (!TupleMatches(matchers_, args)) {
+        ExplainMatchFailureTupleTo(matchers_, args, os);
+      }
+      StringMatchResultListener listener;
+      if (!extra_matcher_.MatchAndExplain(args, &listener)) {
+        *os << "    Expected args: ";
+        extra_matcher_.DescribeTo(os);
+        *os << "\n           Actual: don't match";
+
+        internal::PrintIfNotEmpty(listener.str(), os);
+        *os << "\n";
+      }
+    } else if (!AllPrerequisitesAreSatisfied()) {
+      *os << "         Expected: all pre-requisites are satisfied\n"
+          << "           Actual: the following immediate pre-requisites "
+          << "are not satisfied:\n";
+      ExpectationSet unsatisfied_prereqs;
+      FindUnsatisfiedPrerequisites(&unsatisfied_prereqs);
+      int i = 0;
+      for (ExpectationSet::const_iterator it = unsatisfied_prereqs.begin();
+           it != unsatisfied_prereqs.end(); ++it) {
+        it->expectation_base()->DescribeLocationTo(os);
+        *os << "pre-requisite #" << i++ << "\n";
+      }
+      *os << "                   (end of pre-requisites)\n";
+    } else {
+      // This line is here just for completeness' sake.  It will never
+      // be executed as currently the ExplainMatchResultTo() function
+      // is called only when the mock function call does NOT match the
+      // expectation.
+      *os << "The call matches the expectation.\n";
+    }
+  }
+
+  // Returns the action that should be taken for the current invocation.
+  const Action<F>& GetCurrentAction(const FunctionMocker<F>* mocker,
+                                    const ArgumentTuple& args) const
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    const int count = call_count();
+    Assert(count >= 1, __FILE__, __LINE__,
+           "call_count() is <= 0 when GetCurrentAction() is "
+           "called - this should never happen.");
+
+    const int action_count = static_cast<int>(untyped_actions_.size());
+    if (action_count > 0 && !repeated_action_specified_ &&
+        count > action_count) {
+      // If there is at least one WillOnce() and no WillRepeatedly(),
+      // we warn the user when the WillOnce() clauses ran out.
+      ::std::stringstream ss;
+      DescribeLocationTo(&ss);
+      ss << "Actions ran out in " << source_text() << "...\n"
+         << "Called " << count << " times, but only "
+         << action_count << " WillOnce()"
+         << (action_count == 1 ? " is" : "s are") << " specified - ";
+      mocker->DescribeDefaultActionTo(args, &ss);
+      Log(kWarning, ss.str(), 1);
+    }
+
+    return count <= action_count
+               ? *static_cast<const Action<F>*>(
+                     untyped_actions_[static_cast<size_t>(count - 1)])
+               : repeated_action();
+  }
+
+  // Given the arguments of a mock function call, if the call will
+  // over-saturate this expectation, returns the default action;
+  // otherwise, returns the next action in this expectation.  Also
+  // describes *what* happened to 'what', and explains *why* Google
+  // Mock does it to 'why'.  This method is not const as it calls
+  // IncrementCallCount().  A return value of NULL means the default
+  // action.
+  const Action<F>* GetActionForArguments(const FunctionMocker<F>* mocker,
+                                         const ArgumentTuple& args,
+                                         ::std::ostream* what,
+                                         ::std::ostream* why)
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    if (IsSaturated()) {
+      // We have an excessive call.
+      IncrementCallCount();
+      *what << "Mock function called more times than expected - ";
+      mocker->DescribeDefaultActionTo(args, what);
+      DescribeCallCountTo(why);
+
+      return nullptr;
+    }
+
+    IncrementCallCount();
+    RetireAllPreRequisites();
+
+    if (retires_on_saturation_ && IsSaturated()) {
+      Retire();
+    }
+
+    // Must be done after IncrementCount()!
+    *what << "Mock function call matches " << source_text() <<"...\n";
+    return &(GetCurrentAction(mocker, args));
+  }
+
+  // All the fields below won't change once the EXPECT_CALL()
+  // statement finishes.
+  FunctionMocker<F>* const owner_;
+  ArgumentMatcherTuple matchers_;
+  Matcher<const ArgumentTuple&> extra_matcher_;
+  Action<F> repeated_action_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TypedExpectation);
+};  // class TypedExpectation
+
+// A MockSpec object is used by ON_CALL() or EXPECT_CALL() for
+// specifying the default behavior of, or expectation on, a mock
+// function.
+
+// Note: class MockSpec really belongs to the ::testing namespace.
+// However if we define it in ::testing, MSVC will complain when
+// classes in ::testing::internal declare it as a friend class
+// template.  To workaround this compiler bug, we define MockSpec in
+// ::testing::internal and import it into ::testing.
+
+// Logs a message including file and line number information.
+GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
+                                const char* file, int line,
+                                const std::string& message);
+
+template <typename F>
+class MockSpec {
+ public:
+  typedef typename internal::Function<F>::ArgumentTuple ArgumentTuple;
+  typedef typename internal::Function<F>::ArgumentMatcherTuple
+      ArgumentMatcherTuple;
+
+  // Constructs a MockSpec object, given the function mocker object
+  // that the spec is associated with.
+  MockSpec(internal::FunctionMocker<F>* function_mocker,
+           const ArgumentMatcherTuple& matchers)
+      : function_mocker_(function_mocker), matchers_(matchers) {}
+
+  // Adds a new default action spec to the function mocker and returns
+  // the newly created spec.
+  internal::OnCallSpec<F>& InternalDefaultActionSetAt(
+      const char* file, int line, const char* obj, const char* call) {
+    LogWithLocation(internal::kInfo, file, line,
+                    std::string("ON_CALL(") + obj + ", " + call + ") invoked");
+    return function_mocker_->AddNewOnCallSpec(file, line, matchers_);
+  }
+
+  // Adds a new expectation spec to the function mocker and returns
+  // the newly created spec.
+  internal::TypedExpectation<F>& InternalExpectedAt(
+      const char* file, int line, const char* obj, const char* call) {
+    const std::string source_text(std::string("EXPECT_CALL(") + obj + ", " +
+                                  call + ")");
+    LogWithLocation(internal::kInfo, file, line, source_text + " invoked");
+    return function_mocker_->AddNewExpectation(
+        file, line, source_text, matchers_);
+  }
+
+  // This operator overload is used to swallow the superfluous parameter list
+  // introduced by the ON/EXPECT_CALL macros. See the macro comments for more
+  // explanation.
+  MockSpec<F>& operator()(const internal::WithoutMatchers&, void* const) {
+    return *this;
+  }
+
+ private:
+  template <typename Function>
+  friend class internal::FunctionMocker;
+
+  // The function mocker that owns this spec.
+  internal::FunctionMocker<F>* const function_mocker_;
+  // The argument matchers specified in the spec.
+  ArgumentMatcherTuple matchers_;
+};  // class MockSpec
+
+// Wrapper type for generically holding an ordinary value or lvalue reference.
+// If T is not a reference type, it must be copyable or movable.
+// ReferenceOrValueWrapper<T> is movable, and will also be copyable unless
+// T is a move-only value type (which means that it will always be copyable
+// if the current platform does not support move semantics).
+//
+// The primary template defines handling for values, but function header
+// comments describe the contract for the whole template (including
+// specializations).
+template <typename T>
+class ReferenceOrValueWrapper {
+ public:
+  // Constructs a wrapper from the given value/reference.
+  explicit ReferenceOrValueWrapper(T value)
+      : value_(std::move(value)) {
+  }
+
+  // Unwraps and returns the underlying value/reference, exactly as
+  // originally passed. The behavior of calling this more than once on
+  // the same object is unspecified.
+  T Unwrap() { return std::move(value_); }
+
+  // Provides nondestructive access to the underlying value/reference.
+  // Always returns a const reference (more precisely,
+  // const std::add_lvalue_reference<T>::type). The behavior of calling this
+  // after calling Unwrap on the same object is unspecified.
+  const T& Peek() const {
+    return value_;
+  }
+
+ private:
+  T value_;
+};
+
+// Specialization for lvalue reference types. See primary template
+// for documentation.
+template <typename T>
+class ReferenceOrValueWrapper<T&> {
+ public:
+  // Workaround for debatable pass-by-reference lint warning (c-library-team
+  // policy precludes NOLINT in this context)
+  typedef T& reference;
+  explicit ReferenceOrValueWrapper(reference ref)
+      : value_ptr_(&ref) {}
+  T& Unwrap() { return *value_ptr_; }
+  const T& Peek() const { return *value_ptr_; }
+
+ private:
+  T* value_ptr_;
+};
+
+// C++ treats the void type specially.  For example, you cannot define
+// a void-typed variable or pass a void value to a function.
+// ActionResultHolder<T> holds a value of type T, where T must be a
+// copyable type or void (T doesn't need to be default-constructable).
+// It hides the syntactic difference between void and other types, and
+// is used to unify the code for invoking both void-returning and
+// non-void-returning mock functions.
+
+// Untyped base class for ActionResultHolder<T>.
+class UntypedActionResultHolderBase {
+ public:
+  virtual ~UntypedActionResultHolderBase() {}
+
+  // Prints the held value as an action's result to os.
+  virtual void PrintAsActionResult(::std::ostream* os) const = 0;
+};
+
+// This generic definition is used when T is not void.
+template <typename T>
+class ActionResultHolder : public UntypedActionResultHolderBase {
+ public:
+  // Returns the held value. Must not be called more than once.
+  T Unwrap() {
+    return result_.Unwrap();
+  }
+
+  // Prints the held value as an action's result to os.
+  void PrintAsActionResult(::std::ostream* os) const override {
+    *os << "\n          Returns: ";
+    // T may be a reference type, so we don't use UniversalPrint().
+    UniversalPrinter<T>::Print(result_.Peek(), os);
+  }
+
+  // Performs the given mock function's default action and returns the
+  // result in a new-ed ActionResultHolder.
+  template <typename F>
+  static ActionResultHolder* PerformDefaultAction(
+      const FunctionMocker<F>* func_mocker,
+      typename Function<F>::ArgumentTuple&& args,
+      const std::string& call_description) {
+    return new ActionResultHolder(Wrapper(func_mocker->PerformDefaultAction(
+        std::move(args), call_description)));
+  }
+
+  // Performs the given action and returns the result in a new-ed
+  // ActionResultHolder.
+  template <typename F>
+  static ActionResultHolder* PerformAction(
+      const Action<F>& action, typename Function<F>::ArgumentTuple&& args) {
+    return new ActionResultHolder(
+        Wrapper(action.Perform(std::move(args))));
+  }
+
+ private:
+  typedef ReferenceOrValueWrapper<T> Wrapper;
+
+  explicit ActionResultHolder(Wrapper result)
+      : result_(std::move(result)) {
+  }
+
+  Wrapper result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
+};
+
+// Specialization for T = void.
+template <>
+class ActionResultHolder<void> : public UntypedActionResultHolderBase {
+ public:
+  void Unwrap() { }
+
+  void PrintAsActionResult(::std::ostream* /* os */) const override {}
+
+  // Performs the given mock function's default action and returns ownership
+  // of an empty ActionResultHolder*.
+  template <typename F>
+  static ActionResultHolder* PerformDefaultAction(
+      const FunctionMocker<F>* func_mocker,
+      typename Function<F>::ArgumentTuple&& args,
+      const std::string& call_description) {
+    func_mocker->PerformDefaultAction(std::move(args), call_description);
+    return new ActionResultHolder;
+  }
+
+  // Performs the given action and returns ownership of an empty
+  // ActionResultHolder*.
+  template <typename F>
+  static ActionResultHolder* PerformAction(
+      const Action<F>& action, typename Function<F>::ArgumentTuple&& args) {
+    action.Perform(std::move(args));
+    return new ActionResultHolder;
+  }
+
+ private:
+  ActionResultHolder() {}
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
+};
+
+template <typename F>
+class FunctionMocker;
+
+template <typename R, typename... Args>
+class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
+  using F = R(Args...);
+
+ public:
+  using Result = R;
+  using ArgumentTuple = std::tuple<Args...>;
+  using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>;
+
+  FunctionMocker() {}
+
+  // There is no generally useful and implementable semantics of
+  // copying a mock object, so copying a mock is usually a user error.
+  // Thus we disallow copying function mockers.  If the user really
+  // wants to copy a mock object, they should implement their own copy
+  // operation, for example:
+  //
+  //   class MockFoo : public Foo {
+  //    public:
+  //     // Defines a copy constructor explicitly.
+  //     MockFoo(const MockFoo& src) {}
+  //     ...
+  //   };
+  FunctionMocker(const FunctionMocker&) = delete;
+  FunctionMocker& operator=(const FunctionMocker&) = delete;
+
+  // The destructor verifies that all expectations on this mock
+  // function have been satisfied.  If not, it will report Google Test
+  // non-fatal failures for the violations.
+  ~FunctionMocker() override GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    MutexLock l(&g_gmock_mutex);
+    VerifyAndClearExpectationsLocked();
+    Mock::UnregisterLocked(this);
+    ClearDefaultActionsLocked();
+  }
+
+  // Returns the ON_CALL spec that matches this mock function with the
+  // given arguments; returns NULL if no matching ON_CALL is found.
+  // L = *
+  const OnCallSpec<F>* FindOnCallSpec(
+      const ArgumentTuple& args) const {
+    for (UntypedOnCallSpecs::const_reverse_iterator it
+             = untyped_on_call_specs_.rbegin();
+         it != untyped_on_call_specs_.rend(); ++it) {
+      const OnCallSpec<F>* spec = static_cast<const OnCallSpec<F>*>(*it);
+      if (spec->Matches(args))
+        return spec;
+    }
+
+    return nullptr;
+  }
+
+  // Performs the default action of this mock function on the given
+  // arguments and returns the result. Asserts (or throws if
+  // exceptions are enabled) with a helpful call descrption if there
+  // is no valid return value. This method doesn't depend on the
+  // mutable state of this object, and thus can be called concurrently
+  // without locking.
+  // L = *
+  Result PerformDefaultAction(ArgumentTuple&& args,
+                              const std::string& call_description) const {
+    const OnCallSpec<F>* const spec =
+        this->FindOnCallSpec(args);
+    if (spec != nullptr) {
+      return spec->GetAction().Perform(std::move(args));
+    }
+    const std::string message =
+        call_description +
+        "\n    The mock function has no default action "
+        "set, and its return type has no default value set.";
+#if GTEST_HAS_EXCEPTIONS
+    if (!DefaultValue<Result>::Exists()) {
+      throw std::runtime_error(message);
+    }
+#else
+    Assert(DefaultValue<Result>::Exists(), "", -1, message);
+#endif
+    return DefaultValue<Result>::Get();
+  }
+
+  // Performs the default action with the given arguments and returns
+  // the action's result.  The call description string will be used in
+  // the error message to describe the call in the case the default
+  // action fails.  The caller is responsible for deleting the result.
+  // L = *
+  UntypedActionResultHolderBase* UntypedPerformDefaultAction(
+      void* untyped_args,  // must point to an ArgumentTuple
+      const std::string& call_description) const override {
+    ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
+    return ResultHolder::PerformDefaultAction(this, std::move(*args),
+                                              call_description);
+  }
+
+  // Performs the given action with the given arguments and returns
+  // the action's result.  The caller is responsible for deleting the
+  // result.
+  // L = *
+  UntypedActionResultHolderBase* UntypedPerformAction(
+      const void* untyped_action, void* untyped_args) const override {
+    // Make a copy of the action before performing it, in case the
+    // action deletes the mock object (and thus deletes itself).
+    const Action<F> action = *static_cast<const Action<F>*>(untyped_action);
+    ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
+    return ResultHolder::PerformAction(action, std::move(*args));
+  }
+
+  // Implements UntypedFunctionMockerBase::ClearDefaultActionsLocked():
+  // clears the ON_CALL()s set on this mock function.
+  void ClearDefaultActionsLocked() override
+      GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+
+    // Deleting our default actions may trigger other mock objects to be
+    // deleted, for example if an action contains a reference counted smart
+    // pointer to that mock object, and that is the last reference. So if we
+    // delete our actions within the context of the global mutex we may deadlock
+    // when this method is called again. Instead, make a copy of the set of
+    // actions to delete, clear our set within the mutex, and then delete the
+    // actions outside of the mutex.
+    UntypedOnCallSpecs specs_to_delete;
+    untyped_on_call_specs_.swap(specs_to_delete);
+
+    g_gmock_mutex.Unlock();
+    for (UntypedOnCallSpecs::const_iterator it =
+             specs_to_delete.begin();
+         it != specs_to_delete.end(); ++it) {
+      delete static_cast<const OnCallSpec<F>*>(*it);
+    }
+
+    // Lock the mutex again, since the caller expects it to be locked when we
+    // return.
+    g_gmock_mutex.Lock();
+  }
+
+  // Returns the result of invoking this mock function with the given
+  // arguments.  This function can be safely called from multiple
+  // threads concurrently.
+  Result Invoke(Args... args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    ArgumentTuple tuple(std::forward<Args>(args)...);
+    std::unique_ptr<ResultHolder> holder(DownCast_<ResultHolder*>(
+        this->UntypedInvokeWith(static_cast<void*>(&tuple))));
+    return holder->Unwrap();
+  }
+
+  MockSpec<F> With(Matcher<Args>... m) {
+    return MockSpec<F>(this, ::std::make_tuple(std::move(m)...));
+  }
+
+ protected:
+  template <typename Function>
+  friend class MockSpec;
+
+  typedef ActionResultHolder<Result> ResultHolder;
+
+  // Adds and returns a default action spec for this mock function.
+  OnCallSpec<F>& AddNewOnCallSpec(
+      const char* file, int line,
+      const ArgumentMatcherTuple& m)
+          GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
+    OnCallSpec<F>* const on_call_spec = new OnCallSpec<F>(file, line, m);
+    untyped_on_call_specs_.push_back(on_call_spec);
+    return *on_call_spec;
+  }
+
+  // Adds and returns an expectation spec for this mock function.
+  TypedExpectation<F>& AddNewExpectation(const char* file, int line,
+                                         const std::string& source_text,
+                                         const ArgumentMatcherTuple& m)
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    Mock::RegisterUseByOnCallOrExpectCall(MockObject(), file, line);
+    TypedExpectation<F>* const expectation =
+        new TypedExpectation<F>(this, file, line, source_text, m);
+    const std::shared_ptr<ExpectationBase> untyped_expectation(expectation);
+    // See the definition of untyped_expectations_ for why access to
+    // it is unprotected here.
+    untyped_expectations_.push_back(untyped_expectation);
+
+    // Adds this expectation into the implicit sequence if there is one.
+    Sequence* const implicit_sequence = g_gmock_implicit_sequence.get();
+    if (implicit_sequence != nullptr) {
+      implicit_sequence->AddExpectation(Expectation(untyped_expectation));
+    }
+
+    return *expectation;
+  }
+
+ private:
+  template <typename Func> friend class TypedExpectation;
+
+  // Some utilities needed for implementing UntypedInvokeWith().
+
+  // Describes what default action will be performed for the given
+  // arguments.
+  // L = *
+  void DescribeDefaultActionTo(const ArgumentTuple& args,
+                               ::std::ostream* os) const {
+    const OnCallSpec<F>* const spec = FindOnCallSpec(args);
+
+    if (spec == nullptr) {
+      *os << (std::is_void<Result>::value ? "returning directly.\n"
+                                          : "returning default value.\n");
+    } else {
+      *os << "taking default action specified at:\n"
+          << FormatFileLocation(spec->file(), spec->line()) << "\n";
+    }
+  }
+
+  // Writes a message that the call is uninteresting (i.e. neither
+  // explicitly expected nor explicitly unexpected) to the given
+  // ostream.
+  void UntypedDescribeUninterestingCall(const void* untyped_args,
+                                        ::std::ostream* os) const override
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    const ArgumentTuple& args =
+        *static_cast<const ArgumentTuple*>(untyped_args);
+    *os << "Uninteresting mock function call - ";
+    DescribeDefaultActionTo(args, os);
+    *os << "    Function call: " << Name();
+    UniversalPrint(args, os);
+  }
+
+  // Returns the expectation that matches the given function arguments
+  // (or NULL is there's no match); when a match is found,
+  // untyped_action is set to point to the action that should be
+  // performed (or NULL if the action is "do default"), and
+  // is_excessive is modified to indicate whether the call exceeds the
+  // expected number.
+  //
+  // Critical section: We must find the matching expectation and the
+  // corresponding action that needs to be taken in an ATOMIC
+  // transaction.  Otherwise another thread may call this mock
+  // method in the middle and mess up the state.
+  //
+  // However, performing the action has to be left out of the critical
+  // section.  The reason is that we have no control on what the
+  // action does (it can invoke an arbitrary user function or even a
+  // mock function) and excessive locking could cause a dead lock.
+  const ExpectationBase* UntypedFindMatchingExpectation(
+      const void* untyped_args, const void** untyped_action, bool* is_excessive,
+      ::std::ostream* what, ::std::ostream* why) override
+      GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+    const ArgumentTuple& args =
+        *static_cast<const ArgumentTuple*>(untyped_args);
+    MutexLock l(&g_gmock_mutex);
+    TypedExpectation<F>* exp = this->FindMatchingExpectationLocked(args);
+    if (exp == nullptr) {  // A match wasn't found.
+      this->FormatUnexpectedCallMessageLocked(args, what, why);
+      return nullptr;
+    }
+
+    // This line must be done before calling GetActionForArguments(),
+    // which will increment the call count for *exp and thus affect
+    // its saturation status.
+    *is_excessive = exp->IsSaturated();
+    const Action<F>* action = exp->GetActionForArguments(this, args, what, why);
+    if (action != nullptr && action->IsDoDefault())
+      action = nullptr;  // Normalize "do default" to NULL.
+    *untyped_action = action;
+    return exp;
+  }
+
+  // Prints the given function arguments to the ostream.
+  void UntypedPrintArgs(const void* untyped_args,
+                        ::std::ostream* os) const override {
+    const ArgumentTuple& args =
+        *static_cast<const ArgumentTuple*>(untyped_args);
+    UniversalPrint(args, os);
+  }
+
+  // Returns the expectation that matches the arguments, or NULL if no
+  // expectation matches them.
+  TypedExpectation<F>* FindMatchingExpectationLocked(
+      const ArgumentTuple& args) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    // See the definition of untyped_expectations_ for why access to
+    // it is unprotected here.
+    for (typename UntypedExpectations::const_reverse_iterator it =
+             untyped_expectations_.rbegin();
+         it != untyped_expectations_.rend(); ++it) {
+      TypedExpectation<F>* const exp =
+          static_cast<TypedExpectation<F>*>(it->get());
+      if (exp->ShouldHandleArguments(args)) {
+        return exp;
+      }
+    }
+    return nullptr;
+  }
+
+  // Returns a message that the arguments don't match any expectation.
+  void FormatUnexpectedCallMessageLocked(
+      const ArgumentTuple& args,
+      ::std::ostream* os,
+      ::std::ostream* why) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    *os << "\nUnexpected mock function call - ";
+    DescribeDefaultActionTo(args, os);
+    PrintTriedExpectationsLocked(args, why);
+  }
+
+  // Prints a list of expectations that have been tried against the
+  // current mock function call.
+  void PrintTriedExpectationsLocked(
+      const ArgumentTuple& args,
+      ::std::ostream* why) const
+          GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+    g_gmock_mutex.AssertHeld();
+    const size_t count = untyped_expectations_.size();
+    *why << "Google Mock tried the following " << count << " "
+         << (count == 1 ? "expectation, but it didn't match" :
+             "expectations, but none matched")
+         << ":\n";
+    for (size_t i = 0; i < count; i++) {
+      TypedExpectation<F>* const expectation =
+          static_cast<TypedExpectation<F>*>(untyped_expectations_[i].get());
+      *why << "\n";
+      expectation->DescribeLocationTo(why);
+      if (count > 1) {
+        *why << "tried expectation #" << i << ": ";
+      }
+      *why << expectation->source_text() << "...\n";
+      expectation->ExplainMatchResultTo(args, why);
+      expectation->DescribeCallCountTo(why);
+    }
+  }
+};  // class FunctionMocker
+
+// Reports an uninteresting call (whose description is in msg) in the
+// manner specified by 'reaction'.
+void ReportUninterestingCall(CallReaction reaction, const std::string& msg);
+
+}  // namespace internal
+
+namespace internal {
+
+template <typename F>
+class MockFunction;
+
+template <typename R, typename... Args>
+class MockFunction<R(Args...)> {
+ public:
+  MockFunction(const MockFunction&) = delete;
+  MockFunction& operator=(const MockFunction&) = delete;
+
+  std::function<R(Args...)> AsStdFunction() {
+    return [this](Args... args) -> R {
+      return this->Call(std::forward<Args>(args)...);
+    };
+  }
+
+  // Implementation detail: the expansion of the MOCK_METHOD macro.
+  R Call(Args... args) {
+    mock_.SetOwnerAndName(this, "Call");
+    return mock_.Invoke(std::forward<Args>(args)...);
+  }
+
+  MockSpec<R(Args...)> gmock_Call(Matcher<Args>... m) {
+    mock_.RegisterOwner(this);
+    return mock_.With(std::move(m)...);
+  }
+
+  MockSpec<R(Args...)> gmock_Call(const WithoutMatchers&, R (*)(Args...)) {
+    return this->gmock_Call(::testing::A<Args>()...);
+  }
+
+ protected:
+  MockFunction() = default;
+  ~MockFunction() = default;
+
+ private:
+  FunctionMocker<R(Args...)> mock_;
+};
+
+/*
+The SignatureOf<F> struct is a meta-function returning function signature
+corresponding to the provided F argument.
+
+It makes use of MockFunction easier by allowing it to accept more F arguments
+than just function signatures.
+
+Specializations provided here cover a signature type itself and any template
+that can be parameterized with a signature, including std::function and
+boost::function.
+*/
+
+template <typename F, typename = void>
+struct SignatureOf;
+
+template <typename R, typename... Args>
+struct SignatureOf<R(Args...)> {
+  using type = R(Args...);
+};
+
+template <template <typename> class C, typename F>
+struct SignatureOf<C<F>,
+                   typename std::enable_if<std::is_function<F>::value>::type>
+    : SignatureOf<F> {};
+
+template <typename F>
+using SignatureOfT = typename SignatureOf<F>::type;
+
+}  // namespace internal
+
+// A MockFunction<F> type has one mock method whose type is
+// internal::SignatureOfT<F>.  It is useful when you just want your
+// test code to emit some messages and have Google Mock verify the
+// right messages are sent (and perhaps at the right times).  For
+// example, if you are exercising code:
+//
+//   Foo(1);
+//   Foo(2);
+//   Foo(3);
+//
+// and want to verify that Foo(1) and Foo(3) both invoke
+// mock.Bar("a"), but Foo(2) doesn't invoke anything, you can write:
+//
+// TEST(FooTest, InvokesBarCorrectly) {
+//   MyMock mock;
+//   MockFunction<void(string check_point_name)> check;
+//   {
+//     InSequence s;
+//
+//     EXPECT_CALL(mock, Bar("a"));
+//     EXPECT_CALL(check, Call("1"));
+//     EXPECT_CALL(check, Call("2"));
+//     EXPECT_CALL(mock, Bar("a"));
+//   }
+//   Foo(1);
+//   check.Call("1");
+//   Foo(2);
+//   check.Call("2");
+//   Foo(3);
+// }
+//
+// The expectation spec says that the first Bar("a") must happen
+// before check point "1", the second Bar("a") must happen after check
+// point "2", and nothing should happen between the two check
+// points. The explicit check points make it easy to tell which
+// Bar("a") is called by which call to Foo().
+//
+// MockFunction<F> can also be used to exercise code that accepts
+// std::function<internal::SignatureOfT<F>> callbacks. To do so, use
+// AsStdFunction() method to create std::function proxy forwarding to
+// original object's Call. Example:
+//
+// TEST(FooTest, RunsCallbackWithBarArgument) {
+//   MockFunction<int(string)> callback;
+//   EXPECT_CALL(callback, Call("bar")).WillOnce(Return(1));
+//   Foo(callback.AsStdFunction());
+// }
+//
+// The internal::SignatureOfT<F> indirection allows to use other types
+// than just function signature type. This is typically useful when
+// providing a mock for a predefined std::function type. Example:
+//
+// using FilterPredicate = std::function<bool(string)>;
+// void MyFilterAlgorithm(FilterPredicate predicate);
+//
+// TEST(FooTest, FilterPredicateAlwaysAccepts) {
+//   MockFunction<FilterPredicate> predicateMock;
+//   EXPECT_CALL(predicateMock, Call(_)).WillRepeatedly(Return(true));
+//   MyFilterAlgorithm(predicateMock.AsStdFunction());
+// }
+template <typename F>
+class MockFunction : public internal::MockFunction<internal::SignatureOfT<F>> {
+  using Base = internal::MockFunction<internal::SignatureOfT<F>>;
+
+ public:
+  using Base::Base;
+};
+
+// The style guide prohibits "using" statements in a namespace scope
+// inside a header file.  However, the MockSpec class template is
+// meant to be defined in the ::testing namespace.  The following line
+// is just a trick for working around a bug in MSVC 8.0, which cannot
+// handle it if we define MockSpec in ::testing.
+using internal::MockSpec;
+
+// Const(x) is a convenient function for obtaining a const reference
+// to x.  This is useful for setting expectations on an overloaded
+// const mock method, e.g.
+//
+//   class MockFoo : public FooInterface {
+//    public:
+//     MOCK_METHOD0(Bar, int());
+//     MOCK_CONST_METHOD0(Bar, int&());
+//   };
+//
+//   MockFoo foo;
+//   // Expects a call to non-const MockFoo::Bar().
+//   EXPECT_CALL(foo, Bar());
+//   // Expects a call to const MockFoo::Bar().
+//   EXPECT_CALL(Const(foo), Bar());
+template <typename T>
+inline const T& Const(const T& x) { return x; }
+
+// Constructs an Expectation object that references and co-owns exp.
+inline Expectation::Expectation(internal::ExpectationBase& exp)  // NOLINT
+    : expectation_base_(exp.GetHandle().expectation_base()) {}
+
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+// Implementation for ON_CALL and EXPECT_CALL macros. A separate macro is
+// required to avoid compile errors when the name of the method used in call is
+// a result of macro expansion. See CompilesWithMethodNameExpandedFromMacro
+// tests in internal/gmock-spec-builders_test.cc for more details.
+//
+// This macro supports statements both with and without parameter matchers. If
+// the parameter list is omitted, gMock will accept any parameters, which allows
+// tests to be written that don't need to encode the number of method
+// parameter. This technique may only be used for non-overloaded methods.
+//
+//   // These are the same:
+//   ON_CALL(mock, NoArgsMethod()).WillByDefault(...);
+//   ON_CALL(mock, NoArgsMethod).WillByDefault(...);
+//
+//   // As are these:
+//   ON_CALL(mock, TwoArgsMethod(_, _)).WillByDefault(...);
+//   ON_CALL(mock, TwoArgsMethod).WillByDefault(...);
+//
+//   // Can also specify args if you want, of course:
+//   ON_CALL(mock, TwoArgsMethod(_, 45)).WillByDefault(...);
+//
+//   // Overloads work as long as you specify parameters:
+//   ON_CALL(mock, OverloadedMethod(_)).WillByDefault(...);
+//   ON_CALL(mock, OverloadedMethod(_, _)).WillByDefault(...);
+//
+//   // Oops! Which overload did you want?
+//   ON_CALL(mock, OverloadedMethod).WillByDefault(...);
+//     => ERROR: call to member function 'gmock_OverloadedMethod' is ambiguous
+//
+// How this works: The mock class uses two overloads of the gmock_Method
+// expectation setter method plus an operator() overload on the MockSpec object.
+// In the matcher list form, the macro expands to:
+//
+//   // This statement:
+//   ON_CALL(mock, TwoArgsMethod(_, 45))...
+//
+//   // ...expands to:
+//   mock.gmock_TwoArgsMethod(_, 45)(WithoutMatchers(), nullptr)...
+//   |-------------v---------------||------------v-------------|
+//       invokes first overload        swallowed by operator()
+//
+//   // ...which is essentially:
+//   mock.gmock_TwoArgsMethod(_, 45)...
+//
+// Whereas the form without a matcher list:
+//
+//   // This statement:
+//   ON_CALL(mock, TwoArgsMethod)...
+//
+//   // ...expands to:
+//   mock.gmock_TwoArgsMethod(WithoutMatchers(), nullptr)...
+//   |-----------------------v--------------------------|
+//                 invokes second overload
+//
+//   // ...which is essentially:
+//   mock.gmock_TwoArgsMethod(_, _)...
+//
+// The WithoutMatchers() argument is used to disambiguate overloads and to
+// block the caller from accidentally invoking the second overload directly. The
+// second argument is an internal type derived from the method signature. The
+// failure to disambiguate two overloads of this method in the ON_CALL statement
+// is how we block callers from setting expectations on overloaded methods.
+#define GMOCK_ON_CALL_IMPL_(mock_expr, Setter, call)                    \
+  ((mock_expr).gmock_##call)(::testing::internal::GetWithoutMatchers(), \
+                             nullptr)                                   \
+      .Setter(__FILE__, __LINE__, #mock_expr, #call)
+
+#define ON_CALL(obj, call) \
+  GMOCK_ON_CALL_IMPL_(obj, InternalDefaultActionSetAt, call)
+
+#define EXPECT_CALL(obj, call) \
+  GMOCK_ON_CALL_IMPL_(obj, InternalExpectedAt, call)
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
diff --git a/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock.h b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock.h
new file mode 100644
index 000000000..12469bc46
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/gmock.h
@@ -0,0 +1,98 @@
+// Copyright 2007, 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.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This is the main header file a user should include.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_
+
+// This file implements the following syntax:
+//
+//   ON_CALL(mock_object, Method(...))
+//     .With(...) ?
+//     .WillByDefault(...);
+//
+// where With() is optional and WillByDefault() must appear exactly
+// once.
+//
+//   EXPECT_CALL(mock_object, Method(...))
+//     .With(...) ?
+//     .Times(...) ?
+//     .InSequence(...) *
+//     .WillOnce(...) *
+//     .WillRepeatedly(...) ?
+//     .RetiresOnSaturation() ? ;
+//
+// 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/internal/gmock-internal-utils.h"
+
+namespace testing {
+
+// Declares Google Mock flags that we want a user to use programmatically.
+GMOCK_DECLARE_bool_(catch_leaked_mocks);
+GMOCK_DECLARE_string_(verbose);
+GMOCK_DECLARE_int32_(default_mock_behavior);
+
+// Initializes Google Mock.  This must be called before running the
+// tests.  In particular, it parses the command line for the flags
+// that Google Mock recognizes.  Whenever a Google Mock flag is seen,
+// it is removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Mock flag variables are
+// updated.
+//
+// Since Google Test is needed for Google Mock to work, this function
+// also initializes Google Test and parses its flags, if that hasn't
+// been done.
+GTEST_API_ void InitGoogleMock(int* argc, char** argv);
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv);
+
+// This overloaded version can be used on Arduino/embedded platforms where
+// there is no argc/argv.
+GTEST_API_ void InitGoogleMock();
+
+}  // namespace testing
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_H_
diff --git a/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/custom/README.md b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/custom/README.md
new file mode 100644
index 000000000..f6c93f616
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/custom/README.md
@@ -0,0 +1,16 @@
+# Customization Points
+
+The custom directory is an injection point for custom user configurations.
+
+## Header `gmock-port.h`
+
+The following macros can be defined:
+
+### Flag related macros:
+
+*   `GMOCK_DECLARE_bool_(name)`
+*   `GMOCK_DECLARE_int32_(name)`
+*   `GMOCK_DECLARE_string_(name)`
+*   `GMOCK_DEFINE_bool_(name, default_val, doc)`
+*   `GMOCK_DEFINE_int32_(name, default_val, doc)`
+*   `GMOCK_DEFINE_string_(name, default_val, doc)`
diff --git a/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/custom/gmock-generated-actions.h b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/custom/gmock-generated-actions.h
new file mode 100644
index 000000000..63f899962
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/custom/gmock-generated-actions.h
@@ -0,0 +1,6 @@
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
diff --git a/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/custom/gmock-matchers.h b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/custom/gmock-matchers.h
new file mode 100644
index 000000000..638429488
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/custom/gmock-matchers.h
@@ -0,0 +1,36 @@
+// Copyright 2015, 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.
+//
+// Injection point for custom user configurations. See README for details
+//
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
diff --git a/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/custom/gmock-port.h b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/custom/gmock-port.h
new file mode 100644
index 000000000..14378692a
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/custom/gmock-port.h
@@ -0,0 +1,39 @@
+// Copyright 2015, 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.
+//
+// Injection point for custom user configurations. See README for details
+//
+// ** Custom implementation starts here **
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
diff --git a/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/gmock-internal-utils.h b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/gmock-internal-utils.h
new file mode 100644
index 000000000..317544a7d
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/gmock-internal-utils.h
@@ -0,0 +1,459 @@
+// Copyright 2007, 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.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file defines some utilities useful for implementing Google
+// Mock.  They are subject to change without notice, so please DO NOT
+// USE THEM IN USER CODE.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
+
+#include <stdio.h>
+#include <ostream>  // NOLINT
+#include <string>
+#include <type_traits>
+#include "gmock/internal/gmock-port.h"
+#include "gtest/gtest.h"
+
+namespace testing {
+
+template <typename>
+class Matcher;
+
+namespace internal {
+
+// Silence MSVC C4100 (unreferenced formal parameter) and
+// C4805('==': unsafe mix of type 'const int' and type 'const bool')
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4100)
+# pragma warning(disable:4805)
+#endif
+
+// Joins a vector of strings as if they are fields of a tuple; returns
+// the joined string.
+GTEST_API_ std::string JoinAsTuple(const Strings& fields);
+
+// Converts an identifier name to a space-separated list of lower-case
+// words.  Each maximum substring of the form [A-Za-z][a-z]*|\d+ is
+// treated as one word.  For example, both "FooBar123" and
+// "foo_bar_123" are converted to "foo bar 123".
+GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name);
+
+// GetRawPointer(p) returns the raw pointer underlying p when p is a
+// smart pointer, or returns p itself when p is already a raw pointer.
+// The following default implementation is for the smart pointer case.
+template <typename Pointer>
+inline const typename Pointer::element_type* GetRawPointer(const Pointer& p) {
+  return p.get();
+}
+// This overloaded version is for the raw pointer case.
+template <typename Element>
+inline Element* GetRawPointer(Element* p) { return p; }
+
+// MSVC treats wchar_t as a native type usually, but treats it as the
+// same as unsigned short when the compiler option /Zc:wchar_t- is
+// specified.  It defines _NATIVE_WCHAR_T_DEFINED symbol when wchar_t
+// is a native type.
+#if defined(_MSC_VER) && !defined(_NATIVE_WCHAR_T_DEFINED)
+// wchar_t is a typedef.
+#else
+# define GMOCK_WCHAR_T_IS_NATIVE_ 1
+#endif
+
+// In what follows, we use the term "kind" to indicate whether a type
+// is bool, an integer type (excluding bool), a floating-point type,
+// or none of them.  This categorization is useful for determining
+// when a matcher argument type can be safely converted to another
+// type in the implementation of SafeMatcherCast.
+enum TypeKind {
+  kBool, kInteger, kFloatingPoint, kOther
+};
+
+// KindOf<T>::value is the kind of type T.
+template <typename T> struct KindOf {
+  enum { value = kOther };  // The default kind.
+};
+
+// This macro declares that the kind of 'type' is 'kind'.
+#define GMOCK_DECLARE_KIND_(type, kind) \
+  template <> struct KindOf<type> { enum { value = kind }; }
+
+GMOCK_DECLARE_KIND_(bool, kBool);
+
+// All standard integer types.
+GMOCK_DECLARE_KIND_(char, kInteger);
+GMOCK_DECLARE_KIND_(signed char, kInteger);
+GMOCK_DECLARE_KIND_(unsigned char, kInteger);
+GMOCK_DECLARE_KIND_(short, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(unsigned short, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(int, kInteger);
+GMOCK_DECLARE_KIND_(unsigned int, kInteger);
+GMOCK_DECLARE_KIND_(long, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(unsigned long, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(long long, kInteger);  // NOLINT
+GMOCK_DECLARE_KIND_(unsigned long long, kInteger);  // NOLINT
+
+#if GMOCK_WCHAR_T_IS_NATIVE_
+GMOCK_DECLARE_KIND_(wchar_t, kInteger);
+#endif
+
+// All standard floating-point types.
+GMOCK_DECLARE_KIND_(float, kFloatingPoint);
+GMOCK_DECLARE_KIND_(double, kFloatingPoint);
+GMOCK_DECLARE_KIND_(long double, kFloatingPoint);
+
+#undef GMOCK_DECLARE_KIND_
+
+// Evaluates to the kind of 'type'.
+#define GMOCK_KIND_OF_(type) \
+  static_cast< ::testing::internal::TypeKind>( \
+      ::testing::internal::KindOf<type>::value)
+
+// LosslessArithmeticConvertibleImpl<kFromKind, From, kToKind, To>::value
+// is true if and only if arithmetic type From can be losslessly converted to
+// arithmetic type To.
+//
+// It's the user's responsibility to ensure that both From and To are
+// raw (i.e. has no CV modifier, is not a pointer, and is not a
+// reference) built-in arithmetic types, kFromKind is the kind of
+// From, and kToKind is the kind of To; the value is
+// implementation-defined when the above pre-condition is violated.
+template <TypeKind kFromKind, typename From, TypeKind kToKind, typename To>
+using LosslessArithmeticConvertibleImpl = std::integral_constant<
+    bool,
+    // clang-format off
+      // Converting from bool is always lossless
+      (kFromKind == kBool) ? true
+      // Converting between any other type kinds will be lossy if the type
+      // kinds are not the same.
+    : (kFromKind != kToKind) ? false
+    : (kFromKind == kInteger &&
+       // Converting between integers of different widths is allowed so long
+       // as the conversion does not go from signed to unsigned.
+      (((sizeof(From) < sizeof(To)) &&
+        !(std::is_signed<From>::value && !std::is_signed<To>::value)) ||
+       // Converting between integers of the same width only requires the
+       // two types to have the same signedness.
+       ((sizeof(From) == sizeof(To)) &&
+        (std::is_signed<From>::value == std::is_signed<To>::value)))
+       ) ? true
+      // Floating point conversions are lossless if and only if `To` is at least
+      // as wide as `From`.
+    : (kFromKind == kFloatingPoint && (sizeof(From) <= sizeof(To))) ? true
+    : false
+    // clang-format on
+    >;
+
+// LosslessArithmeticConvertible<From, To>::value is true if and only if
+// arithmetic type From can be losslessly converted to arithmetic type To.
+//
+// It's the user's responsibility to ensure that both From and To are
+// raw (i.e. has no CV modifier, is not a pointer, and is not a
+// reference) built-in arithmetic types; the value is
+// implementation-defined when the above pre-condition is violated.
+template <typename From, typename To>
+using LosslessArithmeticConvertible =
+    LosslessArithmeticConvertibleImpl<GMOCK_KIND_OF_(From), From,
+                                      GMOCK_KIND_OF_(To), To>;
+
+// This interface knows how to report a Google Mock failure (either
+// non-fatal or fatal).
+class FailureReporterInterface {
+ public:
+  // The type of a failure (either non-fatal or fatal).
+  enum FailureType {
+    kNonfatal, kFatal
+  };
+
+  virtual ~FailureReporterInterface() {}
+
+  // Reports a failure that occurred at the given source file location.
+  virtual void ReportFailure(FailureType type, const char* file, int line,
+                             const std::string& message) = 0;
+};
+
+// Returns the failure reporter used by Google Mock.
+GTEST_API_ FailureReporterInterface* GetFailureReporter();
+
+// Asserts that condition is true; aborts the process with the given
+// message if condition is false.  We cannot use LOG(FATAL) or CHECK()
+// as Google Mock might be used to mock the log sink itself.  We
+// inline this function to prevent it from showing up in the stack
+// trace.
+inline void Assert(bool condition, const char* file, int line,
+                   const std::string& msg) {
+  if (!condition) {
+    GetFailureReporter()->ReportFailure(FailureReporterInterface::kFatal,
+                                        file, line, msg);
+  }
+}
+inline void Assert(bool condition, const char* file, int line) {
+  Assert(condition, file, line, "Assertion failed.");
+}
+
+// Verifies that condition is true; generates a non-fatal failure if
+// condition is false.
+inline void Expect(bool condition, const char* file, int line,
+                   const std::string& msg) {
+  if (!condition) {
+    GetFailureReporter()->ReportFailure(FailureReporterInterface::kNonfatal,
+                                        file, line, msg);
+  }
+}
+inline void Expect(bool condition, const char* file, int line) {
+  Expect(condition, file, line, "Expectation failed.");
+}
+
+// Severity level of a log.
+enum LogSeverity {
+  kInfo = 0,
+  kWarning = 1
+};
+
+// Valid values for the --gmock_verbose flag.
+
+// All logs (informational and warnings) are printed.
+const char kInfoVerbosity[] = "info";
+// Only warnings are printed.
+const char kWarningVerbosity[] = "warning";
+// No logs are printed.
+const char kErrorVerbosity[] = "error";
+
+// Returns true if and only if a log with the given severity is visible
+// according to the --gmock_verbose flag.
+GTEST_API_ bool LogIsVisible(LogSeverity severity);
+
+// Prints the given message to stdout if and only if 'severity' >= the level
+// specified by the --gmock_verbose flag.  If stack_frames_to_skip >=
+// 0, also prints the stack trace excluding the top
+// stack_frames_to_skip frames.  In opt mode, any positive
+// stack_frames_to_skip is treated as 0, since we don't know which
+// function calls will be inlined by the compiler and need to be
+// conservative.
+GTEST_API_ void Log(LogSeverity severity, const std::string& message,
+                    int stack_frames_to_skip);
+
+// A marker class that is used to resolve parameterless expectations to the
+// correct overload. This must not be instantiable, to prevent client code from
+// accidentally resolving to the overload; for example:
+//
+//    ON_CALL(mock, Method({}, nullptr))...
+//
+class WithoutMatchers {
+ private:
+  WithoutMatchers() {}
+  friend GTEST_API_ WithoutMatchers GetWithoutMatchers();
+};
+
+// Internal use only: access the singleton instance of WithoutMatchers.
+GTEST_API_ WithoutMatchers GetWithoutMatchers();
+
+// Disable MSVC warnings for infinite recursion, since in this case the
+// the recursion is unreachable.
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4717)
+#endif
+
+// Invalid<T>() is usable as an expression of type T, but will terminate
+// the program with an assertion failure if actually run.  This is useful
+// when a value of type T is needed for compilation, but the statement
+// will not really be executed (or we don't care if the statement
+// crashes).
+template <typename T>
+inline T Invalid() {
+  Assert(false, "", -1, "Internal error: attempt to return invalid value");
+  // This statement is unreachable, and would never terminate even if it
+  // could be reached. It is provided only to placate compiler warnings
+  // about missing return statements.
+  return Invalid<T>();
+}
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+// Given a raw type (i.e. having no top-level reference or const
+// modifier) RawContainer that's either an STL-style container or a
+// native array, class StlContainerView<RawContainer> has the
+// following members:
+//
+//   - type is a type that provides an STL-style container view to
+//     (i.e. implements the STL container concept for) RawContainer;
+//   - const_reference is a type that provides a reference to a const
+//     RawContainer;
+//   - ConstReference(raw_container) returns a const reference to an STL-style
+//     container view to raw_container, which is a RawContainer.
+//   - Copy(raw_container) returns an STL-style container view of a
+//     copy of raw_container, which is a RawContainer.
+//
+// This generic version is used when RawContainer itself is already an
+// STL-style container.
+template <class RawContainer>
+class StlContainerView {
+ public:
+  typedef RawContainer type;
+  typedef const type& const_reference;
+
+  static const_reference ConstReference(const RawContainer& container) {
+    static_assert(!std::is_const<RawContainer>::value,
+                  "RawContainer type must not be const");
+    return container;
+  }
+  static type Copy(const RawContainer& container) { return container; }
+};
+
+// This specialization is used when RawContainer is a native array type.
+template <typename Element, size_t N>
+class StlContainerView<Element[N]> {
+ public:
+  typedef typename std::remove_const<Element>::type RawElement;
+  typedef internal::NativeArray<RawElement> type;
+  // NativeArray<T> can represent a native array either by value or by
+  // reference (selected by a constructor argument), so 'const type'
+  // can be used to reference a const native array.  We cannot
+  // 'typedef const type& const_reference' here, as that would mean
+  // ConstReference() has to return a reference to a local variable.
+  typedef const type const_reference;
+
+  static const_reference ConstReference(const Element (&array)[N]) {
+    static_assert(std::is_same<Element, RawElement>::value,
+                  "Element type must not be const");
+    return type(array, N, RelationToSourceReference());
+  }
+  static type Copy(const Element (&array)[N]) {
+    return type(array, N, RelationToSourceCopy());
+  }
+};
+
+// This specialization is used when RawContainer is a native array
+// represented as a (pointer, size) tuple.
+template <typename ElementPointer, typename Size>
+class StlContainerView< ::std::tuple<ElementPointer, Size> > {
+ public:
+  typedef typename std::remove_const<
+      typename std::pointer_traits<ElementPointer>::element_type>::type
+      RawElement;
+  typedef internal::NativeArray<RawElement> type;
+  typedef const type const_reference;
+
+  static const_reference ConstReference(
+      const ::std::tuple<ElementPointer, Size>& array) {
+    return type(std::get<0>(array), std::get<1>(array),
+                RelationToSourceReference());
+  }
+  static type Copy(const ::std::tuple<ElementPointer, Size>& array) {
+    return type(std::get<0>(array), std::get<1>(array), RelationToSourceCopy());
+  }
+};
+
+// The following specialization prevents the user from instantiating
+// StlContainer with a reference type.
+template <typename T> class StlContainerView<T&>;
+
+// A type transform to remove constness from the first part of a pair.
+// Pairs like that are used as the value_type of associative containers,
+// and this transform produces a similar but assignable pair.
+template <typename T>
+struct RemoveConstFromKey {
+  typedef T type;
+};
+
+// Partially specialized to remove constness from std::pair<const K, V>.
+template <typename K, typename V>
+struct RemoveConstFromKey<std::pair<const K, V> > {
+  typedef std::pair<K, V> type;
+};
+
+// Emit an assertion failure due to incorrect DoDefault() usage. Out-of-lined to
+// reduce code size.
+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...>) -> decltype(
+    std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...)) {
+  return std::forward<F>(f)(std::get<Idx>(std::forward<Tuple>(args))...);
+}
+
+// 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>())) {
+  return ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
+                   MakeIndexSequence<std::tuple_size<
+                       typename std::remove_reference<Tuple>::type>::value>());
+}
+
+// Template struct Function<F>, where F must be a function type, contains
+// the following typedefs:
+//
+//   Result:               the function's return type.
+//   Arg<N>:               the type of the N-th argument, where N starts with 0.
+//   ArgumentTuple:        the tuple type consisting of all parameters of F.
+//   ArgumentMatcherTuple: the tuple type consisting of Matchers for all
+//                         parameters of F.
+//   MakeResultVoid:       the function type obtained by substituting void
+//                         for the return type of F.
+//   MakeResultIgnoredValue:
+//                         the function type obtained by substituting Something
+//                         for the return type of F.
+template <typename T>
+struct Function;
+
+template <typename R, typename... Args>
+struct Function<R(Args...)> {
+  using Result = R;
+  static constexpr size_t ArgumentCount = sizeof...(Args);
+  template <size_t I>
+  using Arg = ElemFromList<I, Args...>;
+  using ArgumentTuple = std::tuple<Args...>;
+  using ArgumentMatcherTuple = std::tuple<Matcher<Args>...>;
+  using MakeResultVoid = void(Args...);
+  using MakeResultIgnoredValue = IgnoredValue(Args...);
+};
+
+template <typename R, typename... Args>
+constexpr size_t Function<R(Args...)>::ArgumentCount;
+
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
diff --git a/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/gmock-port.h b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/gmock-port.h
new file mode 100644
index 000000000..367a44d36
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/gmock-port.h
@@ -0,0 +1,87 @@
+// Copyright 2008, 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.
+
+//
+// Low-level types and utilities for porting Google Mock to various
+// platforms.  All macros ending with _ and symbols defined in an
+// internal namespace are subject to change without notice.  Code
+// outside Google Mock MUST NOT USE THEM DIRECTLY.  Macros that don't
+// end with _ are part of Google Mock's public API and can be used by
+// code outside Google Mock.
+
+// GOOGLETEST_CM0002 DO NOT DELETE
+
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
+
+#include <assert.h>
+#include <stdlib.h>
+#include <cstdint>
+#include <iostream>
+
+// Most of the utilities needed for porting Google Mock are also
+// required for Google Test and are defined in gtest-port.h.
+//
+// Note to maintainers: to reduce code duplication, prefer adding
+// portability utilities to Google Test's gtest-port.h instead of
+// here, as Google Mock depends on Google Test.  Only add a utility
+// here if it's truly specific to Google Mock.
+
+#include "gtest/internal/gtest-port.h"
+#include "gmock/internal/custom/gmock-port.h"
+
+// For MS Visual C++, check the compiler version. At least VS 2015 is
+// required to compile Google Mock.
+#if defined(_MSC_VER) && _MSC_VER < 1900
+# error "At least Visual C++ 2015 (14.0) is required to compile Google Mock."
+#endif
+
+// Macro for referencing flags.  This is public as we want the user to
+// use this syntax to reference Google Mock flags.
+#define GMOCK_FLAG(name) FLAGS_gmock_##name
+
+#if !defined(GMOCK_DECLARE_bool_)
+
+// Macros for declaring flags.
+# define GMOCK_DECLARE_bool_(name) extern GTEST_API_ bool GMOCK_FLAG(name)
+# define GMOCK_DECLARE_int32_(name) extern GTEST_API_ int32_t GMOCK_FLAG(name)
+# define GMOCK_DECLARE_string_(name) \
+    extern GTEST_API_ ::std::string GMOCK_FLAG(name)
+
+// Macros for defining flags.
+# define GMOCK_DEFINE_bool_(name, default_val, doc) \
+    GTEST_API_ bool GMOCK_FLAG(name) = (default_val)
+# define GMOCK_DEFINE_int32_(name, default_val, doc) \
+    GTEST_API_ int32_t GMOCK_FLAG(name) = (default_val)
+# define GMOCK_DEFINE_string_(name, default_val, doc) \
+    GTEST_API_ ::std::string GMOCK_FLAG(name) = (default_val)
+
+#endif  // !defined(GMOCK_DECLARE_bool_)
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
diff --git a/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/gmock-pp.h b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/gmock-pp.h
new file mode 100644
index 000000000..94d61c09c
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/include/gmock/internal/gmock-pp.h
@@ -0,0 +1,279 @@
+#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_
+#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_
+
+// Expands and concatenates the arguments. Constructed macros reevaluate.
+#define GMOCK_PP_CAT(_1, _2) GMOCK_PP_INTERNAL_CAT(_1, _2)
+
+// Expands and stringifies the only argument.
+#define GMOCK_PP_STRINGIZE(...) GMOCK_PP_INTERNAL_STRINGIZE(__VA_ARGS__)
+
+// Returns empty. Given a variadic number of arguments.
+#define GMOCK_PP_EMPTY(...)
+
+// Returns a comma. Given a variadic number of arguments.
+#define GMOCK_PP_COMMA(...) ,
+
+// Returns the only argument.
+#define GMOCK_PP_IDENTITY(_1) _1
+
+// Evaluates to the number of arguments after expansion.
+//
+//   #define PAIR x, y
+//
+//   GMOCK_PP_NARG() => 1
+//   GMOCK_PP_NARG(x) => 1
+//   GMOCK_PP_NARG(x, y) => 2
+//   GMOCK_PP_NARG(PAIR) => 2
+//
+// Requires: the number of arguments after expansion is at most 15.
+#define GMOCK_PP_NARG(...) \
+  GMOCK_PP_INTERNAL_16TH(  \
+      (__VA_ARGS__, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0))
+
+// Returns 1 if the expansion of arguments has an unprotected comma. Otherwise
+// returns 0. Requires no more than 15 unprotected commas.
+#define GMOCK_PP_HAS_COMMA(...) \
+  GMOCK_PP_INTERNAL_16TH(       \
+      (__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0))
+
+// Returns the first argument.
+#define GMOCK_PP_HEAD(...) GMOCK_PP_INTERNAL_HEAD((__VA_ARGS__, unusedArg))
+
+// Returns the tail. A variadic list of all arguments minus the first. Requires
+// at least one argument.
+#define GMOCK_PP_TAIL(...) GMOCK_PP_INTERNAL_TAIL((__VA_ARGS__))
+
+// Calls CAT(_Macro, NARG(__VA_ARGS__))(__VA_ARGS__)
+#define GMOCK_PP_VARIADIC_CALL(_Macro, ...) \
+  GMOCK_PP_IDENTITY(                        \
+      GMOCK_PP_CAT(_Macro, GMOCK_PP_NARG(__VA_ARGS__))(__VA_ARGS__))
+
+// If the arguments after expansion have no tokens, evaluates to `1`. Otherwise
+// evaluates to `0`.
+//
+// Requires: * the number of arguments after expansion is at most 15.
+//           * If the argument is a macro, it must be able to be called with one
+//             argument.
+//
+// Implementation details:
+//
+// There is one case when it generates a compile error: if the argument is macro
+// that cannot be called with one argument.
+//
+//   #define M(a, b)  // it doesn't matter what it expands to
+//
+//   // Expected: expands to `0`.
+//   // Actual: compile error.
+//   GMOCK_PP_IS_EMPTY(M)
+//
+// There are 4 cases tested:
+//
+// * __VA_ARGS__ possible expansion has no unparen'd commas. Expected 0.
+// * __VA_ARGS__ possible expansion is not enclosed in parenthesis. Expected 0.
+// * __VA_ARGS__ possible expansion is not a macro that ()-evaluates to a comma.
+//   Expected 0
+// * __VA_ARGS__ is empty, or has unparen'd commas, or is enclosed in
+//   parenthesis, or is a macro that ()-evaluates to comma. Expected 1.
+//
+// We trigger detection on '0001', i.e. on empty.
+#define GMOCK_PP_IS_EMPTY(...)                                               \
+  GMOCK_PP_INTERNAL_IS_EMPTY(GMOCK_PP_HAS_COMMA(__VA_ARGS__),                \
+                             GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA __VA_ARGS__), \
+                             GMOCK_PP_HAS_COMMA(__VA_ARGS__()),              \
+                             GMOCK_PP_HAS_COMMA(GMOCK_PP_COMMA __VA_ARGS__()))
+
+// Evaluates to _Then if _Cond is 1 and _Else if _Cond is 0.
+#define GMOCK_PP_IF(_Cond, _Then, _Else) \
+  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IF_, _Cond)(_Then, _Else)
+
+// Similar to GMOCK_PP_IF but takes _Then and _Else in parentheses.
+//
+// GMOCK_PP_GENERIC_IF(1, (a, b, c), (d, e, f)) => a, b, c
+// GMOCK_PP_GENERIC_IF(0, (a, b, c), (d, e, f)) => d, e, f
+//
+#define GMOCK_PP_GENERIC_IF(_Cond, _Then, _Else) \
+  GMOCK_PP_REMOVE_PARENS(GMOCK_PP_IF(_Cond, _Then, _Else))
+
+// Evaluates to the number of arguments after expansion. Identifies 'empty' as
+// 0.
+//
+//   #define PAIR x, y
+//
+//   GMOCK_PP_NARG0() => 0
+//   GMOCK_PP_NARG0(x) => 1
+//   GMOCK_PP_NARG0(x, y) => 2
+//   GMOCK_PP_NARG0(PAIR) => 2
+//
+// Requires: * the number of arguments after expansion is at most 15.
+//           * If the argument is a macro, it must be able to be called with one
+//             argument.
+#define GMOCK_PP_NARG0(...) \
+  GMOCK_PP_IF(GMOCK_PP_IS_EMPTY(__VA_ARGS__), 0, GMOCK_PP_NARG(__VA_ARGS__))
+
+// Expands to 1 if the first argument starts with something in parentheses,
+// otherwise to 0.
+#define GMOCK_PP_IS_BEGIN_PARENS(...)                              \
+  GMOCK_PP_HEAD(GMOCK_PP_CAT(GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_, \
+                             GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C __VA_ARGS__))
+
+// Expands to 1 is there is only one argument and it is enclosed in parentheses.
+#define GMOCK_PP_IS_ENCLOSED_PARENS(...)             \
+  GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(__VA_ARGS__), \
+              GMOCK_PP_IS_EMPTY(GMOCK_PP_EMPTY __VA_ARGS__), 0)
+
+// Remove the parens, requires GMOCK_PP_IS_ENCLOSED_PARENS(args) => 1.
+#define GMOCK_PP_REMOVE_PARENS(...) GMOCK_PP_INTERNAL_REMOVE_PARENS __VA_ARGS__
+
+// Expands to _Macro(0, _Data, e1) _Macro(1, _Data, e2) ... _Macro(K -1, _Data,
+// eK) as many of GMOCK_INTERNAL_NARG0 _Tuple.
+// Requires: * |_Macro| can be called with 3 arguments.
+//           * |_Tuple| expansion has no more than 15 elements.
+#define GMOCK_PP_FOR_EACH(_Macro, _Data, _Tuple)                        \
+  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, GMOCK_PP_NARG0 _Tuple) \
+  (0, _Macro, _Data, _Tuple)
+
+// Expands to _Macro(0, _Data, ) _Macro(1, _Data, ) ... _Macro(K - 1, _Data, )
+// Empty if _K = 0.
+// Requires: * |_Macro| can be called with 3 arguments.
+//           * |_K| literal between 0 and 15
+#define GMOCK_PP_REPEAT(_Macro, _Data, _N)           \
+  GMOCK_PP_CAT(GMOCK_PP_INTERNAL_FOR_EACH_IMPL_, _N) \
+  (0, _Macro, _Data, GMOCK_PP_INTENRAL_EMPTY_TUPLE)
+
+// Increments the argument, requires the argument to be between 0 and 15.
+#define GMOCK_PP_INC(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_INC_, _i)
+
+// Returns comma if _i != 0. Requires _i to be between 0 and 15.
+#define GMOCK_PP_COMMA_IF(_i) GMOCK_PP_CAT(GMOCK_PP_INTERNAL_COMMA_IF_, _i)
+
+// Internal details follow. Do not use any of these symbols outside of this
+// file or we will break your code.
+#define GMOCK_PP_INTENRAL_EMPTY_TUPLE (, , , , , , , , , , , , , , , )
+#define GMOCK_PP_INTERNAL_CAT(_1, _2) _1##_2
+#define GMOCK_PP_INTERNAL_STRINGIZE(...) #__VA_ARGS__
+#define GMOCK_PP_INTERNAL_CAT_5(_1, _2, _3, _4, _5) _1##_2##_3##_4##_5
+#define GMOCK_PP_INTERNAL_IS_EMPTY(_1, _2, _3, _4)                             \
+  GMOCK_PP_HAS_COMMA(GMOCK_PP_INTERNAL_CAT_5(GMOCK_PP_INTERNAL_IS_EMPTY_CASE_, \
+                                             _1, _2, _3, _4))
+#define GMOCK_PP_INTERNAL_IS_EMPTY_CASE_0001 ,
+#define GMOCK_PP_INTERNAL_IF_1(_Then, _Else) _Then
+#define GMOCK_PP_INTERNAL_IF_0(_Then, _Else) _Else
+
+// Because of MSVC treating a token with a comma in it as a single token when
+// passed to another macro, we need to force it to evaluate it as multiple
+// tokens. We do that by using a "IDENTITY(MACRO PARENTHESIZED_ARGS)" macro. We
+// define one per possible macro that relies on this behavior. Note "_Args" must
+// be parenthesized.
+#define GMOCK_PP_INTERNAL_INTERNAL_16TH(_1, _2, _3, _4, _5, _6, _7, _8, _9, \
+                                        _10, _11, _12, _13, _14, _15, _16,  \
+                                        ...)                                \
+  _16
+#define GMOCK_PP_INTERNAL_16TH(_Args) \
+  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_16TH _Args)
+#define GMOCK_PP_INTERNAL_INTERNAL_HEAD(_1, ...) _1
+#define GMOCK_PP_INTERNAL_HEAD(_Args) \
+  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_HEAD _Args)
+#define GMOCK_PP_INTERNAL_INTERNAL_TAIL(_1, ...) __VA_ARGS__
+#define GMOCK_PP_INTERNAL_TAIL(_Args) \
+  GMOCK_PP_IDENTITY(GMOCK_PP_INTERNAL_INTERNAL_TAIL _Args)
+
+#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C(...) 1 _
+#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_1 1,
+#define GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_R_GMOCK_PP_INTERNAL_IBP_IS_VARIADIC_C \
+  0,
+#define GMOCK_PP_INTERNAL_REMOVE_PARENS(...) __VA_ARGS__
+#define GMOCK_PP_INTERNAL_INC_0 1
+#define GMOCK_PP_INTERNAL_INC_1 2
+#define GMOCK_PP_INTERNAL_INC_2 3
+#define GMOCK_PP_INTERNAL_INC_3 4
+#define GMOCK_PP_INTERNAL_INC_4 5
+#define GMOCK_PP_INTERNAL_INC_5 6
+#define GMOCK_PP_INTERNAL_INC_6 7
+#define GMOCK_PP_INTERNAL_INC_7 8
+#define GMOCK_PP_INTERNAL_INC_8 9
+#define GMOCK_PP_INTERNAL_INC_9 10
+#define GMOCK_PP_INTERNAL_INC_10 11
+#define GMOCK_PP_INTERNAL_INC_11 12
+#define GMOCK_PP_INTERNAL_INC_12 13
+#define GMOCK_PP_INTERNAL_INC_13 14
+#define GMOCK_PP_INTERNAL_INC_14 15
+#define GMOCK_PP_INTERNAL_INC_15 16
+#define GMOCK_PP_INTERNAL_COMMA_IF_0
+#define GMOCK_PP_INTERNAL_COMMA_IF_1 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_2 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_3 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_4 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_5 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_6 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_7 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_8 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_9 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_10 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_11 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_12 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_13 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_14 ,
+#define GMOCK_PP_INTERNAL_COMMA_IF_15 ,
+#define GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, _element) \
+  _Macro(_i, _Data, _element)
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_0(_i, _Macro, _Data, _Tuple)
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(_i, _Macro, _Data, _Tuple) \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple)
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_1(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_2(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_3(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_4(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_5(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_6(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_7(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(_i, _Macro, _Data, _Tuple)    \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_8(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(_i, _Macro, _Data, _Tuple)   \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_9(GMOCK_PP_INC(_i), _Macro, _Data,    \
+                                    (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(_i, _Macro, _Data, _Tuple)   \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_10(GMOCK_PP_INC(_i), _Macro, _Data,   \
+                                     (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(_i, _Macro, _Data, _Tuple)   \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_11(GMOCK_PP_INC(_i), _Macro, _Data,   \
+                                     (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(_i, _Macro, _Data, _Tuple)   \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_12(GMOCK_PP_INC(_i), _Macro, _Data,   \
+                                     (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(_i, _Macro, _Data, _Tuple)   \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_13(GMOCK_PP_INC(_i), _Macro, _Data,   \
+                                     (GMOCK_PP_TAIL _Tuple))
+#define GMOCK_PP_INTERNAL_FOR_EACH_IMPL_15(_i, _Macro, _Data, _Tuple)   \
+  GMOCK_PP_INTERNAL_CALL_MACRO(_Macro, _i, _Data, GMOCK_PP_HEAD _Tuple) \
+  GMOCK_PP_INTERNAL_FOR_EACH_IMPL_14(GMOCK_PP_INC(_i), _Macro, _Data,   \
+                                     (GMOCK_PP_TAIL _Tuple))
+
+#endif  // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PP_H_
diff --git a/trunk/3rdparty/gtest-fit/googlemock/src/gmock-all.cc b/trunk/3rdparty/gtest-fit/googlemock/src/gmock-all.cc
new file mode 100644
index 000000000..e43c9b7b4
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/src/gmock-all.cc
@@ -0,0 +1,46 @@
+// Copyright 2008, 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.
+
+//
+// Google C++ Mocking Framework (Google Mock)
+//
+// This file #includes all Google Mock implementation .cc files.  The
+// purpose is to allow a user to build Google Mock by compiling this
+// file alone.
+
+// This line ensures that gmock.h can be compiled on its own, even
+// when it's fused.
+#include "gmock/gmock.h"
+
+// The following lines pull in the real gmock *.cc files.
+#include "src/gmock-cardinalities.cc"
+#include "src/gmock-internal-utils.cc"
+#include "src/gmock-matchers.cc"
+#include "src/gmock-spec-builders.cc"
+#include "src/gmock.cc"
diff --git a/trunk/3rdparty/gtest-fit/googlemock/src/gmock-cardinalities.cc b/trunk/3rdparty/gtest-fit/googlemock/src/gmock-cardinalities.cc
new file mode 100644
index 000000000..7463f4383
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/src/gmock-cardinalities.cc
@@ -0,0 +1,155 @@
+// Copyright 2007, 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.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements cardinalities.
+
+#include "gmock/gmock-cardinalities.h"
+
+#include <limits.h>
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <string>
+#include "gmock/internal/gmock-internal-utils.h"
+#include "gtest/gtest.h"
+
+namespace testing {
+
+namespace {
+
+// Implements the Between(m, n) cardinality.
+class BetweenCardinalityImpl : public CardinalityInterface {
+ public:
+  BetweenCardinalityImpl(int min, int max)
+      : 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 << ".";
+      internal::Expect(false, __FILE__, __LINE__, ss.str());
+    } else if (max < 0) {
+      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
+         << ") must be >= the invocation lower bound (" << min
+         << ").";
+      internal::Expect(false, __FILE__, __LINE__, ss.str());
+    }
+  }
+
+  // Conservative estimate on the lower/upper bound of the number of
+  // calls allowed.
+  int ConservativeLowerBound() const override { return min_; }
+  int ConservativeUpperBound() const override { return max_; }
+
+  bool IsSatisfiedByCallCount(int call_count) const override {
+    return min_ <= call_count && call_count <= max_;
+  }
+
+  bool IsSaturatedByCallCount(int call_count) const override {
+    return call_count >= max_;
+  }
+
+  void DescribeTo(::std::ostream* os) const override;
+
+ private:
+  const int min_;
+  const int max_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(BetweenCardinalityImpl);
+};
+
+// Formats "n times" in a human-friendly way.
+inline std::string FormatTimes(int n) {
+  if (n == 1) {
+    return "once";
+  } else if (n == 2) {
+    return "twice";
+  } else {
+    std::stringstream ss;
+    ss << n << " times";
+    return ss.str();
+  }
+}
+
+// Describes the Between(m, n) cardinality in human-friendly text.
+void BetweenCardinalityImpl::DescribeTo(::std::ostream* os) const {
+  if (min_ == 0) {
+    if (max_ == 0) {
+      *os << "never called";
+    } else if (max_ == INT_MAX) {
+      *os << "called any number of times";
+    } else {
+      *os << "called at most " << FormatTimes(max_);
+    }
+  } else if (min_ == max_) {
+    *os << "called " << FormatTimes(min_);
+  } else if (max_ == INT_MAX) {
+    *os << "called at least " << FormatTimes(min_);
+  } else {
+    // 0 < min_ < max_ < INT_MAX
+    *os << "called between " << min_ << " and " << max_ << " times";
+  }
+}
+
+}  // Unnamed namespace
+
+// Describes the given call count to an ostream.
+void Cardinality::DescribeActualCallCountTo(int actual_call_count,
+                                            ::std::ostream* os) {
+  if (actual_call_count > 0) {
+    *os << "called " << FormatTimes(actual_call_count);
+  } else {
+    *os << "never called";
+  }
+}
+
+// Creates a cardinality that allows at least n calls.
+GTEST_API_ Cardinality AtLeast(int n) { return Between(n, INT_MAX); }
+
+// Creates a cardinality that allows at most n calls.
+GTEST_API_ Cardinality AtMost(int n) { return Between(0, n); }
+
+// Creates a cardinality that allows any number of calls.
+GTEST_API_ Cardinality AnyNumber() { return AtLeast(0); }
+
+// Creates a cardinality that allows between min and max calls.
+GTEST_API_ Cardinality Between(int min, int max) {
+  return Cardinality(new BetweenCardinalityImpl(min, max));
+}
+
+// Creates a cardinality that allows exactly n calls.
+GTEST_API_ Cardinality Exactly(int n) { return Between(n, n); }
+
+}  // namespace testing
diff --git a/trunk/3rdparty/gtest-fit/googlemock/src/gmock-internal-utils.cc b/trunk/3rdparty/gtest-fit/googlemock/src/gmock-internal-utils.cc
new file mode 100644
index 000000000..e5b547981
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/src/gmock-internal-utils.cc
@@ -0,0 +1,200 @@
+// Copyright 2007, 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.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file defines some utilities useful for implementing Google
+// Mock.  They are subject to change without notice, so please DO NOT
+// USE THEM IN USER CODE.
+
+#include "gmock/internal/gmock-internal-utils.h"
+
+#include <ctype.h>
+#include <ostream>  // NOLINT
+#include <string>
+#include "gmock/gmock.h"
+#include "gmock/internal/gmock-port.h"
+#include "gtest/gtest.h"
+
+namespace testing {
+namespace internal {
+
+// Joins a vector of strings as if they are fields of a tuple; returns
+// the joined string.
+GTEST_API_ std::string JoinAsTuple(const Strings& fields) {
+  switch (fields.size()) {
+    case 0:
+      return "";
+    case 1:
+      return fields[0];
+    default:
+      std::string result = "(" + fields[0];
+      for (size_t i = 1; i < fields.size(); i++) {
+        result += ", ";
+        result += fields[i];
+      }
+      result += ")";
+      return result;
+  }
+}
+
+// Converts an identifier name to a space-separated list of lower-case
+// words.  Each maximum substring of the form [A-Za-z][a-z]*|\d+ is
+// treated as one word.  For example, both "FooBar123" and
+// "foo_bar_123" are converted to "foo bar 123".
+GTEST_API_ std::string ConvertIdentifierNameToWords(const char* id_name) {
+  std::string result;
+  char prev_char = '\0';
+  for (const char* p = id_name; *p != '\0'; prev_char = *(p++)) {
+    // We don't care about the current locale as the input is
+    // guaranteed to be a valid C++ identifier name.
+    const bool starts_new_word = IsUpper(*p) ||
+        (!IsAlpha(prev_char) && IsLower(*p)) ||
+        (!IsDigit(prev_char) && IsDigit(*p));
+
+    if (IsAlNum(*p)) {
+      if (starts_new_word && result != "")
+        result += ' ';
+      result += ToLower(*p);
+    }
+  }
+  return result;
+}
+
+// This class reports Google Mock failures as Google Test failures.  A
+// user can define another class in a similar fashion if they intend to
+// use Google Mock with a testing framework other than Google Test.
+class GoogleTestFailureReporter : public FailureReporterInterface {
+ public:
+  void ReportFailure(FailureType type, const char* file, int line,
+                     const std::string& message) override {
+    AssertHelper(type == kFatal ?
+                 TestPartResult::kFatalFailure :
+                 TestPartResult::kNonFatalFailure,
+                 file,
+                 line,
+                 message.c_str()) = Message();
+    if (type == kFatal) {
+      posix::Abort();
+    }
+  }
+};
+
+// Returns the global failure reporter.  Will create a
+// GoogleTestFailureReporter and return it the first time called.
+GTEST_API_ FailureReporterInterface* GetFailureReporter() {
+  // Points to the global failure reporter used by Google Mock.  gcc
+  // guarantees that the following use of failure_reporter is
+  // thread-safe.  We may need to add additional synchronization to
+  // protect failure_reporter if we port Google Mock to other
+  // compilers.
+  static FailureReporterInterface* const failure_reporter =
+      new GoogleTestFailureReporter();
+  return failure_reporter;
+}
+
+// Protects global resources (stdout in particular) used by Log().
+static GTEST_DEFINE_STATIC_MUTEX_(g_log_mutex);
+
+// Returns true if and only if a log with the given severity is visible
+// according to the --gmock_verbose flag.
+GTEST_API_ bool LogIsVisible(LogSeverity severity) {
+  if (GMOCK_FLAG(verbose) == kInfoVerbosity) {
+    // Always show the log if --gmock_verbose=info.
+    return true;
+  } else if (GMOCK_FLAG(verbose) == kErrorVerbosity) {
+    // Always hide it if --gmock_verbose=error.
+    return false;
+  } else {
+    // If --gmock_verbose is neither "info" nor "error", we treat it
+    // as "warning" (its default value).
+    return severity == kWarning;
+  }
+}
+
+// Prints the given message to stdout if and only if 'severity' >= the level
+// specified by the --gmock_verbose flag.  If stack_frames_to_skip >=
+// 0, also prints the stack trace excluding the top
+// stack_frames_to_skip frames.  In opt mode, any positive
+// stack_frames_to_skip is treated as 0, since we don't know which
+// function calls will be inlined by the compiler and need to be
+// conservative.
+GTEST_API_ void Log(LogSeverity severity, const std::string& message,
+                    int stack_frames_to_skip) {
+  if (!LogIsVisible(severity))
+    return;
+
+  // Ensures that logs from different threads don't interleave.
+  MutexLock l(&g_log_mutex);
+
+  if (severity == kWarning) {
+    // Prints a GMOCK WARNING marker to make the warnings easily searchable.
+    std::cout << "\nGMOCK WARNING:";
+  }
+  // Pre-pends a new-line to message if it doesn't start with one.
+  if (message.empty() || message[0] != '\n') {
+    std::cout << "\n";
+  }
+  std::cout << message;
+  if (stack_frames_to_skip >= 0) {
+#ifdef NDEBUG
+    // In opt mode, we have to be conservative and skip no stack frame.
+    const int actual_to_skip = 0;
+#else
+    // In dbg mode, we can do what the caller tell us to do (plus one
+    // for skipping this function's stack frame).
+    const int actual_to_skip = stack_frames_to_skip + 1;
+#endif  // NDEBUG
+
+    // Appends a new-line to message if it doesn't end with one.
+    if (!message.empty() && *message.rbegin() != '\n') {
+      std::cout << "\n";
+    }
+    std::cout << "Stack trace:\n"
+         << ::testing::internal::GetCurrentOsStackTraceExceptTop(
+             ::testing::UnitTest::GetInstance(), actual_to_skip);
+  }
+  std::cout << ::std::flush;
+}
+
+GTEST_API_ WithoutMatchers GetWithoutMatchers() { return WithoutMatchers(); }
+
+GTEST_API_ void IllegalDoDefault(const char* file, int line) {
+  internal::Assert(
+      false, file, line,
+      "You are using DoDefault() inside a composite action like "
+      "DoAll() or WithArgs().  This is not supported for technical "
+      "reasons.  Please instead spell out the default action, or "
+      "assign the default action to an Action variable and use "
+      "the variable in various places.");
+}
+
+}  // namespace internal
+}  // namespace testing
diff --git a/trunk/3rdparty/gtest-fit/googlemock/src/gmock-matchers.cc b/trunk/3rdparty/gtest-fit/googlemock/src/gmock-matchers.cc
new file mode 100644
index 000000000..dded437ad
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/src/gmock-matchers.cc
@@ -0,0 +1,459 @@
+// Copyright 2007, 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.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements Matcher<const string&>, Matcher<string>, and
+// utilities for defining matchers.
+
+#include "gmock/gmock-matchers.h"
+
+#include <string.h>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+namespace testing {
+namespace internal {
+
+// Returns the description for a matcher defined using the MATCHER*()
+// macro where the user-supplied description string is "", if
+// 'negation' is false; otherwise returns the description of the
+// negation of the matcher.  'param_values' contains a list of strings
+// that are the print-out of the matcher's parameters.
+GTEST_API_ std::string FormatMatcherDescription(bool negation,
+                                                const char* matcher_name,
+                                                const Strings& param_values) {
+  std::string result = ConvertIdentifierNameToWords(matcher_name);
+  if (param_values.size() >= 1) result += " " + JoinAsTuple(param_values);
+  return negation ? "not (" + result + ")" : result;
+}
+
+// FindMaxBipartiteMatching and its helper class.
+//
+// Uses the well-known Ford-Fulkerson max flow method to find a maximum
+// bipartite matching. Flow is considered to be from left to right.
+// There is an implicit source node that is connected to all of the left
+// nodes, and an implicit sink node that is connected to all of the
+// right nodes. All edges have unit capacity.
+//
+// Neither the flow graph nor the residual flow graph are represented
+// explicitly. Instead, they are implied by the information in 'graph' and
+// a vector<int> called 'left_' whose elements are initialized to the
+// value kUnused. This represents the initial state of the algorithm,
+// where the flow graph is empty, and the residual flow graph has the
+// following edges:
+//   - An edge from source to each left_ node
+//   - An edge from each right_ node to sink
+//   - An edge from each left_ node to each right_ node, if the
+//     corresponding edge exists in 'graph'.
+//
+// When the TryAugment() method adds a flow, it sets left_[l] = r for some
+// nodes l and r. This induces the following changes:
+//   - The edges (source, l), (l, r), and (r, sink) are added to the
+//     flow graph.
+//   - The same three edges are removed from the residual flow graph.
+//   - The reverse edges (l, source), (r, l), and (sink, r) are added
+//     to the residual flow graph, which is a directional graph
+//     representing unused flow capacity.
+//
+// When the method augments a flow (moving left_[l] from some r1 to some
+// other r2), this can be thought of as "undoing" the above steps with
+// respect to r1 and "redoing" them with respect to r2.
+//
+// It bears repeating that the flow graph and residual flow graph are
+// never represented explicitly, but can be derived by looking at the
+// information in 'graph' and in left_.
+//
+// As an optimization, there is a second vector<int> called right_ which
+// does not provide any new information. Instead, it enables more
+// efficient queries about edges entering or leaving the right-side nodes
+// of the flow or residual flow graphs. The following invariants are
+// maintained:
+//
+// left[l] == kUnused or right[left[l]] == l
+// right[r] == kUnused or left[right[r]] == r
+//
+// . [ source ]                                        .
+// .   |||                                             .
+// .   |||                                             .
+// .   ||\--> left[0]=1  ---\    right[0]=-1 ----\     .
+// .   ||                   |                    |     .
+// .   |\---> left[1]=-1    \--> right[1]=0  ---\|     .
+// .   |                                        ||     .
+// .   \----> left[2]=2  ------> right[2]=2  --\||     .
+// .                                           |||     .
+// .         elements           matchers       vvv     .
+// .                                         [ sink ]  .
+//
+// See Also:
+//   [1] Cormen, et al (2001). "Section 26.2: The Ford-Fulkerson method".
+//       "Introduction to Algorithms (Second ed.)", pp. 651-664.
+//   [2] "Ford-Fulkerson algorithm", Wikipedia,
+//       'http://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm'
+class MaxBipartiteMatchState {
+ public:
+  explicit MaxBipartiteMatchState(const MatchMatrix& graph)
+      : graph_(&graph),
+        left_(graph_->LhsSize(), kUnused),
+        right_(graph_->RhsSize(), kUnused) {}
+
+  // Returns the edges of a maximal match, each in the form {left, right}.
+  ElementMatcherPairs Compute() {
+    // 'seen' is used for path finding { 0: unseen, 1: seen }.
+    ::std::vector<char> seen;
+    // Searches the residual flow graph for a path from each left node to
+    // the sink in the residual flow graph, and if one is found, add flow
+    // to the graph. It's okay to search through the left nodes once. The
+    // edge from the implicit source node to each previously-visited left
+    // node will have flow if that left node has any path to the sink
+    // whatsoever. Subsequent augmentations can only add flow to the
+    // network, and cannot take away that previous flow unit from the source.
+    // Since the source-to-left edge can only carry one flow unit (or,
+    // each element can be matched to only one matcher), there is no need
+    // to visit the left nodes more than once looking for augmented paths.
+    // The flow is known to be possible or impossible by looking at the
+    // node once.
+    for (size_t ilhs = 0; ilhs < graph_->LhsSize(); ++ilhs) {
+      // Reset the path-marking vector and try to find a path from
+      // source to sink starting at the left_[ilhs] node.
+      GTEST_CHECK_(left_[ilhs] == kUnused)
+          << "ilhs: " << ilhs << ", left_[ilhs]: " << left_[ilhs];
+      // 'seen' initialized to 'graph_->RhsSize()' copies of 0.
+      seen.assign(graph_->RhsSize(), 0);
+      TryAugment(ilhs, &seen);
+    }
+    ElementMatcherPairs result;
+    for (size_t ilhs = 0; ilhs < left_.size(); ++ilhs) {
+      size_t irhs = left_[ilhs];
+      if (irhs == kUnused) continue;
+      result.push_back(ElementMatcherPair(ilhs, irhs));
+    }
+    return result;
+  }
+
+ private:
+  static const size_t kUnused = static_cast<size_t>(-1);
+
+  // Perform a depth-first search from left node ilhs to the sink.  If a
+  // path is found, flow is added to the network by linking the left and
+  // right vector elements corresponding each segment of the path.
+  // Returns true if a path to sink was found, which means that a unit of
+  // flow was added to the network. The 'seen' vector elements correspond
+  // to right nodes and are marked to eliminate cycles from the search.
+  //
+  // Left nodes will only be explored at most once because they
+  // are accessible from at most one right node in the residual flow
+  // graph.
+  //
+  // Note that left_[ilhs] is the only element of left_ that TryAugment will
+  // potentially transition from kUnused to another value. Any other
+  // left_ element holding kUnused before TryAugment will be holding it
+  // when TryAugment returns.
+  //
+  bool TryAugment(size_t ilhs, ::std::vector<char>* seen) {
+    for (size_t irhs = 0; irhs < graph_->RhsSize(); ++irhs) {
+      if ((*seen)[irhs]) continue;
+      if (!graph_->HasEdge(ilhs, irhs)) continue;
+      // There's an available edge from ilhs to irhs.
+      (*seen)[irhs] = 1;
+      // Next a search is performed to determine whether
+      // this edge is a dead end or leads to the sink.
+      //
+      // right_[irhs] == kUnused means that there is residual flow from
+      // right node irhs to the sink, so we can use that to finish this
+      // flow path and return success.
+      //
+      // Otherwise there is residual flow to some ilhs. We push flow
+      // along that path and call ourselves recursively to see if this
+      // ultimately leads to sink.
+      if (right_[irhs] == kUnused || TryAugment(right_[irhs], seen)) {
+        // Add flow from left_[ilhs] to right_[irhs].
+        left_[ilhs] = irhs;
+        right_[irhs] = ilhs;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  const MatchMatrix* graph_;  // not owned
+  // Each element of the left_ vector represents a left hand side node
+  // (i.e. an element) and each element of right_ is a right hand side
+  // node (i.e. a matcher). The values in the left_ vector indicate
+  // outflow from that node to a node on the right_ side. The values
+  // in the right_ indicate inflow, and specify which left_ node is
+  // feeding that right_ node, if any. For example, left_[3] == 1 means
+  // there's a flow from element #3 to matcher #1. Such a flow would also
+  // be redundantly represented in the right_ vector as right_[1] == 3.
+  // Elements of left_ and right_ are either kUnused or mutually
+  // referent. Mutually referent means that left_[right_[i]] = i and
+  // right_[left_[i]] = i.
+  ::std::vector<size_t> left_;
+  ::std::vector<size_t> right_;
+};
+
+const size_t MaxBipartiteMatchState::kUnused;
+
+GTEST_API_ ElementMatcherPairs FindMaxBipartiteMatching(const MatchMatrix& g) {
+  return MaxBipartiteMatchState(g).Compute();
+}
+
+static void LogElementMatcherPairVec(const ElementMatcherPairs& pairs,
+                                     ::std::ostream* stream) {
+  typedef ElementMatcherPairs::const_iterator Iter;
+  ::std::ostream& os = *stream;
+  os << "{";
+  const char* sep = "";
+  for (Iter it = pairs.begin(); it != pairs.end(); ++it) {
+    os << sep << "\n  ("
+       << "element #" << it->first << ", "
+       << "matcher #" << it->second << ")";
+    sep = ",";
+  }
+  os << "\n}";
+}
+
+bool MatchMatrix::NextGraph() {
+  for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) {
+    for (size_t irhs = 0; irhs < RhsSize(); ++irhs) {
+      char& b = matched_[SpaceIndex(ilhs, irhs)];
+      if (!b) {
+        b = 1;
+        return true;
+      }
+      b = 0;
+    }
+  }
+  return false;
+}
+
+void MatchMatrix::Randomize() {
+  for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) {
+    for (size_t irhs = 0; irhs < RhsSize(); ++irhs) {
+      char& b = matched_[SpaceIndex(ilhs, irhs)];
+      b = static_cast<char>(rand() & 1);  // NOLINT
+    }
+  }
+}
+
+std::string MatchMatrix::DebugString() const {
+  ::std::stringstream ss;
+  const char* sep = "";
+  for (size_t i = 0; i < LhsSize(); ++i) {
+    ss << sep;
+    for (size_t j = 0; j < RhsSize(); ++j) {
+      ss << HasEdge(i, j);
+    }
+    sep = ";";
+  }
+  return ss.str();
+}
+
+void UnorderedElementsAreMatcherImplBase::DescribeToImpl(
+    ::std::ostream* os) const {
+  switch (match_flags()) {
+    case UnorderedMatcherRequire::ExactMatch:
+      if (matcher_describers_.empty()) {
+        *os << "is empty";
+        return;
+      }
+      if (matcher_describers_.size() == 1) {
+        *os << "has " << Elements(1) << " and that element ";
+        matcher_describers_[0]->DescribeTo(os);
+        return;
+      }
+      *os << "has " << Elements(matcher_describers_.size())
+          << " and there exists some permutation of elements such that:\n";
+      break;
+    case UnorderedMatcherRequire::Superset:
+      *os << "a surjection from elements to requirements exists such that:\n";
+      break;
+    case UnorderedMatcherRequire::Subset:
+      *os << "an injection from elements to requirements exists such that:\n";
+      break;
+  }
+
+  const char* sep = "";
+  for (size_t i = 0; i != matcher_describers_.size(); ++i) {
+    *os << sep;
+    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
+      *os << " - element #" << i << " ";
+    } else {
+      *os << " - an element ";
+    }
+    matcher_describers_[i]->DescribeTo(os);
+    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
+      sep = ", and\n";
+    } else {
+      sep = "\n";
+    }
+  }
+}
+
+void UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(
+    ::std::ostream* os) const {
+  switch (match_flags()) {
+    case UnorderedMatcherRequire::ExactMatch:
+      if (matcher_describers_.empty()) {
+        *os << "isn't empty";
+        return;
+      }
+      if (matcher_describers_.size() == 1) {
+        *os << "doesn't have " << Elements(1) << ", or has " << Elements(1)
+            << " that ";
+        matcher_describers_[0]->DescribeNegationTo(os);
+        return;
+      }
+      *os << "doesn't have " << Elements(matcher_describers_.size())
+          << ", or there exists no permutation of elements such that:\n";
+      break;
+    case UnorderedMatcherRequire::Superset:
+      *os << "no surjection from elements to requirements exists such that:\n";
+      break;
+    case UnorderedMatcherRequire::Subset:
+      *os << "no injection from elements to requirements exists such that:\n";
+      break;
+  }
+  const char* sep = "";
+  for (size_t i = 0; i != matcher_describers_.size(); ++i) {
+    *os << sep;
+    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
+      *os << " - element #" << i << " ";
+    } else {
+      *os << " - an element ";
+    }
+    matcher_describers_[i]->DescribeTo(os);
+    if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
+      sep = ", and\n";
+    } else {
+      sep = "\n";
+    }
+  }
+}
+
+// Checks that all matchers match at least one element, and that all
+// elements match at least one matcher. This enables faster matching
+// and better error reporting.
+// Returns false, writing an explanation to 'listener', if and only
+// if the success criteria are not met.
+bool UnorderedElementsAreMatcherImplBase::VerifyMatchMatrix(
+    const ::std::vector<std::string>& element_printouts,
+    const MatchMatrix& matrix, MatchResultListener* listener) const {
+  bool result = true;
+  ::std::vector<char> element_matched(matrix.LhsSize(), 0);
+  ::std::vector<char> matcher_matched(matrix.RhsSize(), 0);
+
+  for (size_t ilhs = 0; ilhs < matrix.LhsSize(); ilhs++) {
+    for (size_t irhs = 0; irhs < matrix.RhsSize(); irhs++) {
+      char matched = matrix.HasEdge(ilhs, irhs);
+      element_matched[ilhs] |= matched;
+      matcher_matched[irhs] |= matched;
+    }
+  }
+
+  if (match_flags() & UnorderedMatcherRequire::Superset) {
+    const char* sep =
+        "where the following matchers don't match any elements:\n";
+    for (size_t mi = 0; mi < matcher_matched.size(); ++mi) {
+      if (matcher_matched[mi]) continue;
+      result = false;
+      if (listener->IsInterested()) {
+        *listener << sep << "matcher #" << mi << ": ";
+        matcher_describers_[mi]->DescribeTo(listener->stream());
+        sep = ",\n";
+      }
+    }
+  }
+
+  if (match_flags() & UnorderedMatcherRequire::Subset) {
+    const char* sep =
+        "where the following elements don't match any matchers:\n";
+    const char* outer_sep = "";
+    if (!result) {
+      outer_sep = "\nand ";
+    }
+    for (size_t ei = 0; ei < element_matched.size(); ++ei) {
+      if (element_matched[ei]) continue;
+      result = false;
+      if (listener->IsInterested()) {
+        *listener << outer_sep << sep << "element #" << ei << ": "
+                  << element_printouts[ei];
+        sep = ",\n";
+        outer_sep = "";
+      }
+    }
+  }
+  return result;
+}
+
+bool UnorderedElementsAreMatcherImplBase::FindPairing(
+    const MatchMatrix& matrix, MatchResultListener* listener) const {
+  ElementMatcherPairs matches = FindMaxBipartiteMatching(matrix);
+
+  size_t max_flow = matches.size();
+  if ((match_flags() & UnorderedMatcherRequire::Superset) &&
+      max_flow < matrix.RhsSize()) {
+    if (listener->IsInterested()) {
+      *listener << "where no permutation of the elements can satisfy all "
+                   "matchers, and the closest match is "
+                << max_flow << " of " << matrix.RhsSize()
+                << " matchers with the pairings:\n";
+      LogElementMatcherPairVec(matches, listener->stream());
+    }
+    return false;
+  }
+  if ((match_flags() & UnorderedMatcherRequire::Subset) &&
+      max_flow < matrix.LhsSize()) {
+    if (listener->IsInterested()) {
+      *listener
+          << "where not all elements can be matched, and the closest match is "
+          << max_flow << " of " << matrix.RhsSize()
+          << " matchers with the pairings:\n";
+      LogElementMatcherPairVec(matches, listener->stream());
+    }
+    return false;
+  }
+
+  if (matches.size() > 1) {
+    if (listener->IsInterested()) {
+      const char* sep = "where:\n";
+      for (size_t mi = 0; mi < matches.size(); ++mi) {
+        *listener << sep << " - element #" << matches[mi].first
+                  << " is matched by matcher #" << matches[mi].second;
+        sep = ",\n";
+      }
+    }
+  }
+  return true;
+}
+
+}  // namespace internal
+}  // namespace testing
diff --git a/trunk/3rdparty/gtest-fit/googlemock/src/gmock-spec-builders.cc b/trunk/3rdparty/gtest-fit/googlemock/src/gmock-spec-builders.cc
new file mode 100644
index 000000000..c7266a370
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/src/gmock-spec-builders.cc
@@ -0,0 +1,908 @@
+// Copyright 2007, 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.
+
+
+// Google Mock - a framework for writing C++ mock classes.
+//
+// This file implements the spec builder syntax (ON_CALL and
+// EXPECT_CALL).
+
+#include "gmock/gmock-spec-builders.h"
+
+#include <stdlib.h>
+
+#include <iostream>  // NOLINT
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "gtest/internal/gtest-port.h"
+
+#if GTEST_OS_CYGWIN || GTEST_OS_LINUX || GTEST_OS_MAC
+# include <unistd.h>  // NOLINT
+#endif
+
+// Silence C4800 (C4800: 'int *const ': forcing value
+// to bool 'true' or 'false') for MSVC 15
+#ifdef _MSC_VER
+#if _MSC_VER == 1900
+#  pragma warning(push)
+#  pragma warning(disable:4800)
+#endif
+#endif
+
+namespace testing {
+namespace internal {
+
+// Protects the mock object registry (in class Mock), all function
+// mockers, and all expectations.
+GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_gmock_mutex);
+
+// Logs a message including file and line number information.
+GTEST_API_ void LogWithLocation(testing::internal::LogSeverity severity,
+                                const char* file, int line,
+                                const std::string& message) {
+  ::std::ostringstream s;
+  s << internal::FormatFileLocation(file, line) << " " << message
+    << ::std::endl;
+  Log(severity, s.str(), 0);
+}
+
+// Constructs an ExpectationBase object.
+ExpectationBase::ExpectationBase(const char* a_file, int a_line,
+                                 const std::string& a_source_text)
+    : file_(a_file),
+      line_(a_line),
+      source_text_(a_source_text),
+      cardinality_specified_(false),
+      cardinality_(Exactly(1)),
+      call_count_(0),
+      retired_(false),
+      extra_matcher_specified_(false),
+      repeated_action_specified_(false),
+      retires_on_saturation_(false),
+      last_clause_(kNone),
+      action_count_checked_(false) {}
+
+// Destructs an ExpectationBase object.
+ExpectationBase::~ExpectationBase() {}
+
+// Explicitly specifies the cardinality of this expectation.  Used by
+// the subclasses to implement the .Times() clause.
+void ExpectationBase::SpecifyCardinality(const Cardinality& a_cardinality) {
+  cardinality_specified_ = true;
+  cardinality_ = a_cardinality;
+}
+
+// Retires all pre-requisites of this expectation.
+void ExpectationBase::RetireAllPreRequisites()
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  if (is_retired()) {
+    // We can take this short-cut as we never retire an expectation
+    // until we have retired all its pre-requisites.
+    return;
+  }
+
+  ::std::vector<ExpectationBase*> expectations(1, this);
+  while (!expectations.empty()) {
+    ExpectationBase* exp = expectations.back();
+    expectations.pop_back();
+
+    for (ExpectationSet::const_iterator it =
+             exp->immediate_prerequisites_.begin();
+         it != exp->immediate_prerequisites_.end(); ++it) {
+      ExpectationBase* next = it->expectation_base().get();
+      if (!next->is_retired()) {
+        next->Retire();
+        expectations.push_back(next);
+      }
+    }
+  }
+}
+
+// Returns true if and only if all pre-requisites of this expectation
+// have been satisfied.
+bool ExpectationBase::AllPrerequisitesAreSatisfied() const
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  g_gmock_mutex.AssertHeld();
+  ::std::vector<const ExpectationBase*> expectations(1, this);
+  while (!expectations.empty()) {
+    const ExpectationBase* exp = expectations.back();
+    expectations.pop_back();
+
+    for (ExpectationSet::const_iterator it =
+             exp->immediate_prerequisites_.begin();
+         it != exp->immediate_prerequisites_.end(); ++it) {
+      const ExpectationBase* next = it->expectation_base().get();
+      if (!next->IsSatisfied()) return false;
+      expectations.push_back(next);
+    }
+  }
+  return true;
+}
+
+// Adds unsatisfied pre-requisites of this expectation to 'result'.
+void ExpectationBase::FindUnsatisfiedPrerequisites(ExpectationSet* result) const
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  g_gmock_mutex.AssertHeld();
+  ::std::vector<const ExpectationBase*> expectations(1, this);
+  while (!expectations.empty()) {
+    const ExpectationBase* exp = expectations.back();
+    expectations.pop_back();
+
+    for (ExpectationSet::const_iterator it =
+             exp->immediate_prerequisites_.begin();
+         it != exp->immediate_prerequisites_.end(); ++it) {
+      const ExpectationBase* next = it->expectation_base().get();
+
+      if (next->IsSatisfied()) {
+        // If *it is satisfied and has a call count of 0, some of its
+        // pre-requisites may not be satisfied yet.
+        if (next->call_count_ == 0) {
+          expectations.push_back(next);
+        }
+      } else {
+        // Now that we know next is unsatisfied, we are not so interested
+        // in whether its pre-requisites are satisfied.  Therefore we
+        // don't iterate into it here.
+        *result += *it;
+      }
+    }
+  }
+}
+
+// Describes how many times a function call matching this
+// expectation has occurred.
+void ExpectationBase::DescribeCallCountTo(::std::ostream* os) const
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  g_gmock_mutex.AssertHeld();
+
+  // Describes how many times the function is expected to be called.
+  *os << "         Expected: to be ";
+  cardinality().DescribeTo(os);
+  *os << "\n           Actual: ";
+  Cardinality::DescribeActualCallCountTo(call_count(), os);
+
+  // Describes the state of the expectation (e.g. is it satisfied?
+  // is it active?).
+  *os << " - " << (IsOverSaturated() ? "over-saturated" :
+                   IsSaturated() ? "saturated" :
+                   IsSatisfied() ? "satisfied" : "unsatisfied")
+      << " and "
+      << (is_retired() ? "retired" : "active");
+}
+
+// Checks the action count (i.e. the number of WillOnce() and
+// WillRepeatedly() clauses) against the cardinality if this hasn't
+// been done before.  Prints a warning if there are too many or too
+// few actions.
+void ExpectationBase::CheckActionCountIfNotDone() const
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  bool should_check = false;
+  {
+    MutexLock l(&mutex_);
+    if (!action_count_checked_) {
+      action_count_checked_ = true;
+      should_check = true;
+    }
+  }
+
+  if (should_check) {
+    if (!cardinality_specified_) {
+      // The cardinality was inferred - no need to check the action
+      // count against it.
+      return;
+    }
+
+    // The cardinality was explicitly specified.
+    const int action_count = static_cast<int>(untyped_actions_.size());
+    const int upper_bound = cardinality().ConservativeUpperBound();
+    const int lower_bound = cardinality().ConservativeLowerBound();
+    bool too_many;  // True if there are too many actions, or false
+    // if there are too few.
+    if (action_count > upper_bound ||
+        (action_count == upper_bound && repeated_action_specified_)) {
+      too_many = true;
+    } else if (0 < action_count && action_count < lower_bound &&
+               !repeated_action_specified_) {
+      too_many = false;
+    } else {
+      return;
+    }
+
+    ::std::stringstream ss;
+    DescribeLocationTo(&ss);
+    ss << "Too " << (too_many ? "many" : "few")
+       << " actions specified in " << source_text() << "...\n"
+       << "Expected to be ";
+    cardinality().DescribeTo(&ss);
+    ss << ", but has " << (too_many ? "" : "only ")
+       << action_count << " WillOnce()"
+       << (action_count == 1 ? "" : "s");
+    if (repeated_action_specified_) {
+      ss << " and a WillRepeatedly()";
+    }
+    ss << ".";
+    Log(kWarning, ss.str(), -1);  // -1 means "don't print stack trace".
+  }
+}
+
+// Implements the .Times() clause.
+void ExpectationBase::UntypedTimes(const Cardinality& a_cardinality) {
+  if (last_clause_ == kTimes) {
+    ExpectSpecProperty(false,
+                       ".Times() cannot appear "
+                       "more than once in an EXPECT_CALL().");
+  } else {
+    ExpectSpecProperty(last_clause_ < kTimes,
+                       ".Times() cannot appear after "
+                       ".InSequence(), .WillOnce(), .WillRepeatedly(), "
+                       "or .RetiresOnSaturation().");
+  }
+  last_clause_ = kTimes;
+
+  SpecifyCardinality(a_cardinality);
+}
+
+// Points to the implicit sequence introduced by a living InSequence
+// object (if any) in the current thread or NULL.
+GTEST_API_ ThreadLocal<Sequence*> g_gmock_implicit_sequence;
+
+// Reports an uninteresting call (whose description is in msg) in the
+// manner specified by 'reaction'.
+void ReportUninterestingCall(CallReaction reaction, const std::string& msg) {
+  // Include a stack trace only if --gmock_verbose=info is specified.
+  const int stack_frames_to_skip =
+      GMOCK_FLAG(verbose) == kInfoVerbosity ? 3 : -1;
+  switch (reaction) {
+    case kAllow:
+      Log(kInfo, msg, stack_frames_to_skip);
+      break;
+    case kWarn:
+      Log(kWarning,
+          msg +
+              "\nNOTE: You can safely ignore the above warning unless this "
+              "call should not happen.  Do not suppress it by blindly adding "
+              "an EXPECT_CALL() if you don't mean to enforce the call.  "
+              "See "
+              "https://github.com/google/googletest/blob/master/docs/"
+              "gmock_cook_book.md#"
+              "knowing-when-to-expect for details.\n",
+          stack_frames_to_skip);
+      break;
+    default:  // FAIL
+      Expect(false, nullptr, -1, msg);
+  }
+}
+
+UntypedFunctionMockerBase::UntypedFunctionMockerBase()
+    : mock_obj_(nullptr), name_("") {}
+
+UntypedFunctionMockerBase::~UntypedFunctionMockerBase() {}
+
+// Sets the mock object this mock method belongs to, and registers
+// this information in the global mock registry.  Will be called
+// whenever an EXPECT_CALL() or ON_CALL() is executed on this mock
+// method.
+void UntypedFunctionMockerBase::RegisterOwner(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  {
+    MutexLock l(&g_gmock_mutex);
+    mock_obj_ = mock_obj;
+  }
+  Mock::Register(mock_obj, this);
+}
+
+// Sets the mock object this mock method belongs to, and sets the name
+// of the mock function.  Will be called upon each invocation of this
+// mock function.
+void UntypedFunctionMockerBase::SetOwnerAndName(const void* mock_obj,
+                                                const char* name)
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  // We protect name_ under g_gmock_mutex in case this mock function
+  // is called from two threads concurrently.
+  MutexLock l(&g_gmock_mutex);
+  mock_obj_ = mock_obj;
+  name_ = name;
+}
+
+// Returns the name of the function being mocked.  Must be called
+// after RegisterOwner() or SetOwnerAndName() has been called.
+const void* UntypedFunctionMockerBase::MockObject() const
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  const void* mock_obj;
+  {
+    // We protect mock_obj_ under g_gmock_mutex in case this mock
+    // function is called from two threads concurrently.
+    MutexLock l(&g_gmock_mutex);
+    Assert(mock_obj_ != nullptr, __FILE__, __LINE__,
+           "MockObject() must not be called before RegisterOwner() or "
+           "SetOwnerAndName() has been called.");
+    mock_obj = mock_obj_;
+  }
+  return mock_obj;
+}
+
+// Returns the name of this mock method.  Must be called after
+// SetOwnerAndName() has been called.
+const char* UntypedFunctionMockerBase::Name() const
+    GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  const char* name;
+  {
+    // We protect name_ under g_gmock_mutex in case this mock
+    // function is called from two threads concurrently.
+    MutexLock l(&g_gmock_mutex);
+    Assert(name_ != nullptr, __FILE__, __LINE__,
+           "Name() must not be called before SetOwnerAndName() has "
+           "been called.");
+    name = name_;
+  }
+  return name;
+}
+
+// Calculates the result of invoking this mock function with the given
+// arguments, prints it, and returns it.  The caller is responsible
+// for deleting the result.
+UntypedActionResultHolderBase* UntypedFunctionMockerBase::UntypedInvokeWith(
+    void* const untyped_args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
+  // See the definition of untyped_expectations_ for why access to it
+  // is unprotected here.
+  if (untyped_expectations_.size() == 0) {
+    // No expectation is set on this mock method - we have an
+    // uninteresting call.
+
+    // We must get Google Mock's reaction on uninteresting calls
+    // made on this mock object BEFORE performing the action,
+    // because the action may DELETE the mock object and make the
+    // following expression meaningless.
+    const CallReaction reaction =
+        Mock::GetReactionOnUninterestingCalls(MockObject());
+
+    // True if and only if we need to print this call's arguments and return
+    // value.  This definition must be kept in sync with
+    // the behavior of ReportUninterestingCall().
+    const bool need_to_report_uninteresting_call =
+        // If the user allows this uninteresting call, we print it
+        // only when they want informational messages.
+        reaction == kAllow ? LogIsVisible(kInfo) :
+                           // If the user wants this to be a warning, we print
+                           // it only when they want to see warnings.
+            reaction == kWarn
+                ? LogIsVisible(kWarning)
+                :
+                // Otherwise, the user wants this to be an error, and we
+                // should always print detailed information in the error.
+                true;
+
+    if (!need_to_report_uninteresting_call) {
+      // Perform the action without printing the call information.
+      return this->UntypedPerformDefaultAction(
+          untyped_args, "Function call: " + std::string(Name()));
+    }
+
+    // Warns about the uninteresting call.
+    ::std::stringstream ss;
+    this->UntypedDescribeUninterestingCall(untyped_args, &ss);
+
+    // Calculates the function result.
+    UntypedActionResultHolderBase* const result =
+        this->UntypedPerformDefaultAction(untyped_args, ss.str());
+
+    // Prints the function result.
+    if (result != nullptr) result->PrintAsActionResult(&ss);
+
+    ReportUninterestingCall(reaction, ss.str());
+    return result;
+  }
+
+  bool is_excessive = false;
+  ::std::stringstream ss;
+  ::std::stringstream why;
+  ::std::stringstream loc;
+  const void* untyped_action = nullptr;
+
+  // The UntypedFindMatchingExpectation() function acquires and
+  // releases g_gmock_mutex.
+
+  const ExpectationBase* const untyped_expectation =
+      this->UntypedFindMatchingExpectation(untyped_args, &untyped_action,
+                                           &is_excessive, &ss, &why);
+  const bool found = untyped_expectation != nullptr;
+
+  // True if and only if we need to print the call's arguments
+  // and return value.
+  // This definition must be kept in sync with the uses of Expect()
+  // and Log() in this function.
+  const bool need_to_report_call =
+      !found || is_excessive || LogIsVisible(kInfo);
+  if (!need_to_report_call) {
+    // Perform the action without printing the call information.
+    return untyped_action == nullptr
+               ? this->UntypedPerformDefaultAction(untyped_args, "")
+               : this->UntypedPerformAction(untyped_action, untyped_args);
+  }
+
+  ss << "    Function call: " << Name();
+  this->UntypedPrintArgs(untyped_args, &ss);
+
+  // In case the action deletes a piece of the expectation, we
+  // generate the message beforehand.
+  if (found && !is_excessive) {
+    untyped_expectation->DescribeLocationTo(&loc);
+  }
+
+  UntypedActionResultHolderBase* result = nullptr;
+
+  auto perform_action = [&] {
+    return untyped_action == nullptr
+               ? this->UntypedPerformDefaultAction(untyped_args, ss.str())
+               : this->UntypedPerformAction(untyped_action, untyped_args);
+  };
+  auto handle_failures = [&] {
+    ss << "\n" << why.str();
+
+    if (!found) {
+      // No expectation matches this call - reports a failure.
+      Expect(false, nullptr, -1, ss.str());
+    } else if (is_excessive) {
+      // We had an upper-bound violation and the failure message is in ss.
+      Expect(false, untyped_expectation->file(), untyped_expectation->line(),
+             ss.str());
+    } else {
+      // We had an expected call and the matching expectation is
+      // described in ss.
+      Log(kInfo, loc.str() + ss.str(), 2);
+    }
+  };
+#if GTEST_HAS_EXCEPTIONS
+  try {
+    result = perform_action();
+  } catch (...) {
+    handle_failures();
+    throw;
+  }
+#else
+  result = perform_action();
+#endif
+
+  if (result != nullptr) result->PrintAsActionResult(&ss);
+  handle_failures();
+  return result;
+}
+
+// Returns an Expectation object that references and co-owns exp,
+// which must be an expectation on this mock function.
+Expectation UntypedFunctionMockerBase::GetHandleOf(ExpectationBase* exp) {
+  // See the definition of untyped_expectations_ for why access to it
+  // is unprotected here.
+  for (UntypedExpectations::const_iterator it =
+           untyped_expectations_.begin();
+       it != untyped_expectations_.end(); ++it) {
+    if (it->get() == exp) {
+      return Expectation(*it);
+    }
+  }
+
+  Assert(false, __FILE__, __LINE__, "Cannot find expectation.");
+  return Expectation();
+  // The above statement is just to make the code compile, and will
+  // never be executed.
+}
+
+// Verifies that all expectations on this mock function have been
+// satisfied.  Reports one or more Google Test non-fatal failures
+// and returns false if not.
+bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked()
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
+  g_gmock_mutex.AssertHeld();
+  bool expectations_met = true;
+  for (UntypedExpectations::const_iterator it =
+           untyped_expectations_.begin();
+       it != untyped_expectations_.end(); ++it) {
+    ExpectationBase* const untyped_expectation = it->get();
+    if (untyped_expectation->IsOverSaturated()) {
+      // There was an upper-bound violation.  Since the error was
+      // already reported when it occurred, there is no need to do
+      // anything here.
+      expectations_met = false;
+    } else if (!untyped_expectation->IsSatisfied()) {
+      expectations_met = false;
+      ::std::stringstream ss;
+      ss  << "Actual function call count doesn't match "
+          << untyped_expectation->source_text() << "...\n";
+      // No need to show the source file location of the expectation
+      // in the description, as the Expect() call that follows already
+      // takes care of it.
+      untyped_expectation->MaybeDescribeExtraMatcherTo(&ss);
+      untyped_expectation->DescribeCallCountTo(&ss);
+      Expect(false, untyped_expectation->file(),
+             untyped_expectation->line(), ss.str());
+    }
+  }
+
+  // Deleting our expectations may trigger other mock objects to be deleted, for
+  // example if an action contains a reference counted smart pointer to that
+  // mock object, and that is the last reference. So if we delete our
+  // expectations within the context of the global mutex we may deadlock when
+  // this method is called again. Instead, make a copy of the set of
+  // expectations to delete, clear our set within the mutex, and then clear the
+  // copied set outside of it.
+  UntypedExpectations expectations_to_delete;
+  untyped_expectations_.swap(expectations_to_delete);
+
+  g_gmock_mutex.Unlock();
+  expectations_to_delete.clear();
+  g_gmock_mutex.Lock();
+
+  return expectations_met;
+}
+
+CallReaction intToCallReaction(int mock_behavior) {
+  if (mock_behavior >= kAllow && mock_behavior <= kFail) {
+    return static_cast<internal::CallReaction>(mock_behavior);
+  }
+  return kWarn;
+}
+
+}  // namespace internal
+
+// Class Mock.
+
+namespace {
+
+typedef std::set<internal::UntypedFunctionMockerBase*> FunctionMockers;
+
+// The current state of a mock object.  Such information is needed for
+// detecting leaked mock objects and explicitly verifying a mock's
+// expectations.
+struct MockObjectState {
+  MockObjectState()
+      : first_used_file(nullptr), first_used_line(-1), leakable(false) {}
+
+  // Where in the source file an ON_CALL or EXPECT_CALL is first
+  // invoked on this mock object.
+  const char* first_used_file;
+  int first_used_line;
+  ::std::string first_used_test_suite;
+  ::std::string first_used_test;
+  bool leakable;  // true if and only if it's OK to leak the object.
+  FunctionMockers function_mockers;  // All registered methods of the object.
+};
+
+// A global registry holding the state of all mock objects that are
+// alive.  A mock object is added to this registry the first time
+// Mock::AllowLeak(), ON_CALL(), or EXPECT_CALL() is called on it.  It
+// is removed from the registry in the mock object's destructor.
+class MockObjectRegistry {
+ public:
+  // Maps a mock object (identified by its address) to its state.
+  typedef std::map<const void*, MockObjectState> StateMap;
+
+  // This destructor will be called when a program exits, after all
+  // tests in it have been run.  By then, there should be no mock
+  // object alive.  Therefore we report any living object as test
+  // failure, unless the user explicitly asked us to ignore it.
+  ~MockObjectRegistry() {
+    if (!GMOCK_FLAG(catch_leaked_mocks))
+      return;
+
+    int leaked_count = 0;
+    for (StateMap::const_iterator it = states_.begin(); it != states_.end();
+         ++it) {
+      if (it->second.leakable)  // The user said it's fine to leak this object.
+        continue;
+
+      // FIXME: Print the type of the leaked object.
+      // This can help the user identify the leaked object.
+      std::cout << "\n";
+      const MockObjectState& state = it->second;
+      std::cout << internal::FormatFileLocation(state.first_used_file,
+                                                state.first_used_line);
+      std::cout << " ERROR: this mock object";
+      if (state.first_used_test != "") {
+        std::cout << " (used in test " << state.first_used_test_suite << "."
+                  << state.first_used_test << ")";
+      }
+      std::cout << " should be deleted but never is. Its address is @"
+           << it->first << ".";
+      leaked_count++;
+    }
+    if (leaked_count > 0) {
+      std::cout << "\nERROR: " << leaked_count << " leaked mock "
+                << (leaked_count == 1 ? "object" : "objects")
+                << " found at program exit. Expectations on a mock object are "
+                   "verified when the object is destructed. Leaking a mock "
+                   "means that its expectations aren't verified, which is "
+                   "usually a test bug. If you really intend to leak a mock, "
+                   "you can suppress this error using "
+                   "testing::Mock::AllowLeak(mock_object), or you may use a "
+                   "fake or stub instead of a mock.\n";
+      std::cout.flush();
+      ::std::cerr.flush();
+      // RUN_ALL_TESTS() has already returned when this destructor is
+      // called.  Therefore we cannot use the normal Google Test
+      // failure reporting mechanism.
+      _exit(1);  // We cannot call exit() as it is not reentrant and
+                 // may already have been called.
+    }
+  }
+
+  StateMap& states() { return states_; }
+
+ private:
+  StateMap states_;
+};
+
+// Protected by g_gmock_mutex.
+MockObjectRegistry g_mock_object_registry;
+
+// Maps a mock object to the reaction Google Mock should have when an
+// uninteresting method is called.  Protected by g_gmock_mutex.
+std::map<const void*, internal::CallReaction> g_uninteresting_call_reaction;
+
+// Sets the reaction Google Mock should have when an uninteresting
+// method of the given mock object is called.
+void SetReactionOnUninterestingCalls(const void* mock_obj,
+                                     internal::CallReaction reaction)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  g_uninteresting_call_reaction[mock_obj] = reaction;
+}
+
+}  // namespace
+
+// Tells Google Mock to allow uninteresting calls on the given mock
+// object.
+void Mock::AllowUninterestingCalls(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  SetReactionOnUninterestingCalls(mock_obj, internal::kAllow);
+}
+
+// Tells Google Mock to warn the user about uninteresting calls on the
+// given mock object.
+void Mock::WarnUninterestingCalls(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  SetReactionOnUninterestingCalls(mock_obj, internal::kWarn);
+}
+
+// Tells Google Mock to fail uninteresting calls on the given mock
+// object.
+void Mock::FailUninterestingCalls(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  SetReactionOnUninterestingCalls(mock_obj, internal::kFail);
+}
+
+// Tells Google Mock the given mock object is being destroyed and its
+// entry in the call-reaction table should be removed.
+void Mock::UnregisterCallReaction(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  g_uninteresting_call_reaction.erase(mock_obj);
+}
+
+// Returns the reaction Google Mock will have on uninteresting calls
+// made on the given mock object.
+internal::CallReaction Mock::GetReactionOnUninterestingCalls(
+    const void* mock_obj)
+        GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  return (g_uninteresting_call_reaction.count(mock_obj) == 0) ?
+      internal::intToCallReaction(GMOCK_FLAG(default_mock_behavior)) :
+      g_uninteresting_call_reaction[mock_obj];
+}
+
+// Tells Google Mock to ignore mock_obj when checking for leaked mock
+// objects.
+void Mock::AllowLeak(const void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  g_mock_object_registry.states()[mock_obj].leakable = true;
+}
+
+// Verifies and clears all expectations on the given mock object.  If
+// the expectations aren't satisfied, generates one or more Google
+// Test non-fatal failures and returns false.
+bool Mock::VerifyAndClearExpectations(void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  return VerifyAndClearExpectationsLocked(mock_obj);
+}
+
+// Verifies all expectations on the given mock object and clears its
+// default actions and expectations.  Returns true if and only if the
+// verification was successful.
+bool Mock::VerifyAndClear(void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  ClearDefaultActionsLocked(mock_obj);
+  return VerifyAndClearExpectationsLocked(mock_obj);
+}
+
+// Verifies and clears all expectations on the given mock object.  If
+// the expectations aren't satisfied, generates one or more Google
+// Test non-fatal failures and returns false.
+bool Mock::VerifyAndClearExpectationsLocked(void* mock_obj)
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
+  internal::g_gmock_mutex.AssertHeld();
+  if (g_mock_object_registry.states().count(mock_obj) == 0) {
+    // No EXPECT_CALL() was set on the given mock object.
+    return true;
+  }
+
+  // Verifies and clears the expectations on each mock method in the
+  // given mock object.
+  bool expectations_met = true;
+  FunctionMockers& mockers =
+      g_mock_object_registry.states()[mock_obj].function_mockers;
+  for (FunctionMockers::const_iterator it = mockers.begin();
+       it != mockers.end(); ++it) {
+    if (!(*it)->VerifyAndClearExpectationsLocked()) {
+      expectations_met = false;
+    }
+  }
+
+  // We don't clear the content of mockers, as they may still be
+  // needed by ClearDefaultActionsLocked().
+  return expectations_met;
+}
+
+bool Mock::IsNaggy(void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kWarn;
+}
+bool Mock::IsNice(void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kAllow;
+}
+bool Mock::IsStrict(void* mock_obj)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  return Mock::GetReactionOnUninterestingCalls(mock_obj) == internal::kFail;
+}
+
+// Registers a mock object and a mock method it owns.
+void Mock::Register(const void* mock_obj,
+                    internal::UntypedFunctionMockerBase* mocker)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  g_mock_object_registry.states()[mock_obj].function_mockers.insert(mocker);
+}
+
+// Tells Google Mock where in the source code mock_obj is used in an
+// ON_CALL or EXPECT_CALL.  In case mock_obj is leaked, this
+// information helps the user identify which object it is.
+void Mock::RegisterUseByOnCallOrExpectCall(const void* mock_obj,
+                                           const char* file, int line)
+    GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
+  internal::MutexLock l(&internal::g_gmock_mutex);
+  MockObjectState& state = g_mock_object_registry.states()[mock_obj];
+  if (state.first_used_file == nullptr) {
+    state.first_used_file = file;
+    state.first_used_line = line;
+    const TestInfo* const test_info =
+        UnitTest::GetInstance()->current_test_info();
+    if (test_info != nullptr) {
+      state.first_used_test_suite = test_info->test_suite_name();
+      state.first_used_test = test_info->name();
+    }
+  }
+}
+
+// Unregisters a mock method; removes the owning mock object from the
+// registry when the last mock method associated with it has been
+// unregistered.  This is called only in the destructor of
+// FunctionMockerBase.
+void Mock::UnregisterLocked(internal::UntypedFunctionMockerBase* mocker)
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
+  internal::g_gmock_mutex.AssertHeld();
+  for (MockObjectRegistry::StateMap::iterator it =
+           g_mock_object_registry.states().begin();
+       it != g_mock_object_registry.states().end(); ++it) {
+    FunctionMockers& mockers = it->second.function_mockers;
+    if (mockers.erase(mocker) > 0) {
+      // mocker was in mockers and has been just removed.
+      if (mockers.empty()) {
+        g_mock_object_registry.states().erase(it);
+      }
+      return;
+    }
+  }
+}
+
+// Clears all ON_CALL()s set on the given mock object.
+void Mock::ClearDefaultActionsLocked(void* mock_obj)
+    GTEST_EXCLUSIVE_LOCK_REQUIRED_(internal::g_gmock_mutex) {
+  internal::g_gmock_mutex.AssertHeld();
+
+  if (g_mock_object_registry.states().count(mock_obj) == 0) {
+    // No ON_CALL() was set on the given mock object.
+    return;
+  }
+
+  // Clears the default actions for each mock method in the given mock
+  // object.
+  FunctionMockers& mockers =
+      g_mock_object_registry.states()[mock_obj].function_mockers;
+  for (FunctionMockers::const_iterator it = mockers.begin();
+       it != mockers.end(); ++it) {
+    (*it)->ClearDefaultActionsLocked();
+  }
+
+  // We don't clear the content of mockers, as they may still be
+  // needed by VerifyAndClearExpectationsLocked().
+}
+
+Expectation::Expectation() {}
+
+Expectation::Expectation(
+    const std::shared_ptr<internal::ExpectationBase>& an_expectation_base)
+    : expectation_base_(an_expectation_base) {}
+
+Expectation::~Expectation() {}
+
+// Adds an expectation to a sequence.
+void Sequence::AddExpectation(const Expectation& expectation) const {
+  if (*last_expectation_ != expectation) {
+    if (last_expectation_->expectation_base() != nullptr) {
+      expectation.expectation_base()->immediate_prerequisites_
+          += *last_expectation_;
+    }
+    *last_expectation_ = expectation;
+  }
+}
+
+// Creates the implicit sequence if there isn't one.
+InSequence::InSequence() {
+  if (internal::g_gmock_implicit_sequence.get() == nullptr) {
+    internal::g_gmock_implicit_sequence.set(new Sequence);
+    sequence_created_ = true;
+  } else {
+    sequence_created_ = false;
+  }
+}
+
+// Deletes the implicit sequence if it was created by the constructor
+// of this object.
+InSequence::~InSequence() {
+  if (sequence_created_) {
+    delete internal::g_gmock_implicit_sequence.get();
+    internal::g_gmock_implicit_sequence.set(nullptr);
+  }
+}
+
+}  // namespace testing
+
+#ifdef _MSC_VER
+#if _MSC_VER == 1900
+#  pragma warning(pop)
+#endif
+#endif
diff --git a/trunk/3rdparty/gtest-fit/googlemock/src/gmock.cc b/trunk/3rdparty/gtest-fit/googlemock/src/gmock.cc
new file mode 100644
index 000000000..7bcdb0ba2
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/src/gmock.cc
@@ -0,0 +1,213 @@
+// Copyright 2008, 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.
+
+
+#include "gmock/gmock.h"
+#include "gmock/internal/gmock-port.h"
+
+namespace testing {
+
+GMOCK_DEFINE_bool_(catch_leaked_mocks, true,
+                   "true if and only if Google Mock should report leaked "
+                   "mock objects as failures.");
+
+GMOCK_DEFINE_string_(verbose, internal::kWarningVerbosity,
+                     "Controls how verbose Google Mock's output is."
+                     "  Valid values:\n"
+                     "  info    - prints all messages.\n"
+                     "  warning - prints warnings and errors.\n"
+                     "  error   - prints errors only.");
+
+GMOCK_DEFINE_int32_(default_mock_behavior, 1,
+                    "Controls the default behavior of mocks."
+                    "  Valid values:\n"
+                    "  0 - by default, mocks act as NiceMocks.\n"
+                    "  1 - by default, mocks act as NaggyMocks.\n"
+                    "  2 - by default, mocks act as StrictMocks.");
+
+namespace internal {
+
+// Parses a string as a command line flag.  The string should have the
+// format "--gmock_flag=value".  When def_optional is true, the
+// "=value" part can be omitted.
+//
+// Returns the value of the flag, or NULL if the parsing failed.
+static const char* ParseGoogleMockFlagValue(const char* str,
+                                            const char* flag,
+                                            bool def_optional) {
+  // str and flag must not be NULL.
+  if (str == nullptr || flag == nullptr) return nullptr;
+
+  // The flag must start with "--gmock_".
+  const std::string flag_str = std::string("--gmock_") + flag;
+  const size_t flag_len = flag_str.length();
+  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
+
+  // Skips the flag name.
+  const char* flag_end = str + flag_len;
+
+  // When def_optional is true, it's OK to not have a "=value" part.
+  if (def_optional && (flag_end[0] == '\0')) {
+    return flag_end;
+  }
+
+  // If def_optional is true and there are more characters after the
+  // flag name, or if def_optional is false, there must be a '=' after
+  // the flag name.
+  if (flag_end[0] != '=') return nullptr;
+
+  // Returns the string after "=".
+  return flag_end + 1;
+}
+
+// Parses a string for a Google Mock bool flag, in the form of
+// "--gmock_flag=value".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+static bool ParseGoogleMockBoolFlag(const char* str, const char* flag,
+                                    bool* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);
+
+  // Aborts if the parsing failed.
+  if (value_str == nullptr) return false;
+
+  // Converts the string value to a bool.
+  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
+  return true;
+}
+
+// Parses a string for a Google Mock string flag, in the form of
+// "--gmock_flag=value".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+template <typename String>
+static bool ParseGoogleMockStringFlag(const char* str, const char* flag,
+                                      String* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseGoogleMockFlagValue(str, flag, false);
+
+  // Aborts if the parsing failed.
+  if (value_str == nullptr) return false;
+
+  // Sets *value to the value of the flag.
+  *value = value_str;
+  return true;
+}
+
+static bool ParseGoogleMockIntFlag(const char* str, const char* flag,
+                                   int32_t* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);
+
+  // Aborts if the parsing failed.
+  if (value_str == nullptr) return false;
+
+  // Sets *value to the value of the flag.
+  return ParseInt32(Message() << "The value of flag --" << flag,
+                    value_str, value);
+}
+
+// The internal implementation of InitGoogleMock().
+//
+// The type parameter CharType can be instantiated to either char or
+// wchar_t.
+template <typename CharType>
+void InitGoogleMockImpl(int* argc, CharType** argv) {
+  // Makes sure Google Test is initialized.  InitGoogleTest() is
+  // idempotent, so it's fine if the user has already called it.
+  InitGoogleTest(argc, argv);
+  if (*argc <= 0) return;
+
+  for (int i = 1; i != *argc; i++) {
+    const std::string arg_string = StreamableToString(argv[i]);
+    const char* const arg = arg_string.c_str();
+
+    // Do we see a Google Mock flag?
+    if (ParseGoogleMockBoolFlag(arg, "catch_leaked_mocks",
+                                &GMOCK_FLAG(catch_leaked_mocks)) ||
+        ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose)) ||
+        ParseGoogleMockIntFlag(arg, "default_mock_behavior",
+                               &GMOCK_FLAG(default_mock_behavior))) {
+      // Yes.  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];
+      }
+
+      // Decrements the argument count.
+      (*argc)--;
+
+      // We also need to decrement the iterator as we just removed
+      // an element.
+      i--;
+    }
+  }
+}
+
+}  // namespace internal
+
+// Initializes Google Mock.  This must be called before running the
+// tests.  In particular, it parses a command line for the flags that
+// Google Mock recognizes.  Whenever a Google Mock flag is seen, it is
+// removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Mock flag variables are
+// updated.
+//
+// Since Google Test is needed for Google Mock to work, this function
+// also initializes Google Test and parses its flags, if that hasn't
+// been done.
+GTEST_API_ void InitGoogleMock(int* argc, char** argv) {
+  internal::InitGoogleMockImpl(argc, argv);
+}
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+GTEST_API_ void InitGoogleMock(int* argc, wchar_t** argv) {
+  internal::InitGoogleMockImpl(argc, argv);
+}
+
+// This overloaded version can be used on Arduino/embedded platforms where
+// there is no argc/argv.
+GTEST_API_ void InitGoogleMock() {
+  // Since Arduino doesn't have a command line, fake out the argc/argv arguments
+  int argc = 1;
+  const auto arg0 = "dummy";
+  char* argv0 = const_cast<char*>(arg0);
+  char** argv = &argv0;
+
+  internal::InitGoogleMockImpl(&argc, argv);
+}
+
+}  // namespace testing
diff --git a/trunk/3rdparty/gtest-fit/googlemock/src/gmock_main.cc b/trunk/3rdparty/gtest-fit/googlemock/src/gmock_main.cc
new file mode 100644
index 000000000..18c500f66
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googlemock/src/gmock_main.cc
@@ -0,0 +1,72 @@
+// Copyright 2008, 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.
+
+
+#include <iostream>
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+#if GTEST_OS_ESP8266 || GTEST_OS_ESP32
+#if GTEST_OS_ESP8266
+extern "C" {
+#endif
+void setup() {
+  // Since Google Mock depends on Google Test, InitGoogleMock() is
+  // also responsible for initializing Google Test.  Therefore there's
+  // no need for calling testing::InitGoogleTest() separately.
+  testing::InitGoogleMock();
+}
+void loop() { RUN_ALL_TESTS(); }
+#if GTEST_OS_ESP8266
+}
+#endif
+
+#else
+
+// MS C++ compiler/linker has a bug on Windows (not on Windows CE), which
+// causes a link error when _tmain is defined in a static library and UNICODE
+// is enabled. For this reason instead of _tmain, main function is used on
+// Windows. See the following link to track the current status of this bug:
+// https://web.archive.org/web/20170912203238/connect.microsoft.com/VisualStudio/feedback/details/394464/wmain-link-error-in-the-static-library
+// // NOLINT
+#if GTEST_OS_WINDOWS_MOBILE
+# include <tchar.h>  // NOLINT
+
+GTEST_API_ int _tmain(int argc, TCHAR** argv) {
+#else
+GTEST_API_ int main(int argc, char** argv) {
+#endif  // GTEST_OS_WINDOWS_MOBILE
+  std::cout << "Running main() from gmock_main.cc\n";
+  // Since Google Mock depends on Google Test, InitGoogleMock() is
+  // also responsible for initializing Google Test.  Therefore there's
+  // no need for calling testing::InitGoogleTest() separately.
+  testing::InitGoogleMock(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+#endif
diff --git a/trunk/3rdparty/gtest-fit/googletest/CMakeLists.txt b/trunk/3rdparty/gtest-fit/googletest/CMakeLists.txt
new file mode 100644
index 000000000..abdd98b79
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/CMakeLists.txt
@@ -0,0 +1,323 @@
+########################################################################
+# Note: CMake support is community-based. The maintainers do not use CMake
+# internally.
+#
+# 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'.
+# For more options, run 'ctest --help'.
+
+# When other libraries are using a shared version of runtime libraries,
+# Google Test also has to use one.
+option(
+  gtest_force_shared_crt
+  "Use shared (DLL) run-time lib even when Google Test is built as static lib."
+  OFF)
+
+option(gtest_build_tests "Build all of gtest's own tests." OFF)
+
+option(gtest_build_samples "Build gtest's sample programs." OFF)
+
+option(gtest_disable_pthreads "Disable uses of pthreads in gtest." OFF)
+
+option(
+  gtest_hide_internal_symbols
+  "Build gtest with internal symbols hidden in shared libraries."
+  OFF)
+
+# Defines pre_project_set_up_hermetic_build() and set_up_hermetic_build().
+include(cmake/hermetic_build.cmake OPTIONAL)
+
+if (COMMAND pre_project_set_up_hermetic_build)
+  pre_project_set_up_hermetic_build()
+endif()
+
+########################################################################
+#
+# Project-wide settings
+
+# Name of the project.
+#
+# CMake files in this project can refer to the root source directory
+# as ${gtest_SOURCE_DIR} and to the root binary directory as
+# ${gtest_BINARY_DIR}.
+# Language "C" is required for find_package(Threads).
+
+# Project version:
+
+if (CMAKE_VERSION VERSION_LESS 3.0)
+  project(gtest CXX C)
+  set(PROJECT_VERSION ${GOOGLETEST_VERSION})
+else()
+  cmake_policy(SET CMP0048 NEW)
+  project(gtest VERSION ${GOOGLETEST_VERSION} LANGUAGES CXX C)
+endif()
+cmake_minimum_required(VERSION 2.8.12)
+
+if (POLICY CMP0063) # Visibility
+  cmake_policy(SET CMP0063 NEW)
+endif (POLICY CMP0063)
+
+if (COMMAND set_up_hermetic_build)
+  set_up_hermetic_build()
+endif()
+
+# These commands only run if this is the main project
+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
+  # make it prominent in the GUI.
+  option(BUILD_SHARED_LIBS "Build shared libraries (DLLs)." OFF)
+
+else()
+
+  mark_as_advanced(
+    gtest_force_shared_crt
+    gtest_build_tests
+    gtest_build_samples
+    gtest_disable_pthreads
+    gtest_hide_internal_symbols)
+
+endif()
+
+
+if (gtest_hide_internal_symbols)
+  set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+  set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
+endif()
+
+# Define helper functions and macros used by Google Test.
+include(cmake/internal_utils.cmake)
+
+config_compiler_and_linker()  # Defined in internal_utils.cmake.
+
+# Needed to set the namespace for both the export targets and the
+# alias libraries
+set(cmake_package_name GTest CACHE INTERNAL "")
+
+# Create the CMake package file descriptors.
+if (INSTALL_GTEST)
+  include(CMakePackageConfigHelpers)
+  set(targets_export_name ${cmake_package_name}Targets CACHE INTERNAL "")
+  set(generated_dir "${CMAKE_CURRENT_BINARY_DIR}/generated" CACHE INTERNAL "")
+  set(cmake_files_install_dir "${CMAKE_INSTALL_LIBDIR}/cmake/${cmake_package_name}")
+  set(version_file "${generated_dir}/${cmake_package_name}ConfigVersion.cmake")
+  write_basic_package_version_file(${version_file} VERSION ${GOOGLETEST_VERSION} COMPATIBILITY AnyNewerVersion)
+  install(EXPORT ${targets_export_name}
+    NAMESPACE ${cmake_package_name}::
+    DESTINATION ${cmake_files_install_dir})
+  set(config_file "${generated_dir}/${cmake_package_name}Config.cmake")
+  configure_package_config_file("${gtest_SOURCE_DIR}/cmake/Config.cmake.in"
+    "${config_file}" INSTALL_DESTINATION ${cmake_files_install_dir})
+  install(FILES ${version_file} ${config_file}
+    DESTINATION ${cmake_files_install_dir})
+endif()
+
+# Where Google Test's .h files can be found.
+set(gtest_build_include_dirs
+  "${gtest_SOURCE_DIR}/include"
+  "${gtest_SOURCE_DIR}")
+include_directories(${gtest_build_include_dirs})
+
+########################################################################
+#
+# 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
+# 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)
+set_target_properties(gtest PROPERTIES VERSION ${GOOGLETEST_VERSION})
+cxx_library(gtest_main "${cxx_strict}" src/gtest_main.cc)
+set_target_properties(gtest_main PROPERTIES VERSION ${GOOGLETEST_VERSION})
+# If the CMake version supports it, attach header directory information
+# to the targets for when we are part of a parent build (ie being pulled
+# in via add_subdirectory() rather than being a standalone build).
+if (DEFINED CMAKE_VERSION AND NOT "${CMAKE_VERSION}" VERSION_LESS "2.8.11")
+  target_include_directories(gtest SYSTEM INTERFACE
+    "$<BUILD_INTERFACE:${gtest_build_include_dirs}>"
+    "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>")
+  target_include_directories(gtest_main SYSTEM INTERFACE
+    "$<BUILD_INTERFACE:${gtest_build_include_dirs}>"
+    "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}>")
+endif()
+target_link_libraries(gtest_main PUBLIC gtest)
+
+########################################################################
+#
+# 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
+# or specifying the -Dgtest_build_samples=ON flag when running cmake.
+
+if (gtest_build_samples)
+  cxx_executable(sample1_unittest samples gtest_main samples/sample1.cc)
+  cxx_executable(sample2_unittest samples gtest_main samples/sample2.cc)
+  cxx_executable(sample3_unittest samples gtest_main)
+  cxx_executable(sample4_unittest samples gtest_main samples/sample4.cc)
+  cxx_executable(sample5_unittest samples gtest_main samples/sample1.cc)
+  cxx_executable(sample6_unittest samples gtest_main)
+  cxx_executable(sample7_unittest samples gtest_main)
+  cxx_executable(sample8_unittest samples gtest_main)
+  cxx_executable(sample9_unittest samples gtest)
+  cxx_executable(sample10_unittest samples gtest)
+endif()
+
+########################################################################
+#
+# Google Test's own tests.
+#
+# 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
+# or specifying the -Dgtest_build_tests=ON flag when running cmake.
+
+if (gtest_build_tests)
+  # This must be set in the root directory for the tests to be run by
+  # 'make test' or ctest.
+  enable_testing()
+
+  ############################################################
+  # C++ tests built with standard compiler flags.
+
+  cxx_test(googletest-death-test-test gtest_main)
+  cxx_test(gtest_environment_test gtest)
+  cxx_test(googletest-filepath-test gtest_main)
+  cxx_test(googletest-listener-test gtest_main)
+  cxx_test(gtest_main_unittest gtest_main)
+  cxx_test(googletest-message-test gtest_main)
+  cxx_test(gtest_no_test_unittest gtest)
+  cxx_test(googletest-options-test gtest_main)
+  cxx_test(googletest-param-test-test gtest
+    test/googletest-param-test2-test.cc)
+  cxx_test(googletest-port-test gtest_main)
+  cxx_test(gtest_pred_impl_unittest gtest_main)
+  cxx_test(gtest_premature_exit_test gtest
+    test/gtest_premature_exit_test.cc)
+  cxx_test(googletest-printers-test gtest_main)
+  cxx_test(gtest_prod_test gtest_main
+    test/production.cc)
+  cxx_test(gtest_repeat_test gtest)
+  cxx_test(gtest_sole_header_test gtest_main)
+  cxx_test(gtest_stress_test gtest)
+  cxx_test(googletest-test-part-test gtest_main)
+  cxx_test(gtest_throw_on_failure_ex_test gtest)
+  cxx_test(gtest-typed-test_test gtest_main
+    test/gtest-typed-test2_test.cc)
+  cxx_test(gtest_unittest gtest_main)
+  cxx_test(gtest-unittest-api_test gtest)
+  cxx_test(gtest_skip_in_environment_setup_test gtest_main)
+  cxx_test(gtest_skip_test gtest_main)
+
+  ############################################################
+  # C++ tests built with non-standard compiler flags.
+
+  # MSVC 7.1 does not support STL with exceptions disabled.
+  if (NOT MSVC OR MSVC_VERSION GREATER 1310)
+    cxx_library(gtest_no_exception "${cxx_no_exception}"
+      src/gtest-all.cc)
+    cxx_library(gtest_main_no_exception "${cxx_no_exception}"
+      src/gtest-all.cc src/gtest_main.cc)
+  endif()
+  cxx_library(gtest_main_no_rtti "${cxx_no_rtti}"
+    src/gtest-all.cc src/gtest_main.cc)
+
+  cxx_test_with_flags(gtest-death-test_ex_nocatch_test
+    "${cxx_exception} -DGTEST_ENABLE_CATCH_EXCEPTIONS_=0"
+    gtest test/googletest-death-test_ex_test.cc)
+  cxx_test_with_flags(gtest-death-test_ex_catch_test
+    "${cxx_exception} -DGTEST_ENABLE_CATCH_EXCEPTIONS_=1"
+    gtest test/googletest-death-test_ex_test.cc)
+
+  cxx_test_with_flags(gtest_no_rtti_unittest "${cxx_no_rtti}"
+    gtest_main_no_rtti test/gtest_unittest.cc)
+
+  cxx_shared_library(gtest_dll "${cxx_default}"
+    src/gtest-all.cc src/gtest_main.cc)
+
+  cxx_executable_with_flags(gtest_dll_test_ "${cxx_default}"
+    gtest_dll test/gtest_all_test.cc)
+  set_target_properties(gtest_dll_test_
+                        PROPERTIES
+                        COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
+
+  ############################################################
+  # Python tests.
+
+  cxx_executable(googletest-break-on-failure-unittest_ test gtest)
+  py_test(googletest-break-on-failure-unittest)
+
+  py_test(gtest_skip_check_output_test)
+  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
+    cxx_executable_with_flags(
+      googletest-catch-exceptions-no-ex-test_
+      "${cxx_no_exception}"
+      gtest_main_no_exception
+      test/googletest-catch-exceptions-test_.cc)
+  endif()
+
+  cxx_executable_with_flags(
+    googletest-catch-exceptions-ex-test_
+    "${cxx_exception}"
+    gtest_main
+    test/googletest-catch-exceptions-test_.cc)
+  py_test(googletest-catch-exceptions-test)
+
+  cxx_executable(googletest-color-test_ test gtest)
+  py_test(googletest-color-test)
+
+  cxx_executable(googletest-env-var-test_ test gtest)
+  py_test(googletest-env-var-test)
+
+  cxx_executable(googletest-filter-unittest_ test gtest)
+  py_test(googletest-filter-unittest)
+
+  cxx_executable(gtest_help_test_ test gtest_main)
+  py_test(gtest_help_test)
+
+  cxx_executable(googletest-list-tests-unittest_ test gtest)
+  py_test(googletest-list-tests-unittest)
+
+  cxx_executable(googletest-output-test_ test gtest)
+  py_test(googletest-output-test --no_stacktrace_support)
+
+  cxx_executable(googletest-shuffle-test_ test gtest)
+  py_test(googletest-shuffle-test)
+
+  # MSVC 7.1 does not support STL with exceptions disabled.
+  if (NOT MSVC OR MSVC_VERSION GREATER 1310)
+    cxx_executable(googletest-throw-on-failure-test_ test gtest_no_exception)
+    set_target_properties(googletest-throw-on-failure-test_
+      PROPERTIES
+      COMPILE_FLAGS "${cxx_no_exception}")
+    py_test(googletest-throw-on-failure-test)
+  endif()
+
+  cxx_executable(googletest-uninitialized-test_ test gtest)
+  py_test(googletest-uninitialized-test)
+
+  cxx_executable(gtest_list_output_unittest_ test gtest)
+  py_test(gtest_list_output_unittest)
+
+  cxx_executable(gtest_xml_outfile1_test_ test gtest_main)
+  cxx_executable(gtest_xml_outfile2_test_ test gtest_main)
+  py_test(gtest_xml_outfiles_test)
+  py_test(googletest-json-outfiles-test)
+
+  cxx_executable(gtest_xml_output_unittest_ test gtest)
+  py_test(gtest_xml_output_unittest --no_stacktrace_support)
+  py_test(googletest-json-output-unittest --no_stacktrace_support)
+endif()
diff --git a/trunk/3rdparty/gtest-fit/googletest/README.md b/trunk/3rdparty/gtest-fit/googletest/README.md
new file mode 100644
index 000000000..1f8b349ae
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/README.md
@@ -0,0 +1,215 @@
+### Generic Build Instructions
+
+#### Setup
+
+To build GoogleTest and your tests that use it, you need to tell your build
+system where to find its headers and source files. The exact way to do it
+depends on which build system you use, and is usually straightforward.
+
+### Build with CMake
+
+GoogleTest comes with a CMake build script
+([CMakeLists.txt](https://github.com/google/googletest/blob/master/CMakeLists.txt))
+that can be used on a wide range of platforms ("C" stands for cross-platform.).
+If you don't have CMake installed already, you can download it for free from
+<http://www.cmake.org/>.
+
+CMake works by generating native makefiles or build projects that can be used in
+the compiler environment of your choice. You can either build GoogleTest as a
+standalone project or it can be incorporated into an existing CMake build for
+another project.
+
+#### Standalone CMake Project
+
+When building GoogleTest as a standalone project, the typical workflow starts
+with
+
+```
+git clone https://github.com/google/googletest.git -b release-1.10.0
+cd googletest        # Main directory of the cloned repository.
+mkdir build          # Create a directory to hold the build output.
+cd build
+cmake ..             # Generate native build scripts for GoogleTest.
+```
+
+The above command also includes GoogleMock by default. And so, if you want to
+build only GoogleTest, you should replace the last command with
+
+```
+cmake .. -DBUILD_GMOCK=OFF
+```
+
+If you are on a \*nix system, you should now see a Makefile in the current
+directory. Just type `make` to build GoogleTest. And then you can simply install
+GoogleTest if you are a system administrator.
+
+```
+make
+sudo make install    # Install in /usr/local/ by default
+```
+
+If you use Windows and have Visual Studio installed, a `gtest.sln` file and
+several `.vcproj` files will be created. You can then build them using Visual
+Studio.
+
+On Mac OS X with Xcode installed, a `.xcodeproj` file will be generated.
+
+#### Incorporating Into An Existing CMake Project
+
+If you want to use GoogleTest in a project which already uses CMake, the easiest
+way is to get installed libraries and headers.
+
+*   Import GoogleTest by using `find_package` (or `pkg_check_modules`). For
+    example, if `find_package(GTest CONFIG REQUIRED)` succeeds, you can use the
+    libraries as `GTest::gtest`, `GTest::gmock`.
+
+And a more robust and flexible approach is to build GoogleTest as part of that
+project directly. This is done by making the GoogleTest source code available to
+the main build and adding it using CMake's `add_subdirectory()` command. This
+has the significant advantage that the same compiler and linker settings are
+used between GoogleTest and the rest of your project, so issues associated with
+using incompatible libraries (eg debug/release), etc. are avoided. This is
+particularly useful on Windows. Making GoogleTest's source code available to the
+main build can be done a few different ways:
+
+*   Download the GoogleTest source code manually and place it at a known
+    location. This is the least flexible approach and can make it more difficult
+    to use with continuous integration systems, etc.
+*   Embed the GoogleTest source code as a direct copy in the main project's
+    source tree. This is often the simplest approach, but is also the hardest to
+    keep up to date. Some organizations may not permit this method.
+*   Add GoogleTest as a git submodule or equivalent. This may not always be
+    possible or appropriate. Git submodules, for example, have their own set of
+    advantages and drawbacks.
+*   Use CMake to download GoogleTest as part of the build's configure step. This
+    approach doesn't have the limitations of the other methods.
+
+The last of the above methods is implemented with a small piece of CMake code
+that downloads and pulls the GoogleTest code into the main build.
+
+Just add to your `CMakeLists.txt`:
+
+```cmake
+include(FetchContent)
+FetchContent_Declare(
+  googletest
+  # Specify the commit you depend on and update it regularly.
+  URL https://github.com/google/googletest/archive/609281088cfefc76f9d0ce82e1ff6c30cc3591e5.zip
+)
+# For Windows: Prevent overriding the parent project's compiler/linker settings
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+FetchContent_MakeAvailable(googletest)
+
+# Now simply link against gtest or gtest_main as needed. Eg
+add_executable(example example.cpp)
+target_link_libraries(example gtest_main)
+add_test(NAME example_test COMMAND example)
+```
+
+Note that this approach requires CMake 3.14 or later due to its use of the
+`FetchContent_MakeAvailable()` command.
+
+##### Visual Studio Dynamic vs Static Runtimes
+
+By default, new Visual Studio projects link the C runtimes dynamically but
+GoogleTest links them statically. This will generate an error that looks
+something like the following: gtest.lib(gtest-all.obj) : error LNK2038: mismatch
+detected for 'RuntimeLibrary': value 'MTd_StaticDebug' doesn't match value
+'MDd_DynamicDebug' in main.obj
+
+GoogleTest already has a CMake option for this: `gtest_force_shared_crt`
+
+Enabling this option will make gtest link the runtimes dynamically too, and
+match the project in which it is included.
+
+#### C++ Standard Version
+
+An environment that supports C++11 is required in order to successfully build
+GoogleTest. One way to ensure this is to specify the standard in the top-level
+project, for example by using the `set(CMAKE_CXX_STANDARD 11)` command. If this
+is not feasible, for example in a C project using GoogleTest for validation,
+then it can be specified by adding it to the options for cmake via the
+`DCMAKE_CXX_FLAGS` option.
+
+### Tweaking GoogleTest
+
+GoogleTest can be used in diverse environments. The default configuration may
+not work (or may not work well) out of the box in some environments. However,
+you can easily tweak GoogleTest by defining control macros on the compiler
+command line. Generally, these macros are named like `GTEST_XYZ` and you define
+them to either 1 or 0 to enable or disable a certain feature.
+
+We list the most frequently used macros below. For a complete list, see file
+[include/gtest/internal/gtest-port.h](https://github.com/google/googletest/blob/master/googletest/include/gtest/internal/gtest-port.h).
+
+### Multi-threaded Tests
+
+GoogleTest is thread-safe where the pthread library is available. After
+`#include "gtest/gtest.h"`, you can check the
+`GTEST_IS_THREADSAFE` macro to see whether this is the case (yes if the macro is
+`#defined` to 1, no if it's undefined.).
+
+If GoogleTest doesn't correctly detect whether pthread is available in your
+environment, you can force it with
+
+    -DGTEST_HAS_PTHREAD=1
+
+or
+
+    -DGTEST_HAS_PTHREAD=0
+
+When GoogleTest uses pthread, you may need to add flags to your compiler and/or
+linker to select the pthread library, or you'll get link errors. If you use the
+CMake script, this is taken care of for you. If you use your own build script,
+you'll need to read your compiler and linker's manual to figure out what flags
+to add.
+
+### As a Shared Library (DLL)
+
+GoogleTest is compact, so most users can build and link it as a static library
+for the simplicity. You can choose to use GoogleTest as a shared library (known
+as a DLL on Windows) if you prefer.
+
+To compile *gtest* as a shared library, add
+
+    -DGTEST_CREATE_SHARED_LIBRARY=1
+
+to the compiler flags. You'll also need to tell the linker to produce a shared
+library instead - consult your linker's manual for how to do it.
+
+To compile your *tests* that use the gtest shared library, add
+
+    -DGTEST_LINKED_AS_SHARED_LIBRARY=1
+
+to the compiler flags.
+
+Note: while the above steps aren't technically necessary today when using some
+compilers (e.g. GCC), they may become necessary in the future, if we decide to
+improve the speed of loading the library (see
+<http://gcc.gnu.org/wiki/Visibility> for details). Therefore you are recommended
+to always add the above flags when using GoogleTest as a shared library.
+Otherwise a future release of GoogleTest may break your build script.
+
+### Avoiding Macro Name Clashes
+
+In C++, macros don't obey namespaces. Therefore two libraries that both define a
+macro of the same name will clash if you `#include` both definitions. In case a
+GoogleTest macro clashes with another library, you can force GoogleTest to
+rename its macro to avoid the conflict.
+
+Specifically, if both GoogleTest and some other code define macro FOO, you can
+add
+
+    -DGTEST_DONT_DEFINE_FOO=1
+
+to the compiler flags to tell GoogleTest to change the macro's name from `FOO`
+to `GTEST_FOO`. Currently `FOO` can be `FAIL`, `SUCCEED`, or `TEST`. For
+example, with `-DGTEST_DONT_DEFINE_TEST=1`, you'll need to write
+
+    GTEST_TEST(SomeTest, DoesThis) { ... }
+
+instead of
+
+    TEST(SomeTest, DoesThis) { ... }
+
+in order to define a test.
diff --git a/trunk/3rdparty/gtest-fit/googletest/cmake/Config.cmake.in b/trunk/3rdparty/gtest-fit/googletest/cmake/Config.cmake.in
new file mode 100644
index 000000000..12be4498b
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/cmake/Config.cmake.in
@@ -0,0 +1,9 @@
+@PACKAGE_INIT@
+include(CMakeFindDependencyMacro)
+if (@GTEST_HAS_PTHREAD@)
+  set(THREADS_PREFER_PTHREAD_FLAG @THREADS_PREFER_PTHREAD_FLAG@)
+  find_dependency(Threads)
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake")
+check_required_components("@project_name@")
diff --git a/trunk/3rdparty/gtest-fit/googletest/cmake/gtest.pc.in b/trunk/3rdparty/gtest-fit/googletest/cmake/gtest.pc.in
new file mode 100644
index 000000000..b4148fae4
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/cmake/gtest.pc.in
@@ -0,0 +1,9 @@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+
+Name: gtest
+Description: GoogleTest (without main() function)
+Version: @PROJECT_VERSION@
+URL: https://github.com/google/googletest
+Libs: -L${libdir} -lgtest @CMAKE_THREAD_LIBS_INIT@
+Cflags: -I${includedir} @GTEST_HAS_PTHREAD_MACRO@
diff --git a/trunk/3rdparty/gtest-fit/googletest/cmake/gtest_main.pc.in b/trunk/3rdparty/gtest-fit/googletest/cmake/gtest_main.pc.in
new file mode 100644
index 000000000..38c88c54d
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/cmake/gtest_main.pc.in
@@ -0,0 +1,10 @@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+
+Name: gtest_main
+Description: GoogleTest (with main() function)
+Version: @PROJECT_VERSION@
+URL: https://github.com/google/googletest
+Requires: gtest = @PROJECT_VERSION@
+Libs: -L${libdir} -lgtest_main @CMAKE_THREAD_LIBS_INIT@
+Cflags: -I${includedir} @GTEST_HAS_PTHREAD_MACRO@
diff --git a/trunk/3rdparty/gtest-fit/googletest/cmake/internal_utils.cmake b/trunk/3rdparty/gtest-fit/googletest/cmake/internal_utils.cmake
new file mode 100644
index 000000000..8d8d60a86
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/cmake/internal_utils.cmake
@@ -0,0 +1,344 @@
+# Defines functions and macros useful for building Google Test and
+# Google Mock.
+#
+# Note:
+#
+# - This file will be run twice when building Google Mock (once via
+#   Google Test's CMakeLists.txt, and once via Google Mock's).
+#   Therefore it shouldn't have any side effects other than defining
+#   the functions and macros.
+#
+# - The functions/macros defined in this file may depend on Google
+#   Test and Google Mock's option() definitions, and thus must be
+#   called *after* the options have been defined.
+
+if (POLICY CMP0054)
+  cmake_policy(SET CMP0054 NEW)
+endif (POLICY CMP0054)
+
+# Tweaks CMake's default compiler/linker settings to suit Google Test's needs.
+#
+# This must be a macro(), as inside a function string() can only
+# update variables in the function scope.
+macro(fix_default_compiler_settings_)
+  if (MSVC)
+    # For MSVC, CMake sets certain flags to defaults we want to override.
+    # This replacement code is taken from sample in the CMake Wiki at
+    # https://gitlab.kitware.com/cmake/community/wikis/FAQ#dynamic-replace.
+    foreach (flag_var
+             CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE
+             CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO
+             CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+             CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+      if (NOT BUILD_SHARED_LIBS AND NOT gtest_force_shared_crt)
+        # When Google Test is built as a shared library, it should also use
+        # shared runtime libraries.  Otherwise, it may end up with multiple
+        # copies of runtime library data in different modules, resulting in
+        # hard-to-find crashes. When it is built as a static library, it is
+        # preferable to use CRT as static libraries, as we don't have to rely
+        # on CRT DLLs being available. CMake always defaults to using shared
+        # CRT libraries, so we override that default here.
+        string(REPLACE "/MD" "-MT" ${flag_var} "${${flag_var}}")
+      endif()
+
+      # We prefer more strict warning checking for building Google Test.
+      # Replaces /W3 with /W4 in defaults.
+      string(REPLACE "/W3" "/W4" ${flag_var} "${${flag_var}}")
+
+      # Prevent D9025 warning for targets that have exception handling
+      # turned off (/EHs-c- flag). Where required, exceptions are explicitly
+      # re-enabled using the cxx_exception_flags variable.
+      string(REPLACE "/EHsc" "" ${flag_var} "${${flag_var}}")
+    endforeach()
+  endif()
+endmacro()
+
+# Defines the compiler/linker flags used to build Google Test and
+# 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
+  unset(GTEST_HAS_PTHREAD)
+  if (NOT gtest_disable_pthreads AND NOT MINGW)
+    # Defines CMAKE_USE_PTHREADS_INIT and CMAKE_THREAD_LIBS_INIT.
+    find_package(Threads)
+    if (CMAKE_USE_PTHREADS_INIT)
+      set(GTEST_HAS_PTHREAD ON)
+    endif()
+  endif()
+
+  fix_default_compiler_settings_()
+  if (MSVC)
+    # Newlines inside flags variables break CMake's NMake generator.
+    # TODO(vladl@google.com): Add -RTCs and -RTCu to debug builds.
+    set(cxx_base_flags "-GS -W4 -WX -wd4251 -wd4275 -nologo -J")
+    set(cxx_base_flags "${cxx_base_flags} -D_UNICODE -DUNICODE -DWIN32 -D_WIN32")
+    set(cxx_base_flags "${cxx_base_flags} -DSTRICT -DWIN32_LEAN_AND_MEAN")
+    set(cxx_exception_flags "-EHsc -D_HAS_EXCEPTIONS=1")
+    set(cxx_no_exception_flags "-EHs-c- -D_HAS_EXCEPTIONS=0")
+    set(cxx_no_rtti_flags "-GR-")
+    # Suppress "unreachable code" warning
+    # http://stackoverflow.com/questions/3232669 explains the issue.
+    set(cxx_base_flags "${cxx_base_flags} -wd4702")
+    # Ensure MSVC treats source files as UTF-8 encoded.
+    set(cxx_base_flags "${cxx_base_flags} -utf-8")
+  elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    set(cxx_base_flags "-Wall -Wshadow -Werror -Wconversion")
+    set(cxx_exception_flags "-fexceptions")
+    set(cxx_no_exception_flags "-fno-exceptions")
+    set(cxx_strict_flags "-W -Wpointer-arith -Wreturn-type -Wcast-qual -Wwrite-strings -Wswitch -Wunused-parameter -Wcast-align -Wchar-subscripts -Winline -Wredundant-decls")
+    set(cxx_no_rtti_flags "-fno-rtti")
+  elseif (CMAKE_COMPILER_IS_GNUCXX)
+    set(cxx_base_flags "-Wall -Wshadow -Werror")
+    if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0.0)
+      set(cxx_base_flags "${cxx_base_flags} -Wno-error=dangling-else")
+    endif()
+    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
+    # explicitly.
+    set(cxx_no_rtti_flags "-fno-rtti -DGTEST_HAS_RTTI=0")
+    set(cxx_strict_flags
+      "-Wextra -Wno-unused-parameter -Wno-missing-field-initializers")
+  elseif (CMAKE_CXX_COMPILER_ID STREQUAL "SunPro")
+    set(cxx_exception_flags "-features=except")
+    # Sun Pro doesn't provide macros to indicate whether exceptions and
+    # RTTI are enabled, so we define GTEST_HAS_* explicitly.
+    set(cxx_no_exception_flags "-features=no%except -DGTEST_HAS_EXCEPTIONS=0")
+    set(cxx_no_rtti_flags "-features=no%rtti -DGTEST_HAS_RTTI=0")
+  elseif (CMAKE_CXX_COMPILER_ID STREQUAL "VisualAge" OR
+      CMAKE_CXX_COMPILER_ID STREQUAL "XL")
+    # CMake 2.8 changes Visual Age's compiler ID to "XL".
+    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
+    # explicitly.
+    set(cxx_no_rtti_flags "-qnortti -DGTEST_HAS_RTTI=0")
+  elseif (CMAKE_CXX_COMPILER_ID STREQUAL "HP")
+    set(cxx_base_flags "-AA -mt")
+    set(cxx_exception_flags "-DGTEST_HAS_EXCEPTIONS=1")
+    set(cxx_no_exception_flags "+noeh -DGTEST_HAS_EXCEPTIONS=0")
+    # RTTI can not be disabled in HP aCC compiler.
+    set(cxx_no_rtti_flags "")
+  endif()
+
+  # The pthreads library is available and allowed?
+  if (DEFINED GTEST_HAS_PTHREAD)
+    set(GTEST_HAS_PTHREAD_MACRO "-DGTEST_HAS_PTHREAD=1")
+  else()
+    set(GTEST_HAS_PTHREAD_MACRO "-DGTEST_HAS_PTHREAD=0")
+  endif()
+  set(cxx_base_flags "${cxx_base_flags} ${GTEST_HAS_PTHREAD_MACRO}")
+
+  # For building gtest's own tests and samples.
+  set(cxx_exception "${cxx_base_flags} ${cxx_exception_flags}")
+  set(cxx_no_exception
+    "${CMAKE_CXX_FLAGS} ${cxx_base_flags} ${cxx_no_exception_flags}")
+  set(cxx_default "${cxx_exception}")
+  set(cxx_no_rtti "${cxx_default} ${cxx_no_rtti_flags}")
+
+  # For building the gtest libraries.
+  set(cxx_strict "${cxx_default} ${cxx_strict_flags}")
+endmacro()
+
+# 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.
+  # ARGN refers to additional arguments after 'cxx_flags'.
+  add_library(${name} ${type} ${ARGN})
+  add_library(${cmake_package_name}::${name} ALIAS ${name})
+  set_target_properties(${name}
+    PROPERTIES
+    COMPILE_FLAGS "${cxx_flags}")
+  # Generate debug library name with a postfix.
+  set_target_properties(${name}
+    PROPERTIES
+    DEBUG_POSTFIX "d")
+  # Set the output directory for build artifacts
+  set_target_properties(${name}
+    PROPERTIES
+    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin"
+    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib"
+    ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib"
+    PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
+  # make PDBs match library name
+  get_target_property(pdb_debug_postfix ${name} DEBUG_POSTFIX)
+  set_target_properties(${name}
+    PROPERTIES
+    PDB_NAME "${name}"
+    PDB_NAME_DEBUG "${name}${pdb_debug_postfix}"
+    COMPILE_PDB_NAME "${name}"
+    COMPILE_PDB_NAME_DEBUG "${name}${pdb_debug_postfix}")
+
+  if (BUILD_SHARED_LIBS OR type STREQUAL "SHARED")
+    set_target_properties(${name}
+      PROPERTIES
+      COMPILE_DEFINITIONS "GTEST_CREATE_SHARED_LIBRARY=1")
+    if (NOT "${CMAKE_VERSION}" VERSION_LESS "2.8.11")
+      target_compile_definitions(${name} INTERFACE
+        $<INSTALL_INTERFACE:GTEST_LINKED_AS_SHARED_LIBRARY=1>)
+    endif()
+  endif()
+  if (DEFINED GTEST_HAS_PTHREAD)
+    if ("${CMAKE_VERSION}" VERSION_LESS "3.1.0")
+      set(threads_spec ${CMAKE_THREAD_LIBS_INIT})
+    else()
+      set(threads_spec Threads::Threads)
+    endif()
+    target_link_libraries(${name} PUBLIC ${threads_spec})
+  endif()
+
+  if (NOT "${CMAKE_VERSION}" VERSION_LESS "3.8")
+    target_compile_features(${name} PUBLIC cxx_std_11)
+  endif()
+endfunction()
+
+########################################################################
+#
+# Helper functions for creating build targets.
+
+function(cxx_shared_library name cxx_flags)
+  cxx_library_with_type(${name} SHARED "${cxx_flags}" ${ARGN})
+endfunction()
+
+function(cxx_library name cxx_flags)
+  cxx_library_with_type(${name} "" "${cxx_flags}" ${ARGN})
+endfunction()
+
+# cxx_executable_with_flags(name cxx_flags libs srcs...)
+#
+# 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})
+  if (MSVC)
+    # BigObj required for tests.
+    set(cxx_flags "${cxx_flags} -bigobj")
+  endif()
+  if (cxx_flags)
+    set_target_properties(${name}
+      PROPERTIES
+      COMPILE_FLAGS "${cxx_flags}")
+  endif()
+  if (BUILD_SHARED_LIBS)
+    set_target_properties(${name}
+      PROPERTIES
+      COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1")
+  endif()
+  # To support mixing linking in static and dynamic libraries, link each
+  # library in with an extra call to target_link_libraries.
+  foreach (lib "${libs}")
+    target_link_libraries(${name} ${lib})
+  endforeach()
+endfunction()
+
+# cxx_executable(name dir lib srcs...)
+#
+# creates a named target that depends on the given libs and is built
+# from the given source files.  dir/name.cc is implicitly included in
+# the source file list.
+function(cxx_executable name dir libs)
+  cxx_executable_with_flags(
+    ${name} "${cxx_default}" "${libs}" "${dir}/${name}.cc" ${ARGN})
+endfunction()
+
+# Sets PYTHONINTERP_FOUND and PYTHON_EXECUTABLE.
+if ("${CMAKE_VERSION}" VERSION_LESS "3.12.0")
+  find_package(PythonInterp)
+else()
+  find_package(Python COMPONENTS Interpreter)
+  set(PYTHONINTERP_FOUND ${Python_Interpreter_FOUND})
+  set(PYTHON_EXECUTABLE ${Python_EXECUTABLE})
+endif()
+
+# cxx_test_with_flags(name cxx_flags libs srcs...)
+#
+# 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})
+    add_test(NAME ${name} COMMAND "$<TARGET_FILE:${name}>")
+endfunction()
+
+# cxx_test(name libs srcs...)
+#
+# creates a named test target that depends on the given libs and is
+# built from the given source files.  Unlike cxx_test_with_flags,
+# 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}"
+    "test/${name}.cc" ${ARGN})
+endfunction()
+
+# py_test(name)
+#
+# creates a Python test with the given name whose main module is in
+# test/name.py.  It does nothing if Python is not installed.
+function(py_test name)
+  if (PYTHONINTERP_FOUND)
+    if ("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" VERSION_GREATER 3.1)
+      if (CMAKE_CONFIGURATION_TYPES)
+        # Multi-configuration build generators as for Visual Studio save
+        # output in a subdirectory of CMAKE_CURRENT_BINARY_DIR (Debug,
+        # Release etc.), so we have to provide it here.
+        add_test(NAME ${name}
+          COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py
+              --build_dir=${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG> ${ARGN})
+      else (CMAKE_CONFIGURATION_TYPES)
+        # Single-configuration build generators like Makefile generators
+        # don't have subdirs below CMAKE_CURRENT_BINARY_DIR.
+        add_test(NAME ${name}
+          COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py
+            --build_dir=${CMAKE_CURRENT_BINARY_DIR} ${ARGN})
+      endif (CMAKE_CONFIGURATION_TYPES)
+    else()
+      # ${CMAKE_CURRENT_BINARY_DIR} is known at configuration time, so we can
+      # directly bind it from cmake. ${CTEST_CONFIGURATION_TYPE} is known
+      # only at ctest runtime (by calling ctest -c <Configuration>), so
+      # we have to escape $ to delay variable substitution here.
+      add_test(NAME ${name}
+        COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py
+          --build_dir=${CMAKE_CURRENT_BINARY_DIR}/\${CTEST_CONFIGURATION_TYPE} ${ARGN})
+    endif()
+  endif(PYTHONINTERP_FOUND)
+endfunction()
+
+# install_project(targets...)
+#
+# Installs the specified targets and configures the associated pkgconfig files.
+function(install_project)
+  if(INSTALL_GTEST)
+    install(DIRECTORY "${PROJECT_SOURCE_DIR}/include/"
+      DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
+    # Install the project targets.
+    install(TARGETS ${ARGN}
+      EXPORT ${targets_export_name}
+      RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+      ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+      LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+    if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+      # Install PDBs
+      foreach(t ${ARGN})
+        get_target_property(t_pdb_name ${t} COMPILE_PDB_NAME)
+        get_target_property(t_pdb_name_debug ${t} COMPILE_PDB_NAME_DEBUG)
+        get_target_property(t_pdb_output_directory ${t} PDB_OUTPUT_DIRECTORY)
+        install(FILES
+          "${t_pdb_output_directory}/\${CMAKE_INSTALL_CONFIG_NAME}/$<$<CONFIG:Debug>:${t_pdb_name_debug}>$<$<NOT:$<CONFIG:Debug>>:${t_pdb_name}>.pdb"
+          DESTINATION ${CMAKE_INSTALL_LIBDIR}
+          OPTIONAL)
+      endforeach()
+    endif()
+    # Configure and install pkgconfig files.
+    foreach(t ${ARGN})
+      set(configured_pc "${generated_dir}/${t}.pc")
+      configure_file("${PROJECT_SOURCE_DIR}/cmake/${t}.pc.in"
+        "${configured_pc}" @ONLY)
+      install(FILES "${configured_pc}"
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+    endforeach()
+  endif()
+endfunction()
diff --git a/trunk/3rdparty/gtest-fit/googletest/cmake/libgtest.la.in b/trunk/3rdparty/gtest-fit/googletest/cmake/libgtest.la.in
new file mode 100644
index 000000000..840c83885
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/cmake/libgtest.la.in
@@ -0,0 +1,21 @@
+# libgtest.la - a libtool library file
+# Generated by libtool (GNU libtool) 2.4.6
+
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# Names of this library.
+library_names='libgtest.so'
+
+# Is this an already installed library?
+installed=yes
+
+# Should we warn about portability when linking against -modules?
+shouldnotlink=no
+
+# Files to dlopen/dlpreopen
+dlopen=''
+dlpreopen=''
+
+# Directory that this library needs to be installed in:
+libdir='@CMAKE_INSTALL_FULL_LIBDIR@'
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-death-test.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-death-test.h
new file mode 100644
index 000000000..9b4d4d133
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-death-test.h
@@ -0,0 +1,346 @@
+// Copyright 2005, 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.
+
+//
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file defines the public API for death tests.  It is
+// #included by gtest.h so a user doesn't need to include this
+// directly.
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
+
+#include "gtest/internal/gtest-death-test-internal.h"
+
+namespace testing {
+
+// This flag controls the style of death tests.  Valid values are "threadsafe",
+// meaning that the death test child process will re-execute the test binary
+// from the start, running only a single death test, or "fast",
+// meaning that the child process will execute the test logic immediately
+// after forking.
+GTEST_DECLARE_string_(death_test_style);
+
+#if GTEST_HAS_DEATH_TEST
+
+namespace internal {
+
+// Returns a Boolean value indicating whether the caller is currently
+// executing in the context of the death test child process.  Tools such as
+// Valgrind heap checkers may need this to modify their behavior in death
+// tests.  IMPORTANT: This is an internal utility.  Using it may break the
+// implementation of death tests.  User code MUST NOT use it.
+GTEST_API_ bool InDeathTestChild();
+
+}  // namespace internal
+
+// The following macros are useful for writing death tests.
+
+// Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is
+// executed:
+//
+//   1. It generates a warning if there is more than one active
+//   thread.  This is because it's safe to fork() or clone() only
+//   when there is a single thread.
+//
+//   2. The parent process clone()s a sub-process and runs the death
+//   test in it; the sub-process exits with code 0 at the end of the
+//   death test, if it hasn't exited already.
+//
+//   3. The parent process waits for the sub-process to terminate.
+//
+//   4. The parent process checks the exit code and error message of
+//   the sub-process.
+//
+// Examples:
+//
+//   ASSERT_DEATH(server.SendMessage(56, "Hello"), "Invalid port number");
+//   for (int i = 0; i < 5; i++) {
+//     EXPECT_DEATH(server.ProcessRequest(i),
+//                  "Invalid request .* in ProcessRequest()")
+//                  << "Failed to die on request " << i;
+//   }
+//
+//   ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting");
+//
+//   bool KilledBySIGHUP(int exit_code) {
+//     return WIFSIGNALED(exit_code) && WTERMSIG(exit_code) == SIGHUP;
+//   }
+//
+//   ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!");
+//
+// The final parameter to each of these macros is a matcher applied to any data
+// the sub-process wrote to stderr.  For compatibility with existing tests, a
+// bare string is interpreted as a regular expression matcher.
+//
+// On the regular expressions used in death tests:
+//
+//   GOOGLETEST_CM0005 DO NOT DELETE
+//   On POSIX-compliant systems (*nix), we use the <regex.h> library,
+//   which uses the POSIX extended regex syntax.
+//
+//   On other platforms (e.g. Windows or Mac), we only support a simple regex
+//   syntax implemented as part of Google Test.  This limited
+//   implementation should be enough most of the time when writing
+//   death tests; though it lacks many features you can find in PCRE
+//   or POSIX extended regex syntax.  For example, we don't support
+//   union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and
+//   repetition count ("x{5,7}"), among others.
+//
+//   Below is the syntax that we do support.  We chose it to be a
+//   subset of both PCRE and POSIX extended regex, so it's easy to
+//   learn wherever you come from.  In the following: 'A' denotes a
+//   literal character, period (.), or a single \\ escape sequence;
+//   'x' and 'y' denote regular expressions; 'm' and 'n' are for
+//   natural numbers.
+//
+//     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
+//
+//   If you accidentally use PCRE or POSIX extended regex features
+//   not implemented by us, you will get a run-time failure.  In that
+//   case, please try to rewrite your regular expression within the
+//   above syntax.
+//
+//   This implementation is *not* meant to be as highly tuned or robust
+//   as a compiled regex library, but should perform well enough for a
+//   death test, which already incurs significant overhead by launching
+//   a child process.
+//
+// Known caveats:
+//
+//   A "threadsafe" style death test obtains the path to the test
+//   program from argv[0] and re-executes it in the sub-process.  For
+//   simplicity, the current implementation doesn't search the PATH
+//   when launching the sub-process.  This means that the user must
+//   invoke the test program via a path that contains at least one
+//   path separator (e.g. path/to/foo_test and
+//   /absolute/path/to/bar_test are fine, but foo_test is not).  This
+//   is rarely a problem as people usually don't put the test binary
+//   directory in PATH.
+//
+
+// Asserts that a given `statement` causes the program to exit, with an
+// integer exit status that satisfies `predicate`, and emitting error output
+// that matches `matcher`.
+# define ASSERT_EXIT(statement, predicate, matcher) \
+    GTEST_DEATH_TEST_(statement, predicate, matcher, GTEST_FATAL_FAILURE_)
+
+// Like `ASSERT_EXIT`, but continues on to successive tests in the
+// test suite, if any:
+# define EXPECT_EXIT(statement, predicate, matcher) \
+    GTEST_DEATH_TEST_(statement, predicate, matcher, GTEST_NONFATAL_FAILURE_)
+
+// Asserts that a given `statement` causes the program to exit, either by
+// explicitly exiting with a nonzero exit code or being killed by a
+// signal, and emitting error output that matches `matcher`.
+# define ASSERT_DEATH(statement, matcher) \
+    ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, matcher)
+
+// Like `ASSERT_DEATH`, but continues on to successive tests in the
+// test suite, if any:
+# define EXPECT_DEATH(statement, matcher) \
+    EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, matcher)
+
+// Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*:
+
+// Tests that an exit code describes a normal exit with a given exit code.
+class GTEST_API_ ExitedWithCode {
+ public:
+  explicit ExitedWithCode(int exit_code);
+  ExitedWithCode(const ExitedWithCode&) = default;
+  void operator=(const ExitedWithCode& other) = delete;
+  bool operator()(int exit_status) const;
+ private:
+  const int exit_code_;
+};
+
+# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+// Tests that an exit code describes an exit due to termination by a
+// given signal.
+// GOOGLETEST_CM0006 DO NOT DELETE
+class GTEST_API_ KilledBySignal {
+ public:
+  explicit KilledBySignal(int signum);
+  bool operator()(int exit_status) const;
+ private:
+  const int signum_;
+};
+# endif  // !GTEST_OS_WINDOWS
+
+// EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode.
+// The death testing framework causes this to have interesting semantics,
+// since the sideeffects of the call are only visible in opt mode, and not
+// in debug mode.
+//
+// In practice, this can be used to test functions that utilize the
+// LOG(DFATAL) macro using the following style:
+//
+// int DieInDebugOr12(int* sideeffect) {
+//   if (sideeffect) {
+//     *sideeffect = 12;
+//   }
+//   LOG(DFATAL) << "death";
+//   return 12;
+// }
+//
+// TEST(TestSuite, TestDieOr12WorksInDgbAndOpt) {
+//   int sideeffect = 0;
+//   // Only asserts in dbg.
+//   EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death");
+//
+// #ifdef NDEBUG
+//   // opt-mode has sideeffect visible.
+//   EXPECT_EQ(12, sideeffect);
+// #else
+//   // dbg-mode no visible sideeffect.
+//   EXPECT_EQ(0, sideeffect);
+// #endif
+// }
+//
+// This will assert that DieInDebugReturn12InOpt() crashes in debug
+// mode, usually due to a DCHECK or LOG(DFATAL), but returns the
+// appropriate fallback value (12 in this case) in opt mode. If you
+// need to test that a function has appropriate side-effects in opt
+// mode, include assertions against the side-effects.  A general
+// pattern for this is:
+//
+// EXPECT_DEBUG_DEATH({
+//   // Side-effects here will have an effect after this statement in
+//   // opt mode, but none in debug mode.
+//   EXPECT_EQ(12, DieInDebugOr12(&sideeffect));
+// }, "death");
+//
+# ifdef NDEBUG
+
+#  define EXPECT_DEBUG_DEATH(statement, regex) \
+  GTEST_EXECUTE_STATEMENT_(statement, regex)
+
+#  define ASSERT_DEBUG_DEATH(statement, regex) \
+  GTEST_EXECUTE_STATEMENT_(statement, regex)
+
+# else
+
+#  define EXPECT_DEBUG_DEATH(statement, regex) \
+  EXPECT_DEATH(statement, regex)
+
+#  define ASSERT_DEBUG_DEATH(statement, regex) \
+  ASSERT_DEATH(statement, regex)
+
+# endif  // NDEBUG for EXPECT_DEBUG_DEATH
+#endif  // GTEST_HAS_DEATH_TEST
+
+// This macro is used for implementing macros such as
+// EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems where
+// death tests are not supported. Those macros must compile on such systems
+// if and only if EXPECT_DEATH and ASSERT_DEATH compile with the same parameters
+// on systems that support death tests. This allows one to write such a macro on
+// a system that does not support death tests and be sure that it will compile
+// on a death-test supporting system. It is exposed publicly so that systems
+// that have death-tests with stricter requirements than GTEST_HAS_DEATH_TEST
+// can write their own equivalent of EXPECT_DEATH_IF_SUPPORTED and
+// ASSERT_DEATH_IF_SUPPORTED.
+//
+// Parameters:
+//   statement -  A statement that a macro such as EXPECT_DEATH would test
+//                for program termination. This macro has to make sure this
+//                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
+//                compiled but not evaluated by this macro, to ensure that
+//                this macro only accepts expressions that a macro such as
+//                EXPECT_DEATH would accept.
+//   terminator - Must be an empty statement for EXPECT_DEATH_IF_SUPPORTED
+//                and a return statement for ASSERT_DEATH_IF_SUPPORTED.
+//                This ensures that ASSERT_DEATH_IF_SUPPORTED will not
+//                compile inside functions where ASSERT_DEATH doesn't
+//                compile.
+//
+//  The branch that has an always false condition is used to ensure that
+//  statement and regex are compiled (and thus syntactically correct) but
+//  never executed. The unreachable code macro protects the terminator
+//  statement from generating an 'unreachable code' warning in case
+//  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) \
+    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)); \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+      terminator; \
+    } else \
+      ::testing::Message()
+
+// EXPECT_DEATH_IF_SUPPORTED(statement, regex) and
+// ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if
+// death tests are supported; otherwise they just issue a warning.  This is
+// useful when you are combining death test assertions with normal test
+// assertions in one test.
+#if GTEST_HAS_DEATH_TEST
+# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
+    EXPECT_DEATH(statement, regex)
+# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
+    ASSERT_DEATH(statement, regex)
+#else
+# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \
+    GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, )
+# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \
+    GTEST_UNSUPPORTED_DEATH_TEST(statement, regex, return)
+#endif
+
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-matchers.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-matchers.h
new file mode 100644
index 000000000..9fa34a05b
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-matchers.h
@@ -0,0 +1,930 @@
+// Copyright 2007, 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.
+
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This file implements just enough of the matcher interface to allow
+// EXPECT_DEATH and friends to accept a matcher argument.
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
+
+#include <atomic>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <type_traits>
+
+#include "gtest/gtest-printers.h"
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-port.h"
+
+// MSVC warning C5046 is new as of VS2017 version 15.8.
+#if defined(_MSC_VER) && _MSC_VER >= 1915
+#define GTEST_MAYBE_5046_ 5046
+#else
+#define GTEST_MAYBE_5046_
+#endif
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(
+    4251 GTEST_MAYBE_5046_ /* class A needs to have dll-interface to be used by
+                              clients of class B */
+    /* Symbol involving type with internal linkage not defined */)
+
+namespace testing {
+
+// To implement a matcher Foo for type T, define:
+//   1. a class FooMatcherMatcher that implements the matcher interface:
+//     using is_gtest_matcher = void;
+//     bool MatchAndExplain(const T&, std::ostream*);
+//       (MatchResultListener* can also be used instead of std::ostream*)
+//     void DescribeTo(std::ostream*);
+//     void DescribeNegationTo(std::ostream*);
+//
+//   2. a factory function that creates a Matcher<T> object from a
+//      FooMatcherMatcher.
+
+class MatchResultListener {
+ public:
+  // Creates a listener object with the given underlying ostream.  The
+  // listener does not own the ostream, and does not dereference it
+  // in the constructor or destructor.
+  explicit MatchResultListener(::std::ostream* os) : stream_(os) {}
+  virtual ~MatchResultListener() = 0;  // Makes this class abstract.
+
+  // Streams x to the underlying ostream; does nothing if the ostream
+  // is NULL.
+  template <typename T>
+  MatchResultListener& operator<<(const T& x) {
+    if (stream_ != nullptr) *stream_ << x;
+    return *this;
+  }
+
+  // Returns the underlying ostream.
+  ::std::ostream* stream() { return stream_; }
+
+  // Returns true if and only if the listener is interested in an explanation
+  // of the match result.  A matcher's MatchAndExplain() method can use
+  // this information to avoid generating the explanation when no one
+  // intends to hear it.
+  bool IsInterested() const { return stream_ != nullptr; }
+
+ private:
+  ::std::ostream* const stream_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener);
+};
+
+inline MatchResultListener::~MatchResultListener() {
+}
+
+// An instance of a subclass of this knows how to describe itself as a
+// matcher.
+class GTEST_API_ MatcherDescriberInterface {
+ public:
+  virtual ~MatcherDescriberInterface() {}
+
+  // Describes this matcher to an ostream.  The function should print
+  // a verb phrase that describes the property a value matching this
+  // matcher should have.  The subject of the verb phrase is the value
+  // being matched.  For example, the DescribeTo() method of the Gt(7)
+  // matcher prints "is greater than 7".
+  virtual void DescribeTo(::std::ostream* os) const = 0;
+
+  // Describes the negation of this matcher to an ostream.  For
+  // example, if the description of this matcher is "is greater than
+  // 7", the negated description could be "is not greater than 7".
+  // You are not required to override this when implementing
+  // MatcherInterface, but it is highly advised so that your matcher
+  // can produce good error messages.
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "not (";
+    DescribeTo(os);
+    *os << ")";
+  }
+};
+
+// The implementation of a matcher.
+template <typename T>
+class MatcherInterface : public MatcherDescriberInterface {
+ public:
+  // Returns true if and only if the matcher matches x; also explains the
+  // match result to 'listener' if necessary (see the next paragraph), in
+  // the form of a non-restrictive relative clause ("which ...",
+  // "whose ...", etc) that describes x.  For example, the
+  // MatchAndExplain() method of the Pointee(...) matcher should
+  // generate an explanation like "which points to ...".
+  //
+  // Implementations of MatchAndExplain() should add an explanation of
+  // the match result *if and only if* they can provide additional
+  // information that's not already present (or not obvious) in the
+  // print-out of x and the matcher's description.  Whether the match
+  // succeeds is not a factor in deciding whether an explanation is
+  // needed, as sometimes the caller needs to print a failure message
+  // when the match succeeds (e.g. when the matcher is used inside
+  // Not()).
+  //
+  // For example, a "has at least 10 elements" matcher should explain
+  // what the actual element count is, regardless of the match result,
+  // as it is useful information to the reader; on the other hand, an
+  // "is empty" matcher probably only needs to explain what the actual
+  // size is when the match fails, as it's redundant to say that the
+  // size is 0 when the value is already known to be empty.
+  //
+  // You should override this method when defining a new matcher.
+  //
+  // It's the responsibility of the caller (Google Test) to guarantee
+  // that 'listener' is not NULL.  This helps to simplify a matcher's
+  // implementation when it doesn't care about the performance, as it
+  // can talk to 'listener' without checking its validity first.
+  // However, in order to implement dummy listeners efficiently,
+  // listener->stream() may be NULL.
+  virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0;
+
+  // Inherits these methods from MatcherDescriberInterface:
+  //   virtual void DescribeTo(::std::ostream* os) const = 0;
+  //   virtual void DescribeNegationTo(::std::ostream* os) const;
+};
+
+namespace internal {
+
+struct AnyEq {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a == b; }
+};
+struct AnyNe {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a != b; }
+};
+struct AnyLt {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a < b; }
+};
+struct AnyGt {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a > b; }
+};
+struct AnyLe {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a <= b; }
+};
+struct AnyGe {
+  template <typename A, typename B>
+  bool operator()(const A& a, const B& b) const { return a >= b; }
+};
+
+// A match result listener that ignores the explanation.
+class DummyMatchResultListener : public MatchResultListener {
+ public:
+  DummyMatchResultListener() : MatchResultListener(nullptr) {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener);
+};
+
+// A match result listener that forwards the explanation to a given
+// ostream.  The difference between this and MatchResultListener is
+// that the former is concrete.
+class StreamMatchResultListener : public MatchResultListener {
+ public:
+  explicit StreamMatchResultListener(::std::ostream* os)
+      : MatchResultListener(os) {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener);
+};
+
+struct SharedPayloadBase {
+  std::atomic<int> ref{1};
+  void Ref() { ref.fetch_add(1, std::memory_order_relaxed); }
+  bool Unref() { return ref.fetch_sub(1, std::memory_order_acq_rel) == 1; }
+};
+
+template <typename T>
+struct SharedPayload : SharedPayloadBase {
+  explicit SharedPayload(const T& v) : value(v) {}
+  explicit SharedPayload(T&& v) : value(std::move(v)) {}
+
+  static void Destroy(SharedPayloadBase* shared) {
+    delete static_cast<SharedPayload*>(shared);
+  }
+
+  T value;
+};
+
+// An internal class for implementing Matcher<T>, which will derive
+// from it.  We put functionalities common to all Matcher<T>
+// specializations here to avoid code duplication.
+template <typename T>
+class MatcherBase : private MatcherDescriberInterface {
+ public:
+  // Returns true if and only if the matcher matches x; also explains the
+  // match result to 'listener'.
+  bool MatchAndExplain(const T& x, MatchResultListener* listener) const {
+    GTEST_CHECK_(vtable_ != nullptr);
+    return vtable_->match_and_explain(*this, x, listener);
+  }
+
+  // Returns true if and only if this matcher matches x.
+  bool Matches(const T& x) const {
+    DummyMatchResultListener dummy;
+    return MatchAndExplain(x, &dummy);
+  }
+
+  // Describes this matcher to an ostream.
+  void DescribeTo(::std::ostream* os) const final {
+    GTEST_CHECK_(vtable_ != nullptr);
+    vtable_->describe(*this, os, false);
+  }
+
+  // Describes the negation of this matcher to an ostream.
+  void DescribeNegationTo(::std::ostream* os) const final {
+    GTEST_CHECK_(vtable_ != nullptr);
+    vtable_->describe(*this, os, true);
+  }
+
+  // Explains why x matches, or doesn't match, the matcher.
+  void ExplainMatchResultTo(const T& x, ::std::ostream* os) const {
+    StreamMatchResultListener listener(os);
+    MatchAndExplain(x, &listener);
+  }
+
+  // Returns the describer for this matcher object; retains ownership
+  // of the describer, which is only guaranteed to be alive when
+  // this matcher object is alive.
+  const MatcherDescriberInterface* GetDescriber() const {
+    if (vtable_ == nullptr) return nullptr;
+    return vtable_->get_describer(*this);
+  }
+
+ protected:
+  MatcherBase() : vtable_(nullptr) {}
+
+  // Constructs a matcher from its implementation.
+  template <typename U>
+  explicit MatcherBase(const MatcherInterface<U>* impl) {
+    Init(impl);
+  }
+
+  template <typename M, typename = typename std::remove_reference<
+                            M>::type::is_gtest_matcher>
+  MatcherBase(M&& m) {  // NOLINT
+    Init(std::forward<M>(m));
+  }
+
+  MatcherBase(const MatcherBase& other)
+      : vtable_(other.vtable_), buffer_(other.buffer_) {
+    if (IsShared()) buffer_.shared->Ref();
+  }
+
+  MatcherBase& operator=(const MatcherBase& other) {
+    if (this == &other) return *this;
+    Destroy();
+    vtable_ = other.vtable_;
+    buffer_ = other.buffer_;
+    if (IsShared()) buffer_.shared->Ref();
+    return *this;
+  }
+
+  MatcherBase(MatcherBase&& other)
+      : vtable_(other.vtable_), buffer_(other.buffer_) {
+    other.vtable_ = nullptr;
+  }
+
+  MatcherBase& operator=(MatcherBase&& other) {
+    if (this == &other) return *this;
+    Destroy();
+    vtable_ = other.vtable_;
+    buffer_ = other.buffer_;
+    other.vtable_ = nullptr;
+    return *this;
+  }
+
+  ~MatcherBase() override { Destroy(); }
+
+ private:
+  struct VTable {
+    bool (*match_and_explain)(const MatcherBase&, const T&,
+                              MatchResultListener*);
+    void (*describe)(const MatcherBase&, std::ostream*, bool negation);
+    // Returns the captured object if it implements the interface, otherwise
+    // returns the MatcherBase itself.
+    const MatcherDescriberInterface* (*get_describer)(const MatcherBase&);
+    // Called on shared instances when the reference count reaches 0.
+    void (*shared_destroy)(SharedPayloadBase*);
+  };
+
+  bool IsShared() const {
+    return vtable_ != nullptr && vtable_->shared_destroy != nullptr;
+  }
+
+  // If the implementation uses a listener, call that.
+  template <typename P>
+  static auto MatchAndExplainImpl(const MatcherBase& m, const T& value,
+                                  MatchResultListener* listener)
+      -> decltype(P::Get(m).MatchAndExplain(value, listener->stream())) {
+    return P::Get(m).MatchAndExplain(value, listener->stream());
+  }
+
+  template <typename P>
+  static auto MatchAndExplainImpl(const MatcherBase& m, const T& value,
+                                  MatchResultListener* listener)
+      -> decltype(P::Get(m).MatchAndExplain(value, listener)) {
+    return P::Get(m).MatchAndExplain(value, listener);
+  }
+
+  template <typename P>
+  static void DescribeImpl(const MatcherBase& m, std::ostream* os,
+                           bool negation) {
+    if (negation) {
+      P::Get(m).DescribeNegationTo(os);
+    } else {
+      P::Get(m).DescribeTo(os);
+    }
+  }
+
+  template <typename P>
+  static const MatcherDescriberInterface* GetDescriberImpl(
+      const MatcherBase& m) {
+    // If the impl is a MatcherDescriberInterface, then return it.
+    // Otherwise use MatcherBase itself.
+    // This allows us to implement the GetDescriber() function without support
+    // from the impl, but some users really want to get their impl back when
+    // they call GetDescriber().
+    // We use std::get on a tuple as a workaround of not having `if constexpr`.
+    return std::get<(
+        std::is_convertible<decltype(&P::Get(m)),
+                            const MatcherDescriberInterface*>::value
+            ? 1
+            : 0)>(std::make_tuple(&m, &P::Get(m)));
+  }
+
+  template <typename P>
+  const VTable* GetVTable() {
+    static constexpr VTable kVTable = {&MatchAndExplainImpl<P>,
+                                       &DescribeImpl<P>, &GetDescriberImpl<P>,
+                                       P::shared_destroy};
+    return &kVTable;
+  }
+
+  union Buffer {
+    // Add some types to give Buffer some common alignment/size use cases.
+    void* ptr;
+    double d;
+    int64_t i;
+    // And add one for the out-of-line cases.
+    SharedPayloadBase* shared;
+  };
+
+  void Destroy() {
+    if (IsShared() && buffer_.shared->Unref()) {
+      vtable_->shared_destroy(buffer_.shared);
+    }
+  }
+
+  template <typename M>
+  static constexpr bool IsInlined() {
+    return sizeof(M) <= sizeof(Buffer) && alignof(M) <= alignof(Buffer) &&
+           std::is_trivially_copy_constructible<M>::value &&
+           std::is_trivially_destructible<M>::value;
+  }
+
+  template <typename M, bool = MatcherBase::IsInlined<M>()>
+  struct ValuePolicy {
+    static const M& Get(const MatcherBase& m) {
+      // When inlined along with Init, need to be explicit to avoid violating
+      // strict aliasing rules.
+      const M *ptr = static_cast<const M*>(
+          static_cast<const void*>(&m.buffer_));
+      return *ptr;
+    }
+    static void Init(MatcherBase& m, M impl) {
+      ::new (static_cast<void*>(&m.buffer_)) M(impl);
+    }
+    static constexpr auto shared_destroy = nullptr;
+  };
+
+  template <typename M>
+  struct ValuePolicy<M, false> {
+    using Shared = SharedPayload<M>;
+    static const M& Get(const MatcherBase& m) {
+      return static_cast<Shared*>(m.buffer_.shared)->value;
+    }
+    template <typename Arg>
+    static void Init(MatcherBase& m, Arg&& arg) {
+      m.buffer_.shared = new Shared(std::forward<Arg>(arg));
+    }
+    static constexpr auto shared_destroy = &Shared::Destroy;
+  };
+
+  template <typename U, bool B>
+  struct ValuePolicy<const MatcherInterface<U>*, B> {
+    using M = const MatcherInterface<U>;
+    using Shared = SharedPayload<std::unique_ptr<M>>;
+    static const M& Get(const MatcherBase& m) {
+      return *static_cast<Shared*>(m.buffer_.shared)->value;
+    }
+    static void Init(MatcherBase& m, M* impl) {
+      m.buffer_.shared = new Shared(std::unique_ptr<M>(impl));
+    }
+
+    static constexpr auto shared_destroy = &Shared::Destroy;
+  };
+
+  template <typename M>
+  void Init(M&& m) {
+    using MM = typename std::decay<M>::type;
+    using Policy = ValuePolicy<MM>;
+    vtable_ = GetVTable<Policy>();
+    Policy::Init(*this, std::forward<M>(m));
+  }
+
+  const VTable* vtable_;
+  Buffer buffer_;
+};
+
+}  // namespace internal
+
+// A Matcher<T> is a copyable and IMMUTABLE (except by assignment)
+// object that can check whether a value of type T matches.  The
+// implementation of Matcher<T> is just a std::shared_ptr to const
+// MatcherInterface<T>.  Don't inherit from Matcher!
+template <typename T>
+class Matcher : public internal::MatcherBase<T> {
+ public:
+  // Constructs a null matcher.  Needed for storing Matcher objects in STL
+  // containers.  A default-constructed matcher is not yet initialized.  You
+  // cannot use it until a valid value has been assigned to it.
+  explicit Matcher() {}  // NOLINT
+
+  // Constructs a matcher from its implementation.
+  explicit Matcher(const MatcherInterface<const T&>* impl)
+      : internal::MatcherBase<T>(impl) {}
+
+  template <typename U>
+  explicit Matcher(
+      const MatcherInterface<U>* impl,
+      typename std::enable_if<!std::is_same<U, const U&>::value>::type* =
+          nullptr)
+      : internal::MatcherBase<T>(impl) {}
+
+  template <typename M, typename = typename std::remove_reference<
+                            M>::type::is_gtest_matcher>
+  Matcher(M&& m) : internal::MatcherBase<T>(std::forward<M>(m)) {}  // NOLINT
+
+  // Implicit constructor here allows people to write
+  // EXPECT_CALL(foo, Bar(5)) instead of EXPECT_CALL(foo, Bar(Eq(5))) sometimes
+  Matcher(T value);  // NOLINT
+};
+
+// The following two specializations allow the user to write str
+// instead of Eq(str) and "foo" instead of Eq("foo") when a std::string
+// matcher is expected.
+template <>
+class GTEST_API_ Matcher<const std::string&>
+    : public internal::MatcherBase<const std::string&> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<const std::string&>* impl)
+      : internal::MatcherBase<const std::string&>(impl) {}
+
+  template <typename M, typename = typename std::remove_reference<
+                            M>::type::is_gtest_matcher>
+  Matcher(M&& m)  // NOLINT
+      : internal::MatcherBase<const std::string&>(std::forward<M>(m)) {}
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a std::string object.
+  Matcher(const std::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+};
+
+template <>
+class GTEST_API_ Matcher<std::string>
+    : public internal::MatcherBase<std::string> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<const std::string&>* impl)
+      : internal::MatcherBase<std::string>(impl) {}
+  explicit Matcher(const MatcherInterface<std::string>* impl)
+      : internal::MatcherBase<std::string>(impl) {}
+
+  template <typename M, typename = typename std::remove_reference<
+                            M>::type::is_gtest_matcher>
+  Matcher(M&& m)  // NOLINT
+      : internal::MatcherBase<std::string>(std::forward<M>(m)) {}
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a string object.
+  Matcher(const std::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+};
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+// The following two specializations allow the user to write str
+// instead of Eq(str) and "foo" instead of Eq("foo") when a absl::string_view
+// matcher is expected.
+template <>
+class GTEST_API_ Matcher<const internal::StringView&>
+    : public internal::MatcherBase<const internal::StringView&> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
+      : internal::MatcherBase<const internal::StringView&>(impl) {}
+
+  template <typename M, typename = typename std::remove_reference<
+                            M>::type::is_gtest_matcher>
+  Matcher(M&& m)  // NOLINT
+      : internal::MatcherBase<const internal::StringView&>(std::forward<M>(m)) {
+  }
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a std::string object.
+  Matcher(const std::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+
+  // Allows the user to pass absl::string_views or std::string_views directly.
+  Matcher(internal::StringView s);  // NOLINT
+};
+
+template <>
+class GTEST_API_ Matcher<internal::StringView>
+    : public internal::MatcherBase<internal::StringView> {
+ public:
+  Matcher() {}
+
+  explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
+      : internal::MatcherBase<internal::StringView>(impl) {}
+  explicit Matcher(const MatcherInterface<internal::StringView>* impl)
+      : internal::MatcherBase<internal::StringView>(impl) {}
+
+  template <typename M, typename = typename std::remove_reference<
+                            M>::type::is_gtest_matcher>
+  Matcher(M&& m)  // NOLINT
+      : internal::MatcherBase<internal::StringView>(std::forward<M>(m)) {}
+
+  // Allows the user to write str instead of Eq(str) sometimes, where
+  // str is a std::string object.
+  Matcher(const std::string& s);  // NOLINT
+
+  // Allows the user to write "foo" instead of Eq("foo") sometimes.
+  Matcher(const char* s);  // NOLINT
+
+  // Allows the user to pass absl::string_views or std::string_views directly.
+  Matcher(internal::StringView s);  // NOLINT
+};
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+// Prints a matcher in a human-readable format.
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const Matcher<T>& matcher) {
+  matcher.DescribeTo(&os);
+  return os;
+}
+
+// The PolymorphicMatcher class template makes it easy to implement a
+// polymorphic matcher (i.e. a matcher that can match values of more
+// than one type, e.g. Eq(n) and NotNull()).
+//
+// To define a polymorphic matcher, a user should provide an Impl
+// class that has a DescribeTo() method and a DescribeNegationTo()
+// method, and define a member function (or member function template)
+//
+//   bool MatchAndExplain(const Value& value,
+//                        MatchResultListener* listener) const;
+//
+// See the definition of NotNull() for a complete example.
+template <class Impl>
+class PolymorphicMatcher {
+ public:
+  explicit PolymorphicMatcher(const Impl& an_impl) : impl_(an_impl) {}
+
+  // Returns a mutable reference to the underlying matcher
+  // implementation object.
+  Impl& mutable_impl() { return impl_; }
+
+  // Returns an immutable reference to the underlying matcher
+  // implementation object.
+  const Impl& impl() const { return impl_; }
+
+  template <typename T>
+  operator Matcher<T>() const {
+    return Matcher<T>(new MonomorphicImpl<const T&>(impl_));
+  }
+
+ private:
+  template <typename T>
+  class MonomorphicImpl : public MatcherInterface<T> {
+   public:
+    explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {}
+
+    void DescribeTo(::std::ostream* os) const override { impl_.DescribeTo(os); }
+
+    void DescribeNegationTo(::std::ostream* os) const override {
+      impl_.DescribeNegationTo(os);
+    }
+
+    bool MatchAndExplain(T x, MatchResultListener* listener) const override {
+      return impl_.MatchAndExplain(x, listener);
+    }
+
+   private:
+    const Impl impl_;
+  };
+
+  Impl impl_;
+};
+
+// Creates a matcher from its implementation.
+// DEPRECATED: Especially in the generic code, prefer:
+//   Matcher<T>(new MyMatcherImpl<const T&>(...));
+//
+// MakeMatcher may create a Matcher that accepts its argument by value, which
+// leads to unnecessary copies & lack of support for non-copyable types.
+template <typename T>
+inline Matcher<T> MakeMatcher(const MatcherInterface<T>* impl) {
+  return Matcher<T>(impl);
+}
+
+// Creates a polymorphic matcher from its implementation.  This is
+// easier to use than the PolymorphicMatcher<Impl> constructor as it
+// doesn't require you to explicitly write the template argument, e.g.
+//
+//   MakePolymorphicMatcher(foo);
+// vs
+//   PolymorphicMatcher<TypeOfFoo>(foo);
+template <class Impl>
+inline PolymorphicMatcher<Impl> MakePolymorphicMatcher(const Impl& impl) {
+  return PolymorphicMatcher<Impl>(impl);
+}
+
+namespace internal {
+// Implements a matcher that compares a given value with a
+// pre-supplied value using one of the ==, <=, <, etc, operators.  The
+// two values being compared don't have to have the same type.
+//
+// The matcher defined here is polymorphic (for example, Eq(5) can be
+// used to match an int, a short, a double, etc).  Therefore we use
+// a template type conversion operator in the implementation.
+//
+// The following template definition assumes that the Rhs parameter is
+// a "bare" type (i.e. neither 'const T' nor 'T&').
+template <typename D, typename Rhs, typename Op>
+class ComparisonBase {
+ public:
+  explicit ComparisonBase(const Rhs& rhs) : rhs_(rhs) {}
+
+  using is_gtest_matcher = void;
+
+  template <typename Lhs>
+  bool MatchAndExplain(const Lhs& lhs, std::ostream*) const {
+    return Op()(lhs, Unwrap(rhs_));
+  }
+  void DescribeTo(std::ostream* os) const {
+    *os << D::Desc() << " ";
+    UniversalPrint(Unwrap(rhs_), os);
+  }
+  void DescribeNegationTo(std::ostream* os) const {
+    *os << D::NegatedDesc() << " ";
+    UniversalPrint(Unwrap(rhs_), os);
+  }
+
+ private:
+  template <typename T>
+  static const T& Unwrap(const T& v) {
+    return v;
+  }
+  template <typename T>
+  static const T& Unwrap(std::reference_wrapper<T> v) {
+    return v;
+  }
+
+  Rhs rhs_;
+};
+
+template <typename Rhs>
+class EqMatcher : public ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq> {
+ public:
+  explicit EqMatcher(const Rhs& rhs)
+      : ComparisonBase<EqMatcher<Rhs>, Rhs, AnyEq>(rhs) { }
+  static const char* Desc() { return "is equal to"; }
+  static const char* NegatedDesc() { return "isn't equal to"; }
+};
+template <typename Rhs>
+class NeMatcher : public ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe> {
+ public:
+  explicit NeMatcher(const Rhs& rhs)
+      : ComparisonBase<NeMatcher<Rhs>, Rhs, AnyNe>(rhs) { }
+  static const char* Desc() { return "isn't equal to"; }
+  static const char* NegatedDesc() { return "is equal to"; }
+};
+template <typename Rhs>
+class LtMatcher : public ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt> {
+ public:
+  explicit LtMatcher(const Rhs& rhs)
+      : ComparisonBase<LtMatcher<Rhs>, Rhs, AnyLt>(rhs) { }
+  static const char* Desc() { return "is <"; }
+  static const char* NegatedDesc() { return "isn't <"; }
+};
+template <typename Rhs>
+class GtMatcher : public ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt> {
+ public:
+  explicit GtMatcher(const Rhs& rhs)
+      : ComparisonBase<GtMatcher<Rhs>, Rhs, AnyGt>(rhs) { }
+  static const char* Desc() { return "is >"; }
+  static const char* NegatedDesc() { return "isn't >"; }
+};
+template <typename Rhs>
+class LeMatcher : public ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe> {
+ public:
+  explicit LeMatcher(const Rhs& rhs)
+      : ComparisonBase<LeMatcher<Rhs>, Rhs, AnyLe>(rhs) { }
+  static const char* Desc() { return "is <="; }
+  static const char* NegatedDesc() { return "isn't <="; }
+};
+template <typename Rhs>
+class GeMatcher : public ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe> {
+ public:
+  explicit GeMatcher(const Rhs& rhs)
+      : ComparisonBase<GeMatcher<Rhs>, Rhs, AnyGe>(rhs) { }
+  static const char* Desc() { return "is >="; }
+  static const char* NegatedDesc() { return "isn't >="; }
+};
+
+template <typename T, typename = typename std::enable_if<
+                          std::is_constructible<std::string, T>::value>::type>
+using StringLike = T;
+
+// Implements polymorphic matchers MatchesRegex(regex) and
+// ContainsRegex(regex), which can be used as a Matcher<T> as long as
+// T can be converted to a string.
+class MatchesRegexMatcher {
+ public:
+  MatchesRegexMatcher(const RE* regex, bool full_match)
+      : regex_(regex), full_match_(full_match) {}
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  bool MatchAndExplain(const internal::StringView& s,
+                       MatchResultListener* listener) const {
+    return MatchAndExplain(std::string(s), listener);
+  }
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+  // Accepts pointer types, particularly:
+  //   const char*
+  //   char*
+  //   const wchar_t*
+  //   wchar_t*
+  template <typename CharType>
+  bool MatchAndExplain(CharType* s, MatchResultListener* listener) const {
+    return s != nullptr && MatchAndExplain(std::string(s), listener);
+  }
+
+  // Matches anything that can convert to std::string.
+  //
+  // This is a template, not just a plain function with const std::string&,
+  // because absl::string_view has some interfering non-explicit constructors.
+  template <class MatcheeStringType>
+  bool MatchAndExplain(const MatcheeStringType& s,
+                       MatchResultListener* /* listener */) const {
+    const std::string& s2(s);
+    return full_match_ ? RE::FullMatch(s2, *regex_)
+                       : RE::PartialMatch(s2, *regex_);
+  }
+
+  void DescribeTo(::std::ostream* os) const {
+    *os << (full_match_ ? "matches" : "contains") << " regular expression ";
+    UniversalPrinter<std::string>::Print(regex_->pattern(), os);
+  }
+
+  void DescribeNegationTo(::std::ostream* os) const {
+    *os << "doesn't " << (full_match_ ? "match" : "contain")
+        << " regular expression ";
+    UniversalPrinter<std::string>::Print(regex_->pattern(), os);
+  }
+
+ private:
+  const std::shared_ptr<const RE> regex_;
+  const bool full_match_;
+};
+}  // namespace internal
+
+// Matches a string that fully matches regular expression 'regex'.
+// The matcher takes ownership of 'regex'.
+inline PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
+    const internal::RE* regex) {
+  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, true));
+}
+template <typename T = std::string>
+PolymorphicMatcher<internal::MatchesRegexMatcher> MatchesRegex(
+    const internal::StringLike<T>& regex) {
+  return MatchesRegex(new internal::RE(std::string(regex)));
+}
+
+// Matches a string that contains regular expression 'regex'.
+// The matcher takes ownership of 'regex'.
+inline PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
+    const internal::RE* regex) {
+  return MakePolymorphicMatcher(internal::MatchesRegexMatcher(regex, false));
+}
+template <typename T = std::string>
+PolymorphicMatcher<internal::MatchesRegexMatcher> ContainsRegex(
+    const internal::StringLike<T>& regex) {
+  return ContainsRegex(new internal::RE(std::string(regex)));
+}
+
+// Creates a polymorphic matcher that matches anything equal to x.
+// Note: if the parameter of Eq() were declared as const T&, Eq("foo")
+// wouldn't compile.
+template <typename T>
+inline internal::EqMatcher<T> Eq(T x) { return internal::EqMatcher<T>(x); }
+
+// Constructs a Matcher<T> from a 'value' of type T.  The constructed
+// matcher matches any value that's equal to 'value'.
+template <typename T>
+Matcher<T>::Matcher(T value) { *this = Eq(value); }
+
+// Creates a monomorphic matcher that matches anything with type Lhs
+// and equal to rhs.  A user may need to use this instead of Eq(...)
+// in order to resolve an overloading ambiguity.
+//
+// TypedEq<T>(x) is just a convenient short-hand for Matcher<T>(Eq(x))
+// or Matcher<T>(x), but more readable than the latter.
+//
+// We could define similar monomorphic matchers for other comparison
+// operations (e.g. TypedLt, TypedGe, and etc), but decided not to do
+// it yet as those are used much less than Eq() in practice.  A user
+// can always write Matcher<T>(Lt(5)) to be explicit about the type,
+// for example.
+template <typename Lhs, typename Rhs>
+inline Matcher<Lhs> TypedEq(const Rhs& rhs) { return Eq(rhs); }
+
+// Creates a polymorphic matcher that matches anything >= x.
+template <typename Rhs>
+inline internal::GeMatcher<Rhs> Ge(Rhs x) {
+  return internal::GeMatcher<Rhs>(x);
+}
+
+// Creates a polymorphic matcher that matches anything > x.
+template <typename Rhs>
+inline internal::GtMatcher<Rhs> Gt(Rhs x) {
+  return internal::GtMatcher<Rhs>(x);
+}
+
+// Creates a polymorphic matcher that matches anything <= x.
+template <typename Rhs>
+inline internal::LeMatcher<Rhs> Le(Rhs x) {
+  return internal::LeMatcher<Rhs>(x);
+}
+
+// Creates a polymorphic matcher that matches anything < x.
+template <typename Rhs>
+inline internal::LtMatcher<Rhs> Lt(Rhs x) {
+  return internal::LtMatcher<Rhs>(x);
+}
+
+// Creates a polymorphic matcher that matches anything != x.
+template <typename Rhs>
+inline internal::NeMatcher<Rhs> Ne(Rhs x) {
+  return internal::NeMatcher<Rhs>(x);
+}
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251 5046
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_MATCHERS_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-message.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-message.h
new file mode 100644
index 000000000..becfd49fc
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-message.h
@@ -0,0 +1,219 @@
+// Copyright 2005, 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.
+
+//
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file defines the Message class.
+//
+// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
+// leave some internal implementation details in this header file.
+// They are clearly marked by comments like this:
+//
+//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+//
+// Such code is NOT meant to be used by a user directly, and is subject
+// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
+// program!
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
+
+#include <limits>
+#include <memory>
+#include <sstream>
+
+#include "gtest/internal/gtest-port.h"
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+// Ensures that there is at least one operator<< in the global namespace.
+// See Message& operator<<(...) below for why.
+void operator<<(const testing::internal::Secret&, int);
+
+namespace testing {
+
+// The Message class works like an ostream repeater.
+//
+// Typical usage:
+//
+//   1. You stream a bunch of values to a Message object.
+//      It will remember the text in a stringstream.
+//   2. Then you stream the Message object to an ostream.
+//      This causes the text in the Message to be streamed
+//      to the ostream.
+//
+// For example;
+//
+//   testing::Message foo;
+//   foo << 1 << " != " << 2;
+//   std::cout << foo;
+//
+// will print "1 != 2".
+//
+// Message is not intended to be inherited from.  In particular, its
+// destructor is not virtual.
+//
+// Note that stringstream behaves differently in gcc and in MSVC.  You
+// can stream a NULL char pointer to it in the former, but not in the
+// latter (it causes an access violation if you do).  The Message
+// class hides this difference by treating a NULL char pointer as
+// "(null)".
+class GTEST_API_ Message {
+ private:
+  // The type of basic IO manipulators (endl, ends, and flush) for
+  // narrow streams.
+  typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&);
+
+ public:
+  // Constructs an empty Message.
+  Message();
+
+  // Copy constructor.
+  Message(const Message& msg) : ss_(new ::std::stringstream) {  // NOLINT
+    *ss_ << msg.GetString();
+  }
+
+  // Constructs a Message from a C-string.
+  explicit Message(const char* str) : ss_(new ::std::stringstream) {
+    *ss_ << str;
+  }
+
+  // Streams a non-pointer value to this object.
+  template <typename T>
+  inline Message& operator <<(const T& val) {
+    // Some libraries overload << for STL containers.  These
+    // overloads are defined in the global namespace instead of ::std.
+    //
+    // C++'s symbol lookup rule (i.e. Koenig lookup) says that these
+    // overloads are visible in either the std namespace or the global
+    // namespace, but not other namespaces, including the testing
+    // namespace which Google Test's Message class is in.
+    //
+    // To allow STL containers (and other types that has a << operator
+    // defined in the global namespace) to be used in Google Test
+    // assertions, testing::Message must access the custom << operator
+    // from the global namespace.  With this using declaration,
+    // overloads of << defined in the global namespace and those
+    // visible via Koenig lookup are both exposed in this function.
+    using ::operator <<;
+    *ss_ << val;
+    return *this;
+  }
+
+  // Streams a pointer value to this object.
+  //
+  // This function is an overload of the previous one.  When you
+  // stream a pointer to a Message, this definition will be used as it
+  // is more specialized.  (The C++ Standard, section
+  // [temp.func.order].)  If you stream a non-pointer, then the
+  // previous definition will be used.
+  //
+  // The reason for this overload is that streaming a NULL pointer to
+  // ostream is undefined behavior.  Depending on the compiler, you
+  // may get "0", "(nil)", "(null)", or an access violation.  To
+  // ensure consistent result across compilers, we always treat NULL
+  // as "(null)".
+  template <typename T>
+  inline Message& operator <<(T* const& pointer) {  // NOLINT
+    if (pointer == nullptr) {
+      *ss_ << "(null)";
+    } else {
+      *ss_ << pointer;
+    }
+    return *this;
+  }
+
+  // Since the basic IO manipulators are overloaded for both narrow
+  // and wide streams, we have to provide this specialized definition
+  // of operator <<, even though its body is the same as the
+  // templatized version above.  Without this definition, streaming
+  // endl or other basic IO manipulators to Message will confuse the
+  // compiler.
+  Message& operator <<(BasicNarrowIoManip val) {
+    *ss_ << val;
+    return *this;
+  }
+
+  // Instead of 1/0, we want to see true/false for bool values.
+  Message& operator <<(bool b) {
+    return *this << (b ? "true" : "false");
+  }
+
+  // These two overloads allow streaming a wide C string to a Message
+  // using the UTF-8 encoding.
+  Message& operator <<(const wchar_t* wide_c_str);
+  Message& operator <<(wchar_t* wide_c_str);
+
+#if GTEST_HAS_STD_WSTRING
+  // Converts the given wide string to a narrow string using the UTF-8
+  // encoding, and streams the result to this Message object.
+  Message& operator <<(const ::std::wstring& wstr);
+#endif  // GTEST_HAS_STD_WSTRING
+
+  // Gets the text streamed to this object so far as an std::string.
+  // Each '\0' character in the buffer is replaced with "\\0".
+  //
+  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+  std::string GetString() const;
+
+ private:
+  // We'll hold the text streamed to this object here.
+  const std::unique_ptr< ::std::stringstream> ss_;
+
+  // We declare (but don't implement) this to prevent the compiler
+  // from implementing the assignment operator.
+  void operator=(const Message&);
+};
+
+// Streams a Message to an ostream.
+inline std::ostream& operator <<(std::ostream& os, const Message& sb) {
+  return os << sb.GetString();
+}
+
+namespace internal {
+
+// Converts a streamable value to an std::string.  A NULL pointer is
+// converted to "(null)".  When the input value is a ::string,
+// ::std::string, ::wstring, or ::std::wstring object, each NUL
+// character in it is replaced with "\\0".
+template <typename T>
+std::string StreamableToString(const T& streamable) {
+  return (Message() << streamable).GetString();
+}
+
+}  // namespace internal
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-param-test.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-param-test.h
new file mode 100644
index 000000000..804e70281
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-param-test.h
@@ -0,0 +1,507 @@
+// Copyright 2008, 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.
+//
+// Macros and functions for implementing parameterized tests
+// in Google C++ Testing and Mocking Framework (Google Test)
+//
+// GOOGLETEST_CM0001 DO NOT DELETE
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
+
+// Value-parameterized tests allow you to test your code with different
+// parameters without writing multiple copies of the same test.
+//
+// Here is how you use value-parameterized tests:
+
+#if 0
+
+// To write value-parameterized tests, first you should define a fixture
+// class. It is usually derived from testing::TestWithParam<T> (see below for
+// another inheritance scheme that's sometimes useful in more complicated
+// class hierarchies), where the type of your parameter values.
+// TestWithParam<T> is itself derived from testing::Test. T can be any
+// copyable type. If it's a raw pointer, you are responsible for managing the
+// lifespan of the pointed values.
+
+class FooTest : public ::testing::TestWithParam<const char*> {
+  // You can implement all the usual class fixture members here.
+};
+
+// Then, use the TEST_P macro to define as many parameterized tests
+// for this fixture as you want. The _P suffix is for "parameterized"
+// or "pattern", whichever you prefer to think.
+
+TEST_P(FooTest, DoesBlah) {
+  // Inside a test, access the test parameter with the GetParam() method
+  // of the TestWithParam<T> class:
+  EXPECT_TRUE(foo.Blah(GetParam()));
+  ...
+}
+
+TEST_P(FooTest, HasBlahBlah) {
+  ...
+}
+
+// Finally, you can use INSTANTIATE_TEST_SUITE_P to instantiate the test
+// case with any set of parameters you want. Google Test defines a number
+// of functions for generating test parameters. They return what we call
+// (surprise!) parameter generators. Here is a summary of them, which
+// are all in the testing namespace:
+//
+//
+//  Range(begin, end [, step]) - Yields values {begin, begin+step,
+//                               begin+step+step, ...}. The values do not
+//                               include end. step defaults to 1.
+//  Values(v1, v2, ..., vN)    - Yields values {v1, v2, ..., vN}.
+//  ValuesIn(container)        - Yields values from a C-style array, an STL
+//  ValuesIn(begin,end)          container, or an iterator range [begin, end).
+//  Bool()                     - Yields sequence {false, true}.
+//  Combine(g1, g2, ..., gN)   - Yields all combinations (the Cartesian product
+//                               for the math savvy) of the values generated
+//                               by the N generators.
+//
+// For more details, see comments at the definitions of these functions below
+// in this file.
+//
+// The following statement will instantiate tests from the FooTest test suite
+// each with parameter values "meeny", "miny", and "moe".
+
+INSTANTIATE_TEST_SUITE_P(InstantiationName,
+                         FooTest,
+                         Values("meeny", "miny", "moe"));
+
+// To distinguish different instances of the pattern, (yes, you
+// can instantiate it more than once) the first argument to the
+// INSTANTIATE_TEST_SUITE_P macro is a prefix that will be added to the
+// actual test suite name. Remember to pick unique prefixes for different
+// instantiations. The tests from the instantiation above will have
+// these names:
+//
+//    * InstantiationName/FooTest.DoesBlah/0 for "meeny"
+//    * InstantiationName/FooTest.DoesBlah/1 for "miny"
+//    * InstantiationName/FooTest.DoesBlah/2 for "moe"
+//    * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"
+//    * InstantiationName/FooTest.HasBlahBlah/1 for "miny"
+//    * InstantiationName/FooTest.HasBlahBlah/2 for "moe"
+//
+// You can use these names in --gtest_filter.
+//
+// This statement will instantiate all tests from FooTest again, each
+// with parameter values "cat" and "dog":
+
+const char* pets[] = {"cat", "dog"};
+INSTANTIATE_TEST_SUITE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));
+
+// The tests from the instantiation above will have these names:
+//
+//    * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"
+//    * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"
+//    * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"
+//    * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"
+//
+// Please note that INSTANTIATE_TEST_SUITE_P will instantiate all tests
+// in the given test suite, whether their definitions come before or
+// AFTER the INSTANTIATE_TEST_SUITE_P statement.
+//
+// Please also note that generator expressions (including parameters to the
+// generators) are evaluated in InitGoogleTest(), after main() has started.
+// This allows the user on one hand, to adjust generator parameters in order
+// to dynamically determine a set of tests to run and on the other hand,
+// give the user a chance to inspect the generated tests with Google Test
+// reflection API before RUN_ALL_TESTS() is executed.
+//
+// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc
+// for more examples.
+//
+// In the future, we plan to publish the API for defining new parameter
+// generators. But for now this interface remains part of the internal
+// implementation and is subject to change.
+//
+//
+// A parameterized test fixture must be derived from testing::Test and from
+// testing::WithParamInterface<T>, where T is the type of the parameter
+// values. Inheriting from TestWithParam<T> satisfies that requirement because
+// TestWithParam<T> inherits from both Test and WithParamInterface. In more
+// complicated hierarchies, however, it is occasionally useful to inherit
+// separately from Test and WithParamInterface. For example:
+
+class BaseTest : public ::testing::Test {
+  // You can inherit all the usual members for a non-parameterized test
+  // fixture here.
+};
+
+class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {
+  // The usual test fixture members go here too.
+};
+
+TEST_F(BaseTest, HasFoo) {
+  // This is an ordinary non-parameterized test.
+}
+
+TEST_P(DerivedTest, DoesBlah) {
+  // GetParam works just the same here as if you inherit from TestWithParam.
+  EXPECT_TRUE(foo.Blah(GetParam()));
+}
+
+#endif  // 0
+
+#include <iterator>
+#include <utility>
+
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-param-util.h"
+#include "gtest/internal/gtest-port.h"
+
+namespace testing {
+
+// Functions producing parameter generators.
+//
+// Google Test uses these generators to produce parameters for value-
+// parameterized tests. When a parameterized test suite is instantiated
+// with a particular generator, Google Test creates and runs tests
+// for each element in the sequence produced by the generator.
+//
+// In the following sample, tests from test suite FooTest are instantiated
+// each three times with parameter values 3, 5, and 8:
+//
+// class FooTest : public TestWithParam<int> { ... };
+//
+// TEST_P(FooTest, TestThis) {
+// }
+// TEST_P(FooTest, TestThat) {
+// }
+// INSTANTIATE_TEST_SUITE_P(TestSequence, FooTest, Values(3, 5, 8));
+//
+
+// Range() returns generators providing sequences of values in a range.
+//
+// Synopsis:
+// Range(start, end)
+//   - returns a generator producing a sequence of values {start, start+1,
+//     start+2, ..., }.
+// Range(start, end, step)
+//   - returns a generator producing a sequence of values {start, start+step,
+//     start+step+step, ..., }.
+// Notes:
+//   * The generated sequences never include end. For example, Range(1, 5)
+//     returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)
+//     returns a generator producing {1, 3, 5, 7}.
+//   * start and end must have the same type. That type may be any integral or
+//     floating-point type or a user defined type satisfying these conditions:
+//     * It must be assignable (have operator=() defined).
+//     * It must have operator+() (operator+(int-compatible type) for
+//       two-operand version).
+//     * It must have operator<() defined.
+//     Elements in the resulting sequences will also have that type.
+//   * Condition start < end must be satisfied in order for resulting sequences
+//     to contain any elements.
+//
+template <typename T, typename IncrementT>
+internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {
+  return internal::ParamGenerator<T>(
+      new internal::RangeGenerator<T, IncrementT>(start, end, step));
+}
+
+template <typename T>
+internal::ParamGenerator<T> Range(T start, T end) {
+  return Range(start, end, 1);
+}
+
+// ValuesIn() function allows generation of tests with parameters coming from
+// a container.
+//
+// Synopsis:
+// ValuesIn(const T (&array)[N])
+//   - returns a generator producing sequences with elements from
+//     a C-style array.
+// ValuesIn(const Container& container)
+//   - returns a generator producing sequences with elements from
+//     an STL-style container.
+// ValuesIn(Iterator begin, Iterator end)
+//   - returns a generator producing sequences with elements from
+//     a range [begin, end) defined by a pair of STL-style iterators. These
+//     iterators can also be plain C pointers.
+//
+// Please note that ValuesIn copies the values from the containers
+// passed in and keeps them to generate tests in RUN_ALL_TESTS().
+//
+// Examples:
+//
+// This instantiates tests from test suite StringTest
+// each with C-string values of "foo", "bar", and "baz":
+//
+// const char* strings[] = {"foo", "bar", "baz"};
+// INSTANTIATE_TEST_SUITE_P(StringSequence, StringTest, ValuesIn(strings));
+//
+// This instantiates tests from test suite StlStringTest
+// each with STL strings with values "a" and "b":
+//
+// ::std::vector< ::std::string> GetParameterStrings() {
+//   ::std::vector< ::std::string> v;
+//   v.push_back("a");
+//   v.push_back("b");
+//   return v;
+// }
+//
+// INSTANTIATE_TEST_SUITE_P(CharSequence,
+//                          StlStringTest,
+//                          ValuesIn(GetParameterStrings()));
+//
+//
+// This will also instantiate tests from CharTest
+// each with parameter values 'a' and 'b':
+//
+// ::std::list<char> GetParameterChars() {
+//   ::std::list<char> list;
+//   list.push_back('a');
+//   list.push_back('b');
+//   return list;
+// }
+// ::std::list<char> l = GetParameterChars();
+// INSTANTIATE_TEST_SUITE_P(CharSequence2,
+//                          CharTest,
+//                          ValuesIn(l.begin(), l.end()));
+//
+template <typename ForwardIterator>
+internal::ParamGenerator<
+    typename std::iterator_traits<ForwardIterator>::value_type>
+ValuesIn(ForwardIterator begin, ForwardIterator end) {
+  typedef typename std::iterator_traits<ForwardIterator>::value_type ParamType;
+  return internal::ParamGenerator<ParamType>(
+      new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));
+}
+
+template <typename T, size_t N>
+internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {
+  return ValuesIn(array, array + N);
+}
+
+template <class Container>
+internal::ParamGenerator<typename Container::value_type> ValuesIn(
+    const Container& container) {
+  return ValuesIn(container.begin(), container.end());
+}
+
+// Values() allows generating tests from explicitly specified list of
+// parameters.
+//
+// Synopsis:
+// Values(T v1, T v2, ..., T vN)
+//   - returns a generator producing sequences with elements v1, v2, ..., vN.
+//
+// For example, this instantiates tests from test suite BarTest each
+// with values "one", "two", and "three":
+//
+// INSTANTIATE_TEST_SUITE_P(NumSequence,
+//                          BarTest,
+//                          Values("one", "two", "three"));
+//
+// This instantiates tests from test suite BazTest each with values 1, 2, 3.5.
+// The exact type of values will depend on the type of parameter in BazTest.
+//
+// INSTANTIATE_TEST_SUITE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));
+//
+//
+template <typename... T>
+internal::ValueArray<T...> Values(T... v) {
+  return internal::ValueArray<T...>(std::move(v)...);
+}
+
+// Bool() allows generating tests with parameters in a set of (false, true).
+//
+// Synopsis:
+// Bool()
+//   - returns a generator producing sequences with elements {false, true}.
+//
+// It is useful when testing code that depends on Boolean flags. Combinations
+// of multiple flags can be tested when several Bool()'s are combined using
+// Combine() function.
+//
+// In the following example all tests in the test suite FlagDependentTest
+// will be instantiated twice with parameters false and true.
+//
+// class FlagDependentTest : public testing::TestWithParam<bool> {
+//   virtual void SetUp() {
+//     external_flag = GetParam();
+//   }
+// }
+// INSTANTIATE_TEST_SUITE_P(BoolSequence, FlagDependentTest, Bool());
+//
+inline internal::ParamGenerator<bool> Bool() {
+  return Values(false, true);
+}
+
+// Combine() allows the user to combine two or more sequences to produce
+// values of a Cartesian product of those sequences' elements.
+//
+// Synopsis:
+// Combine(gen1, gen2, ..., genN)
+//   - returns a generator producing sequences with elements coming from
+//     the Cartesian product of elements from the sequences generated by
+//     gen1, gen2, ..., genN. The sequence elements will have a type of
+//     std::tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types
+//     of elements from sequences produces by gen1, gen2, ..., genN.
+//
+// Example:
+//
+// This will instantiate tests in test suite AnimalTest each one with
+// the parameter values tuple("cat", BLACK), tuple("cat", WHITE),
+// tuple("dog", BLACK), and tuple("dog", WHITE):
+//
+// enum Color { BLACK, GRAY, WHITE };
+// class AnimalTest
+//     : public testing::TestWithParam<std::tuple<const char*, Color> > {...};
+//
+// TEST_P(AnimalTest, AnimalLooksNice) {...}
+//
+// INSTANTIATE_TEST_SUITE_P(AnimalVariations, AnimalTest,
+//                          Combine(Values("cat", "dog"),
+//                                  Values(BLACK, WHITE)));
+//
+// This will instantiate tests in FlagDependentTest with all variations of two
+// Boolean flags:
+//
+// class FlagDependentTest
+//     : public testing::TestWithParam<std::tuple<bool, bool> > {
+//   virtual void SetUp() {
+//     // Assigns external_flag_1 and external_flag_2 values from the tuple.
+//     std::tie(external_flag_1, external_flag_2) = GetParam();
+//   }
+// };
+//
+// TEST_P(FlagDependentTest, TestFeature1) {
+//   // Test your code using external_flag_1 and external_flag_2 here.
+// }
+// INSTANTIATE_TEST_SUITE_P(TwoBoolSequence, FlagDependentTest,
+//                          Combine(Bool(), Bool()));
+//
+template <typename... Generator>
+internal::CartesianProductHolder<Generator...> Combine(const Generator&... g) {
+  return internal::CartesianProductHolder<Generator...>(g...);
+}
+
+#define TEST_P(test_suite_name, test_name)                                     \
+  class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                     \
+      : public test_suite_name {                                               \
+   public:                                                                     \
+    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() {}                    \
+    void TestBody() override;                                                  \
+                                                                               \
+   private:                                                                    \
+    static int AddToRegistry() {                                               \
+      ::testing::UnitTest::GetInstance()                                       \
+          ->parameterized_test_registry()                                      \
+          .GetTestSuitePatternHolder<test_suite_name>(                         \
+              GTEST_STRINGIFY_(test_suite_name),                               \
+              ::testing::internal::CodeLocation(__FILE__, __LINE__))           \
+          ->AddTestPattern(                                                    \
+              GTEST_STRINGIFY_(test_suite_name), GTEST_STRINGIFY_(test_name),  \
+              new ::testing::internal::TestMetaFactory<GTEST_TEST_CLASS_NAME_( \
+                  test_suite_name, test_name)>(),                              \
+              ::testing::internal::CodeLocation(__FILE__, __LINE__));          \
+      return 0;                                                                \
+    }                                                                          \
+    static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_;               \
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,    \
+                                                           test_name));        \
+  };                                                                           \
+  int GTEST_TEST_CLASS_NAME_(test_suite_name,                                  \
+                             test_name)::gtest_registering_dummy_ =            \
+      GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::AddToRegistry();     \
+  void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()
+
+// The last argument to INSTANTIATE_TEST_SUITE_P allows the user to specify
+// generator and an optional function or functor that generates custom test name
+// suffixes based on the test parameters. Such a function or functor should
+// accept one argument of type testing::TestParamInfo<class ParamType>, and
+// return std::string.
+//
+// testing::PrintToStringParamName is a builtin test suffix generator that
+// returns the value of testing::PrintToString(GetParam()).
+//
+// Note: test names must be non-empty, unique, and may only contain ASCII
+// alphanumeric characters or underscore. Because PrintToString adds quotes
+// to std::string and C strings, it won't work for these types.
+
+#define GTEST_EXPAND_(arg) arg
+#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),                                   \
+                  &gtest_##prefix##test_suite_name##_EvalGenerator_,          \
+                  &gtest_##prefix##test_suite_name##_EvalGenerateName_,       \
+                  __FILE__, __LINE__)
+
+
+// Allow Marking a Parameterized test class as not needing to be instantiated.
+#define GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(T)                   \
+  namespace gtest_do_not_use_outside_namespace_scope {}                   \
+  static const ::testing::internal::MarkAsIgnored gtest_allow_ignore_##T( \
+      GTEST_STRINGIFY_(T))
+
+// Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#define INSTANTIATE_TEST_CASE_P                                            \
+  static_assert(::testing::internal::InstantiateTestCase_P_IsDeprecated(), \
+                "");                                                       \
+  INSTANTIATE_TEST_SUITE_P
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-printers.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-printers.h
new file mode 100644
index 000000000..076c9de1f
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-printers.h
@@ -0,0 +1,1029 @@
+// Copyright 2007, 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.
+
+
+// Google Test - The Google C++ Testing and Mocking Framework
+//
+// This file implements a universal value printer that can print a
+// value of any type T:
+//
+//   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
+//
+// A user can teach this function how to print a class type T by
+// defining either operator<<() or PrintTo() in the namespace that
+// defines T.  More specifically, the FIRST defined function in the
+// following list will be used (assuming T is defined in namespace
+// foo):
+//
+//   1. foo::PrintTo(const T&, ostream*)
+//   2. operator<<(ostream&, const T&) defined in either foo or the
+//      global namespace.
+//
+// However if T is an STL-style container then it is printed element-wise
+// unless foo::PrintTo(const T&, ostream*) is defined. Note that
+// operator<<() is ignored for container types.
+//
+// If none of the above is defined, it will print the debug string of
+// the value if it is a protocol buffer, or print the raw bytes in the
+// value otherwise.
+//
+// To aid debugging: when T is a reference type, the address of the
+// value is also printed; when T is a (const) char pointer, both the
+// pointer value and the NUL-terminated string it points to are
+// printed.
+//
+// We also provide some convenient wrappers:
+//
+//   // Prints a value to a string.  For a (const or not) char
+//   // pointer, the NUL-terminated string (but not the pointer) is
+//   // printed.
+//   std::string ::testing::PrintToString(const T& value);
+//
+//   // Prints a value tersely: for a reference type, the referenced
+//   // value (but not the address) is printed; for a (const or not) char
+//   // pointer, the NUL-terminated string (but not the pointer) is
+//   // printed.
+//   void ::testing::internal::UniversalTersePrint(const T& value, ostream*);
+//
+//   // Prints value using the type inferred by the compiler.  The difference
+//   // from UniversalTersePrint() is that this function prints both the
+//   // pointer and the NUL-terminated string for a (const or not) char pointer.
+//   void ::testing::internal::UniversalPrint(const T& value, ostream*);
+//
+//   // Prints the fields of a tuple tersely to a string vector, one
+//   // element for each field. Tuple support must be enabled in
+//   // gtest-port.h.
+//   std::vector<string> UniversalTersePrintTupleFieldsToStrings(
+//       const Tuple& value);
+//
+// Known limitation:
+//
+// The print primitives print the elements of an STL-style container
+// using the compiler-inferred type of *iter where iter is a
+// const_iterator of the container.  When const_iterator is an input
+// iterator but not a forward iterator, this inferred type may not
+// match value_type, and the print output may be incorrect.  In
+// practice, this is rarely a problem as for most containers
+// const_iterator is a forward iterator.  We'll fix this if there's an
+// actual need for it.  Note that this fix cannot rely on value_type
+// being defined as many user-defined container types don't have
+// value_type.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
+
+#include <functional>
+#include <memory>
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-port.h"
+
+namespace testing {
+
+// Definitions in the internal* namespaces are subject to change without notice.
+// DO NOT USE THEM IN USER CODE!
+namespace internal {
+
+template <typename T>
+void UniversalPrint(const T& value, ::std::ostream* os);
+
+// Used to print an STL-style container when the user doesn't define
+// a PrintTo() for it.
+struct ContainerPrinter {
+  template <typename T,
+            typename = typename std::enable_if<
+                (sizeof(IsContainerTest<T>(0)) == sizeof(IsContainer)) &&
+                !IsRecursiveContainer<T>::value>::type>
+  static void PrintValue(const T& container, std::ostream* os) {
+    const size_t kMaxCount = 32;  // The maximum number of elements to print.
+    *os << '{';
+    size_t count = 0;
+    for (auto&& elem : container) {
+      if (count > 0) {
+        *os << ',';
+        if (count == kMaxCount) {  // Enough has been printed.
+          *os << " ...";
+          break;
+        }
+      }
+      *os << ' ';
+      // We cannot call PrintTo(elem, os) here as PrintTo() doesn't
+      // handle `elem` being a native array.
+      internal::UniversalPrint(elem, os);
+      ++count;
+    }
+
+    if (count > 0) {
+      *os << ' ';
+    }
+    *os << '}';
+  }
+};
+
+// Used to print a pointer that is neither a char pointer nor a member
+// pointer, when the user doesn't define PrintTo() for it.  (A member
+// variable pointer or member function pointer doesn't really point to
+// a location in the address space.  Their representation is
+// implementation-defined.  Therefore they will be printed as raw
+// bytes.)
+struct FunctionPointerPrinter {
+  template <typename T, typename = typename std::enable_if<
+                            std::is_function<T>::value>::type>
+  static void PrintValue(T* p, ::std::ostream* os) {
+    if (p == nullptr) {
+      *os << "NULL";
+    } else {
+      // T is a function type, so '*os << p' doesn't do what we want
+      // (it just prints p as bool).  We want to print p as a const
+      // void*.
+      *os << reinterpret_cast<const void*>(p);
+    }
+  }
+};
+
+struct PointerPrinter {
+  template <typename T>
+  static void PrintValue(T* p, ::std::ostream* os) {
+    if (p == nullptr) {
+      *os << "NULL";
+    } else {
+      // T is not a function type.  We just call << to print p,
+      // relying on ADL to pick up user-defined << for their pointer
+      // types, if any.
+      *os << p;
+    }
+  }
+};
+
+namespace internal_stream_operator_without_lexical_name_lookup {
+
+// The presence of an operator<< here will terminate lexical scope lookup
+// straight away (even though it cannot be a match because of its argument
+// types). Thus, the two operator<< calls in StreamPrinter will find only ADL
+// candidates.
+struct LookupBlocker {};
+void operator<<(LookupBlocker, LookupBlocker);
+
+struct StreamPrinter {
+  template <typename T,
+            // Don't accept member pointers here. We'd print them via implicit
+            // conversion to bool, which isn't useful.
+            typename = typename std::enable_if<
+                !std::is_member_pointer<T>::value>::type,
+            // Only accept types for which we can find a streaming operator via
+            // ADL (possibly involving implicit conversions).
+            typename = decltype(std::declval<std::ostream&>()
+                                << std::declval<const T&>())>
+  static void PrintValue(const T& value, ::std::ostream* os) {
+    // Call streaming operator found by ADL, possibly with implicit conversions
+    // of the arguments.
+    *os << value;
+  }
+};
+
+}  // namespace internal_stream_operator_without_lexical_name_lookup
+
+struct ProtobufPrinter {
+  // We print a protobuf using its ShortDebugString() when the string
+  // doesn't exceed this many characters; otherwise we print it using
+  // DebugString() for better readability.
+  static const size_t kProtobufOneLinerMaxLength = 50;
+
+  template <typename T,
+            typename = typename std::enable_if<
+                internal::HasDebugStringAndShortDebugString<T>::value>::type>
+  static void PrintValue(const T& value, ::std::ostream* os) {
+    std::string pretty_str = value.ShortDebugString();
+    if (pretty_str.length() > kProtobufOneLinerMaxLength) {
+      pretty_str = "\n" + value.DebugString();
+    }
+    *os << ("<" + pretty_str + ">");
+  }
+};
+
+struct ConvertibleToIntegerPrinter {
+  // Since T has no << operator or PrintTo() but can be implicitly
+  // converted to BiggestInt, we print it as a BiggestInt.
+  //
+  // Most likely T is an enum type (either named or unnamed), in which
+  // case printing it as an integer is the desired behavior.  In case
+  // T is not an enum, printing it as an integer is the best we can do
+  // given that it has no user-defined printer.
+  static void PrintValue(internal::BiggestInt value, ::std::ostream* os) {
+    *os << value;
+  }
+};
+
+struct ConvertibleToStringViewPrinter {
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+  static void PrintValue(internal::StringView value, ::std::ostream* os) {
+    internal::UniversalPrint(value, os);
+  }
+#endif
+};
+
+
+// Prints the given number of bytes in the given object to the given
+// ostream.
+GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes,
+                                     size_t count,
+                                     ::std::ostream* os);
+struct RawBytesPrinter {
+  // SFINAE on `sizeof` to make sure we have a complete type.
+  template <typename T, size_t = sizeof(T)>
+  static void PrintValue(const T& value, ::std::ostream* os) {
+    PrintBytesInObjectTo(
+        static_cast<const unsigned char*>(
+            // Load bearing cast to void* to support iOS
+            reinterpret_cast<const void*>(std::addressof(value))),
+        sizeof(value), os);
+  }
+};
+
+struct FallbackPrinter {
+  template <typename T>
+  static void PrintValue(const T&, ::std::ostream* os) {
+    *os << "(incomplete type)";
+  }
+};
+
+// Try every printer in order and return the first one that works.
+template <typename T, typename E, typename Printer, typename... Printers>
+struct FindFirstPrinter : FindFirstPrinter<T, E, Printers...> {};
+
+template <typename T, typename Printer, typename... Printers>
+struct FindFirstPrinter<
+    T, decltype(Printer::PrintValue(std::declval<const T&>(), nullptr)),
+    Printer, Printers...> {
+  using type = Printer;
+};
+
+// Select the best printer in the following order:
+//  - Print containers (they have begin/end/etc).
+//  - Print function pointers.
+//  - Print object pointers.
+//  - Use the stream operator, if available.
+//  - Print protocol buffers.
+//  - Print types convertible to BiggestInt.
+//  - Print types convertible to StringView, if available.
+//  - Fallback to printing the raw bytes of the object.
+template <typename T>
+void PrintWithFallback(const T& value, ::std::ostream* os) {
+  using Printer = typename FindFirstPrinter<
+      T, void, ContainerPrinter, FunctionPointerPrinter, PointerPrinter,
+      internal_stream_operator_without_lexical_name_lookup::StreamPrinter,
+      ProtobufPrinter, ConvertibleToIntegerPrinter,
+      ConvertibleToStringViewPrinter, RawBytesPrinter, FallbackPrinter>::type;
+  Printer::PrintValue(value, os);
+}
+
+// FormatForComparison<ToPrint, OtherOperand>::Format(value) formats a
+// value of type ToPrint that is an operand of a comparison assertion
+// (e.g. ASSERT_EQ).  OtherOperand is the type of the other operand in
+// the comparison, and is used to help determine the best way to
+// format the value.  In particular, when the value is a C string
+// (char pointer) and the other operand is an STL string object, we
+// want to format the C string as a string, since we know it is
+// compared by value with the string object.  If the value is a char
+// pointer but the other operand is not an STL string object, we don't
+// know whether the pointer is supposed to point to a NUL-terminated
+// string, and thus want to print it as a pointer to be safe.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+
+// The default case.
+template <typename ToPrint, typename OtherOperand>
+class FormatForComparison {
+ public:
+  static ::std::string Format(const ToPrint& value) {
+    return ::testing::PrintToString(value);
+  }
+};
+
+// Array.
+template <typename ToPrint, size_t N, typename OtherOperand>
+class FormatForComparison<ToPrint[N], OtherOperand> {
+ public:
+  static ::std::string Format(const ToPrint* value) {
+    return FormatForComparison<const ToPrint*, OtherOperand>::Format(value);
+  }
+};
+
+// By default, print C string as pointers to be safe, as we don't know
+// whether they actually point to a NUL-terminated string.
+
+#define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType)                \
+  template <typename OtherOperand>                                      \
+  class FormatForComparison<CharType*, OtherOperand> {                  \
+   public:                                                              \
+    static ::std::string Format(CharType* value) {                      \
+      return ::testing::PrintToString(static_cast<const void*>(value)); \
+    }                                                                   \
+  }
+
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t);
+#ifdef __cpp_char8_t
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char8_t);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char8_t);
+#endif
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char16_t);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char16_t);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char32_t);
+GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char32_t);
+
+#undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_
+
+// If a C string is compared with an STL string object, we know it's meant
+// to point to a NUL-terminated string, and thus can print it as a string.
+
+#define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \
+  template <>                                                           \
+  class FormatForComparison<CharType*, OtherStringType> {               \
+   public:                                                              \
+    static ::std::string Format(CharType* value) {                      \
+      return ::testing::PrintToString(value);                           \
+    }                                                                   \
+  }
+
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string);
+#ifdef __cpp_char8_t
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char8_t, ::std::u8string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char8_t, ::std::u8string);
+#endif
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char16_t, ::std::u16string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char16_t, ::std::u16string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char32_t, ::std::u32string);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char32_t, ::std::u32string);
+
+#if GTEST_HAS_STD_WSTRING
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring);
+GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring);
+#endif
+
+#undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_
+
+// Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc)
+// operand to be used in a failure message.  The type (but not value)
+// of the other operand may affect the format.  This allows us to
+// print a char* as a raw pointer when it is compared against another
+// char* or void*, and print it as a C string when it is compared
+// against an std::string object, for example.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+template <typename T1, typename T2>
+std::string FormatForComparisonFailureMessage(
+    const T1& value, const T2& /* other_operand */) {
+  return FormatForComparison<T1, T2>::Format(value);
+}
+
+// UniversalPrinter<T>::Print(value, ostream_ptr) prints the given
+// value to the given ostream.  The caller must ensure that
+// 'ostream_ptr' is not NULL, or the behavior is undefined.
+//
+// We define UniversalPrinter as a class template (as opposed to a
+// function template), as we need to partially specialize it for
+// reference types, which cannot be done with function templates.
+template <typename T>
+class UniversalPrinter;
+
+// Prints the given value using the << operator if it has one;
+// otherwise prints the bytes in it.  This is what
+// UniversalPrinter<T>::Print() does when PrintTo() is not specialized
+// or overloaded for type T.
+//
+// A user can override this behavior for a class type Foo by defining
+// an overload of PrintTo() in the namespace where Foo is defined.  We
+// give the user this option as sometimes defining a << operator for
+// Foo is not desirable (e.g. the coding style may prevent doing it,
+// or there is already a << operator but it doesn't do what the user
+// wants).
+template <typename T>
+void PrintTo(const T& value, ::std::ostream* os) {
+  internal::PrintWithFallback(value, os);
+}
+
+// The following list of PrintTo() overloads tells
+// UniversalPrinter<T>::Print() how to print standard types (built-in
+// types, strings, plain arrays, and pointers).
+
+// Overloads for various char types.
+GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os);
+GTEST_API_ void PrintTo(signed char c, ::std::ostream* os);
+inline void PrintTo(char c, ::std::ostream* os) {
+  // When printing a plain char, we always treat it as unsigned.  This
+  // way, the output won't be affected by whether the compiler thinks
+  // char is signed or not.
+  PrintTo(static_cast<unsigned char>(c), os);
+}
+
+// Overloads for other simple built-in types.
+inline void PrintTo(bool x, ::std::ostream* os) {
+  *os << (x ? "true" : "false");
+}
+
+// Overload for wchar_t type.
+// Prints a wchar_t as a symbol if it is printable or as its internal
+// code otherwise and also as its decimal code (except for L'\0').
+// The L'\0' char is printed as "L'\\0'". The decimal code is printed
+// as signed integer when wchar_t is implemented by the compiler
+// as a signed type and is printed as an unsigned integer when wchar_t
+// is implemented as an unsigned type.
+GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os);
+
+GTEST_API_ void PrintTo(char32_t c, ::std::ostream* os);
+inline void PrintTo(char16_t c, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<char32_t>(c), os);
+}
+#ifdef __cpp_char8_t
+inline void PrintTo(char8_t c, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<char32_t>(c), os);
+}
+#endif
+
+// Overloads for C strings.
+GTEST_API_ void PrintTo(const char* s, ::std::ostream* os);
+inline void PrintTo(char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const char*>(s), os);
+}
+
+// signed/unsigned char is often used for representing binary data, so
+// we print pointers to it as void* to be safe.
+inline void PrintTo(const signed char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+inline void PrintTo(signed char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+inline void PrintTo(unsigned char* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const void*>(s), os);
+}
+#ifdef __cpp_char8_t
+// Overloads for u8 strings.
+GTEST_API_ void PrintTo(const char8_t* s, ::std::ostream* os);
+inline void PrintTo(char8_t* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const char8_t*>(s), os);
+}
+#endif
+// Overloads for u16 strings.
+GTEST_API_ void PrintTo(const char16_t* s, ::std::ostream* os);
+inline void PrintTo(char16_t* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const char16_t*>(s), os);
+}
+// Overloads for u32 strings.
+GTEST_API_ void PrintTo(const char32_t* s, ::std::ostream* os);
+inline void PrintTo(char32_t* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const char32_t*>(s), os);
+}
+
+// MSVC can be configured to define wchar_t as a typedef of unsigned
+// short.  It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native
+// type.  When wchar_t is a typedef, defining an overload for const
+// wchar_t* would cause unsigned short* be printed as a wide string,
+// possibly causing invalid memory accesses.
+#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
+// Overloads for wide C strings
+GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os);
+inline void PrintTo(wchar_t* s, ::std::ostream* os) {
+  PrintTo(ImplicitCast_<const wchar_t*>(s), os);
+}
+#endif
+
+// Overload for C arrays.  Multi-dimensional arrays are printed
+// properly.
+
+// Prints the given number of elements in an array, without printing
+// the curly braces.
+template <typename T>
+void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) {
+  UniversalPrint(a[0], os);
+  for (size_t i = 1; i != count; i++) {
+    *os << ", ";
+    UniversalPrint(a[i], os);
+  }
+}
+
+// Overloads for ::std::string.
+GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os);
+inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
+  PrintStringTo(s, os);
+}
+
+// Overloads for ::std::u8string
+#ifdef __cpp_char8_t
+GTEST_API_ void PrintU8StringTo(const ::std::u8string& s, ::std::ostream* os);
+inline void PrintTo(const ::std::u8string& s, ::std::ostream* os) {
+  PrintU8StringTo(s, os);
+}
+#endif
+
+// Overloads for ::std::u16string
+GTEST_API_ void PrintU16StringTo(const ::std::u16string& s, ::std::ostream* os);
+inline void PrintTo(const ::std::u16string& s, ::std::ostream* os) {
+  PrintU16StringTo(s, os);
+}
+
+// Overloads for ::std::u32string
+GTEST_API_ void PrintU32StringTo(const ::std::u32string& s, ::std::ostream* os);
+inline void PrintTo(const ::std::u32string& s, ::std::ostream* os) {
+  PrintU32StringTo(s, os);
+}
+
+// Overloads for ::std::wstring.
+#if GTEST_HAS_STD_WSTRING
+GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os);
+inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
+  PrintWideStringTo(s, os);
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+// Overload for internal::StringView.
+inline void PrintTo(internal::StringView sp, ::std::ostream* os) {
+  PrintTo(::std::string(sp), os);
+}
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os << "(nullptr)"; }
+
+template <typename T>
+void PrintTo(std::reference_wrapper<T> ref, ::std::ostream* os) {
+  UniversalPrinter<T&>::Print(ref.get(), os);
+}
+
+inline const void* VoidifyPointer(const void* p) { return p; }
+inline const void* VoidifyPointer(volatile const void* p) {
+  return const_cast<const void*>(p);
+}
+
+template <typename T, typename Ptr>
+void PrintSmartPointer(const Ptr& ptr, std::ostream* os, char) {
+  if (ptr == nullptr) {
+    *os << "(nullptr)";
+  } else {
+    // We can't print the value. Just print the pointer..
+    *os << "(" << (VoidifyPointer)(ptr.get()) << ")";
+  }
+}
+template <typename T, typename Ptr,
+          typename = typename std::enable_if<!std::is_void<T>::value &&
+                                             !std::is_array<T>::value>::type>
+void PrintSmartPointer(const Ptr& ptr, std::ostream* os, int) {
+  if (ptr == nullptr) {
+    *os << "(nullptr)";
+  } else {
+    *os << "(ptr = " << (VoidifyPointer)(ptr.get()) << ", value = ";
+    UniversalPrinter<T>::Print(*ptr, os);
+    *os << ")";
+  }
+}
+
+template <typename T, typename D>
+void PrintTo(const std::unique_ptr<T, D>& ptr, std::ostream* os) {
+  (PrintSmartPointer<T>)(ptr, os, 0);
+}
+
+template <typename T>
+void PrintTo(const std::shared_ptr<T>& ptr, std::ostream* os) {
+  (PrintSmartPointer<T>)(ptr, os, 0);
+}
+
+// Helper function for printing a tuple.  T must be instantiated with
+// a tuple type.
+template <typename T>
+void PrintTupleTo(const T&, std::integral_constant<size_t, 0>,
+                  ::std::ostream*) {}
+
+template <typename T, size_t I>
+void PrintTupleTo(const T& t, std::integral_constant<size_t, I>,
+                  ::std::ostream* os) {
+  PrintTupleTo(t, std::integral_constant<size_t, I - 1>(), os);
+  GTEST_INTENTIONAL_CONST_COND_PUSH_()
+  if (I > 1) {
+    GTEST_INTENTIONAL_CONST_COND_POP_()
+    *os << ", ";
+  }
+  UniversalPrinter<typename std::tuple_element<I - 1, T>::type>::Print(
+      std::get<I - 1>(t), os);
+}
+
+template <typename... Types>
+void PrintTo(const ::std::tuple<Types...>& t, ::std::ostream* os) {
+  *os << "(";
+  PrintTupleTo(t, std::integral_constant<size_t, sizeof...(Types)>(), os);
+  *os << ")";
+}
+
+// Overload for std::pair.
+template <typename T1, typename T2>
+void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) {
+  *os << '(';
+  // We cannot use UniversalPrint(value.first, os) here, as T1 may be
+  // a reference type.  The same for printing value.second.
+  UniversalPrinter<T1>::Print(value.first, os);
+  *os << ", ";
+  UniversalPrinter<T2>::Print(value.second, os);
+  *os << ')';
+}
+
+// Implements printing a non-reference type T by letting the compiler
+// pick the right overload of PrintTo() for T.
+template <typename T>
+class UniversalPrinter {
+ public:
+  // MSVC warns about adding const to a function type, so we want to
+  // disable the warning.
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)
+
+  // Note: we deliberately don't call this PrintTo(), as that name
+  // conflicts with ::testing::internal::PrintTo in the body of the
+  // function.
+  static void Print(const T& value, ::std::ostream* os) {
+    // By default, ::testing::internal::PrintTo() is used for printing
+    // the value.
+    //
+    // Thanks to Koenig look-up, if T is a class and has its own
+    // PrintTo() function defined in its namespace, that function will
+    // be visible here.  Since it is more specific than the generic ones
+    // in ::testing::internal, it will be picked by the compiler in the
+    // following statement - exactly what we want.
+    PrintTo(value, os);
+  }
+
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+};
+
+// Remove any const-qualifiers before passing a type to UniversalPrinter.
+template <typename T>
+class UniversalPrinter<const T> : public UniversalPrinter<T> {};
+
+#if GTEST_INTERNAL_HAS_ANY
+
+// Printer for std::any / absl::any
+
+template <>
+class UniversalPrinter<Any> {
+ public:
+  static void Print(const Any& value, ::std::ostream* os) {
+    if (value.has_value()) {
+      *os << "value of type " << GetTypeName(value);
+    } else {
+      *os << "no value";
+    }
+  }
+
+ private:
+  static std::string GetTypeName(const Any& value) {
+#if GTEST_HAS_RTTI
+    return internal::GetTypeName(value.type());
+#else
+    static_cast<void>(value);  // possibly unused
+    return "<unknown_type>";
+#endif  // GTEST_HAS_RTTI
+  }
+};
+
+#endif  // GTEST_INTERNAL_HAS_ANY
+
+#if GTEST_INTERNAL_HAS_OPTIONAL
+
+// Printer for std::optional / absl::optional
+
+template <typename T>
+class UniversalPrinter<Optional<T>> {
+ public:
+  static void Print(const Optional<T>& value, ::std::ostream* os) {
+    *os << '(';
+    if (!value) {
+      *os << "nullopt";
+    } else {
+      UniversalPrint(*value, os);
+    }
+    *os << ')';
+  }
+};
+
+#endif  // GTEST_INTERNAL_HAS_OPTIONAL
+
+#if GTEST_INTERNAL_HAS_VARIANT
+
+// Printer for std::variant / absl::variant
+
+template <typename... T>
+class UniversalPrinter<Variant<T...>> {
+ public:
+  static void Print(const Variant<T...>& value, ::std::ostream* os) {
+    *os << '(';
+#if GTEST_HAS_ABSL
+    absl::visit(Visitor{os, value.index()}, value);
+#else
+    std::visit(Visitor{os, value.index()}, value);
+#endif  // GTEST_HAS_ABSL
+    *os << ')';
+  }
+
+ private:
+  struct Visitor {
+    template <typename U>
+    void operator()(const U& u) const {
+      *os << "'" << GetTypeName<U>() << "(index = " << index
+          << ")' with value ";
+      UniversalPrint(u, os);
+    }
+    ::std::ostream* os;
+    std::size_t index;
+  };
+};
+
+#endif  // GTEST_INTERNAL_HAS_VARIANT
+
+// UniversalPrintArray(begin, len, os) prints an array of 'len'
+// elements, starting at address 'begin'.
+template <typename T>
+void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) {
+  if (len == 0) {
+    *os << "{}";
+  } else {
+    *os << "{ ";
+    const size_t kThreshold = 18;
+    const size_t kChunkSize = 8;
+    // If the array has more than kThreshold elements, we'll have to
+    // omit some details by printing only the first and the last
+    // kChunkSize elements.
+    if (len <= kThreshold) {
+      PrintRawArrayTo(begin, len, os);
+    } else {
+      PrintRawArrayTo(begin, kChunkSize, os);
+      *os << ", ..., ";
+      PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os);
+    }
+    *os << " }";
+  }
+}
+// This overload prints a (const) char array compactly.
+GTEST_API_ void UniversalPrintArray(
+    const char* begin, size_t len, ::std::ostream* os);
+
+#ifdef __cpp_char8_t
+// This overload prints a (const) char8_t array compactly.
+GTEST_API_ void UniversalPrintArray(const char8_t* begin, size_t len,
+                                    ::std::ostream* os);
+#endif
+
+// This overload prints a (const) char16_t array compactly.
+GTEST_API_ void UniversalPrintArray(const char16_t* begin, size_t len,
+                                    ::std::ostream* os);
+
+// This overload prints a (const) char32_t array compactly.
+GTEST_API_ void UniversalPrintArray(const char32_t* begin, size_t len,
+                                    ::std::ostream* os);
+
+// This overload prints a (const) wchar_t array compactly.
+GTEST_API_ void UniversalPrintArray(
+    const wchar_t* begin, size_t len, ::std::ostream* os);
+
+// Implements printing an array type T[N].
+template <typename T, size_t N>
+class UniversalPrinter<T[N]> {
+ public:
+  // Prints the given array, omitting some elements when there are too
+  // many.
+  static void Print(const T (&a)[N], ::std::ostream* os) {
+    UniversalPrintArray(a, N, os);
+  }
+};
+
+// Implements printing a reference type T&.
+template <typename T>
+class UniversalPrinter<T&> {
+ public:
+  // MSVC warns about adding const to a function type, so we want to
+  // disable the warning.
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4180)
+
+  static void Print(const T& value, ::std::ostream* os) {
+    // Prints the address of the value.  We use reinterpret_cast here
+    // as static_cast doesn't compile when T is a function type.
+    *os << "@" << reinterpret_cast<const void*>(&value) << " ";
+
+    // Then prints the value itself.
+    UniversalPrint(value, os);
+  }
+
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+};
+
+// Prints a value tersely: for a reference type, the referenced value
+// (but not the address) is printed; for a (const) char pointer, the
+// NUL-terminated string (but not the pointer) is printed.
+
+template <typename T>
+class UniversalTersePrinter {
+ public:
+  static void Print(const T& value, ::std::ostream* os) {
+    UniversalPrint(value, os);
+  }
+};
+template <typename T>
+class UniversalTersePrinter<T&> {
+ public:
+  static void Print(const T& value, ::std::ostream* os) {
+    UniversalPrint(value, os);
+  }
+};
+template <typename T, size_t N>
+class UniversalTersePrinter<T[N]> {
+ public:
+  static void Print(const T (&value)[N], ::std::ostream* os) {
+    UniversalPrinter<T[N]>::Print(value, os);
+  }
+};
+template <>
+class UniversalTersePrinter<const char*> {
+ public:
+  static void Print(const char* str, ::std::ostream* os) {
+    if (str == nullptr) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(std::string(str), os);
+    }
+  }
+};
+template <>
+class UniversalTersePrinter<char*> : public UniversalTersePrinter<const char*> {
+};
+
+#ifdef __cpp_char8_t
+template <>
+class UniversalTersePrinter<const char8_t*> {
+ public:
+  static void Print(const char8_t* str, ::std::ostream* os) {
+    if (str == nullptr) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(::std::u8string(str), os);
+    }
+  }
+};
+template <>
+class UniversalTersePrinter<char8_t*>
+    : public UniversalTersePrinter<const char8_t*> {};
+#endif
+
+template <>
+class UniversalTersePrinter<const char16_t*> {
+ public:
+  static void Print(const char16_t* str, ::std::ostream* os) {
+    if (str == nullptr) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(::std::u16string(str), os);
+    }
+  }
+};
+template <>
+class UniversalTersePrinter<char16_t*>
+    : public UniversalTersePrinter<const char16_t*> {};
+
+template <>
+class UniversalTersePrinter<const char32_t*> {
+ public:
+  static void Print(const char32_t* str, ::std::ostream* os) {
+    if (str == nullptr) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(::std::u32string(str), os);
+    }
+  }
+};
+template <>
+class UniversalTersePrinter<char32_t*>
+    : public UniversalTersePrinter<const char32_t*> {};
+
+#if GTEST_HAS_STD_WSTRING
+template <>
+class UniversalTersePrinter<const wchar_t*> {
+ public:
+  static void Print(const wchar_t* str, ::std::ostream* os) {
+    if (str == nullptr) {
+      *os << "NULL";
+    } else {
+      UniversalPrint(::std::wstring(str), os);
+    }
+  }
+};
+#endif
+
+template <>
+class UniversalTersePrinter<wchar_t*> {
+ public:
+  static void Print(wchar_t* str, ::std::ostream* os) {
+    UniversalTersePrinter<const wchar_t*>::Print(str, os);
+  }
+};
+
+template <typename T>
+void UniversalTersePrint(const T& value, ::std::ostream* os) {
+  UniversalTersePrinter<T>::Print(value, os);
+}
+
+// Prints a value using the type inferred by the compiler.  The
+// difference between this and UniversalTersePrint() is that for a
+// (const) char pointer, this prints both the pointer and the
+// NUL-terminated string.
+template <typename T>
+void UniversalPrint(const T& value, ::std::ostream* os) {
+  // A workarond for the bug in VC++ 7.1 that prevents us from instantiating
+  // UniversalPrinter with T directly.
+  typedef T T1;
+  UniversalPrinter<T1>::Print(value, os);
+}
+
+typedef ::std::vector< ::std::string> Strings;
+
+  // Tersely prints the first N fields of a tuple to a string vector,
+  // one element for each field.
+template <typename Tuple>
+void TersePrintPrefixToStrings(const Tuple&, std::integral_constant<size_t, 0>,
+                               Strings*) {}
+template <typename Tuple, size_t I>
+void TersePrintPrefixToStrings(const Tuple& t,
+                               std::integral_constant<size_t, I>,
+                               Strings* strings) {
+  TersePrintPrefixToStrings(t, std::integral_constant<size_t, I - 1>(),
+                            strings);
+  ::std::stringstream ss;
+  UniversalTersePrint(std::get<I - 1>(t), &ss);
+  strings->push_back(ss.str());
+}
+
+// Prints the fields of a tuple tersely to a string vector, one
+// element for each field.  See the comment before
+// UniversalTersePrint() for how we define "tersely".
+template <typename Tuple>
+Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) {
+  Strings result;
+  TersePrintPrefixToStrings(
+      value, std::integral_constant<size_t, std::tuple_size<Tuple>::value>(),
+      &result);
+  return result;
+}
+
+}  // namespace internal
+
+template <typename T>
+::std::string PrintToString(const T& value) {
+  ::std::stringstream ss;
+  internal::UniversalTersePrinter<T>::Print(value, &ss);
+  return ss.str();
+}
+
+}  // namespace testing
+
+// Include any custom printer added by the local installation.
+// We must include this header at the end to make sure it can use the
+// declarations from this file.
+#include "gtest/internal/custom/gtest-printers.h"
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-spi.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-spi.h
new file mode 100644
index 000000000..eacef4466
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-spi.h
@@ -0,0 +1,238 @@
+// Copyright 2007, 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.
+
+//
+// Utilities for testing Google Test itself and code that uses Google Test
+// (e.g. frameworks built on top of Google Test).
+
+// GOOGLETEST_CM0004 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
+
+#include "gtest/gtest.h"
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// This helper class can be used to mock out Google Test failure reporting
+// so that we can test Google Test or code that builds on Google Test.
+//
+// An object of this class appends a TestPartResult object to the
+// TestPartResultArray object given in the constructor whenever a Google Test
+// failure is reported. It can either intercept only failures that are
+// generated in the same thread that created this object or it can intercept
+// all generated failures. The scope of this mock object can be controlled with
+// the second argument to the two arguments constructor.
+class GTEST_API_ ScopedFakeTestPartResultReporter
+    : public TestPartResultReporterInterface {
+ public:
+  // The two possible mocking modes of this object.
+  enum InterceptMode {
+    INTERCEPT_ONLY_CURRENT_THREAD,  // Intercepts only thread local failures.
+    INTERCEPT_ALL_THREADS           // Intercepts all failures.
+  };
+
+  // The c'tor sets this object as the test part result reporter used
+  // by Google Test.  The 'result' parameter specifies where to report the
+  // results. This reporter will only catch failures generated in the current
+  // thread. DEPRECATED
+  explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result);
+
+  // Same as above, but you can choose the interception scope of this object.
+  ScopedFakeTestPartResultReporter(InterceptMode intercept_mode,
+                                   TestPartResultArray* result);
+
+  // The d'tor restores the previous test part result reporter.
+  ~ScopedFakeTestPartResultReporter() override;
+
+  // Appends the TestPartResult object to the TestPartResultArray
+  // received in the constructor.
+  //
+  // This method is from the TestPartResultReporterInterface
+  // interface.
+  void ReportTestPartResult(const TestPartResult& result) override;
+
+ private:
+  void Init();
+
+  const InterceptMode intercept_mode_;
+  TestPartResultReporterInterface* old_reporter_;
+  TestPartResultArray* const result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
+};
+
+namespace internal {
+
+// A helper class for implementing EXPECT_FATAL_FAILURE() and
+// EXPECT_NONFATAL_FAILURE().  Its destructor verifies that the given
+// TestPartResultArray contains exactly one failure that has the given
+// type and contains the given substring.  If that's not the case, a
+// non-fatal failure will be generated.
+class GTEST_API_ SingleFailureChecker {
+ public:
+  // The constructor remembers the arguments.
+  SingleFailureChecker(const TestPartResultArray* results,
+                       TestPartResult::Type type, const std::string& substr);
+  ~SingleFailureChecker();
+ private:
+  const TestPartResultArray* const results_;
+  const TestPartResult::Type type_;
+  const std::string substr_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
+};
+
+}  // namespace internal
+
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+// A set of macros for testing Google Test assertions or code that's expected
+// to generate Google Test fatal failures.  It verifies that the given
+// statement will cause exactly one fatal Google Test failure with 'substr'
+// being part of the failure message.
+//
+// There are two different versions of this macro. EXPECT_FATAL_FAILURE only
+// affects and considers failures generated in the current thread and
+// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
+//
+// The verification of the assertion is done correctly even when the statement
+// throws an exception or aborts the current function.
+//
+// Known restrictions:
+//   - 'statement' cannot reference local non-static variables or
+//     non-static members of the current object.
+//   - 'statement' cannot return a value.
+//   - You cannot stream a failure message to this macro.
+//
+// Note that even though the implementations of the following two
+// macros are much alike, we cannot refactor them to use a common
+// helper macro, due to some peculiarity in how the preprocessor
+// works.  The AcceptsMacroThatExpandsToUnprotectedComma test in
+// gtest_unittest.cc will fail to compile if we do that.
+#define EXPECT_FATAL_FAILURE(statement, substr) \
+  do { \
+    class GTestExpectFatalFailureHelper {\
+     public:\
+      static void Execute() { statement; }\
+    };\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
+      GTestExpectFatalFailureHelper::Execute();\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
+  do { \
+    class GTestExpectFatalFailureHelper {\
+     public:\
+      static void Execute() { statement; }\
+    };\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kFatalFailure, (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ALL_THREADS, &gtest_failures);\
+      GTestExpectFatalFailureHelper::Execute();\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+// A macro for testing Google Test assertions or code that's expected to
+// generate Google Test non-fatal failures.  It asserts that the given
+// statement will cause exactly one non-fatal Google Test failure with 'substr'
+// being part of the failure message.
+//
+// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
+// affects and considers failures generated in the current thread and
+// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads.
+//
+// 'statement' is allowed to reference local variables and members of
+// the current object.
+//
+// The verification of the assertion is done correctly even when the statement
+// throws an exception or aborts the current function.
+//
+// Known restrictions:
+//   - You cannot stream a failure message to this macro.
+//
+// Note that even though the implementations of the following two
+// macros are much alike, we cannot refactor them to use a common
+// helper macro, due to some peculiarity in how the preprocessor
+// works.  If we do that, the code won't compile when the user gives
+// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that
+// expands to code containing an unprotected comma.  The
+// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc
+// catches that.
+//
+// For the same reason, we have to write
+//   if (::testing::internal::AlwaysTrue()) { statement; }
+// instead of
+//   GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
+// to avoid an MSVC warning on unreachable code.
+#define EXPECT_NONFATAL_FAILURE(statement, substr) \
+  do {\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
+        (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter:: \
+          INTERCEPT_ONLY_CURRENT_THREAD, &gtest_failures);\
+      if (::testing::internal::AlwaysTrue()) { statement; }\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \
+  do {\
+    ::testing::TestPartResultArray gtest_failures;\
+    ::testing::internal::SingleFailureChecker gtest_checker(\
+        &gtest_failures, ::testing::TestPartResult::kNonFatalFailure, \
+        (substr));\
+    {\
+      ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\
+          ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \
+          &gtest_failures);\
+      if (::testing::internal::AlwaysTrue()) { statement; }\
+    }\
+  } while (::testing::internal::AlwaysFalse())
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_SPI_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-test-part.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-test-part.h
new file mode 100644
index 000000000..203fdf98c
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-test-part.h
@@ -0,0 +1,184 @@
+// Copyright 2008, 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.
+//
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
+
+#include <iosfwd>
+#include <vector>
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-string.h"
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// A copyable object representing the result of a test part (i.e. an
+// assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()).
+//
+// Don't inherit from TestPartResult as its destructor is not virtual.
+class GTEST_API_ TestPartResult {
+ public:
+  // The possible outcomes of a test part (i.e. an assertion or an
+  // explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
+  enum Type {
+    kSuccess,          // Succeeded.
+    kNonFatalFailure,  // Failed but the test can continue.
+    kFatalFailure,     // Failed and the test should be terminated.
+    kSkip              // Skipped.
+  };
+
+  // C'tor.  TestPartResult does NOT have a default constructor.
+  // Always use this constructor (with parameters) to create a
+  // TestPartResult object.
+  TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
+                 const char* a_message)
+      : type_(a_type),
+        file_name_(a_file_name == nullptr ? "" : a_file_name),
+        line_number_(a_line_number),
+        summary_(ExtractSummary(a_message)),
+        message_(a_message) {}
+
+  // Gets the outcome of the test part.
+  Type type() const { return type_; }
+
+  // Gets the name of the source file where the test part took place, or
+  // NULL if it's unknown.
+  const char* file_name() const {
+    return file_name_.empty() ? nullptr : file_name_.c_str();
+  }
+
+  // Gets the line in the source file where the test part took place,
+  // or -1 if it's unknown.
+  int line_number() const { return line_number_; }
+
+  // Gets the summary of the failure message.
+  const char* summary() const { return summary_.c_str(); }
+
+  // Gets the message associated with the test part.
+  const char* message() const { return message_.c_str(); }
+
+  // Returns true if and only if the test part was skipped.
+  bool skipped() const { return type_ == kSkip; }
+
+  // Returns true if and only if the test part passed.
+  bool passed() const { return type_ == kSuccess; }
+
+  // Returns true if and only if the test part non-fatally failed.
+  bool nonfatally_failed() const { return type_ == kNonFatalFailure; }
+
+  // Returns true if and only if the test part fatally failed.
+  bool fatally_failed() const { return type_ == kFatalFailure; }
+
+  // Returns true if and only if the test part failed.
+  bool failed() const { return fatally_failed() || nonfatally_failed(); }
+
+ private:
+  Type type_;
+
+  // Gets the summary of the failure message by omitting the stack
+  // trace in it.
+  static std::string ExtractSummary(const char* message);
+
+  // The name of the source file where the test part took place, or
+  // "" if the source file is unknown.
+  std::string file_name_;
+  // The line in the source file where the test part took place, or -1
+  // if the line number is unknown.
+  int line_number_;
+  std::string summary_;  // The test failure summary.
+  std::string message_;  // The test failure message.
+};
+
+// Prints a TestPartResult object.
+std::ostream& operator<<(std::ostream& os, const TestPartResult& result);
+
+// An array of TestPartResult objects.
+//
+// Don't inherit from TestPartResultArray as its destructor is not
+// virtual.
+class GTEST_API_ TestPartResultArray {
+ public:
+  TestPartResultArray() {}
+
+  // Appends the given TestPartResult to the array.
+  void Append(const TestPartResult& result);
+
+  // Returns the TestPartResult at the given index (0-based).
+  const TestPartResult& GetTestPartResult(int index) const;
+
+  // Returns the number of TestPartResult objects in the array.
+  int size() const;
+
+ private:
+  std::vector<TestPartResult> array_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray);
+};
+
+// This interface knows how to report a test part result.
+class GTEST_API_ TestPartResultReporterInterface {
+ public:
+  virtual ~TestPartResultReporterInterface() {}
+
+  virtual void ReportTestPartResult(const TestPartResult& result) = 0;
+};
+
+namespace internal {
+
+// This helper class is used by {ASSERT|EXPECT}_NO_FATAL_FAILURE to check if a
+// statement generates new fatal failures. To do so it registers itself as the
+// current test part result reporter. Besides checking if fatal failures were
+// reported, it only delegates the reporting to the former result reporter.
+// The original result reporter is restored in the destructor.
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+class GTEST_API_ HasNewFatalFailureHelper
+    : public TestPartResultReporterInterface {
+ public:
+  HasNewFatalFailureHelper();
+  ~HasNewFatalFailureHelper() override;
+  void ReportTestPartResult(const TestPartResult& result) override;
+  bool has_new_fatal_failure() const { return has_new_fatal_failure_; }
+ private:
+  bool has_new_fatal_failure_;
+  TestPartResultReporterInterface* original_reporter_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper);
+};
+
+}  // namespace internal
+
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-typed-test.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-typed-test.h
new file mode 100644
index 000000000..9fdc6be10
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest-typed-test.h
@@ -0,0 +1,329 @@
+// Copyright 2008 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.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
+
+// This header implements typed tests and type-parameterized tests.
+
+// Typed (aka type-driven) tests repeat the same test for types in a
+// list.  You must know which types you want to test with when writing
+// typed tests. Here's how you do it:
+
+#if 0
+
+// First, define a fixture class template.  It should be parameterized
+// by a type.  Remember to derive it from testing::Test.
+template <typename T>
+class FooTest : public testing::Test {
+ public:
+  ...
+  typedef std::list<T> List;
+  static T shared_;
+  T value_;
+};
+
+// Next, associate a list of types with the test suite, which will be
+// repeated for each type in the list.  The typedef is necessary for
+// the macro to parse correctly.
+typedef testing::Types<char, int, unsigned int> MyTypes;
+TYPED_TEST_SUITE(FooTest, MyTypes);
+
+// If the type list contains only one type, you can write that type
+// directly without Types<...>:
+//   TYPED_TEST_SUITE(FooTest, int);
+
+// Then, use TYPED_TEST() instead of TEST_F() to define as many typed
+// tests for this test suite as you want.
+TYPED_TEST(FooTest, DoesBlah) {
+  // Inside a test, refer to the special name TypeParam to get the type
+  // parameter.  Since we are inside a derived class template, C++ requires
+  // us to visit the members of FooTest via 'this'.
+  TypeParam n = this->value_;
+
+  // To visit static members of the fixture, add the TestFixture::
+  // prefix.
+  n += TestFixture::shared_;
+
+  // To refer to typedefs in the fixture, add the "typename
+  // TestFixture::" prefix.
+  typename TestFixture::List values;
+  values.push_back(n);
+  ...
+}
+
+TYPED_TEST(FooTest, HasPropertyA) { ... }
+
+// TYPED_TEST_SUITE takes an optional third argument which allows to specify a
+// class that generates custom test name suffixes based on the type. This should
+// be a class which has a static template function GetName(int index) returning
+// a string for each type. The provided integer index equals the index of the
+// type in the provided type list. In many cases the index can be ignored.
+//
+// For example:
+//   class MyTypeNames {
+//    public:
+//     template <typename T>
+//     static std::string GetName(int) {
+//       if (std::is_same<T, char>()) return "char";
+//       if (std::is_same<T, int>()) return "int";
+//       if (std::is_same<T, unsigned int>()) return "unsignedInt";
+//     }
+//   };
+//   TYPED_TEST_SUITE(FooTest, MyTypes, MyTypeNames);
+
+#endif  // 0
+
+// Type-parameterized tests are abstract test patterns parameterized
+// by a type.  Compared with typed tests, type-parameterized tests
+// allow you to define the test pattern without knowing what the type
+// parameters are.  The defined pattern can be instantiated with
+// different types any number of times, in any number of translation
+// units.
+//
+// If you are designing an interface or concept, you can define a
+// suite of type-parameterized tests to verify properties that any
+// valid implementation of the interface/concept should have.  Then,
+// each implementation can easily instantiate the test suite to verify
+// that it conforms to the requirements, without having to write
+// similar tests repeatedly.  Here's an example:
+
+#if 0
+
+// First, define a fixture class template.  It should be parameterized
+// by a type.  Remember to derive it from testing::Test.
+template <typename T>
+class FooTest : public testing::Test {
+  ...
+};
+
+// Next, declare that you will define a type-parameterized test suite
+// (the _P suffix is for "parameterized" or "pattern", whichever you
+// prefer):
+TYPED_TEST_SUITE_P(FooTest);
+
+// Then, use TYPED_TEST_P() to define as many type-parameterized tests
+// for this type-parameterized test suite as you want.
+TYPED_TEST_P(FooTest, DoesBlah) {
+  // Inside a test, refer to TypeParam to get the type parameter.
+  TypeParam n = 0;
+  ...
+}
+
+TYPED_TEST_P(FooTest, HasPropertyA) { ... }
+
+// Now the tricky part: you need to register all test patterns before
+// you can instantiate them.  The first argument of the macro is the
+// test suite name; the rest are the names of the tests in this test
+// case.
+REGISTER_TYPED_TEST_SUITE_P(FooTest,
+                            DoesBlah, HasPropertyA);
+
+// Finally, you are free to instantiate the pattern with the types you
+// want.  If you put the above code in a header file, you can #include
+// it in multiple C++ source files and instantiate it multiple times.
+//
+// To distinguish different instances of the pattern, the first
+// argument to the INSTANTIATE_* macro is a prefix that will be added
+// to the actual test suite name.  Remember to pick unique prefixes for
+// different instances.
+typedef testing::Types<char, int, unsigned int> MyTypes;
+INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes);
+
+// If the type list contains only one type, you can write that type
+// directly without Types<...>:
+//   INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, int);
+//
+// Similar to the optional argument of TYPED_TEST_SUITE above,
+// INSTANTIATE_TEST_SUITE_P takes an optional fourth argument which allows to
+// generate custom names.
+//   INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes, MyTypeNames);
+
+#endif  // 0
+
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-port.h"
+#include "gtest/internal/gtest-type-util.h"
+
+// Implements typed tests.
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Expands to the name of the typedef for the type parameters of the
+// given test suite.
+#define GTEST_TYPE_PARAMS_(TestSuiteName) gtest_type_params_##TestSuiteName##_
+
+// Expands to the name of the typedef for the NameGenerator, responsible for
+// creating the suffixes of the name.
+#define GTEST_NAME_GENERATOR_(TestSuiteName) \
+  gtest_type_params_##TestSuiteName##_NameGenerator
+
+#define TYPED_TEST_SUITE(CaseName, Types, ...)                          \
+  typedef ::testing::internal::GenerateTypeList<Types>::type            \
+      GTEST_TYPE_PARAMS_(CaseName);                                     \
+  typedef ::testing::internal::NameGeneratorSelector<__VA_ARGS__>::type \
+      GTEST_NAME_GENERATOR_(CaseName)
+
+#define TYPED_TEST(CaseName, TestName)                                        \
+  static_assert(sizeof(GTEST_STRINGIFY_(TestName)) > 1,                       \
+                "test-name must not be empty");                               \
+  template <typename gtest_TypeParam_>                                        \
+  class GTEST_TEST_CLASS_NAME_(CaseName, TestName)                            \
+      : public CaseName<gtest_TypeParam_> {                                   \
+   private:                                                                   \
+    typedef CaseName<gtest_TypeParam_> TestFixture;                           \
+    typedef gtest_TypeParam_ TypeParam;                                       \
+    void TestBody() override;                                                 \
+  };                                                                          \
+  static bool gtest_##CaseName##_##TestName##_registered_                     \
+      GTEST_ATTRIBUTE_UNUSED_ = ::testing::internal::TypeParameterizedTest<   \
+          CaseName,                                                           \
+          ::testing::internal::TemplateSel<GTEST_TEST_CLASS_NAME_(CaseName,   \
+                                                                  TestName)>, \
+          GTEST_TYPE_PARAMS_(                                                 \
+              CaseName)>::Register("",                                        \
+                                   ::testing::internal::CodeLocation(         \
+                                       __FILE__, __LINE__),                   \
+                                   GTEST_STRINGIFY_(CaseName),                \
+                                   GTEST_STRINGIFY_(TestName), 0,             \
+                                   ::testing::internal::GenerateNames<        \
+                                       GTEST_NAME_GENERATOR_(CaseName),       \
+                                       GTEST_TYPE_PARAMS_(CaseName)>());      \
+  template <typename gtest_TypeParam_>                                        \
+  void GTEST_TEST_CLASS_NAME_(CaseName,                                       \
+                              TestName)<gtest_TypeParam_>::TestBody()
+
+// Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#define TYPED_TEST_CASE                                                \
+  static_assert(::testing::internal::TypedTestCaseIsDeprecated(), ""); \
+  TYPED_TEST_SUITE
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+// Implements type-parameterized tests.
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Expands to the namespace name that the type-parameterized tests for
+// the given type-parameterized test suite are defined in.  The exact
+// name of the namespace is subject to change without notice.
+#define GTEST_SUITE_NAMESPACE_(TestSuiteName) gtest_suite_##TestSuiteName##_
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Expands to the name of the variable used to remember the names of
+// the defined tests in the given test suite.
+#define GTEST_TYPED_TEST_SUITE_P_STATE_(TestSuiteName) \
+  gtest_typed_test_suite_p_state_##TestSuiteName##_
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY.
+//
+// Expands to the name of the variable used to remember the names of
+// the registered tests in the given test suite.
+#define GTEST_REGISTERED_TEST_NAMES_(TestSuiteName) \
+  gtest_registered_test_names_##TestSuiteName##_
+
+// The variables defined in the type-parameterized test macros are
+// static as typically these macros are used in a .h file that can be
+// #included in multiple translation units linked together.
+#define TYPED_TEST_SUITE_P(SuiteName)              \
+  static ::testing::internal::TypedTestSuitePState \
+      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName)
+
+// Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#define TYPED_TEST_CASE_P                                                 \
+  static_assert(::testing::internal::TypedTestCase_P_IsDeprecated(), ""); \
+  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_(                                        \
+      SuiteName)::TestName<gtest_TypeParam_>::TestBody()
+
+// Note: this won't work correctly if the trailing arguments are macros.
+#define REGISTER_TYPED_TEST_SUITE_P(SuiteName, ...)                         \
+  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_ =                                  \
+      GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName).VerifyRegisteredTestNames( \
+          GTEST_STRINGIFY_(SuiteName), __FILE__, __LINE__, #__VA_ARGS__)
+
+// Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#define REGISTER_TYPED_TEST_CASE_P                                           \
+  static_assert(::testing::internal::RegisterTypedTestCase_P_IsDeprecated(), \
+                "");                                                         \
+  REGISTER_TYPED_TEST_SUITE_P
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+#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_ =        \
+      ::testing::internal::TypeParameterizedTestSuite<                      \
+          SuiteName, GTEST_SUITE_NAMESPACE_(SuiteName)::gtest_AllTests_,    \
+          ::testing::internal::GenerateTypeList<Types>::type>::             \
+          Register(GTEST_STRINGIFY_(Prefix),                                \
+                   ::testing::internal::CodeLocation(__FILE__, __LINE__),   \
+                   &GTEST_TYPED_TEST_SUITE_P_STATE_(SuiteName),             \
+                   GTEST_STRINGIFY_(SuiteName),                             \
+                   GTEST_REGISTERED_TEST_NAMES_(SuiteName),                 \
+                   ::testing::internal::GenerateNames<                      \
+                       ::testing::internal::NameGeneratorSelector<          \
+                           __VA_ARGS__>::type,                              \
+                       ::testing::internal::GenerateTypeList<Types>::type>())
+
+// Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+#define INSTANTIATE_TYPED_TEST_CASE_P                                      \
+  static_assert(                                                           \
+      ::testing::internal::InstantiateTypedTestCase_P_IsDeprecated(), ""); \
+  INSTANTIATE_TYPED_TEST_SUITE_P
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest.h
new file mode 100644
index 000000000..7a5d057c4
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest.h
@@ -0,0 +1,2495 @@
+// Copyright 2005, 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.
+
+//
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file defines the public API for Google Test.  It should be
+// included by any test program that uses Google Test.
+//
+// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
+// leave some internal implementation details in this header file.
+// They are clearly marked by comments like this:
+//
+//   // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+//
+// Such code is NOT meant to be used by a user directly, and is subject
+// to CHANGE WITHOUT NOTICE.  Therefore DO NOT DEPEND ON IT in a user
+// program!
+//
+// Acknowledgment: Google Test borrowed the idea of automatic test
+// registration from Barthelemy Dagenais' (barthelemy@prologique.com)
+// easyUnit framework.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_H_
+
+#include <cstddef>
+#include <limits>
+#include <memory>
+#include <ostream>
+#include <type_traits>
+#include <vector>
+
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-string.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_prod.h"
+#include "gtest/gtest-test-part.h"
+#include "gtest/gtest-typed-test.h"
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// Silence C4100 (unreferenced formal parameter) and 4805
+// unsafe mix of type 'const int' and type 'const bool'
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable:4805)
+# pragma warning(disable:4100)
+#endif
+
+
+// Declares the flags.
+
+// This flag temporary enables the disabled tests.
+GTEST_DECLARE_bool_(also_run_disabled_tests);
+
+// This flag brings the debugger on an assertion failure.
+GTEST_DECLARE_bool_(break_on_failure);
+
+// This flag controls whether Google Test catches all test-thrown exceptions
+// and logs them as failures.
+GTEST_DECLARE_bool_(catch_exceptions);
+
+// This flag enables using colors in terminal output. Available values are
+// "yes" to enable colors, "no" (disable colors), or "auto" (the default)
+// to let Google Test decide.
+GTEST_DECLARE_string_(color);
+
+// This flag controls whether the test runner should continue execution past
+// first failure.
+GTEST_DECLARE_bool_(fail_fast);
+
+// This flag sets up the filter to select by name using a glob pattern
+// the tests to run. If the filter is not given all tests are executed.
+GTEST_DECLARE_string_(filter);
+
+// This flag controls whether Google Test installs a signal handler that dumps
+// debugging information when fatal signals are raised.
+GTEST_DECLARE_bool_(install_failure_signal_handler);
+
+// This flag causes the Google Test to list tests. None of the tests listed
+// are actually run if the flag is provided.
+GTEST_DECLARE_bool_(list_tests);
+
+// This flag controls whether Google Test emits a detailed XML report to a file
+// in addition to its normal textual output.
+GTEST_DECLARE_string_(output);
+
+// This flags control whether Google Test prints only test failures.
+GTEST_DECLARE_bool_(brief);
+
+// This flags control whether Google Test prints the elapsed time for each
+// test.
+GTEST_DECLARE_bool_(print_time);
+
+// This flags control whether Google Test prints UTF8 characters as text.
+GTEST_DECLARE_bool_(print_utf8);
+
+// This flag specifies the random number seed.
+GTEST_DECLARE_int32_(random_seed);
+
+// This flag sets how many times the tests are repeated. The default value
+// is 1. If the value is -1 the tests are repeating forever.
+GTEST_DECLARE_int32_(repeat);
+
+// This flag controls whether Google Test includes Google Test internal
+// stack frames in failure stack traces.
+GTEST_DECLARE_bool_(show_internal_stack_frames);
+
+// When this flag is specified, tests' order is randomized on every iteration.
+GTEST_DECLARE_bool_(shuffle);
+
+// This flag specifies the maximum number of stack frames to be
+// printed in a failure message.
+GTEST_DECLARE_int32_(stack_trace_depth);
+
+// When this flag is specified, a failed assertion will throw an
+// exception if exceptions are enabled, or exit the program with a
+// non-zero code otherwise. For use with an external test framework.
+GTEST_DECLARE_bool_(throw_on_failure);
+
+// When this flag is set with a "host:port" string, on supported
+// platforms test results are streamed to the specified port on
+// the specified host machine.
+GTEST_DECLARE_string_(stream_result_to);
+
+#if GTEST_USE_OWN_FLAGFILE_FLAG_
+GTEST_DECLARE_string_(flagfile);
+#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
+
+// The upper limit for valid stack trace depths.
+const int kMaxStackTraceDepth = 100;
+
+namespace internal {
+
+class AssertHelper;
+class DefaultGlobalTestPartResultReporter;
+class ExecDeathTest;
+class NoExecDeathTest;
+class FinalSuccessChecker;
+class GTestFlagSaver;
+class StreamingListenerTest;
+class TestResultAccessor;
+class TestEventListenersAccessor;
+class TestEventRepeater;
+class UnitTestRecordPropertyTestHelper;
+class WindowsDeathTest;
+class FuchsiaDeathTest;
+class UnitTestImpl* GetUnitTestImpl();
+void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
+                                    const std::string& message);
+std::set<std::string>* GetIgnoredParameterizedTestSuites();
+
+}  // namespace internal
+
+// The friend relationship of some of these classes is cyclic.
+// If we don't forward declare them the compiler might confuse the classes
+// in friendship clauses with same named classes on the scope.
+class Test;
+class TestSuite;
+
+// Old API is still available but deprecated
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+using TestCase = TestSuite;
+#endif
+class TestInfo;
+class UnitTest;
+
+// A class for indicating whether an assertion was successful.  When
+// the assertion wasn't successful, the AssertionResult object
+// remembers a non-empty message that describes how it failed.
+//
+// To create an instance of this class, use one of the factory functions
+// (AssertionSuccess() and AssertionFailure()).
+//
+// This class is useful for two purposes:
+//   1. Defining predicate functions to be used with Boolean test assertions
+//      EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts
+//   2. Defining predicate-format functions to be
+//      used with predicate assertions (ASSERT_PRED_FORMAT*, etc).
+//
+// For example, if you define IsEven predicate:
+//
+//   testing::AssertionResult IsEven(int n) {
+//     if ((n % 2) == 0)
+//       return testing::AssertionSuccess();
+//     else
+//       return testing::AssertionFailure() << n << " is odd";
+//   }
+//
+// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5)))
+// will print the message
+//
+//   Value of: IsEven(Fib(5))
+//     Actual: false (5 is odd)
+//   Expected: true
+//
+// instead of a more opaque
+//
+//   Value of: IsEven(Fib(5))
+//     Actual: false
+//   Expected: true
+//
+// in case IsEven is a simple Boolean predicate.
+//
+// If you expect your predicate to be reused and want to support informative
+// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up
+// about half as often as positive ones in our tests), supply messages for
+// both success and failure cases:
+//
+//   testing::AssertionResult IsEven(int n) {
+//     if ((n % 2) == 0)
+//       return testing::AssertionSuccess() << n << " is even";
+//     else
+//       return testing::AssertionFailure() << n << " is odd";
+//   }
+//
+// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print
+//
+//   Value of: IsEven(Fib(6))
+//     Actual: true (8 is even)
+//   Expected: false
+//
+// NB: Predicates that support negative Boolean assertions have reduced
+// performance in positive ones so be careful not to use them in tests
+// that have lots (tens of thousands) of positive Boolean assertions.
+//
+// To use this class with EXPECT_PRED_FORMAT assertions such as:
+//
+//   // Verifies that Foo() returns an even number.
+//   EXPECT_PRED_FORMAT1(IsEven, Foo());
+//
+// you need to define:
+//
+//   testing::AssertionResult IsEven(const char* expr, int n) {
+//     if ((n % 2) == 0)
+//       return testing::AssertionSuccess();
+//     else
+//       return testing::AssertionFailure()
+//         << "Expected: " << expr << " is even\n  Actual: it's " << n;
+//   }
+//
+// If Foo() returns 5, you will see the following message:
+//
+//   Expected: Foo() is even
+//     Actual: it's 5
+//
+class GTEST_API_ AssertionResult {
+ public:
+  // Copy constructor.
+  // Used in EXPECT_TRUE/FALSE(assertion_result).
+  AssertionResult(const AssertionResult& other);
+
+// C4800 is a level 3 warning in Visual Studio 2015 and earlier.
+// This warning is not emitted in Visual Studio 2017.
+// This warning is off by default starting in Visual Studio 2019 but can be
+// enabled with command-line options.
+#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
+  GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 /* forcing value to bool */)
+#endif
+
+  // Used in the EXPECT_TRUE/FALSE(bool_expression).
+  //
+  // T must be contextually convertible to bool.
+  //
+  // The second parameter prevents this overload from being considered if
+  // the argument is implicitly convertible to AssertionResult. In that case
+  // we want AssertionResult's copy constructor to be used.
+  template <typename T>
+  explicit AssertionResult(
+      const T& success,
+      typename std::enable_if<
+          !std::is_convertible<T, AssertionResult>::value>::type*
+      /*enabler*/
+      = nullptr)
+      : success_(success) {}
+
+#if defined(_MSC_VER) && (_MSC_VER < 1910 || _MSC_VER >= 1920)
+  GTEST_DISABLE_MSC_WARNINGS_POP_()
+#endif
+
+  // Assignment operator.
+  AssertionResult& operator=(AssertionResult other) {
+    swap(other);
+    return *this;
+  }
+
+  // Returns true if and only if the assertion succeeded.
+  operator bool() const { return success_; }  // NOLINT
+
+  // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
+  AssertionResult operator!() const;
+
+  // Returns the text streamed into this AssertionResult. Test assertions
+  // use it when they fail (i.e., the predicate's outcome doesn't match the
+  // assertion's expectation). When nothing has been streamed into the
+  // object, returns an empty string.
+  const char* message() const {
+    return message_.get() != nullptr ? message_->c_str() : "";
+  }
+  // Deprecated; please use message() instead.
+  const char* failure_message() const { return message(); }
+
+  // Streams a custom failure message into this object.
+  template <typename T> AssertionResult& operator<<(const T& value) {
+    AppendMessage(Message() << value);
+    return *this;
+  }
+
+  // Allows streaming basic output manipulators such as endl or flush into
+  // this object.
+  AssertionResult& operator<<(
+      ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) {
+    AppendMessage(Message() << basic_manipulator);
+    return *this;
+  }
+
+ private:
+  // Appends the contents of message to message_.
+  void AppendMessage(const Message& a_message) {
+    if (message_.get() == nullptr) message_.reset(new ::std::string);
+    message_->append(a_message.GetString().c_str());
+  }
+
+  // Swap the contents of this AssertionResult with other.
+  void swap(AssertionResult& other);
+
+  // Stores result of the assertion predicate.
+  bool success_;
+  // Stores the message describing the condition in case the expectation
+  // construct is not satisfied with the predicate's outcome.
+  // Referenced via a pointer to avoid taking too much stack frame space
+  // with test assertions.
+  std::unique_ptr< ::std::string> message_;
+};
+
+// Makes a successful assertion result.
+GTEST_API_ AssertionResult AssertionSuccess();
+
+// Makes a failed assertion result.
+GTEST_API_ AssertionResult AssertionFailure();
+
+// Makes a failed assertion result with the given failure message.
+// Deprecated; use AssertionFailure() << msg.
+GTEST_API_ AssertionResult AssertionFailure(const Message& msg);
+
+}  // namespace testing
+
+// Includes the auto-generated header that implements a family of generic
+// predicate assertion macros. This include comes late because it relies on
+// APIs declared above.
+#include "gtest/gtest_pred_impl.h"
+
+namespace testing {
+
+// The abstract class that all tests inherit from.
+//
+// In Google Test, a unit test program contains one or many TestSuites, and
+// each TestSuite contains one or many Tests.
+//
+// When you define a test using the TEST macro, you don't need to
+// explicitly derive from Test - the TEST macro automatically does
+// this for you.
+//
+// The only time you derive from Test is when defining a test fixture
+// to be used in a TEST_F.  For example:
+//
+//   class FooTest : public testing::Test {
+//    protected:
+//     void SetUp() override { ... }
+//     void TearDown() override { ... }
+//     ...
+//   };
+//
+//   TEST_F(FooTest, Bar) { ... }
+//   TEST_F(FooTest, Baz) { ... }
+//
+// Test is not copyable.
+class GTEST_API_ Test {
+ public:
+  friend class TestInfo;
+
+  // The d'tor is virtual as we intend to inherit from Test.
+  virtual ~Test();
+
+  // Sets up the stuff shared by all tests in this test suite.
+  //
+  // Google Test will call Foo::SetUpTestSuite() before running the first
+  // test in test suite Foo.  Hence a sub-class can define its own
+  // SetUpTestSuite() method to shadow the one defined in the super
+  // class.
+  static void SetUpTestSuite() {}
+
+  // Tears down the stuff shared by all tests in this test suite.
+  //
+  // Google Test will call Foo::TearDownTestSuite() after running the last
+  // test in test suite Foo.  Hence a sub-class can define its own
+  // TearDownTestSuite() method to shadow the one defined in the super
+  // class.
+  static void TearDownTestSuite() {}
+
+  // Legacy API is deprecated but still available. Use SetUpTestSuite and
+  // TearDownTestSuite instead.
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  static void TearDownTestCase() {}
+  static void SetUpTestCase() {}
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Returns true if and only if the current test has a fatal failure.
+  static bool HasFatalFailure();
+
+  // Returns true if and only if the current test has a non-fatal failure.
+  static bool HasNonfatalFailure();
+
+  // Returns true if and only if the current test was skipped.
+  static bool IsSkipped();
+
+  // Returns true if and only if the current test has a (either fatal or
+  // non-fatal) failure.
+  static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); }
+
+  // Logs a property for the current test, test suite, or for the entire
+  // invocation of the test program when used outside of the context of a
+  // test suite.  Only the last value for a given key is remembered.  These
+  // are public static so they can be called from utility functions that are
+  // not members of the test fixture.  Calls to RecordProperty made during
+  // lifespan of the test (from the moment its constructor starts to the
+  // moment its destructor finishes) will be output in XML as attributes of
+  // the <testcase> element.  Properties recorded from fixture's
+  // SetUpTestSuite or TearDownTestSuite are logged as attributes of the
+  // corresponding <testsuite> element.  Calls to RecordProperty made in the
+  // global context (before or after invocation of RUN_ALL_TESTS and from
+  // SetUp/TearDown method of Environment objects registered with Google
+  // Test) will be output as attributes of the <testsuites> element.
+  static void RecordProperty(const std::string& key, const std::string& value);
+  static void RecordProperty(const std::string& key, int value);
+
+ protected:
+  // Creates a Test object.
+  Test();
+
+  // Sets up the test fixture.
+  virtual void SetUp();
+
+  // Tears down the test fixture.
+  virtual void TearDown();
+
+ private:
+  // Returns true if and only if the current test has the same fixture class
+  // as the first test in the current test suite.
+  static bool HasSameFixtureClass();
+
+  // Runs the test after the test fixture has been set up.
+  //
+  // A sub-class must implement this to define the test logic.
+  //
+  // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM.
+  // Instead, use the TEST or TEST_F macro.
+  virtual void TestBody() = 0;
+
+  // Sets up, executes, and tears down the test.
+  void Run();
+
+  // Deletes self.  We deliberately pick an unusual name for this
+  // internal method to avoid clashing with names used in user TESTs.
+  void DeleteSelf_() { delete this; }
+
+  const std::unique_ptr<GTEST_FLAG_SAVER_> gtest_flag_saver_;
+
+  // Often a user misspells SetUp() as Setup() and spends a long time
+  // wondering why it is never called by Google Test.  The declaration of
+  // the following method is solely for catching such an error at
+  // compile time:
+  //
+  //   - The return type is deliberately chosen to be not void, so it
+  //   will be a conflict if void Setup() is declared in the user's
+  //   test fixture.
+  //
+  //   - This method is private, so it will be another compiler error
+  //   if the method is called from the user's test fixture.
+  //
+  // DO NOT OVERRIDE THIS FUNCTION.
+  //
+  // If you see an error about overriding the following function or
+  // about it being private, you have mis-spelled SetUp() as Setup().
+  struct Setup_should_be_spelled_SetUp {};
+  virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; }
+
+  // We disallow copying Tests.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
+};
+
+typedef internal::TimeInMillis TimeInMillis;
+
+// A copyable object representing a user specified test property which can be
+// output as a key/value string pair.
+//
+// Don't inherit from TestProperty as its destructor is not virtual.
+class TestProperty {
+ public:
+  // C'tor.  TestProperty does NOT have a default constructor.
+  // Always use this constructor (with parameters) to create a
+  // TestProperty object.
+  TestProperty(const std::string& a_key, const std::string& a_value) :
+    key_(a_key), value_(a_value) {
+  }
+
+  // Gets the user supplied key.
+  const char* key() const {
+    return key_.c_str();
+  }
+
+  // Gets the user supplied value.
+  const char* value() const {
+    return value_.c_str();
+  }
+
+  // Sets a new value, overriding the one supplied in the constructor.
+  void SetValue(const std::string& new_value) {
+    value_ = new_value;
+  }
+
+ private:
+  // The key supplied by the user.
+  std::string key_;
+  // The value supplied by the user.
+  std::string value_;
+};
+
+// The result of a single Test.  This includes a list of
+// TestPartResults, a list of TestProperties, a count of how many
+// death tests there are in the Test, and how much time it took to run
+// the Test.
+//
+// TestResult is not copyable.
+class GTEST_API_ TestResult {
+ public:
+  // Creates an empty TestResult.
+  TestResult();
+
+  // D'tor.  Do not inherit from TestResult.
+  ~TestResult();
+
+  // Gets the number of all test parts.  This is the sum of the number
+  // of successful test parts and the number of failed test parts.
+  int total_part_count() const;
+
+  // Returns the number of the test properties.
+  int test_property_count() const;
+
+  // Returns true if and only if the test passed (i.e. no test part failed).
+  bool Passed() const { return !Skipped() && !Failed(); }
+
+  // Returns true if and only if the test was skipped.
+  bool Skipped() const;
+
+  // Returns true if and only if the test failed.
+  bool Failed() const;
+
+  // Returns true if and only if the test fatally failed.
+  bool HasFatalFailure() const;
+
+  // Returns true if and only if the test has a non-fatal failure.
+  bool HasNonfatalFailure() const;
+
+  // Returns the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const { return elapsed_time_; }
+
+  // Gets the time of the test case start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp() const { return start_timestamp_; }
+
+  // Returns the i-th test part result among all the results. i can range from 0
+  // to total_part_count() - 1. If i is not in that range, aborts the program.
+  const TestPartResult& GetTestPartResult(int i) const;
+
+  // Returns the i-th test property. i can range from 0 to
+  // test_property_count() - 1. If i is not in that range, aborts the
+  // program.
+  const TestProperty& GetTestProperty(int i) const;
+
+ private:
+  friend class TestInfo;
+  friend class TestSuite;
+  friend class UnitTest;
+  friend class internal::DefaultGlobalTestPartResultReporter;
+  friend class internal::ExecDeathTest;
+  friend class internal::TestResultAccessor;
+  friend class internal::UnitTestImpl;
+  friend class internal::WindowsDeathTest;
+  friend class internal::FuchsiaDeathTest;
+
+  // Gets the vector of TestPartResults.
+  const std::vector<TestPartResult>& test_part_results() const {
+    return test_part_results_;
+  }
+
+  // Gets the vector of TestProperties.
+  const std::vector<TestProperty>& test_properties() const {
+    return test_properties_;
+  }
+
+  // Sets the start time.
+  void set_start_timestamp(TimeInMillis start) { start_timestamp_ = start; }
+
+  // Sets the elapsed time.
+  void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; }
+
+  // Adds a test property to the list. The property is validated and may add
+  // a non-fatal failure if invalid (e.g., if it conflicts with reserved
+  // key names). If a property is already recorded for the same key, the
+  // value will be updated, rather than storing multiple values for the same
+  // key.  xml_element specifies the element for which the property is being
+  // recorded and is used for validation.
+  void RecordProperty(const std::string& xml_element,
+                      const TestProperty& test_property);
+
+  // Adds a failure if the key is a reserved attribute of Google Test
+  // testsuite tags.  Returns true if the property is valid.
+  // FIXME: Validate attribute names are legal and human readable.
+  static bool ValidateTestProperty(const std::string& xml_element,
+                                   const TestProperty& test_property);
+
+  // Adds a test part result to the list.
+  void AddTestPartResult(const TestPartResult& test_part_result);
+
+  // Returns the death test count.
+  int death_test_count() const { return death_test_count_; }
+
+  // Increments the death test count, returning the new count.
+  int increment_death_test_count() { return ++death_test_count_; }
+
+  // Clears the test part results.
+  void ClearTestPartResults();
+
+  // Clears the object.
+  void Clear();
+
+  // Protects mutable state of the property vector and of owned
+  // properties, whose values may be updated.
+  internal::Mutex test_properties_mutex_;
+
+  // The vector of TestPartResults
+  std::vector<TestPartResult> test_part_results_;
+  // The vector of TestProperties
+  std::vector<TestProperty> test_properties_;
+  // Running count of death tests.
+  int death_test_count_;
+  // The start time, in milliseconds since UNIX Epoch.
+  TimeInMillis start_timestamp_;
+  // The elapsed time, in milliseconds.
+  TimeInMillis elapsed_time_;
+
+  // We disallow copying TestResult.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult);
+};  // class TestResult
+
+// A TestInfo object stores the following information about a test:
+//
+//   Test suite name
+//   Test name
+//   Whether the test should be run
+//   A function pointer that creates the test object when invoked
+//   Test result
+//
+// The constructor of TestInfo registers itself with the UnitTest
+// singleton such that the RUN_ALL_TESTS() macro knows which tests to
+// run.
+class GTEST_API_ TestInfo {
+ public:
+  // Destructs a TestInfo object.  This function is not virtual, so
+  // don't inherit from TestInfo.
+  ~TestInfo();
+
+  // Returns the test suite name.
+  const char* test_suite_name() const { return test_suite_name_.c_str(); }
+
+// Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  const char* test_case_name() const { return test_suite_name(); }
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Returns the test name.
+  const char* name() const { return name_.c_str(); }
+
+  // Returns the name of the parameter type, or NULL if this is not a typed
+  // or a type-parameterized test.
+  const char* type_param() const {
+    if (type_param_.get() != nullptr) return type_param_->c_str();
+    return nullptr;
+  }
+
+  // Returns the text representation of the value parameter, or NULL if this
+  // is not a value-parameterized test.
+  const char* value_param() const {
+    if (value_param_.get() != nullptr) return value_param_->c_str();
+    return nullptr;
+  }
+
+  // Returns the file name where this test is defined.
+  const char* file() const { return location_.file.c_str(); }
+
+  // Returns the line where this test is defined.
+  int line() const { return location_.line; }
+
+  // Return true if this test should not be run because it's in another shard.
+  bool is_in_another_shard() const { return is_in_another_shard_; }
+
+  // Returns true if this test should run, that is if the test is not
+  // disabled (or it is disabled but the also_run_disabled_tests flag has
+  // been specified) and its full name matches the user-specified filter.
+  //
+  // Google Test allows the user to filter the tests by their full names.
+  // The full name of a test Bar in test suite Foo is defined as
+  // "Foo.Bar".  Only the tests that match the filter will run.
+  //
+  // A filter is a colon-separated list of glob (not regex) patterns,
+  // optionally followed by a '-' and a colon-separated list of
+  // negative patterns (tests to exclude).  A test is run if it
+  // matches one of the positive patterns and does not match any of
+  // the negative patterns.
+  //
+  // For example, *A*:Foo.* is a filter that matches any string that
+  // contains the character 'A' or starts with "Foo.".
+  bool should_run() const { return should_run_; }
+
+  // Returns true if and only if this test will appear in the XML report.
+  bool is_reportable() const {
+    // The XML report includes tests matching the filter, excluding those
+    // run in other shards.
+    return matches_filter_ && !is_in_another_shard_;
+  }
+
+  // Returns the result of the test.
+  const TestResult* result() const { return &result_; }
+
+ private:
+#if GTEST_HAS_DEATH_TEST
+  friend class internal::DefaultDeathTestFactory;
+#endif  // GTEST_HAS_DEATH_TEST
+  friend class Test;
+  friend class TestSuite;
+  friend class internal::UnitTestImpl;
+  friend class internal::StreamingListenerTest;
+  friend TestInfo* internal::MakeAndRegisterTestInfo(
+      const char* test_suite_name, const char* name, const char* type_param,
+      const char* value_param, internal::CodeLocation code_location,
+      internal::TypeId fixture_class_id, internal::SetUpTestSuiteFunc set_up_tc,
+      internal::TearDownTestSuiteFunc tear_down_tc,
+      internal::TestFactoryBase* factory);
+
+  // 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,
+           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,
+           internal::TypeId fixture_class_id,
+           internal::TestFactoryBase* factory);
+
+  // Increments the number of death tests encountered in this test so
+  // far.
+  int increment_death_test_count() {
+    return result_.increment_death_test_count();
+  }
+
+  // Creates the test object, runs it, records its result, and then
+  // deletes it.
+  void Run();
+
+  // Skip and records the test result for this object.
+  void Skip();
+
+  static void ClearTestResult(TestInfo* test_info) {
+    test_info->result_.Clear();
+  }
+
+  // These fields are immutable properties of the test.
+  const std::string test_suite_name_;    // test suite name
+  const std::string name_;               // Test name
+  // Name of the parameter type, or NULL if this is not a typed or a
+  // type-parameterized test.
+  const std::unique_ptr<const ::std::string> type_param_;
+  // Text representation of the value parameter, or NULL if this is not a
+  // value-parameterized test.
+  const std::unique_ptr<const ::std::string> value_param_;
+  internal::CodeLocation location_;
+  const internal::TypeId fixture_class_id_;  // ID of the test fixture class
+  bool should_run_;           // True if and only if this test should run
+  bool is_disabled_;          // True if and only if this test is disabled
+  bool matches_filter_;       // True if this test matches the
+                              // user-specified filter.
+  bool is_in_another_shard_;  // Will be run in another shard.
+  internal::TestFactoryBase* const factory_;  // The factory that creates
+                                              // the test object
+
+  // This field is mutable and needs to be reset before running the
+  // test for the second time.
+  TestResult result_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
+};
+
+// A test suite, which consists of a vector of TestInfos.
+//
+// TestSuite is not copyable.
+class GTEST_API_ TestSuite {
+ public:
+  // Creates a TestSuite with the given name.
+  //
+  // TestSuite does NOT have a default constructor.  Always use this
+  // constructor to create a TestSuite object.
+  //
+  // Arguments:
+  //
+  //   name:         name of the test suite
+  //   a_type_param: the name of the test's type parameter, or NULL if
+  //                 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,
+            internal::SetUpTestSuiteFunc set_up_tc,
+            internal::TearDownTestSuiteFunc tear_down_tc);
+
+  // Destructor of TestSuite.
+  virtual ~TestSuite();
+
+  // Gets the name of the TestSuite.
+  const char* name() const { return name_.c_str(); }
+
+  // Returns the name of the parameter type, or NULL if this is not a
+  // type-parameterized test suite.
+  const char* type_param() const {
+    if (type_param_.get() != nullptr) return type_param_->c_str();
+    return nullptr;
+  }
+
+  // Returns true if any test in this test suite should run.
+  bool should_run() const { return should_run_; }
+
+  // Gets the number of successful tests in this test suite.
+  int successful_test_count() const;
+
+  // Gets the number of skipped tests in this test suite.
+  int skipped_test_count() const;
+
+  // Gets the number of failed tests in this test suite.
+  int failed_test_count() const;
+
+  // Gets the number of disabled tests that will be reported in the XML report.
+  int reportable_disabled_test_count() const;
+
+  // Gets the number of disabled tests in this test suite.
+  int disabled_test_count() const;
+
+  // Gets the number of tests to be printed in the XML report.
+  int reportable_test_count() const;
+
+  // Get the number of tests in this test suite that should run.
+  int test_to_run_count() const;
+
+  // Gets the number of all tests in this test suite.
+  int total_test_count() const;
+
+  // Returns true if and only if the test suite passed.
+  bool Passed() const { return !Failed(); }
+
+  // Returns true if and only if the test suite failed.
+  bool Failed() const {
+    return failed_test_count() > 0 || ad_hoc_test_result().Failed();
+  }
+
+  // Returns the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const { return elapsed_time_; }
+
+  // Gets the time of the test suite start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp() const { return start_timestamp_; }
+
+  // Returns the i-th test among all the tests. i can range from 0 to
+  // total_test_count() - 1. If i is not in that range, returns NULL.
+  const TestInfo* GetTestInfo(int i) const;
+
+  // Returns the TestResult that holds test properties recorded during
+  // execution of SetUpTestSuite and TearDownTestSuite.
+  const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; }
+
+ private:
+  friend class Test;
+  friend class internal::UnitTestImpl;
+
+  // Gets the (mutable) vector of TestInfos in this TestSuite.
+  std::vector<TestInfo*>& test_info_list() { return test_info_list_; }
+
+  // Gets the (immutable) vector of TestInfos in this TestSuite.
+  const std::vector<TestInfo*>& test_info_list() const {
+    return test_info_list_;
+  }
+
+  // Returns the i-th test among all the tests. i can range from 0 to
+  // total_test_count() - 1. If i is not in that range, returns NULL.
+  TestInfo* GetMutableTestInfo(int i);
+
+  // Sets the should_run member.
+  void set_should_run(bool should) { should_run_ = should; }
+
+  // Adds a TestInfo to this test suite.  Will delete the TestInfo upon
+  // destruction of the TestSuite object.
+  void AddTestInfo(TestInfo * test_info);
+
+  // Clears the results of all tests in this test suite.
+  void ClearResult();
+
+  // Clears the results of all tests in the given test suite.
+  static void ClearTestSuiteResult(TestSuite* test_suite) {
+    test_suite->ClearResult();
+  }
+
+  // Runs every test in this TestSuite.
+  void Run();
+
+  // Skips the execution of tests under this TestSuite
+  void Skip();
+
+  // Runs SetUpTestSuite() for this TestSuite.  This wrapper is needed
+  // for catching exceptions thrown from SetUpTestSuite().
+  void RunSetUpTestSuite() {
+    if (set_up_tc_ != nullptr) {
+      (*set_up_tc_)();
+    }
+  }
+
+  // Runs TearDownTestSuite() for this TestSuite.  This wrapper is
+  // needed for catching exceptions thrown from TearDownTestSuite().
+  void RunTearDownTestSuite() {
+    if (tear_down_tc_ != nullptr) {
+      (*tear_down_tc_)();
+    }
+  }
+
+  // Returns true if and only if test passed.
+  static bool TestPassed(const TestInfo* test_info) {
+    return test_info->should_run() && test_info->result()->Passed();
+  }
+
+  // Returns true if and only if test skipped.
+  static bool TestSkipped(const TestInfo* test_info) {
+    return test_info->should_run() && test_info->result()->Skipped();
+  }
+
+  // Returns true if and only if test failed.
+  static bool TestFailed(const TestInfo* test_info) {
+    return test_info->should_run() && test_info->result()->Failed();
+  }
+
+  // Returns true if and only if the test is disabled and will be reported in
+  // the XML report.
+  static bool TestReportableDisabled(const TestInfo* test_info) {
+    return test_info->is_reportable() && test_info->is_disabled_;
+  }
+
+  // Returns true if and only if test is disabled.
+  static bool TestDisabled(const TestInfo* test_info) {
+    return test_info->is_disabled_;
+  }
+
+  // Returns true if and only if this test will appear in the XML report.
+  static bool TestReportable(const TestInfo* test_info) {
+    return test_info->is_reportable();
+  }
+
+  // Returns true if the given test should run.
+  static bool ShouldRunTest(const TestInfo* test_info) {
+    return test_info->should_run();
+  }
+
+  // Shuffles the tests in this test suite.
+  void ShuffleTests(internal::Random* random);
+
+  // Restores the test order to before the first shuffle.
+  void UnshuffleTests();
+
+  // Name of the test suite.
+  std::string name_;
+  // Name of the parameter type, or NULL if this is not a typed or a
+  // type-parameterized test.
+  const std::unique_ptr<const ::std::string> type_param_;
+  // The vector of TestInfos in their original order.  It owns the
+  // elements in the vector.
+  std::vector<TestInfo*> test_info_list_;
+  // Provides a level of indirection for the test list to allow easy
+  // shuffling and restoring the test order.  The i-th element in this
+  // vector is the index of the i-th test in the shuffled test list.
+  std::vector<int> test_indices_;
+  // Pointer to the function that sets up the test suite.
+  internal::SetUpTestSuiteFunc set_up_tc_;
+  // Pointer to the function that tears down the test suite.
+  internal::TearDownTestSuiteFunc tear_down_tc_;
+  // True if and only if any test in this test suite should run.
+  bool should_run_;
+  // The start time, in milliseconds since UNIX Epoch.
+  TimeInMillis start_timestamp_;
+  // Elapsed time, in milliseconds.
+  TimeInMillis elapsed_time_;
+  // Holds test properties recorded during execution of SetUpTestSuite and
+  // TearDownTestSuite.
+  TestResult ad_hoc_test_result_;
+
+  // We disallow copying TestSuites.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestSuite);
+};
+
+// An Environment object is capable of setting up and tearing down an
+// environment.  You should subclass this to define your own
+// environment(s).
+//
+// An Environment object does the set-up and tear-down in virtual
+// methods SetUp() and TearDown() instead of the constructor and the
+// destructor, as:
+//
+//   1. You cannot safely throw from a destructor.  This is a problem
+//      as in some cases Google Test is used where exceptions are enabled, and
+//      we may want to implement ASSERT_* using exceptions where they are
+//      available.
+//   2. You cannot use ASSERT_* directly in a constructor or
+//      destructor.
+class Environment {
+ public:
+  // The d'tor is virtual as we need to subclass Environment.
+  virtual ~Environment() {}
+
+  // Override this to define how to set up the environment.
+  virtual void SetUp() {}
+
+  // Override this to define how to tear down the environment.
+  virtual void TearDown() {}
+ private:
+  // If you see an error about overriding the following function or
+  // about it being private, you have mis-spelled SetUp() as Setup().
+  struct Setup_should_be_spelled_SetUp {};
+  virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; }
+};
+
+#if GTEST_HAS_EXCEPTIONS
+
+// Exception which can be thrown from TestEventListener::OnTestPartResult.
+class GTEST_API_ AssertionException
+    : public internal::GoogleTestFailureException {
+ public:
+  explicit AssertionException(const TestPartResult& result)
+      : GoogleTestFailureException(result) {}
+};
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// The interface for tracing execution of tests. The methods are organized in
+// the order the corresponding events are fired.
+class TestEventListener {
+ public:
+  virtual ~TestEventListener() {}
+
+  // Fired before any test activity starts.
+  virtual void OnTestProgramStart(const UnitTest& unit_test) = 0;
+
+  // Fired before each iteration of tests starts.  There may be more than
+  // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration
+  // index, starting from 0.
+  virtual void OnTestIterationStart(const UnitTest& unit_test,
+                                    int iteration) = 0;
+
+  // Fired before environment set-up for each iteration of tests starts.
+  virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0;
+
+  // Fired after environment set-up for each iteration of tests ends.
+  virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0;
+
+  // Fired before the test suite starts.
+  virtual void OnTestSuiteStart(const TestSuite& /*test_suite*/) {}
+
+  //  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Fired before the test starts.
+  virtual void OnTestStart(const TestInfo& test_info) = 0;
+
+  // Fired after a failed assertion or a SUCCEED() invocation.
+  // If you want to throw an exception from this function to skip to the next
+  // TEST, it must be AssertionException defined above, or inherited from it.
+  virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0;
+
+  // Fired after the test ends.
+  virtual void OnTestEnd(const TestInfo& test_info) = 0;
+
+  // Fired after the test suite ends.
+  virtual void OnTestSuiteEnd(const TestSuite& /*test_suite*/) {}
+
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Fired before environment tear-down for each iteration of tests starts.
+  virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0;
+
+  // Fired after environment tear-down for each iteration of tests ends.
+  virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0;
+
+  // Fired after each iteration of tests finishes.
+  virtual void OnTestIterationEnd(const UnitTest& unit_test,
+                                  int iteration) = 0;
+
+  // Fired after all test activities have ended.
+  virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0;
+};
+
+// The convenience class for users who need to override just one or two
+// methods and are not concerned that a possible change to a signature of
+// the methods they override will not be caught during the build.  For
+// comments about each method please see the definition of TestEventListener
+// above.
+class EmptyTestEventListener : public TestEventListener {
+ public:
+  void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
+  void OnTestIterationStart(const UnitTest& /*unit_test*/,
+                            int /*iteration*/) override {}
+  void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) override {}
+  void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
+  void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestCaseStart(const TestCase& /*test_case*/) override {}
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  void OnTestStart(const TestInfo& /*test_info*/) override {}
+  void OnTestPartResult(const TestPartResult& /*test_part_result*/) override {}
+  void OnTestEnd(const TestInfo& /*test_info*/) override {}
+  void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) override {}
+  void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}
+  void OnTestIterationEnd(const UnitTest& /*unit_test*/,
+                          int /*iteration*/) override {}
+  void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
+};
+
+// TestEventListeners lets users add listeners to track events in Google Test.
+class GTEST_API_ TestEventListeners {
+ public:
+  TestEventListeners();
+  ~TestEventListeners();
+
+  // Appends an event listener to the end of the list. Google Test assumes
+  // the ownership of the listener (i.e. it will delete the listener when
+  // the test program finishes).
+  void Append(TestEventListener* listener);
+
+  // Removes the given event listener from the list and returns it.  It then
+  // becomes the caller's responsibility to delete the listener. Returns
+  // NULL if the listener is not found in the list.
+  TestEventListener* Release(TestEventListener* listener);
+
+  // Returns the standard listener responsible for the default console
+  // output.  Can be removed from the listeners list to shut down default
+  // console output.  Note that removing this object from the listener list
+  // with Release transfers its ownership to the caller and makes this
+  // function return NULL the next time.
+  TestEventListener* default_result_printer() const {
+    return default_result_printer_;
+  }
+
+  // Returns the standard listener responsible for the default XML output
+  // controlled by the --gtest_output=xml flag.  Can be removed from the
+  // listeners list by users who want to shut down the default XML output
+  // controlled by this flag and substitute it with custom one.  Note that
+  // removing this object from the listener list with Release transfers its
+  // ownership to the caller and makes this function return NULL the next
+  // time.
+  TestEventListener* default_xml_generator() const {
+    return default_xml_generator_;
+  }
+
+ private:
+  friend class TestSuite;
+  friend class TestInfo;
+  friend class internal::DefaultGlobalTestPartResultReporter;
+  friend class internal::NoExecDeathTest;
+  friend class internal::TestEventListenersAccessor;
+  friend class internal::UnitTestImpl;
+
+  // Returns repeater that broadcasts the TestEventListener events to all
+  // subscribers.
+  TestEventListener* repeater();
+
+  // Sets the default_result_printer attribute to the provided listener.
+  // The listener is also added to the listener list and previous
+  // default_result_printer is removed from it and deleted. The listener can
+  // also be NULL in which case it will not be added to the list. Does
+  // nothing if the previous and the current listener objects are the same.
+  void SetDefaultResultPrinter(TestEventListener* listener);
+
+  // Sets the default_xml_generator attribute to the provided listener.  The
+  // listener is also added to the listener list and previous
+  // default_xml_generator is removed from it and deleted. The listener can
+  // also be NULL in which case it will not be added to the list. Does
+  // nothing if the previous and the current listener objects are the same.
+  void SetDefaultXmlGenerator(TestEventListener* listener);
+
+  // Controls whether events will be forwarded by the repeater to the
+  // listeners in the list.
+  bool EventForwardingEnabled() const;
+  void SuppressEventForwarding();
+
+  // The actual list of listeners.
+  internal::TestEventRepeater* repeater_;
+  // Listener responsible for the standard result output.
+  TestEventListener* default_result_printer_;
+  // Listener responsible for the creation of the XML output file.
+  TestEventListener* default_xml_generator_;
+
+  // We disallow copying TestEventListeners.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
+};
+
+// A UnitTest consists of a vector of TestSuites.
+//
+// This is a singleton class.  The only instance of UnitTest is
+// created when UnitTest::GetInstance() is first called.  This
+// instance is never deleted.
+//
+// UnitTest is not copyable.
+//
+// This class is thread-safe as long as the methods are called
+// according to their specification.
+class GTEST_API_ UnitTest {
+ public:
+  // Gets the singleton UnitTest object.  The first time this method
+  // is called, a UnitTest object is constructed and returned.
+  // Consecutive calls will return the same object.
+  static UnitTest* GetInstance();
+
+  // Runs all tests in this UnitTest object and prints the result.
+  // Returns 0 if successful, or 1 otherwise.
+  //
+  // 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_;
+
+  // Returns the working directory when the first TEST() or TEST_F()
+  // was executed.  The UnitTest object owns the string.
+  const char* original_working_dir() const;
+
+  // Returns the TestSuite object for the test that's currently running,
+  // or NULL if no test is running.
+  const TestSuite* current_test_suite() const GTEST_LOCK_EXCLUDED_(mutex_);
+
+// Legacy API is still available but deprecated
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  const TestCase* current_test_case() const GTEST_LOCK_EXCLUDED_(mutex_);
+#endif
+
+  // Returns the TestInfo object for the test that's currently running,
+  // or NULL if no test is running.
+  const TestInfo* current_test_info() const
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Returns the random seed used at the start of the current test run.
+  int random_seed() const;
+
+  // Returns the ParameterizedTestSuiteRegistry object used to keep track of
+  // value-parameterized tests and instantiate and register them.
+  //
+  // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+  internal::ParameterizedTestSuiteRegistry& parameterized_test_registry()
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Gets the number of successful test suites.
+  int successful_test_suite_count() const;
+
+  // Gets the number of failed test suites.
+  int failed_test_suite_count() const;
+
+  // Gets the number of all test suites.
+  int total_test_suite_count() const;
+
+  // Gets the number of all test suites that contain at least one test
+  // that should run.
+  int test_suite_to_run_count() const;
+
+  //  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  int successful_test_case_count() const;
+  int failed_test_case_count() const;
+  int total_test_case_count() const;
+  int test_case_to_run_count() const;
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Gets the number of successful tests.
+  int successful_test_count() const;
+
+  // Gets the number of skipped tests.
+  int skipped_test_count() const;
+
+  // Gets the number of failed tests.
+  int failed_test_count() const;
+
+  // Gets the number of disabled tests that will be reported in the XML report.
+  int reportable_disabled_test_count() const;
+
+  // Gets the number of disabled tests.
+  int disabled_test_count() const;
+
+  // Gets the number of tests to be printed in the XML report.
+  int reportable_test_count() const;
+
+  // Gets the number of all tests.
+  int total_test_count() const;
+
+  // Gets the number of tests that should run.
+  int test_to_run_count() const;
+
+  // Gets the time of the test program start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp() const;
+
+  // Gets the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const;
+
+  // Returns true if and only if the unit test passed (i.e. all test suites
+  // passed).
+  bool Passed() const;
+
+  // Returns true if and only if the unit test failed (i.e. some test suite
+  // failed or something outside of all tests failed).
+  bool Failed() const;
+
+  // Gets the i-th test suite among all the test suites. i can range from 0 to
+  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
+  const TestSuite* GetTestSuite(int i) const;
+
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  const TestCase* GetTestCase(int i) const;
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Returns the TestResult containing information on test failures and
+  // properties logged outside of individual test suites.
+  const TestResult& ad_hoc_test_result() const;
+
+  // Returns the list of event listeners that can be used to track events
+  // inside Google Test.
+  TestEventListeners& listeners();
+
+ private:
+  // Registers and returns a global test environment.  When a test
+  // program is run, all global test environments will be set-up in
+  // the order they were registered.  After all tests in the program
+  // have finished, all global test environments will be torn-down in
+  // the *reverse* order they were registered.
+  //
+  // The UnitTest object takes ownership of the given environment.
+  //
+  // This method can only be called from the main thread.
+  Environment* AddEnvironment(Environment* env);
+
+  // Adds a TestPartResult to the current TestResult object.  All
+  // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc)
+  // eventually call this to report their results.  The user code
+  // should use the assertion macros instead of calling this directly.
+  void AddTestPartResult(TestPartResult::Type result_type,
+                         const char* file_name,
+                         int line_number,
+                         const std::string& message,
+                         const std::string& os_stack_trace)
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Adds a TestProperty to the current TestResult object when invoked from
+  // inside a test, to current TestSuite's ad_hoc_test_result_ when invoked
+  // from SetUpTestSuite or TearDownTestSuite, or to the global property set
+  // when invoked elsewhere.  If the result already contains a property with
+  // the same key, the value will be updated.
+  void RecordProperty(const std::string& key, const std::string& value);
+
+  // Gets the i-th test suite among all the test suites. i can range from 0 to
+  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
+  TestSuite* GetMutableTestSuite(int i);
+
+  // Accessors for the implementation object.
+  internal::UnitTestImpl* impl() { return impl_; }
+  const internal::UnitTestImpl* impl() const { return impl_; }
+
+  // These classes and functions are friends as they need to access private
+  // members of UnitTest.
+  friend class ScopedTrace;
+  friend class Test;
+  friend class internal::AssertHelper;
+  friend class internal::StreamingListenerTest;
+  friend class internal::UnitTestRecordPropertyTestHelper;
+  friend Environment* AddGlobalTestEnvironment(Environment* env);
+  friend std::set<std::string>* internal::GetIgnoredParameterizedTestSuites();
+  friend internal::UnitTestImpl* internal::GetUnitTestImpl();
+  friend void internal::ReportFailureInUnknownLocation(
+      TestPartResult::Type result_type,
+      const std::string& message);
+
+  // Creates an empty UnitTest.
+  UnitTest();
+
+  // D'tor
+  virtual ~UnitTest();
+
+  // Pushes a trace defined by SCOPED_TRACE() on to the per-thread
+  // Google Test trace stack.
+  void PushGTestTrace(const internal::TraceInfo& trace)
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Pops a trace from the per-thread Google Test trace stack.
+  void PopGTestTrace()
+      GTEST_LOCK_EXCLUDED_(mutex_);
+
+  // Protects mutable state in *impl_.  This is mutable as some const
+  // methods need to lock it too.
+  mutable internal::Mutex mutex_;
+
+  // Opaque implementation object.  This field is never changed once
+  // the object is constructed.  We don't mark it as const here, as
+  // doing so will cause a warning in the constructor of UnitTest.
+  // Mutable state in *impl_ is protected by mutex_.
+  internal::UnitTestImpl* impl_;
+
+  // We disallow copying UnitTest.
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest);
+};
+
+// A convenient wrapper for adding an environment for the test
+// program.
+//
+// You should call this before RUN_ALL_TESTS() is called, probably in
+// main().  If you use gtest_main, you need to call this before main()
+// starts for it to take effect.  For example, you can define a global
+// variable like this:
+//
+//   testing::Environment* const foo_env =
+//       testing::AddGlobalTestEnvironment(new FooEnvironment);
+//
+// However, we strongly recommend you to write your own main() and
+// call AddGlobalTestEnvironment() there, as relying on initialization
+// of global variables makes the code harder to read and may cause
+// problems when you register multiple environments from different
+// translation units and the environments have dependencies among them
+// (remember that the compiler doesn't guarantee the order in which
+// global variables from different translation units are initialized).
+inline Environment* AddGlobalTestEnvironment(Environment* env) {
+  return UnitTest::GetInstance()->AddEnvironment(env);
+}
+
+// Initializes Google Test.  This must be called before calling
+// RUN_ALL_TESTS().  In particular, it parses a command line for the
+// flags that Google Test recognizes.  Whenever a Google Test flag is
+// seen, it is removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Test flag variables are
+// updated.
+//
+// Calling the function for the second time has no user-visible effect.
+GTEST_API_ void InitGoogleTest(int* argc, char** argv);
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv);
+
+// This overloaded version can be used on Arduino/embedded platforms where
+// there is no argc/argv.
+GTEST_API_ void InitGoogleTest();
+
+namespace internal {
+
+// Separate the error generating code from the code path to reduce the stack
+// frame size of CmpHelperEQ. This helps reduce the overhead of some sanitizers
+// when calling EXPECT_* in a tight loop.
+template <typename T1, typename T2>
+AssertionResult CmpHelperEQFailure(const char* lhs_expression,
+                                   const char* rhs_expression,
+                                   const T1& lhs, const T2& rhs) {
+  return EqFailure(lhs_expression,
+                   rhs_expression,
+                   FormatForComparisonFailureMessage(lhs, rhs),
+                   FormatForComparisonFailureMessage(rhs, lhs),
+                   false);
+}
+
+// This block of code defines operator==/!=
+// to block lexical scope lookup.
+// It prevents using invalid operator==/!= defined at namespace scope.
+struct faketype {};
+inline bool operator==(faketype, faketype) { return true; }
+inline bool operator!=(faketype, faketype) { return false; }
+
+// The helper function for {ASSERT|EXPECT}_EQ.
+template <typename T1, typename T2>
+AssertionResult CmpHelperEQ(const char* lhs_expression,
+                            const char* rhs_expression,
+                            const T1& lhs,
+                            const T2& rhs) {
+  if (lhs == rhs) {
+    return AssertionSuccess();
+  }
+
+  return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
+}
+
+class EqHelper {
+ public:
+  // This templatized version is for the general case.
+  template <
+      typename T1, typename T2,
+      // Disable this overload for cases where one argument is a pointer
+      // and the other is the null pointer constant.
+      typename std::enable_if<!std::is_integral<T1>::value ||
+                              !std::is_pointer<T2>::value>::type* = nullptr>
+  static AssertionResult Compare(const char* lhs_expression,
+                                 const char* rhs_expression, const T1& lhs,
+                                 const T2& rhs) {
+    return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
+  }
+
+  // With this overloaded version, we allow anonymous enums to be used
+  // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous
+  // enums can be implicitly cast to BiggestInt.
+  //
+  // Even though its body looks the same as the above version, we
+  // cannot merge the two, as it will make anonymous enums unhappy.
+  static AssertionResult Compare(const char* lhs_expression,
+                                 const char* rhs_expression,
+                                 BiggestInt lhs,
+                                 BiggestInt rhs) {
+    return CmpHelperEQ(lhs_expression, rhs_expression, lhs, rhs);
+  }
+
+  template <typename T>
+  static AssertionResult Compare(
+      const char* lhs_expression, const char* rhs_expression,
+      // Handle cases where '0' is used as a null pointer literal.
+      std::nullptr_t /* lhs */, T* rhs) {
+    // We already know that 'lhs' is a null pointer.
+    return CmpHelperEQ(lhs_expression, rhs_expression, static_cast<T*>(nullptr),
+                       rhs);
+  }
+};
+
+// Separate the error generating code from the code path to reduce the stack
+// frame size of CmpHelperOP. This helps reduce the overhead of some sanitizers
+// when calling EXPECT_OP in a tight loop.
+template <typename T1, typename T2>
+AssertionResult CmpHelperOpFailure(const char* expr1, const char* expr2,
+                                   const T1& val1, const T2& val2,
+                                   const char* op) {
+  return AssertionFailure()
+         << "Expected: (" << expr1 << ") " << op << " (" << expr2
+         << "), actual: " << FormatForComparisonFailureMessage(val1, val2)
+         << " vs " << FormatForComparisonFailureMessage(val2, val1);
+}
+
+// A macro for implementing the helper functions needed to implement
+// ASSERT_?? and EXPECT_??.  It is here just to avoid copy-and-paste
+// of similar code.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+
+#define GTEST_IMPL_CMP_HELPER_(op_name, op)\
+template <typename T1, typename T2>\
+AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \
+                                   const T1& val1, const T2& val2) {\
+  if (val1 op val2) {\
+    return AssertionSuccess();\
+  } else {\
+    return CmpHelperOpFailure(expr1, expr2, val1, val2, #op);\
+  }\
+}
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+
+// Implements the helper function for {ASSERT|EXPECT}_NE
+GTEST_IMPL_CMP_HELPER_(NE, !=)
+// Implements the helper function for {ASSERT|EXPECT}_LE
+GTEST_IMPL_CMP_HELPER_(LE, <=)
+// Implements the helper function for {ASSERT|EXPECT}_LT
+GTEST_IMPL_CMP_HELPER_(LT, <)
+// Implements the helper function for {ASSERT|EXPECT}_GE
+GTEST_IMPL_CMP_HELPER_(GE, >=)
+// Implements the helper function for {ASSERT|EXPECT}_GT
+GTEST_IMPL_CMP_HELPER_(GT, >)
+
+#undef GTEST_IMPL_CMP_HELPER_
+
+// The helper function for {ASSERT|EXPECT}_STREQ.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
+                                          const char* s2_expression,
+                                          const char* s1,
+                                          const char* s2);
+
+// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* s1_expression,
+                                              const char* s2_expression,
+                                              const char* s1,
+                                              const char* s2);
+
+// The helper function for {ASSERT|EXPECT}_STRNE.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                                          const char* s2_expression,
+                                          const char* s1,
+                                          const char* s2);
+
+// The helper function for {ASSERT|EXPECT}_STRCASENE.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
+                                              const char* s2_expression,
+                                              const char* s1,
+                                              const char* s2);
+
+
+// Helper function for *_STREQ on wide strings.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTREQ(const char* s1_expression,
+                                          const char* s2_expression,
+                                          const wchar_t* s1,
+                                          const wchar_t* s2);
+
+// Helper function for *_STRNE on wide strings.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                                          const char* s2_expression,
+                                          const wchar_t* s1,
+                                          const wchar_t* s2);
+
+}  // namespace internal
+
+// IsSubstring() and IsNotSubstring() are intended to be used as the
+// first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by
+// themselves.  They check whether needle is a substring of haystack
+// (NULL is considered a substring of itself only), and return an
+// appropriate error message when they fail.
+//
+// The {needle,haystack}_expr arguments are the stringified
+// expressions that generated the two real arguments.
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack);
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack);
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack);
+
+#if GTEST_HAS_STD_WSTRING
+GTEST_API_ AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack);
+GTEST_API_ AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack);
+#endif  // GTEST_HAS_STD_WSTRING
+
+namespace internal {
+
+// Helper template function for comparing floating-points.
+//
+// Template parameter:
+//
+//   RawType: the raw floating-point type (either float or double)
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+template <typename RawType>
+AssertionResult CmpHelperFloatingPointEQ(const char* lhs_expression,
+                                         const char* rhs_expression,
+                                         RawType lhs_value,
+                                         RawType rhs_value) {
+  const FloatingPoint<RawType> lhs(lhs_value), rhs(rhs_value);
+
+  if (lhs.AlmostEquals(rhs)) {
+    return AssertionSuccess();
+  }
+
+  ::std::stringstream lhs_ss;
+  lhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+         << lhs_value;
+
+  ::std::stringstream rhs_ss;
+  rhs_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+         << rhs_value;
+
+  return EqFailure(lhs_expression,
+                   rhs_expression,
+                   StringStreamToString(&lhs_ss),
+                   StringStreamToString(&rhs_ss),
+                   false);
+}
+
+// Helper function for implementing ASSERT_NEAR.
+//
+// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM.
+GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1,
+                                                const char* expr2,
+                                                const char* abs_error_expr,
+                                                double val1,
+                                                double val2,
+                                                double abs_error);
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+// A class that enables one to stream messages to assertion macros
+class GTEST_API_ AssertHelper {
+ public:
+  // Constructor.
+  AssertHelper(TestPartResult::Type type,
+               const char* file,
+               int line,
+               const char* message);
+  ~AssertHelper();
+
+  // Message assignment is a semantic trick to enable assertion
+  // streaming; see the GTEST_MESSAGE_ macro below.
+  void operator=(const Message& message) const;
+
+ private:
+  // We put our data in a struct so that the size of the AssertHelper class can
+  // be as small as possible.  This is important because gcc is incapable of
+  // re-using stack space even for temporary variables, so every EXPECT_EQ
+  // reserves stack space for another AssertHelper.
+  struct AssertHelperData {
+    AssertHelperData(TestPartResult::Type t,
+                     const char* srcfile,
+                     int line_num,
+                     const char* msg)
+        : type(t), file(srcfile), line(line_num), message(msg) { }
+
+    TestPartResult::Type const type;
+    const char* const file;
+    int const line;
+    std::string const message;
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
+  };
+
+  AssertHelperData* const data_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
+};
+
+}  // namespace internal
+
+// The pure interface class that all value-parameterized tests inherit from.
+// A value-parameterized class must inherit from both ::testing::Test and
+// ::testing::WithParamInterface. In most cases that just means inheriting
+// from ::testing::TestWithParam, but more complicated test hierarchies
+// may need to inherit from Test and WithParamInterface at different levels.
+//
+// This interface has support for accessing the test parameter value via
+// the GetParam() method.
+//
+// Use it with one of the parameter generator defining functions, like Range(),
+// Values(), ValuesIn(), Bool(), and Combine().
+//
+// class FooTest : public ::testing::TestWithParam<int> {
+//  protected:
+//   FooTest() {
+//     // Can use GetParam() here.
+//   }
+//   ~FooTest() override {
+//     // Can use GetParam() here.
+//   }
+//   void SetUp() override {
+//     // Can use GetParam() here.
+//   }
+//   void TearDown override {
+//     // Can use GetParam() here.
+//   }
+// };
+// TEST_P(FooTest, DoesBar) {
+//   // Can use GetParam() method here.
+//   Foo foo;
+//   ASSERT_TRUE(foo.DoesBar(GetParam()));
+// }
+// INSTANTIATE_TEST_SUITE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));
+
+template <typename T>
+class WithParamInterface {
+ public:
+  typedef T ParamType;
+  virtual ~WithParamInterface() {}
+
+  // The current parameter value. Is also available in the test fixture's
+  // constructor.
+  static const ParamType& GetParam() {
+    GTEST_CHECK_(parameter_ != nullptr)
+        << "GetParam() can only be called inside a value-parameterized test "
+        << "-- did you intend to write TEST_P instead of TEST_F?";
+    return *parameter_;
+  }
+
+ private:
+  // Sets parameter value. The caller is responsible for making sure the value
+  // remains alive and unchanged throughout the current test.
+  static void SetParam(const ParamType* parameter) {
+    parameter_ = parameter;
+  }
+
+  // Static value used for accessing parameter during a test lifetime.
+  static const ParamType* parameter_;
+
+  // TestClass must be a subclass of WithParamInterface<T> and Test.
+  template <class TestClass> friend class internal::ParameterizedTestFactory;
+};
+
+template <typename T>
+const T* WithParamInterface<T>::parameter_ = nullptr;
+
+// Most value-parameterized classes can ignore the existence of
+// WithParamInterface, and can just inherit from ::testing::TestWithParam.
+
+template <typename T>
+class TestWithParam : public Test, public WithParamInterface<T> {
+};
+
+// Macros for indicating success/failure in test code.
+
+// Skips test in runtime.
+// Skipping test aborts current function.
+// Skipped tests are neither successful nor failed.
+#define GTEST_SKIP() GTEST_SKIP_("")
+
+// ADD_FAILURE unconditionally adds a failure to the current test.
+// SUCCEED generates a success - it doesn't automatically make the
+// current test successful, as a test is only successful when it has
+// no failure.
+//
+// EXPECT_* verifies that a certain condition is satisfied.  If not,
+// it behaves like ADD_FAILURE.  In particular:
+//
+//   EXPECT_TRUE  verifies that a Boolean condition is true.
+//   EXPECT_FALSE verifies that a Boolean condition is false.
+//
+// FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except
+// that they will also abort the current function on failure.  People
+// usually want the fail-fast behavior of FAIL and ASSERT_*, but those
+// writing data-driven tests often find themselves using ADD_FAILURE
+// and EXPECT_* more.
+
+// Generates a nonfatal failure with a generic message.
+#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed")
+
+// Generates a nonfatal failure at the given source file location with
+// a generic message.
+#define ADD_FAILURE_AT(file, line) \
+  GTEST_MESSAGE_AT_(file, line, "Failed", \
+                    ::testing::TestPartResult::kNonFatalFailure)
+
+// Generates a fatal failure with a generic message.
+#define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed")
+
+// Like GTEST_FAIL(), but at the given source file location.
+#define GTEST_FAIL_AT(file, line)         \
+  GTEST_MESSAGE_AT_(file, line, "Failed", \
+                    ::testing::TestPartResult::kFatalFailure)
+
+// Define this macro to 1 to omit the definition of FAIL(), which is a
+// generic name and clashes with some other libraries.
+#if !GTEST_DONT_DEFINE_FAIL
+# define FAIL() GTEST_FAIL()
+#endif
+
+// Generates a success with a generic message.
+#define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded")
+
+// Define this macro to 1 to omit the definition of SUCCEED(), which
+// is a generic name and clashes with some other libraries.
+#if !GTEST_DONT_DEFINE_SUCCEED
+# define SUCCEED() GTEST_SUCCEED()
+#endif
+
+// Macros for testing exceptions.
+//
+//    * {ASSERT|EXPECT}_THROW(statement, expected_exception):
+//         Tests that the statement throws the expected exception.
+//    * {ASSERT|EXPECT}_NO_THROW(statement):
+//         Tests that the statement doesn't throw any exception.
+//    * {ASSERT|EXPECT}_ANY_THROW(statement):
+//         Tests that the statement throws an exception.
+
+#define EXPECT_THROW(statement, expected_exception) \
+  GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_NO_THROW(statement) \
+  GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_ANY_THROW(statement) \
+  GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_THROW(statement, expected_exception) \
+  GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_)
+#define ASSERT_NO_THROW(statement) \
+  GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_)
+#define ASSERT_ANY_THROW(statement) \
+  GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_)
+
+// Boolean assertions. Condition can be either a Boolean expression or an
+// AssertionResult. For more information on how to use AssertionResult with
+// these macros see comments on that class.
+#define GTEST_EXPECT_TRUE(condition) \
+  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
+                      GTEST_NONFATAL_FAILURE_)
+#define GTEST_EXPECT_FALSE(condition) \
+  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
+                      GTEST_NONFATAL_FAILURE_)
+#define GTEST_ASSERT_TRUE(condition) \
+  GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \
+                      GTEST_FATAL_FAILURE_)
+#define GTEST_ASSERT_FALSE(condition) \
+  GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \
+                      GTEST_FATAL_FAILURE_)
+
+// Define these macros to 1 to omit the definition of the corresponding
+// EXPECT or ASSERT, which clashes with some users' own code.
+
+#if !GTEST_DONT_DEFINE_EXPECT_TRUE
+#define EXPECT_TRUE(condition) GTEST_EXPECT_TRUE(condition)
+#endif
+
+#if !GTEST_DONT_DEFINE_EXPECT_FALSE
+#define EXPECT_FALSE(condition) GTEST_EXPECT_FALSE(condition)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_TRUE
+#define ASSERT_TRUE(condition) GTEST_ASSERT_TRUE(condition)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_FALSE
+#define ASSERT_FALSE(condition) GTEST_ASSERT_FALSE(condition)
+#endif
+
+// Macros for testing equalities and inequalities.
+//
+//    * {ASSERT|EXPECT}_EQ(v1, v2): Tests that v1 == v2
+//    * {ASSERT|EXPECT}_NE(v1, v2): Tests that v1 != v2
+//    * {ASSERT|EXPECT}_LT(v1, v2): Tests that v1 < v2
+//    * {ASSERT|EXPECT}_LE(v1, v2): Tests that v1 <= v2
+//    * {ASSERT|EXPECT}_GT(v1, v2): Tests that v1 > v2
+//    * {ASSERT|EXPECT}_GE(v1, v2): Tests that v1 >= v2
+//
+// When they are not, Google Test prints both the tested expressions and
+// their actual values.  The values must be compatible built-in types,
+// or you will get a compiler error.  By "compatible" we mean that the
+// values can be compared by the respective operator.
+//
+// Note:
+//
+//   1. It is possible to make a user-defined type work with
+//   {ASSERT|EXPECT}_??(), but that requires overloading the
+//   comparison operators and is thus discouraged by the Google C++
+//   Usage Guide.  Therefore, you are advised to use the
+//   {ASSERT|EXPECT}_TRUE() macro to assert that two objects are
+//   equal.
+//
+//   2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on
+//   pointers (in particular, C strings).  Therefore, if you use it
+//   with two C strings, you are testing how their locations in memory
+//   are related, not how their content is related.  To compare two C
+//   strings by content, use {ASSERT|EXPECT}_STR*().
+//
+//   3. {ASSERT|EXPECT}_EQ(v1, v2) is preferred to
+//   {ASSERT|EXPECT}_TRUE(v1 == v2), as the former tells you
+//   what the actual value is when it fails, and similarly for the
+//   other comparisons.
+//
+//   4. Do not depend on the order in which {ASSERT|EXPECT}_??()
+//   evaluate their arguments, which is undefined.
+//
+//   5. These macros evaluate their arguments exactly once.
+//
+// Examples:
+//
+//   EXPECT_NE(Foo(), 5);
+//   EXPECT_EQ(a_pointer, NULL);
+//   ASSERT_LT(i, array_size);
+//   ASSERT_GT(records.size(), 0) << "There is no record left.";
+
+#define EXPECT_EQ(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)
+#define EXPECT_NE(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
+#define EXPECT_LE(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
+#define EXPECT_LT(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
+#define EXPECT_GE(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
+#define EXPECT_GT(val1, val2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
+
+#define GTEST_ASSERT_EQ(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)
+#define GTEST_ASSERT_NE(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2)
+#define GTEST_ASSERT_LE(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2)
+#define GTEST_ASSERT_LT(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2)
+#define GTEST_ASSERT_GE(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2)
+#define GTEST_ASSERT_GT(val1, val2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2)
+
+// Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of
+// ASSERT_XY(), which clashes with some users' own code.
+
+#if !GTEST_DONT_DEFINE_ASSERT_EQ
+# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_NE
+# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_LE
+# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_LT
+# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_GE
+# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2)
+#endif
+
+#if !GTEST_DONT_DEFINE_ASSERT_GT
+# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2)
+#endif
+
+// C-string Comparisons.  All tests treat NULL and any non-NULL string
+// as different.  Two NULLs are equal.
+//
+//    * {ASSERT|EXPECT}_STREQ(s1, s2):     Tests that s1 == s2
+//    * {ASSERT|EXPECT}_STRNE(s1, s2):     Tests that s1 != s2
+//    * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case
+//    * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case
+//
+// For wide or narrow string objects, you can use the
+// {ASSERT|EXPECT}_??() macros.
+//
+// Don't depend on the order in which the arguments are evaluated,
+// which is undefined.
+//
+// These macros evaluate their arguments exactly once.
+
+#define EXPECT_STREQ(s1, s2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
+#define EXPECT_STRNE(s1, s2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
+#define EXPECT_STRCASEEQ(s1, s2) \
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
+#define EXPECT_STRCASENE(s1, s2)\
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
+
+#define ASSERT_STREQ(s1, s2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, s1, s2)
+#define ASSERT_STRNE(s1, s2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2)
+#define ASSERT_STRCASEEQ(s1, s2) \
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, s1, s2)
+#define ASSERT_STRCASENE(s1, s2)\
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2)
+
+// Macros for comparing floating-point numbers.
+//
+//    * {ASSERT|EXPECT}_FLOAT_EQ(val1, val2):
+//         Tests that two float values are almost equal.
+//    * {ASSERT|EXPECT}_DOUBLE_EQ(val1, val2):
+//         Tests that two double values are almost equal.
+//    * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error):
+//         Tests that v1 and v2 are within the given distance to each other.
+//
+// Google Test uses ULP-based comparison to automatically pick a default
+// error bound that is appropriate for the operands.  See the
+// FloatingPoint template class in gtest-internal.h if you are
+// interested in the implementation details.
+
+#define EXPECT_FLOAT_EQ(val1, val2)\
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
+                      val1, val2)
+
+#define EXPECT_DOUBLE_EQ(val1, val2)\
+  EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
+                      val1, val2)
+
+#define ASSERT_FLOAT_EQ(val1, val2)\
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \
+                      val1, val2)
+
+#define ASSERT_DOUBLE_EQ(val1, val2)\
+  ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \
+                      val1, val2)
+
+#define EXPECT_NEAR(val1, val2, abs_error)\
+  EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
+                      val1, val2, abs_error)
+
+#define ASSERT_NEAR(val1, val2, abs_error)\
+  ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \
+                      val1, val2, abs_error)
+
+// These predicate format functions work on floating-point values, and
+// can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g.
+//
+//   EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0);
+
+// Asserts that val1 is less than, or almost equal to, val2.  Fails
+// otherwise.  In particular, it fails if either val1 or val2 is NaN.
+GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2,
+                                   float val1, float val2);
+GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2,
+                                    double val1, double val2);
+
+
+#if GTEST_OS_WINDOWS
+
+// Macros that test for HRESULT failure and success, these are only useful
+// on Windows, and rely on Windows SDK macros and APIs to compile.
+//
+//    * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr)
+//
+// When expr unexpectedly fails or succeeds, Google Test prints the
+// expected result and the actual result with both a human-readable
+// string representation of the error, if available, as well as the
+// hex result code.
+# define EXPECT_HRESULT_SUCCEEDED(expr) \
+    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
+
+# define ASSERT_HRESULT_SUCCEEDED(expr) \
+    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr))
+
+# define EXPECT_HRESULT_FAILED(expr) \
+    EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
+
+# define ASSERT_HRESULT_FAILED(expr) \
+    ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr))
+
+#endif  // GTEST_OS_WINDOWS
+
+// Macros that execute statement and check that it doesn't generate new fatal
+// failures in the current thread.
+//
+//   * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement);
+//
+// Examples:
+//
+//   EXPECT_NO_FATAL_FAILURE(Process());
+//   ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed";
+//
+#define ASSERT_NO_FATAL_FAILURE(statement) \
+    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_)
+#define EXPECT_NO_FATAL_FAILURE(statement) \
+    GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_)
+
+// Causes a trace (including the given source file path and line number,
+// and the given message) to be included in every test failure message generated
+// by code in the scope of the lifetime of an instance of this class. The effect
+// is undone with the destruction of the instance.
+//
+// The message argument can be anything streamable to std::ostream.
+//
+// Example:
+//   testing::ScopedTrace trace("file.cc", 123, "message");
+//
+class GTEST_API_ ScopedTrace {
+ public:
+  // The c'tor pushes the given source file location and message onto
+  // a trace stack maintained by Google Test.
+
+  // Template version. Uses Message() to convert the values into strings.
+  // Slow, but flexible.
+  template <typename T>
+  ScopedTrace(const char* file, int line, const T& message) {
+    PushTrace(file, line, (Message() << message).GetString());
+  }
+
+  // Optimize for some known types.
+  ScopedTrace(const char* file, int line, const char* message) {
+    PushTrace(file, line, message ? message : "(null)");
+  }
+
+  ScopedTrace(const char* file, int line, const std::string& message) {
+    PushTrace(file, line, message);
+  }
+
+  // The d'tor pops the info pushed by the c'tor.
+  //
+  // Note that the d'tor is not virtual in order to be efficient.
+  // Don't inherit from ScopedTrace!
+  ~ScopedTrace();
+
+ private:
+  void PushTrace(const char* file, int line, std::string message);
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace);
+} GTEST_ATTRIBUTE_UNUSED_;  // A ScopedTrace object does its job in its
+                            // c'tor and d'tor.  Therefore it doesn't
+                            // need to be used otherwise.
+
+// Causes a trace (including the source file path, the current line
+// number, and the given message) to be included in every test failure
+// message generated by code in the current scope.  The effect is
+// undone when the control leaves the current scope.
+//
+// The message argument can be anything streamable to std::ostream.
+//
+// In the implementation, we include the current line number as part
+// of the dummy variable name, thus allowing multiple SCOPED_TRACE()s
+// to appear in the same block - as long as they are on different
+// lines.
+//
+// Assuming that each thread maintains its own stack of traces.
+// Therefore, a SCOPED_TRACE() would (correctly) only affect the
+// assertions in its own thread.
+#define SCOPED_TRACE(message) \
+  ::testing::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\
+    __FILE__, __LINE__, (message))
+
+// Compile-time assertion for type equality.
+// StaticAssertTypeEq<type1, type2>() compiles if and only if type1 and type2
+// are the same type.  The value it returns is not interesting.
+//
+// Instead of making StaticAssertTypeEq a class template, we make it a
+// function template that invokes a helper class template.  This
+// prevents a user from misusing StaticAssertTypeEq<T1, T2> by
+// defining objects of that type.
+//
+// CAVEAT:
+//
+// When used inside a method of a class template,
+// StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is
+// instantiated.  For example, given:
+//
+//   template <typename T> class Foo {
+//    public:
+//     void Bar() { testing::StaticAssertTypeEq<int, T>(); }
+//   };
+//
+// the code:
+//
+//   void Test1() { Foo<bool> foo; }
+//
+// will NOT generate a compiler error, as Foo<bool>::Bar() is never
+// actually instantiated.  Instead, you need:
+//
+//   void Test2() { Foo<bool> foo; foo.Bar(); }
+//
+// to cause a compiler error.
+template <typename T1, typename T2>
+constexpr bool StaticAssertTypeEq() noexcept {
+  static_assert(std::is_same<T1, T2>::value, "T1 and T2 are not the same type");
+  return true;
+}
+
+// Defines a test.
+//
+// The first parameter is the name of the test suite, and the second
+// parameter is the name of the test within the test suite.
+//
+// The convention is to end the test suite name with "Test".  For
+// example, a test suite for the Foo class can be named FooTest.
+//
+// Test code should appear between braces after an invocation of
+// this macro.  Example:
+//
+//   TEST(FooTest, InitializesCorrectly) {
+//     Foo foo;
+//     EXPECT_TRUE(foo.StatusIsOK());
+//   }
+
+// Note that we call GetTestTypeId() instead of GetTypeId<
+// ::testing::Test>() here to get the type ID of testing::Test.  This
+// is to work around a suspected linker bug when using Google Test as
+// a framework on Mac OS X.  The bug causes GetTypeId<
+// ::testing::Test>() to return different values depending on whether
+// the call is from the Google Test framework itself or from user test
+// code.  GetTestTypeId() is guaranteed to always return the same
+// value, as it always calls GetTypeId<>() from the Google Test
+// framework.
+#define GTEST_TEST(test_suite_name, test_name)             \
+  GTEST_TEST_(test_suite_name, test_name, ::testing::Test, \
+              ::testing::internal::GetTestTypeId())
+
+// Define this macro to 1 to omit the definition of TEST(), which
+// is a generic name and clashes with some other libraries.
+#if !GTEST_DONT_DEFINE_TEST
+#define TEST(test_suite_name, test_name) GTEST_TEST(test_suite_name, test_name)
+#endif
+
+// Defines a test that uses a test fixture.
+//
+// The first parameter is the name of the test fixture class, which
+// also doubles as the test suite name.  The second parameter is the
+// name of the test within the test suite.
+//
+// A test fixture class must be declared earlier.  The user should put
+// the test code between braces after using this macro.  Example:
+//
+//   class FooTest : public testing::Test {
+//    protected:
+//     void SetUp() override { b_.AddElement(3); }
+//
+//     Foo a_;
+//     Foo b_;
+//   };
+//
+//   TEST_F(FooTest, InitializesCorrectly) {
+//     EXPECT_TRUE(a_.StatusIsOK());
+//   }
+//
+//   TEST_F(FooTest, ReturnsElementCountCorrectly) {
+//     EXPECT_EQ(a_.size(), 0);
+//     EXPECT_EQ(b_.size(), 1);
+//   }
+//
+// GOOGLETEST_CM0011 DO NOT DELETE
+#if !GTEST_DONT_DEFINE_TEST
+#define TEST_F(test_fixture, test_name)\
+  GTEST_TEST_(test_fixture, test_name, test_fixture, \
+              ::testing::internal::GetTypeId<test_fixture>())
+#endif  // !GTEST_DONT_DEFINE_TEST
+
+// Returns a path to temporary directory.
+// Tries to determine an appropriate directory for the platform.
+GTEST_API_ std::string TempDir();
+
+#ifdef _MSC_VER
+#  pragma warning(pop)
+#endif
+
+// Dynamically registers a test with the framework.
+//
+// This is an advanced API only to be used when the `TEST` macros are
+// insufficient. The macros should be preferred when possible, as they avoid
+// most of the complexity of calling this function.
+//
+// The `factory` argument is a factory callable (move-constructible) object or
+// function pointer that creates a new instance of the Test object. It
+// handles ownership to the caller. The signature of the callable is
+// `Fixture*()`, where `Fixture` is the test fixture class for the test. All
+// tests registered with the same `test_suite_name` must return the same
+// fixture type. This is checked at runtime.
+//
+// The framework will infer the fixture class from the factory and will call
+// the `SetUpTestSuite` and `TearDownTestSuite` for it.
+//
+// Must be called before `RUN_ALL_TESTS()` is invoked, otherwise behavior is
+// undefined.
+//
+// Use case example:
+//
+// class MyFixture : public ::testing::Test {
+//  public:
+//   // All of these optional, just like in regular macro usage.
+//   static void SetUpTestSuite() { ... }
+//   static void TearDownTestSuite() { ... }
+//   void SetUp() override { ... }
+//   void TearDown() override { ... }
+// };
+//
+// class MyTest : public MyFixture {
+//  public:
+//   explicit MyTest(int data) : data_(data) {}
+//   void TestBody() override { ... }
+//
+//  private:
+//   int data_;
+// };
+//
+// void RegisterMyTests(const std::vector<int>& values) {
+//   for (int v : values) {
+//     ::testing::RegisterTest(
+//         "MyFixture", ("Test" + std::to_string(v)).c_str(), nullptr,
+//         std::to_string(v).c_str(),
+//         __FILE__, __LINE__,
+//         // Important to use the fixture type as the return type here.
+//         [=]() -> MyFixture* { return new MyTest(v); });
+//   }
+// }
+// ...
+// int main(int argc, char** argv) {
+//   std::vector<int> values_to_test = LoadValuesFromConfig();
+//   RegisterMyTests(values_to_test);
+//   ...
+//   return RUN_ALL_TESTS();
+// }
+//
+template <int&... ExplicitParameterBarrier, typename Factory>
+TestInfo* RegisterTest(const char* test_suite_name, const char* test_name,
+                       const char* type_param, const char* value_param,
+                       const char* file, int line, Factory factory) {
+  using TestT = typename std::remove_pointer<decltype(factory())>::type;
+
+  class FactoryImpl : public internal::TestFactoryBase {
+   public:
+    explicit FactoryImpl(Factory f) : factory_(std::move(f)) {}
+    Test* CreateTest() override { return factory_(); }
+
+   private:
+    Factory factory_;
+  };
+
+  return internal::MakeAndRegisterTestInfo(
+      test_suite_name, test_name, type_param, value_param,
+      internal::CodeLocation(file, line), internal::GetTypeId<TestT>(),
+      internal::SuiteApiResolver<TestT>::GetSetUpCaseOrSuite(file, line),
+      internal::SuiteApiResolver<TestT>::GetTearDownCaseOrSuite(file, line),
+      new FactoryImpl{std::move(factory)});
+}
+
+}  // namespace testing
+
+// Use this function in main() to run all tests.  It returns 0 if all
+// tests are successful, or 1 otherwise.
+//
+// RUN_ALL_TESTS() should be invoked after the command line has been
+// parsed by InitGoogleTest().
+//
+// 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_;
+
+inline int RUN_ALL_TESTS() {
+  return ::testing::UnitTest::GetInstance()->Run();
+}
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest_pred_impl.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest_pred_impl.h
new file mode 100644
index 000000000..5029a9bb0
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest_pred_impl.h
@@ -0,0 +1,359 @@
+// Copyright 2006, 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.
+
+// This file is AUTOMATICALLY GENERATED on 01/02/2019 by command
+// 'gen_gtest_pred_impl.py 5'.  DO NOT EDIT BY HAND!
+//
+// Implements a family of generic predicate assertion macros.
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
+
+#include "gtest/gtest.h"
+
+namespace testing {
+
+// This header implements a family of generic predicate assertion
+// macros:
+//
+//   ASSERT_PRED_FORMAT1(pred_format, v1)
+//   ASSERT_PRED_FORMAT2(pred_format, v1, v2)
+//   ...
+//
+// where pred_format is a function or functor that takes n (in the
+// case of ASSERT_PRED_FORMATn) values and their source expression
+// text, and returns a testing::AssertionResult.  See the definition
+// of ASSERT_EQ in gtest.h for an example.
+//
+// If you don't care about formatting, you can use the more
+// restrictive version:
+//
+//   ASSERT_PRED1(pred, v1)
+//   ASSERT_PRED2(pred, v1, v2)
+//   ...
+//
+// where pred is an n-ary function or functor that returns bool,
+// and the values v1, v2, ..., must support the << operator for
+// streaming to std::ostream.
+//
+// We also define the EXPECT_* variations.
+//
+// For now we only support predicates whose arity is at most 5.
+// Please email googletestframework@googlegroups.com if you need
+// support for higher arities.
+
+// GTEST_ASSERT_ is the basic statement to which all of the assertions
+// in this file reduce.  Don't use this in your code.
+
+#define GTEST_ASSERT_(expression, on_failure) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (const ::testing::AssertionResult gtest_ar = (expression)) \
+    ; \
+  else \
+    on_failure(gtest_ar.failure_message())
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED1.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1>
+AssertionResult AssertPred1Helper(const char* pred_text,
+                                  const char* e1,
+                                  Pred pred,
+                                  const T1& v1) {
+  if (pred(v1)) return AssertionSuccess();
+
+  return AssertionFailure()
+         << pred_text << "(" << e1 << ") evaluates to false, where"
+         << "\n"
+         << e1 << " evaluates to " << ::testing::PrintToString(v1);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, v1), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED1.  Don't use
+// this in your code.
+#define GTEST_PRED1_(pred, v1, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \
+                                             #v1, \
+                                             pred, \
+                                             v1), on_failure)
+
+// Unary predicate assertion macros.
+#define EXPECT_PRED_FORMAT1(pred_format, v1) \
+  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED1(pred, v1) \
+  GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT1(pred_format, v1) \
+  GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED1(pred, v1) \
+  GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED2.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2>
+AssertionResult AssertPred2Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2) {
+  if (pred(v1, v2)) return AssertionSuccess();
+
+  return AssertionFailure()
+         << pred_text << "(" << e1 << ", " << e2
+         << ") evaluates to false, where"
+         << "\n"
+         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
+         << e2 << " evaluates to " << ::testing::PrintToString(v2);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED2.  Don't use
+// this in your code.
+#define GTEST_PRED2_(pred, v1, v2, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             pred, \
+                                             v1, \
+                                             v2), on_failure)
+
+// Binary predicate assertion macros.
+#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \
+  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED2(pred, v1, v2) \
+  GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \
+  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED2(pred, v1, v2) \
+  GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED3.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2,
+          typename T3>
+AssertionResult AssertPred3Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  const char* e3,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2,
+                                  const T3& v3) {
+  if (pred(v1, v2, v3)) return AssertionSuccess();
+
+  return AssertionFailure()
+         << pred_text << "(" << e1 << ", " << e2 << ", " << e3
+         << ") evaluates to false, where"
+         << "\n"
+         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
+         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
+         << e3 << " evaluates to " << ::testing::PrintToString(v3);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED3.  Don't use
+// this in your code.
+#define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             #v3, \
+                                             pred, \
+                                             v1, \
+                                             v2, \
+                                             v3), on_failure)
+
+// Ternary predicate assertion macros.
+#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \
+  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED3(pred, v1, v2, v3) \
+  GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \
+  GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED3(pred, v1, v2, v3) \
+  GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED4.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4>
+AssertionResult AssertPred4Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  const char* e3,
+                                  const char* e4,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2,
+                                  const T3& v3,
+                                  const T4& v4) {
+  if (pred(v1, v2, v3, v4)) return AssertionSuccess();
+
+  return AssertionFailure()
+         << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4
+         << ") evaluates to false, where"
+         << "\n"
+         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
+         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
+         << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n"
+         << e4 << " evaluates to " << ::testing::PrintToString(v4);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED4.  Don't use
+// this in your code.
+#define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             #v3, \
+                                             #v4, \
+                                             pred, \
+                                             v1, \
+                                             v2, \
+                                             v3, \
+                                             v4), on_failure)
+
+// 4-ary predicate assertion macros.
+#define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
+  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED4(pred, v1, v2, v3, v4) \
+  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \
+  GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED4(pred, v1, v2, v3, v4) \
+  GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_)
+
+
+
+// Helper function for implementing {EXPECT|ASSERT}_PRED5.  Don't use
+// this in your code.
+template <typename Pred,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5>
+AssertionResult AssertPred5Helper(const char* pred_text,
+                                  const char* e1,
+                                  const char* e2,
+                                  const char* e3,
+                                  const char* e4,
+                                  const char* e5,
+                                  Pred pred,
+                                  const T1& v1,
+                                  const T2& v2,
+                                  const T3& v3,
+                                  const T4& v4,
+                                  const T5& v5) {
+  if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess();
+
+  return AssertionFailure()
+         << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4
+         << ", " << e5 << ") evaluates to false, where"
+         << "\n"
+         << e1 << " evaluates to " << ::testing::PrintToString(v1) << "\n"
+         << e2 << " evaluates to " << ::testing::PrintToString(v2) << "\n"
+         << e3 << " evaluates to " << ::testing::PrintToString(v3) << "\n"
+         << e4 << " evaluates to " << ::testing::PrintToString(v4) << "\n"
+         << e5 << " evaluates to " << ::testing::PrintToString(v5);
+}
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5.
+// Don't use this in your code.
+#define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\
+  GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \
+                on_failure)
+
+// Internal macro for implementing {EXPECT|ASSERT}_PRED5.  Don't use
+// this in your code.
+#define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\
+  GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \
+                                             #v1, \
+                                             #v2, \
+                                             #v3, \
+                                             #v4, \
+                                             #v5, \
+                                             pred, \
+                                             v1, \
+                                             v2, \
+                                             v3, \
+                                             v4, \
+                                             v5), on_failure)
+
+// 5-ary predicate assertion macros.
+#define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
+  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
+#define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \
+  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_)
+#define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \
+  GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
+#define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \
+  GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_)
+
+
+
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest_prod.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest_prod.h
new file mode 100644
index 000000000..38b9d85a5
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/gtest_prod.h
@@ -0,0 +1,61 @@
+// Copyright 2006, 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.
+
+//
+// Google C++ Testing and Mocking Framework definitions useful in production code.
+// GOOGLETEST_CM0003 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
+#define GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
+
+// When you need to test the private or protected members of a class,
+// use the FRIEND_TEST macro to declare your tests as friends of the
+// class.  For example:
+//
+// class MyClass {
+//  private:
+//   void PrivateMethod();
+//   FRIEND_TEST(MyClassTest, PrivateMethodWorks);
+// };
+//
+// class MyClassTest : public testing::Test {
+//   // ...
+// };
+//
+// TEST_F(MyClassTest, PrivateMethodWorks) {
+//   // Can call MyClass::PrivateMethod() here.
+// }
+//
+// Note: The test class must be in the same namespace as the class being tested.
+// For example, putting MyClassTest in an anonymous namespace will not work.
+
+#define FRIEND_TEST(test_case_name, test_name)\
+friend class test_case_name##_##test_name##_Test
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_GTEST_PROD_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/custom/README.md b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/custom/README.md
new file mode 100644
index 000000000..ff391fb4e
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/custom/README.md
@@ -0,0 +1,56 @@
+# Customization Points
+
+The custom directory is an injection point for custom user configurations.
+
+## Header `gtest.h`
+
+### The following macros can be defined:
+
+*   `GTEST_OS_STACK_TRACE_GETTER_` - The name of an implementation of
+    `OsStackTraceGetterInterface`.
+*   `GTEST_CUSTOM_TEMPDIR_FUNCTION_` - An override for `testing::TempDir()`. See
+    `testing::TempDir` for semantics and signature.
+
+## Header `gtest-port.h`
+
+The following macros can be defined:
+
+### Flag related macros:
+
+*   `GTEST_FLAG(flag_name)`
+*   `GTEST_USE_OWN_FLAGFILE_FLAG_` - Define to 0 when the system provides its
+    own flagfile flag parsing.
+*   `GTEST_DECLARE_bool_(name)`
+*   `GTEST_DECLARE_int32_(name)`
+*   `GTEST_DECLARE_string_(name)`
+*   `GTEST_DEFINE_bool_(name, default_val, doc)`
+*   `GTEST_DEFINE_int32_(name, default_val, doc)`
+*   `GTEST_DEFINE_string_(name, default_val, doc)`
+
+### Logging:
+
+*   `GTEST_LOG_(severity)`
+*   `GTEST_CHECK_(condition)`
+*   Functions `LogToStderr()` and `FlushInfoLog()` have to be provided too.
+
+### Threading:
+
+*   `GTEST_HAS_NOTIFICATION_` - Enabled if Notification is already provided.
+*   `GTEST_HAS_MUTEX_AND_THREAD_LOCAL_` - Enabled if `Mutex` and `ThreadLocal`
+    are already provided. Must also provide `GTEST_DECLARE_STATIC_MUTEX_(mutex)`
+    and `GTEST_DEFINE_STATIC_MUTEX_(mutex)`
+*   `GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)`
+*   `GTEST_LOCK_EXCLUDED_(locks)`
+
+### Underlying library support features
+
+*   `GTEST_HAS_CXXABI_H_`
+
+### Exporting API symbols:
+
+*   `GTEST_API_` - Specifier for exported symbols.
+
+## Header `gtest-printers.h`
+
+*   See documentation at `gtest/gtest-printers.h` for details on how to define a
+    custom printer.
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/custom/gtest-port.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/custom/gtest-port.h
new file mode 100644
index 000000000..db02881c0
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/custom/gtest-port.h
@@ -0,0 +1,37 @@
+// Copyright 2015, 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.
+//
+// Injection point for custom user configurations. See README for details
+//
+// ** Custom implementation starts here **
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/custom/gtest-printers.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/custom/gtest-printers.h
new file mode 100644
index 000000000..b9495d837
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/custom/gtest-printers.h
@@ -0,0 +1,42 @@
+// Copyright 2015, 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.
+//
+// This file provides an injection point for custom printers in a local
+// installation of gTest.
+// It will be included from gtest-printers.h and the overrides in this file
+// will be visible to everyone.
+//
+// Injection point for custom user configurations. See README for details
+//
+// ** Custom implementation starts here **
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/custom/gtest.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/custom/gtest.h
new file mode 100644
index 000000000..afaaf17ba
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/custom/gtest.h
@@ -0,0 +1,37 @@
+// Copyright 2015, 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.
+//
+// Injection point for custom user configurations. See README for details
+//
+// ** Custom implementation starts here **
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-death-test-internal.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-death-test-internal.h
new file mode 100644
index 000000000..490296dfa
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-death-test-internal.h
@@ -0,0 +1,304 @@
+// Copyright 2005, 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.
+//
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file defines internal utilities needed for implementing
+// death tests.  They are subject to change without notice.
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
+
+#include "gtest/gtest-matchers.h"
+#include "gtest/internal/gtest-internal.h"
+
+#include <stdio.h>
+#include <memory>
+
+namespace testing {
+namespace internal {
+
+GTEST_DECLARE_string_(internal_run_death_test);
+
+// Names of the flags (needed for parsing Google Test flags).
+const char kDeathTestStyleFlag[] = "death_test_style";
+const char kDeathTestUseFork[] = "death_test_use_fork";
+const char kInternalRunDeathTestFlag[] = "internal_run_death_test";
+
+#if GTEST_HAS_DEATH_TEST
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+// DeathTest is a class that hides much of the complexity of the
+// GTEST_DEATH_TEST_ macro.  It is abstract; its static Create method
+// returns a concrete class that depends on the prevailing death test
+// style, as defined by the --gtest_death_test_style and/or
+// --gtest_internal_run_death_test flags.
+
+// In describing the results of death tests, these terms are used with
+// the corresponding definitions:
+//
+// 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
+//               returned from main()
+class GTEST_API_ DeathTest {
+ public:
+  // Create returns false if there was an error determining the
+  // appropriate action to take for the current death test; for example,
+  // if the gtest_death_test_style flag is set to an invalid value.
+  // The LastMessage method will return a more detailed message in that
+  // case.  Otherwise, the DeathTest pointer pointed to by the "test"
+  // argument is set.  If the death test should be skipped, the pointer
+  // is set to NULL; otherwise, it is set to the address of a new concrete
+  // DeathTest object that controls the execution of the current test.
+  static bool Create(const char* statement, Matcher<const std::string&> matcher,
+                     const char* file, int line, DeathTest** test);
+  DeathTest();
+  virtual ~DeathTest() { }
+
+  // A helper class that aborts a death test when it's deleted.
+  class ReturnSentinel {
+   public:
+    explicit ReturnSentinel(DeathTest* test) : test_(test) { }
+    ~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); }
+   private:
+    DeathTest* const test_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ReturnSentinel);
+  } GTEST_ATTRIBUTE_UNUSED_;
+
+  // An enumeration of possible roles that may be taken when a death
+  // test is encountered.  EXECUTE means that the death test logic should
+  // be executed immediately.  OVERSEE means that the program should prepare
+  // the appropriate environment for a child process to execute the death
+  // test, then wait for it to complete.
+  enum TestRole { OVERSEE_TEST, EXECUTE_TEST };
+
+  // An enumeration of the three reasons that a test might be aborted.
+  enum AbortReason {
+    TEST_ENCOUNTERED_RETURN_STATEMENT,
+    TEST_THREW_EXCEPTION,
+    TEST_DID_NOT_DIE
+  };
+
+  // Assumes one of the above roles.
+  virtual TestRole AssumeRole() = 0;
+
+  // Waits for the death test to finish and returns its status.
+  virtual int Wait() = 0;
+
+  // Returns true if the death test passed; that is, the test process
+  // exited during the test, its exit status matches a user-supplied
+  // predicate, and its stderr output matches a user-supplied regular
+  // expression.
+  // The user-supplied predicate may be a macro expression rather
+  // than a function pointer or functor, or else Wait and Passed could
+  // be combined.
+  virtual bool Passed(bool exit_status_ok) = 0;
+
+  // Signals that the death test did not die as expected.
+  virtual void Abort(AbortReason reason) = 0;
+
+  // Returns a human-readable outcome message regarding the outcome of
+  // the last death test.
+  static const char* LastMessage();
+
+  static void set_last_death_test_message(const std::string& message);
+
+ private:
+  // A string containing a description of the outcome of the last death test.
+  static std::string last_death_test_message_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest);
+};
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+// Factory interface for death tests.  May be mocked out for testing.
+class DeathTestFactory {
+ public:
+  virtual ~DeathTestFactory() { }
+  virtual bool Create(const char* statement,
+                      Matcher<const std::string&> matcher, const char* file,
+                      int line, DeathTest** test) = 0;
+};
+
+// A concrete DeathTestFactory implementation for normal use.
+class DefaultDeathTestFactory : public DeathTestFactory {
+ public:
+  bool Create(const char* statement, Matcher<const std::string&> matcher,
+              const char* file, int line, DeathTest** test) override;
+};
+
+// Returns true if exit_status describes a process that was terminated
+// 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
+#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
+  try { \
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+  } catch (const ::std::exception& gtest_exception) { \
+    fprintf(\
+        stderr, \
+        "\n%s: Caught std::exception-derived exception escaping the " \
+        "death test statement. Exception message: %s\n", \
+        ::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \
+        gtest_exception.what()); \
+    fflush(stderr); \
+    death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
+  } catch (...) { \
+    death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \
+  }
+
+# else
+#  define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \
+  GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement)
+
+# endif
+
+// This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*,
+// ASSERT_EXIT*, and EXPECT_EXIT*.
+#define GTEST_DEATH_TEST_(statement, predicate, regex_or_matcher, fail)        \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                                \
+  if (::testing::internal::AlwaysTrue()) {                                     \
+    ::testing::internal::DeathTest* gtest_dt;                                  \
+    if (!::testing::internal::DeathTest::Create(                               \
+            #statement,                                                        \
+            ::testing::internal::MakeDeathTestMatcher(regex_or_matcher),       \
+            __FILE__, __LINE__, &gtest_dt)) {                                  \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);                        \
+    }                                                                          \
+    if (gtest_dt != nullptr) {                                                 \
+      std::unique_ptr< ::testing::internal::DeathTest> gtest_dt_ptr(gtest_dt); \
+      switch (gtest_dt->AssumeRole()) {                                        \
+        case ::testing::internal::DeathTest::OVERSEE_TEST:                     \
+          if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) {                \
+            goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__);                  \
+          }                                                                    \
+          break;                                                               \
+        case ::testing::internal::DeathTest::EXECUTE_TEST: {                   \
+          ::testing::internal::DeathTest::ReturnSentinel gtest_sentinel(       \
+              gtest_dt);                                                       \
+          GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt);            \
+          gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE);   \
+          break;                                                               \
+        }                                                                      \
+        default:                                                               \
+          break;                                                               \
+      }                                                                        \
+    }                                                                          \
+  } else                                                                       \
+    GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__)                                \
+        : fail(::testing::internal::DeathTest::LastMessage())
+// The symbol "fail" here expands to something into which a message
+// can be streamed.
+
+// This macro is for implementing ASSERT/EXPECT_DEBUG_DEATH when compiled in
+// NDEBUG mode. In this case we need the statements to be executed and the macro
+// must accept a streamed message even though the message is never printed.
+// The regex object is not evaluated, but it is used to prevent "unused"
+// warnings and to avoid an expression that doesn't compile in debug mode.
+#define GTEST_EXECUTE_STATEMENT_(statement, regex_or_matcher)    \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                  \
+  if (::testing::internal::AlwaysTrue()) {                       \
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);   \
+  } else if (!::testing::internal::AlwaysTrue()) {               \
+    ::testing::internal::MakeDeathTestMatcher(regex_or_matcher); \
+  } else                                                         \
+    ::testing::Message()
+
+// A class representing the parsed contents of the
+// --gtest_internal_run_death_test flag, as it existed when
+// RUN_ALL_TESTS was called.
+class InternalRunDeathTestFlag {
+ public:
+  InternalRunDeathTestFlag(const std::string& a_file,
+                           int a_line,
+                           int an_index,
+                           int a_write_fd)
+      : file_(a_file), line_(a_line), index_(an_index),
+        write_fd_(a_write_fd) {}
+
+  ~InternalRunDeathTestFlag() {
+    if (write_fd_ >= 0)
+      posix::Close(write_fd_);
+  }
+
+  const std::string& file() const { return file_; }
+  int line() const { return line_; }
+  int index() const { return index_; }
+  int write_fd() const { return write_fd_; }
+
+ private:
+  std::string file_;
+  int line_;
+  int index_;
+  int write_fd_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag);
+};
+
+// Returns a newly created InternalRunDeathTestFlag object with fields
+// initialized from the GTEST_FLAG(internal_run_death_test) flag if
+// the flag is specified; otherwise returns NULL.
+InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag();
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-filepath.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-filepath.h
new file mode 100644
index 000000000..0c033abc3
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-filepath.h
@@ -0,0 +1,211 @@
+// Copyright 2008, 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.
+//
+// Google Test filepath utilities
+//
+// This header file declares classes and functions used internally by
+// Google Test.  They are subject to change without notice.
+//
+// This file is #included in gtest/internal/gtest-internal.h.
+// Do not include this header file separately!
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
+
+#include "gtest/internal/gtest-string.h"
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+namespace internal {
+
+// FilePath - a class for file and directory pathname manipulation which
+// handles platform-specific conventions (like the pathname separator).
+// Used for helper functions for naming files in a directory for xml output.
+// Except for Set methods, all methods are const or static, which provides an
+// "immutable value object" -- useful for peace of mind.
+// A FilePath with a value ending in a path separator ("like/this/") represents
+// a directory, otherwise it is assumed to represent a file. In either case,
+// it may or may not represent an actual file or directory in the file system.
+// Names are NOT checked for syntax correctness -- no checking for illegal
+// characters, malformed paths, etc.
+
+class GTEST_API_ FilePath {
+ public:
+  FilePath() : pathname_("") { }
+  FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { }
+
+  explicit FilePath(const std::string& pathname) : pathname_(pathname) {
+    Normalize();
+  }
+
+  FilePath& operator=(const FilePath& rhs) {
+    Set(rhs);
+    return *this;
+  }
+
+  void Set(const FilePath& rhs) {
+    pathname_ = rhs.pathname_;
+  }
+
+  const std::string& string() const { return pathname_; }
+  const char* c_str() const { return pathname_.c_str(); }
+
+  // Returns the current working directory, or "" if unsuccessful.
+  static FilePath GetCurrentDir();
+
+  // Given directory = "dir", base_name = "test", number = 0,
+  // extension = "xml", returns "dir/test.xml". If number is greater
+  // than zero (e.g., 12), returns "dir/test_12.xml".
+  // On Windows platform, uses \ as the separator rather than /.
+  static FilePath MakeFileName(const FilePath& directory,
+                               const FilePath& base_name,
+                               int number,
+                               const char* extension);
+
+  // Given directory = "dir", relative_path = "test.xml",
+  // returns "dir/test.xml".
+  // On Windows, uses \ as the separator rather than /.
+  static FilePath ConcatPaths(const FilePath& directory,
+                              const FilePath& relative_path);
+
+  // Returns a pathname for a file that does not currently exist. The pathname
+  // will be directory/base_name.extension or
+  // directory/base_name_<number>.extension if directory/base_name.extension
+  // already exists. The number will be incremented until a pathname is found
+  // that does not already exist.
+  // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
+  // There could be a race condition if two or more processes are calling this
+  // function at the same time -- they could both pick the same filename.
+  static FilePath GenerateUniqueFileName(const FilePath& directory,
+                                         const FilePath& base_name,
+                                         const char* extension);
+
+  // Returns true if and only if the path is "".
+  bool IsEmpty() const { return pathname_.empty(); }
+
+  // If input name has a trailing separator character, removes it and returns
+  // the name, otherwise return the name string unmodified.
+  // On Windows platform, uses \ as the separator, other platforms use /.
+  FilePath RemoveTrailingPathSeparator() const;
+
+  // Returns a copy of the FilePath with the directory part removed.
+  // Example: FilePath("path/to/file").RemoveDirectoryName() returns
+  // FilePath("file"). If there is no directory part ("just_a_file"), it returns
+  // the FilePath unmodified. If there is no file part ("just_a_dir/") it
+  // returns an empty FilePath ("").
+  // On Windows platform, '\' is the path separator, otherwise it is '/'.
+  FilePath RemoveDirectoryName() const;
+
+  // RemoveFileName returns the directory path with the filename removed.
+  // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
+  // If the FilePath is "a_file" or "/a_file", RemoveFileName returns
+  // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
+  // not have a file, like "just/a/dir/", it returns the FilePath unmodified.
+  // On Windows platform, '\' is the path separator, otherwise it is '/'.
+  FilePath RemoveFileName() const;
+
+  // Returns a copy of the FilePath with the case-insensitive extension removed.
+  // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
+  // FilePath("dir/file"). If a case-insensitive extension is not
+  // found, returns a copy of the original FilePath.
+  FilePath RemoveExtension(const char* extension) const;
+
+  // Creates directories so that path exists. Returns true if successful or if
+  // the directories already exist; returns false if unable to create
+  // directories for any reason. Will also return false if the FilePath does
+  // not represent a directory (that is, it doesn't end with a path separator).
+  bool CreateDirectoriesRecursively() const;
+
+  // Create the directory so that path exists. Returns true if successful or
+  // if the directory already exists; returns false if unable to create the
+  // directory for any reason, including if the parent directory does not
+  // exist. Not named "CreateDirectory" because that's a macro on Windows.
+  bool CreateFolder() const;
+
+  // Returns true if FilePath describes something in the file-system,
+  // either a file, directory, or whatever, and that something exists.
+  bool FileOrDirectoryExists() const;
+
+  // Returns true if pathname describes a directory in the file-system
+  // that exists.
+  bool DirectoryExists() const;
+
+  // Returns true if FilePath ends with a path separator, which indicates that
+  // it is intended to represent a directory. Returns false otherwise.
+  // This does NOT check that a directory (or file) actually exists.
+  bool IsDirectory() const;
+
+  // Returns true if pathname describes a root directory. (Windows has one
+  // root directory per disk drive.)
+  bool IsRootDirectory() const;
+
+  // Returns true if pathname describes an absolute path.
+  bool IsAbsolutePath() const;
+
+ private:
+  // Replaces multiple consecutive separators with a single separator.
+  // For example, "bar///foo" becomes "bar/foo". Does not eliminate other
+  // redundancies that might be in a pathname involving "." or "..".
+  //
+  // A pathname with multiple consecutive separators may occur either through
+  // user error or as a result of some scripts or APIs that generate a pathname
+  // with a trailing separator. On other platforms the same API or script
+  // may NOT generate a pathname with a trailing "/". Then elsewhere that
+  // pathname may have another "/" and pathname components added to it,
+  // without checking for the separator already being there.
+  // The script language and operating system may allow paths like "foo//bar"
+  // but some of the functions in FilePath will not handle that correctly. In
+  // particular, RemoveTrailingPathSeparator() only removes one separator, and
+  // it is called in CreateDirectoriesRecursively() assuming that it will change
+  // a pathname from directory syntax (trailing separator) to filename syntax.
+  //
+  // On Windows this method also replaces the alternate path separator '/' with
+  // the primary path separator '\\', so that for example "bar\\/\\foo" becomes
+  // "bar\\foo".
+
+  void Normalize();
+
+  // Returns a pointer to the last occurrence of a valid path separator in
+  // the FilePath. On Windows, for example, both '/' and '\' are valid path
+  // separators. Returns NULL if no path separator was found.
+  const char* FindLastPathSeparator() const;
+
+  std::string pathname_;
+};  // class FilePath
+
+}  // namespace internal
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-internal.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-internal.h
new file mode 100644
index 000000000..f8cbdbd81
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-internal.h
@@ -0,0 +1,1560 @@
+// Copyright 2005, 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.
+//
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file declares functions and macros used internally by
+// Google Test.  They are subject to change without notice.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
+
+#include "gtest/internal/gtest-port.h"
+
+#if GTEST_OS_LINUX
+# include <stdlib.h>
+# include <sys/types.h>
+# include <sys/wait.h>
+# include <unistd.h>
+#endif  // GTEST_OS_LINUX
+
+#if GTEST_HAS_EXCEPTIONS
+# include <stdexcept>
+#endif
+
+#include <ctype.h>
+#include <float.h>
+#include <string.h>
+#include <cstdint>
+#include <iomanip>
+#include <limits>
+#include <map>
+#include <set>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include "gtest/gtest-message.h"
+#include "gtest/internal/gtest-filepath.h"
+#include "gtest/internal/gtest-string.h"
+#include "gtest/internal/gtest-type-util.h"
+
+// Due to C++ preprocessor weirdness, we need double indirection to
+// concatenate two tokens when one of them is __LINE__.  Writing
+//
+//   foo ## __LINE__
+//
+// will result in the token foo__LINE__, instead of foo followed by
+// the current line number.  For more details, see
+// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6
+#define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar)
+#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar
+
+// Stringifies its argument.
+// Work around a bug in visual studio which doesn't accept code like this:
+//
+//   #define GTEST_STRINGIFY_(name) #name
+//   #define MACRO(a, b, c) ... GTEST_STRINGIFY_(a) ...
+//   MACRO(, x, y)
+//
+// Complaining about the argument to GTEST_STRINGIFY_ being empty.
+// This is allowed by the spec.
+#define GTEST_STRINGIFY_HELPER_(name, ...) #name
+#define GTEST_STRINGIFY_(...) GTEST_STRINGIFY_HELPER_(__VA_ARGS__, )
+
+namespace proto2 {
+class MessageLite;
+}
+
+namespace testing {
+
+// Forward declarations.
+
+class AssertionResult;                 // Result of an assertion.
+class Message;                         // Represents a failure message.
+class Test;                            // Represents a test.
+class TestInfo;                        // Information about a test.
+class TestPartResult;                  // Result of a test part.
+class UnitTest;                        // A collection of test suites.
+
+template <typename T>
+::std::string PrintToString(const T& value);
+
+namespace internal {
+
+struct TraceInfo;                      // Information about a trace point.
+class TestInfoImpl;                    // Opaque implementation of TestInfo
+class UnitTestImpl;                    // Opaque implementation of UnitTest
+
+// The text used in failure messages to indicate the start of the
+// stack trace.
+GTEST_API_ extern const char kStackTraceMarker[];
+
+// An IgnoredValue object can be implicitly constructed from ANY value.
+class IgnoredValue {
+  struct Sink {};
+ public:
+  // This constructor template allows any value to be implicitly
+  // converted to IgnoredValue.  The object has no data member and
+  // doesn't try to remember anything about the argument.  We
+  // deliberately omit the 'explicit' keyword in order to allow the
+  // conversion to be implicit.
+  // Disable the conversion if T already has a magical conversion operator.
+  // Otherwise we get ambiguity.
+  template <typename T,
+            typename std::enable_if<!std::is_convertible<T, Sink>::value,
+                                    int>::type = 0>
+  IgnoredValue(const T& /* ignored */) {}  // NOLINT(runtime/explicit)
+};
+
+// Appends the user-supplied message to the Google-Test-generated message.
+GTEST_API_ std::string AppendUserMessage(
+    const std::string& gtest_msg, const Message& user_msg);
+
+#if GTEST_HAS_EXCEPTIONS
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4275 \
+/* an exported class was derived from a class that was not exported */)
+
+// This exception is thrown by (and only by) a failed Google Test
+// assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions
+// are enabled).  We derive it from std::runtime_error, which is for
+// errors presumably detectable only at run time.  Since
+// std::runtime_error inherits from std::exception, many testing
+// frameworks know how to extract and print the message inside it.
+class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error {
+ public:
+  explicit GoogleTestFailureException(const TestPartResult& failure);
+};
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4275
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+namespace edit_distance {
+// Returns the optimal edits to go from 'left' to 'right'.
+// All edits cost the same, with replace having lower priority than
+// add/remove.
+// Simple implementation of the Wagner-Fischer algorithm.
+// See http://en.wikipedia.org/wiki/Wagner-Fischer_algorithm
+enum EditType { kMatch, kAdd, kRemove, kReplace };
+GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
+    const std::vector<size_t>& left, const std::vector<size_t>& right);
+
+// Same as above, but the input is represented as strings.
+GTEST_API_ std::vector<EditType> CalculateOptimalEdits(
+    const std::vector<std::string>& left,
+    const std::vector<std::string>& right);
+
+// Create a diff of the input strings in Unified diff format.
+GTEST_API_ std::string CreateUnifiedDiff(const std::vector<std::string>& left,
+                                         const std::vector<std::string>& right,
+                                         size_t context = 2);
+
+}  // namespace edit_distance
+
+// Calculate the diff between 'left' and 'right' and return it in unified diff
+// format.
+// If not null, stores in 'total_line_count' the total number of lines found
+// in left + right.
+GTEST_API_ std::string DiffStrings(const std::string& left,
+                                   const std::string& right,
+                                   size_t* total_line_count);
+
+// Constructs and returns the message for an equality assertion
+// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
+//
+// The first four parameters are the expressions used in the assertion
+// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
+// where foo is 5 and bar is 6, we have:
+//
+//   expected_expression: "foo"
+//   actual_expression:   "bar"
+//   expected_value:      "5"
+//   actual_value:        "6"
+//
+// The ignoring_case parameter is true if and only if the assertion is a
+// *_STRCASEEQ*.  When it's true, the string " (ignoring case)" will
+// be inserted into the message.
+GTEST_API_ AssertionResult EqFailure(const char* expected_expression,
+                                     const char* actual_expression,
+                                     const std::string& expected_value,
+                                     const std::string& actual_value,
+                                     bool ignoring_case);
+
+// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
+GTEST_API_ std::string GetBoolAssertionFailureMessage(
+    const AssertionResult& assertion_result,
+    const char* expression_text,
+    const char* actual_predicate_value,
+    const char* expected_predicate_value);
+
+// This template class represents an IEEE floating-point number
+// (either single-precision or double-precision, depending on the
+// template parameters).
+//
+// The purpose of this class is to do more sophisticated number
+// comparison.  (Due to round-off error, etc, it's very unlikely that
+// two floating-points will be equal exactly.  Hence a naive
+// comparison by the == operation often doesn't work.)
+//
+// Format of IEEE floating-point:
+//
+//   The most-significant bit being the leftmost, an IEEE
+//   floating-point looks like
+//
+//     sign_bit exponent_bits fraction_bits
+//
+//   Here, sign_bit is a single bit that designates the sign of the
+//   number.
+//
+//   For float, there are 8 exponent bits and 23 fraction bits.
+//
+//   For double, there are 11 exponent bits and 52 fraction bits.
+//
+//   More details can be found at
+//   http://en.wikipedia.org/wiki/IEEE_floating-point_standard.
+//
+// Template parameter:
+//
+//   RawType: the raw floating-point type (either float or double)
+template <typename RawType>
+class FloatingPoint {
+ public:
+  // Defines the unsigned integer type that has the same size as the
+  // floating point number.
+  typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits;
+
+  // Constants.
+
+  // # of bits in a number.
+  static const size_t kBitCount = 8*sizeof(RawType);
+
+  // # of fraction bits in a number.
+  static const size_t kFractionBitCount =
+    std::numeric_limits<RawType>::digits - 1;
+
+  // # of exponent bits in a number.
+  static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount;
+
+  // The mask for the sign bit.
+  static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1);
+
+  // The mask for the fraction bits.
+  static const Bits kFractionBitMask =
+    ~static_cast<Bits>(0) >> (kExponentBitCount + 1);
+
+  // The mask for the exponent bits.
+  static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask);
+
+  // How many ULP's (Units in the Last Place) we want to tolerate when
+  // comparing two numbers.  The larger the value, the more error we
+  // allow.  A 0 value means that two numbers must be exactly the same
+  // to be considered equal.
+  //
+  // The maximum error of a single floating-point operation is 0.5
+  // units in the last place.  On Intel CPU's, all floating-point
+  // calculations are done with 80-bit precision, while double has 64
+  // bits.  Therefore, 4 should be enough for ordinary use.
+  //
+  // See the following article for more details on ULP:
+  // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
+  static const uint32_t kMaxUlps = 4;
+
+  // Constructs a FloatingPoint from a raw floating-point number.
+  //
+  // On an Intel CPU, passing a non-normalized NAN (Not a Number)
+  // around may change its bits, although the new value is guaranteed
+  // to be also a NAN.  Therefore, don't expect this constructor to
+  // preserve the bits in x when x is a NAN.
+  explicit FloatingPoint(const RawType& x) { u_.value_ = x; }
+
+  // Static methods
+
+  // Reinterprets a bit pattern as a floating-point number.
+  //
+  // This function is needed to test the AlmostEquals() method.
+  static RawType ReinterpretBits(const Bits bits) {
+    FloatingPoint fp(0);
+    fp.u_.bits_ = bits;
+    return fp.u_.value_;
+  }
+
+  // Returns the floating-point number that represent positive infinity.
+  static RawType Infinity() {
+    return ReinterpretBits(kExponentBitMask);
+  }
+
+  // Returns the maximum representable finite floating-point number.
+  static RawType Max();
+
+  // Non-static methods
+
+  // Returns the bits that represents this number.
+  const Bits &bits() const { return u_.bits_; }
+
+  // Returns the exponent bits of this number.
+  Bits exponent_bits() const { return kExponentBitMask & u_.bits_; }
+
+  // Returns the fraction bits of this number.
+  Bits fraction_bits() const { return kFractionBitMask & u_.bits_; }
+
+  // Returns the sign bit of this number.
+  Bits sign_bit() const { return kSignBitMask & u_.bits_; }
+
+  // Returns true if and only if this is NAN (not a number).
+  bool is_nan() const {
+    // It's a NAN if the exponent bits are all ones and the fraction
+    // bits are not entirely zeros.
+    return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0);
+  }
+
+  // Returns true if and only if this number is at most kMaxUlps ULP's away
+  // from rhs.  In particular, this function:
+  //
+  //   - returns false if either number is (or both are) NAN.
+  //   - treats really large numbers as almost equal to infinity.
+  //   - thinks +0.0 and -0.0 are 0 DLP's apart.
+  bool AlmostEquals(const FloatingPoint& rhs) const {
+    // The IEEE standard says that any comparison operation involving
+    // a NAN must return false.
+    if (is_nan() || rhs.is_nan()) return false;
+
+    return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
+        <= kMaxUlps;
+  }
+
+ private:
+  // The data type used to store the actual floating-point number.
+  union FloatingPointUnion {
+    RawType value_;  // The raw floating-point number.
+    Bits bits_;      // The bits that represent the number.
+  };
+
+  // Converts an integer from the sign-and-magnitude representation to
+  // the biased representation.  More precisely, let N be 2 to the
+  // power of (kBitCount - 1), an integer x is represented by the
+  // unsigned number x + N.
+  //
+  // For instance,
+  //
+  //   -N + 1 (the most negative number representable using
+  //          sign-and-magnitude) is represented by 1;
+  //   0      is represented by N; and
+  //   N - 1  (the biggest number representable using
+  //          sign-and-magnitude) is represented by 2N - 1.
+  //
+  // Read http://en.wikipedia.org/wiki/Signed_number_representations
+  // for more details on signed number representations.
+  static Bits SignAndMagnitudeToBiased(const Bits &sam) {
+    if (kSignBitMask & sam) {
+      // sam represents a negative number.
+      return ~sam + 1;
+    } else {
+      // sam represents a positive number.
+      return kSignBitMask | sam;
+    }
+  }
+
+  // Given two numbers in the sign-and-magnitude representation,
+  // returns the distance between them as an unsigned number.
+  static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1,
+                                                     const Bits &sam2) {
+    const Bits biased1 = SignAndMagnitudeToBiased(sam1);
+    const Bits biased2 = SignAndMagnitudeToBiased(sam2);
+    return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1);
+  }
+
+  FloatingPointUnion u_;
+};
+
+// We cannot use std::numeric_limits<T>::max() as it clashes with the max()
+// macro defined by <windows.h>.
+template <>
+inline float FloatingPoint<float>::Max() { return FLT_MAX; }
+template <>
+inline double FloatingPoint<double>::Max() { return DBL_MAX; }
+
+// Typedefs the instances of the FloatingPoint template class that we
+// care to use.
+typedef FloatingPoint<float> Float;
+typedef FloatingPoint<double> Double;
+
+// In order to catch the mistake of putting tests that use different
+// test fixture classes in the same test suite, we need to assign
+// unique IDs to fixture classes and compare them.  The TypeId type is
+// used to hold such IDs.  The user should treat TypeId as an opaque
+// type: the only operation allowed on TypeId values is to compare
+// them for equality using the == operator.
+typedef const void* TypeId;
+
+template <typename T>
+class TypeIdHelper {
+ public:
+  // dummy_ must not have a const type.  Otherwise an overly eager
+  // compiler (e.g. MSVC 7.1 & 8.0) may try to merge
+  // TypeIdHelper<T>::dummy_ for different Ts as an "optimization".
+  static bool dummy_;
+};
+
+template <typename T>
+bool TypeIdHelper<T>::dummy_ = false;
+
+// GetTypeId<T>() returns the ID of type T.  Different values will be
+// returned for different types.  Calling the function twice with the
+// same type argument is guaranteed to return the same ID.
+template <typename T>
+TypeId GetTypeId() {
+  // The compiler is required to allocate a different
+  // TypeIdHelper<T>::dummy_ variable for each T used to instantiate
+  // the template.  Therefore, the address of dummy_ is guaranteed to
+  // be unique.
+  return &(TypeIdHelper<T>::dummy_);
+}
+
+// Returns the type ID of ::testing::Test.  Always call this instead
+// of GetTypeId< ::testing::Test>() to get the type ID of
+// ::testing::Test, as the latter may give the wrong result due to a
+// suspected linker bug when compiling Google Test as a Mac OS X
+// framework.
+GTEST_API_ TypeId GetTestTypeId();
+
+// Defines the abstract factory interface that creates instances
+// of a Test object.
+class TestFactoryBase {
+ public:
+  virtual ~TestFactoryBase() {}
+
+  // Creates a test instance to run. The instance is both created and destroyed
+  // within TestInfoImpl::Run()
+  virtual Test* CreateTest() = 0;
+
+ protected:
+  TestFactoryBase() {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase);
+};
+
+// This class provides implementation of TeastFactoryBase interface.
+// It is used in TEST and TEST_F macros.
+template <class TestClass>
+class TestFactoryImpl : public TestFactoryBase {
+ public:
+  Test* CreateTest() override { return new TestClass; }
+};
+
+#if GTEST_OS_WINDOWS
+
+// Predicate-formatters for implementing the HRESULT checking macros
+// {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}
+// We pass a long instead of HRESULT to avoid causing an
+// include dependency for the HRESULT type.
+GTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr,
+                                            long hr);  // NOLINT
+GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr,
+                                            long hr);  // NOLINT
+
+#endif  // GTEST_OS_WINDOWS
+
+// Types of SetUpTestSuite() and TearDownTestSuite() functions.
+using SetUpTestSuiteFunc = void (*)();
+using TearDownTestSuiteFunc = void (*)();
+
+struct CodeLocation {
+  CodeLocation(const std::string& a_file, int a_line)
+      : file(a_file), line(a_line) {}
+
+  std::string file;
+  int line;
+};
+
+//  Helper to identify which setup function for TestCase / TestSuite to call.
+//  Only one function is allowed, either TestCase or TestSute but not both.
+
+// Utility functions to help SuiteApiResolver
+using SetUpTearDownSuiteFuncType = void (*)();
+
+inline SetUpTearDownSuiteFuncType GetNotDefaultOrNull(
+    SetUpTearDownSuiteFuncType a, SetUpTearDownSuiteFuncType def) {
+  return a == def ? nullptr : a;
+}
+
+template <typename T>
+//  Note that SuiteApiResolver inherits from T because
+//  SetUpTestSuite()/TearDownTestSuite() could be protected. Ths way
+//  SuiteApiResolver can access them.
+struct SuiteApiResolver : T {
+  // testing::Test is only forward declared at this point. So we make it a
+  // dependend class for the compiler to be OK with it.
+  using Test =
+      typename std::conditional<sizeof(T) != 0, ::testing::Test, void>::type;
+
+  static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
+                                                        int line_num) {
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+    SetUpTearDownSuiteFuncType test_case_fp =
+        GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
+    SetUpTearDownSuiteFuncType test_suite_fp =
+        GetNotDefaultOrNull(&T::SetUpTestSuite, &Test::SetUpTestSuite);
+
+    GTEST_CHECK_(!test_case_fp || !test_suite_fp)
+        << "Test can not provide both SetUpTestSuite and SetUpTestCase, please "
+           "make sure there is only one present at "
+        << filename << ":" << line_num;
+
+    return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
+#else
+    (void)(filename);
+    (void)(line_num);
+    return &T::SetUpTestSuite;
+#endif
+  }
+
+  static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
+                                                           int line_num) {
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+    SetUpTearDownSuiteFuncType test_case_fp =
+        GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
+    SetUpTearDownSuiteFuncType test_suite_fp =
+        GetNotDefaultOrNull(&T::TearDownTestSuite, &Test::TearDownTestSuite);
+
+    GTEST_CHECK_(!test_case_fp || !test_suite_fp)
+        << "Test can not provide both TearDownTestSuite and TearDownTestCase,"
+           " please make sure there is only one present at"
+        << filename << ":" << line_num;
+
+    return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
+#else
+    (void)(filename);
+    (void)(line_num);
+    return &T::TearDownTestSuite;
+#endif
+  }
+};
+
+// Creates a new TestInfo object and registers it with Google Test;
+// returns the created object.
+//
+// Arguments:
+//
+//   test_suite_name:  name of the test suite
+//   name:             name of the test
+//   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.
+//   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
+//   tear_down_tc:     pointer to the function that tears down the test suite
+//   factory:          pointer to the factory that creates a test object.
+//                     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,
+    const char* value_param, CodeLocation code_location,
+    TypeId fixture_class_id, SetUpTestSuiteFunc set_up_tc,
+    TearDownTestSuiteFunc tear_down_tc, TestFactoryBase* factory);
+
+// If *pstr starts with the given prefix, modifies *pstr to be right
+// past the prefix and returns true; otherwise leaves *pstr unchanged
+// and returns false.  None of pstr, *pstr, and prefix can be NULL.
+GTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr);
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+// State of the definition of a type-parameterized test suite.
+class GTEST_API_ TypedTestSuitePState {
+ public:
+  TypedTestSuitePState() : registered_(false) {}
+
+  // Adds the given test name to defined_test_names_ and return true
+  // if the test suite hasn't been registered; otherwise aborts the
+  // program.
+  bool AddTestName(const char* file, int line, const char* case_name,
+                   const char* test_name) {
+    if (registered_) {
+      fprintf(stderr,
+              "%s Test %s must be defined before "
+              "REGISTER_TYPED_TEST_SUITE_P(%s, ...).\n",
+              FormatFileLocation(file, line).c_str(), test_name, case_name);
+      fflush(stderr);
+      posix::Abort();
+    }
+    registered_tests_.insert(
+        ::std::make_pair(test_name, CodeLocation(file, line)));
+    return true;
+  }
+
+  bool TestExists(const std::string& test_name) const {
+    return registered_tests_.count(test_name) > 0;
+  }
+
+  const CodeLocation& GetCodeLocation(const std::string& test_name) const {
+    RegisteredTestsMap::const_iterator it = registered_tests_.find(test_name);
+    GTEST_CHECK_(it != registered_tests_.end());
+    return it->second;
+  }
+
+  // Verifies that registered_tests match the test names in
+  // defined_test_names_; returns registered_tests if successful, or
+  // aborts the program otherwise.
+  const char* VerifyRegisteredTestNames(const char* test_suite_name,
+                                        const char* file, int line,
+                                        const char* registered_tests);
+
+ private:
+  typedef ::std::map<std::string, CodeLocation> RegisteredTestsMap;
+
+  bool registered_;
+  RegisteredTestsMap registered_tests_;
+};
+
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+using TypedTestCasePState = TypedTestSuitePState;
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+// Skips to the first non-space char after the first comma in 'str';
+// returns NULL if no comma is found in 'str'.
+inline const char* SkipComma(const char* str) {
+  const char* comma = strchr(str, ',');
+  if (comma == nullptr) {
+    return nullptr;
+  }
+  while (IsSpace(*(++comma))) {}
+  return comma;
+}
+
+// Returns the prefix of 'str' before the first comma in it; returns
+// the entire string if it contains no comma.
+inline std::string GetPrefixUntilComma(const char* str) {
+  const char* comma = strchr(str, ',');
+  return comma == nullptr ? str : std::string(str, comma);
+}
+
+// Splits a given string on a given delimiter, populating a given
+// vector with the fields.
+void SplitString(const ::std::string& str, char delimiter,
+                 ::std::vector< ::std::string>* dest);
+
+// The default argument to the template below for the case when the user does
+// not provide a name generator.
+struct DefaultNameGenerator {
+  template <typename T>
+  static std::string GetName(int i) {
+    return StreamableToString(i);
+  }
+};
+
+template <typename Provided = DefaultNameGenerator>
+struct NameGeneratorSelector {
+  typedef Provided type;
+};
+
+template <typename NameGenerator>
+void GenerateNamesRecursively(internal::None, std::vector<std::string>*, int) {}
+
+template <typename NameGenerator, typename Types>
+void GenerateNamesRecursively(Types, std::vector<std::string>* result, int i) {
+  result->push_back(NameGenerator::template GetName<typename Types::Head>(i));
+  GenerateNamesRecursively<NameGenerator>(typename Types::Tail(), result,
+                                          i + 1);
+}
+
+template <typename NameGenerator, typename Types>
+std::vector<std::string> GenerateNames() {
+  std::vector<std::string> result;
+  GenerateNamesRecursively<NameGenerator>(Types(), &result, 0);
+  return result;
+}
+
+// TypeParameterizedTest<Fixture, TestSel, Types>::Register()
+// registers a list of type-parameterized tests with Google Test.  The
+// return value is insignificant - we just need to return something
+// such that we can call this function in a namespace scope.
+//
+// Implementation note: The GTEST_TEMPLATE_ macro declares a template
+// template parameter.  It's defined in gtest-type-util.h.
+template <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types>
+class TypeParameterizedTest {
+ public:
+  // 'index' is the index of the test in the type list 'Types'
+  // specified in INSTANTIATE_TYPED_TEST_SUITE_P(Prefix, TestSuite,
+  // Types).  Valid values for 'index' are [0, N - 1] where N is the
+  // length of Types.
+  static bool Register(const char* prefix, const CodeLocation& code_location,
+                       const char* case_name, const char* test_names, int index,
+                       const std::vector<std::string>& type_names =
+                           GenerateNames<DefaultNameGenerator, Types>()) {
+    typedef typename Types::Head Type;
+    typedef Fixture<Type> FixtureClass;
+    typedef typename GTEST_BIND_(TestSel, Type) TestClass;
+
+    // First, registers the first type-parameterized test in the type
+    // list.
+    MakeAndRegisterTestInfo(
+        (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name +
+         "/" + type_names[static_cast<size_t>(index)])
+            .c_str(),
+        StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(),
+        GetTypeName<Type>().c_str(),
+        nullptr,  // No value parameter.
+        code_location, GetTypeId<FixtureClass>(),
+        SuiteApiResolver<TestClass>::GetSetUpCaseOrSuite(
+            code_location.file.c_str(), code_location.line),
+        SuiteApiResolver<TestClass>::GetTearDownCaseOrSuite(
+            code_location.file.c_str(), code_location.line),
+        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);
+  }
+};
+
+// The base case for the compile time recursion.
+template <GTEST_TEMPLATE_ Fixture, class TestSel>
+class TypeParameterizedTest<Fixture, TestSel, internal::None> {
+ public:
+  static bool Register(const char* /*prefix*/, const CodeLocation&,
+                       const char* /*case_name*/, const char* /*test_names*/,
+                       int /*index*/,
+                       const std::vector<std::string>& =
+                           std::vector<std::string>() /*type_names*/) {
+    return true;
+  }
+};
+
+GTEST_API_ void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
+                                                   CodeLocation code_location);
+GTEST_API_ void RegisterTypeParameterizedTestSuiteInstantiation(
+    const char* case_name);
+
+// TypeParameterizedTestSuite<Fixture, Tests, Types>::Register()
+// registers *all combinations* of 'Tests' and 'Types' with Google
+// Test.  The return value is insignificant - we just need to return
+// something such that we can call this function in a namespace scope.
+template <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types>
+class TypeParameterizedTestSuite {
+ public:
+  static bool Register(const char* prefix, CodeLocation code_location,
+                       const TypedTestSuitePState* state, const char* case_name,
+                       const char* test_names,
+                       const std::vector<std::string>& type_names =
+                           GenerateNames<DefaultNameGenerator, Types>()) {
+    RegisterTypeParameterizedTestSuiteInstantiation(case_name);
+    std::string test_name = StripTrailingSpaces(
+        GetPrefixUntilComma(test_names));
+    if (!state->TestExists(test_name)) {
+      fprintf(stderr, "Failed to get code location for test %s.%s at %s.",
+              case_name, test_name.c_str(),
+              FormatFileLocation(code_location.file.c_str(),
+                                 code_location.line).c_str());
+      fflush(stderr);
+      posix::Abort();
+    }
+    const CodeLocation& test_location = state->GetCodeLocation(test_name);
+
+    typedef typename Tests::Head Head;
+
+    // First, register the first test in 'Test' for each type in 'Types'.
+    TypeParameterizedTest<Fixture, Head, Types>::Register(
+        prefix, test_location, case_name, test_names, 0, type_names);
+
+    // Next, recurses (at compile time) with the tail of the test list.
+    return TypeParameterizedTestSuite<Fixture, typename Tests::Tail,
+                                      Types>::Register(prefix, code_location,
+                                                       state, case_name,
+                                                       SkipComma(test_names),
+                                                       type_names);
+  }
+};
+
+// The base case for the compile time recursion.
+template <GTEST_TEMPLATE_ Fixture, typename Types>
+class TypeParameterizedTestSuite<Fixture, internal::None, Types> {
+ public:
+  static bool Register(const char* /*prefix*/, const CodeLocation&,
+                       const TypedTestSuitePState* /*state*/,
+                       const char* /*case_name*/, const char* /*test_names*/,
+                       const std::vector<std::string>& =
+                           std::vector<std::string>() /*type_names*/) {
+    return true;
+  }
+};
+
+// Returns the current OS stack trace as an std::string.
+//
+// The maximum number of stack frames to be included is specified by
+// the gtest_stack_trace_depth flag.  The skip_count parameter
+// specifies the number of top frames to be skipped, which doesn't
+// count against the number of frames to be included.
+//
+// For example, if Foo() calls Bar(), which in turn calls
+// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
+// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
+GTEST_API_ std::string GetCurrentOsStackTraceExceptTop(
+    UnitTest* unit_test, int skip_count);
+
+// Helpers for suppressing warnings on unreachable code or constant
+// condition.
+
+// Always returns true.
+GTEST_API_ bool AlwaysTrue();
+
+// Always returns false.
+inline bool AlwaysFalse() { return !AlwaysTrue(); }
+
+// Helper for suppressing false warning from Clang on a const char*
+// variable declared in a conditional expression always being NULL in
+// the else branch.
+struct GTEST_API_ ConstCharPtr {
+  ConstCharPtr(const char* str) : value(str) {}
+  operator bool() const { return true; }
+  const char* value;
+};
+
+// Helper for declaring std::string within 'if' statement
+// in pre C++17 build environment.
+struct TrueWithString {
+  TrueWithString() = default;
+  explicit TrueWithString(const char* str) : value(str) {}
+  explicit TrueWithString(const std::string& str) : value(str) {}
+  explicit operator bool() const { return true; }
+  std::string value;
+};
+
+// A simple Linear Congruential Generator for generating random
+// numbers with a uniform distribution.  Unlike rand() and srand(), it
+// doesn't use global state (and therefore can't interfere with user
+// code).  Unlike rand_r(), it's portable.  An LCG isn't very random,
+// but it's good enough for our purposes.
+class GTEST_API_ Random {
+ public:
+  static const uint32_t kMaxRange = 1u << 31;
+
+  explicit Random(uint32_t seed) : state_(seed) {}
+
+  void Reseed(uint32_t seed) { state_ = seed; }
+
+  // Generates a random number from [0, range).  Crashes if 'range' is
+  // 0 or greater than kMaxRange.
+  uint32_t Generate(uint32_t range);
+
+ private:
+  uint32_t state_;
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Random);
+};
+
+// Turns const U&, U&, const U, and U all into U.
+#define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \
+  typename std::remove_const<typename std::remove_reference<T>::type>::type
+
+// HasDebugStringAndShortDebugString<T>::value is a compile-time bool constant
+// that's true if and only if T has methods DebugString() and ShortDebugString()
+// that return std::string.
+template <typename T>
+class HasDebugStringAndShortDebugString {
+ private:
+  template <typename C>
+  static auto CheckDebugString(C*) -> typename std::is_same<
+      std::string, decltype(std::declval<const C>().DebugString())>::type;
+  template <typename>
+  static std::false_type CheckDebugString(...);
+
+  template <typename C>
+  static auto CheckShortDebugString(C*) -> typename std::is_same<
+      std::string, decltype(std::declval<const C>().ShortDebugString())>::type;
+  template <typename>
+  static std::false_type CheckShortDebugString(...);
+
+  using HasDebugStringType = decltype(CheckDebugString<T>(nullptr));
+  using HasShortDebugStringType = decltype(CheckShortDebugString<T>(nullptr));
+
+ public:
+  static constexpr bool value =
+      HasDebugStringType::value && HasShortDebugStringType::value;
+};
+
+template <typename T>
+constexpr bool HasDebugStringAndShortDebugString<T>::value;
+
+// 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
+// valid types and NULL can be implicitly converted to them).  It will
+// be picked over the second overload as 'int' is a perfect match for
+// the type of argument 0.  If C::iterator or C::const_iterator is not
+// a valid type, the first overload is not viable, and the second
+// overload will be picked.  Therefore, we can determine whether C is
+// a container class by checking the type of IsContainerTest<C>(0).
+// The value of the expression is insignificant.
+//
+// In C++11 mode we check the existence of a const_iterator and that an
+// iterator is properly implemented for the container.
+//
+// For pre-C++11 that we look for both C::iterator and C::const_iterator.
+// The reason is that C++ injects the name of a class as a member of the
+// class itself (e.g. you can refer to class iterator as either
+// 'iterator' or 'iterator::iterator').  If we look for C::iterator
+// only, for example, we would mistakenly think that a class named
+// iterator is an STL container.
+//
+// Also note that the simpler approach of overloading
+// IsContainerTest(typename C::const_iterator*) and
+// IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++.
+typedef int IsContainer;
+template <class C,
+          class Iterator = decltype(::std::declval<const C&>().begin()),
+          class = decltype(::std::declval<const C&>().end()),
+          class = decltype(++::std::declval<Iterator&>()),
+          class = decltype(*::std::declval<Iterator>()),
+          class = typename C::const_iterator>
+IsContainer IsContainerTest(int /* dummy */) {
+  return 0;
+}
+
+typedef char IsNotContainer;
+template <class C>
+IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; }
+
+// Trait to detect whether a type T is a hash table.
+// The heuristic used is that the type contains an inner type `hasher` and does
+// not contain an inner type `reverse_iterator`.
+// If the container is iterable in reverse, then order might actually matter.
+template <typename T>
+struct IsHashTable {
+ private:
+  template <typename U>
+  static char test(typename U::hasher*, typename U::reverse_iterator*);
+  template <typename U>
+  static int test(typename U::hasher*, ...);
+  template <typename U>
+  static char test(...);
+
+ public:
+  static const bool value = sizeof(test<T>(nullptr, nullptr)) == sizeof(int);
+};
+
+template <typename T>
+const bool IsHashTable<T>::value;
+
+template <typename C,
+          bool = sizeof(IsContainerTest<C>(0)) == sizeof(IsContainer)>
+struct IsRecursiveContainerImpl;
+
+template <typename C>
+struct IsRecursiveContainerImpl<C, false> : public std::false_type {};
+
+// Since the IsRecursiveContainerImpl depends on the IsContainerTest we need to
+// obey the same inconsistencies as the IsContainerTest, namely check if
+// something is a container is relying on only const_iterator in C++11 and
+// is relying on both const_iterator and iterator otherwise
+template <typename C>
+struct IsRecursiveContainerImpl<C, true> {
+  using value_type = decltype(*std::declval<typename C::const_iterator>());
+  using type =
+      std::is_same<typename std::remove_const<
+                       typename std::remove_reference<value_type>::type>::type,
+                   C>;
+};
+
+// IsRecursiveContainer<Type> is a unary compile-time predicate that
+// evaluates whether C is a recursive container type. A recursive container
+// type is a container type whose value_type is equal to the container type
+// itself. An example for a recursive container type is
+// boost::filesystem::path, whose iterator has a value_type that is equal to
+// boost::filesystem::path.
+template <typename C>
+struct IsRecursiveContainer : public IsRecursiveContainerImpl<C>::type {};
+
+// Utilities for native arrays.
+
+// ArrayEq() compares two k-dimensional native arrays using the
+// elements' operator==, where k can be any integer >= 0.  When k is
+// 0, ArrayEq() degenerates into comparing a single pair of values.
+
+template <typename T, typename U>
+bool ArrayEq(const T* lhs, size_t size, const U* rhs);
+
+// This generic version is used when k is 0.
+template <typename T, typename U>
+inline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; }
+
+// This overload is used when k >= 1.
+template <typename T, typename U, size_t N>
+inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) {
+  return internal::ArrayEq(lhs, N, rhs);
+}
+
+// This helper reduces code bloat.  If we instead put its logic inside
+// the previous ArrayEq() function, arrays with different sizes would
+// lead to different copies of the template code.
+template <typename T, typename U>
+bool ArrayEq(const T* lhs, size_t size, const U* rhs) {
+  for (size_t i = 0; i != size; i++) {
+    if (!internal::ArrayEq(lhs[i], rhs[i]))
+      return false;
+  }
+  return true;
+}
+
+// Finds the first element in the iterator range [begin, end) that
+// equals elem.  Element may be a native array type itself.
+template <typename Iter, typename Element>
+Iter ArrayAwareFind(Iter begin, Iter end, const Element& elem) {
+  for (Iter it = begin; it != end; ++it) {
+    if (internal::ArrayEq(*it, elem))
+      return it;
+  }
+  return end;
+}
+
+// CopyArray() copies a k-dimensional native array using the elements'
+// operator=, where k can be any integer >= 0.  When k is 0,
+// CopyArray() degenerates into copying a single value.
+
+template <typename T, typename U>
+void CopyArray(const T* from, size_t size, U* to);
+
+// This generic version is used when k is 0.
+template <typename T, typename U>
+inline void CopyArray(const T& from, U* to) { *to = from; }
+
+// This overload is used when k >= 1.
+template <typename T, typename U, size_t N>
+inline void CopyArray(const T(&from)[N], U(*to)[N]) {
+  internal::CopyArray(from, N, *to);
+}
+
+// This helper reduces code bloat.  If we instead put its logic inside
+// the previous CopyArray() function, arrays with different sizes
+// would lead to different copies of the template code.
+template <typename T, typename U>
+void CopyArray(const T* from, size_t size, U* to) {
+  for (size_t i = 0; i != size; i++) {
+    internal::CopyArray(from[i], to + i);
+  }
+}
+
+// The relation between an NativeArray object (see below) and the
+// native array it represents.
+// We use 2 different structs to allow non-copyable types to be used, as long
+// as RelationToSourceReference() is passed.
+struct RelationToSourceReference {};
+struct RelationToSourceCopy {};
+
+// Adapts a native array to a read-only STL-style container.  Instead
+// of the complete STL container concept, this adaptor only implements
+// members useful for Google Mock's container matchers.  New members
+// should be added as needed.  To simplify the implementation, we only
+// support Element being a raw type (i.e. having no top-level const or
+// reference modifier).  It's the client's responsibility to satisfy
+// this requirement.  Element can be an array type itself (hence
+// multi-dimensional arrays are supported).
+template <typename Element>
+class NativeArray {
+ public:
+  // STL-style container typedefs.
+  typedef Element value_type;
+  typedef Element* iterator;
+  typedef const Element* const_iterator;
+
+  // Constructs from a native array. References the source.
+  NativeArray(const Element* array, size_t count, RelationToSourceReference) {
+    InitRef(array, count);
+  }
+
+  // Constructs from a native array. Copies the source.
+  NativeArray(const Element* array, size_t count, RelationToSourceCopy) {
+    InitCopy(array, count);
+  }
+
+  // Copy constructor.
+  NativeArray(const NativeArray& rhs) {
+    (this->*rhs.clone_)(rhs.array_, rhs.size_);
+  }
+
+  ~NativeArray() {
+    if (clone_ != &NativeArray::InitRef)
+      delete[] array_;
+  }
+
+  // STL-style container methods.
+  size_t size() const { return size_; }
+  const_iterator begin() const { return array_; }
+  const_iterator end() const { return array_ + size_; }
+  bool operator==(const NativeArray& rhs) const {
+    return size() == rhs.size() &&
+        ArrayEq(begin(), size(), rhs.begin());
+  }
+
+ private:
+  static_assert(!std::is_const<Element>::value, "Type must not be const");
+  static_assert(!std::is_reference<Element>::value,
+                "Type must not be a reference");
+
+  // Initializes this object with a copy of the input.
+  void InitCopy(const Element* array, size_t a_size) {
+    Element* const copy = new Element[a_size];
+    CopyArray(array, a_size, copy);
+    array_ = copy;
+    size_ = a_size;
+    clone_ = &NativeArray::InitCopy;
+  }
+
+  // Initializes this object with a reference of the input.
+  void InitRef(const Element* array, size_t a_size) {
+    array_ = array;
+    size_ = a_size;
+    clone_ = &NativeArray::InitRef;
+  }
+
+  const Element* array_;
+  size_t size_;
+  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
+};
+
+template <typename>
+struct ElemFromListImpl;
+template <size_t... I>
+struct ElemFromListImpl<IndexSequence<I...>> {
+  // We make Ignore a template to solve a problem with MSVC.
+  // A non-template Ignore would work fine with `decltype(Ignore(I))...`, but
+  // MSVC doesn't understand how to deal with that pack expansion.
+  // Use `0 * I` to have a single instantiation of Ignore.
+  template <typename R>
+  static R Apply(Ignore<0 * I>..., R (*)(), ...);
+};
+
+template <size_t N, typename... T>
+struct ElemFromList {
+  using type =
+      decltype(ElemFromListImpl<typename MakeIndexSequence<N>::type>::Apply(
+          static_cast<T (*)()>(nullptr)...));
+};
+
+struct FlatTupleConstructTag {};
+
+template <typename... T>
+class FlatTuple;
+
+template <typename Derived, size_t I>
+struct FlatTupleElemBase;
+
+template <typename... T, size_t I>
+struct FlatTupleElemBase<FlatTuple<T...>, I> {
+  using value_type = typename ElemFromList<I, T...>::type;
+  FlatTupleElemBase() = default;
+  template <typename Arg>
+  explicit FlatTupleElemBase(FlatTupleConstructTag, Arg&& t)
+      : value(std::forward<Arg>(t)) {}
+  value_type value;
+};
+
+template <typename Derived, typename Idx>
+struct FlatTupleBase;
+
+template <size_t... Idx, typename... T>
+struct FlatTupleBase<FlatTuple<T...>, IndexSequence<Idx...>>
+    : FlatTupleElemBase<FlatTuple<T...>, Idx>... {
+  using Indices = IndexSequence<Idx...>;
+  FlatTupleBase() = default;
+  template <typename... Args>
+  explicit FlatTupleBase(FlatTupleConstructTag, Args&&... args)
+      : FlatTupleElemBase<FlatTuple<T...>, Idx>(FlatTupleConstructTag{},
+                                                std::forward<Args>(args))... {}
+
+  template <size_t I>
+  const typename ElemFromList<I, T...>::type& Get() const {
+    return FlatTupleElemBase<FlatTuple<T...>, I>::value;
+  }
+
+  template <size_t I>
+  typename ElemFromList<I, T...>::type& Get() {
+    return FlatTupleElemBase<FlatTuple<T...>, I>::value;
+  }
+
+  template <typename F>
+  auto Apply(F&& f) -> decltype(std::forward<F>(f)(this->Get<Idx>()...)) {
+    return std::forward<F>(f)(Get<Idx>()...);
+  }
+
+  template <typename F>
+  auto Apply(F&& f) const -> decltype(std::forward<F>(f)(this->Get<Idx>()...)) {
+    return std::forward<F>(f)(Get<Idx>()...);
+  }
+};
+
+// Analog to std::tuple but with different tradeoffs.
+// This class minimizes the template instantiation depth, thus allowing more
+// elements than std::tuple would. std::tuple has been seen to require an
+// instantiation depth of more than 10x the number of elements in some
+// 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
+// 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;
+
+ public:
+  FlatTuple() = default;
+  template <typename... Args>
+  explicit FlatTuple(FlatTupleConstructTag tag, Args&&... args)
+      : FlatTuple::FlatTupleBase(tag, std::forward<Args>(args)...) {}
+
+  using FlatTuple::FlatTupleBase::Apply;
+  using FlatTuple::FlatTupleBase::Get;
+};
+
+// Utility functions to be called with static_assert to induce deprecation
+// warnings.
+GTEST_INTERNAL_DEPRECATED(
+    "INSTANTIATE_TEST_CASE_P is deprecated, please use "
+    "INSTANTIATE_TEST_SUITE_P")
+constexpr bool InstantiateTestCase_P_IsDeprecated() { return true; }
+
+GTEST_INTERNAL_DEPRECATED(
+    "TYPED_TEST_CASE_P is deprecated, please use "
+    "TYPED_TEST_SUITE_P")
+constexpr bool TypedTestCase_P_IsDeprecated() { return true; }
+
+GTEST_INTERNAL_DEPRECATED(
+    "TYPED_TEST_CASE is deprecated, please use "
+    "TYPED_TEST_SUITE")
+constexpr bool TypedTestCaseIsDeprecated() { return true; }
+
+GTEST_INTERNAL_DEPRECATED(
+    "REGISTER_TYPED_TEST_CASE_P is deprecated, please use "
+    "REGISTER_TYPED_TEST_SUITE_P")
+constexpr bool RegisterTypedTestCase_P_IsDeprecated() { return true; }
+
+GTEST_INTERNAL_DEPRECATED(
+    "INSTANTIATE_TYPED_TEST_CASE_P is deprecated, please use "
+    "INSTANTIATE_TYPED_TEST_SUITE_P")
+constexpr bool InstantiateTypedTestCase_P_IsDeprecated() { return true; }
+
+}  // namespace internal
+}  // namespace testing
+
+namespace std {
+// Some standard library implementations use `struct tuple_size` and some use
+// `class tuple_size`. Clang warns about the mismatch.
+// https://reviews.llvm.org/D55466
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wmismatched-tags"
+#endif
+template <typename... Ts>
+struct tuple_size<testing::internal::FlatTuple<Ts...>>
+    : std::integral_constant<size_t, sizeof...(Ts)> {};
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+}  // namespace std
+
+#define GTEST_MESSAGE_AT_(file, line, message, result_type) \
+  ::testing::internal::AssertHelper(result_type, file, line, message) \
+    = ::testing::Message()
+
+#define GTEST_MESSAGE_(message, result_type) \
+  GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type)
+
+#define GTEST_FATAL_FAILURE_(message) \
+  return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure)
+
+#define GTEST_NONFATAL_FAILURE_(message) \
+  GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure)
+
+#define GTEST_SUCCESS_(message) \
+  GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)
+
+#define GTEST_SKIP_(message) \
+  return GTEST_MESSAGE_(message, ::testing::TestPartResult::kSkip)
+
+// Suppress MSVC warning 4072 (unreachable code) for the code following
+// statement if it returns or throws (or doesn't return or throw in some
+// situations).
+// NOTE: The "else" is important to keep this expansion to prevent a top-level
+// "else" from attaching to our "if".
+#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
+  if (::testing::internal::AlwaysTrue()) {                        \
+    statement;                                                    \
+  } else                     /* NOLINT */                         \
+    static_assert(true, "")  // User must have a semicolon after expansion.
+
+#if GTEST_HAS_EXCEPTIONS
+
+namespace testing {
+namespace internal {
+
+class NeverThrown {
+ public:
+  const char* what() const noexcept {
+    return "this exception should never be thrown";
+  }
+};
+
+}  // namespace internal
+}  // namespace testing
+
+#if GTEST_HAS_RTTI
+
+#define GTEST_EXCEPTION_TYPE_(e) ::testing::internal::GetTypeName(typeid(e))
+
+#else  // GTEST_HAS_RTTI
+
+#define GTEST_EXCEPTION_TYPE_(e) \
+  std::string { "an std::exception-derived error" }
+
+#endif  // GTEST_HAS_RTTI
+
+#define GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)   \
+  catch (typename std::conditional<                                            \
+         std::is_same<typename std::remove_cv<typename std::remove_reference<  \
+                          expected_exception>::type>::type,                    \
+                      std::exception>::value,                                  \
+         const ::testing::internal::NeverThrown&, const std::exception&>::type \
+             e) {                                                              \
+    gtest_msg.value = "Expected: " #statement                                  \
+                      " throws an exception of type " #expected_exception      \
+                      ".\n  Actual: it throws ";                               \
+    gtest_msg.value += GTEST_EXCEPTION_TYPE_(e);                               \
+    gtest_msg.value += " with description \"";                                 \
+    gtest_msg.value += e.what();                                               \
+    gtest_msg.value += "\".";                                                  \
+    goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);                \
+  }
+
+#else  // GTEST_HAS_EXCEPTIONS
+
+#define GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+#define GTEST_TEST_THROW_(statement, expected_exception, fail)              \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                             \
+  if (::testing::internal::TrueWithString gtest_msg{}) {                    \
+    bool gtest_caught_expected = false;                                     \
+    try {                                                                   \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement);            \
+    } catch (expected_exception const&) {                                   \
+      gtest_caught_expected = true;                                         \
+    }                                                                       \
+    GTEST_TEST_THROW_CATCH_STD_EXCEPTION_(statement, expected_exception)    \
+    catch (...) {                                                           \
+      gtest_msg.value = "Expected: " #statement                             \
+                        " throws an exception of type " #expected_exception \
+                        ".\n  Actual: it throws a different type.";         \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);           \
+    }                                                                       \
+    if (!gtest_caught_expected) {                                           \
+      gtest_msg.value = "Expected: " #statement                             \
+                        " throws an exception of type " #expected_exception \
+                        ".\n  Actual: it throws nothing.";                  \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__);           \
+    }                                                                       \
+  } else /*NOLINT*/                                                         \
+    GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__)                   \
+        : fail(gtest_msg.value.c_str())
+
+#if GTEST_HAS_EXCEPTIONS
+
+#define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_()                \
+  catch (std::exception const& e) {                               \
+    gtest_msg.value = "it throws ";                               \
+    gtest_msg.value += GTEST_EXCEPTION_TYPE_(e);                  \
+    gtest_msg.value += " with description \"";                    \
+    gtest_msg.value += e.what();                                  \
+    gtest_msg.value += "\".";                                     \
+    goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
+  }
+
+#else  // GTEST_HAS_EXCEPTIONS
+
+#define GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_()
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+#define GTEST_TEST_NO_THROW_(statement, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::TrueWithString gtest_msg{}) { \
+    try { \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+    } \
+    GTEST_TEST_NO_THROW_CATCH_STD_EXCEPTION_() \
+    catch (...) { \
+      gtest_msg.value = "it throws."; \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \
+    } \
+  } else \
+    GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \
+      fail(("Expected: " #statement " doesn't throw an exception.\n" \
+            "  Actual: " + gtest_msg.value).c_str())
+
+#define GTEST_TEST_ANY_THROW_(statement, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::AlwaysTrue()) { \
+    bool gtest_caught_any = false; \
+    try { \
+      GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+    } \
+    catch (...) { \
+      gtest_caught_any = true; \
+    } \
+    if (!gtest_caught_any) { \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \
+    } \
+  } else \
+    GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \
+      fail("Expected: " #statement " throws an exception.\n" \
+           "  Actual: it doesn't.")
+
+
+// Implements Boolean test assertions such as EXPECT_TRUE. expression can be
+// either a boolean expression or an AssertionResult. text is a textual
+// representation of expression as it was passed into the EXPECT_TRUE.
+#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (const ::testing::AssertionResult gtest_ar_ = \
+      ::testing::AssertionResult(expression)) \
+    ; \
+  else \
+    fail(::testing::internal::GetBoolAssertionFailureMessage(\
+        gtest_ar_, text, #actual, #expected).c_str())
+
+#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \
+  GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+  if (::testing::internal::AlwaysTrue()) { \
+    ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \
+    GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \
+    if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \
+      goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \
+    } \
+  } else \
+    GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \
+      fail("Expected: " #statement " doesn't generate new fatal " \
+           "failures in the current thread.\n" \
+           "  Actual: it does.")
+
+// Expands to the name of the class that implements the given test.
+#define GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
+  test_suite_name##_##test_name##_Test
+
+// Helper macro for defining tests.
+#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id)      \
+  static_assert(sizeof(GTEST_STRINGIFY_(test_suite_name)) > 1,                \
+                "test_suite_name must not be empty");                         \
+  static_assert(sizeof(GTEST_STRINGIFY_(test_name)) > 1,                      \
+                "test_name must not be empty");                               \
+  class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                    \
+      : public parent_class {                                                 \
+   public:                                                                    \
+    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() = default;           \
+    ~GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() override = default; \
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,   \
+                                                           test_name));       \
+    GTEST_DISALLOW_MOVE_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name,   \
+                                                           test_name));       \
+                                                                              \
+   private:                                                                   \
+    void TestBody() override;                                                 \
+    static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;     \
+  };                                                                          \
+                                                                              \
+  ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name,          \
+                                                    test_name)::test_info_ =  \
+      ::testing::internal::MakeAndRegisterTestInfo(                           \
+          #test_suite_name, #test_name, nullptr, nullptr,                     \
+          ::testing::internal::CodeLocation(__FILE__, __LINE__), (parent_id), \
+          ::testing::internal::SuiteApiResolver<                              \
+              parent_class>::GetSetUpCaseOrSuite(__FILE__, __LINE__),         \
+          ::testing::internal::SuiteApiResolver<                              \
+              parent_class>::GetTearDownCaseOrSuite(__FILE__, __LINE__),      \
+          new ::testing::internal::TestFactoryImpl<GTEST_TEST_CLASS_NAME_(    \
+              test_suite_name, test_name)>);                                  \
+  void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-param-util.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-param-util.h
new file mode 100644
index 000000000..c2ef6e312
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-param-util.h
@@ -0,0 +1,947 @@
+// Copyright 2008 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.
+
+
+// Type and function utilities for implementing parameterized tests.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
+
+#include <ctype.h>
+
+#include <cassert>
+#include <iterator>
+#include <memory>
+#include <set>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-port.h"
+#include "gtest/gtest-printers.h"
+#include "gtest/gtest-test-part.h"
+
+namespace testing {
+// Input to a parameterized test name generator, describing a test parameter.
+// Consists of the parameter value and the integer parameter index.
+template <class ParamType>
+struct TestParamInfo {
+  TestParamInfo(const ParamType& a_param, size_t an_index) :
+    param(a_param),
+    index(an_index) {}
+  ParamType param;
+  size_t index;
+};
+
+// A builtin parameterized test name generator which returns the result of
+// testing::PrintToString.
+struct PrintToStringParamName {
+  template <class ParamType>
+  std::string operator()(const TestParamInfo<ParamType>& info) const {
+    return PrintToString(info.param);
+  }
+};
+
+namespace internal {
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+// Utility Functions
+
+// Outputs a message explaining invalid registration of different
+// fixture class for the same test suite. This may happen when
+// 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);
+
+template <typename> class ParamGeneratorInterface;
+template <typename> class ParamGenerator;
+
+// Interface for iterating over elements provided by an implementation
+// of ParamGeneratorInterface<T>.
+template <typename T>
+class ParamIteratorInterface {
+ public:
+  virtual ~ParamIteratorInterface() {}
+  // A pointer to the base generator instance.
+  // Used only for the purposes of iterator comparison
+  // to make sure that two iterators belong to the same generator.
+  virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0;
+  // Advances iterator to point to the next element
+  // provided by the generator. The caller is responsible
+  // for not calling Advance() on an iterator equal to
+  // BaseGenerator()->End().
+  virtual void Advance() = 0;
+  // Clones the iterator object. Used for implementing copy semantics
+  // of ParamIterator<T>.
+  virtual ParamIteratorInterface* Clone() const = 0;
+  // Dereferences the current iterator and provides (read-only) access
+  // to the pointed value. It is the caller's responsibility not to call
+  // Current() on an iterator equal to BaseGenerator()->End().
+  // Used for implementing ParamGenerator<T>::operator*().
+  virtual const T* Current() const = 0;
+  // Determines whether the given iterator and other point to the same
+  // element in the sequence generated by the generator.
+  // Used for implementing ParamGenerator<T>::operator==().
+  virtual bool Equals(const ParamIteratorInterface& other) const = 0;
+};
+
+// Class iterating over elements provided by an implementation of
+// ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T>
+// and implements the const forward iterator concept.
+template <typename T>
+class ParamIterator {
+ public:
+  typedef T value_type;
+  typedef const T& reference;
+  typedef ptrdiff_t difference_type;
+
+  // ParamIterator assumes ownership of the impl_ pointer.
+  ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {}
+  ParamIterator& operator=(const ParamIterator& other) {
+    if (this != &other)
+      impl_.reset(other.impl_->Clone());
+    return *this;
+  }
+
+  const T& operator*() const { return *impl_->Current(); }
+  const T* operator->() const { return impl_->Current(); }
+  // Prefix version of operator++.
+  ParamIterator& operator++() {
+    impl_->Advance();
+    return *this;
+  }
+  // Postfix version of operator++.
+  ParamIterator operator++(int /*unused*/) {
+    ParamIteratorInterface<T>* clone = impl_->Clone();
+    impl_->Advance();
+    return ParamIterator(clone);
+  }
+  bool operator==(const ParamIterator& other) const {
+    return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_);
+  }
+  bool operator!=(const ParamIterator& other) const {
+    return !(*this == other);
+  }
+
+ private:
+  friend class ParamGenerator<T>;
+  explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {}
+  std::unique_ptr<ParamIteratorInterface<T> > impl_;
+};
+
+// ParamGeneratorInterface<T> is the binary interface to access generators
+// defined in other translation units.
+template <typename T>
+class ParamGeneratorInterface {
+ public:
+  typedef T ParamType;
+
+  virtual ~ParamGeneratorInterface() {}
+
+  // Generator interface definition
+  virtual ParamIteratorInterface<T>* Begin() const = 0;
+  virtual ParamIteratorInterface<T>* End() const = 0;
+};
+
+// Wraps ParamGeneratorInterface<T> and provides general generator syntax
+// compatible with the STL Container concept.
+// This class implements copy initialization semantics and the contained
+// ParamGeneratorInterface<T> instance is shared among all copies
+// of the original object. This is possible because that instance is immutable.
+template<typename T>
+class ParamGenerator {
+ public:
+  typedef ParamIterator<T> iterator;
+
+  explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {}
+  ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {}
+
+  ParamGenerator& operator=(const ParamGenerator& other) {
+    impl_ = other.impl_;
+    return *this;
+  }
+
+  iterator begin() const { return iterator(impl_->Begin()); }
+  iterator end() const { return iterator(impl_->End()); }
+
+ private:
+  std::shared_ptr<const ParamGeneratorInterface<T> > impl_;
+};
+
+// Generates values from a range of two comparable values. Can be used to
+// generate sequences of user-defined types that implement operator+() and
+// operator<().
+// This class is used in the Range() function.
+template <typename T, typename IncrementT>
+class RangeGenerator : public ParamGeneratorInterface<T> {
+ public:
+  RangeGenerator(T begin, T end, IncrementT step)
+      : begin_(begin), end_(end),
+        step_(step), end_index_(CalculateEndIndex(begin, end, step)) {}
+  ~RangeGenerator() override {}
+
+  ParamIteratorInterface<T>* Begin() const override {
+    return new Iterator(this, begin_, 0, step_);
+  }
+  ParamIteratorInterface<T>* End() const override {
+    return new Iterator(this, end_, end_index_, step_);
+  }
+
+ private:
+  class Iterator : public ParamIteratorInterface<T> {
+   public:
+    Iterator(const ParamGeneratorInterface<T>* base, T value, int index,
+             IncrementT step)
+        : base_(base), value_(value), index_(index), step_(step) {}
+    ~Iterator() override {}
+
+    const ParamGeneratorInterface<T>* BaseGenerator() const override {
+      return base_;
+    }
+    void Advance() override {
+      value_ = static_cast<T>(value_ + step_);
+      index_++;
+    }
+    ParamIteratorInterface<T>* Clone() const override {
+      return new Iterator(*this);
+    }
+    const T* Current() const override { return &value_; }
+    bool Equals(const ParamIteratorInterface<T>& other) const override {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      const int other_index =
+          CheckedDowncastToActualType<const Iterator>(&other)->index_;
+      return index_ == other_index;
+    }
+
+   private:
+    Iterator(const Iterator& other)
+        : ParamIteratorInterface<T>(),
+          base_(other.base_), value_(other.value_), index_(other.index_),
+          step_(other.step_) {}
+
+    // No implementation - assignment is unsupported.
+    void operator=(const Iterator& other);
+
+    const ParamGeneratorInterface<T>* const base_;
+    T value_;
+    int index_;
+    const IncrementT step_;
+  };  // class RangeGenerator::Iterator
+
+  static int CalculateEndIndex(const T& begin,
+                               const T& end,
+                               const IncrementT& step) {
+    int end_index = 0;
+    for (T i = begin; i < end; i = static_cast<T>(i + step))
+      end_index++;
+    return end_index;
+  }
+
+  // No implementation - assignment is unsupported.
+  void operator=(const RangeGenerator& other);
+
+  const T begin_;
+  const T end_;
+  const IncrementT step_;
+  // The index for the end() iterator. All the elements in the generated
+  // sequence are indexed (0-based) to aid iterator comparison.
+  const int end_index_;
+};  // class RangeGenerator
+
+
+// Generates values from a pair of STL-style iterators. Used in the
+// ValuesIn() function. The elements are copied from the source range
+// since the source can be located on the stack, and the generator
+// is likely to persist beyond that stack frame.
+template <typename T>
+class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> {
+ public:
+  template <typename ForwardIterator>
+  ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end)
+      : container_(begin, end) {}
+  ~ValuesInIteratorRangeGenerator() override {}
+
+  ParamIteratorInterface<T>* Begin() const override {
+    return new Iterator(this, container_.begin());
+  }
+  ParamIteratorInterface<T>* End() const override {
+    return new Iterator(this, container_.end());
+  }
+
+ private:
+  typedef typename ::std::vector<T> ContainerType;
+
+  class Iterator : public ParamIteratorInterface<T> {
+   public:
+    Iterator(const ParamGeneratorInterface<T>* base,
+             typename ContainerType::const_iterator iterator)
+        : base_(base), iterator_(iterator) {}
+    ~Iterator() override {}
+
+    const ParamGeneratorInterface<T>* BaseGenerator() const override {
+      return base_;
+    }
+    void Advance() override {
+      ++iterator_;
+      value_.reset();
+    }
+    ParamIteratorInterface<T>* Clone() const override {
+      return new Iterator(*this);
+    }
+    // We need to use cached value referenced by iterator_ because *iterator_
+    // can return a temporary object (and of type other then T), so just
+    // having "return &*iterator_;" doesn't work.
+    // value_ is updated here and not in Advance() because Advance()
+    // can advance iterator_ beyond the end of the range, and we cannot
+    // detect that fact. The client code, on the other hand, is
+    // responsible for not calling Current() on an out-of-range iterator.
+    const T* Current() const override {
+      if (value_.get() == nullptr) value_.reset(new T(*iterator_));
+      return value_.get();
+    }
+    bool Equals(const ParamIteratorInterface<T>& other) const override {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      return iterator_ ==
+          CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
+    }
+
+   private:
+    Iterator(const Iterator& other)
+          // The explicit constructor call suppresses a false warning
+          // emitted by gcc when supplied with the -Wextra option.
+        : ParamIteratorInterface<T>(),
+          base_(other.base_),
+          iterator_(other.iterator_) {}
+
+    const ParamGeneratorInterface<T>* const base_;
+    typename ContainerType::const_iterator iterator_;
+    // A cached value of *iterator_. We keep it here to allow access by
+    // pointer in the wrapping iterator's operator->().
+    // value_ needs to be mutable to be accessed in Current().
+    // Use of std::unique_ptr helps manage cached value's lifetime,
+    // which is bound by the lifespan of the iterator itself.
+    mutable std::unique_ptr<const T> value_;
+  };  // class ValuesInIteratorRangeGenerator::Iterator
+
+  // No implementation - assignment is unsupported.
+  void operator=(const ValuesInIteratorRangeGenerator& other);
+
+  const ContainerType container_;
+};  // class ValuesInIteratorRangeGenerator
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Default parameterized test name generator, returns a string containing the
+// 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();
+}
+
+template <typename T = int>
+void TestNotEmpty() {
+  static_assert(sizeof(T) == 0, "Empty arguments are not allowed.");
+}
+template <typename T = int>
+void TestNotEmpty(const T&) {}
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Stores a parameter value and later creates tests parameterized with that
+// value.
+template <class TestClass>
+class ParameterizedTestFactory : public TestFactoryBase {
+ public:
+  typedef typename TestClass::ParamType ParamType;
+  explicit ParameterizedTestFactory(ParamType parameter) :
+      parameter_(parameter) {}
+  Test* CreateTest() override {
+    TestClass::SetParam(&parameter_);
+    return new TestClass();
+  }
+
+ private:
+  const ParamType parameter_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory);
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// TestMetaFactoryBase is a base class for meta-factories that create
+// test factories for passing into MakeAndRegisterTestInfo function.
+template <class ParamType>
+class TestMetaFactoryBase {
+ public:
+  virtual ~TestMetaFactoryBase() {}
+
+  virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0;
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// TestMetaFactory creates test factories for passing into
+// MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives
+// ownership of test factory pointer, same factory object cannot be passed
+// into that method twice. But ParameterizedTestSuiteInfo is going to call
+// it for each Test/Parameter value combination. Thus it needs meta factory
+// creator class.
+template <class TestSuite>
+class TestMetaFactory
+    : public TestMetaFactoryBase<typename TestSuite::ParamType> {
+ public:
+  using ParamType = typename TestSuite::ParamType;
+
+  TestMetaFactory() {}
+
+  TestFactoryBase* CreateTestFactory(ParamType parameter) override {
+    return new ParameterizedTestFactory<TestSuite>(parameter);
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory);
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// ParameterizedTestSuiteInfoBase is a generic interface
+// to ParameterizedTestSuiteInfo classes. ParameterizedTestSuiteInfoBase
+// accumulates test information provided by TEST_P macro invocations
+// and generators provided by INSTANTIATE_TEST_SUITE_P macro invocations
+// and uses that information to register all resulting test instances
+// in RegisterTests method. The ParameterizeTestSuiteRegistry class holds
+// a collection of pointers to the ParameterizedTestSuiteInfo objects
+// and calls RegisterTests() on each of them when asked.
+class ParameterizedTestSuiteInfoBase {
+ public:
+  virtual ~ParameterizedTestSuiteInfoBase() {}
+
+  // Base part of test suite name for display purposes.
+  virtual const std::string& GetTestSuiteName() const = 0;
+  // Test suite id to verify identity.
+  virtual TypeId GetTestSuiteTypeId() const = 0;
+  // UnitTest class invokes this method to register tests in this
+  // test suite right before running them in RUN_ALL_TESTS macro.
+  // This method should not be called more than once on any single
+  // instance of a ParameterizedTestSuiteInfoBase derived class.
+  virtual void RegisterTests() = 0;
+
+ protected:
+  ParameterizedTestSuiteInfoBase() {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfoBase);
+};
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Report a the name of a test_suit as safe to ignore
+// as the side effect of construction of this type.
+struct GTEST_API_ MarkAsIgnored {
+  explicit MarkAsIgnored(const char* test_suite);
+};
+
+GTEST_API_ void InsertSyntheticTestCase(const std::string& name,
+                                        CodeLocation location, bool has_test_p);
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// ParameterizedTestSuiteInfo accumulates tests obtained from TEST_P
+// macro invocations for a particular test suite and generators
+// obtained from INSTANTIATE_TEST_SUITE_P macro invocations for that
+// test suite. It registers tests with all values generated by all
+// generators when asked.
+template <class TestSuite>
+class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
+ public:
+  // ParamType and GeneratorCreationFunc are private types but are required
+  // for declarations of public methods AddTestPattern() and
+  // AddTestSuiteInstantiation().
+  using ParamType = typename TestSuite::ParamType;
+  // A function that returns an instance of appropriate generator type.
+  typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
+  using ParamNameGeneratorFunc = std::string(const TestParamInfo<ParamType>&);
+
+  explicit ParameterizedTestSuiteInfo(const char* name,
+                                      CodeLocation code_location)
+      : test_suite_name_(name), code_location_(code_location) {}
+
+  // Test suite base name for display purposes.
+  const std::string& GetTestSuiteName() const override {
+    return test_suite_name_;
+  }
+  // Test suite id to verify identity.
+  TypeId GetTestSuiteTypeId() const override { return GetTypeId<TestSuite>(); }
+  // TEST_P macro uses AddTestPattern() to record information
+  // about a single test in a LocalTestInfo structure.
+  // test_suite_name is the base name of the test suite (without invocation
+  // 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,
+                      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)));
+  }
+  // INSTANTIATE_TEST_SUITE_P macro uses AddGenerator() to record information
+  // about a generator.
+  int AddTestSuiteInstantiation(const 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));
+    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
+  // right before running tests in RUN_ALL_TESTS macro.
+  // This method should not be called more than once on any single
+  // instance of a ParameterizedTestSuiteInfoBase derived class.
+  // UnitTest has a guard to prevent from calling this method more than once.
+  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;
+        if ( !instantiation_name.empty() )
+          test_suite_name = instantiation_name + "/";
+        test_suite_name += test_info->test_suite_base_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) {
+          generated_instantiations = true;
+
+          Message test_name_stream;
+
+          std::string param_name = name_func(
+              TestParamInfo<ParamType>(*param_it, i));
+
+          GTEST_CHECK_(IsValidParamName(param_name))
+              << "Parameterized test name '" << param_name
+              << "' is invalid, in " << file
+              << " line " << line << std::endl;
+
+          GTEST_CHECK_(test_param_names.count(param_name) == 0)
+              << "Duplicate parameterized test name '" << param_name
+              << "', in " << file << " line " << line << std::endl;
+
+          test_param_names.insert(param_name);
+
+          if (!test_info->test_base_name.empty()) {
+            test_name_stream << test_info->test_base_name << "/";
+          }
+          test_name_stream << param_name;
+          MakeAndRegisterTestInfo(
+              test_suite_name.c_str(), test_name_stream.GetString().c_str(),
+              nullptr,  // No type parameter.
+              PrintToString(*param_it).c_str(), test_info->code_location,
+              GetTestSuiteTypeId(),
+              SuiteApiResolver<TestSuite>::GetSetUpCaseOrSuite(file, line),
+              SuiteApiResolver<TestSuite>::GetTearDownCaseOrSuite(file, line),
+              test_info->test_meta_factory->CreateTestFactory(*param_it));
+        }  // for param_it
+      }  // for gen_it
+    }  // for test_it
+
+    if (!generated_instantiations) {
+      // There are no generaotrs, or they all generate nothing ...
+      InsertSyntheticTestCase(GetTestSuiteName(), code_location_,
+                              !tests_.empty());
+    }
+  }    // RegisterTests
+
+ private:
+  // 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,
+             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_meta_factory(a_test_meta_factory),
+          code_location(a_code_location) {}
+
+    const std::string test_suite_base_name;
+    const std::string test_base_name;
+    const std::unique_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory;
+    const CodeLocation code_location;
+  };
+  using TestInfoContainer = ::std::vector<std::shared_ptr<TestInfo> >;
+  // Records data received from INSTANTIATE_TEST_SUITE_P macros:
+  //  <Instantiation name, Sequence generator creation function,
+  //     Name generator function, Source file, Source line>
+  struct InstantiationInfo {
+      InstantiationInfo(const std::string &name_in,
+                        GeneratorCreationFunc* generator_in,
+                        ParamNameGeneratorFunc* name_func_in,
+                        const char* file_in,
+                        int line_in)
+          : name(name_in),
+            generator(generator_in),
+            name_func(name_func_in),
+            file(file_in),
+            line(line_in) {}
+
+      std::string name;
+      GeneratorCreationFunc* generator;
+      ParamNameGeneratorFunc* name_func;
+      const char* file;
+      int line;
+  };
+  typedef ::std::vector<InstantiationInfo> InstantiationContainer;
+
+  static bool IsValidParamName(const std::string& name) {
+    // Check for empty string
+    if (name.empty())
+      return false;
+
+    // Check for invalid characters
+    for (std::string::size_type index = 0; index < name.size(); ++index) {
+      if (!IsAlNum(name[index]) && name[index] != '_')
+        return false;
+    }
+
+    return true;
+  }
+
+  const std::string test_suite_name_;
+  CodeLocation code_location_;
+  TestInfoContainer tests_;
+  InstantiationContainer instantiations_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfo);
+};  // class ParameterizedTestSuiteInfo
+
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+template <class TestCase>
+using ParameterizedTestCaseInfo = ParameterizedTestSuiteInfo<TestCase>;
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// ParameterizedTestSuiteRegistry contains a map of
+// ParameterizedTestSuiteInfoBase classes accessed by test suite names. TEST_P
+// and INSTANTIATE_TEST_SUITE_P macros use it to locate their corresponding
+// ParameterizedTestSuiteInfo descriptors.
+class ParameterizedTestSuiteRegistry {
+ public:
+  ParameterizedTestSuiteRegistry() {}
+  ~ParameterizedTestSuiteRegistry() {
+    for (auto& test_suite_info : test_suite_infos_) {
+      delete test_suite_info;
+    }
+  }
+
+  // Looks up or creates and returns a structure containing information about
+  // tests and instantiations of a particular test suite.
+  template <class TestSuite>
+  ParameterizedTestSuiteInfo<TestSuite>* GetTestSuitePatternHolder(
+      const char* 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;
+      }
+    }
+    if (typed_test_info == nullptr) {
+      typed_test_info = new ParameterizedTestSuiteInfo<TestSuite>(
+          test_suite_name, code_location);
+      test_suite_infos_.push_back(typed_test_info);
+    }
+    return typed_test_info;
+  }
+  void RegisterTests() {
+    for (auto& test_suite_info : test_suite_infos_) {
+      test_suite_info->RegisterTests();
+    }
+  }
+//  Legacy API is deprecated but still available
+#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);
+  }
+
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+ private:
+  using TestSuiteInfoContainer = ::std::vector<ParameterizedTestSuiteInfoBase*>;
+
+  TestSuiteInfoContainer test_suite_infos_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteRegistry);
+};
+
+// Keep track of what type-parameterized test suite are defined and
+// where as well as which are intatiated. This allows susequently
+// identifying suits that are defined but never used.
+class TypeParameterizedTestSuiteRegistry {
+ public:
+  // Add a suite definition
+  void RegisterTestSuite(const char* test_suite_name,
+                         CodeLocation code_location);
+
+  // Add an instantiation of a suit.
+  void RegisterInstantiation(const char* test_suite_name);
+
+  // For each suit repored as defined but not reported as instantiation,
+  // emit a test that reports that fact (configurably, as an error).
+  void CheckForInstantiations();
+
+ private:
+  struct TypeParameterizedTestSuiteInfo {
+    explicit TypeParameterizedTestSuiteInfo(CodeLocation c)
+        : code_location(c), instantiated(false) {}
+
+    CodeLocation code_location;
+    bool instantiated;
+  };
+
+  std::map<std::string, TypeParameterizedTestSuiteInfo> suites_;
+};
+
+}  // namespace internal
+
+// Forward declarations of ValuesIn(), which is implemented in
+// include/gtest/gtest-param-test.h.
+template <class Container>
+internal::ParamGenerator<typename Container::value_type> ValuesIn(
+    const Container& container);
+
+namespace internal {
+// Used in the Values() function to provide polymorphic capabilities.
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4100)
+#endif
+
+template <typename... Ts>
+class ValueArray {
+ public:
+  explicit ValueArray(Ts... v) : v_(FlatTupleConstructTag{}, std::move(v)...) {}
+
+  template <typename T>
+  operator ParamGenerator<T>() const {  // NOLINT
+    return ValuesIn(MakeVector<T>(MakeIndexSequence<sizeof...(Ts)>()));
+  }
+
+ private:
+  template <typename T, size_t... I>
+  std::vector<T> MakeVector(IndexSequence<I...>) const {
+    return std::vector<T>{static_cast<T>(v_.template Get<I>())...};
+  }
+
+  FlatTuple<Ts...> v_;
+};
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+template <typename... T>
+class CartesianProductGenerator
+    : public ParamGeneratorInterface<::std::tuple<T...>> {
+ public:
+  typedef ::std::tuple<T...> ParamType;
+
+  CartesianProductGenerator(const std::tuple<ParamGenerator<T>...>& g)
+      : generators_(g) {}
+  ~CartesianProductGenerator() override {}
+
+  ParamIteratorInterface<ParamType>* Begin() const override {
+    return new Iterator(this, generators_, false);
+  }
+  ParamIteratorInterface<ParamType>* End() const override {
+    return new Iterator(this, generators_, true);
+  }
+
+ private:
+  template <class I>
+  class IteratorImpl;
+  template <size_t... I>
+  class IteratorImpl<IndexSequence<I...>>
+      : public ParamIteratorInterface<ParamType> {
+   public:
+    IteratorImpl(const ParamGeneratorInterface<ParamType>* base,
+             const std::tuple<ParamGenerator<T>...>& generators, bool is_end)
+        : base_(base),
+          begin_(std::get<I>(generators).begin()...),
+          end_(std::get<I>(generators).end()...),
+          current_(is_end ? end_ : begin_) {
+      ComputeCurrentValue();
+    }
+    ~IteratorImpl() override {}
+
+    const ParamGeneratorInterface<ParamType>* BaseGenerator() const override {
+      return base_;
+    }
+    // Advance should not be called on beyond-of-range iterators
+    // so no component iterators must be beyond end of range, either.
+    void Advance() override {
+      assert(!AtEnd());
+      // Advance the last iterator.
+      ++std::get<sizeof...(T) - 1>(current_);
+      // if that reaches end, propagate that up.
+      AdvanceIfEnd<sizeof...(T) - 1>();
+      ComputeCurrentValue();
+    }
+    ParamIteratorInterface<ParamType>* Clone() const override {
+      return new IteratorImpl(*this);
+    }
+
+    const ParamType* Current() const override { return current_value_.get(); }
+
+    bool Equals(const ParamIteratorInterface<ParamType>& other) const override {
+      // Having the same base generator guarantees that the other
+      // iterator is of the same type and we can downcast.
+      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
+          << "The program attempted to compare iterators "
+          << "from different generators." << std::endl;
+      const IteratorImpl* typed_other =
+          CheckedDowncastToActualType<const IteratorImpl>(&other);
+
+      // We must report iterators equal if they both point beyond their
+      // respective ranges. That can happen in a variety of fashions,
+      // so we have to consult AtEnd().
+      if (AtEnd() && typed_other->AtEnd()) return true;
+
+      bool same = true;
+      bool dummy[] = {
+          (same = same && std::get<I>(current_) ==
+                              std::get<I>(typed_other->current_))...};
+      (void)dummy;
+      return same;
+    }
+
+   private:
+    template <size_t ThisI>
+    void AdvanceIfEnd() {
+      if (std::get<ThisI>(current_) != std::get<ThisI>(end_)) return;
+
+      bool last = ThisI == 0;
+      if (last) {
+        // We are done. Nothing else to propagate.
+        return;
+      }
+
+      constexpr size_t NextI = ThisI - (ThisI != 0);
+      std::get<ThisI>(current_) = std::get<ThisI>(begin_);
+      ++std::get<NextI>(current_);
+      AdvanceIfEnd<NextI>();
+    }
+
+    void ComputeCurrentValue() {
+      if (!AtEnd())
+        current_value_ = std::make_shared<ParamType>(*std::get<I>(current_)...);
+    }
+    bool AtEnd() const {
+      bool at_end = false;
+      bool dummy[] = {
+          (at_end = at_end || std::get<I>(current_) == std::get<I>(end_))...};
+      (void)dummy;
+      return at_end;
+    }
+
+    const ParamGeneratorInterface<ParamType>* const base_;
+    std::tuple<typename ParamGenerator<T>::iterator...> begin_;
+    std::tuple<typename ParamGenerator<T>::iterator...> end_;
+    std::tuple<typename ParamGenerator<T>::iterator...> current_;
+    std::shared_ptr<ParamType> current_value_;
+  };
+
+  using Iterator = IteratorImpl<typename MakeIndexSequence<sizeof...(T)>::type>;
+
+  std::tuple<ParamGenerator<T>...> generators_;
+};
+
+template <class... Gen>
+class CartesianProductHolder {
+ public:
+  CartesianProductHolder(const Gen&... g) : generators_(g...) {}
+  template <typename... T>
+  operator ParamGenerator<::std::tuple<T...>>() const {
+    return ParamGenerator<::std::tuple<T...>>(
+        new CartesianProductGenerator<T...>(generators_));
+  }
+
+ private:
+  std::tuple<Gen...> generators_;
+};
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-port-arch.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-port-arch.h
new file mode 100644
index 000000000..dd845915e
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-port-arch.h
@@ -0,0 +1,114 @@
+// Copyright 2015, 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.
+//
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file defines the GTEST_OS_* macro.
+// It is separate from gtest-port.h so that custom/gtest-port.h can include it.
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
+
+// Determines the platform on which Google Test is compiled.
+#ifdef __CYGWIN__
+# define GTEST_OS_CYGWIN 1
+# elif defined(__MINGW__) || defined(__MINGW32__) || defined(__MINGW64__)
+#  define GTEST_OS_WINDOWS_MINGW 1
+#  define GTEST_OS_WINDOWS 1
+#elif defined _WIN32
+# define GTEST_OS_WINDOWS 1
+# ifdef _WIN32_WCE
+#  define GTEST_OS_WINDOWS_MOBILE 1
+# elif defined(WINAPI_FAMILY)
+#  include <winapifamily.h>
+#  if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#   define GTEST_OS_WINDOWS_DESKTOP 1
+#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)
+#   define GTEST_OS_WINDOWS_PHONE 1
+#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+#   define GTEST_OS_WINDOWS_RT 1
+#  elif WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_TV_TITLE)
+#   define GTEST_OS_WINDOWS_PHONE 1
+#   define GTEST_OS_WINDOWS_TV_TITLE 1
+#  else
+    // WINAPI_FAMILY defined but no known partition matched.
+    // Default to desktop.
+#   define GTEST_OS_WINDOWS_DESKTOP 1
+#  endif
+# else
+#  define GTEST_OS_WINDOWS_DESKTOP 1
+# endif  // _WIN32_WCE
+#elif defined __OS2__
+# define GTEST_OS_OS2 1
+#elif defined __APPLE__
+# define GTEST_OS_MAC 1
+# include <TargetConditionals.h>
+# if TARGET_OS_IPHONE
+#  define GTEST_OS_IOS 1
+# endif
+#elif defined __DragonFly__
+# define GTEST_OS_DRAGONFLY 1
+#elif defined __FreeBSD__
+# define GTEST_OS_FREEBSD 1
+#elif defined __Fuchsia__
+# define GTEST_OS_FUCHSIA 1
+#elif defined(__GLIBC__) && defined(__FreeBSD_kernel__)
+# define GTEST_OS_GNU_KFREEBSD 1
+#elif defined __linux__
+# define GTEST_OS_LINUX 1
+# if defined __ANDROID__
+#  define GTEST_OS_LINUX_ANDROID 1
+# endif
+#elif defined __MVS__
+# define GTEST_OS_ZOS 1
+#elif defined(__sun) && defined(__SVR4)
+# define GTEST_OS_SOLARIS 1
+#elif defined(_AIX)
+# define GTEST_OS_AIX 1
+#elif defined(__hpux)
+# define GTEST_OS_HPUX 1
+#elif defined __native_client__
+# define GTEST_OS_NACL 1
+#elif defined __NetBSD__
+# define GTEST_OS_NETBSD 1
+#elif defined __OpenBSD__
+# define GTEST_OS_OPENBSD 1
+#elif defined __QNX__
+# define GTEST_OS_QNX 1
+#elif defined(__HAIKU__)
+#define GTEST_OS_HAIKU 1
+#elif defined ESP8266
+#define GTEST_OS_ESP8266 1
+#elif defined ESP32
+#define GTEST_OS_ESP32 1
+#elif defined(__XTENSA__)
+#define GTEST_OS_XTENSA 1
+#endif  // __CYGWIN__
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_ARCH_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-port.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-port.h
new file mode 100644
index 000000000..0953a781c
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-port.h
@@ -0,0 +1,2389 @@
+// Copyright 2005, 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.
+//
+// Low-level types and utilities for porting Google Test to various
+// platforms.  All macros ending with _ and symbols defined in an
+// internal namespace are subject to change without notice.  Code
+// outside Google Test MUST NOT USE THEM DIRECTLY.  Macros that don't
+// end with _ are part of Google Test's public API and can be used by
+// code outside Google Test.
+//
+// This file is fundamental to Google Test.  All other Google Test source
+// files are expected to #include this.  Therefore, it cannot #include
+// any other Google Test header.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
+
+// Environment-describing macros
+// -----------------------------
+//
+// Google Test can be used in many different environments.  Macros in
+// this section tell Google Test what kind of environment it is being
+// used in, such that Google Test can provide environment-specific
+// features and implementations.
+//
+// Google Test tries to automatically detect the properties of its
+// environment, so users usually don't need to worry about these
+// macros.  However, the automatic detection is not perfect.
+// Sometimes it's necessary for a user to define some of the following
+// macros in the build script to override Google Test's decisions.
+//
+// If the user doesn't define a macro in the list, Google Test will
+// provide a default definition.  After this header is #included, all
+// macros in this list will be defined to either 1 or 0.
+//
+// Notes to maintainers:
+//   - Each macro here is a user-tweakable knob; do not grow the list
+//     lightly.
+//   - Use #if to key off these macros.  Don't use #ifdef or "#if
+//     defined(...)", which will not work as these macros are ALWAYS
+//     defined.
+//
+//   GTEST_HAS_CLONE          - Define it to 1/0 to indicate that clone(2)
+//                              is/isn't available.
+//   GTEST_HAS_EXCEPTIONS     - Define it to 1/0 to indicate that exceptions
+//                              are enabled.
+//   GTEST_HAS_POSIX_RE       - Define it to 1/0 to indicate that POSIX regular
+//                              expressions are/aren't available.
+//   GTEST_HAS_PTHREAD        - Define it to 1/0 to indicate that <pthread.h>
+//                              is/isn't available.
+//   GTEST_HAS_RTTI           - Define it to 1/0 to indicate that RTTI is/isn't
+//                              enabled.
+//   GTEST_HAS_STD_WSTRING    - Define it to 1/0 to indicate that
+//                              std::wstring does/doesn't work (Google Test can
+//                              be used where std::wstring is unavailable).
+//   GTEST_HAS_SEH            - Define it to 1/0 to indicate whether the
+//                              compiler supports Microsoft's "Structured
+//                              Exception Handling".
+//   GTEST_HAS_STREAM_REDIRECTION
+//                            - Define it to 1/0 to indicate whether the
+//                              platform supports I/O stream redirection using
+//                              dup() and dup2().
+//   GTEST_LINKED_AS_SHARED_LIBRARY
+//                            - Define to 1 when compiling tests that use
+//                              Google Test as a shared library (known as
+//                              DLL on Windows).
+//   GTEST_CREATE_SHARED_LIBRARY
+//                            - Define to 1 when compiling Google Test itself
+//                              as a shared library.
+//   GTEST_DEFAULT_DEATH_TEST_STYLE
+//                            - The default value of --gtest_death_test_style.
+//                              The legacy default has been "fast" in the open
+//                              source version since 2008. The recommended value
+//                              is "threadsafe", and can be set in
+//                              custom/gtest-port.h.
+
+// Platform-indicating macros
+// --------------------------
+//
+// Macros indicating the platform on which Google Test is being used
+// (a macro is defined to 1 if compiled on the given platform;
+// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
+// defines these macros automatically.  Code outside Google Test MUST
+// NOT define them.
+//
+//   GTEST_OS_AIX      - IBM AIX
+//   GTEST_OS_CYGWIN   - Cygwin
+//   GTEST_OS_DRAGONFLY - DragonFlyBSD
+//   GTEST_OS_FREEBSD  - FreeBSD
+//   GTEST_OS_FUCHSIA  - Fuchsia
+//   GTEST_OS_GNU_KFREEBSD - GNU/kFreeBSD
+//   GTEST_OS_HAIKU    - Haiku
+//   GTEST_OS_HPUX     - HP-UX
+//   GTEST_OS_LINUX    - Linux
+//     GTEST_OS_LINUX_ANDROID - Google Android
+//   GTEST_OS_MAC      - Mac OS X
+//     GTEST_OS_IOS    - iOS
+//   GTEST_OS_NACL     - Google Native Client (NaCl)
+//   GTEST_OS_NETBSD   - NetBSD
+//   GTEST_OS_OPENBSD  - OpenBSD
+//   GTEST_OS_OS2      - OS/2
+//   GTEST_OS_QNX      - QNX
+//   GTEST_OS_SOLARIS  - Sun Solaris
+//   GTEST_OS_WINDOWS  - Windows (Desktop, MinGW, or Mobile)
+//     GTEST_OS_WINDOWS_DESKTOP  - Windows Desktop
+//     GTEST_OS_WINDOWS_MINGW    - MinGW
+//     GTEST_OS_WINDOWS_MOBILE   - Windows Mobile
+//     GTEST_OS_WINDOWS_PHONE    - Windows Phone
+//     GTEST_OS_WINDOWS_RT       - Windows Store App/WinRT
+//   GTEST_OS_ZOS      - z/OS
+//
+// Among the platforms, Cygwin, Linux, Mac OS X, and Windows have the
+// most stable support.  Since core members of the Google Test project
+// don't have access to other platforms, support for them may be less
+// stable.  If you notice any problems on your platform, please notify
+// googletestframework@googlegroups.com (patches for fixing them are
+// even more welcome!).
+//
+// It is possible that none of the GTEST_OS_* macros are defined.
+
+// Feature-indicating macros
+// -------------------------
+//
+// Macros indicating which Google Test features are available (a macro
+// is defined to 1 if the corresponding feature is supported;
+// otherwise UNDEFINED -- it's never defined to 0.).  Google Test
+// defines these macros automatically.  Code outside Google Test MUST
+// NOT define them.
+//
+// These macros are public so that portable tests can be written.
+// Such tests typically surround code using a feature with an #if
+// which controls that code.  For example:
+//
+// #if GTEST_HAS_DEATH_TEST
+//   EXPECT_DEATH(DoSomethingDeadly());
+// #endif
+//
+//   GTEST_HAS_DEATH_TEST   - death tests
+//   GTEST_HAS_TYPED_TEST   - typed tests
+//   GTEST_HAS_TYPED_TEST_P - type-parameterized tests
+//   GTEST_IS_THREADSAFE    - Google Test is thread-safe.
+//   GOOGLETEST_CM0007 DO NOT DELETE
+//   GTEST_USES_POSIX_RE    - enhanced POSIX regex is used. Do not confuse with
+//                            GTEST_HAS_POSIX_RE (see above) which users can
+//                            define themselves.
+//   GTEST_USES_SIMPLE_RE   - our own simple regex is used;
+//                            the above RE\b(s) are mutually exclusive.
+
+// Misc public macros
+// ------------------
+//
+//   GTEST_FLAG(flag_name)  - references the variable corresponding to
+//                            the given Google Test flag.
+
+// Internal utilities
+// ------------------
+//
+// The following macros and utilities are for Google Test's INTERNAL
+// use only.  Code outside Google Test MUST NOT USE THEM DIRECTLY.
+//
+// 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_DISALLOW_ASSIGN_   - disables copy operator=.
+//   GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
+//   GTEST_DISALLOW_MOVE_ASSIGN_   - disables move operator=.
+//   GTEST_DISALLOW_MOVE_AND_ASSIGN_ - disables move ctor and operator=.
+//   GTEST_MUST_USE_RESULT_   - declares that a function's result must be used.
+//   GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is
+//                                        suppressed (constant conditional).
+//   GTEST_INTENTIONAL_CONST_COND_POP_  - finish code section where MSVC C4127
+//                                        is suppressed.
+//   GTEST_INTERNAL_HAS_ANY - for enabling UniversalPrinter<std::any> or
+//                            UniversalPrinter<absl::any> specializations.
+//   GTEST_INTERNAL_HAS_OPTIONAL - for enabling UniversalPrinter<std::optional>
+//   or
+//                                 UniversalPrinter<absl::optional>
+//                                 specializations.
+//   GTEST_INTERNAL_HAS_STRING_VIEW - for enabling Matcher<std::string_view> or
+//                                    Matcher<absl::string_view>
+//                                    specializations.
+//   GTEST_INTERNAL_HAS_VARIANT - for enabling UniversalPrinter<std::variant> or
+//                                UniversalPrinter<absl::variant>
+//                                specializations.
+//
+// Synchronization:
+//   Mutex, MutexLock, ThreadLocal, GetThreadCount()
+//                            - synchronization primitives.
+//
+// Regular expressions:
+//   RE             - a simple regular expression class using the POSIX
+//                    Extended Regular Expression syntax on UNIX-like platforms
+//                    GOOGLETEST_CM0008 DO NOT DELETE
+//                    or a reduced regular exception syntax on other
+//                    platforms, including Windows.
+// Logging:
+//   GTEST_LOG_()   - logs messages at the specified severity level.
+//   LogToStderr()  - directs all log messages to stderr.
+//   FlushInfoLog() - flushes informational log messages.
+//
+// Stdout and stderr capturing:
+//   CaptureStdout()     - starts capturing stdout.
+//   GetCapturedStdout() - stops capturing stdout and returns the captured
+//                         string.
+//   CaptureStderr()     - starts capturing stderr.
+//   GetCapturedStderr() - stops capturing stderr and returns the captured
+//                         string.
+//
+// Integer types:
+//   TypeWithSize   - maps an integer to a int type.
+//   TimeInMillis   - integers of known sizes.
+//   BiggestInt     - the biggest signed integer type.
+//
+// Command-line utilities:
+//   GTEST_DECLARE_*()  - declares a flag.
+//   GTEST_DEFINE_*()   - defines a flag.
+//   GetInjectableArgvs() - returns the command line as a vector of strings.
+//
+// Environment variable utilities:
+//   GetEnv()             - gets the value of an environment variable.
+//   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
+
+#include <ctype.h>   // for isspace, etc
+#include <stddef.h>  // for ptrdiff_t
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <cerrno>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+#ifndef _WIN32_WCE
+# include <sys/types.h>
+# include <sys/stat.h>
+#endif  // !_WIN32_WCE
+
+#if defined __APPLE__
+# include <AvailabilityMacros.h>
+# include <TargetConditionals.h>
+#endif
+
+#include <iostream>  // NOLINT
+#include <locale>
+#include <memory>
+#include <string>  // NOLINT
+#include <tuple>
+#include <vector>  // NOLINT
+
+#include "gtest/internal/custom/gtest-port.h"
+#include "gtest/internal/gtest-port-arch.h"
+
+#if !defined(GTEST_DEV_EMAIL_)
+# define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
+# define GTEST_FLAG_PREFIX_ "gtest_"
+# define GTEST_FLAG_PREFIX_DASH_ "gtest-"
+# define GTEST_FLAG_PREFIX_UPPER_ "GTEST_"
+# define GTEST_NAME_ "Google Test"
+# define GTEST_PROJECT_URL_ "https://github.com/google/googletest/"
+#endif  // !defined(GTEST_DEV_EMAIL_)
+
+#if !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
+# define GTEST_INIT_GOOGLE_TEST_NAME_ "testing::InitGoogleTest"
+#endif  // !defined(GTEST_INIT_GOOGLE_TEST_NAME_)
+
+// Determines the version of gcc that is used to compile this.
+#ifdef __GNUC__
+// 40302 means version 4.3.2.
+# define GTEST_GCC_VER_ \
+    (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__)
+#endif  // __GNUC__
+
+// Macros for disabling Microsoft Visual C++ warnings.
+//
+//   GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385)
+//   /* code that triggers warnings C4800 and C4385 */
+//   GTEST_DISABLE_MSC_WARNINGS_POP_()
+#if defined(_MSC_VER)
+# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
+    __pragma(warning(push))                        \
+    __pragma(warning(disable: warnings))
+# define GTEST_DISABLE_MSC_WARNINGS_POP_()          \
+    __pragma(warning(pop))
+#else
+// Not all compilers are MSVC
+# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings)
+# define GTEST_DISABLE_MSC_WARNINGS_POP_()
+#endif
+
+// Clang on Windows does not understand MSVC's pragma warning.
+// We need clang-specific way to disable function deprecation warning.
+#ifdef __clang__
+# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_()                         \
+    _Pragma("clang diagnostic push")                                  \
+    _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") \
+    _Pragma("clang diagnostic ignored \"-Wdeprecated-implementations\"")
+#define GTEST_DISABLE_MSC_DEPRECATED_POP_() \
+    _Pragma("clang diagnostic pop")
+#else
+# define GTEST_DISABLE_MSC_DEPRECATED_PUSH_() \
+    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
+# define GTEST_DISABLE_MSC_DEPRECATED_POP_() \
+    GTEST_DISABLE_MSC_WARNINGS_POP_()
+#endif
+
+// Brings in definitions for functions used in the testing::internal::posix
+// namespace (read, write, close, chdir, isatty, stat). We do not currently
+// use them on Windows Mobile.
+#if GTEST_OS_WINDOWS
+# if !GTEST_OS_WINDOWS_MOBILE
+#  include <direct.h>
+#  include <io.h>
+# endif
+// In order to avoid having to include <windows.h>, use forward declaration
+#if GTEST_OS_WINDOWS_MINGW && !defined(__MINGW64_VERSION_MAJOR)
+// MinGW defined _CRITICAL_SECTION and _RTL_CRITICAL_SECTION as two
+// separate (equivalent) structs, instead of using typedef
+typedef struct _CRITICAL_SECTION GTEST_CRITICAL_SECTION;
+#else
+// Assume CRITICAL_SECTION is a typedef of _RTL_CRITICAL_SECTION.
+// This assumption is verified by
+// WindowsTypesTest.CRITICAL_SECTIONIs_RTL_CRITICAL_SECTION.
+typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
+#endif
+#elif GTEST_OS_XTENSA
+#include <unistd.h>
+// Xtensa toolchains define strcasecmp in the string.h header instead of
+// strings.h. string.h is already included.
+#else
+// This assumes that non-Windows OSes provide unistd.h. For OSes where this
+// is not the case, we need to include headers that provide the functions
+// mentioned above.
+# include <unistd.h>
+# include <strings.h>
+#endif  // GTEST_OS_WINDOWS
+
+#if GTEST_OS_LINUX_ANDROID
+// Used to define __ANDROID_API__ matching the target NDK API level.
+#  include <android/api-level.h>  // NOLINT
+#endif
+
+// Defines this to true if and only if Google Test can use POSIX regular
+// expressions.
+#ifndef GTEST_HAS_POSIX_RE
+# if GTEST_OS_LINUX_ANDROID
+// On Android, <regex.h> is only available starting with Gingerbread.
+#  define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9)
+# else
+#define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS && !GTEST_OS_XTENSA)
+# endif
+#endif
+
+#if GTEST_USES_PCRE
+// The appropriate headers have already been included.
+
+#elif GTEST_HAS_POSIX_RE
+
+// On some platforms, <regex.h> needs someone to define size_t, and
+// won't compile otherwise.  We can #include it here as we already
+// included <stdlib.h>, which is guaranteed to define size_t through
+// <stddef.h>.
+# include <regex.h>  // NOLINT
+
+# define GTEST_USES_POSIX_RE 1
+
+#elif GTEST_OS_WINDOWS
+
+// <regex.h> is not available on Windows.  Use our own simple regex
+// implementation instead.
+# define GTEST_USES_SIMPLE_RE 1
+
+#else
+
+// <regex.h> may not be available on this platform.  Use our own
+// simple regex implementation instead.
+# define GTEST_USES_SIMPLE_RE 1
+
+#endif  // GTEST_USES_PCRE
+
+#ifndef GTEST_HAS_EXCEPTIONS
+// The user didn't tell us whether exceptions are enabled, so we need
+// to figure it out.
+# if defined(_MSC_VER) && defined(_CPPUNWIND)
+// MSVC defines _CPPUNWIND to 1 if and only if exceptions are enabled.
+#  define GTEST_HAS_EXCEPTIONS 1
+# elif defined(__BORLANDC__)
+// C++Builder's implementation of the STL uses the _HAS_EXCEPTIONS
+// macro to enable exceptions, so we'll do the same.
+// Assumes that exceptions are enabled by default.
+#  ifndef _HAS_EXCEPTIONS
+#   define _HAS_EXCEPTIONS 1
+#  endif  // _HAS_EXCEPTIONS
+#  define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS
+# elif defined(__clang__)
+// clang defines __EXCEPTIONS if and only if exceptions are enabled before clang
+// 220714, but if and only if cleanups are enabled after that. In Obj-C++ files,
+// there can be cleanups for ObjC exceptions which also need cleanups, even if
+// C++ exceptions are disabled. clang has __has_feature(cxx_exceptions) which
+// checks for C++ exceptions starting at clang r206352, but which checked for
+// cleanups prior to that. To reliably check for C++ exception availability with
+// clang, check for
+// __EXCEPTIONS && __has_feature(cxx_exceptions).
+#  define GTEST_HAS_EXCEPTIONS (__EXCEPTIONS && __has_feature(cxx_exceptions))
+# elif defined(__GNUC__) && __EXCEPTIONS
+// gcc defines __EXCEPTIONS to 1 if and only if exceptions are enabled.
+#  define GTEST_HAS_EXCEPTIONS 1
+# elif defined(__SUNPRO_CC)
+// Sun Pro CC supports exceptions.  However, there is no compile-time way of
+// detecting whether they are enabled or not.  Therefore, we assume that
+// they are enabled unless the user tells us otherwise.
+#  define GTEST_HAS_EXCEPTIONS 1
+# elif defined(__IBMCPP__) && __EXCEPTIONS
+// xlC defines __EXCEPTIONS to 1 if and only if exceptions are enabled.
+#  define GTEST_HAS_EXCEPTIONS 1
+# elif defined(__HP_aCC)
+// Exception handling is in effect by default in HP aCC compiler. It has to
+// be turned of by +noeh compiler option if desired.
+#  define GTEST_HAS_EXCEPTIONS 1
+# else
+// For other compilers, we assume exceptions are disabled to be
+// conservative.
+#  define GTEST_HAS_EXCEPTIONS 0
+# endif  // defined(_MSC_VER) || defined(__BORLANDC__)
+#endif  // GTEST_HAS_EXCEPTIONS
+
+#ifndef GTEST_HAS_STD_WSTRING
+// The user didn't tell us whether ::std::wstring is available, so we need
+// to figure it out.
+// Cygwin 1.7 and below doesn't support ::std::wstring.
+// Solaris' libc++ doesn't support it either.  Android has
+// no support for it at least as recent as Froyo (2.2).
+#define GTEST_HAS_STD_WSTRING                                         \
+  (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \
+     GTEST_OS_HAIKU || GTEST_OS_ESP32 || GTEST_OS_ESP8266 || GTEST_OS_XTENSA))
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+// Determines whether RTTI is available.
+#ifndef GTEST_HAS_RTTI
+// The user didn't tell us whether RTTI is enabled, so we need to
+// figure it out.
+
+# ifdef _MSC_VER
+
+#ifdef _CPPRTTI  // MSVC defines this macro if and only if RTTI is enabled.
+#   define GTEST_HAS_RTTI 1
+#  else
+#   define GTEST_HAS_RTTI 0
+#  endif
+
+// Starting with version 4.3.2, gcc defines __GXX_RTTI if and only if RTTI is
+// enabled.
+# elif defined(__GNUC__)
+
+#  ifdef __GXX_RTTI
+// When building against STLport with the Android NDK and with
+// -frtti -fno-exceptions, the build fails at link time with undefined
+// references to __cxa_bad_typeid. Note sure if STL or toolchain bug,
+// so disable RTTI when detected.
+#   if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \
+       !defined(__EXCEPTIONS)
+#    define GTEST_HAS_RTTI 0
+#   else
+#    define GTEST_HAS_RTTI 1
+#   endif  // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS
+#  else
+#   define GTEST_HAS_RTTI 0
+#  endif  // __GXX_RTTI
+
+// Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends
+// using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the
+// first version with C++ support.
+# elif defined(__clang__)
+
+#  define GTEST_HAS_RTTI __has_feature(cxx_rtti)
+
+// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if
+// both the typeid and dynamic_cast features are present.
+# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900)
+
+#  ifdef __RTTI_ALL__
+#   define GTEST_HAS_RTTI 1
+#  else
+#   define GTEST_HAS_RTTI 0
+#  endif
+
+# else
+
+// For all other compilers, we assume RTTI is enabled.
+#  define GTEST_HAS_RTTI 1
+
+# endif  // _MSC_VER
+
+#endif  // GTEST_HAS_RTTI
+
+// It's this header's responsibility to #include <typeinfo> when RTTI
+// is enabled.
+#if GTEST_HAS_RTTI
+# include <typeinfo>
+#endif
+
+// Determines whether Google Test can use the pthreads library.
+#ifndef GTEST_HAS_PTHREAD
+// The user didn't tell us explicitly, so we make reasonable assumptions about
+// which platforms have pthreads support.
+//
+// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
+// to your compiler flags.
+#define GTEST_HAS_PTHREAD                                                      \
+  (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX ||          \
+   GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA || \
+   GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_OPENBSD ||          \
+   GTEST_OS_HAIKU)
+#endif  // GTEST_HAS_PTHREAD
+
+#if GTEST_HAS_PTHREAD
+// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is
+// true.
+# include <pthread.h>  // NOLINT
+
+// For timespec and nanosleep, used below.
+# include <time.h>  // NOLINT
+#endif
+
+// Determines whether clone(2) is supported.
+// Usually it will only be available on Linux, excluding
+// Linux on the Itanium architecture.
+// Also see http://linux.die.net/man/2/clone.
+#ifndef GTEST_HAS_CLONE
+// The user didn't tell us, so we need to figure it out.
+
+# if GTEST_OS_LINUX && !defined(__ia64__)
+#  if GTEST_OS_LINUX_ANDROID
+// On Android, clone() became available at different API levels for each 32-bit
+// architecture.
+#    if defined(__LP64__) || \
+        (defined(__arm__) && __ANDROID_API__ >= 9) || \
+        (defined(__mips__) && __ANDROID_API__ >= 12) || \
+        (defined(__i386__) && __ANDROID_API__ >= 17)
+#     define GTEST_HAS_CLONE 1
+#    else
+#     define GTEST_HAS_CLONE 0
+#    endif
+#  else
+#   define GTEST_HAS_CLONE 1
+#  endif
+# else
+#  define GTEST_HAS_CLONE 0
+# endif  // GTEST_OS_LINUX && !defined(__ia64__)
+
+#endif  // GTEST_HAS_CLONE
+
+// Determines whether to support stream redirection. This is used to test
+// output correctness and to implement death tests.
+#ifndef GTEST_HAS_STREAM_REDIRECTION
+// By default, we assume that stream redirection is supported on all
+// platforms except known mobile ones.
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
+    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA
+#  define GTEST_HAS_STREAM_REDIRECTION 0
+# else
+#  define GTEST_HAS_STREAM_REDIRECTION 1
+# endif  // !GTEST_OS_WINDOWS_MOBILE
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+// Determines whether to support death tests.
+// pops up a dialog window that cannot be suppressed programmatically.
+#if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS ||             \
+     (GTEST_OS_MAC && !GTEST_OS_IOS) ||                                   \
+     (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER) || GTEST_OS_WINDOWS_MINGW ||  \
+     GTEST_OS_AIX || GTEST_OS_HPUX || GTEST_OS_OPENBSD || GTEST_OS_QNX || \
+     GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA ||           \
+     GTEST_OS_DRAGONFLY || GTEST_OS_GNU_KFREEBSD || GTEST_OS_HAIKU)
+# define GTEST_HAS_DEATH_TEST 1
+#endif
+
+// Determines whether to support type-driven tests.
+
+// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0,
+// Sun Pro CC, IBM Visual Age, and HP aCC support.
+#if defined(__GNUC__) || defined(_MSC_VER) || defined(__SUNPRO_CC) || \
+    defined(__IBMCPP__) || defined(__HP_aCC)
+# define GTEST_HAS_TYPED_TEST 1
+# define GTEST_HAS_TYPED_TEST_P 1
+#endif
+
+// Determines whether the system compiler uses UTF-16 for encoding wide strings.
+#define GTEST_WIDE_STRING_USES_UTF16_ \
+  (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_AIX || GTEST_OS_OS2)
+
+// Determines whether test results can be streamed to a socket.
+#if GTEST_OS_LINUX || GTEST_OS_GNU_KFREEBSD || GTEST_OS_DRAGONFLY || \
+    GTEST_OS_FREEBSD || GTEST_OS_NETBSD || GTEST_OS_OPENBSD
+# define GTEST_CAN_STREAM_RESULTS_ 1
+#endif
+
+// Defines some utility macros.
+
+// The GNU compiler emits a warning if nested "if" statements are followed by
+// an "else" statement and braces are not used to explicitly disambiguate the
+// "else" binding.  This leads to problems with code like:
+//
+//   if (gate)
+//     ASSERT_*(condition) << "Some message";
+//
+// The "switch (0) case 0:" idiom is used to suppress this.
+#ifdef __INTEL_COMPILER
+# define GTEST_AMBIGUOUS_ELSE_BLOCKER_
+#else
+# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default:  // NOLINT
+#endif
+
+// Use this annotation at the end of a struct/class definition to
+// prevent the compiler from optimizing away instances that are never
+// used.  This is useful when all interesting logic happens inside the
+// c'tor and / or d'tor.  Example:
+//
+//   struct Foo {
+//     Foo() { ... }
+//   } GTEST_ATTRIBUTE_UNUSED_;
+//
+// Also use it after a variable or parameter declaration to tell the
+// compiler the variable/parameter does not have to be used.
+#if defined(__GNUC__) && !defined(COMPILER_ICC)
+# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
+#elif defined(__clang__)
+# if __has_attribute(unused)
+#  define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused))
+# endif
+#endif
+#ifndef GTEST_ATTRIBUTE_UNUSED_
+# define GTEST_ATTRIBUTE_UNUSED_
+#endif
+
+// Use this annotation before a function that takes a printf format string.
+#if (defined(__GNUC__) || defined(__clang__)) && !defined(COMPILER_ICC)
+# if defined(__MINGW_PRINTF_FORMAT)
+// MinGW has two different printf implementations. Ensure the format macro
+// matches the selected implementation. See
+// https://sourceforge.net/p/mingw-w64/wiki2/gnu%20printf/.
+#  define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
+       __attribute__((__format__(__MINGW_PRINTF_FORMAT, string_index, \
+                                 first_to_check)))
+# else
+#  define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check) \
+       __attribute__((__format__(__printf__, string_index, first_to_check)))
+# endif
+#else
+# define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check)
+#endif
+
+
+// A macro to disallow copy operator=
+// This should be used in the private: declarations for a class.
+#define GTEST_DISALLOW_ASSIGN_(type) \
+  type& operator=(type const &) = delete
+
+// A macro to disallow copy constructor and operator=
+// This should be used in the private: declarations for a class.
+#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type) \
+  type(type const&) = delete;                 \
+  type& operator=(type const&) = delete
+
+// A macro to disallow move operator=
+// This should be used in the private: declarations for a class.
+#define GTEST_DISALLOW_MOVE_ASSIGN_(type) \
+  type& operator=(type &&) noexcept = delete
+
+// A macro to disallow move constructor and operator=
+// This should be used in the private: declarations for a class.
+#define GTEST_DISALLOW_MOVE_AND_ASSIGN_(type) \
+  type(type&&) noexcept = delete;             \
+  type& operator=(type&&) noexcept = delete
+
+// 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 defined(__GNUC__) && !defined(COMPILER_ICC)
+# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result))
+#else
+# define GTEST_MUST_USE_RESULT_
+#endif  // __GNUC__ && !COMPILER_ICC
+
+// 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:
+//
+// GTEST_INTENTIONAL_CONST_COND_PUSH_()
+// while (true) {
+// GTEST_INTENTIONAL_CONST_COND_POP_()
+// }
+# define GTEST_INTENTIONAL_CONST_COND_PUSH_() \
+    GTEST_DISABLE_MSC_WARNINGS_PUSH_(4127)
+# define GTEST_INTENTIONAL_CONST_COND_POP_() \
+    GTEST_DISABLE_MSC_WARNINGS_POP_()
+
+// Determine whether the compiler supports Microsoft's Structured Exception
+// Handling.  This is supported by several Windows compilers but generally
+// does not exist on any other system.
+#ifndef GTEST_HAS_SEH
+// The user didn't tell us, so we need to figure it out.
+
+# if defined(_MSC_VER) || defined(__BORLANDC__)
+// These two compilers are known to support SEH.
+#  define GTEST_HAS_SEH 1
+# else
+// Assume no SEH.
+#  define GTEST_HAS_SEH 0
+# endif
+
+#endif  // GTEST_HAS_SEH
+
+#ifndef GTEST_IS_THREADSAFE
+
+#define GTEST_IS_THREADSAFE                                                 \
+  (GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ ||                                     \
+   (GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT) || \
+   GTEST_HAS_PTHREAD)
+
+#endif  // GTEST_IS_THREADSAFE
+
+// GTEST_API_ qualifies all symbols that must be exported. The definitions below
+// are guarded by #ifndef to give embedders a chance to define GTEST_API_ in
+// gtest/internal/custom/gtest-port.h
+#ifndef GTEST_API_
+
+#ifdef _MSC_VER
+# if GTEST_LINKED_AS_SHARED_LIBRARY
+#  define GTEST_API_ __declspec(dllimport)
+# elif GTEST_CREATE_SHARED_LIBRARY
+#  define GTEST_API_ __declspec(dllexport)
+# endif
+#elif __GNUC__ >= 4 || defined(__clang__)
+# define GTEST_API_ __attribute__((visibility ("default")))
+#endif  // _MSC_VER
+
+#endif  // GTEST_API_
+
+#ifndef GTEST_API_
+# define GTEST_API_
+#endif  // GTEST_API_
+
+#ifndef GTEST_DEFAULT_DEATH_TEST_STYLE
+# define GTEST_DEFAULT_DEATH_TEST_STYLE  "fast"
+#endif  // GTEST_DEFAULT_DEATH_TEST_STYLE
+
+#ifdef __GNUC__
+// Ask the compiler to never inline a given function.
+# define GTEST_NO_INLINE_ __attribute__((noinline))
+#else
+# define GTEST_NO_INLINE_
+#endif
+
+// _LIBCPP_VERSION is defined by the libc++ library from the LLVM project.
+#if !defined(GTEST_HAS_CXXABI_H_)
+# if defined(__GLIBCXX__) || (defined(_LIBCPP_VERSION) && !defined(_MSC_VER))
+#  define GTEST_HAS_CXXABI_H_ 1
+# else
+#  define GTEST_HAS_CXXABI_H_ 0
+# endif
+#endif
+
+// A function level attribute to disable checking for use of uninitialized
+// memory when built with MemorySanitizer.
+#if defined(__clang__)
+# if __has_feature(memory_sanitizer)
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_ \
+       __attribute__((no_sanitize_memory))
+# else
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+# endif  // __has_feature(memory_sanitizer)
+#else
+# define GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+#endif  // __clang__
+
+// A function level attribute to disable AddressSanitizer instrumentation.
+#if defined(__clang__)
+# if __has_feature(address_sanitizer)
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_ \
+       __attribute__((no_sanitize_address))
+# else
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+# endif  // __has_feature(address_sanitizer)
+#else
+# define GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+#endif  // __clang__
+
+// A function level attribute to disable HWAddressSanitizer instrumentation.
+#if defined(__clang__)
+# if __has_feature(hwaddress_sanitizer)
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_ \
+       __attribute__((no_sanitize("hwaddress")))
+# else
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+# endif  // __has_feature(hwaddress_sanitizer)
+#else
+# define GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+#endif  // __clang__
+
+// A function level attribute to disable ThreadSanitizer instrumentation.
+#if defined(__clang__)
+# if __has_feature(thread_sanitizer)
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_ \
+       __attribute__((no_sanitize_thread))
+# else
+#  define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+# endif  // __has_feature(thread_sanitizer)
+#else
+# define GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+#endif  // __clang__
+
+namespace testing {
+
+class Message;
+
+// Legacy imports for backwards compatibility.
+// New code should use std:: names directly.
+using std::get;
+using std::make_tuple;
+using std::tuple;
+using std::tuple_element;
+using std::tuple_size;
+
+namespace internal {
+
+// A secret type that Google Test users don't know about.  It has no
+// definition on purpose.  Therefore it's impossible to create a
+// Secret object, which is what we want.
+class Secret;
+
+// The GTEST_COMPILE_ASSERT_ is a legacy macro used to verify that a compile
+// time expression is true (in new code, use static_assert instead). For
+// example, you could use it to verify the size of a static array:
+//
+//   GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES,
+//                         names_incorrect_size);
+//
+// The second argument to the macro must be a valid C++ identifier. If the
+// expression is false, compiler will issue an error containing this identifier.
+#define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
+
+// A helper for suppressing warnings on constant condition.  It just
+// returns 'condition'.
+GTEST_API_ bool IsTrue(bool condition);
+
+// Defines RE.
+
+#if GTEST_USES_PCRE
+// if used, PCRE is injected by custom/gtest-port.h
+#elif GTEST_USES_POSIX_RE || GTEST_USES_SIMPLE_RE
+
+// A simple C++ wrapper for <regex.h>.  It uses the POSIX Extended
+// Regular Expression syntax.
+class GTEST_API_ RE {
+ public:
+  // A copy constructor is required by the Standard to initialize object
+  // references from r-values.
+  RE(const RE& other) { Init(other.pattern()); }
+
+  // Constructs an RE from a string.
+  RE(const ::std::string& regex) { Init(regex.c_str()); }  // NOLINT
+
+  RE(const char* regex) { Init(regex); }  // NOLINT
+  ~RE();
+
+  // Returns the string representation of the regex.
+  const char* pattern() const { return pattern_; }
+
+  // FullMatch(str, re) returns true if and only if regular expression re
+  // matches the entire str.
+  // PartialMatch(str, re) returns true if and only if regular expression re
+  // matches a substring of str (including str itself).
+  static bool FullMatch(const ::std::string& str, const RE& re) {
+    return FullMatch(str.c_str(), re);
+  }
+  static bool PartialMatch(const ::std::string& str, const RE& re) {
+    return PartialMatch(str.c_str(), re);
+  }
+
+  static bool FullMatch(const char* str, const RE& re);
+  static bool PartialMatch(const char* str, const RE& re);
+
+ private:
+  void Init(const char* regex);
+  const char* pattern_;
+  bool is_valid_;
+
+# if GTEST_USES_POSIX_RE
+
+  regex_t full_regex_;     // For FullMatch().
+  regex_t partial_regex_;  // For PartialMatch().
+
+# else  // GTEST_USES_SIMPLE_RE
+
+  const char* full_pattern_;  // For FullMatch();
+
+# endif
+};
+
+#endif  // GTEST_USES_PCRE
+
+// Formats a source file path and a line number as they would appear
+// in an error message from the compiler used to compile this code.
+GTEST_API_ ::std::string FormatFileLocation(const char* file, int line);
+
+// Formats a file location for compiler-independent XML output.
+// Although this function is not platform dependent, we put it next to
+// FormatFileLocation in order to contrast the two functions.
+GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
+                                                               int line);
+
+// Defines logging utilities:
+//   GTEST_LOG_(severity) - logs messages at the specified severity level. The
+//                          message itself is streamed into the macro.
+//   LogToStderr()  - directs all log messages to stderr.
+//   FlushInfoLog() - flushes informational log messages.
+
+enum GTestLogSeverity {
+  GTEST_INFO,
+  GTEST_WARNING,
+  GTEST_ERROR,
+  GTEST_FATAL
+};
+
+// Formats log entry severity, provides a stream object for streaming the
+// log message, and terminates the message with a newline when going out of
+// scope.
+class GTEST_API_ GTestLog {
+ public:
+  GTestLog(GTestLogSeverity severity, const char* file, int line);
+
+  // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
+  ~GTestLog();
+
+  ::std::ostream& GetStream() { return ::std::cerr; }
+
+ private:
+  const GTestLogSeverity severity_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
+};
+
+#if !defined(GTEST_LOG_)
+
+# define GTEST_LOG_(severity) \
+    ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \
+                                  __FILE__, __LINE__).GetStream()
+
+inline void LogToStderr() {}
+inline void FlushInfoLog() { fflush(nullptr); }
+
+#endif  // !defined(GTEST_LOG_)
+
+#if !defined(GTEST_CHECK_)
+// INTERNAL IMPLEMENTATION - DO NOT USE.
+//
+// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition
+// is not satisfied.
+//  Synopsys:
+//    GTEST_CHECK_(boolean_condition);
+//     or
+//    GTEST_CHECK_(boolean_condition) << "Additional message";
+//
+//    This checks the condition and if the condition is not satisfied
+//    it prints message about the condition violation, including the
+//    condition itself, plus additional message streamed into it, if any,
+//    and then it aborts the program. It aborts the program irrespective of
+//    whether it is built in the debug mode or not.
+# define GTEST_CHECK_(condition) \
+    GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
+    if (::testing::internal::IsTrue(condition)) \
+      ; \
+    else \
+      GTEST_LOG_(FATAL) << "Condition " #condition " failed. "
+#endif  // !defined(GTEST_CHECK_)
+
+// An all-mode assert to verify that the given POSIX-style function
+// call returns 0 (indicating success).  Known limitation: this
+// doesn't expand to a balanced 'if' statement, so enclose the macro
+// in {} if you need to use it as the only statement in an 'if'
+// branch.
+#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \
+  if (const int gtest_error = (posix_call)) \
+    GTEST_LOG_(FATAL) << #posix_call << "failed with error " \
+                      << gtest_error
+
+// Transforms "T" into "const T&" according to standard reference collapsing
+// rules (this is only needed as a backport for C++98 compilers that do not
+// support reference collapsing). Specifically, it transforms:
+//
+//   char         ==> const char&
+//   const char   ==> const char&
+//   char&        ==> char&
+//   const char&  ==> const char&
+//
+// Note that the non-const reference will not have "const" added. This is
+// standard, and necessary so that "T" can always bind to "const T&".
+template <typename T>
+struct ConstRef { typedef const T& type; };
+template <typename T>
+struct ConstRef<T&> { typedef T& type; };
+
+// The argument T must depend on some template parameters.
+#define GTEST_REFERENCE_TO_CONST_(T) \
+  typename ::testing::internal::ConstRef<T>::type
+
+// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
+//
+// Use ImplicitCast_ as a safe version of static_cast for upcasting in
+// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a
+// const Foo*).  When you use ImplicitCast_, the compiler checks that
+// the cast is safe.  Such explicit ImplicitCast_s are necessary in
+// surprisingly many situations where C++ demands an exact type match
+// instead of an argument type convertable to a target type.
+//
+// The syntax for using ImplicitCast_ is the same as for static_cast:
+//
+//   ImplicitCast_<ToType>(expr)
+//
+// ImplicitCast_ would have been part of the C++ standard library,
+// but the proposal was submitted too late.  It will probably make
+// its way into the language in the future.
+//
+// This relatively ugly name is intentional. It prevents clashes with
+// similar functions users may have (e.g., implicit_cast). The internal
+// namespace alone is not enough because the function can be found by ADL.
+template<typename To>
+inline To ImplicitCast_(To x) { return x; }
+
+// When you upcast (that is, cast a pointer from type Foo to type
+// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts
+// always succeed.  When you downcast (that is, cast a pointer from
+// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
+// how do you know the pointer is really of type SubclassOfFoo?  It
+// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
+// when you downcast, you should use this macro.  In debug mode, we
+// use dynamic_cast<> to double-check the downcast is legal (we die
+// if it's not).  In normal mode, we do the efficient static_cast<>
+// instead.  Thus, it's important to test in debug mode to make sure
+// the cast is legal!
+//    This is the only place in the code we should use dynamic_cast<>.
+// In particular, you SHOULDN'T be using dynamic_cast<> in order to
+// do RTTI (eg code like this:
+//    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
+//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
+// You should design the code some other way not to need this.
+//
+// This relatively ugly name is intentional. It prevents clashes with
+// similar functions users may have (e.g., down_cast). The internal
+// namespace alone is not enough because the function can be found by ADL.
+template<typename To, typename From>  // use like this: DownCast_<T*>(foo);
+inline To DownCast_(From* f) {  // so we only accept pointers
+  // Ensures that To is a sub-type of From *.  This test is here only
+  // for compile-time type checking, and has no overhead in an
+  // optimized build at run-time, as it will be optimized away
+  // completely.
+  GTEST_INTENTIONAL_CONST_COND_PUSH_()
+  if (false) {
+  GTEST_INTENTIONAL_CONST_COND_POP_()
+  const To to = nullptr;
+  ::testing::internal::ImplicitCast_<From*>(to);
+  }
+
+#if GTEST_HAS_RTTI
+  // RTTI: debug mode only!
+  GTEST_CHECK_(f == nullptr || dynamic_cast<To>(f) != nullptr);
+#endif
+  return static_cast<To>(f);
+}
+
+// Downcasts the pointer of type Base to Derived.
+// Derived must be a subclass of Base. The parameter MUST
+// point to a class of type Derived, not any subclass of it.
+// When RTTI is available, the function performs a runtime
+// check to enforce this.
+template <class Derived, class Base>
+Derived* CheckedDowncastToActualType(Base* base) {
+#if GTEST_HAS_RTTI
+  GTEST_CHECK_(typeid(*base) == typeid(Derived));
+#endif
+
+#if GTEST_HAS_DOWNCAST_
+  return ::down_cast<Derived*>(base);
+#elif GTEST_HAS_RTTI
+  return dynamic_cast<Derived*>(base);  // NOLINT
+#else
+  return static_cast<Derived*>(base);  // Poor man's downcast.
+#endif
+}
+
+#if GTEST_HAS_STREAM_REDIRECTION
+
+// Defines the stderr capturer:
+//   CaptureStdout     - starts capturing stdout.
+//   GetCapturedStdout - stops capturing stdout and returns the captured string.
+//   CaptureStderr     - starts capturing stderr.
+//   GetCapturedStderr - stops capturing stderr and returns the captured string.
+//
+GTEST_API_ void CaptureStdout();
+GTEST_API_ std::string GetCapturedStdout();
+GTEST_API_ void CaptureStderr();
+GTEST_API_ std::string GetCapturedStderr();
+
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+// Returns the size (in bytes) of a file.
+GTEST_API_ size_t GetFileSize(FILE* file);
+
+// Reads the entire content of a file as a string.
+GTEST_API_ std::string ReadEntireFile(FILE* file);
+
+// All command line arguments.
+GTEST_API_ std::vector<std::string> GetArgvs();
+
+#if GTEST_HAS_DEATH_TEST
+
+std::vector<std::string> GetInjectableArgvs();
+// Deprecated: pass the args vector by value instead.
+void SetInjectableArgvs(const std::vector<std::string>* new_argvs);
+void SetInjectableArgvs(const std::vector<std::string>& new_argvs);
+void ClearInjectableArgvs();
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+// Defines synchronization primitives.
+#if GTEST_IS_THREADSAFE
+# if GTEST_HAS_PTHREAD
+// Sleeps for (roughly) n milliseconds.  This function is only for testing
+// Google Test's own constructs.  Don't use it in user tests, either
+// directly or indirectly.
+inline void SleepMilliseconds(int n) {
+  const timespec time = {
+    0,                  // 0 seconds.
+    n * 1000L * 1000L,  // And n ms.
+  };
+  nanosleep(&time, nullptr);
+}
+# endif  // GTEST_HAS_PTHREAD
+
+# if GTEST_HAS_NOTIFICATION_
+// Notification has already been imported into the namespace.
+// Nothing to do here.
+
+# elif GTEST_HAS_PTHREAD
+// Allows a controller thread to pause execution of newly created
+// threads until notified.  Instances of this class must be created
+// and destroyed in the controller thread.
+//
+// This class is only for testing Google Test's own constructs. Do not
+// use it in user tests, either directly or indirectly.
+class Notification {
+ public:
+  Notification() : notified_(false) {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
+  }
+  ~Notification() {
+    pthread_mutex_destroy(&mutex_);
+  }
+
+  // Notifies all threads created with this notification to start. Must
+  // be called from the controller thread.
+  void Notify() {
+    pthread_mutex_lock(&mutex_);
+    notified_ = true;
+    pthread_mutex_unlock(&mutex_);
+  }
+
+  // Blocks until the controller thread notifies. Must be called from a test
+  // thread.
+  void WaitForNotification() {
+    for (;;) {
+      pthread_mutex_lock(&mutex_);
+      const bool notified = notified_;
+      pthread_mutex_unlock(&mutex_);
+      if (notified)
+        break;
+      SleepMilliseconds(10);
+    }
+  }
+
+ private:
+  pthread_mutex_t mutex_;
+  bool notified_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
+};
+
+# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+
+GTEST_API_ void SleepMilliseconds(int n);
+
+// Provides leak-safe Windows kernel handle ownership.
+// Used in death tests and in threading support.
+class GTEST_API_ AutoHandle {
+ public:
+  // Assume that Win32 HANDLE type is equivalent to void*. Doing so allows us to
+  // avoid including <windows.h> in this header file. Including <windows.h> is
+  // undesirable because it defines a lot of symbols and macros that tend to
+  // conflict with client code. This assumption is verified by
+  // WindowsTypesTest.HANDLEIsVoidStar.
+  typedef void* Handle;
+  AutoHandle();
+  explicit AutoHandle(Handle handle);
+
+  ~AutoHandle();
+
+  Handle Get() const;
+  void Reset();
+  void Reset(Handle handle);
+
+ private:
+  // Returns true if and only if the handle is a valid handle object that can be
+  // closed.
+  bool IsCloseable() const;
+
+  Handle handle_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);
+};
+
+// Allows a controller thread to pause execution of newly created
+// threads until notified.  Instances of this class must be created
+// and destroyed in the controller thread.
+//
+// This class is only for testing Google Test's own constructs. Do not
+// use it in user tests, either directly or indirectly.
+class GTEST_API_ Notification {
+ public:
+  Notification();
+  void Notify();
+  void WaitForNotification();
+
+ private:
+  AutoHandle event_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification);
+};
+# endif  // GTEST_HAS_NOTIFICATION_
+
+// On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD
+// defined, but we don't want to use MinGW's pthreads implementation, which
+// has conformance problems with some versions of the POSIX standard.
+# if GTEST_HAS_PTHREAD && !GTEST_OS_WINDOWS_MINGW
+
+// As a C-function, ThreadFuncWithCLinkage cannot be templated itself.
+// Consequently, it cannot select a correct instantiation of ThreadWithParam
+// in order to call its Run(). Introducing ThreadWithParamBase as a
+// non-templated base class for ThreadWithParam allows us to bypass this
+// problem.
+class ThreadWithParamBase {
+ public:
+  virtual ~ThreadWithParamBase() {}
+  virtual void Run() = 0;
+};
+
+// pthread_create() accepts a pointer to a function type with the C linkage.
+// According to the Standard (7.5/1), function types with different linkages
+// are different even if they are otherwise identical.  Some compilers (for
+// example, SunStudio) treat them as different types.  Since class methods
+// cannot be defined with C-linkage we need to define a free C-function to
+// pass into pthread_create().
+extern "C" inline void* ThreadFuncWithCLinkage(void* thread) {
+  static_cast<ThreadWithParamBase*>(thread)->Run();
+  return nullptr;
+}
+
+// Helper class for testing Google Test's multi-threading constructs.
+// To use it, write:
+//
+//   void ThreadFunc(int param) { /* Do things with param */ }
+//   Notification thread_can_start;
+//   ...
+//   // The thread_can_start parameter is optional; you can supply NULL.
+//   ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start);
+//   thread_can_start.Notify();
+//
+// These classes are only for testing Google Test's own constructs. Do
+// not use them in user tests, either directly or indirectly.
+template <typename T>
+class ThreadWithParam : public ThreadWithParamBase {
+ public:
+  typedef void UserThreadFunc(T);
+
+  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
+      : func_(func),
+        param_(param),
+        thread_can_start_(thread_can_start),
+        finished_(false) {
+    ThreadWithParamBase* const base = this;
+    // The thread can be created only after all fields except thread_
+    // have been initialized.
+    GTEST_CHECK_POSIX_SUCCESS_(
+        pthread_create(&thread_, nullptr, &ThreadFuncWithCLinkage, base));
+  }
+  ~ThreadWithParam() override { Join(); }
+
+  void Join() {
+    if (!finished_) {
+      GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, nullptr));
+      finished_ = true;
+    }
+  }
+
+  void Run() override {
+    if (thread_can_start_ != nullptr) thread_can_start_->WaitForNotification();
+    func_(param_);
+  }
+
+ private:
+  UserThreadFunc* const func_;  // User-supplied thread function.
+  const T param_;  // User-supplied parameter to the thread function.
+  // When non-NULL, used to block execution until the controller thread
+  // notifies.
+  Notification* const thread_can_start_;
+  bool finished_;  // true if and only if we know that the thread function has
+                   // finished.
+  pthread_t thread_;  // The native thread object.
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
+};
+# endif  // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD ||
+         // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
+
+# if GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
+// Mutex and ThreadLocal have already been imported into the namespace.
+// Nothing to do here.
+
+# elif GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+
+// Mutex implements mutex on Windows platforms.  It is used in conjunction
+// with class MutexLock:
+//
+//   Mutex mutex;
+//   ...
+//   MutexLock lock(&mutex);  // Acquires the mutex and releases it at the
+//                            // end of the current scope.
+//
+// A static Mutex *must* be defined or declared using one of the following
+// macros:
+//   GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex);
+//   GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex);
+//
+// (A non-static Mutex is defined/declared in the usual way).
+class GTEST_API_ Mutex {
+ public:
+  enum MutexType { kStatic = 0, kDynamic = 1 };
+  // We rely on kStaticMutex being 0 as it is to what the linker initializes
+  // type_ in static mutexes.  critical_section_ will be initialized lazily
+  // in ThreadSafeLazyInit().
+  enum StaticConstructorSelector { kStaticMutex = 0 };
+
+  // This constructor intentionally does nothing.  It relies on type_ being
+  // statically initialized to 0 (effectively setting it to kStatic) and on
+  // ThreadSafeLazyInit() to lazily initialize the rest of the members.
+  explicit Mutex(StaticConstructorSelector /*dummy*/) {}
+
+  Mutex();
+  ~Mutex();
+
+  void Lock();
+
+  void Unlock();
+
+  // Does nothing if the current thread holds the mutex. Otherwise, crashes
+  // with high probability.
+  void AssertHeld();
+
+ private:
+  // Initializes owner_thread_id_ and critical_section_ in static mutexes.
+  void ThreadSafeLazyInit();
+
+  // Per https://blogs.msdn.microsoft.com/oldnewthing/20040223-00/?p=40503,
+  // we assume that 0 is an invalid value for thread IDs.
+  unsigned int owner_thread_id_;
+
+  // For static mutexes, we rely on these members being initialized to zeros
+  // by the linker.
+  MutexType type_;
+  long critical_section_init_phase_;  // NOLINT
+  GTEST_CRITICAL_SECTION* critical_section_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
+};
+
+# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
+    extern ::testing::internal::Mutex mutex
+
+# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
+    ::testing::internal::Mutex mutex(::testing::internal::Mutex::kStaticMutex)
+
+// We cannot name this class MutexLock because the ctor declaration would
+// conflict with a macro named MutexLock, which is defined on some
+// platforms. That macro is used as a defensive measure to prevent against
+// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
+// "MutexLock l(&mu)".  Hence the typedef trick below.
+class GTestMutexLock {
+ public:
+  explicit GTestMutexLock(Mutex* mutex)
+      : mutex_(mutex) { mutex_->Lock(); }
+
+  ~GTestMutexLock() { mutex_->Unlock(); }
+
+ private:
+  Mutex* const mutex_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
+};
+
+typedef GTestMutexLock MutexLock;
+
+// Base class for ValueHolder<T>.  Allows a caller to hold and delete a value
+// without knowing its type.
+class ThreadLocalValueHolderBase {
+ public:
+  virtual ~ThreadLocalValueHolderBase() {}
+};
+
+// Provides a way for a thread to send notifications to a ThreadLocal
+// regardless of its parameter type.
+class ThreadLocalBase {
+ public:
+  // Creates a new ValueHolder<T> object holding a default value passed to
+  // this ThreadLocal<T>'s constructor and returns it.  It is the caller's
+  // responsibility not to call this when the ThreadLocal<T> instance already
+  // has a value on the current thread.
+  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const = 0;
+
+ protected:
+  ThreadLocalBase() {}
+  virtual ~ThreadLocalBase() {}
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase);
+};
+
+// Maps a thread to a set of ThreadLocals that have values instantiated on that
+// thread and notifies them when the thread exits.  A ThreadLocal instance is
+// expected to persist until all threads it has values on have terminated.
+class GTEST_API_ ThreadLocalRegistry {
+ public:
+  // Registers thread_local_instance as having value on the current thread.
+  // Returns a value that can be used to identify the thread from other threads.
+  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
+      const ThreadLocalBase* thread_local_instance);
+
+  // Invoked when a ThreadLocal instance is destroyed.
+  static void OnThreadLocalDestroyed(
+      const ThreadLocalBase* thread_local_instance);
+};
+
+class GTEST_API_ ThreadWithParamBase {
+ public:
+  void Join();
+
+ protected:
+  class Runnable {
+   public:
+    virtual ~Runnable() {}
+    virtual void Run() = 0;
+  };
+
+  ThreadWithParamBase(Runnable *runnable, Notification* thread_can_start);
+  virtual ~ThreadWithParamBase();
+
+ private:
+  AutoHandle thread_;
+};
+
+// Helper class for testing Google Test's multi-threading constructs.
+template <typename T>
+class ThreadWithParam : public ThreadWithParamBase {
+ public:
+  typedef void UserThreadFunc(T);
+
+  ThreadWithParam(UserThreadFunc* func, T param, Notification* thread_can_start)
+      : ThreadWithParamBase(new RunnableImpl(func, param), thread_can_start) {
+  }
+  virtual ~ThreadWithParam() {}
+
+ private:
+  class RunnableImpl : public Runnable {
+   public:
+    RunnableImpl(UserThreadFunc* func, T param)
+        : func_(func),
+          param_(param) {
+    }
+    virtual ~RunnableImpl() {}
+    virtual void Run() {
+      func_(param_);
+    }
+
+   private:
+    UserThreadFunc* const func_;
+    const T param_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl);
+  };
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
+};
+
+// Implements thread-local storage on Windows systems.
+//
+//   // Thread 1
+//   ThreadLocal<int> tl(100);  // 100 is the default value for each thread.
+//
+//   // Thread 2
+//   tl.set(150);  // Changes the value for thread 2 only.
+//   EXPECT_EQ(150, tl.get());
+//
+//   // Thread 1
+//   EXPECT_EQ(100, tl.get());  // In thread 1, tl has the original value.
+//   tl.set(200);
+//   EXPECT_EQ(200, tl.get());
+//
+// The template type argument T must have a public copy constructor.
+// In addition, the default ThreadLocal constructor requires T to have
+// a public default constructor.
+//
+// The users of a TheadLocal instance have to make sure that all but one
+// threads (including the main one) using that instance have exited before
+// destroying it. Otherwise, the per-thread objects managed for them by the
+// ThreadLocal instance are not guaranteed to be destroyed on all platforms.
+//
+// Google Test only uses global ThreadLocal objects.  That means they
+// will die after main() has returned.  Therefore, no per-thread
+// object managed by Google Test will be leaked as long as all threads
+// using Google Test have exited when main() returns.
+template <typename T>
+class ThreadLocal : public ThreadLocalBase {
+ public:
+  ThreadLocal() : default_factory_(new DefaultValueHolderFactory()) {}
+  explicit ThreadLocal(const T& value)
+      : default_factory_(new InstanceValueHolderFactory(value)) {}
+
+  ~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(this); }
+
+  T* pointer() { return GetOrCreateValue(); }
+  const T* pointer() const { return GetOrCreateValue(); }
+  const T& get() const { return *pointer(); }
+  void set(const T& value) { *pointer() = value; }
+
+ private:
+  // Holds a value of T.  Can be deleted via its base class without the caller
+  // knowing the type of T.
+  class ValueHolder : public ThreadLocalValueHolderBase {
+   public:
+    ValueHolder() : value_() {}
+    explicit ValueHolder(const T& value) : value_(value) {}
+
+    T* pointer() { return &value_; }
+
+   private:
+    T value_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
+  };
+
+
+  T* GetOrCreateValue() const {
+    return static_cast<ValueHolder*>(
+        ThreadLocalRegistry::GetValueOnCurrentThread(this))->pointer();
+  }
+
+  virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const {
+    return default_factory_->MakeNewHolder();
+  }
+
+  class ValueHolderFactory {
+   public:
+    ValueHolderFactory() {}
+    virtual ~ValueHolderFactory() {}
+    virtual ValueHolder* MakeNewHolder() const = 0;
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
+  };
+
+  class DefaultValueHolderFactory : public ValueHolderFactory {
+   public:
+    DefaultValueHolderFactory() {}
+    ValueHolder* MakeNewHolder() const override { return new ValueHolder(); }
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
+  };
+
+  class InstanceValueHolderFactory : public ValueHolderFactory {
+   public:
+    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
+    ValueHolder* MakeNewHolder() const override {
+      return new ValueHolder(value_);
+    }
+
+   private:
+    const T value_;  // The value for each thread.
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
+  };
+
+  std::unique_ptr<ValueHolderFactory> default_factory_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
+};
+
+# elif GTEST_HAS_PTHREAD
+
+// MutexBase and Mutex implement mutex on pthreads-based platforms.
+class MutexBase {
+ public:
+  // Acquires this mutex.
+  void Lock() {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_));
+    owner_ = pthread_self();
+    has_owner_ = true;
+  }
+
+  // Releases this mutex.
+  void Unlock() {
+    // Since the lock is being released the owner_ field should no longer be
+    // considered valid. We don't protect writing to has_owner_ here, as it's
+    // the caller's responsibility to ensure that the current thread holds the
+    // mutex when this is called.
+    has_owner_ = false;
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
+  }
+
+  // Does nothing if the current thread holds the mutex. Otherwise, crashes
+  // with high probability.
+  void AssertHeld() const {
+    GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self()))
+        << "The current thread is not holding the mutex @" << this;
+  }
+
+  // A static mutex may be used before main() is entered.  It may even
+  // be used before the dynamic initialization stage.  Therefore we
+  // must be able to initialize a static mutex object at link time.
+  // This means MutexBase has to be a POD and its member variables
+  // have to be public.
+ public:
+  pthread_mutex_t mutex_;  // The underlying pthread mutex.
+  // has_owner_ indicates whether the owner_ field below contains a valid thread
+  // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All
+  // accesses to the owner_ field should be protected by a check of this field.
+  // An alternative might be to memset() owner_ to all zeros, but there's no
+  // guarantee that a zero'd pthread_t is necessarily invalid or even different
+  // from pthread_self().
+  bool has_owner_;
+  pthread_t owner_;  // The thread holding the mutex.
+};
+
+// Forward-declares a static mutex.
+#  define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
+     extern ::testing::internal::MutexBase mutex
+
+// Defines and statically (i.e. at link time) initializes a static mutex.
+// The initialization list here does not explicitly initialize each field,
+// instead relying on default initialization for the unspecified fields. In
+// particular, the owner_ field (a pthread_t) is not explicitly initialized.
+// This allows initialization to work whether pthread_t is a scalar or struct.
+// The flag -Wmissing-field-initializers must not be specified for this to work.
+#define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
+  ::testing::internal::MutexBase mutex = {PTHREAD_MUTEX_INITIALIZER, false, 0}
+
+// The Mutex class can only be used for mutexes created at runtime. It
+// shares its API with MutexBase otherwise.
+class Mutex : public MutexBase {
+ public:
+  Mutex() {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, nullptr));
+    has_owner_ = false;
+  }
+  ~Mutex() {
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_));
+  }
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
+};
+
+// We cannot name this class MutexLock because the ctor declaration would
+// conflict with a macro named MutexLock, which is defined on some
+// platforms. That macro is used as a defensive measure to prevent against
+// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
+// "MutexLock l(&mu)".  Hence the typedef trick below.
+class GTestMutexLock {
+ public:
+  explicit GTestMutexLock(MutexBase* mutex)
+      : mutex_(mutex) { mutex_->Lock(); }
+
+  ~GTestMutexLock() { mutex_->Unlock(); }
+
+ private:
+  MutexBase* const mutex_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
+};
+
+typedef GTestMutexLock MutexLock;
+
+// Helpers for ThreadLocal.
+
+// pthread_key_create() requires DeleteThreadLocalValue() to have
+// C-linkage.  Therefore it cannot be templatized to access
+// ThreadLocal<T>.  Hence the need for class
+// ThreadLocalValueHolderBase.
+class ThreadLocalValueHolderBase {
+ public:
+  virtual ~ThreadLocalValueHolderBase() {}
+};
+
+// Called by pthread to delete thread-local data stored by
+// pthread_setspecific().
+extern "C" inline void DeleteThreadLocalValue(void* value_holder) {
+  delete static_cast<ThreadLocalValueHolderBase*>(value_holder);
+}
+
+// Implements thread-local storage on pthreads-based systems.
+template <typename T>
+class GTEST_API_ ThreadLocal {
+ public:
+  ThreadLocal()
+      : key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
+  explicit ThreadLocal(const T& value)
+      : key_(CreateKey()),
+        default_factory_(new InstanceValueHolderFactory(value)) {}
+
+  ~ThreadLocal() {
+    // Destroys the managed object for the current thread, if any.
+    DeleteThreadLocalValue(pthread_getspecific(key_));
+
+    // Releases resources associated with the key.  This will *not*
+    // delete managed objects for other threads.
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
+  }
+
+  T* pointer() { return GetOrCreateValue(); }
+  const T* pointer() const { return GetOrCreateValue(); }
+  const T& get() const { return *pointer(); }
+  void set(const T& value) { *pointer() = value; }
+
+ private:
+  // Holds a value of type T.
+  class ValueHolder : public ThreadLocalValueHolderBase {
+   public:
+    ValueHolder() : value_() {}
+    explicit ValueHolder(const T& value) : value_(value) {}
+
+    T* pointer() { return &value_; }
+
+   private:
+    T value_;
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
+  };
+
+  static pthread_key_t CreateKey() {
+    pthread_key_t key;
+    // When a thread exits, DeleteThreadLocalValue() will be called on
+    // the object managed for that thread.
+    GTEST_CHECK_POSIX_SUCCESS_(
+        pthread_key_create(&key, &DeleteThreadLocalValue));
+    return key;
+  }
+
+  T* GetOrCreateValue() const {
+    ThreadLocalValueHolderBase* const holder =
+        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
+    if (holder != nullptr) {
+      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
+    }
+
+    ValueHolder* const new_holder = default_factory_->MakeNewHolder();
+    ThreadLocalValueHolderBase* const holder_base = new_holder;
+    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
+    return new_holder->pointer();
+  }
+
+  class ValueHolderFactory {
+   public:
+    ValueHolderFactory() {}
+    virtual ~ValueHolderFactory() {}
+    virtual ValueHolder* MakeNewHolder() const = 0;
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
+  };
+
+  class DefaultValueHolderFactory : public ValueHolderFactory {
+   public:
+    DefaultValueHolderFactory() {}
+    ValueHolder* MakeNewHolder() const override { return new ValueHolder(); }
+
+   private:
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
+  };
+
+  class InstanceValueHolderFactory : public ValueHolderFactory {
+   public:
+    explicit InstanceValueHolderFactory(const T& value) : value_(value) {}
+    ValueHolder* MakeNewHolder() const override {
+      return new ValueHolder(value_);
+    }
+
+   private:
+    const T value_;  // The value for each thread.
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
+  };
+
+  // A key pthreads uses for looking up per-thread values.
+  const pthread_key_t key_;
+  std::unique_ptr<ValueHolderFactory> default_factory_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
+};
+
+# endif  // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
+
+#else  // GTEST_IS_THREADSAFE
+
+// A dummy implementation of synchronization primitives (mutex, lock,
+// and thread-local variable).  Necessary for compiling Google Test where
+// mutex is not supported - using Google Test in multiple threads is not
+// supported on such platforms.
+
+class Mutex {
+ public:
+  Mutex() {}
+  void Lock() {}
+  void Unlock() {}
+  void AssertHeld() const {}
+};
+
+# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
+  extern ::testing::internal::Mutex mutex
+
+# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex
+
+// We cannot name this class MutexLock because the ctor declaration would
+// conflict with a macro named MutexLock, which is defined on some
+// platforms. That macro is used as a defensive measure to prevent against
+// inadvertent misuses of MutexLock like "MutexLock(&mu)" rather than
+// "MutexLock l(&mu)".  Hence the typedef trick below.
+class GTestMutexLock {
+ public:
+  explicit GTestMutexLock(Mutex*) {}  // NOLINT
+};
+
+typedef GTestMutexLock MutexLock;
+
+template <typename T>
+class GTEST_API_ ThreadLocal {
+ public:
+  ThreadLocal() : value_() {}
+  explicit ThreadLocal(const T& value) : value_(value) {}
+  T* pointer() { return &value_; }
+  const T* pointer() const { return &value_; }
+  const T& get() const { return value_; }
+  void set(const T& value) { value_ = value; }
+ private:
+  T value_;
+};
+
+#endif  // GTEST_IS_THREADSAFE
+
+// Returns the number of threads running in the process, or 0 to indicate that
+// we cannot detect it.
+GTEST_API_ size_t GetThreadCount();
+
+#if GTEST_OS_WINDOWS
+# define GTEST_PATH_SEP_ "\\"
+# define GTEST_HAS_ALT_PATH_SEP_ 1
+#else
+# define GTEST_PATH_SEP_ "/"
+# define GTEST_HAS_ALT_PATH_SEP_ 0
+#endif  // GTEST_OS_WINDOWS
+
+// Utilities for char.
+
+// isspace(int ch) and friends accept an unsigned char or EOF.  char
+// may be signed, depending on the compiler (or compiler flags).
+// Therefore we need to cast a char to unsigned char before calling
+// isspace(), etc.
+
+inline bool IsAlpha(char ch) {
+  return isalpha(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsAlNum(char ch) {
+  return isalnum(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsDigit(char ch) {
+  return isdigit(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsLower(char ch) {
+  return islower(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsSpace(char ch) {
+  return isspace(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsUpper(char ch) {
+  return isupper(static_cast<unsigned char>(ch)) != 0;
+}
+inline bool IsXDigit(char ch) {
+  return isxdigit(static_cast<unsigned char>(ch)) != 0;
+}
+#ifdef __cpp_char8_t
+inline bool IsXDigit(char8_t ch) {
+  return isxdigit(static_cast<unsigned char>(ch)) != 0;
+}
+#endif
+inline bool IsXDigit(char16_t ch) {
+  const unsigned char low_byte = static_cast<unsigned char>(ch);
+  return ch == low_byte && isxdigit(low_byte) != 0;
+}
+inline bool IsXDigit(char32_t ch) {
+  const unsigned char low_byte = static_cast<unsigned char>(ch);
+  return ch == low_byte && isxdigit(low_byte) != 0;
+}
+inline bool IsXDigit(wchar_t ch) {
+  const unsigned char low_byte = static_cast<unsigned char>(ch);
+  return ch == low_byte && isxdigit(low_byte) != 0;
+}
+
+inline char ToLower(char ch) {
+  return static_cast<char>(tolower(static_cast<unsigned char>(ch)));
+}
+inline char ToUpper(char ch) {
+  return static_cast<char>(toupper(static_cast<unsigned char>(ch)));
+}
+
+inline std::string StripTrailingSpaces(std::string str) {
+  std::string::iterator it = str.end();
+  while (it != str.begin() && IsSpace(*--it))
+    it = str.erase(it);
+  return str;
+}
+
+// The testing::internal::posix namespace holds wrappers for common
+// POSIX functions.  These wrappers hide the differences between
+// Windows/MSVC and POSIX systems.  Since some compilers define these
+// standard functions as macros, the wrapper cannot have the same name
+// as the wrapped function.
+
+namespace posix {
+
+// Functions with a different name on Windows.
+
+#if GTEST_OS_WINDOWS
+
+typedef struct _stat StatStruct;
+
+# ifdef __BORLANDC__
+inline int DoIsATTY(int fd) { return isatty(fd); }
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return stricmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return strdup(src); }
+# else  // !__BORLANDC__
+#  if GTEST_OS_WINDOWS_MOBILE
+inline int DoIsATTY(int /* fd */) { return 0; }
+#  else
+inline int DoIsATTY(int fd) { return _isatty(fd); }
+#  endif  // GTEST_OS_WINDOWS_MOBILE
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return _stricmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return _strdup(src); }
+# endif  // __BORLANDC__
+
+# if GTEST_OS_WINDOWS_MOBILE
+inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); }
+// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this
+// time and thus not defined there.
+# else
+inline int FileNo(FILE* file) { return _fileno(file); }
+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  // GTEST_OS_WINDOWS_MOBILE
+
+#elif GTEST_OS_ESP8266
+typedef struct stat StatStruct;
+
+inline int FileNo(FILE* file) { return fileno(file); }
+inline int DoIsATTY(int fd) { return isatty(fd); }
+inline int Stat(const char* path, StatStruct* buf) {
+  // stat function not implemented on ESP8266
+  return 0;
+}
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return strcasecmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return strdup(src); }
+inline int RmDir(const char* dir) { return rmdir(dir); }
+inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
+
+#else
+
+typedef struct stat StatStruct;
+
+inline int FileNo(FILE* file) { return fileno(file); }
+inline int DoIsATTY(int fd) { return isatty(fd); }
+inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); }
+inline int StrCaseCmp(const char* s1, const char* s2) {
+  return strcasecmp(s1, s2);
+}
+inline char* StrDup(const char* src) { return strdup(src); }
+inline int RmDir(const char* dir) { return rmdir(dir); }
+inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); }
+
+#endif  // GTEST_OS_WINDOWS
+
+inline int IsATTY(int fd) {
+  // DoIsATTY might change errno (for example ENOTTY in case you redirect stdout
+  // to a file on Linux), which is unexpected, so save the previous value, and
+  // restore it after the call.
+  int savedErrno = errno;
+  int isAttyValue = DoIsATTY(fd);
+  errno = savedErrno;
+
+  return isAttyValue;
+}
+
+// Functions deprecated by MSVC 8.0.
+
+GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
+
+// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and
+// StrError() aren't needed on Windows CE at this time and thus not
+// defined there.
+
+#if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && \
+    !GTEST_OS_WINDOWS_RT && !GTEST_OS_ESP8266 && !GTEST_OS_XTENSA
+inline int ChDir(const char* dir) { return chdir(dir); }
+#endif
+inline FILE* FOpen(const char* path, const char* mode) {
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
+  struct wchar_codecvt : public std::codecvt<wchar_t, char, std::mbstate_t> {};
+  std::wstring_convert<wchar_codecvt> converter;
+  std::wstring wide_path = converter.from_bytes(path);
+  std::wstring wide_mode = converter.from_bytes(mode);
+  return _wfopen(wide_path.c_str(), wide_mode.c_str());
+#else  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
+  return fopen(path, mode);
+#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
+}
+#if !GTEST_OS_WINDOWS_MOBILE
+inline FILE *FReopen(const char* path, const char* mode, FILE* stream) {
+  return freopen(path, mode, stream);
+}
+inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); }
+#endif
+inline int FClose(FILE* fp) { return fclose(fp); }
+#if !GTEST_OS_WINDOWS_MOBILE
+inline int Read(int fd, void* buf, unsigned int count) {
+  return static_cast<int>(read(fd, buf, count));
+}
+inline int Write(int fd, const void* buf, unsigned int count) {
+  return static_cast<int>(write(fd, buf, count));
+}
+inline int Close(int fd) { return close(fd); }
+inline const char* StrError(int errnum) { return strerror(errnum); }
+#endif
+inline const char* GetEnv(const char* name) {
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || \
+    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_XTENSA
+  // We are on an embedded platform, which has no environment variables.
+  static_cast<void>(name);  // To prevent 'unused argument' warning.
+  return nullptr;
+#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
+  // Environment variables which we programmatically clear will be set to the
+  // empty string rather than unset (NULL).  Handle that case.
+  const char* const env = getenv(name);
+  return (env != nullptr && env[0] != '\0') ? env : nullptr;
+#else
+  return getenv(name);
+#endif
+}
+
+GTEST_DISABLE_MSC_DEPRECATED_POP_()
+
+#if GTEST_OS_WINDOWS_MOBILE
+// Windows CE has no C library. The abort() function is used in
+// several places in Google Test. This implementation provides a reasonable
+// imitation of standard behaviour.
+[[noreturn]] void Abort();
+#else
+[[noreturn]] inline void Abort() { abort(); }
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+}  // namespace posix
+
+// MSVC "deprecates" snprintf and issues warnings wherever it is used.  In
+// order to avoid these warnings, we need to use _snprintf or _snprintf_s on
+// MSVC-based platforms.  We map the GTEST_SNPRINTF_ macro to the appropriate
+// function in order to achieve that.  We use macro definition here because
+// snprintf is a variadic function.
+#if _MSC_VER && !GTEST_OS_WINDOWS_MOBILE
+// MSVC 2005 and above support variadic macros.
+# define GTEST_SNPRINTF_(buffer, size, format, ...) \
+     _snprintf_s(buffer, size, size, format, __VA_ARGS__)
+#elif defined(_MSC_VER)
+// Windows CE does not define _snprintf_s
+# define GTEST_SNPRINTF_ _snprintf
+#else
+# define GTEST_SNPRINTF_ snprintf
+#endif
+
+// The biggest signed integer type the compiler supports.
+//
+// long long is guaranteed to be at least 64-bits in C++11.
+using BiggestInt = long long;  // NOLINT
+
+// The maximum number a BiggestInt can represent.
+constexpr BiggestInt kMaxBiggestInt = (std::numeric_limits<BiggestInt>::max)();
+
+// This template class serves as a compile-time function from size to
+// type.  It maps a size in bytes to a primitive type with that
+// size. e.g.
+//
+//   TypeWithSize<4>::UInt
+//
+// is typedef-ed to be unsigned int (unsigned integer made up of 4
+// bytes).
+//
+// Such functionality should belong to STL, but I cannot find it
+// there.
+//
+// Google Test uses this class in the implementation of floating-point
+// comparison.
+//
+// For now it only handles UInt (unsigned int) as that's all Google Test
+// needs.  Other types can be easily added in the future if need
+// arises.
+template <size_t size>
+class TypeWithSize {
+ public:
+  // This prevents the user from using TypeWithSize<N> with incorrect
+  // values of N.
+  using UInt = void;
+};
+
+// The specialization for size 4.
+template <>
+class TypeWithSize<4> {
+ public:
+  using Int = std::int32_t;
+  using UInt = std::uint32_t;
+};
+
+// The specialization for size 8.
+template <>
+class TypeWithSize<8> {
+ public:
+  using Int = std::int64_t;
+  using UInt = std::uint64_t;
+};
+
+// Integer types of known sizes.
+using TimeInMillis = int64_t;  // Represents time in milliseconds.
+
+// Utilities for command line flags and environment variables.
+
+// Macro for referencing flags.
+#if !defined(GTEST_FLAG)
+# define GTEST_FLAG(name) FLAGS_gtest_##name
+#endif  // !defined(GTEST_FLAG)
+
+#if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
+# define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
+#endif  // !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
+
+#if !defined(GTEST_DECLARE_bool_)
+# define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
+
+// Macros for declaring flags.
+# define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name)
+# define GTEST_DECLARE_int32_(name) \
+    GTEST_API_ extern std::int32_t GTEST_FLAG(name)
+# define GTEST_DECLARE_string_(name) \
+    GTEST_API_ extern ::std::string GTEST_FLAG(name)
+
+// Macros for defining flags.
+# define GTEST_DEFINE_bool_(name, default_val, doc) \
+    GTEST_API_ bool GTEST_FLAG(name) = (default_val)
+# define GTEST_DEFINE_int32_(name, default_val, doc) \
+    GTEST_API_ std::int32_t GTEST_FLAG(name) = (default_val)
+# define GTEST_DEFINE_string_(name, default_val, doc) \
+    GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val)
+
+#endif  // !defined(GTEST_DECLARE_bool_)
+
+// Thread annotations
+#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
+# define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks)
+# define GTEST_LOCK_EXCLUDED_(locks)
+#endif  // !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
+
+// Parses 'str' for a 32-bit signed integer.  If successful, writes the result
+// to *value and returns true; otherwise leaves *value unchanged and returns
+// false.
+GTEST_API_ bool ParseInt32(const Message& src_text, const char* str,
+                           int32_t* value);
+
+// Parses a bool/int32_t/string from the environment variable
+// corresponding to the given Google Test flag.
+bool BoolFromGTestEnv(const char* flag, bool default_val);
+GTEST_API_ int32_t Int32FromGTestEnv(const char* flag, int32_t default_val);
+std::string OutputFlagAlsoCheckEnvVar();
+const char* StringFromGTestEnv(const char* flag, const char* default_val);
+
+}  // 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)
+
+#if GTEST_HAS_ABSL
+// Always use absl::any for UniversalPrinter<> specializations if googletest
+// is built with absl support.
+#define GTEST_INTERNAL_HAS_ANY 1
+#include "absl/types/any.h"
+namespace testing {
+namespace internal {
+using Any = ::absl::any;
+}  // namespace internal
+}  // namespace testing
+#else
+#ifdef __has_include
+#if __has_include(<any>) && __cplusplus >= 201703L
+// Otherwise for C++17 and higher use std::any for UniversalPrinter<>
+// specializations.
+#define GTEST_INTERNAL_HAS_ANY 1
+#include <any>
+namespace testing {
+namespace internal {
+using Any = ::std::any;
+}  // namespace internal
+}  // namespace testing
+// The case where absl is configured NOT to alias std::any is not
+// supported.
+#endif  // __has_include(<any>) && __cplusplus >= 201703L
+#endif  // __has_include
+#endif  // GTEST_HAS_ABSL
+
+#if GTEST_HAS_ABSL
+// Always use absl::optional for UniversalPrinter<> specializations if
+// googletest is built with absl support.
+#define GTEST_INTERNAL_HAS_OPTIONAL 1
+#include "absl/types/optional.h"
+namespace testing {
+namespace internal {
+template <typename T>
+using Optional = ::absl::optional<T>;
+}  // namespace internal
+}  // namespace testing
+#else
+#ifdef __has_include
+#if __has_include(<optional>) && __cplusplus >= 201703L
+// Otherwise for C++17 and higher use std::optional for UniversalPrinter<>
+// specializations.
+#define GTEST_INTERNAL_HAS_OPTIONAL 1
+#include <optional>
+namespace testing {
+namespace internal {
+template <typename T>
+using Optional = ::std::optional<T>;
+}  // namespace internal
+}  // namespace testing
+// The case where absl is configured NOT to alias std::optional is not
+// supported.
+#endif  // __has_include(<optional>) && __cplusplus >= 201703L
+#endif  // __has_include
+#endif  // GTEST_HAS_ABSL
+
+#if GTEST_HAS_ABSL
+// Always use absl::string_view for Matcher<> specializations if googletest
+// is built with absl support.
+# define GTEST_INTERNAL_HAS_STRING_VIEW 1
+#include "absl/strings/string_view.h"
+namespace testing {
+namespace internal {
+using StringView = ::absl::string_view;
+}  // namespace internal
+}  // namespace testing
+#else
+# ifdef __has_include
+#   if __has_include(<string_view>) && __cplusplus >= 201703L
+// Otherwise for C++17 and higher use std::string_view for Matcher<>
+// specializations.
+#   define GTEST_INTERNAL_HAS_STRING_VIEW 1
+#include <string_view>
+namespace testing {
+namespace internal {
+using StringView = ::std::string_view;
+}  // namespace internal
+}  // namespace testing
+// The case where absl is configured NOT to alias std::string_view is not
+// supported.
+#  endif  // __has_include(<string_view>) && __cplusplus >= 201703L
+# endif  // __has_include
+#endif  // GTEST_HAS_ABSL
+
+#if GTEST_HAS_ABSL
+// Always use absl::variant for UniversalPrinter<> specializations if googletest
+// is built with absl support.
+#define GTEST_INTERNAL_HAS_VARIANT 1
+#include "absl/types/variant.h"
+namespace testing {
+namespace internal {
+template <typename... T>
+using Variant = ::absl::variant<T...>;
+}  // namespace internal
+}  // namespace testing
+#else
+#ifdef __has_include
+#if __has_include(<variant>) && __cplusplus >= 201703L
+// Otherwise for C++17 and higher use std::variant for UniversalPrinter<>
+// specializations.
+#define GTEST_INTERNAL_HAS_VARIANT 1
+#include <variant>
+namespace testing {
+namespace internal {
+template <typename... T>
+using Variant = ::std::variant<T...>;
+}  // namespace internal
+}  // namespace testing
+// The case where absl is configured NOT to alias std::variant is not supported.
+#endif  // __has_include(<variant>) && __cplusplus >= 201703L
+#endif  // __has_include
+#endif  // GTEST_HAS_ABSL
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-string.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-string.h
new file mode 100644
index 000000000..10f774f96
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-string.h
@@ -0,0 +1,175 @@
+// Copyright 2005, 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.
+//
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This header file declares the String class and functions used internally by
+// Google Test.  They are subject to change without notice. They should not used
+// by code external to Google Test.
+//
+// This header file is #included by gtest-internal.h.
+// It should not be #included by other files.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
+
+#ifdef __BORLANDC__
+// string.h is not guaranteed to provide strcpy on C++ Builder.
+# include <mem.h>
+#endif
+
+#include <string.h>
+#include <cstdint>
+#include <string>
+
+#include "gtest/internal/gtest-port.h"
+
+namespace testing {
+namespace internal {
+
+// String - an abstract class holding static string utilities.
+class GTEST_API_ String {
+ public:
+  // Static utility methods
+
+  // Clones a 0-terminated C string, allocating memory using new.  The
+  // caller is responsible for deleting the return value using
+  // delete[].  Returns the cloned string, or NULL if the input is
+  // NULL.
+  //
+  // This is different from strdup() in string.h, which allocates
+  // memory using malloc().
+  static const char* CloneCString(const char* c_str);
+
+#if GTEST_OS_WINDOWS_MOBILE
+  // Windows CE does not have the 'ANSI' versions of Win32 APIs. To be
+  // able to pass strings to Win32 APIs on CE we need to convert them
+  // to 'Unicode', UTF-16.
+
+  // Creates a UTF-16 wide string from the given ANSI string, allocating
+  // memory using new. The caller is responsible for deleting the return
+  // value using delete[]. Returns the wide string, or NULL if the
+  // input is NULL.
+  //
+  // The wide string is created using the ANSI codepage (CP_ACP) to
+  // match the behaviour of the ANSI versions of Win32 calls and the
+  // C runtime.
+  static LPCWSTR AnsiToUtf16(const char* c_str);
+
+  // Creates an ANSI string from the given wide string, allocating
+  // memory using new. The caller is responsible for deleting the return
+  // value using delete[]. Returns the ANSI string, or NULL if the
+  // input is NULL.
+  //
+  // The returned string is created using the ANSI codepage (CP_ACP) to
+  // match the behaviour of the ANSI versions of Win32 calls and the
+  // C runtime.
+  static const char* Utf16ToAnsi(LPCWSTR utf16_str);
+#endif
+
+  // Compares two C strings.  Returns true if and only if they have the same
+  // content.
+  //
+  // Unlike strcmp(), this function can handle NULL argument(s).  A
+  // NULL C string is considered different to any non-NULL C string,
+  // including the empty string.
+  static bool CStringEquals(const char* lhs, const char* rhs);
+
+  // Converts a wide C string to a String using the UTF-8 encoding.
+  // NULL will be converted to "(null)".  If an error occurred during
+  // the conversion, "(failed to convert from wide string)" is
+  // returned.
+  static std::string ShowWideCString(const wchar_t* wide_c_str);
+
+  // Compares two wide C strings.  Returns true if and only if they have the
+  // same content.
+  //
+  // Unlike wcscmp(), this function can handle NULL argument(s).  A
+  // NULL C string is considered different to any non-NULL C string,
+  // including the empty string.
+  static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs);
+
+  // Compares two C strings, ignoring case.  Returns true if and only if
+  // they have the same content.
+  //
+  // Unlike strcasecmp(), this function can handle NULL argument(s).
+  // A NULL C string is considered different to any non-NULL C string,
+  // including the empty string.
+  static bool CaseInsensitiveCStringEquals(const char* lhs,
+                                           const char* rhs);
+
+  // Compares two wide C strings, ignoring case.  Returns true if and only if
+  // they have the same content.
+  //
+  // Unlike wcscasecmp(), this function can handle NULL argument(s).
+  // A NULL C string is considered different to any non-NULL wide C string,
+  // including the empty string.
+  // NB: The implementations on different platforms slightly differ.
+  // On windows, this method uses _wcsicmp which compares according to LC_CTYPE
+  // environment variable. On GNU platform this method uses wcscasecmp
+  // which compares according to LC_CTYPE category of the current locale.
+  // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
+  // current locale.
+  static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
+                                               const wchar_t* rhs);
+
+  // Returns true if and only if the given string ends with the given suffix,
+  // ignoring case. Any string is considered to end with an empty suffix.
+  static bool EndsWithCaseInsensitive(
+      const std::string& str, const std::string& suffix);
+
+  // Formats an int value as "%02d".
+  static std::string FormatIntWidth2(int value);  // "%02d" for width == 2
+
+  // Formats an int value to given width with leading zeros.
+  static std::string FormatIntWidthN(int value, int width);
+
+  // Formats an int value as "%X".
+  static std::string FormatHexInt(int value);
+
+  // Formats an int value as "%X".
+  static std::string FormatHexUInt32(uint32_t value);
+
+  // Formats a byte as "%02X".
+  static std::string FormatByte(unsigned char value);
+
+ private:
+  String();  // Not meant to be instantiated.
+};  // class String
+
+// Gets the content of the stringstream's buffer as an std::string.  Each '\0'
+// character in the buffer is replaced with "\\0".
+GTEST_API_ std::string StringStreamToString(::std::stringstream* stream);
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-type-util.h b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-type-util.h
new file mode 100644
index 000000000..b87a2e2ca
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/include/gtest/internal/gtest-type-util.h
@@ -0,0 +1,183 @@
+// Copyright 2008 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.
+
+// Type utilities needed for implementing typed and type-parameterized
+// tests.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
+#ifndef GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
+#define GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
+
+#include "gtest/internal/gtest-port.h"
+
+// #ifdef __GNUC__ is too general here.  It is possible to use gcc without using
+// libstdc++ (which is where cxxabi.h comes from).
+# if GTEST_HAS_CXXABI_H_
+#  include <cxxabi.h>
+# elif defined(__HP_aCC)
+#  include <acxx_demangle.h>
+# endif  // GTEST_HASH_CXXABI_H_
+
+namespace testing {
+namespace internal {
+
+// Canonicalizes a given name with respect to the Standard C++ Library.
+// This handles removing the inline namespace within `std` that is
+// used by various standard libraries (e.g., `std::__1`).  Names outside
+// of namespace std are returned unmodified.
+inline std::string CanonicalizeForStdLibVersioning(std::string s) {
+  static const char prefix[] = "std::__";
+  if (s.compare(0, strlen(prefix), prefix) == 0) {
+    std::string::size_type end = s.find("::", strlen(prefix));
+    if (end != s.npos) {
+      // Erase everything between the initial `std` and the second `::`.
+      s.erase(strlen("std"), end - strlen("std"));
+    }
+  }
+  return s;
+}
+
+#if GTEST_HAS_RTTI
+// GetTypeName(const std::type_info&) returns a human-readable name of type T.
+inline std::string GetTypeName(const std::type_info& type) {
+  const char* const name = type.name();
+#if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC)
+  int status = 0;
+  // gcc's implementation of typeid(T).name() mangles the type name,
+  // so we have to demangle it.
+#if GTEST_HAS_CXXABI_H_
+  using abi::__cxa_demangle;
+#endif  // GTEST_HAS_CXXABI_H_
+  char* const readable_name = __cxa_demangle(name, nullptr, nullptr, &status);
+  const std::string name_str(status == 0 ? readable_name : name);
+  free(readable_name);
+  return CanonicalizeForStdLibVersioning(name_str);
+#else
+  return name;
+#endif  // GTEST_HAS_CXXABI_H_ || __HP_aCC
+}
+#endif  // GTEST_HAS_RTTI
+
+// GetTypeName<T>() returns a human-readable name of type T if and only if
+// RTTI is enabled, otherwise it returns a dummy type name.
+// NB: This function is also used in Google Mock, so don't move it inside of
+// the typed-test-only section below.
+template <typename T>
+std::string GetTypeName() {
+#if GTEST_HAS_RTTI
+  return GetTypeName(typeid(T));
+#else
+  return "<type>";
+#endif  // GTEST_HAS_RTTI
+}
+
+// A unique type indicating an empty node
+struct None {};
+
+# define GTEST_TEMPLATE_ template <typename T> class
+
+// The template "selector" struct TemplateSel<Tmpl> is used to
+// represent Tmpl, which must be a class template with one type
+// parameter, as a type.  TemplateSel<Tmpl>::Bind<T>::type is defined
+// as the type Tmpl<T>.  This allows us to actually instantiate the
+// template "selected" by TemplateSel<Tmpl>.
+//
+// This trick is necessary for simulating typedef for class templates,
+// which C++ doesn't support directly.
+template <GTEST_TEMPLATE_ Tmpl>
+struct TemplateSel {
+  template <typename T>
+  struct Bind {
+    typedef Tmpl<T> type;
+  };
+};
+
+# define GTEST_BIND_(TmplSel, T) \
+  TmplSel::template Bind<T>::type
+
+template <GTEST_TEMPLATE_ Head_, GTEST_TEMPLATE_... Tail_>
+struct Templates {
+  using Head = TemplateSel<Head_>;
+  using Tail = Templates<Tail_...>;
+};
+
+template <GTEST_TEMPLATE_ Head_>
+struct Templates<Head_> {
+  using Head = TemplateSel<Head_>;
+  using Tail = None;
+};
+
+// Tuple-like type lists
+template <typename Head_, typename... Tail_>
+struct Types {
+  using Head = Head_;
+  using Tail = Types<Tail_...>;
+};
+
+template <typename Head_>
+struct Types<Head_> {
+  using Head = Head_;
+  using Tail = None;
+};
+
+// Helper metafunctions to tell apart a single type from types
+// generated by ::testing::Types
+template <typename... Ts>
+struct ProxyTypeList {
+  using type = Types<Ts...>;
+};
+
+template <typename>
+struct is_proxy_type_list : std::false_type {};
+
+template <typename... Ts>
+struct is_proxy_type_list<ProxyTypeList<Ts...>> : std::true_type {};
+
+// Generator which conditionally creates type lists.
+// It recognizes if a requested type list should be created
+// and prevents creating a new type list nested within another one.
+template <typename T>
+struct GenerateTypeList {
+ private:
+  using proxy = typename std::conditional<is_proxy_type_list<T>::value, T,
+                                          ProxyTypeList<T>>::type;
+
+ public:
+  using type = typename proxy::type;
+};
+
+}  // namespace internal
+
+template <typename... Ts>
+using Types = internal::ProxyTypeList<Ts...>;
+
+}  // namespace testing
+
+#endif  // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/src/gtest-all.cc b/trunk/3rdparty/gtest-fit/googletest/src/gtest-all.cc
new file mode 100644
index 000000000..ad292905c
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/src/gtest-all.cc
@@ -0,0 +1,48 @@
+// Copyright 2008, 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.
+
+//
+// Google C++ Testing and Mocking Framework (Google Test)
+//
+// Sometimes it's desirable to build Google Test by compiling a single file.
+// This file serves this purpose.
+
+// This line ensures that gtest.h can be compiled on its own, even
+// when it's fused.
+#include "gtest/gtest.h"
+
+// The following lines pull in the real gtest *.cc files.
+#include "src/gtest.cc"
+#include "src/gtest-death-test.cc"
+#include "src/gtest-filepath.cc"
+#include "src/gtest-matchers.cc"
+#include "src/gtest-port.cc"
+#include "src/gtest-printers.cc"
+#include "src/gtest-test-part.cc"
+#include "src/gtest-typed-test.cc"
diff --git a/trunk/3rdparty/gtest-fit/googletest/src/gtest-death-test.cc b/trunk/3rdparty/gtest-fit/googletest/src/gtest-death-test.cc
new file mode 100644
index 000000000..bf4f6331d
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/src/gtest-death-test.cc
@@ -0,0 +1,1644 @@
+// Copyright 2005, 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.
+
+//
+// This file implements death tests.
+
+#include "gtest/gtest-death-test.h"
+
+#include <functional>
+#include <utility>
+
+#include "gtest/internal/gtest-port.h"
+#include "gtest/internal/custom/gtest.h"
+
+#if GTEST_HAS_DEATH_TEST
+
+# if GTEST_OS_MAC
+#  include <crt_externs.h>
+# endif  // GTEST_OS_MAC
+
+# include <errno.h>
+# include <fcntl.h>
+# include <limits.h>
+
+# if GTEST_OS_LINUX
+#  include <signal.h>
+# endif  // GTEST_OS_LINUX
+
+# include <stdarg.h>
+
+# if GTEST_OS_WINDOWS
+#  include <windows.h>
+# else
+#  include <sys/mman.h>
+#  include <sys/wait.h>
+# endif  // GTEST_OS_WINDOWS
+
+# if GTEST_OS_QNX
+#  include <spawn.h>
+# endif  // GTEST_OS_QNX
+
+# if GTEST_OS_FUCHSIA
+#  include <lib/fdio/fd.h>
+#  include <lib/fdio/io.h>
+#  include <lib/fdio/spawn.h>
+#  include <lib/zx/channel.h>
+#  include <lib/zx/port.h>
+#  include <lib/zx/process.h>
+#  include <lib/zx/socket.h>
+#  include <zircon/processargs.h>
+#  include <zircon/syscalls.h>
+#  include <zircon/syscalls/policy.h>
+#  include <zircon/syscalls/port.h>
+# endif  // GTEST_OS_FUCHSIA
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+#include "gtest/gtest-message.h"
+#include "gtest/internal/gtest-string.h"
+#include "src/gtest-internal-inl.h"
+
+namespace testing {
+
+// Constants.
+
+// The default death test style.
+//
+// This is defined in internal/gtest-port.h as "fast", but can be overridden by
+// a definition in internal/custom/gtest-port.h. The recommended value, which is
+// used internally at Google, is "threadsafe".
+static const char kDefaultDeathTestStyle[] = GTEST_DEFAULT_DEATH_TEST_STYLE;
+
+GTEST_DEFINE_string_(
+    death_test_style,
+    internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle),
+    "Indicates how to run a death test in a forked child process: "
+    "\"threadsafe\" (child process re-executes the test binary "
+    "from the beginning, running only the specific death test) or "
+    "\"fast\" (child process runs the death test immediately "
+    "after forking).");
+
+GTEST_DEFINE_bool_(
+    death_test_use_fork,
+    internal::BoolFromGTestEnv("death_test_use_fork", false),
+    "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 "
+    "it sees an unsupported combination of clone() flags. "
+    "It is not recommended to use this flag w/o valgrind though it will "
+    "work in 99% of the cases. Once valgrind is fixed, this flag will "
+    "most likely be removed.");
+
+namespace internal {
+GTEST_DEFINE_string_(
+    internal_run_death_test, "",
+    "Indicates the file, line number, temporal index of "
+    "the single death test to run, and a file descriptor to "
+    "which a success code may be sent, all separated by "
+    "the '|' characters.  This flag is specified if and only if the "
+    "current process is a sub-process launched for running a thread-safe "
+    "death test.  FOR INTERNAL USE ONLY.");
+}  // namespace internal
+
+#if GTEST_HAS_DEATH_TEST
+
+namespace internal {
+
+// Valid only for fast death tests. Indicates the code is running in the
+// child process of a fast style death test.
+# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+static bool g_in_fast_death_test_child = false;
+# endif
+
+// Returns a Boolean value indicating whether the caller is currently
+// executing in the context of the death test child process.  Tools such as
+// Valgrind heap checkers may need this to modify their behavior in death
+// tests.  IMPORTANT: This is an internal utility.  Using it may break the
+// implementation of death tests.  User code MUST NOT use it.
+bool InDeathTestChild() {
+# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+
+  // On Windows and Fuchsia, death tests are thread-safe regardless of the value
+  // of the death_test_style flag.
+  return !GTEST_FLAG(internal_run_death_test).empty();
+
+# else
+
+  if (GTEST_FLAG(death_test_style) == "threadsafe")
+    return !GTEST_FLAG(internal_run_death_test).empty();
+  else
+    return g_in_fast_death_test_child;
+#endif
+}
+
+}  // namespace internal
+
+// ExitedWithCode constructor.
+ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) {
+}
+
+// ExitedWithCode function-call operator.
+bool ExitedWithCode::operator()(int exit_status) const {
+# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+
+  return exit_status == exit_code_;
+
+# else
+
+  return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_;
+
+# endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+}
+
+# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+// KilledBySignal constructor.
+KilledBySignal::KilledBySignal(int signum) : signum_(signum) {
+}
+
+// KilledBySignal function-call operator.
+bool KilledBySignal::operator()(int exit_status) const {
+#  if defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
+  {
+    bool result;
+    if (GTEST_KILLED_BY_SIGNAL_OVERRIDE_(signum_, exit_status, &result)) {
+      return result;
+    }
+  }
+#  endif  // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
+  return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_;
+}
+# endif  // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+
+namespace internal {
+
+// Utilities needed for death tests.
+
+// Generates a textual description of a given exit code, in the format
+// specified by wait(2).
+static std::string ExitSummary(int exit_code) {
+  Message m;
+
+# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+
+  m << "Exited with exit status " << exit_code;
+
+# else
+
+  if (WIFEXITED(exit_code)) {
+    m << "Exited with exit status " << WEXITSTATUS(exit_code);
+  } else if (WIFSIGNALED(exit_code)) {
+    m << "Terminated by signal " << WTERMSIG(exit_code);
+  }
+#  ifdef WCOREDUMP
+  if (WCOREDUMP(exit_code)) {
+    m << " (core dumped)";
+  }
+#  endif
+# endif  // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
+
+  return m.GetString();
+}
+
+// Returns true if exit_status describes a process that was terminated
+// by a signal, or exited normally with a nonzero exit code.
+bool ExitedUnsuccessfully(int exit_status) {
+  return !ExitedWithCode(0)(exit_status);
+}
+
+# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+// Generates a textual failure message when a death test finds more than
+// one thread running, or cannot determine the number of threads, prior
+// to executing the given statement.  It is the responsibility of the
+// caller not to pass a thread_count of 1.
+static std::string DeathTestThreadWarning(size_t thread_count) {
+  Message msg;
+  msg << "Death tests use fork(), which is unsafe particularly"
+      << " in a threaded context. For this test, " << GTEST_NAME_ << " ";
+  if (thread_count == 0) {
+    msg << "couldn't detect the number of threads.";
+  } else {
+    msg << "detected " << thread_count << " threads.";
+  }
+  msg << " See "
+         "https://github.com/google/googletest/blob/master/docs/"
+         "advanced.md#death-tests-and-threads"
+      << " for more explanation and suggested solutions, especially if"
+      << " this is the last message you see before your test times out.";
+  return msg.GetString();
+}
+# endif  // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
+
+// Flag characters for reporting a death test that did not die.
+static const char kDeathTestLived = 'L';
+static const char kDeathTestReturned = 'R';
+static const char kDeathTestThrew = 'T';
+static const char kDeathTestInternalError = 'I';
+
+#if GTEST_OS_FUCHSIA
+
+// File descriptor used for the pipe in the child process.
+static const int kFuchsiaReadPipeFd = 3;
+
+#endif
+
+// An enumeration describing all of the possible ways that a death test can
+// conclude.  DIED means that the process died while executing the test
+// code; LIVED means that process lived beyond the end of the test code;
+// RETURNED means that the test statement attempted to execute a return
+// statement, which is not allowed; THREW means that the test statement
+// returned control by throwing an exception.  IN_PROGRESS means the test
+// has not yet concluded.
+enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW };
+
+// Routine for aborting the program which is safe to call from an
+// exec-style death test child process, in which case the error
+// message is propagated back to the parent process.  Otherwise, the
+// message is simply printed to stderr.  In either case, the program
+// then exits with status 1.
+static void DeathTestAbort(const std::string& message) {
+  // On a POSIX system, this function may be called from a threadsafe-style
+  // death test child process, which operates on a very small stack.  Use
+  // the heap for any additional non-minuscule memory requirements.
+  const InternalRunDeathTestFlag* const flag =
+      GetUnitTestImpl()->internal_run_death_test_flag();
+  if (flag != nullptr) {
+    FILE* parent = posix::FDOpen(flag->write_fd(), "w");
+    fputc(kDeathTestInternalError, parent);
+    fprintf(parent, "%s", message.c_str());
+    fflush(parent);
+    _exit(1);
+  } else {
+    fprintf(stderr, "%s", message.c_str());
+    fflush(stderr);
+    posix::Abort();
+  }
+}
+
+// A replacement for CHECK that calls DeathTestAbort if the assertion
+// fails.
+# define GTEST_DEATH_TEST_CHECK_(expression) \
+  do { \
+    if (!::testing::internal::IsTrue(expression)) { \
+      DeathTestAbort( \
+          ::std::string("CHECK failed: File ") + __FILE__ +  ", line " \
+          + ::testing::internal::StreamableToString(__LINE__) + ": " \
+          + #expression); \
+    } \
+  } while (::testing::internal::AlwaysFalse())
+
+// This macro is similar to GTEST_DEATH_TEST_CHECK_, but it is meant for
+// evaluating any system call that fulfills two conditions: it must return
+// -1 on failure, and set errno to EINTR when it is interrupted and
+// should be tried again.  The macro expands to a loop that repeatedly
+// evaluates the expression as long as it evaluates to -1 and sets
+// errno to EINTR.  If the expression evaluates to -1 but errno is
+// something other than EINTR, DeathTestAbort is called.
+# define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression) \
+  do { \
+    int gtest_retval; \
+    do { \
+      gtest_retval = (expression); \
+    } while (gtest_retval == -1 && errno == EINTR); \
+    if (gtest_retval == -1) { \
+      DeathTestAbort( \
+          ::std::string("CHECK failed: File ") + __FILE__ + ", line " \
+          + ::testing::internal::StreamableToString(__LINE__) + ": " \
+          + #expression + " != -1"); \
+    } \
+  } while (::testing::internal::AlwaysFalse())
+
+// Returns the message describing the last system error in errno.
+std::string GetLastErrnoDescription() {
+    return errno == 0 ? "" : posix::StrError(errno);
+}
+
+// This is called from a death test parent process to read a failure
+// message from the death test child process and log it with the FATAL
+// severity. On Windows, the message is read from a pipe handle. On other
+// platforms, it is read from a file descriptor.
+static void FailFromInternalError(int fd) {
+  Message error;
+  char buffer[256];
+  int num_read;
+
+  do {
+    while ((num_read = posix::Read(fd, buffer, 255)) > 0) {
+      buffer[num_read] = '\0';
+      error << buffer;
+    }
+  } while (num_read == -1 && errno == EINTR);
+
+  if (num_read == 0) {
+    GTEST_LOG_(FATAL) << error.GetString();
+  } else {
+    const int last_error = errno;
+    GTEST_LOG_(FATAL) << "Error while reading death test internal: "
+                      << GetLastErrnoDescription() << " [" << last_error << "]";
+  }
+}
+
+// Death test constructor.  Increments the running death test count
+// for the current test.
+DeathTest::DeathTest() {
+  TestInfo* const info = GetUnitTestImpl()->current_test_info();
+  if (info == nullptr) {
+    DeathTestAbort("Cannot run a death test outside of a TEST or "
+                   "TEST_F construct");
+  }
+}
+
+// Creates and returns a death test by dispatching to the current
+// death test factory.
+bool DeathTest::Create(const char* statement,
+                       Matcher<const std::string&> matcher, const char* file,
+                       int line, DeathTest** test) {
+  return GetUnitTestImpl()->death_test_factory()->Create(
+      statement, std::move(matcher), file, line, test);
+}
+
+const char* DeathTest::LastMessage() {
+  return last_death_test_message_.c_str();
+}
+
+void DeathTest::set_last_death_test_message(const std::string& message) {
+  last_death_test_message_ = message;
+}
+
+std::string DeathTest::last_death_test_message_;
+
+// Provides cross platform implementation for some death functionality.
+class DeathTestImpl : public DeathTest {
+ protected:
+  DeathTestImpl(const char* a_statement, Matcher<const std::string&> matcher)
+      : statement_(a_statement),
+        matcher_(std::move(matcher)),
+        spawned_(false),
+        status_(-1),
+        outcome_(IN_PROGRESS),
+        read_fd_(-1),
+        write_fd_(-1) {}
+
+  // read_fd_ is expected to be closed and cleared by a derived class.
+  ~DeathTestImpl() override { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); }
+
+  void Abort(AbortReason reason) override;
+  bool Passed(bool status_ok) override;
+
+  const char* statement() const { return statement_; }
+  bool spawned() const { return spawned_; }
+  void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
+  int status() const { return status_; }
+  void set_status(int a_status) { status_ = a_status; }
+  DeathTestOutcome outcome() const { return outcome_; }
+  void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outcome; }
+  int read_fd() const { return read_fd_; }
+  void set_read_fd(int fd) { read_fd_ = fd; }
+  int write_fd() const { return write_fd_; }
+  void set_write_fd(int fd) { write_fd_ = fd; }
+
+  // Called in the parent process only. Reads the result code of the death
+  // test child process via a pipe, interprets it to set the outcome_
+  // member, and closes read_fd_.  Outputs diagnostics and terminates in
+  // case of unexpected codes.
+  void ReadAndInterpretStatusByte();
+
+  // Returns stderr output from the child process.
+  virtual std::string GetErrorLogs();
+
+ private:
+  // The textual content of the code this object is testing.  This class
+  // doesn't own this string and should not attempt to delete it.
+  const char* const statement_;
+  // A matcher that's expected to match the stderr output by the child process.
+  Matcher<const std::string&> matcher_;
+  // True if the death test child process has been successfully spawned.
+  bool spawned_;
+  // The exit status of the child process.
+  int status_;
+  // How the death test concluded.
+  DeathTestOutcome outcome_;
+  // Descriptor to the read end of the pipe to the child process.  It is
+  // always -1 in the child process.  The child keeps its write end of the
+  // pipe in write_fd_.
+  int read_fd_;
+  // Descriptor to the child's write end of the pipe to the parent process.
+  // It is always -1 in the parent process.  The parent keeps its end of the
+  // pipe in read_fd_.
+  int write_fd_;
+};
+
+// Called in the parent process only. Reads the result code of the death
+// test child process via a pipe, interprets it to set the outcome_
+// member, and closes read_fd_.  Outputs diagnostics and terminates in
+// case of unexpected codes.
+void DeathTestImpl::ReadAndInterpretStatusByte() {
+  char flag;
+  int bytes_read;
+
+  // The read() here blocks until data is available (signifying the
+  // failure of the death test) or until the pipe is closed (signifying
+  // its success), so it's okay to call this in the parent before
+  // the child process has exited.
+  do {
+    bytes_read = posix::Read(read_fd(), &flag, 1);
+  } while (bytes_read == -1 && errno == EINTR);
+
+  if (bytes_read == 0) {
+    set_outcome(DIED);
+  } else if (bytes_read == 1) {
+    switch (flag) {
+      case kDeathTestReturned:
+        set_outcome(RETURNED);
+        break;
+      case kDeathTestThrew:
+        set_outcome(THREW);
+        break;
+      case kDeathTestLived:
+        set_outcome(LIVED);
+        break;
+      case kDeathTestInternalError:
+        FailFromInternalError(read_fd());  // Does not return.
+        break;
+      default:
+        GTEST_LOG_(FATAL) << "Death test child process reported "
+                          << "unexpected status byte ("
+                          << static_cast<unsigned int>(flag) << ")";
+    }
+  } else {
+    GTEST_LOG_(FATAL) << "Read from death test child process failed: "
+                      << GetLastErrnoDescription();
+  }
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd()));
+  set_read_fd(-1);
+}
+
+std::string DeathTestImpl::GetErrorLogs() {
+  return GetCapturedStderr();
+}
+
+// Signals that the death test code which should have exited, didn't.
+// Should be called only in a death test child process.
+// Writes a status byte to the child's status file descriptor, then
+// calls _exit(1).
+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
+  // to the pipe, then exit.
+  const char status_ch =
+      reason == TEST_DID_NOT_DIE ? kDeathTestLived :
+      reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned;
+
+  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
+  // 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)
+}
+
+// Returns an indented copy of stderr output for a death test.
+// This makes distinguishing death test output lines from regular log lines
+// much easier.
+static ::std::string FormatDeathTestOutput(const ::std::string& output) {
+  ::std::string ret;
+  for (size_t at = 0; ; ) {
+    const size_t line_end = output.find('\n', at);
+    ret += "[  DEATH   ] ";
+    if (line_end == ::std::string::npos) {
+      ret += output.substr(at);
+      break;
+    }
+    ret += output.substr(at, line_end + 1 - at);
+    at = line_end + 1;
+  }
+  return ret;
+}
+
+// Assesses the success or failure of a death test, using both private
+// members which have previously been set, and one argument:
+//
+// Private data members:
+//   outcome:  An enumeration describing how the death test
+//             concluded: DIED, LIVED, THREW, or RETURNED.  The death test
+//             fails in the latter three cases.
+//   status:   The exit status of the child process. On *nix, it is in the
+//             in the format specified by wait(2). On Windows, this is the
+//             value supplied to the ExitProcess() API or a numeric code
+//             of the exception that terminated the program.
+//   matcher_: A matcher that's expected to match the stderr output by the child
+//             process.
+//
+// Argument:
+//   status_ok: true if exit_status is acceptable in the context of
+//              this particular death test, which fails if it is false
+//
+// Returns true if and only if all of the above conditions are met.  Otherwise,
+// the first failing condition, in the order given above, is the one that is
+// reported. Also sets the last death test message string.
+bool DeathTestImpl::Passed(bool status_ok) {
+  if (!spawned())
+    return false;
+
+  const std::string error_message = GetErrorLogs();
+
+  bool success = false;
+  Message buffer;
+
+  buffer << "Death test: " << statement() << "\n";
+  switch (outcome()) {
+    case LIVED:
+      buffer << "    Result: failed to die.\n"
+             << " Error msg:\n" << FormatDeathTestOutput(error_message);
+      break;
+    case THREW:
+      buffer << "    Result: threw an exception.\n"
+             << " Error msg:\n" << FormatDeathTestOutput(error_message);
+      break;
+    case RETURNED:
+      buffer << "    Result: illegal return in test statement.\n"
+             << " Error msg:\n" << FormatDeathTestOutput(error_message);
+      break;
+    case DIED:
+      if (status_ok) {
+        if (matcher_.Matches(error_message)) {
+          success = true;
+        } else {
+          std::ostringstream stream;
+          matcher_.DescribeTo(&stream);
+          buffer << "    Result: died but not with expected error.\n"
+                 << "  Expected: " << stream.str() << "\n"
+                 << "Actual msg:\n"
+                 << FormatDeathTestOutput(error_message);
+        }
+      } else {
+        buffer << "    Result: died but not with expected exit code:\n"
+               << "            " << ExitSummary(status()) << "\n"
+               << "Actual msg:\n" << FormatDeathTestOutput(error_message);
+      }
+      break;
+    case IN_PROGRESS:
+    default:
+      GTEST_LOG_(FATAL)
+          << "DeathTest::Passed somehow called before conclusion of test";
+  }
+
+  DeathTest::set_last_death_test_message(buffer.GetString());
+  return success;
+}
+
+# if GTEST_OS_WINDOWS
+// WindowsDeathTest implements death tests on Windows. Due to the
+// specifics of starting new processes on Windows, death tests there are
+// always threadsafe, and Google Test considers the
+// --gtest_death_test_style=fast setting to be equivalent to
+// --gtest_death_test_style=threadsafe there.
+//
+// A few implementation notes:  Like the Linux version, the Windows
+// implementation uses pipes for child-to-parent communication. But due to
+// the specifics of pipes on Windows, some extra steps are required:
+//
+// 1. The parent creates a communication pipe and stores handles to both
+//    ends of it.
+// 2. The parent starts the child and provides it with the information
+//    necessary to acquire the handle to the write end of the pipe.
+// 3. The child acquires the write end of the pipe and signals the parent
+//    using a Windows event.
+// 4. Now the parent can release the write end of the pipe on its side. If
+//    this is done before step 3, the object's reference count goes down to
+//    0 and it is destroyed, preventing the child from acquiring it. The
+//    parent now has to release it, or read operations on the read end of
+//    the pipe will not return when the child terminates.
+// 5. The parent reads child's output through the pipe (outcome code and
+//    any possible error messages) from the pipe, and its stderr and then
+//    determines whether to fail the test.
+//
+// Note: to distinguish Win32 API calls from the local method and function
+// calls, the former are explicitly resolved in the global namespace.
+//
+class WindowsDeathTest : public DeathTestImpl {
+ public:
+  WindowsDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
+                   const char* file, int line)
+      : DeathTestImpl(a_statement, std::move(matcher)),
+        file_(file),
+        line_(line) {}
+
+  // All of these virtual functions are inherited from DeathTest.
+  virtual int Wait();
+  virtual TestRole AssumeRole();
+
+ private:
+  // The name of the file in which the death test is located.
+  const char* const file_;
+  // The line number on which the death test is located.
+  const int line_;
+  // Handle to the write end of the pipe to the child process.
+  AutoHandle write_handle_;
+  // Child process handle.
+  AutoHandle child_handle_;
+  // Event the child process uses to signal the parent that it has
+  // acquired the handle to the write end of the pipe. After seeing this
+  // event the parent can release its own handles to make sure its
+  // ReadFile() calls return when the child terminates.
+  AutoHandle event_handle_;
+};
+
+// Waits for the child in a death test to exit, returning its exit
+// status, or 0 if no child process exists.  As a side effect, sets the
+// outcome data member.
+int WindowsDeathTest::Wait() {
+  if (!spawned())
+    return 0;
+
+  // Wait until the child either signals that it has acquired the write end
+  // of the pipe or it dies.
+  const HANDLE wait_handles[2] = { child_handle_.Get(), event_handle_.Get() };
+  switch (::WaitForMultipleObjects(2,
+                                   wait_handles,
+                                   FALSE,  // Waits for any of the handles.
+                                   INFINITE)) {
+    case WAIT_OBJECT_0:
+    case WAIT_OBJECT_0 + 1:
+      break;
+    default:
+      GTEST_DEATH_TEST_CHECK_(false);  // Should not get here.
+  }
+
+  // The child has acquired the write end of the pipe or exited.
+  // We release the handle on our side and continue.
+  write_handle_.Reset();
+  event_handle_.Reset();
+
+  ReadAndInterpretStatusByte();
+
+  // Waits for the child process to exit if it haven't already. This
+  // returns immediately if the child has already exited, regardless of
+  // whether previous calls to WaitForMultipleObjects synchronized on this
+  // handle or not.
+  GTEST_DEATH_TEST_CHECK_(
+      WAIT_OBJECT_0 == ::WaitForSingleObject(child_handle_.Get(),
+                                             INFINITE));
+  DWORD status_code;
+  GTEST_DEATH_TEST_CHECK_(
+      ::GetExitCodeProcess(child_handle_.Get(), &status_code) != FALSE);
+  child_handle_.Reset();
+  set_status(static_cast<int>(status_code));
+  return status();
+}
+
+// The AssumeRole process for a Windows death test.  It creates a child
+// process with the same executable as the current process to run the
+// death test.  The child process is given the --gtest_filter and
+// --gtest_internal_run_death_test flags such that it knows to run the
+// current death test only.
+DeathTest::TestRole WindowsDeathTest::AssumeRole() {
+  const UnitTestImpl* const impl = GetUnitTestImpl();
+  const InternalRunDeathTestFlag* const flag =
+      impl->internal_run_death_test_flag();
+  const TestInfo* const info = impl->current_test_info();
+  const int death_test_index = info->result()->death_test_count();
+
+  if (flag != nullptr) {
+    // ParseInternalRunDeathTestFlag() has performed all the necessary
+    // processing.
+    set_write_fd(flag->write_fd());
+    return EXECUTE_TEST;
+  }
+
+  // WindowsDeathTest uses an anonymous pipe to communicate results of
+  // a death test.
+  SECURITY_ATTRIBUTES handles_are_inheritable = {sizeof(SECURITY_ATTRIBUTES),
+                                                 nullptr, TRUE};
+  HANDLE read_handle, write_handle;
+  GTEST_DEATH_TEST_CHECK_(
+      ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable,
+                   0)  // Default buffer size.
+      != FALSE);
+  set_read_fd(::_open_osfhandle(reinterpret_cast<intptr_t>(read_handle),
+                                O_RDONLY));
+  write_handle_.Reset(write_handle);
+  event_handle_.Reset(::CreateEvent(
+      &handles_are_inheritable,
+      TRUE,       // The event will automatically reset to non-signaled state.
+      FALSE,      // The initial state is non-signalled.
+      nullptr));  // The even is unnamed.
+  GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != nullptr);
+  const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
+                                  kFilterFlag + "=" + info->test_suite_name() +
+                                  "." + info->name();
+  const std::string internal_flag =
+      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag +
+      "=" + file_ + "|" + StreamableToString(line_) + "|" +
+      StreamableToString(death_test_index) + "|" +
+      StreamableToString(static_cast<unsigned int>(::GetCurrentProcessId())) +
+      // size_t has the same width as pointers on both 32-bit and 64-bit
+      // Windows platforms.
+      // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx.
+      "|" + StreamableToString(reinterpret_cast<size_t>(write_handle)) +
+      "|" + StreamableToString(reinterpret_cast<size_t>(event_handle_.Get()));
+
+  char executable_path[_MAX_PATH + 1];  // NOLINT
+  GTEST_DEATH_TEST_CHECK_(_MAX_PATH + 1 != ::GetModuleFileNameA(nullptr,
+                                                                executable_path,
+                                                                _MAX_PATH));
+
+  std::string command_line =
+      std::string(::GetCommandLineA()) + " " + filter_flag + " \"" +
+      internal_flag + "\"";
+
+  DeathTest::set_last_death_test_message("");
+
+  CaptureStderr();
+  // Flush the log buffers since the log streams are shared with the child.
+  FlushInfoLog();
+
+  // The child process will share the standard handles with the parent.
+  STARTUPINFOA startup_info;
+  memset(&startup_info, 0, sizeof(STARTUPINFO));
+  startup_info.dwFlags = STARTF_USESTDHANDLES;
+  startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE);
+  startup_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE);
+  startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE);
+
+  PROCESS_INFORMATION process_info;
+  GTEST_DEATH_TEST_CHECK_(
+      ::CreateProcessA(
+          executable_path, const_cast<char*>(command_line.c_str()),
+          nullptr,  // Retuned process handle is not inheritable.
+          nullptr,  // Retuned thread handle is not inheritable.
+          TRUE,  // Child inherits all inheritable handles (for write_handle_).
+          0x0,   // Default creation flags.
+          nullptr,  // Inherit the parent's environment.
+          UnitTest::GetInstance()->original_working_dir(), &startup_info,
+          &process_info) != FALSE);
+  child_handle_.Reset(process_info.hProcess);
+  ::CloseHandle(process_info.hThread);
+  set_spawned(true);
+  return OVERSEE_TEST;
+}
+
+# elif GTEST_OS_FUCHSIA
+
+class FuchsiaDeathTest : public DeathTestImpl {
+ public:
+  FuchsiaDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
+                   const char* file, int line)
+      : DeathTestImpl(a_statement, std::move(matcher)),
+        file_(file),
+        line_(line) {}
+
+  // All of these virtual functions are inherited from DeathTest.
+  int Wait() override;
+  TestRole AssumeRole() override;
+  std::string GetErrorLogs() override;
+
+ private:
+  // The name of the file in which the death test is located.
+  const char* const file_;
+  // The line number on which the death test is located.
+  const int line_;
+  // The stderr data captured by the child process.
+  std::string captured_stderr_;
+
+  zx::process child_process_;
+  zx::channel exception_channel_;
+  zx::socket stderr_socket_;
+};
+
+// Utility class for accumulating command-line arguments.
+class Arguments {
+ public:
+  Arguments() { args_.push_back(nullptr); }
+
+  ~Arguments() {
+    for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
+         ++i) {
+      free(*i);
+    }
+  }
+  void AddArgument(const char* argument) {
+    args_.insert(args_.end() - 1, posix::StrDup(argument));
+  }
+
+  template <typename Str>
+  void AddArguments(const ::std::vector<Str>& arguments) {
+    for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
+         i != arguments.end();
+         ++i) {
+      args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
+    }
+  }
+  char* const* Argv() {
+    return &args_[0];
+  }
+
+  int size() {
+    return static_cast<int>(args_.size()) - 1;
+  }
+
+ private:
+  std::vector<char*> args_;
+};
+
+// Waits for the child in a death test to exit, returning its exit
+// status, or 0 if no child process exists.  As a side effect, sets the
+// outcome data member.
+int FuchsiaDeathTest::Wait() {
+  const int kProcessKey = 0;
+  const int kSocketKey = 1;
+  const int kExceptionKey = 2;
+
+  if (!spawned())
+    return 0;
+
+  // Create a port to wait for socket/task/exception events.
+  zx_status_t status_zx;
+  zx::port port;
+  status_zx = zx::port::create(0, &port);
+  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+
+  // Register to wait for the child process to terminate.
+  status_zx = child_process_.wait_async(
+      port, kProcessKey, ZX_PROCESS_TERMINATED, 0);
+  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+
+  // Register to wait for the socket to be readable or closed.
+  status_zx = stderr_socket_.wait_async(
+      port, kSocketKey, ZX_SOCKET_READABLE | ZX_SOCKET_PEER_CLOSED, 0);
+  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+
+  // Register to wait for an exception.
+  status_zx = exception_channel_.wait_async(
+      port, kExceptionKey, ZX_CHANNEL_READABLE, 0);
+  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+
+  bool process_terminated = false;
+  bool socket_closed = false;
+  do {
+    zx_port_packet_t packet = {};
+    status_zx = port.wait(zx::time::infinite(), &packet);
+    GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+
+    if (packet.key == kExceptionKey) {
+      // Process encountered an exception. Kill it directly rather than
+      // letting other handlers process the event. We will get a kProcessKey
+      // event when the process actually terminates.
+      status_zx = child_process_.kill();
+      GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+    } else if (packet.key == kProcessKey) {
+      // Process terminated.
+      GTEST_DEATH_TEST_CHECK_(ZX_PKT_IS_SIGNAL_ONE(packet.type));
+      GTEST_DEATH_TEST_CHECK_(packet.signal.observed & ZX_PROCESS_TERMINATED);
+      process_terminated = true;
+    } else if (packet.key == kSocketKey) {
+      GTEST_DEATH_TEST_CHECK_(ZX_PKT_IS_SIGNAL_ONE(packet.type));
+      if (packet.signal.observed & ZX_SOCKET_READABLE) {
+        // Read data from the socket.
+        constexpr size_t kBufferSize = 1024;
+        do {
+          size_t old_length = captured_stderr_.length();
+          size_t bytes_read = 0;
+          captured_stderr_.resize(old_length + kBufferSize);
+          status_zx = stderr_socket_.read(
+              0, &captured_stderr_.front() + old_length, kBufferSize,
+              &bytes_read);
+          captured_stderr_.resize(old_length + bytes_read);
+        } while (status_zx == ZX_OK);
+        if (status_zx == ZX_ERR_PEER_CLOSED) {
+          socket_closed = true;
+        } else {
+          GTEST_DEATH_TEST_CHECK_(status_zx == ZX_ERR_SHOULD_WAIT);
+          status_zx = stderr_socket_.wait_async(
+              port, kSocketKey, ZX_SOCKET_READABLE | ZX_SOCKET_PEER_CLOSED, 0);
+          GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+        }
+      } else {
+        GTEST_DEATH_TEST_CHECK_(packet.signal.observed & ZX_SOCKET_PEER_CLOSED);
+        socket_closed = true;
+      }
+    }
+  } while (!process_terminated && !socket_closed);
+
+  ReadAndInterpretStatusByte();
+
+  zx_info_process_t buffer;
+  status_zx = child_process_.get_info(ZX_INFO_PROCESS, &buffer, sizeof(buffer),
+                                      nullptr, nullptr);
+  GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+
+  GTEST_DEATH_TEST_CHECK_(buffer.flags & ZX_INFO_PROCESS_FLAG_EXITED);
+  set_status(static_cast<int>(buffer.return_code));
+  return status();
+}
+
+// The AssumeRole process for a Fuchsia death test.  It creates a child
+// process with the same executable as the current process to run the
+// death test.  The child process is given the --gtest_filter and
+// --gtest_internal_run_death_test flags such that it knows to run the
+// current death test only.
+DeathTest::TestRole FuchsiaDeathTest::AssumeRole() {
+  const UnitTestImpl* const impl = GetUnitTestImpl();
+  const InternalRunDeathTestFlag* const flag =
+      impl->internal_run_death_test_flag();
+  const TestInfo* const info = impl->current_test_info();
+  const int death_test_index = info->result()->death_test_count();
+
+  if (flag != nullptr) {
+    // ParseInternalRunDeathTestFlag() has performed all the necessary
+    // processing.
+    set_write_fd(kFuchsiaReadPipeFd);
+    return EXECUTE_TEST;
+  }
+
+  // Flush the log buffers since the log streams are shared with the child.
+  FlushInfoLog();
+
+  // Build the child process command line.
+  const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
+                                  kFilterFlag + "=" + info->test_suite_name() +
+                                  "." + info->name();
+  const std::string internal_flag =
+      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
+      + file_ + "|"
+      + StreamableToString(line_) + "|"
+      + StreamableToString(death_test_index);
+  Arguments args;
+  args.AddArguments(GetInjectableArgvs());
+  args.AddArgument(filter_flag.c_str());
+  args.AddArgument(internal_flag.c_str());
+
+  // Build the pipe for communication with the child.
+  zx_status_t status;
+  zx_handle_t child_pipe_handle;
+  int child_pipe_fd;
+  status = fdio_pipe_half(&child_pipe_fd, &child_pipe_handle);
+  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
+  set_read_fd(child_pipe_fd);
+
+  // Set the pipe handle for the child.
+  fdio_spawn_action_t spawn_actions[2] = {};
+  fdio_spawn_action_t* add_handle_action = &spawn_actions[0];
+  add_handle_action->action = FDIO_SPAWN_ACTION_ADD_HANDLE;
+  add_handle_action->h.id = PA_HND(PA_FD, kFuchsiaReadPipeFd);
+  add_handle_action->h.handle = child_pipe_handle;
+
+  // Create a socket pair will be used to receive the child process' stderr.
+  zx::socket stderr_producer_socket;
+  status =
+      zx::socket::create(0, &stderr_producer_socket, &stderr_socket_);
+  GTEST_DEATH_TEST_CHECK_(status >= 0);
+  int stderr_producer_fd = -1;
+  status =
+      fdio_fd_create(stderr_producer_socket.release(), &stderr_producer_fd);
+  GTEST_DEATH_TEST_CHECK_(status >= 0);
+
+  // Make the stderr socket nonblocking.
+  GTEST_DEATH_TEST_CHECK_(fcntl(stderr_producer_fd, F_SETFL, 0) == 0);
+
+  fdio_spawn_action_t* add_stderr_action = &spawn_actions[1];
+  add_stderr_action->action = FDIO_SPAWN_ACTION_CLONE_FD;
+  add_stderr_action->fd.local_fd = stderr_producer_fd;
+  add_stderr_action->fd.target_fd = STDERR_FILENO;
+
+  // Create a child job.
+  zx_handle_t child_job = ZX_HANDLE_INVALID;
+  status = zx_job_create(zx_job_default(), 0, & child_job);
+  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
+  zx_policy_basic_t policy;
+  policy.condition = ZX_POL_NEW_ANY;
+  policy.policy = ZX_POL_ACTION_ALLOW;
+  status = zx_job_set_policy(
+      child_job, ZX_JOB_POL_RELATIVE, ZX_JOB_POL_BASIC, &policy, 1);
+  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
+
+  // Create an exception channel attached to the |child_job|, to allow
+  // us to suppress the system default exception handler from firing.
+  status =
+      zx_task_create_exception_channel(
+          child_job, 0, exception_channel_.reset_and_get_address());
+  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
+
+  // Spawn the child process.
+  status = fdio_spawn_etc(
+      child_job, FDIO_SPAWN_CLONE_ALL, args.Argv()[0], args.Argv(), nullptr,
+      2, spawn_actions, child_process_.reset_and_get_address(), nullptr);
+  GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
+
+  set_spawned(true);
+  return OVERSEE_TEST;
+}
+
+std::string FuchsiaDeathTest::GetErrorLogs() {
+  return captured_stderr_;
+}
+
+#else  // We are neither on Windows, nor on Fuchsia.
+
+// ForkingDeathTest provides implementations for most of the abstract
+// methods of the DeathTest interface.  Only the AssumeRole method is
+// left undefined.
+class ForkingDeathTest : public DeathTestImpl {
+ public:
+  ForkingDeathTest(const char* statement, Matcher<const std::string&> matcher);
+
+  // All of these virtual functions are inherited from DeathTest.
+  int Wait() override;
+
+ protected:
+  void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
+
+ private:
+  // PID of child process during death test; 0 in the child process itself.
+  pid_t child_pid_;
+};
+
+// Constructs a ForkingDeathTest.
+ForkingDeathTest::ForkingDeathTest(const char* a_statement,
+                                   Matcher<const std::string&> matcher)
+    : DeathTestImpl(a_statement, std::move(matcher)), child_pid_(-1) {}
+
+// Waits for the child in a death test to exit, returning its exit
+// status, or 0 if no child process exists.  As a side effect, sets the
+// outcome data member.
+int ForkingDeathTest::Wait() {
+  if (!spawned())
+    return 0;
+
+  ReadAndInterpretStatusByte();
+
+  int status_value;
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0));
+  set_status(status_value);
+  return status_value;
+}
+
+// A concrete death test class that forks, then immediately runs the test
+// in the child process.
+class NoExecDeathTest : public ForkingDeathTest {
+ public:
+  NoExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher)
+      : ForkingDeathTest(a_statement, std::move(matcher)) {}
+  TestRole AssumeRole() override;
+};
+
+// The AssumeRole process for a fork-and-run death test.  It implements a
+// straightforward fork, with a simple pipe to transmit the status byte.
+DeathTest::TestRole NoExecDeathTest::AssumeRole() {
+  const size_t thread_count = GetThreadCount();
+  if (thread_count != 1) {
+    GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count);
+  }
+
+  int pipe_fd[2];
+  GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
+
+  DeathTest::set_last_death_test_message("");
+  CaptureStderr();
+  // When we fork the process below, the log file buffers are copied, but the
+  // file descriptors are shared.  We flush all log files here so that closing
+  // the file descriptors in the child process doesn't throw off the
+  // synchronization between descriptors and buffers in the parent process.
+  // This is as close to the fork as possible to avoid a race condition in case
+  // there are multiple threads running before the death test, and another
+  // thread writes to the log file.
+  FlushInfoLog();
+
+  const pid_t child_pid = fork();
+  GTEST_DEATH_TEST_CHECK_(child_pid != -1);
+  set_child_pid(child_pid);
+  if (child_pid == 0) {
+    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0]));
+    set_write_fd(pipe_fd[1]);
+    // Redirects all logging to stderr in the child process to prevent
+    // concurrent writes to the log files.  We capture stderr in the parent
+    // process and append the child process' output to a log.
+    LogToStderr();
+    // Event forwarding to the listeners of event listener API mush be shut
+    // down in death test subprocesses.
+    GetUnitTestImpl()->listeners()->SuppressEventForwarding();
+    g_in_fast_death_test_child = true;
+    return EXECUTE_TEST;
+  } else {
+    GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
+    set_read_fd(pipe_fd[0]);
+    set_spawned(true);
+    return OVERSEE_TEST;
+  }
+}
+
+// A concrete death test class that forks and re-executes the main
+// program from the beginning, with command-line flags set that cause
+// only this specific death test to be run.
+class ExecDeathTest : public ForkingDeathTest {
+ public:
+  ExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
+                const char* file, int line)
+      : ForkingDeathTest(a_statement, std::move(matcher)),
+        file_(file),
+        line_(line) {}
+  TestRole AssumeRole() override;
+
+ private:
+  static ::std::vector<std::string> GetArgvsForDeathTestChildProcess() {
+    ::std::vector<std::string> args = GetInjectableArgvs();
+#  if defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
+    ::std::vector<std::string> extra_args =
+        GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_();
+    args.insert(args.end(), extra_args.begin(), extra_args.end());
+#  endif  // defined(GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_)
+    return args;
+  }
+  // The name of the file in which the death test is located.
+  const char* const file_;
+  // The line number on which the death test is located.
+  const int line_;
+};
+
+// Utility class for accumulating command-line arguments.
+class Arguments {
+ public:
+  Arguments() { args_.push_back(nullptr); }
+
+  ~Arguments() {
+    for (std::vector<char*>::iterator i = args_.begin(); i != args_.end();
+         ++i) {
+      free(*i);
+    }
+  }
+  void AddArgument(const char* argument) {
+    args_.insert(args_.end() - 1, posix::StrDup(argument));
+  }
+
+  template <typename Str>
+  void AddArguments(const ::std::vector<Str>& arguments) {
+    for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
+         i != arguments.end();
+         ++i) {
+      args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
+    }
+  }
+  char* const* Argv() {
+    return &args_[0];
+  }
+
+ private:
+  std::vector<char*> args_;
+};
+
+// A struct that encompasses the arguments to the child process of a
+// threadsafe-style death test process.
+struct ExecDeathTestArgs {
+  char* const* argv;  // Command-line arguments for the child's call to exec
+  int close_fd;       // File descriptor to close; the read end of a pipe
+};
+
+#  if GTEST_OS_QNX
+extern "C" char** environ;
+#  else  // GTEST_OS_QNX
+// The main function for a threadsafe-style death test child process.
+// This function is called in a clone()-ed process and thus must avoid
+// any potentially unsafe operations like malloc or libc functions.
+static int ExecDeathTestChildMain(void* child_arg) {
+  ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg);
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd));
+
+  // We need to execute the test program in the same environment where
+  // it was originally invoked.  Therefore we change to the original
+  // working directory first.
+  const char* const original_dir =
+      UnitTest::GetInstance()->original_working_dir();
+  // We can safely call chdir() as it's a direct system call.
+  if (chdir(original_dir) != 0) {
+    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
+                   GetLastErrnoDescription());
+    return EXIT_FAILURE;
+  }
+
+  // We can safely call execv() as it's almost a direct system call. We
+  // cannot use execvp() as it's a libc function and thus potentially
+  // unsafe.  Since execv() doesn't search the PATH, the user must
+  // invoke the test program via a valid path that contains at least
+  // one path separator.
+  execv(args->argv[0], args->argv);
+  DeathTestAbort(std::string("execv(") + args->argv[0] + ", ...) in " +
+                 original_dir + " failed: " +
+                 GetLastErrnoDescription());
+  return EXIT_FAILURE;
+}
+#  endif  // GTEST_OS_QNX
+
+#  if GTEST_HAS_CLONE
+// Two utility routines that together determine the direction the stack
+// grows.
+// This could be accomplished more elegantly by a single recursive
+// function, but we want to guard against the unlikely possibility of
+// a smart compiler optimizing the recursion away.
+//
+// GTEST_NO_INLINE_ is required to prevent GCC 4.6 from inlining
+// StackLowerThanAddress into StackGrowsDown, which then doesn't give
+// correct answer.
+static void StackLowerThanAddress(const void* ptr,
+                                  bool* result) GTEST_NO_INLINE_;
+// Make sure sanitizers do not tamper with the stack here.
+// Ideally, we want to use `__builtin_frame_address` instead of a local variable
+// address with sanitizer disabled, but it does not work when the
+// compiler optimizes the stack frame out, which happens on PowerPC targets.
+// HWAddressSanitizer add a random tag to the MSB of the local variable address,
+// making comparison result unpredictable.
+GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+static void StackLowerThanAddress(const void* ptr, bool* result) {
+  int dummy = 0;
+  *result = std::less<const void*>()(&dummy, ptr);
+}
+
+// Make sure AddressSanitizer does not tamper with the stack here.
+GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+static bool StackGrowsDown() {
+  int dummy = 0;
+  bool result;
+  StackLowerThanAddress(&dummy, &result);
+  return result;
+}
+#  endif  // GTEST_HAS_CLONE
+
+// Spawns a child process with the same executable as the current process in
+// a thread-safe manner and instructs it to run the death test.  The
+// implementation uses fork(2) + exec.  On systems where clone(2) is
+// available, it is used instead, being slightly more thread-safe.  On QNX,
+// fork supports only single-threaded environments, so this function uses
+// spawn(2) there instead.  The function dies with an error message if
+// anything goes wrong.
+static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
+  ExecDeathTestArgs args = { argv, close_fd };
+  pid_t child_pid = -1;
+
+#  if GTEST_OS_QNX
+  // Obtains the current directory and sets it to be closed in the child
+  // process.
+  const int cwd_fd = open(".", O_RDONLY);
+  GTEST_DEATH_TEST_CHECK_(cwd_fd != -1);
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(cwd_fd, F_SETFD, FD_CLOEXEC));
+  // We need to execute the test program in the same environment where
+  // it was originally invoked.  Therefore we change to the original
+  // working directory first.
+  const char* const original_dir =
+      UnitTest::GetInstance()->original_working_dir();
+  // We can safely call chdir() as it's a direct system call.
+  if (chdir(original_dir) != 0) {
+    DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " +
+                   GetLastErrnoDescription());
+    return EXIT_FAILURE;
+  }
+
+  int fd_flags;
+  // Set close_fd to be closed after spawn.
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(fd_flags = fcntl(close_fd, F_GETFD));
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(close_fd, F_SETFD,
+                                        fd_flags | FD_CLOEXEC));
+  struct inheritance inherit = {0};
+  // spawn is a system call.
+  child_pid = spawn(args.argv[0], 0, nullptr, &inherit, args.argv, environ);
+  // Restores the current working directory.
+  GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1);
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd));
+
+#  else   // GTEST_OS_QNX
+#   if GTEST_OS_LINUX
+  // When a SIGPROF signal is received while fork() or clone() are executing,
+  // the process may hang. To avoid this, we ignore SIGPROF here and re-enable
+  // it after the call to fork()/clone() is complete.
+  struct sigaction saved_sigprof_action;
+  struct sigaction ignore_sigprof_action;
+  memset(&ignore_sigprof_action, 0, sizeof(ignore_sigprof_action));
+  sigemptyset(&ignore_sigprof_action.sa_mask);
+  ignore_sigprof_action.sa_handler = SIG_IGN;
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(sigaction(
+      SIGPROF, &ignore_sigprof_action, &saved_sigprof_action));
+#   endif  // GTEST_OS_LINUX
+
+#   if GTEST_HAS_CLONE
+  const bool use_fork = GTEST_FLAG(death_test_use_fork);
+
+  if (!use_fork) {
+    static const bool stack_grows_down = StackGrowsDown();
+    const auto stack_size = static_cast<size_t>(getpagesize() * 2);
+    // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead.
+    void* const stack = mmap(nullptr, stack_size, PROT_READ | PROT_WRITE,
+                             MAP_ANON | MAP_PRIVATE, -1, 0);
+    GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED);
+
+    // Maximum stack alignment in bytes:  For a downward-growing stack, this
+    // amount is subtracted from size of the stack space to get an address
+    // that is within the stack space and is aligned on all systems we care
+    // about.  As far as I know there is no ABI with stack alignment greater
+    // than 64.  We assume stack and stack_size already have alignment of
+    // kMaxStackAlignment.
+    const size_t kMaxStackAlignment = 64;
+    void* const stack_top =
+        static_cast<char*>(stack) +
+            (stack_grows_down ? stack_size - kMaxStackAlignment : 0);
+    GTEST_DEATH_TEST_CHECK_(
+        static_cast<size_t>(stack_size) > kMaxStackAlignment &&
+        reinterpret_cast<uintptr_t>(stack_top) % kMaxStackAlignment == 0);
+
+    child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args);
+
+    GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1);
+  }
+#   else
+  const bool use_fork = true;
+#   endif  // GTEST_HAS_CLONE
+
+  if (use_fork && (child_pid = fork()) == 0) {
+      ExecDeathTestChildMain(&args);
+      _exit(0);
+  }
+#  endif  // GTEST_OS_QNX
+#  if GTEST_OS_LINUX
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(
+      sigaction(SIGPROF, &saved_sigprof_action, nullptr));
+#  endif  // GTEST_OS_LINUX
+
+  GTEST_DEATH_TEST_CHECK_(child_pid != -1);
+  return child_pid;
+}
+
+// The AssumeRole process for a fork-and-exec death test.  It re-executes the
+// main program from the beginning, setting the --gtest_filter
+// and --gtest_internal_run_death_test flags to cause only the current
+// death test to be re-run.
+DeathTest::TestRole ExecDeathTest::AssumeRole() {
+  const UnitTestImpl* const impl = GetUnitTestImpl();
+  const InternalRunDeathTestFlag* const flag =
+      impl->internal_run_death_test_flag();
+  const TestInfo* const info = impl->current_test_info();
+  const int death_test_index = info->result()->death_test_count();
+
+  if (flag != nullptr) {
+    set_write_fd(flag->write_fd());
+    return EXECUTE_TEST;
+  }
+
+  int pipe_fd[2];
+  GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1);
+  // Clear the close-on-exec flag on the write end of the pipe, lest
+  // it be closed when the child process does an exec:
+  GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1);
+
+  const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ +
+                                  kFilterFlag + "=" + info->test_suite_name() +
+                                  "." + info->name();
+  const std::string internal_flag =
+      std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "="
+      + file_ + "|" + StreamableToString(line_) + "|"
+      + StreamableToString(death_test_index) + "|"
+      + StreamableToString(pipe_fd[1]);
+  Arguments args;
+  args.AddArguments(GetArgvsForDeathTestChildProcess());
+  args.AddArgument(filter_flag.c_str());
+  args.AddArgument(internal_flag.c_str());
+
+  DeathTest::set_last_death_test_message("");
+
+  CaptureStderr();
+  // See the comment in NoExecDeathTest::AssumeRole for why the next line
+  // is necessary.
+  FlushInfoLog();
+
+  const pid_t child_pid = ExecDeathTestSpawnChild(args.Argv(), pipe_fd[0]);
+  GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1]));
+  set_child_pid(child_pid);
+  set_read_fd(pipe_fd[0]);
+  set_spawned(true);
+  return OVERSEE_TEST;
+}
+
+# endif  // !GTEST_OS_WINDOWS
+
+// Creates a concrete DeathTest-derived class that depends on the
+// --gtest_death_test_style flag, and sets the pointer pointed to
+// by the "test" argument to its address.  If the test should be
+// skipped, sets that pointer to NULL.  Returns true, unless the
+// flag is set to an invalid value.
+bool DefaultDeathTestFactory::Create(const char* statement,
+                                     Matcher<const std::string&> matcher,
+                                     const char* file, int line,
+                                     DeathTest** test) {
+  UnitTestImpl* const impl = GetUnitTestImpl();
+  const InternalRunDeathTestFlag* const flag =
+      impl->internal_run_death_test_flag();
+  const int death_test_index = impl->current_test_info()
+      ->increment_death_test_count();
+
+  if (flag != nullptr) {
+    if (death_test_index > flag->index()) {
+      DeathTest::set_last_death_test_message(
+          "Death test count (" + StreamableToString(death_test_index)
+          + ") somehow exceeded expected maximum ("
+          + StreamableToString(flag->index()) + ")");
+      return false;
+    }
+
+    if (!(flag->file() == file && flag->line() == line &&
+          flag->index() == death_test_index)) {
+      *test = nullptr;
+      return true;
+    }
+  }
+
+# if GTEST_OS_WINDOWS
+
+  if (GTEST_FLAG(death_test_style) == "threadsafe" ||
+      GTEST_FLAG(death_test_style) == "fast") {
+    *test = new WindowsDeathTest(statement, std::move(matcher), file, line);
+  }
+
+# elif GTEST_OS_FUCHSIA
+
+  if (GTEST_FLAG(death_test_style) == "threadsafe" ||
+      GTEST_FLAG(death_test_style) == "fast") {
+    *test = new FuchsiaDeathTest(statement, std::move(matcher), file, line);
+  }
+
+# else
+
+  if (GTEST_FLAG(death_test_style) == "threadsafe") {
+    *test = new ExecDeathTest(statement, std::move(matcher), file, line);
+  } else if (GTEST_FLAG(death_test_style) == "fast") {
+    *test = new NoExecDeathTest(statement, std::move(matcher));
+  }
+
+# endif  // GTEST_OS_WINDOWS
+
+  else {  // NOLINT - this is more readable than unbalanced brackets inside #if.
+    DeathTest::set_last_death_test_message(
+        "Unknown death test style \"" + GTEST_FLAG(death_test_style)
+        + "\" encountered");
+    return false;
+  }
+
+  return true;
+}
+
+# if GTEST_OS_WINDOWS
+// Recreates the pipe and event handles from the provided parameters,
+// signals the event, and returns a file descriptor wrapped around the pipe
+// handle. This function is called in the child process only.
+static int GetStatusFileDescriptor(unsigned int parent_process_id,
+                            size_t write_handle_as_size_t,
+                            size_t event_handle_as_size_t) {
+  AutoHandle parent_process_handle(::OpenProcess(PROCESS_DUP_HANDLE,
+                                                   FALSE,  // Non-inheritable.
+                                                   parent_process_id));
+  if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) {
+    DeathTestAbort("Unable to open parent process " +
+                   StreamableToString(parent_process_id));
+  }
+
+  GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t));
+
+  const HANDLE write_handle =
+      reinterpret_cast<HANDLE>(write_handle_as_size_t);
+  HANDLE dup_write_handle;
+
+  // The newly initialized handle is accessible only in the parent
+  // process. To obtain one accessible within the child, we need to use
+  // DuplicateHandle.
+  if (!::DuplicateHandle(parent_process_handle.Get(), write_handle,
+                         ::GetCurrentProcess(), &dup_write_handle,
+                         0x0,    // Requested privileges ignored since
+                                 // DUPLICATE_SAME_ACCESS is used.
+                         FALSE,  // Request non-inheritable handler.
+                         DUPLICATE_SAME_ACCESS)) {
+    DeathTestAbort("Unable to duplicate the pipe handle " +
+                   StreamableToString(write_handle_as_size_t) +
+                   " from the parent process " +
+                   StreamableToString(parent_process_id));
+  }
+
+  const HANDLE event_handle = reinterpret_cast<HANDLE>(event_handle_as_size_t);
+  HANDLE dup_event_handle;
+
+  if (!::DuplicateHandle(parent_process_handle.Get(), event_handle,
+                         ::GetCurrentProcess(), &dup_event_handle,
+                         0x0,
+                         FALSE,
+                         DUPLICATE_SAME_ACCESS)) {
+    DeathTestAbort("Unable to duplicate the event handle " +
+                   StreamableToString(event_handle_as_size_t) +
+                   " from the parent process " +
+                   StreamableToString(parent_process_id));
+  }
+
+  const int write_fd =
+      ::_open_osfhandle(reinterpret_cast<intptr_t>(dup_write_handle), O_APPEND);
+  if (write_fd == -1) {
+    DeathTestAbort("Unable to convert pipe handle " +
+                   StreamableToString(write_handle_as_size_t) +
+                   " to a file descriptor");
+  }
+
+  // Signals the parent that the write end of the pipe has been acquired
+  // so the parent can release its own write end.
+  ::SetEvent(dup_event_handle);
+
+  return write_fd;
+}
+# endif  // GTEST_OS_WINDOWS
+
+// Returns a newly created InternalRunDeathTestFlag object with fields
+// initialized from the GTEST_FLAG(internal_run_death_test) flag if
+// the flag is specified; otherwise returns NULL.
+InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
+  if (GTEST_FLAG(internal_run_death_test) == "") return nullptr;
+
+  // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we
+  // can use it here.
+  int line = -1;
+  int index = -1;
+  ::std::vector< ::std::string> fields;
+  SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields);
+  int write_fd = -1;
+
+# if GTEST_OS_WINDOWS
+
+  unsigned int parent_process_id = 0;
+  size_t write_handle_as_size_t = 0;
+  size_t event_handle_as_size_t = 0;
+
+  if (fields.size() != 6
+      || !ParseNaturalNumber(fields[1], &line)
+      || !ParseNaturalNumber(fields[2], &index)
+      || !ParseNaturalNumber(fields[3], &parent_process_id)
+      || !ParseNaturalNumber(fields[4], &write_handle_as_size_t)
+      || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) {
+    DeathTestAbort("Bad --gtest_internal_run_death_test flag: " +
+                   GTEST_FLAG(internal_run_death_test));
+  }
+  write_fd = GetStatusFileDescriptor(parent_process_id,
+                                     write_handle_as_size_t,
+                                     event_handle_as_size_t);
+
+# elif GTEST_OS_FUCHSIA
+
+  if (fields.size() != 3
+      || !ParseNaturalNumber(fields[1], &line)
+      || !ParseNaturalNumber(fields[2], &index)) {
+    DeathTestAbort("Bad --gtest_internal_run_death_test flag: "
+        + GTEST_FLAG(internal_run_death_test));
+  }
+
+# else
+
+  if (fields.size() != 4
+      || !ParseNaturalNumber(fields[1], &line)
+      || !ParseNaturalNumber(fields[2], &index)
+      || !ParseNaturalNumber(fields[3], &write_fd)) {
+    DeathTestAbort("Bad --gtest_internal_run_death_test flag: "
+        + GTEST_FLAG(internal_run_death_test));
+  }
+
+# endif  // GTEST_OS_WINDOWS
+
+  return new InternalRunDeathTestFlag(fields[0], line, index, write_fd);
+}
+
+}  // namespace internal
+
+#endif  // GTEST_HAS_DEATH_TEST
+
+}  // namespace testing
diff --git a/trunk/3rdparty/gtest-fit/googletest/src/gtest-filepath.cc b/trunk/3rdparty/gtest-fit/googletest/src/gtest-filepath.cc
new file mode 100644
index 000000000..0b5629401
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/src/gtest-filepath.cc
@@ -0,0 +1,369 @@
+// Copyright 2008, 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.
+
+#include "gtest/internal/gtest-filepath.h"
+
+#include <stdlib.h>
+#include "gtest/internal/gtest-port.h"
+#include "gtest/gtest-message.h"
+
+#if GTEST_OS_WINDOWS_MOBILE
+# include <windows.h>
+#elif GTEST_OS_WINDOWS
+# include <direct.h>
+# include <io.h>
+#else
+# include <limits.h>
+# include <climits>  // Some Linux distributions define PATH_MAX here.
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+#include "gtest/internal/gtest-string.h"
+
+#if GTEST_OS_WINDOWS
+# define GTEST_PATH_MAX_ _MAX_PATH
+#elif defined(PATH_MAX)
+# define GTEST_PATH_MAX_ PATH_MAX
+#elif defined(_XOPEN_PATH_MAX)
+# define GTEST_PATH_MAX_ _XOPEN_PATH_MAX
+#else
+# define GTEST_PATH_MAX_ _POSIX_PATH_MAX
+#endif  // GTEST_OS_WINDOWS
+
+namespace testing {
+namespace internal {
+
+#if GTEST_OS_WINDOWS
+// On Windows, '\\' is the standard path separator, but many tools and the
+// Windows API also accept '/' as an alternate path separator. Unless otherwise
+// noted, a file path can contain either kind of path separators, or a mixture
+// of them.
+const char kPathSeparator = '\\';
+const char kAlternatePathSeparator = '/';
+const char kAlternatePathSeparatorString[] = "/";
+# if GTEST_OS_WINDOWS_MOBILE
+// Windows CE doesn't have a current directory. You should not use
+// the current directory in tests on Windows CE, but this at least
+// provides a reasonable fallback.
+const char kCurrentDirectoryString[] = "\\";
+// Windows CE doesn't define INVALID_FILE_ATTRIBUTES
+const DWORD kInvalidFileAttributes = 0xffffffff;
+# else
+const char kCurrentDirectoryString[] = ".\\";
+# endif  // GTEST_OS_WINDOWS_MOBILE
+#else
+const char kPathSeparator = '/';
+const char kCurrentDirectoryString[] = "./";
+#endif  // GTEST_OS_WINDOWS
+
+// Returns whether the given character is a valid path separator.
+static bool IsPathSeparator(char c) {
+#if GTEST_HAS_ALT_PATH_SEP_
+  return (c == kPathSeparator) || (c == kAlternatePathSeparator);
+#else
+  return c == kPathSeparator;
+#endif
+}
+
+// Returns the current working directory, or "" if unsuccessful.
+FilePath FilePath::GetCurrentDir() {
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE ||         \
+    GTEST_OS_WINDOWS_RT || GTEST_OS_ESP8266 || GTEST_OS_ESP32 || \
+    GTEST_OS_XTENSA
+  // These platforms do not have a current directory, so we just return
+  // something reasonable.
+  return FilePath(kCurrentDirectoryString);
+#elif GTEST_OS_WINDOWS
+  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
+  return FilePath(_getcwd(cwd, sizeof(cwd)) == nullptr ? "" : cwd);
+#else
+  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
+  char* result = getcwd(cwd, sizeof(cwd));
+# if GTEST_OS_NACL
+  // getcwd will likely fail in NaCl due to the sandbox, so return something
+  // reasonable. The user may have provided a shim implementation for getcwd,
+  // however, so fallback only when failure is detected.
+  return FilePath(result == nullptr ? kCurrentDirectoryString : cwd);
+# endif  // GTEST_OS_NACL
+  return FilePath(result == nullptr ? "" : cwd);
+#endif  // GTEST_OS_WINDOWS_MOBILE
+}
+
+// Returns a copy of the FilePath with the case-insensitive extension removed.
+// Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns
+// FilePath("dir/file"). If a case-insensitive extension is not
+// found, returns a copy of the original FilePath.
+FilePath FilePath::RemoveExtension(const char* extension) const {
+  const std::string dot_extension = std::string(".") + extension;
+  if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) {
+    return FilePath(pathname_.substr(
+        0, pathname_.length() - dot_extension.length()));
+  }
+  return *this;
+}
+
+// Returns a pointer to the last occurrence of a valid path separator in
+// the FilePath. On Windows, for example, both '/' and '\' are valid path
+// separators. Returns NULL if no path separator was found.
+const char* FilePath::FindLastPathSeparator() const {
+  const char* const last_sep = strrchr(c_str(), kPathSeparator);
+#if GTEST_HAS_ALT_PATH_SEP_
+  const char* const last_alt_sep = strrchr(c_str(), kAlternatePathSeparator);
+  // Comparing two pointers of which only one is NULL is undefined.
+  if (last_alt_sep != nullptr &&
+      (last_sep == nullptr || last_alt_sep > last_sep)) {
+    return last_alt_sep;
+  }
+#endif
+  return last_sep;
+}
+
+// Returns a copy of the FilePath with the directory part removed.
+// Example: FilePath("path/to/file").RemoveDirectoryName() returns
+// FilePath("file"). If there is no directory part ("just_a_file"), it returns
+// the FilePath unmodified. If there is no file part ("just_a_dir/") it
+// returns an empty FilePath ("").
+// On Windows platform, '\' is the path separator, otherwise it is '/'.
+FilePath FilePath::RemoveDirectoryName() const {
+  const char* const last_sep = FindLastPathSeparator();
+  return last_sep ? FilePath(last_sep + 1) : *this;
+}
+
+// RemoveFileName returns the directory path with the filename removed.
+// Example: FilePath("path/to/file").RemoveFileName() returns "path/to/".
+// If the FilePath is "a_file" or "/a_file", RemoveFileName returns
+// FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does
+// not have a file, like "just/a/dir/", it returns the FilePath unmodified.
+// On Windows platform, '\' is the path separator, otherwise it is '/'.
+FilePath FilePath::RemoveFileName() const {
+  const char* const last_sep = FindLastPathSeparator();
+  std::string dir;
+  if (last_sep) {
+    dir = std::string(c_str(), static_cast<size_t>(last_sep + 1 - c_str()));
+  } else {
+    dir = kCurrentDirectoryString;
+  }
+  return FilePath(dir);
+}
+
+// Helper functions for naming files in a directory for xml output.
+
+// Given directory = "dir", base_name = "test", number = 0,
+// extension = "xml", returns "dir/test.xml". If number is greater
+// than zero (e.g., 12), returns "dir/test_12.xml".
+// On Windows platform, uses \ as the separator rather than /.
+FilePath FilePath::MakeFileName(const FilePath& directory,
+                                const FilePath& base_name,
+                                int number,
+                                const char* extension) {
+  std::string file;
+  if (number == 0) {
+    file = base_name.string() + "." + extension;
+  } else {
+    file = base_name.string() + "_" + StreamableToString(number)
+        + "." + extension;
+  }
+  return ConcatPaths(directory, FilePath(file));
+}
+
+// Given directory = "dir", relative_path = "test.xml", returns "dir/test.xml".
+// On Windows, uses \ as the separator rather than /.
+FilePath FilePath::ConcatPaths(const FilePath& directory,
+                               const FilePath& relative_path) {
+  if (directory.IsEmpty())
+    return relative_path;
+  const FilePath dir(directory.RemoveTrailingPathSeparator());
+  return FilePath(dir.string() + kPathSeparator + relative_path.string());
+}
+
+// Returns true if pathname describes something findable in the file-system,
+// either a file, directory, or whatever.
+bool FilePath::FileOrDirectoryExists() const {
+#if GTEST_OS_WINDOWS_MOBILE
+  LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str());
+  const DWORD attributes = GetFileAttributes(unicode);
+  delete [] unicode;
+  return attributes != kInvalidFileAttributes;
+#else
+  posix::StatStruct file_stat{};
+  return posix::Stat(pathname_.c_str(), &file_stat) == 0;
+#endif  // GTEST_OS_WINDOWS_MOBILE
+}
+
+// Returns true if pathname describes a directory in the file-system
+// that exists.
+bool FilePath::DirectoryExists() const {
+  bool result = false;
+#if GTEST_OS_WINDOWS
+  // Don't strip off trailing separator if path is a root directory on
+  // Windows (like "C:\\").
+  const FilePath& path(IsRootDirectory() ? *this :
+                                           RemoveTrailingPathSeparator());
+#else
+  const FilePath& path(*this);
+#endif
+
+#if GTEST_OS_WINDOWS_MOBILE
+  LPCWSTR unicode = String::AnsiToUtf16(path.c_str());
+  const DWORD attributes = GetFileAttributes(unicode);
+  delete [] unicode;
+  if ((attributes != kInvalidFileAttributes) &&
+      (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
+    result = true;
+  }
+#else
+  posix::StatStruct file_stat{};
+  result = posix::Stat(path.c_str(), &file_stat) == 0 &&
+      posix::IsDir(file_stat);
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+  return result;
+}
+
+// Returns true if pathname describes a root directory. (Windows has one
+// root directory per disk drive.)
+bool FilePath::IsRootDirectory() const {
+#if GTEST_OS_WINDOWS
+  return pathname_.length() == 3 && IsAbsolutePath();
+#else
+  return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]);
+#endif
+}
+
+// Returns true if pathname describes an absolute path.
+bool FilePath::IsAbsolutePath() const {
+  const char* const name = pathname_.c_str();
+#if GTEST_OS_WINDOWS
+  return pathname_.length() >= 3 &&
+     ((name[0] >= 'a' && name[0] <= 'z') ||
+      (name[0] >= 'A' && name[0] <= 'Z')) &&
+     name[1] == ':' &&
+     IsPathSeparator(name[2]);
+#else
+  return IsPathSeparator(name[0]);
+#endif
+}
+
+// Returns a pathname for a file that does not currently exist. The pathname
+// will be directory/base_name.extension or
+// directory/base_name_<number>.extension if directory/base_name.extension
+// already exists. The number will be incremented until a pathname is found
+// that does not already exist.
+// Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'.
+// There could be a race condition if two or more processes are calling this
+// function at the same time -- they could both pick the same filename.
+FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
+                                          const FilePath& base_name,
+                                          const char* extension) {
+  FilePath full_pathname;
+  int number = 0;
+  do {
+    full_pathname.Set(MakeFileName(directory, base_name, number++, extension));
+  } while (full_pathname.FileOrDirectoryExists());
+  return full_pathname;
+}
+
+// Returns true if FilePath ends with a path separator, which indicates that
+// it is intended to represent a directory. Returns false otherwise.
+// This does NOT check that a directory (or file) actually exists.
+bool FilePath::IsDirectory() const {
+  return !pathname_.empty() &&
+         IsPathSeparator(pathname_.c_str()[pathname_.length() - 1]);
+}
+
+// Create directories so that path exists. Returns true if successful or if
+// the directories already exist; returns false if unable to create directories
+// for any reason.
+bool FilePath::CreateDirectoriesRecursively() const {
+  if (!this->IsDirectory()) {
+    return false;
+  }
+
+  if (pathname_.length() == 0 || this->DirectoryExists()) {
+    return true;
+  }
+
+  const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName());
+  return parent.CreateDirectoriesRecursively() && this->CreateFolder();
+}
+
+// Create the directory so that path exists. Returns true if successful or
+// if the directory already exists; returns false if unable to create the
+// directory for any reason, including if the parent directory does not
+// exist. Not named "CreateDirectory" because that's a macro on Windows.
+bool FilePath::CreateFolder() const {
+#if GTEST_OS_WINDOWS_MOBILE
+  FilePath removed_sep(this->RemoveTrailingPathSeparator());
+  LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
+  int result = CreateDirectory(unicode, nullptr) ? 0 : -1;
+  delete [] unicode;
+#elif GTEST_OS_WINDOWS
+  int result = _mkdir(pathname_.c_str());
+#elif GTEST_OS_ESP8266 || GTEST_OS_XTENSA
+  // do nothing
+  int result = 0;
+#else
+  int result = mkdir(pathname_.c_str(), 0777);
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+  if (result == -1) {
+    return this->DirectoryExists();  // An error is OK if the directory exists.
+  }
+  return true;  // No error.
+}
+
+// If input name has a trailing separator character, remove it and return the
+// name, otherwise return the name string unmodified.
+// On Windows platform, uses \ as the separator, other platforms use /.
+FilePath FilePath::RemoveTrailingPathSeparator() const {
+  return IsDirectory()
+      ? FilePath(pathname_.substr(0, pathname_.length() - 1))
+      : *this;
+}
+
+// Removes any redundant separators that might be in the pathname.
+// For example, "bar///foo" becomes "bar/foo". Does not eliminate other
+// redundancies that might be in a pathname involving "." or "..".
+void FilePath::Normalize() {
+  auto out = pathname_.begin();
+
+  for (const char character : pathname_) {
+    if (!IsPathSeparator(character)) {
+      *(out++) = character;
+    } else if (out == pathname_.begin() || *std::prev(out) != kPathSeparator) {
+      *(out++) = kPathSeparator;
+    } else {
+      continue;
+    }
+  }
+
+  pathname_.erase(out, pathname_.end());
+}
+
+}  // namespace internal
+}  // namespace testing
diff --git a/trunk/3rdparty/gtest-fit/googletest/src/gtest-internal-inl.h b/trunk/3rdparty/gtest-fit/googletest/src/gtest-internal-inl.h
new file mode 100644
index 000000000..6d8cecbbb
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/src/gtest-internal-inl.h
@@ -0,0 +1,1221 @@
+// Copyright 2005, 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.
+
+// Utility functions and classes used by the Google C++ testing framework.//
+// This file contains purely Google Test's internal implementation.  Please
+// DO NOT #INCLUDE IT IN A USER PROGRAM.
+
+#ifndef GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_
+#define GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_
+
+#ifndef _WIN32_WCE
+# include <errno.h>
+#endif  // !_WIN32_WCE
+#include <stddef.h>
+#include <stdlib.h>  // For strtoll/_strtoul64/malloc/free.
+#include <string.h>  // For memmove.
+
+#include <algorithm>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "gtest/internal/gtest-port.h"
+
+#if GTEST_CAN_STREAM_RESULTS_
+# include <arpa/inet.h>  // NOLINT
+# include <netdb.h>  // NOLINT
+#endif
+
+#if GTEST_OS_WINDOWS
+# include <windows.h>  // NOLINT
+#endif  // GTEST_OS_WINDOWS
+
+#include "gtest/gtest.h"
+#include "gtest/gtest-spi.h"
+
+GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
+/* class A needs to have dll-interface to be used by clients of class B */)
+
+namespace testing {
+
+// Declares the flags.
+//
+// We don't want the users to modify this flag in the code, but want
+// Google Test's own unit tests to be able to access it. Therefore we
+// declare it here as opposed to in gtest.h.
+GTEST_DECLARE_bool_(death_test_use_fork);
+
+namespace internal {
+
+// The value of GetTestTypeId() as seen from within the Google Test
+// library.  This is solely for testing GetTestTypeId().
+GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest;
+
+// Names of the flags (needed for parsing Google Test flags).
+const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests";
+const char kBreakOnFailureFlag[] = "break_on_failure";
+const char kCatchExceptionsFlag[] = "catch_exceptions";
+const char kColorFlag[] = "color";
+const char kFailFast[] = "fail_fast";
+const char kFilterFlag[] = "filter";
+const char kListTestsFlag[] = "list_tests";
+const char kOutputFlag[] = "output";
+const char kBriefFlag[] = "brief";
+const char kPrintTimeFlag[] = "print_time";
+const char kPrintUTF8Flag[] = "print_utf8";
+const char kRandomSeedFlag[] = "random_seed";
+const char kRepeatFlag[] = "repeat";
+const char kShuffleFlag[] = "shuffle";
+const char kStackTraceDepthFlag[] = "stack_trace_depth";
+const char kStreamResultToFlag[] = "stream_result_to";
+const char kThrowOnFailureFlag[] = "throw_on_failure";
+const char kFlagfileFlag[] = "flagfile";
+
+// A valid random seed must be in [1, kMaxRandomSeed].
+const int kMaxRandomSeed = 99999;
+
+// g_help_flag is true if and only if the --help flag or an equivalent form
+// is specified on the command line.
+GTEST_API_ extern bool g_help_flag;
+
+// Returns the current time in milliseconds.
+GTEST_API_ TimeInMillis GetTimeInMillis();
+
+// Returns true if and only if Google Test should use colors in the output.
+GTEST_API_ bool ShouldUseColor(bool stdout_is_tty);
+
+// Formats the given time in milliseconds as seconds.
+GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms);
+
+// Converts the given time in milliseconds to a date string in the ISO 8601
+// format, without the timezone information.  N.B.: due to the use the
+// non-reentrant localtime() function, this function is not thread safe.  Do
+// not use it in any code that can be called from multiple threads.
+GTEST_API_ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms);
+
+// Parses a string for an Int32 flag, in the form of "--flag=value".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+GTEST_API_ bool ParseInt32Flag(
+    const char* str, const char* flag, int32_t* value);
+
+// Returns a random seed in range [1, kMaxRandomSeed] based on the
+// given --gtest_random_seed flag value.
+inline int GetRandomSeedFromFlag(int32_t random_seed_flag) {
+  const unsigned int raw_seed = (random_seed_flag == 0) ?
+      static_cast<unsigned int>(GetTimeInMillis()) :
+      static_cast<unsigned int>(random_seed_flag);
+
+  // Normalizes the actual seed to range [1, kMaxRandomSeed] such that
+  // it's easy to type.
+  const int normalized_seed =
+      static_cast<int>((raw_seed - 1U) %
+                       static_cast<unsigned int>(kMaxRandomSeed)) + 1;
+  return normalized_seed;
+}
+
+// Returns the first valid random seed after 'seed'.  The behavior is
+// undefined if 'seed' is invalid.  The seed after kMaxRandomSeed is
+// considered to be 1.
+inline int GetNextRandomSeed(int seed) {
+  GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
+      << "Invalid random seed " << seed << " - must be in [1, "
+      << kMaxRandomSeed << "].";
+  const int next_seed = seed + 1;
+  return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
+}
+
+// This class saves the values of all Google Test flags in its c'tor, and
+// restores them in its d'tor.
+class GTestFlagSaver {
+ public:
+  // The c'tor.
+  GTestFlagSaver() {
+    also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests);
+    break_on_failure_ = GTEST_FLAG(break_on_failure);
+    catch_exceptions_ = GTEST_FLAG(catch_exceptions);
+    color_ = GTEST_FLAG(color);
+    death_test_style_ = GTEST_FLAG(death_test_style);
+    death_test_use_fork_ = GTEST_FLAG(death_test_use_fork);
+    fail_fast_ = GTEST_FLAG(fail_fast);
+    filter_ = GTEST_FLAG(filter);
+    internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);
+    list_tests_ = GTEST_FLAG(list_tests);
+    output_ = GTEST_FLAG(output);
+    brief_ = GTEST_FLAG(brief);
+    print_time_ = GTEST_FLAG(print_time);
+    print_utf8_ = GTEST_FLAG(print_utf8);
+    random_seed_ = GTEST_FLAG(random_seed);
+    repeat_ = GTEST_FLAG(repeat);
+    shuffle_ = GTEST_FLAG(shuffle);
+    stack_trace_depth_ = GTEST_FLAG(stack_trace_depth);
+    stream_result_to_ = GTEST_FLAG(stream_result_to);
+    throw_on_failure_ = GTEST_FLAG(throw_on_failure);
+  }
+
+  // The d'tor is not virtual.  DO NOT INHERIT FROM THIS CLASS.
+  ~GTestFlagSaver() {
+    GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
+    GTEST_FLAG(break_on_failure) = break_on_failure_;
+    GTEST_FLAG(catch_exceptions) = catch_exceptions_;
+    GTEST_FLAG(color) = color_;
+    GTEST_FLAG(death_test_style) = death_test_style_;
+    GTEST_FLAG(death_test_use_fork) = death_test_use_fork_;
+    GTEST_FLAG(filter) = filter_;
+    GTEST_FLAG(fail_fast) = fail_fast_;
+    GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
+    GTEST_FLAG(list_tests) = list_tests_;
+    GTEST_FLAG(output) = output_;
+    GTEST_FLAG(brief) = brief_;
+    GTEST_FLAG(print_time) = print_time_;
+    GTEST_FLAG(print_utf8) = print_utf8_;
+    GTEST_FLAG(random_seed) = random_seed_;
+    GTEST_FLAG(repeat) = repeat_;
+    GTEST_FLAG(shuffle) = shuffle_;
+    GTEST_FLAG(stack_trace_depth) = stack_trace_depth_;
+    GTEST_FLAG(stream_result_to) = stream_result_to_;
+    GTEST_FLAG(throw_on_failure) = throw_on_failure_;
+  }
+
+ private:
+  // Fields for saving the original values of flags.
+  bool also_run_disabled_tests_;
+  bool break_on_failure_;
+  bool catch_exceptions_;
+  std::string color_;
+  std::string death_test_style_;
+  bool death_test_use_fork_;
+  bool fail_fast_;
+  std::string filter_;
+  std::string internal_run_death_test_;
+  bool list_tests_;
+  std::string output_;
+  bool brief_;
+  bool print_time_;
+  bool print_utf8_;
+  int32_t random_seed_;
+  int32_t repeat_;
+  bool shuffle_;
+  int32_t stack_trace_depth_;
+  std::string stream_result_to_;
+  bool throw_on_failure_;
+} GTEST_ATTRIBUTE_UNUSED_;
+
+// Converts a Unicode code point to a narrow string in UTF-8 encoding.
+// code_point parameter is of type UInt32 because wchar_t may not be
+// wide enough to contain a code point.
+// If the code_point is not a valid Unicode code point
+// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
+// to "(Invalid Unicode 0xXXXXXXXX)".
+GTEST_API_ std::string CodePointToUtf8(uint32_t code_point);
+
+// Converts a wide string to a narrow string in UTF-8 encoding.
+// The wide string is assumed to have the following encoding:
+//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin)
+//   UTF-32 if sizeof(wchar_t) == 4 (on Linux)
+// Parameter str points to a null-terminated wide string.
+// Parameter num_chars may additionally limit the number
+// of wchar_t characters processed. -1 is used when the entire string
+// should be processed.
+// If the string contains code points that are not valid Unicode code points
+// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
+// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
+// and contains invalid UTF-16 surrogate pairs, values in those pairs
+// will be encoded as individual Unicode characters from Basic Normal Plane.
+GTEST_API_ std::string WideStringToUtf8(const wchar_t* str, int num_chars);
+
+// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
+// if the variable is present. If a file already exists at this location, this
+// function will write over it. If the variable is present, but the file cannot
+// be created, prints an error and exits.
+void WriteToShardStatusFileIfNeeded();
+
+// Checks whether sharding is enabled by examining the relevant
+// environment variable values. If the variables are present,
+// but inconsistent (e.g., shard_index >= total_shards), prints
+// an error and exits. If in_subprocess_for_death_test, sharding is
+// disabled because it must only be applied to the original test
+// process. Otherwise, we could filter out death tests we intended to execute.
+GTEST_API_ bool ShouldShard(const char* total_shards_str,
+                            const char* shard_index_str,
+                            bool in_subprocess_for_death_test);
+
+// Parses the environment variable var as a 32-bit integer. If it is unset,
+// returns default_val. If it is not a 32-bit integer, prints an error and
+// and aborts.
+GTEST_API_ int32_t Int32FromEnvOrDie(const char* env_var, int32_t default_val);
+
+// Given the total number of shards, the shard index, and the test id,
+// returns true if and only if the test should be run on this shard. The test id
+// is some arbitrary but unique non-negative integer assigned to each test
+// method. Assumes that 0 <= shard_index < total_shards.
+GTEST_API_ bool ShouldRunTestOnShard(
+    int total_shards, int shard_index, int test_id);
+
+// STL container utilities.
+
+// Returns the number of elements in the given container that satisfy
+// the given predicate.
+template <class Container, typename Predicate>
+inline int CountIf(const Container& c, Predicate predicate) {
+  // Implemented as an explicit loop since std::count_if() in libCstd on
+  // Solaris has a non-standard signature.
+  int count = 0;
+  for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {
+    if (predicate(*it))
+      ++count;
+  }
+  return count;
+}
+
+// Applies a function/functor to each element in the container.
+template <class Container, typename Functor>
+void ForEach(const Container& c, Functor functor) {
+  std::for_each(c.begin(), c.end(), functor);
+}
+
+// Returns the i-th element of the vector, or default_value if i is not
+// in range [0, v.size()).
+template <typename E>
+inline E GetElementOr(const std::vector<E>& v, int i, E default_value) {
+  return (i < 0 || i >= static_cast<int>(v.size())) ? default_value
+                                                    : v[static_cast<size_t>(i)];
+}
+
+// Performs an in-place shuffle of a range of the vector's elements.
+// 'begin' and 'end' are element indices as an STL-style range;
+// i.e. [begin, end) are shuffled, where 'end' == size() means to
+// shuffle to the end of the vector.
+template <typename E>
+void ShuffleRange(internal::Random* random, int begin, int end,
+                  std::vector<E>* v) {
+  const int size = static_cast<int>(v->size());
+  GTEST_CHECK_(0 <= begin && begin <= size)
+      << "Invalid shuffle range start " << begin << ": must be in range [0, "
+      << size << "].";
+  GTEST_CHECK_(begin <= end && end <= size)
+      << "Invalid shuffle range finish " << end << ": must be in range ["
+      << begin << ", " << size << "].";
+
+  // Fisher-Yates shuffle, from
+  // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
+  for (int range_width = end - begin; range_width >= 2; range_width--) {
+    const int last_in_range = begin + range_width - 1;
+    const int selected =
+        begin +
+        static_cast<int>(random->Generate(static_cast<uint32_t>(range_width)));
+    std::swap((*v)[static_cast<size_t>(selected)],
+              (*v)[static_cast<size_t>(last_in_range)]);
+  }
+}
+
+// Performs an in-place shuffle of the vector's elements.
+template <typename E>
+inline void Shuffle(internal::Random* random, std::vector<E>* v) {
+  ShuffleRange(random, 0, static_cast<int>(v->size()), v);
+}
+
+// A function for deleting an object.  Handy for being used as a
+// functor.
+template <typename T>
+static void Delete(T* x) {
+  delete x;
+}
+
+// A predicate that checks the key of a TestProperty against a known key.
+//
+// TestPropertyKeyIs is copyable.
+class TestPropertyKeyIs {
+ public:
+  // Constructor.
+  //
+  // TestPropertyKeyIs has NO default constructor.
+  explicit TestPropertyKeyIs(const std::string& key) : key_(key) {}
+
+  // Returns true if and only if the test name of test property matches on key_.
+  bool operator()(const TestProperty& test_property) const {
+    return test_property.key() == key_;
+  }
+
+ private:
+  std::string key_;
+};
+
+// Class UnitTestOptions.
+//
+// This class contains functions for processing options the user
+// specifies when running the tests.  It has only static members.
+//
+// In most cases, the user can specify an option using either an
+// environment variable or a command line flag.  E.g. you can set the
+// test filter using either GTEST_FILTER or --gtest_filter.  If both
+// the variable and the flag are present, the latter overrides the
+// former.
+class GTEST_API_ UnitTestOptions {
+ public:
+  // Functions for processing the gtest_output flag.
+
+  // Returns the output format, or "" for normal printed output.
+  static std::string GetOutputFormat();
+
+  // Returns the absolute path of the requested output file, or the
+  // default (test_detail.xml in the original working directory) if
+  // none was explicitly specified.
+  static std::string GetAbsolutePathToOutputFile();
+
+  // Functions for processing the gtest_filter flag.
+
+  // Returns true if and only if the user-specified filter matches the test
+  // suite name and the test name.
+  static bool FilterMatchesTest(const std::string& test_suite_name,
+                                const std::string& test_name);
+
+#if GTEST_OS_WINDOWS
+  // Function for supporting the gtest_catch_exception flag.
+
+  // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
+  // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
+  // This function is useful as an __except condition.
+  static int GTestShouldProcessSEH(DWORD exception_code);
+#endif  // GTEST_OS_WINDOWS
+
+  // Returns true if "name" matches the ':' separated list of glob-style
+  // filters in "filter".
+  static bool MatchesFilter(const std::string& name, const char* filter);
+};
+
+// Returns the current application's name, removing directory path if that
+// is present.  Used by UnitTestOptions::GetOutputFile.
+GTEST_API_ FilePath GetCurrentExecutableName();
+
+// The role interface for getting the OS stack trace as a string.
+class OsStackTraceGetterInterface {
+ public:
+  OsStackTraceGetterInterface() {}
+  virtual ~OsStackTraceGetterInterface() {}
+
+  // Returns the current OS stack trace as an std::string.  Parameters:
+  //
+  //   max_depth  - the maximum number of stack frames to be included
+  //                in the trace.
+  //   skip_count - the number of top frames to be skipped; doesn't count
+  //                against max_depth.
+  virtual std::string CurrentStackTrace(int max_depth, int skip_count) = 0;
+
+  // 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.
+  virtual void UponLeavingGTest() = 0;
+
+  // This string is inserted in place of stack frames that are part of
+  // Google Test's implementation.
+  static const char* const kElidedFramesMarker;
+
+ private:
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface);
+};
+
+// A working implementation of the OsStackTraceGetterInterface interface.
+class OsStackTraceGetter : public OsStackTraceGetterInterface {
+ public:
+  OsStackTraceGetter() {}
+
+  std::string CurrentStackTrace(int max_depth, int skip_count) override;
+  void UponLeavingGTest() override;
+
+ private:
+#if GTEST_HAS_ABSL
+  Mutex mutex_;  // Protects all internal state.
+
+  // We save the stack frame below the frame that calls user code.
+  // We do this because the address of the frame immediately below
+  // the user code changes between the call to UponLeavingGTest()
+  // and any calls to the stack trace code from within the user code.
+  void* caller_frame_ = nullptr;
+#endif  // GTEST_HAS_ABSL
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter);
+};
+
+// Information about a Google Test trace point.
+struct TraceInfo {
+  const char* file;
+  int line;
+  std::string message;
+};
+
+// This is the default global test part result reporter used in UnitTestImpl.
+// This class should only be used by UnitTestImpl.
+class DefaultGlobalTestPartResultReporter
+  : public TestPartResultReporterInterface {
+ public:
+  explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test);
+  // Implements the TestPartResultReporterInterface. Reports the test part
+  // result in the current test.
+  void ReportTestPartResult(const TestPartResult& result) override;
+
+ private:
+  UnitTestImpl* const unit_test_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter);
+};
+
+// This is the default per thread test part result reporter used in
+// UnitTestImpl. This class should only be used by UnitTestImpl.
+class DefaultPerThreadTestPartResultReporter
+    : public TestPartResultReporterInterface {
+ public:
+  explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test);
+  // Implements the TestPartResultReporterInterface. The implementation just
+  // delegates to the current global test part result reporter of *unit_test_.
+  void ReportTestPartResult(const TestPartResult& result) override;
+
+ private:
+  UnitTestImpl* const unit_test_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter);
+};
+
+// The private implementation of the UnitTest class.  We don't protect
+// the methods under a mutex, as this class is not accessible by a
+// user and the UnitTest class that delegates work to this class does
+// proper locking.
+class GTEST_API_ UnitTestImpl {
+ public:
+  explicit UnitTestImpl(UnitTest* parent);
+  virtual ~UnitTestImpl();
+
+  // There are two different ways to register your own TestPartResultReporter.
+  // You can register your own repoter to listen either only for test results
+  // from the current thread or for results from all threads.
+  // By default, each per-thread test result repoter just passes a new
+  // TestPartResult to the global test result reporter, which registers the
+  // test part result for the currently running test.
+
+  // Returns the global test part result reporter.
+  TestPartResultReporterInterface* GetGlobalTestPartResultReporter();
+
+  // Sets the global test part result reporter.
+  void SetGlobalTestPartResultReporter(
+      TestPartResultReporterInterface* reporter);
+
+  // Returns the test part result reporter for the current thread.
+  TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread();
+
+  // Sets the test part result reporter for the current thread.
+  void SetTestPartResultReporterForCurrentThread(
+      TestPartResultReporterInterface* reporter);
+
+  // Gets the number of successful test suites.
+  int successful_test_suite_count() const;
+
+  // Gets the number of failed test suites.
+  int failed_test_suite_count() const;
+
+  // Gets the number of all test suites.
+  int total_test_suite_count() const;
+
+  // Gets the number of all test suites that contain at least one test
+  // that should run.
+  int test_suite_to_run_count() const;
+
+  // Gets the number of successful tests.
+  int successful_test_count() const;
+
+  // Gets the number of skipped tests.
+  int skipped_test_count() const;
+
+  // Gets the number of failed tests.
+  int failed_test_count() const;
+
+  // Gets the number of disabled tests that will be reported in the XML report.
+  int reportable_disabled_test_count() const;
+
+  // Gets the number of disabled tests.
+  int disabled_test_count() const;
+
+  // Gets the number of tests to be printed in the XML report.
+  int reportable_test_count() const;
+
+  // Gets the number of all tests.
+  int total_test_count() const;
+
+  // Gets the number of tests that should run.
+  int test_to_run_count() const;
+
+  // Gets the time of the test program start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp() const { return start_timestamp_; }
+
+  // Gets the elapsed time, in milliseconds.
+  TimeInMillis elapsed_time() const { return elapsed_time_; }
+
+  // Returns true if and only if the unit test passed (i.e. all test suites
+  // passed).
+  bool Passed() const { return !Failed(); }
+
+  // Returns true if and only if the unit test failed (i.e. some test suite
+  // failed or something outside of all tests failed).
+  bool Failed() const {
+    return failed_test_suite_count() > 0 || ad_hoc_test_result()->Failed();
+  }
+
+  // Gets the i-th test suite among all the test suites. i can range from 0 to
+  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
+  const TestSuite* GetTestSuite(int i) const {
+    const int index = GetElementOr(test_suite_indices_, i, -1);
+    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(i)];
+  }
+
+  //  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  const TestCase* GetTestCase(int i) const { return GetTestSuite(i); }
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Gets the i-th test suite among all the test suites. i can range from 0 to
+  // total_test_suite_count() - 1. If i is not in that range, returns NULL.
+  TestSuite* GetMutableSuiteCase(int i) {
+    const int index = GetElementOr(test_suite_indices_, i, -1);
+    return index < 0 ? nullptr : test_suites_[static_cast<size_t>(index)];
+  }
+
+  // Provides access to the event listener list.
+  TestEventListeners* listeners() { return &listeners_; }
+
+  // Returns the TestResult for the test that's currently running, or
+  // the TestResult for the ad hoc test if no test is running.
+  TestResult* current_test_result();
+
+  // Returns the TestResult for the ad hoc test.
+  const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; }
+
+  // Sets the OS stack trace getter.
+  //
+  // Does nothing if the input and the current OS stack trace getter
+  // are the same; otherwise, deletes the old getter and makes the
+  // input the current getter.
+  void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter);
+
+  // Returns the current OS stack trace getter if it is not NULL;
+  // otherwise, creates an OsStackTraceGetter, makes it the current
+  // getter, and returns it.
+  OsStackTraceGetterInterface* os_stack_trace_getter();
+
+  // Returns the current OS stack trace as an std::string.
+  //
+  // The maximum number of stack frames to be included is specified by
+  // the gtest_stack_trace_depth flag.  The skip_count parameter
+  // specifies the number of top frames to be skipped, which doesn't
+  // count against the number of frames to be included.
+  //
+  // For example, if Foo() calls Bar(), which in turn calls
+  // CurrentOsStackTraceExceptTop(1), Foo() will be included in the
+  // trace but Bar() and CurrentOsStackTraceExceptTop() won't.
+  std::string CurrentOsStackTraceExceptTop(int skip_count) GTEST_NO_INLINE_;
+
+  // Finds and returns a TestSuite with the given name.  If one doesn't
+  // exist, creates one and returns it.
+  //
+  // Arguments:
+  //
+  //   test_suite_name: name of the test suite
+  //   type_param:      the name of the test's type parameter, or NULL if
+  //                    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,
+                          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,
+                        internal::SetUpTestSuiteFunc set_up_tc,
+                        internal::TearDownTestSuiteFunc tear_down_tc) {
+    return GetTestSuite(test_case_name, type_param, set_up_tc, tear_down_tc);
+  }
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  // Adds a TestInfo to the unit test.
+  //
+  // Arguments:
+  //
+  //   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
+  //   test_info:    the TestInfo object
+  void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc,
+                   internal::TearDownTestSuiteFunc tear_down_tc,
+                   TestInfo* test_info) {
+#if GTEST_HAS_DEATH_TEST
+    // In order to support thread-safe death tests, we need to
+    // remember the original working directory when the test program
+    // was first invoked.  We cannot do this in RUN_ALL_TESTS(), as
+    // the user may have changed the current directory before calling
+    // RUN_ALL_TESTS().  Therefore we capture the current directory in
+    // 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());
+      GTEST_CHECK_(!original_working_dir_.IsEmpty())
+          << "Failed to get the current working directory.";
+    }
+#endif  // GTEST_HAS_DEATH_TEST
+
+    GetTestSuite(test_info->test_suite_name(), test_info->type_param(),
+                 set_up_tc, tear_down_tc)
+        ->AddTestInfo(test_info);
+  }
+
+  // Returns ParameterizedTestSuiteRegistry object used to keep track of
+  // value-parameterized tests and instantiate and register them.
+  internal::ParameterizedTestSuiteRegistry& parameterized_test_registry() {
+    return parameterized_test_registry_;
+  }
+
+  std::set<std::string>* ignored_parameterized_test_suites() {
+    return &ignored_parameterized_test_suites_;
+  }
+
+  // Returns TypeParameterizedTestSuiteRegistry object used to keep track of
+  // type-parameterized tests and instantiations of them.
+  internal::TypeParameterizedTestSuiteRegistry&
+  type_parameterized_test_registry() {
+    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
+  // protecting from registering the tests more then once.  If
+  // value-parameterized tests are disabled, RegisterParameterizedTests is
+  // present but does nothing.
+  void RegisterParameterizedTests();
+
+  // Runs all tests in this UnitTest object, prints the result, and
+  // returns true if all tests are successful.  If any exception is
+  // thrown during a test, this test is considered to be failed, but
+  // the rest of the tests will still be run.
+  bool RunAllTests();
+
+  // Clears the results of all tests, except the ad hoc tests.
+  void ClearNonAdHocTestResult() {
+    ForEach(test_suites_, TestSuite::ClearTestSuiteResult);
+  }
+
+  // Clears the results of ad-hoc test assertions.
+  void ClearAdHocTestResult() {
+    ad_hoc_test_result_.Clear();
+  }
+
+  // Adds a TestProperty to the current TestResult object when invoked in a
+  // context of a test or a test suite, or to the global property set. If the
+  // result already contains a property with the same key, the value will be
+  // updated.
+  void RecordProperty(const TestProperty& test_property);
+
+  enum ReactionToSharding {
+    HONOR_SHARDING_PROTOCOL,
+    IGNORE_SHARDING_PROTOCOL
+  };
+
+  // Matches the full name of each test against the user-specified
+  // filter to decide whether the test should run, then records the
+  // result in each TestSuite and TestInfo object.
+  // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests
+  // based on sharding variables in the environment.
+  // Returns the number of tests that should run.
+  int FilterTests(ReactionToSharding shard_tests);
+
+  // Prints the names of the tests matching the user-specified filter flag.
+  void ListTestsMatchingFilter();
+
+  const TestSuite* current_test_suite() const { return current_test_suite_; }
+  TestInfo* current_test_info() { return current_test_info_; }
+  const TestInfo* current_test_info() const { return current_test_info_; }
+
+  // Returns the vector of environments that need to be set-up/torn-down
+  // before/after the tests are run.
+  std::vector<Environment*>& environments() { return environments_; }
+
+  // Getters for the per-thread Google Test trace stack.
+  std::vector<TraceInfo>& gtest_trace_stack() {
+    return *(gtest_trace_stack_.pointer());
+  }
+  const std::vector<TraceInfo>& gtest_trace_stack() const {
+    return gtest_trace_stack_.get();
+  }
+
+#if GTEST_HAS_DEATH_TEST
+  void InitDeathTestSubprocessControlInfo() {
+    internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag());
+  }
+  // Returns a pointer to the parsed --gtest_internal_run_death_test
+  // flag, or NULL if that flag was not specified.
+  // This information is useful only in a death test child process.
+  // Must not be called before a call to InitGoogleTest.
+  const InternalRunDeathTestFlag* internal_run_death_test_flag() const {
+    return internal_run_death_test_flag_.get();
+  }
+
+  // Returns a pointer to the current death test factory.
+  internal::DeathTestFactory* death_test_factory() {
+    return death_test_factory_.get();
+  }
+
+  void SuppressTestEventsIfInSubprocess();
+
+  friend class ReplaceDeathTestFactory;
+#endif  // GTEST_HAS_DEATH_TEST
+
+  // Initializes the event listener performing XML output as specified by
+  // UnitTestOptions. Must not be called before InitGoogleTest.
+  void ConfigureXmlOutput();
+
+#if GTEST_CAN_STREAM_RESULTS_
+  // Initializes the event listener for streaming test results to a socket.
+  // Must not be called before InitGoogleTest.
+  void ConfigureStreamingOutput();
+#endif
+
+  // Performs initialization dependent upon flag values obtained in
+  // ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
+  // ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
+  // this function is also called from RunAllTests.  Since this function can be
+  // called more than once, it has to be idempotent.
+  void PostFlagParsingInit();
+
+  // Gets the random seed used at the start of the current test iteration.
+  int random_seed() const { return random_seed_; }
+
+  // Gets the random number generator.
+  internal::Random* random() { return &random_; }
+
+  // Shuffles all test suites, and the tests within each test suite,
+  // making sure that death tests are still run first.
+  void ShuffleTests();
+
+  // Restores the test suites and tests to their order before the first shuffle.
+  void UnshuffleTests();
+
+  // Returns the value of GTEST_FLAG(catch_exceptions) at the moment
+  // UnitTest::Run() starts.
+  bool catch_exceptions() const { return catch_exceptions_; }
+
+ private:
+  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; }
+
+  // The UnitTest object that owns this implementation object.
+  UnitTest* const parent_;
+
+  // The working directory when the first TEST() or TEST_F() was
+  // executed.
+  internal::FilePath original_working_dir_;
+
+  // The default test part result reporters.
+  DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_;
+  DefaultPerThreadTestPartResultReporter
+      default_per_thread_test_part_result_reporter_;
+
+  // Points to (but doesn't own) the global test part result reporter.
+  TestPartResultReporterInterface* global_test_part_result_repoter_;
+
+  // Protects read and write access to global_test_part_result_reporter_.
+  internal::Mutex global_test_part_result_reporter_mutex_;
+
+  // Points to (but doesn't own) the per-thread test part result reporter.
+  internal::ThreadLocal<TestPartResultReporterInterface*>
+      per_thread_test_part_result_reporter_;
+
+  // The vector of environments that need to be set-up/torn-down
+  // before/after the tests are run.
+  std::vector<Environment*> environments_;
+
+  // The vector of TestSuites in their original order.  It owns the
+  // elements in the vector.
+  std::vector<TestSuite*> test_suites_;
+
+  // 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
+  // shuffled order.
+  std::vector<int> test_suite_indices_;
+
+  // ParameterizedTestRegistry object used to register value-parameterized
+  // tests.
+  internal::ParameterizedTestSuiteRegistry parameterized_test_registry_;
+  internal::TypeParameterizedTestSuiteRegistry
+      type_parameterized_test_registry_;
+
+  // The set holding the name of parameterized
+  // test suites that may go uninstantiated.
+  std::set<std::string> ignored_parameterized_test_suites_;
+
+  // Indicates whether RegisterParameterizedTests() has been called already.
+  bool parameterized_tests_registered_;
+
+  // Index of the last death test suite registered.  Initially -1.
+  int last_death_test_suite_;
+
+  // This points to the TestSuite for the currently running test.  It
+  // changes as Google Test goes through one test suite after another.
+  // When no test is running, this is set to NULL and Google Test
+  // stores assertion results in ad_hoc_test_result_.  Initially NULL.
+  TestSuite* current_test_suite_;
+
+  // This points to the TestInfo for the currently running test.  It
+  // changes as Google Test goes through one test after another.  When
+  // no test is running, this is set to NULL and Google Test stores
+  // assertion results in ad_hoc_test_result_.  Initially NULL.
+  TestInfo* current_test_info_;
+
+  // Normally, a user only writes assertions inside a TEST or TEST_F,
+  // or inside a function called by a TEST or TEST_F.  Since Google
+  // Test keeps track of which test is current running, it can
+  // associate such an assertion with the test it belongs to.
+  //
+  // If an assertion is encountered when no TEST or TEST_F is running,
+  // Google Test attributes the assertion result to an imaginary "ad hoc"
+  // test, and records the result in ad_hoc_test_result_.
+  TestResult ad_hoc_test_result_;
+
+  // The list of event listeners that can be used to track events inside
+  // Google Test.
+  TestEventListeners listeners_;
+
+  // The OS stack trace getter.  Will be deleted when the UnitTest
+  // object is destructed.  By default, an OsStackTraceGetter is used,
+  // but the user can set this field to use a custom getter if that is
+  // desired.
+  OsStackTraceGetterInterface* os_stack_trace_getter_;
+
+  // True if and only if PostFlagParsingInit() has been called.
+  bool post_flag_parse_init_performed_;
+
+  // The random number seed used at the beginning of the test run.
+  int random_seed_;
+
+  // Our random number generator.
+  internal::Random random_;
+
+  // The time of the test program start, in ms from the start of the
+  // UNIX epoch.
+  TimeInMillis start_timestamp_;
+
+  // How long the test took to run, in milliseconds.
+  TimeInMillis elapsed_time_;
+
+#if GTEST_HAS_DEATH_TEST
+  // The decomposed components of the gtest_internal_run_death_test flag,
+  // parsed when RUN_ALL_TESTS is called.
+  std::unique_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_;
+  std::unique_ptr<internal::DeathTestFactory> death_test_factory_;
+#endif  // GTEST_HAS_DEATH_TEST
+
+  // A per-thread stack of traces created by the SCOPED_TRACE() macro.
+  internal::ThreadLocal<std::vector<TraceInfo> > gtest_trace_stack_;
+
+  // The value of GTEST_FLAG(catch_exceptions) at the moment RunAllTests()
+  // starts.
+  bool catch_exceptions_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl);
+};  // class UnitTestImpl
+
+// Convenience function for accessing the global UnitTest
+// implementation object.
+inline UnitTestImpl* GetUnitTestImpl() {
+  return UnitTest::GetInstance()->impl();
+}
+
+#if GTEST_USES_SIMPLE_RE
+
+// Internal helper functions for implementing the simple regular
+// expression matcher.
+GTEST_API_ bool IsInSet(char ch, const char* str);
+GTEST_API_ bool IsAsciiDigit(char ch);
+GTEST_API_ bool IsAsciiPunct(char ch);
+GTEST_API_ bool IsRepeat(char ch);
+GTEST_API_ bool IsAsciiWhiteSpace(char ch);
+GTEST_API_ bool IsAsciiWordChar(char ch);
+GTEST_API_ bool IsValidEscape(char ch);
+GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch);
+GTEST_API_ bool ValidateRegex(const char* regex);
+GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str);
+GTEST_API_ bool MatchRepetitionAndRegexAtHead(
+    bool escaped, char ch, char repeat, const char* regex, const char* str);
+GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str);
+
+#endif  // GTEST_USES_SIMPLE_RE
+
+// Parses the command line for Google Test flags, without initializing
+// other parts of Google Test.
+GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv);
+GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv);
+
+#if GTEST_HAS_DEATH_TEST
+
+// Returns the message describing the last system error, regardless of the
+// platform.
+GTEST_API_ std::string GetLastErrnoDescription();
+
+// Attempts to parse a string into a positive integer pointed to by the
+// number parameter.  Returns true if that is possible.
+// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use
+// it here.
+template <typename Integer>
+bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
+  // Fail fast if the given string does not begin with a digit;
+  // this bypasses strtoXXX's "optional leading whitespace and plus
+  // or minus sign" semantics, which are undesirable here.
+  if (str.empty() || !IsDigit(str[0])) {
+    return false;
+  }
+  errno = 0;
+
+  char* end;
+  // BiggestConvertible is the largest integer type that system-provided
+  // string-to-number conversion routines can return.
+  using BiggestConvertible = unsigned long long;  // NOLINT
+
+  const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10);  // NOLINT
+  const bool parse_success = *end == '\0' && errno == 0;
+
+  GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed));
+
+  const Integer result = static_cast<Integer>(parsed);
+  if (parse_success && static_cast<BiggestConvertible>(result) == parsed) {
+    *number = result;
+    return true;
+  }
+  return false;
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+// TestResult contains some private methods that should be hidden from
+// Google Test user but are required for testing. This class allow our tests
+// to access them.
+//
+// This class is supplied only for the purpose of testing Google Test's own
+// constructs. Do not use it in user tests, either directly or indirectly.
+class TestResultAccessor {
+ public:
+  static void RecordProperty(TestResult* test_result,
+                             const std::string& xml_element,
+                             const TestProperty& property) {
+    test_result->RecordProperty(xml_element, property);
+  }
+
+  static void ClearTestPartResults(TestResult* test_result) {
+    test_result->ClearTestPartResults();
+  }
+
+  static const std::vector<testing::TestPartResult>& test_part_results(
+      const TestResult& test_result) {
+    return test_result.test_part_results();
+  }
+};
+
+#if GTEST_CAN_STREAM_RESULTS_
+
+// Streams test results to the given port on the given host machine.
+class StreamingListener : public EmptyTestEventListener {
+ public:
+  // Abstract base class for writing strings to a socket.
+  class AbstractSocketWriter {
+   public:
+    virtual ~AbstractSocketWriter() {}
+
+    // Sends a string to the socket.
+    virtual void Send(const std::string& message) = 0;
+
+    // Closes the socket.
+    virtual void CloseConnection() {}
+
+    // Sends a string and a newline to the socket.
+    void SendLn(const std::string& message) { Send(message + "\n"); }
+  };
+
+  // Concrete class for actually writing strings to a socket.
+  class SocketWriter : public AbstractSocketWriter {
+   public:
+    SocketWriter(const std::string& host, const std::string& port)
+        : sockfd_(-1), host_name_(host), port_num_(port) {
+      MakeConnection();
+    }
+
+    ~SocketWriter() override {
+      if (sockfd_ != -1)
+        CloseConnection();
+    }
+
+    // Sends a string to the socket.
+    void Send(const std::string& message) override {
+      GTEST_CHECK_(sockfd_ != -1)
+          << "Send() can be called only when there is a connection.";
+
+      const auto len = static_cast<size_t>(message.length());
+      if (write(sockfd_, message.c_str(), len) != static_cast<ssize_t>(len)) {
+        GTEST_LOG_(WARNING)
+            << "stream_result_to: failed to stream to "
+            << host_name_ << ":" << port_num_;
+      }
+    }
+
+   private:
+    // Creates a client socket and connects to the server.
+    void MakeConnection();
+
+    // Closes the socket.
+    void CloseConnection() override {
+      GTEST_CHECK_(sockfd_ != -1)
+          << "CloseConnection() can be called only when there is a connection.";
+
+      close(sockfd_);
+      sockfd_ = -1;
+    }
+
+    int sockfd_;  // socket file descriptor
+    const std::string host_name_;
+    const std::string port_num_;
+
+    GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter);
+  };  // class SocketWriter
+
+  // Escapes '=', '&', '%', and '\n' characters in str as "%xx".
+  static std::string UrlEncode(const char* str);
+
+  StreamingListener(const std::string& host, const std::string& port)
+      : socket_writer_(new SocketWriter(host, port)) {
+    Start();
+  }
+
+  explicit StreamingListener(AbstractSocketWriter* socket_writer)
+      : socket_writer_(socket_writer) { Start(); }
+
+  void OnTestProgramStart(const UnitTest& /* unit_test */) override {
+    SendLn("event=TestProgramStart");
+  }
+
+  void OnTestProgramEnd(const UnitTest& unit_test) override {
+    // Note that Google Test current only report elapsed time for each
+    // test iteration, not for the entire test program.
+    SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));
+
+    // Notify the streaming server to stop.
+    socket_writer_->CloseConnection();
+  }
+
+  void OnTestIterationStart(const UnitTest& /* unit_test */,
+                            int iteration) override {
+    SendLn("event=TestIterationStart&iteration=" +
+           StreamableToString(iteration));
+  }
+
+  void OnTestIterationEnd(const UnitTest& unit_test,
+                          int /* iteration */) override {
+    SendLn("event=TestIterationEnd&passed=" +
+           FormatBool(unit_test.Passed()) + "&elapsed_time=" +
+           StreamableToString(unit_test.elapsed_time()) + "ms");
+  }
+
+  // Note that "event=TestCaseStart" is a wire format and has to remain
+  // "case" for compatibility
+  void OnTestCaseStart(const TestCase& test_case) override {
+    SendLn(std::string("event=TestCaseStart&name=") + test_case.name());
+  }
+
+  // Note that "event=TestCaseEnd" is a wire format and has to remain
+  // "case" for compatibility
+  void OnTestCaseEnd(const TestCase& test_case) override {
+    SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed()) +
+           "&elapsed_time=" + StreamableToString(test_case.elapsed_time()) +
+           "ms");
+  }
+
+  void OnTestStart(const TestInfo& test_info) override {
+    SendLn(std::string("event=TestStart&name=") + test_info.name());
+  }
+
+  void OnTestEnd(const TestInfo& test_info) override {
+    SendLn("event=TestEnd&passed=" +
+           FormatBool((test_info.result())->Passed()) +
+           "&elapsed_time=" +
+           StreamableToString((test_info.result())->elapsed_time()) + "ms");
+  }
+
+  void OnTestPartResult(const TestPartResult& test_part_result) override {
+    const char* file_name = test_part_result.file_name();
+    if (file_name == nullptr) file_name = "";
+    SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
+           "&line=" + StreamableToString(test_part_result.line_number()) +
+           "&message=" + UrlEncode(test_part_result.message()));
+  }
+
+ private:
+  // Sends the given message and a newline to the socket.
+  void SendLn(const std::string& message) { socket_writer_->SendLn(message); }
+
+  // Called at the start of streaming to notify the receiver what
+  // protocol we are using.
+  void Start() { SendLn("gtest_streaming_protocol_version=1.0"); }
+
+  std::string FormatBool(bool value) { return value ? "1" : "0"; }
+
+  const std::unique_ptr<AbstractSocketWriter> socket_writer_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener);
+};  // class StreamingListener
+
+#endif  // GTEST_CAN_STREAM_RESULTS_
+
+}  // namespace internal
+}  // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_()  //  4251
+
+#endif  // GOOGLETEST_SRC_GTEST_INTERNAL_INL_H_
diff --git a/trunk/3rdparty/gtest-fit/googletest/src/gtest-matchers.cc b/trunk/3rdparty/gtest-fit/googletest/src/gtest-matchers.cc
new file mode 100644
index 000000000..65104ebab
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/src/gtest-matchers.cc
@@ -0,0 +1,97 @@
+// Copyright 2007, 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.
+
+// The Google C++ Testing and Mocking Framework (Google Test)
+//
+// This file implements just enough of the matcher interface to allow
+// EXPECT_DEATH and friends to accept a matcher argument.
+
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-port.h"
+#include "gtest/gtest-matchers.h"
+
+#include <string>
+
+namespace testing {
+
+// Constructs a matcher that matches a const std::string& whose value is
+// equal to s.
+Matcher<const std::string&>::Matcher(const std::string& s) { *this = Eq(s); }
+
+// Constructs a matcher that matches a const std::string& whose value is
+// equal to s.
+Matcher<const std::string&>::Matcher(const char* s) {
+  *this = Eq(std::string(s));
+}
+
+// Constructs a matcher that matches a std::string whose value is equal to
+// s.
+Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s); }
+
+// Constructs a matcher that matches a std::string whose value is equal to
+// s.
+Matcher<std::string>::Matcher(const char* s) { *this = Eq(std::string(s)); }
+
+#if GTEST_INTERNAL_HAS_STRING_VIEW
+// Constructs a matcher that matches a const StringView& whose value is
+// equal to s.
+Matcher<const internal::StringView&>::Matcher(const std::string& s) {
+  *this = Eq(s);
+}
+
+// Constructs a matcher that matches a const StringView& whose value is
+// equal to s.
+Matcher<const internal::StringView&>::Matcher(const char* s) {
+  *this = Eq(std::string(s));
+}
+
+// Constructs a matcher that matches a const StringView& whose value is
+// equal to s.
+Matcher<const internal::StringView&>::Matcher(internal::StringView s) {
+  *this = Eq(std::string(s));
+}
+
+// Constructs a matcher that matches a StringView whose value is equal to
+// s.
+Matcher<internal::StringView>::Matcher(const std::string& s) { *this = Eq(s); }
+
+// Constructs a matcher that matches a StringView whose value is equal to
+// s.
+Matcher<internal::StringView>::Matcher(const char* s) {
+  *this = Eq(std::string(s));
+}
+
+// Constructs a matcher that matches a StringView whose value is equal to
+// s.
+Matcher<internal::StringView>::Matcher(internal::StringView s) {
+  *this = Eq(std::string(s));
+}
+#endif  // GTEST_INTERNAL_HAS_STRING_VIEW
+
+}  // namespace testing
diff --git a/trunk/3rdparty/gtest-fit/googletest/src/gtest-port.cc b/trunk/3rdparty/gtest-fit/googletest/src/gtest-port.cc
new file mode 100644
index 000000000..53a4d37f9
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/src/gtest-port.cc
@@ -0,0 +1,1433 @@
+// Copyright 2008, 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.
+
+
+#include "gtest/internal/gtest-port.h"
+
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <cstdint>
+#include <fstream>
+#include <memory>
+
+#if GTEST_OS_WINDOWS
+# include <windows.h>
+# include <io.h>
+# include <sys/stat.h>
+# include <map>  // Used in ThreadLocal.
+# ifdef _MSC_VER
+#  include <crtdbg.h>
+# endif  // _MSC_VER
+#else
+# include <unistd.h>
+#endif  // GTEST_OS_WINDOWS
+
+#if GTEST_OS_MAC
+# include <mach/mach_init.h>
+# include <mach/task.h>
+# include <mach/vm_map.h>
+#endif  // GTEST_OS_MAC
+
+#if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \
+    GTEST_OS_NETBSD || GTEST_OS_OPENBSD
+# include <sys/sysctl.h>
+# if GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD
+#  include <sys/user.h>
+# endif
+#endif
+
+#if GTEST_OS_QNX
+# include <devctl.h>
+# include <fcntl.h>
+# include <sys/procfs.h>
+#endif  // GTEST_OS_QNX
+
+#if GTEST_OS_AIX
+# include <procinfo.h>
+# include <sys/types.h>
+#endif  // GTEST_OS_AIX
+
+#if GTEST_OS_FUCHSIA
+# include <zircon/process.h>
+# include <zircon/syscalls.h>
+#endif  // GTEST_OS_FUCHSIA
+
+#include "gtest/gtest-spi.h"
+#include "gtest/gtest-message.h"
+#include "gtest/internal/gtest-internal.h"
+#include "gtest/internal/gtest-string.h"
+#include "src/gtest-internal-inl.h"
+
+namespace testing {
+namespace internal {
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+// MSVC and C++Builder do not provide a definition of STDERR_FILENO.
+const int kStdOutFileno = 1;
+const int kStdErrFileno = 2;
+#else
+const int kStdOutFileno = STDOUT_FILENO;
+const int kStdErrFileno = STDERR_FILENO;
+#endif  // _MSC_VER
+
+#if GTEST_OS_LINUX
+
+namespace {
+template <typename T>
+T ReadProcFileField(const std::string& filename, int field) {
+  std::string dummy;
+  std::ifstream file(filename.c_str());
+  while (field-- > 0) {
+    file >> dummy;
+  }
+  T output = 0;
+  file >> output;
+  return output;
+}
+}  // namespace
+
+// Returns the number of active threads, or 0 when there is an error.
+size_t GetThreadCount() {
+  const std::string filename =
+      (Message() << "/proc/" << getpid() << "/stat").GetString();
+  return ReadProcFileField<size_t>(filename, 19);
+}
+
+#elif GTEST_OS_MAC
+
+size_t GetThreadCount() {
+  const task_t task = mach_task_self();
+  mach_msg_type_number_t thread_count;
+  thread_act_array_t thread_list;
+  const kern_return_t status = task_threads(task, &thread_list, &thread_count);
+  if (status == KERN_SUCCESS) {
+    // task_threads allocates resources in thread_list and we need to free them
+    // to avoid leaks.
+    vm_deallocate(task,
+                  reinterpret_cast<vm_address_t>(thread_list),
+                  sizeof(thread_t) * thread_count);
+    return static_cast<size_t>(thread_count);
+  } else {
+    return 0;
+  }
+}
+
+#elif GTEST_OS_DRAGONFLY || GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD || \
+      GTEST_OS_NETBSD
+
+#if GTEST_OS_NETBSD
+#undef KERN_PROC
+#define KERN_PROC KERN_PROC2
+#define kinfo_proc kinfo_proc2
+#endif
+
+#if GTEST_OS_DRAGONFLY
+#define KP_NLWP(kp) (kp.kp_nthreads)
+#elif GTEST_OS_FREEBSD || GTEST_OS_GNU_KFREEBSD
+#define KP_NLWP(kp) (kp.ki_numthreads)
+#elif GTEST_OS_NETBSD
+#define KP_NLWP(kp) (kp.p_nlwps)
+#endif
+
+// Returns the number of threads running in the process, or 0 to indicate that
+// we cannot detect it.
+size_t GetThreadCount() {
+  int mib[] = {
+    CTL_KERN,
+    KERN_PROC,
+    KERN_PROC_PID,
+    getpid(),
+#if GTEST_OS_NETBSD
+    sizeof(struct kinfo_proc),
+    1,
+#endif
+  };
+  u_int miblen = sizeof(mib) / sizeof(mib[0]);
+  struct kinfo_proc info;
+  size_t size = sizeof(info);
+  if (sysctl(mib, miblen, &info, &size, NULL, 0)) {
+    return 0;
+  }
+  return static_cast<size_t>(KP_NLWP(info));
+}
+#elif GTEST_OS_OPENBSD
+
+// Returns the number of threads running in the process, or 0 to indicate that
+// we cannot detect it.
+size_t GetThreadCount() {
+  int mib[] = {
+    CTL_KERN,
+    KERN_PROC,
+    KERN_PROC_PID | KERN_PROC_SHOW_THREADS,
+    getpid(),
+    sizeof(struct kinfo_proc),
+    0,
+  };
+  u_int miblen = sizeof(mib) / sizeof(mib[0]);
+
+  // get number of structs
+  size_t size;
+  if (sysctl(mib, miblen, NULL, &size, NULL, 0)) {
+    return 0;
+  }
+
+  mib[5] = static_cast<int>(size / static_cast<size_t>(mib[4]));
+
+  // populate array of structs
+  struct kinfo_proc info[mib[5]];
+  if (sysctl(mib, miblen, &info, &size, NULL, 0)) {
+    return 0;
+  }
+
+  // exclude empty members
+  size_t nthreads = 0;
+  for (size_t i = 0; i < size / static_cast<size_t>(mib[4]); i++) {
+    if (info[i].p_tid != -1)
+      nthreads++;
+  }
+  return nthreads;
+}
+
+#elif GTEST_OS_QNX
+
+// Returns the number of threads running in the process, or 0 to indicate that
+// we cannot detect it.
+size_t GetThreadCount() {
+  const int fd = open("/proc/self/as", O_RDONLY);
+  if (fd < 0) {
+    return 0;
+  }
+  procfs_info process_info;
+  const int status =
+      devctl(fd, DCMD_PROC_INFO, &process_info, sizeof(process_info), nullptr);
+  close(fd);
+  if (status == EOK) {
+    return static_cast<size_t>(process_info.num_threads);
+  } else {
+    return 0;
+  }
+}
+
+#elif GTEST_OS_AIX
+
+size_t GetThreadCount() {
+  struct procentry64 entry;
+  pid_t pid = getpid();
+  int status = getprocs64(&entry, sizeof(entry), nullptr, 0, &pid, 1);
+  if (status == 1) {
+    return entry.pi_thcount;
+  } else {
+    return 0;
+  }
+}
+
+#elif GTEST_OS_FUCHSIA
+
+size_t GetThreadCount() {
+  int dummy_buffer;
+  size_t avail;
+  zx_status_t status = zx_object_get_info(
+      zx_process_self(),
+      ZX_INFO_PROCESS_THREADS,
+      &dummy_buffer,
+      0,
+      nullptr,
+      &avail);
+  if (status == ZX_OK) {
+    return avail;
+  } else {
+    return 0;
+  }
+}
+
+#else
+
+size_t GetThreadCount() {
+  // There's no portable way to detect the number of threads, so we just
+  // return 0 to indicate that we cannot detect it.
+  return 0;
+}
+
+#endif  // GTEST_OS_LINUX
+
+#if GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS
+
+void SleepMilliseconds(int n) {
+  ::Sleep(static_cast<DWORD>(n));
+}
+
+AutoHandle::AutoHandle()
+    : handle_(INVALID_HANDLE_VALUE) {}
+
+AutoHandle::AutoHandle(Handle handle)
+    : handle_(handle) {}
+
+AutoHandle::~AutoHandle() {
+  Reset();
+}
+
+AutoHandle::Handle AutoHandle::Get() const {
+  return handle_;
+}
+
+void AutoHandle::Reset() {
+  Reset(INVALID_HANDLE_VALUE);
+}
+
+void AutoHandle::Reset(HANDLE handle) {
+  // Resetting with the same handle we already own is invalid.
+  if (handle_ != handle) {
+    if (IsCloseable()) {
+      ::CloseHandle(handle_);
+    }
+    handle_ = handle;
+  } else {
+    GTEST_CHECK_(!IsCloseable())
+        << "Resetting a valid handle to itself is likely a programmer error "
+            "and thus not allowed.";
+  }
+}
+
+bool AutoHandle::IsCloseable() const {
+  // Different Windows APIs may use either of these values to represent an
+  // invalid handle.
+  return handle_ != nullptr && handle_ != INVALID_HANDLE_VALUE;
+}
+
+Notification::Notification()
+    : event_(::CreateEvent(nullptr,     // Default security attributes.
+                           TRUE,        // Do not reset automatically.
+                           FALSE,       // Initially unset.
+                           nullptr)) {  // Anonymous event.
+  GTEST_CHECK_(event_.Get() != nullptr);
+}
+
+void Notification::Notify() {
+  GTEST_CHECK_(::SetEvent(event_.Get()) != FALSE);
+}
+
+void Notification::WaitForNotification() {
+  GTEST_CHECK_(
+      ::WaitForSingleObject(event_.Get(), INFINITE) == WAIT_OBJECT_0);
+}
+
+Mutex::Mutex()
+    : owner_thread_id_(0),
+      type_(kDynamic),
+      critical_section_init_phase_(0),
+      critical_section_(new CRITICAL_SECTION) {
+  ::InitializeCriticalSection(critical_section_);
+}
+
+Mutex::~Mutex() {
+  // Static mutexes are leaked intentionally. It is not thread-safe to try
+  // to clean them up.
+  if (type_ == kDynamic) {
+    ::DeleteCriticalSection(critical_section_);
+    delete critical_section_;
+    critical_section_ = nullptr;
+  }
+}
+
+void Mutex::Lock() {
+  ThreadSafeLazyInit();
+  ::EnterCriticalSection(critical_section_);
+  owner_thread_id_ = ::GetCurrentThreadId();
+}
+
+void Mutex::Unlock() {
+  ThreadSafeLazyInit();
+  // We don't protect writing to owner_thread_id_ here, as it's the
+  // caller's responsibility to ensure that the current thread holds the
+  // mutex when this is called.
+  owner_thread_id_ = 0;
+  ::LeaveCriticalSection(critical_section_);
+}
+
+// Does nothing if the current thread holds the mutex. Otherwise, crashes
+// with high probability.
+void Mutex::AssertHeld() {
+  ThreadSafeLazyInit();
+  GTEST_CHECK_(owner_thread_id_ == ::GetCurrentThreadId())
+      << "The current thread is not holding the mutex @" << this;
+}
+
+namespace {
+
+#ifdef _MSC_VER
+// Use the RAII idiom to flag mem allocs that are intentionally never
+// deallocated. The motivation is to silence the false positive mem leaks
+// that are reported by the debug version of MS's CRT which can only detect
+// if an alloc is missing a matching deallocation.
+// Example:
+//    MemoryIsNotDeallocated memory_is_not_deallocated;
+//    critical_section_ = new CRITICAL_SECTION;
+//
+class MemoryIsNotDeallocated
+{
+ public:
+  MemoryIsNotDeallocated() : old_crtdbg_flag_(0) {
+    old_crtdbg_flag_ = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+    // Set heap allocation block type to _IGNORE_BLOCK so that MS debug CRT
+    // doesn't report mem leak if there's no matching deallocation.
+    _CrtSetDbgFlag(old_crtdbg_flag_ & ~_CRTDBG_ALLOC_MEM_DF);
+  }
+
+  ~MemoryIsNotDeallocated() {
+    // Restore the original _CRTDBG_ALLOC_MEM_DF flag
+    _CrtSetDbgFlag(old_crtdbg_flag_);
+  }
+
+ private:
+  int old_crtdbg_flag_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(MemoryIsNotDeallocated);
+};
+#endif  // _MSC_VER
+
+}  // namespace
+
+// Initializes owner_thread_id_ and critical_section_ in static mutexes.
+void Mutex::ThreadSafeLazyInit() {
+  // Dynamic mutexes are initialized in the constructor.
+  if (type_ == kStatic) {
+    switch (
+        ::InterlockedCompareExchange(&critical_section_init_phase_, 1L, 0L)) {
+      case 0:
+        // If critical_section_init_phase_ was 0 before the exchange, we
+        // are the first to test it and need to perform the initialization.
+        owner_thread_id_ = 0;
+        {
+          // Use RAII to flag that following mem alloc is never deallocated.
+#ifdef _MSC_VER
+          MemoryIsNotDeallocated memory_is_not_deallocated;
+#endif  // _MSC_VER
+          critical_section_ = new CRITICAL_SECTION;
+        }
+        ::InitializeCriticalSection(critical_section_);
+        // Updates the critical_section_init_phase_ to 2 to signal
+        // initialization complete.
+        GTEST_CHECK_(::InterlockedCompareExchange(
+                          &critical_section_init_phase_, 2L, 1L) ==
+                      1L);
+        break;
+      case 1:
+        // Somebody else is already initializing the mutex; spin until they
+        // are done.
+        while (::InterlockedCompareExchange(&critical_section_init_phase_,
+                                            2L,
+                                            2L) != 2L) {
+          // Possibly yields the rest of the thread's time slice to other
+          // threads.
+          ::Sleep(0);
+        }
+        break;
+
+      case 2:
+        break;  // The mutex is already initialized and ready for use.
+
+      default:
+        GTEST_CHECK_(false)
+            << "Unexpected value of critical_section_init_phase_ "
+            << "while initializing a static mutex.";
+    }
+  }
+}
+
+namespace {
+
+class ThreadWithParamSupport : public ThreadWithParamBase {
+ public:
+  static HANDLE CreateThread(Runnable* runnable,
+                             Notification* thread_can_start) {
+    ThreadMainParam* param = new ThreadMainParam(runnable, thread_can_start);
+    DWORD thread_id;
+    HANDLE thread_handle = ::CreateThread(
+        nullptr,  // Default security.
+        0,        // Default stack size.
+        &ThreadWithParamSupport::ThreadMain,
+        param,        // Parameter to ThreadMainStatic
+        0x0,          // Default creation flags.
+        &thread_id);  // Need a valid pointer for the call to work under Win98.
+    GTEST_CHECK_(thread_handle != nullptr)
+        << "CreateThread failed with error " << ::GetLastError() << ".";
+    if (thread_handle == nullptr) {
+      delete param;
+    }
+    return thread_handle;
+  }
+
+ private:
+  struct ThreadMainParam {
+    ThreadMainParam(Runnable* runnable, Notification* thread_can_start)
+        : runnable_(runnable),
+          thread_can_start_(thread_can_start) {
+    }
+    std::unique_ptr<Runnable> runnable_;
+    // Does not own.
+    Notification* thread_can_start_;
+  };
+
+  static DWORD WINAPI ThreadMain(void* ptr) {
+    // Transfers ownership.
+    std::unique_ptr<ThreadMainParam> param(static_cast<ThreadMainParam*>(ptr));
+    if (param->thread_can_start_ != nullptr)
+      param->thread_can_start_->WaitForNotification();
+    param->runnable_->Run();
+    return 0;
+  }
+
+  // Prohibit instantiation.
+  ThreadWithParamSupport();
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParamSupport);
+};
+
+}  // namespace
+
+ThreadWithParamBase::ThreadWithParamBase(Runnable *runnable,
+                                         Notification* thread_can_start)
+      : thread_(ThreadWithParamSupport::CreateThread(runnable,
+                                                     thread_can_start)) {
+}
+
+ThreadWithParamBase::~ThreadWithParamBase() {
+  Join();
+}
+
+void ThreadWithParamBase::Join() {
+  GTEST_CHECK_(::WaitForSingleObject(thread_.Get(), INFINITE) == WAIT_OBJECT_0)
+      << "Failed to join the thread with error " << ::GetLastError() << ".";
+}
+
+// Maps a thread to a set of ThreadIdToThreadLocals that have values
+// instantiated on that thread and notifies them when the thread exits.  A
+// ThreadLocal instance is expected to persist until all threads it has
+// values on have terminated.
+class ThreadLocalRegistryImpl {
+ public:
+  // Registers thread_local_instance as having value on the current thread.
+  // Returns a value that can be used to identify the thread from other threads.
+  static ThreadLocalValueHolderBase* GetValueOnCurrentThread(
+      const ThreadLocalBase* thread_local_instance) {
+#ifdef _MSC_VER
+    MemoryIsNotDeallocated memory_is_not_deallocated;
+#endif  // _MSC_VER
+    DWORD current_thread = ::GetCurrentThreadId();
+    MutexLock lock(&mutex_);
+    ThreadIdToThreadLocals* const thread_to_thread_locals =
+        GetThreadLocalsMapLocked();
+    ThreadIdToThreadLocals::iterator thread_local_pos =
+        thread_to_thread_locals->find(current_thread);
+    if (thread_local_pos == thread_to_thread_locals->end()) {
+      thread_local_pos = thread_to_thread_locals->insert(
+          std::make_pair(current_thread, ThreadLocalValues())).first;
+      StartWatcherThreadFor(current_thread);
+    }
+    ThreadLocalValues& thread_local_values = thread_local_pos->second;
+    ThreadLocalValues::iterator value_pos =
+        thread_local_values.find(thread_local_instance);
+    if (value_pos == thread_local_values.end()) {
+      value_pos =
+          thread_local_values
+              .insert(std::make_pair(
+                  thread_local_instance,
+                  std::shared_ptr<ThreadLocalValueHolderBase>(
+                      thread_local_instance->NewValueForCurrentThread())))
+              .first;
+    }
+    return value_pos->second.get();
+  }
+
+  static void OnThreadLocalDestroyed(
+      const ThreadLocalBase* thread_local_instance) {
+    std::vector<std::shared_ptr<ThreadLocalValueHolderBase> > value_holders;
+    // Clean up the ThreadLocalValues data structure while holding the lock, but
+    // defer the destruction of the ThreadLocalValueHolderBases.
+    {
+      MutexLock lock(&mutex_);
+      ThreadIdToThreadLocals* const thread_to_thread_locals =
+          GetThreadLocalsMapLocked();
+      for (ThreadIdToThreadLocals::iterator it =
+          thread_to_thread_locals->begin();
+          it != thread_to_thread_locals->end();
+          ++it) {
+        ThreadLocalValues& thread_local_values = it->second;
+        ThreadLocalValues::iterator value_pos =
+            thread_local_values.find(thread_local_instance);
+        if (value_pos != thread_local_values.end()) {
+          value_holders.push_back(value_pos->second);
+          thread_local_values.erase(value_pos);
+          // This 'if' can only be successful at most once, so theoretically we
+          // could break out of the loop here, but we don't bother doing so.
+        }
+      }
+    }
+    // Outside the lock, let the destructor for 'value_holders' deallocate the
+    // ThreadLocalValueHolderBases.
+  }
+
+  static void OnThreadExit(DWORD thread_id) {
+    GTEST_CHECK_(thread_id != 0) << ::GetLastError();
+    std::vector<std::shared_ptr<ThreadLocalValueHolderBase> > value_holders;
+    // Clean up the ThreadIdToThreadLocals data structure while holding the
+    // lock, but defer the destruction of the ThreadLocalValueHolderBases.
+    {
+      MutexLock lock(&mutex_);
+      ThreadIdToThreadLocals* const thread_to_thread_locals =
+          GetThreadLocalsMapLocked();
+      ThreadIdToThreadLocals::iterator thread_local_pos =
+          thread_to_thread_locals->find(thread_id);
+      if (thread_local_pos != thread_to_thread_locals->end()) {
+        ThreadLocalValues& thread_local_values = thread_local_pos->second;
+        for (ThreadLocalValues::iterator value_pos =
+            thread_local_values.begin();
+            value_pos != thread_local_values.end();
+            ++value_pos) {
+          value_holders.push_back(value_pos->second);
+        }
+        thread_to_thread_locals->erase(thread_local_pos);
+      }
+    }
+    // Outside the lock, let the destructor for 'value_holders' deallocate the
+    // ThreadLocalValueHolderBases.
+  }
+
+ private:
+  // In a particular thread, maps a ThreadLocal object to its value.
+  typedef std::map<const ThreadLocalBase*,
+                   std::shared_ptr<ThreadLocalValueHolderBase> >
+      ThreadLocalValues;
+  // Stores all ThreadIdToThreadLocals having values in a thread, indexed by
+  // 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;
+
+  static void StartWatcherThreadFor(DWORD thread_id) {
+    // The returned handle will be kept in thread_map and closed by
+    // watcher_thread in WatcherThreadFunc.
+    HANDLE thread = ::OpenThread(SYNCHRONIZE | THREAD_QUERY_INFORMATION,
+                                 FALSE,
+                                 thread_id);
+    GTEST_CHECK_(thread != nullptr);
+    // 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);
+    GTEST_CHECK_(watcher_thread != nullptr);
+    // Give the watcher thread the same priority as ours to avoid being
+    // blocked by it.
+    ::SetThreadPriority(watcher_thread,
+                        ::GetThreadPriority(::GetCurrentThread()));
+    ::ResumeThread(watcher_thread);
+    ::CloseHandle(watcher_thread);
+  }
+
+  // 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;
+    return 0;
+  }
+
+  // Returns map of thread local instances.
+  static ThreadIdToThreadLocals* GetThreadLocalsMapLocked() {
+    mutex_.AssertHeld();
+#ifdef _MSC_VER
+    MemoryIsNotDeallocated memory_is_not_deallocated;
+#endif  // _MSC_VER
+    static ThreadIdToThreadLocals* map = new ThreadIdToThreadLocals();
+    return map;
+  }
+
+  // Protects access to GetThreadLocalsMapLocked() and its return value.
+  static Mutex mutex_;
+  // Protects access to GetThreadMapLocked() and its return value.
+  static Mutex thread_map_mutex_;
+};
+
+Mutex ThreadLocalRegistryImpl::mutex_(Mutex::kStaticMutex);  // NOLINT
+Mutex ThreadLocalRegistryImpl::thread_map_mutex_(Mutex::kStaticMutex);  // NOLINT
+
+ThreadLocalValueHolderBase* ThreadLocalRegistry::GetValueOnCurrentThread(
+      const ThreadLocalBase* thread_local_instance) {
+  return ThreadLocalRegistryImpl::GetValueOnCurrentThread(
+      thread_local_instance);
+}
+
+void ThreadLocalRegistry::OnThreadLocalDestroyed(
+      const ThreadLocalBase* thread_local_instance) {
+  ThreadLocalRegistryImpl::OnThreadLocalDestroyed(thread_local_instance);
+}
+
+#endif  // GTEST_IS_THREADSAFE && GTEST_OS_WINDOWS
+
+#if GTEST_USES_POSIX_RE
+
+// Implements RE.  Currently only needed for death tests.
+
+RE::~RE() {
+  if (is_valid_) {
+    // regfree'ing an invalid regex might crash because the content
+    // of the regex is undefined. Since the regex's are essentially
+    // the same, one cannot be valid (or invalid) without the other
+    // being so too.
+    regfree(&partial_regex_);
+    regfree(&full_regex_);
+  }
+  free(const_cast<char*>(pattern_));
+}
+
+// Returns true if and only if regular expression re matches the entire str.
+bool RE::FullMatch(const char* str, const RE& re) {
+  if (!re.is_valid_) return false;
+
+  regmatch_t match;
+  return regexec(&re.full_regex_, str, 1, &match, 0) == 0;
+}
+
+// Returns true if and only if regular expression re matches a substring of
+// str (including str itself).
+bool RE::PartialMatch(const char* str, const RE& re) {
+  if (!re.is_valid_) return false;
+
+  regmatch_t match;
+  return regexec(&re.partial_regex_, str, 1, &match, 0) == 0;
+}
+
+// Initializes an RE from its string representation.
+void RE::Init(const char* regex) {
+  pattern_ = posix::StrDup(regex);
+
+  // 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;
+  // 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
+  // freed.
+  //
+  // Some implementation of POSIX regex (e.g. on at least some
+  // versions of Cygwin) doesn't accept the empty string as a valid
+  // 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;
+  }
+  EXPECT_TRUE(is_valid_)
+      << "Regular expression \"" << regex
+      << "\" is not a valid POSIX Extended regular expression.";
+
+  delete[] full_pattern;
+}
+
+#elif GTEST_USES_SIMPLE_RE
+
+// Returns true if and only if ch appears anywhere in str (excluding the
+// terminating '\0' character).
+bool IsInSet(char ch, const char* str) {
+  return ch != '\0' && strchr(str, ch) != nullptr;
+}
+
+// Returns true if and only if ch belongs to the given classification.
+// Unlike similar functions in <ctype.h>, these aren't affected by the
+// current locale.
+bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
+bool IsAsciiPunct(char ch) {
+  return IsInSet(ch, "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~");
+}
+bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
+bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
+bool IsAsciiWordChar(char ch) {
+  return ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') ||
+      ('0' <= ch && ch <= '9') || ch == '_';
+}
+
+// Returns true if and only if "\\c" is a supported escape sequence.
+bool IsValidEscape(char c) {
+  return (IsAsciiPunct(c) || IsInSet(c, "dDfnrsStvwW"));
+}
+
+// Returns true if and only if the given atom (specified by escaped and
+// pattern) matches ch.  The result is undefined if the atom is invalid.
+bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
+  if (escaped) {  // "\\p" where p is pattern_char.
+    switch (pattern_char) {
+      case 'd': return IsAsciiDigit(ch);
+      case 'D': return !IsAsciiDigit(ch);
+      case 'f': return ch == '\f';
+      case 'n': return ch == '\n';
+      case 'r': return ch == '\r';
+      case 's': return IsAsciiWhiteSpace(ch);
+      case 'S': return !IsAsciiWhiteSpace(ch);
+      case 't': return ch == '\t';
+      case 'v': return ch == '\v';
+      case 'w': return IsAsciiWordChar(ch);
+      case 'W': return !IsAsciiWordChar(ch);
+    }
+    return IsAsciiPunct(pattern_char) && pattern_char == ch;
+  }
+
+  return (pattern_char == '.' && ch != '\n') || pattern_char == ch;
+}
+
+// Helper function used by ValidateRegex() to format error messages.
+static std::string FormatRegexSyntaxError(const char* regex, int index) {
+  return (Message() << "Syntax error at index " << index
+          << " in simple regular expression \"" << regex << "\": ").GetString();
+}
+
+// Generates non-fatal failures and returns false if regex is invalid;
+// otherwise returns true.
+bool ValidateRegex(const char* regex) {
+  if (regex == nullptr) {
+    ADD_FAILURE() << "NULL is not a valid simple regular expression.";
+    return false;
+  }
+
+  bool is_valid = true;
+
+  // True if and only if ?, *, or + can follow the previous atom.
+  bool prev_repeatable = false;
+  for (int i = 0; regex[i]; i++) {
+    if (regex[i] == '\\') {  // An escape sequence
+      i++;
+      if (regex[i] == '\0') {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
+                      << "'\\' cannot appear at the end.";
+        return false;
+      }
+
+      if (!IsValidEscape(regex[i])) {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1)
+                      << "invalid escape sequence \"\\" << regex[i] << "\".";
+        is_valid = false;
+      }
+      prev_repeatable = true;
+    } else {  // Not an escape sequence.
+      const char ch = regex[i];
+
+      if (ch == '^' && i > 0) {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
+                      << "'^' can only appear at the beginning.";
+        is_valid = false;
+      } else if (ch == '$' && regex[i + 1] != '\0') {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
+                      << "'$' can only appear at the end.";
+        is_valid = false;
+      } else if (IsInSet(ch, "()[]{}|")) {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
+                      << "'" << ch << "' is unsupported.";
+        is_valid = false;
+      } else if (IsRepeat(ch) && !prev_repeatable) {
+        ADD_FAILURE() << FormatRegexSyntaxError(regex, i)
+                      << "'" << ch << "' can only follow a repeatable token.";
+        is_valid = false;
+      }
+
+      prev_repeatable = !IsInSet(ch, "^$?*+");
+    }
+  }
+
+  return is_valid;
+}
+
+// Matches a repeated regex atom followed by a valid simple regular
+// expression.  The regex atom is defined as c if escaped is false,
+// or \c otherwise.  repeat is the repetition meta character (?, *,
+// or +).  The behavior is undefined if str contains too many
+// characters to be indexable by size_t, in which case the test will
+// probably time out anyway.  We are fine with this limitation as
+// std::string has it too.
+bool MatchRepetitionAndRegexAtHead(
+    bool escaped, char c, char repeat, const char* regex,
+    const char* str) {
+  const size_t min_count = (repeat == '+') ? 1 : 0;
+  const size_t max_count = (repeat == '?') ? 1 :
+      static_cast<size_t>(-1) - 1;
+  // We cannot call numeric_limits::max() as it conflicts with the
+  // max() macro on Windows.
+
+  for (size_t i = 0; i <= max_count; ++i) {
+    // We know that the atom matches each of the first i characters in str.
+    if (i >= min_count && MatchRegexAtHead(regex, str + i)) {
+      // We have enough matches at the head, and the tail matches too.
+      // Since we only care about *whether* the pattern matches str
+      // (as opposed to *how* it matches), there is no need to find a
+      // greedy match.
+      return true;
+    }
+    if (str[i] == '\0' || !AtomMatchesChar(escaped, c, str[i]))
+      return false;
+  }
+  return false;
+}
+
+// Returns true if and only if regex matches a prefix of str. regex must
+// be a valid simple regular expression and not start with "^", or the
+// result is undefined.
+bool MatchRegexAtHead(const char* regex, const char* str) {
+  if (*regex == '\0')  // An empty regex matches a prefix of anything.
+    return true;
+
+  // "$" only matches the end of a string.  Note that regex being
+  // valid guarantees that there's nothing after "$" in it.
+  if (*regex == '$')
+    return *str == '\0';
+
+  // Is the first thing in regex an escape sequence?
+  const bool escaped = *regex == '\\';
+  if (escaped)
+    ++regex;
+  if (IsRepeat(regex[1])) {
+    // MatchRepetitionAndRegexAtHead() calls MatchRegexAtHead(), so
+    // here's an indirect recursion.  It terminates as the regex gets
+    // shorter in each recursion.
+    return MatchRepetitionAndRegexAtHead(
+        escaped, regex[0], regex[1], regex + 2, str);
+  } else {
+    // regex isn't empty, isn't "$", and doesn't start with a
+    // repetition.  We match the first atom of regex with the first
+    // character of str and recurse.
+    return (*str != '\0') && AtomMatchesChar(escaped, *regex, *str) &&
+        MatchRegexAtHead(regex + 1, str + 1);
+  }
+}
+
+// Returns true if and only if regex matches any substring of str.  regex must
+// be a valid simple regular expression, or the result is undefined.
+//
+// The algorithm is recursive, but the recursion depth doesn't exceed
+// the regex length, so we won't need to worry about running out of
+// stack space normally.  In rare cases the time complexity can be
+// exponential with respect to the regex length + the string length,
+// but usually it's must faster (often close to linear).
+bool MatchRegexAnywhere(const char* regex, const char* str) {
+  if (regex == nullptr || str == nullptr) return false;
+
+  if (*regex == '^')
+    return MatchRegexAtHead(regex + 1, str);
+
+  // A successful match can be anywhere in str.
+  do {
+    if (MatchRegexAtHead(regex, str))
+      return true;
+  } while (*str++ != '\0');
+  return false;
+}
+
+// Implements the RE class.
+
+RE::~RE() {
+  free(const_cast<char*>(pattern_));
+  free(const_cast<char*>(full_pattern_));
+}
+
+// Returns true if and only if regular expression re matches the entire str.
+bool RE::FullMatch(const char* str, const RE& re) {
+  return re.is_valid_ && MatchRegexAnywhere(re.full_pattern_, str);
+}
+
+// Returns true if and only if regular expression re matches a substring of
+// str (including str itself).
+bool RE::PartialMatch(const char* str, const RE& re) {
+  return re.is_valid_ && MatchRegexAnywhere(re.pattern_, str);
+}
+
+// Initializes an RE from its string representation.
+void RE::Init(const char* regex) {
+  pattern_ = full_pattern_ = nullptr;
+  if (regex != nullptr) {
+    pattern_ = posix::StrDup(regex);
+  }
+
+  is_valid_ = ValidateRegex(regex);
+  if (!is_valid_) {
+    // No need to calculate the full pattern when the regex is invalid.
+    return;
+  }
+
+  const size_t len = strlen(regex);
+  // Reserves enough bytes to hold the regular expression used for a
+  // full match: we need space to prepend a '^', append a '$', and
+  // terminate the string with '\0'.
+  char* buffer = static_cast<char*>(malloc(len + 3));
+  full_pattern_ = buffer;
+
+  if (*regex != '^')
+    *buffer++ = '^';  // Makes sure full_pattern_ starts with '^'.
+
+  // We don't use snprintf or strncpy, as they trigger a warning when
+  // compiled with VC++ 8.0.
+  memcpy(buffer, regex, len);
+  buffer += len;
+
+  if (len == 0 || regex[len - 1] != '$')
+    *buffer++ = '$';  // Makes sure full_pattern_ ends with '$'.
+
+  *buffer = '\0';
+}
+
+#endif  // GTEST_USES_POSIX_RE
+
+const char kUnknownFile[] = "unknown file";
+
+// Formats a source file path and a line number as they would appear
+// in an error message from the compiler used to compile this code.
+GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
+  const std::string file_name(file == nullptr ? kUnknownFile : file);
+
+  if (line < 0) {
+    return file_name + ":";
+  }
+#ifdef _MSC_VER
+  return file_name + "(" + StreamableToString(line) + "):";
+#else
+  return file_name + ":" + StreamableToString(line) + ":";
+#endif  // _MSC_VER
+}
+
+// Formats a file location for compiler-independent XML output.
+// Although this function is not platform dependent, we put it next to
+// FormatFileLocation in order to contrast the two functions.
+// Note that FormatCompilerIndependentFileLocation() does NOT append colon
+// to the file location it produces, unlike FormatFileLocation().
+GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
+    const char* file, int line) {
+  const std::string file_name(file == nullptr ? kUnknownFile : file);
+
+  if (line < 0)
+    return file_name;
+  else
+    return file_name + ":" + StreamableToString(line);
+}
+
+GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
+    : severity_(severity) {
+  const char* const marker =
+      severity == GTEST_INFO ?    "[  INFO ]" :
+      severity == GTEST_WARNING ? "[WARNING]" :
+      severity == GTEST_ERROR ?   "[ ERROR ]" : "[ FATAL ]";
+  GetStream() << ::std::endl << marker << " "
+              << FormatFileLocation(file, line).c_str() << ": ";
+}
+
+// Flushes the buffers and, if severity is GTEST_FATAL, aborts the program.
+GTestLog::~GTestLog() {
+  GetStream() << ::std::endl;
+  if (severity_ == GTEST_FATAL) {
+    fflush(stderr);
+    posix::Abort();
+  }
+}
+
+// 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
+
+// Object that captures an output stream (stdout/stderr).
+class CapturedStream {
+ public:
+  // The ctor redirects the stream to a temporary file.
+  explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
+# if GTEST_OS_WINDOWS
+    char temp_dir_path[MAX_PATH + 1] = { '\0' };  // NOLINT
+    char temp_file_path[MAX_PATH + 1] = { '\0' };  // NOLINT
+
+    ::GetTempPathA(sizeof(temp_dir_path), temp_dir_path);
+    const UINT success = ::GetTempFileNameA(temp_dir_path,
+                                            "gtest_redir",
+                                            0,  // Generate unique file name.
+                                            temp_file_path);
+    GTEST_CHECK_(success != 0)
+        << "Unable to create a temporary file in " << temp_dir_path;
+    const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE);
+    GTEST_CHECK_(captured_fd != -1) << "Unable to open temporary file "
+                                    << temp_file_path;
+    filename_ = temp_file_path;
+# else
+    // There's no guarantee that a test has write access to the current
+    // directory, so we create the temporary file in a temporary directory.
+    std::string name_template;
+
+#  if GTEST_OS_LINUX_ANDROID
+    // Note: Android applications are expected to call the framework's
+    // Context.getExternalStorageDirectory() method through JNI to get
+    // the location of the world-writable SD Card directory. However,
+    // this requires a Context handle, which cannot be retrieved
+    // globally from native code. Doing so also precludes running the
+    // code as part of a regular standalone executable, which doesn't
+    // run in a Dalvik process (e.g. when running it through 'adb shell').
+    //
+    // 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/";
+#  elif GTEST_OS_IOS
+    char user_temp_dir[PATH_MAX + 1];
+
+    // Documented alternative to NSTemporaryDirectory() (for obtaining creating
+    // a temporary directory) at
+    // https://developer.apple.com/library/archive/documentation/Security/Conceptual/SecureCodingGuide/Articles/RaceConditions.html#//apple_ref/doc/uid/TP40002585-SW10
+    //
+    // _CS_DARWIN_USER_TEMP_DIR (as well as _CS_DARWIN_USER_CACHE_DIR) is not
+    // documented in the confstr() man page at
+    // https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/confstr.3.html#//apple_ref/doc/man/3/confstr
+    // but are still available, according to the WebKit patches at
+    // https://trac.webkit.org/changeset/262004/webkit
+    // https://trac.webkit.org/changeset/263705/webkit
+    //
+    // The confstr() implementation falls back to getenv("TMPDIR"). See
+    // https://opensource.apple.com/source/Libc/Libc-1439.100.3/gen/confstr.c.auto.html
+    ::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])
+      name_template.push_back(GTEST_PATH_SEP_[0]);
+#  else
+    name_template = "/tmp/";
+#  endif
+    name_template.append("gtest_captured_stream.XXXXXX");
+
+    // mkstemp() modifies the string bytes in place, and does not go beyond the
+    // string's length. This results in well-defined behavior in C++17.
+    //
+    // The const_cast is needed below C++17. The constraints on std::string
+    // implementations in C++11 and above make assumption behind the const_cast
+    // fairly safe.
+    const int captured_fd = ::mkstemp(const_cast<char*>(name_template.data()));
+    if (captured_fd == -1) {
+      GTEST_LOG_(WARNING)
+          << "Failed to create tmp file " << name_template
+          << " for test; does the test have access to the /tmp directory?";
+    }
+    filename_ = std::move(name_template);
+# endif  // GTEST_OS_WINDOWS
+    fflush(nullptr);
+    dup2(captured_fd, fd_);
+    close(captured_fd);
+  }
+
+  ~CapturedStream() {
+    remove(filename_.c_str());
+  }
+
+  std::string GetCapturedString() {
+    if (uncaptured_fd_ != -1) {
+      // Restores the original stream.
+      fflush(nullptr);
+      dup2(uncaptured_fd_, fd_);
+      close(uncaptured_fd_);
+      uncaptured_fd_ = -1;
+    }
+
+    FILE* const file = posix::FOpen(filename_.c_str(), "r");
+    if (file == nullptr) {
+      GTEST_LOG_(FATAL) << "Failed to open tmp file " << filename_
+                        << " for capturing stream.";
+    }
+    const std::string content = ReadEntireFile(file);
+    posix::FClose(file);
+    return content;
+  }
+
+ private:
+  const int fd_;  // A stream to capture.
+  int uncaptured_fd_;
+  // Name of the temporary file holding the stderr output.
+  ::std::string filename_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(CapturedStream);
+};
+
+GTEST_DISABLE_MSC_DEPRECATED_POP_()
+
+static CapturedStream* g_captured_stderr = nullptr;
+static CapturedStream* g_captured_stdout = nullptr;
+
+// Starts capturing an output stream (stdout/stderr).
+static void CaptureStream(int fd, const char* stream_name,
+                          CapturedStream** stream) {
+  if (*stream != nullptr) {
+    GTEST_LOG_(FATAL) << "Only one " << stream_name
+                      << " capturer can exist at a time.";
+  }
+  *stream = new CapturedStream(fd);
+}
+
+// Stops capturing the output stream and returns the captured string.
+static std::string GetCapturedStream(CapturedStream** captured_stream) {
+  const std::string content = (*captured_stream)->GetCapturedString();
+
+  delete *captured_stream;
+  *captured_stream = nullptr;
+
+  return content;
+}
+
+// Starts capturing stdout.
+void CaptureStdout() {
+  CaptureStream(kStdOutFileno, "stdout", &g_captured_stdout);
+}
+
+// Starts capturing stderr.
+void CaptureStderr() {
+  CaptureStream(kStdErrFileno, "stderr", &g_captured_stderr);
+}
+
+// Stops capturing stdout and returns the captured string.
+std::string GetCapturedStdout() {
+  return GetCapturedStream(&g_captured_stdout);
+}
+
+// Stops capturing stderr and returns the captured string.
+std::string GetCapturedStderr() {
+  return GetCapturedStream(&g_captured_stderr);
+}
+
+#endif  // GTEST_HAS_STREAM_REDIRECTION
+
+
+
+
+
+size_t GetFileSize(FILE* file) {
+  fseek(file, 0, SEEK_END);
+  return static_cast<size_t>(ftell(file));
+}
+
+std::string ReadEntireFile(FILE* file) {
+  const size_t file_size = GetFileSize(file);
+  char* const buffer = new char[file_size];
+
+  size_t bytes_last_read = 0;  // # of bytes read in the last fread()
+  size_t bytes_read = 0;       // # of bytes read so far
+
+  fseek(file, 0, SEEK_SET);
+
+  // Keeps reading the file until we cannot read further or the
+  // pre-determined file size is reached.
+  do {
+    bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file);
+    bytes_read += bytes_last_read;
+  } while (bytes_last_read > 0 && bytes_read < file_size);
+
+  const std::string content(buffer, bytes_read);
+  delete[] buffer;
+
+  return content;
+}
+
+#if GTEST_HAS_DEATH_TEST
+static const std::vector<std::string>* g_injected_test_argvs =
+    nullptr;  // Owned.
+
+std::vector<std::string> GetInjectableArgvs() {
+  if (g_injected_test_argvs != nullptr) {
+    return *g_injected_test_argvs;
+  }
+  return GetArgvs();
+}
+
+void SetInjectableArgvs(const std::vector<std::string>* new_argvs) {
+  if (g_injected_test_argvs != new_argvs) delete g_injected_test_argvs;
+  g_injected_test_argvs = new_argvs;
+}
+
+void SetInjectableArgvs(const std::vector<std::string>& new_argvs) {
+  SetInjectableArgvs(
+      new std::vector<std::string>(new_argvs.begin(), new_argvs.end()));
+}
+
+void ClearInjectableArgvs() {
+  delete g_injected_test_argvs;
+  g_injected_test_argvs = nullptr;
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+#if GTEST_OS_WINDOWS_MOBILE
+namespace posix {
+void Abort() {
+  DebugBreak();
+  TerminateProcess(GetCurrentProcess(), 1);
+}
+}  // namespace posix
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+// Returns the name of the environment variable corresponding to the
+// given flag.  For example, FlagToEnvVar("foo") will return
+// "GTEST_FOO" in the open-source version.
+static std::string FlagToEnvVar(const char* flag) {
+  const std::string full_flag =
+      (Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
+
+  Message env_var;
+  for (size_t i = 0; i != full_flag.length(); i++) {
+    env_var << ToUpper(full_flag.c_str()[i]);
+  }
+
+  return env_var.GetString();
+}
+
+// Parses 'str' for a 32-bit signed integer.  If successful, writes
+// the result to *value and returns true; otherwise leaves *value
+// unchanged and returns false.
+bool ParseInt32(const Message& src_text, const char* str, int32_t* value) {
+  // Parses the environment variable as a decimal integer.
+  char* end = nullptr;
+  const long long_value = strtol(str, &end, 10);  // NOLINT
+
+  // Has strtol() consumed all characters in the string?
+  if (*end != '\0') {
+    // No - an invalid character was encountered.
+    Message msg;
+    msg << "WARNING: " << src_text
+        << " is expected to be a 32-bit integer, but actually"
+        << " has value \"" << str << "\".\n";
+    printf("%s", msg.GetString().c_str());
+    fflush(stdout);
+    return false;
+  }
+
+  // Is the parsed value in the range of an int32_t?
+  const auto result = static_cast<int32_t>(long_value);
+  if (long_value == LONG_MAX || long_value == LONG_MIN ||
+      // The parsed value overflows as a long.  (strtol() returns
+      // LONG_MAX or LONG_MIN when the input overflows.)
+      result != long_value
+      // The parsed value overflows as an int32_t.
+      ) {
+    Message msg;
+    msg << "WARNING: " << src_text
+        << " 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;
+  }
+
+  *value = result;
+  return true;
+}
+
+// Reads and returns the Boolean environment variable corresponding to
+// the given flag; if it's not set, returns default_value.
+//
+// The value is considered true if and only if it's not "0".
+bool BoolFromGTestEnv(const char* flag, bool default_value) {
+#if defined(GTEST_GET_BOOL_FROM_ENV_)
+  return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
+#else
+  const std::string env_var = FlagToEnvVar(flag);
+  const char* const string_value = posix::GetEnv(env_var.c_str());
+  return string_value == nullptr ? default_value
+                                 : strcmp(string_value, "0") != 0;
+#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
+}
+
+// Reads and returns a 32-bit integer stored in the environment
+// variable corresponding to the given flag; if it isn't set or
+// doesn't represent a valid 32-bit integer, returns default_value.
+int32_t Int32FromGTestEnv(const char* flag, int32_t default_value) {
+#if defined(GTEST_GET_INT32_FROM_ENV_)
+  return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
+#else
+  const std::string env_var = FlagToEnvVar(flag);
+  const char* const string_value = posix::GetEnv(env_var.c_str());
+  if (string_value == nullptr) {
+    // The environment variable is not set.
+    return default_value;
+  }
+
+  int32_t result = default_value;
+  if (!ParseInt32(Message() << "Environment variable " << env_var,
+                  string_value, &result)) {
+    printf("The default value %s is used.\n",
+           (Message() << default_value).GetString().c_str());
+    fflush(stdout);
+    return default_value;
+  }
+
+  return result;
+#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
+}
+
+// As a special case for the 'output' flag, if GTEST_OUTPUT is not
+// set, we look for XML_OUTPUT_FILE, which is set by the Bazel build
+// system.  The value of XML_OUTPUT_FILE is a filename without the
+// "xml:" prefix of GTEST_OUTPUT.
+// Note that this is meant to be called at the call site so it does
+// not check that the flag is 'output'
+// In essence this checks an env variable called XML_OUTPUT_FILE
+// and if it is set we prepend "xml:" to its value, if it not set we return ""
+std::string OutputFlagAlsoCheckEnvVar(){
+  std::string default_value_for_output_flag = "";
+  const char* xml_output_file_env = posix::GetEnv("XML_OUTPUT_FILE");
+  if (nullptr != xml_output_file_env) {
+    default_value_for_output_flag = std::string("xml:") + xml_output_file_env;
+  }
+  return default_value_for_output_flag;
+}
+
+// Reads and returns the string environment variable corresponding to
+// the given flag; if it's not set, returns default_value.
+const char* StringFromGTestEnv(const char* flag, const char* default_value) {
+#if defined(GTEST_GET_STRING_FROM_ENV_)
+  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
+#else
+  const std::string env_var = FlagToEnvVar(flag);
+  const char* const value = posix::GetEnv(env_var.c_str());
+  return value == nullptr ? default_value : value;
+#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
+}
+
+}  // namespace internal
+}  // namespace testing
diff --git a/trunk/3rdparty/gtest-fit/googletest/src/gtest-printers.cc b/trunk/3rdparty/gtest-fit/googletest/src/gtest-printers.cc
new file mode 100644
index 000000000..1b68fcb50
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/src/gtest-printers.cc
@@ -0,0 +1,533 @@
+// Copyright 2007, 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.
+
+
+// Google Test - The Google C++ Testing and Mocking Framework
+//
+// This file implements a universal value printer that can print a
+// value of any type T:
+//
+//   void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr);
+//
+// It uses the << operator when possible, and prints the bytes in the
+// object otherwise.  A user can override its behavior for a class
+// type Foo by defining either operator<<(::std::ostream&, const Foo&)
+// or void PrintTo(const Foo&, ::std::ostream*) in the namespace that
+// defines Foo.
+
+#include "gtest/gtest-printers.h"
+
+#include <stdio.h>
+
+#include <cctype>
+#include <cstdint>
+#include <cwchar>
+#include <ostream>  // NOLINT
+#include <string>
+#include <type_traits>
+
+#include "gtest/internal/gtest-port.h"
+#include "src/gtest-internal-inl.h"
+
+namespace testing {
+
+namespace {
+
+using ::std::ostream;
+
+// Prints a segment of bytes in the given object.
+GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start,
+                                size_t count, ostream* os) {
+  char text[5] = "";
+  for (size_t i = 0; i != count; i++) {
+    const size_t j = start + i;
+    if (i != 0) {
+      // Organizes the bytes into groups of 2 for easy parsing by
+      // human.
+      if ((j % 2) == 0)
+        *os << ' ';
+      else
+        *os << '-';
+    }
+    GTEST_SNPRINTF_(text, sizeof(text), "%02X", obj_bytes[j]);
+    *os << text;
+  }
+}
+
+// Prints the bytes in the given value to the given ostream.
+void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count,
+                              ostream* os) {
+  // Tells the user how big the object is.
+  *os << count << "-byte object <";
+
+  const size_t kThreshold = 132;
+  const size_t kChunkSize = 64;
+  // If the object size is bigger than kThreshold, we'll have to omit
+  // some details by printing only the first and the last kChunkSize
+  // bytes.
+  if (count < kThreshold) {
+    PrintByteSegmentInObjectTo(obj_bytes, 0, count, os);
+  } else {
+    PrintByteSegmentInObjectTo(obj_bytes, 0, kChunkSize, os);
+    *os << " ... ";
+    // Rounds up to 2-byte boundary.
+    const size_t resume_pos = (count - kChunkSize + 1)/2*2;
+    PrintByteSegmentInObjectTo(obj_bytes, resume_pos, count - resume_pos, os);
+  }
+  *os << ">";
+}
+
+// Helpers for widening a character to char32_t. Since the standard does not
+// specify if char / wchar_t is signed or unsigned, it is important to first
+// convert it to the unsigned type of the same width before widening it to
+// char32_t.
+template <typename CharType>
+char32_t ToChar32(CharType in) {
+  return static_cast<char32_t>(
+      static_cast<typename std::make_unsigned<CharType>::type>(in));
+}
+
+}  // namespace
+
+namespace internal {
+
+// Delegates to PrintBytesInObjectToImpl() to print the bytes in the
+// given object.  The delegation simplifies the implementation, which
+// uses the << operator and thus is easier done outside of the
+// ::testing::internal namespace, which contains a << operator that
+// sometimes conflicts with the one in STL.
+void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
+                          ostream* os) {
+  PrintBytesInObjectToImpl(obj_bytes, count, os);
+}
+
+// Depending on the value of a char (or wchar_t), we print it in one
+// of three formats:
+//   - as is if it's a printable ASCII (e.g. 'a', '2', ' '),
+//   - as a hexadecimal escape sequence (e.g. '\x7F'), or
+//   - as a special escape sequence (e.g. '\r', '\n').
+enum CharFormat {
+  kAsIs,
+  kHexEscape,
+  kSpecialEscape
+};
+
+// Returns true if c is a printable ASCII character.  We test the
+// value of c directly instead of calling isprint(), which is buggy on
+// Windows Mobile.
+inline bool IsPrintableAscii(char32_t c) { return 0x20 <= c && c <= 0x7E; }
+
+// Prints c (of type char, char8_t, char16_t, char32_t, or wchar_t) as a
+// character literal without the quotes, escaping it when necessary; returns how
+// c was formatted.
+template <typename Char>
+static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
+  const char32_t u_c = ToChar32(c);
+  switch (u_c) {
+    case L'\0':
+      *os << "\\0";
+      break;
+    case L'\'':
+      *os << "\\'";
+      break;
+    case L'\\':
+      *os << "\\\\";
+      break;
+    case L'\a':
+      *os << "\\a";
+      break;
+    case L'\b':
+      *os << "\\b";
+      break;
+    case L'\f':
+      *os << "\\f";
+      break;
+    case L'\n':
+      *os << "\\n";
+      break;
+    case L'\r':
+      *os << "\\r";
+      break;
+    case L'\t':
+      *os << "\\t";
+      break;
+    case L'\v':
+      *os << "\\v";
+      break;
+    default:
+      if (IsPrintableAscii(u_c)) {
+        *os << static_cast<char>(c);
+        return kAsIs;
+      } else {
+        ostream::fmtflags flags = os->flags();
+        *os << "\\x" << std::hex << std::uppercase << static_cast<int>(u_c);
+        os->flags(flags);
+        return kHexEscape;
+      }
+  }
+  return kSpecialEscape;
+}
+
+// Prints a char32_t c as if it's part of a string literal, escaping it when
+// necessary; returns how c was formatted.
+static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) {
+  switch (c) {
+    case L'\'':
+      *os << "'";
+      return kAsIs;
+    case L'"':
+      *os << "\\\"";
+      return kSpecialEscape;
+    default:
+      return PrintAsCharLiteralTo(c, os);
+  }
+}
+
+static const char* GetCharWidthPrefix(char) {
+  return "";
+}
+
+static const char* GetCharWidthPrefix(signed char) {
+  return "";
+}
+
+static const char* GetCharWidthPrefix(unsigned char) {
+  return "";
+}
+
+#ifdef __cpp_char8_t
+static const char* GetCharWidthPrefix(char8_t) {
+  return "u8";
+}
+#endif
+
+static const char* GetCharWidthPrefix(char16_t) {
+  return "u";
+}
+
+static const char* GetCharWidthPrefix(char32_t) {
+  return "U";
+}
+
+static const char* GetCharWidthPrefix(wchar_t) {
+  return "L";
+}
+
+// Prints a char c as if it's part of a string literal, escaping it when
+// necessary; returns how c was formatted.
+static CharFormat PrintAsStringLiteralTo(char c, ostream* os) {
+  return PrintAsStringLiteralTo(ToChar32(c), os);
+}
+
+#ifdef __cpp_char8_t
+static CharFormat PrintAsStringLiteralTo(char8_t c, ostream* os) {
+  return PrintAsStringLiteralTo(ToChar32(c), os);
+}
+#endif
+
+static CharFormat PrintAsStringLiteralTo(char16_t c, ostream* os) {
+  return PrintAsStringLiteralTo(ToChar32(c), os);
+}
+
+static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) {
+  return PrintAsStringLiteralTo(ToChar32(c), os);
+}
+
+// Prints a character c (of type char, char8_t, char16_t, char32_t, or wchar_t)
+// and its code. '\0' is printed as "'\\0'", other unprintable characters are
+// also properly escaped using the standard C++ escape sequence.
+template <typename Char>
+void PrintCharAndCodeTo(Char c, ostream* os) {
+  // First, print c as a literal in the most readable form we can find.
+  *os << GetCharWidthPrefix(c) << "'";
+  const CharFormat format = PrintAsCharLiteralTo(c, os);
+  *os << "'";
+
+  // To aid user debugging, we also print c's code in decimal, unless
+  // it's 0 (in which case c was printed as '\\0', making the code
+  // obvious).
+  if (c == 0)
+    return;
+  *os << " (" << static_cast<int>(c);
+
+  // For more convenience, we print c's code again in hexadecimal,
+  // unless c was already printed in the form '\x##' or the code is in
+  // [1, 9].
+  if (format == kHexEscape || (1 <= c && c <= 9)) {
+    // Do nothing.
+  } else {
+    *os << ", 0x" << String::FormatHexInt(static_cast<int>(c));
+  }
+  *os << ")";
+}
+
+void PrintTo(unsigned char c, ::std::ostream* os) { PrintCharAndCodeTo(c, os); }
+void PrintTo(signed char c, ::std::ostream* os) { PrintCharAndCodeTo(c, os); }
+
+// Prints a wchar_t as a symbol if it is printable or as its internal
+// code otherwise and also as its code.  L'\0' is printed as "L'\\0'".
+void PrintTo(wchar_t wc, ostream* os) { PrintCharAndCodeTo(wc, os); }
+
+// TODO(dcheng): Consider making this delegate to PrintCharAndCodeTo() as well.
+void PrintTo(char32_t c, ::std::ostream* os) {
+  *os << std::hex << "U+" << std::uppercase << std::setfill('0') << std::setw(4)
+      << static_cast<uint32_t>(c);
+}
+
+// Prints the given array of characters to the ostream.  CharType must be either
+// char, char8_t, char16_t, char32_t, or wchar_t.
+// The array starts at begin, the length is len, it may include '\0' characters
+// and may not be NUL-terminated.
+template <typename CharType>
+GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+static CharFormat PrintCharsAsStringTo(
+    const CharType* begin, size_t len, ostream* os) {
+  const char* const quote_prefix = GetCharWidthPrefix(*begin);
+  *os << quote_prefix << "\"";
+  bool is_previous_hex = false;
+  CharFormat print_format = kAsIs;
+  for (size_t index = 0; index < len; ++index) {
+    const CharType cur = begin[index];
+    if (is_previous_hex && IsXDigit(cur)) {
+      // Previous character is of '\x..' form and this character can be
+      // interpreted as another hexadecimal digit in its number. Break string to
+      // disambiguate.
+      *os << "\" " << quote_prefix << "\"";
+    }
+    is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape;
+    // Remember if any characters required hex escaping.
+    if (is_previous_hex) {
+      print_format = kHexEscape;
+    }
+  }
+  *os << "\"";
+  return print_format;
+}
+
+// Prints a (const) char/wchar_t array of 'len' elements, starting at address
+// 'begin'.  CharType must be either char or wchar_t.
+template <typename CharType>
+GTEST_ATTRIBUTE_NO_SANITIZE_MEMORY_
+GTEST_ATTRIBUTE_NO_SANITIZE_ADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_HWADDRESS_
+GTEST_ATTRIBUTE_NO_SANITIZE_THREAD_
+static void UniversalPrintCharArray(
+    const CharType* begin, size_t len, ostream* os) {
+  // The code
+  //   const char kFoo[] = "foo";
+  // generates an array of 4, not 3, elements, with the last one being '\0'.
+  //
+  // Therefore when printing a char array, we don't print the last element if
+  // it's '\0', such that the output matches the string literal as it's
+  // written in the source code.
+  if (len > 0 && begin[len - 1] == '\0') {
+    PrintCharsAsStringTo(begin, len - 1, os);
+    return;
+  }
+
+  // If, however, the last element in the array is not '\0', e.g.
+  //    const char kFoo[] = { 'f', 'o', 'o' };
+  // we must print the entire array.  We also print a message to indicate
+  // that the array is not NUL-terminated.
+  PrintCharsAsStringTo(begin, len, os);
+  *os << " (no terminating NUL)";
+}
+
+// Prints a (const) char array of 'len' elements, starting at address 'begin'.
+void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
+  UniversalPrintCharArray(begin, len, os);
+}
+
+#ifdef __cpp_char8_t
+// Prints a (const) char8_t array of 'len' elements, starting at address
+// 'begin'.
+void UniversalPrintArray(const char8_t* begin, size_t len, ostream* os) {
+  UniversalPrintCharArray(begin, len, os);
+}
+#endif
+
+// Prints a (const) char16_t array of 'len' elements, starting at address
+// 'begin'.
+void UniversalPrintArray(const char16_t* begin, size_t len, ostream* os) {
+  UniversalPrintCharArray(begin, len, os);
+}
+
+// Prints a (const) char32_t array of 'len' elements, starting at address
+// 'begin'.
+void UniversalPrintArray(const char32_t* begin, size_t len, ostream* os) {
+  UniversalPrintCharArray(begin, len, os);
+}
+
+// Prints a (const) wchar_t array of 'len' elements, starting at address
+// 'begin'.
+void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* os) {
+  UniversalPrintCharArray(begin, len, os);
+}
+
+namespace {
+
+// Prints a null-terminated C-style string to the ostream.
+template <typename Char>
+void PrintCStringTo(const Char* s, ostream* os) {
+  if (s == nullptr) {
+    *os << "NULL";
+  } else {
+    *os << ImplicitCast_<const void*>(s) << " pointing to ";
+    PrintCharsAsStringTo(s, std::char_traits<Char>::length(s), os);
+  }
+}
+
+}  // anonymous namespace
+
+void PrintTo(const char* s, ostream* os) { PrintCStringTo(s, os); }
+
+#ifdef __cpp_char8_t
+void PrintTo(const char8_t* s, ostream* os) { PrintCStringTo(s, os); }
+#endif
+
+void PrintTo(const char16_t* s, ostream* os) { PrintCStringTo(s, os); }
+
+void PrintTo(const char32_t* s, ostream* os) { PrintCStringTo(s, os); }
+
+// MSVC compiler can be configured to define whar_t as a typedef
+// of unsigned short. Defining an overload for const wchar_t* in that case
+// would cause pointers to unsigned shorts be printed as wide strings,
+// possibly accessing more memory than intended and causing invalid
+// memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when
+// wchar_t is implemented as a native type.
+#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)
+// Prints the given wide C string to the ostream.
+void PrintTo(const wchar_t* s, ostream* os) { PrintCStringTo(s, os); }
+#endif  // wchar_t is native
+
+namespace {
+
+bool ContainsUnprintableControlCodes(const char* str, size_t length) {
+  const unsigned char *s = reinterpret_cast<const unsigned char *>(str);
+
+  for (size_t i = 0; i < length; i++) {
+    unsigned char ch = *s++;
+    if (std::iscntrl(ch)) {
+        switch (ch) {
+        case '\t':
+        case '\n':
+        case '\r':
+          break;
+        default:
+          return true;
+        }
+      }
+  }
+  return false;
+}
+
+bool IsUTF8TrailByte(unsigned char t) { return 0x80 <= t && t<= 0xbf; }
+
+bool IsValidUTF8(const char* str, size_t length) {
+  const unsigned char *s = reinterpret_cast<const unsigned char *>(str);
+
+  for (size_t i = 0; i < length;) {
+    unsigned char lead = s[i++];
+
+    if (lead <= 0x7f) {
+      continue;  // single-byte character (ASCII) 0..7F
+    }
+    if (lead < 0xc2) {
+      return false;  // trail byte or non-shortest form
+    } else if (lead <= 0xdf && (i + 1) <= length && IsUTF8TrailByte(s[i])) {
+      ++i;  // 2-byte character
+    } else if (0xe0 <= lead && lead <= 0xef && (i + 2) <= length &&
+               IsUTF8TrailByte(s[i]) &&
+               IsUTF8TrailByte(s[i + 1]) &&
+               // check for non-shortest form and surrogate
+               (lead != 0xe0 || s[i] >= 0xa0) &&
+               (lead != 0xed || s[i] < 0xa0)) {
+      i += 2;  // 3-byte character
+    } else if (0xf0 <= lead && lead <= 0xf4 && (i + 3) <= length &&
+               IsUTF8TrailByte(s[i]) &&
+               IsUTF8TrailByte(s[i + 1]) &&
+               IsUTF8TrailByte(s[i + 2]) &&
+               // check for non-shortest form
+               (lead != 0xf0 || s[i] >= 0x90) &&
+               (lead != 0xf4 || s[i] < 0x90)) {
+      i += 3;  // 4-byte character
+    } else {
+      return false;
+    }
+  }
+  return true;
+}
+
+void ConditionalPrintAsText(const char* str, size_t length, ostream* os) {
+  if (!ContainsUnprintableControlCodes(str, length) &&
+      IsValidUTF8(str, length)) {
+    *os << "\n    As Text: \"" << str << "\"";
+  }
+}
+
+}  // anonymous namespace
+
+void PrintStringTo(const ::std::string& s, ostream* os) {
+  if (PrintCharsAsStringTo(s.data(), s.size(), os) == kHexEscape) {
+    if (GTEST_FLAG(print_utf8)) {
+      ConditionalPrintAsText(s.data(), s.size(), os);
+    }
+  }
+}
+
+#ifdef __cpp_char8_t
+void PrintU8StringTo(const ::std::u8string& s, ostream* os) {
+  PrintCharsAsStringTo(s.data(), s.size(), os);
+}
+#endif
+
+void PrintU16StringTo(const ::std::u16string& s, ostream* os) {
+  PrintCharsAsStringTo(s.data(), s.size(), os);
+}
+
+void PrintU32StringTo(const ::std::u32string& s, ostream* os) {
+  PrintCharsAsStringTo(s.data(), s.size(), os);
+}
+
+#if GTEST_HAS_STD_WSTRING
+void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
+  PrintCharsAsStringTo(s.data(), s.size(), os);
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+}  // namespace internal
+
+}  // namespace testing
diff --git a/trunk/3rdparty/gtest-fit/googletest/src/gtest-test-part.cc b/trunk/3rdparty/gtest-fit/googletest/src/gtest-test-part.cc
new file mode 100644
index 000000000..a938683ce
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/src/gtest-test-part.cc
@@ -0,0 +1,108 @@
+// Copyright 2008, 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.
+
+//
+// The Google C++ Testing and Mocking Framework (Google Test)
+
+#include "gtest/gtest-test-part.h"
+
+#include "gtest/internal/gtest-port.h"
+#include "src/gtest-internal-inl.h"
+
+namespace testing {
+
+using internal::GetUnitTestImpl;
+
+// Gets the summary of the failure message by omitting the stack trace
+// in it.
+std::string TestPartResult::ExtractSummary(const char* message) {
+  const char* const stack_trace = strstr(message, internal::kStackTraceMarker);
+  return stack_trace == nullptr ? message : std::string(message, stack_trace);
+}
+
+// Prints a TestPartResult object.
+std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
+  return os << internal::FormatFileLocation(result.file_name(),
+                                            result.line_number())
+            << " "
+            << (result.type() == TestPartResult::kSuccess
+                    ? "Success"
+                    : result.type() == TestPartResult::kSkip
+                          ? "Skipped"
+                          : result.type() == TestPartResult::kFatalFailure
+                                ? "Fatal failure"
+                                : "Non-fatal failure")
+            << ":\n"
+            << result.message() << std::endl;
+}
+
+// Appends a TestPartResult to the array.
+void TestPartResultArray::Append(const TestPartResult& result) {
+  array_.push_back(result);
+}
+
+// Returns the TestPartResult at the given index (0-based).
+const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
+  if (index < 0 || index >= size()) {
+    printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
+    internal::posix::Abort();
+  }
+
+  return array_[static_cast<size_t>(index)];
+}
+
+// Returns the number of TestPartResult objects in the array.
+int TestPartResultArray::size() const {
+  return static_cast<int>(array_.size());
+}
+
+namespace internal {
+
+HasNewFatalFailureHelper::HasNewFatalFailureHelper()
+    : has_new_fatal_failure_(false),
+      original_reporter_(GetUnitTestImpl()->
+                         GetTestPartResultReporterForCurrentThread()) {
+  GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(this);
+}
+
+HasNewFatalFailureHelper::~HasNewFatalFailureHelper() {
+  GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(
+      original_reporter_);
+}
+
+void HasNewFatalFailureHelper::ReportTestPartResult(
+    const TestPartResult& result) {
+  if (result.fatally_failed())
+    has_new_fatal_failure_ = true;
+  original_reporter_->ReportTestPartResult(result);
+}
+
+}  // namespace internal
+
+}  // namespace testing
diff --git a/trunk/3rdparty/gtest-fit/googletest/src/gtest-typed-test.cc b/trunk/3rdparty/gtest-fit/googletest/src/gtest-typed-test.cc
new file mode 100644
index 000000000..c02c3df65
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/src/gtest-typed-test.cc
@@ -0,0 +1,107 @@
+// Copyright 2008 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.
+
+
+#include "gtest/gtest-typed-test.h"
+
+#include "gtest/gtest.h"
+
+namespace testing {
+namespace internal {
+
+// Skips to the first non-space char in str. Returns an empty string if str
+// contains only whitespace characters.
+static const char* SkipSpaces(const char* str) {
+  while (IsSpace(*str))
+    str++;
+  return str;
+}
+
+static std::vector<std::string> SplitIntoTestNames(const char* src) {
+  std::vector<std::string> name_vec;
+  src = SkipSpaces(src);
+  for (; src != nullptr; src = SkipComma(src)) {
+    name_vec.push_back(StripTrailingSpaces(GetPrefixUntilComma(src)));
+  }
+  return name_vec;
+}
+
+// Verifies that registered_tests match the test names in
+// registered_tests_; returns registered_tests if successful, or
+// aborts the program otherwise.
+const char* TypedTestSuitePState::VerifyRegisteredTestNames(
+    const char* test_suite_name, const char* file, int line,
+    const char* registered_tests) {
+  RegisterTypeParameterizedTestSuite(test_suite_name, CodeLocation(file, line));
+
+  typedef RegisteredTestsMap::const_iterator RegisteredTestIter;
+  registered_ = true;
+
+  std::vector<std::string> name_vec = SplitIntoTestNames(registered_tests);
+
+  Message errors;
+
+  std::set<std::string> tests;
+  for (std::vector<std::string>::const_iterator name_it = name_vec.begin();
+       name_it != name_vec.end(); ++name_it) {
+    const std::string& name = *name_it;
+    if (tests.count(name) != 0) {
+      errors << "Test " << name << " is listed more than once.\n";
+      continue;
+    }
+
+    if (registered_tests_.count(name) != 0) {
+      tests.insert(name);
+    } else {
+      errors << "No test named " << name
+             << " can be found in this test suite.\n";
+    }
+  }
+
+  for (RegisteredTestIter it = registered_tests_.begin();
+       it != registered_tests_.end();
+       ++it) {
+    if (tests.count(it->first) == 0) {
+      errors << "You forgot to list test " << it->first << ".\n";
+    }
+  }
+
+  const std::string& errors_str = errors.GetString();
+  if (errors_str != "") {
+    fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(),
+            errors_str.c_str());
+    fflush(stderr);
+    posix::Abort();
+  }
+
+  return registered_tests;
+}
+
+}  // namespace internal
+}  // namespace testing
diff --git a/trunk/3rdparty/gtest-fit/googletest/src/gtest.cc b/trunk/3rdparty/gtest-fit/googletest/src/gtest.cc
new file mode 100644
index 000000000..21c611aff
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/src/gtest.cc
@@ -0,0 +1,6746 @@
+// Copyright 2005, 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.
+
+//
+// The Google C++ Testing and Mocking Framework (Google Test)
+
+#include "gtest/gtest.h"
+#include "gtest/internal/custom/gtest.h"
+#include "gtest/gtest-spi.h"
+
+#include <ctype.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <wchar.h>
+#include <wctype.h>
+
+#include <algorithm>
+#include <chrono>  // NOLINT
+#include <cmath>
+#include <cstdint>
+#include <iomanip>
+#include <limits>
+#include <list>
+#include <map>
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <vector>
+
+#if GTEST_OS_LINUX
+
+# include <fcntl.h>  // NOLINT
+# include <limits.h>  // NOLINT
+# include <sched.h>  // NOLINT
+// Declares vsnprintf().  This header is not available on Windows.
+# include <strings.h>  // NOLINT
+# include <sys/mman.h>  // NOLINT
+# include <sys/time.h>  // NOLINT
+# include <unistd.h>  // NOLINT
+# include <string>
+
+#elif GTEST_OS_ZOS
+# include <sys/time.h>  // NOLINT
+
+// On z/OS we additionally need strings.h for strcasecmp.
+# include <strings.h>  // NOLINT
+
+#elif GTEST_OS_WINDOWS_MOBILE  // We are on Windows CE.
+
+# include <windows.h>  // NOLINT
+# undef min
+
+#elif GTEST_OS_WINDOWS  // We are on Windows proper.
+
+# include <windows.h>  // NOLINT
+# undef min
+
+#ifdef _MSC_VER
+# include <crtdbg.h>  // NOLINT
+#endif
+
+# include <io.h>  // NOLINT
+# include <sys/timeb.h>  // NOLINT
+# include <sys/types.h>  // NOLINT
+# include <sys/stat.h>  // NOLINT
+
+# if GTEST_OS_WINDOWS_MINGW
+#  include <sys/time.h>  // NOLINT
+# endif  // GTEST_OS_WINDOWS_MINGW
+
+#else
+
+// cpplint thinks that the header is already included, so we want to
+// silence it.
+# include <sys/time.h>  // NOLINT
+# include <unistd.h>  // NOLINT
+
+#endif  // GTEST_OS_LINUX
+
+#if GTEST_HAS_EXCEPTIONS
+# include <stdexcept>
+#endif
+
+#if GTEST_CAN_STREAM_RESULTS_
+# include <arpa/inet.h>  // NOLINT
+# include <netdb.h>  // NOLINT
+# include <sys/socket.h>  // NOLINT
+# include <sys/types.h>  // NOLINT
+#endif
+
+#include "src/gtest-internal-inl.h"
+
+#if GTEST_OS_WINDOWS
+# define vsnprintf _vsnprintf
+#endif  // GTEST_OS_WINDOWS
+
+#if GTEST_OS_MAC
+#ifndef GTEST_OS_IOS
+#include <crt_externs.h>
+#endif
+#endif
+
+#if GTEST_HAS_ABSL
+#include "absl/debugging/failure_signal_handler.h"
+#include "absl/debugging/stacktrace.h"
+#include "absl/debugging/symbolize.h"
+#include "absl/strings/str_cat.h"
+#endif  // GTEST_HAS_ABSL
+
+namespace testing {
+
+using internal::CountIf;
+using internal::ForEach;
+using internal::GetElementOr;
+using internal::Shuffle;
+
+// Constants.
+
+// A test whose test suite name or test name matches this filter is
+// disabled and not run.
+static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*";
+
+// A test suite whose name matches this filter is considered a death
+// test suite and will be run before test suites whose name doesn't
+// match this filter.
+static const char kDeathTestSuiteFilter[] = "*DeathTest:*DeathTest/*";
+
+// A test filter that matches everything.
+static const char kUniversalFilter[] = "*";
+
+// The default output format.
+static const char kDefaultOutputFormat[] = "xml";
+// The default output file.
+static const char kDefaultOutputFile[] = "test_detail";
+
+// The environment variable name for the test shard index.
+static const char kTestShardIndex[] = "GTEST_SHARD_INDEX";
+// The environment variable name for the total number of test shards.
+static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS";
+// The environment variable name for the test shard status file.
+static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE";
+
+namespace internal {
+
+// The text used in failure messages to indicate the start of the
+// stack trace.
+const char kStackTraceMarker[] = "\nStack trace:\n";
+
+// g_help_flag is true if and only if the --help flag or an equivalent form
+// is specified on the command line.
+bool g_help_flag = false;
+
+// Utilty function to Open File for Writing
+static FILE* OpenFileForWriting(const std::string& output_file) {
+  FILE* fileout = nullptr;
+  FilePath output_file_path(output_file);
+  FilePath output_dir(output_file_path.RemoveFileName());
+
+  if (output_dir.CreateDirectoriesRecursively()) {
+    fileout = posix::FOpen(output_file.c_str(), "w");
+  }
+  if (fileout == nullptr) {
+    GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file << "\"";
+  }
+  return fileout;
+}
+
+}  // namespace internal
+
+// Bazel passes in the argument to '--test_filter' via the TESTBRIDGE_TEST_ONLY
+// environment variable.
+static const char* GetDefaultFilter() {
+  const char* const testbridge_test_only =
+      internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY");
+  if (testbridge_test_only != nullptr) {
+    return testbridge_test_only;
+  }
+  return kUniversalFilter;
+}
+
+// Bazel passes in the argument to '--test_runner_fail_fast' via the
+// TESTBRIDGE_TEST_RUNNER_FAIL_FAST environment variable.
+static bool GetDefaultFailFast() {
+  const char* const testbridge_test_runner_fail_fast =
+      internal::posix::GetEnv("TESTBRIDGE_TEST_RUNNER_FAIL_FAST");
+  if (testbridge_test_runner_fail_fast != nullptr) {
+    return strcmp(testbridge_test_runner_fail_fast, "1") == 0;
+  }
+  return false;
+}
+
+GTEST_DEFINE_bool_(
+    fail_fast, internal::BoolFromGTestEnv("fail_fast", GetDefaultFailFast()),
+    "True if and only if a test failure should stop further test execution.");
+
+GTEST_DEFINE_bool_(
+    also_run_disabled_tests,
+    internal::BoolFromGTestEnv("also_run_disabled_tests", false),
+    "Run disabled tests too, in addition to the tests normally being run.");
+
+GTEST_DEFINE_bool_(
+    break_on_failure, internal::BoolFromGTestEnv("break_on_failure", false),
+    "True if and only if a failed assertion should be a debugger "
+    "break-point.");
+
+GTEST_DEFINE_bool_(catch_exceptions,
+                   internal::BoolFromGTestEnv("catch_exceptions", true),
+                   "True if and only if " GTEST_NAME_
+                   " should catch exceptions and treat them as test failures.");
+
+GTEST_DEFINE_string_(
+    color,
+    internal::StringFromGTestEnv("color", "auto"),
+    "Whether to use colors in the output.  Valid values: yes, no, "
+    "and auto.  'auto' means to use colors if the output is "
+    "being sent to a terminal and the TERM environment variable "
+    "is set to a terminal type that supports colors.");
+
+GTEST_DEFINE_string_(
+    filter,
+    internal::StringFromGTestEnv("filter", GetDefaultFilter()),
+    "A colon-separated list of glob (not regex) patterns "
+    "for filtering the tests to run, optionally followed by a "
+    "'-' and a : separated list of negative patterns (tests to "
+    "exclude).  A test is run if it matches one of the positive "
+    "patterns and does not match any of the negative patterns.");
+
+GTEST_DEFINE_bool_(
+    install_failure_signal_handler,
+    internal::BoolFromGTestEnv("install_failure_signal_handler", false),
+    "If true and supported on the current platform, " GTEST_NAME_ " should "
+    "install a signal handler that dumps debugging information when fatal "
+    "signals are raised.");
+
+GTEST_DEFINE_bool_(list_tests, false,
+                   "List all tests without running them.");
+
+// The net priority order after flag processing is thus:
+//   --gtest_output command line flag
+//   GTEST_OUTPUT environment variable
+//   XML_OUTPUT_FILE environment variable
+//   ''
+GTEST_DEFINE_string_(
+    output,
+    internal::StringFromGTestEnv("output",
+      internal::OutputFlagAlsoCheckEnvVar().c_str()),
+    "A format (defaults to \"xml\" but can be specified to be \"json\"), "
+    "optionally followed by a colon and an output file name or directory. "
+    "A directory is indicated by a trailing pathname separator. "
+    "Examples: \"xml:filename.xml\", \"xml::directoryname/\". "
+    "If a directory is specified, output files will be created "
+    "within that directory, with file-names based on the test "
+    "executable's name and, if necessary, made unique by adding "
+    "digits.");
+
+GTEST_DEFINE_bool_(
+    brief, internal::BoolFromGTestEnv("brief", false),
+    "True if only test failures should be displayed in text output.");
+
+GTEST_DEFINE_bool_(print_time, internal::BoolFromGTestEnv("print_time", true),
+                   "True if and only if " GTEST_NAME_
+                   " should display elapsed time in text output.");
+
+GTEST_DEFINE_bool_(print_utf8, internal::BoolFromGTestEnv("print_utf8", true),
+                   "True if and only if " GTEST_NAME_
+                   " prints UTF8 characters as text.");
+
+GTEST_DEFINE_int32_(
+    random_seed,
+    internal::Int32FromGTestEnv("random_seed", 0),
+    "Random number seed to use when shuffling test orders.  Must be in range "
+    "[1, 99999], or 0 to use a seed based on the current time.");
+
+GTEST_DEFINE_int32_(
+    repeat,
+    internal::Int32FromGTestEnv("repeat", 1),
+    "How many times to repeat each test.  Specify a negative number "
+    "for repeating forever.  Useful for shaking out flaky tests.");
+
+GTEST_DEFINE_bool_(show_internal_stack_frames, false,
+                   "True if and only if " GTEST_NAME_
+                   " should include internal stack frames when "
+                   "printing test failure stack traces.");
+
+GTEST_DEFINE_bool_(shuffle, internal::BoolFromGTestEnv("shuffle", false),
+                   "True if and only if " GTEST_NAME_
+                   " should randomize tests' order on every run.");
+
+GTEST_DEFINE_int32_(
+    stack_trace_depth,
+    internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth),
+    "The maximum number of stack frames to print when an "
+    "assertion fails.  The valid range is 0 through 100, inclusive.");
+
+GTEST_DEFINE_string_(
+    stream_result_to,
+    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.");
+
+GTEST_DEFINE_bool_(
+    throw_on_failure,
+    internal::BoolFromGTestEnv("throw_on_failure", false),
+    "When this flag is specified, a failed assertion will throw an exception "
+    "if exceptions are enabled or exit the program with a non-zero code "
+    "otherwise. For use with an external test framework.");
+
+#if GTEST_USE_OWN_FLAGFILE_FLAG_
+GTEST_DEFINE_string_(
+    flagfile,
+    internal::StringFromGTestEnv("flagfile", ""),
+    "This flag specifies the flagfile to read command-line flags from.");
+#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
+
+namespace internal {
+
+// Generates a random number from [0, range), using a Linear
+// Congruential Generator (LCG).  Crashes if 'range' is 0 or greater
+// than kMaxRange.
+uint32_t Random::Generate(uint32_t range) {
+  // These constants are the same as are used in glibc's rand(3).
+  // Use wider types than necessary to prevent unsigned overflow diagnostics.
+  state_ = static_cast<uint32_t>(1103515245ULL*state_ + 12345U) % kMaxRange;
+
+  GTEST_CHECK_(range > 0)
+      << "Cannot generate a number in the range [0, 0).";
+  GTEST_CHECK_(range <= kMaxRange)
+      << "Generation of a number in [0, " << range << ") was requested, "
+      << "but this can only generate numbers in [0, " << kMaxRange << ").";
+
+  // Converting via modulus introduces a bit of downward bias, but
+  // it's simple, and a linear congruential generator isn't too good
+  // to begin with.
+  return state_ % range;
+}
+
+// GTestIsInitialized() returns true if and only if the user has initialized
+// Google Test.  Useful for catching the user mistake of not initializing
+// Google Test before calling RUN_ALL_TESTS().
+static bool GTestIsInitialized() { return GetArgvs().size() > 0; }
+
+// Iterates over a vector of TestSuites, keeping a running sum of the
+// results of calling a given int-returning method on each.
+// Returns the sum.
+static int SumOverTestSuiteList(const std::vector<TestSuite*>& case_list,
+                                int (TestSuite::*method)() const) {
+  int sum = 0;
+  for (size_t i = 0; i < case_list.size(); i++) {
+    sum += (case_list[i]->*method)();
+  }
+  return sum;
+}
+
+// Returns true if and only if the test suite passed.
+static bool TestSuitePassed(const TestSuite* test_suite) {
+  return test_suite->should_run() && test_suite->Passed();
+}
+
+// Returns true if and only if the test suite failed.
+static bool TestSuiteFailed(const TestSuite* test_suite) {
+  return test_suite->should_run() && test_suite->Failed();
+}
+
+// Returns true if and only if test_suite contains at least one test that
+// should run.
+static bool ShouldRunTestSuite(const TestSuite* test_suite) {
+  return test_suite->should_run();
+}
+
+// AssertHelper constructor.
+AssertHelper::AssertHelper(TestPartResult::Type type,
+                           const char* file,
+                           int line,
+                           const char* message)
+    : data_(new AssertHelperData(type, file, line, message)) {
+}
+
+AssertHelper::~AssertHelper() {
+  delete data_;
+}
+
+// Message assignment, for assertion streaming support.
+void AssertHelper::operator=(const Message& message) const {
+  UnitTest::GetInstance()->
+    AddTestPartResult(data_->type, data_->file, data_->line,
+                      AppendUserMessage(data_->message, message),
+                      UnitTest::GetInstance()->impl()
+                      ->CurrentOsStackTraceExceptTop(1)
+                      // Skips the stack frame for this function itself.
+                      );  // NOLINT
+}
+
+namespace {
+
+// When TEST_P is found without a matching INSTANTIATE_TEST_SUITE_P
+// to creates test cases for it, a syntetic test case is
+// inserted to report ether an error or a log message.
+//
+// This configuration bit will likely be removed at some point.
+constexpr bool kErrorOnUninstantiatedParameterizedTest = true;
+constexpr bool kErrorOnUninstantiatedTypeParameterizedTest = true;
+
+// A test that fails at a given file/line location with a given message.
+class FailureTest : public Test {
+ public:
+  explicit FailureTest(const CodeLocation& loc, std::string error_message,
+                       bool as_error)
+      : loc_(loc),
+        error_message_(std::move(error_message)),
+        as_error_(as_error) {}
+
+  void TestBody() override {
+    if (as_error_) {
+      AssertHelper(TestPartResult::kNonFatalFailure, loc_.file.c_str(),
+                   loc_.line, "") = Message() << error_message_;
+    } else {
+      std::cout << error_message_ << std::endl;
+    }
+  }
+
+ private:
+  const CodeLocation loc_;
+  const std::string error_message_;
+  const bool as_error_;
+};
+
+
+}  // namespace
+
+std::set<std::string>* GetIgnoredParameterizedTestSuites() {
+  return UnitTest::GetInstance()->impl()->ignored_parameterized_test_suites();
+}
+
+// Add a given test_suit to the list of them allow to go un-instantiated.
+MarkAsIgnored::MarkAsIgnored(const char* test_suite) {
+  GetIgnoredParameterizedTestSuites()->insert(test_suite);
+}
+
+// If this parameterized test suite has no instantiations (and that
+// has not been marked as okay), emit a test case reporting that.
+void InsertSyntheticTestCase(const std::string& name, CodeLocation location,
+                             bool has_test_p) {
+  const auto& ignored = *GetIgnoredParameterizedTestSuites();
+  if (ignored.find(name) != ignored.end()) return;
+
+  const char kMissingInstantiation[] =  //
+      " 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"
+      "Ideally, 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 utilities.)";
+
+  const char kMissingTestCase[] =  //
+      " is instantiated via INSTANTIATE_TEST_SUITE_P, but no tests are "
+      "defined via TEST_P . No test cases will run."
+      "\n\n"
+      "Ideally, INSTANTIATE_TEST_SUITE_P should only ever be invoked from "
+      "code that always depend on code that provides TEST_P. Failing to do "
+      "so is often an indication of dead code, e.g. the last TEST_P was "
+      "removed but the rest got left behind.";
+
+  std::string message =
+      "Parameterized test suite " + name +
+      (has_test_p ? kMissingInstantiation : kMissingTestCase) +
+      "\n\n"
+      "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(" + name + ");";
+
+  std::string full_name = "UninstantiatedParameterizedTestSuite<" + name + ">";
+  RegisterTest(  //
+      "GoogleTestVerification", full_name.c_str(),
+      nullptr,  // No type parameter.
+      nullptr,  // No value parameter.
+      location.file.c_str(), location.line, [message, location] {
+        return new FailureTest(location, message,
+                               kErrorOnUninstantiatedParameterizedTest);
+      });
+}
+
+void RegisterTypeParameterizedTestSuite(const char* test_suite_name,
+                                        CodeLocation code_location) {
+  GetUnitTestImpl()->type_parameterized_test_registry().RegisterTestSuite(
+      test_suite_name, code_location);
+}
+
+void RegisterTypeParameterizedTestSuiteInstantiation(const char* case_name) {
+  GetUnitTestImpl()
+      ->type_parameterized_test_registry()
+      .RegisterInstantiation(case_name);
+}
+
+void TypeParameterizedTestSuiteRegistry::RegisterTestSuite(
+    const char* test_suite_name, CodeLocation code_location) {
+  suites_.emplace(std::string(test_suite_name),
+                 TypeParameterizedTestSuiteInfo(code_location));
+}
+
+void TypeParameterizedTestSuiteRegistry::RegisterInstantiation(
+        const char* test_suite_name) {
+  auto it = suites_.find(std::string(test_suite_name));
+  if (it != suites_.end()) {
+    it->second.instantiated = true;
+  } else {
+    GTEST_LOG_(ERROR) << "Unknown type parameterized test suit '"
+                      << test_suite_name << "'";
+  }
+}
+
+void TypeParameterizedTestSuiteRegistry::CheckForInstantiations() {
+  const auto& ignored = *GetIgnoredParameterizedTestSuites();
+  for (const auto& testcase : suites_) {
+    if (testcase.second.instantiated) continue;
+    if (ignored.find(testcase.first) != ignored.end()) continue;
+
+    std::string message =
+        "Type parameterized test suite " + testcase.first +
+        " is defined via REGISTER_TYPED_TEST_SUITE_P, but never instantiated "
+        "via INSTANTIATE_TYPED_TEST_SUITE_P. None of the test cases will run."
+        "\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 "
+        "utilities.)"
+        "\n\n"
+        "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(" +
+        testcase.first + ");";
+
+    std::string full_name =
+        "UninstantiatedTypeParameterizedTestSuite<" + testcase.first + ">";
+    RegisterTest(  //
+        "GoogleTestVerification", full_name.c_str(),
+        nullptr,  // No type parameter.
+        nullptr,  // No value parameter.
+        testcase.second.code_location.file.c_str(),
+        testcase.second.code_location.line, [message, testcase] {
+          return new FailureTest(testcase.second.code_location, message,
+                                 kErrorOnUninstantiatedTypeParameterizedTest);
+        });
+  }
+}
+
+// A copy of all command line arguments.  Set by InitGoogleTest().
+static ::std::vector<std::string> g_argvs;
+
+::std::vector<std::string> GetArgvs() {
+#if defined(GTEST_CUSTOM_GET_ARGVS_)
+  // GTEST_CUSTOM_GET_ARGVS_() may return a container of std::string or
+  // ::string. This code converts it to the appropriate type.
+  const auto& custom = GTEST_CUSTOM_GET_ARGVS_();
+  return ::std::vector<std::string>(custom.begin(), custom.end());
+#else   // defined(GTEST_CUSTOM_GET_ARGVS_)
+  return g_argvs;
+#endif  // defined(GTEST_CUSTOM_GET_ARGVS_)
+}
+
+// Returns the current application's name, removing directory path if that
+// is present.
+FilePath GetCurrentExecutableName() {
+  FilePath result;
+
+#if GTEST_OS_WINDOWS || GTEST_OS_OS2
+  result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
+#else
+  result.Set(FilePath(GetArgvs()[0]));
+#endif  // GTEST_OS_WINDOWS
+
+  return result.RemoveDirectoryName();
+}
+
+// Functions for processing the gtest_output flag.
+
+// Returns the output format, or "" for normal printed output.
+std::string UnitTestOptions::GetOutputFormat() {
+  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
+  const char* const colon = strchr(gtest_output_flag, ':');
+  return (colon == nullptr)
+             ? std::string(gtest_output_flag)
+             : std::string(gtest_output_flag,
+                           static_cast<size_t>(colon - gtest_output_flag));
+}
+
+// Returns the name of the requested output file, or the default if none
+// was explicitly specified.
+std::string UnitTestOptions::GetAbsolutePathToOutputFile() {
+  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
+
+  std::string format = GetOutputFormat();
+  if (format.empty())
+    format = std::string(kDefaultOutputFormat);
+
+  const char* const colon = strchr(gtest_output_flag, ':');
+  if (colon == nullptr)
+    return internal::FilePath::MakeFileName(
+        internal::FilePath(
+            UnitTest::GetInstance()->original_working_dir()),
+        internal::FilePath(kDefaultOutputFile), 0,
+        format.c_str()).string();
+
+  internal::FilePath output_name(colon + 1);
+  if (!output_name.IsAbsolutePath())
+    output_name = internal::FilePath::ConcatPaths(
+        internal::FilePath(UnitTest::GetInstance()->original_working_dir()),
+        internal::FilePath(colon + 1));
+
+  if (!output_name.IsDirectory())
+    return output_name.string();
+
+  internal::FilePath result(internal::FilePath::GenerateUniqueFileName(
+      output_name, internal::GetCurrentExecutableName(),
+      GetOutputFormat().c_str()));
+  return result.string();
+}
+
+// Returns true if and only if the wildcard pattern matches the string. Each
+// pattern consists of regular characters, single-character wildcards (?), and
+// multi-character wildcards (*).
+//
+// This function implements a linear-time string globbing algorithm based on
+// https://research.swtch.com/glob.
+static bool PatternMatchesString(const std::string& name_str,
+                                 const char* pattern, const char* pattern_end) {
+  const char* name = name_str.c_str();
+  const char* const name_begin = name;
+  const char* const name_end = name + name_str.size();
+
+  const char* pattern_next = pattern;
+  const char* name_next = name;
+
+  while (pattern < pattern_end || name < name_end) {
+    if (pattern < pattern_end) {
+      switch (*pattern) {
+        default:  // Match an ordinary character.
+          if (name < name_end && *name == *pattern) {
+            ++pattern;
+            ++name;
+            continue;
+          }
+          break;
+        case '?':  // Match any single character.
+          if (name < name_end) {
+            ++pattern;
+            ++name;
+            continue;
+          }
+          break;
+        case '*':
+          // Match zero or more characters. Start by skipping over the wildcard
+          // and matching zero characters from name. If that fails, restart and
+          // match one more character than the last attempt.
+          pattern_next = pattern;
+          name_next = name + 1;
+          ++pattern;
+          continue;
+      }
+    }
+    // Failed to match a character. Restart if possible.
+    if (name_begin < name_next && name_next <= name_end) {
+      pattern = pattern_next;
+      name = name_next;
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+
+bool UnitTestOptions::MatchesFilter(const std::string& name_str,
+                                    const char* filter) {
+  // The filter is a list of patterns separated by colons (:).
+  const char* pattern = filter;
+  while (true) {
+    // Find the bounds of this pattern.
+    const char* const next_sep = strchr(pattern, ':');
+    const char* const pattern_end =
+        next_sep != nullptr ? next_sep : pattern + strlen(pattern);
+
+    // Check if this pattern matches name_str.
+    if (PatternMatchesString(name_str, pattern, pattern_end)) {
+      return true;
+    }
+
+    // Give up on this pattern. However, if we found a pattern separator (:),
+    // advance to the next pattern (skipping over the separator) and restart.
+    if (next_sep == nullptr) {
+      return false;
+    }
+    pattern = next_sep + 1;
+  }
+  return true;
+}
+
+// Returns true if and only if the user-specified filter matches the test
+// suite name and the test name.
+bool UnitTestOptions::FilterMatchesTest(const std::string& test_suite_name,
+                                        const std::string& test_name) {
+  const std::string& full_name = test_suite_name + "." + test_name.c_str();
+
+  // Split --gtest_filter at '-', if there is one, to separate into
+  // positive filter and negative filter portions
+  const char* const p = GTEST_FLAG(filter).c_str();
+  const char* const dash = strchr(p, '-');
+  std::string positive;
+  std::string negative;
+  if (dash == nullptr) {
+    positive = GTEST_FLAG(filter).c_str();  // Whole string is a positive filter
+    negative = "";
+  } else {
+    positive = std::string(p, dash);   // Everything up to the dash
+    negative = std::string(dash + 1);  // Everything after the dash
+    if (positive.empty()) {
+      // Treat '-test1' as the same as '*-test1'
+      positive = kUniversalFilter;
+    }
+  }
+
+  // A filter is a colon-separated list of patterns.  It matches a
+  // test if any pattern in it matches the test.
+  return (MatchesFilter(full_name, positive.c_str()) &&
+          !MatchesFilter(full_name, negative.c_str()));
+}
+
+#if GTEST_HAS_SEH
+// Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the
+// given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise.
+// This function is useful as an __except condition.
+int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) {
+  // Google Test should handle a SEH exception if:
+  //   1. the user wants it to, AND
+  //   2. this is not a breakpoint exception, AND
+  //   3. this is not a C++ exception (VC++ implements them via SEH,
+  //      apparently).
+  //
+  // SEH exception code for C++ exceptions.
+  // (see http://support.microsoft.com/kb/185294 for more information).
+  const DWORD kCxxExceptionCode = 0xe06d7363;
+
+  bool should_handle = true;
+
+  if (!GTEST_FLAG(catch_exceptions))
+    should_handle = false;
+  else if (exception_code == EXCEPTION_BREAKPOINT)
+    should_handle = false;
+  else if (exception_code == kCxxExceptionCode)
+    should_handle = false;
+
+  return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
+}
+#endif  // GTEST_HAS_SEH
+
+}  // namespace internal
+
+// The c'tor sets this object as the test part result reporter used by
+// Google Test.  The 'result' parameter specifies where to report the
+// results. Intercepts only failures from the current thread.
+ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
+    TestPartResultArray* result)
+    : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD),
+      result_(result) {
+  Init();
+}
+
+// The c'tor sets this object as the test part result reporter used by
+// Google Test.  The 'result' parameter specifies where to report the
+// results.
+ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter(
+    InterceptMode intercept_mode, TestPartResultArray* result)
+    : intercept_mode_(intercept_mode),
+      result_(result) {
+  Init();
+}
+
+void ScopedFakeTestPartResultReporter::Init() {
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
+    old_reporter_ = impl->GetGlobalTestPartResultReporter();
+    impl->SetGlobalTestPartResultReporter(this);
+  } else {
+    old_reporter_ = impl->GetTestPartResultReporterForCurrentThread();
+    impl->SetTestPartResultReporterForCurrentThread(this);
+  }
+}
+
+// The d'tor restores the test part result reporter used by Google Test
+// before.
+ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
+    impl->SetGlobalTestPartResultReporter(old_reporter_);
+  } else {
+    impl->SetTestPartResultReporterForCurrentThread(old_reporter_);
+  }
+}
+
+// Increments the test part result count and remembers the result.
+// This method is from the TestPartResultReporterInterface interface.
+void ScopedFakeTestPartResultReporter::ReportTestPartResult(
+    const TestPartResult& result) {
+  result_->Append(result);
+}
+
+namespace internal {
+
+// Returns the type ID of ::testing::Test.  We should always call this
+// instead of GetTypeId< ::testing::Test>() to get the type ID of
+// testing::Test.  This is to work around a suspected linker bug when
+// using Google Test as a framework on Mac OS X.  The bug causes
+// GetTypeId< ::testing::Test>() to return different values depending
+// on whether the call is from the Google Test framework itself or
+// from user test code.  GetTestTypeId() is guaranteed to always
+// return the same value, as it always calls GetTypeId<>() from the
+// gtest.cc, which is within the Google Test framework.
+TypeId GetTestTypeId() {
+  return GetTypeId<Test>();
+}
+
+// The value of GetTestTypeId() as seen from within the Google Test
+// library.  This is solely for testing GetTestTypeId().
+extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId();
+
+// This predicate-formatter checks that 'results' contains a test part
+// failure of the given type and that the failure message contains the
+// given substring.
+static AssertionResult HasOneFailure(const char* /* results_expr */,
+                                     const char* /* type_expr */,
+                                     const char* /* substr_expr */,
+                                     const TestPartResultArray& results,
+                                     TestPartResult::Type type,
+                                     const std::string& substr) {
+  const std::string expected(type == TestPartResult::kFatalFailure ?
+                        "1 fatal failure" :
+                        "1 non-fatal failure");
+  Message msg;
+  if (results.size() != 1) {
+    msg << "Expected: " << expected << "\n"
+        << "  Actual: " << results.size() << " failures";
+    for (int i = 0; i < results.size(); i++) {
+      msg << "\n" << results.GetTestPartResult(i);
+    }
+    return AssertionFailure() << msg;
+  }
+
+  const TestPartResult& r = results.GetTestPartResult(0);
+  if (r.type() != type) {
+    return AssertionFailure() << "Expected: " << expected << "\n"
+                              << "  Actual:\n"
+                              << r;
+  }
+
+  if (strstr(r.message(), substr.c_str()) == nullptr) {
+    return AssertionFailure() << "Expected: " << expected << " containing \""
+                              << substr << "\"\n"
+                              << "  Actual:\n"
+                              << r;
+  }
+
+  return AssertionSuccess();
+}
+
+// The constructor of SingleFailureChecker remembers where to look up
+// test part results, what type of failure we expect, and what
+// substring the failure message should contain.
+SingleFailureChecker::SingleFailureChecker(const TestPartResultArray* results,
+                                           TestPartResult::Type type,
+                                           const std::string& substr)
+    : results_(results), type_(type), substr_(substr) {}
+
+// The destructor of SingleFailureChecker verifies that the given
+// TestPartResultArray contains exactly one failure that has the given
+// type and contains the given substring.  If that's not the case, a
+// non-fatal failure will be generated.
+SingleFailureChecker::~SingleFailureChecker() {
+  EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_);
+}
+
+DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter(
+    UnitTestImpl* unit_test) : unit_test_(unit_test) {}
+
+void DefaultGlobalTestPartResultReporter::ReportTestPartResult(
+    const TestPartResult& result) {
+  unit_test_->current_test_result()->AddTestPartResult(result);
+  unit_test_->listeners()->repeater()->OnTestPartResult(result);
+}
+
+DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter(
+    UnitTestImpl* unit_test) : unit_test_(unit_test) {}
+
+void DefaultPerThreadTestPartResultReporter::ReportTestPartResult(
+    const TestPartResult& result) {
+  unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result);
+}
+
+// Returns the global test part result reporter.
+TestPartResultReporterInterface*
+UnitTestImpl::GetGlobalTestPartResultReporter() {
+  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
+  return global_test_part_result_repoter_;
+}
+
+// Sets the global test part result reporter.
+void UnitTestImpl::SetGlobalTestPartResultReporter(
+    TestPartResultReporterInterface* reporter) {
+  internal::MutexLock lock(&global_test_part_result_reporter_mutex_);
+  global_test_part_result_repoter_ = reporter;
+}
+
+// Returns the test part result reporter for the current thread.
+TestPartResultReporterInterface*
+UnitTestImpl::GetTestPartResultReporterForCurrentThread() {
+  return per_thread_test_part_result_reporter_.get();
+}
+
+// Sets the test part result reporter for the current thread.
+void UnitTestImpl::SetTestPartResultReporterForCurrentThread(
+    TestPartResultReporterInterface* reporter) {
+  per_thread_test_part_result_reporter_.set(reporter);
+}
+
+// Gets the number of successful test suites.
+int UnitTestImpl::successful_test_suite_count() const {
+  return CountIf(test_suites_, TestSuitePassed);
+}
+
+// Gets the number of failed test suites.
+int UnitTestImpl::failed_test_suite_count() const {
+  return CountIf(test_suites_, TestSuiteFailed);
+}
+
+// Gets the number of all test suites.
+int UnitTestImpl::total_test_suite_count() const {
+  return static_cast<int>(test_suites_.size());
+}
+
+// Gets the number of all test suites that contain at least one test
+// that should run.
+int UnitTestImpl::test_suite_to_run_count() const {
+  return CountIf(test_suites_, ShouldRunTestSuite);
+}
+
+// Gets the number of successful tests.
+int UnitTestImpl::successful_test_count() const {
+  return SumOverTestSuiteList(test_suites_, &TestSuite::successful_test_count);
+}
+
+// Gets the number of skipped tests.
+int UnitTestImpl::skipped_test_count() const {
+  return SumOverTestSuiteList(test_suites_, &TestSuite::skipped_test_count);
+}
+
+// Gets the number of failed tests.
+int UnitTestImpl::failed_test_count() const {
+  return SumOverTestSuiteList(test_suites_, &TestSuite::failed_test_count);
+}
+
+// Gets the number of disabled tests that will be reported in the XML report.
+int UnitTestImpl::reportable_disabled_test_count() const {
+  return SumOverTestSuiteList(test_suites_,
+                              &TestSuite::reportable_disabled_test_count);
+}
+
+// Gets the number of disabled tests.
+int UnitTestImpl::disabled_test_count() const {
+  return SumOverTestSuiteList(test_suites_, &TestSuite::disabled_test_count);
+}
+
+// Gets the number of tests to be printed in the XML report.
+int UnitTestImpl::reportable_test_count() const {
+  return SumOverTestSuiteList(test_suites_, &TestSuite::reportable_test_count);
+}
+
+// Gets the number of all tests.
+int UnitTestImpl::total_test_count() const {
+  return SumOverTestSuiteList(test_suites_, &TestSuite::total_test_count);
+}
+
+// Gets the number of tests that should run.
+int UnitTestImpl::test_to_run_count() const {
+  return SumOverTestSuiteList(test_suites_, &TestSuite::test_to_run_count);
+}
+
+// Returns the current OS stack trace as an std::string.
+//
+// The maximum number of stack frames to be included is specified by
+// the gtest_stack_trace_depth flag.  The skip_count parameter
+// specifies the number of top frames to be skipped, which doesn't
+// count against the number of frames to be included.
+//
+// For example, if Foo() calls Bar(), which in turn calls
+// CurrentOsStackTraceExceptTop(1), Foo() will be included in the
+// trace but Bar() and CurrentOsStackTraceExceptTop() won't.
+std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
+  return os_stack_trace_getter()->CurrentStackTrace(
+      static_cast<int>(GTEST_FLAG(stack_trace_depth)),
+      skip_count + 1
+      // Skips the user-specified number of frames plus this function
+      // itself.
+      );  // NOLINT
+}
+
+// A helper class for measuring elapsed times.
+class Timer {
+ public:
+  Timer() : start_(std::chrono::steady_clock::now()) {}
+
+  // Return time elapsed in milliseconds since the timer was created.
+  TimeInMillis Elapsed() {
+    return std::chrono::duration_cast<std::chrono::milliseconds>(
+               std::chrono::steady_clock::now() - start_)
+        .count();
+  }
+
+ private:
+  std::chrono::steady_clock::time_point start_;
+};
+
+// Returns a timestamp as milliseconds since the epoch. Note this time may jump
+// around subject to adjustments by the system, to measure elapsed time use
+// Timer instead.
+TimeInMillis GetTimeInMillis() {
+  return std::chrono::duration_cast<std::chrono::milliseconds>(
+             std::chrono::system_clock::now() -
+             std::chrono::system_clock::from_time_t(0))
+      .count();
+}
+
+// Utilities
+
+// class String.
+
+#if GTEST_OS_WINDOWS_MOBILE
+// Creates a UTF-16 wide string from the given ANSI string, allocating
+// memory using new. The caller is responsible for deleting the return
+// value using delete[]. Returns the wide string, or NULL if the
+// input is NULL.
+LPCWSTR String::AnsiToUtf16(const char* ansi) {
+  if (!ansi) return nullptr;
+  const int length = strlen(ansi);
+  const int unicode_length =
+      MultiByteToWideChar(CP_ACP, 0, ansi, length, nullptr, 0);
+  WCHAR* unicode = new WCHAR[unicode_length + 1];
+  MultiByteToWideChar(CP_ACP, 0, ansi, length,
+                      unicode, unicode_length);
+  unicode[unicode_length] = 0;
+  return unicode;
+}
+
+// Creates an ANSI string from the given wide string, allocating
+// memory using new. The caller is responsible for deleting the return
+// value using delete[]. Returns the ANSI string, or NULL if the
+// input is NULL.
+const char* String::Utf16ToAnsi(LPCWSTR utf16_str)  {
+  if (!utf16_str) return nullptr;
+  const int ansi_length = WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, nullptr,
+                                              0, nullptr, nullptr);
+  char* ansi = new char[ansi_length + 1];
+  WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, ansi, ansi_length, nullptr,
+                      nullptr);
+  ansi[ansi_length] = 0;
+  return ansi;
+}
+
+#endif  // GTEST_OS_WINDOWS_MOBILE
+
+// Compares two C strings.  Returns true if and only if they have the same
+// content.
+//
+// Unlike strcmp(), this function can handle NULL argument(s).  A NULL
+// C string is considered different to any non-NULL C string,
+// including the empty string.
+bool String::CStringEquals(const char * lhs, const char * rhs) {
+  if (lhs == nullptr) return rhs == nullptr;
+
+  if (rhs == nullptr) return false;
+
+  return strcmp(lhs, rhs) == 0;
+}
+
+#if GTEST_HAS_STD_WSTRING
+
+// Converts an array of wide chars to a narrow string using the UTF-8
+// encoding, and streams the result to the given Message object.
+static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
+                                     Message* msg) {
+  for (size_t i = 0; i != length; ) {  // NOLINT
+    if (wstr[i] != L'\0') {
+      *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));
+      while (i != length && wstr[i] != L'\0')
+        i++;
+    } else {
+      *msg << '\0';
+      i++;
+    }
+  }
+}
+
+#endif  // GTEST_HAS_STD_WSTRING
+
+void SplitString(const ::std::string& str, char delimiter,
+                 ::std::vector< ::std::string>* dest) {
+  ::std::vector< ::std::string> parsed;
+  ::std::string::size_type pos = 0;
+  while (::testing::internal::AlwaysTrue()) {
+    const ::std::string::size_type colon = str.find(delimiter, pos);
+    if (colon == ::std::string::npos) {
+      parsed.push_back(str.substr(pos));
+      break;
+    } else {
+      parsed.push_back(str.substr(pos, colon - pos));
+      pos = colon + 1;
+    }
+  }
+  dest->swap(parsed);
+}
+
+}  // namespace internal
+
+// Constructs an empty Message.
+// We allocate the stringstream separately because otherwise each use of
+// ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's
+// stack frame leading to huge stack frames in some cases; gcc does not reuse
+// the stack space.
+Message::Message() : ss_(new ::std::stringstream) {
+  // By default, we want there to be enough precision when printing
+  // a double to a Message.
+  *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2);
+}
+
+// These two overloads allow streaming a wide C string to a Message
+// using the UTF-8 encoding.
+Message& Message::operator <<(const wchar_t* wide_c_str) {
+  return *this << internal::String::ShowWideCString(wide_c_str);
+}
+Message& Message::operator <<(wchar_t* wide_c_str) {
+  return *this << internal::String::ShowWideCString(wide_c_str);
+}
+
+#if GTEST_HAS_STD_WSTRING
+// Converts the given wide string to a narrow string using the UTF-8
+// encoding, and streams the result to this Message object.
+Message& Message::operator <<(const ::std::wstring& wstr) {
+  internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
+  return *this;
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+// Gets the text streamed to this object so far as an std::string.
+// Each '\0' character in the buffer is replaced with "\\0".
+std::string Message::GetString() const {
+  return internal::StringStreamToString(ss_.get());
+}
+
+// AssertionResult constructors.
+// Used in EXPECT_TRUE/FALSE(assertion_result).
+AssertionResult::AssertionResult(const AssertionResult& other)
+    : success_(other.success_),
+      message_(other.message_.get() != nullptr
+                   ? new ::std::string(*other.message_)
+                   : static_cast< ::std::string*>(nullptr)) {}
+
+// Swaps two AssertionResults.
+void AssertionResult::swap(AssertionResult& other) {
+  using std::swap;
+  swap(success_, other.success_);
+  swap(message_, other.message_);
+}
+
+// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE.
+AssertionResult AssertionResult::operator!() const {
+  AssertionResult negation(!success_);
+  if (message_.get() != nullptr) negation << *message_;
+  return negation;
+}
+
+// Makes a successful assertion result.
+AssertionResult AssertionSuccess() {
+  return AssertionResult(true);
+}
+
+// Makes a failed assertion result.
+AssertionResult AssertionFailure() {
+  return AssertionResult(false);
+}
+
+// Makes a failed assertion result with the given failure message.
+// Deprecated; use AssertionFailure() << message.
+AssertionResult AssertionFailure(const Message& message) {
+  return AssertionFailure() << message;
+}
+
+namespace internal {
+
+namespace edit_distance {
+std::vector<EditType> CalculateOptimalEdits(const std::vector<size_t>& left,
+                                            const std::vector<size_t>& right) {
+  std::vector<std::vector<double> > costs(
+      left.size() + 1, std::vector<double>(right.size() + 1));
+  std::vector<std::vector<EditType> > best_move(
+      left.size() + 1, std::vector<EditType>(right.size() + 1));
+
+  // Populate for empty right.
+  for (size_t l_i = 0; l_i < costs.size(); ++l_i) {
+    costs[l_i][0] = static_cast<double>(l_i);
+    best_move[l_i][0] = kRemove;
+  }
+  // Populate for empty left.
+  for (size_t r_i = 1; r_i < costs[0].size(); ++r_i) {
+    costs[0][r_i] = static_cast<double>(r_i);
+    best_move[0][r_i] = kAdd;
+  }
+
+  for (size_t l_i = 0; l_i < left.size(); ++l_i) {
+    for (size_t r_i = 0; r_i < right.size(); ++r_i) {
+      if (left[l_i] == right[r_i]) {
+        // Found a match. Consume it.
+        costs[l_i + 1][r_i + 1] = costs[l_i][r_i];
+        best_move[l_i + 1][r_i + 1] = kMatch;
+        continue;
+      }
+
+      const double add = costs[l_i + 1][r_i];
+      const double remove = costs[l_i][r_i + 1];
+      const double replace = costs[l_i][r_i];
+      if (add < remove && add < replace) {
+        costs[l_i + 1][r_i + 1] = add + 1;
+        best_move[l_i + 1][r_i + 1] = kAdd;
+      } else if (remove < add && remove < replace) {
+        costs[l_i + 1][r_i + 1] = remove + 1;
+        best_move[l_i + 1][r_i + 1] = kRemove;
+      } else {
+        // We make replace a little more expensive than add/remove to lower
+        // their priority.
+        costs[l_i + 1][r_i + 1] = replace + 1.00001;
+        best_move[l_i + 1][r_i + 1] = kReplace;
+      }
+    }
+  }
+
+  // Reconstruct the best path. We do it in reverse order.
+  std::vector<EditType> best_path;
+  for (size_t l_i = left.size(), r_i = right.size(); l_i > 0 || r_i > 0;) {
+    EditType move = best_move[l_i][r_i];
+    best_path.push_back(move);
+    l_i -= move != kAdd;
+    r_i -= move != kRemove;
+  }
+  std::reverse(best_path.begin(), best_path.end());
+  return best_path;
+}
+
+namespace {
+
+// Helper class to convert string into ids with deduplication.
+class InternalStrings {
+ public:
+  size_t GetId(const std::string& str) {
+    IdMap::iterator it = ids_.find(str);
+    if (it != ids_.end()) return it->second;
+    size_t id = ids_.size();
+    return ids_[str] = id;
+  }
+
+ private:
+  typedef std::map<std::string, size_t> IdMap;
+  IdMap ids_;
+};
+
+}  // namespace
+
+std::vector<EditType> CalculateOptimalEdits(
+    const std::vector<std::string>& left,
+    const std::vector<std::string>& right) {
+  std::vector<size_t> left_ids, right_ids;
+  {
+    InternalStrings intern_table;
+    for (size_t i = 0; i < left.size(); ++i) {
+      left_ids.push_back(intern_table.GetId(left[i]));
+    }
+    for (size_t i = 0; i < right.size(); ++i) {
+      right_ids.push_back(intern_table.GetId(right[i]));
+    }
+  }
+  return CalculateOptimalEdits(left_ids, right_ids);
+}
+
+namespace {
+
+// Helper class that holds the state for one hunk and prints it out to the
+// stream.
+// It reorders adds/removes when possible to group all removes before all
+// adds. It also adds the hunk header before printint into the stream.
+class Hunk {
+ public:
+  Hunk(size_t left_start, size_t right_start)
+      : left_start_(left_start),
+        right_start_(right_start),
+        adds_(),
+        removes_(),
+        common_() {}
+
+  void PushLine(char edit, const char* line) {
+    switch (edit) {
+      case ' ':
+        ++common_;
+        FlushEdits();
+        hunk_.push_back(std::make_pair(' ', line));
+        break;
+      case '-':
+        ++removes_;
+        hunk_removes_.push_back(std::make_pair('-', line));
+        break;
+      case '+':
+        ++adds_;
+        hunk_adds_.push_back(std::make_pair('+', line));
+        break;
+    }
+  }
+
+  void PrintTo(std::ostream* os) {
+    PrintHeader(os);
+    FlushEdits();
+    for (std::list<std::pair<char, const char*> >::const_iterator it =
+             hunk_.begin();
+         it != hunk_.end(); ++it) {
+      *os << it->first << it->second << "\n";
+    }
+  }
+
+  bool has_edits() const { return adds_ || removes_; }
+
+ private:
+  void FlushEdits() {
+    hunk_.splice(hunk_.end(), hunk_removes_);
+    hunk_.splice(hunk_.end(), hunk_adds_);
+  }
+
+  // Print a unified diff header for one hunk.
+  // The format is
+  //   "@@ -<left_start>,<left_length> +<right_start>,<right_length> @@"
+  // where the left/right parts are omitted if unnecessary.
+  void PrintHeader(std::ostream* ss) const {
+    *ss << "@@ ";
+    if (removes_) {
+      *ss << "-" << left_start_ << "," << (removes_ + common_);
+    }
+    if (removes_ && adds_) {
+      *ss << " ";
+    }
+    if (adds_) {
+      *ss << "+" << right_start_ << "," << (adds_ + common_);
+    }
+    *ss << " @@\n";
+  }
+
+  size_t left_start_, right_start_;
+  size_t adds_, removes_, common_;
+  std::list<std::pair<char, const char*> > hunk_, hunk_adds_, hunk_removes_;
+};
+
+}  // namespace
+
+// Create a list of diff hunks in Unified diff format.
+// Each hunk has a header generated by PrintHeader above plus a body with
+// lines prefixed with ' ' for no change, '-' for deletion and '+' for
+// addition.
+// 'context' represents the desired unchanged prefix/suffix around the diff.
+// If two hunks are close enough that their contexts overlap, then they are
+// joined into one hunk.
+std::string CreateUnifiedDiff(const std::vector<std::string>& left,
+                              const std::vector<std::string>& right,
+                              size_t context) {
+  const std::vector<EditType> edits = CalculateOptimalEdits(left, right);
+
+  size_t l_i = 0, r_i = 0, edit_i = 0;
+  std::stringstream ss;
+  while (edit_i < edits.size()) {
+    // Find first edit.
+    while (edit_i < edits.size() && edits[edit_i] == kMatch) {
+      ++l_i;
+      ++r_i;
+      ++edit_i;
+    }
+
+    // Find the first line to include in the hunk.
+    const size_t prefix_context = std::min(l_i, context);
+    Hunk hunk(l_i - prefix_context + 1, r_i - prefix_context + 1);
+    for (size_t i = prefix_context; i > 0; --i) {
+      hunk.PushLine(' ', left[l_i - i].c_str());
+    }
+
+    // Iterate the edits until we found enough suffix for the hunk or the input
+    // is over.
+    size_t n_suffix = 0;
+    for (; edit_i < edits.size(); ++edit_i) {
+      if (n_suffix >= context) {
+        // Continue only if the next hunk is very close.
+        auto it = edits.begin() + static_cast<int>(edit_i);
+        while (it != edits.end() && *it == kMatch) ++it;
+        if (it == edits.end() ||
+            static_cast<size_t>(it - edits.begin()) - edit_i >= context) {
+          // There is no next edit or it is too far away.
+          break;
+        }
+      }
+
+      EditType edit = edits[edit_i];
+      // Reset count when a non match is found.
+      n_suffix = edit == kMatch ? n_suffix + 1 : 0;
+
+      if (edit == kMatch || edit == kRemove || edit == kReplace) {
+        hunk.PushLine(edit == kMatch ? ' ' : '-', left[l_i].c_str());
+      }
+      if (edit == kAdd || edit == kReplace) {
+        hunk.PushLine('+', right[r_i].c_str());
+      }
+
+      // Advance indices, depending on edit type.
+      l_i += edit != kAdd;
+      r_i += edit != kRemove;
+    }
+
+    if (!hunk.has_edits()) {
+      // We are done. We don't want this hunk.
+      break;
+    }
+
+    hunk.PrintTo(&ss);
+  }
+  return ss.str();
+}
+
+}  // namespace edit_distance
+
+namespace {
+
+// The string representation of the values received in EqFailure() are already
+// escaped. Split them on escaped '\n' boundaries. Leave all other escaped
+// characters the same.
+std::vector<std::string> SplitEscapedString(const std::string& str) {
+  std::vector<std::string> lines;
+  size_t start = 0, end = str.size();
+  if (end > 2 && str[0] == '"' && str[end - 1] == '"') {
+    ++start;
+    --end;
+  }
+  bool escaped = false;
+  for (size_t i = start; i + 1 < end; ++i) {
+    if (escaped) {
+      escaped = false;
+      if (str[i] == 'n') {
+        lines.push_back(str.substr(start, i - start - 1));
+        start = i + 1;
+      }
+    } else {
+      escaped = str[i] == '\\';
+    }
+  }
+  lines.push_back(str.substr(start, end - start));
+  return lines;
+}
+
+}  // namespace
+
+// Constructs and returns the message for an equality assertion
+// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
+//
+// The first four parameters are the expressions used in the assertion
+// and their values, as strings.  For example, for ASSERT_EQ(foo, bar)
+// where foo is 5 and bar is 6, we have:
+//
+//   lhs_expression: "foo"
+//   rhs_expression: "bar"
+//   lhs_value:      "5"
+//   rhs_value:      "6"
+//
+// The ignoring_case parameter is true if and only if the assertion is a
+// *_STRCASEEQ*.  When it's true, the string "Ignoring case" will
+// be inserted into the message.
+AssertionResult EqFailure(const char* lhs_expression,
+                          const char* rhs_expression,
+                          const std::string& lhs_value,
+                          const std::string& rhs_value,
+                          bool ignoring_case) {
+  Message msg;
+  msg << "Expected equality of these values:";
+  msg << "\n  " << lhs_expression;
+  if (lhs_value != lhs_expression) {
+    msg << "\n    Which is: " << lhs_value;
+  }
+  msg << "\n  " << rhs_expression;
+  if (rhs_value != rhs_expression) {
+    msg << "\n    Which is: " << rhs_value;
+  }
+
+  if (ignoring_case) {
+    msg << "\nIgnoring case";
+  }
+
+  if (!lhs_value.empty() && !rhs_value.empty()) {
+    const std::vector<std::string> lhs_lines =
+        SplitEscapedString(lhs_value);
+    const std::vector<std::string> rhs_lines =
+        SplitEscapedString(rhs_value);
+    if (lhs_lines.size() > 1 || rhs_lines.size() > 1) {
+      msg << "\nWith diff:\n"
+          << edit_distance::CreateUnifiedDiff(lhs_lines, rhs_lines);
+    }
+  }
+
+  return AssertionFailure() << msg;
+}
+
+// Constructs a failure message for Boolean assertions such as EXPECT_TRUE.
+std::string GetBoolAssertionFailureMessage(
+    const AssertionResult& assertion_result,
+    const char* expression_text,
+    const char* actual_predicate_value,
+    const char* expected_predicate_value) {
+  const char* actual_message = assertion_result.message();
+  Message msg;
+  msg << "Value of: " << expression_text
+      << "\n  Actual: " << actual_predicate_value;
+  if (actual_message[0] != '\0')
+    msg << " (" << actual_message << ")";
+  msg << "\nExpected: " << expected_predicate_value;
+  return msg.GetString();
+}
+
+// Helper function for implementing ASSERT_NEAR.
+AssertionResult DoubleNearPredFormat(const char* expr1,
+                                     const char* expr2,
+                                     const char* abs_error_expr,
+                                     double val1,
+                                     double val2,
+                                     double abs_error) {
+  const double diff = fabs(val1 - val2);
+  if (diff <= abs_error) return AssertionSuccess();
+
+  // Find the value which is closest to zero.
+  const double min_abs = std::min(fabs(val1), fabs(val2));
+  // Find the distance to the next double from that value.
+  const double epsilon =
+      nextafter(min_abs, std::numeric_limits<double>::infinity()) - min_abs;
+  // Detect the case where abs_error is so small that EXPECT_NEAR is
+  // effectively the same as EXPECT_EQUAL, and give an informative error
+  // message so that the situation can be more easily understood without
+  // requiring exotic floating-point knowledge.
+  // Don't do an epsilon check if abs_error is zero because that implies
+  // that an equality check was actually intended.
+  if (!(std::isnan)(val1) && !(std::isnan)(val2) && abs_error > 0 &&
+      abs_error < epsilon) {
+    return AssertionFailure()
+           << "The difference between " << expr1 << " and " << expr2 << " is "
+           << diff << ", where\n"
+           << expr1 << " evaluates to " << val1 << ",\n"
+           << expr2 << " evaluates to " << val2 << ".\nThe abs_error parameter "
+           << abs_error_expr << " evaluates to " << abs_error
+           << " which is smaller than the minimum distance between doubles for "
+              "numbers of this magnitude which is "
+           << epsilon
+           << ", thus making this EXPECT_NEAR check equivalent to "
+              "EXPECT_EQUAL. Consider using EXPECT_DOUBLE_EQ instead.";
+  }
+  return AssertionFailure()
+      << "The difference between " << expr1 << " and " << expr2
+      << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n"
+      << expr1 << " evaluates to " << val1 << ",\n"
+      << expr2 << " evaluates to " << val2 << ", and\n"
+      << abs_error_expr << " evaluates to " << abs_error << ".";
+}
+
+
+// Helper template for implementing FloatLE() and DoubleLE().
+template <typename RawType>
+AssertionResult FloatingPointLE(const char* expr1,
+                                const char* expr2,
+                                RawType val1,
+                                RawType val2) {
+  // Returns success if val1 is less than val2,
+  if (val1 < val2) {
+    return AssertionSuccess();
+  }
+
+  // or if val1 is almost equal to val2.
+  const FloatingPoint<RawType> lhs(val1), rhs(val2);
+  if (lhs.AlmostEquals(rhs)) {
+    return AssertionSuccess();
+  }
+
+  // Note that the above two checks will both fail if either val1 or
+  // val2 is NaN, as the IEEE floating-point standard requires that
+  // any predicate involving a NaN must return false.
+
+  ::std::stringstream val1_ss;
+  val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+          << val1;
+
+  ::std::stringstream val2_ss;
+  val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2)
+          << val2;
+
+  return AssertionFailure()
+      << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n"
+      << "  Actual: " << StringStreamToString(&val1_ss) << " vs "
+      << StringStreamToString(&val2_ss);
+}
+
+}  // namespace internal
+
+// Asserts that val1 is less than, or almost equal to, val2.  Fails
+// otherwise.  In particular, it fails if either val1 or val2 is NaN.
+AssertionResult FloatLE(const char* expr1, const char* expr2,
+                        float val1, float val2) {
+  return internal::FloatingPointLE<float>(expr1, expr2, val1, val2);
+}
+
+// Asserts that val1 is less than, or almost equal to, val2.  Fails
+// otherwise.  In particular, it fails if either val1 or val2 is NaN.
+AssertionResult DoubleLE(const char* expr1, const char* expr2,
+                         double val1, double val2) {
+  return internal::FloatingPointLE<double>(expr1, expr2, val1, val2);
+}
+
+namespace internal {
+
+// The helper function for {ASSERT|EXPECT}_STREQ.
+AssertionResult CmpHelperSTREQ(const char* lhs_expression,
+                               const char* rhs_expression,
+                               const char* lhs,
+                               const char* rhs) {
+  if (String::CStringEquals(lhs, rhs)) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(lhs_expression,
+                   rhs_expression,
+                   PrintToString(lhs),
+                   PrintToString(rhs),
+                   false);
+}
+
+// The helper function for {ASSERT|EXPECT}_STRCASEEQ.
+AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
+                                   const char* rhs_expression,
+                                   const char* lhs,
+                                   const char* rhs) {
+  if (String::CaseInsensitiveCStringEquals(lhs, rhs)) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(lhs_expression,
+                   rhs_expression,
+                   PrintToString(lhs),
+                   PrintToString(rhs),
+                   true);
+}
+
+// The helper function for {ASSERT|EXPECT}_STRNE.
+AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                               const char* s2_expression,
+                               const char* s1,
+                               const char* s2) {
+  if (!String::CStringEquals(s1, s2)) {
+    return AssertionSuccess();
+  } else {
+    return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
+                              << s2_expression << "), actual: \""
+                              << s1 << "\" vs \"" << s2 << "\"";
+  }
+}
+
+// The helper function for {ASSERT|EXPECT}_STRCASENE.
+AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
+                                   const char* s2_expression,
+                                   const char* s1,
+                                   const char* s2) {
+  if (!String::CaseInsensitiveCStringEquals(s1, s2)) {
+    return AssertionSuccess();
+  } else {
+    return AssertionFailure()
+        << "Expected: (" << s1_expression << ") != ("
+        << s2_expression << ") (ignoring case), actual: \""
+        << s1 << "\" vs \"" << s2 << "\"";
+  }
+}
+
+}  // namespace internal
+
+namespace {
+
+// Helper functions for implementing IsSubString() and IsNotSubstring().
+
+// This group of overloaded functions return true if and only if needle
+// is a substring of haystack.  NULL is considered a substring of
+// itself only.
+
+bool IsSubstringPred(const char* needle, const char* haystack) {
+  if (needle == nullptr || haystack == nullptr) return needle == haystack;
+
+  return strstr(haystack, needle) != nullptr;
+}
+
+bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
+  if (needle == nullptr || haystack == nullptr) return needle == haystack;
+
+  return wcsstr(haystack, needle) != nullptr;
+}
+
+// StringType here can be either ::std::string or ::std::wstring.
+template <typename StringType>
+bool IsSubstringPred(const StringType& needle,
+                     const StringType& haystack) {
+  return haystack.find(needle) != StringType::npos;
+}
+
+// This function implements either IsSubstring() or IsNotSubstring(),
+// depending on the value of the expected_to_be_substring parameter.
+// StringType here can be const char*, const wchar_t*, ::std::string,
+// or ::std::wstring.
+template <typename StringType>
+AssertionResult IsSubstringImpl(
+    bool expected_to_be_substring,
+    const char* needle_expr, const char* haystack_expr,
+    const StringType& needle, const StringType& haystack) {
+  if (IsSubstringPred(needle, haystack) == expected_to_be_substring)
+    return AssertionSuccess();
+
+  const bool is_wide_string = sizeof(needle[0]) > 1;
+  const char* const begin_string_quote = is_wide_string ? "L\"" : "\"";
+  return AssertionFailure()
+      << "Value of: " << needle_expr << "\n"
+      << "  Actual: " << begin_string_quote << needle << "\"\n"
+      << "Expected: " << (expected_to_be_substring ? "" : "not ")
+      << "a substring of " << haystack_expr << "\n"
+      << "Which is: " << begin_string_quote << haystack << "\"";
+}
+
+}  // namespace
+
+// IsSubstring() and IsNotSubstring() check whether needle is a
+// substring of haystack (NULL is considered a substring of itself
+// only), and return an appropriate error message when they fail.
+
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const char* needle, const char* haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const wchar_t* needle, const wchar_t* haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::string& needle, const ::std::string& haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+
+#if GTEST_HAS_STD_WSTRING
+AssertionResult IsSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack) {
+  return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack);
+}
+
+AssertionResult IsNotSubstring(
+    const char* needle_expr, const char* haystack_expr,
+    const ::std::wstring& needle, const ::std::wstring& haystack) {
+  return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack);
+}
+#endif  // GTEST_HAS_STD_WSTRING
+
+namespace internal {
+
+#if GTEST_OS_WINDOWS
+
+namespace {
+
+// Helper function for IsHRESULT{SuccessFailure} predicates
+AssertionResult HRESULTFailureHelper(const char* expr,
+                                     const char* expected,
+                                     long hr) {  // NOLINT
+# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_TV_TITLE
+
+  // Windows CE doesn't support FormatMessage.
+  const char error_text[] = "";
+
+# else
+
+  // Looks up the human-readable system message for the HRESULT code
+  // and since we're not passing any params to FormatMessage, we don't
+  // want inserts expanded.
+  const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM |
+                       FORMAT_MESSAGE_IGNORE_INSERTS;
+  const DWORD kBufSize = 4096;
+  // Gets the system's human readable message string for this HRESULT.
+  char error_text[kBufSize] = { '\0' };
+  DWORD message_length = ::FormatMessageA(kFlags,
+                                          0,   // no source, we're asking system
+                                          static_cast<DWORD>(hr),  // the error
+                                          0,   // no line width restrictions
+                                          error_text,  // output buffer
+                                          kBufSize,    // buf size
+                                          nullptr);  // no arguments for inserts
+  // Trims tailing white space (FormatMessage leaves a trailing CR-LF)
+  for (; message_length && IsSpace(error_text[message_length - 1]);
+          --message_length) {
+    error_text[message_length - 1] = '\0';
+  }
+
+# endif  // GTEST_OS_WINDOWS_MOBILE
+
+  const std::string error_hex("0x" + String::FormatHexInt(hr));
+  return ::testing::AssertionFailure()
+      << "Expected: " << expr << " " << expected << ".\n"
+      << "  Actual: " << error_hex << " " << error_text << "\n";
+}
+
+}  // namespace
+
+AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NOLINT
+  if (SUCCEEDED(hr)) {
+    return AssertionSuccess();
+  }
+  return HRESULTFailureHelper(expr, "succeeds", hr);
+}
+
+AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
+  if (FAILED(hr)) {
+    return AssertionSuccess();
+  }
+  return HRESULTFailureHelper(expr, "fails", hr);
+}
+
+#endif  // GTEST_OS_WINDOWS
+
+// Utility functions for encoding Unicode text (wide strings) in
+// UTF-8.
+
+// A Unicode code-point can have up to 21 bits, and is encoded in UTF-8
+// like this:
+//
+// Code-point length   Encoding
+//   0 -  7 bits       0xxxxxxx
+//   8 - 11 bits       110xxxxx 10xxxxxx
+//  12 - 16 bits       1110xxxx 10xxxxxx 10xxxxxx
+//  17 - 21 bits       11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+
+// The maximum code-point a one-byte UTF-8 sequence can represent.
+constexpr uint32_t kMaxCodePoint1 = (static_cast<uint32_t>(1) <<  7) - 1;
+
+// The maximum code-point a two-byte UTF-8 sequence can represent.
+constexpr uint32_t kMaxCodePoint2 = (static_cast<uint32_t>(1) << (5 + 6)) - 1;
+
+// The maximum code-point a three-byte UTF-8 sequence can represent.
+constexpr uint32_t kMaxCodePoint3 = (static_cast<uint32_t>(1) << (4 + 2*6)) - 1;
+
+// The maximum code-point a four-byte UTF-8 sequence can represent.
+constexpr uint32_t kMaxCodePoint4 = (static_cast<uint32_t>(1) << (3 + 3*6)) - 1;
+
+// Chops off the n lowest bits from a bit pattern.  Returns the n
+// lowest bits.  As a side effect, the original bit pattern will be
+// shifted to the right by n bits.
+inline uint32_t ChopLowBits(uint32_t* bits, int n) {
+  const uint32_t low_bits = *bits & ((static_cast<uint32_t>(1) << n) - 1);
+  *bits >>= n;
+  return low_bits;
+}
+
+// Converts a Unicode code point to a narrow string in UTF-8 encoding.
+// code_point parameter is of type uint32_t because wchar_t may not be
+// wide enough to contain a code point.
+// If the code_point is not a valid Unicode code point
+// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted
+// to "(Invalid Unicode 0xXXXXXXXX)".
+std::string CodePointToUtf8(uint32_t code_point) {
+  if (code_point > kMaxCodePoint4) {
+    return "(Invalid Unicode 0x" + String::FormatHexUInt32(code_point) + ")";
+  }
+
+  char str[5];  // Big enough for the largest valid code point.
+  if (code_point <= kMaxCodePoint1) {
+    str[1] = '\0';
+    str[0] = static_cast<char>(code_point);                          // 0xxxxxxx
+  } else if (code_point <= kMaxCodePoint2) {
+    str[2] = '\0';
+    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[0] = static_cast<char>(0xC0 | code_point);                   // 110xxxxx
+  } else if (code_point <= kMaxCodePoint3) {
+    str[3] = '\0';
+    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[0] = static_cast<char>(0xE0 | code_point);                   // 1110xxxx
+  } else {  // code_point <= kMaxCodePoint4
+    str[4] = '\0';
+    str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6));  // 10xxxxxx
+    str[0] = static_cast<char>(0xF0 | code_point);                   // 11110xxx
+  }
+  return str;
+}
+
+// The following two functions only make sense if the system
+// uses UTF-16 for wide string encoding. All supported systems
+// with 16 bit wchar_t (Windows, Cygwin) do use UTF-16.
+
+// Determines if the arguments constitute UTF-16 surrogate pair
+// and thus should be combined into a single Unicode code point
+// using CreateCodePointFromUtf16SurrogatePair.
+inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
+  return sizeof(wchar_t) == 2 &&
+      (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00;
+}
+
+// Creates a Unicode code point from UTF16 surrogate pair.
+inline uint32_t CreateCodePointFromUtf16SurrogatePair(wchar_t first,
+                                                      wchar_t second) {
+  const auto first_u = static_cast<uint32_t>(first);
+  const auto second_u = static_cast<uint32_t>(second);
+  const uint32_t mask = (1 << 10) - 1;
+  return (sizeof(wchar_t) == 2)
+             ? (((first_u & mask) << 10) | (second_u & mask)) + 0x10000
+             :
+             // This function should not be called when the condition is
+             // false, but we provide a sensible default in case it is.
+             first_u;
+}
+
+// Converts a wide string to a narrow string in UTF-8 encoding.
+// The wide string is assumed to have the following encoding:
+//   UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin)
+//   UTF-32 if sizeof(wchar_t) == 4 (on Linux)
+// Parameter str points to a null-terminated wide string.
+// Parameter num_chars may additionally limit the number
+// of wchar_t characters processed. -1 is used when the entire string
+// should be processed.
+// If the string contains code points that are not valid Unicode code points
+// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output
+// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding
+// and contains invalid UTF-16 surrogate pairs, values in those pairs
+// will be encoded as individual Unicode characters from Basic Normal Plane.
+std::string WideStringToUtf8(const wchar_t* str, int num_chars) {
+  if (num_chars == -1)
+    num_chars = static_cast<int>(wcslen(str));
+
+  ::std::stringstream stream;
+  for (int i = 0; i < num_chars; ++i) {
+    uint32_t unicode_code_point;
+
+    if (str[i] == L'\0') {
+      break;
+    } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) {
+      unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i],
+                                                                 str[i + 1]);
+      i++;
+    } else {
+      unicode_code_point = static_cast<uint32_t>(str[i]);
+    }
+
+    stream << CodePointToUtf8(unicode_code_point);
+  }
+  return StringStreamToString(&stream);
+}
+
+// Converts a wide C string to an std::string using the UTF-8 encoding.
+// NULL will be converted to "(null)".
+std::string String::ShowWideCString(const wchar_t * wide_c_str) {
+  if (wide_c_str == nullptr) return "(null)";
+
+  return internal::WideStringToUtf8(wide_c_str, -1);
+}
+
+// Compares two wide C strings.  Returns true if and only if they have the
+// same content.
+//
+// Unlike wcscmp(), this function can handle NULL argument(s).  A NULL
+// C string is considered different to any non-NULL C string,
+// including the empty string.
+bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) {
+  if (lhs == nullptr) return rhs == nullptr;
+
+  if (rhs == nullptr) return false;
+
+  return wcscmp(lhs, rhs) == 0;
+}
+
+// Helper function for *_STREQ on wide strings.
+AssertionResult CmpHelperSTREQ(const char* lhs_expression,
+                               const char* rhs_expression,
+                               const wchar_t* lhs,
+                               const wchar_t* rhs) {
+  if (String::WideCStringEquals(lhs, rhs)) {
+    return AssertionSuccess();
+  }
+
+  return EqFailure(lhs_expression,
+                   rhs_expression,
+                   PrintToString(lhs),
+                   PrintToString(rhs),
+                   false);
+}
+
+// Helper function for *_STRNE on wide strings.
+AssertionResult CmpHelperSTRNE(const char* s1_expression,
+                               const char* s2_expression,
+                               const wchar_t* s1,
+                               const wchar_t* s2) {
+  if (!String::WideCStringEquals(s1, s2)) {
+    return AssertionSuccess();
+  }
+
+  return AssertionFailure() << "Expected: (" << s1_expression << ") != ("
+                            << s2_expression << "), actual: "
+                            << PrintToString(s1)
+                            << " vs " << PrintToString(s2);
+}
+
+// Compares two C strings, ignoring case.  Returns true if and only if they have
+// the same content.
+//
+// Unlike strcasecmp(), this function can handle NULL argument(s).  A
+// NULL C string is considered different to any non-NULL C string,
+// including the empty string.
+bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) {
+  if (lhs == nullptr) return rhs == nullptr;
+  if (rhs == nullptr) return false;
+  return posix::StrCaseCmp(lhs, rhs) == 0;
+}
+
+// Compares two wide C strings, ignoring case.  Returns true if and only if they
+// have the same content.
+//
+// Unlike wcscasecmp(), this function can handle NULL argument(s).
+// A NULL C string is considered different to any non-NULL wide C string,
+// including the empty string.
+// NB: The implementations on different platforms slightly differ.
+// On windows, this method uses _wcsicmp which compares according to LC_CTYPE
+// environment variable. On GNU platform this method uses wcscasecmp
+// which compares according to LC_CTYPE category of the current locale.
+// On MacOS X, it uses towlower, which also uses LC_CTYPE category of the
+// current locale.
+bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
+                                              const wchar_t* rhs) {
+  if (lhs == nullptr) return rhs == nullptr;
+
+  if (rhs == nullptr) return false;
+
+#if GTEST_OS_WINDOWS
+  return _wcsicmp(lhs, rhs) == 0;
+#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
+  return wcscasecmp(lhs, rhs) == 0;
+#else
+  // Android, Mac OS X and Cygwin don't define wcscasecmp.
+  // Other unknown OSes may not define it either.
+  wint_t left, right;
+  do {
+    left = towlower(static_cast<wint_t>(*lhs++));
+    right = towlower(static_cast<wint_t>(*rhs++));
+  } while (left && left == right);
+  return left == right;
+#endif  // OS selector
+}
+
+// Returns true if and only if str ends with the given suffix, ignoring case.
+// Any string is considered to end with an empty suffix.
+bool String::EndsWithCaseInsensitive(
+    const std::string& str, const std::string& suffix) {
+  const size_t str_len = str.length();
+  const size_t suffix_len = suffix.length();
+  return (str_len >= suffix_len) &&
+         CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len,
+                                      suffix.c_str());
+}
+
+// Formats an int value as "%02d".
+std::string String::FormatIntWidth2(int value) {
+  return FormatIntWidthN(value, 2);
+}
+
+// Formats an int value to given width with leading zeros.
+std::string String::FormatIntWidthN(int value, int width) {
+  std::stringstream ss;
+  ss << std::setfill('0') << std::setw(width) << value;
+  return ss.str();
+}
+
+// Formats an int value as "%X".
+std::string String::FormatHexUInt32(uint32_t value) {
+  std::stringstream ss;
+  ss << std::hex << std::uppercase << value;
+  return ss.str();
+}
+
+// Formats an int value as "%X".
+std::string String::FormatHexInt(int value) {
+  return FormatHexUInt32(static_cast<uint32_t>(value));
+}
+
+// Formats a byte as "%02X".
+std::string String::FormatByte(unsigned char value) {
+  std::stringstream ss;
+  ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase
+     << static_cast<unsigned int>(value);
+  return ss.str();
+}
+
+// Converts the buffer in a stringstream to an std::string, converting NUL
+// bytes to "\\0" along the way.
+std::string StringStreamToString(::std::stringstream* ss) {
+  const ::std::string& str = ss->str();
+  const char* const start = str.c_str();
+  const char* const end = start + str.length();
+
+  std::string result;
+  result.reserve(static_cast<size_t>(2 * (end - start)));
+  for (const char* ch = start; ch != end; ++ch) {
+    if (*ch == '\0') {
+      result += "\\0";  // Replaces NUL with "\\0";
+    } else {
+      result += *ch;
+    }
+  }
+
+  return result;
+}
+
+// Appends the user-supplied message to the Google-Test-generated message.
+std::string AppendUserMessage(const std::string& gtest_msg,
+                              const Message& user_msg) {
+  // Appends the user message if it's non-empty.
+  const std::string user_msg_string = user_msg.GetString();
+  if (user_msg_string.empty()) {
+    return gtest_msg;
+  }
+  if (gtest_msg.empty()) {
+    return user_msg_string;
+  }
+  return gtest_msg + "\n" + user_msg_string;
+}
+
+}  // namespace internal
+
+// class TestResult
+
+// Creates an empty TestResult.
+TestResult::TestResult()
+    : death_test_count_(0), start_timestamp_(0), elapsed_time_(0) {}
+
+// D'tor.
+TestResult::~TestResult() {
+}
+
+// Returns the i-th test part result among all the results. i can
+// range from 0 to total_part_count() - 1. If i is not in that range,
+// aborts the program.
+const TestPartResult& TestResult::GetTestPartResult(int i) const {
+  if (i < 0 || i >= total_part_count())
+    internal::posix::Abort();
+  return test_part_results_.at(static_cast<size_t>(i));
+}
+
+// Returns the i-th test property. i can range from 0 to
+// test_property_count() - 1. If i is not in that range, aborts the
+// program.
+const TestProperty& TestResult::GetTestProperty(int i) const {
+  if (i < 0 || i >= test_property_count())
+    internal::posix::Abort();
+  return test_properties_.at(static_cast<size_t>(i));
+}
+
+// Clears the test part results.
+void TestResult::ClearTestPartResults() {
+  test_part_results_.clear();
+}
+
+// Adds a test part result to the list.
+void TestResult::AddTestPartResult(const TestPartResult& test_part_result) {
+  test_part_results_.push_back(test_part_result);
+}
+
+// Adds a test property to the list. If a property with the same key as the
+// supplied property is already represented, the value of this test_property
+// replaces the old value for that key.
+void TestResult::RecordProperty(const std::string& xml_element,
+                                const TestProperty& test_property) {
+  if (!ValidateTestProperty(xml_element, test_property)) {
+    return;
+  }
+  internal::MutexLock lock(&test_properties_mutex_);
+  const std::vector<TestProperty>::iterator property_with_matching_key =
+      std::find_if(test_properties_.begin(), test_properties_.end(),
+                   internal::TestPropertyKeyIs(test_property.key()));
+  if (property_with_matching_key == test_properties_.end()) {
+    test_properties_.push_back(test_property);
+    return;
+  }
+  property_with_matching_key->SetValue(test_property.value());
+}
+
+// The list of reserved attributes used in the <testsuites> element of XML
+// output.
+static const char* const kReservedTestSuitesAttributes[] = {
+  "disabled",
+  "errors",
+  "failures",
+  "name",
+  "random_seed",
+  "tests",
+  "time",
+  "timestamp"
+};
+
+// The list of reserved attributes used in the <testsuite> element of XML
+// output.
+static const char* const kReservedTestSuiteAttributes[] = {
+    "disabled", "errors", "failures",  "name",
+    "tests",    "time",   "timestamp", "skipped"};
+
+// The list of reserved attributes used in the <testcase> element of XML output.
+static const char* const kReservedTestCaseAttributes[] = {
+    "classname",   "name", "status", "time",  "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")
+static const char* const kReservedOutputTestCaseAttributes[] = {
+    "classname",   "name", "status", "time",   "type_param",
+    "value_param", "file", "line",   "result", "timestamp"};
+
+template <size_t kSize>
+std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) {
+  return std::vector<std::string>(array, array + kSize);
+}
+
+static std::vector<std::string> GetReservedAttributesForElement(
+    const std::string& xml_element) {
+  if (xml_element == "testsuites") {
+    return ArrayAsVector(kReservedTestSuitesAttributes);
+  } else if (xml_element == "testsuite") {
+    return ArrayAsVector(kReservedTestSuiteAttributes);
+  } else if (xml_element == "testcase") {
+    return ArrayAsVector(kReservedTestCaseAttributes);
+  } else {
+    GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
+  }
+  // This code is unreachable but some compilers may not realizes that.
+  return std::vector<std::string>();
+}
+
+// TODO(jdesprez): Merge the two getReserved attributes once skip is improved
+static std::vector<std::string> GetReservedOutputAttributesForElement(
+    const std::string& xml_element) {
+  if (xml_element == "testsuites") {
+    return ArrayAsVector(kReservedTestSuitesAttributes);
+  } else if (xml_element == "testsuite") {
+    return ArrayAsVector(kReservedTestSuiteAttributes);
+  } else if (xml_element == "testcase") {
+    return ArrayAsVector(kReservedOutputTestCaseAttributes);
+  } else {
+    GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element;
+  }
+  // This code is unreachable but some compilers may not realizes that.
+  return std::vector<std::string>();
+}
+
+static std::string FormatWordList(const std::vector<std::string>& words) {
+  Message word_list;
+  for (size_t i = 0; i < words.size(); ++i) {
+    if (i > 0 && words.size() > 2) {
+      word_list << ", ";
+    }
+    if (i == words.size() - 1) {
+      word_list << "and ";
+    }
+    word_list << "'" << words[i] << "'";
+  }
+  return word_list.GetString();
+}
+
+static bool ValidateTestPropertyName(
+    const std::string& property_name,
+    const std::vector<std::string>& reserved_names) {
+  if (std::find(reserved_names.begin(), reserved_names.end(), property_name) !=
+          reserved_names.end()) {
+    ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name
+                  << " (" << FormatWordList(reserved_names)
+                  << " are reserved by " << GTEST_NAME_ << ")";
+    return false;
+  }
+  return true;
+}
+
+// Adds a failure if the key is a reserved attribute of the element named
+// xml_element.  Returns true if the property is valid.
+bool TestResult::ValidateTestProperty(const std::string& xml_element,
+                                      const TestProperty& test_property) {
+  return ValidateTestPropertyName(test_property.key(),
+                                  GetReservedAttributesForElement(xml_element));
+}
+
+// Clears the object.
+void TestResult::Clear() {
+  test_part_results_.clear();
+  test_properties_.clear();
+  death_test_count_ = 0;
+  elapsed_time_ = 0;
+}
+
+// Returns true off the test part was skipped.
+static bool TestPartSkipped(const TestPartResult& result) {
+  return result.skipped();
+}
+
+// Returns true if and only if the test was skipped.
+bool TestResult::Skipped() const {
+  return !Failed() && CountIf(test_part_results_, TestPartSkipped) > 0;
+}
+
+// Returns true if and only if the test failed.
+bool TestResult::Failed() const {
+  for (int i = 0; i < total_part_count(); ++i) {
+    if (GetTestPartResult(i).failed())
+      return true;
+  }
+  return false;
+}
+
+// Returns true if and only if the test part fatally failed.
+static bool TestPartFatallyFailed(const TestPartResult& result) {
+  return result.fatally_failed();
+}
+
+// Returns true if and only if the test fatally failed.
+bool TestResult::HasFatalFailure() const {
+  return CountIf(test_part_results_, TestPartFatallyFailed) > 0;
+}
+
+// Returns true if and only if the test part non-fatally failed.
+static bool TestPartNonfatallyFailed(const TestPartResult& result) {
+  return result.nonfatally_failed();
+}
+
+// Returns true if and only if the test has a non-fatal failure.
+bool TestResult::HasNonfatalFailure() const {
+  return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0;
+}
+
+// Gets the number of all test parts.  This is the sum of the number
+// of successful test parts and the number of failed test parts.
+int TestResult::total_part_count() const {
+  return static_cast<int>(test_part_results_.size());
+}
+
+// Returns the number of the test properties.
+int TestResult::test_property_count() const {
+  return static_cast<int>(test_properties_.size());
+}
+
+// class Test
+
+// Creates a Test object.
+
+// The c'tor saves the states of all flags.
+Test::Test()
+    : gtest_flag_saver_(new GTEST_FLAG_SAVER_) {
+}
+
+// The d'tor restores the states of all flags.  The actual work is
+// done by the d'tor of the gtest_flag_saver_ field, and thus not
+// visible here.
+Test::~Test() {
+}
+
+// Sets up the test fixture.
+//
+// A sub-class may override this.
+void Test::SetUp() {
+}
+
+// Tears down the test fixture.
+//
+// A sub-class may override this.
+void Test::TearDown() {
+}
+
+// Allows user supplied key value pairs to be recorded for later output.
+void Test::RecordProperty(const std::string& key, const std::string& value) {
+  UnitTest::GetInstance()->RecordProperty(key, value);
+}
+
+// Allows user supplied key value pairs to be recorded for later output.
+void Test::RecordProperty(const std::string& key, int value) {
+  Message value_message;
+  value_message << value;
+  RecordProperty(key, value_message.GetString().c_str());
+}
+
+namespace internal {
+
+void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
+                                    const std::string& message) {
+  // This function is a friend of UnitTest and as such has access to
+  // AddTestPartResult.
+  UnitTest::GetInstance()->AddTestPartResult(
+      result_type,
+      nullptr,  // No info about the source file where the exception occurred.
+      -1,       // We have no info on which line caused the exception.
+      message,
+      "");  // No stack trace, either.
+}
+
+}  // namespace internal
+
+// Google Test requires all tests in the same test suite to use the same test
+// fixture class.  This function checks if the current test has the
+// same fixture class as the first test in the current test suite.  If
+// yes, it returns true; otherwise it generates a Google Test failure and
+// returns false.
+bool Test::HasSameFixtureClass() {
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  const TestSuite* const test_suite = impl->current_test_suite();
+
+  // Info about the first test in the current test suite.
+  const TestInfo* const first_test_info = test_suite->test_info_list()[0];
+  const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_;
+  const char* const first_test_name = first_test_info->name();
+
+  // Info about the current test.
+  const TestInfo* const this_test_info = impl->current_test_info();
+  const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_;
+  const char* const this_test_name = this_test_info->name();
+
+  if (this_fixture_id != first_fixture_id) {
+    // Is the first test defined using TEST?
+    const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId();
+    // Is this test defined using TEST?
+    const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId();
+
+    if (first_is_TEST || this_is_TEST) {
+      // Both TEST and TEST_F appear in same test suite, which is incorrect.
+      // Tell the user how to fix this.
+
+      // Gets the name of the TEST and the name of the TEST_F.  Note
+      // that first_is_TEST and this_is_TEST cannot both be true, as
+      // the fixture IDs are different for the two tests.
+      const char* const TEST_name =
+          first_is_TEST ? first_test_name : this_test_name;
+      const char* const TEST_F_name =
+          first_is_TEST ? this_test_name : first_test_name;
+
+      ADD_FAILURE()
+          << "All tests in the same test suite must use the same test fixture\n"
+          << "class, so mixing TEST_F and TEST in the same test suite is\n"
+          << "illegal.  In test suite " << this_test_info->test_suite_name()
+          << ",\n"
+          << "test " << TEST_F_name << " is defined using TEST_F but\n"
+          << "test " << TEST_name << " is defined using TEST.  You probably\n"
+          << "want to change the TEST to TEST_F or move it to another test\n"
+          << "case.";
+    } else {
+      // Two fixture classes with the same name appear in two different
+      // namespaces, which is not allowed. Tell the user how to fix this.
+      ADD_FAILURE()
+          << "All tests in the same test suite must use the same test fixture\n"
+          << "class.  However, in test suite "
+          << this_test_info->test_suite_name() << ",\n"
+          << "you defined test " << first_test_name << " and test "
+          << this_test_name << "\n"
+          << "using two different test fixture classes.  This can happen if\n"
+          << "the two classes are from different namespaces or translation\n"
+          << "units and have the same name.  You should probably rename one\n"
+          << "of the classes to put the tests into different test suites.";
+    }
+    return false;
+  }
+
+  return true;
+}
+
+#if GTEST_HAS_SEH
+
+// Adds an "exception thrown" fatal failure to the current test.  This
+// function returns its result via an output parameter pointer because VC++
+// prohibits creation of objects with destructors on stack in functions
+// using __try (see error C2712).
+static std::string* FormatSehExceptionMessage(DWORD exception_code,
+                                              const char* location) {
+  Message message;
+  message << "SEH exception with code 0x" << std::setbase(16) <<
+    exception_code << std::setbase(10) << " thrown in " << location << ".";
+
+  return new std::string(message.GetString());
+}
+
+#endif  // GTEST_HAS_SEH
+
+namespace internal {
+
+#if GTEST_HAS_EXCEPTIONS
+
+// Adds an "exception thrown" fatal failure to the current test.
+static std::string FormatCxxExceptionMessage(const char* description,
+                                             const char* location) {
+  Message message;
+  if (description != nullptr) {
+    message << "C++ exception with description \"" << description << "\"";
+  } else {
+    message << "Unknown C++ exception";
+  }
+  message << " thrown in " << location << ".";
+
+  return message.GetString();
+}
+
+static std::string PrintTestPartResultToString(
+    const TestPartResult& test_part_result);
+
+GoogleTestFailureException::GoogleTestFailureException(
+    const TestPartResult& failure)
+    : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {}
+
+#endif  // GTEST_HAS_EXCEPTIONS
+
+// We put these helper functions in the internal namespace as IBM's xlC
+// compiler rejects the code if they were declared static.
+
+// Runs the given method and handles SEH exceptions it throws, when
+// SEH is supported; returns the 0-value for type Result in case of an
+// SEH exception.  (Microsoft compilers cannot handle SEH and C++
+// exceptions in the same function.  Therefore, we provide a separate
+// wrapper function for handling SEH exceptions.)
+template <class T, typename Result>
+Result HandleSehExceptionsInMethodIfSupported(
+    T* object, Result (T::*method)(), const char* location) {
+#if GTEST_HAS_SEH
+  __try {
+    return (object->*method)();
+  } __except (internal::UnitTestOptions::GTestShouldProcessSEH(  // NOLINT
+      GetExceptionCode())) {
+    // We create the exception message on the heap because VC++ prohibits
+    // creation of objects with destructors on stack in functions using __try
+    // (see error C2712).
+    std::string* exception_message = FormatSehExceptionMessage(
+        GetExceptionCode(), location);
+    internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure,
+                                             *exception_message);
+    delete exception_message;
+    return static_cast<Result>(0);
+  }
+#else
+  (void)location;
+  return (object->*method)();
+#endif  // GTEST_HAS_SEH
+}
+
+// Runs the given method and catches and reports C++ and/or SEH-style
+// exceptions, if they are supported; returns the 0-value for type
+// Result in case of an SEH exception.
+template <class T, typename Result>
+Result HandleExceptionsInMethodIfSupported(
+    T* object, Result (T::*method)(), const char* location) {
+  // NOTE: The user code can affect the way in which Google Test handles
+  // exceptions by setting GTEST_FLAG(catch_exceptions), but only before
+  // RUN_ALL_TESTS() starts. It is technically possible to check the flag
+  // after the exception is caught and either report or re-throw the
+  // exception based on the flag's value:
+  //
+  // try {
+  //   // Perform the test method.
+  // } catch (...) {
+  //   if (GTEST_FLAG(catch_exceptions))
+  //     // Report the exception as failure.
+  //   else
+  //     throw;  // Re-throws the original exception.
+  // }
+  //
+  // However, the purpose of this flag is to allow the program to drop into
+  // the debugger when the exception is thrown. On most platforms, once the
+  // control enters the catch block, the exception origin information is
+  // lost and the debugger will stop the program at the point of the
+  // re-throw in this function -- instead of at the point of the original
+  // throw statement in the code under test.  For this reason, we perform
+  // the check early, sacrificing the ability to affect Google Test's
+  // exception handling in the method where the exception is thrown.
+  if (internal::GetUnitTestImpl()->catch_exceptions()) {
+#if GTEST_HAS_EXCEPTIONS
+    try {
+      return HandleSehExceptionsInMethodIfSupported(object, method, location);
+    } catch (const AssertionException&) {  // NOLINT
+      // This failure was reported already.
+    } catch (const internal::GoogleTestFailureException&) {  // NOLINT
+      // This exception type can only be thrown by a failed Google
+      // Test assertion with the intention of letting another testing
+      // framework catch it.  Therefore we just re-throw it.
+      throw;
+    } catch (const std::exception& e) {  // NOLINT
+      internal::ReportFailureInUnknownLocation(
+          TestPartResult::kFatalFailure,
+          FormatCxxExceptionMessage(e.what(), location));
+    } catch (...) {  // NOLINT
+      internal::ReportFailureInUnknownLocation(
+          TestPartResult::kFatalFailure,
+          FormatCxxExceptionMessage(nullptr, location));
+    }
+    return static_cast<Result>(0);
+#else
+    return HandleSehExceptionsInMethodIfSupported(object, method, location);
+#endif  // GTEST_HAS_EXCEPTIONS
+  } else {
+    return (object->*method)();
+  }
+}
+
+}  // namespace internal
+
+// Runs the test and updates the test result.
+void Test::Run() {
+  if (!HasSameFixtureClass()) return;
+
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
+  // We will run the test only if SetUp() was successful and didn't call
+  // GTEST_SKIP().
+  if (!HasFatalFailure() && !IsSkipped()) {
+    impl->os_stack_trace_getter()->UponLeavingGTest();
+    internal::HandleExceptionsInMethodIfSupported(
+        this, &Test::TestBody, "the test body");
+  }
+
+  // However, we want to clean up as much as possible.  Hence we will
+  // always call TearDown(), even if SetUp() or the test body has
+  // failed.
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  internal::HandleExceptionsInMethodIfSupported(
+      this, &Test::TearDown, "TearDown()");
+}
+
+// Returns true if and only if the current test has a fatal failure.
+bool Test::HasFatalFailure() {
+  return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure();
+}
+
+// Returns true if and only if the current test has a non-fatal failure.
+bool Test::HasNonfatalFailure() {
+  return internal::GetUnitTestImpl()->current_test_result()->
+      HasNonfatalFailure();
+}
+
+// Returns true if and only if the current test was skipped.
+bool Test::IsSkipped() {
+  return internal::GetUnitTestImpl()->current_test_result()->Skipped();
+}
+
+// class TestInfo
+
+// 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,
+                   internal::CodeLocation a_code_location,
+                   internal::TypeId fixture_class_id,
+                   internal::TestFactoryBase* factory)
+    : test_suite_name_(a_test_suite_name),
+      name_(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),
+      fixture_class_id_(fixture_class_id),
+      should_run_(false),
+      is_disabled_(false),
+      matches_filter_(false),
+      is_in_another_shard_(false),
+      factory_(factory),
+      result_() {}
+
+// Destructs a TestInfo object.
+TestInfo::~TestInfo() { delete factory_; }
+
+namespace internal {
+
+// Creates a new TestInfo object and registers it with Google Test;
+// returns the created object.
+//
+// Arguments:
+//
+//   test_suite_name:  name of the test suite
+//   name:             name of the test
+//   type_param:       the name of the test's type parameter, or NULL if
+//                     this is not a typed or a type-parameterized test.
+//   value_param:      text representation of the test's value parameter,
+//                     or NULL if this is not a value-parameterized test.
+//   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
+//   tear_down_tc:     pointer to the function that tears down the test suite
+//   factory:          pointer to the factory that creates a test object.
+//                     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,
+    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);
+  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
+  return test_info;
+}
+
+void ReportInvalidTestSuiteType(const char* test_suite_name,
+                                CodeLocation code_location) {
+  Message errors;
+  errors
+      << "Attempted redefinition of test suite " << test_suite_name << ".\n"
+      << "All tests in the same test suite must use the same test fixture\n"
+      << "class.  However, in test suite " << test_suite_name << ", you tried\n"
+      << "to define a test using a fixture class different from the one\n"
+      << "used earlier. This can happen if the two fixture classes are\n"
+      << "from different namespaces and have the same name. You should\n"
+      << "probably rename one of the classes to put the tests into different\n"
+      << "test suites.";
+
+  GTEST_LOG_(ERROR) << FormatFileLocation(code_location.file.c_str(),
+                                          code_location.line)
+                    << " " << errors.GetString();
+}
+}  // namespace internal
+
+namespace {
+
+// A predicate that checks the test name of a TestInfo against a known
+// value.
+//
+// This is used for implementation of the TestSuite class only.  We put
+// it in the anonymous namespace to prevent polluting the outer
+// namespace.
+//
+// TestNameIs is copyable.
+class TestNameIs {
+ public:
+  // Constructor.
+  //
+  // TestNameIs has NO default constructor.
+  explicit TestNameIs(const char* name)
+      : name_(name) {}
+
+  // Returns true if and only if the test name of test_info matches name_.
+  bool operator()(const TestInfo * test_info) const {
+    return test_info && test_info->name() == name_;
+  }
+
+ private:
+  std::string name_;
+};
+
+}  // namespace
+
+namespace internal {
+
+// This method expands all parameterized tests registered with macros TEST_P
+// and INSTANTIATE_TEST_SUITE_P into regular tests and registers those.
+// This will be done just once during the program runtime.
+void UnitTestImpl::RegisterParameterizedTests() {
+  if (!parameterized_tests_registered_) {
+    parameterized_test_registry_.RegisterTests();
+    type_parameterized_test_registry_.CheckForInstantiations();
+    parameterized_tests_registered_ = true;
+  }
+}
+
+}  // namespace internal
+
+// Creates the test object, runs it, records its result, and then
+// deletes it.
+void TestInfo::Run() {
+  if (!should_run_) return;
+
+  // Tells UnitTest where to store test result.
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  impl->set_current_test_info(this);
+
+  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
+
+  // 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();
+
+  // Creates the test object.
+  Test* const test = internal::HandleExceptionsInMethodIfSupported(
+      factory_, &internal::TestFactoryBase::CreateTest,
+      "the test fixture's constructor");
+
+  // Runs the test if the constructor didn't generate a fatal failure or invoke
+  // GTEST_SKIP().
+  // Note that the object will not be null
+  if (!Test::HasFatalFailure() && !Test::IsSkipped()) {
+    // This doesn't throw as all user code that can throw are wrapped into
+    // exception handling code.
+    test->Run();
+  }
+
+  if (test != nullptr) {
+    // Deletes the test object.
+    impl->os_stack_trace_getter()->UponLeavingGTest();
+    internal::HandleExceptionsInMethodIfSupported(
+        test, &Test::DeleteSelf_, "the test fixture's destructor");
+  }
+
+  result_.set_elapsed_time(timer.Elapsed());
+
+  // Notifies the unit test event listener that a test has just finished.
+  repeater->OnTestEnd(*this);
+
+  // Tells UnitTest to stop associating assertion results to this
+  // test.
+  impl->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);
+
+  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
+
+  // Notifies the unit test event listeners that a test is about to start.
+  repeater->OnTestStart(*this);
+
+  const TestPartResult test_part_result =
+      TestPartResult(TestPartResult::kSkip, this->file(), this->line(), "");
+  impl->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);
+}
+
+// class TestSuite
+
+// Gets the number of successful tests in this test suite.
+int TestSuite::successful_test_count() const {
+  return CountIf(test_info_list_, TestPassed);
+}
+
+// Gets the number of successful tests in this test suite.
+int TestSuite::skipped_test_count() const {
+  return CountIf(test_info_list_, TestSkipped);
+}
+
+// Gets the number of failed tests in this test suite.
+int TestSuite::failed_test_count() const {
+  return CountIf(test_info_list_, TestFailed);
+}
+
+// Gets the number of disabled tests that will be reported in the XML report.
+int TestSuite::reportable_disabled_test_count() const {
+  return CountIf(test_info_list_, TestReportableDisabled);
+}
+
+// Gets the number of disabled tests in this test suite.
+int TestSuite::disabled_test_count() const {
+  return CountIf(test_info_list_, TestDisabled);
+}
+
+// Gets the number of tests to be printed in the XML report.
+int TestSuite::reportable_test_count() const {
+  return CountIf(test_info_list_, TestReportable);
+}
+
+// Get the number of tests in this test suite that should run.
+int TestSuite::test_to_run_count() const {
+  return CountIf(test_info_list_, ShouldRunTest);
+}
+
+// Gets the number of all tests.
+int TestSuite::total_test_count() const {
+  return static_cast<int>(test_info_list_.size());
+}
+
+// Creates a TestSuite with the given name.
+//
+// Arguments:
+//
+//   a_name:       name of the test suite
+//   a_type_param: the name of the test suite's type parameter, or NULL if
+//                 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,
+                     internal::SetUpTestSuiteFunc set_up_tc,
+                     internal::TearDownTestSuiteFunc tear_down_tc)
+    : name_(a_name),
+      type_param_(a_type_param ? new std::string(a_type_param) : nullptr),
+      set_up_tc_(set_up_tc),
+      tear_down_tc_(tear_down_tc),
+      should_run_(false),
+      start_timestamp_(0),
+      elapsed_time_(0) {}
+
+// Destructor of TestSuite.
+TestSuite::~TestSuite() {
+  // Deletes every Test in the collection.
+  ForEach(test_info_list_, internal::Delete<TestInfo>);
+}
+
+// Returns the i-th test among all the tests. i can range from 0 to
+// total_test_count() - 1. If i is not in that range, returns NULL.
+const TestInfo* TestSuite::GetTestInfo(int i) const {
+  const int index = GetElementOr(test_indices_, i, -1);
+  return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
+}
+
+// Returns the i-th test among all the tests. i can range from 0 to
+// total_test_count() - 1. If i is not in that range, returns NULL.
+TestInfo* TestSuite::GetMutableTestInfo(int i) {
+  const int index = GetElementOr(test_indices_, i, -1);
+  return index < 0 ? nullptr : test_info_list_[static_cast<size_t>(index)];
+}
+
+// Adds a test to this test suite.  Will delete the test upon
+// destruction of the TestSuite object.
+void TestSuite::AddTestInfo(TestInfo* test_info) {
+  test_info_list_.push_back(test_info);
+  test_indices_.push_back(static_cast<int>(test_indices_.size()));
+}
+
+// Runs every test in this TestSuite.
+void TestSuite::Run() {
+  if (!should_run_) return;
+
+  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
+  impl->set_current_test_suite(this);
+
+  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
+
+  // Call both legacy and the new API
+  repeater->OnTestSuiteStart(*this);
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  repeater->OnTestCaseStart(*this);
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  internal::HandleExceptionsInMethodIfSupported(
+      this, &TestSuite::RunSetUpTestSuite, "SetUpTestSuite()");
+
+  start_timestamp_ = internal::GetTimeInMillis();
+  internal::Timer timer;
+  for (int i = 0; i < total_test_count(); i++) {
+    GetMutableTestInfo(i)->Run();
+    if (GTEST_FLAG(fail_fast) && GetMutableTestInfo(i)->result()->Failed()) {
+      for (int j = i + 1; j < total_test_count(); j++) {
+        GetMutableTestInfo(j)->Skip();
+      }
+      break;
+    }
+  }
+  elapsed_time_ = timer.Elapsed();
+
+  impl->os_stack_trace_getter()->UponLeavingGTest();
+  internal::HandleExceptionsInMethodIfSupported(
+      this, &TestSuite::RunTearDownTestSuite, "TearDownTestSuite()");
+
+  // Call both legacy and the new API
+  repeater->OnTestSuiteEnd(*this);
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  repeater->OnTestCaseEnd(*this);
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  impl->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);
+
+  TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
+
+  // Call both legacy and the new API
+  repeater->OnTestSuiteStart(*this);
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  repeater->OnTestCaseStart(*this);
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  for (int i = 0; i < total_test_count(); i++) {
+    GetMutableTestInfo(i)->Skip();
+  }
+
+  // Call both legacy and the new API
+  repeater->OnTestSuiteEnd(*this);
+  // Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  repeater->OnTestCaseEnd(*this);
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  impl->set_current_test_suite(nullptr);
+}
+
+// Clears the results of all tests in this test suite.
+void TestSuite::ClearResult() {
+  ad_hoc_test_result_.Clear();
+  ForEach(test_info_list_, TestInfo::ClearTestResult);
+}
+
+// Shuffles the tests in this test suite.
+void TestSuite::ShuffleTests(internal::Random* random) {
+  Shuffle(random, &test_indices_);
+}
+
+// Restores the test order to before the first shuffle.
+void TestSuite::UnshuffleTests() {
+  for (size_t i = 0; i < test_indices_.size(); i++) {
+    test_indices_[i] = static_cast<int>(i);
+  }
+}
+
+// Formats a countable noun.  Depending on its quantity, either the
+// singular form or the plural form is used. e.g.
+//
+// FormatCountableNoun(1, "formula", "formuli") returns "1 formula".
+// FormatCountableNoun(5, "book", "books") returns "5 books".
+static std::string FormatCountableNoun(int count,
+                                       const char * singular_form,
+                                       const char * plural_form) {
+  return internal::StreamableToString(count) + " " +
+      (count == 1 ? singular_form : plural_form);
+}
+
+// Formats the count of tests.
+static std::string FormatTestCount(int test_count) {
+  return FormatCountableNoun(test_count, "test", "tests");
+}
+
+// Formats the count of test suites.
+static std::string FormatTestSuiteCount(int test_suite_count) {
+  return FormatCountableNoun(test_suite_count, "test suite", "test suites");
+}
+
+// Converts a TestPartResult::Type enum to human-friendly string
+// representation.  Both kNonFatalFailure and kFatalFailure are translated
+// to "Failure", as the user usually doesn't care about the difference
+// between the two when viewing the test result.
+static const char * TestPartResultTypeToString(TestPartResult::Type type) {
+  switch (type) {
+    case TestPartResult::kSkip:
+      return "Skipped\n";
+    case TestPartResult::kSuccess:
+      return "Success";
+
+    case TestPartResult::kNonFatalFailure:
+    case TestPartResult::kFatalFailure:
+#ifdef _MSC_VER
+      return "error: ";
+#else
+      return "Failure\n";
+#endif
+    default:
+      return "Unknown result type";
+  }
+}
+
+namespace internal {
+namespace {
+enum class GTestColor { kDefault, kRed, kGreen, kYellow };
+}  // namespace
+
+// Prints a TestPartResult to an std::string.
+static std::string PrintTestPartResultToString(
+    const TestPartResult& test_part_result) {
+  return (Message()
+          << internal::FormatFileLocation(test_part_result.file_name(),
+                                          test_part_result.line_number())
+          << " " << TestPartResultTypeToString(test_part_result.type())
+          << test_part_result.message()).GetString();
+}
+
+// Prints a TestPartResult.
+static void PrintTestPartResult(const TestPartResult& test_part_result) {
+  const std::string& result =
+      PrintTestPartResultToString(test_part_result);
+  printf("%s\n", result.c_str());
+  fflush(stdout);
+  // If the test program runs in Visual Studio or a debugger, the
+  // following statements add the test part result message to the Output
+  // window such that the user can double-click on it to jump to the
+  // corresponding source code location; otherwise they do nothing.
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
+  // We don't call OutputDebugString*() on Windows Mobile, as printing
+  // to stdout is done by OutputDebugString() there already - we don't
+  // want the same message printed twice.
+  ::OutputDebugStringA(result.c_str());
+  ::OutputDebugStringA("\n");
+#endif
+}
+
+// class PrettyUnitTestResultPrinter
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
+    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
+
+// Returns the character attribute for the given color.
+static WORD GetColorAttribute(GTestColor color) {
+  switch (color) {
+    case GTestColor::kRed:
+      return FOREGROUND_RED;
+    case GTestColor::kGreen:
+      return FOREGROUND_GREEN;
+    case GTestColor::kYellow:
+      return FOREGROUND_RED | FOREGROUND_GREEN;
+    default:           return 0;
+  }
+}
+
+static int GetBitOffset(WORD color_mask) {
+  if (color_mask == 0) return 0;
+
+  int bitOffset = 0;
+  while ((color_mask & 1) == 0) {
+    color_mask >>= 1;
+    ++bitOffset;
+  }
+  return bitOffset;
+}
+
+static WORD GetNewColor(GTestColor color, WORD old_color_attrs) {
+  // Let's reuse the BG
+  static const WORD background_mask = BACKGROUND_BLUE | BACKGROUND_GREEN |
+                                      BACKGROUND_RED | BACKGROUND_INTENSITY;
+  static const WORD foreground_mask = FOREGROUND_BLUE | FOREGROUND_GREEN |
+                                      FOREGROUND_RED | FOREGROUND_INTENSITY;
+  const WORD existing_bg = old_color_attrs & background_mask;
+
+  WORD new_color =
+      GetColorAttribute(color) | existing_bg | FOREGROUND_INTENSITY;
+  static const int bg_bitOffset = GetBitOffset(background_mask);
+  static const int fg_bitOffset = GetBitOffset(foreground_mask);
+
+  if (((new_color & background_mask) >> bg_bitOffset) ==
+      ((new_color & foreground_mask) >> fg_bitOffset)) {
+    new_color ^= FOREGROUND_INTENSITY;  // invert intensity
+  }
+  return new_color;
+}
+
+#else
+
+// Returns the ANSI color code for the given color. GTestColor::kDefault is
+// an invalid input.
+static const char* GetAnsiColorCode(GTestColor color) {
+  switch (color) {
+    case GTestColor::kRed:
+      return "1";
+    case GTestColor::kGreen:
+      return "2";
+    case GTestColor::kYellow:
+      return "3";
+    default:
+      return nullptr;
+  }
+}
+
+#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
+
+// Returns true if and only if Google Test should use colors in the output.
+bool ShouldUseColor(bool stdout_is_tty) {
+  const char* const gtest_color = GTEST_FLAG(color).c_str();
+
+  if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
+    // On Windows the TERM variable is usually not set, but the
+    // console there does support colors.
+    return stdout_is_tty;
+#else
+    // On non-Windows platforms, we rely on the TERM variable.
+    const char* const term = posix::GetEnv("TERM");
+    const bool term_supports_color =
+        String::CStringEquals(term, "xterm") ||
+        String::CStringEquals(term, "xterm-color") ||
+        String::CStringEquals(term, "xterm-256color") ||
+        String::CStringEquals(term, "screen") ||
+        String::CStringEquals(term, "screen-256color") ||
+        String::CStringEquals(term, "tmux") ||
+        String::CStringEquals(term, "tmux-256color") ||
+        String::CStringEquals(term, "rxvt-unicode") ||
+        String::CStringEquals(term, "rxvt-unicode-256color") ||
+        String::CStringEquals(term, "linux") ||
+        String::CStringEquals(term, "cygwin");
+    return stdout_is_tty && term_supports_color;
+#endif  // GTEST_OS_WINDOWS
+  }
+
+  return String::CaseInsensitiveCStringEquals(gtest_color, "yes") ||
+      String::CaseInsensitiveCStringEquals(gtest_color, "true") ||
+      String::CaseInsensitiveCStringEquals(gtest_color, "t") ||
+      String::CStringEquals(gtest_color, "1");
+  // We take "yes", "true", "t", and "1" as meaning "yes".  If the
+  // value is neither one of these nor "auto", we treat it as "no" to
+  // be conservative.
+}
+
+// Helpers for printing colored strings to stdout. Note that on Windows, we
+// cannot simply emit special characters and have the terminal change colors.
+// This routine must actually emit the characters rather than return a string
+// that would be colored when printed, as can be done on Linux.
+
+GTEST_ATTRIBUTE_PRINTF_(2, 3)
+static void ColoredPrintf(GTestColor color, const char *fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+
+#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \
+    GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || defined(ESP_PLATFORM)
+  const bool use_color = AlwaysFalse();
+#else
+  static const bool in_color_mode =
+      ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
+  const bool use_color = in_color_mode && (color != GTestColor::kDefault);
+#endif  // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS
+
+  if (!use_color) {
+    vprintf(fmt, args);
+    va_end(args);
+    return;
+  }
+
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
+    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
+  const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
+
+  // Gets the current text color.
+  CONSOLE_SCREEN_BUFFER_INFO buffer_info;
+  GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
+  const WORD old_color_attrs = buffer_info.wAttributes;
+  const WORD new_color = GetNewColor(color, old_color_attrs);
+
+  // We need to flush the stream buffers into the console before each
+  // SetConsoleTextAttribute call lest it affect the text that is already
+  // printed but has not yet reached the console.
+  fflush(stdout);
+  SetConsoleTextAttribute(stdout_handle, new_color);
+
+  vprintf(fmt, args);
+
+  fflush(stdout);
+  // Restores the text color.
+  SetConsoleTextAttribute(stdout_handle, old_color_attrs);
+#else
+  printf("\033[0;3%sm", GetAnsiColorCode(color));
+  vprintf(fmt, args);
+  printf("\033[m");  // Resets the terminal to default.
+#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
+  va_end(args);
+}
+
+// Text printed in Google Test's text output and --gtest_list_tests
+// output to label the type parameter and value parameter for a test.
+static const char kTypeParamLabel[] = "TypeParam";
+static const char kValueParamLabel[] = "GetParam()";
+
+static void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
+  const char* const type_param = test_info.type_param();
+  const char* const value_param = test_info.value_param();
+
+  if (type_param != nullptr || value_param != nullptr) {
+    printf(", where ");
+    if (type_param != nullptr) {
+      printf("%s = %s", kTypeParamLabel, type_param);
+      if (value_param != nullptr) printf(" and ");
+    }
+    if (value_param != nullptr) {
+      printf("%s = %s", kValueParamLabel, value_param);
+    }
+  }
+}
+
+// This class implements the TestEventListener interface.
+//
+// Class PrettyUnitTestResultPrinter is copyable.
+class PrettyUnitTestResultPrinter : public TestEventListener {
+ public:
+  PrettyUnitTestResultPrinter() {}
+  static void PrintTestName(const char* test_suite, const char* test) {
+    printf("%s.%s", test_suite, test);
+  }
+
+  // The following methods override what's in the TestEventListener class.
+  void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
+  void OnTestIterationStart(const UnitTest& unit_test, int iteration) override;
+  void OnEnvironmentsSetUpStart(const UnitTest& unit_test) override;
+  void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestCaseStart(const TestCase& test_case) override;
+#else
+  void OnTestSuiteStart(const TestSuite& test_suite) override;
+#endif  // OnTestCaseStart
+
+  void OnTestStart(const TestInfo& test_info) override;
+
+  void OnTestPartResult(const TestPartResult& result) override;
+  void OnTestEnd(const TestInfo& test_info) override;
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestCaseEnd(const TestCase& test_case) override;
+#else
+  void OnTestSuiteEnd(const TestSuite& test_suite) override;
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  void OnEnvironmentsTearDownStart(const UnitTest& unit_test) override;
+  void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}
+  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
+  void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
+
+ private:
+  static void PrintFailedTests(const UnitTest& unit_test);
+  static void PrintFailedTestSuites(const UnitTest& unit_test);
+  static void PrintSkippedTests(const UnitTest& unit_test);
+};
+
+  // Fired before each iteration of tests starts.
+void PrettyUnitTestResultPrinter::OnTestIterationStart(
+    const UnitTest& unit_test, int iteration) {
+  if (GTEST_FLAG(repeat) != 1)
+    printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
+
+  const char* const filter = GTEST_FLAG(filter).c_str();
+
+  // Prints the filter if it's not *.  This reminds the user that some
+  // tests may be skipped.
+  if (!String::CStringEquals(filter, kUniversalFilter)) {
+    ColoredPrintf(GTestColor::kYellow, "Note: %s filter = %s\n", GTEST_NAME_,
+                  filter);
+  }
+
+  if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
+    const int32_t shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
+    ColoredPrintf(GTestColor::kYellow, "Note: This is test shard %d of %s.\n",
+                  static_cast<int>(shard_index) + 1,
+                  internal::posix::GetEnv(kTestTotalShards));
+  }
+
+  if (GTEST_FLAG(shuffle)) {
+    ColoredPrintf(GTestColor::kYellow,
+                  "Note: Randomizing tests' orders with a seed of %d .\n",
+                  unit_test.random_seed());
+  }
+
+  ColoredPrintf(GTestColor::kGreen, "[==========] ");
+  printf("Running %s from %s.\n",
+         FormatTestCount(unit_test.test_to_run_count()).c_str(),
+         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
+  fflush(stdout);
+}
+
+void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart(
+    const UnitTest& /*unit_test*/) {
+  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  printf("Global test environment set-up.\n");
+  fflush(stdout);
+}
+
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
+  const std::string counts =
+      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
+  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  printf("%s from %s", counts.c_str(), test_case.name());
+  if (test_case.type_param() == nullptr) {
+    printf("\n");
+  } else {
+    printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
+  }
+  fflush(stdout);
+}
+#else
+void PrettyUnitTestResultPrinter::OnTestSuiteStart(
+    const TestSuite& test_suite) {
+  const std::string counts =
+      FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests");
+  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  printf("%s from %s", counts.c_str(), test_suite.name());
+  if (test_suite.type_param() == nullptr) {
+    printf("\n");
+  } else {
+    printf(", where %s = %s\n", kTypeParamLabel, test_suite.type_param());
+  }
+  fflush(stdout);
+}
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) {
+  ColoredPrintf(GTestColor::kGreen, "[ RUN      ] ");
+  PrintTestName(test_info.test_suite_name(), test_info.name());
+  printf("\n");
+  fflush(stdout);
+}
+
+// Called after an assertion failure.
+void PrettyUnitTestResultPrinter::OnTestPartResult(
+    const TestPartResult& result) {
+  switch (result.type()) {
+    // If the test part succeeded, we don't need to do anything.
+    case TestPartResult::kSuccess:
+      return;
+    default:
+      // Print failure message from the assertion
+      // (e.g. expected this and got that).
+      PrintTestPartResult(result);
+      fflush(stdout);
+  }
+}
+
+void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
+  if (test_info.result()->Passed()) {
+    ColoredPrintf(GTestColor::kGreen, "[       OK ] ");
+  } else if (test_info.result()->Skipped()) {
+    ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
+  } else {
+    ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
+  }
+  PrintTestName(test_info.test_suite_name(), test_info.name());
+  if (test_info.result()->Failed())
+    PrintFullTestCommentIfPresent(test_info);
+
+  if (GTEST_FLAG(print_time)) {
+    printf(" (%s ms)\n", internal::StreamableToString(
+           test_info.result()->elapsed_time()).c_str());
+  } else {
+    printf("\n");
+  }
+  fflush(stdout);
+}
+
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) {
+  if (!GTEST_FLAG(print_time)) return;
+
+  const std::string counts =
+      FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
+  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_case.name(),
+         internal::StreamableToString(test_case.elapsed_time()).c_str());
+  fflush(stdout);
+}
+#else
+void PrettyUnitTestResultPrinter::OnTestSuiteEnd(const TestSuite& test_suite) {
+  if (!GTEST_FLAG(print_time)) return;
+
+  const std::string counts =
+      FormatCountableNoun(test_suite.test_to_run_count(), "test", "tests");
+  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_suite.name(),
+         internal::StreamableToString(test_suite.elapsed_time()).c_str());
+  fflush(stdout);
+}
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart(
+    const UnitTest& /*unit_test*/) {
+  ColoredPrintf(GTestColor::kGreen, "[----------] ");
+  printf("Global test environment tear-down\n");
+  fflush(stdout);
+}
+
+// Internal helper for printing the list of failed tests.
+void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) {
+  const int failed_test_count = unit_test.failed_test_count();
+  ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
+  printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str());
+
+  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
+    const TestSuite& test_suite = *unit_test.GetTestSuite(i);
+    if (!test_suite.should_run() || (test_suite.failed_test_count() == 0)) {
+      continue;
+    }
+    for (int j = 0; j < test_suite.total_test_count(); ++j) {
+      const TestInfo& test_info = *test_suite.GetTestInfo(j);
+      if (!test_info.should_run() || !test_info.result()->Failed()) {
+        continue;
+      }
+      ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
+      printf("%s.%s", test_suite.name(), test_info.name());
+      PrintFullTestCommentIfPresent(test_info);
+      printf("\n");
+    }
+  }
+  printf("\n%2d FAILED %s\n", failed_test_count,
+         failed_test_count == 1 ? "TEST" : "TESTS");
+}
+
+// Internal helper for printing the list of test suite failures not covered by
+// PrintFailedTests.
+void PrettyUnitTestResultPrinter::PrintFailedTestSuites(
+    const UnitTest& unit_test) {
+  int suite_failure_count = 0;
+  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
+    const TestSuite& test_suite = *unit_test.GetTestSuite(i);
+    if (!test_suite.should_run()) {
+      continue;
+    }
+    if (test_suite.ad_hoc_test_result().Failed()) {
+      ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
+      printf("%s: SetUpTestSuite or TearDownTestSuite\n", test_suite.name());
+      ++suite_failure_count;
+    }
+  }
+  if (suite_failure_count > 0) {
+    printf("\n%2d FAILED TEST %s\n", suite_failure_count,
+           suite_failure_count == 1 ? "SUITE" : "SUITES");
+  }
+}
+
+// Internal helper for printing the list of skipped tests.
+void PrettyUnitTestResultPrinter::PrintSkippedTests(const UnitTest& unit_test) {
+  const int skipped_test_count = unit_test.skipped_test_count();
+  if (skipped_test_count == 0) {
+    return;
+  }
+
+  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
+    const TestSuite& test_suite = *unit_test.GetTestSuite(i);
+    if (!test_suite.should_run() || (test_suite.skipped_test_count() == 0)) {
+      continue;
+    }
+    for (int j = 0; j < test_suite.total_test_count(); ++j) {
+      const TestInfo& test_info = *test_suite.GetTestInfo(j);
+      if (!test_info.should_run() || !test_info.result()->Skipped()) {
+        continue;
+      }
+      ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
+      printf("%s.%s", test_suite.name(), test_info.name());
+      printf("\n");
+    }
+  }
+}
+
+void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
+                                                     int /*iteration*/) {
+  ColoredPrintf(GTestColor::kGreen, "[==========] ");
+  printf("%s from %s ran.",
+         FormatTestCount(unit_test.test_to_run_count()).c_str(),
+         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
+  if (GTEST_FLAG(print_time)) {
+    printf(" (%s ms total)",
+           internal::StreamableToString(unit_test.elapsed_time()).c_str());
+  }
+  printf("\n");
+  ColoredPrintf(GTestColor::kGreen, "[  PASSED  ] ");
+  printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
+
+  const int skipped_test_count = unit_test.skipped_test_count();
+  if (skipped_test_count > 0) {
+    ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
+    printf("%s, listed below:\n", FormatTestCount(skipped_test_count).c_str());
+    PrintSkippedTests(unit_test);
+  }
+
+  if (!unit_test.Passed()) {
+    PrintFailedTests(unit_test);
+    PrintFailedTestSuites(unit_test);
+  }
+
+  int num_disabled = unit_test.reportable_disabled_test_count();
+  if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
+    if (unit_test.Passed()) {
+      printf("\n");  // Add a spacer if no FAILURE banner is displayed.
+    }
+    ColoredPrintf(GTestColor::kYellow, "  YOU HAVE %d DISABLED %s\n\n",
+                  num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
+  }
+  // Ensure that Google Test output is printed before, e.g., heapchecker output.
+  fflush(stdout);
+}
+
+// End PrettyUnitTestResultPrinter
+
+// This class implements the TestEventListener interface.
+//
+// Class BriefUnitTestResultPrinter is copyable.
+class BriefUnitTestResultPrinter : public TestEventListener {
+ public:
+  BriefUnitTestResultPrinter() {}
+  static void PrintTestName(const char* test_suite, const char* test) {
+    printf("%s.%s", test_suite, test);
+  }
+
+  // The following methods override what's in the TestEventListener class.
+  void OnTestProgramStart(const UnitTest& /*unit_test*/) override {}
+  void OnTestIterationStart(const UnitTest& /*unit_test*/,
+                            int /*iteration*/) override {}
+  void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) override {}
+  void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) override {}
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestCaseStart(const TestCase& /*test_case*/) override {}
+#else
+  void OnTestSuiteStart(const TestSuite& /*test_suite*/) override {}
+#endif  // OnTestCaseStart
+
+  void OnTestStart(const TestInfo& /*test_info*/) override {}
+
+  void OnTestPartResult(const TestPartResult& result) override;
+  void OnTestEnd(const TestInfo& test_info) override;
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestCaseEnd(const TestCase& /*test_case*/) override {}
+#else
+  void OnTestSuiteEnd(const TestSuite& /*test_suite*/) override {}
+#endif  // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+  void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) override {}
+  void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) override {}
+  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
+  void OnTestProgramEnd(const UnitTest& /*unit_test*/) override {}
+};
+
+// Called after an assertion failure.
+void BriefUnitTestResultPrinter::OnTestPartResult(
+    const TestPartResult& result) {
+  switch (result.type()) {
+    // If the test part succeeded, we don't need to do anything.
+    case TestPartResult::kSuccess:
+      return;
+    default:
+      // Print failure message from the assertion
+      // (e.g. expected this and got that).
+      PrintTestPartResult(result);
+      fflush(stdout);
+  }
+}
+
+void BriefUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) {
+  if (test_info.result()->Failed()) {
+    ColoredPrintf(GTestColor::kRed, "[  FAILED  ] ");
+    PrintTestName(test_info.test_suite_name(), test_info.name());
+    PrintFullTestCommentIfPresent(test_info);
+
+    if (GTEST_FLAG(print_time)) {
+      printf(" (%s ms)\n",
+             internal::StreamableToString(test_info.result()->elapsed_time())
+                 .c_str());
+    } else {
+      printf("\n");
+    }
+    fflush(stdout);
+  }
+}
+
+void BriefUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
+                                                    int /*iteration*/) {
+  ColoredPrintf(GTestColor::kGreen, "[==========] ");
+  printf("%s from %s ran.",
+         FormatTestCount(unit_test.test_to_run_count()).c_str(),
+         FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
+  if (GTEST_FLAG(print_time)) {
+    printf(" (%s ms total)",
+           internal::StreamableToString(unit_test.elapsed_time()).c_str());
+  }
+  printf("\n");
+  ColoredPrintf(GTestColor::kGreen, "[  PASSED  ] ");
+  printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str());
+
+  const int skipped_test_count = unit_test.skipped_test_count();
+  if (skipped_test_count > 0) {
+    ColoredPrintf(GTestColor::kGreen, "[  SKIPPED ] ");
+    printf("%s.\n", FormatTestCount(skipped_test_count).c_str());
+  }
+
+  int num_disabled = unit_test.reportable_disabled_test_count();
+  if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) {
+    if (unit_test.Passed()) {
+      printf("\n");  // Add a spacer if no FAILURE banner is displayed.
+    }
+    ColoredPrintf(GTestColor::kYellow, "  YOU HAVE %d DISABLED %s\n\n",
+                  num_disabled, num_disabled == 1 ? "TEST" : "TESTS");
+  }
+  // Ensure that Google Test output is printed before, e.g., heapchecker output.
+  fflush(stdout);
+}
+
+// End BriefUnitTestResultPrinter
+
+// class TestEventRepeater
+//
+// This class forwards events to other event listeners.
+class TestEventRepeater : public TestEventListener {
+ public:
+  TestEventRepeater() : forwarding_enabled_(true) {}
+  ~TestEventRepeater() override;
+  void Append(TestEventListener *listener);
+  TestEventListener* Release(TestEventListener* listener);
+
+  // Controls whether events will be forwarded to listeners_. Set to false
+  // in death test child processes.
+  bool forwarding_enabled() const { return forwarding_enabled_; }
+  void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; }
+
+  void OnTestProgramStart(const UnitTest& unit_test) override;
+  void OnTestIterationStart(const UnitTest& unit_test, int iteration) override;
+  void OnEnvironmentsSetUpStart(const UnitTest& unit_test) override;
+  void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) override;
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestCaseStart(const TestSuite& parameter) override;
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestSuiteStart(const TestSuite& parameter) override;
+  void OnTestStart(const TestInfo& test_info) override;
+  void OnTestPartResult(const TestPartResult& result) override;
+  void OnTestEnd(const TestInfo& test_info) override;
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestCaseEnd(const TestCase& parameter) override;
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+  void OnTestSuiteEnd(const TestSuite& parameter) override;
+  void OnEnvironmentsTearDownStart(const UnitTest& unit_test) override;
+  void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) override;
+  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
+  void OnTestProgramEnd(const UnitTest& unit_test) override;
+
+ private:
+  // Controls whether events will be forwarded to listeners_. Set to false
+  // in death test child processes.
+  bool forwarding_enabled_;
+  // The list of listeners that receive events.
+  std::vector<TestEventListener*> listeners_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater);
+};
+
+TestEventRepeater::~TestEventRepeater() {
+  ForEach(listeners_, Delete<TestEventListener>);
+}
+
+void TestEventRepeater::Append(TestEventListener *listener) {
+  listeners_.push_back(listener);
+}
+
+TestEventListener* TestEventRepeater::Release(TestEventListener *listener) {
+  for (size_t i = 0; i < listeners_.size(); ++i) {
+    if (listeners_[i] == listener) {
+      listeners_.erase(listeners_.begin() + static_cast<int>(i));
+      return listener;
+    }
+  }
+
+  return nullptr;
+}
+
+// Since most methods are very similar, use macros to reduce boilerplate.
+// This defines a member that forwards the call to all listeners.
+#define GTEST_REPEATER_METHOD_(Name, Type) \
+void TestEventRepeater::Name(const Type& parameter) { \
+  if (forwarding_enabled_) { \
+    for (size_t i = 0; i < listeners_.size(); i++) { \
+      listeners_[i]->Name(parameter); \
+    } \
+  } \
+}
+// This defines a member that forwards the call to all listeners in reverse
+// order.
+#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type)      \
+  void TestEventRepeater::Name(const Type& parameter) { \
+    if (forwarding_enabled_) {                          \
+      for (size_t i = listeners_.size(); i != 0; i--) { \
+        listeners_[i - 1]->Name(parameter);             \
+      }                                                 \
+    }                                                   \
+  }
+
+GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest)
+GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest)
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+GTEST_REPEATER_METHOD_(OnTestCaseStart, TestSuite)
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+GTEST_REPEATER_METHOD_(OnTestSuiteStart, TestSuite)
+GTEST_REPEATER_METHOD_(OnTestStart, TestInfo)
+GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult)
+GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest)
+GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest)
+GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest)
+GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo)
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestSuite)
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+GTEST_REVERSE_REPEATER_METHOD_(OnTestSuiteEnd, TestSuite)
+GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest)
+
+#undef GTEST_REPEATER_METHOD_
+#undef GTEST_REVERSE_REPEATER_METHOD_
+
+void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test,
+                                             int iteration) {
+  if (forwarding_enabled_) {
+    for (size_t i = 0; i < listeners_.size(); i++) {
+      listeners_[i]->OnTestIterationStart(unit_test, iteration);
+    }
+  }
+}
+
+void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test,
+                                           int iteration) {
+  if (forwarding_enabled_) {
+    for (size_t i = listeners_.size(); i > 0; i--) {
+      listeners_[i - 1]->OnTestIterationEnd(unit_test, iteration);
+    }
+  }
+}
+
+// End TestEventRepeater
+
+// This class generates an XML output file.
+class XmlUnitTestResultPrinter : public EmptyTestEventListener {
+ public:
+  explicit XmlUnitTestResultPrinter(const char* output_file);
+
+  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
+  void ListTestsMatchingFilter(const std::vector<TestSuite*>& test_suites);
+
+  // Prints an XML summary of all unit tests.
+  static void PrintXmlTestsList(std::ostream* stream,
+                                const std::vector<TestSuite*>& test_suites);
+
+ private:
+  // Is c a whitespace character that is normalized to a space character
+  // when it appears in an XML attribute value?
+  static bool IsNormalizableWhitespace(char c) {
+    return c == 0x9 || c == 0xA || c == 0xD;
+  }
+
+  // May c appear in a well-formed XML document?
+  static bool IsValidXmlCharacter(char c) {
+    return IsNormalizableWhitespace(c) || c >= 0x20;
+  }
+
+  // Returns an XML-escaped copy of the input string str.  If
+  // is_attribute is true, the text is meant to appear as an attribute
+  // value, and normalizable whitespace is preserved by replacing it
+  // with character references.
+  static std::string EscapeXml(const std::string& str, bool is_attribute);
+
+  // Returns the given string with all characters invalid in XML removed.
+  static std::string RemoveInvalidXmlCharacters(const std::string& str);
+
+  // Convenience wrapper around EscapeXml when str is an attribute value.
+  static std::string EscapeXmlAttribute(const std::string& str) {
+    return EscapeXml(str, true);
+  }
+
+  // Convenience wrapper around EscapeXml when str is not an attribute value.
+  static std::string EscapeXmlText(const char* str) {
+    return EscapeXml(str, false);
+  }
+
+  // Verifies that the given attribute belongs to the given element and
+  // streams the attribute as XML.
+  static void OutputXmlAttribute(std::ostream* stream,
+                                 const std::string& element_name,
+                                 const std::string& name,
+                                 const std::string& value);
+
+  // Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
+  static void OutputXmlCDataSection(::std::ostream* stream, const char* data);
+
+  // Streams a test suite XML stanza containing the given test result.
+  //
+  // Requires: result.Failed()
+  static void OutputXmlTestSuiteForTestResult(::std::ostream* stream,
+                                              const TestResult& result);
+
+  // Streams an XML representation of a TestResult object.
+  static void OutputXmlTestResult(::std::ostream* stream,
+                                  const TestResult& result);
+
+  // Streams an XML representation of a TestInfo object.
+  static void OutputXmlTestInfo(::std::ostream* stream,
+                                const char* test_suite_name,
+                                const TestInfo& test_info);
+
+  // Prints an XML representation of a TestSuite object
+  static void PrintXmlTestSuite(::std::ostream* stream,
+                                const TestSuite& test_suite);
+
+  // Prints an XML summary of unit_test to output stream out.
+  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);
+
+  // The output file.
+  const std::string output_file_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter);
+};
+
+// Creates a new XmlUnitTestResultPrinter.
+XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
+    : output_file_(output_file) {
+  if (output_file_.empty()) {
+    GTEST_LOG_(FATAL) << "XML output file may not be null";
+  }
+}
+
+// Called after the unit test ends.
+void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
+                                                  int /*iteration*/) {
+  FILE* xmlout = OpenFileForWriting(output_file_);
+  std::stringstream stream;
+  PrintXmlUnitTest(&stream, unit_test);
+  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
+  fclose(xmlout);
+}
+
+void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
+    const std::vector<TestSuite*>& test_suites) {
+  FILE* xmlout = OpenFileForWriting(output_file_);
+  std::stringstream stream;
+  PrintXmlTestsList(&stream, test_suites);
+  fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
+  fclose(xmlout);
+}
+
+// Returns an XML-escaped copy of the input string str.  If is_attribute
+// is true, the text is meant to appear as an attribute value, and
+// normalizable whitespace is preserved by replacing it with character
+// references.
+//
+// Invalid XML characters in str, if any, are stripped from the output.
+// It is expected that most, if not all, of the text processed by this
+// module will consist of ordinary English text.
+// If this module is ever modified to produce version 1.1 XML output,
+// most invalid characters can be retained using character references.
+std::string XmlUnitTestResultPrinter::EscapeXml(
+    const std::string& str, bool is_attribute) {
+  Message m;
+
+  for (size_t i = 0; i < str.size(); ++i) {
+    const char ch = str[i];
+    switch (ch) {
+      case '<':
+        m << "&lt;";
+        break;
+      case '>':
+        m << "&gt;";
+        break;
+      case '&':
+        m << "&amp;";
+        break;
+      case '\'':
+        if (is_attribute)
+          m << "&apos;";
+        else
+          m << '\'';
+        break;
+      case '"':
+        if (is_attribute)
+          m << "&quot;";
+        else
+          m << '"';
+        break;
+      default:
+        if (IsValidXmlCharacter(ch)) {
+          if (is_attribute && IsNormalizableWhitespace(ch))
+            m << "&#x" << String::FormatByte(static_cast<unsigned char>(ch))
+              << ";";
+          else
+            m << ch;
+        }
+        break;
+    }
+  }
+
+  return m.GetString();
+}
+
+// Returns the given string with all characters invalid in XML removed.
+// Currently invalid characters are dropped from the string. An
+// alternative is to replace them with certain characters such as . or ?.
+std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(
+    const std::string& str) {
+  std::string output;
+  output.reserve(str.size());
+  for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
+    if (IsValidXmlCharacter(*it))
+      output.push_back(*it);
+
+  return output;
+}
+
+// The following routines generate an XML representation of a UnitTest
+// object.
+// GOOGLETEST_CM0009 DO NOT DELETE
+//
+// This is how Google Test concepts map to the DTD:
+//
+// <testsuites name="AllTests">        <-- corresponds to a UnitTest object
+//   <testsuite name="testcase-name">  <-- corresponds to a TestSuite object
+//     <testcase name="test-name">     <-- corresponds to a TestInfo object
+//       <failure message="...">...</failure>
+//       <failure message="...">...</failure>
+//       <failure message="...">...</failure>
+//                                     <-- individual assertion failures
+//     </testcase>
+//   </testsuite>
+// </testsuites>
+
+// Formats the given time in milliseconds as seconds.
+std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
+  ::std::stringstream ss;
+  ss << (static_cast<double>(ms) * 1e-3);
+  return ss.str();
+}
+
+static bool PortableLocaltime(time_t seconds, struct tm* out) {
+#if defined(_MSC_VER)
+  return localtime_s(out, &seconds) == 0;
+#elif defined(__MINGW32__) || defined(__MINGW64__)
+  // MINGW <time.h> provides neither localtime_r nor localtime_s, but uses
+  // Windows' localtime(), which has a thread-local tm buffer.
+  struct tm* tm_ptr = localtime(&seconds);  // NOLINT
+  if (tm_ptr == nullptr) return false;
+  *out = *tm_ptr;
+  return true;
+#elif defined(__STDC_LIB_EXT1__)
+  // Uses localtime_s when available as localtime_r is only available from
+  // C23 standard.
+  return localtime_s(&seconds, out) != nullptr;
+#else
+  return localtime_r(&seconds, out) != nullptr;
+#endif
+}
+
+// Converts the given epoch time in milliseconds to a date string in the ISO
+// 8601 format, without the timezone information.
+std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
+  struct tm time_struct;
+  if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
+    return "";
+  // YYYY-MM-DDThh:mm:ss.sss
+  return StreamableToString(time_struct.tm_year + 1900) + "-" +
+      String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
+      String::FormatIntWidth2(time_struct.tm_mday) + "T" +
+      String::FormatIntWidth2(time_struct.tm_hour) + ":" +
+      String::FormatIntWidth2(time_struct.tm_min) + ":" +
+      String::FormatIntWidth2(time_struct.tm_sec) + "." +
+      String::FormatIntWidthN(static_cast<int>(ms % 1000), 3);
+}
+
+// Streams an XML CDATA section, escaping invalid CDATA sequences as needed.
+void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream,
+                                                     const char* data) {
+  const char* segment = data;
+  *stream << "<![CDATA[";
+  for (;;) {
+    const char* const next_segment = strstr(segment, "]]>");
+    if (next_segment != nullptr) {
+      stream->write(
+          segment, static_cast<std::streamsize>(next_segment - segment));
+      *stream << "]]>]]&gt;<![CDATA[";
+      segment = next_segment + strlen("]]>");
+    } else {
+      *stream << segment;
+      break;
+    }
+  }
+  *stream << "]]>";
+}
+
+void XmlUnitTestResultPrinter::OutputXmlAttribute(
+    std::ostream* stream,
+    const std::string& element_name,
+    const std::string& name,
+    const std::string& value) {
+  const std::vector<std::string>& allowed_names =
+      GetReservedOutputAttributesForElement(element_name);
+
+  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
+                   allowed_names.end())
+      << "Attribute " << name << " is not allowed for element <" << element_name
+      << ">.";
+
+  *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\"";
+}
+
+// Streams a test suite XML stanza containing the given test result.
+void XmlUnitTestResultPrinter::OutputXmlTestSuiteForTestResult(
+    ::std::ostream* stream, const TestResult& result) {
+  // Output the boilerplate for a minimal test suite with one test.
+  *stream << "  <testsuite";
+  OutputXmlAttribute(stream, "testsuite", "name", "NonTestSuiteFailure");
+  OutputXmlAttribute(stream, "testsuite", "tests", "1");
+  OutputXmlAttribute(stream, "testsuite", "failures", "1");
+  OutputXmlAttribute(stream, "testsuite", "disabled", "0");
+  OutputXmlAttribute(stream, "testsuite", "skipped", "0");
+  OutputXmlAttribute(stream, "testsuite", "errors", "0");
+  OutputXmlAttribute(stream, "testsuite", "time",
+                     FormatTimeInMillisAsSeconds(result.elapsed_time()));
+  OutputXmlAttribute(
+      stream, "testsuite", "timestamp",
+      FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
+  *stream << ">";
+
+  // Output the boilerplate for a minimal test case with a single test.
+  *stream << "    <testcase";
+  OutputXmlAttribute(stream, "testcase", "name", "");
+  OutputXmlAttribute(stream, "testcase", "status", "run");
+  OutputXmlAttribute(stream, "testcase", "result", "completed");
+  OutputXmlAttribute(stream, "testcase", "classname", "");
+  OutputXmlAttribute(stream, "testcase", "time",
+                     FormatTimeInMillisAsSeconds(result.elapsed_time()));
+  OutputXmlAttribute(
+      stream, "testcase", "timestamp",
+      FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
+
+  // Output the actual test result.
+  OutputXmlTestResult(stream, result);
+
+  // Complete the test suite.
+  *stream << "  </testsuite>\n";
+}
+
+// Prints an XML representation of a TestInfo object.
+void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
+                                                 const char* test_suite_name,
+                                                 const TestInfo& test_info) {
+  const TestResult& result = *test_info.result();
+  const std::string kTestsuite = "testcase";
+
+  if (test_info.is_in_another_shard()) {
+    return;
+  }
+
+  *stream << "    <testcase";
+  OutputXmlAttribute(stream, kTestsuite, "name", test_info.name());
+
+  if (test_info.value_param() != nullptr) {
+    OutputXmlAttribute(stream, kTestsuite, "value_param",
+                       test_info.value_param());
+  }
+  if (test_info.type_param() != nullptr) {
+    OutputXmlAttribute(stream, kTestsuite, "type_param",
+                       test_info.type_param());
+  }
+  if (GTEST_FLAG(list_tests)) {
+    OutputXmlAttribute(stream, kTestsuite, "file", test_info.file());
+    OutputXmlAttribute(stream, kTestsuite, "line",
+                       StreamableToString(test_info.line()));
+    *stream << " />\n";
+    return;
+  }
+
+  OutputXmlAttribute(stream, kTestsuite, "status",
+                     test_info.should_run() ? "run" : "notrun");
+  OutputXmlAttribute(stream, kTestsuite, "result",
+                     test_info.should_run()
+                         ? (result.Skipped() ? "skipped" : "completed")
+                         : "suppressed");
+  OutputXmlAttribute(stream, kTestsuite, "time",
+                     FormatTimeInMillisAsSeconds(result.elapsed_time()));
+  OutputXmlAttribute(
+      stream, kTestsuite, "timestamp",
+      FormatEpochTimeInMillisAsIso8601(result.start_timestamp()));
+  OutputXmlAttribute(stream, kTestsuite, "classname", test_suite_name);
+
+  OutputXmlTestResult(stream, result);
+}
+
+void XmlUnitTestResultPrinter::OutputXmlTestResult(::std::ostream* stream,
+                                                   const TestResult& result) {
+  int failures = 0;
+  int skips = 0;
+  for (int i = 0; i < result.total_part_count(); ++i) {
+    const TestPartResult& part = result.GetTestPartResult(i);
+    if (part.failed()) {
+      if (++failures == 1 && skips == 0) {
+        *stream << ">\n";
+      }
+      const std::string location =
+          internal::FormatCompilerIndependentFileLocation(part.file_name(),
+                                                          part.line_number());
+      const std::string summary = location + "\n" + part.summary();
+      *stream << "      <failure message=\""
+              << EscapeXmlAttribute(summary)
+              << "\" type=\"\">";
+      const std::string detail = location + "\n" + part.message();
+      OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
+      *stream << "</failure>\n";
+    } else if (part.skipped()) {
+      if (++skips == 1 && failures == 0) {
+        *stream << ">\n";
+      }
+      const std::string location =
+          internal::FormatCompilerIndependentFileLocation(part.file_name(),
+                                                          part.line_number());
+      const std::string summary = location + "\n" + part.summary();
+      *stream << "      <skipped message=\""
+              << EscapeXmlAttribute(summary.c_str()) << "\">";
+      const std::string detail = location + "\n" + part.message();
+      OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str());
+      *stream << "</skipped>\n";
+    }
+  }
+
+  if (failures == 0 && skips == 0 && result.test_property_count() == 0) {
+    *stream << " />\n";
+  } else {
+    if (failures == 0 && skips == 0) {
+      *stream << ">\n";
+    }
+    OutputXmlTestProperties(stream, result);
+    *stream << "    </testcase>\n";
+  }
+}
+
+// Prints an XML representation of a TestSuite object
+void XmlUnitTestResultPrinter::PrintXmlTestSuite(std::ostream* stream,
+                                                 const TestSuite& test_suite) {
+  const std::string kTestsuite = "testsuite";
+  *stream << "  <" << kTestsuite;
+  OutputXmlAttribute(stream, kTestsuite, "name", test_suite.name());
+  OutputXmlAttribute(stream, kTestsuite, "tests",
+                     StreamableToString(test_suite.reportable_test_count()));
+  if (!GTEST_FLAG(list_tests)) {
+    OutputXmlAttribute(stream, kTestsuite, "failures",
+                       StreamableToString(test_suite.failed_test_count()));
+    OutputXmlAttribute(
+        stream, kTestsuite, "disabled",
+        StreamableToString(test_suite.reportable_disabled_test_count()));
+    OutputXmlAttribute(stream, kTestsuite, "skipped",
+                       StreamableToString(test_suite.skipped_test_count()));
+
+    OutputXmlAttribute(stream, kTestsuite, "errors", "0");
+
+    OutputXmlAttribute(stream, kTestsuite, "time",
+                       FormatTimeInMillisAsSeconds(test_suite.elapsed_time()));
+    OutputXmlAttribute(
+        stream, kTestsuite, "timestamp",
+        FormatEpochTimeInMillisAsIso8601(test_suite.start_timestamp()));
+    *stream << TestPropertiesAsXmlAttributes(test_suite.ad_hoc_test_result());
+  }
+  *stream << ">\n";
+  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));
+  }
+  *stream << "  </" << kTestsuite << ">\n";
+}
+
+// Prints an XML summary of unit_test to output stream out.
+void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream,
+                                                const UnitTest& unit_test) {
+  const std::string kTestsuites = "testsuites";
+
+  *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+  *stream << "<" << kTestsuites;
+
+  OutputXmlAttribute(stream, kTestsuites, "tests",
+                     StreamableToString(unit_test.reportable_test_count()));
+  OutputXmlAttribute(stream, kTestsuites, "failures",
+                     StreamableToString(unit_test.failed_test_count()));
+  OutputXmlAttribute(
+      stream, kTestsuites, "disabled",
+      StreamableToString(unit_test.reportable_disabled_test_count()));
+  OutputXmlAttribute(stream, kTestsuites, "errors", "0");
+  OutputXmlAttribute(stream, kTestsuites, "time",
+                     FormatTimeInMillisAsSeconds(unit_test.elapsed_time()));
+  OutputXmlAttribute(
+      stream, kTestsuites, "timestamp",
+      FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp()));
+
+  if (GTEST_FLAG(shuffle)) {
+    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";
+
+  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));
+  }
+
+  // If there was a test failure outside of one of the test suites (like in a
+  // test environment) include that in the output.
+  if (unit_test.ad_hoc_test_result().Failed()) {
+    OutputXmlTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result());
+  }
+
+  *stream << "</" << kTestsuites << ">\n";
+}
+
+void XmlUnitTestResultPrinter::PrintXmlTestsList(
+    std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
+  const std::string kTestsuites = "testsuites";
+
+  *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+  *stream << "<" << kTestsuites;
+
+  int total_tests = 0;
+  for (auto test_suite : test_suites) {
+    total_tests += test_suite->total_test_count();
+  }
+  OutputXmlAttribute(stream, kTestsuites, "tests",
+                     StreamableToString(total_tests));
+  OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
+  *stream << ">\n";
+
+  for (auto test_suite : test_suites) {
+    PrintXmlTestSuite(stream, *test_suite);
+  }
+  *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) {
+  const std::string kProperties = "properties";
+  const std::string kProperty = "property";
+
+  if (result.test_property_count() <= 0) {
+    return;
+  }
+
+  *stream << "<" << kProperties << ">\n";
+  for (int i = 0; i < result.test_property_count(); ++i) {
+    const TestProperty& property = result.GetTestProperty(i);
+    *stream << "<" << kProperty;
+    *stream << " name=\"" << EscapeXmlAttribute(property.key()) << "\"";
+    *stream << " value=\"" << EscapeXmlAttribute(property.value()) << "\"";
+    *stream << "/>\n";
+  }
+  *stream << "</" << kProperties << ">\n";
+}
+
+// End XmlUnitTestResultPrinter
+
+// This class generates an JSON output file.
+class JsonUnitTestResultPrinter : public EmptyTestEventListener {
+ public:
+  explicit JsonUnitTestResultPrinter(const char* output_file);
+
+  void OnTestIterationEnd(const UnitTest& unit_test, int iteration) override;
+
+  // Prints an JSON summary of all unit tests.
+  static void PrintJsonTestList(::std::ostream* stream,
+                                const std::vector<TestSuite*>& test_suites);
+
+ private:
+  // Returns an JSON-escaped copy of the input string str.
+  static std::string EscapeJson(const std::string& str);
+
+  //// Verifies that the given attribute belongs to the given element and
+  //// streams the attribute as JSON.
+  static void OutputJsonKey(std::ostream* stream,
+                            const std::string& element_name,
+                            const std::string& name,
+                            const std::string& value,
+                            const std::string& indent,
+                            bool comma = true);
+  static void OutputJsonKey(std::ostream* stream,
+                            const std::string& element_name,
+                            const std::string& name,
+                            int value,
+                            const std::string& indent,
+                            bool comma = true);
+
+  // Streams a test suite JSON stanza containing the given test result.
+  //
+  // Requires: result.Failed()
+  static void OutputJsonTestSuiteForTestResult(::std::ostream* stream,
+                                               const TestResult& result);
+
+  // Streams a JSON representation of a TestResult object.
+  static void OutputJsonTestResult(::std::ostream* stream,
+                                   const TestResult& result);
+
+  // Streams a JSON representation of a TestInfo object.
+  static void OutputJsonTestInfo(::std::ostream* stream,
+                                 const char* test_suite_name,
+                                 const TestInfo& test_info);
+
+  // Prints a JSON representation of a TestSuite object
+  static void PrintJsonTestSuite(::std::ostream* stream,
+                                 const TestSuite& test_suite);
+
+  // Prints a JSON summary of unit_test to output stream out.
+  static void PrintJsonUnitTest(::std::ostream* stream,
+                                const UnitTest& unit_test);
+
+  // Produces a string representing the test properties in a result as
+  // a JSON dictionary.
+  static std::string TestPropertiesAsJson(const TestResult& result,
+                                          const std::string& indent);
+
+  // The output file.
+  const std::string output_file_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(JsonUnitTestResultPrinter);
+};
+
+// Creates a new JsonUnitTestResultPrinter.
+JsonUnitTestResultPrinter::JsonUnitTestResultPrinter(const char* output_file)
+    : output_file_(output_file) {
+  if (output_file_.empty()) {
+    GTEST_LOG_(FATAL) << "JSON output file may not be null";
+  }
+}
+
+void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
+                                                  int /*iteration*/) {
+  FILE* jsonout = OpenFileForWriting(output_file_);
+  std::stringstream stream;
+  PrintJsonUnitTest(&stream, unit_test);
+  fprintf(jsonout, "%s", StringStreamToString(&stream).c_str());
+  fclose(jsonout);
+}
+
+// Returns an JSON-escaped copy of the input string str.
+std::string JsonUnitTestResultPrinter::EscapeJson(const std::string& str) {
+  Message m;
+
+  for (size_t i = 0; i < str.size(); ++i) {
+    const char ch = str[i];
+    switch (ch) {
+      case '\\':
+      case '"':
+      case '/':
+        m << '\\' << ch;
+        break;
+      case '\b':
+        m << "\\b";
+        break;
+      case '\t':
+        m << "\\t";
+        break;
+      case '\n':
+        m << "\\n";
+        break;
+      case '\f':
+        m << "\\f";
+        break;
+      case '\r':
+        m << "\\r";
+        break;
+      default:
+        if (ch < ' ') {
+          m << "\\u00" << String::FormatByte(static_cast<unsigned char>(ch));
+        } else {
+          m << ch;
+        }
+        break;
+    }
+  }
+
+  return m.GetString();
+}
+
+// The following routines generate an JSON representation of a UnitTest
+// object.
+
+// Formats the given time in milliseconds as seconds.
+static std::string FormatTimeInMillisAsDuration(TimeInMillis ms) {
+  ::std::stringstream ss;
+  ss << (static_cast<double>(ms) * 1e-3) << "s";
+  return ss.str();
+}
+
+// Converts the given epoch time in milliseconds to a date string in the
+// RFC3339 format, without the timezone information.
+static std::string FormatEpochTimeInMillisAsRFC3339(TimeInMillis ms) {
+  struct tm time_struct;
+  if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
+    return "";
+  // YYYY-MM-DDThh:mm:ss
+  return StreamableToString(time_struct.tm_year + 1900) + "-" +
+      String::FormatIntWidth2(time_struct.tm_mon + 1) + "-" +
+      String::FormatIntWidth2(time_struct.tm_mday) + "T" +
+      String::FormatIntWidth2(time_struct.tm_hour) + ":" +
+      String::FormatIntWidth2(time_struct.tm_min) + ":" +
+      String::FormatIntWidth2(time_struct.tm_sec) + "Z";
+}
+
+static inline std::string Indent(size_t width) {
+  return std::string(width, ' ');
+}
+
+void JsonUnitTestResultPrinter::OutputJsonKey(
+    std::ostream* stream,
+    const std::string& element_name,
+    const std::string& name,
+    const std::string& value,
+    const std::string& indent,
+    bool comma) {
+  const std::vector<std::string>& allowed_names =
+      GetReservedOutputAttributesForElement(element_name);
+
+  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
+                   allowed_names.end())
+      << "Key \"" << name << "\" is not allowed for value \"" << element_name
+      << "\".";
+
+  *stream << indent << "\"" << name << "\": \"" << EscapeJson(value) << "\"";
+  if (comma)
+    *stream << ",\n";
+}
+
+void JsonUnitTestResultPrinter::OutputJsonKey(
+    std::ostream* stream,
+    const std::string& element_name,
+    const std::string& name,
+    int value,
+    const std::string& indent,
+    bool comma) {
+  const std::vector<std::string>& allowed_names =
+      GetReservedOutputAttributesForElement(element_name);
+
+  GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) !=
+                   allowed_names.end())
+      << "Key \"" << name << "\" is not allowed for value \"" << element_name
+      << "\".";
+
+  *stream << indent << "\"" << name << "\": " << StreamableToString(value);
+  if (comma)
+    *stream << ",\n";
+}
+
+// Streams a test suite JSON stanza containing the given test result.
+void JsonUnitTestResultPrinter::OutputJsonTestSuiteForTestResult(
+    ::std::ostream* stream, const TestResult& result) {
+  // Output the boilerplate for a new test suite.
+  *stream << Indent(4) << "{\n";
+  OutputJsonKey(stream, "testsuite", "name", "NonTestSuiteFailure", Indent(6));
+  OutputJsonKey(stream, "testsuite", "tests", 1, Indent(6));
+  if (!GTEST_FLAG(list_tests)) {
+    OutputJsonKey(stream, "testsuite", "failures", 1, Indent(6));
+    OutputJsonKey(stream, "testsuite", "disabled", 0, Indent(6));
+    OutputJsonKey(stream, "testsuite", "skipped", 0, Indent(6));
+    OutputJsonKey(stream, "testsuite", "errors", 0, Indent(6));
+    OutputJsonKey(stream, "testsuite", "time",
+                  FormatTimeInMillisAsDuration(result.elapsed_time()),
+                  Indent(6));
+    OutputJsonKey(stream, "testsuite", "timestamp",
+                  FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
+                  Indent(6));
+  }
+  *stream << Indent(6) << "\"testsuite\": [\n";
+
+  // Output the boilerplate for a new test case.
+  *stream << Indent(8) << "{\n";
+  OutputJsonKey(stream, "testcase", "name", "", Indent(10));
+  OutputJsonKey(stream, "testcase", "status", "RUN", Indent(10));
+  OutputJsonKey(stream, "testcase", "result", "COMPLETED", Indent(10));
+  OutputJsonKey(stream, "testcase", "timestamp",
+                FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
+                Indent(10));
+  OutputJsonKey(stream, "testcase", "time",
+                FormatTimeInMillisAsDuration(result.elapsed_time()),
+                Indent(10));
+  OutputJsonKey(stream, "testcase", "classname", "", Indent(10), false);
+  *stream << TestPropertiesAsJson(result, Indent(10));
+
+  // 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.
+void JsonUnitTestResultPrinter::OutputJsonTestInfo(::std::ostream* stream,
+                                                   const char* test_suite_name,
+                                                   const TestInfo& test_info) {
+  const TestResult& result = *test_info.result();
+  const std::string kTestsuite = "testcase";
+  const std::string kIndent = Indent(10);
+
+  *stream << Indent(8) << "{\n";
+  OutputJsonKey(stream, kTestsuite, "name", test_info.name(), kIndent);
+
+  if (test_info.value_param() != nullptr) {
+    OutputJsonKey(stream, kTestsuite, "value_param", test_info.value_param(),
+                  kIndent);
+  }
+  if (test_info.type_param() != nullptr) {
+    OutputJsonKey(stream, kTestsuite, "type_param", test_info.type_param(),
+                  kIndent);
+  }
+  if (GTEST_FLAG(list_tests)) {
+    OutputJsonKey(stream, kTestsuite, "file", test_info.file(), kIndent);
+    OutputJsonKey(stream, kTestsuite, "line", test_info.line(), kIndent, false);
+    *stream << "\n" << Indent(8) << "}";
+    return;
+  }
+
+  OutputJsonKey(stream, kTestsuite, "status",
+                test_info.should_run() ? "RUN" : "NOTRUN", kIndent);
+  OutputJsonKey(stream, kTestsuite, "result",
+                test_info.should_run()
+                    ? (result.Skipped() ? "SKIPPED" : "COMPLETED")
+                    : "SUPPRESSED",
+                kIndent);
+  OutputJsonKey(stream, kTestsuite, "timestamp",
+                FormatEpochTimeInMillisAsRFC3339(result.start_timestamp()),
+                kIndent);
+  OutputJsonKey(stream, kTestsuite, "time",
+                FormatTimeInMillisAsDuration(result.elapsed_time()), kIndent);
+  OutputJsonKey(stream, kTestsuite, "classname", test_suite_name, kIndent,
+                false);
+  *stream << TestPropertiesAsJson(result, kIndent);
+
+  OutputJsonTestResult(stream, result);
+}
+
+void JsonUnitTestResultPrinter::OutputJsonTestResult(::std::ostream* stream,
+                                                     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";
+      }
+      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 << "]";
+  *stream << "\n" << Indent(8) << "}";
+}
+
+// Prints an JSON representation of a TestSuite object
+void JsonUnitTestResultPrinter::PrintJsonTestSuite(
+    std::ostream* stream, const TestSuite& test_suite) {
+  const std::string kTestsuite = "testsuite";
+  const std::string kIndent = Indent(6);
+
+  *stream << Indent(4) << "{\n";
+  OutputJsonKey(stream, kTestsuite, "name", test_suite.name(), kIndent);
+  OutputJsonKey(stream, kTestsuite, "tests", test_suite.reportable_test_count(),
+                kIndent);
+  if (!GTEST_FLAG(list_tests)) {
+    OutputJsonKey(stream, kTestsuite, "failures",
+                  test_suite.failed_test_count(), kIndent);
+    OutputJsonKey(stream, kTestsuite, "disabled",
+                  test_suite.reportable_disabled_test_count(), kIndent);
+    OutputJsonKey(stream, kTestsuite, "errors", 0, kIndent);
+    OutputJsonKey(
+        stream, kTestsuite, "timestamp",
+        FormatEpochTimeInMillisAsRFC3339(test_suite.start_timestamp()),
+        kIndent);
+    OutputJsonKey(stream, kTestsuite, "time",
+                  FormatTimeInMillisAsDuration(test_suite.elapsed_time()),
+                  kIndent, false);
+    *stream << TestPropertiesAsJson(test_suite.ad_hoc_test_result(), kIndent)
+            << ",\n";
+  }
+
+  *stream << kIndent << "\"" << kTestsuite << "\": [\n";
+
+  bool comma = false;
+  for (int i = 0; i < test_suite.total_test_count(); ++i) {
+    if (test_suite.GetTestInfo(i)->is_reportable()) {
+      if (comma) {
+        *stream << ",\n";
+      } else {
+        comma = true;
+      }
+      OutputJsonTestInfo(stream, test_suite.name(), *test_suite.GetTestInfo(i));
+    }
+  }
+  *stream << "\n" << kIndent << "]\n" << Indent(4) << "}";
+}
+
+// Prints a JSON summary of unit_test to output stream out.
+void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream,
+                                                  const UnitTest& unit_test) {
+  const std::string kTestsuites = "testsuites";
+  const std::string kIndent = Indent(2);
+  *stream << "{\n";
+
+  OutputJsonKey(stream, kTestsuites, "tests", unit_test.reportable_test_count(),
+                kIndent);
+  OutputJsonKey(stream, kTestsuites, "failures", unit_test.failed_test_count(),
+                kIndent);
+  OutputJsonKey(stream, kTestsuites, "disabled",
+                unit_test.reportable_disabled_test_count(), kIndent);
+  OutputJsonKey(stream, kTestsuites, "errors", 0, kIndent);
+  if (GTEST_FLAG(shuffle)) {
+    OutputJsonKey(stream, kTestsuites, "random_seed", unit_test.random_seed(),
+                  kIndent);
+  }
+  OutputJsonKey(stream, kTestsuites, "timestamp",
+                FormatEpochTimeInMillisAsRFC3339(unit_test.start_timestamp()),
+                kIndent);
+  OutputJsonKey(stream, kTestsuites, "time",
+                FormatTimeInMillisAsDuration(unit_test.elapsed_time()), kIndent,
+                false);
+
+  *stream << TestPropertiesAsJson(unit_test.ad_hoc_test_result(), kIndent)
+          << ",\n";
+
+  OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);
+  *stream << kIndent << "\"" << kTestsuites << "\": [\n";
+
+  bool comma = false;
+  for (int i = 0; i < unit_test.total_test_suite_count(); ++i) {
+    if (unit_test.GetTestSuite(i)->reportable_test_count() > 0) {
+      if (comma) {
+        *stream << ",\n";
+      } else {
+        comma = true;
+      }
+      PrintJsonTestSuite(stream, *unit_test.GetTestSuite(i));
+    }
+  }
+
+  // If there was a test failure outside of one of the test suites (like in a
+  // test environment) include that in the output.
+  if (unit_test.ad_hoc_test_result().Failed()) {
+    OutputJsonTestSuiteForTestResult(stream, unit_test.ad_hoc_test_result());
+  }
+
+  *stream << "\n" << kIndent << "]\n" << "}\n";
+}
+
+void JsonUnitTestResultPrinter::PrintJsonTestList(
+    std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
+  const std::string kTestsuites = "testsuites";
+  const std::string kIndent = Indent(2);
+  *stream << "{\n";
+  int total_tests = 0;
+  for (auto test_suite : test_suites) {
+    total_tests += test_suite->total_test_count();
+  }
+  OutputJsonKey(stream, kTestsuites, "tests", total_tests, kIndent);
+
+  OutputJsonKey(stream, kTestsuites, "name", "AllTests", kIndent);
+  *stream << kIndent << "\"" << kTestsuites << "\": [\n";
+
+  for (size_t i = 0; i < test_suites.size(); ++i) {
+    if (i != 0) {
+      *stream << ",\n";
+    }
+    PrintJsonTestSuite(stream, *test_suites[i]);
+  }
+
+  *stream << "\n"
+          << kIndent << "]\n"
+          << "}\n";
+}
+// Produces a string representing the test properties in a result as
+// a JSON dictionary.
+std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
+    const TestResult& result, const std::string& indent) {
+  Message attributes;
+  for (int i = 0; i < result.test_property_count(); ++i) {
+    const TestProperty& property = result.GetTestProperty(i);
+    attributes << ",\n" << indent << "\"" << property.key() << "\": "
+               << "\"" << EscapeJson(property.value()) << "\"";
+  }
+  return attributes.GetString();
+}
+
+// End JsonUnitTestResultPrinter
+
+#if GTEST_CAN_STREAM_RESULTS_
+
+// Checks if str contains '=', '&', '%' or '\n' characters. If yes,
+// replaces them by "%xx" where xx is their hexadecimal value. For
+// example, replaces "=" with "%3D".  This algorithm is O(strlen(str))
+// in both time and space -- important as the input str may contain an
+// arbitrarily long test failure message and stack trace.
+std::string StreamingListener::UrlEncode(const char* str) {
+  std::string result;
+  result.reserve(strlen(str) + 1);
+  for (char ch = *str; ch != '\0'; ch = *++str) {
+    switch (ch) {
+      case '%':
+      case '=':
+      case '&':
+      case '\n':
+        result.append("%" + String::FormatByte(static_cast<unsigned char>(ch)));
+        break;
+      default:
+        result.push_back(ch);
+        break;
+    }
+  }
+  return result;
+}
+
+void StreamingListener::SocketWriter::MakeConnection() {
+  GTEST_CHECK_(sockfd_ == -1)
+      << "MakeConnection() can't be called when there is already a connection.";
+
+  addrinfo hints;
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = AF_UNSPEC;    // To allow both IPv4 and IPv6 addresses.
+  hints.ai_socktype = SOCK_STREAM;
+  addrinfo* servinfo = nullptr;
+
+  // Use the getaddrinfo() to get a linked list of IP addresses for
+  // the given host name.
+  const int error_num = getaddrinfo(
+      host_name_.c_str(), port_num_.c_str(), &hints, &servinfo);
+  if (error_num != 0) {
+    GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: "
+                        << gai_strerror(error_num);
+  }
+
+  // Loop through all the results and connect to the first we can.
+  for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != nullptr;
+       cur_addr = cur_addr->ai_next) {
+    sockfd_ = socket(
+        cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol);
+    if (sockfd_ != -1) {
+      // Connect the client socket to the server socket.
+      if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) {
+        close(sockfd_);
+        sockfd_ = -1;
+      }
+    }
+  }
+
+  freeaddrinfo(servinfo);  // all done with this structure
+
+  if (sockfd_ == -1) {
+    GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to "
+                        << host_name_ << ":" << port_num_;
+  }
+}
+
+// End of class Streaming Listener
+#endif  // GTEST_CAN_STREAM_RESULTS__
+
+// class OsStackTraceGetter
+
+const char* const OsStackTraceGetterInterface::kElidedFramesMarker =
+    "... " GTEST_NAME_ " internal frames ...";
+
+std::string OsStackTraceGetter::CurrentStackTrace(int max_depth, int skip_count)
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+#if GTEST_HAS_ABSL
+  std::string result;
+
+  if (max_depth <= 0) {
+    return result;
+  }
+
+  max_depth = std::min(max_depth, kMaxStackTraceDepth);
+
+  std::vector<void*> raw_stack(max_depth);
+  // Skips the frames requested by the caller, plus this function.
+  const int raw_stack_size =
+      absl::GetStackTrace(&raw_stack[0], max_depth, skip_count + 1);
+
+  void* caller_frame = nullptr;
+  {
+    MutexLock lock(&mutex_);
+    caller_frame = caller_frame_;
+  }
+
+  for (int i = 0; i < raw_stack_size; ++i) {
+    if (raw_stack[i] == caller_frame &&
+        !GTEST_FLAG(show_internal_stack_frames)) {
+      // Add a marker to the trace and stop adding frames.
+      absl::StrAppend(&result, kElidedFramesMarker, "\n");
+      break;
+    }
+
+    char tmp[1024];
+    const char* symbol = "(unknown)";
+    if (absl::Symbolize(raw_stack[i], tmp, sizeof(tmp))) {
+      symbol = tmp;
+    }
+
+    char line[1024];
+    snprintf(line, sizeof(line), "  %p: %s\n", raw_stack[i], symbol);
+    result += line;
+  }
+
+  return result;
+
+#else  // !GTEST_HAS_ABSL
+  static_cast<void>(max_depth);
+  static_cast<void>(skip_count);
+  return "";
+#endif  // GTEST_HAS_ABSL
+}
+
+void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) {
+#if GTEST_HAS_ABSL
+  void* caller_frame = nullptr;
+  if (absl::GetStackTrace(&caller_frame, 1, 3) <= 0) {
+    caller_frame = nullptr;
+  }
+
+  MutexLock lock(&mutex_);
+  caller_frame_ = caller_frame;
+#endif  // GTEST_HAS_ABSL
+}
+
+// A helper class that creates the premature-exit file in its
+// constructor and deletes the file in its destructor.
+class ScopedPrematureExitFile {
+ public:
+  explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
+      : premature_exit_filepath_(premature_exit_filepath ?
+                                 premature_exit_filepath : "") {
+    // If a path to the premature-exit file is specified...
+    if (!premature_exit_filepath_.empty()) {
+      // create the file with a single "0" character in it.  I/O
+      // errors are ignored as there's nothing better we can do and we
+      // don't want to fail the test because of this.
+      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
+      fwrite("0", 1, 1, pfile);
+      fclose(pfile);
+    }
+  }
+
+  ~ScopedPrematureExitFile() {
+#if !defined GTEST_OS_ESP8266
+    if (!premature_exit_filepath_.empty()) {
+      int retval = remove(premature_exit_filepath_.c_str());
+      if (retval) {
+        GTEST_LOG_(ERROR) << "Failed to remove premature exit filepath \""
+                          << premature_exit_filepath_ << "\" with error "
+                          << retval;
+      }
+    }
+#endif
+  }
+
+ private:
+  const std::string premature_exit_filepath_;
+
+  GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile);
+};
+
+}  // namespace internal
+
+// class TestEventListeners
+
+TestEventListeners::TestEventListeners()
+    : repeater_(new internal::TestEventRepeater()),
+      default_result_printer_(nullptr),
+      default_xml_generator_(nullptr) {}
+
+TestEventListeners::~TestEventListeners() { delete repeater_; }
+
+// Returns the standard listener responsible for the default console
+// output.  Can be removed from the listeners list to shut down default
+// console output.  Note that removing this object from the listener list
+// with Release transfers its ownership to the user.
+void TestEventListeners::Append(TestEventListener* listener) {
+  repeater_->Append(listener);
+}
+
+// Removes the given event listener from the list and returns it.  It then
+// becomes the caller's responsibility to delete the listener. Returns
+// NULL if the listener is not found in the list.
+TestEventListener* TestEventListeners::Release(TestEventListener* listener) {
+  if (listener == default_result_printer_)
+    default_result_printer_ = nullptr;
+  else if (listener == default_xml_generator_)
+    default_xml_generator_ = nullptr;
+  return repeater_->Release(listener);
+}
+
+// Returns repeater that broadcasts the TestEventListener events to all
+// subscribers.
+TestEventListener* TestEventListeners::repeater() { return repeater_; }
+
+// Sets the default_result_printer attribute to the provided listener.
+// The listener is also added to the listener list and previous
+// default_result_printer is removed from it and deleted. The listener can
+// also be NULL in which case it will not be added to the list. Does
+// nothing if the previous and the current listener objects are the same.
+void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) {
+  if (default_result_printer_ != listener) {
+    // It is an error to pass this method a listener that is already in the
+    // list.
+    delete Release(default_result_printer_);
+    default_result_printer_ = listener;
+    if (listener != nullptr) Append(listener);
+  }
+}
+
+// Sets the default_xml_generator attribute to the provided listener.  The
+// listener is also added to the listener list and previous
+// default_xml_generator is removed from it and deleted. The listener can
+// also be NULL in which case it will not be added to the list. Does
+// nothing if the previous and the current listener objects are the same.
+void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) {
+  if (default_xml_generator_ != listener) {
+    // It is an error to pass this method a listener that is already in the
+    // list.
+    delete Release(default_xml_generator_);
+    default_xml_generator_ = listener;
+    if (listener != nullptr) Append(listener);
+  }
+}
+
+// Controls whether events will be forwarded by the repeater to the
+// listeners in the list.
+bool TestEventListeners::EventForwardingEnabled() const {
+  return repeater_->forwarding_enabled();
+}
+
+void TestEventListeners::SuppressEventForwarding() {
+  repeater_->set_forwarding_enabled(false);
+}
+
+// class UnitTest
+
+// Gets the singleton UnitTest object.  The first time this method is
+// called, a UnitTest object is constructed and returned.  Consecutive
+// calls will return the same object.
+//
+// We don't protect this under mutex_ as a user is not supposed to
+// call this before main() starts, from which point on the return
+// value will never change.
+UnitTest* UnitTest::GetInstance() {
+  // CodeGear C++Builder insists on a public destructor for the
+  // default implementation.  Use this implementation to keep good OO
+  // design with private destructor.
+
+#if defined(__BORLANDC__)
+  static UnitTest* const instance = new UnitTest;
+  return instance;
+#else
+  static UnitTest instance;
+  return &instance;
+#endif  // defined(__BORLANDC__)
+}
+
+// Gets the number of successful test suites.
+int UnitTest::successful_test_suite_count() const {
+  return impl()->successful_test_suite_count();
+}
+
+// Gets the number of failed test suites.
+int UnitTest::failed_test_suite_count() const {
+  return impl()->failed_test_suite_count();
+}
+
+// Gets the number of all test suites.
+int UnitTest::total_test_suite_count() const {
+  return impl()->total_test_suite_count();
+}
+
+// Gets the number of all test suites that contain at least one test
+// that should run.
+int UnitTest::test_suite_to_run_count() const {
+  return impl()->test_suite_to_run_count();
+}
+
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+int UnitTest::successful_test_case_count() const {
+  return impl()->successful_test_suite_count();
+}
+int UnitTest::failed_test_case_count() const {
+  return impl()->failed_test_suite_count();
+}
+int UnitTest::total_test_case_count() const {
+  return impl()->total_test_suite_count();
+}
+int UnitTest::test_case_to_run_count() const {
+  return impl()->test_suite_to_run_count();
+}
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+// Gets the number of successful tests.
+int UnitTest::successful_test_count() const {
+  return impl()->successful_test_count();
+}
+
+// Gets the number of skipped tests.
+int UnitTest::skipped_test_count() const {
+  return impl()->skipped_test_count();
+}
+
+// Gets the number of failed tests.
+int UnitTest::failed_test_count() const { return impl()->failed_test_count(); }
+
+// Gets the number of disabled tests that will be reported in the XML report.
+int UnitTest::reportable_disabled_test_count() const {
+  return impl()->reportable_disabled_test_count();
+}
+
+// Gets the number of disabled tests.
+int UnitTest::disabled_test_count() const {
+  return impl()->disabled_test_count();
+}
+
+// Gets the number of tests to be printed in the XML report.
+int UnitTest::reportable_test_count() const {
+  return impl()->reportable_test_count();
+}
+
+// Gets the number of all tests.
+int UnitTest::total_test_count() const { return impl()->total_test_count(); }
+
+// Gets the number of tests that should run.
+int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); }
+
+// Gets the time of the test program start, in ms from the start of the
+// UNIX epoch.
+internal::TimeInMillis UnitTest::start_timestamp() const {
+    return impl()->start_timestamp();
+}
+
+// Gets the elapsed time, in milliseconds.
+internal::TimeInMillis UnitTest::elapsed_time() const {
+  return impl()->elapsed_time();
+}
+
+// Returns true if and only if the unit test passed (i.e. all test suites
+// passed).
+bool UnitTest::Passed() const { return impl()->Passed(); }
+
+// Returns true if and only if the unit test failed (i.e. some test suite
+// failed or something outside of all tests failed).
+bool UnitTest::Failed() const { return impl()->Failed(); }
+
+// Gets the i-th test suite among all the test suites. i can range from 0 to
+// total_test_suite_count() - 1. If i is not in that range, returns NULL.
+const TestSuite* UnitTest::GetTestSuite(int i) const {
+  return impl()->GetTestSuite(i);
+}
+
+//  Legacy API is deprecated but still available
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+const TestCase* UnitTest::GetTestCase(int i) const {
+  return impl()->GetTestCase(i);
+}
+#endif  //  GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+
+// Returns the TestResult containing information on test failures and
+// properties logged outside of individual test suites.
+const TestResult& UnitTest::ad_hoc_test_result() const {
+  return *impl()->ad_hoc_test_result();
+}
+
+// Gets the i-th test suite among all the test suites. i can range from 0 to
+// total_test_suite_count() - 1. If i is not in that range, returns NULL.
+TestSuite* UnitTest::GetMutableTestSuite(int i) {
+  return impl()->GetMutableSuiteCase(i);
+}
+
+// Returns the list of event listeners that can be used to track events
+// inside Google Test.
+TestEventListeners& UnitTest::listeners() {
+  return *impl()->listeners();
+}
+
+// Registers and returns a global test environment.  When a test
+// program is run, all global test environments will be set-up in the
+// order they were registered.  After all tests in the program have
+// finished, all global test environments will be torn-down in the
+// *reverse* order they were registered.
+//
+// The UnitTest object takes ownership of the given environment.
+//
+// We don't protect this under mutex_, as we only support calling it
+// from the main thread.
+Environment* UnitTest::AddEnvironment(Environment* env) {
+  if (env == nullptr) {
+    return nullptr;
+  }
+
+  impl_->environments().push_back(env);
+  return env;
+}
+
+// Adds a TestPartResult to the current TestResult object.  All Google Test
+// assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call
+// this to report their results.  The user code should use the
+// assertion macros instead of calling this directly.
+void UnitTest::AddTestPartResult(
+    TestPartResult::Type result_type,
+    const char* file_name,
+    int line_number,
+    const std::string& message,
+    const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) {
+  Message msg;
+  msg << message;
+
+  internal::MutexLock lock(&mutex_);
+  if (impl_->gtest_trace_stack().size() > 0) {
+    msg << "\n" << GTEST_NAME_ << " trace:";
+
+    for (size_t i = impl_->gtest_trace_stack().size(); i > 0; --i) {
+      const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1];
+      msg << "\n" << internal::FormatFileLocation(trace.file, trace.line)
+          << " " << trace.message;
+    }
+  }
+
+  if (os_stack_trace.c_str() != nullptr && !os_stack_trace.empty()) {
+    msg << internal::kStackTraceMarker << os_stack_trace;
+  }
+
+  const TestPartResult result = TestPartResult(
+      result_type, file_name, line_number, msg.GetString().c_str());
+  impl_->GetTestPartResultReporterForCurrentThread()->
+      ReportTestPartResult(result);
+
+  if (result_type != TestPartResult::kSuccess &&
+      result_type != TestPartResult::kSkip) {
+    // gtest_break_on_failure takes precedence over
+    // gtest_throw_on_failure.  This allows a user to set the latter
+    // in the code (perhaps in order to use Google Test assertions
+    // with another testing framework) and specify the former on the
+    // command line for debugging.
+    if (GTEST_FLAG(break_on_failure)) {
+#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+      // Using DebugBreak on Windows allows gtest to still break into a debugger
+      // when a failure happens and both the --gtest_break_on_failure and
+      // the --gtest_catch_exceptions flags are specified.
+      DebugBreak();
+#elif (!defined(__native_client__)) &&            \
+    ((defined(__clang__) || defined(__GNUC__)) && \
+     (defined(__x86_64__) || defined(__i386__)))
+      // with clang/gcc we can achieve the same effect on x86 by invoking int3
+      asm("int3");
+#else
+      // Dereference nullptr through a volatile pointer to prevent the compiler
+      // from removing. We use this rather than abort() or __builtin_trap() for
+      // portability: some debuggers don't correctly trap abort().
+      *static_cast<volatile int*>(nullptr) = 1;
+#endif  // GTEST_OS_WINDOWS
+    } else if (GTEST_FLAG(throw_on_failure)) {
+#if GTEST_HAS_EXCEPTIONS
+      throw internal::GoogleTestFailureException(result);
+#else
+      // We cannot call abort() as it generates a pop-up in debug mode
+      // that cannot be suppressed in VC 7.1 or below.
+      exit(1);
+#endif
+    }
+  }
+}
+
+// Adds a TestProperty to the current TestResult object when invoked from
+// inside a test, to current TestSuite's ad_hoc_test_result_ when invoked
+// from SetUpTestSuite or TearDownTestSuite, or to the global property set
+// when invoked elsewhere.  If the result already contains a property with
+// the same key, the value will be updated.
+void UnitTest::RecordProperty(const std::string& key,
+                              const std::string& value) {
+  impl_->RecordProperty(TestProperty(key, value));
+}
+
+// Runs all tests in this UnitTest object and prints the result.
+// Returns 0 if successful, or 1 otherwise.
+//
+// We don't protect this under mutex_, as we only support calling it
+// from the main thread.
+int UnitTest::Run() {
+  const bool in_death_test_child_process =
+      internal::GTEST_FLAG(internal_run_death_test).length() > 0;
+
+  // Google Test implements this protocol for catching that a test
+  // program exits before returning control to Google Test:
+  //
+  //   1. Upon start, Google Test creates a file whose absolute path
+  //      is specified by the environment variable
+  //      TEST_PREMATURE_EXIT_FILE.
+  //   2. When Google Test has finished its work, it deletes the file.
+  //
+  // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before
+  // running a Google-Test-based test program and check the existence
+  // of the file at the end of the test execution to see if it has
+  // exited prematurely.
+
+  // If we are in the child process of a death test, don't
+  // create/delete the premature exit file, as doing so is unnecessary
+  // and will confuse the parent process.  Otherwise, create/delete
+  // the file upon entering/leaving this function.  If the program
+  // somehow exits before this function has a chance to return, the
+  // premature-exit file will be left undeleted, causing a test runner
+  // that understands the premature-exit-file protocol to report the
+  // test as having failed.
+  const internal::ScopedPrematureExitFile premature_exit_file(
+      in_death_test_child_process
+          ? nullptr
+          : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE"));
+
+  // Captures the value of GTEST_FLAG(catch_exceptions).  This value will be
+  // used for the duration of the program.
+  impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions));
+
+#if GTEST_OS_WINDOWS
+  // Either the user wants Google Test to catch exceptions thrown by the
+  // tests or this is executing in the context of death test child
+  // process. In either case the user does not want to see pop-up dialogs
+  // about crashes - they are expected.
+  if (impl()->catch_exceptions() || in_death_test_child_process) {
+# if !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
+    // SetErrorMode doesn't exist on CE.
+    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT |
+                 SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
+# endif  // !GTEST_OS_WINDOWS_MOBILE
+
+# if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE
+    // Death test children can be terminated with _abort().  On Windows,
+    // _abort() can show a dialog with a warning message.  This forces the
+    // abort message to go to stderr instead.
+    _set_error_mode(_OUT_TO_STDERR);
+# endif
+
+# if defined(_MSC_VER) && !GTEST_OS_WINDOWS_MOBILE
+    // In the debug version, Visual Studio pops up a separate dialog
+    // offering a choice to debug the aborted program. We need to suppress
+    // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement
+    // executed. Google Test will notify the user of any unexpected
+    // failure via stderr.
+    if (!GTEST_FLAG(break_on_failure))
+      _set_abort_behavior(
+          0x0,                                    // Clear the following flags:
+          _WRITE_ABORT_MSG | _CALL_REPORTFAULT);  // pop-up window, core dump.
+
+    // In debug mode, the Windows CRT can crash with an assertion over invalid
+    // input (e.g. passing an invalid file descriptor).  The default handling
+    // for these assertions is to pop up a dialog and wait for user input.
+    // Instead ask the CRT to dump such assertions to stderr non-interactively.
+    if (!IsDebuggerPresent()) {
+      (void)_CrtSetReportMode(_CRT_ASSERT,
+                              _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+      (void)_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
+    }
+# endif
+  }
+#endif  // GTEST_OS_WINDOWS
+
+  return internal::HandleExceptionsInMethodIfSupported(
+      impl(),
+      &internal::UnitTestImpl::RunAllTests,
+      "auxiliary test code (environments or event listeners)") ? 0 : 1;
+}
+
+// Returns the working directory when the first TEST() or TEST_F() was
+// executed.
+const char* UnitTest::original_working_dir() const {
+  return impl_->original_working_dir_.c_str();
+}
+
+// Returns the TestSuite object for the test that's currently running,
+// or NULL if no test is running.
+const TestSuite* UnitTest::current_test_suite() const
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  internal::MutexLock lock(&mutex_);
+  return impl_->current_test_suite();
+}
+
+// Legacy API is still available but deprecated
+#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
+const TestCase* UnitTest::current_test_case() const
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  internal::MutexLock lock(&mutex_);
+  return impl_->current_test_suite();
+}
+#endif
+
+// Returns the TestInfo object for the test that's currently running,
+// or NULL if no test is running.
+const TestInfo* UnitTest::current_test_info() const
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  internal::MutexLock lock(&mutex_);
+  return impl_->current_test_info();
+}
+
+// Returns the random seed used at the start of the current test run.
+int UnitTest::random_seed() const { return impl_->random_seed(); }
+
+// Returns ParameterizedTestSuiteRegistry object used to keep track of
+// value-parameterized tests and instantiate and register them.
+internal::ParameterizedTestSuiteRegistry&
+UnitTest::parameterized_test_registry() GTEST_LOCK_EXCLUDED_(mutex_) {
+  return impl_->parameterized_test_registry();
+}
+
+// Creates an empty UnitTest.
+UnitTest::UnitTest() {
+  impl_ = new internal::UnitTestImpl(this);
+}
+
+// Destructor of UnitTest.
+UnitTest::~UnitTest() {
+  delete impl_;
+}
+
+// Pushes a trace defined by SCOPED_TRACE() on to the per-thread
+// Google Test trace stack.
+void UnitTest::PushGTestTrace(const internal::TraceInfo& trace)
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  internal::MutexLock lock(&mutex_);
+  impl_->gtest_trace_stack().push_back(trace);
+}
+
+// Pops a trace from the per-thread Google Test trace stack.
+void UnitTest::PopGTestTrace()
+    GTEST_LOCK_EXCLUDED_(mutex_) {
+  internal::MutexLock lock(&mutex_);
+  impl_->gtest_trace_stack().pop_back();
+}
+
+namespace internal {
+
+UnitTestImpl::UnitTestImpl(UnitTest* parent)
+    : parent_(parent),
+      GTEST_DISABLE_MSC_WARNINGS_PUSH_(4355 /* using this in initializer */)
+          default_global_test_part_result_reporter_(this),
+      default_per_thread_test_part_result_reporter_(this),
+      GTEST_DISABLE_MSC_WARNINGS_POP_() global_test_part_result_repoter_(
+          &default_global_test_part_result_reporter_),
+      per_thread_test_part_result_reporter_(
+          &default_per_thread_test_part_result_reporter_),
+      parameterized_test_registry_(),
+      parameterized_tests_registered_(false),
+      last_death_test_suite_(-1),
+      current_test_suite_(nullptr),
+      current_test_info_(nullptr),
+      ad_hoc_test_result_(),
+      os_stack_trace_getter_(nullptr),
+      post_flag_parse_init_performed_(false),
+      random_seed_(0),  // Will be overridden by the flag before first use.
+      random_(0),       // Will be reseeded before first use.
+      start_timestamp_(0),
+      elapsed_time_(0),
+#if GTEST_HAS_DEATH_TEST
+      death_test_factory_(new DefaultDeathTestFactory),
+#endif
+      // Will be overridden by the flag before first use.
+      catch_exceptions_(false) {
+  listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter);
+}
+
+UnitTestImpl::~UnitTestImpl() {
+  // Deletes every TestSuite.
+  ForEach(test_suites_, internal::Delete<TestSuite>);
+
+  // Deletes every Environment.
+  ForEach(environments_, internal::Delete<Environment>);
+
+  delete os_stack_trace_getter_;
+}
+
+// Adds a TestProperty to the current TestResult object when invoked in a
+// context of a test, to current test suite's ad_hoc_test_result when invoke
+// from SetUpTestSuite/TearDownTestSuite, or to the global property set
+// otherwise.  If the result already contains a property with the same key,
+// the value will be updated.
+void UnitTestImpl::RecordProperty(const TestProperty& test_property) {
+  std::string xml_element;
+  TestResult* test_result;  // TestResult appropriate for property recording.
+
+  if (current_test_info_ != nullptr) {
+    xml_element = "testcase";
+    test_result = &(current_test_info_->result_);
+  } else if (current_test_suite_ != nullptr) {
+    xml_element = "testsuite";
+    test_result = &(current_test_suite_->ad_hoc_test_result_);
+  } else {
+    xml_element = "testsuites";
+    test_result = &ad_hoc_test_result_;
+  }
+  test_result->RecordProperty(xml_element, test_property);
+}
+
+#if GTEST_HAS_DEATH_TEST
+// Disables event forwarding if the control is currently in a death test
+// subprocess. Must not be called before InitGoogleTest.
+void UnitTestImpl::SuppressTestEventsIfInSubprocess() {
+  if (internal_run_death_test_flag_.get() != nullptr)
+    listeners()->SuppressEventForwarding();
+}
+#endif  // GTEST_HAS_DEATH_TEST
+
+// Initializes event listeners performing XML output as specified by
+// UnitTestOptions. Must not be called before InitGoogleTest.
+void UnitTestImpl::ConfigureXmlOutput() {
+  const std::string& output_format = UnitTestOptions::GetOutputFormat();
+  if (output_format == "xml") {
+    listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
+        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
+  } else if (output_format == "json") {
+    listeners()->SetDefaultXmlGenerator(new JsonUnitTestResultPrinter(
+        UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
+  } else if (output_format != "") {
+    GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
+                        << output_format << "\" ignored.";
+  }
+}
+
+#if GTEST_CAN_STREAM_RESULTS_
+// Initializes event listeners for streaming test results in string form.
+// Must not be called before InitGoogleTest.
+void UnitTestImpl::ConfigureStreamingOutput() {
+  const std::string& target = GTEST_FLAG(stream_result_to);
+  if (!target.empty()) {
+    const size_t pos = target.find(':');
+    if (pos != std::string::npos) {
+      listeners()->Append(new StreamingListener(target.substr(0, pos),
+                                                target.substr(pos+1)));
+    } else {
+      GTEST_LOG_(WARNING) << "unrecognized streaming target \"" << target
+                          << "\" ignored.";
+    }
+  }
+}
+#endif  // GTEST_CAN_STREAM_RESULTS_
+
+// Performs initialization dependent upon flag values obtained in
+// ParseGoogleTestFlagsOnly.  Is called from InitGoogleTest after the call to
+// ParseGoogleTestFlagsOnly.  In case a user neglects to call InitGoogleTest
+// this function is also called from RunAllTests.  Since this function can be
+// called more than once, it has to be idempotent.
+void UnitTestImpl::PostFlagParsingInit() {
+  // Ensures that this function does not execute more than once.
+  if (!post_flag_parse_init_performed_) {
+    post_flag_parse_init_performed_ = true;
+
+#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
+    // Register to send notifications about key process state changes.
+    listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
+#endif  // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
+
+#if GTEST_HAS_DEATH_TEST
+    InitDeathTestSubprocessControlInfo();
+    SuppressTestEventsIfInSubprocess();
+#endif  // GTEST_HAS_DEATH_TEST
+
+    // Registers parameterized tests. This makes parameterized tests
+    // available to the UnitTest reflection API without running
+    // RUN_ALL_TESTS.
+    RegisterParameterizedTests();
+
+    // Configures listeners for XML output. This makes it possible for users
+    // to shut down the default XML output before invoking RUN_ALL_TESTS.
+    ConfigureXmlOutput();
+
+    if (GTEST_FLAG(brief)) {
+      listeners()->SetDefaultResultPrinter(new BriefUnitTestResultPrinter);
+    }
+
+#if GTEST_CAN_STREAM_RESULTS_
+    // Configures listeners for streaming test results to the specified server.
+    ConfigureStreamingOutput();
+#endif  // GTEST_CAN_STREAM_RESULTS_
+
+#if GTEST_HAS_ABSL
+    if (GTEST_FLAG(install_failure_signal_handler)) {
+      absl::FailureSignalHandlerOptions options;
+      absl::InstallFailureSignalHandler(options);
+    }
+#endif  // GTEST_HAS_ABSL
+  }
+}
+
+// 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
+// TESTS ARE NOT SHUFFLED.
+//
+// Arguments:
+//
+//   test_suite_name: name of the test suite
+//   type_param:      the name of the test suite's type parameter, or NULL if
+//                    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* UnitTestImpl::GetTestSuite(
+    const char* 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));
+
+  if (test_suite != test_suites_.rend()) return *test_suite;
+
+  // No.  Let's create one.
+  auto* const new_test_suite =
+      new TestSuite(test_suite_name, type_param, set_up_tc, tear_down_tc);
+
+  // Is this a death test suite?
+  if (internal::UnitTestOptions::MatchesFilter(test_suite_name,
+                                               kDeathTestSuiteFilter)) {
+    // Yes.  Inserts the test suite after the last death test suite
+    // defined so far.  This only works when the test suites haven't
+    // been shuffled.  Otherwise we may end up running a death test
+    // after a non-death test.
+    ++last_death_test_suite_;
+    test_suites_.insert(test_suites_.begin() + last_death_test_suite_,
+                        new_test_suite);
+  } else {
+    // No.  Appends to the end of the list.
+    test_suites_.push_back(new_test_suite);
+  }
+
+  test_suite_indices_.push_back(static_cast<int>(test_suite_indices_.size()));
+  return new_test_suite;
+}
+
+// Helpers for setting up / tearing down the given environment.  They
+// are for use in the ForEach() function.
+static void SetUpEnvironment(Environment* env) { env->SetUp(); }
+static void TearDownEnvironment(Environment* env) { env->TearDown(); }
+
+// Runs all tests in this UnitTest object, prints the result, and
+// returns true if all tests are successful.  If any exception is
+// thrown during a test, the test is considered to be failed, but the
+// rest of the tests will still be run.
+//
+// When parameterized tests are enabled, it expands and registers
+// parameterized tests first in RegisterParameterizedTests().
+// All other functions called from RunAllTests() may safely assume that
+// parameterized tests are ready to be counted and run.
+bool UnitTestImpl::RunAllTests() {
+  // True if and only if Google Test is initialized before RUN_ALL_TESTS() is
+  // called.
+  const bool gtest_is_initialized_before_run_all_tests = GTestIsInitialized();
+
+  // Do not run any test if the --help flag was specified.
+  if (g_help_flag)
+    return true;
+
+  // Repeats the call to the post-flag parsing initialization in case the
+  // user didn't call InitGoogleTest.
+  PostFlagParsingInit();
+
+  // 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
+  // protocol.
+  internal::WriteToShardStatusFileIfNeeded();
+
+  // True if and only if we are in a subprocess for running a thread-safe-style
+  // death test.
+  bool in_subprocess_for_death_test = false;
+
+#if GTEST_HAS_DEATH_TEST
+  in_subprocess_for_death_test =
+      (internal_run_death_test_flag_.get() != nullptr);
+# if defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
+  if (in_subprocess_for_death_test) {
+    GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_();
+  }
+# endif  // defined(GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_)
+#endif  // GTEST_HAS_DEATH_TEST
+
+  const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex,
+                                        in_subprocess_for_death_test);
+
+  // Compares the full test names with the filter to decide which
+  // tests to run.
+  const bool has_tests_to_run = FilterTests(should_shard
+                                              ? HONOR_SHARDING_PROTOCOL
+                                              : IGNORE_SHARDING_PROTOCOL) > 0;
+
+  // Lists the tests and exits if the --gtest_list_tests flag was specified.
+  if (GTEST_FLAG(list_tests)) {
+    // This must be called *after* FilterTests() has been called.
+    ListTestsMatchingFilter();
+    return true;
+  }
+
+  random_seed_ = GTEST_FLAG(shuffle) ?
+      GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0;
+
+  // True if and only if at least one test has failed.
+  bool failed = false;
+
+  TestEventListener* repeater = listeners()->repeater();
+
+  start_timestamp_ = GetTimeInMillis();
+  repeater->OnTestProgramStart(*parent_);
+
+  // How many times to repeat the tests?  We don't want to repeat them
+  // when we are inside the subprocess of a death test.
+  const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat);
+  // Repeats forever if the repeat count is negative.
+  const bool gtest_repeat_forever = repeat < 0;
+  for (int i = 0; gtest_repeat_forever || i != repeat; i++) {
+    // We want to preserve failures generated by ad-hoc test
+    // assertions executed before RUN_ALL_TESTS().
+    ClearNonAdHocTestResult();
+
+    Timer timer;
+
+    // Shuffles test suites and tests if requested.
+    if (has_tests_to_run && GTEST_FLAG(shuffle)) {
+      random()->Reseed(static_cast<uint32_t>(random_seed_));
+      // This should be done before calling OnTestIterationStart(),
+      // such that a test event listener can see the actual test order
+      // in the event.
+      ShuffleTests();
+    }
+
+    // Tells the unit test event listeners that the tests are about to start.
+    repeater->OnTestIterationStart(*parent_, i);
+
+    // Runs each test suite if there is at least one test to run.
+    if (has_tests_to_run) {
+      // Sets up all environments beforehand.
+      repeater->OnEnvironmentsSetUpStart(*parent_);
+      ForEach(environments_, SetUpEnvironment);
+      repeater->OnEnvironmentsSetUpEnd(*parent_);
+
+      // Runs the tests only if there was no fatal failure or skip triggered
+      // during global set-up.
+      if (Test::IsSkipped()) {
+        // Emit diagnostics when global set-up calls skip, as it will not be
+        // emitted by default.
+        TestResult& test_result =
+            *internal::GetUnitTestImpl()->current_test_result();
+        for (int j = 0; j < test_result.total_part_count(); ++j) {
+          const TestPartResult& test_part_result =
+              test_result.GetTestPartResult(j);
+          if (test_part_result.type() == TestPartResult::kSkip) {
+            const std::string& result = test_part_result.message();
+            printf("%s\n", result.c_str());
+          }
+        }
+        fflush(stdout);
+      } else if (!Test::HasFatalFailure()) {
+        for (int test_index = 0; test_index < total_test_suite_count();
+             test_index++) {
+          GetMutableSuiteCase(test_index)->Run();
+          if (GTEST_FLAG(fail_fast) &&
+              GetMutableSuiteCase(test_index)->Failed()) {
+            for (int j = test_index + 1; j < total_test_suite_count(); j++) {
+              GetMutableSuiteCase(j)->Skip();
+            }
+            break;
+          }
+        }
+      } else if (Test::HasFatalFailure()) {
+        // If there was a fatal failure during the global setup then we know we
+        // aren't going to run any tests. Explicitly mark all of the tests as
+        // skipped to make this obvious in the output.
+        for (int test_index = 0; test_index < total_test_suite_count();
+             test_index++) {
+          GetMutableSuiteCase(test_index)->Skip();
+        }
+      }
+
+      // Tears down all environments in reverse order afterwards.
+      repeater->OnEnvironmentsTearDownStart(*parent_);
+      std::for_each(environments_.rbegin(), environments_.rend(),
+                    TearDownEnvironment);
+      repeater->OnEnvironmentsTearDownEnd(*parent_);
+    }
+
+    elapsed_time_ = timer.Elapsed();
+
+    // Tells the unit test event listener that the tests have just finished.
+    repeater->OnTestIterationEnd(*parent_, i);
+
+    // Gets the result and clears it.
+    if (!Passed()) {
+      failed = true;
+    }
+
+    // Restores the original test order after the iteration.  This
+    // allows the user to quickly repro a failure that happens in the
+    // N-th iteration without repeating the first (N - 1) iterations.
+    // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in
+    // case the user somehow changes the value of the flag somewhere
+    // (it's always safe to unshuffle the tests).
+    UnshuffleTests();
+
+    if (GTEST_FLAG(shuffle)) {
+      // Picks a new random seed for each iteration.
+      random_seed_ = GetNextRandomSeed(random_seed_);
+    }
+  }
+
+  repeater->OnTestProgramEnd(*parent_);
+
+  if (!gtest_is_initialized_before_run_all_tests) {
+    ColoredPrintf(
+        GTestColor::kRed,
+        "\nIMPORTANT NOTICE - DO NOT IGNORE:\n"
+        "This test program did NOT call " GTEST_INIT_GOOGLE_TEST_NAME_
+        "() before calling RUN_ALL_TESTS(). This is INVALID. Soon " GTEST_NAME_
+        " will start to enforce the valid usage. "
+        "Please fix it ASAP, or IT WILL START TO FAIL.\n");  // NOLINT
+#if GTEST_FOR_GOOGLE_
+    ColoredPrintf(GTestColor::kRed,
+                  "For more details, see http://wiki/Main/ValidGUnitMain.\n");
+#endif  // GTEST_FOR_GOOGLE_
+  }
+
+  return !failed;
+}
+
+// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file
+// if the variable is present. If a file already exists at this location, this
+// function will write over it. If the variable is present, but the file cannot
+// be created, prints an error and exits.
+void WriteToShardStatusFileIfNeeded() {
+  const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile);
+  if (test_shard_file != nullptr) {
+    FILE* const file = posix::FOpen(test_shard_file, "w");
+    if (file == nullptr) {
+      ColoredPrintf(GTestColor::kRed,
+                    "Could not write to the test shard status file \"%s\" "
+                    "specified by the %s environment variable.\n",
+                    test_shard_file, kTestShardStatusFile);
+      fflush(stdout);
+      exit(EXIT_FAILURE);
+    }
+    fclose(file);
+  }
+}
+
+// Checks whether sharding is enabled by examining the relevant
+// environment variable values. If the variables are present,
+// but inconsistent (i.e., shard_index >= total_shards), prints
+// an error and exits. If in_subprocess_for_death_test, sharding is
+// disabled because it must only be applied to the original test
+// process. Otherwise, we could filter out death tests we intended to execute.
+bool ShouldShard(const char* total_shards_env,
+                 const char* shard_index_env,
+                 bool in_subprocess_for_death_test) {
+  if (in_subprocess_for_death_test) {
+    return false;
+  }
+
+  const int32_t total_shards = Int32FromEnvOrDie(total_shards_env, -1);
+  const int32_t shard_index = Int32FromEnvOrDie(shard_index_env, -1);
+
+  if (total_shards == -1 && shard_index == -1) {
+    return false;
+  } else if (total_shards == -1 && shard_index != -1) {
+    const Message msg = Message()
+      << "Invalid environment variables: you have "
+      << kTestShardIndex << " = " << shard_index
+      << ", but have left " << kTestTotalShards << " unset.\n";
+    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
+    fflush(stdout);
+    exit(EXIT_FAILURE);
+  } else if (total_shards != -1 && shard_index == -1) {
+    const Message msg = Message()
+      << "Invalid environment variables: you have "
+      << kTestTotalShards << " = " << total_shards
+      << ", but have left " << kTestShardIndex << " unset.\n";
+    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
+    fflush(stdout);
+    exit(EXIT_FAILURE);
+  } else if (shard_index < 0 || shard_index >= total_shards) {
+    const Message msg = Message()
+      << "Invalid environment variables: we require 0 <= "
+      << kTestShardIndex << " < " << kTestTotalShards
+      << ", but you have " << kTestShardIndex << "=" << shard_index
+      << ", " << kTestTotalShards << "=" << total_shards << ".\n";
+    ColoredPrintf(GTestColor::kRed, "%s", msg.GetString().c_str());
+    fflush(stdout);
+    exit(EXIT_FAILURE);
+  }
+
+  return total_shards > 1;
+}
+
+// Parses the environment variable var as an Int32. If it is unset,
+// returns default_val. If it is not an Int32, prints an error
+// and aborts.
+int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
+  const char* str_val = posix::GetEnv(var);
+  if (str_val == nullptr) {
+    return default_val;
+  }
+
+  int32_t result;
+  if (!ParseInt32(Message() << "The value of environment variable " << var,
+                  str_val, &result)) {
+    exit(EXIT_FAILURE);
+  }
+  return result;
+}
+
+// Given the total number of shards, the shard index, and the test id,
+// returns true if and only if the test should be run on this shard. The test id
+// is some arbitrary but unique non-negative integer assigned to each test
+// method. Assumes that 0 <= shard_index < total_shards.
+bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) {
+  return (test_id % total_shards) == shard_index;
+}
+
+// Compares the name of each test with the user-specified filter to
+// decide whether the test should be run, then records the result in
+// each TestSuite and TestInfo object.
+// If shard_tests == true, further filters tests based on sharding
+// variables in the environment - see
+// https://github.com/google/googletest/blob/master/googletest/docs/advanced.md
+// . Returns the number of tests that should run.
+int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
+  const int32_t total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
+      Int32FromEnvOrDie(kTestTotalShards, -1) : -1;
+  const int32_t shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ?
+      Int32FromEnvOrDie(kTestShardIndex, -1) : -1;
+
+  // num_runnable_tests are the number of tests that will
+  // run across all shards (i.e., match filter and are not disabled).
+  // num_selected_tests are the number of tests to be run on
+  // this shard.
+  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();
+    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());
+      // A test is disabled if test suite name or test name matches
+      // kDisableTestFilter.
+      const bool is_disabled = internal::UnitTestOptions::MatchesFilter(
+                                   test_suite_name, kDisableTestFilter) ||
+                               internal::UnitTestOptions::MatchesFilter(
+                                   test_name, kDisableTestFilter);
+      test_info->is_disabled_ = is_disabled;
+
+      const bool matches_filter = internal::UnitTestOptions::FilterMatchesTest(
+          test_suite_name, test_name);
+      test_info->matches_filter_ = matches_filter;
+
+      const bool is_runnable =
+          (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) &&
+          matches_filter;
+
+      const bool is_in_another_shard =
+          shard_tests != IGNORE_SHARDING_PROTOCOL &&
+          !ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests);
+      test_info->is_in_another_shard_ = is_in_another_shard;
+      const bool is_selected = is_runnable && !is_in_another_shard;
+
+      num_runnable_tests += is_runnable;
+      num_selected_tests += is_selected;
+
+      test_info->should_run_ = is_selected;
+      test_suite->set_should_run(test_suite->should_run() || is_selected);
+    }
+  }
+  return num_selected_tests;
+}
+
+// Prints the given C-string on a single line by replacing all '\n'
+// characters with string "\\n".  If the output takes more than
+// max_length characters, only prints the first max_length characters
+// and "...".
+static void PrintOnOneLine(const char* str, int max_length) {
+  if (str != nullptr) {
+    for (int i = 0; *str != '\0'; ++str) {
+      if (i >= max_length) {
+        printf("...");
+        break;
+      }
+      if (*str == '\n') {
+        printf("\\n");
+        i += 2;
+      } else {
+        printf("%c", *str);
+        ++i;
+      }
+    }
+  }
+}
+
+// Prints the names of the tests matching the user-specified filter flag.
+void UnitTestImpl::ListTestsMatchingFilter() {
+  // Print at most this many characters for each type/value parameter.
+  const int kMaxParamLength = 250;
+
+  for (auto* test_suite : test_suites_) {
+    bool printed_test_suite_name = false;
+
+    for (size_t j = 0; j < test_suite->test_info_list().size(); j++) {
+      const TestInfo* const test_info = test_suite->test_info_list()[j];
+      if (test_info->matches_filter_) {
+        if (!printed_test_suite_name) {
+          printed_test_suite_name = true;
+          printf("%s.", test_suite->name());
+          if (test_suite->type_param() != nullptr) {
+            printf("  # %s = ", kTypeParamLabel);
+            // We print the type parameter on a single line to make
+            // the output easy to parse by a program.
+            PrintOnOneLine(test_suite->type_param(), kMaxParamLength);
+          }
+          printf("\n");
+        }
+        printf("  %s", test_info->name());
+        if (test_info->value_param() != nullptr) {
+          printf("  # %s = ", kValueParamLabel);
+          // We print the value parameter on a single line to make the
+          // output easy to parse by a program.
+          PrintOnOneLine(test_info->value_param(), kMaxParamLength);
+        }
+        printf("\n");
+      }
+    }
+  }
+  fflush(stdout);
+  const std::string& output_format = UnitTestOptions::GetOutputFormat();
+  if (output_format == "xml" || output_format == "json") {
+    FILE* fileout = OpenFileForWriting(
+        UnitTestOptions::GetAbsolutePathToOutputFile().c_str());
+    std::stringstream stream;
+    if (output_format == "xml") {
+      XmlUnitTestResultPrinter(
+          UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
+          .PrintXmlTestsList(&stream, test_suites_);
+    } else if (output_format == "json") {
+      JsonUnitTestResultPrinter(
+          UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
+          .PrintJsonTestList(&stream, test_suites_);
+    }
+    fprintf(fileout, "%s", StringStreamToString(&stream).c_str());
+    fclose(fileout);
+  }
+}
+
+// Sets the OS stack trace getter.
+//
+// Does nothing if the input and the current OS stack trace getter are
+// the same; otherwise, deletes the old getter and makes the input the
+// current getter.
+void UnitTestImpl::set_os_stack_trace_getter(
+    OsStackTraceGetterInterface* getter) {
+  if (os_stack_trace_getter_ != getter) {
+    delete os_stack_trace_getter_;
+    os_stack_trace_getter_ = getter;
+  }
+}
+
+// Returns the current OS stack trace getter if it is not NULL;
+// otherwise, creates an OsStackTraceGetter, makes it the current
+// getter, and returns it.
+OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
+  if (os_stack_trace_getter_ == nullptr) {
+#ifdef GTEST_OS_STACK_TRACE_GETTER_
+    os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
+#else
+    os_stack_trace_getter_ = new OsStackTraceGetter;
+#endif  // GTEST_OS_STACK_TRACE_GETTER_
+  }
+
+  return os_stack_trace_getter_;
+}
+
+// Returns the most specific TestResult currently running.
+TestResult* UnitTestImpl::current_test_result() {
+  if (current_test_info_ != nullptr) {
+    return &current_test_info_->result_;
+  }
+  if (current_test_suite_ != nullptr) {
+    return &current_test_suite_->ad_hoc_test_result_;
+  }
+  return &ad_hoc_test_result_;
+}
+
+// Shuffles all test suites, and the tests within each test suite,
+// making sure that death tests are still run first.
+void UnitTestImpl::ShuffleTests() {
+  // Shuffles the death test suites.
+  ShuffleRange(random(), 0, last_death_test_suite_ + 1, &test_suite_indices_);
+
+  // Shuffles the non-death test suites.
+  ShuffleRange(random(), last_death_test_suite_ + 1,
+               static_cast<int>(test_suites_.size()), &test_suite_indices_);
+
+  // Shuffles the tests inside each test suite.
+  for (auto& test_suite : test_suites_) {
+    test_suite->ShuffleTests(random());
+  }
+}
+
+// Restores the test suites and tests to their order before the first shuffle.
+void UnitTestImpl::UnshuffleTests() {
+  for (size_t i = 0; i < test_suites_.size(); i++) {
+    // Unshuffles the tests in each test suite.
+    test_suites_[i]->UnshuffleTests();
+    // Resets the index of each test suite.
+    test_suite_indices_[i] = static_cast<int>(i);
+  }
+}
+
+// Returns the current OS stack trace as an std::string.
+//
+// The maximum number of stack frames to be included is specified by
+// the gtest_stack_trace_depth flag.  The skip_count parameter
+// specifies the number of top frames to be skipped, which doesn't
+// count against the number of frames to be included.
+//
+// For example, if Foo() calls Bar(), which in turn calls
+// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in
+// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't.
+std::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
+                                            int skip_count) {
+  // We pass skip_count + 1 to skip this wrapper function in addition
+  // to what the user really wants to skip.
+  return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1);
+}
+
+// Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to
+// suppress unreachable code warnings.
+namespace {
+class ClassUniqueToAlwaysTrue {};
+}
+
+bool IsTrue(bool condition) { return condition; }
+
+bool AlwaysTrue() {
+#if GTEST_HAS_EXCEPTIONS
+  // This condition is always false so AlwaysTrue() never actually throws,
+  // but it makes the compiler think that it may throw.
+  if (IsTrue(false))
+    throw ClassUniqueToAlwaysTrue();
+#endif  // GTEST_HAS_EXCEPTIONS
+  return true;
+}
+
+// If *pstr starts with the given prefix, modifies *pstr to be right
+// past the prefix and returns true; otherwise leaves *pstr unchanged
+// and returns false.  None of pstr, *pstr, and prefix can be NULL.
+bool SkipPrefix(const char* prefix, const char** pstr) {
+  const size_t prefix_len = strlen(prefix);
+  if (strncmp(*pstr, prefix, prefix_len) == 0) {
+    *pstr += prefix_len;
+    return true;
+  }
+  return false;
+}
+
+// Parses a string as a command line flag.  The string should have
+// the format "--flag=value".  When def_optional is true, the "=value"
+// part can be omitted.
+//
+// Returns the value of the flag, or NULL if the parsing failed.
+static const char* ParseFlagValue(const char* str, const char* flag,
+                                  bool def_optional) {
+  // str and flag must not be NULL.
+  if (str == nullptr || flag == nullptr) return nullptr;
+
+  // The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
+  const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag;
+  const size_t flag_len = flag_str.length();
+  if (strncmp(str, flag_str.c_str(), flag_len) != 0) return nullptr;
+
+  // Skips the flag name.
+  const char* flag_end = str + flag_len;
+
+  // When def_optional is true, it's OK to not have a "=value" part.
+  if (def_optional && (flag_end[0] == '\0')) {
+    return flag_end;
+  }
+
+  // If def_optional is true and there are more characters after the
+  // flag name, or if def_optional is false, there must be a '=' after
+  // the flag name.
+  if (flag_end[0] != '=') return nullptr;
+
+  // Returns the string after "=".
+  return flag_end + 1;
+}
+
+// Parses a string for a bool flag, in the form of either
+// "--flag=value" or "--flag".
+//
+// In the former case, the value is taken as true as long as it does
+// not start with '0', 'f', or 'F'.
+//
+// In the latter case, the value is taken as true.
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+static bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseFlagValue(str, flag, true);
+
+  // Aborts if the parsing failed.
+  if (value_str == nullptr) return false;
+
+  // Converts the string value to a bool.
+  *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
+  return true;
+}
+
+// Parses a string for an int32_t flag, in the form of "--flag=value".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+bool ParseInt32Flag(const char* str, const char* flag, int32_t* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseFlagValue(str, flag, false);
+
+  // Aborts if the parsing failed.
+  if (value_str == nullptr) return false;
+
+  // Sets *value to the value of the flag.
+  return ParseInt32(Message() << "The value of flag --" << flag,
+                    value_str, value);
+}
+
+// Parses a string for a string flag, in the form of "--flag=value".
+//
+// On success, stores the value of the flag in *value, and returns
+// true.  On failure, returns false without changing *value.
+template <typename String>
+static bool ParseStringFlag(const char* str, const char* flag, String* value) {
+  // Gets the value of the flag as a string.
+  const char* const value_str = ParseFlagValue(str, flag, false);
+
+  // Aborts if the parsing failed.
+  if (value_str == nullptr) return false;
+
+  // Sets *value to the value of the flag.
+  *value = value_str;
+  return true;
+}
+
+// Determines whether a string has a prefix that Google Test uses for its
+// flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_.
+// If Google Test detects that a command line flag has its prefix but is not
+// recognized, it will print its help message. Flags starting with
+// GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test
+// internal flags and do not trigger the help message.
+static bool HasGoogleTestFlagPrefix(const char* str) {
+  return (SkipPrefix("--", &str) ||
+          SkipPrefix("-", &str) ||
+          SkipPrefix("/", &str)) &&
+         !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
+         (SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
+          SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str));
+}
+
+// Prints a string containing code-encoded text.  The following escape
+// sequences can be used in the string to control the text color:
+//
+//   @@    prints a single '@' character.
+//   @R    changes the color to red.
+//   @G    changes the color to green.
+//   @Y    changes the color to yellow.
+//   @D    changes to the default terminal text color.
+//
+static void PrintColorEncoded(const char* str) {
+  GTestColor color = GTestColor::kDefault;  // The current color.
+
+  // Conceptually, we split the string into segments divided by escape
+  // sequences.  Then we print one segment at a time.  At the end of
+  // each iteration, the str pointer advances to the beginning of the
+  // next segment.
+  for (;;) {
+    const char* p = strchr(str, '@');
+    if (p == nullptr) {
+      ColoredPrintf(color, "%s", str);
+      return;
+    }
+
+    ColoredPrintf(color, "%s", std::string(str, p).c_str());
+
+    const char ch = p[1];
+    str = p + 2;
+    if (ch == '@') {
+      ColoredPrintf(color, "@");
+    } else if (ch == 'D') {
+      color = GTestColor::kDefault;
+    } else if (ch == 'R') {
+      color = GTestColor::kRed;
+    } else if (ch == 'G') {
+      color = GTestColor::kGreen;
+    } else if (ch == 'Y') {
+      color = GTestColor::kYellow;
+    } else {
+      --str;
+    }
+  }
+}
+
+static const char kColorEncodedHelpMessage[] =
+    "This program contains tests written using " GTEST_NAME_
+    ". You can use the\n"
+    "following command line flags to control its behavior:\n"
+    "\n"
+    "Test Selection:\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "list_tests@D\n"
+    "      List the names of all tests instead of running them. The name of\n"
+    "      TEST(Foo, Bar) is \"Foo.Bar\".\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "filter=@YPOSITIVE_PATTERNS"
+    "[@G-@YNEGATIVE_PATTERNS]@D\n"
+    "      Run only the tests whose name matches one of the positive patterns "
+    "but\n"
+    "      none of the negative patterns. '?' matches any single character; "
+    "'*'\n"
+    "      matches any substring; ':' separates two patterns.\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "also_run_disabled_tests@D\n"
+    "      Run all disabled tests too.\n"
+    "\n"
+    "Test Execution:\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "repeat=@Y[COUNT]@D\n"
+    "      Run the tests repeatedly; use a negative count to repeat forever.\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "shuffle@D\n"
+    "      Randomize tests' orders on every iteration.\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "random_seed=@Y[NUMBER]@D\n"
+    "      Random number seed to use for shuffling test orders (between 1 and\n"
+    "      99999, or 0 to use a seed based on the current time).\n"
+    "\n"
+    "Test Output:\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n"
+    "      Enable/disable colored output. The default is @Gauto@D.\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "brief=1@D\n"
+    "      Only print test failures.\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "print_time=0@D\n"
+    "      Don't print the elapsed time of each test.\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "output=@Y(@Gjson@Y|@Gxml@Y)[@G:@YDIRECTORY_PATH@G" GTEST_PATH_SEP_
+    "@Y|@G:@YFILE_PATH]@D\n"
+    "      Generate a JSON or XML report in the given directory or with the "
+    "given\n"
+    "      file name. @YFILE_PATH@D defaults to @Gtest_detail.xml@D.\n"
+# if GTEST_CAN_STREAM_RESULTS_
+    "  @G--" GTEST_FLAG_PREFIX_
+    "stream_result_to=@YHOST@G:@YPORT@D\n"
+    "      Stream test results to the given server.\n"
+# endif  // GTEST_CAN_STREAM_RESULTS_
+    "\n"
+    "Assertion Behavior:\n"
+# if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
+    "  @G--" GTEST_FLAG_PREFIX_
+    "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n"
+    "      Set the default death test style.\n"
+# endif  // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS
+    "  @G--" GTEST_FLAG_PREFIX_
+    "break_on_failure@D\n"
+    "      Turn assertion failures into debugger break-points.\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "throw_on_failure@D\n"
+    "      Turn assertion failures into C++ exceptions for use by an external\n"
+    "      test framework.\n"
+    "  @G--" GTEST_FLAG_PREFIX_
+    "catch_exceptions=0@D\n"
+    "      Do not report exceptions as test failures. Instead, allow them\n"
+    "      to crash the program or throw a pop-up (on Windows).\n"
+    "\n"
+    "Except for @G--" GTEST_FLAG_PREFIX_
+    "list_tests@D, you can alternatively set "
+    "the corresponding\n"
+    "environment variable of a flag (all letters in upper-case). For example, "
+    "to\n"
+    "disable colored text output, you can either specify "
+    "@G--" GTEST_FLAG_PREFIX_
+    "color=no@D or set\n"
+    "the @G" GTEST_FLAG_PREFIX_UPPER_
+    "COLOR@D environment variable to @Gno@D.\n"
+    "\n"
+    "For more information, please read the " GTEST_NAME_
+    " documentation at\n"
+    "@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_
+    "\n"
+    "(not one in your own code or tests), please report it to\n"
+    "@G<" GTEST_DEV_EMAIL_ ">@D.\n";
+
+static bool ParseGoogleTestFlag(const char* const arg) {
+  return ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag,
+                       &GTEST_FLAG(also_run_disabled_tests)) ||
+         ParseBoolFlag(arg, kBreakOnFailureFlag,
+                       &GTEST_FLAG(break_on_failure)) ||
+         ParseBoolFlag(arg, kCatchExceptionsFlag,
+                       &GTEST_FLAG(catch_exceptions)) ||
+         ParseStringFlag(arg, kColorFlag, &GTEST_FLAG(color)) ||
+         ParseStringFlag(arg, kDeathTestStyleFlag,
+                         &GTEST_FLAG(death_test_style)) ||
+         ParseBoolFlag(arg, kDeathTestUseFork,
+                       &GTEST_FLAG(death_test_use_fork)) ||
+         ParseBoolFlag(arg, kFailFast, &GTEST_FLAG(fail_fast)) ||
+         ParseStringFlag(arg, kFilterFlag, &GTEST_FLAG(filter)) ||
+         ParseStringFlag(arg, kInternalRunDeathTestFlag,
+                         &GTEST_FLAG(internal_run_death_test)) ||
+         ParseBoolFlag(arg, kListTestsFlag, &GTEST_FLAG(list_tests)) ||
+         ParseStringFlag(arg, kOutputFlag, &GTEST_FLAG(output)) ||
+         ParseBoolFlag(arg, kBriefFlag, &GTEST_FLAG(brief)) ||
+         ParseBoolFlag(arg, kPrintTimeFlag, &GTEST_FLAG(print_time)) ||
+         ParseBoolFlag(arg, kPrintUTF8Flag, &GTEST_FLAG(print_utf8)) ||
+         ParseInt32Flag(arg, kRandomSeedFlag, &GTEST_FLAG(random_seed)) ||
+         ParseInt32Flag(arg, kRepeatFlag, &GTEST_FLAG(repeat)) ||
+         ParseBoolFlag(arg, kShuffleFlag, &GTEST_FLAG(shuffle)) ||
+         ParseInt32Flag(arg, kStackTraceDepthFlag,
+                        &GTEST_FLAG(stack_trace_depth)) ||
+         ParseStringFlag(arg, kStreamResultToFlag,
+                         &GTEST_FLAG(stream_result_to)) ||
+         ParseBoolFlag(arg, kThrowOnFailureFlag, &GTEST_FLAG(throw_on_failure));
+}
+
+#if GTEST_USE_OWN_FLAGFILE_FLAG_
+static void LoadFlagsFromFile(const std::string& path) {
+  FILE* flagfile = posix::FOpen(path.c_str(), "r");
+  if (!flagfile) {
+    GTEST_LOG_(FATAL) << "Unable to open file \"" << GTEST_FLAG(flagfile)
+                      << "\"";
+  }
+  std::string contents(ReadEntireFile(flagfile));
+  posix::FClose(flagfile);
+  std::vector<std::string> lines;
+  SplitString(contents, '\n', &lines);
+  for (size_t i = 0; i < lines.size(); ++i) {
+    if (lines[i].empty())
+      continue;
+    if (!ParseGoogleTestFlag(lines[i].c_str()))
+      g_help_flag = true;
+  }
+}
+#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
+
+// Parses the command line for Google Test flags, without initializing
+// other parts of Google Test.  The type parameter CharType can be
+// instantiated to either char or wchar_t.
+template <typename CharType>
+void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
+  for (int i = 1; i < *argc; i++) {
+    const std::string arg_string = StreamableToString(argv[i]);
+    const char* const arg = arg_string.c_str();
+
+    using internal::ParseBoolFlag;
+    using internal::ParseInt32Flag;
+    using internal::ParseStringFlag;
+
+    bool remove_flag = false;
+    if (ParseGoogleTestFlag(arg)) {
+      remove_flag = true;
+#if GTEST_USE_OWN_FLAGFILE_FLAG_
+    } else if (ParseStringFlag(arg, kFlagfileFlag, &GTEST_FLAG(flagfile))) {
+      LoadFlagsFromFile(GTEST_FLAG(flagfile));
+      remove_flag = true;
+#endif  // GTEST_USE_OWN_FLAGFILE_FLAG_
+    } else if (arg_string == "--help" || arg_string == "-h" ||
+               arg_string == "-?" || arg_string == "/?" ||
+               HasGoogleTestFlagPrefix(arg)) {
+      // Both help flag and unrecognized Google Test flags (excluding
+      // internal ones) trigger help display.
+      g_help_flag = true;
+    }
+
+    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];
+      }
+
+      // Decrements the argument count.
+      (*argc)--;
+
+      // We also need to decrement the iterator as we just removed
+      // an element.
+      i--;
+    }
+  }
+
+  if (g_help_flag) {
+    // We print the help here instead of in RUN_ALL_TESTS(), as the
+    // latter may not be called at all if the user is using Google
+    // Test with another testing framework.
+    PrintColorEncoded(kColorEncodedHelpMessage);
+  }
+}
+
+// Parses the command line for Google Test flags, without initializing
+// other parts of Google Test.
+void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
+  ParseGoogleTestFlagsOnlyImpl(argc, argv);
+
+  // Fix the value of *_NSGetArgc() on macOS, but if and only if
+  // *_NSGetArgv() == argv
+  // Only applicable to char** version of argv
+#if GTEST_OS_MAC
+#ifndef GTEST_OS_IOS
+  if (*_NSGetArgv() == argv) {
+    *_NSGetArgc() = *argc;
+  }
+#endif
+#endif
+}
+void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
+  ParseGoogleTestFlagsOnlyImpl(argc, argv);
+}
+
+// The internal implementation of InitGoogleTest().
+//
+// The type parameter CharType can be instantiated to either char or
+// wchar_t.
+template <typename CharType>
+void InitGoogleTestImpl(int* argc, CharType** argv) {
+  // We don't want to run the initialization code twice.
+  if (GTestIsInitialized()) return;
+
+  if (*argc <= 0) return;
+
+  g_argvs.clear();
+  for (int i = 0; i != *argc; i++) {
+    g_argvs.push_back(StreamableToString(argv[i]));
+  }
+
+#if GTEST_HAS_ABSL
+  absl::InitializeSymbolizer(g_argvs[0].c_str());
+#endif  // GTEST_HAS_ABSL
+
+  ParseGoogleTestFlagsOnly(argc, argv);
+  GetUnitTestImpl()->PostFlagParsingInit();
+}
+
+}  // namespace internal
+
+// Initializes Google Test.  This must be called before calling
+// RUN_ALL_TESTS().  In particular, it parses a command line for the
+// flags that Google Test recognizes.  Whenever a Google Test flag is
+// seen, it is removed from argv, and *argc is decremented.
+//
+// No value is returned.  Instead, the Google Test flag variables are
+// updated.
+//
+// Calling the function for the second time has no user-visible effect.
+void InitGoogleTest(int* argc, char** argv) {
+#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
+#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+  internal::InitGoogleTestImpl(argc, argv);
+#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+}
+
+// This overloaded version can be used in Windows programs compiled in
+// UNICODE mode.
+void InitGoogleTest(int* argc, wchar_t** argv) {
+#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(argc, argv);
+#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+  internal::InitGoogleTestImpl(argc, argv);
+#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+}
+
+// This overloaded version can be used on Arduino/embedded platforms where
+// there is no argc/argv.
+void InitGoogleTest() {
+  // Since Arduino doesn't have a command line, fake out the argc/argv arguments
+  int argc = 1;
+  const auto arg0 = "dummy";
+  char* argv0 = const_cast<char*>(arg0);
+  char** argv = &argv0;
+
+#if defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+  GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_(&argc, argv);
+#else  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+  internal::InitGoogleTestImpl(&argc, argv);
+#endif  // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
+}
+
+std::string TempDir() {
+#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
+  return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
+#elif GTEST_OS_WINDOWS_MOBILE
+  return "\\temp\\";
+#elif GTEST_OS_WINDOWS
+  const char* temp_dir = internal::posix::GetEnv("TEMP");
+  if (temp_dir == nullptr || temp_dir[0] == '\0') {
+    return "\\temp\\";
+  } else if (temp_dir[strlen(temp_dir) - 1] == '\\') {
+    return temp_dir;
+  } else {
+    return std::string(temp_dir) + "\\";
+  }
+#elif GTEST_OS_LINUX_ANDROID
+  const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
+  if (temp_dir == nullptr || temp_dir[0] == '\0') {
+    return "/data/local/tmp/";
+  } else {
+    return temp_dir;
+  }
+#elif GTEST_OS_LINUX
+  const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
+  if (temp_dir == nullptr || temp_dir[0] == '\0') {
+    return "/tmp/";
+  } else {
+    return temp_dir;
+  }
+#else
+  return "/tmp/";
+#endif  // GTEST_OS_WINDOWS_MOBILE
+}
+
+// Class ScopedTrace
+
+// Pushes the given source file location and message onto a per-thread
+// trace stack maintained by Google Test.
+void ScopedTrace::PushTrace(const char* file, int line, std::string message) {
+  internal::TraceInfo trace;
+  trace.file = file;
+  trace.line = line;
+  trace.message.swap(message);
+
+  UnitTest::GetInstance()->PushGTestTrace(trace);
+}
+
+// Pops the info pushed by the c'tor.
+ScopedTrace::~ScopedTrace()
+    GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) {
+  UnitTest::GetInstance()->PopGTestTrace();
+}
+
+}  // namespace testing
diff --git a/trunk/3rdparty/gtest-fit/googletest/src/gtest_main.cc b/trunk/3rdparty/gtest-fit/googletest/src/gtest_main.cc
new file mode 100644
index 000000000..46b27c3d7
--- /dev/null
+++ b/trunk/3rdparty/gtest-fit/googletest/src/gtest_main.cc
@@ -0,0 +1,54 @@
+// Copyright 2006, 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.
+
+#include <cstdio>
+#include "gtest/gtest.h"
+
+#if GTEST_OS_ESP8266 || GTEST_OS_ESP32
+#if GTEST_OS_ESP8266
+extern "C" {
+#endif
+void setup() {
+  testing::InitGoogleTest();
+}
+
+void loop() { RUN_ALL_TESTS(); }
+
+#if GTEST_OS_ESP8266
+}
+#endif
+
+#else
+
+GTEST_API_ int main(int argc, char **argv) {
+  printf("Running main() from %s\n", __FILE__);
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+#endif
diff --git a/trunk/Dockerfile.cov b/trunk/Dockerfile.cov
index a898cb969..00ff9ac70 100644
--- a/trunk/Dockerfile.cov
+++ b/trunk/Dockerfile.cov
@@ -1,4 +1,4 @@
-FROM ossrs/srs:dev
+FROM ossrs/srs:dev-gcc7
 
 # Install depends tools.
 RUN yum install -y gcc make gcc-c++ patch unzip perl git
@@ -6,4 +6,8 @@ RUN yum install -y gcc make gcc-c++ patch unzip perl git
 # Build and install SRS.
 COPY . /srs
 WORKDIR /srs/trunk
-RUN ./configure --with-utest --gcov --jobs=2 && make -j2
+
+# Note that we never build the utest, but only build srs.
+# Note that we must enable the gcc7 or link failed.
+RUN scl enable devtoolset-7 -- ./configure --srt=on --utest=on --gcov=on --jobs=2
+RUN scl enable devtoolset-7 -- make -j2
diff --git a/trunk/Dockerfile.test b/trunk/Dockerfile.test
index 936ab19be..4559b7b61 100644
--- a/trunk/Dockerfile.test
+++ b/trunk/Dockerfile.test
@@ -1,4 +1,4 @@
-FROM ossrs/srs:dev
+FROM ossrs/srs:dev-gcc7
 
 # Install depends tools.
 RUN yum install -y gcc make gcc-c++ patch unzip perl git
@@ -6,7 +6,12 @@ RUN yum install -y gcc make gcc-c++ patch unzip perl git
 # Build and install SRS.
 COPY . /srs
 WORKDIR /srs/trunk
-RUN ./configure --srt=on --utest=on --jobs=2 && make -j2 utest
+
+# Note that we must enable the gcc7 or link failed.
+RUN scl enable devtoolset-7 -- ./configure --srt=on --utest=on --jobs=2
+RUN scl enable devtoolset-7 -- make -j2 utest
+
+# Build benchmark tool.
 RUN cd 3rdparty/srs-bench && make
 
 # Run utest
diff --git a/trunk/auto/depends.sh b/trunk/auto/depends.sh
index c774dd746..490e28ddc 100755
--- a/trunk/auto/depends.sh
+++ b/trunk/auto/depends.sh
@@ -811,22 +811,21 @@ fi
 # build utest code
 #####################################################################################
 if [ $SRS_UTEST = YES ]; then
-    if [[ -f ${SRS_OBJS}/${SRS_PLATFORM}/gtest-1.6.0/include/gtest/gtest.h ]]; then
-        echo "The gtest-1.6.0 is ok.";
+    if [[ -f ${SRS_OBJS}/${SRS_PLATFORM}/gtest-fit/googletest/include/gtest/gtest.h ]]; then
+        echo "The gtest-fit is ok.";
     else
-        echo "Build gtest-1.6.0";
+        echo "Build gtest-fit";
         (
-            rm -rf ${SRS_OBJS}/${SRS_PLATFORM}/gtest-1.6.0 && cd ${SRS_OBJS}/${SRS_PLATFORM} &&
-            unzip -q ../../3rdparty/gtest-1.6.0.zip &&
-            rm -rf gtest && ln -sf gtest-1.6.0 gtest
+            cd ${SRS_OBJS}/${SRS_PLATFORM} && rm -rf gtest-fit && cp -R ../../3rdparty/gtest-fit gtest-fit
+            rm -rf gtest && ln -sf gtest-fit/googletest gtest
         )
     fi
     # check status
-    ret=$?; if [[ $ret -ne 0 ]]; then echo "Build gtest-1.6.0 failed, ret=$ret"; exit $ret; fi
+    ret=$?; if [[ $ret -ne 0 ]]; then echo "Build gtest-fit failed, ret=$ret"; exit $ret; fi
     # Always update the links.
-    (cd ${SRS_OBJS}/${SRS_PLATFORM} && rm -rf gtest && ln -sf gtest-1.6.0 gtest)
-    (cd ${SRS_OBJS} && rm -rf gtest && ln -sf ${SRS_PLATFORM}/gtest-1.6.0 gtest)
-    if [ ! -f ${SRS_OBJS}/gtest/include/gtest/gtest.h ]; then echo "Build gtest-1.6.0 failed."; exit -1; fi
+    (cd ${SRS_OBJS}/${SRS_PLATFORM} && rm -rf gtest && ln -sf gtest-fit/googletest gtest)
+    (cd ${SRS_OBJS} && rm -rf gtest && ln -sf ${SRS_PLATFORM}/gtest-fit/googletest gtest)
+    if [ ! -f ${SRS_OBJS}/gtest/include/gtest/gtest.h ]; then echo "Build gtest-fit failed."; exit -1; fi
 fi
 
 #####################################################################################
diff --git a/trunk/auto/utest.sh b/trunk/auto/utest.sh
index 01228b2e5..c457b8ade 100755
--- a/trunk/auto/utest.sh
+++ b/trunk/auto/utest.sh
@@ -53,6 +53,8 @@ CPPFLAGS += -I\$(GTEST_DIR)/include
 
 # Flags passed to the C++ compiler.
 CXXFLAGS += ${CXXFLAGS} ${UTEST_EXTRA_DEFINES} -Wno-unused-private-field -Wno-unused-command-line-argument
+# Always use C++11 for gtest required, see https://github.com/google/googletest
+CXXFLAGS += -std=c++11
 
 # All tests produced by this Makefile.  Remember to add new tests you
 # created to the list.
diff --git a/trunk/ide/srs_clion/CMakeLists.txt b/trunk/ide/srs_clion/CMakeLists.txt
index 9efcffbb9..f1d7b4104 100755
--- a/trunk/ide/srs_clion/CMakeLists.txt
+++ b/trunk/ide/srs_clion/CMakeLists.txt
@@ -1,5 +1,14 @@
+# Name of the project.
+# Language "C" is required for find_package(Threads).
+if (CMAKE_VERSION VERSION_LESS 3.0)
+    project(srs CXX C)
+else()
+    cmake_policy(SET CMP0048 NEW)
+    project(srs VERSION 4.0.0 LANGUAGES CXX C)
+endif()
 cmake_minimum_required(VERSION 2.8.12)
-project(srs CXX)
+
+# For utest required C++11.
 set (CMAKE_CXX_STANDARD 11)
 
 ###########################################################
@@ -17,9 +26,9 @@ ProcessorCount(JOBS)
 
 # We should always configure SRS for switching between branches.
 IF (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-    EXEC_PROGRAM("cd ${SRS_DIR} && ./configure --osx --srt=on --jobs=${JOBS}")
+    EXEC_PROGRAM("cd ${SRS_DIR} && ./configure --osx --srt=on --utest=on --jobs=${JOBS}")
 ELSE ()
-    EXEC_PROGRAM("cd ${SRS_DIR} && ./configure --jobs=${JOBS}")
+    EXEC_PROGRAM("cd ${SRS_DIR} && ./configure --srt=on --utest=on --jobs=${JOBS}")
 ENDIF ()
 
 set(DEPS_LIBS ${SRS_DIR}/objs/st/libst.a
@@ -40,7 +49,7 @@ foreach(DEPS_LIB ${DEPS_LIBS})
 endforeach()
 
 ###########################################################
-# Setup SRS project
+# For whole project.
 INCLUDE_DIRECTORIES(${SRS_DIR}/objs
         ${SRS_DIR}/objs/st
         ${SRS_DIR}/objs/openssl/include
@@ -55,22 +64,48 @@ INCLUDE_DIRECTORIES(${SRS_DIR}/objs
         ${SRS_DIR}/src/service
         ${SRS_DIR}/src/srt)
 
-set(SOURCE_FILES ${SRS_DIR}/src/main/srs_main_server.cpp)
+# Common used sources for SRS and utest.
 AUX_SOURCE_DIRECTORY(${SRS_DIR}/src/core SOURCE_FILES)
 AUX_SOURCE_DIRECTORY(${SRS_DIR}/src/kernel SOURCE_FILES)
 AUX_SOURCE_DIRECTORY(${SRS_DIR}/src/protocol SOURCE_FILES)
 AUX_SOURCE_DIRECTORY(${SRS_DIR}/src/app SOURCE_FILES)
 AUX_SOURCE_DIRECTORY(${SRS_DIR}/src/srt SOURCE_FILES)
 
-# Remove the duplicated main.
+# Remove the duplicated test main for srt.
+# TODO: FIMXE: Remove the file directly, use utest or main or research.
 list(REMOVE_ITEM SOURCE_FILES ${SRS_DIR}/src/srt/ts_demux_test.cpp)
 
 ADD_DEFINITIONS("-g -O0")
 
-ADD_EXECUTABLE(srs ${SOURCE_FILES})
+###########################################################
+# Setup SRS project
+
+set(SRS_SOURCE_FILES ${SOURCE_FILES})
+list(APPEND SRS_SOURCE_FILES ${SRS_DIR}/src/main/srs_main_server.cpp)
+
+ADD_EXECUTABLE(srs ${SRS_SOURCE_FILES})
 TARGET_LINK_LIBRARIES(srs dl)
 TARGET_LINK_LIBRARIES(srs ${DEPS_LIBS})
 TARGET_LINK_LIBRARIES(srs -ldl -pthread)
 
+###########################################################
+# For utest.
+# See https://google.github.io/googletest/quickstart-cmake.html
+# See https://stackoverflow.com/a/21479008/17679565
+ADD_SUBDIRECTORY(${SRS_DIR}/3rdparty/gtest-fit gtest-fit)
+INCLUDE_DIRECTORIES(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR})
+
+INCLUDE_DIRECTORIES(${SRS_DIR}/src/utest)
+set(UTEST_SOURCE_FILES ${SOURCE_FILES})
+AUX_SOURCE_DIRECTORY(${SRS_DIR}/src/utest UTEST_SOURCE_FILES)
+
+ADD_EXECUTABLE(utest ${UTEST_SOURCE_FILES})
+TARGET_LINK_LIBRARIES(utest gtest gtest_main)
+TARGET_LINK_LIBRARIES(utest dl)
+TARGET_LINK_LIBRARIES(utest ${DEPS_LIBS})
+TARGET_LINK_LIBRARIES(utest -ldl -pthread)
+
+###########################################################
+# Done
 MESSAGE(STATUS "@see https://github.com/ossrs/srs/wiki/v4_CN_IDE")
 

From fd219aa07439a7d2de84316e9bc03aae0a1b0a64 Mon Sep 17 00:00:00 2001
From: winlin <winlin@vip.126.com>
Date: Fri, 18 Mar 2022 12:01:11 +0800
Subject: [PATCH 3/4] Refine utest script.

---
 trunk/Dockerfile.cov | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/trunk/Dockerfile.cov b/trunk/Dockerfile.cov
index 00ff9ac70..d86c7cfab 100644
--- a/trunk/Dockerfile.cov
+++ b/trunk/Dockerfile.cov
@@ -7,7 +7,6 @@ RUN yum install -y gcc make gcc-c++ patch unzip perl git
 COPY . /srs
 WORKDIR /srs/trunk
 
-# Note that we never build the utest, but only build srs.
 # Note that we must enable the gcc7 or link failed.
 RUN scl enable devtoolset-7 -- ./configure --srt=on --utest=on --gcov=on --jobs=2
-RUN scl enable devtoolset-7 -- make -j2
+RUN scl enable devtoolset-7 -- make -j2 utest

From 06cff31b24eac51c203a19c33542fe5baa7f3ab4 Mon Sep 17 00:00:00 2001
From: winlin <winlin@vip.126.com>
Date: Fri, 18 Mar 2022 12:02:49 +0800
Subject: [PATCH 4/4] Update script.

---
 trunk/scripts/git.commit.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/trunk/scripts/git.commit.sh b/trunk/scripts/git.commit.sh
index 0de1cfe2d..461f6c154 100755
--- a/trunk/scripts/git.commit.sh
+++ b/trunk/scripts/git.commit.sh
@@ -1,6 +1,6 @@
 #!/bin/bash
 
-for file in $(git remote -v|grep -v https|grep -v gb28181|grep push|awk '{print $1}'); do 
+for file in $(git remote -v|grep -v https|grep -v gb28181|grep -v tmp|grep push|awk '{print $1}'); do 
     echo ""; 
     echo "git push $file $@"; 
     git push $file $@;