ref: 5039d2d82b3beab14ca7c354e1a8fefe67bb671a
parent: 51fe234ad1c021d41a0e74d70ae02a72067db6af
parent: 69d8a9aa5a00c8eb9bc17d2eaa4b4866b98cc644
author: Johann Koenig <[email protected]>
date: Tue Dec 4 18:40:41 EST 2018
Merge "Reland "third_party/googletest: update to v1.8.1""
--- a/third_party/googletest/README.libvpx
+++ b/third_party/googletest/README.libvpx
@@ -1,5 +1,5 @@
URL: https://github.com/google/googletest.git
-Version: release-1.8.0-742-g7857975
+Version: release-1.8.1
License: BSD
License File: LICENSE
@@ -13,7 +13,7 @@
Local Modifications:
- Remove everything but:
- googletest-release-1.8.0/googletest/
+ googletest-release-1.8.1/googletest/
CHANGES
CONTRIBUTORS
include
--- a/third_party/googletest/src/README.md
+++ b/third_party/googletest/src/README.md
@@ -1,23 +1,21 @@
+### Generic Build Instructions
-### Generic Build Instructions ###
+#### Setup
-#### Setup ####
+To build Google Test 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.
-To build Google Test 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
-#### Build ####
+Suppose you put Google Test in directory `${GTEST_DIR}`. To build it, create a+library build target (or a project as called by Visual Studio and Xcode) to
+compile
-Suppose you put Google Test in directory `${GTEST_DIR}`. To build it,-create a library build target (or a project as called by Visual Studio
-and Xcode) to compile
-
${GTEST_DIR}/src/gtest-all.cc with `${GTEST_DIR}/include` in the system header search path and `${GTEST_DIR}`-in the normal header search path. Assuming a Linux-like system and gcc,
+in the normal header search path. Assuming a Linux-like system and gcc,
something like the following will do:
g++ -isystem ${GTEST_DIR}/include -I${GTEST_DIR} \@@ -26,105 +24,101 @@
(We need `-pthread` as Google Test uses threads.)
-Next, you should compile your test source file with
-`${GTEST_DIR}/include` in the system header search path, and link it-with gtest and any other necessary libraries:
+Next, you should compile your test source file with `${GTEST_DIR}/include` in+the system header search path, and link it with gtest and any other necessary
+libraries:
g++ -isystem ${GTEST_DIR}/include -pthread path/to/your_test.cc libgtest.a \-o your_test
-As an example, the make/ directory contains a Makefile that you can
-use to build Google Test on systems where GNU make is available
-(e.g. Linux, Mac OS X, and Cygwin). It doesn't try to build Google
-Test's own tests. Instead, it just builds the Google Test library and
-a sample test. You can use it as a starting point for your own build
-script.
+As an example, the make/ directory contains a Makefile that you can use to build
+Google Test on systems where GNU make is available (e.g. Linux, Mac OS X, and
+Cygwin). It doesn't try to build Google Test's own tests. Instead, it just
+builds the Google Test library and a sample test. You can use it as a starting
+point for your own build script.
-If the default settings are correct for your environment, the
-following commands should succeed:
+If the default settings are correct for your environment, the following commands
+should succeed:
cd ${GTEST_DIR}/makemake
./sample1_unittest
-If you see errors, try to tweak the contents of `make/Makefile` to make
-them go away. There are instructions in `make/Makefile` on how to do
-it.
+If you see errors, try to tweak the contents of `make/Makefile` to make them go
+away. There are instructions in `make/Makefile` on how to do it.
-### Using CMake ###
+### Using CMake
Google Test comes with a CMake build script (
-[CMakeLists.txt](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/>.
+[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 Google Test as a standalone project or it can be incorporated
-into an existing CMake build for another project.
+CMake works by generating native makefiles or build projects that can be used in
+the compiler environment of your choice. You can either build Google Test as a
+standalone project or it can be incorporated into an existing CMake build for
+another project.
-#### Standalone CMake Project ####
+#### Standalone CMake Project
-When building Google Test as a standalone project, the typical
-workflow starts with:
+When building Google Test as a standalone project, the typical workflow starts
+with:
mkdir mybuild # Create a directory to hold the build output.
cd mybuild
cmake ${GTEST_DIR} # Generate native build scripts.-If you want to build Google Test's samples, you should replace the
-last command with
+If you want to build Google Test's samples, you should replace the last command
+with
cmake -Dgtest_build_samples=ON ${GTEST_DIR}-If you are on a \*nix system, you should now see a Makefile in the
-current directory. Just type 'make' to build gtest.
+If you are on a \*nix system, you should now see a Makefile in the current
+directory. Just type 'make' to build gtest.
-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.
+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 ####
+#### Incorporating Into An Existing CMake Project
-If you want to use gtest in a project which already uses CMake, then a
-more robust and flexible approach is to build gtest 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 gtest 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
+If you want to use gtest in a project which already uses CMake, then a more
+robust and flexible approach is to build gtest 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 gtest 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 is just a little more complex, but doesn't have the
- limitations of the other methods.
+* 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
+ is just a little more complex, but doesn't have the limitations of the other
+ methods.
-The last of the above methods is implemented with a small piece
-of CMake code in a separate file (e.g. `CMakeLists.txt.in`) which
-is copied to the build area and then invoked as a sub-build
-_during the CMake stage_. That directory is then pulled into the
-main build with `add_subdirectory()`. For example:
+The last of the above methods is implemented with a small piece of CMake code in
+a separate file (e.g. `CMakeLists.txt.in`) which is copied to the build area and
+then invoked as a sub-build _during the CMake stage_. That directory is then
+pulled into the main build with `add_subdirectory()`. For example:
New file `CMakeLists.txt.in`:
cmake_minimum_required(VERSION 2.8.2)
-
+
project(googletest-download NONE)
-
+
include(ExternalProject)
ExternalProject_Add(googletest
GIT_REPOSITORY https://github.com/google/googletest.git
@@ -136,7 +130,7 @@
INSTALL_COMMAND ""
TEST_COMMAND ""
)
-
+
Existing build's `CMakeLists.txt`:
# Download and unpack googletest at configure time
@@ -157,7 +151,7 @@
# Prevent overriding the parent project's compiler/linker
# settings on Windows
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-
+
# Add googletest directly to our build. This defines
# the gtest and gtest_main targets.
add_subdirectory(${CMAKE_BINARY_DIR}/googletest-src@@ -176,101 +170,93 @@
target_link_libraries(example gtest_main)
add_test(NAME example_test COMMAND example)
-Note that this approach requires CMake 2.8.2 or later due to
-its use of the `ExternalProject_Add()` command. The above
-technique is discussed in more detail in
-[this separate article](http://crascit.com/2015/07/25/cmake-gtest/)
-which also contains a link to a fully generalized implementation
-of the technique.
+Note that this approach requires CMake 2.8.2 or later due to its use of the
+`ExternalProject_Add()` command. The above technique is discussed in more detail
+in [this separate article](http://crascit.com/2015/07/25/cmake-gtest/) which
+also contains a link to a fully generalized implementation of the technique.
-##### Visual Studio Dynamic vs Static Runtimes #####
+##### Visual Studio Dynamic vs Static Runtimes
-By default, new Visual Studio projects link the C runtimes dynamically
-but Google Test 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
+By default, new Visual Studio projects link the C runtimes dynamically but
+Google Test 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
Google Test 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.
+Enabling this option will make gtest link the runtimes dynamically too, and
+match the project in which it is included.
-### Legacy Build Scripts ###
+### Legacy Build Scripts
Before settling on CMake, we have been providing hand-maintained build
-projects/scripts for Visual Studio, Xcode, and Autotools. While we
-continue to provide them for convenience, they are not actively
-maintained any more. We highly recommend that you follow the
-instructions in the above sections to integrate Google Test
-with your existing build system.
+projects/scripts for Visual Studio, Xcode, and Autotools. While we continue to
+provide them for convenience, they are not actively maintained any more. We
+highly recommend that you follow the instructions in the above sections to
+integrate Google Test with your existing build system.
If you still need to use the legacy build scripts, here's how:
-The msvc\ folder contains two solutions with Visual C++ projects.
-Open the `gtest.sln` or `gtest-md.sln` file using Visual Studio, and you
-are ready to build Google Test the same way you build any Visual
-Studio project. Files that have names ending with -md use DLL
-versions of Microsoft runtime libraries (the /MD or the /MDd compiler
-option). Files without that suffix use static versions of the runtime
-libraries (the /MT or the /MTd option). Please note that one must use
-the same option to compile both gtest and the test code. If you use
-Visual Studio 2005 or above, we recommend the -md version as /MD is
-the default for new projects in these versions of Visual Studio.
+The msvc\ folder contains two solutions with Visual C++ projects. Open the
+`gtest.sln` or `gtest-md.sln` file using Visual Studio, and you are ready to
+build Google Test the same way you build any Visual Studio project. Files that
+have names ending with -md use DLL versions of Microsoft runtime libraries (the
+/MD or the /MDd compiler option). Files without that suffix use static versions
+of the runtime libraries (the /MT or the /MTd option). Please note that one must
+use the same option to compile both gtest and the test code. If you use Visual
+Studio 2005 or above, we recommend the -md version as /MD is the default for new
+projects in these versions of Visual Studio.
-On Mac OS X, open the `gtest.xcodeproj` in the `xcode/` folder using
-Xcode. Build the "gtest" target. The universal binary framework will
-end up in your selected build directory (selected in the Xcode
-"Preferences..." -> "Building" pane and defaults to xcode/build).
-Alternatively, at the command line, enter:
+On Mac OS X, open the `gtest.xcodeproj` in the `xcode/` folder using Xcode.
+Build the "gtest" target. The universal binary framework will end up in your
+selected build directory (selected in the Xcode "Preferences..." -> "Building"
+pane and defaults to xcode/build). Alternatively, at the command line, enter:
xcodebuild
-This will build the "Release" configuration of gtest.framework in your
-default build location. See the "xcodebuild" man page for more
-information about building different configurations and building in
-different locations.
+This will build the "Release" configuration of gtest.framework in your default
+build location. See the "xcodebuild" man page for more information about
+building different configurations and building in different locations.
-If you wish to use the Google Test Xcode project with Xcode 4.x and
-above, you need to either:
+If you wish to use the Google Test Xcode project with Xcode 4.x and above, you
+need to either:
- * update the SDK configuration options in xcode/Config/General.xconfig.
- Comment options `SDKROOT`, `MACOS_DEPLOYMENT_TARGET`, and `GCC_VERSION`. If
- you choose this route you lose the ability to target earlier versions
- of MacOS X.
- * Install an SDK for an earlier version. This doesn't appear to be
- supported by Apple, but has been reported to work
- (http://stackoverflow.com/questions/5378518).
+* update the SDK configuration options in xcode/Config/General.xconfig.
+ Comment options `SDKROOT`, `MACOS_DEPLOYMENT_TARGET`, and `GCC_VERSION`. If
+ you choose this route you lose the ability to target earlier versions of
+ MacOS X.
+* Install an SDK for an earlier version. This doesn't appear to be supported
+ by Apple, but has been reported to work
+ (http://stackoverflow.com/questions/5378518).
-### Tweaking Google Test ###
+### Tweaking Google Test
-Google Test 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 Google Test 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.
+Google Test 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 Google Test 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](include/gtest/internal/gtest-port.h).
+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/include/gtest/internal/gtest-port.h).
-### Choosing a TR1 Tuple Library ###
+### Choosing a TR1 Tuple Library
-Some Google Test features require the C++ Technical Report 1 (TR1)
-tuple library, which is not yet available with all compilers. The
-good news is that Google Test implements a subset of TR1 tuple that's
-enough for its own need, and will automatically use this when the
-compiler doesn't provide TR1 tuple.
+Some Google Test features require the C++ Technical Report 1 (TR1) tuple
+library, which is not yet available with all compilers. The good news is that
+Google Test implements a subset of TR1 tuple that's enough for its own need, and
+will automatically use this when the compiler doesn't provide TR1 tuple.
-Usually you don't need to care about which tuple library Google Test
-uses. However, if your project already uses TR1 tuple, you need to
-tell Google Test to use the same TR1 tuple library the rest of your
-project uses, or the two tuple implementations will clash. To do
-that, add
+Usually you don't need to care about which tuple library Google Test uses.
+However, if your project already uses TR1 tuple, you need to tell Google Test to
+use the same TR1 tuple library the rest of your project uses, or the two tuple
+implementations will clash. To do that, add
-DGTEST_USE_OWN_TR1_TUPLE=0
-to the compiler flags while compiling Google Test and your tests. If
-you want to force Google Test to use its own tuple library, just add
+to the compiler flags while compiling Google Test and your tests. If you want to
+force Google Test to use its own tuple library, just add
-DGTEST_USE_OWN_TR1_TUPLE=1
@@ -282,15 +268,15 @@
and all features using tuple will be disabled.
-### Multi-threaded Tests ###
+### Multi-threaded Tests
-Google Test 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.).
+Google Test 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 Google Test doesn't correctly detect whether pthread is available
-in your environment, you can force it with
+If Google Test doesn't correctly detect whether pthread is available in your
+environment, you can force it with
-DGTEST_HAS_PTHREAD=1
@@ -298,26 +284,24 @@
-DGTEST_HAS_PTHREAD=0
-When Google Test 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 or the deprecated Autotools
-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.
+When Google Test 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 or the deprecated Autotools 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) ###
+### As a Shared Library (DLL)
-Google Test is compact, so most users can build and link it as a
-static library for the simplicity. You can choose to use Google Test
-as a shared library (known as a DLL on Windows) if you prefer.
+Google Test is compact, so most users can build and link it as a static library
+for the simplicity. You can choose to use Google Test 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 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
@@ -325,31 +309,28 @@
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 Google Test as a
-shared library. Otherwise a future release of Google Test may break
-your build script.
+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 Google Test as a shared library.
+Otherwise a future release of Google Test may break your build script.
-### Avoiding Macro Name Clashes ###
+### 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 Google Test macro clashes with another
-library, you can force Google Test to rename its macro to avoid the
-conflict.
+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
+Google Test macro clashes with another library, you can force Google Test to
+rename its macro to avoid the conflict.
-Specifically, if both Google Test and some other code define macro
-FOO, you can add
+Specifically, if both Google Test and some other code define macro FOO, you can
+add
-DGTEST_DONT_DEFINE_FOO=1
-to the compiler flags to tell Google Test 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
+to the compiler flags to tell Google Test 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) { ... }--- a/third_party/googletest/src/include/gtest/gtest-death-test.h
+++ b/third_party/googletest/src/include/gtest/gtest-death-test.h
@@ -26,14 +26,14 @@
// 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.
+
//
-// Author: [email protected] (Zhanyong Wan)
+// The Google C++ Testing and Mocking Framework (Google Test)
//
-// The Google C++ Testing 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 GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
#define GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
@@ -99,6 +99,7 @@
//
// 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.
//
@@ -160,7 +161,7 @@
// is rarely a problem as people usually don't put the test binary
// directory in PATH.
//
-// TODO([email protected]): make thread-safe death tests search the PATH.
+// FIXME: make thread-safe death tests search the PATH.
// Asserts that a given statement causes the program to exit, with an
// integer exit status that satisfies predicate, and emitting error output
@@ -198,9 +199,10 @@
const int exit_code_;
};
-# if !GTEST_OS_WINDOWS
+# 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);
--- a/third_party/googletest/src/include/gtest/gtest-message.h
+++ b/third_party/googletest/src/include/gtest/gtest-message.h
@@ -26,11 +26,10 @@
// 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.
+
//
-// Author: [email protected] (Zhanyong Wan)
+// The Google C++ Testing and Mocking Framework (Google Test)
//
-// The Google C++ Testing Framework (Google Test)
-//
// This header file defines the Message class.
//
// IMPORTANT NOTE: Due to limitation of the C++ language, we have to
@@ -43,6 +42,8 @@
// to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user
// program!
+// GOOGLETEST_CM0001 DO NOT DELETE
+
#ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
#define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
@@ -50,6 +51,9 @@
#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);
@@ -245,5 +249,7 @@
} // namespace internal
} // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
#endif // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_
--- a/third_party/googletest/src/include/gtest/gtest-param-test.h
+++ b/third_party/googletest/src/include/gtest/gtest-param-test.h
@@ -31,14 +31,12 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
-// Authors: [email protected] (Vlad Losev)
-//
// Macros and functions for implementing parameterized tests
-// in Google C++ Testing Framework (Google Test)
+// in Google C++ Testing and Mocking Framework (Google Test)
//
// This file is generated by a SCRIPT. DO NOT EDIT BY HAND!
//
-
+// GOOGLETEST_CM0001 DO NOT DELETE
#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
#define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
@@ -1412,26 +1410,24 @@
// alphanumeric characters or underscore. Because PrintToString adds quotes
// to std::string and C strings, it won't work for these types.
-#define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator, ...) \
- static ::testing::internal::ParamGenerator<test_case_name::ParamType> \
- gtest_##prefix##test_case_name##_EvalGenerator_() { \- return generator; \
- } \
- static ::std::string gtest_##prefix##test_case_name##_EvalGenerateName_( \
- const ::testing::TestParamInfo<test_case_name::ParamType>& info) { \- return ::testing::internal::GetParamNameGen<test_case_name::ParamType>( \
- __VA_ARGS__)(info); \
- } \
+# define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator, ...) \
+ static ::testing::internal::ParamGenerator<test_case_name::ParamType> \
+ gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \+ static ::std::string gtest_##prefix##test_case_name##_EvalGenerateName_( \
+ const ::testing::TestParamInfo<test_case_name::ParamType>& info) { \+ return ::testing::internal::GetParamNameGen<test_case_name::ParamType> \
+ (__VA_ARGS__)(info); \
+ } \
static int gtest_##prefix##test_case_name##_dummy_ GTEST_ATTRIBUTE_UNUSED_ = \
- ::testing::UnitTest::GetInstance() \
- ->parameterized_test_registry() \
- .GetTestCasePatternHolder<test_case_name>( \
- #test_case_name, \
- ::testing::internal::CodeLocation(__FILE__, __LINE__)) \
- ->AddTestCaseInstantiation( \
- #prefix, >est_##prefix##test_case_name##_EvalGenerator_, \
- >est_##prefix##test_case_name##_EvalGenerateName_, __FILE__, \
- __LINE__)
+ ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \
+ GetTestCasePatternHolder<test_case_name>(\
+ #test_case_name, \
+ ::testing::internal::CodeLocation(\
+ __FILE__, __LINE__))->AddTestCaseInstantiation(\
+ #prefix, \
+ >est_##prefix##test_case_name##_EvalGenerator_, \
+ >est_##prefix##test_case_name##_EvalGenerateName_, \
+ __FILE__, __LINE__)
} // namespace testing
--- a/third_party/googletest/src/include/gtest/gtest-param-test.h.pump
+++ b/third_party/googletest/src/include/gtest/gtest-param-test.h.pump
@@ -30,13 +30,12 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
-// Authors: [email protected] (Vlad Losev)
-//
// Macros and functions for implementing parameterized tests
-// in Google C++ Testing Framework (Google Test)
+// in Google C++ Testing and Mocking Framework (Google Test)
//
// This file is generated by a SCRIPT. DO NOT EDIT BY HAND!
//
+// GOOGLETEST_CM0001 DO NOT DELETE
#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
#define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_
--- a/third_party/googletest/src/include/gtest/gtest-printers.h
+++ b/third_party/googletest/src/include/gtest/gtest-printers.h
@@ -26,10 +26,9 @@
// 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.
-//
-// Author: [email protected] (Zhanyong Wan)
-// Google Test - The Google C++ Testing Framework
+
+// 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:
@@ -96,6 +95,8 @@
// being defined as many user-defined container types don't have
// value_type.
+// GOOGLETEST_CM0001 DO NOT DELETE
+
#ifndef GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
#define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_
@@ -114,6 +115,7 @@
#if GTEST_HAS_ABSL
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
+#include "absl/types/variant.h"
#endif // GTEST_HAS_ABSL
namespace testing {@@ -636,6 +638,10 @@
}
#endif // GTEST_HAS_ABSL
+#if GTEST_LANG_CXX11
+inline void PrintTo(std::nullptr_t, ::std::ostream* os) { *os << "(nullptr)"; }+#endif // GTEST_LANG_CXX11
+
#if GTEST_HAS_TR1_TUPLE || GTEST_HAS_STD_TUPLE_
// Helper function for printing a tuple. T must be instantiated with
// a tuple type.
@@ -783,6 +789,28 @@
}
};
+// Printer for absl::variant
+
+template <typename... T>
+class UniversalPrinter<::absl::variant<T...>> {+ public:
+ static void Print(const ::absl::variant<T...>& value, ::std::ostream* os) {+ *os << '(';+ absl::visit(Visitor{os}, value);+ *os << ')';
+ }
+
+ private:
+ struct Visitor {+ template <typename U>
+ void operator()(const U& u) const {+ *os << "'" << GetTypeName<U>() << "' with value ";
+ UniversalPrint(u, os);
+ }
+ ::std::ostream* os;
+ };
+};
+
#endif // GTEST_HAS_ABSL
// UniversalPrintArray(begin, len, os) prints an array of 'len'
@@ -798,7 +826,7 @@
// 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.
- // TODO([email protected]): let the user control the threshold using a flag.
+ // FIXME: let the user control the threshold using a flag.
if (len <= kThreshold) {PrintRawArrayTo(begin, len, os);
} else {@@ -950,12 +978,13 @@
static const size_t tuple_size = ::std::tr1::tuple_size<Tuple>::value;
template <size_t I>
- struct tuple_element : ::std::tr1::tuple_element<I, Tuple> {};+ struct tuple_element : ::std::tr1::tuple_element<static_cast<int>(I), Tuple> {+ };
template <size_t I>
- static typename AddReference<
- const typename ::std::tr1::tuple_element<I, Tuple>::type>::type get(
- const Tuple& tuple) {+ static typename AddReference<const typename ::std::tr1::tuple_element<
+ static_cast<int>(I), Tuple>::type>::type
+ get(const Tuple& tuple) {return ::std::tr1::get<I>(tuple);
}
};
--- a/third_party/googletest/src/include/gtest/gtest-spi.h
+++ b/third_party/googletest/src/include/gtest/gtest-spi.h
@@ -26,17 +26,21 @@
// 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.
+
//
-// Author: [email protected] (Zhanyong Wan)
-//
// 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 GTEST_INCLUDE_GTEST_GTEST_SPI_H_
#define GTEST_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
@@ -110,6 +114,8 @@
} // 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
--- a/third_party/googletest/src/include/gtest/gtest-test-part.h
+++ b/third_party/googletest/src/include/gtest/gtest-test-part.h
@@ -27,8 +27,7 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
-// Author: [email protected] (Markus Heule)
-//
+// GOOGLETEST_CM0001 DO NOT DELETE
#ifndef GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
#define GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
@@ -38,6 +37,9 @@
#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
@@ -143,7 +145,7 @@
};
// This interface knows how to report a test part result.
-class TestPartResultReporterInterface {+class GTEST_API_ TestPartResultReporterInterface {public:
virtual ~TestPartResultReporterInterface() {}@@ -175,5 +177,7 @@
} // namespace internal
} // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
#endif // GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_
--- a/third_party/googletest/src/include/gtest/gtest-typed-test.h
+++ b/third_party/googletest/src/include/gtest/gtest-typed-test.h
@@ -26,9 +26,10 @@
// 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.
-//
-// Author: [email protected] (Zhanyong Wan)
+
+// GOOGLETEST_CM0001 DO NOT DELETE
+
#ifndef GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
#define GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_
@@ -82,6 +83,24 @@
TYPED_TEST(FooTest, HasPropertyA) { ... }+// TYPED_TEST_CASE 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_CASE(FooTest, MyTypes, MyTypeNames);
+
#endif // 0
// Type-parameterized tests are abstract test patterns parameterized
@@ -143,6 +162,11 @@
// If the type list contains only one type, you can write that type
// directly without Types<...>:
// INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int);
+//
+// Similar to the optional argument of TYPED_TEST_CASE above,
+// INSTANTIATE_TEST_CASE_P takes an optional fourth argument which allows to
+// generate custom names.
+// INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes, MyTypeNames);
#endif // 0
@@ -159,32 +183,46 @@
// given test case.
# define GTEST_TYPE_PARAMS_(TestCaseName) gtest_type_params_##TestCaseName##_
+// Expands to the name of the typedef for the NameGenerator, responsible for
+// creating the suffixes of the name.
+#define GTEST_NAME_GENERATOR_(TestCaseName) \
+ gtest_type_params_##TestCaseName##_NameGenerator
+
// The 'Types' template argument below must have spaces around it
// since some compilers may choke on '>>' when passing a template
// instance (e.g. Types<int>)
-# define TYPED_TEST_CASE(CaseName, Types) \
- typedef ::testing::internal::TypeList< Types >::type \
- GTEST_TYPE_PARAMS_(CaseName)
+# define TYPED_TEST_CASE(CaseName, Types, ...) \
+ typedef ::testing::internal::TypeList< Types >::type GTEST_TYPE_PARAMS_( \
+ CaseName); \
+ typedef ::testing::internal::NameGeneratorSelector<__VA_ARGS__>::type \
+ GTEST_NAME_GENERATOR_(CaseName)
-# define TYPED_TEST(CaseName, TestName) \
- 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; \
- virtual void TestBody(); \
- }; \
- 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__), \
- #CaseName, #TestName, 0); \
- template <typename gtest_TypeParam_> \
- void GTEST_TEST_CLASS_NAME_(CaseName, TestName)<gtest_TypeParam_>::TestBody()
+# define TYPED_TEST(CaseName, TestName) \
+ 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; \
+ virtual void TestBody(); \
+ }; \
+ 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__), \
+ #CaseName, #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()
#endif // GTEST_HAS_TYPED_TEST
@@ -249,15 +287,19 @@
// The 'Types' template argument below must have spaces around it
// since some compilers may choke on '>>' when passing a template
// instance (e.g. Types<int>)
-# define INSTANTIATE_TYPED_TEST_CASE_P(Prefix, CaseName, Types) \
- bool gtest_##Prefix##_##CaseName GTEST_ATTRIBUTE_UNUSED_ = \
- ::testing::internal::TypeParameterizedTestCase<CaseName, \
- GTEST_CASE_NAMESPACE_(CaseName)::gtest_AllTests_, \
- ::testing::internal::TypeList< Types >::type>::Register(\
- #Prefix, \
- ::testing::internal::CodeLocation(__FILE__, __LINE__), \
- >EST_TYPED_TEST_CASE_P_STATE_(CaseName), \
- #CaseName, GTEST_REGISTERED_TEST_NAMES_(CaseName))
+# define INSTANTIATE_TYPED_TEST_CASE_P(Prefix, CaseName, Types, ...) \
+ static bool gtest_##Prefix##_##CaseName GTEST_ATTRIBUTE_UNUSED_ = \
+ ::testing::internal::TypeParameterizedTestCase< \
+ CaseName, GTEST_CASE_NAMESPACE_(CaseName)::gtest_AllTests_, \
+ ::testing::internal::TypeList< Types >::type>:: \
+ Register(#Prefix, \
+ ::testing::internal::CodeLocation(__FILE__, __LINE__), \
+ >EST_TYPED_TEST_CASE_P_STATE_(CaseName), #CaseName, \
+ GTEST_REGISTERED_TEST_NAMES_(CaseName), \
+ ::testing::internal::GenerateNames< \
+ ::testing::internal::NameGeneratorSelector< \
+ __VA_ARGS__>::type, \
+ ::testing::internal::TypeList< Types >::type>())
#endif // GTEST_HAS_TYPED_TEST_P
--- a/third_party/googletest/src/include/gtest/gtest.h
+++ b/third_party/googletest/src/include/gtest/gtest.h
@@ -26,11 +26,10 @@
// 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.
+
//
-// Author: [email protected] (Zhanyong Wan)
+// The Google C++ Testing and Mocking Framework (Google Test)
//
-// The Google C++ Testing 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.
//
@@ -48,6 +47,8 @@
// registration from Barthelemy Dagenais' ([email protected])
// easyUnit framework.
+// GOOGLETEST_CM0001 DO NOT DELETE
+
#ifndef GTEST_INCLUDE_GTEST_GTEST_H_
#define GTEST_INCLUDE_GTEST_GTEST_H_
@@ -65,6 +66,9 @@
#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 */)
+
// Depending on the platform, different string classes are available.
// On Linux, in addition to ::std::string, Google also makes use of
// class ::string, which has the same interface as ::std::string, but
@@ -82,6 +86,15 @@
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.
@@ -103,6 +116,10 @@
// 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);
@@ -146,6 +163,10 @@
// 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;
@@ -163,6 +184,7 @@
class TestEventRepeater;
class UnitTestRecordPropertyTestHelper;
class WindowsDeathTest;
+class FuchsiaDeathTest;
class UnitTestImpl* GetUnitTestImpl();
void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
const std::string& message);
@@ -304,7 +326,7 @@
const char* message() const {return message_.get() != NULL ? message_->c_str() : "";
}
- // TODO([email protected]): Remove this after making sure no clients use it.
+ // FIXME: Remove this after making sure no clients use it.
// Deprecated; please use message() instead.
const char* failure_message() const { return message(); }@@ -584,6 +606,7 @@
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 {@@ -609,7 +632,7 @@
// Adds a failure if the key is a reserved attribute of Google Test
// testcase tags. Returns true if the property is valid.
- // TODO(russr): Validate attribute names are legal and human readable.
+ // FIXME: Validate attribute names are legal and human readable.
static bool ValidateTestProperty(const std::string& xml_element,
const TestProperty& test_property);
@@ -2295,6 +2318,10 @@
// Tries to determine an appropriate directory for the platform.
GTEST_API_ std::string TempDir();
+#ifdef _MSC_VER
+# pragma warning(pop)
+#endif
+
} // namespace testing
// Use this function in main() to run all tests. It returns 0 if all
@@ -2310,5 +2337,7 @@
inline int RUN_ALL_TESTS() {return ::testing::UnitTest::GetInstance()->Run();
}
+
+GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
#endif // GTEST_INCLUDE_GTEST_GTEST_H_
--- a/third_party/googletest/src/include/gtest/gtest_pred_impl.h
+++ b/third_party/googletest/src/include/gtest/gtest_pred_impl.h
@@ -32,6 +32,8 @@
//
// Implements a family of generic predicate assertion macros.
+// GOOGLETEST_CM0001 DO NOT DELETE
+
#ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
#define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_
--- a/third_party/googletest/src/include/gtest/gtest_prod.h
+++ b/third_party/googletest/src/include/gtest/gtest_prod.h
@@ -26,10 +26,10 @@
// 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.
+
//
-// Author: [email protected] (Zhanyong Wan)
-//
-// Google C++ Testing Framework definitions useful in production code.
+// Google C++ Testing and Mocking Framework definitions useful in production code.
+// GOOGLETEST_CM0003 DO NOT DELETE
#ifndef GTEST_INCLUDE_GTEST_GTEST_PROD_H_
#define GTEST_INCLUDE_GTEST_GTEST_PROD_H_
--- /dev/null
+++ b/third_party/googletest/src/include/gtest/internal/custom/README.md
@@ -1,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.
--- a/third_party/googletest/src/include/gtest/internal/custom/gtest-port.h
+++ b/third_party/googletest/src/include/gtest/internal/custom/gtest-port.h
@@ -27,45 +27,7 @@
// (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.
-// 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)
-//
-// Test filtering:
-// GTEST_TEST_FILTER_ENV_VAR_ - The name of an environment variable that
-// will be used if --GTEST_FLAG(test_filter)
-// is not provided.
-//
-// 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.
+// Injection point for custom user configurations. See README for details
//
// ** Custom implementation starts here **
--- a/third_party/googletest/src/include/gtest/internal/custom/gtest-printers.h
+++ b/third_party/googletest/src/include/gtest/internal/custom/gtest-printers.h
@@ -31,8 +31,8 @@
// installation of gTest.
// It will be included from gtest-printers.h and the overrides in this file
// will be visible to everyone.
-// See documentation at gtest/gtest-printers.h for details on how to define a
-// custom printer.
+//
+// Injection point for custom user configurations. See README for details
//
// ** Custom implementation starts here **
--- a/third_party/googletest/src/include/gtest/internal/custom/gtest.h
+++ b/third_party/googletest/src/include/gtest/internal/custom/gtest.h
@@ -27,15 +27,7 @@
// (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.
-// 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.
+// Injection point for custom user configurations. See README for details
//
// ** Custom implementation starts here **
--- a/third_party/googletest/src/include/gtest/internal/gtest-death-test-internal.h
+++ b/third_party/googletest/src/include/gtest/internal/gtest-death-test-internal.h
@@ -27,11 +27,11 @@
// (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)
//
-// The Google C++ Testing 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 GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_
@@ -52,6 +52,9 @@
#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
@@ -134,6 +137,8 @@
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 {--- a/third_party/googletest/src/include/gtest/internal/gtest-filepath.h
+++ b/third_party/googletest/src/include/gtest/internal/gtest-filepath.h
@@ -27,7 +27,6 @@
// (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
@@ -36,11 +35,16 @@
// This file is #included in gtest/internal/gtest-internal.h.
// Do not include this header file separately!
+// GOOGLETEST_CM0001 DO NOT DELETE
+
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
#define GTEST_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 {@@ -201,5 +205,7 @@
} // namespace internal
} // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_
--- a/third_party/googletest/src/include/gtest/internal/gtest-internal.h
+++ b/third_party/googletest/src/include/gtest/internal/gtest-internal.h
@@ -27,12 +27,13 @@
// (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)
//
-// The Google C++ Testing 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 GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
@@ -140,6 +141,9 @@
#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
@@ -151,6 +155,8 @@
explicit GoogleTestFailureException(const TestPartResult& failure);
};
+GTEST_DISABLE_MSC_WARNINGS_POP_() // 4275
+
#endif // GTEST_HAS_EXCEPTIONS
namespace edit_distance {@@ -157,7 +163,7 @@
// 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.
+// 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(
@@ -527,6 +533,9 @@
#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P
+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 case.
class GTEST_API_ TypedTestCasePState {public:
@@ -572,6 +581,8 @@
RegisteredTestsMap registered_tests_;
};
+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) {@@ -595,6 +606,37 @@
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(Types0, 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
@@ -609,10 +651,10 @@
// specified in INSTANTIATE_TYPED_TEST_CASE_P(Prefix, TestCase,
// 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) {+ 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;
@@ -620,20 +662,23 @@
// First, registers the first type-parameterized test in the type
// list.
MakeAndRegisterTestInfo(
- (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/"
- + StreamableToString(index)).c_str(),
+ (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name +
+ "/" + type_names[index])
+ .c_str(),
StripTrailingSpaces(GetPrefixUntilComma(test_names)).c_str(),
GetTypeName<Type>().c_str(),
NULL, // No value parameter.
- code_location,
- GetTypeId<FixtureClass>(),
- TestClass::SetUpTestCase,
- TestClass::TearDownTestCase,
- new TestFactoryImpl<TestClass>);
+ code_location, GetTypeId<FixtureClass>(), TestClass::SetUpTestCase,
+ TestClass::TearDownTestCase, 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);
+ return TypeParameterizedTest<Fixture, TestSel,
+ typename Types::Tail>::Register(prefix,
+ code_location,
+ case_name,
+ test_names,
+ index + 1,
+ type_names);
}
};
@@ -643,7 +688,9 @@
public:
static bool Register(const char* /*prefix*/, const CodeLocation&,
const char* /*case_name*/, const char* /*test_names*/,
- int /*index*/) {+ int /*index*/,
+ const std::vector<std::string>& =
+ std::vector<std::string>() /*type_names*/) {return true;
}
};
@@ -656,8 +703,10 @@
class TypeParameterizedTestCase {public:
static bool Register(const char* prefix, CodeLocation code_location,
- const TypedTestCasePState* state,
- const char* case_name, const char* test_names) {+ const TypedTestCasePState* state, const char* case_name,
+ const char* test_names,
+ const std::vector<std::string>& type_names =
+ GenerateNames<DefaultNameGenerator, Types>()) {std::string test_name = StripTrailingSpaces(
GetPrefixUntilComma(test_names));
if (!state->TestExists(test_name)) {@@ -674,12 +723,14 @@
// 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);
+ prefix, test_location, case_name, test_names, 0, type_names);
// Next, recurses (at compile time) with the tail of the test list.
- return TypeParameterizedTestCase<Fixture, typename Tests::Tail, Types>
- ::Register(prefix, code_location, state,
- case_name, SkipComma(test_names));
+ return TypeParameterizedTestCase<Fixture, typename Tests::Tail,
+ Types>::Register(prefix, code_location,
+ state, case_name,
+ SkipComma(test_names),
+ type_names);
}
};
@@ -689,7 +740,9 @@
public:
static bool Register(const char* /*prefix*/, const CodeLocation&,
const TypedTestCasePState* /*state*/,
- const char* /*case_name*/, const char* /*test_names*/) {+ const char* /*case_name*/, const char* /*test_names*/,
+ const std::vector<std::string>& =
+ std::vector<std::string>() /*type_names*/) {return true;
}
};
@@ -1155,7 +1208,7 @@
#define GTEST_SUCCESS_(message) \
GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess)
-// Suppresses MSVC warnings 4072 (unreachable code) for the code following
+// Suppress MSVC warning 4702 (unreachable code) for the code following
// statement if it returns or throws (or doesn't return or throw in some
// situations).
#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \
--- a/third_party/googletest/src/include/gtest/internal/gtest-linked_ptr.h
+++ b/third_party/googletest/src/include/gtest/internal/gtest-linked_ptr.h
@@ -27,8 +27,6 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
-// Authors: Dan Egnor ([email protected])
-//
// A "smart" pointer type with reference tracking. Every pointer to a
// particular object is kept on a circular linked list. When the last pointer
// to an object is destroyed or reassigned, the object is deleted.
@@ -62,8 +60,10 @@
// raw pointer (e.g. via get()) concurrently, and
// - it's safe to write to two linked_ptrs that point to the same
// shared object concurrently.
-// TODO([email protected]): rename this to safe_linked_ptr to avoid
+// FIXME: rename this to safe_linked_ptr to avoid
// confusion with normal linked_ptr.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_
--- a/third_party/googletest/src/include/gtest/internal/gtest-param-util-generated.h
+++ b/third_party/googletest/src/include/gtest/internal/gtest-param-util-generated.h
@@ -30,9 +30,8 @@
// 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.
-//
-// Author: [email protected] (Vlad Losev)
+
// Type and function utilities for implementing parameterized tests.
// This file is generated by a SCRIPT. DO NOT EDIT BY HAND!
//
@@ -43,6 +42,8 @@
// by the maximum arity of the implementation of tuple which is
// currently set at 10.
+// GOOGLETEST_CM0001 DO NOT DELETE
+
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
@@ -79,6 +80,8 @@
return ValuesIn(array);
}
+ ValueArray1(const ValueArray1& other) : v1_(other.v1_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray1& other);
@@ -97,6 +100,8 @@
return ValuesIn(array);
}
+ ValueArray2(const ValueArray2& other) : v1_(other.v1_), v2_(other.v2_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray2& other);
@@ -117,6 +122,9 @@
return ValuesIn(array);
}
+ ValueArray3(const ValueArray3& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray3& other);
@@ -139,6 +147,9 @@
return ValuesIn(array);
}
+ ValueArray4(const ValueArray4& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray4& other);
@@ -162,6 +173,9 @@
return ValuesIn(array);
}
+ ValueArray5(const ValueArray5& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray5& other);
@@ -188,6 +202,9 @@
return ValuesIn(array);
}
+ ValueArray6(const ValueArray6& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray6& other);
@@ -215,6 +232,10 @@
return ValuesIn(array);
}
+ ValueArray7(const ValueArray7& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray7& other);
@@ -244,6 +265,10 @@
return ValuesIn(array);
}
+ ValueArray8(const ValueArray8& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray8& other);
@@ -275,6 +300,10 @@
return ValuesIn(array);
}
+ ValueArray9(const ValueArray9& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray9& other);
@@ -307,6 +336,10 @@
return ValuesIn(array);
}
+ ValueArray10(const ValueArray10& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray10& other);
@@ -341,6 +374,11 @@
return ValuesIn(array);
}
+ ValueArray11(const ValueArray11& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray11& other);
@@ -377,6 +415,11 @@
return ValuesIn(array);
}
+ ValueArray12(const ValueArray12& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray12& other);
@@ -415,6 +458,11 @@
return ValuesIn(array);
}
+ ValueArray13(const ValueArray13& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray13& other);
@@ -454,6 +502,11 @@
return ValuesIn(array);
}
+ ValueArray14(const ValueArray14& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray14& other);
@@ -495,6 +548,12 @@
return ValuesIn(array);
}
+ ValueArray15(const ValueArray15& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray15& other);
@@ -539,6 +598,12 @@
return ValuesIn(array);
}
+ ValueArray16(const ValueArray16& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray16& other);
@@ -584,6 +649,12 @@
return ValuesIn(array);
}
+ ValueArray17(const ValueArray17& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray17& other);
@@ -631,6 +702,12 @@
return ValuesIn(array);
}
+ ValueArray18(const ValueArray18& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray18& other);
@@ -679,6 +756,13 @@
return ValuesIn(array);
}
+ ValueArray19(const ValueArray19& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray19& other);
@@ -729,6 +813,13 @@
return ValuesIn(array);
}
+ ValueArray20(const ValueArray20& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray20& other);
@@ -782,6 +873,13 @@
return ValuesIn(array);
}
+ ValueArray21(const ValueArray21& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray21& other);
@@ -836,6 +934,13 @@
return ValuesIn(array);
}
+ ValueArray22(const ValueArray22& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray22& other);
@@ -892,6 +997,14 @@
return ValuesIn(array);
}
+ ValueArray23(const ValueArray23& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray23& other);
@@ -950,6 +1063,14 @@
return ValuesIn(array);
}
+ ValueArray24(const ValueArray24& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray24& other);
@@ -1009,6 +1130,14 @@
return ValuesIn(array);
}
+ ValueArray25(const ValueArray25& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray25& other);
@@ -1070,6 +1199,14 @@
return ValuesIn(array);
}
+ ValueArray26(const ValueArray26& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray26& other);
@@ -1134,6 +1271,15 @@
return ValuesIn(array);
}
+ ValueArray27(const ValueArray27& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray27& other);
@@ -1199,6 +1345,15 @@
return ValuesIn(array);
}
+ ValueArray28(const ValueArray28& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray28& other);
@@ -1265,6 +1420,15 @@
return ValuesIn(array);
}
+ ValueArray29(const ValueArray29& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray29& other);
@@ -1334,6 +1498,15 @@
return ValuesIn(array);
}
+ ValueArray30(const ValueArray30& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray30& other);
@@ -1405,6 +1578,16 @@
return ValuesIn(array);
}
+ ValueArray31(const ValueArray31& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray31& other);
@@ -1477,6 +1660,16 @@
return ValuesIn(array);
}
+ ValueArray32(const ValueArray32& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray32& other);
@@ -1552,6 +1745,16 @@
return ValuesIn(array);
}
+ ValueArray33(const ValueArray33& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_), v33_(other.v33_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray33& other);
@@ -1628,6 +1831,16 @@
return ValuesIn(array);
}
+ ValueArray34(const ValueArray34& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_), v33_(other.v33_), v34_(other.v34_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray34& other);
@@ -1705,6 +1918,17 @@
return ValuesIn(array);
}
+ ValueArray35(const ValueArray35& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_), v33_(other.v33_), v34_(other.v34_),
+ v35_(other.v35_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray35& other);
@@ -1785,6 +2009,17 @@
return ValuesIn(array);
}
+ ValueArray36(const ValueArray36& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_), v33_(other.v33_), v34_(other.v34_),
+ v35_(other.v35_), v36_(other.v36_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray36& other);
@@ -1867,6 +2102,17 @@
return ValuesIn(array);
}
+ ValueArray37(const ValueArray37& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_), v33_(other.v33_), v34_(other.v34_),
+ v35_(other.v35_), v36_(other.v36_), v37_(other.v37_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray37& other);
@@ -1950,6 +2196,17 @@
return ValuesIn(array);
}
+ ValueArray38(const ValueArray38& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_), v33_(other.v33_), v34_(other.v34_),
+ v35_(other.v35_), v36_(other.v36_), v37_(other.v37_), v38_(other.v38_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray38& other);
@@ -2035,6 +2292,18 @@
return ValuesIn(array);
}
+ ValueArray39(const ValueArray39& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_), v33_(other.v33_), v34_(other.v34_),
+ v35_(other.v35_), v36_(other.v36_), v37_(other.v37_), v38_(other.v38_),
+ v39_(other.v39_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray39& other);
@@ -2122,6 +2391,18 @@
return ValuesIn(array);
}
+ ValueArray40(const ValueArray40& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_), v33_(other.v33_), v34_(other.v34_),
+ v35_(other.v35_), v36_(other.v36_), v37_(other.v37_), v38_(other.v38_),
+ v39_(other.v39_), v40_(other.v40_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray40& other);
@@ -2211,6 +2492,18 @@
return ValuesIn(array);
}
+ ValueArray41(const ValueArray41& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_), v33_(other.v33_), v34_(other.v34_),
+ v35_(other.v35_), v36_(other.v36_), v37_(other.v37_), v38_(other.v38_),
+ v39_(other.v39_), v40_(other.v40_), v41_(other.v41_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray41& other);
@@ -2302,6 +2595,18 @@
return ValuesIn(array);
}
+ ValueArray42(const ValueArray42& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_), v33_(other.v33_), v34_(other.v34_),
+ v35_(other.v35_), v36_(other.v36_), v37_(other.v37_), v38_(other.v38_),
+ v39_(other.v39_), v40_(other.v40_), v41_(other.v41_), v42_(other.v42_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray42& other);
@@ -2394,6 +2699,19 @@
return ValuesIn(array);
}
+ ValueArray43(const ValueArray43& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_), v33_(other.v33_), v34_(other.v34_),
+ v35_(other.v35_), v36_(other.v36_), v37_(other.v37_), v38_(other.v38_),
+ v39_(other.v39_), v40_(other.v40_), v41_(other.v41_), v42_(other.v42_),
+ v43_(other.v43_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray43& other);
@@ -2488,6 +2806,19 @@
return ValuesIn(array);
}
+ ValueArray44(const ValueArray44& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_), v33_(other.v33_), v34_(other.v34_),
+ v35_(other.v35_), v36_(other.v36_), v37_(other.v37_), v38_(other.v38_),
+ v39_(other.v39_), v40_(other.v40_), v41_(other.v41_), v42_(other.v42_),
+ v43_(other.v43_), v44_(other.v44_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray44& other);
@@ -2584,6 +2915,19 @@
return ValuesIn(array);
}
+ ValueArray45(const ValueArray45& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_), v33_(other.v33_), v34_(other.v34_),
+ v35_(other.v35_), v36_(other.v36_), v37_(other.v37_), v38_(other.v38_),
+ v39_(other.v39_), v40_(other.v40_), v41_(other.v41_), v42_(other.v42_),
+ v43_(other.v43_), v44_(other.v44_), v45_(other.v45_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray45& other);
@@ -2682,6 +3026,19 @@
return ValuesIn(array);
}
+ ValueArray46(const ValueArray46& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_), v33_(other.v33_), v34_(other.v34_),
+ v35_(other.v35_), v36_(other.v36_), v37_(other.v37_), v38_(other.v38_),
+ v39_(other.v39_), v40_(other.v40_), v41_(other.v41_), v42_(other.v42_),
+ v43_(other.v43_), v44_(other.v44_), v45_(other.v45_), v46_(other.v46_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray46& other);
@@ -2782,6 +3139,20 @@
return ValuesIn(array);
}
+ ValueArray47(const ValueArray47& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_), v33_(other.v33_), v34_(other.v34_),
+ v35_(other.v35_), v36_(other.v36_), v37_(other.v37_), v38_(other.v38_),
+ v39_(other.v39_), v40_(other.v40_), v41_(other.v41_), v42_(other.v42_),
+ v43_(other.v43_), v44_(other.v44_), v45_(other.v45_), v46_(other.v46_),
+ v47_(other.v47_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray47& other);
@@ -2884,6 +3255,20 @@
return ValuesIn(array);
}
+ ValueArray48(const ValueArray48& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_), v33_(other.v33_), v34_(other.v34_),
+ v35_(other.v35_), v36_(other.v36_), v37_(other.v37_), v38_(other.v38_),
+ v39_(other.v39_), v40_(other.v40_), v41_(other.v41_), v42_(other.v42_),
+ v43_(other.v43_), v44_(other.v44_), v45_(other.v45_), v46_(other.v46_),
+ v47_(other.v47_), v48_(other.v48_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray48& other);
@@ -2987,6 +3372,20 @@
return ValuesIn(array);
}
+ ValueArray49(const ValueArray49& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_), v33_(other.v33_), v34_(other.v34_),
+ v35_(other.v35_), v36_(other.v36_), v37_(other.v37_), v38_(other.v38_),
+ v39_(other.v39_), v40_(other.v40_), v41_(other.v41_), v42_(other.v42_),
+ v43_(other.v43_), v44_(other.v44_), v45_(other.v45_), v46_(other.v46_),
+ v47_(other.v47_), v48_(other.v48_), v49_(other.v49_) {}+
private:
// No implementation - assignment is unsupported.
void operator=(const ValueArray49& other);
@@ -3090,6 +3489,20 @@
static_cast<T>(v48_), static_cast<T>(v49_), static_cast<T>(v50_)};
return ValuesIn(array);
}
+
+ ValueArray50(const ValueArray50& other) : v1_(other.v1_), v2_(other.v2_),
+ v3_(other.v3_), v4_(other.v4_), v5_(other.v5_), v6_(other.v6_),
+ v7_(other.v7_), v8_(other.v8_), v9_(other.v9_), v10_(other.v10_),
+ v11_(other.v11_), v12_(other.v12_), v13_(other.v13_), v14_(other.v14_),
+ v15_(other.v15_), v16_(other.v16_), v17_(other.v17_), v18_(other.v18_),
+ v19_(other.v19_), v20_(other.v20_), v21_(other.v21_), v22_(other.v22_),
+ v23_(other.v23_), v24_(other.v24_), v25_(other.v25_), v26_(other.v26_),
+ v27_(other.v27_), v28_(other.v28_), v29_(other.v29_), v30_(other.v30_),
+ v31_(other.v31_), v32_(other.v32_), v33_(other.v33_), v34_(other.v34_),
+ v35_(other.v35_), v36_(other.v36_), v37_(other.v37_), v38_(other.v38_),
+ v39_(other.v39_), v40_(other.v40_), v41_(other.v41_), v42_(other.v42_),
+ v43_(other.v43_), v44_(other.v44_), v45_(other.v45_), v46_(other.v46_),
+ v47_(other.v47_), v48_(other.v48_), v49_(other.v49_), v50_(other.v50_) {}private:
// No implementation - assignment is unsupported.
--- a/third_party/googletest/src/include/gtest/internal/gtest-param-util-generated.h.pump
+++ b/third_party/googletest/src/include/gtest/internal/gtest-param-util-generated.h.pump
@@ -29,9 +29,8 @@
// 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.
-//
-// Author: [email protected] (Vlad Losev)
+
// Type and function utilities for implementing parameterized tests.
// This file is generated by a SCRIPT. DO NOT EDIT BY HAND!
//
@@ -42,6 +41,8 @@
// by the maximum arity of the implementation of tuple which is
// currently set at $maxtuple.
+// GOOGLETEST_CM0001 DO NOT DELETE
+
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_
@@ -81,6 +82,8 @@
const T array[] = {$for j, [[static_cast<T>(v$(j)_)]]};return ValuesIn(array);
}
+
+ ValueArray$i(const ValueArray$i& other) : $for j, [[v$(j)_(other.v$(j)_)]] {}private:
// No implementation - assignment is unsupported.
--- a/third_party/googletest/src/include/gtest/internal/gtest-param-util.h
+++ b/third_party/googletest/src/include/gtest/internal/gtest-param-util.h
@@ -26,10 +26,11 @@
// 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.
-//
-// Author: [email protected] (Vlad Losev)
+
// Type and function utilities for implementing parameterized tests.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_
--- a/third_party/googletest/src/include/gtest/internal/gtest-port-arch.h
+++ b/third_party/googletest/src/include/gtest/internal/gtest-port-arch.h
@@ -27,7 +27,7 @@
// (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 Framework (Google Test)
+// 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.
--- a/third_party/googletest/src/include/gtest/internal/gtest-port.h
+++ b/third_party/googletest/src/include/gtest/internal/gtest-port.h
@@ -27,8 +27,6 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
-// Authors: [email protected] (Zhanyong Wan)
-//
// 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
@@ -40,6 +38,8 @@
// files are expected to #include this. Therefore, it cannot #include
// any other Google Test header.
+// GOOGLETEST_CM0001 DO NOT DELETE
+
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
@@ -178,6 +178,7 @@
// 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.
@@ -228,10 +229,10 @@
//
// Regular expressions:
// RE - a simple regular expression class using the POSIX
-// Extended Regular Expression syntax on UNIX-like
-// platforms, or a reduced regular exception syntax on
-// other platforms, including Windows.
-//
+// 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.
@@ -314,7 +315,7 @@
// GTEST_DISABLE_MSC_WARNINGS_PUSH_(4800 4385)
// /* code that triggers warnings C4800 and C4385 */
// GTEST_DISABLE_MSC_WARNINGS_POP_()
-#if _MSC_VER >= 1500
+#if _MSC_VER >= 1400
# define GTEST_DISABLE_MSC_WARNINGS_PUSH_(warnings) \
__pragma(warning(push)) \
__pragma(warning(disable: warnings))
@@ -326,6 +327,22 @@
# 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
+
#ifndef GTEST_LANG_CXX11
// gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when
// -std={c,gnu}++{0x,11} is passed. The C++11 standard specifies a@@ -380,7 +397,8 @@
#if GTEST_LANG_CXX11
# define GTEST_HAS_STD_TUPLE_ 1
# if defined(__clang__)
-// Inspired by http://clang.llvm.org/docs/LanguageExtensions.html#__has_include
+// Inspired by
+// https://clang.llvm.org/docs/LanguageExtensions.html#include-file-checking-macros
# if defined(__has_include) && !__has_include(<tuple>)
# undef GTEST_HAS_STD_TUPLE_
# endif
@@ -392,7 +410,7 @@
# elif defined(__GLIBCXX__)
// Inspired by boost/config/stdlib/libstdcpp3.hpp,
// http://gcc.gnu.org/gcc-4.2/changes.html and
-// http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt01ch01.html#manual.intro.status.standard.200x
+// https://web.archive.org/web/20140227044429/gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt01ch01.html#manual.intro.status.standard.200x
# if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 2)
# undef GTEST_HAS_STD_TUPLE_
# endif
@@ -523,17 +541,13 @@
#endif // !defined(GTEST_HAS_STD_STRING)
#ifndef GTEST_HAS_GLOBAL_STRING
-// The user didn't tell us whether ::string is available, so we need
-// to figure it out.
-
# define GTEST_HAS_GLOBAL_STRING 0
-
#endif // GTEST_HAS_GLOBAL_STRING
#ifndef GTEST_HAS_STD_WSTRING
// The user didn't tell us whether ::std::wstring is available, so we need
// to figure it out.
-// TODO([email protected]): uses autoconf to detect whether ::std::wstring
+// FIXME: uses autoconf to detect whether ::std::wstring
// is available.
// Cygwin 1.7 and below doesn't support ::std::wstring.
@@ -652,8 +666,13 @@
// STLport, provided with the Android NDK, has neither <tr1/tuple> or <tuple>.
# define GTEST_HAS_TR1_TUPLE 0
# elif defined(_MSC_VER) && (_MSC_VER >= 1910)
-// Prevent `warning C4996: 'std::tr1': warning STL4002: The non-Standard std::tr1 namespace and TR1-only machinery are deprecated and will be REMOVED.`
+// Prevent `warning C4996: 'std::tr1': warning STL4002:
+// The non-Standard std::tr1 namespace and TR1-only machinery
+// are deprecated and will be REMOVED.`
# define GTEST_HAS_TR1_TUPLE 0
+# elif GTEST_LANG_CXX11 && defined(_LIBCPP_VERSION)
+// libc++ doesn't support TR1.
+# define GTEST_HAS_TR1_TUPLE 0
# else
// The user didn't tell us not to do it, so we assume it's OK.
# define GTEST_HAS_TR1_TUPLE 1
@@ -663,6 +682,10 @@
// Determines whether Google Test's own tr1 tuple implementation
// should be used.
#ifndef GTEST_USE_OWN_TR1_TUPLE
+// We use our own tuple implementation on Symbian.
+# if GTEST_OS_SYMBIAN
+# define GTEST_USE_OWN_TR1_TUPLE 1
+# else
// The user didn't tell us, so we need to figure it out.
// We use our own TR1 tuple if we aren't sure the user has an
@@ -693,12 +716,11 @@
# else
# define GTEST_USE_OWN_TR1_TUPLE 1
# endif
-
+# endif // GTEST_OS_SYMBIAN
#endif // GTEST_USE_OWN_TR1_TUPLE
-// To avoid conditional compilation everywhere, we make it
-// gtest-port.h's responsibility to #include the header implementing
-// tuple.
+// To avoid conditional compilation we make it gtest-port.h's responsibility
+// to #include the header implementing tuple.
#if GTEST_HAS_STD_TUPLE_
# include <tuple> // IWYU pragma: export
# define GTEST_TUPLE_NAMESPACE_ ::std
@@ -713,22 +735,6 @@
# if GTEST_USE_OWN_TR1_TUPLE
# include "gtest/internal/gtest-tuple.h" // IWYU pragma: export // NOLINT
-# elif GTEST_ENV_HAS_STD_TUPLE_
-# include <tuple>
-// C++11 puts its tuple into the ::std namespace rather than
-// ::std::tr1. gtest expects tuple to live in ::std::tr1, so put it there.
-// This causes undefined behavior, but supported compilers react in
-// the way we intend.
-namespace std {-namespace tr1 {-using ::std::get;
-using ::std::make_tuple;
-using ::std::tuple;
-using ::std::tuple_element;
-using ::std::tuple_size;
-}
-}
-
# elif GTEST_OS_SYMBIAN
// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to
@@ -753,7 +759,7 @@
// Until version 4.3.2, gcc has a bug that causes <tr1/functional>,
// which is #included by <tr1/tuple>, to not compile when RTTI is
// disabled. _TR1_FUNCTIONAL is the header guard for
-// <tr1/functional>. Hence the following #define is a hack to prevent
+// <tr1/functional>. Hence the following #define is used to prevent
// <tr1/functional> from being included.
# define _TR1_FUNCTIONAL 1
# include <tr1/tuple>
@@ -763,10 +769,12 @@
# include <tr1/tuple> // NOLINT
# endif // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
-# else
-// If the compiler is not GCC 4.0+, we assume the user is using a
-// spec-conforming TR1 implementation.
+// VS 2010 now has tr1 support.
+# elif _MSC_VER >= 1600
# include <tuple> // IWYU pragma: export // NOLINT
+
+# else // GTEST_USE_OWN_TR1_TUPLE
+# include <tr1/tuple> // IWYU pragma: export // NOLINT
# endif // GTEST_USE_OWN_TR1_TUPLE
#endif // GTEST_HAS_TR1_TUPLE
@@ -820,7 +828,8 @@
(GTEST_OS_MAC && !GTEST_OS_IOS) || \
(GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \
GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \
- GTEST_OS_OPENBSD || GTEST_OS_QNX || GTEST_OS_FREEBSD || GTEST_OS_NETBSD)
+ GTEST_OS_OPENBSD || GTEST_OS_QNX || GTEST_OS_FREEBSD || \
+ GTEST_OS_NETBSD || GTEST_OS_FUCHSIA)
# define GTEST_HAS_DEATH_TEST 1
#endif
@@ -1224,7 +1233,7 @@
// Defines RE.
#if GTEST_USES_PCRE
-using ::RE;
+// 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
@@ -1255,7 +1264,7 @@
// PartialMatch(str, re) returns true iff regular expression re
// matches a substring of str (including str itself).
//
- // TODO([email protected]): make FullMatch() and PartialMatch() work
+ // FIXME: make FullMatch() and PartialMatch() work
// when str contains NUL characters.
static bool FullMatch(const ::std::string& str, const RE& re) {return FullMatch(str.c_str(), re);
@@ -1282,7 +1291,7 @@
void Init(const char* regex);
// We use a const char* instead of an std::string, as Google Test used to be
- // used where std::string is not available. TODO([email protected]): change to
+ // used where std::string is not available. FIXME: change to
// std::string.
const char* pattern_;
bool is_valid_;
@@ -1809,7 +1818,7 @@
// Initializes owner_thread_id_ and critical_section_ in static mutexes.
void ThreadSafeLazyInit();
- // Per http://blogs.msdn.com/b/oldnewthing/archive/2004/02/23/78395.aspx,
+ // 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_;
@@ -2093,8 +2102,13 @@
extern ::testing::internal::MutexBase mutex
// Defines and statically (i.e. at link time) initializes a static mutex.
-# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
- ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, false, pthread_t() }+// 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.
@@ -2484,7 +2498,7 @@
// Functions deprecated by MSVC 8.0.
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996 /* deprecated function */)
+GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
inline const char* StrNCpy(char* dest, const char* src, size_t n) {return strncpy(dest, src, n);
@@ -2532,7 +2546,7 @@
#endif
}
-GTEST_DISABLE_MSC_WARNINGS_POP_()
+GTEST_DISABLE_MSC_DEPRECATED_POP_()
#if GTEST_OS_WINDOWS_MOBILE
// Windows CE has no C library. The abort() function is used in
@@ -2670,7 +2684,7 @@
// 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.
-// TODO(chandlerc): Find a better way to refactor flag and environment parsing
+// FIXME: Find a better way to refactor flag and environment parsing
// out of both gtest-port.cc and gtest.cc to avoid exporting this utility
// function.
bool ParseInt32(const Message& src_text, const char* str, Int32* value);
--- a/third_party/googletest/src/include/gtest/internal/gtest-string.h
+++ b/third_party/googletest/src/include/gtest/internal/gtest-string.h
@@ -27,16 +27,16 @@
// (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)
//
-// The Google C++ Testing 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/gtest-internal.h.
+// This header file is #included by gtest-internal.h.
// It should not be #included by other files.
+
+// GOOGLETEST_CM0001 DO NOT DELETE
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_
--- a/third_party/googletest/src/include/gtest/internal/gtest-tuple.h
+++ b/third_party/googletest/src/include/gtest/internal/gtest-tuple.h
@@ -30,11 +30,12 @@
// 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.
-//
-// Author: [email protected] (Zhanyong Wan)
+
// Implements a subset of TR1 tuple needed by Google Test and Google Mock.
+// GOOGLETEST_CM0001 DO NOT DELETE
+
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
@@ -42,7 +43,7 @@
// The compiler used in Symbian has a bug that prevents us from declaring the
// tuple template as a friend (it complains that tuple is redefined). This
-// hack bypasses the bug by declaring the members that should otherwise be
+// bypasses the bug by declaring the members that should otherwise be
// private as public.
// Sun Studio versions < 12 also have the above bug.
#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)
--- a/third_party/googletest/src/include/gtest/internal/gtest-tuple.h.pump
+++ b/third_party/googletest/src/include/gtest/internal/gtest-tuple.h.pump
@@ -29,11 +29,12 @@
// 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.
-//
-// Author: [email protected] (Zhanyong Wan)
+
// Implements a subset of TR1 tuple needed by Google Test and Google Mock.
+// GOOGLETEST_CM0001 DO NOT DELETE
+
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
@@ -41,7 +42,7 @@
// The compiler used in Symbian has a bug that prevents us from declaring the
// tuple template as a friend (it complains that tuple is redefined). This
-// hack bypasses the bug by declaring the members that should otherwise be
+// bypasses the bug by declaring the members that should otherwise be
// private as public.
// Sun Studio versions < 12 also have the above bug.
#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)
--- a/third_party/googletest/src/include/gtest/internal/gtest-type-util.h
+++ b/third_party/googletest/src/include/gtest/internal/gtest-type-util.h
@@ -30,9 +30,8 @@
// 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.
-//
-// Author: [email protected] (Zhanyong Wan)
+
// Type utilities needed for implementing typed and type-parameterized
// tests. This file is generated by a SCRIPT. DO NOT EDIT BY HAND!
//
@@ -41,6 +40,8 @@
// Please contact [email protected] if you need
// more.
+// GOOGLETEST_CM0001 DO NOT DELETE
+
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
@@ -57,6 +58,22 @@
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;
+}
+
// GetTypeName<T>() returns a human-readable name of type T.
// NB: This function is also used in Google Mock, so don't move it inside of
// the typed-test-only section below.
@@ -75,7 +92,7 @@
char* const readable_name = __cxa_demangle(name, 0, 0, &status);
const std::string name_str(status == 0 ? readable_name : name);
free(readable_name);
- return name_str;
+ return CanonicalizeForStdLibVersioning(name_str);
# else
return name;
# endif // GTEST_HAS_CXXABI_H_ || __HP_aCC
--- a/third_party/googletest/src/include/gtest/internal/gtest-type-util.h.pump
+++ b/third_party/googletest/src/include/gtest/internal/gtest-type-util.h.pump
@@ -28,9 +28,8 @@
// 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.
-//
-// Author: [email protected] (Zhanyong Wan)
+
// Type utilities needed for implementing typed and type-parameterized
// tests. This file is generated by a SCRIPT. DO NOT EDIT BY HAND!
//
@@ -39,6 +38,8 @@
// Please contact [email protected] if you need
// more.
+// GOOGLETEST_CM0001 DO NOT DELETE
+
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_
@@ -55,6 +56,22 @@
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;
+}
+
// GetTypeName<T>() returns a human-readable name of type T.
// NB: This function is also used in Google Mock, so don't move it inside of
// the typed-test-only section below.
@@ -73,7 +90,7 @@
char* const readable_name = __cxa_demangle(name, 0, 0, &status);
const std::string name_str(status == 0 ? readable_name : name);
free(readable_name);
- return name_str;
+ return CanonicalizeForStdLibVersioning(name_str);
# else
return name;
# endif // GTEST_HAS_CXXABI_H_ || __HP_aCC
--- a/third_party/googletest/src/src/gtest-all.cc
+++ b/third_party/googletest/src/src/gtest-all.cc
@@ -26,10 +26,9 @@
// 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.
+
//
-// Author: [email protected] (Markus Heule)
-//
-// Google C++ Testing Framework (Google Test)
+// 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.
--- a/third_party/googletest/src/src/gtest-death-test.cc
+++ b/third_party/googletest/src/src/gtest-death-test.cc
@@ -26,9 +26,8 @@
// 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.
+
//
-// Author: [email protected] (Zhanyong Wan), [email protected] (Vlad Losev)
-//
// This file implements death tests.
#include "gtest/gtest-death-test.h"
@@ -62,6 +61,14 @@
# include <spawn.h>
# endif // GTEST_OS_QNX
+# if GTEST_OS_FUCHSIA
+# include <lib/fdio/io.h>
+# include <lib/fdio/spawn.h>
+# include <zircon/processargs.h>
+# include <zircon/syscalls.h>
+# include <zircon/syscalls/port.h>
+# endif // GTEST_OS_FUCHSIA
+
#endif // GTEST_HAS_DEATH_TEST
#include "gtest/gtest-message.h"
@@ -117,7 +124,7 @@
// 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
+# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
static bool g_in_fast_death_test_child = false;
# endif
@@ -127,10 +134,10 @@
// 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
+# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
- // On Windows, death tests are thread-safe regardless of the value of the
- // death_test_style flag.
+ // 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
@@ -150,7 +157,7 @@
// ExitedWithCode function-call operator.
bool ExitedWithCode::operator()(int exit_status) const {-# if GTEST_OS_WINDOWS
+# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
return exit_status == exit_code_;
@@ -158,10 +165,10 @@
return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_;
-# endif // GTEST_OS_WINDOWS
+# endif // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
}
-# if !GTEST_OS_WINDOWS
+# if !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
// KilledBySignal constructor.
KilledBySignal::KilledBySignal(int signum) : signum_(signum) {}
@@ -178,7 +185,7 @@
# endif // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_;
}
-# endif // !GTEST_OS_WINDOWS
+# endif // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
namespace internal {@@ -189,7 +196,7 @@
static std::string ExitSummary(int exit_code) {Message m;
-# if GTEST_OS_WINDOWS
+# if GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
m << "Exited with exit status " << exit_code;
@@ -205,7 +212,7 @@
m << " (core dumped)";
}
# endif
-# endif // GTEST_OS_WINDOWS
+# endif // GTEST_OS_WINDOWS || GTEST_OS_FUCHSIA
return m.GetString();
}
@@ -216,7 +223,7 @@
return !ExitedWithCode(0)(exit_status);
}
-# if !GTEST_OS_WINDOWS
+# 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
@@ -225,13 +232,19 @@
Message msg;
msg << "Death tests use fork(), which is unsafe particularly"
<< " in a threaded context. For this test, " << GTEST_NAME_ << " ";
- if (thread_count == 0)
+ if (thread_count == 0) {msg << "couldn't detect the number of threads.";
- else
+ } else {msg << "detected " << thread_count << " threads.";
+ }
+ msg << " See "
+ "https://github.com/google/googletest/blob/master/googletest/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
+# endif // !GTEST_OS_WINDOWS && !GTEST_OS_FUCHSIA
// Flag characters for reporting a death test that did not die.
static const char kDeathTestLived = 'L';
@@ -239,6 +252,13 @@
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;
@@ -246,7 +266,7 @@
// 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.
-// TODO([email protected]): Unify names and possibly values for
+// FIXME: Unify names and possibly values for
// AbortReason, DeathTestOutcome, and flag characters above.
enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW };@@ -561,7 +581,6 @@
if (status_ok) {# if GTEST_USES_PCRE
// PCRE regexes support embedded NULs.
- // GTEST_USES_PCRE is defined only in google3 mode
const bool matched = RE::PartialMatch(error_message, *regex());
# else
const bool matched = RE::PartialMatch(error_message.c_str(), *regex());
@@ -781,8 +800,201 @@
set_spawned(true);
return OVERSEE_TEST;
}
-# else // We are not on Windows.
+# elif GTEST_OS_FUCHSIA
+
+class FuchsiaDeathTest : public DeathTestImpl {+ public:
+ FuchsiaDeathTest(const char* a_statement,
+ const RE* a_regex,
+ const char* file,
+ int line)
+ : DeathTestImpl(a_statement, a_regex), file_(file), line_(line) {}+ virtual ~FuchsiaDeathTest() {+ zx_status_t status = zx_handle_close(child_process_);
+ GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
+ status = zx_handle_close(port_);
+ GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
+ }
+
+ // 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_;
+
+ zx_handle_t child_process_ = ZX_HANDLE_INVALID;
+ zx_handle_t port_ = ZX_HANDLE_INVALID;
+};
+
+// Utility class for accumulating command-line arguments.
+class Arguments {+ public:
+ Arguments() {+ args_.push_back(NULL);
+ }
+
+ ~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 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() {+ if (!spawned())
+ return 0;
+
+ // Register to wait for the child process to terminate.
+ zx_status_t status_zx;
+ status_zx = zx_object_wait_async(child_process_,
+ port_,
+ 0 /* key */,
+ ZX_PROCESS_TERMINATED,
+ ZX_WAIT_ASYNC_ONCE);
+ GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+
+ // Wait for it to terminate, or an exception to be received.
+ zx_port_packet_t packet;
+ status_zx = zx_port_wait(port_, ZX_TIME_INFINITE, &packet);
+ GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+
+ if (ZX_PKT_IS_EXCEPTION(packet.type)) {+ // Process encountered an exception. Kill it directly rather than letting
+ // other handlers process the event.
+ status_zx = zx_task_kill(child_process_);
+ GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+
+ // Now wait for |child_process_| to terminate.
+ zx_signals_t signals = 0;
+ status_zx = zx_object_wait_one(
+ child_process_, ZX_PROCESS_TERMINATED, ZX_TIME_INFINITE, &signals);
+ GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+ GTEST_DEATH_TEST_CHECK_(signals & ZX_PROCESS_TERMINATED);
+ } else {+ // Process terminated.
+ GTEST_DEATH_TEST_CHECK_(ZX_PKT_IS_SIGNAL_ONE(packet.type));
+ GTEST_DEATH_TEST_CHECK_(packet.signal.observed & ZX_PROCESS_TERMINATED);
+ }
+
+ ReadAndInterpretStatusByte();
+
+ zx_info_process_t buffer;
+ status_zx = zx_object_get_info(
+ child_process_,
+ ZX_INFO_PROCESS,
+ &buffer,
+ sizeof(buffer),
+ nullptr,
+ nullptr);
+ GTEST_DEATH_TEST_CHECK_(status_zx == ZX_OK);
+
+ GTEST_DEATH_TEST_CHECK_(buffer.exited);
+ set_status(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 != NULL) {+ // ParseInternalRunDeathTestFlag() has performed all the necessary
+ // processing.
+ set_write_fd(kFuchsiaReadPipeFd);
+ return EXECUTE_TEST;
+ }
+
+ CaptureStderr();
+ // 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_case_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;
+ uint32_t type;
+ status = fdio_pipe_half(&child_pipe_handle, &type);
+ GTEST_DEATH_TEST_CHECK_(status >= 0);
+ set_read_fd(status);
+
+ // Set the pipe handle for the child.
+ fdio_spawn_action_t add_handle_action = {};+ add_handle_action.action = FDIO_SPAWN_ACTION_ADD_HANDLE;
+ add_handle_action.h.id = PA_HND(type, kFuchsiaReadPipeFd);
+ add_handle_action.h.handle = child_pipe_handle;
+
+ // Spawn the child process.
+ status = fdio_spawn_etc(ZX_HANDLE_INVALID, FDIO_SPAWN_CLONE_ALL,
+ args.Argv()[0], args.Argv(), nullptr, 1,
+ &add_handle_action, &child_process_, nullptr);
+ GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
+
+ // Create an exception port and attach it to the |child_process_|, to allow
+ // us to suppress the system default exception handler from firing.
+ status = zx_port_create(0, &port_);
+ GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
+ status = zx_task_bind_exception_port(
+ child_process_, port_, 0 /* key */, 0 /*options */);
+ GTEST_DEATH_TEST_CHECK_(status == ZX_OK);
+
+ set_spawned(true);
+ return OVERSEE_TEST;
+}
+
+#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.
@@ -1204,6 +1416,13 @@
*test = new WindowsDeathTest(statement, regex, file, line);
}
+# elif GTEST_OS_FUCHSIA
+
+ if (GTEST_FLAG(death_test_style) == "threadsafe" ||
+ GTEST_FLAG(death_test_style) == "fast") {+ *test = new FuchsiaDeathTest(statement, regex, file, line);
+ }
+
# else
if (GTEST_FLAG(death_test_style) == "threadsafe") {@@ -1239,7 +1458,7 @@
StreamableToString(parent_process_id));
}
- // TODO([email protected]): Replace the following check with a
+ // FIXME: Replace the following check with a
// compile-time assertion when available.
GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t));
@@ -1324,6 +1543,16 @@
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
--- a/third_party/googletest/src/src/gtest-filepath.cc
+++ b/third_party/googletest/src/src/gtest-filepath.cc
@@ -250,7 +250,7 @@
// root directory per disk drive.)
bool FilePath::IsRootDirectory() const {#if GTEST_OS_WINDOWS
- // TODO([email protected]): on Windows a network share like
+ // FIXME: on Windows a network share like
// \\server\share can be a root directory, although it cannot be the
// current directory. Handle this properly.
return pathname_.length() == 3 && IsAbsolutePath();
@@ -350,7 +350,7 @@
// 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 "..".
-// TODO([email protected]): handle Windows network shares (e.g. \\server\share).
+// FIXME: handle Windows network shares (e.g. \\server\share).
void FilePath::Normalize() { if (pathname_.c_str() == NULL) {pathname_ = "";
--- a/third_party/googletest/src/src/gtest-internal-inl.h
+++ b/third_party/googletest/src/src/gtest-internal-inl.h
@@ -27,10 +27,7 @@
// (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.
-//
-// Author: [email protected] (Zhanyong Wan)
-//
+// 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.
@@ -62,6 +59,9 @@
#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.
@@ -446,6 +446,16 @@
virtual void UponLeavingGTest();
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);
};
@@ -984,7 +994,7 @@
const bool parse_success = *end == '\0' && errno == 0;
- // TODO([email protected]): Convert this to compile time assertion when it is
+ // FIXME: Convert this to compile time assertion when it is
// available.
GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed));
@@ -1171,5 +1181,7 @@
} // namespace internal
} // namespace testing
+
+GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
#endif // GTEST_SRC_GTEST_INTERNAL_INL_H_
--- a/third_party/googletest/src/src/gtest-port.cc
+++ b/third_party/googletest/src/src/gtest-port.cc
@@ -26,9 +26,8 @@
// 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.
-//
-// Author: [email protected] (Zhanyong Wan)
+
#include "gtest/internal/gtest-port.h"
#include <limits.h>
@@ -63,6 +62,11 @@
# 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"
@@ -156,6 +160,25 @@
}
}
+#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() {@@ -238,9 +261,9 @@
Mutex::~Mutex() {// Static mutexes are leaked intentionally. It is not thread-safe to try
// to clean them up.
- // TODO(yukawa): Switch to Slim Reader/Writer (SRW) Locks, which requires
+ // FIXME: Switch to Slim Reader/Writer (SRW) Locks, which requires
// nothing to clean it up but is available only on Vista and later.
- // http://msdn.microsoft.com/en-us/library/windows/desktop/aa904937.aspx
+ // https://docs.microsoft.com/en-us/windows/desktop/Sync/slim-reader-writer--srw--locks
if (type_ == kDynamic) {::DeleteCriticalSection(critical_section_);
delete critical_section_;
@@ -271,6 +294,43 @@
<< "The current thread is not holding the mutex @" << this;
}
+namespace {+
+// 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) {+#ifdef _MSC_VER
+ 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);
+#endif // _MSC_VER
+ }
+
+ ~MemoryIsNotDeallocated() {+#ifdef _MSC_VER
+ // Restore the original _CRTDBG_ALLOC_MEM_DF flag
+ _CrtSetDbgFlag(old_crtdbg_flag_);
+#endif // _MSC_VER
+ }
+
+ private:
+ int old_crtdbg_flag_;
+
+ GTEST_DISALLOW_COPY_AND_ASSIGN_(MemoryIsNotDeallocated);
+};
+
+} // namespace
+
// Initializes owner_thread_id_ and critical_section_ in static mutexes.
void Mutex::ThreadSafeLazyInit() {// Dynamic mutexes are initialized in the constructor.
@@ -281,7 +341,11 @@
// 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;
- critical_section_ = new CRITICAL_SECTION;
+ {+ // Use RAII to flag that following mem alloc is never deallocated.
+ MemoryIsNotDeallocated memory_is_not_deallocated;
+ critical_section_ = new CRITICAL_SECTION;
+ }
::InitializeCriticalSection(critical_section_);
// Updates the critical_section_init_phase_ to 2 to signal
// initialization complete.
@@ -320,7 +384,7 @@
Notification* thread_can_start) {ThreadMainParam* param = new ThreadMainParam(runnable, thread_can_start);
DWORD thread_id;
- // TODO(yukawa): Consider to use _beginthreadex instead.
+ // FIXME: Consider to use _beginthreadex instead.
HANDLE thread_handle = ::CreateThread(
NULL, // Default security.
0, // Default stack size.
@@ -523,7 +587,8 @@
// Returns map of thread local instances.
static ThreadIdToThreadLocals* GetThreadLocalsMapLocked() {mutex_.AssertHeld();
- static ThreadIdToThreadLocals* map = new ThreadIdToThreadLocals;
+ MemoryIsNotDeallocated memory_is_not_deallocated;
+ static ThreadIdToThreadLocals* map = new ThreadIdToThreadLocals();
return map;
}
@@ -672,7 +737,7 @@
// otherwise returns true.
bool ValidateRegex(const char* regex) { if (regex == NULL) {- // TODO([email protected]): fix the source file location in the
+ // FIXME: fix the source file location in the
// assertion failures to match where the regex is used in user
// code.
ADD_FAILURE() << "NULL is not a valid simple regular expression.";
@@ -918,7 +983,7 @@
// Disable Microsoft deprecation warnings for POSIX functions called from
// this class (creat, dup, dup2, and close)
-GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
+GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
#if GTEST_HAS_STREAM_REDIRECTION
@@ -1002,7 +1067,7 @@
GTEST_DISALLOW_COPY_AND_ASSIGN_(CapturedStream);
};
-GTEST_DISABLE_MSC_WARNINGS_POP_()
+GTEST_DISABLE_MSC_DEPRECATED_POP_()
static CapturedStream* g_captured_stderr = NULL;
static CapturedStream* g_captured_stdout = NULL;
--- a/third_party/googletest/src/src/gtest-printers.cc
+++ b/third_party/googletest/src/src/gtest-printers.cc
@@ -26,10 +26,9 @@
// 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.
-//
-// Author: [email protected] (Zhanyong Wan)
-// Google Test - The Google C++ Testing Framework
+
+// 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:
@@ -90,7 +89,7 @@
// 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.
- // TODO(wan): let the user control the threshold using a flag.
+ // FIXME: let the user control the threshold using a flag.
if (count < kThreshold) {PrintByteSegmentInObjectTo(obj_bytes, 0, count, os);
} else {--- a/third_party/googletest/src/src/gtest-test-part.cc
+++ b/third_party/googletest/src/src/gtest-test-part.cc
@@ -26,10 +26,9 @@
// 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.
+
//
-// Author: [email protected] (Markus Heule)
-//
-// The Google C++ Testing Framework (Google Test)
+// The Google C++ Testing and Mocking Framework (Google Test)
#include "gtest/gtest-test-part.h"
#include "src/gtest-internal-inl.h"
--- a/third_party/googletest/src/src/gtest-typed-test.cc
+++ b/third_party/googletest/src/src/gtest-typed-test.cc
@@ -26,8 +26,7 @@
// 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.
-//
-// Author: [email protected] (Zhanyong Wan)
+
#include "gtest/gtest-typed-test.h"
--- a/third_party/googletest/src/src/gtest.cc
+++ b/third_party/googletest/src/src/gtest.cc
@@ -26,10 +26,9 @@
// 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.
+
//
-// Author: [email protected] (Zhanyong Wan)
-//
-// The Google C++ Testing Framework (Google Test)
+// The Google C++ Testing and Mocking Framework (Google Test)
#include "gtest/gtest.h"
#include "gtest/internal/custom/gtest.h"
@@ -55,7 +54,7 @@
#if GTEST_OS_LINUX
-// TODO([email protected]): Use autoconf to detect availability of
+// FIXME: Use autoconf to detect availability of
// gettimeofday().
# define GTEST_HAS_GETTIMEOFDAY_ 1
@@ -94,9 +93,9 @@
# if GTEST_OS_WINDOWS_MINGW
// MinGW has gettimeofday() but not _ftime64().
-// TODO([email protected]): Use autoconf to detect availability of
+// FIXME: Use autoconf to detect availability of
// gettimeofday().
-// TODO([email protected]): There are other ways to get the time on
+// FIXME: There are other ways to get the time on
// Windows, like GetTickCount() or GetSystemTimeAsFileTime(). MinGW
// supports these. consider using them instead.
# define GTEST_HAS_GETTIMEOFDAY_ 1
@@ -111,7 +110,7 @@
#else
// Assume other platforms have gettimeofday().
-// TODO([email protected]): Use autoconf to detect availability of
+// FIXME: Use autoconf to detect availability of
// gettimeofday().
# define GTEST_HAS_GETTIMEOFDAY_ 1
@@ -139,6 +138,19 @@
# 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;
@@ -182,15 +194,31 @@
// 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 = NULL;
+ 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 == NULL) {+ 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() {-#ifdef GTEST_TEST_FILTER_ENV_VAR_
- const char* const testbridge_test_only = getenv(GTEST_TEST_FILTER_ENV_VAR_);
+ const char* const testbridge_test_only =
+ internal::posix::GetEnv("TESTBRIDGE_TEST_ONLY"); if (testbridge_test_only != NULL) {return testbridge_test_only;
}
-#endif // GTEST_TEST_FILTER_ENV_VAR_
return kUniversalFilter;
}
@@ -227,6 +255,13 @@
"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.");
@@ -392,7 +427,7 @@
GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex);
// A copy of all command line arguments. Set by InitGoogleTest().
-::std::vector<std::string> g_argvs;
+static ::std::vector<std::string> g_argvs;
::std::vector<std::string> GetArgvs() {#if defined(GTEST_CUSTOM_GET_ARGVS_)
@@ -424,8 +459,6 @@
// Returns the output format, or "" for normal printed output.
std::string UnitTestOptions::GetOutputFormat() {const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
- if (gtest_output_flag == NULL) return std::string("");-
const char* const colon = strchr(gtest_output_flag, ':');
return (colon == NULL) ?
std::string(gtest_output_flag) :
@@ -436,8 +469,6 @@
// was explicitly specified.
std::string UnitTestOptions::GetAbsolutePathToOutputFile() {const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
- if (gtest_output_flag == NULL)
- return "";
std::string format = GetOutputFormat();
if (format.empty())
@@ -453,7 +484,7 @@
internal::FilePath output_name(colon + 1);
if (!output_name.IsAbsolutePath())
- // TODO([email protected]): on Windows \some\path is not an absolute
+ // FIXME: on Windows \some\path is not an absolute
// path (as its meaning depends on the current drive), yet the
// following logic for turning it into an absolute path is wrong.
// Fix it.
@@ -827,7 +858,7 @@
SYSTEMTIME now_systime;
FILETIME now_filetime;
ULARGE_INTEGER now_int64;
- // TODO([email protected]): Shouldn't this just use
+ // FIXME: Shouldn't this just use
// GetSystemTimeAsFileTime()?
GetSystemTime(&now_systime);
if (SystemTimeToFileTime(&now_systime, &now_filetime)) {@@ -843,11 +874,11 @@
// MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996
// (deprecated function) there.
- // TODO([email protected]): Use GetTickCount()? Or use
+ // FIXME: Use GetTickCount()? Or use
// SystemTimeToFileTime()
- GTEST_DISABLE_MSC_WARNINGS_PUSH_(4996)
+ GTEST_DISABLE_MSC_DEPRECATED_PUSH_()
_ftime64(&now);
- GTEST_DISABLE_MSC_WARNINGS_POP_()
+ GTEST_DISABLE_MSC_DEPRECATED_POP_()
return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm;
#elif GTEST_HAS_GETTIMEOFDAY_
@@ -1382,7 +1413,7 @@
const double diff = fabs(val1 - val2);
if (diff <= abs_error) return AssertionSuccess();
- // TODO(wan): do not print the value of an expression if it's
+ // FIXME: do not print the value of an expression if it's
// already a literal.
return AssertionFailure()
<< "The difference between " << expr1 << " and " << expr2
@@ -2110,13 +2141,8 @@
// 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"
-};
+ "classname", "name", "status", "time",
+ "type_param", "value_param", "file", "line"};
template <int kSize>
std::vector<std::string> ArrayAsVector(const char* const (&array)[kSize]) {@@ -2659,18 +2685,18 @@
factory_, &internal::TestFactoryBase::CreateTest,
"the test fixture's constructor");
- // Runs the test only if the test object was created and its
- // constructor didn't generate a fatal failure.
- if ((test != NULL) && !Test::HasFatalFailure()) {+ // Runs the test if the constructor didn't generate a fatal failure.
+ // Note that the object will not be null
+ if (!Test::HasFatalFailure()) {// This doesn't throw as all user code that can throw are wrapped into
// exception handling code.
test->Run();
}
- // Deletes the test object.
- impl->os_stack_trace_getter()->UponLeavingGTest();
- internal::HandleExceptionsInMethodIfSupported(
- test, &Test::DeleteSelf_, "the test fixture's destructor");
+ // Deletes the test object.
+ impl->os_stack_trace_getter()->UponLeavingGTest();
+ internal::HandleExceptionsInMethodIfSupported(
+ test, &Test::DeleteSelf_, "the test fixture's destructor");
result_.set_elapsed_time(internal::GetTimeInMillis() - start);
@@ -3123,6 +3149,7 @@
"Note: Randomizing tests' orders with a seed of %d .\n",
unit_test.random_seed());
}
+
ColoredPrintf(COLOR_GREEN, "[==========] ");
printf("Running %s from %s.\n",FormatTestCount(unit_test.test_to_run_count()).c_str(),
@@ -3319,7 +3346,7 @@
listeners_.push_back(listener);
}
-// TODO([email protected]): Factor the search functionality into Vector::Find.
+// FIXME: Factor the search functionality into Vector::Find.
TestEventListener* TestEventRepeater::Release(TestEventListener *listener) { for (size_t i = 0; i < listeners_.size(); ++i) { if (listeners_[i] == listener) {@@ -3393,7 +3420,12 @@
explicit XmlUnitTestResultPrinter(const char* output_file);
virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration);
+ void ListTestsMatchingFilter(const std::vector<TestCase*>& test_cases);
+ // Prints an XML summary of all unit tests.
+ static void PrintXmlTestsList(std::ostream* stream,
+ const std::vector<TestCase*>& test_cases);
+
private:
// Is c a whitespace character that is normalized to a space character
// when it appears in an XML attribute value?
@@ -3468,7 +3500,7 @@
// Creates a new XmlUnitTestResultPrinter.
XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
: output_file_(output_file) {- if (output_file_.c_str() == NULL || output_file_.empty()) {+ if (output_file_.empty()) {GTEST_LOG_(FATAL) << "XML output file may not be null";
}
}
@@ -3476,27 +3508,7 @@
// Called after the unit test ends.
void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {- FILE* xmlout = NULL;
- FilePath output_file(output_file_);
- FilePath output_dir(output_file.RemoveFileName());
-
- if (output_dir.CreateDirectoriesRecursively()) {- xmlout = posix::FOpen(output_file_.c_str(), "w");
- }
- if (xmlout == NULL) {- // TODO(wan): report the reason of the failure.
- //
- // We don't do it for now as:
- //
- // 1. There is no urgent need for it.
- // 2. It's a bit involved to make the errno variable thread-safe on
- // all three operating systems (Linux, Windows, and Mac OS).
- // 3. To interpret the meaning of errno in a thread-safe way,
- // we need the strerror_r() function, which is not available on
- // Windows.
-
- GTEST_LOG_(FATAL) << "Unable to open file \"" << output_file_ << "\"";
- }
+ FILE* xmlout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintXmlUnitTest(&stream, unit_test);
fprintf(xmlout, "%s", StringStreamToString(&stream).c_str());
@@ -3503,6 +3515,15 @@
fclose(xmlout);
}
+void XmlUnitTestResultPrinter::ListTestsMatchingFilter(
+ const std::vector<TestCase*>& test_cases) {+ FILE* xmlout = OpenFileForWriting(output_file_);
+ std::stringstream stream;
+ PrintXmlTestsList(&stream, test_cases);
+ 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
@@ -3513,7 +3534,7 @@
// 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.
-// TODO(wan): It might be nice to have a minimally invasive, human-readable
+// FIXME: It might be nice to have a minimally invasive, human-readable
// escaping scheme for invalid characters, rather than dropping them.
std::string XmlUnitTestResultPrinter::EscapeXml(
const std::string& str, bool is_attribute) {@@ -3574,6 +3595,7 @@
// 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:
//
@@ -3663,7 +3685,7 @@
}
// Prints an XML representation of a TestInfo object.
-// TODO(wan): There is also value in printing properties with the plain printer.
+// FIXME: There is also value in printing properties with the plain printer.
void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream,
const char* test_case_name,
const TestInfo& test_info) {@@ -3684,6 +3706,13 @@
if (test_info.type_param() != NULL) {OutputXmlAttribute(stream, kTestcase, "type_param", test_info.type_param());
}
+ if (GTEST_FLAG(list_tests)) {+ OutputXmlAttribute(stream, kTestcase, "file", test_info.file());
+ OutputXmlAttribute(stream, kTestcase, "line",
+ StreamableToString(test_info.line()));
+ *stream << " />\n";
+ return;
+ }
OutputXmlAttribute(stream, kTestcase, "status",
test_info.should_run() ? "run" : "notrun");
@@ -3730,17 +3759,18 @@
OutputXmlAttribute(stream, kTestsuite, "name", test_case.name());
OutputXmlAttribute(stream, kTestsuite, "tests",
StreamableToString(test_case.reportable_test_count()));
- OutputXmlAttribute(stream, kTestsuite, "failures",
- StreamableToString(test_case.failed_test_count()));
- OutputXmlAttribute(
- stream, kTestsuite, "disabled",
- StreamableToString(test_case.reportable_disabled_test_count()));
- OutputXmlAttribute(stream, kTestsuite, "errors", "0");
- OutputXmlAttribute(stream, kTestsuite, "time",
- FormatTimeInMillisAsSeconds(test_case.elapsed_time()));
- *stream << TestPropertiesAsXmlAttributes(test_case.ad_hoc_test_result())
- << ">\n";
-
+ if (!GTEST_FLAG(list_tests)) {+ OutputXmlAttribute(stream, kTestsuite, "failures",
+ StreamableToString(test_case.failed_test_count()));
+ OutputXmlAttribute(
+ stream, kTestsuite, "disabled",
+ StreamableToString(test_case.reportable_disabled_test_count()));
+ OutputXmlAttribute(stream, kTestsuite, "errors", "0");
+ OutputXmlAttribute(stream, kTestsuite, "time",
+ FormatTimeInMillisAsSeconds(test_case.elapsed_time()));
+ *stream << TestPropertiesAsXmlAttributes(test_case.ad_hoc_test_result());
+ }
+ *stream << ">\n";
for (int i = 0; i < test_case.total_test_count(); ++i) {if (test_case.GetTestInfo(i)->is_reportable())
OutputXmlTestInfo(stream, test_case.name(), *test_case.GetTestInfo(i));
@@ -3786,6 +3816,28 @@
*stream << "</" << kTestsuites << ">\n";
}
+void XmlUnitTestResultPrinter::PrintXmlTestsList(
+ std::ostream* stream, const std::vector<TestCase*>& test_cases) {+ const std::string kTestsuites = "testsuites";
+
+ *stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+ *stream << "<" << kTestsuites;
+
+ int total_tests = 0;
+ for (size_t i = 0; i < test_cases.size(); ++i) {+ total_tests += test_cases[i]->total_test_count();
+ }
+ OutputXmlAttribute(stream, kTestsuites, "tests",
+ StreamableToString(total_tests));
+ OutputXmlAttribute(stream, kTestsuites, "name", "AllTests");
+ *stream << ">\n";
+
+ for (size_t i = 0; i < test_cases.size(); ++i) {+ PrintXmlTestCase(stream, *test_cases[i]);
+ }
+ *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(
@@ -3821,7 +3873,6 @@
// End XmlUnitTestResultPrinter
-
// This class generates an JSON output file.
class JsonUnitTestResultPrinter : public EmptyTestEventListener {public:
@@ -3829,6 +3880,10 @@
virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration);
+ // Prints an JSON summary of all unit tests.
+ static void PrintJsonTestList(::std::ostream* stream,
+ const std::vector<TestCase*>& test_cases);
+
private:
// Returns an JSON-escaped copy of the input string str.
static std::string EscapeJson(const std::string& str);
@@ -3882,27 +3937,7 @@
void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {- FILE* jsonout = NULL;
- FilePath output_file(output_file_);
- FilePath output_dir(output_file.RemoveFileName());
-
- if (output_dir.CreateDirectoriesRecursively()) {- jsonout = posix::FOpen(output_file_.c_str(), "w");
- }
- if (jsonout == NULL) {- // TODO(phosek): report the reason of the failure.
- //
- // We don't do it for now as:
- //
- // 1. There is no urgent need for it.
- // 2. It's a bit involved to make the errno variable thread-safe on
- // all three operating systems (Linux, Windows, and Mac OS).
- // 3. To interpret the meaning of errno in a thread-safe way,
- // we need the strerror_r() function, which is not available on
- // Windows.
- GTEST_LOG_(FATAL) << "Unable to open file \""
- << output_file_ << "\"";
- }
+ FILE* jsonout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintJsonUnitTest(&stream, unit_test);
fprintf(jsonout, "%s", StringStreamToString(&stream).c_str());
@@ -4037,6 +4072,12 @@
OutputJsonKey(stream, kTestcase, "type_param", test_info.type_param(),
kIndent);
}
+ if (GTEST_FLAG(list_tests)) {+ OutputJsonKey(stream, kTestcase, "file", test_info.file(), kIndent);
+ OutputJsonKey(stream, kTestcase, "line", test_info.line(), kIndent, false);
+ *stream << "\n" << Indent(8) << "}";
+ return;
+ }
OutputJsonKey(stream, kTestcase, "status",
test_info.should_run() ? "RUN" : "NOTRUN", kIndent);
@@ -4079,16 +4120,18 @@
OutputJsonKey(stream, kTestsuite, "name", test_case.name(), kIndent);
OutputJsonKey(stream, kTestsuite, "tests", test_case.reportable_test_count(),
kIndent);
- OutputJsonKey(stream, kTestsuite, "failures", test_case.failed_test_count(),
- kIndent);
- OutputJsonKey(stream, kTestsuite, "disabled",
- test_case.reportable_disabled_test_count(), kIndent);
- OutputJsonKey(stream, kTestsuite, "errors", 0, kIndent);
- OutputJsonKey(stream, kTestsuite, "time",
- FormatTimeInMillisAsDuration(test_case.elapsed_time()), kIndent,
- false);
- *stream << TestPropertiesAsJson(test_case.ad_hoc_test_result(), kIndent)
- << ",\n";
+ if (!GTEST_FLAG(list_tests)) {+ OutputJsonKey(stream, kTestsuite, "failures", test_case.failed_test_count(),
+ kIndent);
+ OutputJsonKey(stream, kTestsuite, "disabled",
+ test_case.reportable_disabled_test_count(), kIndent);
+ OutputJsonKey(stream, kTestsuite, "errors", 0, kIndent);
+ OutputJsonKey(stream, kTestsuite, "time",
+ FormatTimeInMillisAsDuration(test_case.elapsed_time()),
+ kIndent, false);
+ *stream << TestPropertiesAsJson(test_case.ad_hoc_test_result(), kIndent)
+ << ",\n";
+ }
*stream << kIndent << "\"" << kTestsuite << "\": [\n";
@@ -4152,6 +4195,31 @@
*stream << "\n" << kIndent << "]\n" << "}\n";
}
+void JsonUnitTestResultPrinter::PrintJsonTestList(
+ std::ostream* stream, const std::vector<TestCase*>& test_cases) {+ const std::string kTestsuites = "testsuites";
+ const std::string kIndent = Indent(2);
+ *stream << "{\n";+ int total_tests = 0;
+ for (size_t i = 0; i < test_cases.size(); ++i) {+ total_tests += test_cases[i]->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_cases.size(); ++i) {+ if (i != 0) {+ *stream << ",\n";
+ }
+ PrintJsonTestCase(stream, *test_cases[i]);
+ }
+
+ *stream << "\n"
+ << kIndent << "]\n"
+ << "}\n";
+}
// Produces a string representing the test properties in a result as
// a JSON dictionary.
std::string JsonUnitTestResultPrinter::TestPropertiesAsJson(
@@ -4242,13 +4310,68 @@
const char* const OsStackTraceGetterInterface::kElidedFramesMarker =
"... " GTEST_NAME_ " internal frames ...";
-std::string OsStackTraceGetter::CurrentStackTrace(int /*max_depth*/,
- int /*skip_count*/) {+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() {}+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 {@@ -4549,6 +4672,11 @@
// 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 NULL through a volatile pointer to prevent the compiler
// from removing. We use this rather than abort() or __builtin_trap() for
@@ -4616,7 +4744,7 @@
// used for the duration of the program.
impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions));
-#if GTEST_HAS_SEH
+#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
@@ -4645,7 +4773,7 @@
// VC++ doesn't define _set_abort_behavior() prior to the version 8.0.
// Users of prior VC versions shall suffer the agony and pain of
// clicking through the countless debug dialogs.
- // TODO([email protected]): find a way to suppress the abort dialog() in the
+ // FIXME: find a way to suppress the abort dialog() in the
// debug mode when compiled with VC 7.1 or lower.
if (!GTEST_FLAG(break_on_failure))
_set_abort_behavior(
@@ -4653,7 +4781,7 @@
_WRITE_ABORT_MSG | _CALL_REPORTFAULT); // pop-up window, core dump.
# endif
}
-#endif // GTEST_HAS_SEH
+#endif // GTEST_OS_WINDOWS
return internal::HandleExceptionsInMethodIfSupported(
impl(),
@@ -4859,6 +4987,13 @@
// 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
}
}
@@ -4902,11 +5037,11 @@
Test::SetUpTestCaseFunc set_up_tc,
Test::TearDownTestCaseFunc tear_down_tc) {// Can we find a TestCase with the given name?
- const std::vector<TestCase*>::const_iterator test_case =
- std::find_if(test_cases_.begin(), test_cases_.end(),
+ const std::vector<TestCase*>::const_reverse_iterator test_case =
+ std::find_if(test_cases_.rbegin(), test_cases_.rend(),
TestCaseNameIs(test_case_name));
- if (test_case != test_cases_.end())
+ if (test_case != test_cases_.rend())
return *test_case;
// No. Let's create one.
@@ -5191,7 +5326,7 @@
// each TestCase 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/AdvancedGuide.md
+// 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 total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
@@ -5305,6 +5440,23 @@
}
}
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_cases_);
+ } else if (output_format == "json") {+ JsonUnitTestResultPrinter(
+ UnitTestOptions::GetAbsolutePathToOutputFile().c_str())
+ .PrintJsonTestList(&stream, test_cases_);
+ }
+ fprintf(fileout, "%s", StringStreamToString(&stream).c_str());
+ fclose(fileout);
+ }
}
// Sets the OS stack trace getter.
@@ -5335,11 +5487,15 @@
return os_stack_trace_getter_;
}
-// Returns the TestResult for the test that's currently running, or
-// the TestResult for the ad hoc test if no test is running.
+// Returns the most specific TestResult currently running.
TestResult* UnitTestImpl::current_test_result() {- return current_test_info_ ?
- &(current_test_info_->result_) : &ad_hoc_test_result_;
+ if (current_test_info_ != NULL) {+ return ¤t_test_info_->result_;
+ }
+ if (current_test_case_ != NULL) {+ return ¤t_test_case_->ad_hoc_test_result_;
+ }
+ return &ad_hoc_test_result_;
}
// Shuffles all test cases, and the tests within each test case,
@@ -5528,7 +5684,7 @@
// @Y changes the color to yellow.
// @D changes to the default terminal text color.
//
-// TODO([email protected]): Write tests for this once we add stdout
+// FIXME: Write tests for this once we add stdout
// capturing to Google Test.
static void PrintColorEncoded(const char* str) {GTestColor color = COLOR_DEFAULT; // The current color.
@@ -5738,6 +5894,17 @@
// other parts of Google Test.
void ParseGoogleTestFlagsOnly(int* argc, char** argv) {ParseGoogleTestFlagsOnlyImpl(argc, argv);
+
+ // Fix the value of *_NSGetArgc() on macOS, but iff
+ // *_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);
@@ -5758,6 +5925,10 @@
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();
--- a/third_party/googletest/src/src/gtest_main.cc
+++ b/third_party/googletest/src/src/gtest_main.cc
@@ -26,13 +26,12 @@
// 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 <stdio.h>
#include "gtest/gtest.h"
GTEST_API_ int main(int argc, char **argv) {- printf("Running main() from gtest_main.cc\n");+ printf("Running main() from %s\n", __FILE__);testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}